[thirdparty/systemd.git] / src / libsystemd / sd-event / test-event.c

/* SPDX-License-Identifier: LGPL-2.1+ */
/***
  This file is part of systemd.

  Copyright 2013 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <sys/wait.h>

#include "sd-event.h"

#include "fd-util.h"
#include "log.h"
#include "macro.h"
#include "signal-util.h"
#include "util.h"

static int prepare_handler(sd_event_source *s, void *userdata) {
        log_info("preparing %c", PTR_TO_INT(userdata));
        return 1;
}

static bool got_a, got_b, got_c, got_unref;
static unsigned got_d;

static int unref_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
        sd_event_source_unref(s);
        got_unref = true;
        return 0;
}

static int io_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {

        log_info("got IO on %c", PTR_TO_INT(userdata));

        if (userdata == INT_TO_PTR('a')) {
                assert_se(sd_event_source_set_enabled(s, SD_EVENT_OFF) >= 0);
                assert_se(!got_a);
                got_a = true;
        } else if (userdata == INT_TO_PTR('b')) {
                assert_se(!got_b);
                got_b = true;
        } else if (userdata == INT_TO_PTR('d')) {
                got_d++;
                if (got_d < 2)
                        assert_se(sd_event_source_set_enabled(s, SD_EVENT_ONESHOT) >= 0);
                else
                        assert_se(sd_event_source_set_enabled(s, SD_EVENT_OFF) >= 0);
        } else
                assert_not_reached("Yuck!");

        return 1;
}

static int child_handler(sd_event_source *s, const siginfo_t *si, void *userdata) {

        assert_se(s);
        assert_se(si);

        log_info("got child on %c", PTR_TO_INT(userdata));

        assert_se(userdata == INT_TO_PTR('f'));

        assert_se(sd_event_exit(sd_event_source_get_event(s), 0) >= 0);
        sd_event_source_unref(s);

        return 1;
}

static int signal_handler(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
        sd_event_source *p = NULL;
        pid_t pid;

        assert_se(s);
        assert_se(si);

        log_info("got signal on %c", PTR_TO_INT(userdata));

        assert_se(userdata == INT_TO_PTR('e'));

        assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGCHLD, -1) >= 0);

        pid = fork();
        assert_se(pid >= 0);

        if (pid == 0)
                _exit(0);

        assert_se(sd_event_add_child(sd_event_source_get_event(s), &p, pid, WEXITED, child_handler, INT_TO_PTR('f')) >= 0);
        assert_se(sd_event_source_set_enabled(p, SD_EVENT_ONESHOT) >= 0);

        sd_event_source_unref(s);

        return 1;
}

static int defer_handler(sd_event_source *s, void *userdata) {
        sd_event_source *p = NULL;

        assert_se(s);

        log_info("got defer on %c", PTR_TO_INT(userdata));

        assert_se(userdata == INT_TO_PTR('d'));

        assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGUSR1, -1) >= 0);

        assert_se(sd_event_add_signal(sd_event_source_get_event(s), &p, SIGUSR1, signal_handler, INT_TO_PTR('e')) >= 0);
        assert_se(sd_event_source_set_enabled(p, SD_EVENT_ONESHOT) >= 0);
        raise(SIGUSR1);

        sd_event_source_unref(s);

        return 1;
}

static bool do_quit = false;

static int time_handler(sd_event_source *s, uint64_t usec, void *userdata) {
        log_info("got timer on %c", PTR_TO_INT(userdata));

        if (userdata == INT_TO_PTR('c')) {

                if (do_quit) {
                        sd_event_source *p;

                        assert_se(sd_event_add_defer(sd_event_source_get_event(s), &p, defer_handler, INT_TO_PTR('d')) >= 0);
                        assert_se(sd_event_source_set_enabled(p, SD_EVENT_ONESHOT) >= 0);
                } else {
                        assert_se(!got_c);
                        got_c = true;
                }
        } else
                assert_not_reached("Huh?");

        return 2;
}

static bool got_exit = false;

static int exit_handler(sd_event_source *s, void *userdata) {
        log_info("got quit handler on %c", PTR_TO_INT(userdata));

        got_exit = true;

        return 3;
}

static bool got_post = false;

static int post_handler(sd_event_source *s, void *userdata) {
        log_info("got post handler");

        got_post = true;

        return 2;
}

static void test_basic(void) {
        sd_event *e = NULL;
        sd_event_source *w = NULL, *x = NULL, *y = NULL, *z = NULL, *q = NULL, *t = NULL;
        static const char ch = 'x';
        int a[2] = { -1, -1 }, b[2] = { -1, -1}, d[2] = { -1, -1}, k[2] = { -1, -1 };
        uint64_t event_now;
        int64_t priority;

        assert_se(pipe(a) >= 0);
        assert_se(pipe(b) >= 0);
        assert_se(pipe(d) >= 0);
        assert_se(pipe(k) >= 0);

        assert_se(sd_event_default(&e) >= 0);
        assert_se(sd_event_now(e, CLOCK_MONOTONIC, &event_now) > 0);

        assert_se(sd_event_set_watchdog(e, true) >= 0);

        /* Test whether we cleanly can destroy an io event source from its own handler */
        got_unref = false;
        assert_se(sd_event_add_io(e, &t, k[0], EPOLLIN, unref_handler, NULL) >= 0);
        assert_se(write(k[1], &ch, 1) == 1);
        assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
        assert_se(got_unref);

        got_a = false, got_b = false, got_c = false, got_d = 0;

        /* Add a oneshot handler, trigger it, re-enable it, and trigger
         * it again. */
        assert_se(sd_event_add_io(e, &w, d[0], EPOLLIN, io_handler, INT_TO_PTR('d')) >= 0);
        assert_se(sd_event_source_set_enabled(w, SD_EVENT_ONESHOT) >= 0);
        assert_se(write(d[1], &ch, 1) >= 0);
        assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
        assert_se(got_d == 1);
        assert_se(write(d[1], &ch, 1) >= 0);
        assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
        assert_se(got_d == 2);

        assert_se(sd_event_add_io(e, &x, a[0], EPOLLIN, io_handler, INT_TO_PTR('a')) >= 0);
        assert_se(sd_event_add_io(e, &y, b[0], EPOLLIN, io_handler, INT_TO_PTR('b')) >= 0);
        assert_se(sd_event_add_time(e, &z, CLOCK_MONOTONIC, 0, 0, time_handler, INT_TO_PTR('c')) >= 0);
        assert_se(sd_event_add_exit(e, &q, exit_handler, INT_TO_PTR('g')) >= 0);

        assert_se(sd_event_source_set_priority(x, 99) >= 0);
        assert_se(sd_event_source_get_priority(x, &priority) >= 0);
        assert_se(priority == 99);
        assert_se(sd_event_source_set_enabled(y, SD_EVENT_ONESHOT) >= 0);
        assert_se(sd_event_source_set_prepare(x, prepare_handler) >= 0);
        assert_se(sd_event_source_set_priority(z, 50) >= 0);
        assert_se(sd_event_source_set_enabled(z, SD_EVENT_ONESHOT) >= 0);
        assert_se(sd_event_source_set_prepare(z, prepare_handler) >= 0);

        /* Test for floating event sources */
        assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGRTMIN+1, -1) >= 0);
        assert_se(sd_event_add_signal(e, NULL, SIGRTMIN+1, NULL, NULL) >= 0);

        assert_se(write(a[1], &ch, 1) >= 0);
        assert_se(write(b[1], &ch, 1) >= 0);

        assert_se(!got_a && !got_b && !got_c);

        assert_se(sd_event_run(e, (uint64_t) -1) >= 1);

        assert_se(!got_a && got_b && !got_c);

        assert_se(sd_event_run(e, (uint64_t) -1) >= 1);

        assert_se(!got_a && got_b && got_c);

        assert_se(sd_event_run(e, (uint64_t) -1) >= 1);

        assert_se(got_a && got_b && got_c);

        sd_event_source_unref(x);
        sd_event_source_unref(y);

        do_quit = true;
        assert_se(sd_event_add_post(e, NULL, post_handler, NULL) >= 0);
        assert_se(sd_event_now(e, CLOCK_MONOTONIC, &event_now) == 0);
        assert_se(sd_event_source_set_time(z, event_now + 200 * USEC_PER_MSEC) >= 0);
        assert_se(sd_event_source_set_enabled(z, SD_EVENT_ONESHOT) >= 0);

        assert_se(sd_event_loop(e) >= 0);
        assert_se(got_post);
        assert_se(got_exit);

        sd_event_source_unref(z);
        sd_event_source_unref(q);

        sd_event_source_unref(w);

        sd_event_unref(e);

        safe_close_pair(a);
        safe_close_pair(b);
        safe_close_pair(d);
        safe_close_pair(k);
}

