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

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