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

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