static void test_sd_event_now(void) {
        _cleanup_(sd_event_unrefp) sd_event *e = NULL;
        uint64_t event_now;

        assert_se(sd_event_new(&e) >= 0);
        assert_se(sd_event_now(e, CLOCK_MONOTONIC, &event_now) > 0);
        assert_se(sd_event_now(e, CLOCK_REALTIME, &event_now) > 0);
        assert_se(sd_event_now(e, CLOCK_REALTIME_ALARM, &event_now) > 0);
        if (clock_boottime_supported()) {
                assert_se(sd_event_now(e, CLOCK_BOOTTIME, &event_now) > 0);
                assert_se(sd_event_now(e, CLOCK_BOOTTIME_ALARM, &event_now) > 0);
        }
        assert_se(sd_event_now(e, -1, &event_now) == -EOPNOTSUPP);
        assert_se(sd_event_now(e, 900 /* arbitrary big number */, &event_now) == -EOPNOTSUPP);

        assert_se(sd_event_run(e, 0) == 0);

        assert_se(sd_event_now(e, CLOCK_MONOTONIC, &event_now) == 0);
        assert_se(sd_event_now(e, CLOCK_REALTIME, &event_now) == 0);
        assert_se(sd_event_now(e, CLOCK_REALTIME_ALARM, &event_now) == 0);
        if (clock_boottime_supported()) {
                assert_se(sd_event_now(e, CLOCK_BOOTTIME, &event_now) == 0);
                assert_se(sd_event_now(e, CLOCK_BOOTTIME_ALARM, &event_now) == 0);
        }
        assert_se(sd_event_now(e, -1, &event_now) == -EOPNOTSUPP);
        assert_se(sd_event_now(e, 900 /* arbitrary big number */, &event_now) == -EOPNOTSUPP);
}

