X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fcore%2Ftimer.c;h=16ca573177a80e82e28d6ab7679dcee79b8e684c;hp=6bd4cc359cf62180386530df533104c9a8a34193;hb=245802dd89ccf10de446faff5577e041d5372062;hpb=5430f7f2bc7330f3088b894166bf3524a067e3d8

diff --git a/src/core/timer.c b/src/core/timer.c
index 6bd4cc359..16ca57317 100644
--- a/src/core/timer.c
+++ b/src/core/timer.c
@@ -42,21 +42,36 @@ static void timer_init(Unit *u) {
         assert(u);
         assert(u->load_state == UNIT_STUB);
 
-        t->next_elapse = (usec_t) -1;
+        t->next_elapse_monotonic = (usec_t) -1;
+        t->next_elapse_realtime = (usec_t) -1;
+        watch_init(&t->monotonic_watch);
+        watch_init(&t->realtime_watch);
 }
 
-static void timer_done(Unit *u) {
-        Timer *t = TIMER(u);
+void timer_free_values(Timer *t) {
         TimerValue *v;
 
         assert(t);
 
         while ((v = t->values)) {
                 LIST_REMOVE(TimerValue, value, t->values, v);
+
+                if (v->calendar_spec)
+                        calendar_spec_free(v->calendar_spec);
+
                 free(v);
         }
+}
 
-        unit_unwatch_timer(u, &t->timer_watch);
+static void timer_done(Unit *u) {
+        Timer *t = TIMER(u);
+
+        assert(t);
+
+        timer_free_values(t);
+
+        unit_unwatch_timer(u, &t->monotonic_watch);
+        unit_unwatch_timer(u, &t->realtime_watch);
 
         unit_ref_unset(&t->unit);
 }
@@ -68,7 +83,8 @@ static int timer_verify(Timer *t) {
                 return 0;
 
         if (!t->values) {
-                log_error("%s lacks value setting. Refusing.", UNIT(t)->id);
+                log_error_unit(UNIT(t)->id,
+                               "%s lacks value setting. Refusing.", UNIT(t)->id);
                 return -EINVAL;
         }
 
@@ -80,11 +96,13 @@ static int timer_add_default_dependencies(Timer *t) {
 
         assert(t);
 
-        if (UNIT(t)->manager->running_as == MANAGER_SYSTEM) {
-                if ((r = unit_add_dependency_by_name(UNIT(t), UNIT_BEFORE, SPECIAL_BASIC_TARGET, NULL, true)) < 0)
-                        return r;
+        r = unit_add_dependency_by_name(UNIT(t), UNIT_BEFORE, SPECIAL_TIMERS_TARGET, NULL, true);
+        if (r < 0)
+                return r;
 
-                if ((r = unit_add_two_dependencies_by_name(UNIT(t), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
+        if (UNIT(t)->manager->running_as == SYSTEMD_SYSTEM) {
+                r = unit_add_two_dependencies_by_name(UNIT(t), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
+                if (r < 0)
                         return r;
         }
 
@@ -98,7 +116,8 @@ static int timer_load(Unit *u) {
         assert(u);
         assert(u->load_state == UNIT_STUB);
 
-        if ((r = unit_load_fragment_and_dropin(u)) < 0)
+        r = unit_load_fragment_and_dropin(u);
+        if (r < 0)
                 return r;
 
         if (u->load_state == UNIT_LOADED) {
@@ -117,9 +136,11 @@ static int timer_load(Unit *u) {
                 if (r < 0)
                         return r;
 
-                if (UNIT(t)->default_dependencies)
-                        if ((r = timer_add_default_dependencies(t)) < 0)
+                if (UNIT(t)->default_dependencies) {
+                        r = timer_add_default_dependencies(t);
+                        if (r < 0)
                                 return r;
+                }
         }
 
         return timer_verify(t);
@@ -128,8 +149,6 @@ static int timer_load(Unit *u) {
 static void timer_dump(Unit *u, FILE *f, const char *prefix) {
         Timer *t = TIMER(u);
         TimerValue *v;
-        char
-                timespan1[FORMAT_TIMESPAN_MAX];
 
         fprintf(f,
                 "%sTimer State: %s\n"
@@ -139,12 +158,28 @@ static void timer_dump(Unit *u, FILE *f, const char *prefix) {
                 prefix, timer_result_to_string(t->result),
                 prefix, UNIT_DEREF(t->unit)->id);
 
-        LIST_FOREACH(value, v, t->values)
-                fprintf(f,
-                        "%s%s: %s\n",
-                        prefix,
-                        timer_base_to_string(v->base),
-                        strna(format_timespan(timespan1, sizeof(timespan1), v->value)));
+        LIST_FOREACH(value, v, t->values) {
+
+                if (v->base == TIMER_CALENDAR) {
+                        _cleanup_free_ char *p = NULL;
+
+                        calendar_spec_to_string(v->calendar_spec, &p);
+
+                        fprintf(f,
+                                "%s%s: %s\n",
+                                prefix,
+                                timer_base_to_string(v->base),
+                                strna(p));
+                } else  {
+                        char timespan1[FORMAT_TIMESPAN_MAX];
+
+                        fprintf(f,
+                                "%s%s: %s\n",
+                                prefix,
+                                timer_base_to_string(v->base),
+                                strna(format_timespan(timespan1, sizeof(timespan1), v->value, 0)));
+                }
+        }
 }
 
 static void timer_set_state(Timer *t, TimerState state) {
@@ -154,14 +189,16 @@ static void timer_set_state(Timer *t, TimerState state) {
         old_state = t->state;
         t->state = state;
 
-        if (state != TIMER_WAITING)
-                unit_unwatch_timer(UNIT(t), &t->timer_watch);
+        if (state != TIMER_WAITING) {
+                unit_unwatch_timer(UNIT(t), &t->monotonic_watch);
+                unit_unwatch_timer(UNIT(t), &t->realtime_watch);
+        }
 
         if (state != old_state)
-                log_debug("%s changed %s -> %s",
-                          UNIT(t)->id,
-                          timer_state_to_string(old_state),
-                          timer_state_to_string(state));
+                log_debug_unit(UNIT(t)->id,
+                               "%s changed %s -> %s", UNIT(t)->id,
+                               timer_state_to_string(old_state),
+                               timer_state_to_string(state));
 
         unit_notify(UNIT(t), state_translation_table[old_state], state_translation_table[state], true);
 }
@@ -196,85 +233,131 @@ static void timer_enter_dead(Timer *t, TimerResult f) {
 
 static void timer_enter_waiting(Timer *t, bool initial) {
         TimerValue *v;
-        usec_t base = 0, delay, n;
-        bool found = false;
+        usec_t base = 0;
+        dual_timestamp ts;
+        bool found_monotonic = false, found_realtime = false;
         int r;
 
-        n = now(CLOCK_MONOTONIC);
+        dual_timestamp_get(&ts);
+        t->next_elapse_monotonic = t->next_elapse_realtime = 0;
 
         LIST_FOREACH(value, v, t->values) {
 
                 if (v->disabled)
                         continue;
 
-                switch (v->base) {
+                if (v->base == TIMER_CALENDAR) {
+
+                        r = calendar_spec_next_usec(v->calendar_spec, ts.realtime, &v->next_elapse);
+                        if (r < 0)
+                                continue;
+
+                        if (!initial && v->next_elapse < ts.realtime) {
+                                v->disabled = true;
+                                continue;
+                        }
 
-                case TIMER_ACTIVE:
-                        if (state_translation_table[t->state] == UNIT_ACTIVE)
-                                base = UNIT(t)->inactive_exit_timestamp.monotonic;
+                        if (!found_realtime)
+                                t->next_elapse_realtime = v->next_elapse;
                         else
-                                base = n;
-                        break;
+                                t->next_elapse_realtime = MIN(t->next_elapse_realtime, v->next_elapse);
 
-                case TIMER_BOOT:
-                        /* CLOCK_MONOTONIC equals the uptime on Linux */
-                        base = 0;
-                        break;
+                        found_realtime = true;
 
-                case TIMER_STARTUP:
-                        base = UNIT(t)->manager->startup_timestamp.monotonic;
-                        break;
+                } else  {
+                        switch (v->base) {
 
-                case TIMER_UNIT_ACTIVE:
+                        case TIMER_ACTIVE:
+                                if (state_translation_table[t->state] == UNIT_ACTIVE)
+                                        base = UNIT(t)->inactive_exit_timestamp.monotonic;
+                                else
+                                        base = ts.monotonic;
+                                break;
 
-                        if (UNIT_DEREF(t->unit)->inactive_exit_timestamp.monotonic <= 0)
-                                continue;
+                        case TIMER_BOOT:
+                                /* CLOCK_MONOTONIC equals the uptime on Linux */
+                                base = 0;
+                                break;
 
-                        base = UNIT_DEREF(t->unit)->inactive_exit_timestamp.monotonic;
-                        break;
+                        case TIMER_STARTUP:
+                                base = UNIT(t)->manager->userspace_timestamp.monotonic;
+                                break;
 
-                case TIMER_UNIT_INACTIVE:
+                        case TIMER_UNIT_ACTIVE:
 
-                        if (UNIT_DEREF(t->unit)->inactive_enter_timestamp.monotonic <= 0)
-                                continue;
+                                if (UNIT_DEREF(t->unit)->inactive_exit_timestamp.monotonic <= 0)
+                                        continue;
 
-                        base = UNIT_DEREF(t->unit)->inactive_enter_timestamp.monotonic;
-                        break;
+                                base = UNIT_DEREF(t->unit)->inactive_exit_timestamp.monotonic;
+                                break;
 
-                default:
-                        assert_not_reached("Unknown timer base");
-                }
+                        case TIMER_UNIT_INACTIVE:
 
-                v->next_elapse = base + v->value;
+                                if (UNIT_DEREF(t->unit)->inactive_enter_timestamp.monotonic <= 0)
+                                        continue;
 
-                if (!initial && v->next_elapse < n) {
-                        v->disabled = true;
-                        continue;
-                }
+                                base = UNIT_DEREF(t->unit)->inactive_enter_timestamp.monotonic;
+                                break;
 
-                if (!found)
-                        t->next_elapse = v->next_elapse;
-                else
-                        t->next_elapse = MIN(t->next_elapse, v->next_elapse);
+                        default:
+                                assert_not_reached("Unknown timer base");
+                        }
+
+                        v->next_elapse = base + v->value;
+
+                        if (!initial && v->next_elapse < ts.monotonic) {
+                                v->disabled = true;
+                                continue;
+                        }
+
+                        if (!found_monotonic)
+                                t->next_elapse_monotonic = v->next_elapse;
+                        else
+                                t->next_elapse_monotonic = MIN(t->next_elapse_monotonic, v->next_elapse);
 
-                found = true;
+                        found_monotonic = true;
+                }
         }
 
-        if (!found) {
+        if (!found_monotonic && !found_realtime) {
+                log_debug_unit(UNIT(t)->id, "%s: Timer is elapsed.", UNIT(t)->id);
                 timer_set_state(t, TIMER_ELAPSED);
                 return;
         }
 
-        delay = n < t->next_elapse ? t->next_elapse - n : 0;
+        if (found_monotonic) {
+                char buf[FORMAT_TIMESPAN_MAX];
+                log_debug_unit(UNIT(t)->id,
+                               "%s: Monotonic timer elapses in %s.",
+                               UNIT(t)->id,
+                               format_timespan(buf, sizeof(buf), t->next_elapse_monotonic > ts.monotonic ? t->next_elapse_monotonic - ts.monotonic : 0, 0));
 
-        if ((r = unit_watch_timer(UNIT(t), delay, &t->timer_watch)) < 0)
-                goto fail;
+                r = unit_watch_timer(UNIT(t), CLOCK_MONOTONIC, false, t->next_elapse_monotonic, &t->monotonic_watch);
+                if (r < 0)
+                        goto fail;
+        } else
+                unit_unwatch_timer(UNIT(t), &t->monotonic_watch);
+
+        if (found_realtime) {
+                char buf[FORMAT_TIMESTAMP_MAX];
+                log_debug_unit(UNIT(t)->id,
+                               "%s: Realtime timer elapses at %s.",
+                               UNIT(t)->id,
+                               format_timestamp(buf, sizeof(buf), t->next_elapse_realtime));
+
+                r = unit_watch_timer(UNIT(t), CLOCK_REALTIME, false, t->next_elapse_realtime, &t->realtime_watch);
+                if (r < 0)
+                        goto fail;
+        } else
+                unit_unwatch_timer(UNIT(t), &t->realtime_watch);
 
         timer_set_state(t, TIMER_WAITING);
         return;
 
 fail:
-        log_warning("%s failed to enter waiting state: %s", UNIT(t)->id, strerror(-r));
+        log_warning_unit(UNIT(t)->id,
+                         "%s failed to enter waiting state: %s",
+                         UNIT(t)->id, strerror(-r));
         timer_enter_dead(t, TIMER_FAILURE_RESOURCES);
 }
 
@@ -289,14 +372,17 @@ static void timer_enter_running(Timer *t) {
         if (UNIT(t)->job && UNIT(t)->job->type == JOB_STOP)
                 return;
 
-        if ((r = manager_add_job(UNIT(t)->manager, JOB_START, UNIT_DEREF(t->unit), JOB_REPLACE, true, &error, NULL)) < 0)
+        r = manager_add_job(UNIT(t)->manager, JOB_START, UNIT_DEREF(t->unit), JOB_REPLACE, true, &error, NULL);
+        if (r < 0)
                 goto fail;
 
         timer_set_state(t, TIMER_RUNNING);
         return;
 
 fail:
-        log_warning("%s failed to queue unit startup job: %s", UNIT(t)->id, bus_error(&error, r));
+        log_warning_unit(UNIT(t)->id,
+                         "%s failed to queue unit startup job: %s",
+                         UNIT(t)->id, bus_error(&error, r));
         timer_enter_dead(t, TIMER_FAILURE_RESOURCES);
 
         dbus_error_free(&error);
@@ -350,8 +436,9 @@ static int timer_deserialize_item(Unit *u, const char *key, const char *value, F
         if (streq(key, "state")) {
                 TimerState state;
 
-                if ((state = timer_state_from_string(value)) < 0)
-                        log_debug("Failed to parse state value %s", value);
+                state = timer_state_from_string(value);
+                if (state < 0)
+                        log_debug_unit(u->id, "Failed to parse state value %s", value);
                 else
                         t->deserialized_state = state;
         } else if (streq(key, "result")) {
@@ -359,12 +446,12 @@ static int timer_deserialize_item(Unit *u, const char *key, const char *value, F
 
                 f = timer_result_from_string(value);
                 if (f < 0)
-                        log_debug("Failed to parse result value %s", value);
+                        log_debug_unit(u->id, "Failed to parse result value %s", value);
                 else if (f != TIMER_SUCCESS)
                         t->result = f;
 
         } else
-                log_debug("Unknown serialization key '%s'", key);
+                log_debug_unit(u->id, "Unknown serialization key '%s'", key);
 
         return 0;
 }
@@ -390,7 +477,7 @@ static void timer_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
         if (t->state != TIMER_WAITING)
                 return;
 
-        log_debug("Timer elapsed on %s", u->id);
+        log_debug_unit(u->id, "Timer elapsed on %s", u->id);
         timer_enter_running(t);
 }
 
@@ -431,7 +518,9 @@ void timer_unit_notify(Unit *u, UnitActiveState new_state) {
                 case TIMER_RUNNING:
 
                         if (UNIT_IS_INACTIVE_OR_FAILED(new_state)) {
-                                log_debug("%s got notified about unit deactivation.", UNIT(t)->id);
+                                log_debug_unit(UNIT(t)->id,
+                                               "%s got notified about unit deactivation.",
+                                               UNIT(t)->id);
                                 timer_enter_waiting(t, false);
                         }
 
@@ -458,6 +547,19 @@ static void timer_reset_failed(Unit *u) {
         t->result = TIMER_SUCCESS;
 }
 
+static void timer_time_change(Unit *u) {
+        Timer *t = TIMER(u);
+
+        assert(u);
+
+        if (t->state != TIMER_WAITING)
+                return;
+
+        log_debug_unit(u->id,
+                       "%s: time change, recalculating next elapse.", u->id);
+        timer_enter_waiting(t, false);
+}
+
 static const char* const timer_state_table[_TIMER_STATE_MAX] = {
         [TIMER_DEAD] = "dead",
         [TIMER_WAITING] = "waiting",
@@ -473,7 +575,8 @@ static const char* const timer_base_table[_TIMER_BASE_MAX] = {
         [TIMER_BOOT] = "OnBootSec",
         [TIMER_STARTUP] = "OnStartupSec",
         [TIMER_UNIT_ACTIVE] = "OnUnitActiveSec",
-        [TIMER_UNIT_INACTIVE] = "OnUnitInactiveSec"
+        [TIMER_UNIT_INACTIVE] = "OnUnitInactiveSec",
+        [TIMER_CALENDAR] = "OnCalendar"
 };
 
 DEFINE_STRING_TABLE_LOOKUP(timer_base, TimerBase);
@@ -486,7 +589,6 @@ static const char* const timer_result_table[_TIMER_RESULT_MAX] = {
 DEFINE_STRING_TABLE_LOOKUP(timer_result, TimerResult);
 
 const UnitVTable timer_vtable = {
-        .suffix = ".timer",
         .object_size = sizeof(Timer),
         .sections =
                 "Unit\0"
@@ -513,6 +615,7 @@ const UnitVTable timer_vtable = {
         .timer_event = timer_timer_event,
 
         .reset_failed = timer_reset_failed,
+        .time_change = timer_time_change,
 
         .bus_interface = "org.freedesktop.systemd1.Timer",
         .bus_message_handler = bus_timer_message_handler,