1 /* SPDX-License-Identifier: LGPL-2.1+ */
7 #include "alloc-util.h"
13 #include "parse-util.h"
14 #include "process-util.h"
16 #include "signal-util.h"
17 #include "stdio-util.h"
18 #include "string-util.h"
22 static int prepare_handler(sd_event_source
*s
, void *userdata
) {
23 log_info("preparing %c", PTR_TO_INT(userdata
));
27 static bool got_a
, got_b
, got_c
, got_unref
;
28 static unsigned got_d
;
30 static int unref_handler(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
31 sd_event_source_unref(s
);
36 static int io_handler(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
38 log_info("got IO on %c", PTR_TO_INT(userdata
));
40 if (userdata
== INT_TO_PTR('a')) {
41 assert_se(sd_event_source_set_enabled(s
, SD_EVENT_OFF
) >= 0);
44 } else if (userdata
== INT_TO_PTR('b')) {
47 } else if (userdata
== INT_TO_PTR('d')) {
50 assert_se(sd_event_source_set_enabled(s
, SD_EVENT_ONESHOT
) >= 0);
52 assert_se(sd_event_source_set_enabled(s
, SD_EVENT_OFF
) >= 0);
54 assert_not_reached("Yuck!");
59 static int child_handler(sd_event_source
*s
, const siginfo_t
*si
, void *userdata
) {
64 log_info("got child on %c", PTR_TO_INT(userdata
));
66 assert_se(userdata
== INT_TO_PTR('f'));
68 assert_se(sd_event_exit(sd_event_source_get_event(s
), 0) >= 0);
69 sd_event_source_unref(s
);
74 static int signal_handler(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
75 sd_event_source
*p
= NULL
;
81 log_info("got signal on %c", PTR_TO_INT(userdata
));
83 assert_se(userdata
== INT_TO_PTR('e'));
85 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGCHLD
, -1) >= 0);
93 assert_se(sd_event_add_child(sd_event_source_get_event(s
), &p
, pid
, WEXITED
, child_handler
, INT_TO_PTR('f')) >= 0);
94 assert_se(sd_event_source_set_enabled(p
, SD_EVENT_ONESHOT
) >= 0);
96 sd_event_source_unref(s
);
101 static int defer_handler(sd_event_source
*s
, void *userdata
) {
102 sd_event_source
*p
= NULL
;
106 log_info("got defer on %c", PTR_TO_INT(userdata
));
108 assert_se(userdata
== INT_TO_PTR('d'));
110 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGUSR1
, -1) >= 0);
112 assert_se(sd_event_add_signal(sd_event_source_get_event(s
), &p
, SIGUSR1
, signal_handler
, INT_TO_PTR('e')) >= 0);
113 assert_se(sd_event_source_set_enabled(p
, SD_EVENT_ONESHOT
) >= 0);
116 sd_event_source_unref(s
);
121 static bool do_quit
= false;
123 static int time_handler(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
124 log_info("got timer on %c", PTR_TO_INT(userdata
));
126 if (userdata
== INT_TO_PTR('c')) {
131 assert_se(sd_event_add_defer(sd_event_source_get_event(s
), &p
, defer_handler
, INT_TO_PTR('d')) >= 0);
132 assert_se(sd_event_source_set_enabled(p
, SD_EVENT_ONESHOT
) >= 0);
138 assert_not_reached("Huh?");
143 static bool got_exit
= false;
145 static int exit_handler(sd_event_source
*s
, void *userdata
) {
146 log_info("got quit handler on %c", PTR_TO_INT(userdata
));
153 static bool got_post
= false;
155 static int post_handler(sd_event_source
*s
, void *userdata
) {
156 log_info("got post handler");
163 static void test_basic(void) {
165 sd_event_source
*w
= NULL
, *x
= NULL
, *y
= NULL
, *z
= NULL
, *q
= NULL
, *t
= NULL
;
166 static const char ch
= 'x';
167 int a
[2] = { -1, -1 }, b
[2] = { -1, -1}, d
[2] = { -1, -1}, k
[2] = { -1, -1 };
171 assert_se(pipe(a
) >= 0);
172 assert_se(pipe(b
) >= 0);
173 assert_se(pipe(d
) >= 0);
174 assert_se(pipe(k
) >= 0);
176 assert_se(sd_event_default(&e
) >= 0);
177 assert_se(sd_event_now(e
, CLOCK_MONOTONIC
, &event_now
) > 0);
179 assert_se(sd_event_set_watchdog(e
, true) >= 0);
181 /* Test whether we cleanly can destroy an io event source from its own handler */
183 assert_se(sd_event_add_io(e
, &t
, k
[0], EPOLLIN
, unref_handler
, NULL
) >= 0);
184 assert_se(write(k
[1], &ch
, 1) == 1);
185 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
186 assert_se(got_unref
);
188 got_a
= false, got_b
= false, got_c
= false, got_d
= 0;
190 /* Add a oneshot handler, trigger it, reenable it, and trigger
192 assert_se(sd_event_add_io(e
, &w
, d
[0], EPOLLIN
, io_handler
, INT_TO_PTR('d')) >= 0);
193 assert_se(sd_event_source_set_enabled(w
, SD_EVENT_ONESHOT
) >= 0);
194 assert_se(write(d
[1], &ch
, 1) >= 0);
195 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
196 assert_se(got_d
== 1);
197 assert_se(write(d
[1], &ch
, 1) >= 0);
198 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
199 assert_se(got_d
== 2);
201 assert_se(sd_event_add_io(e
, &x
, a
[0], EPOLLIN
, io_handler
, INT_TO_PTR('a')) >= 0);
202 assert_se(sd_event_add_io(e
, &y
, b
[0], EPOLLIN
, io_handler
, INT_TO_PTR('b')) >= 0);
203 assert_se(sd_event_add_time(e
, &z
, CLOCK_MONOTONIC
, 0, 0, time_handler
, INT_TO_PTR('c')) >= 0);
204 assert_se(sd_event_add_exit(e
, &q
, exit_handler
, INT_TO_PTR('g')) >= 0);
206 assert_se(sd_event_source_set_priority(x
, 99) >= 0);
207 assert_se(sd_event_source_get_priority(x
, &priority
) >= 0);
208 assert_se(priority
== 99);
209 assert_se(sd_event_source_set_enabled(y
, SD_EVENT_ONESHOT
) >= 0);
210 assert_se(sd_event_source_set_prepare(x
, prepare_handler
) >= 0);
211 assert_se(sd_event_source_set_priority(z
, 50) >= 0);
212 assert_se(sd_event_source_set_enabled(z
, SD_EVENT_ONESHOT
) >= 0);
213 assert_se(sd_event_source_set_prepare(z
, prepare_handler
) >= 0);
215 /* Test for floating event sources */
216 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGRTMIN
+1, -1) >= 0);
217 assert_se(sd_event_add_signal(e
, NULL
, SIGRTMIN
+1, NULL
, NULL
) >= 0);
219 assert_se(write(a
[1], &ch
, 1) >= 0);
220 assert_se(write(b
[1], &ch
, 1) >= 0);
222 assert_se(!got_a
&& !got_b
&& !got_c
);
224 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
226 assert_se(!got_a
&& got_b
&& !got_c
);
228 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
230 assert_se(!got_a
&& got_b
&& got_c
);
232 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
234 assert_se(got_a
&& got_b
&& got_c
);
236 sd_event_source_unref(x
);
237 sd_event_source_unref(y
);
240 assert_se(sd_event_add_post(e
, NULL
, post_handler
, NULL
) >= 0);
241 assert_se(sd_event_now(e
, CLOCK_MONOTONIC
, &event_now
) == 0);
242 assert_se(sd_event_source_set_time(z
, event_now
+ 200 * USEC_PER_MSEC
) >= 0);
243 assert_se(sd_event_source_set_enabled(z
, SD_EVENT_ONESHOT
) >= 0);
245 assert_se(sd_event_loop(e
) >= 0);
249 sd_event_source_unref(z
);
250 sd_event_source_unref(q
);
252 sd_event_source_unref(w
);
262 static void test_sd_event_now(void) {
263 _cleanup_(sd_event_unrefp
) sd_event
*e
= NULL
;
266 assert_se(sd_event_new(&e
) >= 0);
267 assert_se(sd_event_now(e
, CLOCK_MONOTONIC
, &event_now
) > 0);
268 assert_se(sd_event_now(e
, CLOCK_REALTIME
, &event_now
) > 0);
269 assert_se(sd_event_now(e
, CLOCK_REALTIME_ALARM
, &event_now
) > 0);
270 if (clock_boottime_supported()) {
271 assert_se(sd_event_now(e
, CLOCK_BOOTTIME
, &event_now
) > 0);
272 assert_se(sd_event_now(e
, CLOCK_BOOTTIME_ALARM
, &event_now
) > 0);
274 assert_se(sd_event_now(e
, -1, &event_now
) == -EOPNOTSUPP
);
275 assert_se(sd_event_now(e
, 900 /* arbitrary big number */, &event_now
) == -EOPNOTSUPP
);
277 assert_se(sd_event_run(e
, 0) == 0);
279 assert_se(sd_event_now(e
, CLOCK_MONOTONIC
, &event_now
) == 0);
280 assert_se(sd_event_now(e
, CLOCK_REALTIME
, &event_now
) == 0);
281 assert_se(sd_event_now(e
, CLOCK_REALTIME_ALARM
, &event_now
) == 0);
282 if (clock_boottime_supported()) {
283 assert_se(sd_event_now(e
, CLOCK_BOOTTIME
, &event_now
) == 0);
284 assert_se(sd_event_now(e
, CLOCK_BOOTTIME_ALARM
, &event_now
) == 0);
286 assert_se(sd_event_now(e
, -1, &event_now
) == -EOPNOTSUPP
);
287 assert_se(sd_event_now(e
, 900 /* arbitrary big number */, &event_now
) == -EOPNOTSUPP
);
290 static int last_rtqueue_sigval
= 0;
291 static int n_rtqueue
= 0;
293 static int rtqueue_handler(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
294 last_rtqueue_sigval
= si
->ssi_int
;
299 static void test_rtqueue(void) {
300 sd_event_source
*u
= NULL
, *v
= NULL
, *s
= NULL
;
303 assert_se(sd_event_default(&e
) >= 0);
305 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGRTMIN
+2, SIGRTMIN
+3, SIGUSR2
, -1) >= 0);
306 assert_se(sd_event_add_signal(e
, &u
, SIGRTMIN
+2, rtqueue_handler
, NULL
) >= 0);
307 assert_se(sd_event_add_signal(e
, &v
, SIGRTMIN
+3, rtqueue_handler
, NULL
) >= 0);
308 assert_se(sd_event_add_signal(e
, &s
, SIGUSR2
, rtqueue_handler
, NULL
) >= 0);
310 assert_se(sd_event_source_set_priority(v
, -10) >= 0);
312 assert_se(sigqueue(getpid_cached(), SIGRTMIN
+2, (union sigval
) { .sival_int
= 1 }) >= 0);
313 assert_se(sigqueue(getpid_cached(), SIGRTMIN
+3, (union sigval
) { .sival_int
= 2 }) >= 0);
314 assert_se(sigqueue(getpid_cached(), SIGUSR2
, (union sigval
) { .sival_int
= 3 }) >= 0);
315 assert_se(sigqueue(getpid_cached(), SIGRTMIN
+3, (union sigval
) { .sival_int
= 4 }) >= 0);
316 assert_se(sigqueue(getpid_cached(), SIGUSR2
, (union sigval
) { .sival_int
= 5 }) >= 0);
318 assert_se(n_rtqueue
== 0);
319 assert_se(last_rtqueue_sigval
== 0);
321 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
322 assert_se(n_rtqueue
== 1);
323 assert_se(last_rtqueue_sigval
== 2); /* first SIGRTMIN+3 */
325 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
326 assert_se(n_rtqueue
== 2);
327 assert_se(last_rtqueue_sigval
== 4); /* second SIGRTMIN+3 */
329 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
330 assert_se(n_rtqueue
== 3);
331 assert_se(last_rtqueue_sigval
== 3); /* first SIGUSR2 */
333 assert_se(sd_event_run(e
, (uint64_t) -1) >= 1);
334 assert_se(n_rtqueue
== 4);
335 assert_se(last_rtqueue_sigval
== 1); /* SIGRTMIN+2 */
337 assert_se(sd_event_run(e
, 0) == 0); /* the other SIGUSR2 is dropped, because the first one was still queued */
338 assert_se(n_rtqueue
== 4);
339 assert_se(last_rtqueue_sigval
== 1);
341 sd_event_source_unref(u
);
342 sd_event_source_unref(v
);
343 sd_event_source_unref(s
);
348 #define CREATE_EVENTS_MAX (70000U)
350 struct inotify_context
{
351 bool delete_self_handler_called
;
352 unsigned create_called
[CREATE_EVENTS_MAX
];
353 unsigned create_overflow
;
354 unsigned n_create_events
;
357 static void maybe_exit(sd_event_source
*s
, struct inotify_context
*c
) {
363 if (!c
->delete_self_handler_called
)
366 for (n
= 0; n
< 3; n
++) {
369 if (c
->create_overflow
& (1U << n
))
372 for (i
= 0; i
< c
->n_create_events
; i
++)
373 if (!(c
->create_called
[i
] & (1U << n
)))
377 sd_event_exit(sd_event_source_get_event(s
), 0);
380 static int inotify_handler(sd_event_source
*s
, const struct inotify_event
*ev
, void *userdata
) {
381 struct inotify_context
*c
= userdata
;
382 const char *description
;
385 assert_se(sd_event_source_get_description(s
, &description
) >= 0);
386 assert_se(safe_atou(description
, &n
) >= 0);
391 if (ev
->mask
& IN_Q_OVERFLOW
) {
392 log_info("inotify-handler <%s>: overflow", description
);
393 c
->create_overflow
|= bit
;
394 } else if (ev
->mask
& IN_CREATE
) {
397 log_info("inotify-handler <%s>: create on %s", description
, ev
->name
);
399 if (!streq(ev
->name
, "sub")) {
400 assert_se(safe_atou(ev
->name
, &i
) >= 0);
402 assert_se(i
< c
->n_create_events
);
403 c
->create_called
[i
] |= bit
;
405 } else if (ev
->mask
& IN_DELETE
) {
406 log_info("inotify-handler <%s>: delete of %s", description
, ev
->name
);
407 assert_se(streq(ev
->name
, "sub"));
409 assert_not_reached("unexpected inotify event");
415 static int delete_self_handler(sd_event_source
*s
, const struct inotify_event
*ev
, void *userdata
) {
416 struct inotify_context
*c
= userdata
;
418 if (ev
->mask
& IN_Q_OVERFLOW
) {
419 log_info("delete-self-handler: overflow");
420 c
->delete_self_handler_called
= true;
421 } else if (ev
->mask
& IN_DELETE_SELF
) {
422 log_info("delete-self-handler: delete-self");
423 c
->delete_self_handler_called
= true;
424 } else if (ev
->mask
& IN_IGNORED
) {
425 log_info("delete-self-handler: ignore");
427 assert_not_reached("unexpected inotify event (delete-self)");
433 static void test_inotify(unsigned n_create_events
) {
434 _cleanup_(rm_rf_physical_and_freep
) char *p
= NULL
;
435 sd_event_source
*a
= NULL
, *b
= NULL
, *c
= NULL
, *d
= NULL
;
436 struct inotify_context context
= {
437 .n_create_events
= n_create_events
,
443 assert_se(sd_event_default(&e
) >= 0);
445 assert_se(mkdtemp_malloc("/tmp/test-inotify-XXXXXX", &p
) >= 0);
447 assert_se(sd_event_add_inotify(e
, &a
, p
, IN_CREATE
|IN_ONLYDIR
, inotify_handler
, &context
) >= 0);
448 assert_se(sd_event_add_inotify(e
, &b
, p
, IN_CREATE
|IN_DELETE
|IN_DONT_FOLLOW
, inotify_handler
, &context
) >= 0);
449 assert_se(sd_event_source_set_priority(b
, SD_EVENT_PRIORITY_IDLE
) >= 0);
450 assert_se(sd_event_source_set_priority(b
, SD_EVENT_PRIORITY_NORMAL
) >= 0);
451 assert_se(sd_event_add_inotify(e
, &c
, p
, IN_CREATE
|IN_DELETE
|IN_EXCL_UNLINK
, inotify_handler
, &context
) >= 0);
452 assert_se(sd_event_source_set_priority(c
, SD_EVENT_PRIORITY_IDLE
) >= 0);
454 assert_se(sd_event_source_set_description(a
, "0") >= 0);
455 assert_se(sd_event_source_set_description(b
, "1") >= 0);
456 assert_se(sd_event_source_set_description(c
, "2") >= 0);
458 q
= strjoina(p
, "/sub");
459 assert_se(touch(q
) >= 0);
460 assert_se(sd_event_add_inotify(e
, &d
, q
, IN_DELETE_SELF
, delete_self_handler
, &context
) >= 0);
462 for (i
= 0; i
< n_create_events
; i
++) {
463 char buf
[DECIMAL_STR_MAX(unsigned)+1];
464 _cleanup_free_
char *z
;
466 xsprintf(buf
, "%u", i
);
467 assert_se(z
= strjoin(p
, "/", buf
));
469 assert_se(touch(z
) >= 0);
472 assert_se(unlink(q
) >= 0);
474 assert_se(sd_event_loop(e
) >= 0);
476 sd_event_source_unref(a
);
477 sd_event_source_unref(b
);
478 sd_event_source_unref(c
);
479 sd_event_source_unref(d
);
484 int main(int argc
, char *argv
[]) {
485 test_setup_logging(LOG_DEBUG
);
491 test_inotify(100); /* should work without overflow */
492 test_inotify(33000); /* should trigger a q overflow */