along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
-#include <assert.h>
#include <errno.h>
-#include <sys/timerfd.h>
-#include <sys/epoll.h>
-#include "systemd/sd-id128.h"
-#include "systemd/sd-messages.h"
+#include "sd-id128.h"
+#include "sd-messages.h"
#include "set.h"
#include "unit.h"
#include "macro.h"
#include "strv.h"
-#include "load-fragment.h"
-#include "load-dropin.h"
#include "log.h"
#include "dbus-job.h"
-
-JobBusClient* job_bus_client_new(DBusConnection *connection, const char *name) {
- JobBusClient *cl;
- size_t name_len;
-
- name_len = strlen(name);
- cl = malloc0(sizeof(JobBusClient) + name_len + 1);
- if (!cl)
- return NULL;
-
- cl->bus = connection;
- memcpy(cl->name, name, name_len + 1);
- return cl;
-}
+#include "special.h"
+#include "async.h"
+#include "virt.h"
+#include "dbus.h"
Job* job_new_raw(Unit *unit) {
Job *j;
j->manager = unit->manager;
j->unit = unit;
j->type = _JOB_TYPE_INVALID;
- j->timer_watch.type = WATCH_INVALID;
return j;
}
}
void job_free(Job *j) {
- JobBusClient *cl;
-
assert(j);
assert(!j->installed);
assert(!j->transaction_prev);
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);
- }
+ sd_bus_track_unref(j->clients);
+ strv_free(j->deserialized_clients);
- while ((cl = j->bus_client_list)) {
- LIST_REMOVE(JobBusClient, client, j->bus_client_list, cl);
- free(cl);
- }
free(j);
}
+static void job_set_state(Job *j, JobState state) {
+ assert(j);
+ assert(state >= 0);
+ assert(state < _JOB_STATE_MAX);
+
+ if (j->state == state)
+ return;
+
+ j->state = state;
+
+ if (!j->installed)
+ return;
+
+ if (j->state == JOB_RUNNING)
+ j->unit->manager->n_running_jobs++;
+ else {
+ assert(j->state == JOB_WAITING);
+ assert(j->unit->manager->n_running_jobs > 0);
+
+ j->unit->manager->n_running_jobs--;
+
+ if (j->unit->manager->n_running_jobs <= 0)
+ j->unit->manager->jobs_in_progress_event_source = sd_event_source_unref(j->unit->manager->jobs_in_progress_event_source);
+ }
+}
+
void job_uninstall(Job *j) {
Job **pj;
assert(j->installed);
+ job_set_state(j, JOB_WAITING);
+
pj = (j->type == JOB_NOP) ? &j->unit->nop_job : &j->unit->job;
assert(*pj == j);
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) {
assert(!j->installed);
assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION);
+ assert(j->state == JOB_WAITING);
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))
+ if (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 ||
+ if (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,
+ log_unit_debug(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;
/* 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,
+ log_unit_debug(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;
+
+ job_set_state(uj, JOB_WAITING);
return uj;
}
}
/* Install the job */
*pj = j;
j->installed = true;
+
j->manager->n_installed_jobs ++;
- log_debug_unit(j->unit->id,
+ log_unit_debug(j->unit->id,
"Installed new job %s/%s as %u",
j->unit->id, job_type_to_string(j->type), (unsigned) j->id);
return j;
}
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);
+ log_unit_debug(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,
+
+ if (j->state == JOB_RUNNING)
+ j->unit->manager->n_running_jobs++;
+
+ log_unit_debug(j->unit->id,
"Reinstalled deserialized job %s/%s as %u",
j->unit->id, job_type_to_string(j->type), (unsigned) j->id);
return 0;
l->conflicts = conflicts;
if (subject)
- LIST_PREPEND(JobDependency, subject, subject->subject_list, 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;
}
assert(l);
if (l->subject)
- LIST_REMOVE(JobDependency, subject, l->subject->subject_list, 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);
}
"%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));
+ prefix, yes_no(j->override),
+ prefix, yes_no(j->irreversible));
}
/*
* 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.
+ * Merging is associative! A merged with B, and then merged with C is the same
+ * as A merged with the result of B merged with C.
*
* Mergeability is transitive! If A can be merged with B and B with C then
* A also with C.
return
b == UNIT_ACTIVATING;
+ case JOB_NOP:
+ return true;
+
default:
assert_not_reached("Invalid job type");
}
return 0;
}
-bool job_is_runnable(Job *j) {
+static bool job_is_runnable(Job *j) {
Iterator i;
Unit *other;
* 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;
}
static void job_change_type(Job *j, JobType newtype) {
- log_debug_unit(j->unit->id,
+ log_unit_debug(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));
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);
- LIST_REMOVE(Job, run_queue, j->manager->run_queue, j);
+ LIST_REMOVE(run_queue, j->manager->run_queue, j);
j->in_run_queue = false;
if (j->state != JOB_WAITING)
if (!job_is_runnable(j))
return -EAGAIN;
- j->state = JOB_RUNNING;
+ job_set_state(j, JOB_RUNNING);
job_add_to_dbus_queue(j);
/* While we execute this operation the job might go away (for
* store the id here, so that we can verify the job is still
* valid. */
id = j->id;
- m = j->manager;
switch (j->type) {
else if (t == UNIT_ACTIVATING)
r = -EAGAIN;
else
- r = -ENOEXEC;
+ r = -EBADR;
break;
}
if (j) {
if (r == -EALREADY)
r = job_finish_and_invalidate(j, JOB_DONE, true);
- else if (r == -ENOEXEC)
+ else if (r == -EBADR)
r = job_finish_and_invalidate(j, JOB_SKIPPED, true);
+ else if (r == -ENOEXEC)
+ r = job_finish_and_invalidate(j, JOB_INVALID, true);
+ else if (r == -EPROTO)
+ r = job_finish_and_invalidate(j, JOB_ASSERT, true);
+ else if (r == -ENOTSUP)
+ r = job_finish_and_invalidate(j, JOB_UNSUPPORTED, true);
else if (r == -EAGAIN)
- j->state = JOB_WAITING;
+ job_set_state(j, JOB_WAITING);
else if (r < 0)
r = job_finish_and_invalidate(j, JOB_FAILED, true);
}
return r;
}
-static const char *job_get_status_message_format(Unit *u, JobType t, JobResult result) {
+_pure_ static const char *job_get_status_message_format(Unit *u, JobType t, JobResult result) {
const UnitStatusMessageFormats *format_table;
assert(u);
return NULL;
}
-static const char *job_get_status_message_format_try_harder(Unit *u, JobType t, JobResult result) {
+_pure_ static const char *job_get_status_message_format_try_harder(Unit *u, JobType t, JobResult result) {
const char *format;
assert(u);
if (t == JOB_START) {
if (result == JOB_DONE)
return "Started %s.";
+ else if (result == JOB_TIMEOUT)
+ return "Timed out starting %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 (result == JOB_ASSERT)
+ return "Assertion failed for %s.";
+ else if (result == JOB_UNSUPPORTED)
+ return "Starting of %s not supported.";
} else if (t == JOB_STOP || t == JOB_RESTART) {
if (result == JOB_DONE)
return "Stopped %s.";
assert(t >= 0);
assert(t < _JOB_TYPE_MAX);
+ DISABLE_WARNING_FORMAT_NONLITERAL;
+
if (t == JOB_START) {
format = job_get_status_message_format(u, t, result);
if (!format)
case JOB_DONE:
if (u->condition_result)
- unit_status_printf(u, ANSI_HIGHLIGHT_GREEN_ON " OK " ANSI_HIGHLIGHT_OFF, format, 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, format, unit_description(u));
- unit_status_printf(u, NULL, "See 'systemctl status %s' for details.", u->id);
+ case JOB_TIMEOUT:
+ manager_flip_auto_status(u->manager, true);
+ unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " TIME " ANSI_HIGHLIGHT_OFF, format);
break;
+ case JOB_FAILED: {
+ bool quotes;
+
+ quotes = chars_intersect(u->id, SHELL_NEED_QUOTES);
+
+ manager_flip_auto_status(u->manager, true);
+ unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON "FAILED" ANSI_HIGHLIGHT_OFF, format);
+ manager_status_printf(u->manager, STATUS_TYPE_NORMAL, NULL,
+ "See \"systemctl status %s%s%s\" for details.",
+ quotes ? "'" : "", u->id, quotes ? "'" : "");
+ break;
+ }
+
case JOB_DEPENDENCY:
- unit_status_printf(u, ANSI_HIGHLIGHT_YELLOW_ON "DEPEND" ANSI_HIGHLIGHT_OFF, format, unit_description(u));
+ manager_flip_auto_status(u->manager, true);
+ 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, format, unit_description(u));
+ case JOB_ASSERT:
+ manager_flip_auto_status(u->manager, true);
+ unit_status_printf(u, ANSI_HIGHLIGHT_YELLOW_ON "ASSERT" ANSI_HIGHLIGHT_OFF, format);
+ break;
+
+ case JOB_UNSUPPORTED:
+ manager_flip_auto_status(u->manager, true);
+ unit_status_printf(u, ANSI_HIGHLIGHT_YELLOW_ON "UNSUPP" ANSI_HIGHLIGHT_OFF, format);
break;
default:
switch (result) {
case JOB_TIMEOUT:
- unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " TIME " ANSI_HIGHLIGHT_OFF, format, unit_description(u));
+ manager_flip_auto_status(u->manager, true);
+ 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, format, unit_description(u));
+ unit_status_printf(u, ANSI_GREEN_ON " OK " ANSI_HIGHLIGHT_OFF, format);
break;
default:
* 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.", unit_description(u));
+ unit_status_printf(u, ANSI_HIGHLIGHT_ON " INFO " ANSI_HIGHLIGHT_OFF, "%s is not active.");
}
+
+ REENABLE_WARNING;
}
-#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];
if (!format)
return;
+ DISABLE_WARNING_FORMAT_NONLITERAL;
snprintf(buf, sizeof(buf), format, unit_description(u));
- char_array_0(buf);
+ REENABLE_WARNING;
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);
+ log_unit_struct(u->id,
+ result == JOB_DONE ? LOG_INFO : LOG_ERR,
+ LOG_MESSAGE_ID(mid),
+ LOG_MESSAGE("%s", buf),
+ "RESULT=%s", job_result_to_string(result),
+ 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);
+ log_unit_struct(u->id,
+ result == JOB_DONE ? LOG_INFO : LOG_ERR,
+ LOG_MESSAGE_ID(SD_MESSAGE_UNIT_STOPPED),
+ LOG_MESSAGE("%s", buf),
+ "RESULT=%s", job_result_to_string(result),
+ 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);
+ log_unit_struct(u->id,
+ result == JOB_DONE ? LOG_INFO : LOG_ERR,
+ LOG_MESSAGE_ID(SD_MESSAGE_UNIT_RELOADED),
+ LOG_MESSAGE("%s", buf),
+ "RESULT=%s", job_result_to_string(result),
+ NULL);
}
-#pragma GCC diagnostic pop
int job_finish_and_invalidate(Job *j, JobResult result, bool recursive) {
Unit *u;
j->result = result;
- log_debug_unit(u->id, "Job %s/%s finished, result=%s",
+ log_unit_debug(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);
if (result == JOB_DONE && t == JOB_RESTART) {
job_change_type(j, JOB_START);
- j->state = JOB_WAITING;
+ job_set_state(j, JOB_WAITING);
job_add_to_run_queue(j);
goto finish;
}
- if (result == JOB_FAILED)
+ if (result == JOB_FAILED || result == JOB_INVALID)
j->manager->n_failed_jobs ++;
job_uninstall(j);
* this context. And JOB_FAILURE is already handled by the
* unit itself. */
if (result == JOB_TIMEOUT || result == JOB_DEPENDENCY) {
- 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),
- NULL);
-
- unit_trigger_on_failure(u);
+ log_unit_struct(u->id,
+ LOG_NOTICE,
+ "JOB_TYPE=%s", job_type_to_string(t),
+ "JOB_RESULT=%s", job_result_to_string(result),
+ LOG_MESSAGE("Job %s/%s failed with result '%s'.",
+ u->id,
+ job_type_to_string(t),
+ job_result_to_string(result)),
+ NULL);
+
+ 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)
return 0;
}
-int job_start_timer(Job *j) {
- struct itimerspec its;
- struct epoll_event ev;
- int fd, r;
- assert(j);
+static int job_dispatch_timer(sd_event_source *s, uint64_t monotonic, void *userdata) {
+ Job *j = userdata;
+ Unit *u;
- if (j->unit->job_timeout <= 0 ||
- j->timer_watch.type == WATCH_JOB_TIMER)
- return 0;
+ assert(j);
+ assert(s == j->timer_event_source);
- assert(j->timer_watch.type == WATCH_INVALID);
+ log_unit_warning(j->unit->id, "Job %s/%s timed out.", j->unit->id, job_type_to_string(j->type));
- if ((fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0) {
- r = -errno;
- goto fail;
- }
+ u = j->unit;
+ job_finish_and_invalidate(j, JOB_TIMEOUT, true);
- zero(its);
- timespec_store(&its.it_value, j->unit->job_timeout);
+ failure_action(u->manager, u->job_timeout_action, u->job_timeout_reboot_arg);
- if (timerfd_settime(fd, 0, &its, NULL) < 0) {
- r = -errno;
- goto fail;
- }
+ return 0;
+}
- zero(ev);
- ev.data.ptr = &j->timer_watch;
- ev.events = EPOLLIN;
+int job_start_timer(Job *j) {
+ int r;
- if (epoll_ctl(j->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0) {
- r = -errno;
- goto fail;
- }
+ if (j->timer_event_source)
+ return 0;
- j->timer_watch.type = WATCH_JOB_TIMER;
- j->timer_watch.fd = fd;
- j->timer_watch.data.job = j;
+ j->begin_usec = now(CLOCK_MONOTONIC);
- return 0;
+ if (j->unit->job_timeout <= 0)
+ return 0;
-fail:
- if (fd >= 0)
- close_nointr_nofail(fd);
+ r = sd_event_add_time(
+ j->manager->event,
+ &j->timer_event_source,
+ CLOCK_MONOTONIC,
+ j->begin_usec + j->unit->job_timeout, 0,
+ job_dispatch_timer, j);
+ if (r < 0)
+ return r;
- return r;
+ return 0;
}
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;
}
* 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;
}
assert(j);
- if (asprintf(&p, "/org/freedesktop/systemd1/job/%lu", (unsigned long) j->id) < 0)
+ if (asprintf(&p, "/org/freedesktop/systemd1/job/%"PRIu32, j->id) < 0)
return NULL;
return p;
}
-void job_timer_event(Job *j, uint64_t n_elapsed, Watch *w) {
- assert(j);
- assert(w == &j->timer_watch);
-
- log_warning_unit(j->unit->id, "Job %s/%s timed out.",
- j->unit->id, job_type_to_string(j->type));
- job_finish_and_invalidate(j, JOB_TIMEOUT, true);
-}
-
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));
- /* Cannot save bus clients. Just note the fact that we're losing
- * them. job_send_message() will fallback to broadcasting. */
- fprintf(f, "job-forgot-bus-clients=%s\n",
- yes_no(j->forgot_bus_clients || j->bus_client_list));
- if (j->timer_watch.type == WATCH_JOB_TIMER) {
- int copy = fdset_put_dup(fds, j->timer_watch.fd);
- if (copy < 0)
- return copy;
- fprintf(f, "job-timer-watch-fd=%d\n", copy);
- }
+
+ if (j->begin_usec > 0)
+ fprintf(f, "job-begin="USEC_FMT"\n", j->begin_usec);
+
+ bus_track_serialize(j->clients, f);
/* End marker */
fputc('\n', f);
}
int job_deserialize(Job *j, FILE *f, FDSet *fds) {
+ assert(j);
+
for (;;) {
char line[LINE_MAX], *l, *v;
size_t k;
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 = job_type_from_string(v);
+ 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 = job_state_from_string(v);
+ JobState s;
+
+ s = job_state_from_string(v);
if (s < 0)
log_debug("Failed to parse job state %s", v);
else
- j->state = s;
+ job_set_state(j, s);
+
} else if (streq(l, "job-override")) {
- int b = parse_boolean(v);
+ 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 = parse_boolean(v);
+ 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 = parse_boolean(v);
+ 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-forgot-bus-clients")) {
- int b = parse_boolean(v);
- if (b < 0)
- log_debug("Failed to parse job forgot_bus_clients flag %s", v);
+
+ } 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->forgot_bus_clients = j->forgot_bus_clients || b;
- } else if (streq(l, "job-timer-watch-fd")) {
- int fd;
- if (safe_atoi(v, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
- log_debug("Failed to parse job-timer-watch-fd value %s", v);
- else {
- if (j->timer_watch.type == WATCH_JOB_TIMER)
- close_nointr_nofail(j->timer_watch.fd);
-
- j->timer_watch.type = WATCH_JOB_TIMER;
- j->timer_watch.fd = fdset_remove(fds, fd);
- j->timer_watch.data.job = j;
- }
+ j->begin_usec = ull;
+
+ } else if (streq(l, "subscribed")) {
+
+ if (strv_extend(&j->deserialized_clients, v) < 0)
+ return log_oom();
}
}
}
int job_coldplug(Job *j) {
- struct epoll_event ev;
+ int r;
- if (j->timer_watch.type != WATCH_JOB_TIMER)
+ assert(j);
+
+ /* After deserialization is complete and the bus connection
+ * set up again, let's start watching our subscribers again */
+ r = bus_track_coldplug(j->manager, &j->clients, &j->deserialized_clients);
+ if (r < 0)
+ return r;
+
+ if (j->state == JOB_WAITING)
+ job_add_to_run_queue(j);
+
+ if (j->begin_usec == 0 || j->unit->job_timeout == 0)
return 0;
- zero(ev);
- ev.data.ptr = &j->timer_watch;
- ev.events = EPOLLIN;
+ if (j->timer_event_source)
+ j->timer_event_source = sd_event_source_unref(j->timer_event_source);
- if (epoll_ctl(j->manager->epoll_fd, EPOLL_CTL_ADD, j->timer_watch.fd, &ev) < 0)
- return -errno;
+ r = sd_event_add_time(
+ j->manager->event,
+ &j->timer_event_source,
+ CLOCK_MONOTONIC,
+ j->begin_usec + j->unit->job_timeout, 0,
+ job_dispatch_timer, j);
+ if (r < 0)
+ log_debug_errno(r, "Failed to restart timeout for job: %m");
- return 0;
+ return r;
+}
+
+void job_shutdown_magic(Job *j) {
+ assert(j);
+
+ /* 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();
+}
+
+int job_get_timeout(Job *j, uint64_t *timeout) {
+ Unit *u = j->unit;
+ uint64_t x = -1, y = -1;
+ int r = 0, q = 0;
+
+ assert(u);
+
+ if (j->timer_event_source) {
+ r = sd_event_source_get_time(j->timer_event_source, &x);
+ if (r < 0)
+ return r;
+ r = 1;
+ }
+
+ if (UNIT_VTABLE(u)->get_timeout) {
+ q = UNIT_VTABLE(u)->get_timeout(u, &y);
+ if (q < 0)
+ return q;
+ }
+
+ if (r == 0 && q == 0)
+ return 0;
+
+ *timeout = MIN(x, y);
+
+ return 1;
}
static const char* const job_state_table[_JOB_STATE_MAX] = {
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_FLUSH] = "flush",
[JOB_IGNORE_DEPENDENCIES] = "ignore-dependencies",
- [JOB_IGNORE_REQUIREMENTS] = "ignore-requirements"
+ [JOB_IGNORE_REQUIREMENTS] = "ignore-requirements",
};
DEFINE_STRING_TABLE_LOOKUP(job_mode, JobMode);
[JOB_TIMEOUT] = "timeout",
[JOB_FAILED] = "failed",
[JOB_DEPENDENCY] = "dependency",
- [JOB_SKIPPED] = "skipped"
+ [JOB_SKIPPED] = "skipped",
+ [JOB_INVALID] = "invalid",
+ [JOB_ASSERT] = "assert",
+ [JOB_UNSUPPORTED] = "unsupported",
};
DEFINE_STRING_TABLE_LOOKUP(job_result, JobResult);
~ianmdlvl / elogind.git / blobdiff