static int last_rtqueue_sigval = 0;
static int n_rtqueue = 0;

static int rtqueue_handler(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
        last_rtqueue_sigval = si->ssi_int;
        n_rtqueue++;
        return 0;
}

static void test_rtqueue(void) {
        sd_event_source *u = NULL, *v = NULL, *s = NULL;
        sd_event *e = NULL;

        assert_se(sd_event_default(&e) >= 0);

        assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGRTMIN+2, SIGRTMIN+3, SIGUSR2, -1) >= 0);
        assert_se(sd_event_add_signal(e, &u, SIGRTMIN+2, rtqueue_handler, NULL) >= 0);
        assert_se(sd_event_add_signal(e, &v, SIGRTMIN+3, rtqueue_handler, NULL) >= 0);
        assert_se(sd_event_add_signal(e, &s, SIGUSR2, rtqueue_handler, NULL) >= 0);

        assert_se(sd_event_source_set_priority(v, -10) >= 0);

        assert_se(sigqueue(getpid_cached(), SIGRTMIN+2, (union sigval) { .sival_int = 1 }) >= 0);
        assert_se(sigqueue(getpid_cached(), SIGRTMIN+3, (union sigval) { .sival_int = 2 }) >= 0);
        assert_se(sigqueue(getpid_cached(), SIGUSR2, (union sigval) { .sival_int = 3 }) >= 0);
        assert_se(sigqueue(getpid_cached(), SIGRTMIN+3, (union sigval) { .sival_int = 4 }) >= 0);
        assert_se(sigqueue(getpid_cached(), SIGUSR2, (union sigval) { .sival_int = 5 }) >= 0);

        assert_se(n_rtqueue == 0);
        assert_se(last_rtqueue_sigval == 0);

        assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
        assert_se(n_rtqueue == 1);
        assert_se(last_rtqueue_sigval == 2); /* first SIGRTMIN+3 */

        assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
        assert_se(n_rtqueue == 2);
        assert_se(last_rtqueue_sigval == 4); /* second SIGRTMIN+3 */

        assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
        assert_se(n_rtqueue == 3);
        assert_se(last_rtqueue_sigval == 3); /* first SIGUSR2 */

        assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
        assert_se(n_rtqueue == 4);
        assert_se(last_rtqueue_sigval == 1); /* SIGRTMIN+2 */

        assert_se(sd_event_run(e, 0) == 0); /* the other SIGUSR2 is dropped, because the first one was still queued */
        assert_se(n_rtqueue == 4);
        assert_se(last_rtqueue_sigval == 1);

        sd_event_source_unref(u);
        sd_event_source_unref(v);
        sd_event_source_unref(s);

        sd_event_unref(e);
}

