src/core/timer.c

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