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