int main(int argc, char *argv[]) {

        log_set_max_level(LOG_DEBUG);
        log_parse_environment();

        test_basic();
        test_sd_event_now();
        test_rtqueue();

        return 0;
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
fd38203a LP	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
fe993888 MS	21	#include <sys/wait.h>
fe993888 MS	22
fd38203a	23	#include "sd-event.h"
3ffd4af2 LP	24
3ffd4af2 LP	25	#include "fd-util.h"
fd38203a	26	#include "log.h"
0c0cdb06	27	#include "macro.h"
24882e06	28	#include "signal-util.h"
3ffd4af2	29	#include "util.h"
fd38203a LP	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
12179984	36	static bool got_a, got_b, got_c, got_unref;
9ec9694c	37	static unsigned got_d;
fd38203a	38
12179984 LP	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
fd38203a LP	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')) {
baf76283	50	assert_se(sd_event_source_set_enabled(s, SD_EVENT_OFF) >= 0);
fd38203a LP	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;
9ec9694c DS	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);
fd38203a LP	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
0c0cdb06 RC	70	assert_se(s);
0c0cdb06 RC	71	assert_se(si);
fd38203a LP	72
	73	log_info("got child on %c", PTR_TO_INT(userdata));
	74
0c0cdb06	75	assert_se(userdata == INT_TO_PTR('f'));
fd38203a	76
6203e07a	77	assert_se(sd_event_exit(sd_event_source_get_event(s), 0) >= 0);
fd38203a LP	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) {
39883f62	84	sd_event_source *p = NULL;
fd38203a LP	85	pid_t pid;
fd38203a LP	86
0c0cdb06 RC	87	assert_se(s);
0c0cdb06 RC	88	assert_se(si);
fd38203a LP	89
	90	log_info("got signal on %c", PTR_TO_INT(userdata));
	91
0c0cdb06	92	assert_se(userdata == INT_TO_PTR('e'));
fd38203a	93
72c0a2c2	94	assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGCHLD, -1) >= 0);
fd38203a LP	95
	96	pid = fork();
	97	assert_se(pid >= 0);
	98
	99	if (pid == 0)
	100	_exit(0);
	101
151b9b96	102	assert_se(sd_event_add_child(sd_event_source_get_event(s), &p, pid, WEXITED, child_handler, INT_TO_PTR('f')) >= 0);
baf76283	103	assert_se(sd_event_source_set_enabled(p, SD_EVENT_ONESHOT) >= 0);
fd38203a LP	104
	105	sd_event_source_unref(s);
	106
	107	return 1;
	108	}
	109
	110	static int defer_handler(sd_event_source s, void userdata) {
39883f62	111	sd_event_source *p = NULL;
fd38203a	112
0c0cdb06	113	assert_se(s);
fd38203a LP	114
	115	log_info("got defer on %c", PTR_TO_INT(userdata));
	116
0c0cdb06	117	assert_se(userdata == INT_TO_PTR('d'));
fd38203a	118
72c0a2c2 LP	119	assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGUSR1, -1) >= 0);
72c0a2c2 LP	120
151b9b96	121	assert_se(sd_event_add_signal(sd_event_source_get_event(s), &p, SIGUSR1, signal_handler, INT_TO_PTR('e')) >= 0);
baf76283	122	assert_se(sd_event_source_set_enabled(p, SD_EVENT_ONESHOT) >= 0);
fd38203a LP	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
151b9b96	140	assert_se(sd_event_add_defer(sd_event_source_get_event(s), &p, defer_handler, INT_TO_PTR('d')) >= 0);
baf76283	141	assert_se(sd_event_source_set_enabled(p, SD_EVENT_ONESHOT) >= 0);
fd38203a	142	} else {
0c0cdb06	143	assert_se(!got_c);
fd38203a LP	144	got_c = true;
	145	}
	146	} else
	147	assert_not_reached("Huh?");
	148
	149	return 2;
	150	}
	151
6203e07a	152	static bool got_exit = false;
da7e457c	153
6203e07a	154	static int exit_handler(sd_event_source s, void userdata) {
da7e457c LP	155	log_info("got quit handler on %c", PTR_TO_INT(userdata));
da7e457c LP	156
6203e07a	157	got_exit = true;
da7e457c LP	158
	159	return 3;
	160	}
	161
