[thirdparty/systemd.git] / src / core / timer.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <errno.h>

#include "unit.h"
#include "unit-name.h"
#include "timer.h"
#include "dbus-timer.h"
#include "special.h"
#include "bus-util.h"
#include "bus-error.h"
#include "mkdir.h"

static const UnitActiveState state_translation_table[_TIMER_STATE_MAX] = {
        [TIMER_DEAD] = UNIT_INACTIVE,
        [TIMER_WAITING] = UNIT_ACTIVE,
        [TIMER_RUNNING] = UNIT_ACTIVE,
        [TIMER_ELAPSED] = UNIT_ACTIVE,
        [TIMER_FAILED] = UNIT_FAILED
};

static int timer_dispatch(sd_event_source *s, uint64_t usec, void *userdata);

static void timer_init(Unit *u) {
        Timer *t = TIMER(u);

        assert(u);
        assert(u->load_state == UNIT_STUB);

        t->next_elapse_monotonic_or_boottime = (usec_t) -1;
        t->next_elapse_realtime = (usec_t) -1;
        t->accuracy_usec = u->manager->default_timer_accuracy_usec;
}

void timer_free_values(Timer *t) {
        TimerValue *v;

        assert(t);

        while ((v = t->values)) {
                LIST_REMOVE(value, t->values, v);

                if (v->calendar_spec)
                        calendar_spec_free(v->calendar_spec);

                free(v);
        }
}

static void timer_done(Unit *u) {
        Timer *t = TIMER(u);

        assert(t);

        timer_free_values(t);

        t->monotonic_event_source = sd_event_source_unref(t->monotonic_event_source);
        t->realtime_event_source = sd_event_source_unref(t->realtime_event_source);

        free(t->stamp_path);
}

static int timer_verify(Timer *t) {
        assert(t);

        if (UNIT(t)->load_state != UNIT_LOADED)
                return 0;

        if (!t->values) {
                log_error_unit(UNIT(t)->id, "%s lacks value setting. Refusing.", UNIT(t)->id);
                return -EINVAL;
        }

        return 0;
}

static int timer_add_default_dependencies(Timer *t) {
        int r;

        assert(t);

        r = unit_add_dependency_by_name(UNIT(t), UNIT_BEFORE, SPECIAL_TIMERS_TARGET, NULL, true);
        if (r < 0)
                return r;

        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;
        }

        return unit_add_two_dependencies_by_name(UNIT(t), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
}

static int timer_setup_persistent(Timer *t) {
        int r;

        assert(t);

        if (!t->persistent)
                return 0;

        if (UNIT(t)->manager->running_as == SYSTEMD_SYSTEM) {

                r = unit_require_mounts_for(UNIT(t), "/var/lib/systemd/timers");
                if (r < 0)
                        return r;

                t->stamp_path = strappend("/var/lib/systemd/timers/stamp-", UNIT(t)->id);
        } else {
                const char *e;

                e = getenv("XDG_DATA_HOME");
                if (e)
                        t->stamp_path = strjoin(e, "/systemd/timers/", UNIT(t)->id, NULL);
                else {

                        _cleanup_free_ char *h = NULL;

                        r = get_home_dir(&h);
                        if (r < 0) {
                                log_error("Failed to determine home directory: %s", strerror(-r));
                                return r;
                        }

                        t->stamp_path = strjoin(h, "/.local/share/systemd/timers/stamp-", UNIT(t)->id, NULL);
                }
        }

        if (!t->stamp_path)
                return log_oom();

        return 0;
}

static int timer_load(Unit *u) {
        Timer *t = TIMER(u);
        int r;

        assert(u);
        assert(u->load_state == UNIT_STUB);

        r = unit_load_fragment_and_dropin(u);
        if (r < 0)
                return r;

        if (u->load_state == UNIT_LOADED) {

                if (set_isempty(u->dependencies[UNIT_TRIGGERS])) {
                        Unit *x;

                        r = unit_load_related_unit(u, ".service", &x);
                        if (r < 0)
                                return r;

                        r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, x, true);
                        if (r < 0)
                                return r;
                }

                r = timer_setup_persistent(t);
                if (r < 0)
                        return r;

                if (u->default_dependencies) {
                        r = timer_add_default_dependencies(t);
                        if (r < 0)
                                return r;
                }
        }

        return timer_verify(t);
}

static void timer_dump(Unit *u, FILE *f, const char *prefix) {
        char buf[FORMAT_TIMESPAN_MAX];
        Timer *t = TIMER(u);
        Unit *trigger;
        TimerValue *v;

        trigger = UNIT_TRIGGER(u);

        fprintf(f,
                "%sTimer State: %s\n"
                "%sResult: %s\n"
                "%sUnit: %s\n"
                "%sPersistent: %s\n"
                "%sWakeSystem: %s\n"
                "%sAccuracy: %s\n",
                prefix, timer_state_to_string(t->state),
                prefix, timer_result_to_string(t->result),
                prefix, trigger ? trigger->id : "n/a",
                prefix, yes_no(t->persistent),
                prefix, yes_no(t->wake_system),
                prefix, format_timespan(buf, sizeof(buf), t->accuracy_usec, 1));

        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) {
        TimerState old_state;
        assert(t);

        old_state = t->state;
        t->state = state;

        if (state != TIMER_WAITING) {
                t->monotonic_event_source = sd_event_source_unref(t->monotonic_event_source);
                t->realtime_event_source = sd_event_source_unref(t->realtime_event_source);
        }

        if (state != old_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);
}

static void timer_enter_waiting(Timer *t, bool initial);

