X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Flibsystemd-bus%2Fsd-event.c;h=0317088af31b73b59d84345968df5518f206faf0;hp=6af52ecb3cdf45325d91e74d91c0a4801397dbc9;hb=f98a58fe894d34e4d9675757180f34a8523c936e;hpb=12179984a38fe74581333fbcdc11c822d81f505f diff --git a/src/libsystemd-bus/sd-event.c b/src/libsystemd-bus/sd-event.c index 6af52ecb3..0317088af 100644 --- a/src/libsystemd-bus/sd-event.c +++ b/src/libsystemd-bus/sd-event.c @@ -34,7 +34,7 @@ #include "sd-event.h" -#define EPOLL_QUEUE_MAX 64 +#define EPOLL_QUEUE_MAX 512U #define DEFAULT_ACCURACY_USEC (250 * USEC_PER_MSEC) typedef enum EventSourceType { @@ -151,6 +151,8 @@ struct sd_event { sd_event **default_event_ptr; usec_t watchdog_last, watchdog_period; + + unsigned n_sources; }; static int pending_prioq_compare(const void *a, const void *b) { @@ -316,6 +318,7 @@ static int exit_prioq_compare(const void *a, const void *b) { static void event_free(sd_event *e) { assert(e); + assert(e->n_sources == 0); if (e->default_event_ptr) *(e->default_event_ptr) = NULL; @@ -470,6 +473,8 @@ static void source_free(sd_event_source *s) { assert(s); if (s->event) { + assert(s->event->n_sources > 0); + switch (s->type) { case SOURCE_IO: @@ -521,6 +526,9 @@ static void source_free(sd_event_source *s) { case SOURCE_EXIT: prioq_remove(s->event->exit, s, &s->exit.prioq_index); break; + + case SOURCE_WATCHDOG: + assert_not_reached("Wut? I shouldn't exist."); } if (s->pending) @@ -529,6 +537,7 @@ static void source_free(sd_event_source *s) { if (s->prepare) prioq_remove(s->event->prepare, s, &s->prepare_index); + s->event->n_sources--; sd_event_unref(s->event); } @@ -582,6 +591,8 @@ static sd_event_source *source_new(sd_event *e, EventSourceType type) { s->type = type; s->pending_index = s->prepare_index = PRIOQ_IDX_NULL; + e->n_sources ++; + return s; } @@ -1036,6 +1047,42 @@ _public_ int sd_event_source_get_io_fd(sd_event_source *s) { return s->io.fd; } +_public_ int sd_event_source_set_io_fd(sd_event_source *s, int fd) { + int r; + + assert_return(s, -EINVAL); + assert_return(fd >= 0, -EINVAL); + assert_return(s->type == SOURCE_IO, -EDOM); + assert_return(!event_pid_changed(s->event), -ECHILD); + + if (s->io.fd == fd) + return 0; + + if (s->enabled == SD_EVENT_OFF) { + s->io.fd = fd; + s->io.registered = false; + } else { + int saved_fd; + + saved_fd = s->io.fd; + assert(s->io.registered); + + s->io.fd = fd; + s->io.registered = false; + + r = source_io_register(s, s->enabled, s->io.events); + if (r < 0) { + s->io.fd = saved_fd; + s->io.registered = true; + return r; + } + + epoll_ctl(s->event->epoll_fd, EPOLL_CTL_DEL, saved_fd, NULL); + } + + return 0; +} + _public_ int sd_event_source_get_io_events(sd_event_source *s, uint32_t* events) { assert_return(s, -EINVAL); assert_return(events, -EINVAL); @@ -1192,6 +1239,9 @@ _public_ int sd_event_source_set_enabled(sd_event_source *s, int m) { case SOURCE_DEFER: s->enabled = m; break; + + case SOURCE_WATCHDOG: + assert_not_reached("Wut? I shouldn't exist."); } } else { @@ -1247,6 +1297,9 @@ _public_ int sd_event_source_set_enabled(sd_event_source *s, int m) { case SOURCE_DEFER: s->enabled = m; break; + + case SOURCE_WATCHDOG: + assert_not_reached("Wut? I shouldn't exist."); } } @@ -1371,6 +1424,17 @@ _public_ void* sd_event_source_get_userdata(sd_event_source *s) { return s->userdata; } +_public_ void *sd_event_source_set_userdata(sd_event_source *s, void *userdata) { + void *ret; + + assert_return(s, NULL); + + ret = s->userdata; + s->userdata = userdata; + + return ret; +} + static usec_t sleep_between(sd_event *e, usec_t a, usec_t b) { usec_t c; assert(e); @@ -1505,12 +1569,21 @@ static int event_arm_timer( return 0; } -static int process_io(sd_event *e, sd_event_source *s, uint32_t events) { +static int process_io(sd_event *e, sd_event_source *s, uint32_t revents) { assert(e); assert(s); assert(s->type == SOURCE_IO); - s->io.revents = events; + /* If the event source was already pending, we just OR in the + * new revents, otherwise we reset the value. The ORing is + * necessary to handle EPOLLONESHOT events properly where + * readability might happen independently of writability, and + * we need to keep track of both */ + + if (s->pending) + s->io.revents |= revents; + else + s->io.revents = revents; return source_set_pending(s, true); } @@ -1532,7 +1605,7 @@ static int flush_timer(sd_event *e, int fd, uint32_t events, usec_t *next) { return -errno; } - if (ss != sizeof(x)) + if (_unlikely_(ss != sizeof(x))) return -EIO; if (next) @@ -1660,7 +1733,7 @@ static int process_signal(sd_event *e, uint32_t events) { return -errno; } - if (ss != sizeof(si)) + if (_unlikely_(ss != sizeof(si))) return -EIO; read_one = true; @@ -1746,6 +1819,9 @@ static int source_dispatch(sd_event_source *s) { case SOURCE_EXIT: r = s->exit.callback(s, s->userdata); break; + + case SOURCE_WATCHDOG: + assert_not_reached("Wut? I shouldn't exist."); } s->dispatching = false; @@ -1873,7 +1949,8 @@ static int process_watchdog(sd_event *e) { } _public_ int sd_event_run(sd_event *e, uint64_t timeout) { - struct epoll_event ev_queue[EPOLL_QUEUE_MAX]; + struct epoll_event *ev_queue; + unsigned ev_queue_max; sd_event_source *p; int r, i, m; @@ -1903,11 +1980,13 @@ _public_ int sd_event_run(sd_event *e, uint64_t timeout) { if (event_next_pending(e) || e->need_process_child) timeout = 0; + ev_queue_max = CLAMP(e->n_sources, 1U, EPOLL_QUEUE_MAX); + ev_queue = newa(struct epoll_event, ev_queue_max); - m = epoll_wait(e->epoll_fd, ev_queue, EPOLL_QUEUE_MAX, + 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 ? 0 : -errno; + r = errno == EAGAIN || errno == EINTR ? 1 : -errno; goto finish; } @@ -1950,7 +2029,7 @@ _public_ int sd_event_run(sd_event *e, uint64_t timeout) { p = event_next_pending(e); if (!p) { - r = 0; + r = 1; goto finish; } @@ -2037,7 +2116,7 @@ _public_ int sd_event_get_now_monotonic(sd_event *e, uint64_t *usec) { _public_ int sd_event_default(sd_event **ret) { - static __thread sd_event *default_event = NULL; + static thread_local sd_event *default_event = NULL; sd_event *e; int r; @@ -2078,23 +2157,17 @@ _public_ int sd_event_set_watchdog(sd_event *e, int b) { int r; assert_return(e, -EINVAL); + assert_return(!event_pid_changed(e), -ECHILD); if (e->watchdog == !!b) return e->watchdog; if (b) { struct epoll_event ev = {}; - const char *env; - env = getenv("WATCHDOG_USEC"); - if (!env) - return false; - - r = safe_atou64(env, &e->watchdog_period); - if (r < 0) + r = sd_watchdog_enabled(false, &e->watchdog_period); + if (r <= 0) return r; - if (e->watchdog_period <= 0) - return -EIO; /* Issue first ping immediately */ sd_notify(false, "WATCHDOG=1"); @@ -2133,3 +2206,10 @@ fail: e->watchdog_fd = -1; return r; } + +_public_ int sd_event_get_watchdog(sd_event *e) { + assert_return(e, -EINVAL); + assert_return(!event_pid_changed(e), -ECHILD); + + return e->watchdog; +}