1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 Copyright 2013 Lennart Poettering
10 #include "alloc-util.h"
16 #include "parse-util.h"
17 #include "process-util.h"
19 #include "signal-util.h"
20 #include "stdio-util.h"
21 #include "string-util.h"
24 static int prepare_handler(sd_event_source
*s
, void *userdata
) {
25 log_info("preparing %c", PTR_TO_INT(userdata
));
29 static bool got_a
, got_b
, got_c
, got_unref
;
30 static unsigned got_d
;
32 static int unref_handler(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
33 sd_event_source_unref(s
);
38 static int io_handler(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
40 log_info("got IO on %c", PTR_TO_INT(userdata
));
42 if (userdata
== INT_TO_PTR('a')) {
43 assert_se(sd_event_source_set_enabled(s
, SD_EVENT_OFF
) >= 0);
46 } else if (userdata
== INT_TO_PTR('b')) {
49 } else if (userdata
== INT_TO_PTR('d')) {
52 assert_se(sd_event_source_set_enabled(s
, SD_EVENT_ONESHOT
) >= 0);
54 assert_se(sd_event_source_set_enabled(s
, SD_EVENT_OFF
) >= 0);
56 assert_not_reached("Yuck!");
61 static int child_handler(sd_event_source
*s
, const siginfo_t
*si
, void *userdata
) {
66 log_info("got child on %c", PTR_TO_INT(userdata
));
68 assert_se(userdata
== INT_TO_PTR('f'));
70 assert_se(sd_event_exit(sd_event_source_get_event(s
), 0) >= 0);
71 sd_event_source_unref(s
);
76 static int signal_handler(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
77 sd_event_source
*p
= NULL
;
83 log_info("got signal on %c", PTR_TO_INT(userdata
));
85 assert_se(userdata
== INT_TO_PTR('e'));
87 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGCHLD
, -1) >= 0);
95 assert_se(sd_event_add_child(sd_event_source_get_event(s
), &p
, pid
, WEXITED
, child_handler
, INT_TO_PTR('f')) >= 0);
96 assert_se(sd_event_source_set_enabled(p
, SD_EVENT_ONESHOT
) >= 0);
98 sd_event_source_unref(s
);
103 static int defer_handler(sd_event_source
*s
, void *userdata
) {
104 sd_event_source
*p
= NULL
;
108 log_info("got defer on %c", PTR_TO_INT(userdata
));
110 assert_se(userdata
== INT_TO_PTR('d'));
112 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGUSR1
, -1) >= 0);
114 assert_se(sd_event_add_signal(sd_event_source_get_event(s
), &p
, SIGUSR1
, signal_handler
, INT_TO_PTR('e')) >= 0);
115 assert_se(sd_event_source_set_enabled(p
, SD_EVENT_ONESHOT
) >= 0);
118 sd_event_source_unref(s
);
123 static bool do_quit
= false;
125 static int time_handler(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
126 log_info("got timer on %c", PTR_TO_INT(userdata
));
128 if (userdata
== INT_TO_PTR('c')) {
133 assert_se(sd_event_add_defer(sd_event_source_get_event(s
), &p
, defer_handler
, INT_TO_PTR('d')) >= 0);
134 assert_se(sd_event_source_set_enabled(p
, SD_EVENT_ONESHOT
) >= 0);
140 assert_not_reached("Huh?");
145 static bool got_exit
= false;
147 static int exit_handler(sd_event_source
*s
, void *userdata
) {
148 log_info("got quit handler on %c", PTR_TO_INT(userdata
));
155 static bool got_post
= false;
157 static int post_handler(sd_event_source
*s
, void *userdata
) {
158 log_info("got post handler");
165 static void test_basic(void) {
167 sd_event_source
*w
= NULL
, *x
= NULL
, *y
= NULL
, *z
= NULL
, *q
= NULL
, *t
= NULL
;
168 static const char ch
= 'x';
169 int a
[2] = { -1, -1 }, b
[2] = { -1, -1}, d
[2] = { -1, -1}, k
[2] = { -1, -1 };
173 assert_se(pipe(a
) >= 0);
174 assert_se(pipe(b
) >= 0);
175 assert_se(pipe(d
) >= 0);
176 assert_se(pipe(k
) >= 0);
178 assert_se(sd_event_default(&e
) >= 0);
179 assert_se(sd_event_now(e
, CLOCK_MONOTONIC
, &event_now
) > 0);
181 assert_se(sd_event_set_watchdog(e
, true) >= 0);
183 /* Test whether we cleanly can destroy an io event source from its own handler */
185 assert_se(sd_event_add_io(e
, &t
, k
[0], EPOLLIN
, unref_handler
, NULL
) >= 0);
186 assert_se(write(k
[1], &ch
, 1) == 1);
187 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
188 assert_se(got_unref
);
190 got_a
= false, got_b
= false, got_c
= false, got_d
= 0;
192 /* Add a oneshot handler, trigger it, re-enable it, and trigger
194 assert_se(sd_event_add_io(e
, &w
, d
[0], EPOLLIN
, io_handler
, INT_TO_PTR('d')) >= 0);
195 assert_se(sd_event_source_set_enabled(w
, SD_EVENT_ONESHOT
) >= 0);
196 assert_se(write(d
[1], &ch
, 1) >= 0);
197 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
198 assert_se(got_d
== 1);
199 assert_se(write(d
[1], &ch
, 1) >= 0);
200 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
201 assert_se(got_d
== 2);
203 assert_se(sd_event_add_io(e
, &x
, a
[0], EPOLLIN
, io_handler
, INT_TO_PTR('a')) >= 0);
204 assert_se(sd_event_add_io(e
, &y
, b
[0], EPOLLIN
, io_handler
, INT_TO_PTR('b')) >= 0);
205 assert_se(sd_event_add_time(e
, &z
, CLOCK_MONOTONIC
, 0, 0, time_handler
, INT_TO_PTR('c')) >= 0);
206 assert_se(sd_event_add_exit(e
, &q
, exit_handler
, INT_TO_PTR('g')) >= 0);
208 assert_se(sd_event_source_set_priority(x
, 99) >= 0);
209 assert_se(sd_event_source_get_priority(x
, &priority
) >= 0);
210 assert_se(priority
== 99);
211 assert_se(sd_event_source_set_enabled(y
, SD_EVENT_ONESHOT
) >= 0);
212 assert_se(sd_event_source_set_prepare(x
, prepare_handler
) >= 0);
213 assert_se(sd_event_source_set_priority(z
, 50) >= 0);
214 assert_se(sd_event_source_set_enabled(z
, SD_EVENT_ONESHOT
) >= 0);
215 assert_se(sd_event_source_set_prepare(z
, prepare_handler
) >= 0);
217 /* Test for floating event sources */
218 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGRTMIN
+1, -1) >= 0);
219 assert_se(sd_event_add_signal(e
, NULL
, SIGRTMIN
+1, NULL
, NULL
) >= 0);
221 assert_se(write(a
[1], &ch
, 1) >= 0);
222 assert_se(write(b
[1], &ch
, 1) >= 0);
224 assert_se(!got_a
&& !got_b
&& !got_c
);
226 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
228 assert_se(!got_a
&& got_b
&& !got_c
);
230 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
232 assert_se(!got_a
&& got_b
&& got_c
);
234 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
236 assert_se(got_a
&& got_b
&& got_c
);
238 sd_event_source_unref(x
);
239 sd_event_source_unref(y
);
242 assert_se(sd_event_add_post(e
, NULL
, post_handler
, NULL
) >= 0);
243 assert_se(sd_event_now(e
, CLOCK_MONOTONIC
, &event_now
) == 0);
244 assert_se(sd_event_source_set_time(z
, event_now
+ 200 * USEC_PER_MSEC
) >= 0);
245 assert_se(sd_event_source_set_enabled(z
, SD_EVENT_ONESHOT
) >= 0);
247 assert_se(sd_event_loop(e
) >= 0);
251 sd_event_source_unref(z
);
252 sd_event_source_unref(q
);
254 sd_event_source_unref(w
);
264 static void test_sd_event_now(void) {
265 _cleanup_(sd_event_unrefp
) sd_event
*e
= NULL
;
268 assert_se(sd_event_new(&e
) >= 0);
269 assert_se(sd_event_now(e
, CLOCK_MONOTONIC
, &event_now
) > 0);
270 assert_se(sd_event_now(e
, CLOCK_REALTIME
, &event_now
) > 0);
271 assert_se(sd_event_now(e
, CLOCK_REALTIME_ALARM
, &event_now
) > 0);
272 if (clock_boottime_supported()) {
273 assert_se(sd_event_now(e
, CLOCK_BOOTTIME
, &event_now
) > 0);
274 assert_se(sd_event_now(e
, CLOCK_BOOTTIME_ALARM
, &event_now
) > 0);
276 assert_se(sd_event_now(e
, -1, &event_now
) == -EOPNOTSUPP
);
277 assert_se(sd_event_now(e
, 900 /* arbitrary big number */, &event_now
) == -EOPNOTSUPP
);
279 assert_se(sd_event_run(e
, 0) == 0);
281 assert_se(sd_event_now(e
, CLOCK_MONOTONIC
, &event_now
) == 0);
282 assert_se(sd_event_now(e
, CLOCK_REALTIME
, &event_now
) == 0);
283 assert_se(sd_event_now(e
, CLOCK_REALTIME_ALARM
, &event_now
) == 0);
284 if (clock_boottime_supported()) {
285 assert_se(sd_event_now(e
, CLOCK_BOOTTIME
, &event_now
) == 0);
286 assert_se(sd_event_now(e
, CLOCK_BOOTTIME_ALARM
, &event_now
) == 0);
288 assert_se(sd_event_now(e
, -1, &event_now
) == -EOPNOTSUPP
);
289 assert_se(sd_event_now(e
, 900 /* arbitrary big number */, &event_now
) == -EOPNOTSUPP
);
292 static int last_rtqueue_sigval
= 0;
293 static int n_rtqueue
= 0;
295 static int rtqueue_handler(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
296 last_rtqueue_sigval
= si
->ssi_int
;
301 static void test_rtqueue(void) {
302 sd_event_source
*u
= NULL
, *v
= NULL
, *s
= NULL
;
305 assert_se(sd_event_default(&e
) >= 0);
307 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGRTMIN
+2, SIGRTMIN
+3, SIGUSR2
, -1) >= 0);
308 assert_se(sd_event_add_signal(e
, &u
, SIGRTMIN
+2, rtqueue_handler
, NULL
) >= 0);
309 assert_se(sd_event_add_signal(e
, &v
, SIGRTMIN
+3, rtqueue_handler
, NULL
) >= 0);
310 assert_se(sd_event_add_signal(e
, &s
, SIGUSR2
, rtqueue_handler
, NULL
) >= 0);
312 assert_se(sd_event_source_set_priority(v
, -10) >= 0);
314 assert_se(sigqueue(getpid_cached(), SIGRTMIN
+2, (union sigval
) { .sival_int
= 1 }) >= 0);
315 assert_se(sigqueue(getpid_cached(), SIGRTMIN
+3, (union sigval
) { .sival_int
= 2 }) >= 0);
316 assert_se(sigqueue(getpid_cached(), SIGUSR2
, (union sigval
) { .sival_int
= 3 }) >= 0);
317 assert_se(sigqueue(getpid_cached(), SIGRTMIN
+3, (union sigval
) { .sival_int
= 4 }) >= 0);
318 assert_se(sigqueue(getpid_cached(), SIGUSR2
, (union sigval
) { .sival_int
= 5 }) >= 0);
320 assert_se(n_rtqueue
== 0);
321 assert_se(last_rtqueue_sigval
== 0);
323 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
324 assert_se(n_rtqueue
== 1);
325 assert_se(last_rtqueue_sigval
== 2); /* first SIGRTMIN+3 */
327 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
328 assert_se(n_rtqueue
== 2);
329 assert_se(last_rtqueue_sigval
== 4); /* second SIGRTMIN+3 */
331 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
332 assert_se(n_rtqueue
== 3);
333 assert_se(last_rtqueue_sigval
== 3); /* first SIGUSR2 */
335 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
336 assert_se(n_rtqueue
== 4);
337 assert_se(last_rtqueue_sigval
== 1); /* SIGRTMIN+2 */
339 assert_se(sd_event_run(e
, 0) == 0); /* the other SIGUSR2 is dropped, because the first one was still queued */
340 assert_se(n_rtqueue
== 4);
341 assert_se(last_rtqueue_sigval
== 1);
343 sd_event_source_unref(u
);
344 sd_event_source_unref(v
);
345 sd_event_source_unref(s
);
350 #define CREATE_EVENTS_MAX (70000U)
352 struct inotify_context
{
353 bool delete_self_handler_called
;
354 unsigned create_called
[CREATE_EVENTS_MAX
];
355 unsigned create_overflow
;
356 unsigned n_create_events
;
359 static void maybe_exit(sd_event_source
*s
, struct inotify_context
*c
) {
365 if (!c
->delete_self_handler_called
)
368 for (n
= 0; n
< 3; n
++) {
371 if (c
->create_overflow
& (1U << n
))
374 for (i
= 0; i
< c
->n_create_events
; i
++)
375 if (!(c
->create_called
[i
] & (1U << n
)))
379 sd_event_exit(sd_event_source_get_event(s
), 0);
382 static int inotify_handler(sd_event_source
*s
, const struct inotify_event
*ev
, void *userdata
) {
383 struct inotify_context
*c
= userdata
;
384 const char *description
;
387 assert_se(sd_event_source_get_description(s
, &description
) >= 0);
388 assert_se(safe_atou(description
, &n
) >= 0);
393 if (ev
->mask
& IN_Q_OVERFLOW
) {
394 log_info("inotify-handler <%s>: overflow", description
);
395 c
->create_overflow
|= bit
;
396 } else if (ev
->mask
& IN_CREATE
) {
399 log_info("inotify-handler <%s>: create on %s", description
, ev
->name
);
401 if (!streq(ev
->name
, "sub")) {
402 assert_se(safe_atou(ev
->name
, &i
) >= 0);
404 assert_se(i
< c
->n_create_events
);
405 c
->create_called
[i
] |= bit
;
407 } else if (ev
->mask
& IN_DELETE
) {
408 log_info("inotify-handler <%s>: delete of %s", description
, ev
->name
);
409 assert_se(streq(ev
->name
, "sub"));
411 assert_not_reached("unexpected inotify event");
417 static int delete_self_handler(sd_event_source
*s
, const struct inotify_event
*ev
, void *userdata
) {
418 struct inotify_context
*c
= userdata
;
420 if (ev
->mask
& IN_Q_OVERFLOW
) {
421 log_info("delete-self-handler: overflow");
422 c
->delete_self_handler_called
= true;
423 } else if (ev
->mask
& IN_DELETE_SELF
) {
424 log_info("delete-self-handler: delete-self");
425 c
->delete_self_handler_called
= true;
426 } else if (ev
->mask
& IN_IGNORED
) {
427 log_info("delete-self-handler: ignore");
429 assert_not_reached("unexpected inotify event (delete-self)");
435 static void test_inotify(unsigned n_create_events
) {
436 _cleanup_(rm_rf_physical_and_freep
) char *p
= NULL
;
437 sd_event_source
*a
= NULL
, *b
= NULL
, *c
= NULL
, *d
= NULL
;
438 struct inotify_context context
= {
439 .n_create_events
= n_create_events
,
445 assert_se(sd_event_default(&e
) >= 0);
447 assert_se(mkdtemp_malloc("/tmp/test-inotify-XXXXXX", &p
) >= 0);
449 assert_se(sd_event_add_inotify(e
, &a
, p
, IN_CREATE
|IN_ONLYDIR
, inotify_handler
, &context
) >= 0);
450 assert_se(sd_event_add_inotify(e
, &b
, p
, IN_CREATE
|IN_DELETE
|IN_DONT_FOLLOW
, inotify_handler
, &context
) >= 0);
451 assert_se(sd_event_source_set_priority(b
, SD_EVENT_PRIORITY_IDLE
) >= 0);
452 assert_se(sd_event_source_set_priority(b
, SD_EVENT_PRIORITY_NORMAL
) >= 0);
453 assert_se(sd_event_add_inotify(e
, &c
, p
, IN_CREATE
|IN_DELETE
|IN_EXCL_UNLINK
, inotify_handler
, &context
) >= 0);
454 assert_se(sd_event_source_set_priority(c
, SD_EVENT_PRIORITY_IDLE
) >= 0);
456 assert_se(sd_event_source_set_description(a
, "0") >= 0);
457 assert_se(sd_event_source_set_description(b
, "1") >= 0);
458 assert_se(sd_event_source_set_description(c
, "2") >= 0);
460 q
= strjoina(p
, "/sub");
461 assert_se(touch(q
) >= 0);
462 assert_se(sd_event_add_inotify(e
, &d
, q
, IN_DELETE_SELF
, delete_self_handler
, &context
) >= 0);
464 for (i
= 0; i
< n_create_events
; i
++) {
465 char buf
[DECIMAL_STR_MAX(unsigned)+1];
466 _cleanup_free_
char *z
;
468 xsprintf(buf
, "%u", i
);
469 assert_se(z
= strjoin(p
, "/", buf
));
471 assert_se(touch(z
) >= 0);
474 assert_se(unlink(q
) >= 0);
476 assert_se(sd_event_loop(e
) >= 0);
478 sd_event_source_unref(a
);
479 sd_event_source_unref(b
);
480 sd_event_source_unref(c
);
481 sd_event_source_unref(d
);
486 int main(int argc
, char *argv
[]) {
488 log_set_max_level(LOG_DEBUG
);
489 log_parse_environment();
495 test_inotify(100); /* should work without overflow */
496 test_inotify(33000); /* should trigger a q overflow */