1 /* SPDX-License-Identifier: LGPL-2.1+ */
4 #include <sys/timerfd.h>
11 #include "alloc-util.h"
13 #include "event-source.h"
19 #include "memory-util.h"
20 #include "missing_syscall.h"
22 #include "process-util.h"
24 #include "signal-util.h"
25 #include "string-table.h"
26 #include "string-util.h"
28 #include "time-util.h"
30 #define DEFAULT_ACCURACY_USEC (250 * USEC_PER_MSEC)
32 static bool EVENT_SOURCE_WATCH_PIDFD(sd_event_source
*s
) {
33 /* Returns true if this is a PID event source and can be implemented by watching EPOLLIN */
35 s
->type
== SOURCE_CHILD
&&
36 s
->child
.pidfd
>= 0 &&
37 s
->child
.options
== WEXITED
;
40 static const char* const event_source_type_table
[_SOURCE_EVENT_SOURCE_TYPE_MAX
] = {
42 [SOURCE_TIME_REALTIME
] = "realtime",
43 [SOURCE_TIME_BOOTTIME
] = "bootime",
44 [SOURCE_TIME_MONOTONIC
] = "monotonic",
45 [SOURCE_TIME_REALTIME_ALARM
] = "realtime-alarm",
46 [SOURCE_TIME_BOOTTIME_ALARM
] = "boottime-alarm",
47 [SOURCE_SIGNAL
] = "signal",
48 [SOURCE_CHILD
] = "child",
49 [SOURCE_DEFER
] = "defer",
50 [SOURCE_POST
] = "post",
51 [SOURCE_EXIT
] = "exit",
52 [SOURCE_WATCHDOG
] = "watchdog",
53 [SOURCE_INOTIFY
] = "inotify",
56 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(event_source_type
, int);
58 #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)
69 /* timerfd_create() only supports these five clocks so far. We
70 * can add support for more clocks when the kernel learns to
71 * deal with them, too. */
72 struct clock_data realtime
;
73 struct clock_data boottime
;
74 struct clock_data monotonic
;
75 struct clock_data realtime_alarm
;
76 struct clock_data boottime_alarm
;
80 sd_event_source
**signal_sources
; /* indexed by signal number */
81 Hashmap
*signal_data
; /* indexed by priority */
83 Hashmap
*child_sources
;
84 unsigned n_enabled_child_sources
;
90 Hashmap
*inotify_data
; /* indexed by priority */
92 /* A list of inode structures that still have an fd open, that we need to close before the next loop iteration */
93 LIST_HEAD(struct inode_data
, inode_data_to_close
);
95 /* A list of inotify objects that already have events buffered which aren't processed yet */
96 LIST_HEAD(struct inotify_data
, inotify_data_buffered
);
101 triple_timestamp timestamp
;
104 bool exit_requested
:1;
105 bool need_process_child
:1;
107 bool profile_delays
:1;
112 sd_event
**default_event_ptr
;
114 usec_t watchdog_last
, watchdog_period
;
118 struct epoll_event
*event_queue
;
119 size_t event_queue_allocated
;
121 LIST_HEAD(sd_event_source
, sources
);
123 usec_t last_run
, last_log
;
124 unsigned delays
[sizeof(usec_t
) * 8];
127 static thread_local sd_event
*default_event
= NULL
;
129 static void source_disconnect(sd_event_source
*s
);
130 static void event_gc_inode_data(sd_event
*e
, struct inode_data
*d
);
132 static sd_event
*event_resolve(sd_event
*e
) {
133 return e
== SD_EVENT_DEFAULT
? default_event
: e
;
136 static int pending_prioq_compare(const void *a
, const void *b
) {
137 const sd_event_source
*x
= a
, *y
= b
;
143 /* Enabled ones first */
144 if (x
->enabled
!= SD_EVENT_OFF
&& y
->enabled
== SD_EVENT_OFF
)
146 if (x
->enabled
== SD_EVENT_OFF
&& y
->enabled
!= SD_EVENT_OFF
)
149 /* Lower priority values first */
150 r
= CMP(x
->priority
, y
->priority
);
154 /* Older entries first */
155 return CMP(x
->pending_iteration
, y
->pending_iteration
);
158 static int prepare_prioq_compare(const void *a
, const void *b
) {
159 const sd_event_source
*x
= a
, *y
= b
;
165 /* Enabled ones first */
166 if (x
->enabled
!= SD_EVENT_OFF
&& y
->enabled
== SD_EVENT_OFF
)
168 if (x
->enabled
== SD_EVENT_OFF
&& y
->enabled
!= SD_EVENT_OFF
)
171 /* Move most recently prepared ones last, so that we can stop
172 * preparing as soon as we hit one that has already been
173 * prepared in the current iteration */
174 r
= CMP(x
->prepare_iteration
, y
->prepare_iteration
);
178 /* Lower priority values first */
179 return CMP(x
->priority
, y
->priority
);
182 static int earliest_time_prioq_compare(const void *a
, const void *b
) {
183 const sd_event_source
*x
= a
, *y
= b
;
185 assert(EVENT_SOURCE_IS_TIME(x
->type
));
186 assert(x
->type
== y
->type
);
188 /* Enabled ones first */
189 if (x
->enabled
!= SD_EVENT_OFF
&& y
->enabled
== SD_EVENT_OFF
)
191 if (x
->enabled
== SD_EVENT_OFF
&& y
->enabled
!= SD_EVENT_OFF
)
194 /* Move the pending ones to the end */
195 if (!x
->pending
&& y
->pending
)
197 if (x
->pending
&& !y
->pending
)
201 return CMP(x
->time
.next
, y
->time
.next
);
204 static usec_t
time_event_source_latest(const sd_event_source
*s
) {
205 return usec_add(s
->time
.next
, s
->time
.accuracy
);
208 static int latest_time_prioq_compare(const void *a
, const void *b
) {
209 const sd_event_source
*x
= a
, *y
= b
;
211 assert(EVENT_SOURCE_IS_TIME(x
->type
));
212 assert(x
->type
== y
->type
);
214 /* Enabled ones first */
215 if (x
->enabled
!= SD_EVENT_OFF
&& y
->enabled
== SD_EVENT_OFF
)
217 if (x
->enabled
== SD_EVENT_OFF
&& y
->enabled
!= SD_EVENT_OFF
)
220 /* Move the pending ones to the end */
221 if (!x
->pending
&& y
->pending
)
223 if (x
->pending
&& !y
->pending
)
227 return CMP(time_event_source_latest(x
), time_event_source_latest(y
));
230 static int exit_prioq_compare(const void *a
, const void *b
) {
231 const sd_event_source
*x
= a
, *y
= b
;
233 assert(x
->type
== SOURCE_EXIT
);
234 assert(y
->type
== SOURCE_EXIT
);
236 /* Enabled ones first */
237 if (x
->enabled
!= SD_EVENT_OFF
&& y
->enabled
== SD_EVENT_OFF
)
239 if (x
->enabled
== SD_EVENT_OFF
&& y
->enabled
!= SD_EVENT_OFF
)
242 /* Lower priority values first */
243 return CMP(x
->priority
, y
->priority
);
246 static void free_clock_data(struct clock_data
*d
) {
248 assert(d
->wakeup
== WAKEUP_CLOCK_DATA
);
251 prioq_free(d
->earliest
);
252 prioq_free(d
->latest
);
255 static sd_event
*event_free(sd_event
*e
) {
260 while ((s
= e
->sources
)) {
262 source_disconnect(s
);
263 sd_event_source_unref(s
);
266 assert(e
->n_sources
== 0);
268 if (e
->default_event_ptr
)
269 *(e
->default_event_ptr
) = NULL
;
271 safe_close(e
->epoll_fd
);
272 safe_close(e
->watchdog_fd
);
274 free_clock_data(&e
->realtime
);
275 free_clock_data(&e
->boottime
);
276 free_clock_data(&e
->monotonic
);
277 free_clock_data(&e
->realtime_alarm
);
278 free_clock_data(&e
->boottime_alarm
);
280 prioq_free(e
->pending
);
281 prioq_free(e
->prepare
);
284 free(e
->signal_sources
);
285 hashmap_free(e
->signal_data
);
287 hashmap_free(e
->inotify_data
);
289 hashmap_free(e
->child_sources
);
290 set_free(e
->post_sources
);
292 free(e
->event_queue
);
297 _public_
int sd_event_new(sd_event
** ret
) {
301 assert_return(ret
, -EINVAL
);
303 e
= new(sd_event
, 1);
311 .realtime
.wakeup
= WAKEUP_CLOCK_DATA
,
313 .realtime
.next
= USEC_INFINITY
,
314 .boottime
.wakeup
= WAKEUP_CLOCK_DATA
,
316 .boottime
.next
= USEC_INFINITY
,
317 .monotonic
.wakeup
= WAKEUP_CLOCK_DATA
,
319 .monotonic
.next
= USEC_INFINITY
,
320 .realtime_alarm
.wakeup
= WAKEUP_CLOCK_DATA
,
321 .realtime_alarm
.fd
= -1,
322 .realtime_alarm
.next
= USEC_INFINITY
,
323 .boottime_alarm
.wakeup
= WAKEUP_CLOCK_DATA
,
324 .boottime_alarm
.fd
= -1,
325 .boottime_alarm
.next
= USEC_INFINITY
,
326 .perturb
= USEC_INFINITY
,
327 .original_pid
= getpid_cached(),
330 r
= prioq_ensure_allocated(&e
->pending
, pending_prioq_compare
);
334 e
->epoll_fd
= epoll_create1(EPOLL_CLOEXEC
);
335 if (e
->epoll_fd
< 0) {
340 e
->epoll_fd
= fd_move_above_stdio(e
->epoll_fd
);
342 if (secure_getenv("SD_EVENT_PROFILE_DELAYS")) {
343 log_debug("Event loop profiling enabled. Logarithmic histogram of event loop iterations in the range 2^0 ... 2^63 us will be logged every 5s.");
344 e
->profile_delays
= true;
355 DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_event
, sd_event
, event_free
);
357 _public_ sd_event_source
* sd_event_source_disable_unref(sd_event_source
*s
) {
359 (void) sd_event_source_set_enabled(s
, SD_EVENT_OFF
);
360 return sd_event_source_unref(s
);
363 static bool event_pid_changed(sd_event
*e
) {
366 /* We don't support people creating an event loop and keeping
367 * it around over a fork(). Let's complain. */
369 return e
->original_pid
!= getpid_cached();
372 static void source_io_unregister(sd_event_source
*s
) {
374 assert(s
->type
== SOURCE_IO
);
376 if (event_pid_changed(s
->event
))
379 if (!s
->io
.registered
)
382 if (epoll_ctl(s
->event
->epoll_fd
, EPOLL_CTL_DEL
, s
->io
.fd
, NULL
) < 0)
383 log_debug_errno(errno
, "Failed to remove source %s (type %s) from epoll: %m",
384 strna(s
->description
), event_source_type_to_string(s
->type
));
386 s
->io
.registered
= false;
389 static int source_io_register(
395 assert(s
->type
== SOURCE_IO
);
396 assert(enabled
!= SD_EVENT_OFF
);
398 struct epoll_event ev
= {
399 .events
= events
| (enabled
== SD_EVENT_ONESHOT
? EPOLLONESHOT
: 0),
404 r
= epoll_ctl(s
->event
->epoll_fd
,
405 s
->io
.registered
? EPOLL_CTL_MOD
: EPOLL_CTL_ADD
,
411 s
->io
.registered
= true;
416 static void source_child_pidfd_unregister(sd_event_source
*s
) {
418 assert(s
->type
== SOURCE_CHILD
);
420 if (event_pid_changed(s
->event
))
423 if (!s
->child
.registered
)
426 if (EVENT_SOURCE_WATCH_PIDFD(s
))
427 if (epoll_ctl(s
->event
->epoll_fd
, EPOLL_CTL_DEL
, s
->child
.pidfd
, NULL
) < 0)
428 log_debug_errno(errno
, "Failed to remove source %s (type %s) from epoll: %m",
429 strna(s
->description
), event_source_type_to_string(s
->type
));
431 s
->child
.registered
= false;
434 static int source_child_pidfd_register(sd_event_source
*s
, int enabled
) {
438 assert(s
->type
== SOURCE_CHILD
);
439 assert(enabled
!= SD_EVENT_OFF
);
441 if (EVENT_SOURCE_WATCH_PIDFD(s
)) {
442 struct epoll_event ev
= {
443 .events
= EPOLLIN
| (enabled
== SD_EVENT_ONESHOT
? EPOLLONESHOT
: 0),
447 if (s
->child
.registered
)
448 r
= epoll_ctl(s
->event
->epoll_fd
, EPOLL_CTL_MOD
, s
->child
.pidfd
, &ev
);
450 r
= epoll_ctl(s
->event
->epoll_fd
, EPOLL_CTL_ADD
, s
->child
.pidfd
, &ev
);
455 s
->child
.registered
= true;
459 static clockid_t
event_source_type_to_clock(EventSourceType t
) {
463 case SOURCE_TIME_REALTIME
:
464 return CLOCK_REALTIME
;
466 case SOURCE_TIME_BOOTTIME
:
467 return CLOCK_BOOTTIME
;
469 case SOURCE_TIME_MONOTONIC
:
470 return CLOCK_MONOTONIC
;
472 case SOURCE_TIME_REALTIME_ALARM
:
473 return CLOCK_REALTIME_ALARM
;
475 case SOURCE_TIME_BOOTTIME_ALARM
:
476 return CLOCK_BOOTTIME_ALARM
;
479 return (clockid_t
) -1;
483 static EventSourceType
clock_to_event_source_type(clockid_t clock
) {
488 return SOURCE_TIME_REALTIME
;
491 return SOURCE_TIME_BOOTTIME
;
493 case CLOCK_MONOTONIC
:
494 return SOURCE_TIME_MONOTONIC
;
496 case CLOCK_REALTIME_ALARM
:
497 return SOURCE_TIME_REALTIME_ALARM
;
499 case CLOCK_BOOTTIME_ALARM
:
500 return SOURCE_TIME_BOOTTIME_ALARM
;
503 return _SOURCE_EVENT_SOURCE_TYPE_INVALID
;
507 static struct clock_data
* event_get_clock_data(sd_event
*e
, EventSourceType t
) {
512 case SOURCE_TIME_REALTIME
:
515 case SOURCE_TIME_BOOTTIME
:
518 case SOURCE_TIME_MONOTONIC
:
519 return &e
->monotonic
;
521 case SOURCE_TIME_REALTIME_ALARM
:
522 return &e
->realtime_alarm
;
524 case SOURCE_TIME_BOOTTIME_ALARM
:
525 return &e
->boottime_alarm
;
532 static void event_free_signal_data(sd_event
*e
, struct signal_data
*d
) {
538 hashmap_remove(e
->signal_data
, &d
->priority
);
543 static int event_make_signal_data(
546 struct signal_data
**ret
) {
548 struct signal_data
*d
;
556 if (event_pid_changed(e
))
559 if (e
->signal_sources
&& e
->signal_sources
[sig
])
560 priority
= e
->signal_sources
[sig
]->priority
;
562 priority
= SD_EVENT_PRIORITY_NORMAL
;
564 d
= hashmap_get(e
->signal_data
, &priority
);
566 if (sigismember(&d
->sigset
, sig
) > 0) {
572 r
= hashmap_ensure_allocated(&e
->signal_data
, &uint64_hash_ops
);
576 d
= new(struct signal_data
, 1);
580 *d
= (struct signal_data
) {
581 .wakeup
= WAKEUP_SIGNAL_DATA
,
583 .priority
= priority
,
586 r
= hashmap_put(e
->signal_data
, &d
->priority
, d
);
596 assert_se(sigaddset(&ss_copy
, sig
) >= 0);
598 r
= signalfd(d
->fd
, &ss_copy
, SFD_NONBLOCK
|SFD_CLOEXEC
);
612 d
->fd
= fd_move_above_stdio(r
);
614 struct epoll_event ev
= {
619 r
= epoll_ctl(e
->epoll_fd
, EPOLL_CTL_ADD
, d
->fd
, &ev
);
632 event_free_signal_data(e
, d
);
637 static void event_unmask_signal_data(sd_event
*e
, struct signal_data
*d
, int sig
) {
641 /* Turns off the specified signal in the signal data
642 * object. If the signal mask of the object becomes empty that
645 if (sigismember(&d
->sigset
, sig
) == 0)
648 assert_se(sigdelset(&d
->sigset
, sig
) >= 0);
650 if (sigisemptyset(&d
->sigset
)) {
651 /* If all the mask is all-zero we can get rid of the structure */
652 event_free_signal_data(e
, d
);
658 if (signalfd(d
->fd
, &d
->sigset
, SFD_NONBLOCK
|SFD_CLOEXEC
) < 0)
659 log_debug_errno(errno
, "Failed to unset signal bit, ignoring: %m");
662 static void event_gc_signal_data(sd_event
*e
, const int64_t *priority
, int sig
) {
663 struct signal_data
*d
;
664 static const int64_t zero_priority
= 0;
668 /* Rechecks if the specified signal is still something we are interested in. If not, we'll unmask it,
669 * and possibly drop the signalfd for it. */
671 if (sig
== SIGCHLD
&&
672 e
->n_enabled_child_sources
> 0)
675 if (e
->signal_sources
&&
676 e
->signal_sources
[sig
] &&
677 e
->signal_sources
[sig
]->enabled
!= SD_EVENT_OFF
)
681 * The specified signal might be enabled in three different queues:
683 * 1) the one that belongs to the priority passed (if it is non-NULL)
684 * 2) the one that belongs to the priority of the event source of the signal (if there is one)
685 * 3) the 0 priority (to cover the SIGCHLD case)
687 * Hence, let's remove it from all three here.
691 d
= hashmap_get(e
->signal_data
, priority
);
693 event_unmask_signal_data(e
, d
, sig
);
696 if (e
->signal_sources
&& e
->signal_sources
[sig
]) {
697 d
= hashmap_get(e
->signal_data
, &e
->signal_sources
[sig
]->priority
);
699 event_unmask_signal_data(e
, d
, sig
);
702 d
= hashmap_get(e
->signal_data
, &zero_priority
);
704 event_unmask_signal_data(e
, d
, sig
);
707 static void source_disconnect(sd_event_source
*s
) {
715 assert(s
->event
->n_sources
> 0);
721 source_io_unregister(s
);
725 case SOURCE_TIME_REALTIME
:
726 case SOURCE_TIME_BOOTTIME
:
727 case SOURCE_TIME_MONOTONIC
:
728 case SOURCE_TIME_REALTIME_ALARM
:
729 case SOURCE_TIME_BOOTTIME_ALARM
: {
730 struct clock_data
*d
;
732 d
= event_get_clock_data(s
->event
, s
->type
);
735 prioq_remove(d
->earliest
, s
, &s
->time
.earliest_index
);
736 prioq_remove(d
->latest
, s
, &s
->time
.latest_index
);
737 d
->needs_rearm
= true;
742 if (s
->signal
.sig
> 0) {
744 if (s
->event
->signal_sources
)
745 s
->event
->signal_sources
[s
->signal
.sig
] = NULL
;
747 event_gc_signal_data(s
->event
, &s
->priority
, s
->signal
.sig
);
753 if (s
->child
.pid
> 0) {
754 if (s
->enabled
!= SD_EVENT_OFF
) {
755 assert(s
->event
->n_enabled_child_sources
> 0);
756 s
->event
->n_enabled_child_sources
--;
759 (void) hashmap_remove(s
->event
->child_sources
, PID_TO_PTR(s
->child
.pid
));
762 if (EVENT_SOURCE_WATCH_PIDFD(s
))
763 source_child_pidfd_unregister(s
);
765 event_gc_signal_data(s
->event
, &s
->priority
, SIGCHLD
);
774 set_remove(s
->event
->post_sources
, s
);
778 prioq_remove(s
->event
->exit
, s
, &s
->exit
.prioq_index
);
781 case SOURCE_INOTIFY
: {
782 struct inode_data
*inode_data
;
784 inode_data
= s
->inotify
.inode_data
;
786 struct inotify_data
*inotify_data
;
787 assert_se(inotify_data
= inode_data
->inotify_data
);
789 /* Detach this event source from the inode object */
790 LIST_REMOVE(inotify
.by_inode_data
, inode_data
->event_sources
, s
);
791 s
->inotify
.inode_data
= NULL
;
794 assert(inotify_data
->n_pending
> 0);
795 inotify_data
->n_pending
--;
798 /* Note that we don't reduce the inotify mask for the watch descriptor here if the inode is
799 * continued to being watched. That's because inotify doesn't really have an API for that: we
800 * can only change watch masks with access to the original inode either by fd or by path. But
801 * paths aren't stable, and keeping an O_PATH fd open all the time would mean wasting an fd
802 * continuously and keeping the mount busy which we can't really do. We could reconstruct the
803 * original inode from /proc/self/fdinfo/$INOTIFY_FD (as all watch descriptors are listed
804 * there), but given the need for open_by_handle_at() which is privileged and not universally
805 * available this would be quite an incomplete solution. Hence we go the other way, leave the
806 * mask set, even if it is not minimized now, and ignore all events we aren't interested in
807 * anymore after reception. Yes, this sucks, but … Linux … */
809 /* Maybe release the inode data (and its inotify) */
810 event_gc_inode_data(s
->event
, inode_data
);
817 assert_not_reached("Wut? I shouldn't exist.");
821 prioq_remove(s
->event
->pending
, s
, &s
->pending_index
);
824 prioq_remove(s
->event
->prepare
, s
, &s
->prepare_index
);
826 event
= TAKE_PTR(s
->event
);
827 LIST_REMOVE(sources
, event
->sources
, s
);
830 /* Note that we don't invalidate the type here, since we still need it in order to close the fd or
831 * pidfd associated with this event source, which we'll do only on source_free(). */
834 sd_event_unref(event
);
837 static void source_free(sd_event_source
*s
) {
840 source_disconnect(s
);
842 if (s
->type
== SOURCE_IO
&& s
->io
.owned
)
843 s
->io
.fd
= safe_close(s
->io
.fd
);
845 if (s
->type
== SOURCE_CHILD
) {
846 /* Eventually the kernel will do this automatically for us, but for now let's emulate this (unreliably) in userspace. */
848 if (s
->child
.process_owned
) {
850 if (!s
->child
.exited
) {
853 if (s
->child
.pidfd
>= 0) {
854 if (pidfd_send_signal(s
->child
.pidfd
, SIGKILL
, NULL
, 0) < 0) {
855 if (errno
== ESRCH
) /* Already dead */
857 else if (!ERRNO_IS_NOT_SUPPORTED(errno
))
858 log_debug_errno(errno
, "Failed to kill process " PID_FMT
" via pidfd_send_signal(), re-trying via kill(): %m",
865 if (kill(s
->child
.pid
, SIGKILL
) < 0)
866 if (errno
!= ESRCH
) /* Already dead */
867 log_debug_errno(errno
, "Failed to kill process " PID_FMT
" via kill(), ignoring: %m",
871 if (!s
->child
.waited
) {
874 /* Reap the child if we can */
875 (void) waitid(P_PID
, s
->child
.pid
, &si
, WEXITED
);
879 if (s
->child
.pidfd_owned
)
880 s
->child
.pidfd
= safe_close(s
->child
.pidfd
);
883 if (s
->destroy_callback
)
884 s
->destroy_callback(s
->userdata
);
886 free(s
->description
);
889 DEFINE_TRIVIAL_CLEANUP_FUNC(sd_event_source
*, source_free
);
891 static int source_set_pending(sd_event_source
*s
, bool b
) {
895 assert(s
->type
!= SOURCE_EXIT
);
903 s
->pending_iteration
= s
->event
->iteration
;
905 r
= prioq_put(s
->event
->pending
, s
, &s
->pending_index
);
911 assert_se(prioq_remove(s
->event
->pending
, s
, &s
->pending_index
));
913 if (EVENT_SOURCE_IS_TIME(s
->type
)) {
914 struct clock_data
*d
;
916 d
= event_get_clock_data(s
->event
, s
->type
);
919 prioq_reshuffle(d
->earliest
, s
, &s
->time
.earliest_index
);
920 prioq_reshuffle(d
->latest
, s
, &s
->time
.latest_index
);
921 d
->needs_rearm
= true;
924 if (s
->type
== SOURCE_SIGNAL
&& !b
) {
925 struct signal_data
*d
;
927 d
= hashmap_get(s
->event
->signal_data
, &s
->priority
);
928 if (d
&& d
->current
== s
)
932 if (s
->type
== SOURCE_INOTIFY
) {
934 assert(s
->inotify
.inode_data
);
935 assert(s
->inotify
.inode_data
->inotify_data
);
938 s
->inotify
.inode_data
->inotify_data
->n_pending
++;
940 assert(s
->inotify
.inode_data
->inotify_data
->n_pending
> 0);
941 s
->inotify
.inode_data
->inotify_data
->n_pending
--;
948 static sd_event_source
*source_new(sd_event
*e
, bool floating
, EventSourceType type
) {
953 s
= new(sd_event_source
, 1);
957 *s
= (struct sd_event_source
) {
960 .floating
= floating
,
962 .pending_index
= PRIOQ_IDX_NULL
,
963 .prepare_index
= PRIOQ_IDX_NULL
,
969 LIST_PREPEND(sources
, e
->sources
, s
);
975 _public_
int sd_event_add_io(
977 sd_event_source
**ret
,
980 sd_event_io_handler_t callback
,
983 _cleanup_(source_freep
) sd_event_source
*s
= NULL
;
986 assert_return(e
, -EINVAL
);
987 assert_return(e
= event_resolve(e
), -ENOPKG
);
988 assert_return(fd
>= 0, -EBADF
);
989 assert_return(!(events
& ~(EPOLLIN
|EPOLLOUT
|EPOLLRDHUP
|EPOLLPRI
|EPOLLERR
|EPOLLHUP
|EPOLLET
)), -EINVAL
);
990 assert_return(callback
, -EINVAL
);
991 assert_return(e
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
992 assert_return(!event_pid_changed(e
), -ECHILD
);
994 s
= source_new(e
, !ret
, SOURCE_IO
);
998 s
->wakeup
= WAKEUP_EVENT_SOURCE
;
1000 s
->io
.events
= events
;
1001 s
->io
.callback
= callback
;
1002 s
->userdata
= userdata
;
1003 s
->enabled
= SD_EVENT_ON
;
1005 r
= source_io_register(s
, s
->enabled
, events
);
1016 static void initialize_perturb(sd_event
*e
) {
1017 sd_id128_t bootid
= {};
1019 /* When we sleep for longer, we try to realign the wakeup to
1020 the same time within each minute/second/250ms, so that
1021 events all across the system can be coalesced into a single
1022 CPU wakeup. However, let's take some system-specific
1023 randomness for this value, so that in a network of systems
1024 with synced clocks timer events are distributed a
1025 bit. Here, we calculate a perturbation usec offset from the
1028 if (_likely_(e
->perturb
!= USEC_INFINITY
))
1031 if (sd_id128_get_boot(&bootid
) >= 0)
1032 e
->perturb
= (bootid
.qwords
[0] ^ bootid
.qwords
[1]) % USEC_PER_MINUTE
;
1035 static int event_setup_timer_fd(
1037 struct clock_data
*d
,
1043 if (_likely_(d
->fd
>= 0))
1046 _cleanup_close_
int fd
= -1;
1049 fd
= timerfd_create(clock
, TFD_NONBLOCK
|TFD_CLOEXEC
);
1053 fd
= fd_move_above_stdio(fd
);
1055 struct epoll_event ev
= {
1060 r
= epoll_ctl(e
->epoll_fd
, EPOLL_CTL_ADD
, fd
, &ev
);
1064 d
->fd
= TAKE_FD(fd
);
1068 static int time_exit_callback(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
1071 return sd_event_exit(sd_event_source_get_event(s
), PTR_TO_INT(userdata
));
1074 _public_
int sd_event_add_time(
1076 sd_event_source
**ret
,
1080 sd_event_time_handler_t callback
,
1083 EventSourceType type
;
1084 _cleanup_(source_freep
) sd_event_source
*s
= NULL
;
1085 struct clock_data
*d
;
1088 assert_return(e
, -EINVAL
);
1089 assert_return(e
= event_resolve(e
), -ENOPKG
);
1090 assert_return(accuracy
!= (uint64_t) -1, -EINVAL
);
1091 assert_return(e
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
1092 assert_return(!event_pid_changed(e
), -ECHILD
);
1094 if (!clock_supported(clock
)) /* Checks whether the kernel supports the clock */
1097 type
= clock_to_event_source_type(clock
); /* checks whether sd-event supports this clock */
1102 callback
= time_exit_callback
;
1104 d
= event_get_clock_data(e
, type
);
1107 r
= prioq_ensure_allocated(&d
->earliest
, earliest_time_prioq_compare
);
1111 r
= prioq_ensure_allocated(&d
->latest
, latest_time_prioq_compare
);
1116 r
= event_setup_timer_fd(e
, d
, clock
);
1121 s
= source_new(e
, !ret
, type
);
1125 s
->time
.next
= usec
;
1126 s
->time
.accuracy
= accuracy
== 0 ? DEFAULT_ACCURACY_USEC
: accuracy
;
1127 s
->time
.callback
= callback
;
1128 s
->time
.earliest_index
= s
->time
.latest_index
= PRIOQ_IDX_NULL
;
1129 s
->userdata
= userdata
;
1130 s
->enabled
= SD_EVENT_ONESHOT
;
1132 d
->needs_rearm
= true;
1134 r
= prioq_put(d
->earliest
, s
, &s
->time
.earliest_index
);
1138 r
= prioq_put(d
->latest
, s
, &s
->time
.latest_index
);
1149 static int signal_exit_callback(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
1152 return sd_event_exit(sd_event_source_get_event(s
), PTR_TO_INT(userdata
));
1155 _public_
int sd_event_add_signal(
1157 sd_event_source
**ret
,
1159 sd_event_signal_handler_t callback
,
1162 _cleanup_(source_freep
) sd_event_source
*s
= NULL
;
1163 struct signal_data
*d
;
1166 assert_return(e
, -EINVAL
);
1167 assert_return(e
= event_resolve(e
), -ENOPKG
);
1168 assert_return(SIGNAL_VALID(sig
), -EINVAL
);
1169 assert_return(e
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
1170 assert_return(!event_pid_changed(e
), -ECHILD
);
1173 callback
= signal_exit_callback
;
1175 r
= signal_is_blocked(sig
);
1181 if (!e
->signal_sources
) {
1182 e
->signal_sources
= new0(sd_event_source
*, _NSIG
);
1183 if (!e
->signal_sources
)
1185 } else if (e
->signal_sources
[sig
])
1188 s
= source_new(e
, !ret
, SOURCE_SIGNAL
);
1192 s
->signal
.sig
= sig
;
1193 s
->signal
.callback
= callback
;
1194 s
->userdata
= userdata
;
1195 s
->enabled
= SD_EVENT_ON
;
1197 e
->signal_sources
[sig
] = s
;
1199 r
= event_make_signal_data(e
, sig
, &d
);
1203 /* Use the signal name as description for the event source by default */
1204 (void) sd_event_source_set_description(s
, signal_to_string(sig
));
1213 static bool shall_use_pidfd(void) {
1214 /* Mostly relevant for debugging, i.e. this is used in test-event.c to test the event loop once with and once without pidfd */
1215 return getenv_bool_secure("SYSTEMD_PIDFD") != 0;
1218 _public_
int sd_event_add_child(
1220 sd_event_source
**ret
,
1223 sd_event_child_handler_t callback
,
1226 _cleanup_(source_freep
) sd_event_source
*s
= NULL
;
1229 assert_return(e
, -EINVAL
);
1230 assert_return(e
= event_resolve(e
), -ENOPKG
);
1231 assert_return(pid
> 1, -EINVAL
);
1232 assert_return(!(options
& ~(WEXITED
|WSTOPPED
|WCONTINUED
)), -EINVAL
);
1233 assert_return(options
!= 0, -EINVAL
);
1234 assert_return(callback
, -EINVAL
);
1235 assert_return(e
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
1236 assert_return(!event_pid_changed(e
), -ECHILD
);
1238 if (e
->n_enabled_child_sources
== 0) {
1239 /* Caller must block SIGCHLD before using us to watch children, even if pidfd is available,
1240 * for compatibility with pre-pidfd and because we don't want the reap the child processes
1241 * ourselves, i.e. call waitid(), and don't want Linux' default internal logic for that to
1244 * (As an optimization we only do this check on the first child event source created.) */
1245 r
= signal_is_blocked(SIGCHLD
);
1252 r
= hashmap_ensure_allocated(&e
->child_sources
, NULL
);
1256 if (hashmap_contains(e
->child_sources
, PID_TO_PTR(pid
)))
1259 s
= source_new(e
, !ret
, SOURCE_CHILD
);
1263 s
->wakeup
= WAKEUP_EVENT_SOURCE
;
1265 s
->child
.options
= options
;
1266 s
->child
.callback
= callback
;
1267 s
->userdata
= userdata
;
1268 s
->enabled
= SD_EVENT_ONESHOT
;
1270 /* We always take a pidfd here if we can, even if we wait for anything else than WEXITED, so that we
1271 * pin the PID, and make regular waitid() handling race-free. */
1273 if (shall_use_pidfd()) {
1274 s
->child
.pidfd
= pidfd_open(s
->child
.pid
, 0);
1275 if (s
->child
.pidfd
< 0) {
1276 /* Propagate errors unless the syscall is not supported or blocked */
1277 if (!ERRNO_IS_NOT_SUPPORTED(errno
) && !ERRNO_IS_PRIVILEGE(errno
))
1280 s
->child
.pidfd_owned
= true; /* If we allocate the pidfd we own it by default */
1282 s
->child
.pidfd
= -1;
1284 r
= hashmap_put(e
->child_sources
, PID_TO_PTR(pid
), s
);
1288 e
->n_enabled_child_sources
++;
1290 if (EVENT_SOURCE_WATCH_PIDFD(s
)) {
1291 /* We have a pidfd and we only want to watch for exit */
1293 r
= source_child_pidfd_register(s
, s
->enabled
);
1295 e
->n_enabled_child_sources
--;
1299 /* We have no pidfd or we shall wait for some other event than WEXITED */
1301 r
= event_make_signal_data(e
, SIGCHLD
, NULL
);
1303 e
->n_enabled_child_sources
--;
1307 e
->need_process_child
= true;
1317 _public_
int sd_event_add_child_pidfd(
1319 sd_event_source
**ret
,
1322 sd_event_child_handler_t callback
,
1326 _cleanup_(source_freep
) sd_event_source
*s
= NULL
;
1330 assert_return(e
, -EINVAL
);
1331 assert_return(e
= event_resolve(e
), -ENOPKG
);
1332 assert_return(pidfd
>= 0, -EBADF
);
1333 assert_return(!(options
& ~(WEXITED
|WSTOPPED
|WCONTINUED
)), -EINVAL
);
1334 assert_return(options
!= 0, -EINVAL
);
1335 assert_return(callback
, -EINVAL
);
1336 assert_return(e
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
1337 assert_return(!event_pid_changed(e
), -ECHILD
);
1339 if (e
->n_enabled_child_sources
== 0) {
1340 r
= signal_is_blocked(SIGCHLD
);
1347 r
= hashmap_ensure_allocated(&e
->child_sources
, NULL
);
1351 r
= pidfd_get_pid(pidfd
, &pid
);
1355 if (hashmap_contains(e
->child_sources
, PID_TO_PTR(pid
)))
1358 s
= source_new(e
, !ret
, SOURCE_CHILD
);
1362 s
->wakeup
= WAKEUP_EVENT_SOURCE
;
1363 s
->child
.pidfd
= pidfd
;
1365 s
->child
.options
= options
;
1366 s
->child
.callback
= callback
;
1367 s
->child
.pidfd_owned
= false; /* If we got the pidfd passed in we don't own it by default (similar to the IO fd case) */
1368 s
->userdata
= userdata
;
1369 s
->enabled
= SD_EVENT_ONESHOT
;
1371 r
= hashmap_put(e
->child_sources
, PID_TO_PTR(pid
), s
);
1375 e
->n_enabled_child_sources
++;
1377 if (EVENT_SOURCE_WATCH_PIDFD(s
)) {
1378 /* We only want to watch for WEXITED */
1380 r
= source_child_pidfd_register(s
, s
->enabled
);
1382 e
->n_enabled_child_sources
--;
1386 /* We shall wait for some other event than WEXITED */
1388 r
= event_make_signal_data(e
, SIGCHLD
, NULL
);
1390 e
->n_enabled_child_sources
--;
1394 e
->need_process_child
= true;
1404 _public_
int sd_event_add_defer(
1406 sd_event_source
**ret
,
1407 sd_event_handler_t callback
,
1410 _cleanup_(source_freep
) sd_event_source
*s
= NULL
;
1413 assert_return(e
, -EINVAL
);
1414 assert_return(e
= event_resolve(e
), -ENOPKG
);
1415 assert_return(callback
, -EINVAL
);
1416 assert_return(e
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
1417 assert_return(!event_pid_changed(e
), -ECHILD
);
1419 s
= source_new(e
, !ret
, SOURCE_DEFER
);
1423 s
->defer
.callback
= callback
;
1424 s
->userdata
= userdata
;
1425 s
->enabled
= SD_EVENT_ONESHOT
;
1427 r
= source_set_pending(s
, true);
1438 _public_
int sd_event_add_post(
1440 sd_event_source
**ret
,
1441 sd_event_handler_t callback
,
1444 _cleanup_(source_freep
) sd_event_source
*s
= NULL
;
1447 assert_return(e
, -EINVAL
);
1448 assert_return(e
= event_resolve(e
), -ENOPKG
);
1449 assert_return(callback
, -EINVAL
);
1450 assert_return(e
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
1451 assert_return(!event_pid_changed(e
), -ECHILD
);
1453 r
= set_ensure_allocated(&e
->post_sources
, NULL
);
1457 s
= source_new(e
, !ret
, SOURCE_POST
);
1461 s
->post
.callback
= callback
;
1462 s
->userdata
= userdata
;
1463 s
->enabled
= SD_EVENT_ON
;
1465 r
= set_put(e
->post_sources
, s
);
1476 _public_
int sd_event_add_exit(
1478 sd_event_source
**ret
,
1479 sd_event_handler_t callback
,
1482 _cleanup_(source_freep
) sd_event_source
*s
= NULL
;
1485 assert_return(e
, -EINVAL
);
1486 assert_return(e
= event_resolve(e
), -ENOPKG
);
1487 assert_return(callback
, -EINVAL
);
1488 assert_return(e
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
1489 assert_return(!event_pid_changed(e
), -ECHILD
);
1491 r
= prioq_ensure_allocated(&e
->exit
, exit_prioq_compare
);
1495 s
= source_new(e
, !ret
, SOURCE_EXIT
);
1499 s
->exit
.callback
= callback
;
1500 s
->userdata
= userdata
;
1501 s
->exit
.prioq_index
= PRIOQ_IDX_NULL
;
1502 s
->enabled
= SD_EVENT_ONESHOT
;
1504 r
= prioq_put(s
->event
->exit
, s
, &s
->exit
.prioq_index
);
1515 static void event_free_inotify_data(sd_event
*e
, struct inotify_data
*d
) {
1521 assert(hashmap_isempty(d
->inodes
));
1522 assert(hashmap_isempty(d
->wd
));
1524 if (d
->buffer_filled
> 0)
1525 LIST_REMOVE(buffered
, e
->inotify_data_buffered
, d
);
1527 hashmap_free(d
->inodes
);
1528 hashmap_free(d
->wd
);
1530 assert_se(hashmap_remove(e
->inotify_data
, &d
->priority
) == d
);
1533 if (epoll_ctl(e
->epoll_fd
, EPOLL_CTL_DEL
, d
->fd
, NULL
) < 0)
1534 log_debug_errno(errno
, "Failed to remove inotify fd from epoll, ignoring: %m");
1541 static int event_make_inotify_data(
1544 struct inotify_data
**ret
) {
1546 _cleanup_close_
int fd
= -1;
1547 struct inotify_data
*d
;
1552 d
= hashmap_get(e
->inotify_data
, &priority
);
1559 fd
= inotify_init1(IN_NONBLOCK
|O_CLOEXEC
);
1563 fd
= fd_move_above_stdio(fd
);
1565 r
= hashmap_ensure_allocated(&e
->inotify_data
, &uint64_hash_ops
);
1569 d
= new(struct inotify_data
, 1);
1573 *d
= (struct inotify_data
) {
1574 .wakeup
= WAKEUP_INOTIFY_DATA
,
1576 .priority
= priority
,
1579 r
= hashmap_put(e
->inotify_data
, &d
->priority
, d
);
1581 d
->fd
= safe_close(d
->fd
);
1586 struct epoll_event ev
= {
1591 if (epoll_ctl(e
->epoll_fd
, EPOLL_CTL_ADD
, d
->fd
, &ev
) < 0) {
1593 d
->fd
= safe_close(d
->fd
); /* let's close this ourselves, as event_free_inotify_data() would otherwise
1594 * remove the fd from the epoll first, which we don't want as we couldn't
1595 * add it in the first place. */
1596 event_free_inotify_data(e
, d
);
1606 static int inode_data_compare(const struct inode_data
*x
, const struct inode_data
*y
) {
1612 r
= CMP(x
->dev
, y
->dev
);
1616 return CMP(x
->ino
, y
->ino
);
1619 static void inode_data_hash_func(const struct inode_data
*d
, struct siphash
*state
) {
1622 siphash24_compress(&d
->dev
, sizeof(d
->dev
), state
);
1623 siphash24_compress(&d
->ino
, sizeof(d
->ino
), state
);
1626 DEFINE_PRIVATE_HASH_OPS(inode_data_hash_ops
, struct inode_data
, inode_data_hash_func
, inode_data_compare
);
1628 static void event_free_inode_data(
1630 struct inode_data
*d
) {
1637 assert(!d
->event_sources
);
1640 LIST_REMOVE(to_close
, e
->inode_data_to_close
, d
);
1644 if (d
->inotify_data
) {
1647 if (d
->inotify_data
->fd
>= 0) {
1648 /* So here's a problem. At the time this runs the watch descriptor might already be
1649 * invalidated, because an IN_IGNORED event might be queued right the moment we enter
1650 * the syscall. Hence, whenever we get EINVAL, ignore it entirely, since it's a very
1651 * likely case to happen. */
1653 if (inotify_rm_watch(d
->inotify_data
->fd
, d
->wd
) < 0 && errno
!= EINVAL
)
1654 log_debug_errno(errno
, "Failed to remove watch descriptor %i from inotify, ignoring: %m", d
->wd
);
1657 assert_se(hashmap_remove(d
->inotify_data
->wd
, INT_TO_PTR(d
->wd
)) == d
);
1660 assert_se(hashmap_remove(d
->inotify_data
->inodes
, d
) == d
);
1666 static void event_gc_inode_data(
1668 struct inode_data
*d
) {
1670 struct inotify_data
*inotify_data
;
1677 if (d
->event_sources
)
1680 inotify_data
= d
->inotify_data
;
1681 event_free_inode_data(e
, d
);
1683 if (inotify_data
&& hashmap_isempty(inotify_data
->inodes
))
1684 event_free_inotify_data(e
, inotify_data
);
1687 static int event_make_inode_data(
1689 struct inotify_data
*inotify_data
,
1692 struct inode_data
**ret
) {
1694 struct inode_data
*d
, key
;
1698 assert(inotify_data
);
1700 key
= (struct inode_data
) {
1705 d
= hashmap_get(inotify_data
->inodes
, &key
);
1713 r
= hashmap_ensure_allocated(&inotify_data
->inodes
, &inode_data_hash_ops
);
1717 d
= new(struct inode_data
, 1);
1721 *d
= (struct inode_data
) {
1726 .inotify_data
= inotify_data
,
1729 r
= hashmap_put(inotify_data
->inodes
, d
, d
);
1741 static uint32_t inode_data_determine_mask(struct inode_data
*d
) {
1742 bool excl_unlink
= true;
1743 uint32_t combined
= 0;
1748 /* Combines the watch masks of all event sources watching this inode. We generally just OR them together, but
1749 * the IN_EXCL_UNLINK flag is ANDed instead.
1751 * Note that we add all sources to the mask here, regardless whether enabled, disabled or oneshot. That's
1752 * because we cannot change the mask anymore after the event source was created once, since the kernel has no
1753 * API for that. Hence we need to subscribe to the maximum mask we ever might be interested in, and suppress
1754 * events we don't care for client-side. */
1756 LIST_FOREACH(inotify
.by_inode_data
, s
, d
->event_sources
) {
1758 if ((s
->inotify
.mask
& IN_EXCL_UNLINK
) == 0)
1759 excl_unlink
= false;
1761 combined
|= s
->inotify
.mask
;
1764 return (combined
& ~(IN_ONESHOT
|IN_DONT_FOLLOW
|IN_ONLYDIR
|IN_EXCL_UNLINK
)) | (excl_unlink
? IN_EXCL_UNLINK
: 0);
1767 static int inode_data_realize_watch(sd_event
*e
, struct inode_data
*d
) {
1768 uint32_t combined_mask
;
1774 combined_mask
= inode_data_determine_mask(d
);
1776 if (d
->wd
>= 0 && combined_mask
== d
->combined_mask
)
1779 r
= hashmap_ensure_allocated(&d
->inotify_data
->wd
, NULL
);
1783 wd
= inotify_add_watch_fd(d
->inotify_data
->fd
, d
->fd
, combined_mask
);
1788 r
= hashmap_put(d
->inotify_data
->wd
, INT_TO_PTR(wd
), d
);
1790 (void) inotify_rm_watch(d
->inotify_data
->fd
, wd
);
1796 } else if (d
->wd
!= wd
) {
1798 log_debug("Weird, the watch descriptor we already knew for this inode changed?");
1799 (void) inotify_rm_watch(d
->fd
, wd
);
1803 d
->combined_mask
= combined_mask
;
1807 _public_
int sd_event_add_inotify(
1809 sd_event_source
**ret
,
1812 sd_event_inotify_handler_t callback
,
1815 struct inotify_data
*inotify_data
= NULL
;
1816 struct inode_data
*inode_data
= NULL
;
1817 _cleanup_close_
int fd
= -1;
1818 _cleanup_(source_freep
) sd_event_source
*s
= NULL
;
1822 assert_return(e
, -EINVAL
);
1823 assert_return(e
= event_resolve(e
), -ENOPKG
);
1824 assert_return(path
, -EINVAL
);
1825 assert_return(callback
, -EINVAL
);
1826 assert_return(e
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
1827 assert_return(!event_pid_changed(e
), -ECHILD
);
1829 /* Refuse IN_MASK_ADD since we coalesce watches on the same inode, and hence really don't want to merge
1830 * masks. Or in other words, this whole code exists only to manage IN_MASK_ADD type operations for you, hence
1831 * the user can't use them for us. */
1832 if (mask
& IN_MASK_ADD
)
1835 fd
= open(path
, O_PATH
|O_CLOEXEC
|
1836 (mask
& IN_ONLYDIR
? O_DIRECTORY
: 0)|
1837 (mask
& IN_DONT_FOLLOW
? O_NOFOLLOW
: 0));
1841 if (fstat(fd
, &st
) < 0)
1844 s
= source_new(e
, !ret
, SOURCE_INOTIFY
);
1848 s
->enabled
= mask
& IN_ONESHOT
? SD_EVENT_ONESHOT
: SD_EVENT_ON
;
1849 s
->inotify
.mask
= mask
;
1850 s
->inotify
.callback
= callback
;
1851 s
->userdata
= userdata
;
1853 /* Allocate an inotify object for this priority, and an inode object within it */
1854 r
= event_make_inotify_data(e
, SD_EVENT_PRIORITY_NORMAL
, &inotify_data
);
1858 r
= event_make_inode_data(e
, inotify_data
, st
.st_dev
, st
.st_ino
, &inode_data
);
1860 event_free_inotify_data(e
, inotify_data
);
1864 /* Keep the O_PATH fd around until the first iteration of the loop, so that we can still change the priority of
1865 * the event source, until then, for which we need the original inode. */
1866 if (inode_data
->fd
< 0) {
1867 inode_data
->fd
= TAKE_FD(fd
);
1868 LIST_PREPEND(to_close
, e
->inode_data_to_close
, inode_data
);
1871 /* Link our event source to the inode data object */
1872 LIST_PREPEND(inotify
.by_inode_data
, inode_data
->event_sources
, s
);
1873 s
->inotify
.inode_data
= inode_data
;
1875 /* Actually realize the watch now */
1876 r
= inode_data_realize_watch(e
, inode_data
);
1880 (void) sd_event_source_set_description(s
, path
);
1889 static sd_event_source
* event_source_free(sd_event_source
*s
) {
1893 /* Here's a special hack: when we are called from a
1894 * dispatch handler we won't free the event source
1895 * immediately, but we will detach the fd from the
1896 * epoll. This way it is safe for the caller to unref
1897 * the event source and immediately close the fd, but
1898 * we still retain a valid event source object after
1901 if (s
->dispatching
) {
1902 if (s
->type
== SOURCE_IO
)
1903 source_io_unregister(s
);
1905 source_disconnect(s
);
1912 DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_event_source
, sd_event_source
, event_source_free
);
1914 _public_
int sd_event_source_set_description(sd_event_source
*s
, const char *description
) {
1915 assert_return(s
, -EINVAL
);
1916 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
1918 return free_and_strdup(&s
->description
, description
);
1921 _public_
int sd_event_source_get_description(sd_event_source
*s
, const char **description
) {
1922 assert_return(s
, -EINVAL
);
1923 assert_return(description
, -EINVAL
);
1924 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
1926 if (!s
->description
)
1929 *description
= s
->description
;
1933 _public_ sd_event
*sd_event_source_get_event(sd_event_source
*s
) {
1934 assert_return(s
, NULL
);
1939 _public_
int sd_event_source_get_pending(sd_event_source
*s
) {
1940 assert_return(s
, -EINVAL
);
1941 assert_return(s
->type
!= SOURCE_EXIT
, -EDOM
);
1942 assert_return(s
->event
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
1943 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
1948 _public_
int sd_event_source_get_io_fd(sd_event_source
*s
) {
1949 assert_return(s
, -EINVAL
);
1950 assert_return(s
->type
== SOURCE_IO
, -EDOM
);
1951 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
1956 _public_
int sd_event_source_set_io_fd(sd_event_source
*s
, int fd
) {
1959 assert_return(s
, -EINVAL
);
1960 assert_return(fd
>= 0, -EBADF
);
1961 assert_return(s
->type
== SOURCE_IO
, -EDOM
);
1962 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
1967 if (s
->enabled
== SD_EVENT_OFF
) {
1969 s
->io
.registered
= false;
1973 saved_fd
= s
->io
.fd
;
1974 assert(s
->io
.registered
);
1977 s
->io
.registered
= false;
1979 r
= source_io_register(s
, s
->enabled
, s
->io
.events
);
1981 s
->io
.fd
= saved_fd
;
1982 s
->io
.registered
= true;
1986 (void) epoll_ctl(s
->event
->epoll_fd
, EPOLL_CTL_DEL
, saved_fd
, NULL
);
1992 _public_
int sd_event_source_get_io_fd_own(sd_event_source
*s
) {
1993 assert_return(s
, -EINVAL
);
1994 assert_return(s
->type
== SOURCE_IO
, -EDOM
);
1999 _public_
int sd_event_source_set_io_fd_own(sd_event_source
*s
, int own
) {
2000 assert_return(s
, -EINVAL
);
2001 assert_return(s
->type
== SOURCE_IO
, -EDOM
);
2007 _public_
int sd_event_source_get_io_events(sd_event_source
*s
, uint32_t* events
) {
2008 assert_return(s
, -EINVAL
);
2009 assert_return(events
, -EINVAL
);
2010 assert_return(s
->type
== SOURCE_IO
, -EDOM
);
2011 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2013 *events
= s
->io
.events
;
2017 _public_
int sd_event_source_set_io_events(sd_event_source
*s
, uint32_t events
) {
2020 assert_return(s
, -EINVAL
);
2021 assert_return(s
->type
== SOURCE_IO
, -EDOM
);
2022 assert_return(!(events
& ~(EPOLLIN
|EPOLLOUT
|EPOLLRDHUP
|EPOLLPRI
|EPOLLERR
|EPOLLHUP
|EPOLLET
)), -EINVAL
);
2023 assert_return(s
->event
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
2024 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2026 /* edge-triggered updates are never skipped, so we can reset edges */
2027 if (s
->io
.events
== events
&& !(events
& EPOLLET
))
2030 r
= source_set_pending(s
, false);
2034 if (s
->enabled
!= SD_EVENT_OFF
) {
2035 r
= source_io_register(s
, s
->enabled
, events
);
2040 s
->io
.events
= events
;
2045 _public_
int sd_event_source_get_io_revents(sd_event_source
*s
, uint32_t* revents
) {
2046 assert_return(s
, -EINVAL
);
2047 assert_return(revents
, -EINVAL
);
2048 assert_return(s
->type
== SOURCE_IO
, -EDOM
);
2049 assert_return(s
->pending
, -ENODATA
);
2050 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2052 *revents
= s
->io
.revents
;
2056 _public_
int sd_event_source_get_signal(sd_event_source
*s
) {
2057 assert_return(s
, -EINVAL
);
2058 assert_return(s
->type
== SOURCE_SIGNAL
, -EDOM
);
2059 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2061 return s
->signal
.sig
;
2064 _public_
int sd_event_source_get_priority(sd_event_source
*s
, int64_t *priority
) {
2065 assert_return(s
, -EINVAL
);
2066 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2068 *priority
= s
->priority
;
2072 _public_
int sd_event_source_set_priority(sd_event_source
*s
, int64_t priority
) {
2073 bool rm_inotify
= false, rm_inode
= false;
2074 struct inotify_data
*new_inotify_data
= NULL
;
2075 struct inode_data
*new_inode_data
= NULL
;
2078 assert_return(s
, -EINVAL
);
2079 assert_return(s
->event
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
2080 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2082 if (s
->priority
== priority
)
2085 if (s
->type
== SOURCE_INOTIFY
) {
2086 struct inode_data
*old_inode_data
;
2088 assert(s
->inotify
.inode_data
);
2089 old_inode_data
= s
->inotify
.inode_data
;
2091 /* We need the original fd to change the priority. If we don't have it we can't change the priority,
2092 * anymore. Note that we close any fds when entering the next event loop iteration, i.e. for inotify
2093 * events we allow priority changes only until the first following iteration. */
2094 if (old_inode_data
->fd
< 0)
2097 r
= event_make_inotify_data(s
->event
, priority
, &new_inotify_data
);
2102 r
= event_make_inode_data(s
->event
, new_inotify_data
, old_inode_data
->dev
, old_inode_data
->ino
, &new_inode_data
);
2107 if (new_inode_data
->fd
< 0) {
2108 /* Duplicate the fd for the new inode object if we don't have any yet */
2109 new_inode_data
->fd
= fcntl(old_inode_data
->fd
, F_DUPFD_CLOEXEC
, 3);
2110 if (new_inode_data
->fd
< 0) {
2115 LIST_PREPEND(to_close
, s
->event
->inode_data_to_close
, new_inode_data
);
2118 /* Move the event source to the new inode data structure */
2119 LIST_REMOVE(inotify
.by_inode_data
, old_inode_data
->event_sources
, s
);
2120 LIST_PREPEND(inotify
.by_inode_data
, new_inode_data
->event_sources
, s
);
2121 s
->inotify
.inode_data
= new_inode_data
;
2123 /* Now create the new watch */
2124 r
= inode_data_realize_watch(s
->event
, new_inode_data
);
2127 LIST_REMOVE(inotify
.by_inode_data
, new_inode_data
->event_sources
, s
);
2128 LIST_PREPEND(inotify
.by_inode_data
, old_inode_data
->event_sources
, s
);
2129 s
->inotify
.inode_data
= old_inode_data
;
2133 s
->priority
= priority
;
2135 event_gc_inode_data(s
->event
, old_inode_data
);
2137 } else if (s
->type
== SOURCE_SIGNAL
&& s
->enabled
!= SD_EVENT_OFF
) {
2138 struct signal_data
*old
, *d
;
2140 /* Move us from the signalfd belonging to the old
2141 * priority to the signalfd of the new priority */
2143 assert_se(old
= hashmap_get(s
->event
->signal_data
, &s
->priority
));
2145 s
->priority
= priority
;
2147 r
= event_make_signal_data(s
->event
, s
->signal
.sig
, &d
);
2149 s
->priority
= old
->priority
;
2153 event_unmask_signal_data(s
->event
, old
, s
->signal
.sig
);
2155 s
->priority
= priority
;
2158 prioq_reshuffle(s
->event
->pending
, s
, &s
->pending_index
);
2161 prioq_reshuffle(s
->event
->prepare
, s
, &s
->prepare_index
);
2163 if (s
->type
== SOURCE_EXIT
)
2164 prioq_reshuffle(s
->event
->exit
, s
, &s
->exit
.prioq_index
);
2170 event_free_inode_data(s
->event
, new_inode_data
);
2173 event_free_inotify_data(s
->event
, new_inotify_data
);
2178 _public_
int sd_event_source_get_enabled(sd_event_source
*s
, int *m
) {
2179 assert_return(s
, -EINVAL
);
2180 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2184 return s
->enabled
!= SD_EVENT_OFF
;
2187 _public_
int sd_event_source_set_enabled(sd_event_source
*s
, int m
) {
2190 assert_return(s
, -EINVAL
);
2191 assert_return(IN_SET(m
, SD_EVENT_OFF
, SD_EVENT_ON
, SD_EVENT_ONESHOT
), -EINVAL
);
2192 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2194 /* If we are dead anyway, we are fine with turning off
2195 * sources, but everything else needs to fail. */
2196 if (s
->event
->state
== SD_EVENT_FINISHED
)
2197 return m
== SD_EVENT_OFF
? 0 : -ESTALE
;
2199 if (s
->enabled
== m
)
2202 if (m
== SD_EVENT_OFF
) {
2204 /* Unset the pending flag when this event source is disabled */
2205 if (!IN_SET(s
->type
, SOURCE_DEFER
, SOURCE_EXIT
)) {
2206 r
= source_set_pending(s
, false);
2214 source_io_unregister(s
);
2218 case SOURCE_TIME_REALTIME
:
2219 case SOURCE_TIME_BOOTTIME
:
2220 case SOURCE_TIME_MONOTONIC
:
2221 case SOURCE_TIME_REALTIME_ALARM
:
2222 case SOURCE_TIME_BOOTTIME_ALARM
: {
2223 struct clock_data
*d
;
2226 d
= event_get_clock_data(s
->event
, s
->type
);
2229 prioq_reshuffle(d
->earliest
, s
, &s
->time
.earliest_index
);
2230 prioq_reshuffle(d
->latest
, s
, &s
->time
.latest_index
);
2231 d
->needs_rearm
= true;
2238 event_gc_signal_data(s
->event
, &s
->priority
, s
->signal
.sig
);
2244 assert(s
->event
->n_enabled_child_sources
> 0);
2245 s
->event
->n_enabled_child_sources
--;
2247 if (EVENT_SOURCE_WATCH_PIDFD(s
))
2248 source_child_pidfd_unregister(s
);
2250 event_gc_signal_data(s
->event
, &s
->priority
, SIGCHLD
);
2256 prioq_reshuffle(s
->event
->exit
, s
, &s
->exit
.prioq_index
);
2261 case SOURCE_INOTIFY
:
2266 assert_not_reached("Wut? I shouldn't exist.");
2271 /* Unset the pending flag when this event source is enabled */
2272 if (s
->enabled
== SD_EVENT_OFF
&& !IN_SET(s
->type
, SOURCE_DEFER
, SOURCE_EXIT
)) {
2273 r
= source_set_pending(s
, false);
2281 r
= source_io_register(s
, m
, s
->io
.events
);
2288 case SOURCE_TIME_REALTIME
:
2289 case SOURCE_TIME_BOOTTIME
:
2290 case SOURCE_TIME_MONOTONIC
:
2291 case SOURCE_TIME_REALTIME_ALARM
:
2292 case SOURCE_TIME_BOOTTIME_ALARM
: {
2293 struct clock_data
*d
;
2296 d
= event_get_clock_data(s
->event
, s
->type
);
2299 prioq_reshuffle(d
->earliest
, s
, &s
->time
.earliest_index
);
2300 prioq_reshuffle(d
->latest
, s
, &s
->time
.latest_index
);
2301 d
->needs_rearm
= true;
2309 r
= event_make_signal_data(s
->event
, s
->signal
.sig
, NULL
);
2311 s
->enabled
= SD_EVENT_OFF
;
2312 event_gc_signal_data(s
->event
, &s
->priority
, s
->signal
.sig
);
2320 if (s
->enabled
== SD_EVENT_OFF
)
2321 s
->event
->n_enabled_child_sources
++;
2325 if (EVENT_SOURCE_WATCH_PIDFD(s
)) {
2326 /* yes, we have pidfd */
2328 r
= source_child_pidfd_register(s
, s
->enabled
);
2330 s
->enabled
= SD_EVENT_OFF
;
2331 s
->event
->n_enabled_child_sources
--;
2335 /* no pidfd, or something other to watch for than WEXITED */
2337 r
= event_make_signal_data(s
->event
, SIGCHLD
, NULL
);
2339 s
->enabled
= SD_EVENT_OFF
;
2340 s
->event
->n_enabled_child_sources
--;
2341 event_gc_signal_data(s
->event
, &s
->priority
, SIGCHLD
);
2350 prioq_reshuffle(s
->event
->exit
, s
, &s
->exit
.prioq_index
);
2355 case SOURCE_INOTIFY
:
2360 assert_not_reached("Wut? I shouldn't exist.");
2365 prioq_reshuffle(s
->event
->pending
, s
, &s
->pending_index
);
2368 prioq_reshuffle(s
->event
->prepare
, s
, &s
->prepare_index
);
2373 _public_
int sd_event_source_get_time(sd_event_source
*s
, uint64_t *usec
) {
2374 assert_return(s
, -EINVAL
);
2375 assert_return(usec
, -EINVAL
);
2376 assert_return(EVENT_SOURCE_IS_TIME(s
->type
), -EDOM
);
2377 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2379 *usec
= s
->time
.next
;
2383 _public_
int sd_event_source_set_time(sd_event_source
*s
, uint64_t usec
) {
2384 struct clock_data
*d
;
2387 assert_return(s
, -EINVAL
);
2388 assert_return(EVENT_SOURCE_IS_TIME(s
->type
), -EDOM
);
2389 assert_return(s
->event
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
2390 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2392 r
= source_set_pending(s
, false);
2396 s
->time
.next
= usec
;
2398 d
= event_get_clock_data(s
->event
, s
->type
);
2401 prioq_reshuffle(d
->earliest
, s
, &s
->time
.earliest_index
);
2402 prioq_reshuffle(d
->latest
, s
, &s
->time
.latest_index
);
2403 d
->needs_rearm
= true;
2408 _public_
int sd_event_source_get_time_accuracy(sd_event_source
*s
, uint64_t *usec
) {
2409 assert_return(s
, -EINVAL
);
2410 assert_return(usec
, -EINVAL
);
2411 assert_return(EVENT_SOURCE_IS_TIME(s
->type
), -EDOM
);
2412 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2414 *usec
= s
->time
.accuracy
;
2418 _public_
int sd_event_source_set_time_accuracy(sd_event_source
*s
, uint64_t usec
) {
2419 struct clock_data
*d
;
2422 assert_return(s
, -EINVAL
);
2423 assert_return(usec
!= (uint64_t) -1, -EINVAL
);
2424 assert_return(EVENT_SOURCE_IS_TIME(s
->type
), -EDOM
);
2425 assert_return(s
->event
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
2426 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2428 r
= source_set_pending(s
, false);
2433 usec
= DEFAULT_ACCURACY_USEC
;
2435 s
->time
.accuracy
= usec
;
2437 d
= event_get_clock_data(s
->event
, s
->type
);
2440 prioq_reshuffle(d
->latest
, s
, &s
->time
.latest_index
);
2441 d
->needs_rearm
= true;
2446 _public_
int sd_event_source_get_time_clock(sd_event_source
*s
, clockid_t
*clock
) {
2447 assert_return(s
, -EINVAL
);
2448 assert_return(clock
, -EINVAL
);
2449 assert_return(EVENT_SOURCE_IS_TIME(s
->type
), -EDOM
);
2450 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2452 *clock
= event_source_type_to_clock(s
->type
);
2456 _public_
int sd_event_source_get_child_pid(sd_event_source
*s
, pid_t
*pid
) {
2457 assert_return(s
, -EINVAL
);
2458 assert_return(pid
, -EINVAL
);
2459 assert_return(s
->type
== SOURCE_CHILD
, -EDOM
);
2460 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2462 *pid
= s
->child
.pid
;
2466 _public_
int sd_event_source_get_child_pidfd(sd_event_source
*s
) {
2467 assert_return(s
, -EINVAL
);
2468 assert_return(s
->type
== SOURCE_CHILD
, -EDOM
);
2469 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2471 if (s
->child
.pidfd
< 0)
2474 return s
->child
.pidfd
;
2477 _public_
int sd_event_source_send_child_signal(sd_event_source
*s
, int sig
, const siginfo_t
*si
, unsigned flags
) {
2478 assert_return(s
, -EINVAL
);
2479 assert_return(s
->type
== SOURCE_CHILD
, -EDOM
);
2480 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2481 assert_return(SIGNAL_VALID(sig
), -EINVAL
);
2483 /* If we already have seen indication the process exited refuse sending a signal early. This way we
2484 * can be sure we don't accidentally kill the wrong process on PID reuse when pidfds are not
2486 if (s
->child
.exited
)
2489 if (s
->child
.pidfd
>= 0) {
2492 /* pidfd_send_signal() changes the siginfo_t argument. This is weird, let's hence copy the
2497 if (pidfd_send_signal(s
->child
.pidfd
, sig
, si
? ©
: NULL
, 0) < 0) {
2498 /* Let's propagate the error only if the system call is not implemented or prohibited */
2499 if (!ERRNO_IS_NOT_SUPPORTED(errno
) && !ERRNO_IS_PRIVILEGE(errno
))
2505 /* Flags are only supported for pidfd_send_signal(), not for rt_sigqueueinfo(), hence let's refuse
2511 /* We use rt_sigqueueinfo() only if siginfo_t is specified. */
2512 siginfo_t copy
= *si
;
2514 if (rt_sigqueueinfo(s
->child
.pid
, sig
, ©
) < 0)
2516 } else if (kill(s
->child
.pid
, sig
) < 0)
2522 _public_
int sd_event_source_get_child_pidfd_own(sd_event_source
*s
) {
2523 assert_return(s
, -EINVAL
);
2524 assert_return(s
->type
== SOURCE_CHILD
, -EDOM
);
2526 if (s
->child
.pidfd
< 0)
2529 return s
->child
.pidfd_owned
;
2532 _public_
int sd_event_source_set_child_pidfd_own(sd_event_source
*s
, int own
) {
2533 assert_return(s
, -EINVAL
);
2534 assert_return(s
->type
== SOURCE_CHILD
, -EDOM
);
2536 if (s
->child
.pidfd
< 0)
2539 s
->child
.pidfd_owned
= own
;
2543 _public_
int sd_event_source_get_child_process_own(sd_event_source
*s
) {
2544 assert_return(s
, -EINVAL
);
2545 assert_return(s
->type
== SOURCE_CHILD
, -EDOM
);
2547 return s
->child
.process_owned
;
2550 _public_
int sd_event_source_set_child_process_own(sd_event_source
*s
, int own
) {
2551 assert_return(s
, -EINVAL
);
2552 assert_return(s
->type
== SOURCE_CHILD
, -EDOM
);
2554 s
->child
.process_owned
= own
;
2558 _public_
int sd_event_source_get_inotify_mask(sd_event_source
*s
, uint32_t *mask
) {
2559 assert_return(s
, -EINVAL
);
2560 assert_return(mask
, -EINVAL
);
2561 assert_return(s
->type
== SOURCE_INOTIFY
, -EDOM
);
2562 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2564 *mask
= s
->inotify
.mask
;
2568 _public_
int sd_event_source_set_prepare(sd_event_source
*s
, sd_event_handler_t callback
) {
2571 assert_return(s
, -EINVAL
);
2572 assert_return(s
->type
!= SOURCE_EXIT
, -EDOM
);
2573 assert_return(s
->event
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
2574 assert_return(!event_pid_changed(s
->event
), -ECHILD
);
2576 if (s
->prepare
== callback
)
2579 if (callback
&& s
->prepare
) {
2580 s
->prepare
= callback
;
2584 r
= prioq_ensure_allocated(&s
->event
->prepare
, prepare_prioq_compare
);
2588 s
->prepare
= callback
;
2591 r
= prioq_put(s
->event
->prepare
, s
, &s
->prepare_index
);
2595 prioq_remove(s
->event
->prepare
, s
, &s
->prepare_index
);
2600 _public_
void* sd_event_source_get_userdata(sd_event_source
*s
) {
2601 assert_return(s
, NULL
);
2606 _public_
void *sd_event_source_set_userdata(sd_event_source
*s
, void *userdata
) {
2609 assert_return(s
, NULL
);
2612 s
->userdata
= userdata
;
2617 static usec_t
sleep_between(sd_event
*e
, usec_t a
, usec_t b
) {
2624 if (a
>= USEC_INFINITY
)
2625 return USEC_INFINITY
;
2630 initialize_perturb(e
);
2633 Find a good time to wake up again between times a and b. We
2634 have two goals here:
2636 a) We want to wake up as seldom as possible, hence prefer
2637 later times over earlier times.
2639 b) But if we have to wake up, then let's make sure to
2640 dispatch as much as possible on the entire system.
2642 We implement this by waking up everywhere at the same time
2643 within any given minute if we can, synchronised via the
2644 perturbation value determined from the boot ID. If we can't,
2645 then we try to find the same spot in every 10s, then 1s and
2646 then 250ms step. Otherwise, we pick the last possible time
2650 c
= (b
/ USEC_PER_MINUTE
) * USEC_PER_MINUTE
+ e
->perturb
;
2652 if (_unlikely_(c
< USEC_PER_MINUTE
))
2655 c
-= USEC_PER_MINUTE
;
2661 c
= (b
/ (USEC_PER_SEC
*10)) * (USEC_PER_SEC
*10) + (e
->perturb
% (USEC_PER_SEC
*10));
2663 if (_unlikely_(c
< USEC_PER_SEC
*10))
2666 c
-= USEC_PER_SEC
*10;
2672 c
= (b
/ USEC_PER_SEC
) * USEC_PER_SEC
+ (e
->perturb
% USEC_PER_SEC
);
2674 if (_unlikely_(c
< USEC_PER_SEC
))
2683 c
= (b
/ (USEC_PER_MSEC
*250)) * (USEC_PER_MSEC
*250) + (e
->perturb
% (USEC_PER_MSEC
*250));
2685 if (_unlikely_(c
< USEC_PER_MSEC
*250))
2688 c
-= USEC_PER_MSEC
*250;
2697 static int event_arm_timer(
2699 struct clock_data
*d
) {
2701 struct itimerspec its
= {};
2702 sd_event_source
*a
, *b
;
2709 if (!d
->needs_rearm
)
2712 d
->needs_rearm
= false;
2714 a
= prioq_peek(d
->earliest
);
2715 if (!a
|| a
->enabled
== SD_EVENT_OFF
|| a
->time
.next
== USEC_INFINITY
) {
2720 if (d
->next
== USEC_INFINITY
)
2724 r
= timerfd_settime(d
->fd
, TFD_TIMER_ABSTIME
, &its
, NULL
);
2728 d
->next
= USEC_INFINITY
;
2732 b
= prioq_peek(d
->latest
);
2733 assert_se(b
&& b
->enabled
!= SD_EVENT_OFF
);
2735 t
= sleep_between(e
, a
->time
.next
, time_event_source_latest(b
));
2739 assert_se(d
->fd
>= 0);
2742 /* We don' want to disarm here, just mean some time looooong ago. */
2743 its
.it_value
.tv_sec
= 0;
2744 its
.it_value
.tv_nsec
= 1;
2746 timespec_store(&its
.it_value
, t
);
2748 r
= timerfd_settime(d
->fd
, TFD_TIMER_ABSTIME
, &its
, NULL
);
2756 static int process_io(sd_event
*e
, sd_event_source
*s
, uint32_t revents
) {
2759 assert(s
->type
== SOURCE_IO
);
2761 /* If the event source was already pending, we just OR in the
2762 * new revents, otherwise we reset the value. The ORing is
2763 * necessary to handle EPOLLONESHOT events properly where
2764 * readability might happen independently of writability, and
2765 * we need to keep track of both */
2768 s
->io
.revents
|= revents
;
2770 s
->io
.revents
= revents
;
2772 return source_set_pending(s
, true);
2775 static int flush_timer(sd_event
*e
, int fd
, uint32_t events
, usec_t
*next
) {
2782 assert_return(events
== EPOLLIN
, -EIO
);
2784 ss
= read(fd
, &x
, sizeof(x
));
2786 if (IN_SET(errno
, EAGAIN
, EINTR
))
2792 if (_unlikely_(ss
!= sizeof(x
)))
2796 *next
= USEC_INFINITY
;
2801 static int process_timer(
2804 struct clock_data
*d
) {
2813 s
= prioq_peek(d
->earliest
);
2816 s
->enabled
== SD_EVENT_OFF
||
2820 r
= source_set_pending(s
, true);
2824 prioq_reshuffle(d
->earliest
, s
, &s
->time
.earliest_index
);
2825 prioq_reshuffle(d
->latest
, s
, &s
->time
.latest_index
);
2826 d
->needs_rearm
= true;
2832 static int process_child(sd_event
*e
) {
2839 e
->need_process_child
= false;
2842 So, this is ugly. We iteratively invoke waitid() with P_PID
2843 + WNOHANG for each PID we wait for, instead of using
2844 P_ALL. This is because we only want to get child
2845 information of very specific child processes, and not all
2846 of them. We might not have processed the SIGCHLD even of a
2847 previous invocation and we don't want to maintain a
2848 unbounded *per-child* event queue, hence we really don't
2849 want anything flushed out of the kernel's queue that we
2850 don't care about. Since this is O(n) this means that if you
2851 have a lot of processes you probably want to handle SIGCHLD
2854 We do not reap the children here (by using WNOWAIT), this
2855 is only done after the event source is dispatched so that
2856 the callback still sees the process as a zombie.
2859 HASHMAP_FOREACH(s
, e
->child_sources
, i
) {
2860 assert(s
->type
== SOURCE_CHILD
);
2865 if (s
->enabled
== SD_EVENT_OFF
)
2868 if (s
->child
.exited
)
2871 if (EVENT_SOURCE_WATCH_PIDFD(s
)) /* There's a usable pidfd known for this event source? then don't waitid() for it here */
2874 zero(s
->child
.siginfo
);
2875 r
= waitid(P_PID
, s
->child
.pid
, &s
->child
.siginfo
,
2876 WNOHANG
| (s
->child
.options
& WEXITED
? WNOWAIT
: 0) | s
->child
.options
);
2880 if (s
->child
.siginfo
.si_pid
!= 0) {
2881 bool zombie
= IN_SET(s
->child
.siginfo
.si_code
, CLD_EXITED
, CLD_KILLED
, CLD_DUMPED
);
2884 s
->child
.exited
= true;
2886 if (!zombie
&& (s
->child
.options
& WEXITED
)) {
2887 /* If the child isn't dead then let's
2888 * immediately remove the state change
2889 * from the queue, since there's no
2890 * benefit in leaving it queued */
2892 assert(s
->child
.options
& (WSTOPPED
|WCONTINUED
));
2893 (void) waitid(P_PID
, s
->child
.pid
, &s
->child
.siginfo
, WNOHANG
|(s
->child
.options
& (WSTOPPED
|WCONTINUED
)));
2896 r
= source_set_pending(s
, true);
2905 static int process_pidfd(sd_event
*e
, sd_event_source
*s
, uint32_t revents
) {
2908 assert(s
->type
== SOURCE_CHILD
);
2913 if (s
->enabled
== SD_EVENT_OFF
)
2916 if (!EVENT_SOURCE_WATCH_PIDFD(s
))
2919 zero(s
->child
.siginfo
);
2920 if (waitid(P_PID
, s
->child
.pid
, &s
->child
.siginfo
, WNOHANG
| WNOWAIT
| s
->child
.options
) < 0)
2923 if (s
->child
.siginfo
.si_pid
== 0)
2926 if (IN_SET(s
->child
.siginfo
.si_code
, CLD_EXITED
, CLD_KILLED
, CLD_DUMPED
))
2927 s
->child
.exited
= true;
2929 return source_set_pending(s
, true);
2932 static int process_signal(sd_event
*e
, struct signal_data
*d
, uint32_t events
) {
2933 bool read_one
= false;
2938 assert_return(events
== EPOLLIN
, -EIO
);
2940 /* If there's a signal queued on this priority and SIGCHLD is
2941 on this priority too, then make sure to recheck the
2942 children we watch. This is because we only ever dequeue
2943 the first signal per priority, and if we dequeue one, and
2944 SIGCHLD might be enqueued later we wouldn't know, but we
2945 might have higher priority children we care about hence we
2946 need to check that explicitly. */
2948 if (sigismember(&d
->sigset
, SIGCHLD
))
2949 e
->need_process_child
= true;
2951 /* If there's already an event source pending for this
2952 * priority we don't read another */
2957 struct signalfd_siginfo si
;
2959 sd_event_source
*s
= NULL
;
2961 n
= read(d
->fd
, &si
, sizeof(si
));
2963 if (IN_SET(errno
, EAGAIN
, EINTR
))
2969 if (_unlikely_(n
!= sizeof(si
)))
2972 assert(SIGNAL_VALID(si
.ssi_signo
));
2976 if (e
->signal_sources
)
2977 s
= e
->signal_sources
[si
.ssi_signo
];
2983 s
->signal
.siginfo
= si
;
2986 r
= source_set_pending(s
, true);
2994 static int event_inotify_data_read(sd_event
*e
, struct inotify_data
*d
, uint32_t revents
) {
3000 assert_return(revents
== EPOLLIN
, -EIO
);
3002 /* If there's already an event source pending for this priority, don't read another */
3003 if (d
->n_pending
> 0)
3006 /* Is the read buffer non-empty? If so, let's not read more */
3007 if (d
->buffer_filled
> 0)
3010 n
= read(d
->fd
, &d
->buffer
, sizeof(d
->buffer
));
3012 if (IN_SET(errno
, EAGAIN
, EINTR
))
3019 d
->buffer_filled
= (size_t) n
;
3020 LIST_PREPEND(buffered
, e
->inotify_data_buffered
, d
);
3025 static void event_inotify_data_drop(sd_event
*e
, struct inotify_data
*d
, size_t sz
) {
3028 assert(sz
<= d
->buffer_filled
);
3033 /* Move the rest to the buffer to the front, in order to get things properly aligned again */
3034 memmove(d
->buffer
.raw
, d
->buffer
.raw
+ sz
, d
->buffer_filled
- sz
);
3035 d
->buffer_filled
-= sz
;
3037 if (d
->buffer_filled
== 0)
3038 LIST_REMOVE(buffered
, e
->inotify_data_buffered
, d
);
3041 static int event_inotify_data_process(sd_event
*e
, struct inotify_data
*d
) {
3047 /* If there's already an event source pending for this priority, don't read another */
3048 if (d
->n_pending
> 0)
3051 while (d
->buffer_filled
> 0) {
3054 /* Let's validate that the event structures are complete */
3055 if (d
->buffer_filled
< offsetof(struct inotify_event
, name
))
3058 sz
= offsetof(struct inotify_event
, name
) + d
->buffer
.ev
.len
;
3059 if (d
->buffer_filled
< sz
)
3062 if (d
->buffer
.ev
.mask
& IN_Q_OVERFLOW
) {
3063 struct inode_data
*inode_data
;
3066 /* The queue overran, let's pass this event to all event sources connected to this inotify
3069 HASHMAP_FOREACH(inode_data
, d
->inodes
, i
) {
3072 LIST_FOREACH(inotify
.by_inode_data
, s
, inode_data
->event_sources
) {
3074 if (s
->enabled
== SD_EVENT_OFF
)
3077 r
= source_set_pending(s
, true);
3083 struct inode_data
*inode_data
;
3086 /* Find the inode object for this watch descriptor. If IN_IGNORED is set we also remove it from
3087 * our watch descriptor table. */
3088 if (d
->buffer
.ev
.mask
& IN_IGNORED
) {
3090 inode_data
= hashmap_remove(d
->wd
, INT_TO_PTR(d
->buffer
.ev
.wd
));
3092 event_inotify_data_drop(e
, d
, sz
);
3096 /* The watch descriptor was removed by the kernel, let's drop it here too */
3097 inode_data
->wd
= -1;
3099 inode_data
= hashmap_get(d
->wd
, INT_TO_PTR(d
->buffer
.ev
.wd
));
3101 event_inotify_data_drop(e
, d
, sz
);
3106 /* Trigger all event sources that are interested in these events. Also trigger all event
3107 * sources if IN_IGNORED or IN_UNMOUNT is set. */
3108 LIST_FOREACH(inotify
.by_inode_data
, s
, inode_data
->event_sources
) {
3110 if (s
->enabled
== SD_EVENT_OFF
)
3113 if ((d
->buffer
.ev
.mask
& (IN_IGNORED
|IN_UNMOUNT
)) == 0 &&
3114 (s
->inotify
.mask
& d
->buffer
.ev
.mask
& IN_ALL_EVENTS
) == 0)
3117 r
= source_set_pending(s
, true);
3123 /* Something pending now? If so, let's finish, otherwise let's read more. */
3124 if (d
->n_pending
> 0)
3131 static int process_inotify(sd_event
*e
) {
3132 struct inotify_data
*d
;
3137 LIST_FOREACH(buffered
, d
, e
->inotify_data_buffered
) {
3138 r
= event_inotify_data_process(e
, d
);
3148 static int source_dispatch(sd_event_source
*s
) {
3149 EventSourceType saved_type
;
3153 assert(s
->pending
|| s
->type
== SOURCE_EXIT
);
3155 /* Save the event source type, here, so that we still know it after the event callback which might invalidate
3157 saved_type
= s
->type
;
3159 if (!IN_SET(s
->type
, SOURCE_DEFER
, SOURCE_EXIT
)) {
3160 r
= source_set_pending(s
, false);
3165 if (s
->type
!= SOURCE_POST
) {
3169 /* If we execute a non-post source, let's mark all
3170 * post sources as pending */
3172 SET_FOREACH(z
, s
->event
->post_sources
, i
) {
3173 if (z
->enabled
== SD_EVENT_OFF
)
3176 r
= source_set_pending(z
, true);
3182 if (s
->enabled
== SD_EVENT_ONESHOT
) {
3183 r
= sd_event_source_set_enabled(s
, SD_EVENT_OFF
);
3188 s
->dispatching
= true;
3193 r
= s
->io
.callback(s
, s
->io
.fd
, s
->io
.revents
, s
->userdata
);
3196 case SOURCE_TIME_REALTIME
:
3197 case SOURCE_TIME_BOOTTIME
:
3198 case SOURCE_TIME_MONOTONIC
:
3199 case SOURCE_TIME_REALTIME_ALARM
:
3200 case SOURCE_TIME_BOOTTIME_ALARM
:
3201 r
= s
->time
.callback(s
, s
->time
.next
, s
->userdata
);
3205 r
= s
->signal
.callback(s
, &s
->signal
.siginfo
, s
->userdata
);
3208 case SOURCE_CHILD
: {
3211 zombie
= IN_SET(s
->child
.siginfo
.si_code
, CLD_EXITED
, CLD_KILLED
, CLD_DUMPED
);
3213 r
= s
->child
.callback(s
, &s
->child
.siginfo
, s
->userdata
);
3215 /* Now, reap the PID for good. */
3217 (void) waitid(P_PID
, s
->child
.pid
, &s
->child
.siginfo
, WNOHANG
|WEXITED
);
3218 s
->child
.waited
= true;
3225 r
= s
->defer
.callback(s
, s
->userdata
);
3229 r
= s
->post
.callback(s
, s
->userdata
);
3233 r
= s
->exit
.callback(s
, s
->userdata
);
3236 case SOURCE_INOTIFY
: {
3237 struct sd_event
*e
= s
->event
;
3238 struct inotify_data
*d
;
3241 assert(s
->inotify
.inode_data
);
3242 assert_se(d
= s
->inotify
.inode_data
->inotify_data
);
3244 assert(d
->buffer_filled
>= offsetof(struct inotify_event
, name
));
3245 sz
= offsetof(struct inotify_event
, name
) + d
->buffer
.ev
.len
;
3246 assert(d
->buffer_filled
>= sz
);
3248 r
= s
->inotify
.callback(s
, &d
->buffer
.ev
, s
->userdata
);
3250 /* When no event is pending anymore on this inotify object, then let's drop the event from the
3252 if (d
->n_pending
== 0)
3253 event_inotify_data_drop(e
, d
, sz
);
3258 case SOURCE_WATCHDOG
:
3259 case _SOURCE_EVENT_SOURCE_TYPE_MAX
:
3260 case _SOURCE_EVENT_SOURCE_TYPE_INVALID
:
3261 assert_not_reached("Wut? I shouldn't exist.");
3264 s
->dispatching
= false;
3267 log_debug_errno(r
, "Event source %s (type %s) returned error, disabling: %m",
3268 strna(s
->description
), event_source_type_to_string(saved_type
));
3273 sd_event_source_set_enabled(s
, SD_EVENT_OFF
);
3278 static int event_prepare(sd_event
*e
) {
3286 s
= prioq_peek(e
->prepare
);
3287 if (!s
|| s
->prepare_iteration
== e
->iteration
|| s
->enabled
== SD_EVENT_OFF
)
3290 s
->prepare_iteration
= e
->iteration
;
3291 r
= prioq_reshuffle(e
->prepare
, s
, &s
->prepare_index
);
3297 s
->dispatching
= true;
3298 r
= s
->prepare(s
, s
->userdata
);
3299 s
->dispatching
= false;
3302 log_debug_errno(r
, "Prepare callback of event source %s (type %s) returned error, disabling: %m",
3303 strna(s
->description
), event_source_type_to_string(s
->type
));
3308 sd_event_source_set_enabled(s
, SD_EVENT_OFF
);
3314 static int dispatch_exit(sd_event
*e
) {
3316 _cleanup_(sd_event_unrefp
) sd_event
*ref
= NULL
;
3321 p
= prioq_peek(e
->exit
);
3322 if (!p
|| p
->enabled
== SD_EVENT_OFF
) {
3323 e
->state
= SD_EVENT_FINISHED
;
3327 ref
= sd_event_ref(e
);
3329 e
->state
= SD_EVENT_EXITING
;
3330 r
= source_dispatch(p
);
3331 e
->state
= SD_EVENT_INITIAL
;
3335 static sd_event_source
* event_next_pending(sd_event
*e
) {
3340 p
= prioq_peek(e
->pending
);
3344 if (p
->enabled
== SD_EVENT_OFF
)
3350 static int arm_watchdog(sd_event
*e
) {
3351 struct itimerspec its
= {};
3356 assert(e
->watchdog_fd
>= 0);
3358 t
= sleep_between(e
,
3359 e
->watchdog_last
+ (e
->watchdog_period
/ 2),
3360 e
->watchdog_last
+ (e
->watchdog_period
* 3 / 4));
3362 timespec_store(&its
.it_value
, t
);
3364 /* Make sure we never set the watchdog to 0, which tells the
3365 * kernel to disable it. */
3366 if (its
.it_value
.tv_sec
== 0 && its
.it_value
.tv_nsec
== 0)
3367 its
.it_value
.tv_nsec
= 1;
3369 r
= timerfd_settime(e
->watchdog_fd
, TFD_TIMER_ABSTIME
, &its
, NULL
);
3376 static int process_watchdog(sd_event
*e
) {
3382 /* Don't notify watchdog too often */
3383 if (e
->watchdog_last
+ e
->watchdog_period
/ 4 > e
->timestamp
.monotonic
)
3386 sd_notify(false, "WATCHDOG=1");
3387 e
->watchdog_last
= e
->timestamp
.monotonic
;
3389 return arm_watchdog(e
);
3392 static void event_close_inode_data_fds(sd_event
*e
) {
3393 struct inode_data
*d
;
3397 /* Close the fds pointing to the inodes to watch now. We need to close them as they might otherwise pin
3398 * filesystems. But we can't close them right-away as we need them as long as the user still wants to make
3399 * adjustments to the even source, such as changing the priority (which requires us to remove and re-add a watch
3400 * for the inode). Hence, let's close them when entering the first iteration after they were added, as a
3403 while ((d
= e
->inode_data_to_close
)) {
3405 d
->fd
= safe_close(d
->fd
);
3407 LIST_REMOVE(to_close
, e
->inode_data_to_close
, d
);
3411 _public_
int sd_event_prepare(sd_event
*e
) {
3414 assert_return(e
, -EINVAL
);
3415 assert_return(e
= event_resolve(e
), -ENOPKG
);
3416 assert_return(!event_pid_changed(e
), -ECHILD
);
3417 assert_return(e
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
3418 assert_return(e
->state
== SD_EVENT_INITIAL
, -EBUSY
);
3420 /* Let's check that if we are a default event loop we are executed in the correct thread. We only do
3421 * this check here once, since gettid() is typically not cached, and thus want to minimize
3423 assert_return(!e
->default_event_ptr
|| e
->tid
== gettid(), -EREMOTEIO
);
3425 if (e
->exit_requested
)
3430 e
->state
= SD_EVENT_PREPARING
;
3431 r
= event_prepare(e
);
3432 e
->state
= SD_EVENT_INITIAL
;
3436 r
= event_arm_timer(e
, &e
->realtime
);
3440 r
= event_arm_timer(e
, &e
->boottime
);
3444 r
= event_arm_timer(e
, &e
->monotonic
);
3448 r
= event_arm_timer(e
, &e
->realtime_alarm
);
3452 r
= event_arm_timer(e
, &e
->boottime_alarm
);
3456 event_close_inode_data_fds(e
);
3458 if (event_next_pending(e
) || e
->need_process_child
)
3461 e
->state
= SD_EVENT_ARMED
;
3466 e
->state
= SD_EVENT_ARMED
;
3467 r
= sd_event_wait(e
, 0);
3469 e
->state
= SD_EVENT_ARMED
;
3474 _public_
int sd_event_wait(sd_event
*e
, uint64_t timeout
) {
3475 size_t event_queue_max
;
3478 assert_return(e
, -EINVAL
);
3479 assert_return(e
= event_resolve(e
), -ENOPKG
);
3480 assert_return(!event_pid_changed(e
), -ECHILD
);
3481 assert_return(e
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
3482 assert_return(e
->state
== SD_EVENT_ARMED
, -EBUSY
);
3484 if (e
->exit_requested
) {
3485 e
->state
= SD_EVENT_PENDING
;
3489 event_queue_max
= MAX(e
->n_sources
, 1u);
3490 if (!GREEDY_REALLOC(e
->event_queue
, e
->event_queue_allocated
, event_queue_max
))
3493 /* If we still have inotify data buffered, then query the other fds, but don't wait on it */
3494 if (e
->inotify_data_buffered
)
3497 m
= epoll_wait(e
->epoll_fd
, e
->event_queue
, event_queue_max
,
3498 timeout
== (uint64_t) -1 ? -1 : (int) DIV_ROUND_UP(timeout
, USEC_PER_MSEC
));
3500 if (errno
== EINTR
) {
3501 e
->state
= SD_EVENT_PENDING
;
3509 triple_timestamp_get(&e
->timestamp
);
3511 for (i
= 0; i
< m
; i
++) {
3513 if (e
->event_queue
[i
].data
.ptr
== INT_TO_PTR(SOURCE_WATCHDOG
))
3514 r
= flush_timer(e
, e
->watchdog_fd
, e
->event_queue
[i
].events
, NULL
);
3516 WakeupType
*t
= e
->event_queue
[i
].data
.ptr
;
3520 case WAKEUP_EVENT_SOURCE
: {
3521 sd_event_source
*s
= e
->event_queue
[i
].data
.ptr
;
3528 r
= process_io(e
, s
, e
->event_queue
[i
].events
);
3532 r
= process_pidfd(e
, s
, e
->event_queue
[i
].events
);
3536 assert_not_reached("Unexpected event source type");
3542 case WAKEUP_CLOCK_DATA
: {
3543 struct clock_data
*d
= e
->event_queue
[i
].data
.ptr
;
3547 r
= flush_timer(e
, d
->fd
, e
->event_queue
[i
].events
, &d
->next
);
3551 case WAKEUP_SIGNAL_DATA
:
3552 r
= process_signal(e
, e
->event_queue
[i
].data
.ptr
, e
->event_queue
[i
].events
);
3555 case WAKEUP_INOTIFY_DATA
:
3556 r
= event_inotify_data_read(e
, e
->event_queue
[i
].data
.ptr
, e
->event_queue
[i
].events
);
3560 assert_not_reached("Invalid wake-up pointer");
3567 r
= process_watchdog(e
);
3571 r
= process_timer(e
, e
->timestamp
.realtime
, &e
->realtime
);
3575 r
= process_timer(e
, e
->timestamp
.boottime
, &e
->boottime
);
3579 r
= process_timer(e
, e
->timestamp
.monotonic
, &e
->monotonic
);
3583 r
= process_timer(e
, e
->timestamp
.realtime
, &e
->realtime_alarm
);
3587 r
= process_timer(e
, e
->timestamp
.boottime
, &e
->boottime_alarm
);
3591 if (e
->need_process_child
) {
3592 r
= process_child(e
);
3597 r
= process_inotify(e
);
3601 if (event_next_pending(e
)) {
3602 e
->state
= SD_EVENT_PENDING
;
3610 e
->state
= SD_EVENT_INITIAL
;
3615 _public_
int sd_event_dispatch(sd_event
*e
) {
3619 assert_return(e
, -EINVAL
);
3620 assert_return(e
= event_resolve(e
), -ENOPKG
);
3621 assert_return(!event_pid_changed(e
), -ECHILD
);
3622 assert_return(e
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
3623 assert_return(e
->state
== SD_EVENT_PENDING
, -EBUSY
);
3625 if (e
->exit_requested
)
3626 return dispatch_exit(e
);
3628 p
= event_next_pending(e
);
3630 _cleanup_(sd_event_unrefp
) sd_event
*ref
= NULL
;
3632 ref
= sd_event_ref(e
);
3633 e
->state
= SD_EVENT_RUNNING
;
3634 r
= source_dispatch(p
);
3635 e
->state
= SD_EVENT_INITIAL
;
3639 e
->state
= SD_EVENT_INITIAL
;
3644 static void event_log_delays(sd_event
*e
) {
3645 char b
[ELEMENTSOF(e
->delays
) * DECIMAL_STR_MAX(unsigned) + 1], *p
;
3650 for (i
= 0; i
< ELEMENTSOF(e
->delays
); i
++) {
3651 l
= strpcpyf(&p
, l
, "%u ", e
->delays
[i
]);
3654 log_debug("Event loop iterations: %s", b
);
3657 _public_
int sd_event_run(sd_event
*e
, uint64_t timeout
) {
3660 assert_return(e
, -EINVAL
);
3661 assert_return(e
= event_resolve(e
), -ENOPKG
);
3662 assert_return(!event_pid_changed(e
), -ECHILD
);
3663 assert_return(e
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
3664 assert_return(e
->state
== SD_EVENT_INITIAL
, -EBUSY
);
3666 if (e
->profile_delays
&& e
->last_run
) {
3670 this_run
= now(CLOCK_MONOTONIC
);
3672 l
= u64log2(this_run
- e
->last_run
);
3673 assert(l
< sizeof(e
->delays
));
3676 if (this_run
- e
->last_log
>= 5*USEC_PER_SEC
) {
3677 event_log_delays(e
);
3678 e
->last_log
= this_run
;
3682 r
= sd_event_prepare(e
);
3684 /* There was nothing? Then wait... */
3685 r
= sd_event_wait(e
, timeout
);
3687 if (e
->profile_delays
)
3688 e
->last_run
= now(CLOCK_MONOTONIC
);
3691 /* There's something now, then let's dispatch it */
3692 r
= sd_event_dispatch(e
);
3702 _public_
int sd_event_loop(sd_event
*e
) {
3703 _cleanup_(sd_event_unrefp
) sd_event
*ref
= NULL
;
3706 assert_return(e
, -EINVAL
);
3707 assert_return(e
= event_resolve(e
), -ENOPKG
);
3708 assert_return(!event_pid_changed(e
), -ECHILD
);
3709 assert_return(e
->state
== SD_EVENT_INITIAL
, -EBUSY
);
3711 ref
= sd_event_ref(e
);
3713 while (e
->state
!= SD_EVENT_FINISHED
) {
3714 r
= sd_event_run(e
, (uint64_t) -1);
3719 return e
->exit_code
;
3722 _public_
int sd_event_get_fd(sd_event
*e
) {
3724 assert_return(e
, -EINVAL
);
3725 assert_return(e
= event_resolve(e
), -ENOPKG
);
3726 assert_return(!event_pid_changed(e
), -ECHILD
);
3731 _public_
int sd_event_get_state(sd_event
*e
) {
3732 assert_return(e
, -EINVAL
);
3733 assert_return(e
= event_resolve(e
), -ENOPKG
);
3734 assert_return(!event_pid_changed(e
), -ECHILD
);
3739 _public_
int sd_event_get_exit_code(sd_event
*e
, int *code
) {
3740 assert_return(e
, -EINVAL
);
3741 assert_return(e
= event_resolve(e
), -ENOPKG
);
3742 assert_return(code
, -EINVAL
);
3743 assert_return(!event_pid_changed(e
), -ECHILD
);
3745 if (!e
->exit_requested
)
3748 *code
= e
->exit_code
;
3752 _public_
int sd_event_exit(sd_event
*e
, int code
) {
3753 assert_return(e
, -EINVAL
);
3754 assert_return(e
= event_resolve(e
), -ENOPKG
);
3755 assert_return(e
->state
!= SD_EVENT_FINISHED
, -ESTALE
);
3756 assert_return(!event_pid_changed(e
), -ECHILD
);
3758 e
->exit_requested
= true;
3759 e
->exit_code
= code
;
3764 _public_
int sd_event_now(sd_event
*e
, clockid_t clock
, uint64_t *usec
) {
3765 assert_return(e
, -EINVAL
);
3766 assert_return(e
= event_resolve(e
), -ENOPKG
);
3767 assert_return(usec
, -EINVAL
);
3768 assert_return(!event_pid_changed(e
), -ECHILD
);
3770 if (!TRIPLE_TIMESTAMP_HAS_CLOCK(clock
))
3773 /* Generate a clean error in case CLOCK_BOOTTIME is not available. Note that don't use clock_supported() here,
3774 * for a reason: there are systems where CLOCK_BOOTTIME is supported, but CLOCK_BOOTTIME_ALARM is not, but for
3775 * the purpose of getting the time this doesn't matter. */
3776 if (IN_SET(clock
, CLOCK_BOOTTIME
, CLOCK_BOOTTIME_ALARM
) && !clock_boottime_supported())
3779 if (!triple_timestamp_is_set(&e
->timestamp
)) {
3780 /* Implicitly fall back to now() if we never ran
3781 * before and thus have no cached time. */
3786 *usec
= triple_timestamp_by_clock(&e
->timestamp
, clock
);
3790 _public_
int sd_event_default(sd_event
**ret
) {
3795 return !!default_event
;
3797 if (default_event
) {
3798 *ret
= sd_event_ref(default_event
);
3802 r
= sd_event_new(&e
);
3806 e
->default_event_ptr
= &default_event
;
3814 _public_
int sd_event_get_tid(sd_event
*e
, pid_t
*tid
) {
3815 assert_return(e
, -EINVAL
);
3816 assert_return(e
= event_resolve(e
), -ENOPKG
);
3817 assert_return(tid
, -EINVAL
);
3818 assert_return(!event_pid_changed(e
), -ECHILD
);
3828 _public_
int sd_event_set_watchdog(sd_event
*e
, int b
) {
3831 assert_return(e
, -EINVAL
);
3832 assert_return(e
= event_resolve(e
), -ENOPKG
);
3833 assert_return(!event_pid_changed(e
), -ECHILD
);
3835 if (e
->watchdog
== !!b
)
3839 r
= sd_watchdog_enabled(false, &e
->watchdog_period
);
3843 /* Issue first ping immediately */
3844 sd_notify(false, "WATCHDOG=1");
3845 e
->watchdog_last
= now(CLOCK_MONOTONIC
);
3847 e
->watchdog_fd
= timerfd_create(CLOCK_MONOTONIC
, TFD_NONBLOCK
|TFD_CLOEXEC
);
3848 if (e
->watchdog_fd
< 0)
3851 r
= arm_watchdog(e
);
3855 struct epoll_event ev
= {
3857 .data
.ptr
= INT_TO_PTR(SOURCE_WATCHDOG
),
3860 r
= epoll_ctl(e
->epoll_fd
, EPOLL_CTL_ADD
, e
->watchdog_fd
, &ev
);
3867 if (e
->watchdog_fd
>= 0) {
3868 (void) epoll_ctl(e
->epoll_fd
, EPOLL_CTL_DEL
, e
->watchdog_fd
, NULL
);
3869 e
->watchdog_fd
= safe_close(e
->watchdog_fd
);
3877 e
->watchdog_fd
= safe_close(e
->watchdog_fd
);
3881 _public_
int sd_event_get_watchdog(sd_event
*e
) {
3882 assert_return(e
, -EINVAL
);
3883 assert_return(e
= event_resolve(e
), -ENOPKG
);
3884 assert_return(!event_pid_changed(e
), -ECHILD
);
3889 _public_
int sd_event_get_iteration(sd_event
*e
, uint64_t *ret
) {
3890 assert_return(e
, -EINVAL
);
3891 assert_return(e
= event_resolve(e
), -ENOPKG
);
3892 assert_return(!event_pid_changed(e
), -ECHILD
);
3894 *ret
= e
->iteration
;
3898 _public_
int sd_event_source_set_destroy_callback(sd_event_source
*s
, sd_event_destroy_t callback
) {
3899 assert_return(s
, -EINVAL
);
3901 s
->destroy_callback
= callback
;
3905 _public_
int sd_event_source_get_destroy_callback(sd_event_source
*s
, sd_event_destroy_t
*ret
) {
3906 assert_return(s
, -EINVAL
);
3909 *ret
= s
->destroy_callback
;
3911 return !!s
->destroy_callback
;
3914 _public_
int sd_event_source_get_floating(sd_event_source
*s
) {
3915 assert_return(s
, -EINVAL
);
3920 _public_
int sd_event_source_set_floating(sd_event_source
*s
, int b
) {
3921 assert_return(s
, -EINVAL
);
3923 if (s
->floating
== !!b
)
3926 if (!s
->event
) /* Already disconnected */
3932 sd_event_source_ref(s
);
3933 sd_event_unref(s
->event
);
3935 sd_event_ref(s
->event
);
3936 sd_event_source_unref(s
);