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                 assert(!d->current);
 736                 safe_close(d->fd);
 737                 free(d);
 738                 return;
 739         }
 740
 741         assert(d->fd >= 0);
 742
 743         if (signalfd(d->fd, &d->sigset, SFD_NONBLOCK|SFD_CLOEXEC) < 0)
 744                 log_debug_errno(errno, "Failed to unset signal bit, ignoring: %m");
 745 }
 746
 747 static void event_gc_signal_data(sd_event *e, const int64_t *priority, int sig) {
 748         struct signal_data *d;
 749         static const int64_t zero_priority = 0;
 750
 751         assert(e);
 752
 753         /* Rechecks if the specified signal is still something we are
 754          * interested in. If not, we'll unmask it, and possibly drop
 755          * the signalfd for it. */
 756
 757         if (sig == SIGCHLD &&
 758             e->n_enabled_child_sources > 0)
 759                 return;
 760
 761         if (e->signal_sources &&
 762             e->signal_sources[sig] &&
 763             e->signal_sources[sig]->enabled != SD_EVENT_OFF)
 764                 return;
 765
 766         /*
 767          * The specified signal might be enabled in three different queues:
 768          *
 769          * 1) the one that belongs to the priority passed (if it is non-NULL)
 770          * 2) the one that belongs to the priority of the event source of the signal (if there is one)
 771          * 3) the 0 priority (to cover the SIGCHLD case)
 772          *
 773          * Hence, let's remove it from all three here.
 774          */
 775
 776         if (priority) {
 777                 d = hashmap_get(e->signal_data, priority);
 778                 if (d)
 779                         event_unmask_signal_data(e, d, sig);
 780         }
 781
 782         if (e->signal_sources && e->signal_sources[sig]) {
 783                 d = hashmap_get(e->signal_data, &e->signal_sources[sig]->priority);
 784                 if (d)
 785                         event_unmask_signal_data(e, d, sig);
 786         }
 787
 788         d = hashmap_get(e->signal_data, &zero_priority);
 789         if (d)
 790                 event_unmask_signal_data(e, d, sig);
 791 }
 792
 793 static void source_disconnect(sd_event_source *s) {
 794         sd_event *event;
 795
 796         assert(s);
 797
 798         if (!s->event)
 799                 return;
 800
 801         assert(s->event->n_sources > 0);
 802
 803         switch (s->type) {
 804
 805         case SOURCE_IO:
 806                 if (s->io.fd >= 0)
 807                         source_io_unregister(s);
 808
 809                 break;
 810
 811         case SOURCE_TIME_REALTIME:
 812         case SOURCE_TIME_BOOTTIME:
 813         case SOURCE_TIME_MONOTONIC:
 814         case SOURCE_TIME_REALTIME_ALARM:
 815         case SOURCE_TIME_BOOTTIME_ALARM: {
 816                 struct clock_data *d;
 817
 818                 d = event_get_clock_data(s->event, s->type);
 819                 assert(d);
 820
 821                 prioq_remove(d->earliest, s, &s->time.earliest_index);
 822                 prioq_remove(d->latest, s, &s->time.latest_index);
 823                 d->needs_rearm = true;
 824                 break;
 825         }
 826
 827         case SOURCE_SIGNAL:
 828                 if (s->signal.sig > 0) {
 829
 830                         if (s->event->signal_sources)
 831                                 s->event->signal_sources[s->signal.sig] = NULL;
 832
 833                         event_gc_signal_data(s->event, &s->priority, s->signal.sig);
 834                 }
 835
 836                 break;
 837
 838         case SOURCE_CHILD:
 839                 if (s->child.pid > 0) {
 840                         if (s->enabled != SD_EVENT_OFF) {
 841                                 assert(s->event->n_enabled_child_sources > 0);
 842                                 s->event->n_enabled_child_sources--;
 843                         }
 844
 845                         (void) hashmap_remove(s->event->child_sources, PID_TO_PTR(s->child.pid));
 846                         event_gc_signal_data(s->event, &s->priority, SIGCHLD);
 847                 }
 848
 849                 break;
 850
 851         case SOURCE_DEFER:
 852                 /* nothing */
 853                 break;
 854
 855         case SOURCE_POST:
 856                 set_remove(s->event->post_sources, s);
 857                 break;
 858
 859         case SOURCE_EXIT:
 860                 prioq_remove(s->event->exit, s, &s->exit.prioq_index);
 861                 break;
 862
 863         default:
 864                 assert_not_reached("Wut? I shouldn't exist.");
 865         }
 866
 867         if (s->pending)
 868                 prioq_remove(s->event->pending, s, &s->pending_index);
 869
 870         if (s->prepare)
 871                 prioq_remove(s->event->prepare, s, &s->prepare_index);
 872
 873         event = s->event;
 874
 875         s->type = _SOURCE_EVENT_SOURCE_TYPE_INVALID;
 876         s->event = NULL;
 877         LIST_REMOVE(sources, event->sources, s);
 878         event->n_sources--;
 879
 880         if (!s->floating)
 881                 sd_event_unref(event);
 882 }
 883
 884 static void source_free(sd_event_source *s) {
 885         assert(s);
 886
 887         source_disconnect(s);
 888         free(s->description);
 889         free(s);
 890 }
 891
 892 static int source_set_pending(sd_event_source *s, bool b) {
 893         int r;
 894
 895         assert(s);
 896         assert(s->type != SOURCE_EXIT);
 897
 898         if (s->pending == b)
 899                 return 0;
 900
 901         s->pending = b;
 902
 903         if (b) {
 904                 s->pending_iteration = s->event->iteration;
 905
 906                 r = prioq_put(s->event->pending, s, &s->pending_index);
 907                 if (r < 0) {
 908                         s->pending = false;
 909                         return r;
 910                 }
 911         } else
 912                 assert_se(prioq_remove(s->event->pending, s, &s->pending_index));
 913
 914         if (EVENT_SOURCE_IS_TIME(s->type)) {
 915                 struct clock_data *d;
 916
 917                 d = event_get_clock_data(s->event, s->type);
 918                 assert(d);
 919
 920                 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
 921                 prioq_reshuffle(d->latest, s, &s->time.latest_index);
 922                 d->needs_rearm = true;
 923         }
 924
 925         if (s->type == SOURCE_SIGNAL && !b) {
 926                 struct signal_data *d;
 927
 928                 d = hashmap_get(s->event->signal_data, &s->priority);
 929                 if (d && d->current == s)
 930                         d->current = NULL;
 931         }
 932
 933         return 0;
 934 }
 935
 936 static sd_event_source *source_new(sd_event *e, bool floating, EventSourceType type) {
 937         sd_event_source *s;
 938
 939         assert(e);
 940
 941         s = new0(sd_event_source, 1);
 942         if (!s)
 943                 return NULL;
 944
 945         s->n_ref = 1;
 946         s->event = e;
 947         s->floating = floating;
 948         s->type = type;
 949         s->pending_index = s->prepare_index = PRIOQ_IDX_NULL;
 950
 951         if (!floating)
 952                 sd_event_ref(e);
 953
 954         LIST_PREPEND(sources, e->sources, s);
 955         e->n_sources++;
 956
 957         return s;
 958 }
 959
 960 _public_ int sd_event_add_io(
 961                 sd_event *e,
 962                 sd_event_source **ret,
 963                 int fd,
 964                 uint32_t events,
 965                 sd_event_io_handler_t callback,
 966                 void *userdata) {
 967
 968         sd_event_source *s;
 969         int r;
 970
 971         assert_return(e, -EINVAL);
 972         assert_return(fd >= 0, -EBADF);
 973         assert_return(!(events & ~(EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLPRI|EPOLLERR|EPOLLHUP|EPOLLET)), -EINVAL);
 974         assert_return(callback, -EINVAL);
 975         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
 976         assert_return(!event_pid_changed(e), -ECHILD);
 977
 978         s = source_new(e, !ret, SOURCE_IO);
 979         if (!s)
 980                 return -ENOMEM;
 981
 982         s->wakeup = WAKEUP_EVENT_SOURCE;
 983         s->io.fd = fd;
 984         s->io.events = events;
 985         s->io.callback = callback;
 986         s->userdata = userdata;
 987         s->enabled = SD_EVENT_ON;
 988
 989         r = source_io_register(s, s->enabled, events);
 990         if (r < 0) {
 991                 source_free(s);
 992                 return r;
 993         }
 994
 995         if (ret)
 996                 *ret = s;
 997
 998         return 0;
 999 }
