event: implement quit handlers

Quit handlers are executed when an event loop is terminated via
sd_event_request_quit(). They are in a way atexit() handlers that are
executed in a well-defined environment, time and thread: from the event
loop thread when the event loop finishes.

diff --git a/src/libsystemd-bus/sd-event.c b/src/libsystemd-bus/sd-event.c
index e3110c3d6bc50aa7b9fbd8a36fbfc8681c4bbcbd..c52e4cd501a64b48669ab0f57f930702ea35280e 100644 (file)
--- a/src/libsystemd-bus/sd-event.c
+++ b/src/libsystemd-bus/sd-event.c
@@ -24,7 +24,6 @@
 #include <sys/wait.h>
 
 #include "macro.h"
 #include <sys/wait.h>
 
 #include "macro.h"

-#include "refcnt.h"

 #include "prioq.h"
 #include "hashmap.h"
 #include "util.h"
 #include "prioq.h"
 #include "hashmap.h"
 #include "util.h"


@@ -42,18 +41,19 @@ typedef enum EventSourceType {
         SOURCE_REALTIME,
         SOURCE_SIGNAL,
         SOURCE_CHILD,
         SOURCE_REALTIME,
         SOURCE_SIGNAL,
         SOURCE_CHILD,

-        SOURCE_DEFER
+        SOURCE_DEFER,
+        SOURCE_QUIT

 } EventSourceType;
 
 struct sd_event_source {
 } EventSourceType;
 
 struct sd_event_source {

-        RefCount n_ref;
+        unsigned n_ref;

 
         sd_event *event;
         void *userdata;
         sd_prepare_handler_t prepare;
 
         EventSourceType type:4;
 
         sd_event *event;
         void *userdata;
         sd_prepare_handler_t prepare;
 
         EventSourceType type:4;

-        sd_event_mute_t mute:3;
+        int mute:3;

         bool pending:1;
 
         int priority;
         bool pending:1;
 
         int priority;


@@ -90,11 +90,15 @@ struct sd_event_source {
                 struct {
                         sd_defer_handler_t callback;
                 } defer;
                 struct {
                         sd_defer_handler_t callback;
                 } defer;

+                struct {
+                        sd_quit_handler_t callback;
+                        unsigned prioq_index;
+                } quit;

         };
 };
 
 struct sd_event {
         };
 };
 
 struct sd_event {

-        RefCount n_ref;
+        unsigned n_ref;

 
         int epoll_fd;
         int signal_fd;
 
         int epoll_fd;
         int signal_fd;


@@ -115,21 +119,24 @@ struct sd_event {
         Prioq *realtime_earliest;
         Prioq *realtime_latest;
 
         Prioq *realtime_earliest;
         Prioq *realtime_latest;
 

+        usec_t realtime_next, monotonic_next;
+        usec_t perturb;
+

         sigset_t sigset;
         sd_event_source **signal_sources;
 
         Hashmap *child_sources;
         unsigned n_unmuted_child_sources;
 
         sigset_t sigset;
         sd_event_source **signal_sources;
 
         Hashmap *child_sources;
         unsigned n_unmuted_child_sources;
 

-        unsigned iteration;
+        Prioq *quit;

 
 

-        usec_t realtime_next, monotonic_next;
-        usec_t perturb;
+        pid_t original_pid;

 
 

-        bool quit:1;
-        bool need_process_child:1;
+        unsigned iteration;
+        int state;

 
 

-        pid_t original_pid;
+        bool quit_requested:1;
+        bool need_process_child:1;

 };
 
 static int pending_prioq_compare(const void *a, const void *b) {
 };
 
 static int pending_prioq_compare(const void *a, const void *b) {


@@ -236,8 +243,8 @@ static int earliest_time_prioq_compare(const void *a, const void *b) {
 static int latest_time_prioq_compare(const void *a, const void *b) {
         const sd_event_source *x = a, *y = b;
 
 static int latest_time_prioq_compare(const void *a, const void *b) {
         const sd_event_source *x = a, *y = b;
 

-        assert(x->type == SOURCE_MONOTONIC || x->type == SOURCE_REALTIME);
-        assert(y->type == SOURCE_MONOTONIC || y->type == SOURCE_REALTIME);
+        assert((x->type == SOURCE_MONOTONIC && y->type == SOURCE_MONOTONIC) ||
+               (x->type == SOURCE_REALTIME && y->type == SOURCE_REALTIME));

 
         /* Unmuted ones first */
         if (x->mute != SD_EVENT_MUTED && y->mute == SD_EVENT_MUTED)
 
         /* Unmuted ones first */
         if (x->mute != SD_EVENT_MUTED && y->mute == SD_EVENT_MUTED)


@@ -266,6 +273,33 @@ static int latest_time_prioq_compare(const void *a, const void *b) {
         return 0;
 }
 
         return 0;
 }
 

+static int quit_prioq_compare(const void *a, const void *b) {
+        const sd_event_source *x = a, *y = b;
+
+        assert(x->type == SOURCE_QUIT);
+        assert(y->type == SOURCE_QUIT);
+
+        /* Unmuted ones first */
+        if (x->mute != SD_EVENT_MUTED && y->mute == SD_EVENT_MUTED)
+                return -1;
+        if (x->mute == SD_EVENT_MUTED && y->mute != SD_EVENT_MUTED)
+                return 1;
+
+        /* Lower priority values first */
+        if (x->priority < y->priority)
+                return -1;
+        if (x->priority > y->priority)
+                return 1;
+
+        /* Stability for the rest */
+        if (x < y)
+                return -1;
+        if (x > y)
+                return 1;
+
+        return 0;
+}
+

 static void event_free(sd_event *e) {
         assert(e);
 
 static void event_free(sd_event *e) {
         assert(e);
 


@@ -287,6 +321,7 @@ static void event_free(sd_event *e) {
         prioq_free(e->monotonic_latest);
         prioq_free(e->realtime_earliest);
         prioq_free(e->realtime_latest);
         prioq_free(e->monotonic_latest);
         prioq_free(e->realtime_earliest);
         prioq_free(e->realtime_latest);

+        prioq_free(e->quit);

 
         free(e->signal_sources);
 
 
         free(e->signal_sources);
 


@@ -305,7 +340,7 @@ int sd_event_new(sd_event** ret) {
         if (!e)
                 return -ENOMEM;
 
         if (!e)
                 return -ENOMEM;
 

-        e->n_ref = REFCNT_INIT;
+        e->n_ref = 1;

         e->signal_fd = e->realtime_fd = e->monotonic_fd = e->epoll_fd = -1;
         e->realtime_next = e->monotonic_next = (usec_t) -1;
         e->original_pid = getpid();
         e->signal_fd = e->realtime_fd = e->monotonic_fd = e->epoll_fd = -1;
         e->realtime_next = e->monotonic_next = (usec_t) -1;
         e->original_pid = getpid();


@@ -336,7 +371,8 @@ sd_event* sd_event_ref(sd_event *e) {
         if (!e)
                 return NULL;
 
         if (!e)
                 return NULL;
 

-        assert_se(REFCNT_INC(e->n_ref) >= 2);
+        assert(e->n_ref >= 1);
+        e->n_ref++;

 
         return e;
 }
 
         return e;
 }


@@ -345,7 +381,10 @@ sd_event* sd_event_unref(sd_event *e) {
         if (!e)
                 return NULL;
 
         if (!e)
                 return NULL;
 

-        if (REFCNT_DEC(e->n_ref) <= 0)
+        assert(e->n_ref >= 1);
+        e->n_ref--;
+
+        if (e->n_ref <= 0)

                 event_free(e);
 
         return NULL;
                 event_free(e);
 
         return NULL;


@@ -377,18 +416,18 @@ static int source_io_unregister(sd_event_source *s) {
         return 0;
 }
 
         return 0;
 }
 

-static int source_io_register(sd_event_source *s, sd_event_mute_t m, uint32_t events) {
+static int source_io_register(sd_event_source *s, int mute, uint32_t events) {

         struct epoll_event ev = {};
         int r;
 
         assert(s);
         assert(s->type == SOURCE_IO);
         struct epoll_event ev = {};
         int r;
 
         assert(s);
         assert(s->type == SOURCE_IO);

-        assert(m != SD_EVENT_MUTED);
+        assert(mute != SD_EVENT_MUTED);

 
         ev.events = events;
         ev.data.ptr = s;
 
 
         ev.events = events;
         ev.data.ptr = s;
 

-        if (m == SD_EVENT_ONESHOT)
+        if (mute == SD_EVENT_ONESHOT)

                 ev.events |= EPOLLONESHOT;
 
         if (s->io.registered)
                 ev.events |= EPOLLONESHOT;
 
         if (s->io.registered)


@@ -451,6 +490,10 @@ static void source_free(sd_event_source *s) {
                         }
 
                         break;
                         }
 
                         break;

+
+                case SOURCE_QUIT:
+                        prioq_remove(s->event->quit, s, &s->quit.prioq_index);
+                        break;

                 }
 
                 if (s->pending)
                 }
 
                 if (s->pending)


@@ -469,6 +512,7 @@ static int source_set_pending(sd_event_source *s, bool b) {
         int r;
 
         assert(s);
         int r;
 
         assert(s);

+        assert(s->type != SOURCE_QUIT);

 
         if (s->pending == b)
                 return 0;
 
         if (s->pending == b)
                 return 0;


@@ -498,10 +542,9 @@ static sd_event_source *source_new(sd_event *e, EventSourceType type) {
         if (!s)
                 return NULL;
 
         if (!s)
                 return NULL;
 

-        s->n_ref = REFCNT_INIT;
+        s->n_ref = 1;

         s->event = sd_event_ref(e);
         s->type = type;
         s->event = sd_event_ref(e);
         s->type = type;

-        s->mute = SD_EVENT_UNMUTED;

         s->pending_index = s->prepare_index = PRIOQ_IDX_NULL;
 
         return s;
         s->pending_index = s->prepare_index = PRIOQ_IDX_NULL;
 
         return s;


@@ -528,6 +571,7 @@ int sd_event_add_io(
                 return -EINVAL;
         if (!ret)
                 return -EINVAL;
                 return -EINVAL;
         if (!ret)
                 return -EINVAL;

+        assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);

         if (event_pid_changed(e))
                 return -ECHILD;
 
         if (event_pid_changed(e))
                 return -ECHILD;
 


@@ -539,6 +583,7 @@ int sd_event_add_io(
         s->io.events = events;
         s->io.callback = callback;
         s->userdata = userdata;
         s->io.events = events;
         s->io.callback = callback;
         s->userdata = userdata;

+        s->mute = SD_EVENT_UNMUTED;

 
         r = source_io_register(s, s->mute, events);
         if (r < 0) {
 
         r = source_io_register(s, s->mute, events);
         if (r < 0) {


@@ -620,6 +665,7 @@ static int event_add_time_internal(
                 return -EINVAL;
         if (accuracy == (uint64_t) -1)
                 return -EINVAL;
                 return -EINVAL;
         if (accuracy == (uint64_t) -1)
                 return -EINVAL;

+        assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);

         if (event_pid_changed(e))
                 return -ECHILD;
 
         if (event_pid_changed(e))
                 return -ECHILD;
 


@@ -652,9 +698,9 @@ static int event_add_time_internal(
         s->time.next = usec;
         s->time.accuracy = accuracy == 0 ? DEFAULT_ACCURACY_USEC : accuracy;
         s->time.callback = callback;
         s->time.next = usec;
         s->time.accuracy = accuracy == 0 ? DEFAULT_ACCURACY_USEC : accuracy;
         s->time.callback = callback;

-        s->time.earliest_index = PRIOQ_IDX_NULL;
-        s->time.latest_index = PRIOQ_IDX_NULL;
+        s->time.earliest_index = s->time.latest_index = PRIOQ_IDX_NULL;

         s->userdata = userdata;
         s->userdata = userdata;

+        s->mute = SD_EVENT_ONESHOT;

 
         r = prioq_put(*earliest, s, &s->time.earliest_index);
         if (r < 0)
 
         r = prioq_put(*earliest, s, &s->time.earliest_index);
         if (r < 0)


@@ -726,6 +772,7 @@ int sd_event_add_signal(sd_event *e, int sig, sd_signal_handler_t callback, void
                 return -EINVAL;
         if (!ret)
                 return -EINVAL;
                 return -EINVAL;
         if (!ret)
                 return -EINVAL;

+        assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);

         if (event_pid_changed(e))
                 return -ECHILD;
 
         if (event_pid_changed(e))
                 return -ECHILD;
 


@@ -743,6 +790,7 @@ int sd_event_add_signal(sd_event *e, int sig, sd_signal_handler_t callback, void
         s->signal.sig = sig;
         s->signal.callback = callback;
         s->userdata = userdata;
         s->signal.sig = sig;
         s->signal.callback = callback;
         s->userdata = userdata;

+        s->mute = SD_EVENT_UNMUTED;

 
         e->signal_sources[sig] = s;
         assert_se(sigaddset(&e->sigset, sig) == 0);
 
         e->signal_sources[sig] = s;
         assert_se(sigaddset(&e->sigset, sig) == 0);


@@ -773,6 +821,7 @@ int sd_event_add_child(sd_event *e, pid_t pid, int options, sd_child_handler_t c
                 return -EINVAL;
         if (!ret)
                 return -EINVAL;
                 return -EINVAL;
         if (!ret)
                 return -EINVAL;

+        assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);

         if (event_pid_changed(e))
                 return -ECHILD;
 
         if (event_pid_changed(e))
                 return -ECHILD;
 


@@ -791,6 +840,7 @@ int sd_event_add_child(sd_event *e, pid_t pid, int options, sd_child_handler_t c
         s->child.options = options;
         s->child.callback = callback;
         s->userdata = userdata;
         s->child.options = options;
         s->child.callback = callback;
         s->userdata = userdata;

+        s->mute = SD_EVENT_ONESHOT;

 
         r = hashmap_put(e->child_sources, INT_TO_PTR(pid), s);
         if (r < 0) {
 
         r = hashmap_put(e->child_sources, INT_TO_PTR(pid), s);
         if (r < 0) {


@@ -824,6 +874,7 @@ int sd_event_add_defer(sd_event *e, sd_defer_handler_t callback, void *userdata,
                 return -EINVAL;
         if (!ret)
                 return -EINVAL;
                 return -EINVAL;
         if (!ret)
                 return -EINVAL;

+        assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);

         if (event_pid_changed(e))
                 return -ECHILD;
 
         if (event_pid_changed(e))
                 return -ECHILD;
 


@@ -833,6 +884,7 @@ int sd_event_add_defer(sd_event *e, sd_defer_handler_t callback, void *userdata,
 
         s->defer.callback = callback;
         s->userdata = userdata;
 
         s->defer.callback = callback;
         s->userdata = userdata;

+        s->mute = SD_EVENT_ONESHOT;

 
         r = source_set_pending(s, true);
         if (r < 0) {
 
         r = source_set_pending(s, true);
         if (r < 0) {


@@ -844,26 +896,61 @@ int sd_event_add_defer(sd_event *e, sd_defer_handler_t callback, void *userdata,
         return 0;
 }
 
         return 0;
 }
 

-sd_event_source* sd_event_source_ref(sd_event_source *s) {
+int sd_event_add_quit(sd_event *e, sd_quit_handler_t callback, void *userdata, sd_event_source **ret) {
+        sd_event_source *s;
+        int r;
+
+        assert_return(e, -EINVAL);
+        assert_return(callback, -EINVAL);
+        assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
+        assert_return(!event_pid_changed(e), -ECHILD);
+
+        if (!e->quit) {
+                e->quit = prioq_new(quit_prioq_compare);
+                if (!e->quit)
+                        return -ENOMEM;
+        }
+
+        s = source_new(e, SOURCE_QUIT);

         if (!s)
         if (!s)

-                return NULL;
+                return -ENOMEM;

 
 

-        assert_se(REFCNT_INC(s->n_ref) >= 2);
+        s->quit.callback = callback;
+        s->userdata = userdata;
+        s->quit.prioq_index = PRIOQ_IDX_NULL;
+        s->mute = SD_EVENT_ONESHOT;
+
+        r = prioq_put(s->event->quit, s, &s->quit.prioq_index);
+        if (r < 0) {
+                source_free(s);
+                return r;
+        }
+
+        *ret = s;
+        return 0;
+}
+
+sd_event_source* sd_event_source_ref(sd_event_source *s) {
+        assert_return(s, NULL);
+
+        assert(s->n_ref >= 1);
+        s->n_ref++;

 
         return s;
 }
 
 sd_event_source* sd_event_source_unref(sd_event_source *s) {
 
         return s;
 }
 
 sd_event_source* sd_event_source_unref(sd_event_source *s) {

-        if (!s)
-                return NULL;
+        assert_return(s, NULL);

 
 

-        if (REFCNT_DEC(s->n_ref) <= 0)
+        assert(s->n_ref >= 1);
+        s->n_ref--;
+
+        if (s->n_ref <= 0)

                 source_free(s);
 
         return NULL;
 }
 
                 source_free(s);
 
         return NULL;
 }
 

-

 sd_event *sd_event_get(sd_event_source *s) {
         if (!s)
                 return NULL;
 sd_event *sd_event_get(sd_event_source *s) {
         if (!s)
                 return NULL;


@@ -874,6 +961,7 @@ sd_event *sd_event_get(sd_event_source *s) {
 int sd_event_source_get_pending(sd_event_source *s) {
         if (!s)
                 return -EINVAL;
 int sd_event_source_get_pending(sd_event_source *s) {
         if (!s)
                 return -EINVAL;

+        assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);

         if (event_pid_changed(s->event))
                 return -ECHILD;
 
         if (event_pid_changed(s->event))
                 return -ECHILD;
 


@@ -914,6 +1002,7 @@ int sd_event_source_set_io_events(sd_event_source *s, uint32_t events) {
                 return -EDOM;
         if (events & ~(EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLPRI|EPOLLERR|EPOLLHUP))
                 return -EINVAL;
                 return -EDOM;
         if (events & ~(EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLPRI|EPOLLERR|EPOLLHUP))
                 return -EINVAL;

+        assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);

         if (event_pid_changed(s->event))
                 return -ECHILD;
 
         if (event_pid_changed(s->event))
                 return -ECHILD;
 


@@ -952,6 +1041,7 @@ int sd_event_source_get_signal(sd_event_source *s) {
                 return -EINVAL;
         if (s->type != SOURCE_SIGNAL)
                 return -EDOM;
                 return -EINVAL;
         if (s->type != SOURCE_SIGNAL)
                 return -EDOM;

+        assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);

         if (event_pid_changed(s->event))
                 return -ECHILD;
 
         if (event_pid_changed(s->event))
                 return -ECHILD;
 


@@ -970,6 +1060,7 @@ int sd_event_source_get_priority(sd_event_source *s, int *priority) {
 int sd_event_source_set_priority(sd_event_source *s, int priority) {
         if (!s)
                 return -EINVAL;
 int sd_event_source_set_priority(sd_event_source *s, int priority) {
         if (!s)
                 return -EINVAL;

+        assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);

         if (event_pid_changed(s->event))
                 return -ECHILD;
 
         if (event_pid_changed(s->event))
                 return -ECHILD;
 


@@ -987,7 +1078,7 @@ int sd_event_source_set_priority(sd_event_source *s, int priority) {
         return 0;
 }
 
         return 0;
 }
 

-int sd_event_source_get_mute(sd_event_source *s, sd_event_mute_t *m) {
+int sd_event_source_get_mute(sd_event_source *s, int *m) {

         if (!s)
                 return -EINVAL;
         if (!m)
         if (!s)
                 return -EINVAL;
         if (!m)


@@ -999,13 +1090,14 @@ int sd_event_source_get_mute(sd_event_source *s, sd_event_mute_t *m) {
         return 0;
 }
 
         return 0;
 }
 

-int sd_event_source_set_mute(sd_event_source *s, sd_event_mute_t m) {
+int sd_event_source_set_mute(sd_event_source *s, int m) {

         int r;
 
         if (!s)
                 return -EINVAL;
         if (m != SD_EVENT_MUTED && m != SD_EVENT_UNMUTED && !SD_EVENT_ONESHOT)
                 return -EINVAL;
         int r;
 
         if (!s)
                 return -EINVAL;
         if (m != SD_EVENT_MUTED && m != SD_EVENT_UNMUTED && !SD_EVENT_ONESHOT)
                 return -EINVAL;

+        assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);

         if (event_pid_changed(s->event))
                 return -ECHILD;
 
         if (event_pid_changed(s->event))
                 return -ECHILD;
 


@@ -1059,6 +1151,7 @@ int sd_event_source_set_mute(sd_event_source *s, sd_event_mute_t m) {
                         break;
 
                 case SOURCE_DEFER:
                         break;
 
                 case SOURCE_DEFER:

+                case SOURCE_QUIT:

                         s->mute = m;
                         break;
                 }
                         s->mute = m;
                         break;
                 }


@@ -1109,6 +1202,7 @@ int sd_event_source_set_mute(sd_event_source *s, sd_event_mute_t m) {
                         break;
 
                 case SOURCE_DEFER:
                         break;
 
                 case SOURCE_DEFER:

+                case SOURCE_QUIT:

                         s->mute = m;
                         break;
                 }
                         s->mute = m;
                         break;
                 }


@@ -1144,6 +1238,7 @@ int sd_event_source_set_time(sd_event_source *s, uint64_t usec) {
                 return -EINVAL;
         if (s->type != SOURCE_REALTIME && s->type != SOURCE_MONOTONIC)
                 return -EDOM;
                 return -EINVAL;
         if (s->type != SOURCE_REALTIME && s->type != SOURCE_MONOTONIC)
                 return -EDOM;

+        assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);

         if (event_pid_changed(s->event))
                 return -ECHILD;
 
         if (event_pid_changed(s->event))
                 return -ECHILD;
 


@@ -1168,6 +1263,7 @@ int sd_event_source_set_time_accuracy(sd_event_source *s, uint64_t usec) {
                 return -EINVAL;
         if (s->type != SOURCE_MONOTONIC && s->type != SOURCE_REALTIME)
                 return -EDOM;
                 return -EINVAL;
         if (s->type != SOURCE_MONOTONIC && s->type != SOURCE_REALTIME)
                 return -EDOM;

+        assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);

         if (event_pid_changed(s->event))
                 return -ECHILD;
 
         if (event_pid_changed(s->event))
                 return -ECHILD;
 


@@ -1177,7 +1273,6 @@ int sd_event_source_set_time_accuracy(sd_event_source *s, uint64_t usec) {
         if (s->time.accuracy == usec)
                 return 0;
 
         if (s->time.accuracy == usec)
                 return 0;
 

-

         s->time.accuracy = usec;
 
         if (s->type == SOURCE_REALTIME)
         s->time.accuracy = usec;
 
         if (s->type == SOURCE_REALTIME)


@@ -1205,10 +1300,10 @@ int sd_event_source_get_time_accuracy(sd_event_source *s, uint64_t *usec) {
 int sd_event_source_set_prepare(sd_event_source *s, sd_prepare_handler_t callback) {
         int r;
 
 int sd_event_source_set_prepare(sd_event_source *s, sd_prepare_handler_t callback) {
         int r;
 

-        if (!s)
-                return -EINVAL;
-        if (event_pid_changed(s->event))
-                return -ECHILD;
+        assert_return(s, -EINVAL);
+        assert_return(s->type != SOURCE_QUIT, -EDOM);
+        assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
+        assert_return(!event_pid_changed(s->event), -ECHILD);

 
         if (s->prepare == callback)
                 return 0;
 
         if (s->prepare == callback)
                 return 0;


@@ -1235,8 +1330,7 @@ int sd_event_source_set_prepare(sd_event_source *s, sd_prepare_handler_t callbac
 }
 
 void* sd_event_source_get_userdata(sd_event_source *s) {
 }
 
 void* sd_event_source_get_userdata(sd_event_source *s) {

-        if (!s)
-                return NULL;
+        assert_return(s, NULL);

 
         return s->userdata;
 }
 
         return s->userdata;
 }


@@ -1361,6 +1455,7 @@ static int flush_timer(sd_event *e, int fd, uint32_t events) {
         ssize_t ss;
 
         assert(e);
         ssize_t ss;
 
         assert(e);

+        assert(fd >= 0);

 
         if (events != EPOLLIN)
                 return -EIO;
 
         if (events != EPOLLIN)
                 return -EIO;


@@ -1457,6 +1552,8 @@ static int process_signal(sd_event *e, uint32_t events) {
         ssize_t ss;
         int r;
 
         ssize_t ss;
         int r;
 

+        assert(e);
+

         if (events != EPOLLIN)
                 return -EIO;
 
         if (events != EPOLLIN)
                 return -EIO;
 


@@ -1502,11 +1599,13 @@ static int source_dispatch(sd_event_source *s) {
         int r;
 
         assert(s);
         int r;
 
         assert(s);

-        assert(s->pending);
+        assert(s->pending || s->type == SOURCE_QUIT);

 
 

-        r = source_set_pending(s, false);
-        if (r < 0)
-                return r;
+        if (s->type != SOURCE_DEFER && s->type != SOURCE_QUIT) {
+                r = source_set_pending(s, false);
+                if (r < 0)
+                        return r;
+        }

 
         if (s->mute == SD_EVENT_ONESHOT) {
                 r = sd_event_source_set_mute(s, SD_EVENT_MUTED);
 
         if (s->mute == SD_EVENT_ONESHOT) {
                 r = sd_event_source_set_mute(s, SD_EVENT_MUTED);


@@ -1539,6 +1638,10 @@ static int source_dispatch(sd_event_source *s) {
         case SOURCE_DEFER:
                 r = s->defer.callback(s, s->userdata);
                 break;
         case SOURCE_DEFER:
                 r = s->defer.callback(s, s->userdata);
                 break;

+
+        case SOURCE_QUIT:
+                r = s->quit.callback(s, s->userdata);
+                break;

         }
 
         return r;
         }
 
         return r;


@@ -1571,9 +1674,35 @@ static int event_prepare(sd_event *e) {
         return 0;
 }
 
         return 0;
 }
 

+static int dispatch_quit(sd_event *e) {
+        sd_event_source *p;
+        int r;
+
+        assert(e);
+
+        p = prioq_peek(e->quit);
+        if (!p || p->mute == SD_EVENT_MUTED) {
+                e->state = SD_EVENT_FINISHED;
+                return 0;
+        }
+
+        sd_event_ref(e);
+        e->iteration++;
+        e->state = SD_EVENT_QUITTING;
+
+        r = source_dispatch(p);
+
+        e->state = SD_EVENT_PASSIVE;
+        sd_event_unref(e);
+
+        return r;
+}
+

 static sd_event_source* event_next_pending(sd_event *e) {
         sd_event_source *p;
 
 static sd_event_source* event_next_pending(sd_event *e) {
         sd_event_source *p;
 

+        assert(e);
+

         p = prioq_peek(e->pending);
         if (!p)
                 return NULL;
         p = prioq_peek(e->pending);
         if (!p)
                 return NULL;


@@ -1590,18 +1719,21 @@ int sd_event_run(sd_event *e, uint64_t timeout) {
         int r, i, m;
         dual_timestamp n;
 
         int r, i, m;
         dual_timestamp n;
 

-        if (!e)
-                return -EINVAL;
-        if (e->quit)
-                return -ESTALE;
-        if (event_pid_changed(e))
-                return -ECHILD;
+        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);
+
+        if (e->quit_requested)
+                return dispatch_quit(e);

 
 

+        sd_event_ref(e);

         e->iteration++;
         e->iteration++;

+        e->state = SD_EVENT_RUNNING;

 
         r = event_prepare(e);
         if (r < 0)
 
         r = event_prepare(e);
         if (r < 0)

-                return r;
+                goto finish;

 
         if (event_next_pending(e) || e->need_process_child)
                 timeout = 0;
 
         if (event_next_pending(e) || e->need_process_child)
                 timeout = 0;


@@ -1609,17 +1741,19 @@ int sd_event_run(sd_event *e, uint64_t timeout) {
         if (timeout > 0) {
                 r = event_arm_timer(e, e->monotonic_fd, e->monotonic_earliest, e->monotonic_latest, &e->monotonic_next);
                 if (r < 0)
         if (timeout > 0) {
                 r = event_arm_timer(e, e->monotonic_fd, e->monotonic_earliest, e->monotonic_latest, &e->monotonic_next);
                 if (r < 0)

-                        return r;
+                        goto finish;

 
                 r = event_arm_timer(e, e->realtime_fd, e->realtime_earliest, e->realtime_latest, &e->realtime_next);
                 if (r < 0)
 
                 r = event_arm_timer(e, e->realtime_fd, e->realtime_earliest, e->realtime_latest, &e->realtime_next);
                 if (r < 0)

-                        return r;
+                        goto finish;

         }
 
         m = epoll_wait(e->epoll_fd, ev_queue, EPOLL_QUEUE_MAX,
                        timeout == (uint64_t) -1 ? -1 : (int) ((timeout + USEC_PER_MSEC - 1) / USEC_PER_MSEC));
         }
 
         m = epoll_wait(e->epoll_fd, ev_queue, EPOLL_QUEUE_MAX,
                        timeout == (uint64_t) -1 ? -1 : (int) ((timeout + USEC_PER_MSEC - 1) / USEC_PER_MSEC));

-        if (m < 0)
-                return m;
+        if (m < 0) {
+                r = m;
+                goto finish;
+        }

 
         dual_timestamp_get(&n);
 
 
         dual_timestamp_get(&n);
 


@@ -1635,62 +1769,79 @@ int sd_event_run(sd_event *e, uint64_t timeout) {
                         r = process_io(e, ev_queue[i].data.ptr, ev_queue[i].events);
 
                 if (r < 0)
                         r = process_io(e, ev_queue[i].data.ptr, ev_queue[i].events);
 
                 if (r < 0)

-                        return r;
+                        goto finish;

         }
 
         r = process_timer(e, n.monotonic, e->monotonic_earliest, e->monotonic_latest);
         if (r < 0)
         }
 
         r = process_timer(e, n.monotonic, e->monotonic_earliest, e->monotonic_latest);
         if (r < 0)

-                return r;
+                goto finish;

 
         r = process_timer(e, n.realtime, e->realtime_earliest, e->realtime_latest);
         if (r < 0)
 
         r = process_timer(e, n.realtime, e->realtime_earliest, e->realtime_latest);
         if (r < 0)

-                return r;
+                goto finish;

 
         if (e->need_process_child) {
                 r = process_child(e);
                 if (r < 0)
 
         if (e->need_process_child) {
                 r = process_child(e);
                 if (r < 0)

-                        return r;
+                        goto finish;

         }
 
         p = event_next_pending(e);
         }
 
         p = event_next_pending(e);

-        if (!p)
-                return 0;
+        if (!p) {
+                r = 0;
+                goto finish;
+        }
+
+        r = source_dispatch(p);

 
 

-        return source_dispatch(p);
+finish:
+        e->state = SD_EVENT_PASSIVE;
+        sd_event_unref(e);
+
+        return r;

 }
 
 int sd_event_loop(sd_event *e) {
         int r;
 
 }
 
 int sd_event_loop(sd_event *e) {
         int r;
 

-        if (!e)
-                return -EINVAL;
-        if (event_pid_changed(e))
-                return -ECHILD;
+        assert_return(e, -EINVAL);
+        assert_return(!event_pid_changed(e), -ECHILD);
+        assert_return(e->state == SD_EVENT_PASSIVE, -EBUSY);
+
+        sd_event_ref(e);

 
 

-        while (!e->quit) {
+        while (e->state != SD_EVENT_FINISHED) {

                 r = sd_event_run(e, (uint64_t) -1);
                 if (r < 0)
                 r = sd_event_run(e, (uint64_t) -1);
                 if (r < 0)

-                        return r;
+                        goto finish;

         }
 
         }
 

-        return 0;
+        r = 0;
+
+finish:
+        sd_event_unref(e);
+        return r;

 }
 
 }
 

-int sd_event_quit(sd_event *e) {
-        if (!e)
-                return EINVAL;
-        if (event_pid_changed(e))
-                return -ECHILD;
+int sd_event_get_state(sd_event *e) {
+        assert_return(e, -EINVAL);
+        assert_return(!event_pid_changed(e), -ECHILD);
+
+        return e->state;
+}
+
+int sd_event_get_quit(sd_event *e) {
+        assert_return(e, -EINVAL);
+        assert_return(!event_pid_changed(e), -ECHILD);

 
 

-        return e->quit;
+        return e->quit_requested;

 }
 
 int sd_event_request_quit(sd_event *e) {
 }
 
 int sd_event_request_quit(sd_event *e) {

-        if (!e)
-                return -EINVAL;
-        if (event_pid_changed(e))
-                return -ECHILD;
+        assert_return(e, -EINVAL);
+        assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
+        assert_return(!event_pid_changed(e), -ECHILD);

 
 

-        e->quit = true;
+        e->quit_requested = true;

         return 0;
 }
         return 0;
 }

diff --git a/src/libsystemd-bus/test-event.c b/src/libsystemd-bus/test-event.c
index acb5cee3671c22fc0e4ce9d8a34b286933cc87de..7004f61b03f73169ae8a476bb5eb88c38f1ea9f3 100644 (file)
--- a/src/libsystemd-bus/test-event.c
+++ b/src/libsystemd-bus/test-event.c
@@ -136,9 +136,19 @@ static int time_handler(sd_event_source *s, uint64_t usec, void *userdata) {
         return 2;
 }
 
         return 2;
 }
 

+static bool got_quit = false;
+
+static int quit_handler(sd_event_source *s, void *userdata) {
+        log_info("got quit handler on %c", PTR_TO_INT(userdata));
+
+        got_quit = true;
+
+        return 3;
+}
+

 int main(int argc, char *argv[]) {
         sd_event *e = NULL;
 int main(int argc, char *argv[]) {
         sd_event *e = NULL;

-        sd_event_source *x = NULL, *y = NULL, *z = NULL;
+        sd_event_source *x = NULL, *y = NULL, *z = NULL, *q = NULL;

         static const char ch = 'x';
         int a[2] = { -1, -1 }, b[2] = { -1, -1};
 
         static const char ch = 'x';
         int a[2] = { -1, -1 }, b[2] = { -1, -1};
 


@@ -152,6 +162,7 @@ int main(int argc, char *argv[]) {
         assert_se(sd_event_add_io(e, a[0], EPOLLIN, io_handler, INT_TO_PTR('a'), &x) >= 0);
         assert_se(sd_event_add_io(e, b[0], EPOLLIN, io_handler, INT_TO_PTR('b'), &y) >= 0);
         assert_se(sd_event_add_monotonic(e, 0, 0, time_handler, INT_TO_PTR('c'), &z) >= 0);
         assert_se(sd_event_add_io(e, a[0], EPOLLIN, io_handler, INT_TO_PTR('a'), &x) >= 0);
         assert_se(sd_event_add_io(e, b[0], EPOLLIN, io_handler, INT_TO_PTR('b'), &y) >= 0);
         assert_se(sd_event_add_monotonic(e, 0, 0, time_handler, INT_TO_PTR('c'), &z) >= 0);

+        assert_se(sd_event_add_quit(e, quit_handler, INT_TO_PTR('g'), &q) >= 0);

 
         assert_se(sd_event_source_set_priority(x, 99) >= 0);
         assert_se(sd_event_source_set_mute(y, SD_EVENT_ONESHOT) >= 0);
 
         assert_se(sd_event_source_set_priority(x, 99) >= 0);
         assert_se(sd_event_source_set_mute(y, SD_EVENT_ONESHOT) >= 0);


@@ -187,6 +198,7 @@ int main(int argc, char *argv[]) {
         assert_se(sd_event_loop(e) >= 0);
 
         sd_event_source_unref(z);
         assert_se(sd_event_loop(e) >= 0);
 
         sd_event_source_unref(z);

+        sd_event_source_unref(q);

 
         sd_event_unref(e);
 
 
         sd_event_unref(e);
 

diff --git a/src/systemd/sd-event.h b/src/systemd/sd-event.h
index 8908c8454d2af14332d3ba6c71442b1bdde0a22b..3d0b8204ff577dc0f7c13e1d218c887a1ecef938 100644 (file)
--- a/src/systemd/sd-event.h
+++ b/src/systemd/sd-event.h
@@ -36,19 +36,24 @@
   - Automatically tries to coalesce timer events system-wide
   - Handles signals and child PIDs
 
   - Automatically tries to coalesce timer events system-wide
   - Handles signals and child PIDs
 

-  TODO:
-
-  - quit hooks
+  TODO: rename mute to enable?

 */
 
 typedef struct sd_event sd_event;
 typedef struct sd_event_source sd_event_source;
 
 */
 
 typedef struct sd_event sd_event;
 typedef struct sd_event_source sd_event_source;
 

-typedef enum sd_event_mute {
+enum {

         SD_EVENT_MUTED = 0,
         SD_EVENT_UNMUTED = 1,
         SD_EVENT_ONESHOT = -1
         SD_EVENT_MUTED = 0,
         SD_EVENT_UNMUTED = 1,
         SD_EVENT_ONESHOT = -1

-} sd_event_mute_t;
+};
+
+enum {
+        SD_EVENT_PASSIVE,
+        SD_EVENT_RUNNING,
+        SD_EVENT_QUITTING,
+        SD_EVENT_FINISHED
+};

 
 typedef int (*sd_io_handler_t)(sd_event_source *s, int fd, uint32_t revents, void *userdata);
 typedef int (*sd_time_handler_t)(sd_event_source *s, uint64_t usec, void *userdata);
 
 typedef int (*sd_io_handler_t)(sd_event_source *s, int fd, uint32_t revents, void *userdata);
 typedef int (*sd_time_handler_t)(sd_event_source *s, uint64_t usec, void *userdata);


@@ -56,6 +61,7 @@ typedef int (*sd_signal_handler_t)(sd_event_source *s, const struct signalfd_sig
 typedef int (*sd_child_handler_t)(sd_event_source *s, const siginfo_t *si, void *userdata);
 typedef int (*sd_defer_handler_t)(sd_event_source *s, void *userdata);
 typedef int (*sd_prepare_handler_t)(sd_event_source *s, void *userdata);
 typedef int (*sd_child_handler_t)(sd_event_source *s, const siginfo_t *si, void *userdata);
 typedef int (*sd_defer_handler_t)(sd_event_source *s, void *userdata);
 typedef int (*sd_prepare_handler_t)(sd_event_source *s, void *userdata);

+typedef int (*sd_quit_handler_t)(sd_event_source *s, void *userdata);

 
 int sd_event_new(sd_event **e);
 sd_event* sd_event_ref(sd_event *e);
 
 int sd_event_new(sd_event **e);
 sd_event* sd_event_ref(sd_event *e);


@@ -67,11 +73,13 @@ int sd_event_add_realtime(sd_event *e, uint64_t usec, uint64_t accuracy, sd_time
 int sd_event_add_signal(sd_event *e, int sig, sd_signal_handler_t callback, void *userdata, sd_event_source **s);
 int sd_event_add_child(sd_event *e, pid_t pid, int options, sd_child_handler_t callback, void *userdata, sd_event_source **s);
 int sd_event_add_defer(sd_event *e, sd_defer_handler_t callback, void *userdata, sd_event_source **s);
 int sd_event_add_signal(sd_event *e, int sig, sd_signal_handler_t callback, void *userdata, sd_event_source **s);
 int sd_event_add_child(sd_event *e, pid_t pid, int options, sd_child_handler_t callback, void *userdata, sd_event_source **s);
 int sd_event_add_defer(sd_event *e, sd_defer_handler_t callback, void *userdata, sd_event_source **s);

+int sd_event_add_quit(sd_event *e, sd_quit_handler_t callback, void *userdata, sd_event_source **s);

 
 int sd_event_run(sd_event *e, uint64_t timeout);
 int sd_event_loop(sd_event *e);
 
 
 int sd_event_run(sd_event *e, uint64_t timeout);
 int sd_event_loop(sd_event *e);
 

-int sd_event_quit(sd_event *e);
+int sd_event_get_state(sd_event *e);
+int sd_event_get_quit(sd_event *e);

 int sd_event_request_quit(sd_event *e);
 
 sd_event *sd_event_get(sd_event_source *s);
 int sd_event_request_quit(sd_event *e);
 
 sd_event *sd_event_get(sd_event_source *s);


@@ -87,8 +95,8 @@ int sd_event_source_get_io_revents(sd_event_source *s, uint32_t* revents);
 int sd_event_source_get_signal(sd_event_source *s);
 int sd_event_source_get_priority(sd_event_source *s, int *priority);
 int sd_event_source_set_priority(sd_event_source *s, int priority);
 int sd_event_source_get_signal(sd_event_source *s);
 int sd_event_source_get_priority(sd_event_source *s, int *priority);
 int sd_event_source_set_priority(sd_event_source *s, int priority);

-int sd_event_source_get_mute(sd_event_source *s, sd_event_mute_t *m);
-int sd_event_source_set_mute(sd_event_source *s, sd_event_mute_t m);
+int sd_event_source_get_mute(sd_event_source *s, int *m);
+int sd_event_source_set_mute(sd_event_source *s, int m);

 int sd_event_source_get_time(sd_event_source *s, uint64_t *usec);
 int sd_event_source_set_time(sd_event_source *s, uint64_t usec);
 int sd_event_source_set_time_accuracy(sd_event_source *s, uint64_t usec);
 int sd_event_source_get_time(sd_event_source *s, uint64_t *usec);
 int sd_event_source_set_time(sd_event_source *s, uint64_t usec);
 int sd_event_source_set_time_accuracy(sd_event_source *s, uint64_t usec);