509a07ad EV	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
9da4cb2b	172	static void test_basic(void) {
fd38203a	173	sd_event *e = NULL;
12179984	174	sd_event_source w = NULL, x = NULL, y = NULL, z = NULL, q = NULL, t = NULL;
fd38203a	175	static const char ch = 'x';
12179984	176	int a[2] = { -1, -1 }, b[2] = { -1, -1}, d[2] = { -1, -1}, k[2] = { -1, -1 };
591df2b5	177	uint64_t event_now;
6680b8d1	178	int64_t priority;
fd38203a LP	179
	180	assert_se(pipe(a) >= 0);
	181	assert_se(pipe(b) >= 0);
9ec9694c	182	assert_se(pipe(d) >= 0);
12179984	183	assert_se(pipe(k) >= 0);
fd38203a	184
afc6adb5	185	assert_se(sd_event_default(&e) >= 0);
591df2b5	186	assert_se(sd_event_now(e, CLOCK_MONOTONIC, &event_now) > 0);
fd38203a	187
cde93897 LP	188	assert_se(sd_event_set_watchdog(e, true) >= 0);
cde93897 LP	189
12179984 LP	190	/* Test whether we cleanly can destroy an io event source from its own handler */
12179984 LP	191	got_unref = false;
151b9b96	192	assert_se(sd_event_add_io(e, &t, k[0], EPOLLIN, unref_handler, NULL) >= 0);
12179984 LP	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
9ec9694c DS	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. */
151b9b96	201	assert_se(sd_event_add_io(e, &w, d[0], EPOLLIN, io_handler, INT_TO_PTR('d')) >= 0);
9ec9694c DS	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);
fd38203a	209
151b9b96 LP	210	assert_se(sd_event_add_io(e, &x, a[0], EPOLLIN, io_handler, INT_TO_PTR('a')) >= 0);
151b9b96 LP	211	assert_se(sd_event_add_io(e, &y, b[0], EPOLLIN, io_handler, INT_TO_PTR('b')) >= 0);
6a0f1f6d	212	assert_se(sd_event_add_time(e, &z, CLOCK_MONOTONIC, 0, 0, time_handler, INT_TO_PTR('c')) >= 0);
151b9b96	213	assert_se(sd_event_add_exit(e, &q, exit_handler, INT_TO_PTR('g')) >= 0);
fd38203a LP	214
fd38203a LP	215	assert_se(sd_event_source_set_priority(x, 99) >= 0);
6680b8d1 ME	216	assert_se(sd_event_source_get_priority(x, &priority) >= 0);
6680b8d1 ME	217	assert_se(priority == 99);
baf76283	218	assert_se(sd_event_source_set_enabled(y, SD_EVENT_ONESHOT) >= 0);
fd38203a LP	219	assert_se(sd_event_source_set_prepare(x, prepare_handler) >= 0);
fd38203a LP	220	assert_se(sd_event_source_set_priority(z, 50) >= 0);
baf76283	221	assert_se(sd_event_source_set_enabled(z, SD_EVENT_ONESHOT) >= 0);
fd38203a	222	assert_se(sd_event_source_set_prepare(z, prepare_handler) >= 0);
a71fe8b8 LP	223
a71fe8b8 LP	224	/* Test for floating event sources */
72c0a2c2	225	assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGRTMIN+1, -1) >= 0);
a71fe8b8	226	assert_se(sd_event_add_signal(e, NULL, SIGRTMIN+1, NULL, NULL) >= 0);
fd38203a LP	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;
509a07ad	249	assert_se(sd_event_add_post(e, NULL, post_handler, NULL) >= 0);
591df2b5 EV	250	assert_se(sd_event_now(e, CLOCK_MONOTONIC, &event_now) == 0);
591df2b5 EV	251	assert_se(sd_event_source_set_time(z, event_now + 200 * USEC_PER_MSEC) >= 0);
baf76283	252	assert_se(sd_event_source_set_enabled(z, SD_EVENT_ONESHOT) >= 0);
fd38203a LP	253
fd38203a LP	254	assert_se(sd_event_loop(e) >= 0);
509a07ad	255	assert_se(got_post);
5657c75f	256	assert_se(got_exit);
fd38203a LP	257
fd38203a LP	258	sd_event_source_unref(z);
da7e457c	259	sd_event_source_unref(q);
fd38203a	260
d5e4ec5b LP	261	sd_event_source_unref(w);
d5e4ec5b LP	262
fd38203a LP	263	sd_event_unref(e);
fd38203a LP	264
3d94f76c LP	265	safe_close_pair(a);
	266	safe_close_pair(b);
	267	safe_close_pair(d);
	268	safe_close_pair(k);
9da4cb2b LP	269	}
9da4cb2b LP	270
2c86ba5a ZJS	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);
3411372e LP	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	}
2c86ba5a ZJS	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);
3411372e LP	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	}
2c86ba5a ZJS	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
9da4cb2b LP	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;
313cefa1	304	n_rtqueue++;
9da4cb2b LP	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
19500112 YW	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);
9da4cb2b LP	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
2c86ba5a ZJS	359	log_set_max_level(LOG_DEBUG);
	360	log_parse_environment();
	361
9da4cb2b	362	test_basic();
2c86ba5a	363	test_sd_event_now();
9da4cb2b	364	test_rtqueue();
fd38203a LP	365
	366	return 0;
	367	}