static int timer_coldplug(Unit *u) {
        Timer *t = TIMER(u);

        assert(t);
        assert(t->state == TIMER_DEAD);

        if (t->deserialized_state != t->state) {

                if (t->deserialized_state == TIMER_WAITING)
                        timer_enter_waiting(t, false);
                else
                        timer_set_state(t, t->deserialized_state);
        }

        return 0;
}

static void timer_enter_dead(Timer *t, TimerResult f) {
        assert(t);

        if (f != TIMER_SUCCESS)
                t->result = f;

        timer_set_state(t, t->result != TIMER_SUCCESS ? TIMER_FAILED : TIMER_DEAD);
}

static usec_t monotonic_to_boottime(usec_t t) {
        usec_t a, b;

        if (t <= 0)
                return 0;

        a = now(CLOCK_BOOTTIME);
        b = now(CLOCK_MONOTONIC);

        if (t + a > b)
                return t + a - b;
        else
                return 0;
}

static void timer_enter_waiting(Timer *t, bool initial) {
        bool found_monotonic = false, found_realtime = false;
        usec_t ts_realtime, ts_monotonic;
        usec_t base = 0;
        TimerValue *v;
        int r;

        /* If we shall wake the system we use the boottime clock
         * rather than the monotonic clock. */

        ts_realtime = now(CLOCK_REALTIME);
        ts_monotonic = now(t->wake_system ? CLOCK_BOOTTIME : CLOCK_MONOTONIC);
        t->next_elapse_monotonic_or_boottime = t->next_elapse_realtime = 0;

        LIST_FOREACH(value, v, t->values) {

                if (v->disabled)
                        continue;

                if (v->base == TIMER_CALENDAR) {
                        usec_t b;

                        /* If we know the last time this was
                         * triggered, schedule the job based relative
                         * to that. If we don't just start from
                         * now. */

                        b = t->last_trigger.realtime > 0 ? t->last_trigger.realtime : ts_realtime;

                        r = calendar_spec_next_usec(v->calendar_spec, b, &v->next_elapse);
                        if (r < 0)
                                continue;

                        if (!found_realtime)
                                t->next_elapse_realtime = v->next_elapse;
                        else
                                t->next_elapse_realtime = MIN(t->next_elapse_realtime, v->next_elapse);

                        found_realtime = true;

                } else  {
                        switch (v->base) {

                        case TIMER_ACTIVE:
                                if (state_translation_table[t->state] == UNIT_ACTIVE)
                                        base = UNIT(t)->inactive_exit_timestamp.monotonic;
                                else
                                        base = ts_monotonic;
                                break;

                        case TIMER_BOOT:
                                /* CLOCK_MONOTONIC equals the uptime on Linux */
                                base = 0;
                                break;

                        case TIMER_STARTUP:
                                base = UNIT(t)->manager->userspace_timestamp.monotonic;
                                break;

                        case TIMER_UNIT_ACTIVE:

                                base = UNIT_TRIGGER(UNIT(t))->inactive_exit_timestamp.monotonic;

                                if (base <= 0)
                                        base = t->last_trigger.monotonic;

                                if (base <= 0)
                                        continue;

                                break;

                        case TIMER_UNIT_INACTIVE:

                                base = UNIT_TRIGGER(UNIT(t))->inactive_enter_timestamp.monotonic;

                                if (base <= 0)
                                        base = t->last_trigger.monotonic;

                                if (base <= 0)
                                        continue;

                                break;

                        default:
                                assert_not_reached("Unknown timer base");
                        }

                        if (t->wake_system)
                                base = monotonic_to_boottime(base);

                        v->next_elapse = base + v->value;

                        if (!initial && v->next_elapse < ts_monotonic && IN_SET(v->base, TIMER_ACTIVE, TIMER_BOOT, TIMER_STARTUP)) {
                                /* This is a one time trigger, disable it now */
                                v->disabled = true;
                                continue;
                        }

                        if (!found_monotonic)
                                t->next_elapse_monotonic_or_boottime = v->next_elapse;
                        else
                                t->next_elapse_monotonic_or_boottime = MIN(t->next_elapse_monotonic_or_boottime, v->next_elapse);

                        found_monotonic = true;
                }
        }

        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;
        }

        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_or_boottime > ts_monotonic ? t->next_elapse_monotonic_or_boottime - ts_monotonic : 0, 0));

                if (t->monotonic_event_source) {
                        r = sd_event_source_set_time(t->monotonic_event_source, t->next_elapse_monotonic_or_boottime);
                        if (r < 0)
                                goto fail;

                        r = sd_event_source_set_enabled(t->monotonic_event_source, SD_EVENT_ONESHOT);
                } else
                        r = sd_event_add_time(
                                        UNIT(t)->manager->event,
                                        &t->monotonic_event_source,
                                        t->wake_system ? CLOCK_BOOTTIME_ALARM : CLOCK_MONOTONIC,
                                        t->next_elapse_monotonic_or_boottime, t->accuracy_usec,
                                        timer_dispatch, t);
                if (r < 0)
                        goto fail;

        } else if (t->monotonic_event_source) {

                r = sd_event_source_set_enabled(t->monotonic_event_source, SD_EVENT_OFF);
                if (r < 0)
                        goto fail;
        }

        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));

                if (t->realtime_event_source) {
                        r = sd_event_source_set_time(t->realtime_event_source, t->next_elapse_realtime);
                        if (r < 0)
                                goto fail;

                        r = sd_event_source_set_enabled(t->realtime_event_source, SD_EVENT_ONESHOT);
                } else
                        r = sd_event_add_time(
                                        UNIT(t)->manager->event,
                                        &t->realtime_event_source,
                                        t->wake_system ? CLOCK_REALTIME_ALARM : CLOCK_REALTIME,
                                        t->next_elapse_realtime, t->accuracy_usec,
                                        timer_dispatch, t);
                if (r < 0)
                        goto fail;

        } else if (t->realtime_event_source) {

                r = sd_event_source_set_enabled(t->realtime_event_source, SD_EVENT_OFF);
                if (r < 0)
                        goto fail;
        }

        timer_set_state(t, TIMER_WAITING);
        return;

