X-Git-Url: https://arthur.barton.de/cgi-bin/gitweb.cgi?p=ngircd-alex.git;a=blobdiff_plain;f=src%2Fngircd%2Fio.c;h=fb39ecdd99f0b07cb96c6afd61ef05a40468eaa3;hp=6e6f5985afab1e1a934a557bc352e93aa9a7bc02;hb=03628dbeaf40a9de34b3eb6d5bf6dd34eed8248c;hpb=db992975eb2efd44d4452c566620983ecc559a4f diff --git a/src/ngircd/io.c b/src/ngircd/io.c index 6e6f5985..fb39ecdd 100644 --- a/src/ngircd/io.c +++ b/src/ngircd/io.c @@ -5,14 +5,16 @@ * (at your option) any later version. * Please read the file COPYING, README and AUTHORS for more information. * - * I/O abstraction interface. * Copyright (c) 2005 Florian Westphal (westphal@foo.fh-furtwangen.de) * */ #include "portab.h" -static char UNUSED id[] = "$Id: io.c,v 1.9 2005/08/29 13:58:54 fw Exp $"; +/** + * @file + * I/O abstraction interface. + */ #include #include @@ -26,34 +28,53 @@ static char UNUSED id[] = "$Id: io.c,v 1.9 2005/08/29 13:58:54 fw Exp $"; #include "io.h" #include "log.h" +/* Enables extra debug messages in event add/delete/callback code. */ +/* #define DEBUG_IO */ typedef struct { +#ifdef PROTOTYPES void (*callback)(int, short); - int fd; +#else + void (*callback)(); +#endif short what; } io_event; -#define INIT_IOEVENT { NULL, -1, 0, NULL } -#define IO_ERROR 4 +#define INIT_IOEVENT { NULL, -1, 0, NULL } +#define IO_ERROR 4 #ifdef HAVE_EPOLL_CREATE -#define IO_USE_EPOLL 1 +# define IO_USE_EPOLL 1 +# ifdef HAVE_SELECT +# define IO_USE_SELECT 1 +# endif #else -# ifdef HAVE_KQUEUE -#define IO_USE_KQUEUE 1 -# else -#define IO_USE_SELECT 1 -#endif -#endif - -static bool library_initialized; +# ifdef HAVE_KQUEUE +# define IO_USE_KQUEUE 1 +# else +# ifdef HAVE_SYS_DEVPOLL_H +# define IO_USE_DEVPOLL 1 +# else +# ifdef HAVE_POLL +# define IO_USE_POLL 1 +# else +# ifdef HAVE_SELECT +# define IO_USE_SELECT 1 +# else +# error "no IO API available!?" +# endif /* HAVE_SELECT */ +# endif /* HAVE_POLL */ +# endif /* HAVE_SYS_DEVPOLL_H */ +# endif /* HAVE_KQUEUE */ +#endif /* HAVE_EPOLL_CREATE */ + +static bool library_initialized = false; #ifdef IO_USE_EPOLL #include -static int io_masterfd; -static bool io_event_new_epoll(int fd, short what); -static bool io_event_change_epoll(int fd, short what); +static int io_masterfd = -1; +static bool io_event_change_epoll(int fd, short what, const int action); static int io_dispatch_epoll(struct timeval *tv); #endif @@ -64,418 +85,380 @@ static array io_evcache; static int io_masterfd; static int io_dispatch_kqueue(struct timeval *tv); -static bool io_event_add_kqueue(int, short); +static bool io_event_change_kqueue(int, short, const int action); +#endif + +#ifdef IO_USE_POLL +#include + +static array pollfds; +static int poll_maxfd; + +static bool io_event_change_poll PARAMS((int fd, short what)); +#endif + +#ifdef IO_USE_DEVPOLL +#include +static int io_masterfd; + +static bool io_event_change_devpoll(int fd, short what); #endif #ifdef IO_USE_SELECT #include "defines.h" /* for conn.h */ -#include "conn.h" /* for CONN_IDX (needed by resolve.h) */ -#include "resolve.h" /* for RES_STAT (needed by conf.h) */ +#include "proc.h" /* for PROC_STAT (needed by conf.h) */ +#include "conn.h" /* for CONN_ID (needed by conf.h) */ #include "conf.h" /* for Conf_MaxConnections */ static fd_set readers; static fd_set writers; -static int select_maxfd; /* the select() interface sucks badly */ -static int io_dispatch_select(struct timeval *tv); +/* + * this is the first argument for select(), i.e. + * the largest fd registered, plus one. + */ +static int select_maxfd; +static int io_dispatch_select PARAMS((struct timeval *tv)); + +#ifndef IO_USE_EPOLL +#define io_masterfd -1 #endif +#endif /* IO_USE_SELECT */ static array io_events; static void io_docallback PARAMS((int fd, short what)); +#ifdef DEBUG_IO +static void +io_debug(const char *s, int fd, int what) +{ + Log(LOG_DEBUG, "%s: %d, %d\n", s, fd, what); +} +#else +static inline void +io_debug(const char UNUSED *s,int UNUSED a, int UNUSED b) +{ /* NOTHING */ } +#endif + static io_event * io_event_get(int fd) { io_event *i; + assert(fd >= 0); - i = (io_event *) array_get(&io_events, sizeof(io_event), fd); - assert(i); + + i = (io_event *) array_get(&io_events, sizeof(io_event), (size_t) fd); + + assert(i != NULL); return i; } -bool -io_library_init(unsigned int eventsize) +#ifdef IO_USE_DEVPOLL +static int +io_dispatch_devpoll(struct timeval *tv) { - bool ret; -#ifdef IO_USE_EPOLL - int ecreate_hint = (int)eventsize; - if (ecreate_hint <= 0) - ecreate_hint = 128; -#endif + struct dvpoll dvp; + time_t sec = tv->tv_sec * 1000; + int i, total, ret, timeout = tv->tv_usec + sec; + short what; + struct pollfd p[100]; - if (library_initialized) - return true; + if (timeout < 0) + timeout = 1000; -#ifdef IO_USE_SELECT -#ifdef FD_SETSIZE - if (eventsize >= FD_SETSIZE) - eventsize = FD_SETSIZE - 1; -#endif -#endif - if (eventsize && !array_alloc(&io_events, sizeof(io_event), eventsize)) - eventsize = 0; + total = 0; + do { + dvp.dp_timeout = timeout; + dvp.dp_nfds = 100; + dvp.dp_fds = p; + ret = ioctl(io_masterfd, DP_POLL, &dvp); + total += ret; + if (ret <= 0) + return total; + for (i=0; i < ret ; i++) { + what = 0; + if (p[i].revents & (POLLIN|POLLPRI)) + what = IO_WANTREAD; + + if (p[i].revents & POLLOUT) + what |= IO_WANTWRITE; + + if (p[i].revents && !what) { + /* other flag is set, probably POLLERR */ + what = IO_ERROR; + } + io_docallback(p[i].fd, what); + } + } while (ret == 100); -#ifdef IO_USE_EPOLL - io_masterfd = epoll_create(ecreate_hint); - Log(LOG_INFO, - "IO subsystem: epoll (hint size %d, initial maxfd %u, masterfd %d).", - ecreate_hint, eventsize, io_masterfd); - ret = io_masterfd >= 0; - if (ret) library_initialized = true; + return total; +} - return ret; -#endif -#ifdef IO_USE_SELECT - Log(LOG_INFO, "IO subsystem: select (initial maxfd %u).", - eventsize); - FD_ZERO(&readers); - FD_ZERO(&writers); -#ifdef FD_SETSIZE - if (Conf_MaxConnections >= FD_SETSIZE) { - Log(LOG_WARNING, - "MaxConnections (%d) exceeds limit (%u), changed MaxConnections to %u.", - Conf_MaxConnections, FD_SETSIZE, FD_SETSIZE - 1); - Conf_MaxConnections = FD_SETSIZE - 1; - } -#else - Log(LOG_WARNING, - "FD_SETSIZE undefined, don't know how many descriptors select() can handle on your platform ..."); -#endif /* FD_SETSIZE */ - library_initialized = true; - return true; -#endif /* SELECT */ -#ifdef IO_USE_KQUEUE - io_masterfd = kqueue(); +static bool +io_event_change_devpoll(int fd, short what) +{ + struct pollfd p; - Log(LOG_INFO, - "IO subsystem: kqueue (initial maxfd %u, masterfd %d)", - eventsize, io_masterfd); - ret = io_masterfd >= 0; - if (ret) library_initialized = true; + p.events = 0; - return ret; -#endif + if (what & IO_WANTREAD) + p.events = POLLIN | POLLPRI; + if (what & IO_WANTWRITE) + p.events |= POLLOUT; + + p.fd = fd; + return write(io_masterfd, &p, sizeof p) == (ssize_t)sizeof p; } +static void +io_close_devpoll(int fd) +{ + struct pollfd p; + p.events = POLLREMOVE; + p.fd = fd; + write(io_masterfd, &p, sizeof p); +} -void -io_library_shutdown(void) +static void +io_library_init_devpoll(unsigned int eventsize) { -#ifdef IO_USE_SELECT - FD_ZERO(&readers); - FD_ZERO(&writers); + io_masterfd = open("/dev/poll", O_RDWR); + if (io_masterfd >= 0) + library_initialized = true; + Log(LOG_INFO, "IO subsystem: /dev/poll (initial maxfd %u, masterfd %d).", + eventsize, io_masterfd); +} #else - close(io_masterfd); /* kqueue, epoll */ - io_masterfd = -1; -#endif -#ifdef IO_USE_KQUEUE - array_free(&io_evcache); +static inline void +io_close_devpoll(int UNUSED x) +{ /* NOTHING */ } +static inline void +io_library_init_devpoll(unsigned int UNUSED ev) +{ /* NOTHING */ } #endif - library_initialized = false; -} -bool -io_event_setcb(int fd, void (*cbfunc) (int, short)) +#ifdef IO_USE_POLL +static int +io_dispatch_poll(struct timeval *tv) { - io_event *i = io_event_get(fd); - if (!i) - return false; - - i->callback = cbfunc; - return true; -} + time_t sec = tv->tv_sec * 1000; + int i, ret, timeout = tv->tv_usec + sec; + int fds_ready; + short what; + struct pollfd *p = array_start(&pollfds); + if (timeout < 0) + timeout = 1000; -bool -io_event_create(int fd, short what, void (*cbfunc) (int, short)) -{ - io_event *i; + ret = poll(p, poll_maxfd + 1, timeout); + if (ret <= 0) + return ret; - assert(fd >= 0); + fds_ready = ret; + for (i=0; i <= poll_maxfd; i++) { + what = 0; + if (p[i].revents & (POLLIN|POLLPRI)) + what = IO_WANTREAD; -#ifdef IO_USE_SELECT -#ifdef FD_SETSIZE - if (fd >= FD_SETSIZE) { - Log(LOG_ERR, - "fd %d exceeds FD_SETSIZE (%u) (select can't handle more file descriptors)", - fd, FD_SETSIZE); - return false; - } -#endif /* FD_SETSIZE */ -#endif /* IO_USE_SELECT */ + if (p[i].revents & POLLOUT) + what |= IO_WANTWRITE; - i = (io_event *) array_alloc(&io_events, sizeof(io_event), fd); - if (!i) { - Log(LOG_WARNING, - "array_alloc failed: could not allocate space for %d io_event structures", - fd); - return false; + if (p[i].revents && !what) { + /* other flag is set, probably POLLERR */ + what = IO_ERROR; + } + if (what) { + fds_ready--; + io_docallback(i, what); + } + if (fds_ready <= 0) + break; } - i->fd = fd; - i->callback = cbfunc; -#ifdef IO_USE_EPOLL - i->what = what; - return io_event_new_epoll(fd, what); -#endif -#ifdef IO_USE_KQUEUE - i->what = what; - return io_event_add_kqueue(fd, what); -#endif -#ifdef IO_USE_SELECT - i->what = 0; - return io_event_add(fd, what); -#endif + return ret; } - -#ifdef IO_USE_EPOLL static bool -io_event_new_epoll(int fd, short what) +io_event_change_poll(int fd, short what) { - struct epoll_event ev = { 0, {0} }; - ev.data.fd = fd; + struct pollfd *p; + short events = 0; if (what & IO_WANTREAD) - ev.events = EPOLLIN | EPOLLPRI; + events = POLLIN | POLLPRI; if (what & IO_WANTWRITE) - ev.events |= EPOLLOUT; - - return epoll_ctl(io_masterfd, EPOLL_CTL_ADD, fd, &ev) == 0; + events |= POLLOUT; + + p = array_alloc(&pollfds, sizeof *p, fd); + if (p) { + p->events = events; + p->fd = fd; + if (fd > poll_maxfd) + poll_maxfd = fd; + } + return p != NULL; } - -static bool -io_event_change_epoll(int fd, short what) +static void +io_close_poll(int fd) { - struct epoll_event ev = { 0, {0} }; - ev.data.fd = fd; - - if (what & IO_WANTREAD) - ev.events = EPOLLIN | EPOLLPRI; - if (what & IO_WANTWRITE) - ev.events |= EPOLLOUT; + struct pollfd *p; + p = array_get(&pollfds, sizeof *p, fd); + if (!p) return; + + p->fd = -1; + if (fd == poll_maxfd) { + while (poll_maxfd > 0) { + --poll_maxfd; + p = array_get(&pollfds, sizeof *p, poll_maxfd); + if (p && p->fd >= 0) + break; + } + } +} - return epoll_ctl(io_masterfd, EPOLL_CTL_MOD, fd, &ev) == 0; +static void +io_library_init_poll(unsigned int eventsize) +{ + struct pollfd *p; + array_init(&pollfds); + poll_maxfd = 0; + Log(LOG_INFO, "IO subsystem: poll (initial maxfd %u).", + eventsize); + p = array_alloc(&pollfds, sizeof(struct pollfd), eventsize); + if (p) { + unsigned i; + p = array_start(&pollfds); + for (i = 0; i < eventsize; i++) + p[i].fd = -1; + + library_initialized = true; + } } +#else +static inline void +io_close_poll(int UNUSED x) +{ /* NOTHING */ } +static inline void +io_library_init_poll(unsigned int UNUSED ev) +{ /* NOTHING */ } #endif -#ifdef IO_USE_KQUEUE -static bool -io_event_kqueue_commit_cache(void) + +#ifdef IO_USE_SELECT +static int +io_dispatch_select(struct timeval *tv) { - struct kevent *events; - bool ret; - int len = (int) array_length(&io_evcache, sizeof (struct kevent)); - - if (!len) /* nothing to do */ - return true; + fd_set readers_tmp; + fd_set writers_tmp; + short what; + int ret, i; + int fds_ready; - assert(len>0); + readers_tmp = readers; + writers_tmp = writers; - if (len < 0) { - array_free(&io_evcache); - return false; - } + ret = select(select_maxfd + 1, &readers_tmp, &writers_tmp, NULL, tv); + if (ret <= 0) + return ret; - events = array_start(&io_evcache); + fds_ready = ret; - assert(events); + for (i = 0; i <= select_maxfd; i++) { + what = 0; + if (FD_ISSET(i, &readers_tmp)) { + what = IO_WANTREAD; + fds_ready--; + } + + if (FD_ISSET(i, &writers_tmp)) { + what |= IO_WANTWRITE; + fds_ready--; + } + if (what) + io_docallback(i, what); + if (fds_ready <= 0) + break; + } - ret = kevent(io_masterfd, events, len, NULL, 0, NULL) == 0; - if (ret) - array_trunc(&io_evcache); return ret; } - -static bool -io_event_add_kqueue(int fd, short what) +static void +io_library_init_select(unsigned int eventsize) { - struct kevent kev; - short filter = 0; - unsigned int len = array_length(&io_evcache, sizeof kev); - - if (what & IO_WANTREAD) - filter = EVFILT_READ; - - if (what & IO_WANTWRITE) - filter |= EVFILT_WRITE; + if (library_initialized) + return; + Log(LOG_INFO, "IO subsystem: select (initial maxfd %u).", + eventsize); + FD_ZERO(&readers); + FD_ZERO(&writers); +#ifdef FD_SETSIZE + if (Conf_MaxConnections >= (int)FD_SETSIZE) { + Log(LOG_WARNING, + "MaxConnections (%d) exceeds limit (%u), changed MaxConnections to %u.", + Conf_MaxConnections, FD_SETSIZE, FD_SETSIZE - 1); - if (len >= 100) { - (void)io_event_kqueue_commit_cache(); + Conf_MaxConnections = FD_SETSIZE - 1; } - - EV_SET(&kev, fd, filter, EV_ADD | EV_ENABLE, 0, 0, NULL); - return array_catb(&io_evcache, (char*) &kev, sizeof (kev)); +#else + Log(LOG_WARNING, + "FD_SETSIZE undefined, don't know how many descriptors select() can handle on your platform ..."); +#endif /* FD_SETSIZE */ + library_initialized = true; } -#endif - -bool -io_event_add(int fd, short what) -{ - io_event *i = io_event_get(fd); - - assert(i); - - if (!i) - return false; - if (i->what == what) - return true; -#ifdef DEBUG - Log(LOG_DEBUG, "io_event_add(): fd %d (arg: %d), what %d.", i->fd, fd, what); -#endif - - i->what |= what; - -#ifdef IO_USE_EPOLL - return io_event_change_epoll(fd, i->what); -#endif - -#ifdef IO_USE_KQUEUE - return io_event_add_kqueue(fd, what); -#endif - -#ifdef IO_USE_SELECT - if (fd > select_maxfd) - select_maxfd = fd; - - if (what & IO_WANTREAD) - FD_SET(fd, &readers); - if (what & IO_WANTWRITE) - FD_SET(fd, &writers); - - return true; -#endif -} - - -bool -io_setnonblock(int fd) +static void +io_close_select(int fd) { - int flags = fcntl(fd, F_GETFL); - if (flags == -1) - return false; - -#ifndef O_NONBLOCK -#define O_NONBLOCK O_NDELAY -#endif - flags |= O_NONBLOCK; - - return fcntl(fd, F_SETFL, flags) == 0; -} + io_event *i; + if (io_masterfd >= 0) /* Are we using epoll()? */ + return; -bool -io_close(int fd) -{ - io_event *i = io_event_get(fd); - if (i) { - memset(i, 0, sizeof(io_event)); - i->fd = -1; - } -#ifdef IO_USE_SELECT FD_CLR(fd, &writers); FD_CLR(fd, &readers); - if (fd == select_maxfd) - select_maxfd--; -#endif -#ifdef IO_USE_KQUEUE - if (array_length(&io_evcache, sizeof (struct kevent))) /* pending data in cache? */ - io_event_kqueue_commit_cache(); -#endif - return close(fd) == 0; /* both epoll an kqueue will remove fd from all sets automatically */ -} - + i = io_event_get(fd); + if (!i) return; -bool -io_event_del(int fd, short what) -{ -#ifdef IO_USE_KQUEUE - struct kevent kev; - short filter = 0; -#endif - io_event *i = io_event_get(fd); -#ifdef DEBUG - Log(LOG_DEBUG, "io_event_del(): trying to delete eventtype %d on fd %d", what, fd); -#endif - assert(i); - if (!i) - return false; + if (fd == select_maxfd) { + while (select_maxfd>0) { + --select_maxfd; /* find largest fd */ + i = io_event_get(select_maxfd); + if (i && i->callback) break; + } + } +} +#else +static inline void +io_library_init_select(int UNUSED x) +{ /* NOTHING */ } +static inline void +io_close_select(int UNUSED x) +{ /* NOTHING */ } +#endif /* SELECT */ - i->what &= ~what; #ifdef IO_USE_EPOLL - return io_event_change_epoll(fd, i->what); -#endif +static bool +io_event_change_epoll(int fd, short what, const int action) +{ + struct epoll_event ev = { 0, {0} }; + ev.data.fd = fd; -#ifdef IO_USE_KQUEUE if (what & IO_WANTREAD) - filter = EVFILT_READ; - - if (what & IO_WANTWRITE) - filter |= EVFILT_WRITE; - - EV_SET(&kev, fd, filter, EV_DELETE, 0, 0, NULL); - return kevent(io_masterfd, &kev, 1, NULL, 0, NULL) == 0; -#endif - -#ifdef IO_USE_SELECT + ev.events = EPOLLIN | EPOLLPRI; if (what & IO_WANTWRITE) - FD_CLR(i->fd, &writers); - - if (what & IO_WANTREAD) - FD_CLR(i->fd, &readers); - - return true; -#endif -} - - -#ifdef IO_USE_SELECT -static int -io_dispatch_select(struct timeval *tv) -{ - fd_set readers_tmp = readers; - fd_set writers_tmp = writers; - short what; - int ret, i; - int fds_ready; - ret = select(select_maxfd + 1, &readers_tmp, &writers_tmp, NULL, tv); - if (ret <= 0) - return ret; - - fds_ready = ret; - - for (i = 0; i <= select_maxfd; i++) { - what = 0; - if (FD_ISSET(i, &readers_tmp)) { - what = IO_WANTREAD; - fds_ready--; - } - - if (FD_ISSET(i, &writers_tmp)) { - what |= IO_WANTWRITE; - fds_ready--; - } - if (what) - io_docallback(i, what); - if (fds_ready <= 0) - break; - } + ev.events |= EPOLLOUT; - return ret; + return epoll_ctl(io_masterfd, action, fd, &ev) == 0; } -#endif - -#ifdef IO_USE_EPOLL static int io_dispatch_epoll(struct timeval *tv) { @@ -512,10 +495,85 @@ io_dispatch_epoll(struct timeval *tv) return total; } + +static void +io_library_init_epoll(unsigned int eventsize) +{ + int ecreate_hint = (int)eventsize; + if (ecreate_hint <= 0) + ecreate_hint = 128; + io_masterfd = epoll_create(ecreate_hint); + if (io_masterfd >= 0) { + library_initialized = true; + Log(LOG_INFO, + "IO subsystem: epoll (hint size %d, initial maxfd %u, masterfd %d).", + ecreate_hint, eventsize, io_masterfd); + return; + } +#ifdef IO_USE_SELECT + Log(LOG_INFO, "Can't initialize epoll() IO interface, falling back to select() ..."); #endif +} +#else +static inline void +io_library_init_epoll(unsigned int UNUSED ev) +{ /* NOTHING */ } +#endif /* IO_USE_EPOLL */ #ifdef IO_USE_KQUEUE +static bool +io_event_kqueue_commit_cache(void) +{ + struct kevent *events; + bool ret; + int len = (int) array_length(&io_evcache, sizeof (struct kevent)); + + if (!len) /* nothing to do */ + return true; + + assert(len>0); + + if (len < 0) { + array_free(&io_evcache); + return false; + } + + events = array_start(&io_evcache); + + assert(events != NULL); + + ret = kevent(io_masterfd, events, len, NULL, 0, NULL) == 0; + if (ret) + array_trunc(&io_evcache); + return ret; +} + +static bool +io_event_change_kqueue(int fd, short what, const int action) +{ + struct kevent kev; + bool ret = true; + + if (what & IO_WANTREAD) { + EV_SET(&kev, fd, EVFILT_READ, action, 0, 0, 0); + ret = array_catb(&io_evcache, (char*) &kev, sizeof (kev)); + if (!ret) + ret = kevent(io_masterfd, &kev,1, NULL, 0, NULL) == 0; + } + + if (ret && (what & IO_WANTWRITE)) { + EV_SET(&kev, fd, EVFILT_WRITE, action, 0, 0, 0); + ret = array_catb(&io_evcache, (char*) &kev, sizeof (kev)); + if (!ret) + ret = kevent(io_masterfd, &kev, 1, NULL, 0, NULL) == 0; + } + + if (array_length(&io_evcache, sizeof kev) >= 100) + io_event_kqueue_commit_cache(); + return ret; +} + static int io_dispatch_kqueue(struct timeval *tv) { @@ -524,24 +582,16 @@ io_dispatch_kqueue(struct timeval *tv) struct kevent *newevents; struct timespec ts; int newevents_len; - short type; ts.tv_sec = tv->tv_sec; ts.tv_nsec = tv->tv_usec * 1000; - + do { - newevents_len = array_length(&io_evcache, sizeof (struct kevent)); + newevents_len = (int) array_length(&io_evcache, sizeof (struct kevent)); newevents = (newevents_len > 0) ? array_start(&io_evcache) : NULL; assert(newevents_len >= 0); - if (newevents_len < 0) - newevents_len = 0; -#ifdef DEBUG - if (newevents_len) - assert(newevents); -#endif - ret = kevent(io_masterfd, newevents, newevents_len, kev, - 100, &ts); - if ((newevents_len>0) && ret != -1) + ret = kevent(io_masterfd, newevents, newevents_len, kev, 100, &ts); + if (newevents && ret != -1) array_trunc(&io_evcache); total += ret; @@ -549,44 +599,319 @@ io_dispatch_kqueue(struct timeval *tv) return total; for (i = 0; i < ret; i++) { - type = 0; - if (kev[i].flags & EV_EOF) - type = IO_ERROR; + io_debug("dispatch_kqueue: fd, kev.flags", (int)kev[i].ident, kev[i].flags); + if (kev[i].flags & (EV_EOF|EV_ERROR)) { + if (kev[i].flags & EV_ERROR) + Log(LOG_ERR, "kevent fd %d: EV_ERROR (%s)", + (int)kev[i].ident, strerror((int)kev[i].data)); + io_docallback((int)kev[i].ident, IO_ERROR); + continue; + } + + switch (kev[i].filter) { + case EVFILT_READ: + io_docallback((int)kev[i].ident, IO_WANTREAD); + break; + case EVFILT_WRITE: + io_docallback((int)kev[i].ident, IO_WANTWRITE); + break; + default: + LogDebug("Unknown kev.filter number %d for fd %d", + kev[i].filter, kev[i].ident); + /* Fall through */ + case EV_ERROR: + io_docallback((int)kev[i].ident, IO_ERROR); + break; + } + } + ts.tv_sec = 0; + ts.tv_nsec = 0; + } while (ret == 100); - if (kev[i].filter & EV_ERROR) - type = IO_ERROR; + return total; +} - if (kev[i].filter & EVFILT_READ) - type |= IO_WANTREAD; +static void +io_library_init_kqueue(unsigned int eventsize) +{ + io_masterfd = kqueue(); - if (kev[i].filter & EVFILT_WRITE) - type |= IO_WANTWRITE; + Log(LOG_INFO, + "IO subsystem: kqueue (initial maxfd %u, masterfd %d)", + eventsize, io_masterfd); + if (io_masterfd >= 0) + library_initialized = true; +} +#else +static inline void +io_library_init_kqueue(unsigned int UNUSED ev) +{ /* NOTHING */ } +#endif - io_docallback(kev[i].ident, type); - } - ts.tv_sec = 0; - ts.tv_nsec = 0; +bool +io_library_init(unsigned int eventsize) +{ + if (library_initialized) + return true; - } while (ret == 100); + if ((eventsize > 0) && !array_alloc(&io_events, sizeof(io_event), (size_t)eventsize)) + eventsize = 0; - return total; + io_library_init_epoll(eventsize); + io_library_init_kqueue(eventsize); + io_library_init_devpoll(eventsize); + io_library_init_poll(eventsize); + io_library_init_select(eventsize); + + return library_initialized; } + + +void +io_library_shutdown(void) +{ +#ifdef IO_USE_SELECT + FD_ZERO(&readers); + FD_ZERO(&writers); #endif +#if defined(IO_USE_EPOLL) || defined(IO_USE_KQUEUE) || defined(IO_USE_DEVPOLL) + if (io_masterfd >= 0) + close(io_masterfd); + io_masterfd = -1; +#endif +#ifdef IO_USE_KQUEUE + array_free(&io_evcache); +#endif + library_initialized = false; +} + + +bool +io_event_setcb(int fd, void (*cbfunc) (int, short)) +{ + io_event *i = io_event_get(fd); + if (!i) + return false; + + i->callback = cbfunc; + return true; +} + + +static bool +backend_create_ev(int fd, short what) +{ + bool ret; +#ifdef IO_USE_DEVPOLL + ret = io_event_change_devpoll(fd, what); +#endif +#ifdef IO_USE_POLL + ret = io_event_change_poll(fd, what); +#endif +#ifdef IO_USE_EPOLL + ret = io_event_change_epoll(fd, what, EPOLL_CTL_ADD); +#endif +#ifdef IO_USE_KQUEUE + ret = io_event_change_kqueue(fd, what, EV_ADD|EV_ENABLE); +#endif +#ifdef IO_USE_SELECT + if (io_masterfd < 0) + ret = io_event_add(fd, what); +#endif + return ret; +} + + +bool +io_event_create(int fd, short what, void (*cbfunc) (int, short)) +{ + bool ret; + io_event *i; + + assert(fd >= 0); +#if defined(IO_USE_SELECT) && defined(FD_SETSIZE) + if (io_masterfd < 0 && fd >= FD_SETSIZE) { + Log(LOG_ERR, + "fd %d exceeds FD_SETSIZE (%u) (select can't handle more file descriptors)", + fd, FD_SETSIZE); + return false; + } +#endif + i = (io_event *) array_alloc(&io_events, sizeof(io_event), (size_t) fd); + if (!i) { + Log(LOG_WARNING, + "array_alloc failed: could not allocate space for %d io_event structures", + fd); + return false; + } + + i->callback = cbfunc; + i->what = 0; + ret = backend_create_ev(fd, what); + if (ret) + i->what = what; + return ret; +} + + +bool +io_event_add(int fd, short what) +{ + io_event *i = io_event_get(fd); + + if (!i) return false; + + if ((i->what & what) == what) /* event type is already registered */ + return true; + + io_debug("io_event_add: fd, what", fd, what); + + i->what |= what; +#ifdef IO_USE_EPOLL + if (io_masterfd >= 0) + return io_event_change_epoll(fd, i->what, EPOLL_CTL_MOD); +#endif +#ifdef IO_USE_KQUEUE + return io_event_change_kqueue(fd, what, EV_ADD | EV_ENABLE); +#endif +#ifdef IO_USE_DEVPOLL + return io_event_change_devpoll(fd, i->what); +#endif +#ifdef IO_USE_POLL + return io_event_change_poll(fd, i->what); +#endif +#ifdef IO_USE_SELECT + if (fd > select_maxfd) + select_maxfd = fd; + + if (what & IO_WANTREAD) + FD_SET(fd, &readers); + if (what & IO_WANTWRITE) + FD_SET(fd, &writers); + + return true; +#endif + return false; +} + + +bool +io_setnonblock(int fd) +{ + int flags = fcntl(fd, F_GETFL); + if (flags == -1) + return false; +#ifndef O_NONBLOCK +#define O_NONBLOCK O_NDELAY +#endif + flags |= O_NONBLOCK; + + return fcntl(fd, F_SETFL, flags) == 0; +} + +bool +io_setcloexec(int fd) +{ + int flags = fcntl(fd, F_GETFD); + if (flags == -1) + return false; +#ifdef FD_CLOEXEC + flags |= FD_CLOEXEC; +#endif + + return fcntl(fd, F_SETFD, flags) == 0; +} + +bool +io_close(int fd) +{ + io_event *i; + + i = io_event_get(fd); +#ifdef IO_USE_KQUEUE + if (array_length(&io_evcache, sizeof (struct kevent))) /* pending data in cache? */ + io_event_kqueue_commit_cache(); + + /* both kqueue and epoll remove fd from all sets automatically on the last close + * of the descriptor. since we don't know if this is the last close we'll have + * to remove the set explicitly. */ + if (i) { + io_event_change_kqueue(fd, i->what, EV_DELETE); + io_event_kqueue_commit_cache(); + } +#endif + io_close_devpoll(fd); + io_close_poll(fd); + io_close_select(fd); +#ifdef IO_USE_EPOLL + io_event_change_epoll(fd, 0, EPOLL_CTL_DEL); +#endif + if (i) { + i->callback = NULL; + i->what = 0; + } + return close(fd) == 0; +} + + +bool +io_event_del(int fd, short what) +{ + io_event *i = io_event_get(fd); + + io_debug("io_event_del: trying to delete eventtype; fd, what", fd, what); + if (!i) return false; + + if (!(i->what & what)) /* event is already disabled */ + return true; + + i->what &= ~what; +#ifdef IO_USE_DEVPOLL + return io_event_change_devpoll(fd, i->what); +#endif +#ifdef IO_USE_POLL + return io_event_change_poll(fd, i->what); +#endif +#ifdef IO_USE_EPOLL + if (io_masterfd >= 0) + return io_event_change_epoll(fd, i->what, EPOLL_CTL_MOD); +#endif +#ifdef IO_USE_KQUEUE + return io_event_change_kqueue(fd, what, EV_DISABLE); +#endif +#ifdef IO_USE_SELECT + if (what & IO_WANTWRITE) + FD_CLR(fd, &writers); + + if (what & IO_WANTREAD) + FD_CLR(fd, &readers); + return true; +#endif + return false; +} int io_dispatch(struct timeval *tv) { +#ifdef IO_USE_EPOLL + if (io_masterfd >= 0) + return io_dispatch_epoll(tv); +#endif #ifdef IO_USE_SELECT return io_dispatch_select(tv); #endif #ifdef IO_USE_KQUEUE return io_dispatch_kqueue(tv); #endif -#ifdef IO_USE_EPOLL - return io_dispatch_epoll(tv); +#ifdef IO_USE_DEVPOLL + return io_dispatch_devpoll(tv); +#endif +#ifdef IO_USE_POLL + return io_dispatch_poll(tv); #endif + return -1; } @@ -594,14 +919,13 @@ io_dispatch(struct timeval *tv) static void io_docallback(int fd, short what) { - io_event *i; -#ifdef DEBUG - Log(LOG_DEBUG, "doing callback for fd %d, what %d", fd, what); -#endif - i = io_event_get(fd); - assert(i); + io_event *i = io_event_get(fd); + + io_debug("io_docallback; fd, what", fd, what); - if (i->callback) /* callback might be 0 if previous callback function called io_close on this fd */ + if (i->callback) { /* callback might be NULL if a previous callback function + called io_close on this fd */ i->callback(fd, (what & IO_ERROR) ? i->what : what); - /* if error indicator is set, we return the event(s) the app asked for */ + } + /* if error indicator is set, we return the event(s) that were registered */ }