X-Git-Url: https://tinc-vpn.org/git/browse?a=blobdiff_plain;f=src%2Fevent.c;h=c547c46d1f2f5d5a5077d83c335d823c634bb601;hb=0912276c6467aa3ee6f570b31245367319da572a;hp=47adb181016e8fdd7c954a230981d5c18d6b1a35;hpb=1c475ecb575367a6b3f9328b0f643ad636155341;p=tinc diff --git a/src/event.c b/src/event.c index 47adb181..c547c46d 100644 --- a/src/event.c +++ b/src/event.c @@ -1,6 +1,6 @@ /* event.c -- I/O, timeout and signal event handling - Copyright (C) 2012-2013 Guus Sliepen + Copyright (C) 2012-2021 Guus Sliepen 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 @@ -18,18 +18,26 @@ */ #include "system.h" - #include "dropin.h" + +#ifdef HAVE_SYS_EPOLL_H +#include +#endif + #include "event.h" -#include "net.h" #include "utils.h" -#include "xalloc.h" +#include "net.h" struct timeval now; - #ifndef HAVE_MINGW + +#ifdef HAVE_SYS_EPOLL_H +static int epollset = 0; +#else static fd_set readfds; static fd_set writefds; +#endif + #else static const long READ_EVENTS = FD_READ | FD_ACCEPT | FD_CLOSE; static const long WRITE_EVENTS = FD_WRITE | FD_CONNECT; @@ -37,6 +45,17 @@ static DWORD event_count = 0; #endif static bool running; +#ifdef HAVE_SYS_EPOLL_H +static inline int event_epoll_init() { + /* NOTE: 1024 limit is only used on ancient (pre 2.6.27) kernels. + Decent kernels will ignore this value making it unlimited. + epoll_create1 might be better, but these kernels would not be supported + in that case. + */ + return epoll_create(1024); +} +#endif + static int io_compare(const io_t *a, const io_t *b) { #ifndef HAVE_MINGW return a->fd - b->fd; @@ -112,9 +131,13 @@ void io_add(io_t *io, io_cb_t cb, void *data, int fd, int flags) { io_set(io, flags); +#ifndef HAVE_SYS_EPOLL_H + if(!splay_insert_node(&io_tree, &io->node)) { abort(); } + +#endif } #ifdef HAVE_MINGW @@ -125,6 +148,14 @@ void io_add_event(io_t *io, io_cb_t cb, void *data, WSAEVENT event) { #endif void io_set(io_t *io, int flags) { +#ifdef HAVE_SYS_EPOLL_H + + if(!epollset) { + epollset = event_epoll_init(); + } + +#endif + if(flags == io->flags) { return; } @@ -136,6 +167,30 @@ void io_set(io_t *io, int flags) { } #ifndef HAVE_MINGW +#ifdef HAVE_SYS_EPOLL_H + epoll_ctl(epollset, EPOLL_CTL_DEL, io->fd, NULL); + + struct epoll_event ev = { + .events = 0, + .data.ptr = io, + }; + + if(flags & IO_READ) { + ev.events |= EPOLLIN; + } + + if(flags & IO_WRITE) { + ev.events |= EPOLLOUT; + } else if(ev.events == 0) { + io_tree.generation++; + return; + } + + if(epoll_ctl(epollset, EPOLL_CTL_ADD, io->fd, &ev) < 0) { + perror("epoll_ctl_add"); + } + +#else if(flags & IO_READ) { FD_SET(io->fd, &readfds); @@ -149,6 +204,7 @@ void io_set(io_t *io, int flags) { FD_CLR(io->fd, &writefds); } +#endif #else long events = 0; @@ -182,7 +238,9 @@ void io_del(io_t *io) { event_count--; #endif +#ifndef HAVE_SYS_EPOLL_H splay_unlink_node(&io_tree, &io->node); +#endif io->cb = NULL; } @@ -223,13 +281,16 @@ void timeout_del(timeout_t *timeout) { } #ifndef HAVE_MINGW -static int signal_compare(const signal_t *a, const signal_t *b) { - return a->signum - b->signum; -} + +// From Matz's Ruby +#ifndef NSIG +# define NSIG (_SIGMAX + 1) /* For QNX */ +#endif + static io_t signalio; static int pipefd[2] = {-1, -1}; -static splay_tree_t signal_tree = {.compare = (splay_compare_t)signal_compare}; +static signal_t *signal_handle[NSIG + 1] = {}; static void signal_handler(int signum) { unsigned char num = signum; @@ -245,9 +306,7 @@ static void signalio_handler(void *data, int flags) { return; } - signal_t *sig = splay_search(&signal_tree, &((signal_t) { - .signum = signum - })); + signal_t *sig = signal_handle[signum]; if(sig) { sig->cb(sig->data); @@ -265,20 +324,17 @@ void signal_add(signal_t *sig, signal_cb_t cb, void *data, int signum) { return; } + sig->signum = signum; sig->cb = cb; sig->data = data; - sig->signum = signum; - sig->node.data = sig; if(pipefd[0] == -1) { pipe_init(); } - signal(sig->signum, signal_handler); + signal(signum, signal_handler); - if(!splay_insert_node(&signal_tree, &sig->node)) { - abort(); - } + signal_handle[signum] = sig; } void signal_del(signal_t *sig) { @@ -288,12 +344,12 @@ void signal_del(signal_t *sig) { signal(sig->signum, SIG_DFL); - splay_unlink_node(&signal_tree, &sig->node); + signal_handle[sig->signum] = NULL; sig->cb = NULL; } #endif -static struct timeval *get_time_remaining(struct timeval *diff) { +static struct timeval *timeout_execute(struct timeval *diff) { gettimeofday(&now, NULL); struct timeval *tv = NULL; @@ -320,23 +376,46 @@ bool event_loop(void) { running = true; #ifndef HAVE_MINGW + +#ifdef HAVE_SYS_EPOLL_H + + if(!epollset) { + epollset = event_epoll_init(); + } + +#else fd_set readable; fd_set writable; +#endif while(running) { struct timeval diff; - struct timeval *tv = get_time_remaining(&diff); + struct timeval *tv = timeout_execute(&diff); +#ifndef HAVE_SYS_EPOLL_H memcpy(&readable, &readfds, sizeof(readable)); memcpy(&writable, &writefds, sizeof(writable)); +#endif + + +#ifdef HAVE_SYS_EPOLL_H + struct epoll_event events[EPOLL_MAX_EVENTS_PER_LOOP]; + long timeout = (tv->tv_sec * 1000) + (tv->tv_usec / 1000); + + if(timeout > INT_MAX) { + timeout = INT_MAX; + } - int fds = 0; + int n = epoll_wait(epollset, events, EPOLL_MAX_EVENTS_PER_LOOP, (int)timeout); +#else + int maxfds = 0; if(io_tree.tail) { io_t *last = io_tree.tail->data; - fds = last->fd + 1; + maxfds = last->fd + 1; } - int n = select(fds, &readable, &writable, NULL, tv); + int n = select(maxfds, &readable, &writable, NULL, tv); +#endif if(n < 0) { if(sockwouldblock(sockerrno)) { @@ -352,6 +431,31 @@ bool event_loop(void) { unsigned int curgen = io_tree.generation; + +#ifdef HAVE_SYS_EPOLL_H + + for(int i = 0; i < n; i++) { + io_t *io = events[i].data.ptr; + + if(events[i].events & EPOLLOUT && io->flags & IO_WRITE) { + io->cb(io->data, IO_WRITE); + } + + if(curgen != io_tree.generation) { + break; + } + + if(events[i].events & EPOLLIN && io->flags & IO_READ) { + io->cb(io->data, IO_READ); + } + + if(curgen != io_tree.generation) { + break; + } + } + +#else + for splay_each(io_t, io, &io_tree) { if(FD_ISSET(io->fd, &writable)) { io->cb(io->data, IO_WRITE); @@ -362,23 +466,25 @@ bool event_loop(void) { } /* - There are scenarios in which the callback will remove another io_t from the tree - (e.g. closing a double connection). Since splay_each does not support that, we - need to exit the loop if that happens. That's okay, since any remaining events will - get picked up by the next select() call. - */ + There are scenarios in which the callback will remove another io_t from the tree + (e.g. closing a double connection). Since splay_each does not support that, we + need to exit the loop if that happens. That's okay, since any remaining events will + get picked up by the next select() call. + */ if(curgen != io_tree.generation) { break; } } + +#endif } #else while(running) { struct timeval diff; - struct timeval *tv = get_time_remaining(&diff); - DWORD timeout_ms = tv ? (tv->tv_sec * 1000 + tv->tv_usec / 1000 + 1) : WSA_INFINITE; + struct timeval *tv = timeout_execute(&diff); + DWORD timeout_ms = tv ? (DWORD)(tv->tv_sec * 1000 + tv->tv_usec / 1000 + 1) : WSA_INFINITE; if(!event_count) { Sleep(timeout_ms); @@ -436,7 +542,7 @@ bool event_loop(void) { } if(result < WSA_WAIT_EVENT_0 || result >= WSA_WAIT_EVENT_0 + event_count - event_offset) { - return(false); + return false; } /* Look up io in the map by index. */