fail:
        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);
}

static void timer_enter_running(Timer *t) {
        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
        int r;

        assert(t);

        /* Don't start job if we are supposed to go down */
        if (unit_stop_pending(UNIT(t)))
                return;

        r = manager_add_job(UNIT(t)->manager, JOB_START, UNIT_TRIGGER(UNIT(t)),
                            JOB_REPLACE, true, &error, NULL);
        if (r < 0)
                goto fail;

        dual_timestamp_get(&t->last_trigger);

        if (t->stamp_path) {
                _cleanup_close_ int fd = -1;

                mkdir_parents_label(t->stamp_path, 0755);

                /* Update the file atime + mtime, if we can */
                fd = open(t->stamp_path, O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC, 0644);
                if (fd >= 0) {
                        struct timespec ts[2];

                        timespec_store(&ts[0], t->last_trigger.realtime);
                        ts[1] = ts[0];

                        futimens(fd, ts);
                }
        }

        timer_set_state(t, TIMER_RUNNING);
        return;

fail:
        log_warning_unit(UNIT(t)->id,
                         "%s failed to queue unit startup job: %s",
                         UNIT(t)->id, bus_error_message(&error, r));
        timer_enter_dead(t, TIMER_FAILURE_RESOURCES);
}

static int timer_start(Unit *u) {
        Timer *t = TIMER(u);

        assert(t);
        assert(t->state == TIMER_DEAD || t->state == TIMER_FAILED);

        if (UNIT_TRIGGER(u)->load_state != UNIT_LOADED)
                return -ENOENT;

        t->last_trigger = DUAL_TIMESTAMP_NULL;

        if (t->stamp_path) {
                struct stat st;

                if (stat(t->stamp_path, &st) >= 0)
                        t->last_trigger.realtime = timespec_load(&st.st_atim);
        }

        t->result = TIMER_SUCCESS;
        timer_enter_waiting(t, true);
        return 0;
}

static int timer_stop(Unit *u) {
        Timer *t = TIMER(u);

        assert(t);
        assert(t->state == TIMER_WAITING || t->state == TIMER_RUNNING || t->state == TIMER_ELAPSED);

        timer_enter_dead(t, TIMER_SUCCESS);
        return 0;
}

static int timer_serialize(Unit *u, FILE *f, FDSet *fds) {
        Timer *t = TIMER(u);

        assert(u);
        assert(f);
        assert(fds);

        unit_serialize_item(u, f, "state", timer_state_to_string(t->state));
        unit_serialize_item(u, f, "result", timer_result_to_string(t->result));

        if (t->last_trigger.realtime > 0)
                unit_serialize_item_format(u, f, "last-trigger-realtime", "%" PRIu64, t->last_trigger.realtime);

        if (t->last_trigger.monotonic > 0)
                unit_serialize_item_format(u, f, "last-trigger-monotonic", "%" PRIu64, t->last_trigger.monotonic);

        return 0;
}

static int timer_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
        Timer *t = TIMER(u);
        int r;

        assert(u);
        assert(key);
        assert(value);
        assert(fds);

        if (streq(key, "state")) {
                TimerState state;

                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")) {
                TimerResult f;

                f = timer_result_from_string(value);
                if (f < 0)
                        log_debug_unit(u->id, "Failed to parse result value %s", value);
                else if (f != TIMER_SUCCESS)
                        t->result = f;
        } else if (streq(key, "last-trigger-realtime")) {

                r = safe_atou64(value, &t->last_trigger.realtime);
                if (r < 0)
                        log_debug_unit(u->id, "Failed to parse last-trigger-realtime value %s", value);

        } else if (streq(key, "last-trigger-monotonic")) {

                r = safe_atou64(value, &t->last_trigger.monotonic);
                if (r < 0)
                        log_debug_unit(u->id, "Failed to parse last-trigger-monotonic value %s", value);

        } else
                log_debug_unit(u->id, "Unknown serialization key '%s'", key);

        return 0;
}

_pure_ static UnitActiveState timer_active_state(Unit *u) {
        assert(u);

        return state_translation_table[TIMER(u)->state];
}

_pure_ static const char *timer_sub_state_to_string(Unit *u) {
        assert(u);

        return timer_state_to_string(TIMER(u)->state);
}

static int timer_dispatch(sd_event_source *s, uint64_t usec, void *userdata) {
        Timer *t = TIMER(userdata);

        assert(t);

        if (t->state != TIMER_WAITING)
                return 0;

        log_debug_unit(UNIT(t)->id, "Timer elapsed on %s", UNIT(t)->id);
        timer_enter_running(t);
        return 0;
}

static void timer_trigger_notify(Unit *u, Unit *other) {
        Timer *t = TIMER(u);
        TimerValue *v;

        assert(u);
        assert(other);

        if (other->load_state != UNIT_LOADED)
                return;

        /* 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;

        switch (t->state) {

        case TIMER_WAITING:
        case TIMER_ELAPSED:

                /* Recalculate sleep time */
                timer_enter_waiting(t, false);
                break;

        case TIMER_RUNNING:

                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_DEAD:
        case TIMER_FAILED:
                break;

        default:
                assert_not_reached("Unknown timer state");
        }
}

