#include "string-util.h"
#include "tests.h"
#include "tmpfile-util.h"
-#include "util.h"
static int prepare_handler(sd_event_source *s, void *userdata) {
log_info("preparing %c", PTR_TO_INT(userdata));
return 2;
}
-static void test_basic(bool with_pidfd) {
+static void test_basic_one(bool with_pidfd) {
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 };
+ int a[2] = { -EBADF, -EBADF }, b[2] = { -EBADF, -EBADF },
+ d[2] = { -EBADF, -EBADF }, k[2] = { -EBADF, -EBADF };
uint64_t event_now;
int64_t priority;
got_a = false, got_b = false, got_c = false, got_d = 0;
- /* Add a oneshot handler, trigger it, reenable it, and trigger
- * it again. */
+ /* Add a oneshot handler, trigger it, reenable 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(unsetenv("SYSTEMD_PIDFD") >= 0);
}
-static void test_sd_event_now(void) {
+TEST(basic) {
+ test_basic_one(true); /* test with pidfd */
+ test_basic_one(false); /* test without pidfd */
+}
+
+TEST(sd_event_now) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
uint64_t event_now;
- log_info("/* %s */", __func__);
-
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, 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_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, 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);
}
return 0;
}
-static void test_rtqueue(void) {
+TEST(rtqueue) {
sd_event_source *u = NULL, *v = NULL, *s = NULL;
sd_event *e = NULL;
- log_info("/* %s */", __func__);
-
assert_se(sd_event_default(&e) >= 0);
assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGRTMIN+2, SIGRTMIN+3, SIGUSR2, -1) >= 0);
return 1;
}
-static void test_inotify(unsigned n_create_events) {
+static void test_inotify_one(unsigned n_create_events) {
_cleanup_(rm_rf_physical_and_freep) char *p = NULL;
sd_event_source *a = NULL, *b = NULL, *c = NULL, *d = NULL;
struct inotify_context context = {
sd_event_unref(e);
}
+TEST(inotify) {
+ test_inotify_one(100); /* should work without overflow */
+ test_inotify_one(33000); /* should trigger a q overflow */
+}
+
static int pidfd_handler(sd_event_source *s, const siginfo_t *si, void *userdata) {
assert_se(s);
assert_se(si);
return 0;
}
-static void test_pidfd(void) {
+TEST(pidfd) {
sd_event_source *s = NULL, *t = NULL;
sd_event *e = NULL;
int pidfd;
pid_t pid, pid2;
- log_info("/* %s */", __func__);
-
assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGCHLD, -1) >= 0);
pid = fork();
return ++expired;
}
-static void test_ratelimit(void) {
+TEST(ratelimit) {
_cleanup_close_pair_ int p[2] = {-1, -1};
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
uint64_t interval;
unsigned count, burst;
- log_info("/* %s */", __func__);
-
assert_se(sd_event_default(&e) >= 0);
assert_se(pipe2(p, O_CLOEXEC|O_NONBLOCK) >= 0);
assert_se(sd_event_source_is_ratelimited(s) == 0);
assert_se(count == 10);
- log_info("ratelimit_io_handler: called %d times, event source not ratelimited", count);
+ log_info("ratelimit_io_handler: called %u times, event source not ratelimited", count);
assert_se(sd_event_source_set_ratelimit(s, 0, 0) >= 0);
assert_se(sd_event_source_set_ratelimit(s, 1 * USEC_PER_SEC, 5) >= 0);
assert_se(sd_event_run(e, UINT64_MAX) >= 0);
assert_se(usleep(10) >= 0);
}
- log_info("ratelimit_io_handler: called %d times, event source got ratelimited", count);
+ log_info("ratelimit_io_handler: called %u times, event source got ratelimited", count);
assert_se(count < 10);
s = sd_event_source_unref(s);
assert_se(sd_event_run(e, UINT64_MAX) >= 0);
} while (!sd_event_source_is_ratelimited(s));
- log_info("ratelimit_time_handler: called %d times, event source got ratelimited", count);
+ log_info("ratelimit_time_handler: called %u times, event source got ratelimited", count);
assert_se(count == 10);
/* In order to get rid of active rate limit client needs to disable it explicitly */
assert_se(expired == 0);
}
-static void test_simple_timeout(void) {
+TEST(simple_timeout) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
usec_t f, t, some_time;
return 1;
}
-static void test_inotify_self_destroy(void) {
+TEST(inotify_self_destroy) {
_cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
char path[] = "/tmp/inotifyXXXXXX";
- _cleanup_close_ int fd = -1;
+ _cleanup_close_ int fd = -EBADF;
/* Tests that destroying an inotify event source from its own handler is safe */
assert_se(sd_event_loop(e) >= 0);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
+struct inotify_process_buffered_data_context {
+ const char *path[2];
+ unsigned i;
+};
- test_simple_timeout();
+static int inotify_process_buffered_data_handler(sd_event_source *s, const struct inotify_event *ev, void *userdata) {
+ struct inotify_process_buffered_data_context *c = ASSERT_PTR(userdata);
+ const char *description;
- test_basic(true); /* test with pidfd */
- test_basic(false); /* test without pidfd */
+ assert_se(sd_event_source_get_description(s, &description) >= 0);
- test_sd_event_now();
- test_rtqueue();
+ assert_se(c->i < 2);
+ assert_se(streq(c->path[c->i], description));
+ c->i++;
- test_inotify(100); /* should work without overflow */
- test_inotify(33000); /* should trigger a q overflow */
+ return 1;
+}
- test_pidfd();
+TEST(inotify_process_buffered_data) {
+ _cleanup_(rm_rf_physical_and_freep) char *p = NULL, *q = NULL;
+ _cleanup_(sd_event_source_unrefp) sd_event_source *a = NULL, *b = NULL;
+ _cleanup_(sd_event_unrefp) sd_event *e = NULL;
+ _cleanup_free_ char *z = NULL;
- test_ratelimit();
+ /* For issue #23826 */
- test_inotify_self_destroy();
+ assert_se(sd_event_default(&e) >= 0);
- return 0;
+ assert_se(mkdtemp_malloc("/tmp/test-inotify-XXXXXX", &p) >= 0);
+ assert_se(mkdtemp_malloc("/tmp/test-inotify-XXXXXX", &q) >= 0);
+
+ struct inotify_process_buffered_data_context context = {
+ .path = { p, q },
+ };
+
+ assert_se(sd_event_add_inotify(e, &a, p, IN_CREATE, inotify_process_buffered_data_handler, &context) >= 0);
+ assert_se(sd_event_add_inotify(e, &b, q, IN_CREATE, inotify_process_buffered_data_handler, &context) >= 0);
+
+ assert_se(z = path_join(p, "aaa"));
+ assert_se(touch(z) >= 0);
+ z = mfree(z);
+ assert_se(z = path_join(q, "bbb"));
+ assert_se(touch(z) >= 0);
+ z = mfree(z);
+
+ assert_se(sd_event_run(e, 10 * USEC_PER_SEC) > 0);
+ assert_se(sd_event_prepare(e) > 0); /* issue #23826: this was 0. */
+ assert_se(sd_event_dispatch(e) > 0);
+ assert_se(sd_event_prepare(e) == 0);
+ assert_se(sd_event_wait(e, 0) == 0);
}
+
+DEFINE_TEST_MAIN(LOG_DEBUG);
projects / thirdparty / systemd.git / blobdiff