bus: introduce concept of a "default" event loop per-thread and make use of it everywhere

Try to emphasize a bit that there should be a mapping between event
loops and threads, hence introduce a logic that there's one "default"
event loop for each thread, that can be queried via
"sd_event_default()".

src/hostname/hostnamed.c

@@ -643,7 +643,7 @@ int main(int argc, char *argv[]) {
                 goto finish;
         }
 
-        r = sd_event_new(&event);
+        r = sd_event_default(&event);
         if (r < 0) {
                 log_error("Failed to allocate event loop: %s", strerror(-r));
                 goto finish;

src/libsystemd-bus/libsystemd-bus.sym

@@ -197,6 +197,8 @@ global:
         sd_memfd_set_size;
 
         /* sd-event functions */
+        sd_event_default;
+
         sd_event_new;
         sd_event_ref;
         sd_event_unref;
@@ -213,15 +215,17 @@ global:
         sd_event_loop;
 
         sd_event_get_state;
+        sd_event_get_tid;
         sd_event_get_quit;
         sd_event_request_quit;
         sd_event_get_now_realtime;
         sd_event_get_now_monotonic;
-        sd_event_get;
 
         sd_event_source_ref;
         sd_event_source_unref;
 
+        sd_event_get;
+
         sd_event_source_set_prepare;
         sd_event_source_get_pending;
         sd_event_source_get_priority;

src/libsystemd-bus/sd-event.c

@@ -23,12 +23,13 @@
 #include <sys/timerfd.h>
 #include <sys/wait.h>
 
+#include "sd-id128.h"
 #include "macro.h"
 #include "prioq.h"
 #include "hashmap.h"
 #include "util.h"
 #include "time-util.h"
-#include "sd-id128.h"
+#include "missing.h"
 
 #include "sd-event.h"
 
@@ -138,6 +139,9 @@ struct sd_event {
 
         bool quit_requested:1;
         bool need_process_child:1;
+
+        pid_t tid;
+        sd_event **default_event_ptr;
 };
 
 static int pending_prioq_compare(const void *a, const void *b) {
@@ -304,6 +308,9 @@ static int quit_prioq_compare(const void *a, const void *b) {
 static void event_free(sd_event *e) {
         assert(e);
 
+        if (e->default_event_ptr)
+                *(e->default_event_ptr) = NULL;
+
         if (e->epoll_fd >= 0)
                 close_nointr_nofail(e->epoll_fd);
 
@@ -1869,3 +1876,38 @@ _public_ int sd_event_get_now_monotonic(sd_event *e, uint64_t *usec) {
         *usec = e->timestamp.monotonic;
         return 0;
 }
+
+_public_ int sd_event_default(sd_event **ret) {
+
+        static __thread sd_event *default_event = NULL;
+        sd_event *e;
+        int r;
+
+        if (!ret)
+                return !!default_event;
+
+        if (default_event) {
+                *ret = sd_event_ref(default_event);
+                return 0;
+        }
+
+        r = sd_event_new(&e);
+        if (r < 0)
+                return r;
+
+        e->default_event_ptr = &default_event;
+        e->tid = gettid();
+        default_event = e;
+
+        *ret = e;
+        return 1;
+}
+
+_public_ int sd_event_get_tid(sd_event *e, pid_t *tid) {
+        assert_return(e, -EINVAL);
+        assert_return(tid, -EINVAL);
+        assert_return(e->tid != 0, -ENXIO);
+
+        *tid = e->tid;
+        return 0;
+}

src/libsystemd-bus/test-event.c

@@ -163,7 +163,7 @@ int main(int argc, char *argv[]) {
         assert_se(pipe(b) >= 0);
         assert_se(pipe(d) >= 0);
 
-        assert_se(sd_event_new(&e) >= 0);
+        assert_se(sd_event_default(&e) >= 0);
 
         got_a = false, got_b = false, got_c = false, got_d = 0;
 

src/locale/localed.c

@@ -1115,7 +1115,7 @@ int main(int argc, char *argv[]) {
                 goto finish;
         }
 
-        r = sd_event_new(&event);
+        r = sd_event_default(&event);
         if (r < 0) {
                 log_error("Failed to allocate event loop: %s", strerror(-r));
                 goto finish;

src/login/logind.c

@@ -90,7 +90,7 @@ Manager *manager_new(void) {
                 return NULL;
         }
 
-        r = sd_event_new(&m->event);
+        r = sd_event_default(&m->event);
         if (r < 0) {
                 manager_free(m);
                 return NULL;

src/machine/machined.c

@@ -53,7 +53,7 @@ Manager *manager_new(void) {
                 return NULL;
         }
 
-        r = sd_event_new(&m->event);
+        r = sd_event_default(&m->event);
         if (r < 0) {
                 manager_free(m);
                 return NULL;

src/network/networkd-manager.c

@@ -31,7 +31,7 @@ int manager_new(Manager **ret) {
         if (!m)
                 return -ENOMEM;
 
-        r = sd_event_new(&m->event);
+        r = sd_event_default(&m->event);
         if (r < 0)
                 return r;
 

src/socket-proxy/socket-proxyd.c

@@ -626,7 +626,7 @@ int main(int argc, char *argv[]) {
         if (r <= 0)
                 goto finish;
 
-        r = sd_event_new(&event);
+        r = sd_event_default(&event);
         if (r < 0) {
                 log_error("Failed to allocate event loop: %s", strerror(-r));
                 goto finish;

src/systemd/sd-event.h

@@ -72,6 +72,8 @@ 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_default(sd_event **e);
+
 int sd_event_new(sd_event **e);
 sd_event* sd_event_ref(sd_event *e);
 sd_event* sd_event_unref(sd_event *e);
@@ -88,15 +90,17 @@ int sd_event_run(sd_event *e, uint64_t timeout);
 int sd_event_loop(sd_event *e);
 
 int sd_event_get_state(sd_event *e);
+int sd_event_get_tid(sd_event *e, pid_t *tid);
 int sd_event_get_quit(sd_event *e);
 int sd_event_request_quit(sd_event *e);
 int sd_event_get_now_realtime(sd_event *e, uint64_t *usec);
 int sd_event_get_now_monotonic(sd_event *e, uint64_t *usec);
-sd_event *sd_event_get(sd_event_source *s);
 
 sd_event_source* sd_event_source_ref(sd_event_source *s);
 sd_event_source* sd_event_source_unref(sd_event_source *s);
 
+sd_event *sd_event_get(sd_event_source *s);
+
 int sd_event_source_set_prepare(sd_event_source *s, sd_prepare_handler_t callback);
 int sd_event_source_get_pending(sd_event_source *s);
 int sd_event_source_get_priority(sd_event_source *s, int *priority);

src/timedate/timedated.c

@@ -854,7 +854,7 @@ int main(int argc, char *argv[]) {
                 goto finish;
         }
 
-        r = sd_event_new(&event);
+        r = sd_event_default(&event);
         if (r < 0) {
                 log_error("Failed to allocate event loop: %s", strerror(-r));
                 goto finish;