static void timer_reset_failed(Unit *u) {
        Timer *t = TIMER(u);

        assert(t);

        if (t->state == TIMER_FAILED)
                timer_set_state(t, TIMER_DEAD);

        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",
        [TIMER_RUNNING] = "running",
        [TIMER_ELAPSED] = "elapsed",
        [TIMER_FAILED] = "failed"
};

DEFINE_STRING_TABLE_LOOKUP(timer_state, TimerState);

static const char* const timer_base_table[_TIMER_BASE_MAX] = {
        [TIMER_ACTIVE] = "OnActiveSec",
        [TIMER_BOOT] = "OnBootSec",
        [TIMER_STARTUP] = "OnStartupSec",
        [TIMER_UNIT_ACTIVE] = "OnUnitActiveSec",
        [TIMER_UNIT_INACTIVE] = "OnUnitInactiveSec",
        [TIMER_CALENDAR] = "OnCalendar"
};

DEFINE_STRING_TABLE_LOOKUP(timer_base, TimerBase);

static const char* const timer_result_table[_TIMER_RESULT_MAX] = {
        [TIMER_SUCCESS] = "success",
        [TIMER_FAILURE_RESOURCES] = "resources"
};

DEFINE_STRING_TABLE_LOOKUP(timer_result, TimerResult);

