This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
at runtime we fallback to select()
*/
-#include "includes.h"
+#include "replace.h"
#include "system/filesys.h"
-#include "dlinklist.h"
-#include "lib/events/events.h"
-#include "lib/events/events_internal.h"
-
-/* use epoll if it is available */
-#if defined(HAVE_EPOLL_CREATE) && defined(HAVE_SYS_EPOLL_H)
-#define WITH_EPOLL 1
-#endif
-
-#if WITH_EPOLL
-#include <sys/epoll.h>
-#endif
+#include "system/network.h"
+#include "system/select.h" /* needed for HAVE_EVENTS_EPOLL */
+#include "events.h"
+#include "events_util.h"
+#include "events_internal.h"
struct std_event_context {
+ /* a pointer back to the generic event_context */
+ struct event_context *ev;
+
/* list of filedescriptor events */
struct fd_event *fd_events;
- /* list of timed events */
- struct timed_event *timed_events;
-
/* the maximum file descriptor number in fd_events */
int maxfd;
*/
uint32_t destruction_count;
-#if WITH_EPOLL
/* when using epoll this is the handle from epoll_create */
int epoll_fd;
-#endif
+
+ /* our pid at the time the epoll_fd was created */
+ pid_t pid;
};
+/* use epoll if it is available */
+#if HAVE_EVENTS_EPOLL
/*
- destroy an event context
+ called when a epoll call fails, and we should fallback
+ to using select
*/
-static int std_event_context_destructor(void *ptr)
+static void epoll_fallback_to_select(struct std_event_context *std_ev, const char *reason)
+{
+ ev_debug(std_ev->ev, EV_DEBUG_FATAL,
+ "%s (%s) - falling back to select()\n",
+ reason, strerror(errno));
+ close(std_ev->epoll_fd);
+ std_ev->epoll_fd = -1;
+ talloc_set_destructor(std_ev, NULL);
+}
+
+/*
+ map from EVENT_FD_* to EPOLLIN/EPOLLOUT
+*/
+static uint32_t epoll_map_flags(uint16_t flags)
+{
+ uint32_t ret = 0;
+ if (flags & EVENT_FD_READ) ret |= (EPOLLIN | EPOLLERR | EPOLLHUP);
+ if (flags & EVENT_FD_WRITE) ret |= (EPOLLOUT | EPOLLERR | EPOLLHUP);
+ return ret;
+}
+
+/*
+ free the epoll fd
+*/
+static int epoll_ctx_destructor(struct std_event_context *std_ev)
{
-#if WITH_EPOLL
- struct event_context *ev = talloc_get_type(ptr, struct event_context);
- struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
- struct std_event_context);
if (std_ev->epoll_fd != -1) {
close(std_ev->epoll_fd);
- std_ev->epoll_fd = -1;
}
-#endif
+ std_ev->epoll_fd = -1;
return 0;
}
+/*
+ init the epoll fd
+*/
+static void epoll_init_ctx(struct std_event_context *std_ev)
+{
+ std_ev->epoll_fd = epoll_create(64);
+ std_ev->pid = getpid();
+ talloc_set_destructor(std_ev, epoll_ctx_destructor);
+}
+
+static void epoll_add_event(struct std_event_context *std_ev, struct fd_event *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 std_event_context *std_ev)
+{
+ struct fd_event *fde;
+
+ if (std_ev->pid == getpid()) {
+ return;
+ }
+
+ close(std_ev->epoll_fd);
+ std_ev->epoll_fd = epoll_create(64);
+ if (std_ev->epoll_fd == -1) {
+ ev_debug(std_ev->ev, EV_DEBUG_FATAL,
+ "Failed to recreate epoll handle after fork\n");
+ return;
+ }
+ std_ev->pid = getpid();
+ for (fde=std_ev->fd_events;fde;fde=fde->next) {
+ epoll_add_event(std_ev, fde);
+ }
+}
+
+#define EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT (1<<0)
+#define EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR (1<<1)
+#define EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR (1<<2)
+
+/*
+ add the epoll event to the given fd_event
+*/
+static void epoll_add_event(struct std_event_context *std_ev, struct fd_event *fde)
+{
+ struct epoll_event event;
+ if (std_ev->epoll_fd == -1) return;
+
+ fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+
+ /* if we don't want events yet, don't add an epoll_event */
+ if (fde->flags == 0) return;
+
+ ZERO_STRUCT(event);
+ event.events = epoll_map_flags(fde->flags);
+ event.data.ptr = fde;
+ if (epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_ADD, fde->fd, &event) != 0) {
+ epoll_fallback_to_select(std_ev, "EPOLL_CTL_ADD failed");
+ }
+ fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+
+ /* only if we want to read we want to tell the event handler about errors */
+ if (fde->flags & EVENT_FD_READ) {
+ fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+ }
+}
+
+/*
+ delete the epoll event for given fd_event
+*/
+static void epoll_del_event(struct std_event_context *std_ev, struct fd_event *fde)
+{
+ struct epoll_event event;
+ if (std_ev->epoll_fd == -1) return;
+
+ fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+
+ /* if there's no epoll_event, we don't need to delete it */
+ if (!(fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT)) return;
+
+ ZERO_STRUCT(event);
+ event.events = epoll_map_flags(fde->flags);
+ event.data.ptr = fde;
+ epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_DEL, fde->fd, &event);
+ fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+}
+
+/*
+ change the epoll event to the given fd_event
+*/
+static void epoll_mod_event(struct std_event_context *std_ev, struct fd_event *fde)
+{
+ struct epoll_event event;
+ if (std_ev->epoll_fd == -1) return;
+
+ fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+
+ ZERO_STRUCT(event);
+ event.events = epoll_map_flags(fde->flags);
+ event.data.ptr = fde;
+ if (epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_MOD, fde->fd, &event) != 0) {
+ epoll_fallback_to_select(std_ev, "EPOLL_CTL_MOD failed");
+ }
+
+ /* only if we want to read we want to tell the event handler about errors */
+ if (fde->flags & EVENT_FD_READ) {
+ fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+ }
+}
+
+static void epoll_change_event(struct std_event_context *std_ev, struct fd_event *fde)
+{
+ bool got_error = (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR);
+ bool want_read = (fde->flags & EVENT_FD_READ);
+ bool want_write= (fde->flags & EVENT_FD_WRITE);
+
+ if (std_ev->epoll_fd == -1) return;
+
+ fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+
+ /* there's already an event */
+ if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT) {
+ if (want_read || (want_write && !got_error)) {
+ epoll_mod_event(std_ev, fde);
+ 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(std_ev, fde);
+ return;
+ }
+
+ /* there's no epoll_event attached to the fde */
+ if (want_read || (want_write && !got_error)) {
+ epoll_add_event(std_ev, fde);
+ return;
+ }
+}
+
+/*
+ event loop handling using epoll
+*/
+static int epoll_event_loop(struct std_event_context *std_ev, struct timeval *tvalp)
+{
+ int ret, i;
+#define MAXEVENTS 8
+ struct epoll_event events[MAXEVENTS];
+ uint32_t destruction_count = ++std_ev->destruction_count;
+ int timeout = -1;
+
+ if (std_ev->epoll_fd == -1) return -1;
+
+ if (tvalp) {
+ /* it's better to trigger timed events a bit later than to early */
+ timeout = ((tvalp->tv_usec+999) / 1000) + (tvalp->tv_sec*1000);
+ }
+
+ if (std_ev->ev->num_signal_handlers &&
+ common_event_check_signal(std_ev->ev)) {
+ return 0;
+ }
+
+ ret = epoll_wait(std_ev->epoll_fd, events, MAXEVENTS, timeout);
+
+ if (ret == -1 && errno == EINTR && std_ev->ev->num_signal_handlers) {
+ if (common_event_check_signal(std_ev->ev)) {
+ return 0;
+ }
+ }
+
+ if (ret == -1 && errno != EINTR) {
+ epoll_fallback_to_select(std_ev, "epoll_wait() failed");
+ return -1;
+ }
+
+ if (ret == 0 && tvalp) {
+ /* we don't care about a possible delay here */
+ common_event_loop_timer_delay(std_ev->ev);
+ return 0;
+ }
+
+ for (i=0;i<ret;i++) {
+ struct fd_event *fde = talloc_get_type(events[i].data.ptr,
+ struct fd_event);
+ uint16_t flags = 0;
+
+ if (fde == NULL) {
+ epoll_fallback_to_select(std_ev, "epoll_wait() gave bad data");
+ return -1;
+ }
+ if (events[i].events & (EPOLLHUP|EPOLLERR)) {
+ fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR;
+ /*
+ * if we only wait for EVENT_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
+ */
+ if (!(fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR)) {
+ epoll_del_event(std_ev, fde);
+ continue;
+ }
+ flags |= EVENT_FD_READ;
+ }
+ if (events[i].events & EPOLLIN) flags |= EVENT_FD_READ;
+ if (events[i].events & EPOLLOUT) flags |= EVENT_FD_WRITE;
+ if (flags) {
+ fde->handler(std_ev->ev, fde, flags, fde->private_data);
+ if (destruction_count != std_ev->destruction_count) {
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+#else
+#define epoll_init_ctx(std_ev)
+#define epoll_add_event(std_ev,fde)
+#define epoll_del_event(std_ev,fde)
+#define epoll_change_event(std_ev,fde)
+#define epoll_event_loop(std_ev,tvalp) (-1)
+#define epoll_check_reopen(std_ev)
+#endif
+
/*
create a std_event_context structure.
*/
-static int std_event_context_init(struct event_context *ev, void *privata_data)
+static int std_event_context_init(struct event_context *ev)
{
struct std_event_context *std_ev;
std_ev = talloc_zero(ev, struct std_event_context);
if (!std_ev) return -1;
+ std_ev->ev = ev;
+ std_ev->epoll_fd = -1;
-#if WITH_EPOLL
- std_ev->epoll_fd = epoll_create(64);
-#endif
+ epoll_init_ctx(std_ev);
ev->additional_data = std_ev;
-
- talloc_set_destructor(ev, std_event_context_destructor);
-
return 0;
}
/*
recalculate the maxfd
*/
-static void calc_maxfd(struct event_context *ev)
+static void calc_maxfd(struct std_event_context *std_ev)
{
- struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
- struct std_event_context);
struct fd_event *fde;
std_ev->maxfd = 0;
*/
#define EVENT_INVALID_MAXFD (-1)
-
-#if WITH_EPOLL
-/*
- called when a epoll call fails, and we should fallback
- to using select
-*/
-static void epoll_fallback_to_select(struct event_context *ev, const char *reason)
-{
- struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
- struct std_event_context);
- DEBUG(0,("%s (%s) - falling back to select()\n", reason, strerror(errno)));
- close(std_ev->epoll_fd);
- std_ev->epoll_fd = -1;
-}
-#endif
-
-
-#if WITH_EPOLL
-/*
- map from EVENT_FD_* to EPOLLIN/EPOLLOUT
-*/
-static uint32_t epoll_map_flags(uint16_t flags)
-{
- uint32_t ret = 0;
- if (flags & EVENT_FD_READ) ret |= EPOLLIN;
- if (flags & EVENT_FD_WRITE) ret |= EPOLLOUT;
- return ret;
-}
-#endif
-
/*
destroy an fd_event
*/
-static int std_event_fd_destructor(void *ptr)
+static int std_event_fd_destructor(struct fd_event *fde)
{
- struct fd_event *fde = talloc_get_type(ptr, struct fd_event);
struct event_context *ev = fde->event_ctx;
struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
struct std_event_context);
+ epoll_check_reopen(std_ev);
+
if (std_ev->maxfd == fde->fd) {
std_ev->maxfd = EVENT_INVALID_MAXFD;
}
+
DLIST_REMOVE(std_ev->fd_events, fde);
std_ev->destruction_count++;
-#if WITH_EPOLL
- if (std_ev->epoll_fd != -1) {
- struct epoll_event event;
- ZERO_STRUCT(event);
- event.events = epoll_map_flags(fde->flags);
- event.data.ptr = fde;
- epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_DEL, fde->fd, &event);
+
+ epoll_del_event(std_ev, fde);
+
+ if (fde->flags & EVENT_FD_AUTOCLOSE) {
+ close(fde->fd);
+ fde->fd = -1;
}
-#endif
+
return 0;
}
struct std_event_context);
struct fd_event *fde;
+ epoll_check_reopen(std_ev);
+
fde = talloc(mem_ctx?mem_ctx:ev, struct fd_event);
if (!fde) return NULL;
fde->flags = flags;
fde->handler = handler;
fde->private_data = private_data;
+ fde->additional_flags = 0;
fde->additional_data = NULL;
DLIST_ADD(std_ev->fd_events, fde);
-
- if (fde->fd > std_ev->maxfd) {
+ if ((std_ev->maxfd != EVENT_INVALID_MAXFD)
+ && (fde->fd > std_ev->maxfd)) {
std_ev->maxfd = fde->fd;
}
-
talloc_set_destructor(fde, std_event_fd_destructor);
-#if WITH_EPOLL
- if (std_ev->epoll_fd != -1) {
- struct epoll_event event;
- ZERO_STRUCT(event);
- event.events = epoll_map_flags(flags);
- event.data.ptr = fde;
- if (epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_ADD, fde->fd, &event) != 0) {
- epoll_fallback_to_select(ev, "EPOLL_CTL_ADD failed");
- }
- }
-#endif
+ epoll_add_event(std_ev, fde);
return fde;
}
*/
static uint16_t std_event_get_fd_flags(struct fd_event *fde)
{
- return fde?fde->flags:0;
+ return fde->flags;
}
/*
*/
static void std_event_set_fd_flags(struct fd_event *fde, uint16_t flags)
{
-#if WITH_EPOLL
struct event_context *ev;
struct std_event_context *std_ev;
- if (fde == NULL ||
- fde->flags == flags) {
- return;
- }
- ev = fde->event_ctx;
- std_ev = talloc_get_type(ev->additional_data, struct std_event_context);
- if (std_ev->epoll_fd != -1) {
- struct epoll_event event;
- ZERO_STRUCT(event);
- event.events = epoll_map_flags(flags);
- event.data.ptr = fde;
- if (epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_MOD, fde->fd, &event) != 0) {
- epoll_fallback_to_select(ev, "EPOLL_CTL_MOD failed");
- }
- }
-#endif
- if (fde) {
- fde->flags = flags;
- }
-}
-
-/*
- destroy a timed event
-*/
-static int std_event_timed_destructor(void *ptr)
-{
- struct timed_event *te = talloc_get_type(ptr, struct timed_event);
- struct std_event_context *std_ev = talloc_get_type(te->event_ctx->additional_data,
- struct std_event_context);
- DLIST_REMOVE(std_ev->timed_events, te);
- return 0;
-}
-/*
- add a timed event
- return NULL on failure (memory allocation error)
-*/
-static struct timed_event *std_event_add_timed(struct event_context *ev, TALLOC_CTX *mem_ctx,
- struct timeval next_event,
- event_timed_handler_t handler,
- void *private_data)
-{
- struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
- struct std_event_context);
- struct timed_event *te, *last_te, *cur_te;
-
- te = talloc(mem_ctx?mem_ctx:ev, struct timed_event);
- if (te == NULL) return NULL;
-
- te->event_ctx = ev;
- te->next_event = next_event;
- te->handler = handler;
- te->private_data = private_data;
- te->additional_data = NULL;
-
- /* keep the list ordered */
- last_te = NULL;
- for (cur_te = std_ev->timed_events; cur_te; cur_te = cur_te->next) {
- /* if the new event comes before the current one break */
- if (!timeval_is_zero(&cur_te->next_event) &&
- timeval_compare(&cur_te->next_event, &te->next_event) < 0) {
- break;
- }
-
- last_te = cur_te;
- }
-
- DLIST_ADD_AFTER(std_ev->timed_events, te, last_te);
-
- talloc_set_destructor(te, std_event_timed_destructor);
+ if (fde->flags == flags) return;
- return te;
-}
-
-/*
- a timer has gone off - call it
-*/
-static void std_event_loop_timer(struct event_context *ev)
-{
- struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
- struct std_event_context);
- struct timeval t = timeval_current();
- struct timed_event *te = std_ev->timed_events;
-
- if (te == NULL) {
- return;
- }
+ ev = fde->event_ctx;
+ std_ev = talloc_get_type(ev->additional_data, struct std_event_context);
- te->next_event = timeval_zero();
+ fde->flags = flags;
- te->handler(ev, te, t, te->private_data);
+ epoll_check_reopen(std_ev);
- /* note the care taken to prevent referencing a event
- that could have been freed by the handler */
- if (std_ev->timed_events) {
- if (timeval_is_zero(&std_ev->timed_events->next_event)) {
- talloc_free(te);
- }
- }
+ epoll_change_event(std_ev, fde);
}
-#if WITH_EPOLL
-/*
- event loop handling using epoll
-*/
-static int std_event_loop_epoll(struct event_context *ev, struct timeval *tvalp)
-{
- struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
- struct std_event_context);
- int ret, i;
-#define MAXEVENTS 8
- struct epoll_event events[MAXEVENTS];
- uint32_t destruction_count = std_ev->destruction_count;
- int timeout = -1;
-
- if (tvalp) {
- /* it's better to trigger timed events a bit later than to early */
- timeout = ((tvalp->tv_usec+999) / 1000) + (tvalp->tv_sec*1000);
- }
-
- ret = epoll_wait(std_ev->epoll_fd, events, MAXEVENTS, timeout);
-
- if (ret == -1 && errno != EINTR) {
- epoll_fallback_to_select(ev, "epoll_wait() failed");
- return -1;
- }
-
- if (ret == 0 && tvalp) {
- std_event_loop_timer(ev);
- return 0;
- }
-
- for (i=0;i<ret;i++) {
- struct fd_event *fde = talloc_get_type(events[i].data.ptr,
- struct fd_event);
- uint16_t flags = 0;
-
- if (fde == NULL) {
- epoll_fallback_to_select(ev, "epoll_wait() gave bad data");
- return -1;
- }
- if (events[i].events & (EPOLLIN|EPOLLHUP|EPOLLERR))
- flags |= EVENT_FD_READ;
- if (events[i].events & EPOLLOUT) flags |= EVENT_FD_WRITE;
- if (flags) {
- fde->handler(ev, fde, flags, fde->private_data);
- if (destruction_count != std_ev->destruction_count) {
- break;
- }
- }
- }
-
- return 0;
-}
-#endif
-
/*
event loop handling using select()
*/
-static int std_event_loop_select(struct event_context *ev, struct timeval *tvalp)
+static int std_event_loop_select(struct std_event_context *std_ev, struct timeval *tvalp)
{
- struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
- struct std_event_context);
fd_set r_fds, w_fds;
struct fd_event *fde;
int selrtn;
- uint32_t destruction_count = std_ev->destruction_count;
+ uint32_t destruction_count = ++std_ev->destruction_count;
/* we maybe need to recalculate the maxfd */
if (std_ev->maxfd == EVENT_INVALID_MAXFD) {
- calc_maxfd(ev);
+ calc_maxfd(std_ev);
}
FD_ZERO(&r_fds);
}
}
+ if (std_ev->ev->num_signal_handlers &&
+ common_event_check_signal(std_ev->ev)) {
+ return 0;
+ }
+
selrtn = select(std_ev->maxfd+1, &r_fds, &w_fds, NULL, tvalp);
+ if (selrtn == -1 && errno == EINTR &&
+ std_ev->ev->num_signal_handlers) {
+ common_event_check_signal(std_ev->ev);
+ return 0;
+ }
+
if (selrtn == -1 && errno == EBADF) {
/* the socket is dead! this should never
happen as the socket should have first been
made readable and that should have removed
the event, so this must be a bug. This is a
fatal error. */
- DEBUG(0,("ERROR: EBADF on std_event_loop_once\n"));
+ ev_debug(std_ev->ev, EV_DEBUG_FATAL,
+ "ERROR: EBADF on std_event_loop_once\n");
std_ev->exit_code = EBADF;
return -1;
}
if (selrtn == 0 && tvalp) {
- std_event_loop_timer(ev);
+ /* we don't care about a possible delay here */
+ common_event_loop_timer_delay(std_ev->ev);
return 0;
}
if (FD_ISSET(fde->fd, &r_fds)) flags |= EVENT_FD_READ;
if (FD_ISSET(fde->fd, &w_fds)) flags |= EVENT_FD_WRITE;
if (flags) {
- fde->handler(ev, fde, flags, fde->private_data);
+ fde->handler(std_ev->ev, fde, flags, fde->private_data);
if (destruction_count != std_ev->destruction_count) {
break;
}
struct std_event_context);
struct timeval tval;
- /* work out the right timeout for all timed events */
- if (std_ev->timed_events) {
- struct timeval t = timeval_current();
- tval = timeval_diff(&std_ev->timed_events->next_event, &t);
- if (timeval_is_zero(&tval)) {
- std_event_loop_timer(ev);
- return 0;
- }
- } else {
- /* have a default tick time of 30 seconds. This guarantees
- that code that uses its own timeout checking will be
- able to proceeed eventually */
- tval = timeval_set(30, 0);
+ tval = common_event_loop_timer_delay(ev);
+ if (ev_timeval_is_zero(&tval)) {
+ return 0;
}
-#if WITH_EPOLL
- if (std_ev->epoll_fd != -1) {
- if (std_event_loop_epoll(ev, &tval) == 0) {
- return 0;
- }
+ epoll_check_reopen(std_ev);
+
+ if (epoll_event_loop(std_ev, &tval) == 0) {
+ return 0;
}
-#endif
- return std_event_loop_select(ev, &tval);
+ return std_event_loop_select(std_ev, &tval);
}
/*
.add_fd = std_event_add_fd,
.get_fd_flags = std_event_get_fd_flags,
.set_fd_flags = std_event_set_fd_flags,
- .add_timed = std_event_add_timed,
+ .add_timed = common_event_add_timed,
+ .add_signal = common_event_add_signal,
.loop_once = std_event_loop_once,
.loop_wait = std_event_loop_wait,
};
-const struct event_ops *event_standard_get_ops(void)
+
+bool events_standard_init(void)
{
- return &std_event_ops;
+ return event_register_backend("standard", &std_event_ops);
}
+