1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Lennart Poettering
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.
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.
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/>.
22 #include <sys/epoll.h>
23 #include <sys/timerfd.h>
28 #include "sd-daemon.h"
33 #include "time-util.h"
40 #define EPOLL_QUEUE_MAX 512U
41 #define DEFAULT_ACCURACY_USEC (250 * USEC_PER_MSEC)
43 typedef enum EventSourceType {
47 SOURCE_TIME_MONOTONIC,
48 SOURCE_TIME_REALTIME_ALARM,
49 SOURCE_TIME_BOOTTIME_ALARM,
56 _SOURCE_EVENT_SOURCE_TYPE_MAX,
57 _SOURCE_EVENT_SOURCE_TYPE_INVALID = -1
60 #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)
62 struct sd_event_source {
67 sd_event_handler_t prepare;
71 EventSourceType type:5;
78 unsigned pending_index;
79 unsigned prepare_index;
80 unsigned pending_iteration;
81 unsigned prepare_iteration;
83 LIST_FIELDS(sd_event_source, sources);
87 sd_event_io_handler_t callback;
94 sd_event_time_handler_t callback;
95 usec_t next, accuracy;
96 unsigned earliest_index;
97 unsigned latest_index;
100 sd_event_signal_handler_t callback;
101 struct signalfd_siginfo siginfo;
105 sd_event_child_handler_t callback;
111 sd_event_handler_t callback;
114 sd_event_handler_t callback;
117 sd_event_handler_t callback;
118 unsigned prioq_index;
126 /* For all clocks we maintain two priority queues each, one
127 * ordered for the earliest times the events may be
128 * dispatched, and one ordered by the latest times they must
129 * have been dispatched. The range between the top entries in
130 * the two prioqs is the time window we can freely schedule
150 /* timerfd_create() only supports these five clocks so far. We
151 * can add support for more clocks when the kernel learns to
152 * deal with them, too. */
153 struct clock_data realtime;
154 struct clock_data boottime;
155 struct clock_data monotonic;
156 struct clock_data realtime_alarm;
157 struct clock_data boottime_alarm;
162 sd_event_source **signal_sources;
164 Hashmap *child_sources;
165 unsigned n_enabled_child_sources;
174 dual_timestamp timestamp;
175 usec_t timestamp_boottime;
178 bool exit_requested:1;
179 bool need_process_child:1;
185 sd_event **default_event_ptr;
187 usec_t watchdog_last, watchdog_period;
191 LIST_HEAD(sd_event_source, sources);
194 static void source_disconnect(sd_event_source *s);
196 static int pending_prioq_compare(const void *a, const void *b) {
197 const sd_event_source *x = a, *y = b;
202 /* Enabled ones first */
203 if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
205 if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
208 /* Lower priority values first */
209 if (x->priority < y->priority)
211 if (x->priority > y->priority)
214 /* Older entries first */
215 if (x->pending_iteration < y->pending_iteration)
217 if (x->pending_iteration > y->pending_iteration)
220 /* Stability for the rest */
229 static int prepare_prioq_compare(const void *a, const void *b) {
230 const sd_event_source *x = a, *y = b;
235 /* Move most recently prepared ones last, so that we can stop
236 * preparing as soon as we hit one that has already been
237 * prepared in the current iteration */
238 if (x->prepare_iteration < y->prepare_iteration)
240 if (x->prepare_iteration > y->prepare_iteration)
243 /* Enabled ones first */
244 if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
246 if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
249 /* Lower priority values first */
250 if (x->priority < y->priority)
252 if (x->priority > y->priority)
255 /* Stability for the rest */
264 static int earliest_time_prioq_compare(const void *a, const void *b) {
265 const sd_event_source *x = a, *y = b;
267 assert(EVENT_SOURCE_IS_TIME(x->type));
268 assert(x->type == y->type);
270 /* Enabled ones first */
271 if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
273 if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
276 /* Move the pending ones to the end */
277 if (!x->pending && y->pending)
279 if (x->pending && !y->pending)
283 if (x->time.next < y->time.next)
285 if (x->time.next > y->time.next)
288 /* Stability for the rest */
297 static int latest_time_prioq_compare(const void *a, const void *b) {
298 const sd_event_source *x = a, *y = b;
300 assert(EVENT_SOURCE_IS_TIME(x->type));
301 assert(x->type == y->type);
303 /* Enabled ones first */
304 if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
306 if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
309 /* Move the pending ones to the end */
310 if (!x->pending && y->pending)
312 if (x->pending && !y->pending)
316 if (x->time.next + x->time.accuracy < y->time.next + y->time.accuracy)
318 if (x->time.next + x->time.accuracy > y->time.next + y->time.accuracy)
321 /* Stability for the rest */
330 static int exit_prioq_compare(const void *a, const void *b) {
331 const sd_event_source *x = a, *y = b;
333 assert(x->type == SOURCE_EXIT);
334 assert(y->type == SOURCE_EXIT);
336 /* Enabled ones first */
337 if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
339 if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
342 /* Lower priority values first */
343 if (x->priority < y->priority)
345 if (x->priority > y->priority)
348 /* Stability for the rest */
357 static void free_clock_data(struct clock_data *d) {
361 prioq_free(d->earliest);
362 prioq_free(d->latest);
365 static void event_free(sd_event *e) {
370 while ((s = e->sources)) {
372 source_disconnect(s);
373 sd_event_source_unref(s);
376 assert(e->n_sources == 0);
378 if (e->default_event_ptr)
379 *(e->default_event_ptr) = NULL;
381 safe_close(e->epoll_fd);
382 safe_close(e->signal_fd);
383 safe_close(e->watchdog_fd);
385 free_clock_data(&e->realtime);
386 free_clock_data(&e->boottime);
387 free_clock_data(&e->monotonic);
388 free_clock_data(&e->realtime_alarm);
389 free_clock_data(&e->boottime_alarm);
391 prioq_free(e->pending);
392 prioq_free(e->prepare);
395 free(e->signal_sources);
397 hashmap_free(e->child_sources);
398 set_free(e->post_sources);
402 _public_ int sd_event_new(sd_event** ret) {
406 assert_return(ret, -EINVAL);
408 e = new0(sd_event, 1);
413 e->signal_fd = e->watchdog_fd = e->epoll_fd = e->realtime.fd = e->boottime.fd = e->monotonic.fd = e->realtime_alarm.fd = e->boottime_alarm.fd = -1;
414 e->realtime.next = e->boottime.next = e->monotonic.next = e->realtime_alarm.next = e->boottime_alarm.next = USEC_INFINITY;
415 e->original_pid = getpid();
416 e->perturb = USEC_INFINITY;
418 assert_se(sigemptyset(&e->sigset) == 0);
420 e->pending = prioq_new(pending_prioq_compare);
426 e->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
427 if (e->epoll_fd < 0) {
440 _public_ sd_event* sd_event_ref(sd_event *e) {
441 assert_return(e, NULL);
443 assert(e->n_ref >= 1);
449 _public_ sd_event* sd_event_unref(sd_event *e) {
454 assert(e->n_ref >= 1);
463 static bool event_pid_changed(sd_event *e) {
466 /* We don't support people creating am event loop and keeping
467 * it around over a fork(). Let's complain. */
469 return e->original_pid != getpid();
472 static int source_io_unregister(sd_event_source *s) {
476 assert(s->type == SOURCE_IO);
478 if (!s->io.registered)
481 r = epoll_ctl(s->event->epoll_fd, EPOLL_CTL_DEL, s->io.fd, NULL);
485 s->io.registered = false;
489 static int source_io_register(
494 struct epoll_event ev = {};
498 assert(s->type == SOURCE_IO);
499 assert(enabled != SD_EVENT_OFF);
504 if (enabled == SD_EVENT_ONESHOT)
505 ev.events |= EPOLLONESHOT;
507 if (s->io.registered)
508 r = epoll_ctl(s->event->epoll_fd, EPOLL_CTL_MOD, s->io.fd, &ev);
510 r = epoll_ctl(s->event->epoll_fd, EPOLL_CTL_ADD, s->io.fd, &ev);
515 s->io.registered = true;
520 static clockid_t event_source_type_to_clock(EventSourceType t) {
524 case SOURCE_TIME_REALTIME:
525 return CLOCK_REALTIME;
527 case SOURCE_TIME_BOOTTIME:
528 return CLOCK_BOOTTIME;
530 case SOURCE_TIME_MONOTONIC:
531 return CLOCK_MONOTONIC;
533 case SOURCE_TIME_REALTIME_ALARM:
534 return CLOCK_REALTIME_ALARM;
536 case SOURCE_TIME_BOOTTIME_ALARM:
537 return CLOCK_BOOTTIME_ALARM;
540 return (clockid_t) -1;
544 static EventSourceType clock_to_event_source_type(clockid_t clock) {
549 return SOURCE_TIME_REALTIME;
552 return SOURCE_TIME_BOOTTIME;
554 case CLOCK_MONOTONIC:
555 return SOURCE_TIME_MONOTONIC;
557 case CLOCK_REALTIME_ALARM:
558 return SOURCE_TIME_REALTIME_ALARM;
560 case CLOCK_BOOTTIME_ALARM:
561 return SOURCE_TIME_BOOTTIME_ALARM;
564 return _SOURCE_EVENT_SOURCE_TYPE_INVALID;
568 static struct clock_data* event_get_clock_data(sd_event *e, EventSourceType t) {
573 case SOURCE_TIME_REALTIME:
576 case SOURCE_TIME_BOOTTIME:
579 case SOURCE_TIME_MONOTONIC:
580 return &e->monotonic;
582 case SOURCE_TIME_REALTIME_ALARM:
583 return &e->realtime_alarm;
585 case SOURCE_TIME_BOOTTIME_ALARM:
586 return &e->boottime_alarm;
593 static void source_disconnect(sd_event_source *s) {
601 assert(s->event->n_sources > 0);
607 source_io_unregister(s);
611 case SOURCE_TIME_REALTIME:
612 case SOURCE_TIME_BOOTTIME:
613 case SOURCE_TIME_MONOTONIC:
614 case SOURCE_TIME_REALTIME_ALARM:
615 case SOURCE_TIME_BOOTTIME_ALARM: {
616 struct clock_data *d;
618 d = event_get_clock_data(s->event, s->type);
621 prioq_remove(d->earliest, s, &s->time.earliest_index);
622 prioq_remove(d->latest, s, &s->time.latest_index);
623 d->needs_rearm = true;
628 if (s->signal.sig > 0) {
629 if (s->signal.sig != SIGCHLD || s->event->n_enabled_child_sources == 0)
630 assert_se(sigdelset(&s->event->sigset, s->signal.sig) == 0);
632 if (s->event->signal_sources)
633 s->event->signal_sources[s->signal.sig] = NULL;
639 if (s->child.pid > 0) {
640 if (s->enabled != SD_EVENT_OFF) {
641 assert(s->event->n_enabled_child_sources > 0);
642 s->event->n_enabled_child_sources--;
645 if (!s->event->signal_sources || !s->event->signal_sources[SIGCHLD])
646 assert_se(sigdelset(&s->event->sigset, SIGCHLD) == 0);
648 hashmap_remove(s->event->child_sources, INT_TO_PTR(s->child.pid));
658 set_remove(s->event->post_sources, s);
662 prioq_remove(s->event->exit, s, &s->exit.prioq_index);
666 assert_not_reached("Wut? I shouldn't exist.");
670 prioq_remove(s->event->pending, s, &s->pending_index);
673 prioq_remove(s->event->prepare, s, &s->prepare_index);
677 s->type = _SOURCE_EVENT_SOURCE_TYPE_INVALID;
679 LIST_REMOVE(sources, event->sources, s);
683 sd_event_unref(event);
686 static void source_free(sd_event_source *s) {
689 source_disconnect(s);
694 static int source_set_pending(sd_event_source *s, bool b) {
698 assert(s->type != SOURCE_EXIT);
706 s->pending_iteration = s->event->iteration;
708 r = prioq_put(s->event->pending, s, &s->pending_index);
714 assert_se(prioq_remove(s->event->pending, s, &s->pending_index));
716 if (EVENT_SOURCE_IS_TIME(s->type)) {
717 struct clock_data *d;
719 d = event_get_clock_data(s->event, s->type);
722 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
723 prioq_reshuffle(d->latest, s, &s->time.latest_index);
724 d->needs_rearm = true;
730 static sd_event_source *source_new(sd_event *e, bool floating, EventSourceType type) {
735 s = new0(sd_event_source, 1);
741 s->floating = floating;
743 s->pending_index = s->prepare_index = PRIOQ_IDX_NULL;
748 LIST_PREPEND(sources, e->sources, s);
754 _public_ int sd_event_add_io(
756 sd_event_source **ret,
759 sd_event_io_handler_t callback,
765 assert_return(e, -EINVAL);
766 assert_return(fd >= 0, -EINVAL);
767 assert_return(!(events & ~(EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLPRI|EPOLLERR|EPOLLHUP|EPOLLET)), -EINVAL);
768 assert_return(callback, -EINVAL);
769 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
770 assert_return(!event_pid_changed(e), -ECHILD);
772 s = source_new(e, !ret, SOURCE_IO);
777 s->io.events = events;
778 s->io.callback = callback;
779 s->userdata = userdata;
780 s->enabled = SD_EVENT_ON;
782 r = source_io_register(s, s->enabled, events);
794 static void initialize_perturb(sd_event *e) {
795 sd_id128_t bootid = {};
797 /* When we sleep for longer, we try to realign the wakeup to
798 the same time wihtin each minute/second/250ms, so that
799 events all across the system can be coalesced into a single
800 CPU wakeup. However, let's take some system-specific
801 randomness for this value, so that in a network of systems
802 with synced clocks timer events are distributed a
803 bit. Here, we calculate a perturbation usec offset from the
806 if (_likely_(e->perturb != USEC_INFINITY))
809 if (sd_id128_get_boot(&bootid) >= 0)
810 e->perturb = (bootid.qwords[0] ^ bootid.qwords[1]) % USEC_PER_MINUTE;
813 static int event_setup_timer_fd(
815 struct clock_data *d,
818 struct epoll_event ev = {};
824 if (_likely_(d->fd >= 0))
827 fd = timerfd_create(clock, TFD_NONBLOCK|TFD_CLOEXEC);
832 ev.data.ptr = INT_TO_PTR(clock_to_event_source_type(clock));
834 r = epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, fd, &ev);
844 _public_ int sd_event_add_time(
846 sd_event_source **ret,
850 sd_event_time_handler_t callback,
853 EventSourceType type;
855 struct clock_data *d;
858 assert_return(e, -EINVAL);
859 assert_return(usec != (uint64_t) -1, -EINVAL);
860 assert_return(accuracy != (uint64_t) -1, -EINVAL);
861 assert_return(callback, -EINVAL);
862 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
863 assert_return(!event_pid_changed(e), -ECHILD);
865 type = clock_to_event_source_type(clock);
866 assert_return(type >= 0, -ENOTSUP);
868 d = event_get_clock_data(e, type);
872 d->earliest = prioq_new(earliest_time_prioq_compare);
878 d->latest = prioq_new(latest_time_prioq_compare);
884 r = event_setup_timer_fd(e, d, clock);
889 s = source_new(e, !ret, type);
894 s->time.accuracy = accuracy == 0 ? DEFAULT_ACCURACY_USEC : accuracy;
895 s->time.callback = callback;
896 s->time.earliest_index = s->time.latest_index = PRIOQ_IDX_NULL;
897 s->userdata = userdata;
898 s->enabled = SD_EVENT_ONESHOT;
900 d->needs_rearm = true;
902 r = prioq_put(d->earliest, s, &s->time.earliest_index);
906 r = prioq_put(d->latest, s, &s->time.latest_index);
920 static int event_update_signal_fd(sd_event *e) {
921 struct epoll_event ev = {};
927 add_to_epoll = e->signal_fd < 0;
929 r = signalfd(e->signal_fd, &e->sigset, SFD_NONBLOCK|SFD_CLOEXEC);
939 ev.data.ptr = INT_TO_PTR(SOURCE_SIGNAL);
941 r = epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, e->signal_fd, &ev);
943 e->signal_fd = safe_close(e->signal_fd);
950 static int signal_exit_callback(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
953 return sd_event_exit(sd_event_source_get_event(s), PTR_TO_INT(userdata));
956 _public_ int sd_event_add_signal(
958 sd_event_source **ret,
960 sd_event_signal_handler_t callback,
967 assert_return(e, -EINVAL);
968 assert_return(sig > 0, -EINVAL);
969 assert_return(sig < _NSIG, -EINVAL);
970 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
971 assert_return(!event_pid_changed(e), -ECHILD);
974 callback = signal_exit_callback;
976 r = pthread_sigmask(SIG_SETMASK, NULL, &ss);
980 if (!sigismember(&ss, sig))
983 if (!e->signal_sources) {
984 e->signal_sources = new0(sd_event_source*, _NSIG);
985 if (!e->signal_sources)
987 } else if (e->signal_sources[sig])
990 s = source_new(e, !ret, SOURCE_SIGNAL);
995 s->signal.callback = callback;
996 s->userdata = userdata;
997 s->enabled = SD_EVENT_ON;
999 e->signal_sources[sig] = s;
1000 assert_se(sigaddset(&e->sigset, sig) == 0);
1002 if (sig != SIGCHLD || e->n_enabled_child_sources == 0) {
1003 r = event_update_signal_fd(e);
1016 _public_ int sd_event_add_child(
1018 sd_event_source **ret,
1021 sd_event_child_handler_t callback,
1027 assert_return(e, -EINVAL);
1028 assert_return(pid > 1, -EINVAL);
1029 assert_return(!(options & ~(WEXITED|WSTOPPED|WCONTINUED)), -EINVAL);
1030 assert_return(options != 0, -EINVAL);
1031 assert_return(callback, -EINVAL);
1032 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1033 assert_return(!event_pid_changed(e), -ECHILD);
1035 r = hashmap_ensure_allocated(&e->child_sources, trivial_hash_func, trivial_compare_func);
1039 if (hashmap_contains(e->child_sources, INT_TO_PTR(pid)))
1042 s = source_new(e, !ret, SOURCE_CHILD);
1047 s->child.options = options;
1048 s->child.callback = callback;
1049 s->userdata = userdata;
1050 s->enabled = SD_EVENT_ONESHOT;
1052 r = hashmap_put(e->child_sources, INT_TO_PTR(pid), s);
1058 e->n_enabled_child_sources ++;
1060 assert_se(sigaddset(&e->sigset, SIGCHLD) == 0);
1062 if (!e->signal_sources || !e->signal_sources[SIGCHLD]) {
1063 r = event_update_signal_fd(e);
1070 e->need_process_child = true;
1078 _public_ int sd_event_add_defer(
1080 sd_event_source **ret,
1081 sd_event_handler_t callback,
1087 assert_return(e, -EINVAL);
1088 assert_return(callback, -EINVAL);
1089 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1090 assert_return(!event_pid_changed(e), -ECHILD);
1092 s = source_new(e, !ret, SOURCE_DEFER);
1096 s->defer.callback = callback;
1097 s->userdata = userdata;
1098 s->enabled = SD_EVENT_ONESHOT;
1100 r = source_set_pending(s, true);
1112 _public_ int sd_event_add_post(
1114 sd_event_source **ret,
1115 sd_event_handler_t callback,
1121 assert_return(e, -EINVAL);
1122 assert_return(callback, -EINVAL);
1123 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1124 assert_return(!event_pid_changed(e), -ECHILD);
1126 r = set_ensure_allocated(&e->post_sources, trivial_hash_func, trivial_compare_func);
1130 s = source_new(e, !ret, SOURCE_POST);
1134 s->post.callback = callback;
1135 s->userdata = userdata;
1136 s->enabled = SD_EVENT_ON;
1138 r = set_put(e->post_sources, s);
1150 _public_ int sd_event_add_exit(
1152 sd_event_source **ret,
1153 sd_event_handler_t callback,
1159 assert_return(e, -EINVAL);
1160 assert_return(callback, -EINVAL);
1161 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1162 assert_return(!event_pid_changed(e), -ECHILD);
1165 e->exit = prioq_new(exit_prioq_compare);
1170 s = source_new(e, !ret, SOURCE_EXIT);
1174 s->exit.callback = callback;
1175 s->userdata = userdata;
1176 s->exit.prioq_index = PRIOQ_IDX_NULL;
1177 s->enabled = SD_EVENT_ONESHOT;
1179 r = prioq_put(s->event->exit, s, &s->exit.prioq_index);
1191 _public_ sd_event_source* sd_event_source_ref(sd_event_source *s) {
1192 assert_return(s, NULL);
1194 assert(s->n_ref >= 1);
1200 _public_ sd_event_source* sd_event_source_unref(sd_event_source *s) {
1205 assert(s->n_ref >= 1);
1208 if (s->n_ref <= 0) {
1209 /* Here's a special hack: when we are called from a
1210 * dispatch handler we won't free the event source
1211 * immediately, but we will detach the fd from the
1212 * epoll. This way it is safe for the caller to unref
1213 * the event source and immediately close the fd, but
1214 * we still retain a valid event source object after
1217 if (s->dispatching) {
1218 if (s->type == SOURCE_IO)
1219 source_io_unregister(s);
1221 source_disconnect(s);
1229 _public_ int sd_event_source_set_name(sd_event_source *s, const char *name) {
1230 char *new_name = NULL;
1232 assert_return(s, -EINVAL);
1235 new_name = strdup(name);
1246 _public_ int sd_event_source_get_name(sd_event_source *s, const char **name) {
1247 assert_return(s, -EINVAL);
1248 assert_return(name, -EINVAL);
1255 _public_ sd_event *sd_event_source_get_event(sd_event_source *s) {
1256 assert_return(s, NULL);
1261 _public_ int sd_event_source_get_pending(sd_event_source *s) {
1262 assert_return(s, -EINVAL);
1263 assert_return(s->type != SOURCE_EXIT, -EDOM);
1264 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1265 assert_return(!event_pid_changed(s->event), -ECHILD);
1270 _public_ int sd_event_source_get_io_fd(sd_event_source *s) {
1271 assert_return(s, -EINVAL);
1272 assert_return(s->type == SOURCE_IO, -EDOM);
1273 assert_return(!event_pid_changed(s->event), -ECHILD);
1278 _public_ int sd_event_source_set_io_fd(sd_event_source *s, int fd) {
1281 assert_return(s, -EINVAL);
1282 assert_return(fd >= 0, -EINVAL);
1283 assert_return(s->type == SOURCE_IO, -EDOM);
1284 assert_return(!event_pid_changed(s->event), -ECHILD);
1289 if (s->enabled == SD_EVENT_OFF) {
1291 s->io.registered = false;
1295 saved_fd = s->io.fd;
1296 assert(s->io.registered);
1299 s->io.registered = false;
1301 r = source_io_register(s, s->enabled, s->io.events);
1303 s->io.fd = saved_fd;
1304 s->io.registered = true;
1308 epoll_ctl(s->event->epoll_fd, EPOLL_CTL_DEL, saved_fd, NULL);
1314 _public_ int sd_event_source_get_io_events(sd_event_source *s, uint32_t* events) {
1315 assert_return(s, -EINVAL);
1316 assert_return(events, -EINVAL);
1317 assert_return(s->type == SOURCE_IO, -EDOM);
1318 assert_return(!event_pid_changed(s->event), -ECHILD);
1320 *events = s->io.events;
1324 _public_ int sd_event_source_set_io_events(sd_event_source *s, uint32_t events) {
1327 assert_return(s, -EINVAL);
1328 assert_return(s->type == SOURCE_IO, -EDOM);
1329 assert_return(!(events & ~(EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLPRI|EPOLLERR|EPOLLHUP|EPOLLET)), -EINVAL);
1330 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1331 assert_return(!event_pid_changed(s->event), -ECHILD);
1333 /* edge-triggered updates are never skipped, so we can reset edges */
1334 if (s->io.events == events && !(events & EPOLLET))
1337 if (s->enabled != SD_EVENT_OFF) {
1338 r = source_io_register(s, s->enabled, events);
1343 s->io.events = events;
1344 source_set_pending(s, false);
1349 _public_ int sd_event_source_get_io_revents(sd_event_source *s, uint32_t* revents) {
1350 assert_return(s, -EINVAL);
1351 assert_return(revents, -EINVAL);
1352 assert_return(s->type == SOURCE_IO, -EDOM);
1353 assert_return(s->pending, -ENODATA);
1354 assert_return(!event_pid_changed(s->event), -ECHILD);
1356 *revents = s->io.revents;
1360 _public_ int sd_event_source_get_signal(sd_event_source *s) {
1361 assert_return(s, -EINVAL);
1362 assert_return(s->type == SOURCE_SIGNAL, -EDOM);
1363 assert_return(!event_pid_changed(s->event), -ECHILD);
1365 return s->signal.sig;
1368 _public_ int sd_event_source_get_priority(sd_event_source *s, int64_t *priority) {
1369 assert_return(s, -EINVAL);
1370 assert_return(!event_pid_changed(s->event), -ECHILD);
1375 _public_ int sd_event_source_set_priority(sd_event_source *s, int64_t priority) {
1376 assert_return(s, -EINVAL);
1377 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1378 assert_return(!event_pid_changed(s->event), -ECHILD);
1380 if (s->priority == priority)
1383 s->priority = priority;
1386 prioq_reshuffle(s->event->pending, s, &s->pending_index);
1389 prioq_reshuffle(s->event->prepare, s, &s->prepare_index);
1391 if (s->type == SOURCE_EXIT)
1392 prioq_reshuffle(s->event->exit, s, &s->exit.prioq_index);
1397 _public_ int sd_event_source_get_enabled(sd_event_source *s, int *m) {
1398 assert_return(s, -EINVAL);
1399 assert_return(m, -EINVAL);
1400 assert_return(!event_pid_changed(s->event), -ECHILD);
1406 _public_ int sd_event_source_set_enabled(sd_event_source *s, int m) {
1409 assert_return(s, -EINVAL);
1410 assert_return(m == SD_EVENT_OFF || m == SD_EVENT_ON || m == SD_EVENT_ONESHOT, -EINVAL);
1411 assert_return(!event_pid_changed(s->event), -ECHILD);
1413 /* If we are dead anyway, we are fine with turning off
1414 * sources, but everything else needs to fail. */
1415 if (s->event->state == SD_EVENT_FINISHED)
1416 return m == SD_EVENT_OFF ? 0 : -ESTALE;
1418 if (s->enabled == m)
1421 if (m == SD_EVENT_OFF) {
1426 r = source_io_unregister(s);
1433 case SOURCE_TIME_REALTIME:
1434 case SOURCE_TIME_BOOTTIME:
1435 case SOURCE_TIME_MONOTONIC:
1436 case SOURCE_TIME_REALTIME_ALARM:
1437 case SOURCE_TIME_BOOTTIME_ALARM: {
1438 struct clock_data *d;
1441 d = event_get_clock_data(s->event, s->type);
1444 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
1445 prioq_reshuffle(d->latest, s, &s->time.latest_index);
1446 d->needs_rearm = true;
1452 if (s->signal.sig != SIGCHLD || s->event->n_enabled_child_sources == 0) {
1453 assert_se(sigdelset(&s->event->sigset, s->signal.sig) == 0);
1454 event_update_signal_fd(s->event);
1462 assert(s->event->n_enabled_child_sources > 0);
1463 s->event->n_enabled_child_sources--;
1465 if (!s->event->signal_sources || !s->event->signal_sources[SIGCHLD]) {
1466 assert_se(sigdelset(&s->event->sigset, SIGCHLD) == 0);
1467 event_update_signal_fd(s->event);
1474 prioq_reshuffle(s->event->exit, s, &s->exit.prioq_index);
1483 assert_not_reached("Wut? I shouldn't exist.");
1490 r = source_io_register(s, m, s->io.events);
1497 case SOURCE_TIME_REALTIME:
1498 case SOURCE_TIME_BOOTTIME:
1499 case SOURCE_TIME_MONOTONIC:
1500 case SOURCE_TIME_REALTIME_ALARM:
1501 case SOURCE_TIME_BOOTTIME_ALARM: {
1502 struct clock_data *d;
1505 d = event_get_clock_data(s->event, s->type);
1508 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
1509 prioq_reshuffle(d->latest, s, &s->time.latest_index);
1510 d->needs_rearm = true;
1517 if (s->signal.sig != SIGCHLD || s->event->n_enabled_child_sources == 0) {
1518 assert_se(sigaddset(&s->event->sigset, s->signal.sig) == 0);
1519 event_update_signal_fd(s->event);
1524 if (s->enabled == SD_EVENT_OFF) {
1525 s->event->n_enabled_child_sources++;
1527 if (!s->event->signal_sources || !s->event->signal_sources[SIGCHLD]) {
1528 assert_se(sigaddset(&s->event->sigset, SIGCHLD) == 0);
1529 event_update_signal_fd(s->event);
1538 prioq_reshuffle(s->event->exit, s, &s->exit.prioq_index);
1547 assert_not_reached("Wut? I shouldn't exist.");
1552 prioq_reshuffle(s->event->pending, s, &s->pending_index);
1555 prioq_reshuffle(s->event->prepare, s, &s->prepare_index);
1560 _public_ int sd_event_source_get_time(sd_event_source *s, uint64_t *usec) {
1561 assert_return(s, -EINVAL);
1562 assert_return(usec, -EINVAL);
1563 assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1564 assert_return(!event_pid_changed(s->event), -ECHILD);
1566 *usec = s->time.next;
1570 _public_ int sd_event_source_set_time(sd_event_source *s, uint64_t usec) {
1571 struct clock_data *d;
1573 assert_return(s, -EINVAL);
1574 assert_return(usec != (uint64_t) -1, -EINVAL);
1575 assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1576 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1577 assert_return(!event_pid_changed(s->event), -ECHILD);
1579 s->time.next = usec;
1581 source_set_pending(s, false);
1583 d = event_get_clock_data(s->event, s->type);
1586 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
1587 prioq_reshuffle(d->latest, s, &s->time.latest_index);
1588 d->needs_rearm = true;
1593 _public_ int sd_event_source_get_time_accuracy(sd_event_source *s, uint64_t *usec) {
1594 assert_return(s, -EINVAL);
1595 assert_return(usec, -EINVAL);
1596 assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1597 assert_return(!event_pid_changed(s->event), -ECHILD);
1599 *usec = s->time.accuracy;
1603 _public_ int sd_event_source_set_time_accuracy(sd_event_source *s, uint64_t usec) {
1604 struct clock_data *d;
1606 assert_return(s, -EINVAL);
1607 assert_return(usec != (uint64_t) -1, -EINVAL);
1608 assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1609 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1610 assert_return(!event_pid_changed(s->event), -ECHILD);
1613 usec = DEFAULT_ACCURACY_USEC;
1615 s->time.accuracy = usec;
1617 source_set_pending(s, false);
1619 d = event_get_clock_data(s->event, s->type);
1622 prioq_reshuffle(d->latest, s, &s->time.latest_index);
1623 d->needs_rearm = true;
1628 _public_ int sd_event_source_get_time_clock(sd_event_source *s, clockid_t *clock) {
1629 assert_return(s, -EINVAL);
1630 assert_return(clock, -EINVAL);
1631 assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1632 assert_return(!event_pid_changed(s->event), -ECHILD);
1634 *clock = event_source_type_to_clock(s->type);
1638 _public_ int sd_event_source_get_child_pid(sd_event_source *s, pid_t *pid) {
1639 assert_return(s, -EINVAL);
1640 assert_return(pid, -EINVAL);
1641 assert_return(s->type == SOURCE_CHILD, -EDOM);
1642 assert_return(!event_pid_changed(s->event), -ECHILD);
1644 *pid = s->child.pid;
1648 _public_ int sd_event_source_set_prepare(sd_event_source *s, sd_event_handler_t callback) {
1651 assert_return(s, -EINVAL);
1652 assert_return(s->type != SOURCE_EXIT, -EDOM);
1653 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1654 assert_return(!event_pid_changed(s->event), -ECHILD);
1656 if (s->prepare == callback)
1659 if (callback && s->prepare) {
1660 s->prepare = callback;
1664 r = prioq_ensure_allocated(&s->event->prepare, prepare_prioq_compare);
1668 s->prepare = callback;
1671 r = prioq_put(s->event->prepare, s, &s->prepare_index);
1675 prioq_remove(s->event->prepare, s, &s->prepare_index);
1680 _public_ void* sd_event_source_get_userdata(sd_event_source *s) {
1681 assert_return(s, NULL);
1686 _public_ void *sd_event_source_set_userdata(sd_event_source *s, void *userdata) {
1689 assert_return(s, NULL);
1692 s->userdata = userdata;
1697 static usec_t sleep_between(sd_event *e, usec_t a, usec_t b) {
1708 initialize_perturb(e);
1711 Find a good time to wake up again between times a and b. We
1712 have two goals here:
1714 a) We want to wake up as seldom as possible, hence prefer
1715 later times over earlier times.
1717 b) But if we have to wake up, then let's make sure to
1718 dispatch as much as possible on the entire system.
1720 We implement this by waking up everywhere at the same time
1721 within any given minute if we can, synchronised via the
1722 perturbation value determined from the boot ID. If we can't,
1723 then we try to find the same spot in every 10s, then 1s and
1724 then 250ms step. Otherwise, we pick the last possible time
1728 c = (b / USEC_PER_MINUTE) * USEC_PER_MINUTE + e->perturb;
1730 if (_unlikely_(c < USEC_PER_MINUTE))
1733 c -= USEC_PER_MINUTE;
1739 c = (b / (USEC_PER_SEC*10)) * (USEC_PER_SEC*10) + (e->perturb % (USEC_PER_SEC*10));
1741 if (_unlikely_(c < USEC_PER_SEC*10))
1744 c -= USEC_PER_SEC*10;
1750 c = (b / USEC_PER_SEC) * USEC_PER_SEC + (e->perturb % USEC_PER_SEC);
1752 if (_unlikely_(c < USEC_PER_SEC))
1761 c = (b / (USEC_PER_MSEC*250)) * (USEC_PER_MSEC*250) + (e->perturb % (USEC_PER_MSEC*250));
1763 if (_unlikely_(c < USEC_PER_MSEC*250))
1766 c -= USEC_PER_MSEC*250;
1775 static int event_arm_timer(
1777 struct clock_data *d) {
1779 struct itimerspec its = {};
1780 sd_event_source *a, *b;
1787 if (!d->needs_rearm)
1790 d->needs_rearm = false;
1792 a = prioq_peek(d->earliest);
1793 if (!a || a->enabled == SD_EVENT_OFF) {
1798 if (d->next == USEC_INFINITY)
1802 r = timerfd_settime(d->fd, TFD_TIMER_ABSTIME, &its, NULL);
1806 d->next = USEC_INFINITY;
1810 b = prioq_peek(d->latest);
1811 assert_se(b && b->enabled != SD_EVENT_OFF);
1813 t = sleep_between(e, a->time.next, b->time.next + b->time.accuracy);
1817 assert_se(d->fd >= 0);
1820 /* We don' want to disarm here, just mean some time looooong ago. */
1821 its.it_value.tv_sec = 0;
1822 its.it_value.tv_nsec = 1;
1824 timespec_store(&its.it_value, t);
1826 r = timerfd_settime(d->fd, TFD_TIMER_ABSTIME, &its, NULL);
1834 static int process_io(sd_event *e, sd_event_source *s, uint32_t revents) {
1837 assert(s->type == SOURCE_IO);
1839 /* If the event source was already pending, we just OR in the
1840 * new revents, otherwise we reset the value. The ORing is
1841 * necessary to handle EPOLLONESHOT events properly where
1842 * readability might happen independently of writability, and
1843 * we need to keep track of both */
1846 s->io.revents |= revents;
1848 s->io.revents = revents;
1850 return source_set_pending(s, true);
1853 static int flush_timer(sd_event *e, int fd, uint32_t events, usec_t *next) {
1860 assert_return(events == EPOLLIN, -EIO);
1862 ss = read(fd, &x, sizeof(x));
1864 if (errno == EAGAIN || errno == EINTR)
1870 if (_unlikely_(ss != sizeof(x)))
1874 *next = USEC_INFINITY;
1879 static int process_timer(
1882 struct clock_data *d) {
1891 s = prioq_peek(d->earliest);
1894 s->enabled == SD_EVENT_OFF ||
1898 r = source_set_pending(s, true);
1902 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
1903 prioq_reshuffle(d->latest, s, &s->time.latest_index);
1904 d->needs_rearm = true;
1910 static int process_child(sd_event *e) {
1917 e->need_process_child = false;
1920 So, this is ugly. We iteratively invoke waitid() with P_PID
1921 + WNOHANG for each PID we wait for, instead of using
1922 P_ALL. This is because we only want to get child
1923 information of very specific child processes, and not all
1924 of them. We might not have processed the SIGCHLD even of a
1925 previous invocation and we don't want to maintain a
1926 unbounded *per-child* event queue, hence we really don't
1927 want anything flushed out of the kernel's queue that we
1928 don't care about. Since this is O(n) this means that if you
1929 have a lot of processes you probably want to handle SIGCHLD
1932 We do not reap the children here (by using WNOWAIT), this
1933 is only done after the event source is dispatched so that
1934 the callback still sees the process as a zombie.
1937 HASHMAP_FOREACH(s, e->child_sources, i) {
1938 assert(s->type == SOURCE_CHILD);
1943 if (s->enabled == SD_EVENT_OFF)
1946 zero(s->child.siginfo);
1947 r = waitid(P_PID, s->child.pid, &s->child.siginfo,
1948 WNOHANG | (s->child.options & WEXITED ? WNOWAIT : 0) | s->child.options);
1952 if (s->child.siginfo.si_pid != 0) {
1954 s->child.siginfo.si_code == CLD_EXITED ||
1955 s->child.siginfo.si_code == CLD_KILLED ||
1956 s->child.siginfo.si_code == CLD_DUMPED;
1958 if (!zombie && (s->child.options & WEXITED)) {
1959 /* If the child isn't dead then let's
1960 * immediately remove the state change
1961 * from the queue, since there's no
1962 * benefit in leaving it queued */
1964 assert(s->child.options & (WSTOPPED|WCONTINUED));
1965 waitid(P_PID, s->child.pid, &s->child.siginfo, WNOHANG|(s->child.options & (WSTOPPED|WCONTINUED)));
1968 r = source_set_pending(s, true);
1977 static int process_signal(sd_event *e, uint32_t events) {
1978 bool read_one = false;
1983 assert_return(events == EPOLLIN, -EIO);
1986 struct signalfd_siginfo si;
1988 sd_event_source *s = NULL;
1990 ss = read(e->signal_fd, &si, sizeof(si));
1992 if (errno == EAGAIN || errno == EINTR)
1998 if (_unlikely_(ss != sizeof(si)))
2003 if (si.ssi_signo == SIGCHLD) {
2004 r = process_child(e);
2011 if (e->signal_sources)
2012 s = e->signal_sources[si.ssi_signo];
2017 s->signal.siginfo = si;
2018 r = source_set_pending(s, true);
2024 static int source_dispatch(sd_event_source *s) {
2028 assert(s->pending || s->type == SOURCE_EXIT);
2030 if (s->type != SOURCE_DEFER && s->type != SOURCE_EXIT) {
2031 r = source_set_pending(s, false);
2036 if (s->type != SOURCE_POST) {
2040 /* If we execute a non-post source, let's mark all
2041 * post sources as pending */
2043 SET_FOREACH(z, s->event->post_sources, i) {
2044 if (z->enabled == SD_EVENT_OFF)
2047 r = source_set_pending(z, true);
2053 if (s->enabled == SD_EVENT_ONESHOT) {
2054 r = sd_event_source_set_enabled(s, SD_EVENT_OFF);
2059 s->dispatching = true;
2064 r = s->io.callback(s, s->io.fd, s->io.revents, s->userdata);
2067 case SOURCE_TIME_REALTIME:
2068 case SOURCE_TIME_BOOTTIME:
2069 case SOURCE_TIME_MONOTONIC:
2070 case SOURCE_TIME_REALTIME_ALARM:
2071 case SOURCE_TIME_BOOTTIME_ALARM:
2072 r = s->time.callback(s, s->time.next, s->userdata);
2076 r = s->signal.callback(s, &s->signal.siginfo, s->userdata);
2079 case SOURCE_CHILD: {
2082 zombie = s->child.siginfo.si_code == CLD_EXITED ||
2083 s->child.siginfo.si_code == CLD_KILLED ||
2084 s->child.siginfo.si_code == CLD_DUMPED;
2086 r = s->child.callback(s, &s->child.siginfo, s->userdata);
2088 /* Now, reap the PID for good. */
2090 waitid(P_PID, s->child.pid, &s->child.siginfo, WNOHANG|WEXITED);
2096 r = s->defer.callback(s, s->userdata);
2100 r = s->post.callback(s, s->userdata);
2104 r = s->exit.callback(s, s->userdata);
2107 case SOURCE_WATCHDOG:
2108 case _SOURCE_EVENT_SOURCE_TYPE_MAX:
2109 case _SOURCE_EVENT_SOURCE_TYPE_INVALID:
2110 assert_not_reached("Wut? I shouldn't exist.");
2113 s->dispatching = false;
2117 log_debug("Event source '%s' returned error, disabling: %s", s->name, strerror(-r));
2119 log_debug("Event source %p returned error, disabling: %s", s, strerror(-r));
2125 sd_event_source_set_enabled(s, SD_EVENT_OFF);
2130 static int event_prepare(sd_event *e) {
2138 s = prioq_peek(e->prepare);
2139 if (!s || s->prepare_iteration == e->iteration || s->enabled == SD_EVENT_OFF)
2142 s->prepare_iteration = e->iteration;
2143 r = prioq_reshuffle(e->prepare, s, &s->prepare_index);
2149 s->dispatching = true;
2150 r = s->prepare(s, s->userdata);
2151 s->dispatching = false;
2155 log_debug("Prepare callback of event source '%s' returned error, disabling: %s", s->name, strerror(-r));
2157 log_debug("Prepare callback of event source %p returned error, disabling: %s", s, strerror(-r));
2163 sd_event_source_set_enabled(s, SD_EVENT_OFF);
2169 static int dispatch_exit(sd_event *e) {
2175 p = prioq_peek(e->exit);
2176 if (!p || p->enabled == SD_EVENT_OFF) {
2177 e->state = SD_EVENT_FINISHED;
2183 e->state = SD_EVENT_EXITING;
2185 r = source_dispatch(p);
2187 e->state = SD_EVENT_PASSIVE;
2193 static sd_event_source* event_next_pending(sd_event *e) {
2198 p = prioq_peek(e->pending);
2202 if (p->enabled == SD_EVENT_OFF)
2208 static int arm_watchdog(sd_event *e) {
2209 struct itimerspec its = {};
2214 assert(e->watchdog_fd >= 0);
2216 t = sleep_between(e,
2217 e->watchdog_last + (e->watchdog_period / 2),
2218 e->watchdog_last + (e->watchdog_period * 3 / 4));
2220 timespec_store(&its.it_value, t);
2222 /* Make sure we never set the watchdog to 0, which tells the
2223 * kernel to disable it. */
2224 if (its.it_value.tv_sec == 0 && its.it_value.tv_nsec == 0)
2225 its.it_value.tv_nsec = 1;
2227 r = timerfd_settime(e->watchdog_fd, TFD_TIMER_ABSTIME, &its, NULL);
2234 static int process_watchdog(sd_event *e) {
2240 /* Don't notify watchdog too often */
2241 if (e->watchdog_last + e->watchdog_period / 4 > e->timestamp.monotonic)
2244 sd_notify(false, "WATCHDOG=1");
2245 e->watchdog_last = e->timestamp.monotonic;
2247 return arm_watchdog(e);
2250 _public_ int sd_event_prepare(sd_event *e) {
2253 assert_return(e, -EINVAL);
2254 assert_return(!event_pid_changed(e), -ECHILD);
2255 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2256 assert_return(e->state == SD_EVENT_PASSIVE, -EBUSY);
2258 if (e->exit_requested)
2263 r = event_prepare(e);
2267 r = event_arm_timer(e, &e->realtime);
2271 r = event_arm_timer(e, &e->boottime);
2275 r = event_arm_timer(e, &e->monotonic);
2279 r = event_arm_timer(e, &e->realtime_alarm);
2283 r = event_arm_timer(e, &e->boottime_alarm);
2287 if (event_next_pending(e) || e->need_process_child)
2290 e->state = SD_EVENT_PREPARED;
2295 e->state = SD_EVENT_PREPARED;
2296 r = sd_event_wait(e, 0);
2298 e->state = SD_EVENT_PREPARED;
2303 _public_ int sd_event_wait(sd_event *e, uint64_t timeout) {
2304 struct epoll_event *ev_queue;
2305 unsigned ev_queue_max;
2308 assert_return(e, -EINVAL);
2309 assert_return(!event_pid_changed(e), -ECHILD);
2310 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2311 assert_return(e->state == SD_EVENT_PREPARED, -EBUSY);
2313 if (e->exit_requested) {
2314 e->state = SD_EVENT_PENDING;
2318 ev_queue_max = CLAMP(e->n_sources, 1U, EPOLL_QUEUE_MAX);
2319 ev_queue = newa(struct epoll_event, ev_queue_max);
2321 m = epoll_wait(e->epoll_fd, ev_queue, ev_queue_max,
2322 timeout == (uint64_t) -1 ? -1 : (int) ((timeout + USEC_PER_MSEC - 1) / USEC_PER_MSEC));
2324 if (errno == EINTR) {
2325 e->state = SD_EVENT_PENDING;
2334 dual_timestamp_get(&e->timestamp);
2335 e->timestamp_boottime = now(CLOCK_BOOTTIME);
2337 for (i = 0; i < m; i++) {
2339 if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_TIME_REALTIME))
2340 r = flush_timer(e, e->realtime.fd, ev_queue[i].events, &e->realtime.next);
2341 else if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_TIME_BOOTTIME))
2342 r = flush_timer(e, e->boottime.fd, ev_queue[i].events, &e->boottime.next);
2343 else if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_TIME_MONOTONIC))
2344 r = flush_timer(e, e->monotonic.fd, ev_queue[i].events, &e->monotonic.next);
2345 else if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_TIME_REALTIME_ALARM))
2346 r = flush_timer(e, e->realtime_alarm.fd, ev_queue[i].events, &e->realtime_alarm.next);
2347 else if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_TIME_BOOTTIME_ALARM))
2348 r = flush_timer(e, e->boottime_alarm.fd, ev_queue[i].events, &e->boottime_alarm.next);
2349 else if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_SIGNAL))
2350 r = process_signal(e, ev_queue[i].events);
2351 else if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_WATCHDOG))
2352 r = flush_timer(e, e->watchdog_fd, ev_queue[i].events, NULL);
2354 r = process_io(e, ev_queue[i].data.ptr, ev_queue[i].events);
2360 r = process_watchdog(e);
2364 r = process_timer(e, e->timestamp.realtime, &e->realtime);
2368 r = process_timer(e, e->timestamp_boottime, &e->boottime);
2372 r = process_timer(e, e->timestamp.monotonic, &e->monotonic);
2376 r = process_timer(e, e->timestamp.realtime, &e->realtime_alarm);
2380 r = process_timer(e, e->timestamp_boottime, &e->boottime_alarm);
2384 if (e->need_process_child) {
2385 r = process_child(e);
2390 if (event_next_pending(e)) {
2391 e->state = SD_EVENT_PENDING;
2399 e->state = SD_EVENT_PASSIVE;
2404 _public_ int sd_event_dispatch(sd_event *e) {
2408 assert_return(e, -EINVAL);
2409 assert_return(!event_pid_changed(e), -ECHILD);
2410 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2411 assert_return(e->state == SD_EVENT_PENDING, -EBUSY);
2413 if (e->exit_requested)
2414 return dispatch_exit(e);
2416 p = event_next_pending(e);
2420 e->state = SD_EVENT_RUNNING;
2421 r = source_dispatch(p);
2422 e->state = SD_EVENT_PASSIVE;
2429 e->state = SD_EVENT_PASSIVE;
2434 _public_ int sd_event_run(sd_event *e, uint64_t timeout) {
2437 assert_return(e, -EINVAL);
2438 assert_return(!event_pid_changed(e), -ECHILD);
2439 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2440 assert_return(e->state == SD_EVENT_PASSIVE, -EBUSY);
2442 r = sd_event_prepare(e);
2444 return sd_event_dispatch(e);
2448 r = sd_event_wait(e, timeout);
2450 return sd_event_dispatch(e);
2455 _public_ int sd_event_loop(sd_event *e) {
2458 assert_return(e, -EINVAL);
2459 assert_return(!event_pid_changed(e), -ECHILD);
2460 assert_return(e->state == SD_EVENT_PASSIVE, -EBUSY);
2464 while (e->state != SD_EVENT_FINISHED) {
2465 r = sd_event_run(e, (uint64_t) -1);
2477 _public_ int sd_event_get_fd(sd_event *e) {
2479 assert_return(e, -EINVAL);
2480 assert_return(!event_pid_changed(e), -ECHILD);
2485 _public_ int sd_event_get_state(sd_event *e) {
2486 assert_return(e, -EINVAL);
2487 assert_return(!event_pid_changed(e), -ECHILD);
2492 _public_ int sd_event_get_exit_code(sd_event *e, int *code) {
2493 assert_return(e, -EINVAL);
2494 assert_return(code, -EINVAL);
2495 assert_return(!event_pid_changed(e), -ECHILD);
2497 if (!e->exit_requested)
2500 *code = e->exit_code;
2504 _public_ int sd_event_exit(sd_event *e, int code) {
2505 assert_return(e, -EINVAL);
2506 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2507 assert_return(!event_pid_changed(e), -ECHILD);
2509 e->exit_requested = true;
2510 e->exit_code = code;
2515 _public_ int sd_event_now(sd_event *e, clockid_t clock, uint64_t *usec) {
2516 assert_return(e, -EINVAL);
2517 assert_return(usec, -EINVAL);
2518 assert_return(!event_pid_changed(e), -ECHILD);
2520 /* If we haven't run yet, just get the actual time */
2521 if (!dual_timestamp_is_set(&e->timestamp))
2526 case CLOCK_REALTIME:
2527 case CLOCK_REALTIME_ALARM:
2528 *usec = e->timestamp.realtime;
2531 case CLOCK_MONOTONIC:
2532 *usec = e->timestamp.monotonic;
2535 case CLOCK_BOOTTIME:
2536 case CLOCK_BOOTTIME_ALARM:
2537 *usec = e->timestamp_boottime;
2544 _public_ int sd_event_default(sd_event **ret) {
2546 static thread_local sd_event *default_event = NULL;
2551 return !!default_event;
2553 if (default_event) {
2554 *ret = sd_event_ref(default_event);
2558 r = sd_event_new(&e);
2562 e->default_event_ptr = &default_event;
2570 _public_ int sd_event_get_tid(sd_event *e, pid_t *tid) {
2571 assert_return(e, -EINVAL);
2572 assert_return(tid, -EINVAL);
2573 assert_return(!event_pid_changed(e), -ECHILD);
2583 _public_ int sd_event_set_watchdog(sd_event *e, int b) {
2586 assert_return(e, -EINVAL);
2587 assert_return(!event_pid_changed(e), -ECHILD);
2589 if (e->watchdog == !!b)
2593 struct epoll_event ev = {};
2595 r = sd_watchdog_enabled(false, &e->watchdog_period);
2599 /* Issue first ping immediately */
2600 sd_notify(false, "WATCHDOG=1");
2601 e->watchdog_last = now(CLOCK_MONOTONIC);
2603 e->watchdog_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
2604 if (e->watchdog_fd < 0)
2607 r = arm_watchdog(e);
2611 ev.events = EPOLLIN;
2612 ev.data.ptr = INT_TO_PTR(SOURCE_WATCHDOG);
2614 r = epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, e->watchdog_fd, &ev);
2621 if (e->watchdog_fd >= 0) {
2622 epoll_ctl(e->epoll_fd, EPOLL_CTL_DEL, e->watchdog_fd, NULL);
2623 e->watchdog_fd = safe_close(e->watchdog_fd);
2631 e->watchdog_fd = safe_close(e->watchdog_fd);
2635 _public_ int sd_event_get_watchdog(sd_event *e) {
2636 assert_return(e, -EINVAL);
2637 assert_return(!event_pid_changed(e), -ECHILD);