const UnitVTable timer_vtable = {
        .object_size = sizeof(Timer),

        .sections =
                "Unit\0"
                "Timer\0"
                "Install\0",

        .init = timer_init,
        .done = timer_done,
        .load = timer_load,

        .coldplug = timer_coldplug,

        .dump = timer_dump,

        .start = timer_start,
        .stop = timer_stop,

        .serialize = timer_serialize,
        .deserialize_item = timer_deserialize_item,

        .active_state = timer_active_state,
        .sub_state_to_string = timer_sub_state_to_string,

        .trigger_notify = timer_trigger_notify,

        .reset_failed = timer_reset_failed,
        .time_change = timer_time_change,

        .bus_interface = "org.freedesktop.systemd1.Timer",
        .bus_vtable = bus_timer_vtable,
};
Commit	Line	Data
	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2010 Lennart Poettering
	7
	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.
	12
	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.
	17
	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/>.
	20	***/
	21
	22	#include <errno.h>
	23
	24	#include "unit.h"
	25	#include "unit-name.h"
	26	#include "timer.h"
	27	#include "dbus-timer.h"
	28	#include "special.h"
	29	#include "bus-util.h"
	30	#include "bus-error.h"
	31	#include "mkdir.h"
	32
	33	static const UnitActiveState state_translation_table[_TIMER_STATE_MAX] = {
	34	[TIMER_DEAD] = UNIT_INACTIVE,
	35	[TIMER_WAITING] = UNIT_ACTIVE,
	36	[TIMER_RUNNING] = UNIT_ACTIVE,
	37	[TIMER_ELAPSED] = UNIT_ACTIVE,
	38	[TIMER_FAILED] = UNIT_FAILED
	39	};
	40
	41	static int timer_dispatch(sd_event_source s, uint64_t usec, void userdata);
	42
	43	static void timer_init(Unit *u) {
	44	Timer *t = TIMER(u);
	45
	46	assert(u);
	47	assert(u->load_state == UNIT_STUB);
	48
	49	t->next_elapse_monotonic_or_boottime = (usec_t) -1;
	50	t->next_elapse_realtime = (usec_t) -1;
	51	t->accuracy_usec = u->manager->default_timer_accuracy_usec;
	52	}
	53
	54	void timer_free_values(Timer *t) {
	55	TimerValue *v;
	56
	57	assert(t);
	58
	59	while ((v = t->values)) {
	60	LIST_REMOVE(value, t->values, v);
	61
	62	if (v->calendar_spec)
	63	calendar_spec_free(v->calendar_spec);
	64
	65	free(v);
	66	}
	67	}
	68
	69	static void timer_done(Unit *u) {
	70	Timer *t = TIMER(u);
	71
	72	assert(t);
	73
	74	timer_free_values(t);
	75
	76	t->monotonic_event_source = sd_event_source_unref(t->monotonic_event_source);
	77	t->realtime_event_source = sd_event_source_unref(t->realtime_event_source);
	78
	79	free(t->stamp_path);
	80	}
	81
	82	static int timer_verify(Timer *t) {
	83	assert(t);
	84
	85	if (UNIT(t)->load_state != UNIT_LOADED)
	86	return 0;
	87
	88	if (!t->values) {
	89	log_error_unit(UNIT(t)->id, "%s lacks value setting. Refusing.", UNIT(t)->id);
	90	return -EINVAL;
	91	}
	92
	93	return 0;
	94	}
	95
	96	static int timer_add_default_dependencies(Timer *t) {
	97	int r;
	98
	99	assert(t);
	100
	101	r = unit_add_dependency_by_name(UNIT(t), UNIT_BEFORE, SPECIAL_TIMERS_TARGET, NULL, true);
	102	if (r < 0)
	103	return r;
	104
	105	if (UNIT(t)->manager->running_as == SYSTEMD_SYSTEM) {
	106	r = unit_add_two_dependencies_by_name(UNIT(t), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
	107	if (r < 0)
	108	return r;
	109	}
	110
	111	return unit_add_two_dependencies_by_name(UNIT(t), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
	112	}
	113
	114	static int timer_setup_persistent(Timer *t) {
	115	int r;
	116
	117	assert(t);
	118
	119	if (!t->persistent)
	120	return 0;
	121
	122	if (UNIT(t)->manager->running_as == SYSTEMD_SYSTEM) {
	123
	124	r = unit_require_mounts_for(UNIT(t), "/var/lib/systemd/timers");
	125	if (r < 0)
	126	return r;
	127
	128	t->stamp_path = strappend("/var/lib/systemd/timers/stamp-", UNIT(t)->id);
	129	} else {
	130	const char *e;
	131
	132	e = getenv("XDG_DATA_HOME");
	133	if (e)
	134	t->stamp_path = strjoin(e, "/systemd/timers/", UNIT(t)->id, NULL);
	135	else {
	136
	137	_cleanup_free_ char *h = NULL;
	138
	139	r = get_home_dir(&h);
	140	if (r < 0) {
	141	log_error("Failed to determine home directory: %s", strerror(-r));
	142	return r;
	143	}
	144
	145	t->stamp_path = strjoin(h, "/.local/share/systemd/timers/stamp-", UNIT(t)->id, NULL);
	146	}
	147	}
	148
	149	if (!t->stamp_path)
	150	return log_oom();
	151
	152	return 0;
	153	}
	154
	155	static int timer_load(Unit *u) {
	156	Timer *t = TIMER(u);
	157	int r;
	158
	159	assert(u);
	160	assert(u->load_state == UNIT_STUB);
	161
	162	r = unit_load_fragment_and_dropin(u);
	163	if (r < 0)
	164	return r;
	165
	166	if (u->load_state == UNIT_LOADED) {
	167
	168	if (set_isempty(u->dependencies[UNIT_TRIGGERS])) {
	169	Unit *x;
	170
	171	r = unit_load_related_unit(u, ".service", &x);
	172	if (r < 0)
	173	return r;
	174
	175	r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, x, true);
	176	if (r < 0)
	177	return r;
	178	}
	179
	180	r = timer_setup_persistent(t);
	181	if (r < 0)
	182	return r;
	183
	184	if (u->default_dependencies) {
	185	r = timer_add_default_dependencies(t);
	186	if (r < 0)
	187	return r;
	188	}
	189	}
	190
	191	return timer_verify(t);
	192	}
	193
	194	static void timer_dump(Unit u, FILE f, const char *prefix) {
	195	char buf[FORMAT_TIMESPAN_MAX];
	196	Timer *t = TIMER(u);
	197	Unit *trigger;
	198	TimerValue *v;
	199
	200	trigger = UNIT_TRIGGER(u);
	201
	202	fprintf(f,
	203	"%sTimer State: %s\n"
	204	"%sResult: %s\n"
	205	"%sUnit: %s\n"
	206	"%sPersistent: %s\n"
	207	"%sWakeSystem: %s\n"
	208	"%sAccuracy: %s\n",
	209	prefix, timer_state_to_string(t->state),
	210	prefix, timer_result_to_string(t->result),
	211	prefix, trigger ? trigger->id : "n/a",
	212	prefix, yes_no(t->persistent),
	213	prefix, yes_no(t->wake_system),
	214	prefix, format_timespan(buf, sizeof(buf), t->accuracy_usec, 1));
	215
	216	LIST_FOREACH(value, v, t->values) {
	217
	218	if (v->base == TIMER_CALENDAR) {
	219	_cleanup_free_ char *p = NULL;
	220
	221	calendar_spec_to_string(v->calendar_spec, &p);
	222
	223	fprintf(f,
	224	"%s%s: %s\n",
	225	prefix,
	226	timer_base_to_string(v->base),
	227	strna(p));
	228	} else {
	229	char timespan1[FORMAT_TIMESPAN_MAX];
	230
	231	fprintf(f,
	232	"%s%s: %s\n",
	233	prefix,
	234	timer_base_to_string(v->base),
	235	strna(format_timespan(timespan1, sizeof(timespan1), v->value, 0)));
	236	}
	237	}
	238	}
	239
	240	static void timer_set_state(Timer *t, TimerState state) {
	241	TimerState old_state;
	242	assert(t);
	243
	244	old_state = t->state;
	245	t->state = state;
	246
	247	if (state != TIMER_WAITING) {
	248	t->monotonic_event_source = sd_event_source_unref(t->monotonic_event_source);
	249	t->realtime_event_source = sd_event_source_unref(t->realtime_event_source);
	250	}
	251
	252	if (state != old_state)
	253	log_debug_unit(UNIT(t)->id,
	254	"%s changed %s -> %s", UNIT(t)->id,
	255	timer_state_to_string(old_state),
	256	timer_state_to_string(state));
	257
	258	unit_notify(UNIT(t), state_translation_table[old_state], state_translation_table[state], true);
	259	}
	260
	261	static void timer_enter_waiting(Timer *t, bool initial);
	262
	263	static int timer_coldplug(Unit *u) {
	264	Timer *t = TIMER(u);
	265
	266	assert(t);
	267	assert(t->state == TIMER_DEAD);
	268
	269	if (t->deserialized_state != t->state) {
	270
	271	if (t->deserialized_state == TIMER_WAITING)
	272	timer_enter_waiting(t, false);
	273	else
	274	timer_set_state(t, t->deserialized_state);
	275	}
	276
	277	return 0;
	278	}
	279
	280	static void timer_enter_dead(Timer *t, TimerResult f) {
	281	assert(t);
	282
	283	if (f != TIMER_SUCCESS)
	284	t->result = f;
	285
	286	timer_set_state(t, t->result != TIMER_SUCCESS ? TIMER_FAILED : TIMER_DEAD);
	287	}
	288
	289	static usec_t monotonic_to_boottime(usec_t t) {
	290	usec_t a, b;
	291
	292	if (t <= 0)
	293	return 0;
	294
	295	a = now(CLOCK_BOOTTIME);
	296	b = now(CLOCK_MONOTONIC);
	297
	298	if (t + a > b)
	299	return t + a - b;
	300	else
	301	return 0;
	302	}
	303
	304	static void timer_enter_waiting(Timer *t, bool initial) {
	305	bool found_monotonic = false, found_realtime = false;
	306	usec_t ts_realtime, ts_monotonic;
	307	usec_t base = 0;
	308	TimerValue *v;
	309	int r;
	310
	311	/* If we shall wake the system we use the boottime clock
	312	* rather than the monotonic clock. */
	313
	314	ts_realtime = now(CLOCK_REALTIME);
	315	ts_monotonic = now(t->wake_system ? CLOCK_BOOTTIME : CLOCK_MONOTONIC);
	316	t->next_elapse_monotonic_or_boottime = t->next_elapse_realtime = 0;
	317
	318	LIST_FOREACH(value, v, t->values) {
	319
	320	if (v->disabled)
	321	continue;
	322
	323	if (v->base == TIMER_CALENDAR) {
	324	usec_t b;
	325
	326	/* If we know the last time this was
	327	* triggered, schedule the job based relative
	328	* to that. If we don't just start from
	329	* now. */
	330
	331	b = t->last_trigger.realtime > 0 ? t->last_trigger.realtime : ts_realtime;
	332
	333	r = calendar_spec_next_usec(v->calendar_spec, b, &v->next_elapse);
	334	if (r < 0)
	335	continue;
	336
	337	if (!found_realtime)
	338	t->next_elapse_realtime = v->next_elapse;
	339	else
	340	t->next_elapse_realtime = MIN(t->next_elapse_realtime, v->next_elapse);
	341
	342	found_realtime = true;
	343
	344	} else {
	345	switch (v->base) {
	346
	347	case TIMER_ACTIVE:
	348	if (state_translation_table[t->state] == UNIT_ACTIVE)
	349	base = UNIT(t)->inactive_exit_timestamp.monotonic;
	350	else
	351	base = ts_monotonic;
	352	break;
	353
	354	case TIMER_BOOT:
	355	/* CLOCK_MONOTONIC equals the uptime on Linux */
	356	base = 0;
	357	break;
	358
	359	case TIMER_STARTUP:
	360	base = UNIT(t)->manager->userspace_timestamp.monotonic;
	361	break;
	362
	363	case TIMER_UNIT_ACTIVE:
	364
	365	base = UNIT_TRIGGER(UNIT(t))->inactive_exit_timestamp.monotonic;
	366
	367	if (base <= 0)
	368	base = t->last_trigger.monotonic;
	369
	370	if (base <= 0)
	371	continue;
	372
	373	break;
	374
	375	case TIMER_UNIT_INACTIVE:
	376
	377	base = UNIT_TRIGGER(UNIT(t))->inactive_enter_timestamp.monotonic;
	378
	379	if (base <= 0)
	380	base = t->last_trigger.monotonic;
	381
	382	if (base <= 0)
	383	continue;
	384
	385	break;
	386
	387	default:
	388	assert_not_reached("Unknown timer base");
	389	}
	390
	391	if (t->wake_system)
	392	base = monotonic_to_boottime(base);
	393
	394	v->next_elapse = base + v->value;
	395
	396	if (!initial && v->next_elapse < ts_monotonic && IN_SET(v->base, TIMER_ACTIVE, TIMER_BOOT, TIMER_STARTUP)) {
	397	/* This is a one time trigger, disable it now */
	398	v->disabled = true;
	399	continue;
	400	}
	401
	402	if (!found_monotonic)
	403	t->next_elapse_monotonic_or_boottime = v->next_elapse;
	404	else
	405	t->next_elapse_monotonic_or_boottime = MIN(t->next_elapse_monotonic_or_boottime, v->next_elapse);
	406
	407	found_monotonic = true;
	408	}
	409	}
	410
	411	if (!found_monotonic && !found_realtime) {
	412	log_debug_unit(UNIT(t)->id, "%s: Timer is elapsed.", UNIT(t)->id);
	413	timer_set_state(t, TIMER_ELAPSED);
	414	return;
	415	}
	416
	417	if (found_monotonic) {
	418	char buf[FORMAT_TIMESPAN_MAX];
	419
	420	log_debug_unit(UNIT(t)->id, "%s: Monotonic timer elapses in %s.",
	421	UNIT(t)->id,
	422	format_timespan(buf, sizeof(buf), t->next_elapse_monotonic_or_boottime > ts_monotonic ? t->next_elapse_monotonic_or_boottime - ts_monotonic : 0, 0));
	423
	424	if (t->monotonic_event_source) {
	425	r = sd_event_source_set_time(t->monotonic_event_source, t->next_elapse_monotonic_or_boottime);
	426	if (r < 0)
	427	goto fail;
	428
	429	r = sd_event_source_set_enabled(t->monotonic_event_source, SD_EVENT_ONESHOT);
	430	} else
	431	r = sd_event_add_time(
	432	UNIT(t)->manager->event,
	433	&t->monotonic_event_source,
	434	t->wake_system ? CLOCK_BOOTTIME_ALARM : CLOCK_MONOTONIC,
	435	t->next_elapse_monotonic_or_boottime, t->accuracy_usec,
	436	timer_dispatch, t);
	437	if (r < 0)
	438	goto fail;
	439
	440	} else if (t->monotonic_event_source) {
	441
	442	r = sd_event_source_set_enabled(t->monotonic_event_source, SD_EVENT_OFF);
	443	if (r < 0)
	444	goto fail;
	445	}
	446
	447	if (found_realtime) {
	448	char buf[FORMAT_TIMESTAMP_MAX];
	449	log_debug_unit(UNIT(t)->id, "%s: Realtime timer elapses at %s.", UNIT(t)->id, format_timestamp(buf, sizeof(buf), t->next_elapse_realtime));
	450
	451	if (t->realtime_event_source) {
	452	r = sd_event_source_set_time(t->realtime_event_source, t->next_elapse_realtime);
	453	if (r < 0)
	454	goto fail;
	455
	456	r = sd_event_source_set_enabled(t->realtime_event_source, SD_EVENT_ONESHOT);
	457	} else
	458	r = sd_event_add_time(
	459	UNIT(t)->manager->event,
	460	&t->realtime_event_source,
	461	t->wake_system ? CLOCK_REALTIME_ALARM : CLOCK_REALTIME,
	462	t->next_elapse_realtime, t->accuracy_usec,
	463	timer_dispatch, t);
	464	if (r < 0)
	465	goto fail;
	466
	467	} else if (t->realtime_event_source) {
	468
	469	r = sd_event_source_set_enabled(t->realtime_event_source, SD_EVENT_OFF);
	470	if (r < 0)
	471	goto fail;
	472	}
	473
	474	timer_set_state(t, TIMER_WAITING);
	475	return;
	476
	477	fail:
	478	log_warning_unit(UNIT(t)->id, "%s failed to enter waiting state: %s", UNIT(t)->id, strerror(-r));
	479	timer_enter_dead(t, TIMER_FAILURE_RESOURCES);
	480	}
	481
	482	static void timer_enter_running(Timer *t) {
	483	_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
	484	int r;
	485
	486	assert(t);
	487
	488	/* Don't start job if we are supposed to go down */
	489	if (unit_stop_pending(UNIT(t)))
	490	return;
	491
	492	r = manager_add_job(UNIT(t)->manager, JOB_START, UNIT_TRIGGER(UNIT(t)),
	493	JOB_REPLACE, true, &error, NULL);
	494	if (r < 0)
	495	goto fail;
	496
	497	dual_timestamp_get(&t->last_trigger);
	498
	499	if (t->stamp_path) {
	500	_cleanup_close_ int fd = -1;
	501
	502	mkdir_parents_label(t->stamp_path, 0755);
	503
	504	/* Update the file atime + mtime, if we can */
	505	fd = open(t->stamp_path, O_WRONLY\|O_CREAT\|O_TRUNC\|O_CLOEXEC, 0644);
	506	if (fd >= 0) {
	507	struct timespec ts[2];
	508
	509	timespec_store(&ts[0], t->last_trigger.realtime);
	510	ts[1] = ts[0];
	511
	512	futimens(fd, ts);
	513	}
	514	}
	515
	516	timer_set_state(t, TIMER_RUNNING);
	517	return;
	518
	519	fail:
	520	log_warning_unit(UNIT(t)->id,
	521	"%s failed to queue unit startup job: %s",
	522	UNIT(t)->id, bus_error_message(&error, r));
	523	timer_enter_dead(t, TIMER_FAILURE_RESOURCES);
	524	}
	525
	526	static int timer_start(Unit *u) {
	527	Timer *t = TIMER(u);
	528
	529	assert(t);
	530	assert(t->state == TIMER_DEAD \|\| t->state == TIMER_FAILED);
	531
	532	if (UNIT_TRIGGER(u)->load_state != UNIT_LOADED)
	533	return -ENOENT;
	534
	535	t->last_trigger = DUAL_TIMESTAMP_NULL;
	536
	537	if (t->stamp_path) {
	538	struct stat st;
	539
	540	if (stat(t->stamp_path, &st) >= 0)
	541	t->last_trigger.realtime = timespec_load(&st.st_atim);
	542	}
	543
	544	t->result = TIMER_SUCCESS;
	545	timer_enter_waiting(t, true);
	546	return 0;
	547	}
	548
	549	static int timer_stop(Unit *u) {
	550	Timer *t = TIMER(u);
	551
	552	assert(t);
	553	assert(t->state == TIMER_WAITING \|\| t->state == TIMER_RUNNING \|\| t->state == TIMER_ELAPSED);
	554
	555	timer_enter_dead(t, TIMER_SUCCESS);
	556	return 0;
	557	}
	558
	559	static int timer_serialize(Unit u, FILE f, FDSet *fds) {
	560	Timer *t = TIMER(u);
	561
	562	assert(u);
	563	assert(f);
	564	assert(fds);
	565
	566	unit_serialize_item(u, f, "state", timer_state_to_string(t->state));
	567	unit_serialize_item(u, f, "result", timer_result_to_string(t->result));
	568
	569	if (t->last_trigger.realtime > 0)
	570	unit_serialize_item_format(u, f, "last-trigger-realtime", "%" PRIu64, t->last_trigger.realtime);
	571
	572	if (t->last_trigger.monotonic > 0)
	573	unit_serialize_item_format(u, f, "last-trigger-monotonic", "%" PRIu64, t->last_trigger.monotonic);
	574
	575	return 0;
	576	}
	577
	578	static int timer_deserialize_item(Unit u, const char key, const char value, FDSet fds) {
	579	Timer *t = TIMER(u);
	580	int r;
	581
	582	assert(u);
	583	assert(key);
	584	assert(value);
	585	assert(fds);
	586
	587	if (streq(key, "state")) {
	588	TimerState state;
	589
	590	state = timer_state_from_string(value);
	591	if (state < 0)
	592	log_debug_unit(u->id, "Failed to parse state value %s", value);
	593	else
	594	t->deserialized_state = state;
	595	} else if (streq(key, "result")) {
	596	TimerResult f;
	597
	598	f = timer_result_from_string(value);
	599	if (f < 0)
	600	log_debug_unit(u->id, "Failed to parse result value %s", value);
	601	else if (f != TIMER_SUCCESS)
	602	t->result = f;
	603	} else if (streq(key, "last-trigger-realtime")) {
	604
	605	r = safe_atou64(value, &t->last_trigger.realtime);
	606	if (r < 0)
	607	log_debug_unit(u->id, "Failed to parse last-trigger-realtime value %s", value);
	608
	609	} else if (streq(key, "last-trigger-monotonic")) {
	610
	611	r = safe_atou64(value, &t->last_trigger.monotonic);
	612	if (r < 0)
	613	log_debug_unit(u->id, "Failed to parse last-trigger-monotonic value %s", value);
	614
	615	} else
	616	log_debug_unit(u->id, "Unknown serialization key '%s'", key);
	617
	618	return 0;
	619	}
	620
	621	_pure_ static UnitActiveState timer_active_state(Unit *u) {
	622	assert(u);
	623
	624	return state_translation_table[TIMER(u)->state];
	625	}
	626
	627	_pure_ static const char timer_sub_state_to_string(Unit u) {
	628	assert(u);
	629
	630	return timer_state_to_string(TIMER(u)->state);
	631	}
	632
	633	static int timer_dispatch(sd_event_source s, uint64_t usec, void userdata) {
	634	Timer *t = TIMER(userdata);
	635
	636	assert(t);
	637
	638	if (t->state != TIMER_WAITING)
	639	return 0;
	640
	641	log_debug_unit(UNIT(t)->id, "Timer elapsed on %s", UNIT(t)->id);
	642	timer_enter_running(t);
	643	return 0;
	644	}
	645
	646	static void timer_trigger_notify(Unit u, Unit other) {
	647	Timer *t = TIMER(u);
	648	TimerValue *v;
	649
	650	assert(u);
	651	assert(other);
	652
	653	if (other->load_state != UNIT_LOADED)
	654	return;
	655
	656	/* Reenable all timers that depend on unit state */
	657	LIST_FOREACH(value, v, t->values)
	658	if (v->base == TIMER_UNIT_ACTIVE \|\|
	659	v->base == TIMER_UNIT_INACTIVE)
	660	v->disabled = false;
	661
	662	switch (t->state) {
	663
	664	case TIMER_WAITING:
	665	case TIMER_ELAPSED:
	666
	667	/* Recalculate sleep time */
	668	timer_enter_waiting(t, false);
	669	break;
	670
	671	case TIMER_RUNNING:
	672
	673	if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other))) {
	674	log_debug_unit(UNIT(t)->id, "%s got notified about unit deactivation.", UNIT(t)->id);
	675	timer_enter_waiting(t, false);
	676	}
	677	break;
	678
	679	case TIMER_DEAD:
	680	case TIMER_FAILED:
	681	break;
	682
	683	default:
	684	assert_not_reached("Unknown timer state");
	685	}
	686	}
	687
	688	static void timer_reset_failed(Unit *u) {
	689	Timer *t = TIMER(u);
	690
	691	assert(t);
	692
	693	if (t->state == TIMER_FAILED)
	694	timer_set_state(t, TIMER_DEAD);
	695
	696	t->result = TIMER_SUCCESS;
	697	}
	698
	699	static void timer_time_change(Unit *u) {
	700	Timer *t = TIMER(u);
	701
	702	assert(u);
	703
	704	if (t->state != TIMER_WAITING)
	705	return;
	706
	707	log_debug_unit(u->id, "%s: time change, recalculating next elapse.", u->id);
	708	timer_enter_waiting(t, false);
	709	}
	710
	711	static const char* const timer_state_table[_TIMER_STATE_MAX] = {
	712	[TIMER_DEAD] = "dead",
	713	[TIMER_WAITING] = "waiting",
	714	[TIMER_RUNNING] = "running",
	715	[TIMER_ELAPSED] = "elapsed",
	716	[TIMER_FAILED] = "failed"
	717	};
	718
	719	DEFINE_STRING_TABLE_LOOKUP(timer_state, TimerState);
	720
	721	static const char* const timer_base_table[_TIMER_BASE_MAX] = {
	722	[TIMER_ACTIVE] = "OnActiveSec",
	723	[TIMER_BOOT] = "OnBootSec",
	724	[TIMER_STARTUP] = "OnStartupSec",
	725	[TIMER_UNIT_ACTIVE] = "OnUnitActiveSec",
	726	[TIMER_UNIT_INACTIVE] = "OnUnitInactiveSec",
	727	[TIMER_CALENDAR] = "OnCalendar"
	728	};
	729
	730	DEFINE_STRING_TABLE_LOOKUP(timer_base, TimerBase);
	731
	732	static const char* const timer_result_table[_TIMER_RESULT_MAX] = {
	733	[TIMER_SUCCESS] = "success",
	734	[TIMER_FAILURE_RESOURCES] = "resources"
	735	};
	736
	737	DEFINE_STRING_TABLE_LOOKUP(timer_result, TimerResult);
	738
	739	const UnitVTable timer_vtable = {
	740	.object_size = sizeof(Timer),
	741
	742	.sections =
	743	"Unit\0"
	744	"Timer\0"
	745	"Install\0",
	746
	747	.init = timer_init,
	748	.done = timer_done,
	749	.load = timer_load,
	750
	751	.coldplug = timer_coldplug,
	752
	753	.dump = timer_dump,
	754
	755	.start = timer_start,
	756	.stop = timer_stop,
	757
	758	.serialize = timer_serialize,
	759	.deserialize_item = timer_deserialize_item,
	760
	761	.active_state = timer_active_state,
	762	.sub_state_to_string = timer_sub_state_to_string,
	763
	764	.trigger_notify = timer_trigger_notify,
	765
	766	.reset_failed = timer_reset_failed,
	767	.time_change = timer_time_change,
	768
	769	.bus_interface = "org.freedesktop.systemd1.Timer",
	770	.bus_vtable = bus_timer_vtable,
	771	};