src/libelogind/sd-event/sd-event.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2013 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 <sys/epoll.h>
  21 #include <sys/timerfd.h>
  22 #include <sys/wait.h>
  23
  24 #include "sd-daemon.h"
  25 #include "sd-event.h"
  26 #include "sd-id128.h"
  27
  28 #include "alloc-util.h"
  29 #include "fd-util.h"
  30 #include "hashmap.h"
  31 #include "list.h"
  32 #include "macro.h"
  33 #include "missing.h"
  34 #include "prioq.h"
  35 #include "process-util.h"
  36 #include "set.h"
  37 #include "signal-util.h"
  38 #include "string-table.h"
  39 #include "string-util.h"
  40 #include "time-util.h"
  41 #include "util.h"
  42
  43 #define DEFAULT_ACCURACY_USEC (250 * USEC_PER_MSEC)
  44
  45 typedef enum EventSourceType {
  46         SOURCE_IO,
  47         SOURCE_TIME_REALTIME,
  48         SOURCE_TIME_BOOTTIME,
  49         SOURCE_TIME_MONOTONIC,
  50         SOURCE_TIME_REALTIME_ALARM,
  51         SOURCE_TIME_BOOTTIME_ALARM,
  52         SOURCE_SIGNAL,
  53         SOURCE_CHILD,
  54         SOURCE_DEFER,
  55         SOURCE_POST,
  56         SOURCE_EXIT,
  57         SOURCE_WATCHDOG,
  58         _SOURCE_EVENT_SOURCE_TYPE_MAX,
  59         _SOURCE_EVENT_SOURCE_TYPE_INVALID = -1
  60 } EventSourceType;
  61
  62 static const char* const event_source_type_table[_SOURCE_EVENT_SOURCE_TYPE_MAX] = {
  63         [SOURCE_IO] = "io",
  64         [SOURCE_TIME_REALTIME] = "realtime",
  65         [SOURCE_TIME_BOOTTIME] = "bootime",
  66         [SOURCE_TIME_MONOTONIC] = "monotonic",
  67         [SOURCE_TIME_REALTIME_ALARM] = "realtime-alarm",
  68         [SOURCE_TIME_BOOTTIME_ALARM] = "boottime-alarm",
  69         [SOURCE_SIGNAL] = "signal",
  70         [SOURCE_CHILD] = "child",
  71         [SOURCE_DEFER] = "defer",
  72         [SOURCE_POST] = "post",
  73         [SOURCE_EXIT] = "exit",
  74         [SOURCE_WATCHDOG] = "watchdog",
  75 };
  76
  77 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(event_source_type, int);
  78
  79 /* All objects we use in epoll events start with this value, so that
  80  * we know how to dispatch it */
  81 typedef enum WakeupType {
  82         WAKEUP_NONE,
  83         WAKEUP_EVENT_SOURCE,
  84         WAKEUP_CLOCK_DATA,
  85         WAKEUP_SIGNAL_DATA,
  86         _WAKEUP_TYPE_MAX,
  87         _WAKEUP_TYPE_INVALID = -1,
  88 } WakeupType;
  89
  90 #define EVENT_SOURCE_IS_TIME(t) IN_SET((t), SOURCE_TIME_REALTIME, SOURCE_TIME_BOOTTIME, SOURCE_TIME_MONOTONIC, SOURCE_TIME_REALTIME_ALARM, SOURCE_TIME_BOOTTIME_ALARM)
  91
  92 struct sd_event_source {
  93         WakeupType wakeup;
  94
  95         unsigned n_ref;
  96
  97         sd_event *event;
  98         void *userdata;
  99         sd_event_handler_t prepare;
 100
 101         char *description;
 102
 103         EventSourceType type:5;
 104         int enabled:3;
 105         bool pending:1;
 106         bool dispatching:1;
 107         bool floating:1;
 108
 109         int64_t priority;
 110         unsigned pending_index;
 111         unsigned prepare_index;
 112         uint64_t pending_iteration;
 113         uint64_t prepare_iteration;
 114
 115         LIST_FIELDS(sd_event_source, sources);
 116
 117         union {
 118                 struct {
 119                         sd_event_io_handler_t callback;
 120                         int fd;
 121                         uint32_t events;
 122                         uint32_t revents;
 123                         bool registered:1;
 124                 } io;
 125                 struct {
 126                         sd_event_time_handler_t callback;
 127                         usec_t next, accuracy;
 128                         unsigned earliest_index;
 129                         unsigned latest_index;
 130                 } time;
 131                 struct {
 132                         sd_event_signal_handler_t callback;
 133                         struct signalfd_siginfo siginfo;
 134                         int sig;
 135                 } signal;
 136                 struct {
 137                         sd_event_child_handler_t callback;
 138                         siginfo_t siginfo;
 139                         pid_t pid;
 140                         int options;
 141                 } child;
 142                 struct {
 143                         sd_event_handler_t callback;
 144                 } defer;
 145                 struct {
 146                         sd_event_handler_t callback;
 147                 } post;
 148                 struct {
 149                         sd_event_handler_t callback;
 150                         unsigned prioq_index;
 151                 } exit;
 152         };
 153 };
 154
 155 struct clock_data {
 156         WakeupType wakeup;
 157         int fd;
 158
 159         /* For all clocks we maintain two priority queues each, one
 160          * ordered for the earliest times the events may be
 161          * dispatched, and one ordered by the latest times they must
 162          * have been dispatched. The range between the top entries in
 163          * the two prioqs is the time window we can freely schedule
 164          * wakeups in */
 165
 166         Prioq *earliest;
 167         Prioq *latest;
 168         usec_t next;
 169
 170         bool needs_rearm:1;
 171 };
 172
 173 struct signal_data {
 174         WakeupType wakeup;
 175
 176         /* For each priority we maintain one signal fd, so that we
 177          * only have to dequeue a single event per priority at a
 178          * time. */
 179
 180         int fd;
 181         int64_t priority;
 182         sigset_t sigset;
 183         sd_event_source *current;
 184 };
 185
 186 struct sd_event {
 187         unsigned n_ref;
 188
 189         int epoll_fd;
 190         int watchdog_fd;
 191
 192         Prioq *pending;
 193         Prioq *prepare;
 194
 195         /* timerfd_create() only supports these five clocks so far. We
 196          * can add support for more clocks when the kernel learns to
 197          * deal with them, too. */
 198         struct clock_data realtime;
 199         struct clock_data boottime;
 200         struct clock_data monotonic;
 201         struct clock_data realtime_alarm;
 202         struct clock_data boottime_alarm;
 203
 204         usec_t perturb;
 205
 206         sd_event_source **signal_sources; /* indexed by signal number */
 207         Hashmap *signal_data; /* indexed by priority */
 208
 209         Hashmap *child_sources;
 210         unsigned n_enabled_child_sources;
 211
 212         Set *post_sources;
 213
 214         Prioq *exit;
 215
 216         pid_t original_pid;
 217
 218         uint64_t iteration;
 219         triple_timestamp timestamp;
 220         int state;
 221
 222         bool exit_requested:1;
 223         bool need_process_child:1;
 224         bool watchdog:1;
 225         bool profile_delays:1;
 226
 227         int exit_code;
 228
 229         pid_t tid;
 230         sd_event **default_event_ptr;
 231
 232         usec_t watchdog_last, watchdog_period;
 233
 234         unsigned n_sources;
 235
 236         LIST_HEAD(sd_event_source, sources);
 237
 238         usec_t last_run, last_log;
 239         unsigned delays[sizeof(usec_t) * 8];
 240 };
 241
 242 static void source_disconnect(sd_event_source *s);
 243
 244 static int pending_prioq_compare(const void *a, const void *b) {
 245         const sd_event_source *x = a, *y = b;
 246
 247         assert(x->pending);
 248         assert(y->pending);
 249
 250         /* Enabled ones first */
 251         if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
 252                 return -1;
 253         if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
 254                 return 1;
 255
 256         /* Lower priority values first */
 257         if (x->priority < y->priority)
 258                 return -1;
 259         if (x->priority > y->priority)
 260                 return 1;
 261
 262         /* Older entries first */
 263         if (x->pending_iteration < y->pending_iteration)
 264                 return -1;
 265         if (x->pending_iteration > y->pending_iteration)
 266                 return 1;
 267
 268         return 0;
 269 }
 270
 271 static int prepare_prioq_compare(const void *a, const void *b) {
 272         const sd_event_source *x = a, *y = b;
 273
 274         assert(x->prepare);
 275         assert(y->prepare);
 276
 277         /* Enabled ones first */
 278         if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
 279                 return -1;
 280         if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
 281                 return 1;
 282
 283         /* Move most recently prepared ones last, so that we can stop
 284          * preparing as soon as we hit one that has already been
 285          * prepared in the current iteration */
 286         if (x->prepare_iteration < y->prepare_iteration)
 287                 return -1;
 288         if (x->prepare_iteration > y->prepare_iteration)
 289                 return 1;
 290
 291         /* Lower priority values first */
 292         if (x->priority < y->priority)
 293                 return -1;
 294         if (x->priority > y->priority)
 295                 return 1;
 296
 297         return 0;
 298 }
 299
 300 static int earliest_time_prioq_compare(const void *a, const void *b) {
 301         const sd_event_source *x = a, *y = b;
 302
 303         assert(EVENT_SOURCE_IS_TIME(x->type));
 304         assert(x->type == y->type);
 305
 306         /* Enabled ones first */
 307         if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
 308                 return -1;
 309         if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
 310                 return 1;
 311
 312         /* Move the pending ones to the end */
 313         if (!x->pending && y->pending)
 314                 return -1;
 315         if (x->pending && !y->pending)
 316                 return 1;
 317
 318         /* Order by time */
 319         if (x->time.next < y->time.next)
 320                 return -1;
 321         if (x->time.next > y->time.next)
 322                 return 1;
 323
 324         return 0;
 325 }
 326
 327 static usec_t time_event_source_latest(const sd_event_source *s) {
 328         return usec_add(s->time.next, s->time.accuracy);
 329 }
 330
 331 static int latest_time_prioq_compare(const void *a, const void *b) {
 332         const sd_event_source *x = a, *y = b;
 333
 334         assert(EVENT_SOURCE_IS_TIME(x->type));
 335         assert(x->type == y->type);
 336
 337         /* Enabled ones first */
 338         if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
 339                 return -1;
 340         if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
 341                 return 1;
 342
 343         /* Move the pending ones to the end */
 344         if (!x->pending && y->pending)
 345                 return -1;
 346         if (x->pending && !y->pending)
 347                 return 1;
 348
 349         /* Order by time */
 350         if (time_event_source_latest(x) < time_event_source_latest(y))
 351                 return -1;
 352         if (time_event_source_latest(x) > time_event_source_latest(y))
 353                 return 1;
 354
 355         return 0;
 356 }
 357
 358 static int exit_prioq_compare(const void *a, const void *b) {
 359         const sd_event_source *x = a, *y = b;
 360
 361         assert(x->type == SOURCE_EXIT);
 362         assert(y->type == SOURCE_EXIT);
 363
 364         /* Enabled ones first */
 365         if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
 366                 return -1;
 367         if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
 368                 return 1;
 369
 370         /* Lower priority values first */
 371         if (x->priority < y->priority)
 372                 return -1;
 373         if (x->priority > y->priority)
 374                 return 1;
 375
 376         return 0;
 377 }
 378
 379 static void free_clock_data(struct clock_data *d) {
 380         assert(d);
 381         assert(d->wakeup == WAKEUP_CLOCK_DATA);
 382
 383         safe_close(d->fd);
 384         prioq_free(d->earliest);
 385         prioq_free(d->latest);
 386 }
 387
 388 static void event_free(sd_event *e) {
 389         sd_event_source *s;
 390
 391         assert(e);
 392
 393         while ((s = e->sources)) {
 394                 assert(s->floating);
 395                 source_disconnect(s);
 396                 sd_event_source_unref(s);
 397         }
 398
 399         assert(e->n_sources == 0);
 400
 401         if (e->default_event_ptr)
 402                 *(e->default_event_ptr) = NULL;
 403
 404         safe_close(e->epoll_fd);
 405         safe_close(e->watchdog_fd);
 406
 407         free_clock_data(&e->realtime);
 408         free_clock_data(&e->boottime);
 409         free_clock_data(&e->monotonic);
 410         free_clock_data(&e->realtime_alarm);
 411         free_clock_data(&e->boottime_alarm);
 412
 413         prioq_free(e->pending);
 414         prioq_free(e->prepare);
 415         prioq_free(e->exit);
 416
 417         free(e->signal_sources);
 418         hashmap_free(e->signal_data);
 419
 420         hashmap_free(e->child_sources);
 421         set_free(e->post_sources);
 422         free(e);
 423 }
 424
 425 _public_ int sd_event_new(sd_event** ret) {
 426         sd_event *e;
 427         int r;
 428
 429         assert_return(ret, -EINVAL);
 430
 431         e = new0(sd_event, 1);
 432         if (!e)
 433                 return -ENOMEM;
 434
 435         e->n_ref = 1;
 436         e->watchdog_fd = e->epoll_fd = e->realtime.fd = e->boottime.fd = e->monotonic.fd = e->realtime_alarm.fd = e->boottime_alarm.fd = -1;
 437         e->realtime.next = e->boottime.next = e->monotonic.next = e->realtime_alarm.next = e->boottime_alarm.next = USEC_INFINITY;
 438         e->realtime.wakeup = e->boottime.wakeup = e->monotonic.wakeup = e->realtime_alarm.wakeup = e->boottime_alarm.wakeup = WAKEUP_CLOCK_DATA;
 439         e->original_pid = getpid();
 440         e->perturb = USEC_INFINITY;
 441
 442         r = prioq_ensure_allocated(&e->pending, pending_prioq_compare);
 443         if (r < 0)
 444                 goto fail;
 445
 446         e->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
 447         if (e->epoll_fd < 0) {
 448                 r = -errno;
 449                 goto fail;
 450         }
 451
 452         if (secure_getenv("SD_EVENT_PROFILE_DELAYS")) {
 453                 log_debug("Event loop profiling enabled. Logarithmic histogram of event loop iterations in the range 2^0 ... 2^63 us will be logged every 5s.");
 454                 e->profile_delays = true;
 455         }
 456
 457         *ret = e;
 458         return 0;
 459
 460 fail:
 461         event_free(e);
 462         return r;
 463 }
 464
 465 _public_ sd_event* sd_event_ref(sd_event *e) {
 466
 467         if (!e)
 468                 return NULL;
 469
 470         assert(e->n_ref >= 1);
 471         e->n_ref++;
 472
 473         return e;
 474 }
 475
 476 _public_ sd_event* sd_event_unref(sd_event *e) {
 477
 478         if (!e)
 479                 return NULL;
 480
 481         assert(e->n_ref >= 1);
 482         e->n_ref--;
 483
 484         if (e->n_ref <= 0)
 485                 event_free(e);
 486
 487         return NULL;
 488 }
 489
 490 static bool event_pid_changed(sd_event *e) {
 491         assert(e);
 492
 493         /* We don't support people creating an event loop and keeping
 494          * it around over a fork(). Let's complain. */
 495
 496         return e->original_pid != getpid();
 497 }
 498
 499 static void source_io_unregister(sd_event_source *s) {
 500         int r;
 501
 502         assert(s);
 503         assert(s->type == SOURCE_IO);
 504
 505         if (event_pid_changed(s->event))
 506                 return;
 507
 508         if (!s->io.registered)
 509                 return;
 510
 511         r = epoll_ctl(s->event->epoll_fd, EPOLL_CTL_DEL, s->io.fd, NULL);
 512         if (r < 0)
 513                 log_debug_errno(errno, "Failed to remove source %s (type %s) from epoll: %m",
 514                                 strna(s->description), event_source_type_to_string(s->type));
 515
 516         s->io.registered = false;
 517 }
 518
 519 static int source_io_register(
 520                 sd_event_source *s,
 521                 int enabled,
 522                 uint32_t events) {
 523
 524         struct epoll_event ev = {};
 525         int r;
 526
 527         assert(s);
 528         assert(s->type == SOURCE_IO);
 529         assert(enabled != SD_EVENT_OFF);
 530
 531         ev.events = events;
 532         ev.data.ptr = s;
 533
 534         if (enabled == SD_EVENT_ONESHOT)
 535                 ev.events |= EPOLLONESHOT;
 536
 537         if (s->io.registered)
 538                 r = epoll_ctl(s->event->epoll_fd, EPOLL_CTL_MOD, s->io.fd, &ev);
 539         else
 540                 r = epoll_ctl(s->event->epoll_fd, EPOLL_CTL_ADD, s->io.fd, &ev);
 541         if (r < 0)
 542                 return -errno;
 543
 544         s->io.registered = true;
 545
 546         return 0;
 547 }
 548
 549 #if 0 /// UNNEEDED by elogind
 550 static clockid_t event_source_type_to_clock(EventSourceType t) {
 551
 552         switch (t) {
 553
 554         case SOURCE_TIME_REALTIME:
 555                 return CLOCK_REALTIME;
 556
 557         case SOURCE_TIME_BOOTTIME:
 558                 return CLOCK_BOOTTIME;
 559
 560         case SOURCE_TIME_MONOTONIC:
 561                 return CLOCK_MONOTONIC;
 562
 563         case SOURCE_TIME_REALTIME_ALARM:
 564                 return CLOCK_REALTIME_ALARM;
 565
 566         case SOURCE_TIME_BOOTTIME_ALARM:
 567                 return CLOCK_BOOTTIME_ALARM;
 568
 569         default:
 570                 return (clockid_t) -1;
 571         }
 572 }
 573 #endif // 0
 574
 575 static EventSourceType clock_to_event_source_type(clockid_t clock) {
 576
 577         switch (clock) {
 578
 579         case CLOCK_REALTIME:
 580                 return SOURCE_TIME_REALTIME;
 581
 582         case CLOCK_BOOTTIME:
 583                 return SOURCE_TIME_BOOTTIME;
 584
 585         case CLOCK_MONOTONIC:
 586                 return SOURCE_TIME_MONOTONIC;
 587
 588         case CLOCK_REALTIME_ALARM:
 589                 return SOURCE_TIME_REALTIME_ALARM;
 590
 591         case CLOCK_BOOTTIME_ALARM:
 592                 return SOURCE_TIME_BOOTTIME_ALARM;
 593
 594         default:
 595                 return _SOURCE_EVENT_SOURCE_TYPE_INVALID;
 596         }
 597 }
 598
 599 static struct clock_data* event_get_clock_data(sd_event *e, EventSourceType t) {
 600         assert(e);
 601
 602         switch (t) {
 603
 604         case SOURCE_TIME_REALTIME:
 605                 return &e->realtime;
 606
 607         case SOURCE_TIME_BOOTTIME:
 608                 return &e->boottime;
 609
 610         case SOURCE_TIME_MONOTONIC:
 611                 return &e->monotonic;
 612
 613         case SOURCE_TIME_REALTIME_ALARM:
 614                 return &e->realtime_alarm;
 615
 616         case SOURCE_TIME_BOOTTIME_ALARM:
 617                 return &e->boottime_alarm;
 618
 619         default:
 620                 return NULL;
 621         }
 622 }
 623
 624 static int event_make_signal_data(
 625                 sd_event *e,
 626                 int sig,
 627                 struct signal_data **ret) {
 628
 629         struct epoll_event ev = {};
 630         struct signal_data *d;
 631         bool added = false;
 632         sigset_t ss_copy;
 633         int64_t priority;
 634         int r;
 635
 636         assert(e);
 637
 638         if (event_pid_changed(e))
 639                 return -ECHILD;
 640
 641         if (e->signal_sources && e->signal_sources[sig])
 642                 priority = e->signal_sources[sig]->priority;
 643         else
 644                 priority = 0;
 645
 646         d = hashmap_get(e->signal_data, &priority);
 647         if (d) {
 648                 if (sigismember(&d->sigset, sig) > 0) {
 649                         if (ret)
 650                                 *ret = d;
 651                         return 0;
 652                 }
 653         } else {
 654                 r = hashmap_ensure_allocated(&e->signal_data, &uint64_hash_ops);
 655                 if (r < 0)
 656                         return r;
 657
 658                 d = new0(struct signal_data, 1);
 659                 if (!d)
 660                         return -ENOMEM;
 661
 662                 d->wakeup = WAKEUP_SIGNAL_DATA;
 663                 d->fd  = -1;
 664                 d->priority = priority;
 665
 666                 r = hashmap_put(e->signal_data, &d->priority, d);
 667                 if (r < 0) {
 668                         free(d);
 669                         return r;
 670                 }
 671
 672                 added = true;
 673         }
 674
 675         ss_copy = d->sigset;
 676         assert_se(sigaddset(&ss_copy, sig) >= 0);
 677
 678         r = signalfd(d->fd, &ss_copy, SFD_NONBLOCK|SFD_CLOEXEC);
 679         if (r < 0) {
 680                 r = -errno;
 681                 goto fail;
 682         }
 683
 684         d->sigset = ss_copy;
 685
 686         if (d->fd >= 0) {
 687                 if (ret)
 688                         *ret = d;
 689                 return 0;
 690         }
 691
 692         d->fd = r;
 693
 694         ev.events = EPOLLIN;
 695         ev.data.ptr = d;
 696
 697         r = epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, d->fd, &ev);
 698         if (r < 0)  {
 699                 r = -errno;
 700                 goto fail;
 701         }
 702
 703         if (ret)
 704                 *ret = d;
 705
 706         return 0;
 707
 708 fail:
 709         if (added) {
 710                 d->fd = safe_close(d->fd);
 711                 hashmap_remove(e->signal_data, &d->priority);
 712                 free(d);
 713         }
 714
 715         return r;
 716 }
 717
 718 static void event_unmask_signal_data(sd_event *e, struct signal_data *d, int sig) {
 719         assert(e);
 720         assert(d);
 721
 722         /* Turns off the specified signal in the signal data
 723          * object. If the signal mask of the object becomes empty that
 724          * way removes it. */
 725
 726         if (sigismember(&d->sigset, sig) == 0)
 727                 return;
 728
 729         assert_se(sigdelset(&d->sigset, sig) >= 0);
 730
 731         if (sigisemptyset(&d->sigset)) {
 732
 733                 /* If all the mask is all-zero we can get rid of the structure */
 734                 hashmap_remove(e->signal_data, &d->priority);
 735                 safe_close(d->fd);
 736                 free(d);
 737                 return;
 738         }
 739
 740         assert(d->fd >= 0);
 741
 742         if (signalfd(d->fd, &d->sigset, SFD_NONBLOCK|SFD_CLOEXEC) < 0)
 743                 log_debug_errno(errno, "Failed to unset signal bit, ignoring: %m");
 744 }
 745
 746 static void event_gc_signal_data(sd_event *e, const int64_t *priority, int sig) {
 747         struct signal_data *d;
 748         static const int64_t zero_priority = 0;
 749
 750         assert(e);
 751
 752         /* Rechecks if the specified signal is still something we are
 753          * interested in. If not, we'll unmask it, and possibly drop
 754          * the signalfd for it. */
 755
 756         if (sig == SIGCHLD &&
 757             e->n_enabled_child_sources > 0)
 758                 return;
 759
 760         if (e->signal_sources &&
 761             e->signal_sources[sig] &&
 762             e->signal_sources[sig]->enabled != SD_EVENT_OFF)
 763                 return;
 764
 765         /*
 766          * The specified signal might be enabled in three different queues:
 767          *
 768          * 1) the one that belongs to the priority passed (if it is non-NULL)
 769          * 2) the one that belongs to the priority of the event source of the signal (if there is one)
 770          * 3) the 0 priority (to cover the SIGCHLD case)
 771          *
 772          * Hence, let's remove it from all three here.
 773          */
 774
 775         if (priority) {
 776                 d = hashmap_get(e->signal_data, priority);
 777                 if (d)
 778                         event_unmask_signal_data(e, d, sig);
 779         }
 780
 781         if (e->signal_sources && e->signal_sources[sig]) {
 782                 d = hashmap_get(e->signal_data, &e->signal_sources[sig]->priority);
 783                 if (d)
 784                         event_unmask_signal_data(e, d, sig);
 785         }
 786
 787         d = hashmap_get(e->signal_data, &zero_priority);
 788         if (d)
 789                 event_unmask_signal_data(e, d, sig);
 790 }
 791
 792 static void source_disconnect(sd_event_source *s) {
 793         sd_event *event;
 794
 795         assert(s);
 796
 797         if (!s->event)
 798                 return;
 799
 800         assert(s->event->n_sources > 0);
 801
 802         switch (s->type) {
 803
 804         case SOURCE_IO:
 805                 if (s->io.fd >= 0)
 806                         source_io_unregister(s);
 807
 808                 break;
 809
 810         case SOURCE_TIME_REALTIME:
 811         case SOURCE_TIME_BOOTTIME:
 812         case SOURCE_TIME_MONOTONIC:
 813         case SOURCE_TIME_REALTIME_ALARM:
 814         case SOURCE_TIME_BOOTTIME_ALARM: {
 815                 struct clock_data *d;
 816
 817                 d = event_get_clock_data(s->event, s->type);
 818                 assert(d);
 819
 820                 prioq_remove(d->earliest, s, &s->time.earliest_index);
 821                 prioq_remove(d->latest, s, &s->time.latest_index);
 822                 d->needs_rearm = true;
 823                 break;
 824         }
 825
 826         case SOURCE_SIGNAL:
 827                 if (s->signal.sig > 0) {
 828
 829                         if (s->event->signal_sources)
 830                                 s->event->signal_sources[s->signal.sig] = NULL;
 831
 832                         event_gc_signal_data(s->event, &s->priority, s->signal.sig);
 833                 }
 834
 835                 break;
 836
 837         case SOURCE_CHILD:
 838                 if (s->child.pid > 0) {
 839                         if (s->enabled != SD_EVENT_OFF) {
 840                                 assert(s->event->n_enabled_child_sources > 0);
 841                                 s->event->n_enabled_child_sources--;
 842                         }
 843
 844                         (void) hashmap_remove(s->event->child_sources, PID_TO_PTR(s->child.pid));
 845                         event_gc_signal_data(s->event, &s->priority, SIGCHLD);
 846                 }
 847
 848                 break;
 849
 850         case SOURCE_DEFER:
 851                 /* nothing */
 852                 break;
 853
 854         case SOURCE_POST:
 855                 set_remove(s->event->post_sources, s);
 856                 break;
 857
 858         case SOURCE_EXIT:
 859                 prioq_remove(s->event->exit, s, &s->exit.prioq_index);
 860                 break;
 861
 862         default:
 863                 assert_not_reached("Wut? I shouldn't exist.");
 864         }
 865
 866         if (s->pending)
 867                 prioq_remove(s->event->pending, s, &s->pending_index);
 868
 869         if (s->prepare)
 870                 prioq_remove(s->event->prepare, s, &s->prepare_index);
 871
 872         event = s->event;
 873
 874         s->type = _SOURCE_EVENT_SOURCE_TYPE_INVALID;
 875         s->event = NULL;
 876         LIST_REMOVE(sources, event->sources, s);
 877         event->n_sources--;
 878
 879         if (!s->floating)
 880                 sd_event_unref(event);
 881 }
 882
 883 static void source_free(sd_event_source *s) {
 884         assert(s);
 885
 886         source_disconnect(s);
 887         free(s->description);
 888         free(s);
 889 }
 890
 891 static int source_set_pending(sd_event_source *s, bool b) {
 892         int r;
 893
 894         assert(s);
 895         assert(s->type != SOURCE_EXIT);
 896
 897         if (s->pending == b)
 898                 return 0;
 899
 900         s->pending = b;
 901
 902         if (b) {
 903                 s->pending_iteration = s->event->iteration;
 904
 905                 r = prioq_put(s->event->pending, s, &s->pending_index);
 906                 if (r < 0) {
 907                         s->pending = false;
 908                         return r;
 909                 }
 910         } else
 911                 assert_se(prioq_remove(s->event->pending, s, &s->pending_index));
 912
 913         if (EVENT_SOURCE_IS_TIME(s->type)) {
 914                 struct clock_data *d;
 915
 916                 d = event_get_clock_data(s->event, s->type);
 917                 assert(d);
 918
 919                 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
 920                 prioq_reshuffle(d->latest, s, &s->time.latest_index);
 921                 d->needs_rearm = true;
 922         }
 923
 924         if (s->type == SOURCE_SIGNAL && !b) {
 925                 struct signal_data *d;
 926
 927                 d = hashmap_get(s->event->signal_data, &s->priority);
 928                 if (d && d->current == s)
 929                         d->current = NULL;
 930         }
 931
 932         return 0;
 933 }
 934
 935 static sd_event_source *source_new(sd_event *e, bool floating, EventSourceType type) {
 936         sd_event_source *s;
 937
 938         assert(e);
 939
 940         s = new0(sd_event_source, 1);
 941         if (!s)
 942                 return NULL;
 943
 944         s->n_ref = 1;
 945         s->event = e;
 946         s->floating = floating;
 947         s->type = type;
 948         s->pending_index = s->prepare_index = PRIOQ_IDX_NULL;
 949
 950         if (!floating)
 951                 sd_event_ref(e);
 952
 953         LIST_PREPEND(sources, e->sources, s);
 954         e->n_sources++;
 955
 956         return s;
 957 }
 958
 959 _public_ int sd_event_add_io(
 960                 sd_event *e,
 961                 sd_event_source **ret,
 962                 int fd,
 963                 uint32_t events,
 964                 sd_event_io_handler_t callback,
 965                 void *userdata) {
 966
 967         sd_event_source *s;
 968         int r;
 969
 970         assert_return(e, -EINVAL);
 971         assert_return(fd >= 0, -EBADF);
 972         assert_return(!(events & ~(EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLPRI|EPOLLERR|EPOLLHUP|EPOLLET)), -EINVAL);
 973         assert_return(callback, -EINVAL);
 974         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
 975         assert_return(!event_pid_changed(e), -ECHILD);
 976
 977         s = source_new(e, !ret, SOURCE_IO);
 978         if (!s)
 979                 return -ENOMEM;
 980
 981         s->wakeup = WAKEUP_EVENT_SOURCE;
 982         s->io.fd = fd;
 983         s->io.events = events;
 984         s->io.callback = callback;
 985         s->userdata = userdata;
 986         s->enabled = SD_EVENT_ON;
 987
 988         r = source_io_register(s, s->enabled, events);
 989         if (r < 0) {
 990                 source_free(s);
 991                 return r;
 992         }
 993
 994         if (ret)
 995                 *ret = s;
 996
 997         return 0;
 998 }
 999
