#include "timer.h"
#include "dbus-timer.h"
#include "special.h"
-#include "bus-errors.h"
+#include "dbus-common.h"
static const UnitActiveState state_translation_table[_TIMER_STATE_MAX] = {
[TIMER_DEAD] = UNIT_INACTIVE,
unit_unwatch_timer(u, &t->monotonic_watch);
unit_unwatch_timer(u, &t->realtime_watch);
-
- unit_ref_unset(&t->unit);
}
static int timer_verify(Timer *t) {
if (u->load_state == UNIT_LOADED) {
- if (!UNIT_DEREF(t->unit)) {
+ if (set_isempty(u->dependencies[UNIT_TRIGGERS])) {
Unit *x;
r = unit_load_related_unit(u, ".service", &x);
if (r < 0)
return r;
- unit_ref_set(&t->unit, x);
+ r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, x, true);
+ if (r < 0)
+ return r;
}
- r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(t->unit), true);
- if (r < 0)
- return r;
-
if (UNIT(t)->default_dependencies) {
r = timer_add_default_dependencies(t);
if (r < 0)
static void timer_dump(Unit *u, FILE *f, const char *prefix) {
Timer *t = TIMER(u);
+ Unit *trigger;
TimerValue *v;
+ trigger = UNIT_TRIGGER(u);
+
fprintf(f,
"%sTimer State: %s\n"
"%sResult: %s\n"
"%sUnit: %s\n",
prefix, timer_state_to_string(t->state),
prefix, timer_result_to_string(t->result),
- prefix, UNIT_DEREF(t->unit)->id);
+ prefix, trigger ? trigger->id : "n/a");
LIST_FOREACH(value, v, t->values) {
if (r < 0)
continue;
- if (!initial && v->next_elapse < ts.realtime) {
- v->disabled = true;
- continue;
- }
-
if (!found_realtime)
t->next_elapse_realtime = v->next_elapse;
else
case TIMER_UNIT_ACTIVE:
- if (UNIT_DEREF(t->unit)->inactive_exit_timestamp.monotonic <= 0)
+ base = UNIT_TRIGGER(UNIT(t))->inactive_exit_timestamp.monotonic;
+
+ if (base <= 0)
+ base = t->last_trigger_monotonic;
+
+ if (base <= 0)
continue;
- base = UNIT_DEREF(t->unit)->inactive_exit_timestamp.monotonic;
break;
case TIMER_UNIT_INACTIVE:
- if (UNIT_DEREF(t->unit)->inactive_enter_timestamp.monotonic <= 0)
+ base = UNIT_TRIGGER(UNIT(t))->inactive_enter_timestamp.monotonic;
+
+ if (base <= 0)
+ base = t->last_trigger_monotonic;
+
+ if (base <= 0)
continue;
- base = UNIT_DEREF(t->unit)->inactive_enter_timestamp.monotonic;
break;
default:
v->next_elapse = base + v->value;
- if (!initial && v->next_elapse < ts.monotonic) {
+ if (!initial &&
+ v->next_elapse < ts.monotonic &&
+ (v->base == TIMER_ACTIVE || v->base == TIMER_BOOT || v->base == TIMER_STARTUP)) {
+ /* This is a one time trigger, disable it now */
v->disabled = true;
continue;
}
dbus_error_init(&error);
/* Don't start job if we are supposed to go down */
- if (UNIT(t)->job && UNIT(t)->job->type == JOB_STOP)
+ if (unit_stop_pending(UNIT(t)))
return;
- r = manager_add_job(UNIT(t)->manager, JOB_START, UNIT_DEREF(t->unit), JOB_REPLACE, true, &error, NULL);
+ r = manager_add_job(UNIT(t)->manager, JOB_START, UNIT_TRIGGER(UNIT(t)),
+ JOB_REPLACE, true, &error, NULL);
if (r < 0)
goto fail;
+ t->last_trigger_monotonic = now(CLOCK_MONOTONIC);
+
timer_set_state(t, TIMER_RUNNING);
return;
assert(t);
assert(t->state == TIMER_DEAD || t->state == TIMER_FAILED);
- if (UNIT_DEREF(t->unit)->load_state != UNIT_LOADED)
+ if (UNIT_TRIGGER(u)->load_state != UNIT_LOADED)
return -ENOENT;
t->result = TIMER_SUCCESS;
return 0;
}
-static UnitActiveState timer_active_state(Unit *u) {
+_pure_ static UnitActiveState timer_active_state(Unit *u) {
assert(u);
return state_translation_table[TIMER(u)->state];
}
-static const char *timer_sub_state_to_string(Unit *u) {
+_pure_ static const char *timer_sub_state_to_string(Unit *u) {
assert(u);
return timer_state_to_string(TIMER(u)->state);
timer_enter_running(t);
}
-void timer_unit_notify(Unit *u, UnitActiveState new_state) {
- Iterator i;
- Unit *k;
-
- if (u->type == UNIT_TIMER)
- return;
+static void timer_trigger_notify(Unit *u, Unit *other) {
+ Timer *t = TIMER(u);
+ TimerValue *v;
- SET_FOREACH(k, u->dependencies[UNIT_TRIGGERED_BY], i) {
- Timer *t;
- TimerValue *v;
+ assert(u);
+ assert(other);
- if (k->type != UNIT_TIMER)
- continue;
+ if (other->load_state != UNIT_LOADED)
+ return;
- if (k->load_state != UNIT_LOADED)
- continue;
+ /* Reenable all timers that depend on unit state */
+ LIST_FOREACH(value, v, t->values)
+ if (v->base == TIMER_UNIT_ACTIVE ||
+ v->base == TIMER_UNIT_INACTIVE)
+ v->disabled = false;
- t = TIMER(k);
+ switch (t->state) {
- /* Reenable all timers that depend on unit state */
- LIST_FOREACH(value, v, t->values)
- if (v->base == TIMER_UNIT_ACTIVE ||
- v->base == TIMER_UNIT_INACTIVE)
- v->disabled = false;
+ case TIMER_WAITING:
+ case TIMER_ELAPSED:
- switch (t->state) {
+ /* Recalculate sleep time */
+ timer_enter_waiting(t, false);
+ break;
- case TIMER_WAITING:
- case TIMER_ELAPSED:
+ case TIMER_RUNNING:
- /* Recalculate sleep time */
+ if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other))) {
+ log_debug_unit(UNIT(t)->id,
+ "%s got notified about unit deactivation.",
+ UNIT(t)->id);
timer_enter_waiting(t, false);
- break;
-
- case TIMER_RUNNING:
-
- if (UNIT_IS_INACTIVE_OR_FAILED(new_state)) {
- log_debug_unit(UNIT(t)->id,
- "%s got notified about unit deactivation.",
- UNIT(t)->id);
- timer_enter_waiting(t, false);
- }
-
- break;
+ }
+ break;
- case TIMER_DEAD:
- case TIMER_FAILED:
- break;
+ case TIMER_DEAD:
+ case TIMER_FAILED:
+ break;
- default:
- assert_not_reached("Unknown timer state");
- }
+ default:
+ assert_not_reached("Unknown timer state");
}
}
.timer_event = timer_timer_event,
+ .trigger_notify = timer_trigger_notify,
+
.reset_failed = timer_reset_failed,
.time_change = timer_time_change,
~ianmdlvl / elogind.git / blobdiff