1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
8 #include "alloc-util.h"
12 #include "parse-util.h"
13 #include "path-util.h"
14 #include "pidfd-util.h"
15 #include "process-util.h"
16 #include "random-util.h"
18 #include "signal-util.h"
19 #include "stdio-util.h"
20 #include "string-util.h"
22 #include "time-util.h"
23 #include "tmpfile-util.h"
25 static int prepare_handler(sd_event_source
*s
, void *userdata
) {
26 log_info("preparing %c", PTR_TO_INT(userdata
));
30 static bool got_a
, got_b
, got_c
, got_unref
;
31 static unsigned got_d
;
33 static int unref_handler(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
34 sd_event_source_unref(s
);
39 static int io_handler(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
41 log_info("got IO on %c", PTR_TO_INT(userdata
));
43 if (userdata
== INT_TO_PTR('a')) {
44 assert_se(sd_event_source_set_enabled(s
, SD_EVENT_OFF
) >= 0);
47 } else if (userdata
== INT_TO_PTR('b')) {
50 } else if (userdata
== INT_TO_PTR('d')) {
53 assert_se(sd_event_source_set_enabled(s
, SD_EVENT_ONESHOT
) >= 0);
55 assert_se(sd_event_source_set_enabled(s
, SD_EVENT_OFF
) >= 0);
62 static int child_handler(sd_event_source
*s
, const siginfo_t
*si
, void *userdata
) {
67 assert_se(si
->si_uid
== getuid());
68 assert_se(si
->si_signo
== SIGCHLD
);
69 assert_se(si
->si_code
== CLD_EXITED
);
70 assert_se(si
->si_status
== 78);
72 log_info("got child on %c", PTR_TO_INT(userdata
));
74 assert_se(userdata
== INT_TO_PTR('f'));
76 assert_se(sd_event_exit(sd_event_source_get_event(s
), 0) >= 0);
77 sd_event_source_unref(s
);
82 static int signal_handler(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
83 sd_event_source
*p
= NULL
;
90 log_info("got signal on %c", PTR_TO_INT(userdata
));
92 assert_se(userdata
== INT_TO_PTR('e'));
94 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGCHLD
, SIGUSR2
) >= 0);
102 assert_se(sigemptyset(&ss
) >= 0);
103 assert_se(sigaddset(&ss
, SIGUSR2
) >= 0);
106 assert_se(sigwaitinfo(&ss
, &plain_si
) >= 0);
108 assert_se(plain_si
.si_signo
== SIGUSR2
);
109 assert_se(plain_si
.si_value
.sival_int
== 4711);
114 assert_se(sd_event_add_child(sd_event_source_get_event(s
), &p
, pid
, WEXITED
, child_handler
, INT_TO_PTR('f')) >= 0);
115 assert_se(sd_event_source_set_enabled(p
, SD_EVENT_ONESHOT
) >= 0);
116 assert_se(sd_event_source_set_child_process_own(p
, true) >= 0);
118 /* We can't use structured initialization here, since the structure contains various unions and these
119 * fields lie in overlapping (carefully aligned) unions that LLVM is allergic to allow assignments
122 plain_si
.si_signo
= SIGUSR2
;
123 plain_si
.si_code
= SI_QUEUE
;
124 plain_si
.si_pid
= getpid_cached();
125 plain_si
.si_uid
= getuid();
126 plain_si
.si_value
.sival_int
= 4711;
128 assert_se(sd_event_source_send_child_signal(p
, SIGUSR2
, &plain_si
, 0) >= 0);
130 sd_event_source_unref(s
);
135 static int defer_handler(sd_event_source
*s
, void *userdata
) {
136 sd_event_source
*p
= NULL
;
140 log_info("got defer on %c", PTR_TO_INT(userdata
));
142 assert_se(userdata
== INT_TO_PTR('d'));
144 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGUSR1
) >= 0);
146 assert_se(sd_event_add_signal(sd_event_source_get_event(s
), &p
, SIGUSR1
, signal_handler
, INT_TO_PTR('e')) >= 0);
147 assert_se(sd_event_source_set_enabled(p
, SD_EVENT_ONESHOT
) >= 0);
150 sd_event_source_unref(s
);
157 static int time_handler(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
158 log_info("got timer on %c", PTR_TO_INT(userdata
));
160 if (userdata
== INT_TO_PTR('c')) {
165 assert_se(sd_event_add_defer(sd_event_source_get_event(s
), &p
, defer_handler
, INT_TO_PTR('d')) >= 0);
166 assert_se(sd_event_source_set_enabled(p
, SD_EVENT_ONESHOT
) >= 0);
172 assert_not_reached();
177 static bool got_exit
= false;
179 static int exit_handler(sd_event_source
*s
, void *userdata
) {
180 log_info("got quit handler on %c", PTR_TO_INT(userdata
));
187 static bool got_post
= false;
189 static int post_handler(sd_event_source
*s
, void *userdata
) {
190 log_info("got post handler");
199 sd_event_source
*w
= NULL
, *x
= NULL
, *y
= NULL
, *z
= NULL
, *q
= NULL
, *t
= NULL
;
200 static const char ch
= 'x';
201 int a
[2] = EBADF_PAIR
, b
[2] = EBADF_PAIR
,
202 d
[2] = EBADF_PAIR
, k
[2] = EBADF_PAIR
;
206 assert_se(pipe(a
) >= 0);
207 assert_se(pipe(b
) >= 0);
208 assert_se(pipe(d
) >= 0);
209 assert_se(pipe(k
) >= 0);
211 assert_se(sd_event_default(&e
) >= 0);
212 assert_se(sd_event_now(e
, CLOCK_MONOTONIC
, &event_now
) > 0);
214 assert_se(sd_event_set_watchdog(e
, true) >= 0);
216 /* Test whether we cleanly can destroy an io event source from its own handler */
218 assert_se(sd_event_add_io(e
, &t
, k
[0], EPOLLIN
, unref_handler
, NULL
) >= 0);
219 assert_se(write(k
[1], &ch
, 1) == 1);
220 assert_se(sd_event_run(e
, UINT64_MAX
) >= 1);
221 assert_se(got_unref
);
223 got_a
= false, got_b
= false, got_c
= false, got_d
= 0;
225 /* Add a oneshot handler, trigger it, reenable it, and trigger it again. */
226 assert_se(sd_event_add_io(e
, &w
, d
[0], EPOLLIN
, io_handler
, INT_TO_PTR('d')) >= 0);
227 assert_se(sd_event_source_set_enabled(w
, SD_EVENT_ONESHOT
) >= 0);
228 assert_se(write(d
[1], &ch
, 1) >= 0);
229 assert_se(sd_event_run(e
, UINT64_MAX
) >= 1);
230 assert_se(got_d
== 1);
231 assert_se(write(d
[1], &ch
, 1) >= 0);
232 assert_se(sd_event_run(e
, UINT64_MAX
) >= 1);
233 assert_se(got_d
== 2);
235 assert_se(sd_event_add_io(e
, &x
, a
[0], EPOLLIN
, io_handler
, INT_TO_PTR('a')) >= 0);
236 assert_se(sd_event_add_io(e
, &y
, b
[0], EPOLLIN
, io_handler
, INT_TO_PTR('b')) >= 0);
239 assert_se(sd_event_add_time(e
, &z
, CLOCK_MONOTONIC
, 0, 0, time_handler
, INT_TO_PTR('c')) >= 0);
240 assert_se(sd_event_add_exit(e
, &q
, exit_handler
, INT_TO_PTR('g')) >= 0);
242 assert_se(sd_event_source_set_priority(x
, 99) >= 0);
243 assert_se(sd_event_source_get_priority(x
, &priority
) >= 0);
244 assert_se(priority
== 99);
245 assert_se(sd_event_source_set_enabled(y
, SD_EVENT_ONESHOT
) >= 0);
246 assert_se(sd_event_source_set_prepare(x
, prepare_handler
) >= 0);
247 assert_se(sd_event_source_set_priority(z
, 50) >= 0);
248 assert_se(sd_event_source_set_enabled(z
, SD_EVENT_ONESHOT
) >= 0);
249 assert_se(sd_event_source_set_prepare(z
, prepare_handler
) >= 0);
251 /* Test for floating event sources */
252 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGRTMIN
+1) >= 0);
253 assert_se(sd_event_add_signal(e
, NULL
, SIGRTMIN
+1, NULL
, NULL
) >= 0);
255 assert_se(write(a
[1], &ch
, 1) >= 0);
256 assert_se(write(b
[1], &ch
, 1) >= 0);
258 assert_se(!got_a
&& !got_b
&& !got_c
);
260 assert_se(sd_event_run(e
, UINT64_MAX
) >= 1);
262 assert_se(!got_a
&& got_b
&& !got_c
);
264 assert_se(sd_event_run(e
, UINT64_MAX
) >= 1);
266 assert_se(!got_a
&& got_b
&& got_c
);
268 assert_se(sd_event_run(e
, UINT64_MAX
) >= 1);
270 assert_se(got_a
&& got_b
&& got_c
);
272 sd_event_source_unref(x
);
273 sd_event_source_unref(y
);
276 assert_se(sd_event_add_post(e
, NULL
, post_handler
, NULL
) >= 0);
277 assert_se(sd_event_now(e
, CLOCK_MONOTONIC
, &event_now
) == 0);
278 assert_se(sd_event_source_set_time(z
, event_now
+ 200 * USEC_PER_MSEC
) >= 0);
279 assert_se(sd_event_source_set_enabled(z
, SD_EVENT_ONESHOT
) >= 0);
281 assert_se(sd_event_loop(e
) >= 0);
285 sd_event_source_unref(z
);
286 sd_event_source_unref(q
);
288 sd_event_source_unref(w
);
299 _cleanup_(sd_event_unrefp
) sd_event
*e
= NULL
;
302 assert_se(sd_event_new(&e
) >= 0);
303 assert_se(sd_event_now(e
, CLOCK_MONOTONIC
, &event_now
) > 0);
304 assert_se(sd_event_now(e
, CLOCK_REALTIME
, &event_now
) > 0);
305 assert_se(sd_event_now(e
, CLOCK_REALTIME_ALARM
, &event_now
) > 0);
306 assert_se(sd_event_now(e
, CLOCK_BOOTTIME
, &event_now
) > 0);
307 assert_se(sd_event_now(e
, CLOCK_BOOTTIME_ALARM
, &event_now
) > 0);
308 assert_se(sd_event_now(e
, -1, &event_now
) == -EOPNOTSUPP
);
309 assert_se(sd_event_now(e
, 900 /* arbitrary big number */, &event_now
) == -EOPNOTSUPP
);
311 assert_se(sd_event_run(e
, 0) == 0);
313 assert_se(sd_event_now(e
, CLOCK_MONOTONIC
, &event_now
) == 0);
314 assert_se(sd_event_now(e
, CLOCK_REALTIME
, &event_now
) == 0);
315 assert_se(sd_event_now(e
, CLOCK_REALTIME_ALARM
, &event_now
) == 0);
316 assert_se(sd_event_now(e
, CLOCK_BOOTTIME
, &event_now
) == 0);
317 assert_se(sd_event_now(e
, CLOCK_BOOTTIME_ALARM
, &event_now
) == 0);
318 assert_se(sd_event_now(e
, -1, &event_now
) == -EOPNOTSUPP
);
319 assert_se(sd_event_now(e
, 900 /* arbitrary big number */, &event_now
) == -EOPNOTSUPP
);
322 static int last_rtqueue_sigval
= 0;
323 static int n_rtqueue
= 0;
325 static int rtqueue_handler(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
326 last_rtqueue_sigval
= si
->ssi_int
;
332 sd_event_source
*u
= NULL
, *v
= NULL
, *s
= NULL
;
335 assert_se(sd_event_default(&e
) >= 0);
337 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGRTMIN
+2, SIGRTMIN
+3, SIGUSR2
) >= 0);
338 assert_se(sd_event_add_signal(e
, &u
, SIGRTMIN
+2, rtqueue_handler
, NULL
) >= 0);
339 assert_se(sd_event_add_signal(e
, &v
, SIGRTMIN
+3, rtqueue_handler
, NULL
) >= 0);
340 assert_se(sd_event_add_signal(e
, &s
, SIGUSR2
, rtqueue_handler
, NULL
) >= 0);
342 assert_se(sd_event_source_set_priority(v
, -10) >= 0);
344 assert_se(sigqueue(getpid_cached(), SIGRTMIN
+2, (union sigval
) { .sival_int
= 1 }) >= 0);
345 assert_se(sigqueue(getpid_cached(), SIGRTMIN
+3, (union sigval
) { .sival_int
= 2 }) >= 0);
346 assert_se(sigqueue(getpid_cached(), SIGUSR2
, (union sigval
) { .sival_int
= 3 }) >= 0);
347 assert_se(sigqueue(getpid_cached(), SIGRTMIN
+3, (union sigval
) { .sival_int
= 4 }) >= 0);
348 assert_se(sigqueue(getpid_cached(), SIGUSR2
, (union sigval
) { .sival_int
= 5 }) >= 0);
350 assert_se(n_rtqueue
== 0);
351 assert_se(last_rtqueue_sigval
== 0);
353 assert_se(sd_event_run(e
, UINT64_MAX
) >= 1);
354 assert_se(n_rtqueue
== 1);
355 assert_se(last_rtqueue_sigval
== 2); /* first SIGRTMIN+3 */
357 assert_se(sd_event_run(e
, UINT64_MAX
) >= 1);
358 assert_se(n_rtqueue
== 2);
359 assert_se(last_rtqueue_sigval
== 4); /* second SIGRTMIN+3 */
361 assert_se(sd_event_run(e
, UINT64_MAX
) >= 1);
362 assert_se(n_rtqueue
== 3);
363 assert_se(last_rtqueue_sigval
== 3); /* first SIGUSR2 */
365 assert_se(sd_event_run(e
, UINT64_MAX
) >= 1);
366 assert_se(n_rtqueue
== 4);
367 assert_se(last_rtqueue_sigval
== 1); /* SIGRTMIN+2 */
369 assert_se(sd_event_run(e
, 0) == 0); /* the other SIGUSR2 is dropped, because the first one was still queued */
370 assert_se(n_rtqueue
== 4);
371 assert_se(last_rtqueue_sigval
== 1);
373 sd_event_source_unref(u
);
374 sd_event_source_unref(v
);
375 sd_event_source_unref(s
);
380 #define CREATE_EVENTS_MAX (70000U)
382 struct inotify_context
{
383 bool delete_self_handler_called
;
384 unsigned create_called
[CREATE_EVENTS_MAX
];
385 unsigned create_overflow
;
386 unsigned n_create_events
;
390 static void maybe_exit(sd_event_source
*s
, struct inotify_context
*c
) {
396 if (!c
->delete_self_handler_called
)
399 for (n
= 0; n
< 3; n
++) {
402 if (c
->create_overflow
& (1U << n
))
405 for (i
= 0; i
< c
->n_create_events
; i
++)
406 if (!(c
->create_called
[i
] & (1U << n
)))
410 sd_event_exit(sd_event_source_get_event(s
), 0);
413 static int inotify_handler(sd_event_source
*s
, const struct inotify_event
*ev
, void *userdata
) {
414 struct inotify_context
*c
= ASSERT_PTR(userdata
);
415 const char *path
, *description
;
418 assert_se(sd_event_source_get_inotify_path(s
, &path
) >= 0);
420 assert_se(sd_event_source_get_description(s
, &description
) >= 0);
421 assert_se(safe_atou(description
, &n
) >= 0);
426 if (ev
->mask
& IN_Q_OVERFLOW
) {
427 log_info("inotify-handler for %s <%s>: overflow", path
, description
);
428 c
->create_overflow
|= bit
;
429 } else if (ev
->mask
& IN_CREATE
) {
430 assert_se(path_equal_or_inode_same(path
, c
->path
, 0));
431 if (streq(ev
->name
, "sub"))
432 log_debug("inotify-handler for %s <%s>: create on %s", path
, description
, ev
->name
);
436 assert_se(safe_atou(ev
->name
, &i
) >= 0);
437 assert_se(i
< c
->n_create_events
);
438 c
->create_called
[i
] |= bit
;
440 } else if (ev
->mask
& IN_DELETE
) {
441 log_info("inotify-handler for %s <%s>: delete of %s", path
, description
, ev
->name
);
442 assert_se(streq(ev
->name
, "sub"));
444 assert_not_reached();
450 static int delete_self_handler(sd_event_source
*s
, const struct inotify_event
*ev
, void *userdata
) {
451 struct inotify_context
*c
= ASSERT_PTR(userdata
);
454 assert_se(sd_event_source_get_inotify_path(s
, &path
) >= 0);
456 if (ev
->mask
& IN_Q_OVERFLOW
) {
457 log_info("delete-self-handler for %s: overflow", path
);
458 c
->delete_self_handler_called
= true;
459 } else if (ev
->mask
& IN_DELETE_SELF
) {
460 log_info("delete-self-handler for %s: delete-self", path
);
461 c
->delete_self_handler_called
= true;
462 } else if (ev
->mask
& IN_IGNORED
) {
463 log_info("delete-self-handler for %s: ignore", path
);
465 assert_not_reached();
471 static void test_inotify_one(unsigned n_create_events
) {
472 _cleanup_(rm_rf_physical_and_freep
) char *p
= NULL
;
473 sd_event_source
*a
= NULL
, *b
= NULL
, *c
= NULL
, *d
= NULL
;
474 struct inotify_context context
= {
475 .n_create_events
= n_create_events
,
481 log_info("/* %s(%u) */", __func__
, n_create_events
);
483 assert_se(sd_event_default(&e
) >= 0);
485 assert_se(mkdtemp_malloc("/tmp/test-inotify-XXXXXX", &p
) >= 0);
488 assert_se(sd_event_add_inotify(e
, &a
, p
, IN_CREATE
|IN_ONLYDIR
, inotify_handler
, &context
) >= 0);
489 assert_se(sd_event_add_inotify(e
, &b
, p
, IN_CREATE
|IN_DELETE
|IN_DONT_FOLLOW
, inotify_handler
, &context
) >= 0);
490 assert_se(sd_event_source_set_priority(b
, SD_EVENT_PRIORITY_IDLE
) >= 0);
491 assert_se(sd_event_source_set_priority(b
, SD_EVENT_PRIORITY_NORMAL
) >= 0);
492 assert_se(sd_event_add_inotify(e
, &c
, p
, IN_CREATE
|IN_DELETE
|IN_EXCL_UNLINK
, inotify_handler
, &context
) >= 0);
493 assert_se(sd_event_source_set_priority(c
, SD_EVENT_PRIORITY_IDLE
) >= 0);
495 assert_se(sd_event_source_set_description(a
, "0") >= 0);
496 assert_se(sd_event_source_set_description(b
, "1") >= 0);
497 assert_se(sd_event_source_set_description(c
, "2") >= 0);
499 assert_se(sd_event_source_get_inotify_path(a
, &pp
) >= 0);
500 assert_se(path_equal_or_inode_same(pp
, p
, 0));
501 assert_se(sd_event_source_get_inotify_path(b
, &pp
) >= 0);
502 assert_se(path_equal_or_inode_same(pp
, p
, 0));
503 assert_se(sd_event_source_get_inotify_path(b
, &pp
) >= 0);
504 assert_se(path_equal_or_inode_same(pp
, p
, 0));
506 q
= strjoina(p
, "/sub");
507 assert_se(touch(q
) >= 0);
508 assert_se(sd_event_add_inotify(e
, &d
, q
, IN_DELETE_SELF
, delete_self_handler
, &context
) >= 0);
510 for (i
= 0; i
< n_create_events
; i
++) {
511 char buf
[DECIMAL_STR_MAX(unsigned)+1];
512 _cleanup_free_
char *z
= NULL
;
514 xsprintf(buf
, "%u", i
);
515 assert_se(z
= path_join(p
, buf
));
517 assert_se(touch(z
) >= 0);
520 assert_se(unlink(q
) >= 0);
522 assert_se(sd_event_loop(e
) >= 0);
524 sd_event_source_unref(a
);
525 sd_event_source_unref(b
);
526 sd_event_source_unref(c
);
527 sd_event_source_unref(d
);
533 test_inotify_one(100); /* should work without overflow */
534 test_inotify_one(33000); /* should trigger a q overflow */
537 static int pidfd_handler(sd_event_source
*s
, const siginfo_t
*si
, void *userdata
) {
541 assert_se(si
->si_uid
== getuid());
542 assert_se(si
->si_signo
== SIGCHLD
);
543 assert_se(si
->si_code
== CLD_EXITED
);
544 assert_se(si
->si_status
== 66);
546 log_info("got pidfd on %c", PTR_TO_INT(userdata
));
548 assert_se(userdata
== INT_TO_PTR('p'));
550 assert_se(sd_event_exit(sd_event_source_get_event(s
), 0) >= 0);
551 sd_event_source_unref(s
);
557 sd_event_source
*s
= NULL
, *t
= NULL
;
562 assert_se(sigprocmask_many(SIG_BLOCK
, NULL
, SIGCHLD
) >= 0);
571 ASSERT_OK(pidfd
= pidfd_open(pid
, 0));
579 assert_se(sd_event_default(&e
) >= 0);
580 assert_se(sd_event_add_child_pidfd(e
, &s
, pidfd
, WEXITED
, pidfd_handler
, INT_TO_PTR('p')) >= 0);
581 assert_se(sd_event_source_set_child_pidfd_own(s
, true) >= 0);
583 /* This one should never trigger, since our second child lives forever */
584 assert_se(sd_event_add_child(e
, &t
, pid2
, WEXITED
, pidfd_handler
, INT_TO_PTR('q')) >= 0);
585 assert_se(sd_event_source_set_child_process_own(t
, true) >= 0);
587 assert_se(sd_event_loop(e
) >= 0);
589 /* Child should still be alive */
590 assert_se(kill(pid2
, 0) >= 0);
592 t
= sd_event_source_unref(t
);
594 /* Child should now be dead, since we dropped the ref */
595 assert_se(kill(pid2
, 0) < 0 && errno
== ESRCH
);
600 static int ratelimit_io_handler(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
601 unsigned *c
= (unsigned*) userdata
;
606 static int ratelimit_time_handler(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
609 r
= sd_event_source_set_enabled(s
, SD_EVENT_ON
);
611 log_warning_errno(r
, "Failed to turn on notify event source: %m");
613 r
= sd_event_source_set_time(s
, usec
+ 1000);
615 log_error_errno(r
, "Failed to restart watchdog event source: %m");
617 unsigned *c
= (unsigned*) userdata
;
623 static int expired
= -1;
624 static int ratelimit_expired(sd_event_source
*s
, void *userdata
) {
629 _cleanup_close_pair_
int p
[2] = EBADF_PAIR
;
630 _cleanup_(sd_event_unrefp
) sd_event
*e
= NULL
;
631 _cleanup_(sd_event_source_unrefp
) sd_event_source
*s
= NULL
;
633 unsigned count
, burst
;
635 assert_se(sd_event_default(&e
) >= 0);
636 assert_se(pipe2(p
, O_CLOEXEC
|O_NONBLOCK
) >= 0);
638 assert_se(sd_event_add_io(e
, &s
, p
[0], EPOLLIN
, ratelimit_io_handler
, &count
) >= 0);
639 assert_se(sd_event_source_set_description(s
, "test-ratelimit-io") >= 0);
640 assert_se(sd_event_source_set_ratelimit(s
, 1 * USEC_PER_SEC
, 5) >= 0);
641 assert_se(sd_event_source_get_ratelimit(s
, &interval
, &burst
) >= 0);
642 assert_se(interval
== 1 * USEC_PER_SEC
&& burst
== 5);
644 assert_se(write(p
[1], "1", 1) == 1);
647 for (unsigned i
= 0; i
< 10; i
++) {
648 log_debug("slow loop iteration %u", i
);
649 assert_se(sd_event_run(e
, UINT64_MAX
) >= 0);
650 assert_se(usleep_safe(250 * USEC_PER_MSEC
) >= 0);
653 assert_se(sd_event_source_is_ratelimited(s
) == 0);
654 assert_se(count
== 10);
655 log_info("ratelimit_io_handler: called %u times, event source not ratelimited", count
);
657 assert_se(sd_event_source_set_ratelimit(s
, 0, 0) >= 0);
658 assert_se(sd_event_source_set_ratelimit(s
, 1 * USEC_PER_SEC
, 5) >= 0);
661 for (unsigned i
= 0; i
< 10; i
++) {
662 log_debug("fast event loop iteration %u", i
);
663 assert_se(sd_event_run(e
, UINT64_MAX
) >= 0);
664 assert_se(usleep_safe(10) >= 0);
666 log_info("ratelimit_io_handler: called %u times, event source got ratelimited", count
);
667 assert_se(count
< 10);
669 s
= sd_event_source_unref(s
);
673 assert_se(sd_event_add_time_relative(e
, &s
, CLOCK_MONOTONIC
, 1000, 1, ratelimit_time_handler
, &count
) >= 0);
674 assert_se(sd_event_source_set_ratelimit(s
, 1 * USEC_PER_SEC
, 10) == 0);
677 assert_se(sd_event_run(e
, UINT64_MAX
) >= 0);
678 } while (!sd_event_source_is_ratelimited(s
));
680 log_info("ratelimit_time_handler: called %u times, event source got ratelimited", count
);
681 assert_se(count
== 10);
683 /* In order to get rid of active rate limit client needs to disable it explicitly */
684 assert_se(sd_event_source_set_ratelimit(s
, 0, 0) >= 0);
685 assert_se(!sd_event_source_is_ratelimited(s
));
687 assert_se(sd_event_source_set_ratelimit(s
, 1 * USEC_PER_SEC
, 10) >= 0);
689 /* Set callback that will be invoked when we leave rate limited state. */
690 assert_se(sd_event_source_set_ratelimit_expire_callback(s
, ratelimit_expired
) >= 0);
693 assert_se(sd_event_run(e
, UINT64_MAX
) >= 0);
694 } while (!sd_event_source_is_ratelimited(s
));
696 log_info("ratelimit_time_handler: called 10 more times, event source got ratelimited");
697 assert_se(count
== 20);
699 /* Dispatch the event loop once more and check that ratelimit expiration callback got called */
700 assert_se(sd_event_run(e
, UINT64_MAX
) >= 0);
701 assert_se(expired
== 0);
704 TEST(simple_timeout
) {
705 _cleanup_(sd_event_unrefp
) sd_event
*e
= NULL
;
706 usec_t f
, t
, some_time
;
708 some_time
= random_u64_range(2 * USEC_PER_SEC
);
710 assert_se(sd_event_default(&e
) >= 0);
712 assert_se(sd_event_prepare(e
) == 0);
714 f
= now(CLOCK_MONOTONIC
);
715 assert_se(sd_event_wait(e
, some_time
) >= 0);
716 t
= now(CLOCK_MONOTONIC
);
718 /* The event loop may sleep longer than the specified time (timer accuracy, scheduling latencies, …),
719 * but never shorter. Let's check that. */
720 assert_se(t
>= usec_add(f
, some_time
));
723 static int inotify_self_destroy_handler(sd_event_source
*s
, const struct inotify_event
*ev
, void *userdata
) {
724 sd_event_source
**p
= userdata
;
730 assert_se(FLAGS_SET(ev
->mask
, IN_ATTRIB
));
732 assert_se(sd_event_exit(sd_event_source_get_event(s
), 0) >= 0);
734 *p
= sd_event_source_unref(*p
); /* here's what we actually intend to test: we destroy the event
735 * source from inside the event source handler */
739 TEST(inotify_self_destroy
) {
740 _cleanup_(sd_event_source_unrefp
) sd_event_source
*s
= NULL
;
741 _cleanup_(sd_event_unrefp
) sd_event
*e
= NULL
;
742 char path
[] = "/tmp/inotifyXXXXXX";
743 _cleanup_close_
int fd
= -EBADF
;
745 /* Tests that destroying an inotify event source from its own handler is safe */
747 assert_se(sd_event_default(&e
) >= 0);
749 fd
= mkostemp_safe(path
);
751 assert_se(sd_event_add_inotify_fd(e
, &s
, fd
, IN_ATTRIB
, inotify_self_destroy_handler
, &s
) >= 0);
753 assert_se(unlink(path
) >= 0); /* This will trigger IN_ATTRIB because link count goes to zero */
754 assert_se(sd_event_loop(e
) >= 0);
757 struct inotify_process_buffered_data_context
{
762 static int inotify_process_buffered_data_handler(sd_event_source
*s
, const struct inotify_event
*ev
, void *userdata
) {
763 struct inotify_process_buffered_data_context
*c
= ASSERT_PTR(userdata
);
764 const char *description
;
766 assert_se(sd_event_source_get_description(s
, &description
) >= 0);
769 assert_se(streq(c
->path
[c
->i
], description
));
775 TEST(inotify_process_buffered_data
) {
776 _cleanup_(rm_rf_physical_and_freep
) char *p
= NULL
, *q
= NULL
;
777 _cleanup_(sd_event_source_unrefp
) sd_event_source
*a
= NULL
, *b
= NULL
;
778 _cleanup_(sd_event_unrefp
) sd_event
*e
= NULL
;
779 _cleanup_free_
char *z
= NULL
;
781 /* For issue #23826 */
783 assert_se(sd_event_default(&e
) >= 0);
785 assert_se(mkdtemp_malloc("/tmp/test-inotify-XXXXXX", &p
) >= 0);
786 assert_se(mkdtemp_malloc("/tmp/test-inotify-XXXXXX", &q
) >= 0);
788 struct inotify_process_buffered_data_context context
= {
792 assert_se(sd_event_add_inotify(e
, &a
, p
, IN_CREATE
, inotify_process_buffered_data_handler
, &context
) >= 0);
793 assert_se(sd_event_add_inotify(e
, &b
, q
, IN_CREATE
, inotify_process_buffered_data_handler
, &context
) >= 0);
795 assert_se(z
= path_join(p
, "aaa"));
796 assert_se(touch(z
) >= 0);
798 assert_se(z
= path_join(q
, "bbb"));
799 assert_se(touch(z
) >= 0);
802 assert_se(sd_event_run(e
, 10 * USEC_PER_SEC
) > 0);
803 assert_se(sd_event_prepare(e
) > 0); /* issue #23826: this was 0. */
804 assert_se(sd_event_dispatch(e
) > 0);
805 assert_se(sd_event_prepare(e
) == 0);
806 assert_se(sd_event_wait(e
, 0) == 0);
810 _cleanup_(sd_event_unrefp
) sd_event
*e
= NULL
;
813 assert_se(sd_event_default(&e
) >= 0);
814 assert_se(sd_event_prepare(e
) == 0);
816 /* Check that after a fork the cleanup functions return NULL */
817 r
= safe_fork("(bus-fork-test)", FORK_WAIT
|FORK_LOG
, NULL
);
820 assert_se(sd_event_ref(e
) == NULL
);
821 assert_se(sd_event_unref(e
) == NULL
);
828 TEST(sd_event_source_set_io_fd
) {
829 _cleanup_(sd_event_source_unrefp
) sd_event_source
*s
= NULL
;
830 _cleanup_(sd_event_unrefp
) sd_event
*e
= NULL
;
831 _cleanup_close_pair_
int pfd_a
[2] = EBADF_PAIR
, pfd_b
[2] = EBADF_PAIR
;
833 assert_se(sd_event_default(&e
) >= 0);
835 assert_se(pipe2(pfd_a
, O_CLOEXEC
) >= 0);
836 assert_se(pipe2(pfd_b
, O_CLOEXEC
) >= 0);
838 assert_se(sd_event_add_io(e
, &s
, pfd_a
[0], EPOLLIN
, NULL
, INT_TO_PTR(-ENOANO
)) >= 0);
839 assert_se(sd_event_source_set_io_fd_own(s
, true) >= 0);
842 assert_se(sd_event_source_set_io_fd(s
, pfd_b
[0]) >= 0);
846 static int hup_callback(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
847 unsigned *c
= userdata
;
849 assert_se(revents
== EPOLLHUP
);
855 TEST(leave_ratelimit
) {
856 bool expect_ratelimit
= false, manually_left_ratelimit
= false;
857 _cleanup_(sd_event_source_unrefp
) sd_event_source
*s
= NULL
;
858 _cleanup_(sd_event_unrefp
) sd_event
*e
= NULL
;
859 _cleanup_close_pair_
int pfd
[2] = EBADF_PAIR
;
863 assert_se(sd_event_default(&e
) >= 0);
865 /* Create an event source that will continuously fire by creating a pipe whose write side is closed,
866 * and which hence will only see EOF and constant EPOLLHUP */
867 assert_se(pipe2(pfd
, O_CLOEXEC
) >= 0);
868 assert_se(sd_event_add_io(e
, &s
, pfd
[0], EPOLLIN
, hup_callback
, &c
) >= 0);
869 assert_se(sd_event_source_set_io_fd_own(s
, true) >= 0);
870 assert_se(sd_event_source_set_ratelimit(s
, 5*USEC_PER_MINUTE
, 5) >= 0);
873 pfd
[1] = safe_close(pfd
[1]); /* Trigger continuous EOF */
876 r
= sd_event_prepare(e
);
880 r
= sd_event_wait(e
, UINT64_MAX
);
884 r
= sd_event_dispatch(e
);
887 r
= sd_event_source_is_ratelimited(s
);
891 /* First four dispatches should just work */
894 /* The fifth dispatch should still work, but we now expect the ratelimit to be hit subsequently */
895 if (!expect_ratelimit
) {
897 assert_se(sd_event_source_leave_ratelimit(s
) == 0); /* this should be a NOP, and return 0 hence */
898 expect_ratelimit
= true;
900 /* We expected the ratelimit, let's leave it manually, and verify it */
902 assert_se(sd_event_source_leave_ratelimit(s
) > 0); /* we are ratelimited, hence should return > 0 */
903 assert_se(sd_event_source_is_ratelimited(s
) == 0);
905 manually_left_ratelimit
= true;
909 /* On the sixth iteration let's just exit */
913 /* Verify we definitely hit the ratelimit and left it manually again */
914 assert_se(manually_left_ratelimit
);
917 DEFINE_TEST_MAIN(LOG_DEBUG
);