245 lines
7.8 KiB
Diff
245 lines
7.8 KiB
Diff
From c45a5a74465a39280b855f9d720b2ab4779a47fa Mon Sep 17 00:00:00 2001
|
|
From: Tom Gundersen <teg@jklm.no>
|
|
Date: Fri, 15 Aug 2014 18:49:29 +0200
|
|
Subject: [PATCH] sd-event: split run into prepare/wait/dispatch
|
|
|
|
This will allow sd-event to be integrated into an external event loop, which
|
|
in turn will allow (say) glib-based applications to use our various libraries,
|
|
without manually integrating each of them (bus, rtnl, dhcp, ...).
|
|
|
|
The external event-loop should integrate sd-event int he following way:
|
|
|
|
Every iteration must start with a call to sd_event_prepare(), which will
|
|
return 0 if no event sources are ready to be processed, a positive value if
|
|
they are and a negative value on error. sd_event_prepare() may only be called
|
|
following sd_event_dispatch(); a call to sd_event_wait() indicating that no
|
|
sources are ready to be dispatched; or a failed call to sd_event_dispatch() or
|
|
sd_event_wait().
|
|
|
|
A successful call to sd_event_prepare() indicating that no event sources are
|
|
ready to be dispatched must be followed by a call to sd_event_wait(),
|
|
which will return 0 if it timed out without event sources being ready to
|
|
be processed, a negative value on error and a positive value otherwise.
|
|
sd_event_wait() may only be called following a successful call to
|
|
sd_event_prepare() indicating that no event sources are ready to be dispatched.
|
|
|
|
If sd_event_wait() indicates that some events sources are ready to be
|
|
dispatched, it must be followed by a call to sd_event_dispatch(). This
|
|
is the only time sd_event_dispatch() may be called.
|
|
---
|
|
src/libsystemd/sd-event/sd-event.c | 122 +++++++++++++++++++++++++++++--------
|
|
src/systemd/sd-event.h | 5 ++
|
|
2 files changed, 102 insertions(+), 25 deletions(-)
|
|
|
|
diff --git a/src/libsystemd/sd-event/sd-event.c b/src/libsystemd/sd-event/sd-event.c
|
|
index e062997a80..a71962c24c 100644
|
|
--- a/src/libsystemd/sd-event/sd-event.c
|
|
+++ b/src/libsystemd/sd-event/sd-event.c
|
|
@@ -2210,12 +2210,8 @@ static int process_watchdog(sd_event *e) {
|
|
return arm_watchdog(e);
|
|
}
|
|
|
|
-_public_ int sd_event_run(sd_event *e, uint64_t timeout) {
|
|
- struct epoll_event *ev_queue;
|
|
- unsigned ev_queue_max;
|
|
- sd_event_source *p;
|
|
- int r, i, m;
|
|
- bool timedout;
|
|
+_public_ int sd_event_prepare(sd_event *e) {
|
|
+ int r;
|
|
|
|
assert_return(e, -EINVAL);
|
|
assert_return(!event_pid_changed(e), -ECHILD);
|
|
@@ -2223,38 +2219,60 @@ _public_ int sd_event_run(sd_event *e, uint64_t timeout) {
|
|
assert_return(e->state == SD_EVENT_PASSIVE, -EBUSY);
|
|
|
|
if (e->exit_requested)
|
|
- return dispatch_exit(e);
|
|
+ goto pending;
|
|
|
|
- sd_event_ref(e);
|
|
e->iteration++;
|
|
- e->state = SD_EVENT_RUNNING;
|
|
|
|
r = event_prepare(e);
|
|
if (r < 0)
|
|
- goto finish;
|
|
+ return r;
|
|
|
|
r = event_arm_timer(e, &e->realtime);
|
|
if (r < 0)
|
|
- goto finish;
|
|
+ return r;
|
|
|
|
r = event_arm_timer(e, &e->boottime);
|
|
if (r < 0)
|
|
- goto finish;
|
|
+ return r;
|
|
|
|
r = event_arm_timer(e, &e->monotonic);
|
|
if (r < 0)
|
|
- goto finish;
|
|
+ return r;
|
|
|
|
r = event_arm_timer(e, &e->realtime_alarm);
|
|
if (r < 0)
|
|
- goto finish;
|
|
+ return r;
|
|
|
|
r = event_arm_timer(e, &e->boottime_alarm);
|
|
if (r < 0)
|
|
- goto finish;
|
|
+ return r;
|
|
|
|
if (event_next_pending(e) || e->need_process_child)
|
|
- timeout = 0;
|
|
+ goto pending;
|
|
+
|
|
+ e->state = SD_EVENT_PREPARED;
|
|
+
|
|
+ return 0;
|
|
+
|
|
+pending:
|
|
+ e->state = SD_EVENT_PREPARED;
|
|
+ return sd_event_wait(e, 0);
|
|
+}
|
|
+
|
|
+_public_ int sd_event_wait(sd_event *e, uint64_t timeout) {
|
|
+ struct epoll_event *ev_queue;
|
|
+ unsigned ev_queue_max;
|
|
+ int r, m, i;
|
|
+
|
|
+ assert_return(e, -EINVAL);
|
|
+ assert_return(!event_pid_changed(e), -ECHILD);
|
|
+ assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
|
|
+ assert_return(e->state == SD_EVENT_PREPARED, -EBUSY);
|
|
+
|
|
+ if (e->exit_requested) {
|
|
+ e->state = SD_EVENT_PENDING;
|
|
+ return 1;
|
|
+ }
|
|
|
|
ev_queue_max = CLAMP(e->n_sources, 1U, EPOLL_QUEUE_MAX);
|
|
ev_queue = newa(struct epoll_event, ev_queue_max);
|
|
@@ -2262,12 +2280,16 @@ _public_ int sd_event_run(sd_event *e, uint64_t timeout) {
|
|
m = epoll_wait(e->epoll_fd, ev_queue, ev_queue_max,
|
|
timeout == (uint64_t) -1 ? -1 : (int) ((timeout + USEC_PER_MSEC - 1) / USEC_PER_MSEC));
|
|
if (m < 0) {
|
|
- r = errno == EAGAIN || errno == EINTR ? 1 : -errno;
|
|
+ if (errno == EINTR) {
|
|
+ e->state = SD_EVENT_PENDING;
|
|
+ return 1;
|
|
+ }
|
|
+
|
|
+ r = -errno;
|
|
+
|
|
goto finish;
|
|
}
|
|
|
|
- timedout = m == 0;
|
|
-
|
|
dual_timestamp_get(&e->timestamp);
|
|
e->timestamp_boottime = now(CLOCK_BOOTTIME);
|
|
|
|
@@ -2324,21 +2346,71 @@ _public_ int sd_event_run(sd_event *e, uint64_t timeout) {
|
|
goto finish;
|
|
}
|
|
|
|
- p = event_next_pending(e);
|
|
- if (!p) {
|
|
- r = !timedout;
|
|
- goto finish;
|
|
+ if (event_next_pending(e)) {
|
|
+ e->state = SD_EVENT_PENDING;
|
|
+
|
|
+ return 1;
|
|
}
|
|
|
|
- r = source_dispatch(p);
|
|
+ r = 0;
|
|
|
|
finish:
|
|
e->state = SD_EVENT_PASSIVE;
|
|
- sd_event_unref(e);
|
|
|
|
return r;
|
|
}
|
|
|
|
+_public_ int sd_event_dispatch(sd_event *e) {
|
|
+ sd_event_source *p;
|
|
+ int r;
|
|
+
|
|
+ assert_return(e, -EINVAL);
|
|
+ assert_return(!event_pid_changed(e), -ECHILD);
|
|
+ assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
|
|
+ assert_return(e->state == SD_EVENT_PENDING, -EBUSY);
|
|
+
|
|
+ if (e->exit_requested)
|
|
+ return dispatch_exit(e);
|
|
+
|
|
+ p = event_next_pending(e);
|
|
+ if (p) {
|
|
+ sd_event_ref(e);
|
|
+
|
|
+ e->state = SD_EVENT_RUNNING;
|
|
+ r = source_dispatch(p);
|
|
+ e->state = SD_EVENT_PASSIVE;
|
|
+
|
|
+ sd_event_unref(e);
|
|
+
|
|
+ return r;
|
|
+ }
|
|
+
|
|
+ e->state = SD_EVENT_PASSIVE;
|
|
+
|
|
+ return 1;
|
|
+}
|
|
+
|
|
+_public_ int sd_event_run(sd_event *e, uint64_t timeout) {
|
|
+ int r;
|
|
+
|
|
+ assert_return(e, -EINVAL);
|
|
+ assert_return(!event_pid_changed(e), -ECHILD);
|
|
+ assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
|
|
+ assert_return(e->state == SD_EVENT_PASSIVE, -EBUSY);
|
|
+
|
|
+ r = sd_event_prepare(e);
|
|
+ if (r > 0)
|
|
+ return sd_event_dispatch(e);
|
|
+ else if (r < 0)
|
|
+ return r;
|
|
+
|
|
+ r = sd_event_wait(e, timeout);
|
|
+ if (r > 0)
|
|
+ return sd_event_dispatch(e);
|
|
+ else
|
|
+ return r;
|
|
+}
|
|
+
|
|
_public_ int sd_event_loop(sd_event *e) {
|
|
int r;
|
|
|
|
diff --git a/src/systemd/sd-event.h b/src/systemd/sd-event.h
|
|
index d96852a763..8e013b33f6 100644
|
|
--- a/src/systemd/sd-event.h
|
|
+++ b/src/systemd/sd-event.h
|
|
@@ -52,6 +52,8 @@ enum {
|
|
|
|
enum {
|
|
SD_EVENT_PASSIVE,
|
|
+ SD_EVENT_PREPARED,
|
|
+ SD_EVENT_PENDING,
|
|
SD_EVENT_RUNNING,
|
|
SD_EVENT_EXITING,
|
|
SD_EVENT_FINISHED
|
|
@@ -84,6 +86,9 @@ int sd_event_add_defer(sd_event *e, sd_event_source **s, sd_event_handler_t call
|
|
int sd_event_add_post(sd_event *e, sd_event_source **s, sd_event_handler_t callback, void *userdata);
|
|
int sd_event_add_exit(sd_event *e, sd_event_source **s, sd_event_handler_t callback, void *userdata);
|
|
|
|
+int sd_event_prepare(sd_event *e);
|
|
+int sd_event_wait(sd_event *e, uint64_t timeout);
|
|
+int sd_event_dispatch(sd_event *e);
|
|
int sd_event_run(sd_event *e, uint64_t timeout);
|
|
int sd_event_loop(sd_event *e);
|
|
int sd_event_exit(sd_event *e, int code);
|