summaryrefslogtreecommitdiffstats
path: root/tevent_epoll.c
diff options
context:
space:
mode:
Diffstat (limited to 'tevent_epoll.c')
-rw-r--r--tevent_epoll.c945
1 files changed, 945 insertions, 0 deletions
diff --git a/tevent_epoll.c b/tevent_epoll.c
new file mode 100644
index 0000000..e56bd02
--- /dev/null
+++ b/tevent_epoll.c
@@ -0,0 +1,945 @@
+/*
+ Unix SMB/CIFS implementation.
+
+ main select loop and event handling - epoll implementation
+
+ Copyright (C) Andrew Tridgell 2003-2005
+ Copyright (C) Stefan Metzmacher 2005-2013
+ Copyright (C) Jeremy Allison 2013
+
+ ** NOTE! The following LGPL license applies to the tevent
+ ** library. This does NOT imply that all of Samba is released
+ ** under the LGPL
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 3 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/select.h"
+#include "tevent.h"
+#include "tevent_internal.h"
+#include "tevent_util.h"
+
+struct epoll_event_context {
+ /* a pointer back to the generic event_context */
+ struct tevent_context *ev;
+
+ /* when using epoll this is the handle from epoll_create1(2) */
+ int epoll_fd;
+
+ pid_t pid;
+
+ bool panic_force_replay;
+ bool *panic_state;
+ bool (*panic_fallback)(struct tevent_context *ev, bool replay);
+};
+
+#define EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT (1<<0)
+#define EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR (1<<1)
+
+#ifdef TEST_PANIC_FALLBACK
+
+static int epoll_create1_panic_fallback(struct epoll_event_context *epoll_ev,
+ int flags)
+{
+ if (epoll_ev->panic_fallback == NULL) {
+ return epoll_create1(flags);
+ }
+
+ /* 50% of the time, fail... */
+ if ((random() % 2) == 0) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ return epoll_create1(flags);
+}
+
+static int epoll_ctl_panic_fallback(struct epoll_event_context *epoll_ev,
+ int epfd, int op, int fd,
+ struct epoll_event *event)
+{
+ if (epoll_ev->panic_fallback == NULL) {
+ return epoll_ctl(epfd, op, fd, event);
+ }
+
+ /* 50% of the time, fail... */
+ if ((random() % 2) == 0) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ return epoll_ctl(epfd, op, fd, event);
+}
+
+static int epoll_wait_panic_fallback(struct epoll_event_context *epoll_ev,
+ int epfd,
+ struct epoll_event *events,
+ int maxevents,
+ int timeout)
+{
+ if (epoll_ev->panic_fallback == NULL) {
+ return epoll_wait(epfd, events, maxevents, timeout);
+ }
+
+ /* 50% of the time, fail... */
+ if ((random() % 2) == 0) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ return epoll_wait(epfd, events, maxevents, timeout);
+}
+
+#define epoll_create1(_flags) \
+ epoll_create1_panic_fallback(epoll_ev, _flags)
+#define epoll_ctl(_epfd, _op, _fd, _event) \
+ epoll_ctl_panic_fallback(epoll_ev,_epfd, _op, _fd, _event)
+#define epoll_wait(_epfd, _events, _maxevents, _timeout) \
+ epoll_wait_panic_fallback(epoll_ev, _epfd, _events, _maxevents, _timeout)
+#endif
+
+/*
+ called to set the panic fallback function.
+*/
+_PRIVATE_ void tevent_epoll_set_panic_fallback(struct tevent_context *ev,
+ bool (*panic_fallback)(struct tevent_context *ev,
+ bool replay))
+{
+ struct epoll_event_context *epoll_ev =
+ talloc_get_type_abort(ev->additional_data,
+ struct epoll_event_context);
+
+ epoll_ev->panic_fallback = panic_fallback;
+}
+
+/*
+ called when a epoll call fails
+*/
+static void epoll_panic(struct epoll_event_context *epoll_ev,
+ const char *reason, bool replay)
+{
+ struct tevent_context *ev = epoll_ev->ev;
+ bool (*panic_fallback)(struct tevent_context *ev, bool replay);
+
+ panic_fallback = epoll_ev->panic_fallback;
+
+ if (epoll_ev->panic_state != NULL) {
+ *epoll_ev->panic_state = true;
+ }
+
+ if (epoll_ev->panic_force_replay) {
+ replay = true;
+ }
+
+ TALLOC_FREE(ev->additional_data);
+
+ if (panic_fallback == NULL) {
+ tevent_debug(ev, TEVENT_DEBUG_FATAL,
+ "%s (%s) replay[%u] - calling abort()\n",
+ reason, strerror(errno), (unsigned)replay);
+ abort();
+ }
+
+ tevent_debug(ev, TEVENT_DEBUG_ERROR,
+ "%s (%s) replay[%u] - calling panic_fallback\n",
+ reason, strerror(errno), (unsigned)replay);
+
+ if (!panic_fallback(ev, replay)) {
+ /* Fallback failed. */
+ tevent_debug(ev, TEVENT_DEBUG_FATAL,
+ "%s (%s) replay[%u] - calling abort()\n",
+ reason, strerror(errno), (unsigned)replay);
+ abort();
+ }
+}
+
+/*
+ map from TEVENT_FD_* to EPOLLIN/EPOLLOUT
+*/
+static uint32_t epoll_map_flags(uint16_t flags)
+{
+ uint32_t ret = 0;
+
+ /*
+ * we do not need to specify EPOLLERR | EPOLLHUP
+ * they are always reported.
+ */
+
+ if (flags & TEVENT_FD_READ) {
+ /*
+ * Note that EPOLLRDHUP always
+ * returns EPOLLIN in addition,
+ * so EPOLLRDHUP is not strictly needed,
+ * but we want to make it explicit.
+ */
+ ret |= EPOLLIN | EPOLLRDHUP;
+ }
+ if (flags & TEVENT_FD_WRITE) {
+ ret |= EPOLLOUT;
+ }
+ if (flags & TEVENT_FD_ERROR) {
+ ret |= EPOLLRDHUP;
+ }
+ return ret;
+}
+
+/*
+ free the epoll fd
+*/
+static int epoll_ctx_destructor(struct epoll_event_context *epoll_ev)
+{
+ close(epoll_ev->epoll_fd);
+ epoll_ev->epoll_fd = -1;
+ return 0;
+}
+
+/*
+ init the epoll fd
+*/
+static int epoll_init_ctx(struct epoll_event_context *epoll_ev)
+{
+ epoll_ev->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
+ if (epoll_ev->epoll_fd == -1) {
+ tevent_debug(epoll_ev->ev, TEVENT_DEBUG_FATAL,
+ "Failed to create epoll handle (%s).\n",
+ strerror(errno));
+ return -1;
+ }
+
+ epoll_ev->pid = tevent_cached_getpid();
+ talloc_set_destructor(epoll_ev, epoll_ctx_destructor);
+
+ return 0;
+}
+
+static void epoll_update_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde);
+
+/*
+ reopen the epoll handle when our pid changes
+ see http://junkcode.samba.org/ftp/unpacked/junkcode/epoll_fork.c for an
+ demonstration of why this is needed
+ */
+static void epoll_check_reopen(struct epoll_event_context *epoll_ev)
+{
+ struct tevent_fd *fde;
+ bool *caller_panic_state = epoll_ev->panic_state;
+ bool panic_triggered = false;
+ pid_t pid = tevent_cached_getpid();
+
+ if (epoll_ev->pid == pid) {
+ return;
+ }
+
+ close(epoll_ev->epoll_fd);
+ epoll_ev->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
+ if (epoll_ev->epoll_fd == -1) {
+ epoll_panic(epoll_ev, "epoll_create() failed", false);
+ return;
+ }
+
+ epoll_ev->pid = pid;
+ epoll_ev->panic_state = &panic_triggered;
+ for (fde=epoll_ev->ev->fd_events;fde;fde=fde->next) {
+ /*
+ * We leave the mpx mappings alive
+ * so that we'll just re-add events for
+ * the existing primary events in the loop
+ * below.
+ */
+ fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+ }
+ for (fde=epoll_ev->ev->fd_events;fde;fde=fde->next) {
+ epoll_update_event(epoll_ev, fde);
+
+ if (panic_triggered) {
+ if (caller_panic_state != NULL) {
+ *caller_panic_state = true;
+ }
+ return;
+ }
+ }
+ epoll_ev->panic_state = NULL;
+}
+
+/*
+ epoll cannot add the same file descriptor twice, once
+ with read, once with write which is allowed by the
+ tevent poll backend. Multiplex the existing fde, flag it
+ as such so we can search for the correct fde on
+ event triggering.
+*/
+
+static int epoll_add_multiplex_fd(struct epoll_event_context *epoll_ev,
+ struct tevent_fd *add_fde)
+{
+ struct tevent_fd *primary = NULL;
+ uint16_t effective_flags;
+ struct epoll_event event;
+ uint64_t clear_flags = 0;
+ uint64_t add_flags = 0;
+ int ret;
+
+ /*
+ * Check if there is another fde we can attach to
+ */
+ primary = tevent_common_fd_mpx_add(add_fde);
+ if (primary == NULL) {
+ /* the caller calls epoll_panic() */
+ return -1;
+ }
+
+ /*
+ * First propagate the HAS_EVENT flag from
+ * the primary to all others (mainly add_fde)
+ */
+ if (primary->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT) {
+ add_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+ tevent_common_fd_mpx_additional_flags(primary, 0, add_flags);
+ }
+
+ /*
+ * Update the mpx internals and check if
+ * there is an update needed.
+ */
+ primary = tevent_common_fd_mpx_update(primary);
+ if (primary == NULL) {
+ /*
+ * It seems the primary was already
+ * watching (at least) the same flags
+ * as add_fde, so we are done.
+ */
+ return 0;
+ }
+
+ /*
+ * Before me modify the low level epoll state,
+ * we clear HAS_EVENT on all fdes.
+ */
+ clear_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+ tevent_common_fd_mpx_additional_flags(primary, clear_flags, 0);
+
+ effective_flags = tevent_common_fd_mpx_flags(primary);
+
+ /*
+ * Modify the low level epoll state to reflect
+ * the effective flags we want to monitor.
+ */
+ ZERO_STRUCT(event);
+ event.events = epoll_map_flags(effective_flags);
+ event.data.ptr = primary;
+ ret = epoll_ctl(epoll_ev->epoll_fd,
+ EPOLL_CTL_MOD,
+ primary->fd,
+ &event);
+ if (ret != 0 && errno == EBADF) {
+ struct tevent_common_fd_buf pbuf = {};
+ TEVENT_DEBUG(epoll_ev->ev, TEVENT_DEBUG_ERROR,
+ "EPOLL_CTL_MOD EBADF for "
+ "%s - disabling\n",
+ tevent_common_fd_str(&pbuf, "primary", primary));
+ tevent_common_fd_mpx_disarm_all(primary);
+ return 0;
+ } else if (ret != 0) {
+ struct tevent_common_fd_buf pbuf = {};
+ TEVENT_DEBUG(epoll_ev->ev, TEVENT_DEBUG_FATAL,
+ "EPOLL_CTL_MOD for %s - failed - %s",
+ tevent_common_fd_str(&pbuf, "primary", primary),
+ strerror(errno));
+ /* the caller calls epoll_panic() */
+ return ret;
+ }
+
+ /*
+ * Finally re-add HAS_EVENT to all fdes
+ */
+ add_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+ tevent_common_fd_mpx_additional_flags(primary, 0, add_flags);
+
+ return 0;
+}
+
+/*
+ add the epoll event to the given fd_event
+*/
+static void epoll_add_event(struct epoll_event_context *epoll_ev,
+ struct tevent_fd *_primary)
+{
+ struct tevent_fd *primary = tevent_common_fd_mpx_primary(_primary);
+ uint16_t effective_flags = tevent_common_fd_mpx_flags(primary);
+ struct epoll_event event;
+ uint64_t clear_flags = 0;
+ uint64_t add_flags = 0;
+ int ret;
+
+ /*
+ * Before me modify the low level epoll state,
+ * we clear HAS_EVENT on all fdes.
+ */
+ clear_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+ tevent_common_fd_mpx_additional_flags(primary, clear_flags, 0);
+
+ /*
+ * Modify the low level epoll state to reflect
+ * the effective flags we want to monitor.
+ *
+ * Most likely we won't trigger the EEXIST
+ * case, so it's much cheaper to try and
+ * react on EEXIST if needed, than to always
+ * scan the list of all existing events.
+ */
+ ZERO_STRUCT(event);
+ event.events = epoll_map_flags(effective_flags);
+ event.data.ptr = primary;
+ ret = epoll_ctl(epoll_ev->epoll_fd,
+ EPOLL_CTL_ADD,
+ primary->fd,
+ &event);
+ if (ret != 0 && errno == EBADF) {
+ struct tevent_common_fd_buf pbuf = {};
+ TEVENT_DEBUG(epoll_ev->ev, TEVENT_DEBUG_ERROR,
+ "EPOLL_CTL_ADD EBADF for "
+ "%s - disabling\n",
+ tevent_common_fd_str(&pbuf, "primary", primary));
+ tevent_common_fd_mpx_disarm_all(primary);
+ return;
+ } else if (ret != 0 && errno == EEXIST) {
+ ret = epoll_add_multiplex_fd(epoll_ev, primary);
+ if (ret != 0) {
+ epoll_panic(epoll_ev, "epoll_add_multiplex_fd failed",
+ false);
+ return;
+ }
+ /*
+ * epoll_add_multiplex_fd() already
+ * added EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT
+ */
+ return;
+ } else if (ret != 0) {
+ epoll_panic(epoll_ev, "EPOLL_CTL_ADD failed", false);
+ return;
+ }
+
+ /*
+ * Finally re-add HAS_EVENT to all fdes
+ */
+ add_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+ tevent_common_fd_mpx_additional_flags(primary, 0, add_flags);
+}
+
+/*
+ delete the epoll event for given fd_event
+*/
+static void epoll_del_event(struct epoll_event_context *epoll_ev,
+ struct tevent_fd *_primary)
+{
+ struct tevent_fd *primary = tevent_common_fd_mpx_primary(_primary);
+ struct epoll_event event;
+ uint64_t clear_flags = 0;
+ int ret;
+
+ /*
+ * Before me delete the low level epoll state,
+ * we clear HAS_EVENT on all fdes.
+ */
+ clear_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+ tevent_common_fd_mpx_additional_flags(primary, clear_flags, 0);
+
+ /*
+ * Delete the low level epoll state to reflect
+ * the effective flags we want to monitor.
+ */
+ ZERO_STRUCT(event);
+ ret = epoll_ctl(epoll_ev->epoll_fd,
+ EPOLL_CTL_DEL,
+ primary->fd,
+ &event);
+ if (ret != 0 && errno == ENOENT) {
+ struct tevent_common_fd_buf pbuf = {};
+ /*
+ * This can happen after a epoll_check_reopen
+ * within epoll_event_fd_destructor.
+ */
+ TEVENT_DEBUG(epoll_ev->ev, TEVENT_DEBUG_TRACE,
+ "EPOLL_CTL_DEL ignoring ENOENT for %s\n",
+ tevent_common_fd_str(&pbuf, "primary", primary));
+ return;
+ } else if (ret != 0 && errno == EBADF) {
+ struct tevent_common_fd_buf pbuf = {};
+ TEVENT_DEBUG(epoll_ev->ev, TEVENT_DEBUG_WARNING,
+ "EPOLL_CTL_DEL EBADF for %s - disabling\n",
+ tevent_common_fd_str(&pbuf, "primary", primary));
+ tevent_common_fd_mpx_disarm_all(primary);
+ return;
+ } else if (ret != 0) {
+ struct tevent_common_fd_buf pbuf = {};
+ TEVENT_DEBUG(epoll_ev->ev, TEVENT_DEBUG_FATAL,
+ "EPOLL_CTL_DEL for %s - failed - %s",
+ tevent_common_fd_str(&pbuf, "primary", primary),
+ strerror(errno));
+ epoll_panic(epoll_ev, "EPOLL_CTL_DEL failed", false);
+ return;
+ }
+}
+
+/*
+ change the epoll event to the given fd_event
+*/
+static void epoll_mod_event(struct epoll_event_context *epoll_ev,
+ struct tevent_fd *_primary)
+{
+ struct tevent_fd *primary = tevent_common_fd_mpx_primary(_primary);
+ uint16_t effective_flags = tevent_common_fd_mpx_flags(primary);
+ struct epoll_event event;
+ uint64_t clear_flags = 0;
+ uint64_t add_flags = 0;
+ int ret;
+
+ /*
+ * Before me modify the low level epoll state,
+ * we clear HAS_EVENT on all fdes.
+ */
+ clear_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+ tevent_common_fd_mpx_additional_flags(primary, clear_flags, 0);
+
+ /*
+ * Modify the low level epoll state to reflect
+ * the effective flags we want to monitor.
+ */
+ ZERO_STRUCT(event);
+ event.events = epoll_map_flags(effective_flags);
+ event.data.ptr = primary;
+ ret = epoll_ctl(epoll_ev->epoll_fd,
+ EPOLL_CTL_MOD,
+ primary->fd,
+ &event);
+ if (ret != 0 && errno == EBADF) {
+ struct tevent_common_fd_buf pbuf = {};
+ TEVENT_DEBUG(epoll_ev->ev, TEVENT_DEBUG_ERROR,
+ "EPOLL_CTL_MOD EBADF for %s - disabling\n",
+ tevent_common_fd_str(&pbuf, "primary", primary));
+ tevent_common_fd_mpx_disarm_all(primary);
+ return;
+ } else if (ret != 0) {
+ struct tevent_common_fd_buf pbuf = {};
+ TEVENT_DEBUG(epoll_ev->ev, TEVENT_DEBUG_FATAL,
+ "EPOLL_CTL_MOD for %s - failed - %s",
+ tevent_common_fd_str(&pbuf, "primary", primary),
+ strerror(errno));
+ epoll_panic(epoll_ev, "EPOLL_CTL_MOD failed", false);
+ return;
+ }
+
+ /*
+ * Finally re-add HAS_EVENT to all fdes
+ */
+ add_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+ tevent_common_fd_mpx_additional_flags(primary, 0, add_flags);
+}
+
+static void epoll_update_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde)
+{
+ struct tevent_fd *primary = tevent_common_fd_mpx_primary(fde);
+ uint64_t _paf = primary->additional_flags;
+ bool got_error = (_paf & EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR);
+ uint16_t effective_flags = tevent_common_fd_mpx_flags(primary);
+ bool want_read = (effective_flags & TEVENT_FD_READ);
+ bool want_write= (effective_flags & TEVENT_FD_WRITE);
+ bool want_error= (effective_flags & TEVENT_FD_ERROR);
+
+ /* there's already an event */
+ if (primary->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT) {
+ if (want_read || want_error || (want_write && !got_error)) {
+ epoll_mod_event(epoll_ev, primary);
+ return;
+ }
+ /*
+ * if we want to match the select behavior, we need to remove the epoll_event
+ * when the caller isn't interested in events.
+ *
+ * this is because epoll reports EPOLLERR and EPOLLHUP, even without asking for them
+ */
+ epoll_del_event(epoll_ev, primary);
+ return;
+ }
+
+ /* there's no epoll_event attached to the fde */
+ if (want_read || want_error || (want_write && !got_error)) {
+ epoll_add_event(epoll_ev, primary);
+ return;
+ }
+}
+
+/*
+ event loop handling using epoll
+*/
+static int epoll_event_loop(struct epoll_event_context *epoll_ev, struct timeval *tvalp)
+{
+ int ret, i;
+#define MAXEVENTS 1
+ struct epoll_event events[MAXEVENTS];
+ int timeout = -1;
+ int wait_errno;
+
+ if (tvalp) {
+ /* it's better to trigger timed events a bit later than too early */
+ timeout = ((tvalp->tv_usec+999) / 1000) + (tvalp->tv_sec*1000);
+ }
+
+ if (epoll_ev->ev->signal_events &&
+ tevent_common_check_signal(epoll_ev->ev)) {
+ return 0;
+ }
+
+ tevent_trace_point_callback(epoll_ev->ev, TEVENT_TRACE_BEFORE_WAIT);
+ ret = epoll_wait(epoll_ev->epoll_fd, events, MAXEVENTS, timeout);
+ wait_errno = errno;
+ tevent_trace_point_callback(epoll_ev->ev, TEVENT_TRACE_AFTER_WAIT);
+
+ if (ret == -1 && wait_errno == EINTR && epoll_ev->ev->signal_events) {
+ if (tevent_common_check_signal(epoll_ev->ev)) {
+ return 0;
+ }
+ }
+
+ if (ret == -1 && wait_errno != EINTR) {
+ epoll_panic(epoll_ev, "epoll_wait() failed", true);
+ return -1;
+ }
+
+ if (ret == 0 && tvalp) {
+ /* we don't care about a possible delay here */
+ tevent_common_loop_timer_delay(epoll_ev->ev);
+ return 0;
+ }
+
+ for (i=0;i<ret;i++) {
+ struct tevent_fd *fde = talloc_get_type(events[i].data.ptr,
+ struct tevent_fd);
+ struct tevent_fd *selected = NULL;
+ uint16_t effective_flags;
+ uint16_t flags = 0;
+ bool got_error = false;
+
+ if (fde == NULL) {
+ epoll_panic(epoll_ev, "epoll_wait() gave bad data", true);
+ return -1;
+ }
+ effective_flags = tevent_common_fd_mpx_flags(fde);
+ if (events[i].events & (EPOLLHUP|EPOLLERR|EPOLLRDHUP)) {
+ uint64_t add_flags = 0;
+
+ add_flags |= EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR;
+ tevent_common_fd_mpx_additional_flags(fde,
+ 0,
+ add_flags);
+
+ if (effective_flags & TEVENT_FD_ERROR) {
+ flags |= TEVENT_FD_ERROR;
+ }
+ if (effective_flags & TEVENT_FD_READ) {
+ flags |= TEVENT_FD_READ;
+ }
+ }
+ if (events[i].events & EPOLLIN) {
+ if (effective_flags & TEVENT_FD_READ) {
+ flags |= TEVENT_FD_READ;
+ }
+ }
+ if (events[i].events & EPOLLOUT) {
+ if (effective_flags & TEVENT_FD_WRITE) {
+ flags |= TEVENT_FD_WRITE;
+ }
+ }
+
+ if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR)
+ {
+ got_error = true;
+ }
+
+ selected = tevent_common_fd_mpx_select(fde, flags, got_error);
+ if (selected == NULL) {
+ if (got_error) {
+ /*
+ * if we only wait for TEVENT_FD_WRITE, we
+ * should not tell the event handler about it,
+ * and remove the epoll_event, as we only
+ * report errors when waiting for read events,
+ * to match the select() behavior
+ *
+ * Do the same as the poll backend and
+ * remove the writeable flag.
+ */
+ tevent_common_fd_mpx_clear_writeable(fde);
+ epoll_update_event(epoll_ev, fde);
+ }
+ continue;
+ }
+
+ /*
+ * make sure we only pass the flags
+ * the handler is expecting.
+ */
+ flags &= selected->flags;
+ return tevent_common_invoke_fd_handler(selected,
+ flags,
+ NULL);
+ }
+
+ return 0;
+}
+
+/*
+ create a epoll_event_context structure.
+*/
+static int epoll_event_context_init(struct tevent_context *ev)
+{
+ int ret;
+ struct epoll_event_context *epoll_ev;
+
+ /*
+ * We might be called during tevent_re_initialise()
+ * which means we need to free our old additional_data.
+ */
+ TALLOC_FREE(ev->additional_data);
+
+ epoll_ev = talloc_zero(ev, struct epoll_event_context);
+ if (!epoll_ev) return -1;
+ epoll_ev->ev = ev;
+ epoll_ev->epoll_fd = -1;
+
+ ret = epoll_init_ctx(epoll_ev);
+ if (ret != 0) {
+ talloc_free(epoll_ev);
+ return ret;
+ }
+
+ ev->additional_data = epoll_ev;
+ return 0;
+}
+
+/*
+ destroy an fd_event
+*/
+static int epoll_event_fd_destructor(struct tevent_fd *fde)
+{
+ struct tevent_fd *old_primary = NULL;
+ struct tevent_fd *new_primary = NULL;
+ struct tevent_fd *update_primary = NULL;
+ struct tevent_context *ev = fde->event_ctx;
+ struct epoll_event_context *epoll_ev = NULL;
+ bool panic_triggered = false;
+
+ if (ev == NULL) {
+ tevent_common_fd_mpx_reinit(fde);
+ return tevent_common_fd_destructor(fde);
+ }
+
+ epoll_ev = talloc_get_type_abort(ev->additional_data,
+ struct epoll_event_context);
+
+ /*
+ * we must remove the event from the list
+ * otherwise a panic fallback handler may
+ * reuse invalid memory
+ */
+ DLIST_REMOVE(ev->fd_events, fde);
+
+ epoll_ev->panic_state = &panic_triggered;
+ if (epoll_ev->pid != tevent_cached_getpid()) {
+ epoll_check_reopen(epoll_ev);
+ if (panic_triggered) {
+ tevent_common_fd_mpx_reinit(fde);
+ return tevent_common_fd_destructor(fde);
+ }
+ }
+
+ old_primary = tevent_common_fd_mpx_primary(fde);
+
+ if (old_primary == fde) {
+ epoll_del_event(epoll_ev, fde);
+ if (panic_triggered) {
+ tevent_common_fd_mpx_reinit(fde);
+ return tevent_common_fd_destructor(fde);
+ }
+ }
+
+ new_primary = tevent_common_fd_mpx_remove(fde);
+ if (new_primary == NULL) {
+ epoll_ev->panic_state = NULL;
+ return tevent_common_fd_destructor(fde);
+ }
+ update_primary = tevent_common_fd_mpx_update(new_primary);
+ if (update_primary == NULL) {
+ epoll_ev->panic_state = NULL;
+ return tevent_common_fd_destructor(fde);
+ }
+
+ epoll_update_event(epoll_ev, update_primary);
+ if (panic_triggered) {
+ return tevent_common_fd_destructor(fde);
+ }
+ epoll_ev->panic_state = NULL;
+
+ return tevent_common_fd_destructor(fde);
+}
+
+/*
+ add a fd based event
+ return NULL on failure (memory allocation error)
+*/
+static struct tevent_fd *epoll_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
+ int fd, uint16_t flags,
+ tevent_fd_handler_t handler,
+ void *private_data,
+ const char *handler_name,
+ const char *location)
+{
+ struct epoll_event_context *epoll_ev =
+ talloc_get_type_abort(ev->additional_data,
+ struct epoll_event_context);
+ struct tevent_fd *fde;
+ bool panic_triggered = false;
+ pid_t old_pid = epoll_ev->pid;
+
+ fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
+ handler, private_data,
+ handler_name, location);
+ if (!fde) return NULL;
+
+ talloc_set_destructor(fde, epoll_event_fd_destructor);
+
+ /*
+ * prepare for tevent_common_fd_mpx_flags()
+ * in epoll_update_event()
+ */
+ tevent_common_fd_mpx_update_flags(fde);
+
+ if (epoll_ev->pid != tevent_cached_getpid()) {
+ epoll_ev->panic_state = &panic_triggered;
+ epoll_check_reopen(epoll_ev);
+ if (panic_triggered) {
+ return fde;
+ }
+ epoll_ev->panic_state = NULL;
+ }
+
+ if (epoll_ev->pid == old_pid) {
+ epoll_update_event(epoll_ev, fde);
+ }
+
+ return fde;
+}
+
+/*
+ set the fd event flags
+*/
+static void epoll_event_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
+{
+ struct tevent_context *ev;
+ struct epoll_event_context *epoll_ev;
+ bool panic_triggered = false;
+ pid_t old_pid;
+
+ if (fde->flags == flags) return;
+
+ ev = fde->event_ctx;
+ epoll_ev = talloc_get_type_abort(ev->additional_data,
+ struct epoll_event_context);
+ old_pid = epoll_ev->pid;
+
+ fde->flags = flags;
+ /*
+ * prepare for tevent_common_fd_mpx_flags()
+ * in epoll_update_event()
+ */
+ tevent_common_fd_mpx_update_flags(fde);
+
+ if (epoll_ev->pid != tevent_cached_getpid()) {
+ epoll_ev->panic_state = &panic_triggered;
+ epoll_check_reopen(epoll_ev);
+ if (panic_triggered) {
+ return;
+ }
+ epoll_ev->panic_state = NULL;
+ }
+
+ if (epoll_ev->pid == old_pid) {
+ epoll_update_event(epoll_ev, fde);
+ }
+}
+
+/*
+ do a single event loop using the events defined in ev
+*/
+static int epoll_event_loop_once(struct tevent_context *ev, const char *location)
+{
+ struct epoll_event_context *epoll_ev =
+ talloc_get_type_abort(ev->additional_data,
+ struct epoll_event_context);
+ struct timeval tval;
+ bool panic_triggered = false;
+
+ if (ev->signal_events &&
+ tevent_common_check_signal(ev)) {
+ return 0;
+ }
+
+ if (ev->threaded_contexts != NULL) {
+ tevent_common_threaded_activate_immediate(ev);
+ }
+
+ if (ev->immediate_events &&
+ tevent_common_loop_immediate(ev)) {
+ return 0;
+ }
+
+ tval = tevent_common_loop_timer_delay(ev);
+ if (tevent_timeval_is_zero(&tval)) {
+ return 0;
+ }
+
+ if (epoll_ev->pid != tevent_cached_getpid()) {
+ epoll_ev->panic_state = &panic_triggered;
+ epoll_ev->panic_force_replay = true;
+ epoll_check_reopen(epoll_ev);
+ if (panic_triggered) {
+ errno = EINVAL;
+ return -1;
+ }
+ epoll_ev->panic_force_replay = false;
+ epoll_ev->panic_state = NULL;
+ }
+
+ return epoll_event_loop(epoll_ev, &tval);
+}
+
+static const struct tevent_ops epoll_event_ops = {
+ .context_init = epoll_event_context_init,
+ .add_fd = epoll_event_add_fd,
+ .set_fd_close_fn = tevent_common_fd_set_close_fn,
+ .get_fd_flags = tevent_common_fd_get_flags,
+ .set_fd_flags = epoll_event_set_fd_flags,
+ .add_timer = tevent_common_add_timer_v2,
+ .schedule_immediate = tevent_common_schedule_immediate,
+ .add_signal = tevent_common_add_signal,
+ .loop_once = epoll_event_loop_once,
+ .loop_wait = tevent_common_loop_wait,
+};
+
+_PRIVATE_ bool tevent_epoll_init(void)
+{
+ return tevent_register_backend("epoll", &epoll_event_ops);
+}