227 lines
8.4 KiB
Diff
227 lines
8.4 KiB
Diff
From 5f2ee8632f15a8978c522de6789777171e898671 Mon Sep 17 00:00:00 2001
|
|
From: Michal Sekletar <msekleta@redhat.com>
|
|
Date: Mon, 4 Oct 2021 19:44:06 +0200
|
|
Subject: [PATCH] sd-event: introduce callback invoked when event source
|
|
ratelimit expires
|
|
|
|
(cherry picked from commit fd69f2247520b0be3190ded96d646a415edc97b7)
|
|
|
|
Related: #2037395
|
|
---
|
|
src/libsystemd/libsystemd.sym | 5 +++
|
|
src/libsystemd/sd-event/sd-event.c | 61 +++++++++++++++++++++++-----
|
|
src/libsystemd/sd-event/test-event.c | 12 ++++++
|
|
src/systemd/sd-event.h | 1 +
|
|
4 files changed, 68 insertions(+), 11 deletions(-)
|
|
|
|
diff --git a/src/libsystemd/libsystemd.sym b/src/libsystemd/libsystemd.sym
|
|
index 149d2e7b82..f4a1426248 100644
|
|
--- a/src/libsystemd/libsystemd.sym
|
|
+++ b/src/libsystemd/libsystemd.sym
|
|
@@ -579,3 +579,8 @@ global:
|
|
sd_event_source_get_ratelimit;
|
|
sd_event_source_is_ratelimited;
|
|
} LIBSYSTEMD_239;
|
|
+
|
|
+LIBSYSTEMD_250 {
|
|
+global:
|
|
+ sd_event_source_set_ratelimit_expire_callback;
|
|
+} LIBSYSTEMD_248;
|
|
diff --git a/src/libsystemd/sd-event/sd-event.c b/src/libsystemd/sd-event/sd-event.c
|
|
index 47cf93b3f4..0adfdd9e1a 100644
|
|
--- a/src/libsystemd/sd-event/sd-event.c
|
|
+++ b/src/libsystemd/sd-event/sd-event.c
|
|
@@ -125,6 +125,7 @@ struct sd_event_source {
|
|
uint64_t prepare_iteration;
|
|
|
|
sd_event_destroy_t destroy_callback;
|
|
+ sd_event_handler_t ratelimit_expire_callback;
|
|
|
|
LIST_FIELDS(sd_event_source, sources);
|
|
|
|
@@ -2734,7 +2735,7 @@ fail:
|
|
return r;
|
|
}
|
|
|
|
-static int event_source_leave_ratelimit(sd_event_source *s) {
|
|
+static int event_source_leave_ratelimit(sd_event_source *s, bool run_callback) {
|
|
int r;
|
|
|
|
assert(s);
|
|
@@ -2766,6 +2767,23 @@ static int event_source_leave_ratelimit(sd_event_source *s) {
|
|
ratelimit_reset(&s->rate_limit);
|
|
|
|
log_debug("Event source %p (%s) left rate limit state.", s, strna(s->description));
|
|
+
|
|
+ if (run_callback && s->ratelimit_expire_callback) {
|
|
+ s->dispatching = true;
|
|
+ r = s->ratelimit_expire_callback(s, s->userdata);
|
|
+ s->dispatching = false;
|
|
+
|
|
+ if (r < 0) {
|
|
+ log_debug_errno(r, "Ratelimit expiry callback of event source %s (type %s) returned error, disabling: %m",
|
|
+ strna(s->description),
|
|
+ event_source_type_to_string(s->type));
|
|
+
|
|
+ sd_event_source_set_enabled(s, SD_EVENT_OFF);
|
|
+ }
|
|
+
|
|
+ return 1;
|
|
+ }
|
|
+
|
|
return 0;
|
|
|
|
fail:
|
|
@@ -2966,6 +2984,7 @@ static int process_timer(
|
|
struct clock_data *d) {
|
|
|
|
sd_event_source *s;
|
|
+ bool callback_invoked = false;
|
|
int r;
|
|
|
|
assert(e);
|
|
@@ -2981,9 +3000,11 @@ static int process_timer(
|
|
* again. */
|
|
assert(s->ratelimited);
|
|
|
|
- r = event_source_leave_ratelimit(s);
|
|
+ r = event_source_leave_ratelimit(s, /* run_callback */ true);
|
|
if (r < 0)
|
|
return r;
|
|
+ else if (r == 1)
|
|
+ callback_invoked = true;
|
|
|
|
continue;
|
|
}
|
|
@@ -2998,7 +3019,7 @@ static int process_timer(
|
|
event_source_time_prioq_reshuffle(s);
|
|
}
|
|
|
|
- return 0;
|
|
+ return callback_invoked;
|
|
}
|
|
|
|
static int process_child(sd_event *e) {
|
|
@@ -3698,15 +3719,15 @@ _public_ int sd_event_wait(sd_event *e, uint64_t timeout) {
|
|
if (r < 0)
|
|
goto finish;
|
|
|
|
- r = process_timer(e, e->timestamp.realtime, &e->realtime);
|
|
+ r = process_inotify(e);
|
|
if (r < 0)
|
|
goto finish;
|
|
|
|
- r = process_timer(e, e->timestamp.boottime, &e->boottime);
|
|
+ r = process_timer(e, e->timestamp.realtime, &e->realtime);
|
|
if (r < 0)
|
|
goto finish;
|
|
|
|
- r = process_timer(e, e->timestamp.monotonic, &e->monotonic);
|
|
+ r = process_timer(e, e->timestamp.boottime, &e->boottime);
|
|
if (r < 0)
|
|
goto finish;
|
|
|
|
@@ -3718,16 +3739,27 @@ _public_ int sd_event_wait(sd_event *e, uint64_t timeout) {
|
|
if (r < 0)
|
|
goto finish;
|
|
|
|
+ r = process_timer(e, e->timestamp.monotonic, &e->monotonic);
|
|
+ if (r < 0)
|
|
+ goto finish;
|
|
+ else if (r == 1) {
|
|
+ /* Ratelimit expiry callback was called. Let's postpone processing pending sources and
|
|
+ * put loop in the initial state in order to evaluate (in the next iteration) also sources
|
|
+ * there were potentially re-enabled by the callback.
|
|
+ *
|
|
+ * Wondering why we treat only this invocation of process_timer() differently? Once event
|
|
+ * source is ratelimited we essentially transform it into CLOCK_MONOTONIC timer hence
|
|
+ * ratelimit expiry callback is never called for any other timer type. */
|
|
+ r = 0;
|
|
+ goto finish;
|
|
+ }
|
|
+
|
|
if (e->need_process_child) {
|
|
r = process_child(e);
|
|
if (r < 0)
|
|
goto finish;
|
|
}
|
|
|
|
- r = process_inotify(e);
|
|
- if (r < 0)
|
|
- goto finish;
|
|
-
|
|
if (event_next_pending(e)) {
|
|
e->state = SD_EVENT_PENDING;
|
|
|
|
@@ -4054,7 +4086,7 @@ _public_ int sd_event_source_set_ratelimit(sd_event_source *s, uint64_t interval
|
|
|
|
/* When ratelimiting is configured we'll always reset the rate limit state first and start fresh,
|
|
* non-ratelimited. */
|
|
- r = event_source_leave_ratelimit(s);
|
|
+ r = event_source_leave_ratelimit(s, /* run_callback */ false);
|
|
if (r < 0)
|
|
return r;
|
|
|
|
@@ -4062,6 +4094,13 @@ _public_ int sd_event_source_set_ratelimit(sd_event_source *s, uint64_t interval
|
|
return 0;
|
|
}
|
|
|
|
+_public_ int sd_event_source_set_ratelimit_expire_callback(sd_event_source *s, sd_event_handler_t callback) {
|
|
+ assert_return(s, -EINVAL);
|
|
+
|
|
+ s->ratelimit_expire_callback = callback;
|
|
+ return 0;
|
|
+}
|
|
+
|
|
_public_ int sd_event_source_get_ratelimit(sd_event_source *s, uint64_t *ret_interval, unsigned *ret_burst) {
|
|
assert_return(s, -EINVAL);
|
|
|
|
diff --git a/src/libsystemd/sd-event/test-event.c b/src/libsystemd/sd-event/test-event.c
|
|
index e3ee4cd5c3..9135b22839 100644
|
|
--- a/src/libsystemd/sd-event/test-event.c
|
|
+++ b/src/libsystemd/sd-event/test-event.c
|
|
@@ -506,6 +506,11 @@ static int ratelimit_time_handler(sd_event_source *s, uint64_t usec, void *userd
|
|
return 0;
|
|
}
|
|
|
|
+static int expired = -1;
|
|
+static int ratelimit_expired(sd_event_source *s, void *userdata) {
|
|
+ return ++expired;
|
|
+}
|
|
+
|
|
static void test_ratelimit(void) {
|
|
_cleanup_close_pair_ int p[2] = {-1, -1};
|
|
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
|
|
@@ -568,12 +573,19 @@ static void test_ratelimit(void) {
|
|
|
|
assert_se(sd_event_source_set_ratelimit(s, 1 * USEC_PER_SEC, 10) >= 0);
|
|
|
|
+ /* Set callback that will be invoked when we leave rate limited state. */
|
|
+ assert_se(sd_event_source_set_ratelimit_expire_callback(s, ratelimit_expired) >= 0);
|
|
+
|
|
do {
|
|
assert_se(sd_event_run(e, UINT64_MAX) >= 0);
|
|
} while (!sd_event_source_is_ratelimited(s));
|
|
|
|
log_info("ratelimit_time_handler: called 10 more times, event source got ratelimited");
|
|
assert_se(count == 20);
|
|
+
|
|
+ /* Dispatch the event loop once more and check that ratelimit expiration callback got called */
|
|
+ assert_se(sd_event_run(e, UINT64_MAX) >= 0);
|
|
+ assert_se(expired == 0);
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
diff --git a/src/systemd/sd-event.h b/src/systemd/sd-event.h
|
|
index a17a9b3488..c2e9c9614d 100644
|
|
--- a/src/systemd/sd-event.h
|
|
+++ b/src/systemd/sd-event.h
|
|
@@ -147,6 +147,7 @@ int sd_event_source_get_destroy_callback(sd_event_source *s, sd_event_destroy_t
|
|
int sd_event_source_set_ratelimit(sd_event_source *s, uint64_t interval_usec, unsigned burst);
|
|
int sd_event_source_get_ratelimit(sd_event_source *s, uint64_t *ret_interval_usec, unsigned *ret_burst);
|
|
int sd_event_source_is_ratelimited(sd_event_source *s);
|
|
+int sd_event_source_set_ratelimit_expire_callback(sd_event_source *s, sd_event_handler_t callback);
|
|
|
|
/* Define helpers so that __attribute__((cleanup(sd_event_unrefp))) and similar may be used. */
|
|
_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_event, sd_event_unref);
|