X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fcore%2Fjob.c;h=557917a70b0dce3e42ce08ac594acfc91376fdd5;hp=9199cf6a4b6a0e54041159ab8f472d707840a292;hb=99f37ad86e114b2d1c9eaedf2bc1a0004a265d26;hpb=97e7d748d1bf26790fc3b2607885f4ac8c4ecf3a diff --git a/src/core/job.c b/src/core/job.c index 9199cf6a4..557917a70 100644 --- a/src/core/job.c +++ b/src/core/job.c @@ -24,6 +24,8 @@ #include #include +#include "sd-id128.h" +#include "sd-messages.h" #include "set.h" #include "unit.h" #include "macro.h" @@ -32,42 +34,44 @@ #include "load-dropin.h" #include "log.h" #include "dbus-job.h" +#include "special.h" +#include "async.h" +#include "virt.h" +#include "dbus-client-track.h" -Job* job_new(Manager *m, JobType type, Unit *unit) { +Job* job_new_raw(Unit *unit) { Job *j; - assert(m); - assert(type < _JOB_TYPE_MAX); + /* used for deserialization */ + assert(unit); - if (!(j = new0(Job, 1))) + j = new0(Job, 1); + if (!j) return NULL; - j->manager = m; - j->id = m->current_job_id++; - j->type = type; + j->manager = unit->manager; j->unit = unit; - - j->timer_watch.type = WATCH_INVALID; - - /* We don't link it here, that's what job_dependency() is for */ + j->type = _JOB_TYPE_INVALID; return j; } -void job_uninstall(Job *j) { - assert(j->installed); - /* Detach from next 'bigger' objects */ +Job* job_new(Unit *unit, JobType type) { + Job *j; - bus_job_send_removed_signal(j); + assert(type < _JOB_TYPE_MAX); - if (j->unit->job == j) { - j->unit->job = NULL; - unit_add_to_gc_queue(j->unit); - } + j = job_new_raw(unit); + if (!j) + return NULL; - hashmap_remove(j->manager->jobs, UINT32_TO_PTR(j->id)); - j->installed = false; + j->id = j->manager->current_job_id++; + j->type = type; + + /* We don't link it here, that's what job_dependency() is for */ + + return j; } void job_free(Job *j) { @@ -79,24 +83,146 @@ void job_free(Job *j) { assert(!j->object_list); if (j->in_run_queue) - LIST_REMOVE(Job, run_queue, j->manager->run_queue, j); + LIST_REMOVE(run_queue, j->manager->run_queue, j); if (j->in_dbus_queue) - LIST_REMOVE(Job, dbus_queue, j->manager->dbus_job_queue, j); + LIST_REMOVE(dbus_queue, j->manager->dbus_job_queue, j); - if (j->timer_watch.type != WATCH_INVALID) { - assert(j->timer_watch.type == WATCH_JOB_TIMER); - assert(j->timer_watch.data.job == j); - assert(j->timer_watch.fd >= 0); + sd_event_source_unref(j->timer_event_source); - assert_se(epoll_ctl(j->manager->epoll_fd, EPOLL_CTL_DEL, j->timer_watch.fd, NULL) >= 0); - close_nointr_nofail(j->timer_watch.fd); - } + bus_client_track_free(j->subscribed); - free(j->bus_client); free(j); } +void job_uninstall(Job *j) { + Job **pj; + + assert(j->installed); + + pj = (j->type == JOB_NOP) ? &j->unit->nop_job : &j->unit->job; + assert(*pj == j); + + /* Detach from next 'bigger' objects */ + + /* daemon-reload should be transparent to job observers */ + if (j->manager->n_reloading <= 0) + bus_job_send_removed_signal(j); + + *pj = NULL; + + unit_add_to_gc_queue(j->unit); + + hashmap_remove(j->manager->jobs, UINT32_TO_PTR(j->id)); + j->installed = false; +} + +static bool job_type_allows_late_merge(JobType t) { + /* Tells whether it is OK to merge a job of type 't' with an already + * running job. + * Reloads cannot be merged this way. Think of the sequence: + * 1. Reload of a daemon is in progress; the daemon has already loaded + * its config file, but hasn't completed the reload operation yet. + * 2. Edit foo's config file. + * 3. Trigger another reload to have the daemon use the new config. + * Should the second reload job be merged into the first one, the daemon + * would not know about the new config. + * JOB_RESTART jobs on the other hand can be merged, because they get + * patched into JOB_START after stopping the unit. So if we see a + * JOB_RESTART running, it means the unit hasn't stopped yet and at + * this time the merge is still allowed. */ + return t != JOB_RELOAD; +} + +static void job_merge_into_installed(Job *j, Job *other) { + assert(j->installed); + assert(j->unit == other->unit); + + if (j->type != JOB_NOP) + job_type_merge_and_collapse(&j->type, other->type, j->unit); + else + assert(other->type == JOB_NOP); + + j->override = j->override || other->override; + j->irreversible = j->irreversible || other->irreversible; + j->ignore_order = j->ignore_order || other->ignore_order; +} + +Job* job_install(Job *j) { + Job **pj; + Job *uj; + + assert(!j->installed); + assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION); + + pj = (j->type == JOB_NOP) ? &j->unit->nop_job : &j->unit->job; + uj = *pj; + + if (uj) { + if (j->type != JOB_NOP && job_type_is_conflicting(uj->type, j->type)) + job_finish_and_invalidate(uj, JOB_CANCELED, false); + else { + /* not conflicting, i.e. mergeable */ + + if (j->type == JOB_NOP || uj->state == JOB_WAITING || + (job_type_allows_late_merge(j->type) && job_type_is_superset(uj->type, j->type))) { + job_merge_into_installed(uj, j); + log_debug_unit(uj->unit->id, + "Merged into installed job %s/%s as %u", + uj->unit->id, job_type_to_string(uj->type), (unsigned) uj->id); + return uj; + } else { + /* already running and not safe to merge into */ + /* Patch uj to become a merged job and re-run it. */ + /* XXX It should be safer to queue j to run after uj finishes, but it is + * not currently possible to have more than one installed job per unit. */ + job_merge_into_installed(uj, j); + log_debug_unit(uj->unit->id, + "Merged into running job, re-running: %s/%s as %u", + uj->unit->id, job_type_to_string(uj->type), (unsigned) uj->id); + uj->state = JOB_WAITING; + uj->manager->n_running_jobs--; + return uj; + } + } + } + + /* Install the job */ + *pj = j; + j->installed = true; + j->manager->n_installed_jobs ++; + log_debug_unit(j->unit->id, + "Installed new job %s/%s as %u", + j->unit->id, job_type_to_string(j->type), (unsigned) j->id); + return j; +} + +int job_install_deserialized(Job *j) { + Job **pj; + + assert(!j->installed); + + if (j->type < 0 || j->type >= _JOB_TYPE_MAX_IN_TRANSACTION) { + log_debug("Invalid job type %s in deserialization.", strna(job_type_to_string(j->type))); + return -EINVAL; + } + + pj = (j->type == JOB_NOP) ? &j->unit->nop_job : &j->unit->job; + + if (*pj) { + log_debug_unit(j->unit->id, + "Unit %s already has a job installed. Not installing deserialized job.", + j->unit->id); + return -EEXIST; + } + *pj = j; + j->installed = true; + log_debug_unit(j->unit->id, + "Reinstalled deserialized job %s/%s as %u", + j->unit->id, job_type_to_string(j->type), (unsigned) j->id); + return 0; +} + JobDependency* job_dependency_new(Job *subject, Job *object, bool matters, bool conflicts) { JobDependency *l; @@ -116,11 +242,9 @@ JobDependency* job_dependency_new(Job *subject, Job *object, bool matters, bool l->conflicts = conflicts; if (subject) - LIST_PREPEND(JobDependency, subject, subject->subject_list, l); - else - LIST_PREPEND(JobDependency, subject, object->manager->transaction_anchor, l); + LIST_PREPEND(subject, subject->subject_list, l); - LIST_PREPEND(JobDependency, object, object->object_list, l); + LIST_PREPEND(object, object->object_list, l); return l; } @@ -129,11 +253,9 @@ void job_dependency_free(JobDependency *l) { assert(l); if (l->subject) - LIST_REMOVE(JobDependency, subject, l->subject->subject_list, l); - else - LIST_REMOVE(JobDependency, subject, l->object->manager->transaction_anchor, l); + LIST_REMOVE(subject, l->subject->subject_list, l); - LIST_REMOVE(JobDependency, object, l->object->object_list, l); + LIST_REMOVE(object, l->object->object_list, l); free(l); } @@ -149,23 +271,13 @@ void job_dump(Job *j, FILE*f, const char *prefix) { "%s-> Job %u:\n" "%s\tAction: %s -> %s\n" "%s\tState: %s\n" - "%s\tForced: %s\n", + "%s\tForced: %s\n" + "%s\tIrreversible: %s\n", prefix, j->id, prefix, j->unit->id, job_type_to_string(j->type), prefix, job_state_to_string(j->state), - prefix, yes_no(j->override)); -} - -bool job_is_anchor(Job *j) { - JobDependency *l; - - assert(j); - - LIST_FOREACH(object, l, j->object_list) - if (!l->subject) - return true; - - return false; + prefix, yes_no(j->override), + prefix, yes_no(j->irreversible)); } /* @@ -173,6 +285,10 @@ bool job_is_anchor(Job *j) { * its lower triangle to avoid duplication. We don't store the main diagonal, * because A merged with A is simply A. * + * If the resulting type is collapsed immediately afterwards (to get rid of + * the JOB_RELOAD_OR_START, which lies outside the lookup function's domain), + * the following properties hold: + * * Merging is associative! A merged with B merged with C is the same as * A merged with C merged with B. * @@ -183,21 +299,19 @@ bool job_is_anchor(Job *j) { * be merged with C either. */ static const JobType job_merging_table[] = { -/* What \ With * JOB_START JOB_VERIFY_ACTIVE JOB_STOP JOB_RELOAD JOB_RELOAD_OR_START JOB_RESTART JOB_TRY_RESTART */ -/************************************************************************************************************************************/ +/* What \ With * JOB_START JOB_VERIFY_ACTIVE JOB_STOP JOB_RELOAD */ +/*********************************************************************************/ /*JOB_START */ /*JOB_VERIFY_ACTIVE */ JOB_START, /*JOB_STOP */ -1, -1, /*JOB_RELOAD */ JOB_RELOAD_OR_START, JOB_RELOAD, -1, -/*JOB_RELOAD_OR_START*/ JOB_RELOAD_OR_START, JOB_RELOAD_OR_START, -1, JOB_RELOAD_OR_START, -/*JOB_RESTART */ JOB_RESTART, JOB_RESTART, -1, JOB_RESTART, JOB_RESTART, -/*JOB_TRY_RESTART */ JOB_RESTART, JOB_TRY_RESTART, -1, JOB_TRY_RESTART, JOB_RESTART, JOB_RESTART, +/*JOB_RESTART */ JOB_RESTART, JOB_RESTART, -1, JOB_RESTART, }; JobType job_type_lookup_merge(JobType a, JobType b) { - assert_cc(ELEMENTSOF(job_merging_table) == _JOB_TYPE_MAX * (_JOB_TYPE_MAX - 1) / 2); - assert(a >= 0 && a < _JOB_TYPE_MAX); - assert(b >= 0 && b < _JOB_TYPE_MAX); + assert_cc(ELEMENTSOF(job_merging_table) == _JOB_TYPE_MAX_MERGING * (_JOB_TYPE_MAX_MERGING - 1) / 2); + assert(a >= 0 && a < _JOB_TYPE_MAX_MERGING); + assert(b >= 0 && b < _JOB_TYPE_MAX_MERGING); if (a == b) return a; @@ -233,25 +347,51 @@ bool job_type_is_redundant(JobType a, UnitActiveState b) { return b == UNIT_RELOADING; - case JOB_RELOAD_OR_START: - return - b == UNIT_ACTIVATING || - b == UNIT_RELOADING; - case JOB_RESTART: return b == UNIT_ACTIVATING; + default: + assert_not_reached("Invalid job type"); + } +} + +void job_type_collapse(JobType *t, Unit *u) { + UnitActiveState s; + + switch (*t) { + case JOB_TRY_RESTART: - return - b == UNIT_ACTIVATING; + s = unit_active_state(u); + if (UNIT_IS_INACTIVE_OR_DEACTIVATING(s)) + *t = JOB_NOP; + else + *t = JOB_RESTART; + break; + + case JOB_RELOAD_OR_START: + s = unit_active_state(u); + if (UNIT_IS_INACTIVE_OR_DEACTIVATING(s)) + *t = JOB_START; + else + *t = JOB_RELOAD; + break; default: - assert_not_reached("Invalid job type"); + ; } } -bool job_is_runnable(Job *j) { +int job_type_merge_and_collapse(JobType *a, JobType b, Unit *u) { + JobType t = job_type_lookup_merge(*a, b); + if (t < 0) + return -EEXIST; + *a = t; + job_type_collapse(a, u); + return 0; +} + +static bool job_is_runnable(Job *j) { Iterator i; Unit *other; @@ -263,14 +403,21 @@ bool job_is_runnable(Job *j) { * job type) or before (in the case of a 'negative' job * type. */ + /* Note that unit types have a say in what is runnable, + * too. For example, if they return -EAGAIN from + * unit_start() they can indicate they are not + * runnable yet. */ + /* First check if there is an override */ if (j->ignore_order) return true; + if (j->type == JOB_NOP) + return true; + if (j->type == JOB_START || j->type == JOB_VERIFY_ACTIVE || - j->type == JOB_RELOAD || - j->type == JOB_RELOAD_OR_START) { + j->type == JOB_RELOAD) { /* Immediate result is that the job is or might be * started. In this case lets wait for the @@ -288,8 +435,7 @@ bool job_is_runnable(Job *j) { SET_FOREACH(other, j->unit->dependencies[UNIT_BEFORE], i) if (other->job && (other->job->type == JOB_STOP || - other->job->type == JOB_RESTART || - other->job->type == JOB_TRY_RESTART)) + other->job->type == JOB_RESTART)) return false; /* This means that for a service a and a service b where b @@ -307,9 +453,10 @@ bool job_is_runnable(Job *j) { } static void job_change_type(Job *j, JobType newtype) { - log_debug("Converting job %s/%s -> %s/%s", - j->unit->id, job_type_to_string(j->type), - j->unit->id, job_type_to_string(newtype)); + log_debug_unit(j->unit->id, + "Converting job %s/%s -> %s/%s", + j->unit->id, job_type_to_string(j->type), + j->unit->id, job_type_to_string(newtype)); j->type = newtype; } @@ -317,15 +464,15 @@ static void job_change_type(Job *j, JobType newtype) { int job_run_and_invalidate(Job *j) { int r; uint32_t id; - Manager *m; + Manager *m = j->manager; assert(j); assert(j->installed); + assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION); + assert(j->in_run_queue); - if (j->in_run_queue) { - LIST_REMOVE(Job, run_queue, j->manager->run_queue, j); - j->in_run_queue = false; - } + LIST_REMOVE(run_queue, j->manager->run_queue, j); + j->in_run_queue = false; if (j->state != JOB_WAITING) return 0; @@ -334,6 +481,7 @@ int job_run_and_invalidate(Job *j) { return -EAGAIN; j->state = JOB_RUNNING; + m->n_running_jobs++; job_add_to_dbus_queue(j); /* While we execute this operation the job might go away (for @@ -342,19 +490,9 @@ int job_run_and_invalidate(Job *j) { * store the id here, so that we can verify the job is still * valid. */ id = j->id; - m = j->manager; switch (j->type) { - case JOB_RELOAD_OR_START: - if (unit_active_state(j->unit) == UNIT_ACTIVE) { - job_change_type(j, JOB_RELOAD); - r = unit_reload(j->unit); - break; - } - job_change_type(j, JOB_START); - /* fall through */ - case JOB_START: r = unit_start(j->unit); @@ -374,14 +512,6 @@ int job_run_and_invalidate(Job *j) { break; } - case JOB_TRY_RESTART: - if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(j->unit))) { - r = -ENOEXEC; - break; - } - job_change_type(j, JOB_RESTART); - /* fall through */ - case JOB_STOP: case JOB_RESTART: r = unit_stop(j->unit); @@ -395,171 +525,306 @@ int job_run_and_invalidate(Job *j) { r = unit_reload(j->unit); break; + case JOB_NOP: + r = -EALREADY; + break; + default: assert_not_reached("Unknown job type"); } - if ((j = manager_get_job(m, id))) { + j = manager_get_job(m, id); + if (j) { if (r == -EALREADY) - r = job_finish_and_invalidate(j, JOB_DONE); + r = job_finish_and_invalidate(j, JOB_DONE, true); else if (r == -ENOEXEC) - r = job_finish_and_invalidate(j, JOB_SKIPPED); - else if (r == -EAGAIN) + r = job_finish_and_invalidate(j, JOB_SKIPPED, true); + else if (r == -EAGAIN) { j->state = JOB_WAITING; - else if (r < 0) - r = job_finish_and_invalidate(j, JOB_FAILED); + m->n_running_jobs--; + } else if (r < 0) + r = job_finish_and_invalidate(j, JOB_FAILED, true); } return r; } +_pure_ static const char *job_get_status_message_format(Unit *u, JobType t, JobResult result) { + const UnitStatusMessageFormats *format_table; + + assert(u); + assert(t >= 0); + assert(t < _JOB_TYPE_MAX); + + format_table = &UNIT_VTABLE(u)->status_message_formats; + if (!format_table) + return NULL; + + if (t == JOB_START) + return format_table->finished_start_job[result]; + else if (t == JOB_STOP || t == JOB_RESTART) + return format_table->finished_stop_job[result]; + + return NULL; +} + +_pure_ static const char *job_get_status_message_format_try_harder(Unit *u, JobType t, JobResult result) { + const char *format; + + assert(u); + assert(t >= 0); + assert(t < _JOB_TYPE_MAX); + + format = job_get_status_message_format(u, t, result); + if (format) + return format; + + /* Return generic strings */ + if (t == JOB_START) { + if (result == JOB_DONE) + return "Started %s."; + else if (result == JOB_FAILED) + return "Failed to start %s."; + else if (result == JOB_DEPENDENCY) + return "Dependency failed for %s."; + else if (result == JOB_TIMEOUT) + return "Timed out starting %s."; + } else if (t == JOB_STOP || t == JOB_RESTART) { + if (result == JOB_DONE) + return "Stopped %s."; + else if (result == JOB_FAILED) + return "Stopped (with error) %s."; + else if (result == JOB_TIMEOUT) + return "Timed out stoppping %s."; + } else if (t == JOB_RELOAD) { + if (result == JOB_DONE) + return "Reloaded %s."; + else if (result == JOB_FAILED) + return "Reload failed for %s."; + else if (result == JOB_TIMEOUT) + return "Timed out reloading %s."; + } + + return NULL; +} + static void job_print_status_message(Unit *u, JobType t, JobResult result) { + const char *format; + assert(u); + assert(t >= 0); + assert(t < _JOB_TYPE_MAX); if (t == JOB_START) { + format = job_get_status_message_format(u, t, result); + if (!format) + return; switch (result) { case JOB_DONE: if (u->condition_result) - unit_status_printf(u, ANSI_HIGHLIGHT_GREEN_ON " OK " ANSI_HIGHLIGHT_OFF, "Started %s", unit_description(u)); + unit_status_printf(u, ANSI_GREEN_ON " OK " ANSI_HIGHLIGHT_OFF, format); break; case JOB_FAILED: - unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON "FAILED" ANSI_HIGHLIGHT_OFF, "Failed to start %s", unit_description(u)); - unit_status_printf(u, NULL, "See 'systemctl status %s' for details.", u->id); + unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON "FAILED" ANSI_HIGHLIGHT_OFF, format); + manager_status_printf(u->manager, false, NULL, "See 'systemctl status %s' for details.", u->id); break; case JOB_DEPENDENCY: - unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " ABORT" ANSI_HIGHLIGHT_OFF, "Dependency failed. Aborted start of %s", unit_description(u)); + unit_status_printf(u, ANSI_HIGHLIGHT_YELLOW_ON "DEPEND" ANSI_HIGHLIGHT_OFF, format); break; case JOB_TIMEOUT: - unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " TIME " ANSI_HIGHLIGHT_OFF, "Timed out starting %s", unit_description(u)); + unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " TIME " ANSI_HIGHLIGHT_OFF, format); break; default: ; } - } else if (t == JOB_STOP) { + } else if (t == JOB_STOP || t == JOB_RESTART) { + + format = job_get_status_message_format(u, t, result); + if (!format) + return; switch (result) { case JOB_TIMEOUT: - unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " TIME " ANSI_HIGHLIGHT_OFF, "Timed out stopping %s", unit_description(u)); + unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " TIME " ANSI_HIGHLIGHT_OFF, format); break; case JOB_DONE: case JOB_FAILED: - unit_status_printf(u, ANSI_HIGHLIGHT_GREEN_ON " OK " ANSI_HIGHLIGHT_OFF, "Stopped %s", unit_description(u)); + unit_status_printf(u, ANSI_GREEN_ON " OK " ANSI_HIGHLIGHT_OFF, format); break; default: ; } + + } else if (t == JOB_VERIFY_ACTIVE) { + + /* When verify-active detects the unit is inactive, report it. + * Most likely a DEPEND warning from a requisiting unit will + * occur next and it's nice to see what was requisited. */ + if (result == JOB_SKIPPED) + unit_status_printf(u, ANSI_HIGHLIGHT_ON " INFO " ANSI_HIGHLIGHT_OFF, "%s is not active."); } } -int job_finish_and_invalidate(Job *j, JobResult result) { +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wformat-nonliteral" +static void job_log_status_message(Unit *u, JobType t, JobResult result) { + const char *format; + char buf[LINE_MAX]; + + assert(u); + assert(t >= 0); + assert(t < _JOB_TYPE_MAX); + + /* Skip this if it goes to the console. since we already print + * to the console anyway... */ + + if (log_on_console()) + return; + + format = job_get_status_message_format_try_harder(u, t, result); + if (!format) + return; + + snprintf(buf, sizeof(buf), format, unit_description(u)); + char_array_0(buf); + + if (t == JOB_START) { + sd_id128_t mid; + + mid = result == JOB_DONE ? SD_MESSAGE_UNIT_STARTED : SD_MESSAGE_UNIT_FAILED; + log_struct_unit(result == JOB_DONE ? LOG_INFO : LOG_ERR, + u->id, + MESSAGE_ID(mid), + "RESULT=%s", job_result_to_string(result), + "MESSAGE=%s", buf, + NULL); + + } else if (t == JOB_STOP) + log_struct_unit(result == JOB_DONE ? LOG_INFO : LOG_ERR, + u->id, + MESSAGE_ID(SD_MESSAGE_UNIT_STOPPED), + "RESULT=%s", job_result_to_string(result), + "MESSAGE=%s", buf, + NULL); + + else if (t == JOB_RELOAD) + log_struct_unit(result == JOB_DONE ? LOG_INFO : LOG_ERR, + u->id, + MESSAGE_ID(SD_MESSAGE_UNIT_RELOADED), + "RESULT=%s", job_result_to_string(result), + "MESSAGE=%s", buf, + NULL); +} +#pragma GCC diagnostic pop + +int job_finish_and_invalidate(Job *j, JobResult result, bool recursive) { Unit *u; Unit *other; JobType t; Iterator i; - bool recursed = false; assert(j); assert(j->installed); + assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION); + + u = j->unit; + t = j->type; + + j->result = result; + + if (j->state == JOB_RUNNING) + j->manager->n_running_jobs--; + + log_debug_unit(u->id, "Job %s/%s finished, result=%s", + u->id, job_type_to_string(t), job_result_to_string(result)); + + job_print_status_message(u, t, result); + job_log_status_message(u, t, result); job_add_to_dbus_queue(j); /* Patch restart jobs so that they become normal start jobs */ - if (result == JOB_DONE && j->type == JOB_RESTART) { + if (result == JOB_DONE && t == JOB_RESTART) { job_change_type(j, JOB_START); j->state = JOB_WAITING; job_add_to_run_queue(j); - u = j->unit; goto finish; } - j->result = result; - - log_debug("Job %s/%s finished, result=%s", j->unit->id, job_type_to_string(j->type), job_result_to_string(result)); - if (result == JOB_FAILED) j->manager->n_failed_jobs ++; - u = j->unit; - t = j->type; job_uninstall(j); job_free(j); - job_print_status_message(u, t, result); - /* Fail depending jobs on failure */ - if (result != JOB_DONE) { + if (result != JOB_DONE && recursive) { if (t == JOB_START || - t == JOB_VERIFY_ACTIVE || - t == JOB_RELOAD_OR_START) { + t == JOB_VERIFY_ACTIVE) { SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i) if (other->job && (other->job->type == JOB_START || - other->job->type == JOB_VERIFY_ACTIVE || - other->job->type == JOB_RELOAD_OR_START)) { - job_finish_and_invalidate(other->job, JOB_DEPENDENCY); - recursed = true; - } + other->job->type == JOB_VERIFY_ACTIVE)) + job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true); SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i) if (other->job && (other->job->type == JOB_START || - other->job->type == JOB_VERIFY_ACTIVE || - other->job->type == JOB_RELOAD_OR_START)) { - job_finish_and_invalidate(other->job, JOB_DEPENDENCY); - recursed = true; - } + other->job->type == JOB_VERIFY_ACTIVE)) + job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true); SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i) if (other->job && !other->job->override && (other->job->type == JOB_START || - other->job->type == JOB_VERIFY_ACTIVE || - other->job->type == JOB_RELOAD_OR_START)) { - job_finish_and_invalidate(other->job, JOB_DEPENDENCY); - recursed = true; - } + other->job->type == JOB_VERIFY_ACTIVE)) + job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true); } else if (t == JOB_STOP) { SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i) if (other->job && (other->job->type == JOB_START || - other->job->type == JOB_VERIFY_ACTIVE || - other->job->type == JOB_RELOAD_OR_START)) { - job_finish_and_invalidate(other->job, JOB_DEPENDENCY); - recursed = true; - } + other->job->type == JOB_VERIFY_ACTIVE)) + job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true); } } /* Trigger OnFailure dependencies that are not generated by - * the unit itself. We don't tread JOB_CANCELED as failure in + * the unit itself. We don't treat JOB_CANCELED as failure in * this context. And JOB_FAILURE is already handled by the * unit itself. */ if (result == JOB_TIMEOUT || result == JOB_DEPENDENCY) { - log_notice("Job %s/%s failed with result '%s'.", + log_struct_unit(LOG_NOTICE, + u->id, + "JOB_TYPE=%s", job_type_to_string(t), + "JOB_RESULT=%s", job_result_to_string(result), + "Job %s/%s failed with result '%s'.", u->id, job_type_to_string(t), - job_result_to_string(result)); + job_result_to_string(result), + NULL); - unit_trigger_on_failure(u); + unit_start_on_failure(u); } + unit_trigger_notify(u); + finish: /* Try to start the next jobs that can be started */ SET_FOREACH(other, u->dependencies[UNIT_AFTER], i) @@ -571,54 +836,35 @@ finish: manager_check_finished(u->manager); - return recursed; + return 0; } -int job_start_timer(Job *j) { - struct itimerspec its; - struct epoll_event ev; - int fd, r; - assert(j); - - if (j->unit->job_timeout <= 0 || - j->timer_watch.type == WATCH_JOB_TIMER) - return 0; +static int job_dispatch_timer(sd_event_source *s, uint64_t monotonic, void *userdata) { + Job *j = userdata; - assert(j->timer_watch.type == WATCH_INVALID); + assert(j); + assert(s == j->timer_event_source); - if ((fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0) { - r = -errno; - goto fail; - } + log_warning_unit(j->unit->id, "Job %s/%s timed out.", + j->unit->id, job_type_to_string(j->type)); - zero(its); - timespec_store(&its.it_value, j->unit->job_timeout); + job_finish_and_invalidate(j, JOB_TIMEOUT, true); + return 0; +} - if (timerfd_settime(fd, 0, &its, NULL) < 0) { - r = -errno; - goto fail; - } +int job_start_timer(Job *j) { + int r; - zero(ev); - ev.data.ptr = &j->timer_watch; - ev.events = EPOLLIN; + if (j->unit->job_timeout <= 0 || j->timer_event_source) + return 0; - if (epoll_ctl(j->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0) { - r = -errno; - goto fail; - } + j->begin_usec = now(CLOCK_MONOTONIC); - j->timer_watch.type = WATCH_JOB_TIMER; - j->timer_watch.fd = fd; - j->timer_watch.data.job = j; + r = sd_event_add_monotonic(j->manager->event, j->begin_usec + j->unit->job_timeout, 0, job_dispatch_timer, j, &j->timer_event_source); + if (r < 0) + return r; return 0; - -fail: - if (fd >= 0) - close_nointr_nofail(fd); - - return r; } void job_add_to_run_queue(Job *j) { @@ -628,7 +874,10 @@ void job_add_to_run_queue(Job *j) { if (j->in_run_queue) return; - LIST_PREPEND(Job, run_queue, j->manager->run_queue, j); + if (!j->manager->run_queue) + sd_event_source_set_enabled(j->manager->run_queue_event_source, SD_EVENT_ONESHOT); + + LIST_PREPEND(run_queue, j->manager->run_queue, j); j->in_run_queue = true; } @@ -643,7 +892,7 @@ void job_add_to_dbus_queue(Job *j) { * job might just have been created and not yet assigned to a * connection/client. */ - LIST_PREPEND(Job, dbus_queue, j->manager->dbus_job_queue, j); + LIST_PREPEND(dbus_queue, j->manager->dbus_job_queue, j); j->in_dbus_queue = true; } @@ -658,12 +907,178 @@ char *job_dbus_path(Job *j) { return p; } -void job_timer_event(Job *j, uint64_t n_elapsed, Watch *w) { +int job_serialize(Job *j, FILE *f, FDSet *fds) { + fprintf(f, "job-id=%u\n", j->id); + fprintf(f, "job-type=%s\n", job_type_to_string(j->type)); + fprintf(f, "job-state=%s\n", job_state_to_string(j->state)); + fprintf(f, "job-override=%s\n", yes_no(j->override)); + fprintf(f, "job-irreversible=%s\n", yes_no(j->irreversible)); + fprintf(f, "job-sent-dbus-new-signal=%s\n", yes_no(j->sent_dbus_new_signal)); + fprintf(f, "job-ignore-order=%s\n", yes_no(j->ignore_order)); + + if (j->begin_usec > 0) + fprintf(f, "job-begin=%llu\n", (unsigned long long) j->begin_usec); + + bus_client_track_serialize(j->manager, f, j->subscribed); + + /* End marker */ + fputc('\n', f); + return 0; +} + +int job_deserialize(Job *j, FILE *f, FDSet *fds) { + assert(j); + + for (;;) { + char line[LINE_MAX], *l, *v; + size_t k; + + if (!fgets(line, sizeof(line), f)) { + if (feof(f)) + return 0; + return -errno; + } + + char_array_0(line); + l = strstrip(line); + + /* End marker */ + if (l[0] == 0) + return 0; + + k = strcspn(l, "="); + + if (l[k] == '=') { + l[k] = 0; + v = l+k+1; + } else + v = l+k; + + if (streq(l, "job-id")) { + + if (safe_atou32(v, &j->id) < 0) + log_debug("Failed to parse job id value %s", v); + + } else if (streq(l, "job-type")) { + JobType t; + + t = job_type_from_string(v); + if (t < 0) + log_debug("Failed to parse job type %s", v); + else if (t >= _JOB_TYPE_MAX_IN_TRANSACTION) + log_debug("Cannot deserialize job of type %s", v); + else + j->type = t; + + } else if (streq(l, "job-state")) { + JobState s; + + s = job_state_from_string(v); + if (s < 0) + log_debug("Failed to parse job state %s", v); + else + j->state = s; + + } else if (streq(l, "job-override")) { + int b; + + b = parse_boolean(v); + if (b < 0) + log_debug("Failed to parse job override flag %s", v); + else + j->override = j->override || b; + + } else if (streq(l, "job-irreversible")) { + int b; + + b = parse_boolean(v); + if (b < 0) + log_debug("Failed to parse job irreversible flag %s", v); + else + j->irreversible = j->irreversible || b; + + } else if (streq(l, "job-sent-dbus-new-signal")) { + int b; + + b = parse_boolean(v); + if (b < 0) + log_debug("Failed to parse job sent_dbus_new_signal flag %s", v); + else + j->sent_dbus_new_signal = j->sent_dbus_new_signal || b; + + } else if (streq(l, "job-ignore-order")) { + int b; + + b = parse_boolean(v); + if (b < 0) + log_debug("Failed to parse job ignore_order flag %s", v); + else + j->ignore_order = j->ignore_order || b; + + } else if (streq(l, "job-begin")) { + unsigned long long ull; + + if (sscanf(v, "%llu", &ull) != 1) + log_debug("Failed to parse job-begin value %s", v); + else + j->begin_usec = ull; + + } else { + char t[strlen(l) + 1 + strlen(v) + 1]; + + strcpy(stpcpy(stpcpy(t, l), "="), v); + + if (bus_client_track_deserialize_item(j->manager, &j->subscribed, t) == 0) + log_debug("Unknown deserialization key '%s'", l); + } + } +} + +int job_coldplug(Job *j) { + int r; + + assert(j); + + if (j->begin_usec <= 0) + return 0; + + if (j->timer_event_source) + j->timer_event_source = sd_event_source_unref(j->timer_event_source); + + r = sd_event_add_monotonic(j->manager->event, j->begin_usec + j->unit->job_timeout, 0, job_dispatch_timer, j, &j->timer_event_source); + if (r < 0) + log_debug("Failed to restart timeout for job: %s", strerror(-r)); + + return r; +} + +void job_shutdown_magic(Job *j) { assert(j); - assert(w == &j->timer_watch); - log_warning("Job %s/%s timed out.", j->unit->id, job_type_to_string(j->type)); - job_finish_and_invalidate(j, JOB_TIMEOUT); + /* The shutdown target gets some special treatment here: we + * tell the kernel to begin with flushing its disk caches, to + * optimize shutdown time a bit. Ideally we wouldn't hardcode + * this magic into PID 1. However all other processes aren't + * options either since they'd exit much sooner than PID 1 and + * asynchronous sync() would cause their exit to be + * delayed. */ + + if (j->type != JOB_START) + return; + + if (j->unit->manager->running_as != SYSTEMD_SYSTEM) + return; + + if (!unit_has_name(j->unit, SPECIAL_SHUTDOWN_TARGET)) + return; + + /* In case messages on console has been disabled on boot */ + j->unit->manager->no_console_output = false; + + if (detect_container(NULL) > 0) + return; + + asynchronous_sync(); } static const char* const job_state_table[_JOB_STATE_MAX] = { @@ -681,6 +1096,7 @@ static const char* const job_type_table[_JOB_TYPE_MAX] = { [JOB_RELOAD_OR_START] = "reload-or-start", [JOB_RESTART] = "restart", [JOB_TRY_RESTART] = "try-restart", + [JOB_NOP] = "nop", }; DEFINE_STRING_TABLE_LOOKUP(job_type, JobType); @@ -688,9 +1104,11 @@ DEFINE_STRING_TABLE_LOOKUP(job_type, JobType); static const char* const job_mode_table[_JOB_MODE_MAX] = { [JOB_FAIL] = "fail", [JOB_REPLACE] = "replace", + [JOB_REPLACE_IRREVERSIBLY] = "replace-irreversibly", [JOB_ISOLATE] = "isolate", [JOB_IGNORE_DEPENDENCIES] = "ignore-dependencies", - [JOB_IGNORE_REQUIREMENTS] = "ignore-requirements" + [JOB_IGNORE_REQUIREMENTS] = "ignore-requirements", + [JOB_FLUSH] = "flush", }; DEFINE_STRING_TABLE_LOOKUP(job_mode, JobMode);