1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
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.
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.
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/>.
24 #include <sys/timerfd.h>
25 #include <sys/epoll.h>
28 #include "sd-messages.h"
33 #include "load-fragment.h"
34 #include "load-dropin.h"
42 Job* job_new_raw(Unit *unit) {
45 /* used for deserialization */
53 j->manager = unit->manager;
55 j->type = _JOB_TYPE_INVALID;
60 Job* job_new(Unit *unit, JobType type) {
63 assert(type < _JOB_TYPE_MAX);
65 j = job_new_raw(unit);
69 j->id = j->manager->current_job_id++;
72 /* We don't link it here, that's what job_dependency() is for */
77 void job_free(Job *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);
86 LIST_REMOVE(run_queue, j->manager->run_queue, j);
89 LIST_REMOVE(dbus_queue, j->manager->dbus_job_queue, j);
91 sd_event_source_unref(j->timer_event_source);
93 sd_bus_track_unref(j->clients);
94 strv_free(j->deserialized_clients);
99 static void job_set_state(Job *j, JobState state) {
102 assert(state < _JOB_STATE_MAX);
104 if (j->state == state)
112 if (j->state == JOB_RUNNING)
113 j->unit->manager->n_running_jobs++;
115 assert(j->state == JOB_WAITING);
116 assert(j->unit->manager->n_running_jobs > 0);
118 j->unit->manager->n_running_jobs--;
120 if (j->unit->manager->n_running_jobs <= 0)
121 j->unit->manager->jobs_in_progress_event_source = sd_event_source_unref(j->unit->manager->jobs_in_progress_event_source);
125 void job_uninstall(Job *j) {
128 assert(j->installed);
130 job_set_state(j, JOB_WAITING);
132 pj = (j->type == JOB_NOP) ? &j->unit->nop_job : &j->unit->job;
135 /* Detach from next 'bigger' objects */
137 /* daemon-reload should be transparent to job observers */
138 if (j->manager->n_reloading <= 0)
139 bus_job_send_removed_signal(j);
143 unit_add_to_gc_queue(j->unit);
145 hashmap_remove(j->manager->jobs, UINT32_TO_PTR(j->id));
146 j->installed = false;
149 static bool job_type_allows_late_merge(JobType t) {
150 /* Tells whether it is OK to merge a job of type 't' with an already
152 * Reloads cannot be merged this way. Think of the sequence:
153 * 1. Reload of a daemon is in progress; the daemon has already loaded
154 * its config file, but hasn't completed the reload operation yet.
155 * 2. Edit foo's config file.
156 * 3. Trigger another reload to have the daemon use the new config.
157 * Should the second reload job be merged into the first one, the daemon
158 * would not know about the new config.
159 * JOB_RESTART jobs on the other hand can be merged, because they get
160 * patched into JOB_START after stopping the unit. So if we see a
161 * JOB_RESTART running, it means the unit hasn't stopped yet and at
162 * this time the merge is still allowed. */
163 return t != JOB_RELOAD;
166 static void job_merge_into_installed(Job *j, Job *other) {
167 assert(j->installed);
168 assert(j->unit == other->unit);
170 if (j->type != JOB_NOP)
171 job_type_merge_and_collapse(&j->type, other->type, j->unit);
173 assert(other->type == JOB_NOP);
175 j->override = j->override || other->override;
176 j->irreversible = j->irreversible || other->irreversible;
177 j->ignore_order = j->ignore_order || other->ignore_order;
180 Job* job_install(Job *j) {
184 assert(!j->installed);
185 assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION);
186 assert(j->state == JOB_WAITING);
188 pj = (j->type == JOB_NOP) ? &j->unit->nop_job : &j->unit->job;
192 if (job_type_is_conflicting(uj->type, j->type))
193 job_finish_and_invalidate(uj, JOB_CANCELED, false);
195 /* not conflicting, i.e. mergeable */
197 if (uj->state == JOB_WAITING ||
198 (job_type_allows_late_merge(j->type) && job_type_is_superset(uj->type, j->type))) {
199 job_merge_into_installed(uj, j);
200 log_unit_debug(uj->unit->id,
201 "Merged into installed job %s/%s as %u",
202 uj->unit->id, job_type_to_string(uj->type), (unsigned) uj->id);
205 /* already running and not safe to merge into */
206 /* Patch uj to become a merged job and re-run it. */
207 /* XXX It should be safer to queue j to run after uj finishes, but it is
208 * not currently possible to have more than one installed job per unit. */
209 job_merge_into_installed(uj, j);
210 log_unit_debug(uj->unit->id,
211 "Merged into running job, re-running: %s/%s as %u",
212 uj->unit->id, job_type_to_string(uj->type), (unsigned) uj->id);
214 job_set_state(uj, JOB_WAITING);
220 /* Install the job */
224 j->manager->n_installed_jobs ++;
225 log_unit_debug(j->unit->id,
226 "Installed new job %s/%s as %u",
227 j->unit->id, job_type_to_string(j->type), (unsigned) j->id);
231 int job_install_deserialized(Job *j) {
234 assert(!j->installed);
236 if (j->type < 0 || j->type >= _JOB_TYPE_MAX_IN_TRANSACTION) {
237 log_debug("Invalid job type %s in deserialization.", strna(job_type_to_string(j->type)));
241 pj = (j->type == JOB_NOP) ? &j->unit->nop_job : &j->unit->job;
243 log_unit_debug(j->unit->id, "Unit %s already has a job installed. Not installing deserialized job.", j->unit->id);
250 if (j->state == JOB_RUNNING)
251 j->unit->manager->n_running_jobs++;
253 log_unit_debug(j->unit->id,
254 "Reinstalled deserialized job %s/%s as %u",
255 j->unit->id, job_type_to_string(j->type), (unsigned) j->id);
259 JobDependency* job_dependency_new(Job *subject, Job *object, bool matters, bool conflicts) {
264 /* Adds a new job link, which encodes that the 'subject' job
265 * needs the 'object' job in some way. If 'subject' is NULL
266 * this means the 'anchor' job (i.e. the one the user
267 * explicitly asked for) is the requester. */
269 if (!(l = new0(JobDependency, 1)))
272 l->subject = subject;
274 l->matters = matters;
275 l->conflicts = conflicts;
278 LIST_PREPEND(subject, subject->subject_list, l);
280 LIST_PREPEND(object, object->object_list, l);
285 void job_dependency_free(JobDependency *l) {
289 LIST_REMOVE(subject, l->subject->subject_list, l);
291 LIST_REMOVE(object, l->object->object_list, l);
296 void job_dump(Job *j, FILE*f, const char *prefix) {
305 "%s\tAction: %s -> %s\n"
308 "%s\tIrreversible: %s\n",
310 prefix, j->unit->id, job_type_to_string(j->type),
311 prefix, job_state_to_string(j->state),
312 prefix, yes_no(j->override),
313 prefix, yes_no(j->irreversible));
317 * Merging is commutative, so imagine the matrix as symmetric. We store only
318 * its lower triangle to avoid duplication. We don't store the main diagonal,
319 * because A merged with A is simply A.
321 * If the resulting type is collapsed immediately afterwards (to get rid of
322 * the JOB_RELOAD_OR_START, which lies outside the lookup function's domain),
323 * the following properties hold:
325 * Merging is associative! A merged with B merged with C is the same as
326 * A merged with C merged with B.
328 * Mergeability is transitive! If A can be merged with B and B with C then
331 * Also, if A merged with B cannot be merged with C, then either A or B cannot
332 * be merged with C either.
334 static const JobType job_merging_table[] = {
335 /* What \ With * JOB_START JOB_VERIFY_ACTIVE JOB_STOP JOB_RELOAD */
336 /*********************************************************************************/
338 /*JOB_VERIFY_ACTIVE */ JOB_START,
339 /*JOB_STOP */ -1, -1,
340 /*JOB_RELOAD */ JOB_RELOAD_OR_START, JOB_RELOAD, -1,
341 /*JOB_RESTART */ JOB_RESTART, JOB_RESTART, -1, JOB_RESTART,
344 JobType job_type_lookup_merge(JobType a, JobType b) {
345 assert_cc(ELEMENTSOF(job_merging_table) == _JOB_TYPE_MAX_MERGING * (_JOB_TYPE_MAX_MERGING - 1) / 2);
346 assert(a >= 0 && a < _JOB_TYPE_MAX_MERGING);
347 assert(b >= 0 && b < _JOB_TYPE_MAX_MERGING);
358 return job_merging_table[(a - 1) * a / 2 + b];
361 bool job_type_is_redundant(JobType a, UnitActiveState b) {
371 b == UNIT_INACTIVE ||
374 case JOB_VERIFY_ACTIVE:
385 b == UNIT_ACTIVATING;
391 assert_not_reached("Invalid job type");
395 void job_type_collapse(JobType *t, Unit *u) {
400 case JOB_TRY_RESTART:
401 s = unit_active_state(u);
402 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(s))
408 case JOB_RELOAD_OR_START:
409 s = unit_active_state(u);
410 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(s))
421 int job_type_merge_and_collapse(JobType *a, JobType b, Unit *u) {
422 JobType t = job_type_lookup_merge(*a, b);
426 job_type_collapse(a, u);
430 static bool job_is_runnable(Job *j) {
435 assert(j->installed);
437 /* Checks whether there is any job running for the units this
438 * job needs to be running after (in the case of a 'positive'
439 * job type) or before (in the case of a 'negative' job
442 /* Note that unit types have a say in what is runnable,
443 * too. For example, if they return -EAGAIN from
444 * unit_start() they can indicate they are not
447 /* First check if there is an override */
451 if (j->type == JOB_NOP)
454 if (j->type == JOB_START ||
455 j->type == JOB_VERIFY_ACTIVE ||
456 j->type == JOB_RELOAD) {
458 /* Immediate result is that the job is or might be
459 * started. In this case lets wait for the
460 * dependencies, regardless whether they are
461 * starting or stopping something. */
463 SET_FOREACH(other, j->unit->dependencies[UNIT_AFTER], i)
468 /* Also, if something else is being stopped and we should
469 * change state after it, then lets wait. */
471 SET_FOREACH(other, j->unit->dependencies[UNIT_BEFORE], i)
473 (other->job->type == JOB_STOP ||
474 other->job->type == JOB_RESTART))
477 /* This means that for a service a and a service b where b
478 * shall be started after a:
480 * start a + start b → 1st step start a, 2nd step start b
481 * start a + stop b → 1st step stop b, 2nd step start a
482 * stop a + start b → 1st step stop a, 2nd step start b
483 * stop a + stop b → 1st step stop b, 2nd step stop a
485 * This has the side effect that restarts are properly
486 * synchronized too. */
491 static void job_change_type(Job *j, JobType newtype) {
492 log_unit_debug(j->unit->id,
493 "Converting job %s/%s -> %s/%s",
494 j->unit->id, job_type_to_string(j->type),
495 j->unit->id, job_type_to_string(newtype));
500 int job_run_and_invalidate(Job *j) {
503 Manager *m = j->manager;
506 assert(j->installed);
507 assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION);
508 assert(j->in_run_queue);
510 LIST_REMOVE(run_queue, j->manager->run_queue, j);
511 j->in_run_queue = false;
513 if (j->state != JOB_WAITING)
516 if (!job_is_runnable(j))
519 job_set_state(j, JOB_RUNNING);
520 job_add_to_dbus_queue(j);
522 /* While we execute this operation the job might go away (for
523 * example: because it is replaced by a new, conflicting
524 * job.) To make sure we don't access a freed job later on we
525 * store the id here, so that we can verify the job is still
532 r = unit_start(j->unit);
534 /* If this unit cannot be started, then simply wait */
539 case JOB_VERIFY_ACTIVE: {
540 UnitActiveState t = unit_active_state(j->unit);
541 if (UNIT_IS_ACTIVE_OR_RELOADING(t))
543 else if (t == UNIT_ACTIVATING)
552 r = unit_stop(j->unit);
554 /* If this unit cannot stopped, then simply wait. */
560 r = unit_reload(j->unit);
568 assert_not_reached("Unknown job type");
571 j = manager_get_job(m, id);
574 r = job_finish_and_invalidate(j, JOB_DONE, true);
575 else if (r == -EBADR)
576 r = job_finish_and_invalidate(j, JOB_SKIPPED, true);
577 else if (r == -ENOEXEC)
578 r = job_finish_and_invalidate(j, JOB_INVALID, true);
579 else if (r == -EPROTO)
580 r = job_finish_and_invalidate(j, JOB_ASSERT, true);
581 else if (r == -ENOTSUP)
582 r = job_finish_and_invalidate(j, JOB_UNSUPPORTED, true);
583 else if (r == -EAGAIN)
584 job_set_state(j, JOB_WAITING);
586 r = job_finish_and_invalidate(j, JOB_FAILED, true);
592 _pure_ static const char *job_get_status_message_format(Unit *u, JobType t, JobResult result) {
593 const UnitStatusMessageFormats *format_table;
597 assert(t < _JOB_TYPE_MAX);
599 format_table = &UNIT_VTABLE(u)->status_message_formats;
604 return format_table->finished_start_job[result];
605 else if (t == JOB_STOP || t == JOB_RESTART)
606 return format_table->finished_stop_job[result];
611 _pure_ static const char *job_get_status_message_format_try_harder(Unit *u, JobType t, JobResult result) {
616 assert(t < _JOB_TYPE_MAX);
618 format = job_get_status_message_format(u, t, result);
622 /* Return generic strings */
623 if (t == JOB_START) {
624 if (result == JOB_DONE)
625 return "Started %s.";
626 else if (result == JOB_TIMEOUT)
627 return "Timed out starting %s.";
628 else if (result == JOB_FAILED)
629 return "Failed to start %s.";
630 else if (result == JOB_DEPENDENCY)
631 return "Dependency failed for %s.";
632 else if (result == JOB_ASSERT)
633 return "Assertion failed for %s.";
634 else if (result == JOB_UNSUPPORTED)
635 return "Starting of %s not supported.";
636 } else if (t == JOB_STOP || t == JOB_RESTART) {
637 if (result == JOB_DONE)
638 return "Stopped %s.";
639 else if (result == JOB_FAILED)
640 return "Stopped (with error) %s.";
641 else if (result == JOB_TIMEOUT)
642 return "Timed out stoppping %s.";
643 } else if (t == JOB_RELOAD) {
644 if (result == JOB_DONE)
645 return "Reloaded %s.";
646 else if (result == JOB_FAILED)
647 return "Reload failed for %s.";
648 else if (result == JOB_TIMEOUT)
649 return "Timed out reloading %s.";
655 static void job_print_status_message(Unit *u, JobType t, JobResult result) {
660 assert(t < _JOB_TYPE_MAX);
662 DISABLE_WARNING_FORMAT_NONLITERAL;
664 if (t == JOB_START) {
665 format = job_get_status_message_format(u, t, result);
672 if (u->condition_result)
673 unit_status_printf(u, ANSI_GREEN_ON " OK " ANSI_HIGHLIGHT_OFF, format);
677 manager_flip_auto_status(u->manager, true);
678 unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " TIME " ANSI_HIGHLIGHT_OFF, format);
684 quotes = chars_intersect(u->id, SHELL_NEED_QUOTES);
686 manager_flip_auto_status(u->manager, true);
687 unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON "FAILED" ANSI_HIGHLIGHT_OFF, format);
688 manager_status_printf(u->manager, STATUS_TYPE_NORMAL, NULL,
689 "See \"systemctl status %s%s%s\" for details.",
690 quotes ? "'" : "", u->id, quotes ? "'" : "");
695 manager_flip_auto_status(u->manager, true);
696 unit_status_printf(u, ANSI_HIGHLIGHT_YELLOW_ON "DEPEND" ANSI_HIGHLIGHT_OFF, format);
700 manager_flip_auto_status(u->manager, true);
701 unit_status_printf(u, ANSI_HIGHLIGHT_YELLOW_ON "ASSERT" ANSI_HIGHLIGHT_OFF, format);
704 case JOB_UNSUPPORTED:
705 manager_flip_auto_status(u->manager, true);
706 unit_status_printf(u, ANSI_HIGHLIGHT_YELLOW_ON "UNSUPP" ANSI_HIGHLIGHT_OFF, format);
713 } else if (t == JOB_STOP || t == JOB_RESTART) {
715 format = job_get_status_message_format(u, t, result);
722 manager_flip_auto_status(u->manager, true);
723 unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " TIME " ANSI_HIGHLIGHT_OFF, format);
728 unit_status_printf(u, ANSI_GREEN_ON " OK " ANSI_HIGHLIGHT_OFF, format);
735 } else if (t == JOB_VERIFY_ACTIVE) {
737 /* When verify-active detects the unit is inactive, report it.
738 * Most likely a DEPEND warning from a requisiting unit will
739 * occur next and it's nice to see what was requisited. */
740 if (result == JOB_SKIPPED)
741 unit_status_printf(u, ANSI_HIGHLIGHT_ON " INFO " ANSI_HIGHLIGHT_OFF, "%s is not active.");
747 static void job_log_status_message(Unit *u, JobType t, JobResult result) {
753 assert(t < _JOB_TYPE_MAX);
755 /* Skip this if it goes to the console. since we already print
756 * to the console anyway... */
758 if (log_on_console())
761 format = job_get_status_message_format_try_harder(u, t, result);
765 DISABLE_WARNING_FORMAT_NONLITERAL;
766 snprintf(buf, sizeof(buf), format, unit_description(u));
769 if (t == JOB_START) {
772 mid = result == JOB_DONE ? SD_MESSAGE_UNIT_STARTED : SD_MESSAGE_UNIT_FAILED;
773 log_unit_struct(u->id,
774 result == JOB_DONE ? LOG_INFO : LOG_ERR,
776 LOG_MESSAGE("%s", buf),
777 "RESULT=%s", job_result_to_string(result),
780 } else if (t == JOB_STOP)
781 log_unit_struct(u->id,
782 result == JOB_DONE ? LOG_INFO : LOG_ERR,
783 LOG_MESSAGE_ID(SD_MESSAGE_UNIT_STOPPED),
784 LOG_MESSAGE("%s", buf),
785 "RESULT=%s", job_result_to_string(result),
788 else if (t == JOB_RELOAD)
789 log_unit_struct(u->id,
790 result == JOB_DONE ? LOG_INFO : LOG_ERR,
791 LOG_MESSAGE_ID(SD_MESSAGE_UNIT_RELOADED),
792 LOG_MESSAGE("%s", buf),
793 "RESULT=%s", job_result_to_string(result),
797 int job_finish_and_invalidate(Job *j, JobResult result, bool recursive) {
804 assert(j->installed);
805 assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION);
812 log_unit_debug(u->id, "Job %s/%s finished, result=%s",
813 u->id, job_type_to_string(t), job_result_to_string(result));
815 job_print_status_message(u, t, result);
816 job_log_status_message(u, t, result);
818 job_add_to_dbus_queue(j);
820 /* Patch restart jobs so that they become normal start jobs */
821 if (result == JOB_DONE && t == JOB_RESTART) {
823 job_change_type(j, JOB_START);
824 job_set_state(j, JOB_WAITING);
826 job_add_to_run_queue(j);
831 if (result == JOB_FAILED || result == JOB_INVALID)
832 j->manager->n_failed_jobs ++;
837 /* Fail depending jobs on failure */
838 if (result != JOB_DONE && recursive) {
840 if (t == JOB_START ||
841 t == JOB_VERIFY_ACTIVE) {
843 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
845 (other->job->type == JOB_START ||
846 other->job->type == JOB_VERIFY_ACTIVE))
847 job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true);
849 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
851 (other->job->type == JOB_START ||
852 other->job->type == JOB_VERIFY_ACTIVE))
853 job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true);
855 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
857 !other->job->override &&
858 (other->job->type == JOB_START ||
859 other->job->type == JOB_VERIFY_ACTIVE))
860 job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true);
862 } else if (t == JOB_STOP) {
864 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
866 (other->job->type == JOB_START ||
867 other->job->type == JOB_VERIFY_ACTIVE))
868 job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true);
872 /* Trigger OnFailure dependencies that are not generated by
873 * the unit itself. We don't treat JOB_CANCELED as failure in
874 * this context. And JOB_FAILURE is already handled by the
876 if (result == JOB_TIMEOUT || result == JOB_DEPENDENCY) {
877 log_unit_struct(u->id,
879 "JOB_TYPE=%s", job_type_to_string(t),
880 "JOB_RESULT=%s", job_result_to_string(result),
881 LOG_MESSAGE("Job %s/%s failed with result '%s'.",
883 job_type_to_string(t),
884 job_result_to_string(result)),
887 unit_start_on_failure(u);
890 unit_trigger_notify(u);
893 /* Try to start the next jobs that can be started */
894 SET_FOREACH(other, u->dependencies[UNIT_AFTER], i)
896 job_add_to_run_queue(other->job);
897 SET_FOREACH(other, u->dependencies[UNIT_BEFORE], i)
899 job_add_to_run_queue(other->job);
901 manager_check_finished(u->manager);
906 static int job_dispatch_timer(sd_event_source *s, uint64_t monotonic, void *userdata) {
911 assert(s == j->timer_event_source);
913 log_unit_warning(j->unit->id, "Job %s/%s timed out.", j->unit->id, job_type_to_string(j->type));
916 job_finish_and_invalidate(j, JOB_TIMEOUT, true);
918 failure_action(u->manager, u->job_timeout_action, u->job_timeout_reboot_arg);
923 int job_start_timer(Job *j) {
926 if (j->timer_event_source)
929 j->begin_usec = now(CLOCK_MONOTONIC);
931 if (j->unit->job_timeout <= 0)
934 r = sd_event_add_time(
936 &j->timer_event_source,
938 j->begin_usec + j->unit->job_timeout, 0,
939 job_dispatch_timer, j);
946 void job_add_to_run_queue(Job *j) {
948 assert(j->installed);
953 if (!j->manager->run_queue)
954 sd_event_source_set_enabled(j->manager->run_queue_event_source, SD_EVENT_ONESHOT);
956 LIST_PREPEND(run_queue, j->manager->run_queue, j);
957 j->in_run_queue = true;
960 void job_add_to_dbus_queue(Job *j) {
962 assert(j->installed);
964 if (j->in_dbus_queue)
967 /* We don't check if anybody is subscribed here, since this
968 * job might just have been created and not yet assigned to a
969 * connection/client. */
971 LIST_PREPEND(dbus_queue, j->manager->dbus_job_queue, j);
972 j->in_dbus_queue = true;
975 char *job_dbus_path(Job *j) {
980 if (asprintf(&p, "/org/freedesktop/systemd1/job/%"PRIu32, j->id) < 0)
986 int job_serialize(Job *j, FILE *f, FDSet *fds) {
987 fprintf(f, "job-id=%u\n", j->id);
988 fprintf(f, "job-type=%s\n", job_type_to_string(j->type));
989 fprintf(f, "job-state=%s\n", job_state_to_string(j->state));
990 fprintf(f, "job-override=%s\n", yes_no(j->override));
991 fprintf(f, "job-irreversible=%s\n", yes_no(j->irreversible));
992 fprintf(f, "job-sent-dbus-new-signal=%s\n", yes_no(j->sent_dbus_new_signal));
993 fprintf(f, "job-ignore-order=%s\n", yes_no(j->ignore_order));
995 if (j->begin_usec > 0)
996 fprintf(f, "job-begin="USEC_FMT"\n", j->begin_usec);
998 bus_track_serialize(j->clients, f);
1005 int job_deserialize(Job *j, FILE *f, FDSet *fds) {
1009 char line[LINE_MAX], *l, *v;
1012 if (!fgets(line, sizeof(line), f)) {
1025 k = strcspn(l, "=");
1033 if (streq(l, "job-id")) {
1035 if (safe_atou32(v, &j->id) < 0)
1036 log_debug("Failed to parse job id value %s", v);
1038 } else if (streq(l, "job-type")) {
1041 t = job_type_from_string(v);
1043 log_debug("Failed to parse job type %s", v);
1044 else if (t >= _JOB_TYPE_MAX_IN_TRANSACTION)
1045 log_debug("Cannot deserialize job of type %s", v);
1049 } else if (streq(l, "job-state")) {
1052 s = job_state_from_string(v);
1054 log_debug("Failed to parse job state %s", v);
1056 job_set_state(j, s);
1058 } else if (streq(l, "job-override")) {
1061 b = parse_boolean(v);
1063 log_debug("Failed to parse job override flag %s", v);
1065 j->override = j->override || b;
1067 } else if (streq(l, "job-irreversible")) {
1070 b = parse_boolean(v);
1072 log_debug("Failed to parse job irreversible flag %s", v);
1074 j->irreversible = j->irreversible || b;
1076 } else if (streq(l, "job-sent-dbus-new-signal")) {
1079 b = parse_boolean(v);
1081 log_debug("Failed to parse job sent_dbus_new_signal flag %s", v);
1083 j->sent_dbus_new_signal = j->sent_dbus_new_signal || b;
1085 } else if (streq(l, "job-ignore-order")) {
1088 b = parse_boolean(v);
1090 log_debug("Failed to parse job ignore_order flag %s", v);
1092 j->ignore_order = j->ignore_order || b;
1094 } else if (streq(l, "job-begin")) {
1095 unsigned long long ull;
1097 if (sscanf(v, "%llu", &ull) != 1)
1098 log_debug("Failed to parse job-begin value %s", v);
1100 j->begin_usec = ull;
1102 } else if (streq(l, "subscribed")) {
1104 if (strv_extend(&j->deserialized_clients, v) < 0)
1110 int job_coldplug(Job *j) {
1115 /* After deserialization is complete and the bus connection
1116 * set up again, let's start watching our subscribers again */
1117 r = bus_track_coldplug(j->manager, &j->clients, &j->deserialized_clients);
1121 if (j->state == JOB_WAITING)
1122 job_add_to_run_queue(j);
1124 if (j->begin_usec == 0 || j->unit->job_timeout == 0)
1127 if (j->timer_event_source)
1128 j->timer_event_source = sd_event_source_unref(j->timer_event_source);
1130 r = sd_event_add_time(
1132 &j->timer_event_source,
1134 j->begin_usec + j->unit->job_timeout, 0,
1135 job_dispatch_timer, j);
1137 log_debug_errno(r, "Failed to restart timeout for job: %m");
1142 void job_shutdown_magic(Job *j) {
1145 /* The shutdown target gets some special treatment here: we
1146 * tell the kernel to begin with flushing its disk caches, to
1147 * optimize shutdown time a bit. Ideally we wouldn't hardcode
1148 * this magic into PID 1. However all other processes aren't
1149 * options either since they'd exit much sooner than PID 1 and
1150 * asynchronous sync() would cause their exit to be
1153 if (j->type != JOB_START)
1156 if (j->unit->manager->running_as != SYSTEMD_SYSTEM)
1159 if (!unit_has_name(j->unit, SPECIAL_SHUTDOWN_TARGET))
1162 /* In case messages on console has been disabled on boot */
1163 j->unit->manager->no_console_output = false;
1165 if (detect_container(NULL) > 0)
1168 asynchronous_sync();
1171 int job_get_timeout(Job *j, uint64_t *timeout) {
1173 uint64_t x = -1, y = -1;
1178 if (j->timer_event_source) {
1179 r = sd_event_source_get_time(j->timer_event_source, &x);
1185 if (UNIT_VTABLE(u)->get_timeout) {
1186 q = UNIT_VTABLE(u)->get_timeout(u, &y);
1191 if (r == 0 && q == 0)
1194 *timeout = MIN(x, y);
1199 static const char* const job_state_table[_JOB_STATE_MAX] = {
1200 [JOB_WAITING] = "waiting",
1201 [JOB_RUNNING] = "running"
1204 DEFINE_STRING_TABLE_LOOKUP(job_state, JobState);
1206 static const char* const job_type_table[_JOB_TYPE_MAX] = {
1207 [JOB_START] = "start",
1208 [JOB_VERIFY_ACTIVE] = "verify-active",
1209 [JOB_STOP] = "stop",
1210 [JOB_RELOAD] = "reload",
1211 [JOB_RELOAD_OR_START] = "reload-or-start",
1212 [JOB_RESTART] = "restart",
1213 [JOB_TRY_RESTART] = "try-restart",
1217 DEFINE_STRING_TABLE_LOOKUP(job_type, JobType);
1219 static const char* const job_mode_table[_JOB_MODE_MAX] = {
1220 [JOB_FAIL] = "fail",
1221 [JOB_REPLACE] = "replace",
1222 [JOB_REPLACE_IRREVERSIBLY] = "replace-irreversibly",
1223 [JOB_ISOLATE] = "isolate",
1224 [JOB_FLUSH] = "flush",
1225 [JOB_IGNORE_DEPENDENCIES] = "ignore-dependencies",
1226 [JOB_IGNORE_REQUIREMENTS] = "ignore-requirements",
1229 DEFINE_STRING_TABLE_LOOKUP(job_mode, JobMode);
1231 static const char* const job_result_table[_JOB_RESULT_MAX] = {
1232 [JOB_DONE] = "done",
1233 [JOB_CANCELED] = "canceled",
1234 [JOB_TIMEOUT] = "timeout",
1235 [JOB_FAILED] = "failed",
1236 [JOB_DEPENDENCY] = "dependency",
1237 [JOB_SKIPPED] = "skipped",
1238 [JOB_INVALID] = "invalid",
1239 [JOB_ASSERT] = "assert",
1240 [JOB_UNSUPPORTED] = "unsupported",
1243 DEFINE_STRING_TABLE_LOOKUP(job_result, JobResult);