src/libsystemd/sd-event/test-event.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2013 Lennart Poettering
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <sys/wait.h>
  22
  23 #include "sd-event.h"
  24
  25 #include "fd-util.h"
  26 #include "log.h"
  27 #include "macro.h"
  28 #include "signal-util.h"
  29 #include "util.h"
  30
  31 static int prepare_handler(sd_event_source *s, void *userdata) {
  32         log_info("preparing %c", PTR_TO_INT(userdata));
  33         return 1;
  34 }
  35
  36 static bool got_a, got_b, got_c, got_unref;
  37 static unsigned got_d;
  38
  39 static int unref_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
  40         sd_event_source_unref(s);
  41         got_unref = true;
  42         return 0;
  43 }
  44
  45 static int io_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
  46
  47         log_info("got IO on %c", PTR_TO_INT(userdata));
  48
  49         if (userdata == INT_TO_PTR('a')) {
  50                 assert_se(sd_event_source_set_enabled(s, SD_EVENT_OFF) >= 0);
  51                 assert_se(!got_a);
  52                 got_a = true;
  53         } else if (userdata == INT_TO_PTR('b')) {
  54                 assert_se(!got_b);
  55                 got_b = true;
  56         } else if (userdata == INT_TO_PTR('d')) {
  57                 got_d++;
  58                 if (got_d < 2)
  59                         assert_se(sd_event_source_set_enabled(s, SD_EVENT_ONESHOT) >= 0);
  60                 else
  61                         assert_se(sd_event_source_set_enabled(s, SD_EVENT_OFF) >= 0);
  62         } else
  63                 assert_not_reached("Yuck!");
  64
  65         return 1;
  66 }
  67
  68 static int child_handler(sd_event_source *s, const siginfo_t *si, void *userdata) {
  69
  70         assert_se(s);
  71         assert_se(si);
  72
  73         log_info("got child on %c", PTR_TO_INT(userdata));
  74
  75         assert_se(userdata == INT_TO_PTR('f'));
  76
  77         assert_se(sd_event_exit(sd_event_source_get_event(s), 0) >= 0);
  78         sd_event_source_unref(s);
  79
  80         return 1;
  81 }
  82
  83 static int signal_handler(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
  84         sd_event_source *p = NULL;
  85         pid_t pid;
  86
  87         assert_se(s);
  88         assert_se(si);
  89
  90         log_info("got signal on %c", PTR_TO_INT(userdata));
  91
  92         assert_se(userdata == INT_TO_PTR('e'));
  93
  94         assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGCHLD, -1) >= 0);
  95
  96         pid = fork();
  97         assert_se(pid >= 0);
  98
  99         if (pid == 0)
 100                 _exit(0);
 101
 102         assert_se(sd_event_add_child(sd_event_source_get_event(s), &p, pid, WEXITED, child_handler, INT_TO_PTR('f')) >= 0);
 103         assert_se(sd_event_source_set_enabled(p, SD_EVENT_ONESHOT) >= 0);
 104
 105         sd_event_source_unref(s);
 106
 107         return 1;
 108 }
 109
 110 static int defer_handler(sd_event_source *s, void *userdata) {
 111         sd_event_source *p = NULL;
 112
 113         assert_se(s);
 114
 115         log_info("got defer on %c", PTR_TO_INT(userdata));
 116
 117         assert_se(userdata == INT_TO_PTR('d'));
 118
 119         assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGUSR1, -1) >= 0);
 120
 121         assert_se(sd_event_add_signal(sd_event_source_get_event(s), &p, SIGUSR1, signal_handler, INT_TO_PTR('e')) >= 0);
 122         assert_se(sd_event_source_set_enabled(p, SD_EVENT_ONESHOT) >= 0);
 123         raise(SIGUSR1);
 124
 125         sd_event_source_unref(s);
 126
 127         return 1;
 128 }
 129
 130 static bool do_quit = false;
 131
 132 static int time_handler(sd_event_source *s, uint64_t usec, void *userdata) {
 133         log_info("got timer on %c", PTR_TO_INT(userdata));
 134
 135         if (userdata == INT_TO_PTR('c')) {
 136
 137                 if (do_quit) {
 138                         sd_event_source *p;
 139
 140                         assert_se(sd_event_add_defer(sd_event_source_get_event(s), &p, defer_handler, INT_TO_PTR('d')) >= 0);
 141                         assert_se(sd_event_source_set_enabled(p, SD_EVENT_ONESHOT) >= 0);
 142                 } else {
 143                         assert_se(!got_c);
 144                         got_c = true;
 145                 }
 146         } else
 147                 assert_not_reached("Huh?");
 148
 149         return 2;
 150 }
 151
 152 static bool got_exit = false;
 153
 154 static int exit_handler(sd_event_source *s, void *userdata) {
 155         log_info("got quit handler on %c", PTR_TO_INT(userdata));
 156
 157         got_exit = true;
 158
 159         return 3;
 160 }
 161
 162 static bool got_post = false;
 163
 164 static int post_handler(sd_event_source *s, void *userdata) {
 165         log_info("got post handler");
 166
 167         got_post = true;
 168
 169         return 2;
 170 }
 171
 172 static void test_basic(void) {
 173         sd_event *e = NULL;
 174         sd_event_source *w = NULL, *x = NULL, *y = NULL, *z = NULL, *q = NULL, *t = NULL;
 175         static const char ch = 'x';
 176         int a[2] = { -1, -1 }, b[2] = { -1, -1}, d[2] = { -1, -1}, k[2] = { -1, -1 };
 177         uint64_t event_now;
 178         int64_t priority;
 179
 180         assert_se(pipe(a) >= 0);
 181         assert_se(pipe(b) >= 0);
 182         assert_se(pipe(d) >= 0);
 183         assert_se(pipe(k) >= 0);
 184
 185         assert_se(sd_event_default(&e) >= 0);
 186         assert_se(sd_event_now(e, CLOCK_MONOTONIC, &event_now) > 0);
 187
 188         assert_se(sd_event_set_watchdog(e, true) >= 0);
 189
 190         /* Test whether we cleanly can destroy an io event source from its own handler */
 191         got_unref = false;
 192         assert_se(sd_event_add_io(e, &t, k[0], EPOLLIN, unref_handler, NULL) >= 0);
 193         assert_se(write(k[1], &ch, 1) == 1);
 194         assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
 195         assert_se(got_unref);
 196
 197         got_a = false, got_b = false, got_c = false, got_d = 0;
 198
 199         /* Add a oneshot handler, trigger it, re-enable it, and trigger
 200          * it again. */
 201         assert_se(sd_event_add_io(e, &w, d[0], EPOLLIN, io_handler, INT_TO_PTR('d')) >= 0);
 202         assert_se(sd_event_source_set_enabled(w, SD_EVENT_ONESHOT) >= 0);
 203         assert_se(write(d[1], &ch, 1) >= 0);
 204         assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
 205         assert_se(got_d == 1);
 206         assert_se(write(d[1], &ch, 1) >= 0);
 207         assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
 208         assert_se(got_d == 2);
 209
 210         assert_se(sd_event_add_io(e, &x, a[0], EPOLLIN, io_handler, INT_TO_PTR('a')) >= 0);
 211         assert_se(sd_event_add_io(e, &y, b[0], EPOLLIN, io_handler, INT_TO_PTR('b')) >= 0);
 212         assert_se(sd_event_add_time(e, &z, CLOCK_MONOTONIC, 0, 0, time_handler, INT_TO_PTR('c')) >= 0);
 213         assert_se(sd_event_add_exit(e, &q, exit_handler, INT_TO_PTR('g')) >= 0);
 214
 215         assert_se(sd_event_source_set_priority(x, 99) >= 0);
 216         assert_se(sd_event_source_get_priority(x, &priority) >= 0);
 217         assert_se(priority == 99);
 218         assert_se(sd_event_source_set_enabled(y, SD_EVENT_ONESHOT) >= 0);
 219         assert_se(sd_event_source_set_prepare(x, prepare_handler) >= 0);
 220         assert_se(sd_event_source_set_priority(z, 50) >= 0);
 221         assert_se(sd_event_source_set_enabled(z, SD_EVENT_ONESHOT) >= 0);
 222         assert_se(sd_event_source_set_prepare(z, prepare_handler) >= 0);
 223
 224         /* Test for floating event sources */
 225         assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGRTMIN+1, -1) >= 0);
 226         assert_se(sd_event_add_signal(e, NULL, SIGRTMIN+1, NULL, NULL) >= 0);
 227
 228         assert_se(write(a[1], &ch, 1) >= 0);
 229         assert_se(write(b[1], &ch, 1) >= 0);
 230
 231         assert_se(!got_a && !got_b && !got_c);
 232
 233         assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
 234
 235         assert_se(!got_a && got_b && !got_c);
 236
 237         assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
 238
 239         assert_se(!got_a && got_b && got_c);
 240
 241         assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
 242
 243         assert_se(got_a && got_b && got_c);
 244
 245         sd_event_source_unref(x);
 246         sd_event_source_unref(y);
 247
 248         do_quit = true;
 249         assert_se(sd_event_add_post(e, NULL, post_handler, NULL) >= 0);
 250         assert_se(sd_event_now(e, CLOCK_MONOTONIC, &event_now) == 0);
 251         assert_se(sd_event_source_set_time(z, event_now + 200 * USEC_PER_MSEC) >= 0);
 252         assert_se(sd_event_source_set_enabled(z, SD_EVENT_ONESHOT) >= 0);
 253
 254         assert_se(sd_event_loop(e) >= 0);
 255         assert_se(got_post);
 256         assert_se(got_exit);
 257
 258         sd_event_source_unref(z);
 259         sd_event_source_unref(q);
 260
 261         sd_event_source_unref(w);
 262
 263         sd_event_unref(e);
 264
 265         safe_close_pair(a);
 266         safe_close_pair(b);
 267         safe_close_pair(d);
 268         safe_close_pair(k);
 269 }
 270
 271 static void test_sd_event_now(void) {
 272         _cleanup_(sd_event_unrefp) sd_event *e = NULL;
 273         uint64_t event_now;
 274
 275         assert_se(sd_event_new(&e) >= 0);
 276         assert_se(sd_event_now(e, CLOCK_MONOTONIC, &event_now) > 0);
 277         assert_se(sd_event_now(e, CLOCK_REALTIME, &event_now) > 0);
 278         assert_se(sd_event_now(e, CLOCK_REALTIME_ALARM, &event_now) > 0);
 279         if (clock_boottime_supported()) {
 280                 assert_se(sd_event_now(e, CLOCK_BOOTTIME, &event_now) > 0);
 281                 assert_se(sd_event_now(e, CLOCK_BOOTTIME_ALARM, &event_now) > 0);
 282         }
 283         assert_se(sd_event_now(e, -1, &event_now) == -EOPNOTSUPP);
 284         assert_se(sd_event_now(e, 900 /* arbitrary big number */, &event_now) == -EOPNOTSUPP);
 285
 286         assert_se(sd_event_run(e, 0) == 0);
 287
 288         assert_se(sd_event_now(e, CLOCK_MONOTONIC, &event_now) == 0);
 289         assert_se(sd_event_now(e, CLOCK_REALTIME, &event_now) == 0);
 290         assert_se(sd_event_now(e, CLOCK_REALTIME_ALARM, &event_now) == 0);
 291         if (clock_boottime_supported()) {
 292                 assert_se(sd_event_now(e, CLOCK_BOOTTIME, &event_now) == 0);
 293                 assert_se(sd_event_now(e, CLOCK_BOOTTIME_ALARM, &event_now) == 0);
 294         }
 295         assert_se(sd_event_now(e, -1, &event_now) == -EOPNOTSUPP);
 296         assert_se(sd_event_now(e, 900 /* arbitrary big number */, &event_now) == -EOPNOTSUPP);
 297 }
 298
 299 static int last_rtqueue_sigval = 0;
 300 static int n_rtqueue = 0;
 301
 302 static int rtqueue_handler(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
 303         last_rtqueue_sigval = si->ssi_int;
 304         n_rtqueue++;
 305         return 0;
 306 }
 307
 308 static void test_rtqueue(void) {
 309         sd_event_source *u = NULL, *v = NULL, *s = NULL;
 310         sd_event *e = NULL;
 311
 312         assert_se(sd_event_default(&e) >= 0);
 313
 314         assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGRTMIN+2, SIGRTMIN+3, SIGUSR2, -1) >= 0);
 315         assert_se(sd_event_add_signal(e, &u, SIGRTMIN+2, rtqueue_handler, NULL) >= 0);
 316         assert_se(sd_event_add_signal(e, &v, SIGRTMIN+3, rtqueue_handler, NULL) >= 0);
 317         assert_se(sd_event_add_signal(e, &s, SIGUSR2, rtqueue_handler, NULL) >= 0);
 318
 319         assert_se(sd_event_source_set_priority(v, -10) >= 0);
 320
 321         assert_se(sigqueue(getpid_cached(), SIGRTMIN+2, (union sigval) { .sival_int = 1 }) >= 0);
 322         assert_se(sigqueue(getpid_cached(), SIGRTMIN+3, (union sigval) { .sival_int = 2 }) >= 0);
 323         assert_se(sigqueue(getpid_cached(), SIGUSR2, (union sigval) { .sival_int = 3 }) >= 0);
 324         assert_se(sigqueue(getpid_cached(), SIGRTMIN+3, (union sigval) { .sival_int = 4 }) >= 0);
 325         assert_se(sigqueue(getpid_cached(), SIGUSR2, (union sigval) { .sival_int = 5 }) >= 0);
 326
 327         assert_se(n_rtqueue == 0);
 328         assert_se(last_rtqueue_sigval == 0);
 329
 330         assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
 331         assert_se(n_rtqueue == 1);
 332         assert_se(last_rtqueue_sigval == 2); /* first SIGRTMIN+3 */
 333
 334         assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
 335         assert_se(n_rtqueue == 2);
 336         assert_se(last_rtqueue_sigval == 4); /* second SIGRTMIN+3 */
 337
 338         assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
 339         assert_se(n_rtqueue == 3);
 340         assert_se(last_rtqueue_sigval == 3); /* first SIGUSR2 */
 341
 342         assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
 343         assert_se(n_rtqueue == 4);
 344         assert_se(last_rtqueue_sigval == 1); /* SIGRTMIN+2 */
 345
 346         assert_se(sd_event_run(e, 0) == 0); /* the other SIGUSR2 is dropped, because the first one was still queued */
 347         assert_se(n_rtqueue == 4);
 348         assert_se(last_rtqueue_sigval == 1);
 349
 350         sd_event_source_unref(u);
 351         sd_event_source_unref(v);
 352         sd_event_source_unref(s);
 353
 354         sd_event_unref(e);
 355 }
 356
 357 int main(int argc, char *argv[]) {
 358
 359         log_set_max_level(LOG_DEBUG);
 360         log_parse_environment();
 361
 362         test_basic();
 363         test_sd_event_now();
 364         test_rtqueue();
 365
 366         return 0;
 367 }