2 This file is part of systemd.
4 Copyright 2010 Lennart Poettering
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include "alloc-util.h"
23 #include "bus-error.h"
25 #include "dbus-timer.h"
27 #include "parse-util.h"
28 #include "random-util.h"
30 #include "string-table.h"
31 #include "string-util.h"
33 #include "unit-name.h"
35 #include "user-util.h"
38 static const UnitActiveState state_translation_table
[_TIMER_STATE_MAX
] = {
39 [TIMER_DEAD
] = UNIT_INACTIVE
,
40 [TIMER_WAITING
] = UNIT_ACTIVE
,
41 [TIMER_RUNNING
] = UNIT_ACTIVE
,
42 [TIMER_ELAPSED
] = UNIT_ACTIVE
,
43 [TIMER_FAILED
] = UNIT_FAILED
46 static int timer_dispatch(sd_event_source
*s
, uint64_t usec
, void *userdata
);
48 static void timer_init(Unit
*u
) {
52 assert(u
->load_state
== UNIT_STUB
);
54 t
->next_elapse_monotonic_or_boottime
= USEC_INFINITY
;
55 t
->next_elapse_realtime
= USEC_INFINITY
;
56 t
->accuracy_usec
= u
->manager
->default_timer_accuracy_usec
;
57 t
->remain_after_elapse
= true;
60 void timer_free_values(Timer
*t
) {
65 while ((v
= t
->values
)) {
66 LIST_REMOVE(value
, t
->values
, v
);
67 calendar_spec_free(v
->calendar_spec
);
72 static void timer_done(Unit
*u
) {
79 t
->monotonic_event_source
= sd_event_source_unref(t
->monotonic_event_source
);
80 t
->realtime_event_source
= sd_event_source_unref(t
->realtime_event_source
);
85 static int timer_verify(Timer
*t
) {
88 if (UNIT(t
)->load_state
!= UNIT_LOADED
)
92 log_unit_error(UNIT(t
), "Timer unit lacks value setting. Refusing.");
99 static int timer_add_default_dependencies(Timer
*t
) {
105 if (!UNIT(t
)->default_dependencies
)
108 r
= unit_add_dependency_by_name(UNIT(t
), UNIT_BEFORE
, SPECIAL_TIMERS_TARGET
, NULL
, true);
112 if (MANAGER_IS_SYSTEM(UNIT(t
)->manager
)) {
113 r
= unit_add_two_dependencies_by_name(UNIT(t
), UNIT_AFTER
, UNIT_REQUIRES
, SPECIAL_SYSINIT_TARGET
, NULL
, true);
117 LIST_FOREACH(value
, v
, t
->values
) {
118 if (v
->base
== TIMER_CALENDAR
) {
119 r
= unit_add_dependency_by_name(UNIT(t
), UNIT_AFTER
, SPECIAL_TIME_SYNC_TARGET
, NULL
, true);
127 return unit_add_two_dependencies_by_name(UNIT(t
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_SHUTDOWN_TARGET
, NULL
, true);
130 static int timer_setup_persistent(Timer
*t
) {
138 if (MANAGER_IS_SYSTEM(UNIT(t
)->manager
)) {
140 r
= unit_require_mounts_for(UNIT(t
), "/var/lib/systemd/timers");
144 t
->stamp_path
= strappend("/var/lib/systemd/timers/stamp-", UNIT(t
)->id
);
148 e
= getenv("XDG_DATA_HOME");
150 t
->stamp_path
= strjoin(e
, "/systemd/timers/stamp-", UNIT(t
)->id
);
153 _cleanup_free_
char *h
= NULL
;
155 r
= get_home_dir(&h
);
157 return log_unit_error_errno(UNIT(t
), r
, "Failed to determine home directory: %m");
159 t
->stamp_path
= strjoin(h
, "/.local/share/systemd/timers/stamp-", UNIT(t
)->id
);
169 static int timer_load(Unit
*u
) {
174 assert(u
->load_state
== UNIT_STUB
);
176 r
= unit_load_fragment_and_dropin(u
);
180 if (u
->load_state
== UNIT_LOADED
) {
182 if (set_isempty(u
->dependencies
[UNIT_TRIGGERS
])) {
185 r
= unit_load_related_unit(u
, ".service", &x
);
189 r
= unit_add_two_dependencies(u
, UNIT_BEFORE
, UNIT_TRIGGERS
, x
, true);
194 r
= timer_setup_persistent(t
);
198 r
= timer_add_default_dependencies(t
);
203 return timer_verify(t
);
206 static void timer_dump(Unit
*u
, FILE *f
, const char *prefix
) {
207 char buf
[FORMAT_TIMESPAN_MAX
];
212 trigger
= UNIT_TRIGGER(u
);
215 "%sTimer State: %s\n"
221 "%sRemainAfterElapse: %s\n",
222 prefix
, timer_state_to_string(t
->state
),
223 prefix
, timer_result_to_string(t
->result
),
224 prefix
, trigger
? trigger
->id
: "n/a",
225 prefix
, yes_no(t
->persistent
),
226 prefix
, yes_no(t
->wake_system
),
227 prefix
, format_timespan(buf
, sizeof(buf
), t
->accuracy_usec
, 1),
228 prefix
, yes_no(t
->remain_after_elapse
));
230 LIST_FOREACH(value
, v
, t
->values
) {
232 if (v
->base
== TIMER_CALENDAR
) {
233 _cleanup_free_
char *p
= NULL
;
235 (void) calendar_spec_to_string(v
->calendar_spec
, &p
);
240 timer_base_to_string(v
->base
),
243 char timespan1
[FORMAT_TIMESPAN_MAX
];
248 timer_base_to_string(v
->base
),
249 format_timespan(timespan1
, sizeof(timespan1
), v
->value
, 0));
254 static void timer_set_state(Timer
*t
, TimerState state
) {
255 TimerState old_state
;
258 old_state
= t
->state
;
261 if (state
!= TIMER_WAITING
) {
262 t
->monotonic_event_source
= sd_event_source_unref(t
->monotonic_event_source
);
263 t
->realtime_event_source
= sd_event_source_unref(t
->realtime_event_source
);
264 t
->next_elapse_monotonic_or_boottime
= USEC_INFINITY
;
265 t
->next_elapse_realtime
= USEC_INFINITY
;
268 if (state
!= old_state
)
269 log_unit_debug(UNIT(t
), "Changed %s -> %s", timer_state_to_string(old_state
), timer_state_to_string(state
));
271 unit_notify(UNIT(t
), state_translation_table
[old_state
], state_translation_table
[state
], true);
274 static void timer_enter_waiting(Timer
*t
, bool initial
);
276 static int timer_coldplug(Unit
*u
) {
280 assert(t
->state
== TIMER_DEAD
);
282 if (t
->deserialized_state
== t
->state
)
285 if (t
->deserialized_state
== TIMER_WAITING
)
286 timer_enter_waiting(t
, false);
288 timer_set_state(t
, t
->deserialized_state
);
293 static void timer_enter_dead(Timer
*t
, TimerResult f
) {
296 if (t
->result
== TIMER_SUCCESS
)
299 timer_set_state(t
, t
->result
!= TIMER_SUCCESS
? TIMER_FAILED
: TIMER_DEAD
);
302 static void timer_enter_elapsed(Timer
*t
, bool leave_around
) {
305 /* If a unit is marked with RemainAfterElapse=yes we leave it
306 * around even after it elapsed once, so that starting it
307 * later again does not necessarily mean immediate
308 * retriggering. We unconditionally leave units with
309 * TIMER_UNIT_ACTIVE or TIMER_UNIT_INACTIVE triggers around,
310 * since they might be restarted automatically at any time
313 if (t
->remain_after_elapse
|| leave_around
)
314 timer_set_state(t
, TIMER_ELAPSED
);
316 timer_enter_dead(t
, TIMER_SUCCESS
);
319 static usec_t
monotonic_to_boottime(usec_t t
) {
325 a
= now(clock_boottime_or_monotonic());
326 b
= now(CLOCK_MONOTONIC
);
334 static void add_random(Timer
*t
, usec_t
*v
) {
335 char s
[FORMAT_TIMESPAN_MAX
];
341 if (t
->random_usec
== 0)
343 if (*v
== USEC_INFINITY
)
346 add
= random_u64() % t
->random_usec
;
348 if (*v
+ add
< *v
) /* overflow */
349 *v
= (usec_t
) -2; /* Highest possible value, that is not USEC_INFINITY */
353 log_unit_debug(UNIT(t
), "Adding %s random time.", format_timespan(s
, sizeof(s
), add
, 0));
356 static void timer_enter_waiting(Timer
*t
, bool initial
) {
357 bool found_monotonic
= false, found_realtime
= false;
358 usec_t ts_realtime
, ts_monotonic
;
360 bool leave_around
= false;
367 trigger
= UNIT_TRIGGER(UNIT(t
));
369 log_unit_error(UNIT(t
), "Unit to trigger vanished.");
370 timer_enter_dead(t
, TIMER_FAILURE_RESOURCES
);
374 /* If we shall wake the system we use the boottime clock
375 * rather than the monotonic clock. */
377 ts_realtime
= now(CLOCK_REALTIME
);
378 ts_monotonic
= now(t
->wake_system
? clock_boottime_or_monotonic() : CLOCK_MONOTONIC
);
379 t
->next_elapse_monotonic_or_boottime
= t
->next_elapse_realtime
= 0;
381 LIST_FOREACH(value
, v
, t
->values
) {
386 if (v
->base
== TIMER_CALENDAR
) {
389 /* If we know the last time this was
390 * triggered, schedule the job based relative
391 * to that. If we don't just start from
394 b
= t
->last_trigger
.realtime
> 0 ? t
->last_trigger
.realtime
: ts_realtime
;
396 r
= calendar_spec_next_usec(v
->calendar_spec
, b
, &v
->next_elapse
);
401 t
->next_elapse_realtime
= v
->next_elapse
;
403 t
->next_elapse_realtime
= MIN(t
->next_elapse_realtime
, v
->next_elapse
);
405 found_realtime
= true;
411 if (state_translation_table
[t
->state
] == UNIT_ACTIVE
)
412 base
= UNIT(t
)->inactive_exit_timestamp
.monotonic
;
418 if (detect_container() <= 0) {
419 /* CLOCK_MONOTONIC equals the uptime on Linux */
423 /* In a container we don't want to include the time the host
424 * was already up when the container started, so count from
425 * our own startup. */
428 base
= UNIT(t
)->manager
->userspace_timestamp
.monotonic
;
431 case TIMER_UNIT_ACTIVE
:
433 base
= trigger
->inactive_exit_timestamp
.monotonic
;
436 base
= t
->last_trigger
.monotonic
;
443 case TIMER_UNIT_INACTIVE
:
445 base
= trigger
->inactive_enter_timestamp
.monotonic
;
448 base
= t
->last_trigger
.monotonic
;
456 assert_not_reached("Unknown timer base");
460 base
= monotonic_to_boottime(base
);
462 v
->next_elapse
= base
+ v
->value
;
464 if (!initial
&& v
->next_elapse
< ts_monotonic
&& IN_SET(v
->base
, TIMER_ACTIVE
, TIMER_BOOT
, TIMER_STARTUP
)) {
465 /* This is a one time trigger, disable it now */
470 if (!found_monotonic
)
471 t
->next_elapse_monotonic_or_boottime
= v
->next_elapse
;
473 t
->next_elapse_monotonic_or_boottime
= MIN(t
->next_elapse_monotonic_or_boottime
, v
->next_elapse
);
475 found_monotonic
= true;
479 if (!found_monotonic
&& !found_realtime
) {
480 log_unit_debug(UNIT(t
), "Timer is elapsed.");
481 timer_enter_elapsed(t
, leave_around
);
485 if (found_monotonic
) {
486 char buf
[FORMAT_TIMESPAN_MAX
];
489 add_random(t
, &t
->next_elapse_monotonic_or_boottime
);
491 left
= t
->next_elapse_monotonic_or_boottime
> ts_monotonic
? t
->next_elapse_monotonic_or_boottime
- ts_monotonic
: 0;
492 log_unit_debug(UNIT(t
), "Monotonic timer elapses in %s.", format_timespan(buf
, sizeof(buf
), left
, 0));
494 if (t
->monotonic_event_source
) {
495 r
= sd_event_source_set_time(t
->monotonic_event_source
, t
->next_elapse_monotonic_or_boottime
);
499 r
= sd_event_source_set_enabled(t
->monotonic_event_source
, SD_EVENT_ONESHOT
);
504 r
= sd_event_add_time(
505 UNIT(t
)->manager
->event
,
506 &t
->monotonic_event_source
,
507 t
->wake_system
? CLOCK_BOOTTIME_ALARM
: CLOCK_MONOTONIC
,
508 t
->next_elapse_monotonic_or_boottime
, t
->accuracy_usec
,
513 (void) sd_event_source_set_description(t
->monotonic_event_source
, "timer-monotonic");
516 } else if (t
->monotonic_event_source
) {
518 r
= sd_event_source_set_enabled(t
->monotonic_event_source
, SD_EVENT_OFF
);
523 if (found_realtime
) {
524 char buf
[FORMAT_TIMESTAMP_MAX
];
526 add_random(t
, &t
->next_elapse_realtime
);
528 log_unit_debug(UNIT(t
), "Realtime timer elapses at %s.", format_timestamp(buf
, sizeof(buf
), t
->next_elapse_realtime
));
530 if (t
->realtime_event_source
) {
531 r
= sd_event_source_set_time(t
->realtime_event_source
, t
->next_elapse_realtime
);
535 r
= sd_event_source_set_enabled(t
->realtime_event_source
, SD_EVENT_ONESHOT
);
539 r
= sd_event_add_time(
540 UNIT(t
)->manager
->event
,
541 &t
->realtime_event_source
,
542 t
->wake_system
? CLOCK_REALTIME_ALARM
: CLOCK_REALTIME
,
543 t
->next_elapse_realtime
, t
->accuracy_usec
,
548 (void) sd_event_source_set_description(t
->realtime_event_source
, "timer-realtime");
551 } else if (t
->realtime_event_source
) {
553 r
= sd_event_source_set_enabled(t
->realtime_event_source
, SD_EVENT_OFF
);
558 timer_set_state(t
, TIMER_WAITING
);
562 log_unit_warning_errno(UNIT(t
), r
, "Failed to enter waiting state: %m");
563 timer_enter_dead(t
, TIMER_FAILURE_RESOURCES
);
566 static void timer_enter_running(Timer
*t
) {
567 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
573 /* Don't start job if we are supposed to go down */
574 if (unit_stop_pending(UNIT(t
)))
577 trigger
= UNIT_TRIGGER(UNIT(t
));
579 log_unit_error(UNIT(t
), "Unit to trigger vanished.");
580 timer_enter_dead(t
, TIMER_FAILURE_RESOURCES
);
584 r
= manager_add_job(UNIT(t
)->manager
, JOB_START
, trigger
, JOB_REPLACE
, &error
, NULL
);
588 dual_timestamp_get(&t
->last_trigger
);
591 touch_file(t
->stamp_path
, true, t
->last_trigger
.realtime
, UID_INVALID
, GID_INVALID
, MODE_INVALID
);
593 timer_set_state(t
, TIMER_RUNNING
);
597 log_unit_warning(UNIT(t
), "Failed to queue unit startup job: %s", bus_error_message(&error
, r
));
598 timer_enter_dead(t
, TIMER_FAILURE_RESOURCES
);
601 static int timer_start(Unit
*u
) {
608 assert(t
->state
== TIMER_DEAD
|| t
->state
== TIMER_FAILED
);
610 trigger
= UNIT_TRIGGER(u
);
611 if (!trigger
|| trigger
->load_state
!= UNIT_LOADED
) {
612 log_unit_error(u
, "Refusing to start, unit to trigger not loaded.");
616 r
= unit_start_limit_test(u
);
618 timer_enter_dead(t
, TIMER_FAILURE_START_LIMIT_HIT
);
622 r
= unit_acquire_invocation_id(u
);
626 t
->last_trigger
= DUAL_TIMESTAMP_NULL
;
628 /* Reenable all timers that depend on unit activation time */
629 LIST_FOREACH(value
, v
, t
->values
)
630 if (v
->base
== TIMER_ACTIVE
)
636 if (stat(t
->stamp_path
, &st
) >= 0)
637 t
->last_trigger
.realtime
= timespec_load(&st
.st_atim
);
638 else if (errno
== ENOENT
)
639 /* The timer has never run before,
640 * make sure a stamp file exists.
642 (void) touch_file(t
->stamp_path
, true, USEC_INFINITY
, UID_INVALID
, GID_INVALID
, MODE_INVALID
);
645 t
->result
= TIMER_SUCCESS
;
646 timer_enter_waiting(t
, true);
650 static int timer_stop(Unit
*u
) {
654 assert(t
->state
== TIMER_WAITING
|| t
->state
== TIMER_RUNNING
|| t
->state
== TIMER_ELAPSED
);
656 timer_enter_dead(t
, TIMER_SUCCESS
);
660 static int timer_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
667 unit_serialize_item(u
, f
, "state", timer_state_to_string(t
->state
));
668 unit_serialize_item(u
, f
, "result", timer_result_to_string(t
->result
));
670 if (t
->last_trigger
.realtime
> 0)
671 unit_serialize_item_format(u
, f
, "last-trigger-realtime", "%" PRIu64
, t
->last_trigger
.realtime
);
673 if (t
->last_trigger
.monotonic
> 0)
674 unit_serialize_item_format(u
, f
, "last-trigger-monotonic", "%" PRIu64
, t
->last_trigger
.monotonic
);
679 static int timer_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
688 if (streq(key
, "state")) {
691 state
= timer_state_from_string(value
);
693 log_unit_debug(u
, "Failed to parse state value: %s", value
);
695 t
->deserialized_state
= state
;
696 } else if (streq(key
, "result")) {
699 f
= timer_result_from_string(value
);
701 log_unit_debug(u
, "Failed to parse result value: %s", value
);
702 else if (f
!= TIMER_SUCCESS
)
704 } else if (streq(key
, "last-trigger-realtime")) {
706 r
= safe_atou64(value
, &t
->last_trigger
.realtime
);
708 log_unit_debug(u
, "Failed to parse last-trigger-realtime value: %s", value
);
710 } else if (streq(key
, "last-trigger-monotonic")) {
712 r
= safe_atou64(value
, &t
->last_trigger
.monotonic
);
714 log_unit_debug(u
, "Failed to parse last-trigger-monotonic value: %s", value
);
717 log_unit_debug(u
, "Unknown serialization key: %s", key
);
722 _pure_
static UnitActiveState
timer_active_state(Unit
*u
) {
725 return state_translation_table
[TIMER(u
)->state
];
728 _pure_
static const char *timer_sub_state_to_string(Unit
*u
) {
731 return timer_state_to_string(TIMER(u
)->state
);
734 static int timer_dispatch(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
735 Timer
*t
= TIMER(userdata
);
739 if (t
->state
!= TIMER_WAITING
)
742 log_unit_debug(UNIT(t
), "Timer elapsed.");
743 timer_enter_running(t
);
747 static void timer_trigger_notify(Unit
*u
, Unit
*other
) {
754 if (other
->load_state
!= UNIT_LOADED
)
757 /* Reenable all timers that depend on unit state */
758 LIST_FOREACH(value
, v
, t
->values
)
759 if (v
->base
== TIMER_UNIT_ACTIVE
||
760 v
->base
== TIMER_UNIT_INACTIVE
)
768 /* Recalculate sleep time */
769 timer_enter_waiting(t
, false);
774 if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other
))) {
775 log_unit_debug(UNIT(t
), "Got notified about unit deactivation.");
776 timer_enter_waiting(t
, false);
785 assert_not_reached("Unknown timer state");
789 static void timer_reset_failed(Unit
*u
) {
794 if (t
->state
== TIMER_FAILED
)
795 timer_set_state(t
, TIMER_DEAD
);
797 t
->result
= TIMER_SUCCESS
;
800 static void timer_time_change(Unit
*u
) {
805 if (t
->state
!= TIMER_WAITING
)
808 log_unit_debug(u
, "Time change, recalculating next elapse.");
809 timer_enter_waiting(t
, false);
812 static const char* const timer_base_table
[_TIMER_BASE_MAX
] = {
813 [TIMER_ACTIVE
] = "OnActiveSec",
814 [TIMER_BOOT
] = "OnBootSec",
815 [TIMER_STARTUP
] = "OnStartupSec",
816 [TIMER_UNIT_ACTIVE
] = "OnUnitActiveSec",
817 [TIMER_UNIT_INACTIVE
] = "OnUnitInactiveSec",
818 [TIMER_CALENDAR
] = "OnCalendar"
821 DEFINE_STRING_TABLE_LOOKUP(timer_base
, TimerBase
);
823 static const char* const timer_result_table
[_TIMER_RESULT_MAX
] = {
824 [TIMER_SUCCESS
] = "success",
825 [TIMER_FAILURE_RESOURCES
] = "resources",
826 [TIMER_FAILURE_START_LIMIT_HIT
] = "start-limit-hit",
829 DEFINE_STRING_TABLE_LOOKUP(timer_result
, TimerResult
);
831 const UnitVTable timer_vtable
= {
832 .object_size
= sizeof(Timer
),
838 .private_section
= "Timer",
844 .coldplug
= timer_coldplug
,
848 .start
= timer_start
,
851 .serialize
= timer_serialize
,
852 .deserialize_item
= timer_deserialize_item
,
854 .active_state
= timer_active_state
,
855 .sub_state_to_string
= timer_sub_state_to_string
,
857 .trigger_notify
= timer_trigger_notify
,
859 .reset_failed
= timer_reset_failed
,
860 .time_change
= timer_time_change
,
862 .bus_vtable
= bus_timer_vtable
,
863 .bus_set_property
= bus_timer_set_property
,
865 .can_transient
= true,