Line data Source code
1 : /* SPDX-License-Identifier: LGPL-2.1+ */
2 :
3 : #include <sys/stat.h>
4 : #include <sys/types.h>
5 : #include <unistd.h>
6 :
7 : #include <errno.h>
8 :
9 : #include "alloc-util.h"
10 : #include "bus-error.h"
11 : #include "bus-util.h"
12 : #include "dbus-timer.h"
13 : #include "dbus-unit.h"
14 : #include "fs-util.h"
15 : #include "parse-util.h"
16 : #include "random-util.h"
17 : #include "serialize.h"
18 : #include "special.h"
19 : #include "string-table.h"
20 : #include "string-util.h"
21 : #include "timer.h"
22 : #include "unit-name.h"
23 : #include "unit.h"
24 : #include "user-util.h"
25 : #include "virt.h"
26 :
27 : static const UnitActiveState state_translation_table[_TIMER_STATE_MAX] = {
28 : [TIMER_DEAD] = UNIT_INACTIVE,
29 : [TIMER_WAITING] = UNIT_ACTIVE,
30 : [TIMER_RUNNING] = UNIT_ACTIVE,
31 : [TIMER_ELAPSED] = UNIT_ACTIVE,
32 : [TIMER_FAILED] = UNIT_FAILED
33 : };
34 :
35 : static int timer_dispatch(sd_event_source *s, uint64_t usec, void *userdata);
36 :
37 0 : static void timer_init(Unit *u) {
38 0 : Timer *t = TIMER(u);
39 :
40 0 : assert(u);
41 0 : assert(u->load_state == UNIT_STUB);
42 :
43 0 : t->next_elapse_monotonic_or_boottime = USEC_INFINITY;
44 0 : t->next_elapse_realtime = USEC_INFINITY;
45 0 : t->accuracy_usec = u->manager->default_timer_accuracy_usec;
46 0 : t->remain_after_elapse = true;
47 0 : }
48 :
49 0 : void timer_free_values(Timer *t) {
50 : TimerValue *v;
51 :
52 0 : assert(t);
53 :
54 0 : while ((v = t->values)) {
55 0 : LIST_REMOVE(value, t->values, v);
56 0 : calendar_spec_free(v->calendar_spec);
57 0 : free(v);
58 : }
59 0 : }
60 :
61 0 : static void timer_done(Unit *u) {
62 0 : Timer *t = TIMER(u);
63 :
64 0 : assert(t);
65 :
66 0 : timer_free_values(t);
67 :
68 0 : t->monotonic_event_source = sd_event_source_unref(t->monotonic_event_source);
69 0 : t->realtime_event_source = sd_event_source_unref(t->realtime_event_source);
70 :
71 0 : free(t->stamp_path);
72 0 : }
73 :
74 0 : static int timer_verify(Timer *t) {
75 0 : assert(t);
76 :
77 0 : if (UNIT(t)->load_state != UNIT_LOADED)
78 0 : return 0;
79 :
80 0 : if (!t->values && !t->on_clock_change && !t->on_timezone_change) {
81 0 : log_unit_error(UNIT(t), "Timer unit lacks value setting. Refusing.");
82 0 : return -ENOEXEC;
83 : }
84 :
85 0 : return 0;
86 : }
87 :
88 0 : static int timer_add_default_dependencies(Timer *t) {
89 : int r;
90 : TimerValue *v;
91 :
92 0 : assert(t);
93 :
94 0 : if (!UNIT(t)->default_dependencies)
95 0 : return 0;
96 :
97 0 : r = unit_add_dependency_by_name(UNIT(t), UNIT_BEFORE, SPECIAL_TIMERS_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
98 0 : if (r < 0)
99 0 : return r;
100 :
101 0 : if (MANAGER_IS_SYSTEM(UNIT(t)->manager)) {
102 0 : r = unit_add_two_dependencies_by_name(UNIT(t), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
103 0 : if (r < 0)
104 0 : return r;
105 :
106 0 : LIST_FOREACH(value, v, t->values) {
107 0 : if (v->base == TIMER_CALENDAR) {
108 0 : r = unit_add_dependency_by_name(UNIT(t), UNIT_AFTER, SPECIAL_TIME_SYNC_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
109 0 : if (r < 0)
110 0 : return r;
111 0 : break;
112 : }
113 : }
114 : }
115 :
116 0 : return unit_add_two_dependencies_by_name(UNIT(t), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
117 : }
118 :
119 0 : static int timer_add_trigger_dependencies(Timer *t) {
120 : Unit *x;
121 : int r;
122 :
123 0 : assert(t);
124 :
125 0 : if (!hashmap_isempty(UNIT(t)->dependencies[UNIT_TRIGGERS]))
126 0 : return 0;
127 :
128 0 : r = unit_load_related_unit(UNIT(t), ".service", &x);
129 0 : if (r < 0)
130 0 : return r;
131 :
132 0 : return unit_add_two_dependencies(UNIT(t), UNIT_BEFORE, UNIT_TRIGGERS, x, true, UNIT_DEPENDENCY_IMPLICIT);
133 : }
134 :
135 0 : static int timer_setup_persistent(Timer *t) {
136 : int r;
137 :
138 0 : assert(t);
139 :
140 0 : if (!t->persistent)
141 0 : return 0;
142 :
143 0 : if (MANAGER_IS_SYSTEM(UNIT(t)->manager)) {
144 :
145 0 : r = unit_require_mounts_for(UNIT(t), "/var/lib/systemd/timers", UNIT_DEPENDENCY_FILE);
146 0 : if (r < 0)
147 0 : return r;
148 :
149 0 : t->stamp_path = strjoin("/var/lib/systemd/timers/stamp-", UNIT(t)->id);
150 : } else {
151 : const char *e;
152 :
153 0 : e = getenv("XDG_DATA_HOME");
154 0 : if (e)
155 0 : t->stamp_path = strjoin(e, "/systemd/timers/stamp-", UNIT(t)->id);
156 : else {
157 :
158 0 : _cleanup_free_ char *h = NULL;
159 :
160 0 : r = get_home_dir(&h);
161 0 : if (r < 0)
162 0 : return log_unit_error_errno(UNIT(t), r, "Failed to determine home directory: %m");
163 :
164 0 : t->stamp_path = strjoin(h, "/.local/share/systemd/timers/stamp-", UNIT(t)->id);
165 : }
166 : }
167 :
168 0 : if (!t->stamp_path)
169 0 : return log_oom();
170 :
171 0 : return 0;
172 : }
173 :
174 0 : static int timer_load(Unit *u) {
175 0 : Timer *t = TIMER(u);
176 : int r;
177 :
178 0 : assert(u);
179 0 : assert(u->load_state == UNIT_STUB);
180 :
181 0 : r = unit_load_fragment_and_dropin(u);
182 0 : if (r < 0)
183 0 : return r;
184 :
185 0 : if (u->load_state == UNIT_LOADED) {
186 :
187 0 : r = timer_add_trigger_dependencies(t);
188 0 : if (r < 0)
189 0 : return r;
190 :
191 0 : r = timer_setup_persistent(t);
192 0 : if (r < 0)
193 0 : return r;
194 :
195 0 : r = timer_add_default_dependencies(t);
196 0 : if (r < 0)
197 0 : return r;
198 : }
199 :
200 0 : return timer_verify(t);
201 : }
202 :
203 0 : static void timer_dump(Unit *u, FILE *f, const char *prefix) {
204 : char buf[FORMAT_TIMESPAN_MAX];
205 0 : Timer *t = TIMER(u);
206 : Unit *trigger;
207 : TimerValue *v;
208 :
209 0 : trigger = UNIT_TRIGGER(u);
210 :
211 0 : fprintf(f,
212 : "%sTimer State: %s\n"
213 : "%sResult: %s\n"
214 : "%sUnit: %s\n"
215 : "%sPersistent: %s\n"
216 : "%sWakeSystem: %s\n"
217 : "%sAccuracy: %s\n"
218 : "%sRemainAfterElapse: %s\n"
219 : "%sOnClockChange: %s\n"
220 : "%sOnTimeZoneChange %s\n",
221 : prefix, timer_state_to_string(t->state),
222 : prefix, timer_result_to_string(t->result),
223 : prefix, trigger ? trigger->id : "n/a",
224 0 : prefix, yes_no(t->persistent),
225 0 : prefix, yes_no(t->wake_system),
226 : prefix, format_timespan(buf, sizeof(buf), t->accuracy_usec, 1),
227 0 : prefix, yes_no(t->remain_after_elapse),
228 0 : prefix, yes_no(t->on_clock_change),
229 0 : prefix, yes_no(t->on_timezone_change));
230 :
231 0 : LIST_FOREACH(value, v, t->values) {
232 :
233 0 : if (v->base == TIMER_CALENDAR) {
234 0 : _cleanup_free_ char *p = NULL;
235 :
236 0 : (void) calendar_spec_to_string(v->calendar_spec, &p);
237 :
238 0 : fprintf(f,
239 : "%s%s: %s\n",
240 : prefix,
241 : timer_base_to_string(v->base),
242 : strna(p));
243 : } else {
244 : char timespan1[FORMAT_TIMESPAN_MAX];
245 :
246 0 : fprintf(f,
247 : "%s%s: %s\n",
248 : prefix,
249 : timer_base_to_string(v->base),
250 : format_timespan(timespan1, sizeof(timespan1), v->value, 0));
251 : }
252 : }
253 0 : }
254 :
255 0 : static void timer_set_state(Timer *t, TimerState state) {
256 : TimerState old_state;
257 0 : assert(t);
258 :
259 0 : if (t->state != state)
260 0 : bus_unit_send_pending_change_signal(UNIT(t), false);
261 :
262 0 : old_state = t->state;
263 0 : t->state = state;
264 :
265 0 : if (state != TIMER_WAITING) {
266 0 : t->monotonic_event_source = sd_event_source_unref(t->monotonic_event_source);
267 0 : t->realtime_event_source = sd_event_source_unref(t->realtime_event_source);
268 0 : t->next_elapse_monotonic_or_boottime = USEC_INFINITY;
269 0 : t->next_elapse_realtime = USEC_INFINITY;
270 : }
271 :
272 0 : if (state != old_state)
273 0 : log_unit_debug(UNIT(t), "Changed %s -> %s", timer_state_to_string(old_state), timer_state_to_string(state));
274 :
275 0 : unit_notify(UNIT(t), state_translation_table[old_state], state_translation_table[state], 0);
276 0 : }
277 :
278 : static void timer_enter_waiting(Timer *t, bool time_change);
279 :
280 0 : static int timer_coldplug(Unit *u) {
281 0 : Timer *t = TIMER(u);
282 :
283 0 : assert(t);
284 0 : assert(t->state == TIMER_DEAD);
285 :
286 0 : if (t->deserialized_state == t->state)
287 0 : return 0;
288 :
289 0 : if (t->deserialized_state == TIMER_WAITING)
290 0 : timer_enter_waiting(t, false);
291 : else
292 0 : timer_set_state(t, t->deserialized_state);
293 :
294 0 : return 0;
295 : }
296 :
297 0 : static void timer_enter_dead(Timer *t, TimerResult f) {
298 0 : assert(t);
299 :
300 0 : if (t->result == TIMER_SUCCESS)
301 0 : t->result = f;
302 :
303 0 : unit_log_result(UNIT(t), t->result == TIMER_SUCCESS, timer_result_to_string(t->result));
304 0 : timer_set_state(t, t->result != TIMER_SUCCESS ? TIMER_FAILED : TIMER_DEAD);
305 0 : }
306 :
307 0 : static void timer_enter_elapsed(Timer *t, bool leave_around) {
308 0 : assert(t);
309 :
310 : /* If a unit is marked with RemainAfterElapse=yes we leave it
311 : * around even after it elapsed once, so that starting it
312 : * later again does not necessarily mean immediate
313 : * retriggering. We unconditionally leave units with
314 : * TIMER_UNIT_ACTIVE or TIMER_UNIT_INACTIVE triggers around,
315 : * since they might be restarted automatically at any time
316 : * later on. */
317 :
318 0 : if (t->remain_after_elapse || leave_around)
319 0 : timer_set_state(t, TIMER_ELAPSED);
320 : else
321 0 : timer_enter_dead(t, TIMER_SUCCESS);
322 0 : }
323 :
324 0 : static void add_random(Timer *t, usec_t *v) {
325 : char s[FORMAT_TIMESPAN_MAX];
326 : usec_t add;
327 :
328 0 : assert(t);
329 0 : assert(v);
330 :
331 0 : if (t->random_usec == 0)
332 0 : return;
333 0 : if (*v == USEC_INFINITY)
334 0 : return;
335 :
336 0 : add = random_u64() % t->random_usec;
337 :
338 0 : if (*v + add < *v) /* overflow */
339 0 : *v = (usec_t) -2; /* Highest possible value, that is not USEC_INFINITY */
340 : else
341 0 : *v += add;
342 :
343 0 : log_unit_debug(UNIT(t), "Adding %s random time.", format_timespan(s, sizeof(s), add, 0));
344 : }
345 :
346 0 : static void timer_enter_waiting(Timer *t, bool time_change) {
347 0 : bool found_monotonic = false, found_realtime = false;
348 0 : bool leave_around = false;
349 : triple_timestamp ts;
350 : TimerValue *v;
351 : Unit *trigger;
352 : int r;
353 :
354 0 : assert(t);
355 :
356 0 : trigger = UNIT_TRIGGER(UNIT(t));
357 0 : if (!trigger) {
358 0 : log_unit_error(UNIT(t), "Unit to trigger vanished.");
359 0 : timer_enter_dead(t, TIMER_FAILURE_RESOURCES);
360 0 : return;
361 : }
362 :
363 0 : triple_timestamp_get(&ts);
364 0 : t->next_elapse_monotonic_or_boottime = t->next_elapse_realtime = 0;
365 :
366 0 : LIST_FOREACH(value, v, t->values) {
367 0 : if (v->disabled)
368 0 : continue;
369 :
370 0 : if (v->base == TIMER_CALENDAR) {
371 : usec_t b;
372 :
373 : /* If we know the last time this was
374 : * triggered, schedule the job based relative
375 : * to that. If we don't, just start from
376 : * the activation time. */
377 :
378 0 : if (t->last_trigger.realtime > 0)
379 0 : b = t->last_trigger.realtime;
380 : else {
381 0 : if (state_translation_table[t->state] == UNIT_ACTIVE)
382 0 : b = UNIT(t)->inactive_exit_timestamp.realtime;
383 : else
384 0 : b = ts.realtime;
385 : }
386 :
387 0 : r = calendar_spec_next_usec(v->calendar_spec, b, &v->next_elapse);
388 0 : if (r < 0)
389 0 : continue;
390 :
391 : /* To make the delay due to RandomizedDelaySec= work even at boot,
392 : * if the scheduled time has already passed, set the time when systemd
393 : * first started as the scheduled time.
394 : * Also, we don't have to check t->persistent since the logic implicitly express true. */
395 0 : if (v->next_elapse < UNIT(t)->manager->timestamps[MANAGER_TIMESTAMP_USERSPACE].realtime)
396 0 : v->next_elapse = UNIT(t)->manager->timestamps[MANAGER_TIMESTAMP_USERSPACE].realtime;
397 :
398 0 : if (!found_realtime)
399 0 : t->next_elapse_realtime = v->next_elapse;
400 : else
401 0 : t->next_elapse_realtime = MIN(t->next_elapse_realtime, v->next_elapse);
402 :
403 0 : found_realtime = true;
404 :
405 : } else {
406 : usec_t base;
407 :
408 0 : switch (v->base) {
409 :
410 0 : case TIMER_ACTIVE:
411 0 : if (state_translation_table[t->state] == UNIT_ACTIVE)
412 0 : base = UNIT(t)->inactive_exit_timestamp.monotonic;
413 : else
414 0 : base = ts.monotonic;
415 0 : break;
416 :
417 0 : case TIMER_BOOT:
418 0 : if (detect_container() <= 0) {
419 : /* CLOCK_MONOTONIC equals the uptime on Linux */
420 0 : base = 0;
421 0 : break;
422 : }
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. */
426 : _fallthrough_;
427 : case TIMER_STARTUP:
428 0 : base = UNIT(t)->manager->timestamps[MANAGER_TIMESTAMP_USERSPACE].monotonic;
429 0 : break;
430 :
431 0 : case TIMER_UNIT_ACTIVE:
432 0 : leave_around = true;
433 0 : base = MAX(trigger->inactive_exit_timestamp.monotonic, t->last_trigger.monotonic);
434 0 : if (base <= 0)
435 0 : continue;
436 0 : break;
437 :
438 0 : case TIMER_UNIT_INACTIVE:
439 0 : leave_around = true;
440 0 : base = MAX(trigger->inactive_enter_timestamp.monotonic, t->last_trigger.monotonic);
441 0 : if (base <= 0)
442 0 : continue;
443 0 : break;
444 :
445 0 : default:
446 0 : assert_not_reached("Unknown timer base");
447 : }
448 :
449 0 : v->next_elapse = usec_add(usec_shift_clock(base, CLOCK_MONOTONIC, TIMER_MONOTONIC_CLOCK(t)), v->value);
450 :
451 0 : if (dual_timestamp_is_set(&t->last_trigger) &&
452 0 : !time_change &&
453 0 : v->next_elapse < triple_timestamp_by_clock(&ts, TIMER_MONOTONIC_CLOCK(t)) &&
454 0 : IN_SET(v->base, TIMER_ACTIVE, TIMER_BOOT, TIMER_STARTUP)) {
455 : /* This is a one time trigger, disable it now */
456 0 : v->disabled = true;
457 0 : continue;
458 : }
459 :
460 0 : if (!found_monotonic)
461 0 : t->next_elapse_monotonic_or_boottime = v->next_elapse;
462 : else
463 0 : t->next_elapse_monotonic_or_boottime = MIN(t->next_elapse_monotonic_or_boottime, v->next_elapse);
464 :
465 0 : found_monotonic = true;
466 : }
467 : }
468 :
469 0 : if (!found_monotonic && !found_realtime && !t->on_timezone_change && !t->on_clock_change) {
470 0 : log_unit_debug(UNIT(t), "Timer is elapsed.");
471 0 : timer_enter_elapsed(t, leave_around);
472 0 : return;
473 : }
474 :
475 0 : if (found_monotonic) {
476 : char buf[FORMAT_TIMESPAN_MAX];
477 : usec_t left;
478 :
479 0 : add_random(t, &t->next_elapse_monotonic_or_boottime);
480 :
481 0 : left = usec_sub_unsigned(t->next_elapse_monotonic_or_boottime, triple_timestamp_by_clock(&ts, TIMER_MONOTONIC_CLOCK(t)));
482 0 : log_unit_debug(UNIT(t), "Monotonic timer elapses in %s.", format_timespan(buf, sizeof(buf), left, 0));
483 :
484 0 : if (t->monotonic_event_source) {
485 0 : r = sd_event_source_set_time(t->monotonic_event_source, t->next_elapse_monotonic_or_boottime);
486 0 : if (r < 0)
487 0 : goto fail;
488 :
489 0 : r = sd_event_source_set_enabled(t->monotonic_event_source, SD_EVENT_ONESHOT);
490 0 : if (r < 0)
491 0 : goto fail;
492 : } else {
493 :
494 0 : r = sd_event_add_time(
495 0 : UNIT(t)->manager->event,
496 : &t->monotonic_event_source,
497 0 : t->wake_system ? CLOCK_BOOTTIME_ALARM : CLOCK_MONOTONIC,
498 : t->next_elapse_monotonic_or_boottime, t->accuracy_usec,
499 : timer_dispatch, t);
500 0 : if (r < 0)
501 0 : goto fail;
502 :
503 0 : (void) sd_event_source_set_description(t->monotonic_event_source, "timer-monotonic");
504 : }
505 :
506 0 : } else if (t->monotonic_event_source) {
507 :
508 0 : r = sd_event_source_set_enabled(t->monotonic_event_source, SD_EVENT_OFF);
509 0 : if (r < 0)
510 0 : goto fail;
511 : }
512 :
513 0 : if (found_realtime) {
514 : char buf[FORMAT_TIMESTAMP_MAX];
515 :
516 0 : add_random(t, &t->next_elapse_realtime);
517 :
518 0 : log_unit_debug(UNIT(t), "Realtime timer elapses at %s.", format_timestamp(buf, sizeof(buf), t->next_elapse_realtime));
519 :
520 0 : if (t->realtime_event_source) {
521 0 : r = sd_event_source_set_time(t->realtime_event_source, t->next_elapse_realtime);
522 0 : if (r < 0)
523 0 : goto fail;
524 :
525 0 : r = sd_event_source_set_enabled(t->realtime_event_source, SD_EVENT_ONESHOT);
526 0 : if (r < 0)
527 0 : goto fail;
528 : } else {
529 0 : r = sd_event_add_time(
530 0 : UNIT(t)->manager->event,
531 : &t->realtime_event_source,
532 0 : t->wake_system ? CLOCK_REALTIME_ALARM : CLOCK_REALTIME,
533 : t->next_elapse_realtime, t->accuracy_usec,
534 : timer_dispatch, t);
535 0 : if (r < 0)
536 0 : goto fail;
537 :
538 0 : (void) sd_event_source_set_description(t->realtime_event_source, "timer-realtime");
539 : }
540 :
541 0 : } else if (t->realtime_event_source) {
542 :
543 0 : r = sd_event_source_set_enabled(t->realtime_event_source, SD_EVENT_OFF);
544 0 : if (r < 0)
545 0 : goto fail;
546 : }
547 :
548 0 : timer_set_state(t, TIMER_WAITING);
549 0 : return;
550 :
551 0 : fail:
552 0 : log_unit_warning_errno(UNIT(t), r, "Failed to enter waiting state: %m");
553 0 : timer_enter_dead(t, TIMER_FAILURE_RESOURCES);
554 : }
555 :
556 0 : static void timer_enter_running(Timer *t) {
557 0 : _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
558 : Unit *trigger;
559 : int r;
560 :
561 0 : assert(t);
562 :
563 : /* Don't start job if we are supposed to go down */
564 0 : if (unit_stop_pending(UNIT(t)))
565 0 : return;
566 :
567 0 : trigger = UNIT_TRIGGER(UNIT(t));
568 0 : if (!trigger) {
569 0 : log_unit_error(UNIT(t), "Unit to trigger vanished.");
570 0 : timer_enter_dead(t, TIMER_FAILURE_RESOURCES);
571 0 : return;
572 : }
573 :
574 0 : r = manager_add_job(UNIT(t)->manager, JOB_START, trigger, JOB_REPLACE, NULL, &error, NULL);
575 0 : if (r < 0)
576 0 : goto fail;
577 :
578 0 : dual_timestamp_get(&t->last_trigger);
579 :
580 0 : if (t->stamp_path)
581 0 : touch_file(t->stamp_path, true, t->last_trigger.realtime, UID_INVALID, GID_INVALID, MODE_INVALID);
582 :
583 0 : timer_set_state(t, TIMER_RUNNING);
584 0 : return;
585 :
586 0 : fail:
587 0 : log_unit_warning(UNIT(t), "Failed to queue unit startup job: %s", bus_error_message(&error, r));
588 0 : timer_enter_dead(t, TIMER_FAILURE_RESOURCES);
589 : }
590 :
591 0 : static int timer_start(Unit *u) {
592 0 : Timer *t = TIMER(u);
593 : TimerValue *v;
594 : int r;
595 :
596 0 : assert(t);
597 0 : assert(IN_SET(t->state, TIMER_DEAD, TIMER_FAILED));
598 :
599 0 : r = unit_test_trigger_loaded(u);
600 0 : if (r < 0)
601 0 : return r;
602 :
603 0 : r = unit_test_start_limit(u);
604 0 : if (r < 0) {
605 0 : timer_enter_dead(t, TIMER_FAILURE_START_LIMIT_HIT);
606 0 : return r;
607 : }
608 :
609 0 : r = unit_acquire_invocation_id(u);
610 0 : if (r < 0)
611 0 : return r;
612 :
613 0 : t->last_trigger = DUAL_TIMESTAMP_NULL;
614 :
615 : /* Reenable all timers that depend on unit activation time */
616 0 : LIST_FOREACH(value, v, t->values)
617 0 : if (v->base == TIMER_ACTIVE)
618 0 : v->disabled = false;
619 :
620 0 : if (t->stamp_path) {
621 : struct stat st;
622 :
623 0 : if (stat(t->stamp_path, &st) >= 0) {
624 : usec_t ft;
625 :
626 : /* Load the file timestamp, but only if it is actually in the past. If it is in the future,
627 : * something is wrong with the system clock. */
628 :
629 0 : ft = timespec_load(&st.st_mtim);
630 0 : if (ft < now(CLOCK_REALTIME))
631 0 : t->last_trigger.realtime = ft;
632 : else {
633 : char z[FORMAT_TIMESTAMP_MAX];
634 :
635 0 : log_unit_warning(u, "Not using persistent file timestamp %s as it is in the future.",
636 : format_timestamp(z, sizeof(z), ft));
637 : }
638 :
639 0 : } else if (errno == ENOENT)
640 : /* The timer has never run before,
641 : * make sure a stamp file exists.
642 : */
643 0 : (void) touch_file(t->stamp_path, true, USEC_INFINITY, UID_INVALID, GID_INVALID, MODE_INVALID);
644 : }
645 :
646 0 : t->result = TIMER_SUCCESS;
647 0 : timer_enter_waiting(t, false);
648 0 : return 1;
649 : }
650 :
651 0 : static int timer_stop(Unit *u) {
652 0 : Timer *t = TIMER(u);
653 :
654 0 : assert(t);
655 0 : assert(IN_SET(t->state, TIMER_WAITING, TIMER_RUNNING, TIMER_ELAPSED));
656 :
657 0 : timer_enter_dead(t, TIMER_SUCCESS);
658 0 : return 1;
659 : }
660 :
661 0 : static int timer_serialize(Unit *u, FILE *f, FDSet *fds) {
662 0 : Timer *t = TIMER(u);
663 :
664 0 : assert(u);
665 0 : assert(f);
666 0 : assert(fds);
667 :
668 0 : (void) serialize_item(f, "state", timer_state_to_string(t->state));
669 0 : (void) serialize_item(f, "result", timer_result_to_string(t->result));
670 :
671 0 : if (t->last_trigger.realtime > 0)
672 0 : (void) serialize_usec(f, "last-trigger-realtime", t->last_trigger.realtime);
673 :
674 0 : if (t->last_trigger.monotonic > 0)
675 0 : (void) serialize_usec(f, "last-trigger-monotonic", t->last_trigger.monotonic);
676 :
677 0 : return 0;
678 : }
679 :
680 0 : static int timer_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
681 0 : Timer *t = TIMER(u);
682 :
683 0 : assert(u);
684 0 : assert(key);
685 0 : assert(value);
686 0 : assert(fds);
687 :
688 0 : if (streq(key, "state")) {
689 : TimerState state;
690 :
691 0 : state = timer_state_from_string(value);
692 0 : if (state < 0)
693 0 : log_unit_debug(u, "Failed to parse state value: %s", value);
694 : else
695 0 : t->deserialized_state = state;
696 :
697 0 : } else if (streq(key, "result")) {
698 : TimerResult f;
699 :
700 0 : f = timer_result_from_string(value);
701 0 : if (f < 0)
702 0 : log_unit_debug(u, "Failed to parse result value: %s", value);
703 0 : else if (f != TIMER_SUCCESS)
704 0 : t->result = f;
705 :
706 0 : } else if (streq(key, "last-trigger-realtime"))
707 0 : (void) deserialize_usec(value, &t->last_trigger.realtime);
708 0 : else if (streq(key, "last-trigger-monotonic"))
709 0 : (void) deserialize_usec(value, &t->last_trigger.monotonic);
710 : else
711 0 : log_unit_debug(u, "Unknown serialization key: %s", key);
712 :
713 0 : return 0;
714 : }
715 :
716 0 : _pure_ static UnitActiveState timer_active_state(Unit *u) {
717 0 : assert(u);
718 :
719 0 : return state_translation_table[TIMER(u)->state];
720 : }
721 :
722 0 : _pure_ static const char *timer_sub_state_to_string(Unit *u) {
723 0 : assert(u);
724 :
725 0 : return timer_state_to_string(TIMER(u)->state);
726 : }
727 :
728 0 : static int timer_dispatch(sd_event_source *s, uint64_t usec, void *userdata) {
729 0 : Timer *t = TIMER(userdata);
730 :
731 0 : assert(t);
732 :
733 0 : if (t->state != TIMER_WAITING)
734 0 : return 0;
735 :
736 0 : log_unit_debug(UNIT(t), "Timer elapsed.");
737 0 : timer_enter_running(t);
738 0 : return 0;
739 : }
740 :
741 0 : static void timer_trigger_notify(Unit *u, Unit *other) {
742 0 : Timer *t = TIMER(u);
743 : TimerValue *v;
744 :
745 0 : assert(u);
746 0 : assert(other);
747 :
748 0 : if (other->load_state != UNIT_LOADED)
749 0 : return;
750 :
751 : /* Reenable all timers that depend on unit state */
752 0 : LIST_FOREACH(value, v, t->values)
753 0 : if (IN_SET(v->base, TIMER_UNIT_ACTIVE, TIMER_UNIT_INACTIVE))
754 0 : v->disabled = false;
755 :
756 0 : switch (t->state) {
757 :
758 0 : case TIMER_WAITING:
759 : case TIMER_ELAPSED:
760 :
761 : /* Recalculate sleep time */
762 0 : timer_enter_waiting(t, false);
763 0 : break;
764 :
765 0 : case TIMER_RUNNING:
766 :
767 0 : if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other))) {
768 0 : log_unit_debug(UNIT(t), "Got notified about unit deactivation.");
769 0 : timer_enter_waiting(t, false);
770 : }
771 0 : break;
772 :
773 0 : case TIMER_DEAD:
774 : case TIMER_FAILED:
775 0 : break;
776 :
777 0 : default:
778 0 : assert_not_reached("Unknown timer state");
779 : }
780 : }
781 :
782 0 : static void timer_reset_failed(Unit *u) {
783 0 : Timer *t = TIMER(u);
784 :
785 0 : assert(t);
786 :
787 0 : if (t->state == TIMER_FAILED)
788 0 : timer_set_state(t, TIMER_DEAD);
789 :
790 0 : t->result = TIMER_SUCCESS;
791 0 : }
792 :
793 0 : static void timer_time_change(Unit *u) {
794 0 : Timer *t = TIMER(u);
795 : usec_t ts;
796 :
797 0 : assert(u);
798 :
799 0 : if (t->state != TIMER_WAITING)
800 0 : return;
801 :
802 : /* If we appear to have triggered in the future, the system clock must
803 : * have been set backwards. So let's rewind our own clock and allow
804 : * the future trigger(s) to happen again :). Exactly the same as when
805 : * you start a timer unit with Persistent=yes. */
806 0 : ts = now(CLOCK_REALTIME);
807 0 : if (t->last_trigger.realtime > ts)
808 0 : t->last_trigger.realtime = ts;
809 :
810 0 : if (t->on_clock_change) {
811 0 : log_unit_debug(u, "Time change, triggering activation.");
812 0 : timer_enter_running(t);
813 : } else {
814 0 : log_unit_debug(u, "Time change, recalculating next elapse.");
815 0 : timer_enter_waiting(t, true);
816 : }
817 : }
818 :
819 0 : static void timer_timezone_change(Unit *u) {
820 0 : Timer *t = TIMER(u);
821 :
822 0 : assert(u);
823 :
824 0 : if (t->state != TIMER_WAITING)
825 0 : return;
826 :
827 0 : if (t->on_timezone_change) {
828 0 : log_unit_debug(u, "Timezone change, triggering activation.");
829 0 : timer_enter_running(t);
830 : } else {
831 0 : log_unit_debug(u, "Timezone change, recalculating next elapse.");
832 0 : timer_enter_waiting(t, false);
833 : }
834 : }
835 :
836 0 : static int timer_clean(Unit *u, ExecCleanMask mask) {
837 0 : Timer *t = TIMER(u);
838 : int r;
839 :
840 0 : assert(t);
841 0 : assert(mask != 0);
842 :
843 0 : if (t->state != TIMER_DEAD)
844 0 : return -EBUSY;
845 :
846 0 : if (!IN_SET(mask, EXEC_CLEAN_STATE))
847 0 : return -EUNATCH;
848 :
849 0 : r = timer_setup_persistent(t);
850 0 : if (r < 0)
851 0 : return r;
852 :
853 0 : if (!t->stamp_path)
854 0 : return -EUNATCH;
855 :
856 0 : if (unlink(t->stamp_path) && errno != ENOENT)
857 0 : return log_unit_error_errno(u, errno, "Failed to clean stamp file of timer: %m");
858 :
859 0 : return 0;
860 : }
861 :
862 0 : static int timer_can_clean(Unit *u, ExecCleanMask *ret) {
863 0 : Timer *t = TIMER(u);
864 :
865 0 : assert(t);
866 :
867 0 : *ret = t->persistent ? EXEC_CLEAN_STATE : 0;
868 0 : return 0;
869 : }
870 :
871 : static const char* const timer_base_table[_TIMER_BASE_MAX] = {
872 : [TIMER_ACTIVE] = "OnActiveSec",
873 : [TIMER_BOOT] = "OnBootSec",
874 : [TIMER_STARTUP] = "OnStartupSec",
875 : [TIMER_UNIT_ACTIVE] = "OnUnitActiveSec",
876 : [TIMER_UNIT_INACTIVE] = "OnUnitInactiveSec",
877 : [TIMER_CALENDAR] = "OnCalendar"
878 : };
879 :
880 16 : DEFINE_STRING_TABLE_LOOKUP(timer_base, TimerBase);
881 :
882 : static const char* const timer_result_table[_TIMER_RESULT_MAX] = {
883 : [TIMER_SUCCESS] = "success",
884 : [TIMER_FAILURE_RESOURCES] = "resources",
885 : [TIMER_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
886 : };
887 :
888 10 : DEFINE_STRING_TABLE_LOOKUP(timer_result, TimerResult);
889 :
890 : const UnitVTable timer_vtable = {
891 : .object_size = sizeof(Timer),
892 :
893 : .sections =
894 : "Unit\0"
895 : "Timer\0"
896 : "Install\0",
897 : .private_section = "Timer",
898 :
899 : .init = timer_init,
900 : .done = timer_done,
901 : .load = timer_load,
902 :
903 : .coldplug = timer_coldplug,
904 :
905 : .dump = timer_dump,
906 :
907 : .start = timer_start,
908 : .stop = timer_stop,
909 :
910 : .clean = timer_clean,
911 : .can_clean = timer_can_clean,
912 :
913 : .serialize = timer_serialize,
914 : .deserialize_item = timer_deserialize_item,
915 :
916 : .active_state = timer_active_state,
917 : .sub_state_to_string = timer_sub_state_to_string,
918 :
919 : .trigger_notify = timer_trigger_notify,
920 :
921 : .reset_failed = timer_reset_failed,
922 : .time_change = timer_time_change,
923 : .timezone_change = timer_timezone_change,
924 :
925 : .bus_vtable = bus_timer_vtable,
926 : .bus_set_property = bus_timer_set_property,
927 :
928 : .can_transient = true,
929 : };
|