1000 static void initialize_perturb(sd_event *e) {
1001         sd_id128_t bootid = {};
1002
1003         /* When we sleep for longer, we try to realign the wakeup to
1004            the same time wihtin each minute/second/250ms, so that
1005            events all across the system can be coalesced into a single
1006            CPU wakeup. However, let's take some system-specific
1007            randomness for this value, so that in a network of systems
1008            with synced clocks timer events are distributed a
1009            bit. Here, we calculate a perturbation usec offset from the
1010            boot ID. */
1011
1012         if (_likely_(e->perturb != USEC_INFINITY))
1013                 return;
1014
1015         if (sd_id128_get_boot(&bootid) >= 0)
1016                 e->perturb = (bootid.qwords[0] ^ bootid.qwords[1]) % USEC_PER_MINUTE;
1017 }
1018
1019 static int event_setup_timer_fd(
1020                 sd_event *e,
1021                 struct clock_data *d,
1022                 clockid_t clock) {
1023
1024         struct epoll_event ev = {};
1025         int r, fd;
1026
1027         assert(e);
1028         assert(d);
1029
1030         if (_likely_(d->fd >= 0))
1031                 return 0;
1032
1033         fd = timerfd_create(clock, TFD_NONBLOCK|TFD_CLOEXEC);
1034         if (fd < 0)
1035                 return -errno;
1036
1037         ev.events = EPOLLIN;
1038         ev.data.ptr = d;
1039
1040         r = epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, fd, &ev);
1041         if (r < 0) {
1042                 safe_close(fd);
1043                 return -errno;
1044         }
1045
1046         d->fd = fd;
1047         return 0;
1048 }
1049
1050 static int time_exit_callback(sd_event_source *s, uint64_t usec, void *userdata) {
1051         assert(s);
1052
1053         return sd_event_exit(sd_event_source_get_event(s), PTR_TO_INT(userdata));
1054 }
1055
1056 _public_ int sd_event_add_time(
1057                 sd_event *e,
1058                 sd_event_source **ret,
1059                 clockid_t clock,
1060                 uint64_t usec,
1061                 uint64_t accuracy,
1062                 sd_event_time_handler_t callback,
1063                 void *userdata) {
1064
1065         EventSourceType type;
1066         sd_event_source *s;
1067         struct clock_data *d;
1068         int r;
1069
1070         assert_return(e, -EINVAL);
1071         assert_return(accuracy != (uint64_t) -1, -EINVAL);
1072         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1073         assert_return(!event_pid_changed(e), -ECHILD);
1074
1075         if (!clock_supported(clock)) /* Checks whether the kernel supports the clock */
1076                 return -EOPNOTSUPP;
1077
1078         type = clock_to_event_source_type(clock); /* checks whether sd-event supports this clock */
1079         if (type < 0)
1080                 return -EOPNOTSUPP;
1081
1082         if (!callback)
1083                 callback = time_exit_callback;
1084
1085         d = event_get_clock_data(e, type);
1086         assert(d);
1087
1088         r = prioq_ensure_allocated(&d->earliest, earliest_time_prioq_compare);
1089         if (r < 0)
1090                 return r;
1091
1092         r = prioq_ensure_allocated(&d->latest, latest_time_prioq_compare);
1093         if (r < 0)
1094                 return r;
1095
1096         if (d->fd < 0) {
1097                 r = event_setup_timer_fd(e, d, clock);
1098                 if (r < 0)
1099                         return r;
1100         }
1101
1102         s = source_new(e, !ret, type);
1103         if (!s)
1104                 return -ENOMEM;
1105
1106         s->time.next = usec;
1107         s->time.accuracy = accuracy == 0 ? DEFAULT_ACCURACY_USEC : accuracy;
1108         s->time.callback = callback;
1109         s->time.earliest_index = s->time.latest_index = PRIOQ_IDX_NULL;
1110         s->userdata = userdata;
1111         s->enabled = SD_EVENT_ONESHOT;
1112
1113         d->needs_rearm = true;
1114
1115         r = prioq_put(d->earliest, s, &s->time.earliest_index);
1116         if (r < 0)
1117                 goto fail;
1118
1119         r = prioq_put(d->latest, s, &s->time.latest_index);
1120         if (r < 0)
1121                 goto fail;
1122
1123         if (ret)
1124                 *ret = s;
1125
1126         return 0;
1127
1128 fail:
1129         source_free(s);
1130         return r;
1131 }
1132
1133 static int signal_exit_callback(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
1134         assert(s);
1135
1136         return sd_event_exit(sd_event_source_get_event(s), PTR_TO_INT(userdata));
1137 }
1138
1139 _public_ int sd_event_add_signal(
1140                 sd_event *e,
1141                 sd_event_source **ret,
1142                 int sig,
1143                 sd_event_signal_handler_t callback,
1144                 void *userdata) {
1145
1146         sd_event_source *s;
1147         struct signal_data *d;
1148         sigset_t ss;
1149         int r;
1150
1151         assert_return(e, -EINVAL);
1152         assert_return(SIGNAL_VALID(sig), -EINVAL);
1153         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1154         assert_return(!event_pid_changed(e), -ECHILD);
1155
1156         if (!callback)
1157                 callback = signal_exit_callback;
1158
1159         r = pthread_sigmask(SIG_SETMASK, NULL, &ss);
1160         if (r != 0)
1161                 return -r;
1162
1163         if (!sigismember(&ss, sig))
1164                 return -EBUSY;
1165
1166         if (!e->signal_sources) {
1167                 e->signal_sources = new0(sd_event_source*, _NSIG);
1168                 if (!e->signal_sources)
1169                         return -ENOMEM;
1170         } else if (e->signal_sources[sig])
1171                 return -EBUSY;
1172
1173         s = source_new(e, !ret, SOURCE_SIGNAL);
1174         if (!s)
1175                 return -ENOMEM;
1176
1177         s->signal.sig = sig;
1178         s->signal.callback = callback;
1179         s->userdata = userdata;
1180         s->enabled = SD_EVENT_ON;
1181
1182         e->signal_sources[sig] = s;
1183
1184         r = event_make_signal_data(e, sig, &d);
1185         if (r < 0) {
1186                 source_free(s);
1187                 return r;
1188         }
1189
1190         /* Use the signal name as description for the event source by default */
1191         (void) sd_event_source_set_description(s, signal_to_string(sig));
1192
1193         if (ret)
1194                 *ret = s;
1195
1196         return 0;
1197 }
1198
1199 _public_ int sd_event_add_child(
1200                 sd_event *e,
1201                 sd_event_source **ret,
1202                 pid_t pid,
1203                 int options,
1204                 sd_event_child_handler_t callback,
1205                 void *userdata) {
1206
1207         sd_event_source *s;
1208         int r;
1209
1210         assert_return(e, -EINVAL);
1211         assert_return(pid > 1, -EINVAL);
1212         assert_return(!(options & ~(WEXITED|WSTOPPED|WCONTINUED)), -EINVAL);
1213         assert_return(options != 0, -EINVAL);
1214         assert_return(callback, -EINVAL);
1215         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1216         assert_return(!event_pid_changed(e), -ECHILD);
1217
1218         r = hashmap_ensure_allocated(&e->child_sources, NULL);
1219         if (r < 0)
1220                 return r;
1221
1222         if (hashmap_contains(e->child_sources, PID_TO_PTR(pid)))
1223                 return -EBUSY;
1224
1225         s = source_new(e, !ret, SOURCE_CHILD);
1226         if (!s)
1227                 return -ENOMEM;
1228
1229         s->child.pid = pid;
1230         s->child.options = options;
1231         s->child.callback = callback;
1232         s->userdata = userdata;
1233         s->enabled = SD_EVENT_ONESHOT;
1234
1235         r = hashmap_put(e->child_sources, PID_TO_PTR(pid), s);
1236         if (r < 0) {
1237                 source_free(s);
1238                 return r;
1239         }
1240
1241         e->n_enabled_child_sources++;
1242
1243         r = event_make_signal_data(e, SIGCHLD, NULL);
1244         if (r < 0) {
1245                 e->n_enabled_child_sources--;
1246                 source_free(s);
1247                 return r;
1248         }
1249
1250         e->need_process_child = true;
1251
1252         if (ret)
1253                 *ret = s;
1254
1255         return 0;
1256 }
1257
1258 _public_ int sd_event_add_defer(
1259                 sd_event *e,
1260                 sd_event_source **ret,
1261                 sd_event_handler_t callback,
1262                 void *userdata) {
1263
1264         sd_event_source *s;
1265         int r;
1266
1267         assert_return(e, -EINVAL);
1268         assert_return(callback, -EINVAL);
1269         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1270         assert_return(!event_pid_changed(e), -ECHILD);
1271
1272         s = source_new(e, !ret, SOURCE_DEFER);
1273         if (!s)
1274                 return -ENOMEM;
1275
1276         s->defer.callback = callback;
1277         s->userdata = userdata;
1278         s->enabled = SD_EVENT_ONESHOT;
1279
1280         r = source_set_pending(s, true);
1281         if (r < 0) {
1282                 source_free(s);
1283                 return r;
1284         }
1285
1286         if (ret)
1287                 *ret = s;
1288
1289         return 0;
1290 }
1291
1292 _public_ int sd_event_add_post(
1293                 sd_event *e,
1294                 sd_event_source **ret,
1295                 sd_event_handler_t callback,
1296                 void *userdata) {
1297
1298         sd_event_source *s;
1299         int r;
1300
1301         assert_return(e, -EINVAL);
1302         assert_return(callback, -EINVAL);
1303         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1304         assert_return(!event_pid_changed(e), -ECHILD);
1305
1306         r = set_ensure_allocated(&e->post_sources, NULL);
1307         if (r < 0)
1308                 return r;
1309
1310         s = source_new(e, !ret, SOURCE_POST);
1311         if (!s)
1312                 return -ENOMEM;
1313
1314         s->post.callback = callback;
1315         s->userdata = userdata;
1316         s->enabled = SD_EVENT_ON;
1317
1318         r = set_put(e->post_sources, s);
1319         if (r < 0) {
1320                 source_free(s);
1321                 return r;
1322         }
1323
1324         if (ret)
1325                 *ret = s;
1326
1327         return 0;
1328 }
1329
1330 _public_ int sd_event_add_exit(
1331                 sd_event *e,
1332                 sd_event_source **ret,
1333                 sd_event_handler_t callback,
1334                 void *userdata) {
1335
1336         sd_event_source *s;
1337         int r;
1338
1339         assert_return(e, -EINVAL);
1340         assert_return(callback, -EINVAL);
1341         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1342         assert_return(!event_pid_changed(e), -ECHILD);
1343
1344         r = prioq_ensure_allocated(&e->exit, exit_prioq_compare);
1345         if (r < 0)
1346                 return r;
1347
1348         s = source_new(e, !ret, SOURCE_EXIT);
1349         if (!s)
1350                 return -ENOMEM;
1351
1352         s->exit.callback = callback;
1353         s->userdata = userdata;
1354         s->exit.prioq_index = PRIOQ_IDX_NULL;
1355         s->enabled = SD_EVENT_ONESHOT;
1356
1357         r = prioq_put(s->event->exit, s, &s->exit.prioq_index);
1358         if (r < 0) {
1359                 source_free(s);
1360                 return r;
1361         }
1362
1363         if (ret)
1364                 *ret = s;
1365
1366         return 0;
1367 }
1368
1369 #if 0 /// UNNEEDED by elogind
1370 _public_ sd_event_source* sd_event_source_ref(sd_event_source *s) {
1371
1372         if (!s)
1373                 return NULL;
1374
1375         assert(s->n_ref >= 1);
1376         s->n_ref++;
1377
1378         return s;
1379 }
1380 #endif // 0
1381
1382 _public_ sd_event_source* sd_event_source_unref(sd_event_source *s) {
1383
1384         if (!s)
1385                 return NULL;
1386
1387         assert(s->n_ref >= 1);
1388         s->n_ref--;
1389
1390         if (s->n_ref <= 0) {
1391                 /* Here's a special hack: when we are called from a
1392                  * dispatch handler we won't free the event source
1393                  * immediately, but we will detach the fd from the
1394                  * epoll. This way it is safe for the caller to unref
1395                  * the event source and immediately close the fd, but
1396                  * we still retain a valid event source object after
1397                  * the callback. */
1398
1399                 if (s->dispatching) {
1400                         if (s->type == SOURCE_IO)
1401                                 source_io_unregister(s);
1402
1403                         source_disconnect(s);
1404                 } else
1405                         source_free(s);
1406         }
1407
1408         return NULL;
1409 }
1410
1411 _public_ int sd_event_source_set_description(sd_event_source *s, const char *description) {
1412         assert_return(s, -EINVAL);
1413         assert_return(!event_pid_changed(s->event), -ECHILD);
1414
1415         return free_and_strdup(&s->description, description);
1416 }
1417
1418 #if 0 /// UNNEEDED by elogind
1419 _public_ int sd_event_source_get_description(sd_event_source *s, const char **description) {
1420         assert_return(s, -EINVAL);
1421         assert_return(description, -EINVAL);
1422         assert_return(s->description, -ENXIO);
1423         assert_return(!event_pid_changed(s->event), -ECHILD);
1424
1425         *description = s->description;
1426         return 0;
1427 }
1428 #endif // 0
1429
1430 _public_ sd_event *sd_event_source_get_event(sd_event_source *s) {
1431         assert_return(s, NULL);
1432
1433         return s->event;
1434 }
1435
1436 #if 0 /// UNNEEDED by elogind
1437 _public_ int sd_event_source_get_pending(sd_event_source *s) {
1438         assert_return(s, -EINVAL);
1439         assert_return(s->type != SOURCE_EXIT, -EDOM);
1440         assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1441         assert_return(!event_pid_changed(s->event), -ECHILD);
1442
1443         return s->pending;
1444 }
1445
1446 _public_ int sd_event_source_get_io_fd(sd_event_source *s) {
1447         assert_return(s, -EINVAL);
1448         assert_return(s->type == SOURCE_IO, -EDOM);
1449         assert_return(!event_pid_changed(s->event), -ECHILD);
1450
1451         return s->io.fd;
1452 }
1453 #endif // 0
1454
1455 _public_ int sd_event_source_set_io_fd(sd_event_source *s, int fd) {
1456         int r;
1457
1458         assert_return(s, -EINVAL);
1459         assert_return(fd >= 0, -EBADF);
1460         assert_return(s->type == SOURCE_IO, -EDOM);
1461         assert_return(!event_pid_changed(s->event), -ECHILD);
1462
1463         if (s->io.fd == fd)
1464                 return 0;
1465
1466         if (s->enabled == SD_EVENT_OFF) {
1467                 s->io.fd = fd;
1468                 s->io.registered = false;
1469         } else {
1470                 int saved_fd;
1471
1472                 saved_fd = s->io.fd;
1473                 assert(s->io.registered);
1474
1475                 s->io.fd = fd;
1476                 s->io.registered = false;
1477
1478                 r = source_io_register(s, s->enabled, s->io.events);
1479                 if (r < 0) {
1480                         s->io.fd = saved_fd;
1481                         s->io.registered = true;
1482                         return r;
1483                 }
1484
1485                 epoll_ctl(s->event->epoll_fd, EPOLL_CTL_DEL, saved_fd, NULL);
1486         }
1487
1488         return 0;
1489 }
1490
1491 #if 0 /// UNNEEDED by elogind
1492 _public_ int sd_event_source_get_io_events(sd_event_source *s, uint32_t* events) {
1493         assert_return(s, -EINVAL);
1494         assert_return(events, -EINVAL);
1495         assert_return(s->type == SOURCE_IO, -EDOM);
1496         assert_return(!event_pid_changed(s->event), -ECHILD);
1497
1498         *events = s->io.events;
1499         return 0;
1500 }
1501 #endif // 0
1502
1503 _public_ int sd_event_source_set_io_events(sd_event_source *s, uint32_t events) {
1504         int r;
1505
1506         assert_return(s, -EINVAL);
1507         assert_return(s->type == SOURCE_IO, -EDOM);
1508         assert_return(!(events & ~(EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLPRI|EPOLLERR|EPOLLHUP|EPOLLET)), -EINVAL);
1509         assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1510         assert_return(!event_pid_changed(s->event), -ECHILD);
1511
1512         /* edge-triggered updates are never skipped, so we can reset edges */
1513         if (s->io.events == events && !(events & EPOLLET))
1514                 return 0;
1515
1516         if (s->enabled != SD_EVENT_OFF) {
1517                 r = source_io_register(s, s->enabled, events);
1518                 if (r < 0)
1519                         return r;
1520         }
1521
1522         s->io.events = events;
1523         source_set_pending(s, false);
1524
1525         return 0;
1526 }
1527
1528 #if 0 /// UNNEEDED by elogind
1529 _public_ int sd_event_source_get_io_revents(sd_event_source *s, uint32_t* revents) {
1530         assert_return(s, -EINVAL);
1531         assert_return(revents, -EINVAL);
1532         assert_return(s->type == SOURCE_IO, -EDOM);
1533         assert_return(s->pending, -ENODATA);
1534         assert_return(!event_pid_changed(s->event), -ECHILD);
1535
1536         *revents = s->io.revents;
1537         return 0;
1538 }
1539
1540 _public_ int sd_event_source_get_signal(sd_event_source *s) {
1541         assert_return(s, -EINVAL);
1542         assert_return(s->type == SOURCE_SIGNAL, -EDOM);
1543         assert_return(!event_pid_changed(s->event), -ECHILD);
1544
1545         return s->signal.sig;
1546 }
1547 #endif // 0
1548
1549 _public_ int sd_event_source_get_priority(sd_event_source *s, int64_t *priority) {
1550         assert_return(s, -EINVAL);
1551         assert_return(!event_pid_changed(s->event), -ECHILD);
1552
1553         *priority = s->priority;
1554         return 0;
1555 }
1556
1557 _public_ int sd_event_source_set_priority(sd_event_source *s, int64_t priority) {
1558         int r;
1559
1560         assert_return(s, -EINVAL);
1561         assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1562         assert_return(!event_pid_changed(s->event), -ECHILD);
1563
1564         if (s->priority == priority)
1565                 return 0;
1566
1567         if (s->type == SOURCE_SIGNAL && s->enabled != SD_EVENT_OFF) {
1568                 struct signal_data *old, *d;
1569
1570                 /* Move us from the signalfd belonging to the old
1571                  * priority to the signalfd of the new priority */
1572
1573                 assert_se(old = hashmap_get(s->event->signal_data, &s->priority));
1574
1575                 s->priority = priority;
1576
1577                 r = event_make_signal_data(s->event, s->signal.sig, &d);
1578                 if (r < 0) {
1579                         s->priority = old->priority;
1580                         return r;
1581                 }
1582
1583                 event_unmask_signal_data(s->event, old, s->signal.sig);
1584         } else
1585                 s->priority = priority;
1586
1587         if (s->pending)
1588                 prioq_reshuffle(s->event->pending, s, &s->pending_index);
1589
1590         if (s->prepare)
1591                 prioq_reshuffle(s->event->prepare, s, &s->prepare_index);
1592
1593         if (s->type == SOURCE_EXIT)
1594                 prioq_reshuffle(s->event->exit, s, &s->exit.prioq_index);
1595
1596         return 0;
1597 }
1598
1599 #if 0 /// UNNEEDED by elogind
1600 _public_ int sd_event_source_get_enabled(sd_event_source *s, int *m) {
1601         assert_return(s, -EINVAL);
1602         assert_return(m, -EINVAL);
1603         assert_return(!event_pid_changed(s->event), -ECHILD);
1604
1605         *m = s->enabled;
1606         return 0;
1607 }
1608 #endif // 0
1609
1610 _public_ int sd_event_source_set_enabled(sd_event_source *s, int m) {
1611         int r;
1612
1613         assert_return(s, -EINVAL);
1614         assert_return(m == SD_EVENT_OFF || m == SD_EVENT_ON || m == SD_EVENT_ONESHOT, -EINVAL);
1615         assert_return(!event_pid_changed(s->event), -ECHILD);
1616
1617         /* If we are dead anyway, we are fine with turning off
1618          * sources, but everything else needs to fail. */
1619         if (s->event->state == SD_EVENT_FINISHED)
1620                 return m == SD_EVENT_OFF ? 0 : -ESTALE;
1621
1622         if (s->enabled == m)
1623                 return 0;
1624
1625         if (m == SD_EVENT_OFF) {
1626
1627                 switch (s->type) {
1628
1629                 case SOURCE_IO:
1630                         source_io_unregister(s);
1631                         s->enabled = m;
1632                         break;
1633
1634                 case SOURCE_TIME_REALTIME:
1635                 case SOURCE_TIME_BOOTTIME:
1636                 case SOURCE_TIME_MONOTONIC:
1637                 case SOURCE_TIME_REALTIME_ALARM:
1638                 case SOURCE_TIME_BOOTTIME_ALARM: {
1639                         struct clock_data *d;
1640
1641                         s->enabled = m;
1642                         d = event_get_clock_data(s->event, s->type);
1643                         assert(d);
1644
1645                         prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
1646                         prioq_reshuffle(d->latest, s, &s->time.latest_index);
1647                         d->needs_rearm = true;
1648                         break;
1649                 }
1650
1651                 case SOURCE_SIGNAL:
1652                         s->enabled = m;
1653
1654                         event_gc_signal_data(s->event, &s->priority, s->signal.sig);
1655                         break;
1656
1657                 case SOURCE_CHILD:
1658                         s->enabled = m;
1659
1660                         assert(s->event->n_enabled_child_sources > 0);
1661                         s->event->n_enabled_child_sources--;
1662
1663                         event_gc_signal_data(s->event, &s->priority, SIGCHLD);
1664                         break;
1665
1666                 case SOURCE_EXIT:
1667                         s->enabled = m;
1668                         prioq_reshuffle(s->event->exit, s, &s->exit.prioq_index);
1669                         break;
1670
1671                 case SOURCE_DEFER:
1672                 case SOURCE_POST:
1673                         s->enabled = m;
1674                         break;
1675
1676                 default:
1677                         assert_not_reached("Wut? I shouldn't exist.");
1678                 }
1679
1680         } else {
1681                 switch (s->type) {
1682
1683                 case SOURCE_IO:
1684                         r = source_io_register(s, m, s->io.events);
1685                         if (r < 0)
1686                                 return r;
1687
1688                         s->enabled = m;
1689                         break;
1690
1691                 case SOURCE_TIME_REALTIME:
1692                 case SOURCE_TIME_BOOTTIME:
1693                 case SOURCE_TIME_MONOTONIC:
1694                 case SOURCE_TIME_REALTIME_ALARM:
1695                 case SOURCE_TIME_BOOTTIME_ALARM: {
1696                         struct clock_data *d;
1697
1698                         s->enabled = m;
1699                         d = event_get_clock_data(s->event, s->type);
1700                         assert(d);
1701
1702                         prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
1703                         prioq_reshuffle(d->latest, s, &s->time.latest_index);
1704                         d->needs_rearm = true;
1705                         break;
1706                 }
1707
1708                 case SOURCE_SIGNAL:
1709
1710                         s->enabled = m;
1711
1712                         r = event_make_signal_data(s->event, s->signal.sig, NULL);
1713                         if (r < 0) {
1714                                 s->enabled = SD_EVENT_OFF;
1715                                 event_gc_signal_data(s->event, &s->priority, s->signal.sig);
1716                                 return r;
1717                         }
1718
1719                         break;
1720
1721                 case SOURCE_CHILD:
1722
1723                         if (s->enabled == SD_EVENT_OFF)
1724                                 s->event->n_enabled_child_sources++;
1725
1726                         s->enabled = m;
1727
1728                         r = event_make_signal_data(s->event, SIGCHLD, NULL);
1729                         if (r < 0) {
1730                                 s->enabled = SD_EVENT_OFF;
1731                                 s->event->n_enabled_child_sources--;
1732                                 event_gc_signal_data(s->event, &s->priority, SIGCHLD);
1733                                 return r;
1734                         }
1735
1736                         break;
1737
1738                 case SOURCE_EXIT:
1739                         s->enabled = m;
1740                         prioq_reshuffle(s->event->exit, s, &s->exit.prioq_index);
1741                         break;
1742
1743                 case SOURCE_DEFER:
1744                 case SOURCE_POST:
1745                         s->enabled = m;
1746                         break;
1747
1748                 default:
1749                         assert_not_reached("Wut? I shouldn't exist.");
1750                 }
1751         }
1752
1753         if (s->pending)
1754                 prioq_reshuffle(s->event->pending, s, &s->pending_index);
1755
1756         if (s->prepare)
1757                 prioq_reshuffle(s->event->prepare, s, &s->prepare_index);
1758
1759         return 0;
1760 }
1761
1762 _public_ int sd_event_source_get_time(sd_event_source *s, uint64_t *usec) {
1763         assert_return(s, -EINVAL);
1764         assert_return(usec, -EINVAL);
1765         assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1766         assert_return(!event_pid_changed(s->event), -ECHILD);
1767
1768         *usec = s->time.next;
1769         return 0;
1770 }
1771
1772 _public_ int sd_event_source_set_time(sd_event_source *s, uint64_t usec) {
1773         struct clock_data *d;
1774
1775         assert_return(s, -EINVAL);
1776         assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1777         assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1778         assert_return(!event_pid_changed(s->event), -ECHILD);
1779
1780         s->time.next = usec;
1781
1782         source_set_pending(s, false);
1783
1784         d = event_get_clock_data(s->event, s->type);
1785         assert(d);
1786
1787         prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
1788         prioq_reshuffle(d->latest, s, &s->time.latest_index);
1789         d->needs_rearm = true;
1790
1791         return 0;
1792 }
1793
1794 #if 0 /// UNNEEDED by elogind
1795 _public_ int sd_event_source_get_time_accuracy(sd_event_source *s, uint64_t *usec) {
1796         assert_return(s, -EINVAL);
1797         assert_return(usec, -EINVAL);
1798         assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1799         assert_return(!event_pid_changed(s->event), -ECHILD);
1800
1801         *usec = s->time.accuracy;
1802         return 0;
1803 }
1804
1805 _public_ int sd_event_source_set_time_accuracy(sd_event_source *s, uint64_t usec) {
1806         struct clock_data *d;
1807
1808         assert_return(s, -EINVAL);
1809         assert_return(usec != (uint64_t) -1, -EINVAL);
1810         assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1811         assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1812         assert_return(!event_pid_changed(s->event), -ECHILD);
1813
1814         if (usec == 0)
1815                 usec = DEFAULT_ACCURACY_USEC;
1816
1817         s->time.accuracy = usec;
1818
1819         source_set_pending(s, false);
1820
1821         d = event_get_clock_data(s->event, s->type);
1822         assert(d);
1823
1824         prioq_reshuffle(d->latest, s, &s->time.latest_index);
1825         d->needs_rearm = true;
1826
1827         return 0;
1828 }
1829
1830 _public_ int sd_event_source_get_time_clock(sd_event_source *s, clockid_t *clock) {
1831         assert_return(s, -EINVAL);
1832         assert_return(clock, -EINVAL);
1833         assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1834         assert_return(!event_pid_changed(s->event), -ECHILD);
1835
1836         *clock = event_source_type_to_clock(s->type);
1837         return 0;
1838 }
1839
1840 _public_ int sd_event_source_get_child_pid(sd_event_source *s, pid_t *pid) {
1841         assert_return(s, -EINVAL);
1842         assert_return(pid, -EINVAL);
1843         assert_return(s->type == SOURCE_CHILD, -EDOM);
1844         assert_return(!event_pid_changed(s->event), -ECHILD);
1845
1846         *pid = s->child.pid;
1847         return 0;
1848 }
1849 #endif // 0
1850
1851 _public_ int sd_event_source_set_prepare(sd_event_source *s, sd_event_handler_t callback) {
1852         int r;
1853
1854         assert_return(s, -EINVAL);
1855         assert_return(s->type != SOURCE_EXIT, -EDOM);
1856         assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1857         assert_return(!event_pid_changed(s->event), -ECHILD);
1858
1859         if (s->prepare == callback)
1860                 return 0;
1861
1862         if (callback && s->prepare) {
1863                 s->prepare = callback;
1864                 return 0;
1865         }
1866
1867         r = prioq_ensure_allocated(&s->event->prepare, prepare_prioq_compare);
1868         if (r < 0)
1869                 return r;
1870
1871         s->prepare = callback;
1872
1873         if (callback) {
1874                 r = prioq_put(s->event->prepare, s, &s->prepare_index);
1875                 if (r < 0)
1876                         return r;
1877         } else
1878                 prioq_remove(s->event->prepare, s, &s->prepare_index);
1879
1880         return 0;
1881 }
1882
1883 #if 0 /// UNNEEDED by elogind
1884 _public_ void* sd_event_source_get_userdata(sd_event_source *s) {
1885         assert_return(s, NULL);
1886
1887         return s->userdata;
1888 }
1889
1890 _public_ void *sd_event_source_set_userdata(sd_event_source *s, void *userdata) {
1891         void *ret;
1892
1893         assert_return(s, NULL);
1894
1895         ret = s->userdata;
1896         s->userdata = userdata;
1897
1898         return ret;
1899 }
1900 #endif // 0
1901
1902 static usec_t sleep_between(sd_event *e, usec_t a, usec_t b) {
1903         usec_t c;
1904         assert(e);
1905         assert(a <= b);
1906
1907         if (a <= 0)
1908                 return 0;
1909         if (a >= USEC_INFINITY)
1910                 return USEC_INFINITY;
1911
1912         if (b <= a + 1)
1913                 return a;
1914
1915         initialize_perturb(e);
1916
1917         /*
1918           Find a good time to wake up again between times a and b. We
1919           have two goals here:
1920
1921           a) We want to wake up as seldom as possible, hence prefer
1922              later times over earlier times.
1923
1924           b) But if we have to wake up, then let's make sure to
1925              dispatch as much as possible on the entire system.
1926
1927           We implement this by waking up everywhere at the same time
1928           within any given minute if we can, synchronised via the
1929           perturbation value determined from the boot ID. If we can't,
1930           then we try to find the same spot in every 10s, then 1s and
1931           then 250ms step. Otherwise, we pick the last possible time
1932           to wake up.
1933         */
1934
1935         c = (b / USEC_PER_MINUTE) * USEC_PER_MINUTE + e->perturb;
1936         if (c >= b) {
1937                 if (_unlikely_(c < USEC_PER_MINUTE))
1938                         return b;
1939
1940                 c -= USEC_PER_MINUTE;
1941         }
1942
1943         if (c >= a)
1944                 return c;
1945
1946         c = (b / (USEC_PER_SEC*10)) * (USEC_PER_SEC*10) + (e->perturb % (USEC_PER_SEC*10));
1947         if (c >= b) {
1948                 if (_unlikely_(c < USEC_PER_SEC*10))
1949                         return b;
1950
1951                 c -= USEC_PER_SEC*10;
1952         }
1953
1954         if (c >= a)
1955                 return c;
1956
1957         c = (b / USEC_PER_SEC) * USEC_PER_SEC + (e->perturb % USEC_PER_SEC);
1958         if (c >= b) {
1959                 if (_unlikely_(c < USEC_PER_SEC))
1960                         return b;
1961
1962                 c -= USEC_PER_SEC;
1963         }
1964
1965         if (c >= a)
1966                 return c;
1967
1968         c = (b / (USEC_PER_MSEC*250)) * (USEC_PER_MSEC*250) + (e->perturb % (USEC_PER_MSEC*250));
1969         if (c >= b) {
1970                 if (_unlikely_(c < USEC_PER_MSEC*250))
1971                         return b;
1972
1973                 c -= USEC_PER_MSEC*250;
1974         }
1975
1976         if (c >= a)
1977                 return c;
1978
1979         return b;
1980 }
1981
1982 static int event_arm_timer(
1983                 sd_event *e,
1984                 struct clock_data *d) {
1985
1986         struct itimerspec its = {};
1987         sd_event_source *a, *b;
1988         usec_t t;
1989         int r;
1990
1991         assert(e);
1992         assert(d);
1993
1994         if (!d->needs_rearm)
1995                 return 0;
1996         else
1997                 d->needs_rearm = false;
1998
1999         a = prioq_peek(d->earliest);
2000         if (!a || a->enabled == SD_EVENT_OFF || a->time.next == USEC_INFINITY) {
2001
2002                 if (d->fd < 0)
2003                         return 0;
2004
2005                 if (d->next == USEC_INFINITY)
2006                         return 0;
2007
2008                 /* disarm */
2009                 r = timerfd_settime(d->fd, TFD_TIMER_ABSTIME, &its, NULL);
2010                 if (r < 0)
2011                         return r;
2012
2013                 d->next = USEC_INFINITY;
2014                 return 0;
2015         }
2016
2017         b = prioq_peek(d->latest);
2018         assert_se(b && b->enabled != SD_EVENT_OFF);
2019
2020         t = sleep_between(e, a->time.next, time_event_source_latest(b));
2021         if (d->next == t)
2022                 return 0;
2023
2024         assert_se(d->fd >= 0);
2025
2026         if (t == 0) {
2027                 /* We don' want to disarm here, just mean some time looooong ago. */
2028                 its.it_value.tv_sec = 0;
2029                 its.it_value.tv_nsec = 1;
2030         } else
2031                 timespec_store(&its.it_value, t);
2032
2033         r = timerfd_settime(d->fd, TFD_TIMER_ABSTIME, &its, NULL);
2034         if (r < 0)
2035                 return -errno;
2036
2037         d->next = t;
2038         return 0;
2039 }
2040
2041 static int process_io(sd_event *e, sd_event_source *s, uint32_t revents) {
2042         assert(e);
2043         assert(s);
2044         assert(s->type == SOURCE_IO);
2045
2046         /* If the event source was already pending, we just OR in the
2047          * new revents, otherwise we reset the value. The ORing is
2048          * necessary to handle EPOLLONESHOT events properly where
2049          * readability might happen independently of writability, and
2050          * we need to keep track of both */
2051
2052         if (s->pending)
2053                 s->io.revents |= revents;
2054         else
2055                 s->io.revents = revents;
2056
2057         return source_set_pending(s, true);
2058 }
2059
2060 static int flush_timer(sd_event *e, int fd, uint32_t events, usec_t *next) {
2061         uint64_t x;
2062         ssize_t ss;
2063
2064         assert(e);
2065         assert(fd >= 0);
2066
2067         assert_return(events == EPOLLIN, -EIO);
2068
2069         ss = read(fd, &x, sizeof(x));
2070         if (ss < 0) {
2071                 if (errno == EAGAIN || errno == EINTR)
2072                         return 0;
2073
2074                 return -errno;
2075         }
2076
2077         if (_unlikely_(ss != sizeof(x)))
2078                 return -EIO;
2079
2080         if (next)
2081                 *next = USEC_INFINITY;
2082
2083         return 0;
2084 }
2085
2086 static int process_timer(
2087                 sd_event *e,
2088                 usec_t n,
2089                 struct clock_data *d) {
2090
2091         sd_event_source *s;
2092         int r;
2093
2094         assert(e);
2095         assert(d);
2096
2097         for (;;) {
2098                 s = prioq_peek(d->earliest);
2099                 if (!s ||
2100                     s->time.next > n ||
2101                     s->enabled == SD_EVENT_OFF ||
2102                     s->pending)
2103                         break;
2104
2105                 r = source_set_pending(s, true);
2106                 if (r < 0)
2107                         return r;
2108
2109                 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
2110                 prioq_reshuffle(d->latest, s, &s->time.latest_index);
2111                 d->needs_rearm = true;
2112         }
2113
2114         return 0;
2115 }
2116
2117 static int process_child(sd_event *e) {
2118         sd_event_source *s;
2119         Iterator i;
2120         int r;
2121
2122         assert(e);
2123
2124         e->need_process_child = false;
2125
2126         /*
2127            So, this is ugly. We iteratively invoke waitid() with P_PID
2128            + WNOHANG for each PID we wait for, instead of using
2129            P_ALL. This is because we only want to get child
2130            information of very specific child processes, and not all
2131            of them. We might not have processed the SIGCHLD even of a
2132            previous invocation and we don't want to maintain a
2133            unbounded *per-child* event queue, hence we really don't
2134            want anything flushed out of the kernel's queue that we
2135            don't care about. Since this is O(n) this means that if you
2136            have a lot of processes you probably want to handle SIGCHLD
2137            yourself.
2138
2139            We do not reap the children here (by using WNOWAIT), this
2140            is only done after the event source is dispatched so that
2141            the callback still sees the process as a zombie.
2142         */
2143
2144         HASHMAP_FOREACH(s, e->child_sources, i) {
2145                 assert(s->type == SOURCE_CHILD);
2146
2147                 if (s->pending)
2148                         continue;
2149
2150                 if (s->enabled == SD_EVENT_OFF)
2151                         continue;
2152
2153                 zero(s->child.siginfo);
2154                 r = waitid(P_PID, s->child.pid, &s->child.siginfo,
2155                            WNOHANG | (s->child.options & WEXITED ? WNOWAIT : 0) | s->child.options);
2156                 if (r < 0)
2157                         return -errno;
2158
2159                 if (s->child.siginfo.si_pid != 0) {
2160                         bool zombie =
2161                                 s->child.siginfo.si_code == CLD_EXITED ||
2162                                 s->child.siginfo.si_code == CLD_KILLED ||
2163                                 s->child.siginfo.si_code == CLD_DUMPED;
2164
2165                         if (!zombie && (s->child.options & WEXITED)) {
2166                                 /* If the child isn't dead then let's
2167                                  * immediately remove the state change
2168                                  * from the queue, since there's no
2169                                  * benefit in leaving it queued */
2170
2171                                 assert(s->child.options & (WSTOPPED|WCONTINUED));
2172                                 waitid(P_PID, s->child.pid, &s->child.siginfo, WNOHANG|(s->child.options & (WSTOPPED|WCONTINUED)));
2173                         }
2174
2175                         r = source_set_pending(s, true);
2176                         if (r < 0)
2177                                 return r;
2178                 }
2179         }
2180
2181         return 0;
2182 }
2183
2184 static int process_signal(sd_event *e, struct signal_data *d, uint32_t events) {
2185         bool read_one = false;
2186         int r;
2187
2188         assert(e);
2189         assert_return(events == EPOLLIN, -EIO);
2190
2191         /* If there's a signal queued on this priority and SIGCHLD is
2192            on this priority too, then make sure to recheck the
2193            children we watch. This is because we only ever dequeue
2194            the first signal per priority, and if we dequeue one, and
2195            SIGCHLD might be enqueued later we wouldn't know, but we
2196            might have higher priority children we care about hence we
2197            need to check that explicitly. */
2198
2199         if (sigismember(&d->sigset, SIGCHLD))
2200                 e->need_process_child = true;
2201
2202         /* If there's already an event source pending for this
2203          * priority we don't read another */
2204         if (d->current)
2205                 return 0;
2206
2207         for (;;) {
2208                 struct signalfd_siginfo si;
2209                 ssize_t n;
2210                 sd_event_source *s = NULL;
2211
2212                 n = read(d->fd, &si, sizeof(si));
2213                 if (n < 0) {
2214                         if (errno == EAGAIN || errno == EINTR)
2215                                 return read_one;
2216
2217                         return -errno;
2218                 }
2219
2220                 if (_unlikely_(n != sizeof(si)))
2221                         return -EIO;
2222
2223                 assert(SIGNAL_VALID(si.ssi_signo));
2224
2225                 read_one = true;
2226
2227                 if (e->signal_sources)
2228                         s = e->signal_sources[si.ssi_signo];
2229                 if (!s)
2230                         continue;
2231                 if (s->pending)
2232                         continue;
2233
2234                 s->signal.siginfo = si;
2235                 d->current = s;
2236
2237                 r = source_set_pending(s, true);
2238                 if (r < 0)
2239                         return r;
2240
2241                 return 1;
2242         }
2243 }
2244
2245 static int source_dispatch(sd_event_source *s) {
2246         EventSourceType saved_type;
2247         int r = 0;
2248
2249         assert(s);
2250         assert(s->pending || s->type == SOURCE_EXIT);
2251
2252         /* Save the event source type, here, so that we still know it after the event callback which might invalidate
2253          * the event. */
2254         saved_type = s->type;
2255
2256         if (s->type != SOURCE_DEFER && s->type != SOURCE_EXIT) {
2257                 r = source_set_pending(s, false);
2258                 if (r < 0)
2259                         return r;
2260         }
2261
2262         if (s->type != SOURCE_POST) {
2263                 sd_event_source *z;
2264                 Iterator i;
2265
2266                 /* If we execute a non-post source, let's mark all
2267                  * post sources as pending */
2268
2269                 SET_FOREACH(z, s->event->post_sources, i) {
2270                         if (z->enabled == SD_EVENT_OFF)
2271                                 continue;
2272
2273                         r = source_set_pending(z, true);
2274                         if (r < 0)
2275                                 return r;
2276                 }
2277         }
2278
2279         if (s->enabled == SD_EVENT_ONESHOT) {
2280                 r = sd_event_source_set_enabled(s, SD_EVENT_OFF);
2281                 if (r < 0)
2282                         return r;
2283         }
2284
2285         s->dispatching = true;
2286
2287         switch (s->type) {
2288
2289         case SOURCE_IO:
2290                 r = s->io.callback(s, s->io.fd, s->io.revents, s->userdata);
2291                 break;
2292
2293         case SOURCE_TIME_REALTIME:
2294         case SOURCE_TIME_BOOTTIME:
2295         case SOURCE_TIME_MONOTONIC:
2296         case SOURCE_TIME_REALTIME_ALARM:
2297         case SOURCE_TIME_BOOTTIME_ALARM:
2298                 r = s->time.callback(s, s->time.next, s->userdata);
2299                 break;
2300
2301         case SOURCE_SIGNAL:
2302                 r = s->signal.callback(s, &s->signal.siginfo, s->userdata);
2303                 break;
2304
2305         case SOURCE_CHILD: {
2306                 bool zombie;
2307
2308                 zombie = s->child.siginfo.si_code == CLD_EXITED ||
2309                          s->child.siginfo.si_code == CLD_KILLED ||
2310                          s->child.siginfo.si_code == CLD_DUMPED;
2311
2312                 r = s->child.callback(s, &s->child.siginfo, s->userdata);
2313
2314                 /* Now, reap the PID for good. */
2315                 if (zombie)
2316                         waitid(P_PID, s->child.pid, &s->child.siginfo, WNOHANG|WEXITED);
2317
2318                 break;
2319         }
2320
2321         case SOURCE_DEFER:
2322                 r = s->defer.callback(s, s->userdata);
2323                 break;
2324
2325         case SOURCE_POST:
2326                 r = s->post.callback(s, s->userdata);
2327                 break;
2328
2329         case SOURCE_EXIT:
2330                 r = s->exit.callback(s, s->userdata);
2331                 break;
2332
2333         case SOURCE_WATCHDOG:
2334         case _SOURCE_EVENT_SOURCE_TYPE_MAX:
2335         case _SOURCE_EVENT_SOURCE_TYPE_INVALID:
2336                 assert_not_reached("Wut? I shouldn't exist.");
2337         }
2338
2339         s->dispatching = false;
2340
2341         if (r < 0)
2342                 log_debug_errno(r, "Event source %s (type %s) returned error, disabling: %m",
2343                                 strna(s->description), event_source_type_to_string(saved_type));
2344
2345         if (s->n_ref == 0)
2346                 source_free(s);
2347         else if (r < 0)
2348                 sd_event_source_set_enabled(s, SD_EVENT_OFF);
2349
2350         return 1;
2351 }
2352
2353 static int event_prepare(sd_event *e) {
2354         int r;
2355
2356         assert(e);
2357
2358         for (;;) {
2359                 sd_event_source *s;
2360
2361                 s = prioq_peek(e->prepare);
2362                 if (!s || s->prepare_iteration == e->iteration || s->enabled == SD_EVENT_OFF)
2363                         break;
2364
2365                 s->prepare_iteration = e->iteration;
2366                 r = prioq_reshuffle(e->prepare, s, &s->prepare_index);
2367                 if (r < 0)
2368                         return r;
2369
2370                 assert(s->prepare);
2371
2372                 s->dispatching = true;
2373                 r = s->prepare(s, s->userdata);
2374                 s->dispatching = false;
2375
2376                 if (r < 0)
2377                         log_debug_errno(r, "Prepare callback of event source %s (type %s) returned error, disabling: %m",
2378                                         strna(s->description), event_source_type_to_string(s->type));
2379
2380                 if (s->n_ref == 0)
2381                         source_free(s);
2382                 else if (r < 0)
2383                         sd_event_source_set_enabled(s, SD_EVENT_OFF);
2384         }
2385
2386         return 0;
2387 }
2388
2389 static int dispatch_exit(sd_event *e) {
2390         sd_event_source *p;
2391         int r;
2392
2393         assert(e);
2394
2395         p = prioq_peek(e->exit);
2396         if (!p || p->enabled == SD_EVENT_OFF) {
2397                 e->state = SD_EVENT_FINISHED;
2398                 return 0;
2399         }
2400
2401         sd_event_ref(e);
2402         e->iteration++;
2403         e->state = SD_EVENT_EXITING;
2404
2405         r = source_dispatch(p);
2406
2407         e->state = SD_EVENT_INITIAL;
2408         sd_event_unref(e);
2409
2410         return r;
2411 }
2412
2413 static sd_event_source* event_next_pending(sd_event *e) {
2414         sd_event_source *p;
2415
2416         assert(e);
2417
2418         p = prioq_peek(e->pending);
2419         if (!p)
2420                 return NULL;
2421
2422         if (p->enabled == SD_EVENT_OFF)
2423                 return NULL;
2424
2425         return p;
2426 }
2427
2428 static int arm_watchdog(sd_event *e) {
2429         struct itimerspec its = {};
2430         usec_t t;
2431         int r;
2432
2433         assert(e);
2434         assert(e->watchdog_fd >= 0);
2435
2436         t = sleep_between(e,
2437                           e->watchdog_last + (e->watchdog_period / 2),
2438                           e->watchdog_last + (e->watchdog_period * 3 / 4));
2439
2440         timespec_store(&its.it_value, t);
2441
2442         /* Make sure we never set the watchdog to 0, which tells the
2443          * kernel to disable it. */
2444         if (its.it_value.tv_sec == 0 && its.it_value.tv_nsec == 0)
2445                 its.it_value.tv_nsec = 1;
2446
2447         r = timerfd_settime(e->watchdog_fd, TFD_TIMER_ABSTIME, &its, NULL);
2448         if (r < 0)
2449                 return -errno;
2450
2451         return 0;
2452 }
2453
2454 static int process_watchdog(sd_event *e) {
2455         assert(e);
2456
2457         if (!e->watchdog)
2458                 return 0;
2459
2460         /* Don't notify watchdog too often */
2461         if (e->watchdog_last + e->watchdog_period / 4 > e->timestamp.monotonic)
2462                 return 0;
2463
2464         sd_notify(false, "WATCHDOG=1");
2465         e->watchdog_last = e->timestamp.monotonic;
2466
2467         return arm_watchdog(e);
2468 }
2469
2470 _public_ int sd_event_prepare(sd_event *e) {
2471         int r;
2472
2473         assert_return(e, -EINVAL);
2474         assert_return(!event_pid_changed(e), -ECHILD);
2475         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2476         assert_return(e->state == SD_EVENT_INITIAL, -EBUSY);
2477
2478         if (e->exit_requested)
2479                 goto pending;
2480
2481         e->iteration++;
2482
2483         e->state = SD_EVENT_PREPARING;
2484         r = event_prepare(e);
2485         e->state = SD_EVENT_INITIAL;
2486         if (r < 0)
2487                 return r;
2488
2489         r = event_arm_timer(e, &e->realtime);
2490         if (r < 0)
2491                 return r;
2492
2493         r = event_arm_timer(e, &e->boottime);
2494         if (r < 0)
2495                 return r;
2496
2497         r = event_arm_timer(e, &e->monotonic);
2498         if (r < 0)
2499                 return r;
2500
2501         r = event_arm_timer(e, &e->realtime_alarm);
2502         if (r < 0)
2503                 return r;
2504
2505         r = event_arm_timer(e, &e->boottime_alarm);
2506         if (r < 0)
2507                 return r;
2508
2509         if (event_next_pending(e) || e->need_process_child)
2510                 goto pending;
2511
2512         e->state = SD_EVENT_ARMED;
2513
2514         return 0;
2515
2516 pending:
2517         e->state = SD_EVENT_ARMED;
2518         r = sd_event_wait(e, 0);
2519         if (r == 0)
2520                 e->state = SD_EVENT_ARMED;
2521
2522         return r;
2523 }
2524
2525 _public_ int sd_event_wait(sd_event *e, uint64_t timeout) {
2526         struct epoll_event *ev_queue;
2527         unsigned ev_queue_max;
2528         int r, m, i;
2529
2530         assert_return(e, -EINVAL);
2531         assert_return(!event_pid_changed(e), -ECHILD);
2532         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2533         assert_return(e->state == SD_EVENT_ARMED, -EBUSY);
2534
2535         if (e->exit_requested) {
2536                 e->state = SD_EVENT_PENDING;
2537                 return 1;
2538         }
2539
2540         ev_queue_max = MAX(e->n_sources, 1u);
2541         ev_queue = newa(struct epoll_event, ev_queue_max);
2542
2543         m = epoll_wait(e->epoll_fd, ev_queue, ev_queue_max,
2544                        timeout == (uint64_t) -1 ? -1 : (int) ((timeout + USEC_PER_MSEC - 1) / USEC_PER_MSEC));
2545         if (m < 0) {
2546                 if (errno == EINTR) {
2547                         e->state = SD_EVENT_PENDING;
2548                         return 1;
2549                 }
2550
2551                 r = -errno;
2552                 goto finish;
2553         }
2554
2555         triple_timestamp_get(&e->timestamp);
2556
2557         for (i = 0; i < m; i++) {
2558
2559                 if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_WATCHDOG))
2560                         r = flush_timer(e, e->watchdog_fd, ev_queue[i].events, NULL);
2561                 else {
2562                         WakeupType *t = ev_queue[i].data.ptr;
2563
2564                         switch (*t) {
2565
2566                         case WAKEUP_EVENT_SOURCE:
2567                                 r = process_io(e, ev_queue[i].data.ptr, ev_queue[i].events);
2568                                 break;
2569
2570                         case WAKEUP_CLOCK_DATA: {
2571                                 struct clock_data *d = ev_queue[i].data.ptr;
2572                                 r = flush_timer(e, d->fd, ev_queue[i].events, &d->next);
2573                                 break;
2574                         }
2575
2576                         case WAKEUP_SIGNAL_DATA:
2577                                 r = process_signal(e, ev_queue[i].data.ptr, ev_queue[i].events);
2578                                 break;
2579
2580                         default:
2581                                 assert_not_reached("Invalid wake-up pointer");
2582                         }
2583                 }
2584                 if (r < 0)
2585                         goto finish;
2586         }
2587
2588         r = process_watchdog(e);
2589         if (r < 0)
2590                 goto finish;
2591
2592         r = process_timer(e, e->timestamp.realtime, &e->realtime);
2593         if (r < 0)
2594                 goto finish;
2595
2596         r = process_timer(e, e->timestamp.boottime, &e->boottime);
2597         if (r < 0)
2598                 goto finish;
2599
2600         r = process_timer(e, e->timestamp.monotonic, &e->monotonic);
2601         if (r < 0)
2602                 goto finish;
2603
2604         r = process_timer(e, e->timestamp.realtime, &e->realtime_alarm);
2605         if (r < 0)
2606                 goto finish;
2607
2608         r = process_timer(e, e->timestamp.boottime, &e->boottime_alarm);
2609         if (r < 0)
2610                 goto finish;
2611
2612         if (e->need_process_child) {
2613                 r = process_child(e);
2614                 if (r < 0)
2615                         goto finish;
2616         }
2617
2618         if (event_next_pending(e)) {
2619                 e->state = SD_EVENT_PENDING;
2620
2621                 return 1;
2622         }
2623
2624         r = 0;
2625
2626 finish:
2627         e->state = SD_EVENT_INITIAL;
2628
2629         return r;
2630 }
2631
2632 _public_ int sd_event_dispatch(sd_event *e) {
2633         sd_event_source *p;
2634         int r;
2635
2636         assert_return(e, -EINVAL);
2637         assert_return(!event_pid_changed(e), -ECHILD);
2638         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2639         assert_return(e->state == SD_EVENT_PENDING, -EBUSY);
2640
2641         if (e->exit_requested)
2642                 return dispatch_exit(e);
2643
2644         p = event_next_pending(e);
2645         if (p) {
2646                 sd_event_ref(e);
2647
2648                 e->state = SD_EVENT_RUNNING;
2649                 r = source_dispatch(p);
2650                 e->state = SD_EVENT_INITIAL;
2651
2652                 sd_event_unref(e);
2653
2654                 return r;
2655         }
2656
2657         e->state = SD_EVENT_INITIAL;
2658
2659         return 1;
2660 }
2661
2662 static void event_log_delays(sd_event *e) {
2663         char b[ELEMENTSOF(e->delays) * DECIMAL_STR_MAX(unsigned) + 1];
2664         unsigned i;
2665         int o;
2666
2667         for (i = o = 0; i < ELEMENTSOF(e->delays); i++) {
2668                 o += snprintf(&b[o], sizeof(b) - o, "%u ", e->delays[i]);
2669                 e->delays[i] = 0;
2670         }
2671         log_debug("Event loop iterations: %.*s", o, b);
2672 }
2673
2674 _public_ int sd_event_run(sd_event *e, uint64_t timeout) {
2675         int r;
2676
2677         assert_return(e, -EINVAL);
2678         assert_return(!event_pid_changed(e), -ECHILD);
2679         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2680         assert_return(e->state == SD_EVENT_INITIAL, -EBUSY);
2681
2682         if (e->profile_delays && e->last_run) {
2683                 usec_t this_run;
2684                 unsigned l;
2685
2686                 this_run = now(CLOCK_MONOTONIC);
2687
2688                 l = u64log2(this_run - e->last_run);
2689                 assert(l < sizeof(e->delays));
2690                 e->delays[l]++;
2691
2692                 if (this_run - e->last_log >= 5*USEC_PER_SEC) {
2693                         event_log_delays(e);
2694                         e->last_log = this_run;
2695                 }
2696         }
2697
2698         r = sd_event_prepare(e);
2699         if (r == 0)
2700                 /* There was nothing? Then wait... */
2701                 r = sd_event_wait(e, timeout);
2702
2703         if (e->profile_delays)
2704                 e->last_run = now(CLOCK_MONOTONIC);
2705
2706         if (r > 0) {
2707                 /* There's something now, then let's dispatch it */
2708                 r = sd_event_dispatch(e);
2709                 if (r < 0)
2710                         return r;
2711
2712                 return 1;
2713         }
2714
2715         return r;
2716 }
2717
2718 _public_ int sd_event_loop(sd_event *e) {
2719         int r;
2720
2721         assert_return(e, -EINVAL);
2722         assert_return(!event_pid_changed(e), -ECHILD);
2723         assert_return(e->state == SD_EVENT_INITIAL, -EBUSY);
2724
2725         sd_event_ref(e);
2726
2727         while (e->state != SD_EVENT_FINISHED) {
2728                 r = sd_event_run(e, (uint64_t) -1);
2729                 if (r < 0)
2730                         goto finish;
2731         }
2732
2733         r = e->exit_code;
2734
2735 finish:
2736         sd_event_unref(e);
2737         return r;
2738 }
2739
2740 #if 0 /// UNNEEDED by elogind
2741 _public_ int sd_event_get_fd(sd_event *e) {
2742
2743         assert_return(e, -EINVAL);
2744         assert_return(!event_pid_changed(e), -ECHILD);
2745
2746         return e->epoll_fd;
2747 }
2748 #endif // 0
2749
2750 _public_ int sd_event_get_state(sd_event *e) {
2751         assert_return(e, -EINVAL);
2752         assert_return(!event_pid_changed(e), -ECHILD);
2753
2754         return e->state;
2755 }
2756
2757 #if 0 /// UNNEEDED by elogind
2758 _public_ int sd_event_get_exit_code(sd_event *e, int *code) {
2759         assert_return(e, -EINVAL);
2760         assert_return(code, -EINVAL);
2761         assert_return(!event_pid_changed(e), -ECHILD);
2762
2763         if (!e->exit_requested)
2764                 return -ENODATA;
2765
2766         *code = e->exit_code;
2767         return 0;
2768 }
2769 #endif // 0
2770
2771 _public_ int sd_event_exit(sd_event *e, int code) {
2772         assert_return(e, -EINVAL);
2773         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2774         assert_return(!event_pid_changed(e), -ECHILD);
2775
2776         e->exit_requested = true;
2777         e->exit_code = code;
2778
2779         return 0;
2780 }
2781
2782 _public_ int sd_event_now(sd_event *e, clockid_t clock, uint64_t *usec) {
2783         assert_return(e, -EINVAL);
2784         assert_return(usec, -EINVAL);
2785         assert_return(!event_pid_changed(e), -ECHILD);
2786
2787         if (!TRIPLE_TIMESTAMP_HAS_CLOCK(clock))
2788                 return -EOPNOTSUPP;
2789
2790         /* Generate a clean error in case CLOCK_BOOTTIME is not available. Note that don't use clock_supported() here,
2791          * for a reason: there are systems where CLOCK_BOOTTIME is supported, but CLOCK_BOOTTIME_ALARM is not, but for
2792          * the purpose of getting the time this doesn't matter. */
2793         if (IN_SET(clock, CLOCK_BOOTTIME, CLOCK_BOOTTIME_ALARM) && !clock_boottime_supported())
2794                 return -EOPNOTSUPP;
2795
2796         if (!triple_timestamp_is_set(&e->timestamp)) {
2797                 /* Implicitly fall back to now() if we never ran
2798                  * before and thus have no cached time. */
2799                 *usec = now(clock);
2800                 return 1;
2801         }
2802
2803         *usec = triple_timestamp_by_clock(&e->timestamp, clock);
2804         return 0;
2805 }
2806
2807 _public_ int sd_event_default(sd_event **ret) {
2808
2809         static thread_local sd_event *default_event = NULL;
2810         sd_event *e = NULL;
2811         int r;
2812
2813         if (!ret)
2814                 return !!default_event;
2815
2816         if (default_event) {
2817                 *ret = sd_event_ref(default_event);
2818                 return 0;
2819         }
2820
2821         r = sd_event_new(&e);
2822         if (r < 0)
2823                 return r;
2824
2825         e->default_event_ptr = &default_event;
2826         e->tid = gettid();
2827         default_event = e;
2828
2829         *ret = e;
2830         return 1;
2831 }
2832
2833 #if 0 /// UNNEEDED by elogind
2834 _public_ int sd_event_get_tid(sd_event *e, pid_t *tid) {
2835         assert_return(e, -EINVAL);
2836         assert_return(tid, -EINVAL);
2837         assert_return(!event_pid_changed(e), -ECHILD);
2838
2839         if (e->tid != 0) {
2840                 *tid = e->tid;
2841                 return 0;
2842         }
2843
2844         return -ENXIO;
2845 }
2846 #endif // 0
2847
2848 _public_ int sd_event_set_watchdog(sd_event *e, int b) {
2849         int r;
2850
2851         assert_return(e, -EINVAL);
2852         assert_return(!event_pid_changed(e), -ECHILD);
2853
2854         if (e->watchdog == !!b)
2855                 return e->watchdog;
2856
2857         if (b) {
2858                 struct epoll_event ev = {};
2859
2860                 r = sd_watchdog_enabled(false, &e->watchdog_period);
2861                 if (r <= 0)
2862                         return r;
2863
2864                 /* Issue first ping immediately */
2865                 sd_notify(false, "WATCHDOG=1");
2866                 e->watchdog_last = now(CLOCK_MONOTONIC);
2867
2868                 e->watchdog_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
2869                 if (e->watchdog_fd < 0)
2870                         return -errno;
2871
2872                 r = arm_watchdog(e);
2873                 if (r < 0)
2874                         goto fail;
2875
2876                 ev.events = EPOLLIN;
2877                 ev.data.ptr = INT_TO_PTR(SOURCE_WATCHDOG);
2878
2879                 r = epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, e->watchdog_fd, &ev);
2880                 if (r < 0) {
2881                         r = -errno;
2882                         goto fail;
2883                 }
2884
2885         } else {
2886                 if (e->watchdog_fd >= 0) {
2887                         epoll_ctl(e->epoll_fd, EPOLL_CTL_DEL, e->watchdog_fd, NULL);
2888                         e->watchdog_fd = safe_close(e->watchdog_fd);
2889                 }
2890         }
2891
2892         e->watchdog = !!b;
2893         return e->watchdog;
2894
2895 fail:
2896         e->watchdog_fd = safe_close(e->watchdog_fd);
2897         return r;
2898 }
2899
2900 #if 0 /// UNNEEDED by elogind
2901 _public_ int sd_event_get_watchdog(sd_event *e) {
2902         assert_return(e, -EINVAL);
2903         assert_return(!event_pid_changed(e), -ECHILD);
2904
2905         return e->watchdog;
2906 }
2907 #endif // 0
2908
2909 _public_ int sd_event_get_iteration(sd_event *e, uint64_t *ret) {
2910         assert_return(e, -EINVAL);
2911         assert_return(!event_pid_changed(e), -ECHILD);
2912
2913         *ret = e->iteration;
2914         return 0;
2915 }