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 bool need_signal(sd_event *e, int signal) {
594 return (e->signal_sources && e->signal_sources[signal] &&
595 e->signal_sources[signal]->enabled != SD_EVENT_OFF)
597 (signal == SIGCHLD &&
598 e->n_enabled_child_sources > 0);
601 static int event_update_signal_fd(sd_event *e) {
602 struct epoll_event ev = {};
608 add_to_epoll = e->signal_fd < 0;
610 r = signalfd(e->signal_fd, &e->sigset, SFD_NONBLOCK|SFD_CLOEXEC);
620 ev.data.ptr = INT_TO_PTR(SOURCE_SIGNAL);
622 r = epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, e->signal_fd, &ev);
624 e->signal_fd = safe_close(e->signal_fd);
631 static void source_disconnect(sd_event_source *s) {
639 assert(s->event->n_sources > 0);
645 source_io_unregister(s);
649 case SOURCE_TIME_REALTIME:
650 case SOURCE_TIME_BOOTTIME:
651 case SOURCE_TIME_MONOTONIC:
652 case SOURCE_TIME_REALTIME_ALARM:
653 case SOURCE_TIME_BOOTTIME_ALARM: {
654 struct clock_data *d;
656 d = event_get_clock_data(s->event, s->type);
659 prioq_remove(d->earliest, s, &s->time.earliest_index);
660 prioq_remove(d->latest, s, &s->time.latest_index);
661 d->needs_rearm = true;
666 if (s->signal.sig > 0) {
667 if (s->event->signal_sources)
668 s->event->signal_sources[s->signal.sig] = NULL;
670 /* If the signal was on and now it is off... */
671 if (s->enabled != SD_EVENT_OFF && !need_signal(s->event, s->signal.sig)) {
672 assert_se(sigdelset(&s->event->sigset, s->signal.sig) == 0);
674 (void) event_update_signal_fd(s->event);
675 /* If disabling failed, we might get a spurious event,
676 * but otherwise nothing bad should happen. */
683 if (s->child.pid > 0) {
684 if (s->enabled != SD_EVENT_OFF) {
685 assert(s->event->n_enabled_child_sources > 0);
686 s->event->n_enabled_child_sources--;
688 /* We know the signal was on, if it is off now... */
689 if (!need_signal(s->event, SIGCHLD)) {
690 assert_se(sigdelset(&s->event->sigset, SIGCHLD) == 0);
692 (void) event_update_signal_fd(s->event);
693 /* If disabling failed, we might get a spurious event,
694 * but otherwise nothing bad should happen. */
698 hashmap_remove(s->event->child_sources, INT_TO_PTR(s->child.pid));
708 set_remove(s->event->post_sources, s);
712 prioq_remove(s->event->exit, s, &s->exit.prioq_index);
716 assert_not_reached("Wut? I shouldn't exist.");
720 prioq_remove(s->event->pending, s, &s->pending_index);
723 prioq_remove(s->event->prepare, s, &s->prepare_index);
727 s->type = _SOURCE_EVENT_SOURCE_TYPE_INVALID;
729 LIST_REMOVE(sources, event->sources, s);
733 sd_event_unref(event);
736 static void source_free(sd_event_source *s) {
739 source_disconnect(s);
740 free(s->description);
744 static int source_set_pending(sd_event_source *s, bool b) {
748 assert(s->type != SOURCE_EXIT);
756 s->pending_iteration = s->event->iteration;
758 r = prioq_put(s->event->pending, s, &s->pending_index);
764 assert_se(prioq_remove(s->event->pending, s, &s->pending_index));
766 if (EVENT_SOURCE_IS_TIME(s->type)) {
767 struct clock_data *d;
769 d = event_get_clock_data(s->event, s->type);
772 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
773 prioq_reshuffle(d->latest, s, &s->time.latest_index);
774 d->needs_rearm = true;
780 static sd_event_source *source_new(sd_event *e, bool floating, EventSourceType type) {
785 s = new0(sd_event_source, 1);
791 s->floating = floating;
793 s->pending_index = s->prepare_index = PRIOQ_IDX_NULL;
798 LIST_PREPEND(sources, e->sources, s);
804 _public_ int sd_event_add_io(
806 sd_event_source **ret,
809 sd_event_io_handler_t callback,
815 assert_return(e, -EINVAL);
816 assert_return(fd >= 0, -EINVAL);
817 assert_return(!(events & ~(EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLPRI|EPOLLERR|EPOLLHUP|EPOLLET)), -EINVAL);
818 assert_return(callback, -EINVAL);
819 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
820 assert_return(!event_pid_changed(e), -ECHILD);
822 s = source_new(e, !ret, SOURCE_IO);
827 s->io.events = events;
828 s->io.callback = callback;
829 s->userdata = userdata;
830 s->enabled = SD_EVENT_ON;
832 r = source_io_register(s, s->enabled, events);
844 static void initialize_perturb(sd_event *e) {
845 sd_id128_t bootid = {};
847 /* When we sleep for longer, we try to realign the wakeup to
848 the same time wihtin each minute/second/250ms, so that
849 events all across the system can be coalesced into a single
850 CPU wakeup. However, let's take some system-specific
851 randomness for this value, so that in a network of systems
852 with synced clocks timer events are distributed a
853 bit. Here, we calculate a perturbation usec offset from the
856 if (_likely_(e->perturb != USEC_INFINITY))
859 if (sd_id128_get_boot(&bootid) >= 0)
860 e->perturb = (bootid.qwords[0] ^ bootid.qwords[1]) % USEC_PER_MINUTE;
863 static int event_setup_timer_fd(
865 struct clock_data *d,
868 struct epoll_event ev = {};
874 if (_likely_(d->fd >= 0))
877 fd = timerfd_create(clock, TFD_NONBLOCK|TFD_CLOEXEC);
882 ev.data.ptr = INT_TO_PTR(clock_to_event_source_type(clock));
884 r = epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, fd, &ev);
894 static int time_exit_callback(sd_event_source *s, uint64_t usec, void *userdata) {
897 return sd_event_exit(sd_event_source_get_event(s), PTR_TO_INT(userdata));
900 _public_ int sd_event_add_time(
902 sd_event_source **ret,
906 sd_event_time_handler_t callback,
909 EventSourceType type;
911 struct clock_data *d;
914 assert_return(e, -EINVAL);
915 assert_return(usec != (uint64_t) -1, -EINVAL);
916 assert_return(accuracy != (uint64_t) -1, -EINVAL);
917 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
918 assert_return(!event_pid_changed(e), -ECHILD);
921 callback = time_exit_callback;
923 type = clock_to_event_source_type(clock);
924 assert_return(type >= 0, -ENOTSUP);
926 d = event_get_clock_data(e, type);
930 d->earliest = prioq_new(earliest_time_prioq_compare);
936 d->latest = prioq_new(latest_time_prioq_compare);
942 r = event_setup_timer_fd(e, d, clock);
947 s = source_new(e, !ret, type);
952 s->time.accuracy = accuracy == 0 ? DEFAULT_ACCURACY_USEC : accuracy;
953 s->time.callback = callback;
954 s->time.earliest_index = s->time.latest_index = PRIOQ_IDX_NULL;
955 s->userdata = userdata;
956 s->enabled = SD_EVENT_ONESHOT;
958 d->needs_rearm = true;
960 r = prioq_put(d->earliest, s, &s->time.earliest_index);
964 r = prioq_put(d->latest, s, &s->time.latest_index);
978 static int signal_exit_callback(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
981 return sd_event_exit(sd_event_source_get_event(s), PTR_TO_INT(userdata));
984 _public_ int sd_event_add_signal(
986 sd_event_source **ret,
988 sd_event_signal_handler_t callback,
996 assert_return(e, -EINVAL);
997 assert_return(sig > 0, -EINVAL);
998 assert_return(sig < _NSIG, -EINVAL);
999 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1000 assert_return(!event_pid_changed(e), -ECHILD);
1003 callback = signal_exit_callback;
1005 r = pthread_sigmask(SIG_SETMASK, NULL, &ss);
1009 if (!sigismember(&ss, sig))
1012 if (!e->signal_sources) {
1013 e->signal_sources = new0(sd_event_source*, _NSIG);
1014 if (!e->signal_sources)
1016 } else if (e->signal_sources[sig])
1019 previous = need_signal(e, sig);
1021 s = source_new(e, !ret, SOURCE_SIGNAL);
1025 s->signal.sig = sig;
1026 s->signal.callback = callback;
1027 s->userdata = userdata;
1028 s->enabled = SD_EVENT_ON;
1030 e->signal_sources[sig] = s;
1033 assert_se(sigaddset(&e->sigset, sig) == 0);
1035 r = event_update_signal_fd(e);
1042 /* Use the signal name as description for the event source by default */
1043 (void) sd_event_source_set_description(s, signal_to_string(sig));
1051 _public_ int sd_event_add_child(
1053 sd_event_source **ret,
1056 sd_event_child_handler_t callback,
1063 assert_return(e, -EINVAL);
1064 assert_return(pid > 1, -EINVAL);
1065 assert_return(!(options & ~(WEXITED|WSTOPPED|WCONTINUED)), -EINVAL);
1066 assert_return(options != 0, -EINVAL);
1067 assert_return(callback, -EINVAL);
1068 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1069 assert_return(!event_pid_changed(e), -ECHILD);
1071 r = hashmap_ensure_allocated(&e->child_sources, NULL);
1075 if (hashmap_contains(e->child_sources, INT_TO_PTR(pid)))
1078 previous = need_signal(e, SIGCHLD);
1080 s = source_new(e, !ret, SOURCE_CHILD);
1085 s->child.options = options;
1086 s->child.callback = callback;
1087 s->userdata = userdata;
1088 s->enabled = SD_EVENT_ONESHOT;
1090 r = hashmap_put(e->child_sources, INT_TO_PTR(pid), s);
1096 e->n_enabled_child_sources ++;
1099 assert_se(sigaddset(&e->sigset, SIGCHLD) == 0);
1101 r = event_update_signal_fd(e);
1108 e->need_process_child = true;
1116 _public_ int sd_event_add_defer(
1118 sd_event_source **ret,
1119 sd_event_handler_t callback,
1125 assert_return(e, -EINVAL);
1126 assert_return(callback, -EINVAL);
1127 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1128 assert_return(!event_pid_changed(e), -ECHILD);
1130 s = source_new(e, !ret, SOURCE_DEFER);
1134 s->defer.callback = callback;
1135 s->userdata = userdata;
1136 s->enabled = SD_EVENT_ONESHOT;
1138 r = source_set_pending(s, true);
1150 _public_ int sd_event_add_post(
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);
1164 r = set_ensure_allocated(&e->post_sources, NULL);
1168 s = source_new(e, !ret, SOURCE_POST);
1172 s->post.callback = callback;
1173 s->userdata = userdata;
1174 s->enabled = SD_EVENT_ON;
1176 r = set_put(e->post_sources, s);
1188 _public_ int sd_event_add_exit(
1190 sd_event_source **ret,
1191 sd_event_handler_t callback,
1197 assert_return(e, -EINVAL);
1198 assert_return(callback, -EINVAL);
1199 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1200 assert_return(!event_pid_changed(e), -ECHILD);
1203 e->exit = prioq_new(exit_prioq_compare);
1208 s = source_new(e, !ret, SOURCE_EXIT);
1212 s->exit.callback = callback;
1213 s->userdata = userdata;
1214 s->exit.prioq_index = PRIOQ_IDX_NULL;
1215 s->enabled = SD_EVENT_ONESHOT;
1217 r = prioq_put(s->event->exit, s, &s->exit.prioq_index);
1229 _public_ sd_event_source* sd_event_source_ref(sd_event_source *s) {
1230 assert_return(s, NULL);
1232 assert(s->n_ref >= 1);
1238 _public_ sd_event_source* sd_event_source_unref(sd_event_source *s) {
1243 assert(s->n_ref >= 1);
1246 if (s->n_ref <= 0) {
1247 /* Here's a special hack: when we are called from a
1248 * dispatch handler we won't free the event source
1249 * immediately, but we will detach the fd from the
1250 * epoll. This way it is safe for the caller to unref
1251 * the event source and immediately close the fd, but
1252 * we still retain a valid event source object after
1255 if (s->dispatching) {
1256 if (s->type == SOURCE_IO)
1257 source_io_unregister(s);
1259 source_disconnect(s);
1267 _public_ int sd_event_source_set_description(sd_event_source *s, const char *description) {
1268 assert_return(s, -EINVAL);
1269 assert_return(!event_pid_changed(s->event), -ECHILD);
1271 return free_and_strdup(&s->description, description);
1274 _public_ int sd_event_source_get_description(sd_event_source *s, const char **description) {
1275 assert_return(s, -EINVAL);
1276 assert_return(description, -EINVAL);
1277 assert_return(s->description, -ENXIO);
1278 assert_return(!event_pid_changed(s->event), -ECHILD);
1280 *description = s->description;
1284 _public_ sd_event *sd_event_source_get_event(sd_event_source *s) {
1285 assert_return(s, NULL);
1290 _public_ int sd_event_source_get_pending(sd_event_source *s) {
1291 assert_return(s, -EINVAL);
1292 assert_return(s->type != SOURCE_EXIT, -EDOM);
1293 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1294 assert_return(!event_pid_changed(s->event), -ECHILD);
1299 _public_ int sd_event_source_get_io_fd(sd_event_source *s) {
1300 assert_return(s, -EINVAL);
1301 assert_return(s->type == SOURCE_IO, -EDOM);
1302 assert_return(!event_pid_changed(s->event), -ECHILD);
1307 _public_ int sd_event_source_set_io_fd(sd_event_source *s, int fd) {
1310 assert_return(s, -EINVAL);
1311 assert_return(fd >= 0, -EINVAL);
1312 assert_return(s->type == SOURCE_IO, -EDOM);
1313 assert_return(!event_pid_changed(s->event), -ECHILD);
1318 if (s->enabled == SD_EVENT_OFF) {
1320 s->io.registered = false;
1324 saved_fd = s->io.fd;
1325 assert(s->io.registered);
1328 s->io.registered = false;
1330 r = source_io_register(s, s->enabled, s->io.events);
1332 s->io.fd = saved_fd;
1333 s->io.registered = true;
1337 epoll_ctl(s->event->epoll_fd, EPOLL_CTL_DEL, saved_fd, NULL);
1343 _public_ int sd_event_source_get_io_events(sd_event_source *s, uint32_t* events) {
1344 assert_return(s, -EINVAL);
1345 assert_return(events, -EINVAL);
1346 assert_return(s->type == SOURCE_IO, -EDOM);
1347 assert_return(!event_pid_changed(s->event), -ECHILD);
1349 *events = s->io.events;
1353 _public_ int sd_event_source_set_io_events(sd_event_source *s, uint32_t events) {
1356 assert_return(s, -EINVAL);
1357 assert_return(s->type == SOURCE_IO, -EDOM);
1358 assert_return(!(events & ~(EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLPRI|EPOLLERR|EPOLLHUP|EPOLLET)), -EINVAL);
1359 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1360 assert_return(!event_pid_changed(s->event), -ECHILD);
1362 /* edge-triggered updates are never skipped, so we can reset edges */
1363 if (s->io.events == events && !(events & EPOLLET))
1366 if (s->enabled != SD_EVENT_OFF) {
1367 r = source_io_register(s, s->enabled, events);
1372 s->io.events = events;
1373 source_set_pending(s, false);
1378 _public_ int sd_event_source_get_io_revents(sd_event_source *s, uint32_t* revents) {
1379 assert_return(s, -EINVAL);
1380 assert_return(revents, -EINVAL);
1381 assert_return(s->type == SOURCE_IO, -EDOM);
1382 assert_return(s->pending, -ENODATA);
1383 assert_return(!event_pid_changed(s->event), -ECHILD);
1385 *revents = s->io.revents;
1389 _public_ int sd_event_source_get_signal(sd_event_source *s) {
1390 assert_return(s, -EINVAL);
1391 assert_return(s->type == SOURCE_SIGNAL, -EDOM);
1392 assert_return(!event_pid_changed(s->event), -ECHILD);
1394 return s->signal.sig;
1397 _public_ int sd_event_source_get_priority(sd_event_source *s, int64_t *priority) {
1398 assert_return(s, -EINVAL);
1399 assert_return(!event_pid_changed(s->event), -ECHILD);
1404 _public_ int sd_event_source_set_priority(sd_event_source *s, int64_t priority) {
1405 assert_return(s, -EINVAL);
1406 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1407 assert_return(!event_pid_changed(s->event), -ECHILD);
1409 if (s->priority == priority)
1412 s->priority = priority;
1415 prioq_reshuffle(s->event->pending, s, &s->pending_index);
1418 prioq_reshuffle(s->event->prepare, s, &s->prepare_index);
1420 if (s->type == SOURCE_EXIT)
1421 prioq_reshuffle(s->event->exit, s, &s->exit.prioq_index);
1426 _public_ int sd_event_source_get_enabled(sd_event_source *s, int *m) {
1427 assert_return(s, -EINVAL);
1428 assert_return(m, -EINVAL);
1429 assert_return(!event_pid_changed(s->event), -ECHILD);
1435 _public_ int sd_event_source_set_enabled(sd_event_source *s, int m) {
1438 assert_return(s, -EINVAL);
1439 assert_return(m == SD_EVENT_OFF || m == SD_EVENT_ON || m == SD_EVENT_ONESHOT, -EINVAL);
1440 assert_return(!event_pid_changed(s->event), -ECHILD);
1442 /* If we are dead anyway, we are fine with turning off
1443 * sources, but everything else needs to fail. */
1444 if (s->event->state == SD_EVENT_FINISHED)
1445 return m == SD_EVENT_OFF ? 0 : -ESTALE;
1447 if (s->enabled == m)
1450 if (m == SD_EVENT_OFF) {
1455 r = source_io_unregister(s);
1462 case SOURCE_TIME_REALTIME:
1463 case SOURCE_TIME_BOOTTIME:
1464 case SOURCE_TIME_MONOTONIC:
1465 case SOURCE_TIME_REALTIME_ALARM:
1466 case SOURCE_TIME_BOOTTIME_ALARM: {
1467 struct clock_data *d;
1470 d = event_get_clock_data(s->event, s->type);
1473 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
1474 prioq_reshuffle(d->latest, s, &s->time.latest_index);
1475 d->needs_rearm = true;
1480 assert(need_signal(s->event, s->signal.sig));
1484 if (!need_signal(s->event, s->signal.sig)) {
1485 assert_se(sigdelset(&s->event->sigset, s->signal.sig) == 0);
1487 (void) event_update_signal_fd(s->event);
1488 /* If disabling failed, we might get a spurious event,
1489 * but otherwise nothing bad should happen. */
1495 assert(need_signal(s->event, SIGCHLD));
1499 assert(s->event->n_enabled_child_sources > 0);
1500 s->event->n_enabled_child_sources--;
1502 if (!need_signal(s->event, SIGCHLD)) {
1503 assert_se(sigdelset(&s->event->sigset, SIGCHLD) == 0);
1505 (void) event_update_signal_fd(s->event);
1512 prioq_reshuffle(s->event->exit, s, &s->exit.prioq_index);
1521 assert_not_reached("Wut? I shouldn't exist.");
1528 r = source_io_register(s, m, s->io.events);
1535 case SOURCE_TIME_REALTIME:
1536 case SOURCE_TIME_BOOTTIME:
1537 case SOURCE_TIME_MONOTONIC:
1538 case SOURCE_TIME_REALTIME_ALARM:
1539 case SOURCE_TIME_BOOTTIME_ALARM: {
1540 struct clock_data *d;
1543 d = event_get_clock_data(s->event, s->type);
1546 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
1547 prioq_reshuffle(d->latest, s, &s->time.latest_index);
1548 d->needs_rearm = true;
1553 /* Check status before enabling. */
1554 if (!need_signal(s->event, s->signal.sig)) {
1555 assert_se(sigaddset(&s->event->sigset, s->signal.sig) == 0);
1557 r = event_update_signal_fd(s->event);
1559 s->enabled = SD_EVENT_OFF;
1568 /* Check status before enabling. */
1569 if (s->enabled == SD_EVENT_OFF) {
1570 if (!need_signal(s->event, SIGCHLD)) {
1571 assert_se(sigaddset(&s->event->sigset, s->signal.sig) == 0);
1573 r = event_update_signal_fd(s->event);
1575 s->enabled = SD_EVENT_OFF;
1580 s->event->n_enabled_child_sources++;
1588 prioq_reshuffle(s->event->exit, s, &s->exit.prioq_index);
1597 assert_not_reached("Wut? I shouldn't exist.");
1602 prioq_reshuffle(s->event->pending, s, &s->pending_index);
1605 prioq_reshuffle(s->event->prepare, s, &s->prepare_index);
1610 _public_ int sd_event_source_get_time(sd_event_source *s, uint64_t *usec) {
1611 assert_return(s, -EINVAL);
1612 assert_return(usec, -EINVAL);
1613 assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1614 assert_return(!event_pid_changed(s->event), -ECHILD);
1616 *usec = s->time.next;
1620 _public_ int sd_event_source_set_time(sd_event_source *s, uint64_t usec) {
1621 struct clock_data *d;
1623 assert_return(s, -EINVAL);
1624 assert_return(usec != (uint64_t) -1, -EINVAL);
1625 assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1626 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1627 assert_return(!event_pid_changed(s->event), -ECHILD);
1629 s->time.next = usec;
1631 source_set_pending(s, false);
1633 d = event_get_clock_data(s->event, s->type);
1636 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
1637 prioq_reshuffle(d->latest, s, &s->time.latest_index);
1638 d->needs_rearm = true;
1643 _public_ int sd_event_source_get_time_accuracy(sd_event_source *s, uint64_t *usec) {
1644 assert_return(s, -EINVAL);
1645 assert_return(usec, -EINVAL);
1646 assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1647 assert_return(!event_pid_changed(s->event), -ECHILD);
1649 *usec = s->time.accuracy;
1653 _public_ int sd_event_source_set_time_accuracy(sd_event_source *s, uint64_t usec) {
1654 struct clock_data *d;
1656 assert_return(s, -EINVAL);
1657 assert_return(usec != (uint64_t) -1, -EINVAL);
1658 assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1659 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1660 assert_return(!event_pid_changed(s->event), -ECHILD);
1663 usec = DEFAULT_ACCURACY_USEC;
1665 s->time.accuracy = usec;
1667 source_set_pending(s, false);
1669 d = event_get_clock_data(s->event, s->type);
1672 prioq_reshuffle(d->latest, s, &s->time.latest_index);
1673 d->needs_rearm = true;
1678 _public_ int sd_event_source_get_time_clock(sd_event_source *s, clockid_t *clock) {
1679 assert_return(s, -EINVAL);
1680 assert_return(clock, -EINVAL);
1681 assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
1682 assert_return(!event_pid_changed(s->event), -ECHILD);
1684 *clock = event_source_type_to_clock(s->type);
1688 _public_ int sd_event_source_get_child_pid(sd_event_source *s, pid_t *pid) {
1689 assert_return(s, -EINVAL);
1690 assert_return(pid, -EINVAL);
1691 assert_return(s->type == SOURCE_CHILD, -EDOM);
1692 assert_return(!event_pid_changed(s->event), -ECHILD);
1694 *pid = s->child.pid;
1698 _public_ int sd_event_source_set_prepare(sd_event_source *s, sd_event_handler_t callback) {
1701 assert_return(s, -EINVAL);
1702 assert_return(s->type != SOURCE_EXIT, -EDOM);
1703 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1704 assert_return(!event_pid_changed(s->event), -ECHILD);
1706 if (s->prepare == callback)
1709 if (callback && s->prepare) {
1710 s->prepare = callback;
1714 r = prioq_ensure_allocated(&s->event->prepare, prepare_prioq_compare);
1718 s->prepare = callback;
1721 r = prioq_put(s->event->prepare, s, &s->prepare_index);
1725 prioq_remove(s->event->prepare, s, &s->prepare_index);
1730 _public_ void* sd_event_source_get_userdata(sd_event_source *s) {
1731 assert_return(s, NULL);
1736 _public_ void *sd_event_source_set_userdata(sd_event_source *s, void *userdata) {
1739 assert_return(s, NULL);
1742 s->userdata = userdata;
1747 static usec_t sleep_between(sd_event *e, usec_t a, usec_t b) {
1758 initialize_perturb(e);
1761 Find a good time to wake up again between times a and b. We
1762 have two goals here:
1764 a) We want to wake up as seldom as possible, hence prefer
1765 later times over earlier times.
1767 b) But if we have to wake up, then let's make sure to
1768 dispatch as much as possible on the entire system.
1770 We implement this by waking up everywhere at the same time
1771 within any given minute if we can, synchronised via the
1772 perturbation value determined from the boot ID. If we can't,
1773 then we try to find the same spot in every 10s, then 1s and
1774 then 250ms step. Otherwise, we pick the last possible time
1778 c = (b / USEC_PER_MINUTE) * USEC_PER_MINUTE + e->perturb;
1780 if (_unlikely_(c < USEC_PER_MINUTE))
1783 c -= USEC_PER_MINUTE;
1789 c = (b / (USEC_PER_SEC*10)) * (USEC_PER_SEC*10) + (e->perturb % (USEC_PER_SEC*10));
1791 if (_unlikely_(c < USEC_PER_SEC*10))
1794 c -= USEC_PER_SEC*10;
1800 c = (b / USEC_PER_SEC) * USEC_PER_SEC + (e->perturb % USEC_PER_SEC);
1802 if (_unlikely_(c < USEC_PER_SEC))
1811 c = (b / (USEC_PER_MSEC*250)) * (USEC_PER_MSEC*250) + (e->perturb % (USEC_PER_MSEC*250));
1813 if (_unlikely_(c < USEC_PER_MSEC*250))
1816 c -= USEC_PER_MSEC*250;
1825 static int event_arm_timer(
1827 struct clock_data *d) {
1829 struct itimerspec its = {};
1830 sd_event_source *a, *b;
1837 if (!d->needs_rearm)
1840 d->needs_rearm = false;
1842 a = prioq_peek(d->earliest);
1843 if (!a || a->enabled == SD_EVENT_OFF) {
1848 if (d->next == USEC_INFINITY)
1852 r = timerfd_settime(d->fd, TFD_TIMER_ABSTIME, &its, NULL);
1856 d->next = USEC_INFINITY;
1860 b = prioq_peek(d->latest);
1861 assert_se(b && b->enabled != SD_EVENT_OFF);
1863 t = sleep_between(e, a->time.next, b->time.next + b->time.accuracy);
1867 assert_se(d->fd >= 0);
1870 /* We don' want to disarm here, just mean some time looooong ago. */
1871 its.it_value.tv_sec = 0;
1872 its.it_value.tv_nsec = 1;
1874 timespec_store(&its.it_value, t);
1876 r = timerfd_settime(d->fd, TFD_TIMER_ABSTIME, &its, NULL);
1884 static int process_io(sd_event *e, sd_event_source *s, uint32_t revents) {
1887 assert(s->type == SOURCE_IO);
1889 /* If the event source was already pending, we just OR in the
1890 * new revents, otherwise we reset the value. The ORing is
1891 * necessary to handle EPOLLONESHOT events properly where
1892 * readability might happen independently of writability, and
1893 * we need to keep track of both */
1896 s->io.revents |= revents;
1898 s->io.revents = revents;
1900 return source_set_pending(s, true);
1903 static int flush_timer(sd_event *e, int fd, uint32_t events, usec_t *next) {
1910 assert_return(events == EPOLLIN, -EIO);
1912 ss = read(fd, &x, sizeof(x));
1914 if (errno == EAGAIN || errno == EINTR)
1920 if (_unlikely_(ss != sizeof(x)))
1924 *next = USEC_INFINITY;
1929 static int process_timer(
1932 struct clock_data *d) {
1941 s = prioq_peek(d->earliest);
1944 s->enabled == SD_EVENT_OFF ||
1948 r = source_set_pending(s, true);
1952 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
1953 prioq_reshuffle(d->latest, s, &s->time.latest_index);
1954 d->needs_rearm = true;
1960 static int process_child(sd_event *e) {
1967 e->need_process_child = false;
1970 So, this is ugly. We iteratively invoke waitid() with P_PID
1971 + WNOHANG for each PID we wait for, instead of using
1972 P_ALL. This is because we only want to get child
1973 information of very specific child processes, and not all
1974 of them. We might not have processed the SIGCHLD even of a
1975 previous invocation and we don't want to maintain a
1976 unbounded *per-child* event queue, hence we really don't
1977 want anything flushed out of the kernel's queue that we
1978 don't care about. Since this is O(n) this means that if you
1979 have a lot of processes you probably want to handle SIGCHLD
1982 We do not reap the children here (by using WNOWAIT), this
1983 is only done after the event source is dispatched so that
1984 the callback still sees the process as a zombie.
1987 HASHMAP_FOREACH(s, e->child_sources, i) {
1988 assert(s->type == SOURCE_CHILD);
1993 if (s->enabled == SD_EVENT_OFF)
1996 zero(s->child.siginfo);
1997 r = waitid(P_PID, s->child.pid, &s->child.siginfo,
1998 WNOHANG | (s->child.options & WEXITED ? WNOWAIT : 0) | s->child.options);
2002 if (s->child.siginfo.si_pid != 0) {
2004 s->child.siginfo.si_code == CLD_EXITED ||
2005 s->child.siginfo.si_code == CLD_KILLED ||
2006 s->child.siginfo.si_code == CLD_DUMPED;
2008 if (!zombie && (s->child.options & WEXITED)) {
2009 /* If the child isn't dead then let's
2010 * immediately remove the state change
2011 * from the queue, since there's no
2012 * benefit in leaving it queued */
2014 assert(s->child.options & (WSTOPPED|WCONTINUED));
2015 waitid(P_PID, s->child.pid, &s->child.siginfo, WNOHANG|(s->child.options & (WSTOPPED|WCONTINUED)));
2018 r = source_set_pending(s, true);
2027 static int process_signal(sd_event *e, uint32_t events) {
2028 bool read_one = false;
2033 assert_return(events == EPOLLIN, -EIO);
2036 struct signalfd_siginfo si;
2038 sd_event_source *s = NULL;
2040 n = read(e->signal_fd, &si, sizeof(si));
2042 if (errno == EAGAIN || errno == EINTR)
2048 if (_unlikely_(n != sizeof(si)))
2051 assert(si.ssi_signo < _NSIG);
2055 if (si.ssi_signo == SIGCHLD) {
2056 r = process_child(e);
2063 if (e->signal_sources)
2064 s = e->signal_sources[si.ssi_signo];
2069 s->signal.siginfo = si;
2070 r = source_set_pending(s, true);
2076 static int source_dispatch(sd_event_source *s) {
2080 assert(s->pending || s->type == SOURCE_EXIT);
2082 if (s->type != SOURCE_DEFER && s->type != SOURCE_EXIT) {
2083 r = source_set_pending(s, false);
2088 if (s->type != SOURCE_POST) {
2092 /* If we execute a non-post source, let's mark all
2093 * post sources as pending */
2095 SET_FOREACH(z, s->event->post_sources, i) {
2096 if (z->enabled == SD_EVENT_OFF)
2099 r = source_set_pending(z, true);
2105 if (s->enabled == SD_EVENT_ONESHOT) {
2106 r = sd_event_source_set_enabled(s, SD_EVENT_OFF);
2111 s->dispatching = true;
2116 r = s->io.callback(s, s->io.fd, s->io.revents, s->userdata);
2119 case SOURCE_TIME_REALTIME:
2120 case SOURCE_TIME_BOOTTIME:
2121 case SOURCE_TIME_MONOTONIC:
2122 case SOURCE_TIME_REALTIME_ALARM:
2123 case SOURCE_TIME_BOOTTIME_ALARM:
2124 r = s->time.callback(s, s->time.next, s->userdata);
2128 r = s->signal.callback(s, &s->signal.siginfo, s->userdata);
2131 case SOURCE_CHILD: {
2134 zombie = s->child.siginfo.si_code == CLD_EXITED ||
2135 s->child.siginfo.si_code == CLD_KILLED ||
2136 s->child.siginfo.si_code == CLD_DUMPED;
2138 r = s->child.callback(s, &s->child.siginfo, s->userdata);
2140 /* Now, reap the PID for good. */
2142 waitid(P_PID, s->child.pid, &s->child.siginfo, WNOHANG|WEXITED);
2148 r = s->defer.callback(s, s->userdata);
2152 r = s->post.callback(s, s->userdata);
2156 r = s->exit.callback(s, s->userdata);
2159 case SOURCE_WATCHDOG:
2160 case _SOURCE_EVENT_SOURCE_TYPE_MAX:
2161 case _SOURCE_EVENT_SOURCE_TYPE_INVALID:
2162 assert_not_reached("Wut? I shouldn't exist.");
2165 s->dispatching = false;
2169 log_debug_errno(r, "Event source '%s' returned error, disabling: %m", s->description);
2171 log_debug_errno(r, "Event source %p returned error, disabling: %m", s);
2177 sd_event_source_set_enabled(s, SD_EVENT_OFF);
2182 static int event_prepare(sd_event *e) {
2190 s = prioq_peek(e->prepare);
2191 if (!s || s->prepare_iteration == e->iteration || s->enabled == SD_EVENT_OFF)
2194 s->prepare_iteration = e->iteration;
2195 r = prioq_reshuffle(e->prepare, s, &s->prepare_index);
2201 s->dispatching = true;
2202 r = s->prepare(s, s->userdata);
2203 s->dispatching = false;
2207 log_debug_errno(r, "Prepare callback of event source '%s' returned error, disabling: %m", s->description);
2209 log_debug_errno(r, "Prepare callback of event source %p returned error, disabling: %m", s);
2215 sd_event_source_set_enabled(s, SD_EVENT_OFF);
2221 static int dispatch_exit(sd_event *e) {
2227 p = prioq_peek(e->exit);
2228 if (!p || p->enabled == SD_EVENT_OFF) {
2229 e->state = SD_EVENT_FINISHED;
2235 e->state = SD_EVENT_EXITING;
2237 r = source_dispatch(p);
2239 e->state = SD_EVENT_PASSIVE;
2245 static sd_event_source* event_next_pending(sd_event *e) {
2250 p = prioq_peek(e->pending);
2254 if (p->enabled == SD_EVENT_OFF)
2260 static int arm_watchdog(sd_event *e) {
2261 struct itimerspec its = {};
2266 assert(e->watchdog_fd >= 0);
2268 t = sleep_between(e,
2269 e->watchdog_last + (e->watchdog_period / 2),
2270 e->watchdog_last + (e->watchdog_period * 3 / 4));
2272 timespec_store(&its.it_value, t);
2274 /* Make sure we never set the watchdog to 0, which tells the
2275 * kernel to disable it. */
2276 if (its.it_value.tv_sec == 0 && its.it_value.tv_nsec == 0)
2277 its.it_value.tv_nsec = 1;
2279 r = timerfd_settime(e->watchdog_fd, TFD_TIMER_ABSTIME, &its, NULL);
2286 static int process_watchdog(sd_event *e) {
2292 /* Don't notify watchdog too often */
2293 if (e->watchdog_last + e->watchdog_period / 4 > e->timestamp.monotonic)
2296 sd_notify(false, "WATCHDOG=1");
2297 e->watchdog_last = e->timestamp.monotonic;
2299 return arm_watchdog(e);
2302 _public_ int sd_event_prepare(sd_event *e) {
2305 assert_return(e, -EINVAL);
2306 assert_return(!event_pid_changed(e), -ECHILD);
2307 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2308 assert_return(e->state == SD_EVENT_PASSIVE, -EBUSY);
2310 if (e->exit_requested)
2315 r = event_prepare(e);
2319 r = event_arm_timer(e, &e->realtime);
2323 r = event_arm_timer(e, &e->boottime);
2327 r = event_arm_timer(e, &e->monotonic);
2331 r = event_arm_timer(e, &e->realtime_alarm);
2335 r = event_arm_timer(e, &e->boottime_alarm);
2339 if (event_next_pending(e) || e->need_process_child)
2342 e->state = SD_EVENT_PREPARED;
2347 e->state = SD_EVENT_PREPARED;
2348 r = sd_event_wait(e, 0);
2350 e->state = SD_EVENT_PREPARED;
2355 _public_ int sd_event_wait(sd_event *e, uint64_t timeout) {
2356 struct epoll_event *ev_queue;
2357 unsigned ev_queue_max;
2360 assert_return(e, -EINVAL);
2361 assert_return(!event_pid_changed(e), -ECHILD);
2362 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2363 assert_return(e->state == SD_EVENT_PREPARED, -EBUSY);
2365 if (e->exit_requested) {
2366 e->state = SD_EVENT_PENDING;
2370 ev_queue_max = CLAMP(e->n_sources, 1U, EPOLL_QUEUE_MAX);
2371 ev_queue = newa(struct epoll_event, ev_queue_max);
2373 m = epoll_wait(e->epoll_fd, ev_queue, ev_queue_max,
2374 timeout == (uint64_t) -1 ? -1 : (int) ((timeout + USEC_PER_MSEC - 1) / USEC_PER_MSEC));
2376 if (errno == EINTR) {
2377 e->state = SD_EVENT_PENDING;
2386 dual_timestamp_get(&e->timestamp);
2387 e->timestamp_boottime = now(CLOCK_BOOTTIME);
2389 for (i = 0; i < m; i++) {
2391 if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_TIME_REALTIME))
2392 r = flush_timer(e, e->realtime.fd, ev_queue[i].events, &e->realtime.next);
2393 else if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_TIME_BOOTTIME))
2394 r = flush_timer(e, e->boottime.fd, ev_queue[i].events, &e->boottime.next);
2395 else if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_TIME_MONOTONIC))
2396 r = flush_timer(e, e->monotonic.fd, ev_queue[i].events, &e->monotonic.next);
2397 else if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_TIME_REALTIME_ALARM))
2398 r = flush_timer(e, e->realtime_alarm.fd, ev_queue[i].events, &e->realtime_alarm.next);
2399 else if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_TIME_BOOTTIME_ALARM))
2400 r = flush_timer(e, e->boottime_alarm.fd, ev_queue[i].events, &e->boottime_alarm.next);
2401 else if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_SIGNAL))
2402 r = process_signal(e, ev_queue[i].events);
2403 else if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_WATCHDOG))
2404 r = flush_timer(e, e->watchdog_fd, ev_queue[i].events, NULL);
2406 r = process_io(e, ev_queue[i].data.ptr, ev_queue[i].events);
2412 r = process_watchdog(e);
2416 r = process_timer(e, e->timestamp.realtime, &e->realtime);
2420 r = process_timer(e, e->timestamp_boottime, &e->boottime);
2424 r = process_timer(e, e->timestamp.monotonic, &e->monotonic);
2428 r = process_timer(e, e->timestamp.realtime, &e->realtime_alarm);
2432 r = process_timer(e, e->timestamp_boottime, &e->boottime_alarm);
2436 if (e->need_process_child) {
2437 r = process_child(e);
2442 if (event_next_pending(e)) {
2443 e->state = SD_EVENT_PENDING;
2451 e->state = SD_EVENT_PASSIVE;
2456 _public_ int sd_event_dispatch(sd_event *e) {
2460 assert_return(e, -EINVAL);
2461 assert_return(!event_pid_changed(e), -ECHILD);
2462 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2463 assert_return(e->state == SD_EVENT_PENDING, -EBUSY);
2465 if (e->exit_requested)
2466 return dispatch_exit(e);
2468 p = event_next_pending(e);
2472 e->state = SD_EVENT_RUNNING;
2473 r = source_dispatch(p);
2474 e->state = SD_EVENT_PASSIVE;
2481 e->state = SD_EVENT_PASSIVE;
2486 _public_ int sd_event_run(sd_event *e, uint64_t timeout) {
2489 assert_return(e, -EINVAL);
2490 assert_return(!event_pid_changed(e), -ECHILD);
2491 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2492 assert_return(e->state == SD_EVENT_PASSIVE, -EBUSY);
2494 r = sd_event_prepare(e);
2496 return sd_event_dispatch(e);
2500 r = sd_event_wait(e, timeout);
2502 return sd_event_dispatch(e);
2507 _public_ int sd_event_loop(sd_event *e) {
2510 assert_return(e, -EINVAL);
2511 assert_return(!event_pid_changed(e), -ECHILD);
2512 assert_return(e->state == SD_EVENT_PASSIVE, -EBUSY);
2516 while (e->state != SD_EVENT_FINISHED) {
2517 r = sd_event_run(e, (uint64_t) -1);
2529 _public_ int sd_event_get_fd(sd_event *e) {
2531 assert_return(e, -EINVAL);
2532 assert_return(!event_pid_changed(e), -ECHILD);
2537 _public_ int sd_event_get_state(sd_event *e) {
2538 assert_return(e, -EINVAL);
2539 assert_return(!event_pid_changed(e), -ECHILD);
2544 _public_ int sd_event_get_exit_code(sd_event *e, int *code) {
2545 assert_return(e, -EINVAL);
2546 assert_return(code, -EINVAL);
2547 assert_return(!event_pid_changed(e), -ECHILD);
2549 if (!e->exit_requested)
2552 *code = e->exit_code;
2556 _public_ int sd_event_exit(sd_event *e, int code) {
2557 assert_return(e, -EINVAL);
2558 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
2559 assert_return(!event_pid_changed(e), -ECHILD);
2561 e->exit_requested = true;
2562 e->exit_code = code;
2567 _public_ int sd_event_now(sd_event *e, clockid_t clock, uint64_t *usec) {
2568 assert_return(e, -EINVAL);
2569 assert_return(usec, -EINVAL);
2570 assert_return(!event_pid_changed(e), -ECHILD);
2572 /* If we haven't run yet, just get the actual time */
2573 if (!dual_timestamp_is_set(&e->timestamp))
2578 case CLOCK_REALTIME:
2579 case CLOCK_REALTIME_ALARM:
2580 *usec = e->timestamp.realtime;
2583 case CLOCK_MONOTONIC:
2584 *usec = e->timestamp.monotonic;
2587 case CLOCK_BOOTTIME:
2588 case CLOCK_BOOTTIME_ALARM:
2589 *usec = e->timestamp_boottime;
2596 _public_ int sd_event_default(sd_event **ret) {
2598 static thread_local sd_event *default_event = NULL;
2603 return !!default_event;
2605 if (default_event) {
2606 *ret = sd_event_ref(default_event);
2610 r = sd_event_new(&e);
2614 e->default_event_ptr = &default_event;
2622 _public_ int sd_event_get_tid(sd_event *e, pid_t *tid) {
2623 assert_return(e, -EINVAL);
2624 assert_return(tid, -EINVAL);
2625 assert_return(!event_pid_changed(e), -ECHILD);
2635 _public_ int sd_event_set_watchdog(sd_event *e, int b) {
2638 assert_return(e, -EINVAL);
2639 assert_return(!event_pid_changed(e), -ECHILD);
2641 if (e->watchdog == !!b)
2645 struct epoll_event ev = {};
2647 r = sd_watchdog_enabled(false, &e->watchdog_period);
2651 /* Issue first ping immediately */
2652 sd_notify(false, "WATCHDOG=1");
2653 e->watchdog_last = now(CLOCK_MONOTONIC);
2655 e->watchdog_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
2656 if (e->watchdog_fd < 0)
2659 r = arm_watchdog(e);
2663 ev.events = EPOLLIN;
2664 ev.data.ptr = INT_TO_PTR(SOURCE_WATCHDOG);
2666 r = epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, e->watchdog_fd, &ev);
2673 if (e->watchdog_fd >= 0) {
2674 epoll_ctl(e->epoll_fd, EPOLL_CTL_DEL, e->watchdog_fd, NULL);
2675 e->watchdog_fd = safe_close(e->watchdog_fd);
2683 e->watchdog_fd = safe_close(e->watchdog_fd);
2687 _public_ int sd_event_get_watchdog(sd_event *e) {
2688 assert_return(e, -EINVAL);
2689 assert_return(!event_pid_changed(e), -ECHILD);