1000
1001 static void initialize_perturb(sd_event *e) {
1002         sd_id128_t bootid = {};
1003
1004         /* When we sleep for longer, we try to realign the wakeup to
1005            the same time wihtin each minute/second/250ms, so that
1006            events all across the system can be coalesced into a single
1007            CPU wakeup. However, let's take some system-specific
1008            randomness for this value, so that in a network of systems
1009            with synced clocks timer events are distributed a
1010            bit. Here, we calculate a perturbation usec offset from the
1011            boot ID. */
1012
1013         if (_likely_(e->perturb != USEC_INFINITY))
1014                 return;
1015
1016         if (sd_id128_get_boot(&bootid) >= 0)
1017                 e->perturb = (bootid.qwords[0] ^ bootid.qwords[1]) % USEC_PER_MINUTE;
1018 }
1019
1020 static int event_setup_timer_fd(
1021                 sd_event *e,
1022                 struct clock_data *d,
1023                 clockid_t clock) {
1024
1025         struct epoll_event ev = {};
1026         int r, fd;
1027
1028         assert(e);
1029         assert(d);
1030
1031         if (_likely_(d->fd >= 0))
1032                 return 0;
1033
1034         fd = timerfd_create(clock, TFD_NONBLOCK|TFD_CLOEXEC);
1035         if (fd < 0)
1036                 return -errno;
1037
1038         ev.events = EPOLLIN;
1039         ev.data.ptr = d;
1040
1041         r = epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, fd, &ev);
1042         if (r < 0) {
1043                 safe_close(fd);
1044                 return -errno;
1045         }
1046
1047         d->fd = fd;
1048         return 0;
1049 }
1050
1051 static int time_exit_callback(sd_event_source *s, uint64_t usec, void *userdata) {
1052         assert(s);
1053
1054         return sd_event_exit(sd_event_source_get_event(s), PTR_TO_INT(userdata));
1055 }
1056
1057 _public_ int sd_event_add_time(
1058                 sd_event *e,
1059                 sd_event_source **ret,
1060                 clockid_t clock,
1061                 uint64_t usec,
1062                 uint64_t accuracy,
1063                 sd_event_time_handler_t callback,
1064                 void *userdata) {
1065
1066         EventSourceType type;
1067         sd_event_source *s;
1068         struct clock_data *d;
1069         int r;
1070
1071         assert_return(e, -EINVAL);
1072         assert_return(accuracy != (uint64_t) -1, -EINVAL);
1073         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1074         assert_return(!event_pid_changed(e), -ECHILD);
1075
1076         if (!clock_supported(clock)) /* Checks whether the kernel supports the clock */
1077                 return -EOPNOTSUPP;
1078
1079         type = clock_to_event_source_type(clock); /* checks whether sd-event supports this clock */
1080         if (type < 0)
1081                 return -EOPNOTSUPP;
1082
1083         if (!callback)
1084                 callback = time_exit_callback;
1085
1086         d = event_get_clock_data(e, type);
1087         assert(d);
1088
1089         r = prioq_ensure_allocated(&d->earliest, earliest_time_prioq_compare);
1090         if (r < 0)
1091                 return r;
1092
1093         r = prioq_ensure_allocated(&d->latest, latest_time_prioq_compare);
1094         if (r < 0)
1095                 return r;
1096
1097         if (d->fd < 0) {
1098                 r = event_setup_timer_fd(e, d, clock);
1099                 if (r < 0)
1100                         return r;
1101         }
1102
1103         s = source_new(e, !ret, type);
1104         if (!s)
1105                 return -ENOMEM;
1106
1107         s->time.next = usec;
1108         s->time.accuracy = accuracy == 0 ? DEFAULT_ACCURACY_USEC : accuracy;
1109         s->time.callback = callback;
1110         s->time.earliest_index = s->time.latest_index = PRIOQ_IDX_NULL;
1111         s->userdata = userdata;
1112         s->enabled = SD_EVENT_ONESHOT;
1113
1114         d->needs_rearm = true;
1115
1116         r = prioq_put(d->earliest, s, &s->time.earliest_index);
1117         if (r < 0)
1118                 goto fail;
1119
1120         r = prioq_put(d->latest, s, &s->time.latest_index);
1121         if (r < 0)
1122                 goto fail;
1123
1124         if (ret)
1125                 *ret = s;
1126
1127         return 0;
1128
1129 fail:
1130         source_free(s);
1131         return r;
1132 }
1133
1134 static int signal_exit_callback(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
1135         assert(s);
1136
1137         return sd_event_exit(sd_event_source_get_event(s), PTR_TO_INT(userdata));
1138 }
1139
1140 _public_ int sd_event_add_signal(
1141                 sd_event *e,
1142                 sd_event_source **ret,
1143                 int sig,
1144                 sd_event_signal_handler_t callback,
1145                 void *userdata) {
1146
1147         sd_event_source *s;
1148         struct signal_data *d;
1149         sigset_t ss;
1150         int r;
1151
1152         assert_return(e, -EINVAL);
1153         assert_return(SIGNAL_VALID(sig), -EINVAL);
1154         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1155         assert_return(!event_pid_changed(e), -ECHILD);
1156
1157         if (!callback)
1158                 callback = signal_exit_callback;
1159
1160         r = pthread_sigmask(SIG_SETMASK, NULL, &ss);
1161         if (r != 0)
1162                 return -r;
1163
1164         if (!sigismember(&ss, sig))
1165                 return -EBUSY;
1166
1167         if (!e->signal_sources) {
1168                 e->signal_sources = new0(sd_event_source*, _NSIG);
1169                 if (!e->signal_sources)
1170                         return -ENOMEM;
1171         } else if (e->signal_sources[sig])
1172                 return -EBUSY;
1173
1174         s = source_new(e, !ret, SOURCE_SIGNAL);
1175         if (!s)
1176                 return -ENOMEM;
1177
1178         s->signal.sig = sig;
1179         s->signal.callback = callback;
1180         s->userdata = userdata;
1181         s->enabled = SD_EVENT_ON;
1182
1183         e->signal_sources[sig] = s;
1184
1185         r = event_make_signal_data(e, sig, &d);
1186         if (r < 0) {
1187                 source_free(s);
1188                 return r;
1189         }
1190
1191         /* Use the signal name as description for the event source by default */
1192         (void) sd_event_source_set_description(s, signal_to_string(sig));
1193
1194         if (ret)
1195                 *ret = s;
1196
1197         return 0;
1198 }
1199
1200 #if 0 /// UNNEEDED by elogind
1201 _public_ int sd_event_add_child(
1202                 sd_event *e,
1203                 sd_event_source **ret,
1204                 pid_t pid,
1205                 int options,
1206                 sd_event_child_handler_t callback,
1207                 void *userdata) {
1208
1209         sd_event_source *s;
1210         int r;
1211
1212         assert_return(e, -EINVAL);
1213         assert_return(pid > 1, -EINVAL);
1214         assert_return(!(options & ~(WEXITED|WSTOPPED|WCONTINUED)), -EINVAL);
1215         assert_return(options != 0, -EINVAL);
1216         assert_return(callback, -EINVAL);
1217         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1218         assert_return(!event_pid_changed(e), -ECHILD);
1219
1220         r = hashmap_ensure_allocated(&e->child_sources, NULL);
1221         if (r < 0)
1222                 return r;
1223
1224         if (hashmap_contains(e->child_sources, PID_TO_PTR(pid)))
1225                 return -EBUSY;
1226
1227         s = source_new(e, !ret, SOURCE_CHILD);
1228         if (!s)
1229                 return -ENOMEM;
1230
1231         s->child.pid = pid;
1232         s->child.options = options;
1233         s->child.callback = callback;
1234         s->userdata = userdata;
1235         s->enabled = SD_EVENT_ONESHOT;
1236
1237         r = hashmap_put(e->child_sources, PID_TO_PTR(pid), s);
1238         if (r < 0) {
1239                 source_free(s);
1240                 return r;
1241         }
1242
1243         e->n_enabled_child_sources++;
1244
1245         r = event_make_signal_data(e, SIGCHLD, NULL);
1246         if (r < 0) {
1247                 e->n_enabled_child_sources--;
1248                 source_free(s);
1249                 return r;
1250         }
1251
1252         e->need_process_child = true;
1253
1254         if (ret)
1255                 *ret = s;
1256
1257         return 0;
1258 }
1259
1260 _public_ int sd_event_add_defer(
1261                 sd_event *e,
1262                 sd_event_source **ret,
1263                 sd_event_handler_t callback,
1264                 void *userdata) {
1265
1266         sd_event_source *s;
1267         int r;
1268
1269         assert_return(e, -EINVAL);
1270         assert_return(callback, -EINVAL);
1271         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1272         assert_return(!event_pid_changed(e), -ECHILD);
1273
1274         s = source_new(e, !ret, SOURCE_DEFER);
1275         if (!s)
1276                 return -ENOMEM;
1277
1278         s->defer.callback = callback;
1279         s->userdata = userdata;
1280         s->enabled = SD_EVENT_ONESHOT;
1281
1282         r = source_set_pending(s, true);
1283         if (r < 0) {
1284                 source_free(s);
1285                 return r;
1286         }
1287
1288         if (ret)
1289                 *ret = s;
1290
1291         return 0;
1292 }
1293 #endif // 0
1294
1295 _public_ int sd_event_add_post(
1296                 sd_event *e,
1297                 sd_event_source **ret,
1298                 sd_event_handler_t callback,
1299                 void *userdata) {
1300
1301         sd_event_source *s;
1302         int r;
1303
1304         assert_return(e, -EINVAL);
1305         assert_return(callback, -EINVAL);
1306         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1307         assert_return(!event_pid_changed(e), -ECHILD);
1308
1309         r = set_ensure_allocated(&e->post_sources, NULL);
1310         if (r < 0)
1311                 return r;
1312
1313         s = source_new(e, !ret, SOURCE_POST);
1314         if (!s)
1315                 return -ENOMEM;
1316
1317         s->post.callback = callback;
1318         s->userdata = userdata;
1319         s->enabled = SD_EVENT_ON;
1320
1321         r = set_put(e->post_sources, s);
1322         if (r < 0) {
1323                 source_free(s);
1324                 return r;
1325         }
1326
1327         if (ret)
1328                 *ret = s;
1329
1330         return 0;
1331 }
1332
1333 _public_ int sd_event_add_exit(
1334                 sd_event *e,
1335                 sd_event_source **ret,
1336                 sd_event_handler_t callback,
1337                 void *userdata) {
1338
1339         sd_event_source *s;
1340         int r;
1341
1342         assert_return(e, -EINVAL);
1343         assert_return(callback, -EINVAL);
1344         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1345         assert_return(!event_pid_changed(e), -ECHILD);
1346
1347         r = prioq_ensure_allocated(&e->exit, exit_prioq_compare);
1348         if (r < 0)
1349                 return r;
1350
1351         s = source_new(e, !ret, SOURCE_EXIT);
1352         if (!s)
1353                 return -ENOMEM;
1354
1355         s->exit.callback = callback;
1356         s->userdata = userdata;
1357         s->exit.prioq_index = PRIOQ_IDX_NULL;
1358         s->enabled = SD_EVENT_ONESHOT;
1359
1360         r = prioq_put(s->event->exit, s, &s->exit.prioq_index);
1361         if (r < 0) {
1362                 source_free(s);
1363                 return r;
1364         }
1365
1366         if (ret)
1367                 *ret = s;
1368
1369         return 0;
1370 }
1371
1372 #if 0 /// UNNEEDED by elogind
1373 _public_ sd_event_source* sd_event_source_ref(sd_event_source *s) {
1374
1375         if (!s)
1376                 return NULL;
1377
1378         assert(s->n_ref >= 1);
1379         s->n_ref++;
1380
1381         return s;
1382 }
1383 #endif // 0
1384
1385 _public_ sd_event_source* sd_event_source_unref(sd_event_source *s) {
1386
1387         if (!s)
1388                 return NULL;
1389
1390         assert(s->n_ref >= 1);
1391         s->n_ref--;
1392
1393         if (s->n_ref <= 0) {
1394                 /* Here's a special hack: when we are called from a
1395                  * dispatch handler we won't free the event source
1396                  * immediately, but we will detach the fd from the
1397                  * epoll. This way it is safe for the caller to unref
1398                  * the event source and immediately close the fd, but
1399                  * we still retain a valid event source object after
1400                  * the callback. */
1401
1402                 if (s->dispatching) {
1403                         if (s->type == SOURCE_IO)
1404                                 source_io_unregister(s);
1405
1406                         source_disconnect(s);
1407                 } else
1408                         source_free(s);
1409         }
1410
1411         return NULL;
1412 }
1413
1414 _public_ int sd_event_source_set_description(sd_event_source *s, const char *description) {
1415         assert_return(s, -EINVAL);
1416         assert_return(!event_pid_changed(s->event), -ECHILD);
1417
1418         return free_and_strdup(&s->description, description);
1419 }
1420
1421 #if 0 /// UNNEEDED by elogind
1422 _public_ int sd_event_source_get_description(sd_event_source *s, const char **description) {
1423         assert_return(s, -EINVAL);
1424         assert_return(description, -EINVAL);
1425         assert_return(s->description, -ENXIO);
1426         assert_return(!event_pid_changed(s->event), -ECHILD);
1427
1428         *description = s->description;
1429         return 0;
1430 }
1431 #endif // 0
1432
1433 _public_ sd_event *sd_event_source_get_event(sd_event_source *s) {
1434         assert_return(s, NULL);
1435
1436         return s->event;
1437 }
1438
1439 #if 0 /// UNNEEDED by elogind
1440 _public_ int sd_event_source_get_pending(sd_event_source *s) {
1441         assert_return(s, -EINVAL);
1442         assert_return(s->type != SOURCE_EXIT, -EDOM);
1443         assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1444         assert_return(!event_pid_changed(s->event), -ECHILD);
1445
1446         return s->pending;
1447 }
1448
1449 _public_ int sd_event_source_get_io_fd(sd_event_source *s) {
1450         assert_return(s, -EINVAL);
1451         assert_return(s->type == SOURCE_IO, -EDOM);
1452         assert_return(!event_pid_changed(s->event), -ECHILD);
1453
1454         return s->io.fd;
1455 }
1456 #endif // 0
1457
1458 _public_ int sd_event_source_set_io_fd(sd_event_source *s, int fd) {
1459         int r;
1460
1461         assert_return(s, -EINVAL);
1462         assert_return(fd >= 0, -EBADF);
1463         assert_return(s->type == SOURCE_IO, -EDOM);
1464         assert_return(!event_pid_changed(s->event), -ECHILD);
1465
1466         if (s->io.fd == fd)
1467                 return 0;
1468
1469         if (s->enabled == SD_EVENT_OFF) {
1470                 s->io.fd = fd;
1471                 s->io.registered = false;
1472         } else {
1473                 int saved_fd;
1474
1475                 saved_fd = s->io.fd;
1476                 assert(s->io.registered);
1477
1478                 s->io.fd = fd;
1479                 s->io.registered = false;
1480
1481                 r = source_io_register(s, s->enabled, s->io.events);
1482                 if (r < 0) {
1483                         s->io.fd = saved_fd;
1484                         s->io.registered = true;
1485                         return r;
1486                 }
1487
1488                 epoll_ctl(s->event->epoll_fd, EPOLL_CTL_DEL, saved_fd, NULL);
1489         }
1490
1491         return 0;
1492 }
1493
1494 #if 0 /// UNNEEDED by elogind
1495 _public_ int sd_event_source_get_io_events(sd_event_source *s, uint32_t* events) {
1496         assert_return(s, -EINVAL);
1497         assert_return(events, -EINVAL);
1498         assert_return(s->type == SOURCE_IO, -EDOM);
1499         assert_return(!event_pid_changed(s->event), -ECHILD);
1500
1501         *events = s->io.events;
1502         return 0;
1503 }
1504 #endif // 0
1505
1506 _public_ int sd_event_source_set_io_events(sd_event_source *s, uint32_t events) {
1507         int r;
1508
1509         assert_return(s, -EINVAL);
1510         assert_return(s->type == SOURCE_IO, -EDOM);
1511         assert_return(!(events & ~(EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLPRI|EPOLLERR|EPOLLHUP|EPOLLET)), -EINVAL);
1512         assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1513         assert_return(!event_pid_changed(s->event), -ECHILD);
1514
1515         /* edge-triggered updates are never skipped, so we can reset edges */
1516         if (s->io.events == events && !(events & EPOLLET))
1517                 return 0;
1518
1519         if (s->enabled != SD_EVENT_OFF) {
1520                 r = source_io_register(s, s->enabled, events);
1521                 if (r < 0)
1522                         return r;
1523         }
1524
1525         s->io.events = events;
1526         source_set_pending(s, false);
1527
1528         return 0;
1529 }
1530
1531 #if 0 /// UNNEEDED by elogind
1532 _public_ int sd_event_source_get_io_revents(sd_event_source *s, uint32_t* revents) {
1533         assert_return(s, -EINVAL);
1534         assert_return(revents, -EINVAL);
1535         assert_return(s->type == SOURCE_IO, -EDOM);
1536         assert_return(s->pending, -ENODATA);
1537         assert_return(!event_pid_changed(s->event), -ECHILD);
1538
1539         *revents = s->io.revents;
1540         return 0;
1541 }
1542
1543 _public_ int sd_event_source_get_signal(sd_event_source *s) {
1544         assert_return(s, -EINVAL);
1545         assert_return(s->type == SOURCE_SIGNAL, -EDOM);
1546         assert_return(!event_pid_changed(s->event), -ECHILD);
1547
1548         return s->signal.sig;
1549 }
1550
1551 _public_ int sd_event_source_get_priority(sd_event_source *s, int64_t *priority) {
1552         assert_return(s, -EINVAL);
1553         assert_return(!event_pid_changed(s->event), -ECHILD);
1554
1555         *priority = s->priority;
1556         return 0;
1557 }
1558 #endif // 0
1559
1560 _public_ int sd_event_source_set_priority(sd_event_source *s, int64_t priority) {
1561         int r;
1562
1563         assert_return(s, -EINVAL);
1564         assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1565         assert_return(!event_pid_changed(s->event), -ECHILD);
1566
1567         if (s->priority == priority)
1568                 return 0;
1569
1570         if (s->type == SOURCE_SIGNAL && s->enabled != SD_EVENT_OFF) {
1571                 struct signal_data *old, *d;
1572
1573                 /* Move us from the signalfd belonging to the old
1574                  * priority to the signalfd of the new priority */
1575
1576                 assert_se(old = hashmap_get(s->event->signal_data, &s->priority));
1577
1578                 s->priority = priority;
1579
1580                 r = event_make_signal_data(s->event, s->signal.sig, &d);
1581                 if (r < 0) {
1582                         s->priority = old->priority;
1583                         return r;
1584                 }
1585
1586                 event_unmask_signal_data(s->event, old, s->signal.sig);
1587         } else
1588                 s->priority = priority;
1589
1590         if (s->pending)
1591                 prioq_reshuffle(s->event->pending, s, &s->pending_index);
1592
1593         if (s->prepare)
1594                 prioq_reshuffle(s->event->prepare, s, &s->prepare_index);
1595
1596         if (s->type == SOURCE_EXIT)
1597                 prioq_reshuffle(s->event->exit, s, &s->exit.prioq_index);
1598
1599         return 0;
1600 }
1601
1602 #if 0 /// UNNEEDED by elogind
1603 _public_ int sd_event_source_get_enabled(sd_event_source *s, int *m) {
1604         assert_return(s, -EINVAL);
1605         assert_return(m, -EINVAL);
1606         assert_return(!event_pid_changed(s->event), -ECHILD);
1607
1608         *m = s->enabled;
1609         return 0;
1610 }
1611 #endif // 0
1612
1613 _public_ int sd_event_source_set_enabled(sd_event_source *s, int m) {
1614         int r;
1615
1616         assert_return(s, -EINVAL);
1617         assert_return(m == SD_EVENT_OFF || m == SD_EVENT_ON || m == SD_EVENT_ONESHOT, -EINVAL);
1618         assert_return(!event_pid_changed(s->event), -ECHILD);
1619
1620         /* If we are dead anyway, we are fine with turning off
1621          * sources, but everything else needs to fail. */
1622         if (s->event->state == SD_EVENT_FINISHED)
1623                 return m == SD_EVENT_OFF ? 0 : -ESTALE;
1624
1625         if (s->enabled == m)
1626                 return 0;
1627
1628         if (m == SD_EVENT_OFF) {
1629
1630                 switch (s->type) {
1631
1632                 case SOURCE_IO:
1633                         source_io_unregister(s);
1634                         s->enabled = m;
1635                         break;
1636
1637                 case SOURCE_TIME_REALTIME:
1638                 case SOURCE_TIME_BOOTTIME:
1639                 case SOURCE_TIME_MONOTONIC:
1640                 case SOURCE_TIME_REALTIME_ALARM:
1641                 case SOURCE_TIME_BOOTTIME_ALARM: {
1642                         struct clock_data *d;
1643
1644                         s->enabled = m;
1645                         d = event_get_clock_data(s->event, s->type);
1646                         assert(d);
1647
1648                         prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
1649                         prioq_reshuffle(d->latest, s, &s->time.latest_index);
1650                         d->needs_rearm = true;
1651                         break;
1652                 }
1653
1654                 case SOURCE_SIGNAL:
1655                         s->enabled = m;
1656
1657                         event_gc_signal_data(s->event, &s->priority, s->signal.sig);
1658                         break;
1659
1660                 case SOURCE_CHILD:
1661                         s->enabled = m;
1662
1663                         assert(s->event->n_enabled_child_sources > 0);
1664                         s->event->n_enabled_child_sources--;
1665
1666                         event_gc_signal_data(s->event, &s->priority, SIGCHLD);
1667                         break;
1668
1669                 case SOURCE_EXIT:
1670                         s->enabled = m;
1671                         prioq_reshuffle(s->event->exit, s, &s->exit.prioq_index);
1672                         break;
1673
1674                 case SOURCE_DEFER:
1675                 case SOURCE_POST:
1676                         s->enabled = m;
1677                         break;
1678
1679                 default:
1680                         assert_not_reached("Wut? I shouldn't exist.");
1681                 }
1682
1683         } else {
1684                 switch (s->type) {
1685
1686                 case SOURCE_IO:
1687                         r = source_io_register(s, m, s->io.events);
1688                         if (r < 0)
1689                                 return r;
1690
1691                         s->enabled = m;
1692                         break;
1693
1694                 case SOURCE_TIME_REALTIME:
1695                 case SOURCE_TIME_BOOTTIME:
1696                 case SOURCE_TIME_MONOTONIC:
1697                 case SOURCE_TIME_REALTIME_ALARM:
1698                 case SOURCE_TIME_BOOTTIME_ALARM: {
1699                         struct clock_data *d;
1700
1701                         s->enabled = m;
1702                         d = event_get_clock_data(s->event, s->type);
1703                         assert(d);
1704
1705                         prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
1706                         prioq_reshuffle(d->latest, s, &s->time.latest_index);
1707                         d->needs_rearm = true;
1708                         break;
1709                 }
1710
1711                 case SOURCE_SIGNAL:
1712
1713                         s->enabled = m;
1714
1715                         r = event_make_signal_data(s->event, s->signal.sig, NULL);
1716                         if (r < 0) {
1717                                 s->enabled = SD_EVENT_OFF;
1718                                 event_gc_signal_data(s->event, &s->priority, s->signal.sig);
1719                                 return r;
1720                         }
1721
1722                         break;
1723
1724                 case SOURCE_CHILD:
1725
1726                         if (s->enabled == SD_EVENT_OFF)
1727                                 s->event->n_enabled_child_sources++;
1728
1729                         s->enabled = m;
1730
1731                         r = event_make_signal_data(s->event, SIGCHLD, NULL);
1732                         if (r < 0) {
1733                                 s->enabled = SD_EVENT_OFF;
1734                                 s->event->n_enabled_child_sources--;
1735                                 event_gc_signal_data(s->event, &s->priority, SIGCHLD);
1736                                 return r;
1737                         }
1738
1739                         break;
1740
1741                 case SOURCE_EXIT:
1742                         s->enabled = m;
1743                         prioq_reshuffle(s->event->exit, s, &s->exit.prioq_index);
1744                         break;
1745
1746                 case SOURCE_DEFER:
1747                 case SOURCE_POST:
1748                         s->enabled = m;
1749                         break;
1750
1751                 default:
1752                         assert_not_reached("Wut? I shouldn't exist.");
1753                 }
1754         }
1755
1756         if (s->pending)
1757                 prioq_reshuffle(s->event->pending, s, &s->pending_index);
1758
1759         if (s->prepare)
1760                 prioq_reshuffle(s->event->prepare, s, &s->prepare_index);
1761
1762         return 0;
1763 }
1764
1765 _public_ int sd_event_source_get_time(sd_event_source *s, uint64_t *usec) {
1766         assert_return(s, -EINVAL);
1767         assert_return(usec, -EINVAL);
1768         assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1769         assert_return(!event_pid_changed(s->event), -ECHILD);
1770
1771         *usec = s->time.next;
1772         return 0;
1773 }
1774
1775 _public_ int sd_event_source_set_time(sd_event_source *s, uint64_t usec) {
1776         struct clock_data *d;
1777
1778         assert_return(s, -EINVAL);
1779         assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1780         assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1781         assert_return(!event_pid_changed(s->event), -ECHILD);
1782
1783         s->time.next = usec;
1784
1785         source_set_pending(s, false);
1786
1787         d = event_get_clock_data(s->event, s->type);
1788         assert(d);
1789
1790         prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
1791         prioq_reshuffle(d->latest, s, &s->time.latest_index);
1792         d->needs_rearm = true;
1793
1794         return 0;
1795 }
1796
1797 #if 0 /// UNNEEDED by elogind
1798 _public_ int sd_event_source_get_time_accuracy(sd_event_source *s, uint64_t *usec) {
1799         assert_return(s, -EINVAL);
1800         assert_return(usec, -EINVAL);
1801         assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1802         assert_return(!event_pid_changed(s->event), -ECHILD);
1803
1804         *usec = s->time.accuracy;
1805         return 0;
1806 }
1807
1808 _public_ int sd_event_source_set_time_accuracy(sd_event_source *s, uint64_t usec) {
1809         struct clock_data *d;
1810
1811         assert_return(s, -EINVAL);
1812         assert_return(usec != (uint64_t) -1, -EINVAL);
1813         assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1814         assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1815         assert_return(!event_pid_changed(s->event), -ECHILD);
1816
1817         if (usec == 0)
1818                 usec = DEFAULT_ACCURACY_USEC;
1819
1820         s->time.accuracy = usec;
1821
1822         source_set_pending(s, false);
1823
1824         d = event_get_clock_data(s->event, s->type);
1825         assert(d);
1826
1827         prioq_reshuffle(d->latest, s, &s->time.latest_index);
1828         d->needs_rearm = true;
1829
1830         return 0;
1831 }
1832
1833 _public_ int sd_event_source_get_time_clock(sd_event_source *s, clockid_t *clock) {
1834         assert_return(s, -EINVAL);
1835         assert_return(clock, -EINVAL);
1836         assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1837         assert_return(!event_pid_changed(s->event), -ECHILD);
1838
1839         *clock = event_source_type_to_clock(s->type);
1840         return 0;
1841 }
1842
1843 _public_ int sd_event_source_get_child_pid(sd_event_source *s, pid_t *pid) {
1844         assert_return(s, -EINVAL);
1845         assert_return(pid, -EINVAL);
1846         assert_return(s->type == SOURCE_CHILD, -EDOM);
1847         assert_return(!event_pid_changed(s->event), -ECHILD);
1848
1849         *pid = s->child.pid;
1850         return 0;
1851 }
1852 #endif // 0
1853
1854 _public_ int sd_event_source_set_prepare(sd_event_source *s, sd_event_handler_t callback) {
1855         int r;
1856
1857         assert_return(s, -EINVAL);
1858         assert_return(s->type != SOURCE_EXIT, -EDOM);
1859         assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1860         assert_return(!event_pid_changed(s->event), -ECHILD);
1861
1862         if (s->prepare == callback)
1863                 return 0;
1864
1865         if (callback && s->prepare) {
1866                 s->prepare = callback;
1867                 return 0;
1868         }
1869
1870         r = prioq_ensure_allocated(&s->event->prepare, prepare_prioq_compare);
1871         if (r < 0)
1872                 return r;
1873
1874         s->prepare = callback;
1875
1876         if (callback) {
1877                 r = prioq_put(s->event->prepare, s, &s->prepare_index);
1878                 if (r < 0)
1879                         return r;
1880         } else
1881                 prioq_remove(s->event->prepare, s, &s->prepare_index);
1882
1883         return 0;
1884 }
1885
1886 #if 0 /// UNNEEDED by elogind
1887 _public_ void* sd_event_source_get_userdata(sd_event_source *s) {
1888         assert_return(s, NULL);
1889
1890         return s->userdata;
1891 }
1892
1893 _public_ void *sd_event_source_set_userdata(sd_event_source *s, void *userdata) {
1894         void *ret;
1895
1896         assert_return(s, NULL);
1897
1898         ret = s->userdata;
1899         s->userdata = userdata;
1900
1901         return ret;
1902 }
1903 #endif // 0
1904
1905 static usec_t sleep_between(sd_event *e, usec_t a, usec_t b) {
1906         usec_t c;
1907         assert(e);
1908         assert(a <= b);
1909
1910         if (a <= 0)
1911                 return 0;
1912         if (a >= USEC_INFINITY)
1913                 return USEC_INFINITY;
1914
1915         if (b <= a + 1)
1916                 return a;
1917
1918         initialize_perturb(e);
1919
1920         /*
1921           Find a good time to wake up again between times a and b. We
1922           have two goals here:
1923
1924           a) We want to wake up as seldom as possible, hence prefer
1925              later times over earlier times.
1926
1927           b) But if we have to wake up, then let's make sure to
1928              dispatch as much as possible on the entire system.
1929
1930           We implement this by waking up everywhere at the same time
1931           within any given minute if we can, synchronised via the
1932           perturbation value determined from the boot ID. If we can't,
1933           then we try to find the same spot in every 10s, then 1s and
1934           then 250ms step. Otherwise, we pick the last possible time
1935           to wake up.
1936         */
1937
1938         c = (b / USEC_PER_MINUTE) * USEC_PER_MINUTE + e->perturb;
1939         if (c >= b) {
1940                 if (_unlikely_(c < USEC_PER_MINUTE))
1941                         return b;
1942
1943                 c -= USEC_PER_MINUTE;
1944         }
1945
1946         if (c >= a)
1947                 return c;
1948
1949         c = (b / (USEC_PER_SEC*10)) * (USEC_PER_SEC*10) + (e->perturb % (USEC_PER_SEC*10));
1950         if (c >= b) {
1951                 if (_unlikely_(c < USEC_PER_SEC*10))
1952                         return b;
1953
1954                 c -= USEC_PER_SEC*10;
1955         }
1956
1957         if (c >= a)
1958                 return c;
1959
1960         c = (b / USEC_PER_SEC) * USEC_PER_SEC + (e->perturb % USEC_PER_SEC);
1961         if (c >= b) {
1962                 if (_unlikely_(c < USEC_PER_SEC))
1963                         return b;
1964
1965                 c -= USEC_PER_SEC;
1966         }
1967
1968         if (c >= a)
1969                 return c;
1970
1971         c = (b / (USEC_PER_MSEC*250)) * (USEC_PER_MSEC*250) + (e->perturb % (USEC_PER_MSEC*250));
1972         if (c >= b) {
1973                 if (_unlikely_(c < USEC_PER_MSEC*250))
1974                         return b;
1975
1976                 c -= USEC_PER_MSEC*250;
1977         }
1978
1979         if (c >= a)
1980                 return c;
1981
1982         return b;
1983 }
1984
1985 static int event_arm_timer(
1986                 sd_event *e,
1987                 struct clock_data *d) {
1988
1989         struct itimerspec its = {};
1990         sd_event_source *a, *b;
1991         usec_t t;
1992         int r;
1993
1994         assert(e);
1995         assert(d);
1996
1997         if (!d->needs_rearm)
1998                 return 0;
1999         else
2000                 d->needs_rearm = false;
2001
2002         a = prioq_peek(d->earliest);
2003         if (!a || a->enabled == SD_EVENT_OFF || a->time.next == USEC_INFINITY) {
2004
2005                 if (d->fd < 0)
2006                         return 0;
2007
2008                 if (d->next == USEC_INFINITY)
2009                         return 0;
2010
2011                 /* disarm */
2012                 r = timerfd_settime(d->fd, TFD_TIMER_ABSTIME, &its, NULL);
2013                 if (r < 0)
2014                         return r;
2015
2016                 d->next = USEC_INFINITY;
2017                 return 0;
2018         }
2019
2020         b = prioq_peek(d->latest);
2021         assert_se(b && b->enabled != SD_EVENT_OFF);
2022
2023         t = sleep_between(e, a->time.next, time_event_source_latest(b));
2024         if (d->next == t)
2025                 return 0;
2026
2027         assert_se(d->fd >= 0);
2028
2029         if (t == 0) {
2030                 /* We don' want to disarm here, just mean some time looooong ago. */
2031                 its.it_value.tv_sec = 0;
2032                 its.it_value.tv_nsec = 1;
2033         } else
2034                 timespec_store(&its.it_value, t);
2035
2036         r = timerfd_settime(d->fd, TFD_TIMER_ABSTIME, &its, NULL);
2037         if (r < 0)
2038                 return -errno;
2039
2040         d->next = t;
2041         return 0;
2042 }
2043
2044 static int process_io(sd_event *e, sd_event_source *s, uint32_t revents) {
2045         assert(e);
2046         assert(s);
2047         assert(s->type == SOURCE_IO);
2048
2049         /* If the event source was already pending, we just OR in the
2050          * new revents, otherwise we reset the value. The ORing is
2051          * necessary to handle EPOLLONESHOT events properly where
2052          * readability might happen independently of writability, and
2053          * we need to keep track of both */
2054
2055         if (s->pending)
2056                 s->io.revents |= revents;
2057         else
2058                 s->io.revents = revents;
2059
2060         return source_set_pending(s, true);
2061 }
2062
2063 static int flush_timer(sd_event *e, int fd, uint32_t events, usec_t *next) {
2064         uint64_t x;
2065         ssize_t ss;
2066
2067         assert(e);
2068         assert(fd >= 0);
2069
2070         assert_return(events == EPOLLIN, -EIO);
2071
2072         ss = read(fd, &x, sizeof(x));
2073         if (ss < 0) {
2074                 if (errno == EAGAIN || errno == EINTR)
2075                         return 0;
2076
2077                 return -errno;
2078         }
2079
2080         if (_unlikely_(ss != sizeof(x)))
2081                 return -EIO;
2082
2083         if (next)
2084                 *next = USEC_INFINITY;
2085
2086         return 0;
2087 }
2088
2089 static int process_timer(
2090                 sd_event *e,
2091                 usec_t n,
2092                 struct clock_data *d) {
2093
2094         sd_event_source *s;
2095         int r;
2096
2097         assert(e);
2098         assert(d);
2099
2100         for (;;) {
2101                 s = prioq_peek(d->earliest);
2102                 if (!s ||
2103                     s->time.next > n ||
2104                     s->enabled == SD_EVENT_OFF ||
2105                     s->pending)
2106                         break;
2107
2108                 r = source_set_pending(s, true);
2109                 if (r < 0)
2110                         return r;
2111
2112                 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
2113                 prioq_reshuffle(d->latest, s, &s->time.latest_index);
2114                 d->needs_rearm = true;
2115         }
2116
2117         return 0;
2118 }
2119
2120 static int process_child(sd_event *e) {
2121         sd_event_source *s;
2122         Iterator i;
2123         int r;
2124
2125         assert(e);
2126
2127         e->need_process_child = false;
2128
2129         /*
2130            So, this is ugly. We iteratively invoke waitid() with P_PID
2131            + WNOHANG for each PID we wait for, instead of using
2132            P_ALL. This is because we only want to get child
2133            information of very specific child processes, and not all
2134            of them. We might not have processed the SIGCHLD even of a
2135            previous invocation and we don't want to maintain a
2136            unbounded *per-child* event queue, hence we really don't
2137            want anything flushed out of the kernel's queue that we
2138            don't care about. Since this is O(n) this means that if you
2139            have a lot of processes you probably want to handle SIGCHLD
2140            yourself.
2141
2142            We do not reap the children here (by using WNOWAIT), this
2143            is only done after the event source is dispatched so that
2144            the callback still sees the process as a zombie.
2145         */
2146
2147         HASHMAP_FOREACH(s, e->child_sources, i) {
2148                 assert(s->type == SOURCE_CHILD);
2149
2150                 if (s->pending)
2151                         continue;
2152
2153                 if (s->enabled == SD_EVENT_OFF)
2154                         continue;
2155
2156                 zero(s->child.siginfo);
2157                 r = waitid(P_PID, s->child.pid, &s->child.siginfo,
2158                            WNOHANG | (s->child.options & WEXITED ? WNOWAIT : 0) | s->child.options);
2159                 if (r < 0)
2160                         return -errno;
2161
2162                 if (s->child.siginfo.si_pid != 0) {
2163                         bool zombie =
2164                                 s->child.siginfo.si_code == CLD_EXITED ||
2165                                 s->child.siginfo.si_code == CLD_KILLED ||
2166                                 s->child.siginfo.si_code == CLD_DUMPED;
2167
2168                         if (!zombie && (s->child.options & WEXITED)) {
2169                                 /* If the child isn't dead then let's
2170                                  * immediately remove the state change
2171                                  * from the queue, since there's no
2172                                  * benefit in leaving it queued */
2173
2174                                 assert(s->child.options & (WSTOPPED|WCONTINUED));
2175                                 waitid(P_PID, s->child.pid, &s->child.siginfo, WNOHANG|(s->child.options & (WSTOPPED|WCONTINUED)));
2176                         }
2177
2178                         r = source_set_pending(s, true);
2179                         if (r < 0)
2180                                 return r;
2181                 }
2182         }
2183
2184         return 0;
2185 }
2186
2187 static int process_signal(sd_event *e, struct signal_data *d, uint32_t events) {
2188         bool read_one = false;
2189         int r;
2190
2191         assert(e);
2192         assert_return(events == EPOLLIN, -EIO);
2193
2194         /* If there's a signal queued on this priority and SIGCHLD is
2195            on this priority too, then make sure to recheck the
2196            children we watch. This is because we only ever dequeue
2197            the first signal per priority, and if we dequeue one, and
2198            SIGCHLD might be enqueued later we wouldn't know, but we
2199            might have higher priority children we care about hence we
2200            need to check that explicitly. */
2201
2202         if (sigismember(&d->sigset, SIGCHLD))
2203                 e->need_process_child = true;
2204
2205         /* If there's already an event source pending for this
2206          * priority we don't read another */
2207         if (d->current)
2208                 return 0;
2209
2210         for (;;) {
2211                 struct signalfd_siginfo si;
2212                 ssize_t n;
2213                 sd_event_source *s = NULL;
2214
2215                 n = read(d->fd, &si, sizeof(si));
2216                 if (n < 0) {
2217                         if (errno == EAGAIN || errno == EINTR)
2218                                 return read_one;
2219
2220                         return -errno;
2221                 }
2222
2223                 if (_unlikely_(n != sizeof(si)))
2224                         return -EIO;
2225
2226                 assert(SIGNAL_VALID(si.ssi_signo));
2227
2228                 read_one = true;
2229
2230                 if (e->signal_sources)
2231                         s = e->signal_sources[si.ssi_signo];
2232                 if (!s)
2233                         continue;
2234                 if (s->pending)
2235                         continue;
2236
2237                 s->signal.siginfo = si;
2238                 d->current = s;
2239
2240                 r = source_set_pending(s, true);
2241                 if (r < 0)
2242                         return r;
2243
2244                 return 1;
2245         }
2246 }
2247
2248 static int source_dispatch(sd_event_source *s) {
2249         int r = 0;
2250
2251         assert(s);
2252         assert(s->pending || s->type == SOURCE_EXIT);
2253
2254         if (s->type != SOURCE_DEFER && s->type != SOURCE_EXIT) {
2255                 r = source_set_pending(s, false);
2256                 if (r < 0)
2257                         return r;
2258         }
2259
2260         if (s->type != SOURCE_POST) {
2261                 sd_event_source *z;
2262                 Iterator i;
2263
2264                 /* If we execute a non-post source, let's mark all
2265                  * post sources as pending */
2266
2267                 SET_FOREACH(z, s->event->post_sources, i) {
2268                         if (z->enabled == SD_EVENT_OFF)
2269                                 continue;
2270
2271                         r = source_set_pending(z, true);
2272                         if (r < 0)
2273                                 return r;
2274                 }
2275         }
2276
2277         if (s->enabled == SD_EVENT_ONESHOT) {
2278                 r = sd_event_source_set_enabled(s, SD_EVENT_OFF);
2279                 if (r < 0)
2280                         return r;
2281         }
2282
2283         s->dispatching = true;
2284
2285         switch (s->type) {
2286
2287         case SOURCE_IO:
2288                 r = s->io.callback(s, s->io.fd, s->io.revents, s->userdata);
2289                 break;
2290
2291         case SOURCE_TIME_REALTIME:
2292         case SOURCE_TIME_BOOTTIME:
2293         case SOURCE_TIME_MONOTONIC:
2294         case SOURCE_TIME_REALTIME_ALARM:
2295         case SOURCE_TIME_BOOTTIME_ALARM:
2296                 r = s->time.callback(s, s->time.next, s->userdata);
2297                 break;
2298
2299         case SOURCE_SIGNAL:
2300                 r = s->signal.callback(s, &s->signal.siginfo, s->userdata);
2301                 break;
2302
2303         case SOURCE_CHILD: {
2304                 bool zombie;
2305
2306                 zombie = s->child.siginfo.si_code == CLD_EXITED ||
2307                          s->child.siginfo.si_code == CLD_KILLED ||
2308                          s->child.siginfo.si_code == CLD_DUMPED;
2309
2310                 r = s->child.callback(s, &s->child.siginfo, s->userdata);
2311
2312                 /* Now, reap the PID for good. */
2313                 if (zombie)
2314                         waitid(P_PID, s->child.pid, &s->child.siginfo, WNOHANG|WEXITED);
2315
2316                 break;
2317         }
2318
2319         case SOURCE_DEFER:
2320                 r = s->defer.callback(s, s->userdata);
2321                 break;
2322
2323         case SOURCE_POST:
2324                 r = s->post.callback(s, s->userdata);
2325                 break;
2326
2327         case SOURCE_EXIT:
2328                 r = s->exit.callback(s, s->userdata);
2329                 break;
2330
2331         case SOURCE_WATCHDOG:
2332         case _SOURCE_EVENT_SOURCE_TYPE_MAX:
2333         case _SOURCE_EVENT_SOURCE_TYPE_INVALID:
2334                 assert_not_reached("Wut? I shouldn't exist.");
2335         }
2336
2337         s->dispatching = false;
2338
2339         if (r < 0)
2340                 log_debug_errno(r, "Event source %s (type %s) returned error, disabling: %m",
2341                                 strna(s->description), event_source_type_to_string(s->type));
2342
2343         if (s->n_ref == 0)
2344                 source_free(s);
2345         else if (r < 0)
2346                 sd_event_source_set_enabled(s, SD_EVENT_OFF);
2347
2348         return 1;
2349 }
2350
2351 static int event_prepare(sd_event *e) {
2352         int r;
2353
2354         assert(e);
2355
2356         for (;;) {
2357                 sd_event_source *s;
2358
2359                 s = prioq_peek(e->prepare);
2360                 if (!s || s->prepare_iteration == e->iteration || s->enabled == SD_EVENT_OFF)
2361                         break;
2362
2363                 s->prepare_iteration = e->iteration;
2364                 r = prioq_reshuffle(e->prepare, s, &s->prepare_index);
2365                 if (r < 0)
2366                         return r;
2367
2368                 assert(s->prepare);
2369
2370                 s->dispatching = true;
2371                 r = s->prepare(s, s->userdata);
2372                 s->dispatching = false;
2373
2374                 if (r < 0)
2375                         log_debug_errno(r, "Prepare callback of event source %s (type %s) returned error, disabling: %m",
2376                                         strna(s->description), event_source_type_to_string(s->type));
2377
2378                 if (s->n_ref == 0)
2379                         source_free(s);
2380                 else if (r < 0)
2381                         sd_event_source_set_enabled(s, SD_EVENT_OFF);
2382         }
2383
2384         return 0;
2385 }
2386
2387 static int dispatch_exit(sd_event *e) {
2388         sd_event_source *p;
2389         int r;
2390
2391         assert(e);
2392
2393         p = prioq_peek(e->exit);
2394         if (!p || p->enabled == SD_EVENT_OFF) {
2395                 e->state = SD_EVENT_FINISHED;
2396                 return 0;
2397         }
2398
2399         sd_event_ref(e);
2400         e->iteration++;
2401         e->state = SD_EVENT_EXITING;
2402
2403         r = source_dispatch(p);
2404
2405         e->state = SD_EVENT_INITIAL;
2406         sd_event_unref(e);
2407
2408         return r;
2409 }
2410
2411 static sd_event_source* event_next_pending(sd_event *e) {
2412         sd_event_source *p;
2413
2414         assert(e);
2415
2416         p = prioq_peek(e->pending);
2417         if (!p)
2418                 return NULL;
2419
2420         if (p->enabled == SD_EVENT_OFF)
2421                 return NULL;
2422
2423         return p;
2424 }
2425
2426 static int arm_watchdog(sd_event *e) {
2427         struct itimerspec its = {};
2428         usec_t t;
2429         int r;
2430
2431         assert(e);
2432         assert(e->watchdog_fd >= 0);
2433
2434         t = sleep_between(e,
2435                           e->watchdog_last + (e->watchdog_period / 2),
2436                           e->watchdog_last + (e->watchdog_period * 3 / 4));
2437
2438         timespec_store(&its.it_value, t);
2439
2440         /* Make sure we never set the watchdog to 0, which tells the
2441          * kernel to disable it. */
2442         if (its.it_value.tv_sec == 0 && its.it_value.tv_nsec == 0)
2443                 its.it_value.tv_nsec = 1;
2444
2445         r = timerfd_settime(e->watchdog_fd, TFD_TIMER_ABSTIME, &its, NULL);
2446         if (r < 0)
2447                 return -errno;
2448
2449         return 0;
2450 }
2451
2452 static int process_watchdog(sd_event *e) {
2453         assert(e);
2454
2455         if (!e->watchdog)
2456                 return 0;
2457
2458         /* Don't notify watchdog too often */
2459         if (e->watchdog_last + e->watchdog_period / 4 > e->timestamp.monotonic)
2460                 return 0;
2461
2462         sd_notify(false, "WATCHDOG=1");
2463         e->watchdog_last = e->timestamp.monotonic;
2464
2465         return arm_watchdog(e);
2466 }
2467
2468 _public_ int sd_event_prepare(sd_event *e) {
2469         int r;
2470
2471         assert_return(e, -EINVAL);
2472         assert_return(!event_pid_changed(e), -ECHILD);
2473         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2474         assert_return(e->state == SD_EVENT_INITIAL, -EBUSY);
2475
2476         if (e->exit_requested)
2477                 goto pending;
2478
2479         e->iteration++;
2480
2481         e->state = SD_EVENT_PREPARING;
2482         r = event_prepare(e);
2483         e->state = SD_EVENT_INITIAL;
2484         if (r < 0)
2485                 return r;
2486
2487         r = event_arm_timer(e, &e->realtime);
2488         if (r < 0)
2489                 return r;
2490
2491         r = event_arm_timer(e, &e->boottime);
2492         if (r < 0)
2493                 return r;
2494
2495         r = event_arm_timer(e, &e->monotonic);
2496         if (r < 0)
2497                 return r;
2498
2499         r = event_arm_timer(e, &e->realtime_alarm);
2500         if (r < 0)
2501                 return r;
2502
2503         r = event_arm_timer(e, &e->boottime_alarm);
2504         if (r < 0)
2505                 return r;
2506
2507         if (event_next_pending(e) || e->need_process_child)
2508                 goto pending;
2509
2510         e->state = SD_EVENT_ARMED;
2511
2512         return 0;
2513
2514 pending:
2515         e->state = SD_EVENT_ARMED;
2516         r = sd_event_wait(e, 0);
2517         if (r == 0)
2518                 e->state = SD_EVENT_ARMED;
2519
2520         return r;
2521 }
2522
2523 _public_ int sd_event_wait(sd_event *e, uint64_t timeout) {
2524         struct epoll_event *ev_queue;
2525         unsigned ev_queue_max;
2526         int r, m, i;
2527
2528         assert_return(e, -EINVAL);
2529         assert_return(!event_pid_changed(e), -ECHILD);
2530         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2531         assert_return(e->state == SD_EVENT_ARMED, -EBUSY);
2532
2533         if (e->exit_requested) {
2534                 e->state = SD_EVENT_PENDING;
2535                 return 1;
2536         }
2537
2538         ev_queue_max = MAX(e->n_sources, 1u);
2539         ev_queue = newa(struct epoll_event, ev_queue_max);
2540
2541         m = epoll_wait(e->epoll_fd, ev_queue, ev_queue_max,
2542                        timeout == (uint64_t) -1 ? -1 : (int) ((timeout + USEC_PER_MSEC - 1) / USEC_PER_MSEC));
2543         if (m < 0) {
2544                 if (errno == EINTR) {
2545                         e->state = SD_EVENT_PENDING;
2546                         return 1;
2547                 }
2548
2549                 r = -errno;
2550                 goto finish;
2551         }
2552
2553         triple_timestamp_get(&e->timestamp);
2554
2555         for (i = 0; i < m; i++) {
2556
2557                 if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_WATCHDOG))
2558                         r = flush_timer(e, e->watchdog_fd, ev_queue[i].events, NULL);
2559                 else {
2560                         WakeupType *t = ev_queue[i].data.ptr;
2561
2562                         switch (*t) {
2563
2564                         case WAKEUP_EVENT_SOURCE:
2565                                 r = process_io(e, ev_queue[i].data.ptr, ev_queue[i].events);
2566                                 break;
2567
2568                         case WAKEUP_CLOCK_DATA: {
2569                                 struct clock_data *d = ev_queue[i].data.ptr;
2570                                 r = flush_timer(e, d->fd, ev_queue[i].events, &d->next);
2571                                 break;
2572                         }
2573
2574                         case WAKEUP_SIGNAL_DATA:
2575                                 r = process_signal(e, ev_queue[i].data.ptr, ev_queue[i].events);
2576                                 break;
2577
2578                         default:
2579                                 assert_not_reached("Invalid wake-up pointer");
2580                         }
2581                 }
2582                 if (r < 0)
2583                         goto finish;
2584         }
2585
2586         r = process_watchdog(e);
2587         if (r < 0)
2588                 goto finish;
2589
2590         r = process_timer(e, e->timestamp.realtime, &e->realtime);
2591         if (r < 0)
2592                 goto finish;
2593
2594         r = process_timer(e, e->timestamp.boottime, &e->boottime);
2595         if (r < 0)
2596                 goto finish;
2597
2598         r = process_timer(e, e->timestamp.monotonic, &e->monotonic);
2599         if (r < 0)
2600                 goto finish;
2601
2602         r = process_timer(e, e->timestamp.realtime, &e->realtime_alarm);
2603         if (r < 0)
2604                 goto finish;
2605
2606         r = process_timer(e, e->timestamp.boottime, &e->boottime_alarm);
2607         if (r < 0)
2608                 goto finish;
2609
2610         if (e->need_process_child) {
2611                 r = process_child(e);
2612                 if (r < 0)
2613                         goto finish;
2614         }
2615
2616         if (event_next_pending(e)) {
2617                 e->state = SD_EVENT_PENDING;
2618
2619                 return 1;
2620         }
2621
2622         r = 0;
2623
2624 finish:
2625         e->state = SD_EVENT_INITIAL;
2626
2627         return r;
2628 }
2629
2630 _public_ int sd_event_dispatch(sd_event *e) {
2631         sd_event_source *p;
2632         int r;
2633
2634         assert_return(e, -EINVAL);
2635         assert_return(!event_pid_changed(e), -ECHILD);
2636         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2637         assert_return(e->state == SD_EVENT_PENDING, -EBUSY);
2638
2639         if (e->exit_requested)
2640                 return dispatch_exit(e);
2641
2642         p = event_next_pending(e);
2643         if (p) {
2644                 sd_event_ref(e);
2645
2646                 e->state = SD_EVENT_RUNNING;
2647                 r = source_dispatch(p);
2648                 e->state = SD_EVENT_INITIAL;
2649
2650                 sd_event_unref(e);
2651
2652                 return r;
2653         }
2654
2655         e->state = SD_EVENT_INITIAL;
2656
2657         return 1;
2658 }
2659
2660 static void event_log_delays(sd_event *e) {
2661         char b[ELEMENTSOF(e->delays) * DECIMAL_STR_MAX(unsigned) + 1];
2662         unsigned i;
2663         int o;
2664
2665         for (i = o = 0; i < ELEMENTSOF(e->delays); i++) {
2666                 o += snprintf(&b[o], sizeof(b) - o, "%u ", e->delays[i]);
2667                 e->delays[i] = 0;
2668         }
2669         log_debug("Event loop iterations: %.*s", o, b);
2670 }
2671
2672 _public_ int sd_event_run(sd_event *e, uint64_t timeout) {
2673         int r;
2674
2675         assert_return(e, -EINVAL);
2676         assert_return(!event_pid_changed(e), -ECHILD);
2677         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2678         assert_return(e->state == SD_EVENT_INITIAL, -EBUSY);
2679
2680         if (e->profile_delays && e->last_run) {
2681                 usec_t this_run;
2682                 unsigned l;
2683
2684                 this_run = now(CLOCK_MONOTONIC);
2685
2686                 l = u64log2(this_run - e->last_run);
2687                 assert(l < sizeof(e->delays));
2688                 e->delays[l]++;
2689
2690                 if (this_run - e->last_log >= 5*USEC_PER_SEC) {
2691                         event_log_delays(e);
2692                         e->last_log = this_run;
2693                 }
2694         }
2695
2696         r = sd_event_prepare(e);
2697         if (r == 0)
2698                 /* There was nothing? Then wait... */
2699                 r = sd_event_wait(e, timeout);
2700
2701         if (e->profile_delays)
2702                 e->last_run = now(CLOCK_MONOTONIC);
2703
2704         if (r > 0) {
2705                 /* There's something now, then let's dispatch it */
2706                 r = sd_event_dispatch(e);
2707                 if (r < 0)
2708                         return r;
2709
2710                 return 1;
2711         }
2712
2713         return r;
2714 }
2715
2716 #if 0 /// UNNEEDED by elogind
2717 _public_ int sd_event_loop(sd_event *e) {
2718         int r;
2719
2720         assert_return(e, -EINVAL);
2721         assert_return(!event_pid_changed(e), -ECHILD);
2722         assert_return(e->state == SD_EVENT_INITIAL, -EBUSY);
2723
2724         sd_event_ref(e);
2725
2726         while (e->state != SD_EVENT_FINISHED) {
2727                 r = sd_event_run(e, (uint64_t) -1);
2728                 if (r < 0)
2729                         goto finish;
2730         }
2731
2732         r = e->exit_code;
2733
2734 finish:
2735         sd_event_unref(e);
2736         return r;
2737 }
2738
2739 _public_ int sd_event_get_fd(sd_event *e) {
2740
2741         assert_return(e, -EINVAL);
2742         assert_return(!event_pid_changed(e), -ECHILD);
2743
2744         return e->epoll_fd;
2745 }
2746 #endif // 0
2747
2748 _public_ int sd_event_get_state(sd_event *e) {
2749         assert_return(e, -EINVAL);
2750         assert_return(!event_pid_changed(e), -ECHILD);
2751
2752         return e->state;
2753 }
2754
2755 #if 0 /// UNNEEDED by elogind
2756 _public_ int sd_event_get_exit_code(sd_event *e, int *code) {
2757         assert_return(e, -EINVAL);
2758         assert_return(code, -EINVAL);
2759         assert_return(!event_pid_changed(e), -ECHILD);
2760
2761         if (!e->exit_requested)
2762                 return -ENODATA;
2763
2764         *code = e->exit_code;
2765         return 0;
2766 }
2767 #endif // 0
2768
2769 _public_ int sd_event_exit(sd_event *e, int code) {
2770         assert_return(e, -EINVAL);
2771         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2772         assert_return(!event_pid_changed(e), -ECHILD);
2773
2774         e->exit_requested = true;
2775         e->exit_code = code;
2776
2777         return 0;
2778 }
2779
2780 #if 0 /// UNNEEDED by elogind
2781 _public_ int sd_event_now(sd_event *e, clockid_t clock, uint64_t *usec) {
2782         assert_return(e, -EINVAL);
2783         assert_return(usec, -EINVAL);
2784         assert_return(!event_pid_changed(e), -ECHILD);
2785
2786         if (!TRIPLE_TIMESTAMP_HAS_CLOCK(clock))
2787                 return -EOPNOTSUPP;
2788
2789         /* Generate a clean error in case CLOCK_BOOTTIME is not available. Note that don't use clock_supported() here,
2790          * for a reason: there are systems where CLOCK_BOOTTIME is supported, but CLOCK_BOOTTIME_ALARM is not, but for
2791          * the purpose of getting the time this doesn't matter. */
2792         if (IN_SET(clock, CLOCK_BOOTTIME, CLOCK_BOOTTIME_ALARM) && !clock_boottime_supported())
2793                 return -EOPNOTSUPP;
2794
2795         if (!triple_timestamp_is_set(&e->timestamp)) {
2796                 /* Implicitly fall back to now() if we never ran
2797                  * before and thus have no cached time. */
2798                 *usec = now(clock);
2799                 return 1;
2800         }
2801
2802         *usec = triple_timestamp_by_clock(&e->timestamp, clock);
2803         return 0;
2804 }
2805 #endif // 0
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 }