summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
d5e4ec5)
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()".
- 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;
if (r < 0) {
log_error("Failed to allocate event loop: %s", strerror(-r));
goto finish;
sd_memfd_set_size;
/* sd-event functions */
sd_memfd_set_size;
/* sd-event functions */
sd_event_new;
sd_event_ref;
sd_event_unref;
sd_event_new;
sd_event_ref;
sd_event_unref;
sd_event_loop;
sd_event_get_state;
sd_event_loop;
sd_event_get_state;
sd_event_get_quit;
sd_event_request_quit;
sd_event_get_now_realtime;
sd_event_get_now_monotonic;
sd_event_get_quit;
sd_event_request_quit;
sd_event_get_now_realtime;
sd_event_get_now_monotonic;
sd_event_source_ref;
sd_event_source_unref;
sd_event_source_ref;
sd_event_source_unref;
sd_event_source_set_prepare;
sd_event_source_get_pending;
sd_event_source_get_priority;
sd_event_source_set_prepare;
sd_event_source_get_pending;
sd_event_source_get_priority;
#include <sys/timerfd.h>
#include <sys/wait.h>
#include <sys/timerfd.h>
#include <sys/wait.h>
#include "macro.h"
#include "prioq.h"
#include "hashmap.h"
#include "util.h"
#include "time-util.h"
#include "macro.h"
#include "prioq.h"
#include "hashmap.h"
#include "util.h"
#include "time-util.h"
bool quit_requested:1;
bool need_process_child:1;
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) {
};
static int pending_prioq_compare(const void *a, const void *b) {
static void event_free(sd_event *e) {
assert(e);
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);
if (e->epoll_fd >= 0)
close_nointr_nofail(e->epoll_fd);
*usec = e->timestamp.monotonic;
return 0;
}
*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;
+}
assert_se(pipe(b) >= 0);
assert_se(pipe(d) >= 0);
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;
got_a = false, got_b = false, got_c = false, got_d = 0;
- 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;
if (r < 0) {
log_error("Failed to allocate event loop: %s", strerror(-r));
goto finish;
- r = sd_event_new(&m->event);
+ r = sd_event_default(&m->event);
if (r < 0) {
manager_free(m);
return NULL;
if (r < 0) {
manager_free(m);
return NULL;
- r = sd_event_new(&m->event);
+ r = sd_event_default(&m->event);
if (r < 0) {
manager_free(m);
return NULL;
if (r < 0) {
manager_free(m);
return NULL;
- r = sd_event_new(&m->event);
+ r = sd_event_default(&m->event);
- 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;
if (r < 0) {
log_error("Failed to allocate event loop: %s", strerror(-r));
goto finish;
typedef int (*sd_prepare_handler_t)(sd_event_source *s, void *userdata);
typedef int (*sd_quit_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);
int sd_event_new(sd_event **e);
sd_event* sd_event_ref(sd_event *e);
sd_event* sd_event_unref(sd_event *e);
int sd_event_loop(sd_event *e);
int sd_event_get_state(sd_event *e);
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);
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_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);
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);
- 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;
if (r < 0) {
log_error("Failed to allocate event loop: %s", strerror(-r));
goto finish;