X-Git-Url: https://tinc-vpn.org/git/browse?a=blobdiff_plain;f=src%2Fevent.c;h=899b62a077abb435e5327b359bacc41402ccaaf1;hb=01dc7836703ba3aa113f3d0102f13ba73319e50b;hp=8c7de4799e95f570d858d6a063585d018627a85f;hpb=a742ea4d040ecfaabbc875c63f2625654ce68923;p=tinc diff --git a/src/event.c b/src/event.c index 8c7de479..899b62a0 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-2022 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 @@ -19,17 +19,27 @@ #include "system.h" +#include + +#ifdef HAVE_SYS_EPOLL_H +#include +#endif + #include "dropin.h" #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 +47,17 @@ static DWORD event_count = 0; #endif static bool running; +#ifdef HAVE_SYS_EPOLL_H +static inline int event_epoll_init(void) { + /* 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 +133,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 +150,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 +169,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 +206,7 @@ void io_set(io_t *io, int flags) { FD_CLR(io->fd, &writefds); } +#endif #else long events = 0; @@ -182,7 +240,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,29 +283,35 @@ 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] = {NULL}; static void signal_handler(int signum) { unsigned char num = signum; - write(pipefd[1], &num, 1); + + if(write(pipefd[1], &num, 1) != 1) { + // Pipe full or broken, nothing we can do about it. + } } static void signalio_handler(void *data, int flags) { + (void)data; + (void)flags; unsigned char signum; if(read(pipefd[0], &signum, 1) != 1) { return; } - signal_t *sig = splay_search(&signal_tree, &((signal_t) { - .signum = signum - })); + signal_t *sig = signal_handle[signum]; if(sig) { sig->cb(sig->data); @@ -263,20 +329,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) { @@ -286,12 +349,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; @@ -318,23 +381,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)) { @@ -350,6 +436,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); @@ -360,23 +471,26 @@ 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 + assert(WSA_WAIT_EVENT_0 == 0); 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); @@ -433,12 +547,12 @@ bool event_loop(void) { break; } - if(result < WSA_WAIT_EVENT_0 || result >= WSA_WAIT_EVENT_0 + event_count - event_offset) { - return(false); + if(result >= event_count - event_offset) { + return false; } /* Look up io in the map by index. */ - event_index = result - WSA_WAIT_EVENT_0 + event_offset; + event_index = result + event_offset; io_t *io = io_map[event_index]; if(io->fd == -1) {