X-Git-Url: http://git.pk910.de/?a=blobdiff_plain;f=ircd%2Fengine_kqueue.c;h=b3f535f7d8db52825068a42f959ac06d62cadd9b;hb=f50e98744ac3e53605d59a2f313d610c9abc8f26;hp=aafbb59b692822a4463495a0213d4028e1c4c689;hpb=fda30451cac5936729c683d38a700f4928812c6f;p=ircu2.10.12-pk.git diff --git a/ircd/engine_kqueue.c b/ircd/engine_kqueue.c index aafbb59..b3f535f 100644 --- a/ircd/engine_kqueue.c +++ b/ircd/engine_kqueue.c @@ -15,8 +15,10 @@ * 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. - * - * $Id$ + */ +/** @file + * @brief FreeBSD kqueue()/kevent() event engine. + * @version $Id$ */ #include "config.h" @@ -24,32 +26,44 @@ #include "ircd.h" #include "ircd_alloc.h" +#include "ircd_features.h" #include "ircd_log.h" #include "s_debug.h" -#include +/* #include -- Now using assert in ircd_log.h */ #include #include +#include #include #include #include -#include #include #include -#define KQUEUE_ERROR_THRESHOLD 20 /* after 20 kqueue errors, restart */ -#define ERROR_EXPIRE_TIME 3600 /* expire errors after an hour */ - -#define POLLS_PER_KQUEUE 20 /* get 20 kevents per turn */ +#define KQUEUE_ERROR_THRESHOLD 20 /**< after 20 kqueue errors, restart */ +#define ERROR_EXPIRE_TIME 3600 /**< expire errors after an hour */ +/** Array of active Socket structures, indexed by file descriptor. */ static struct Socket** sockList; +/** Maximum file descriptor supported, plus one. */ static int kqueue_max; +/** File descriptor for kqueue pseudo-file. */ static int kqueue_id; - +/** Current array of event descriptors. */ +static struct kevent *events; +/** Number of ::events elements that have been populated. */ +static int events_used; +/** Current processing position in ::events. */ +static int events_i; + +/** Number of recent errors from kqueue. */ static int errors = 0; +/** Periodic timer to forget errors. */ static struct Timer clear_error; -/* decrements the error count once per hour */ +/** Decrement the error count (once per hour). + * @param[in] ev Expired timer event (ignored). + */ static void error_clear(struct Event* ev) { @@ -57,7 +71,10 @@ error_clear(struct Event* ev) timer_del(ev_timer(ev)); } -/* initialize the kqueue engine */ +/** Initialize the kqueue engine. + * @param[in] max_sockets Maximum number of file descriptors to support. + * @return Non-zero on success, or zero on failure. + */ static int engine_init(int max_sockets) { @@ -81,14 +98,16 @@ engine_init(int max_sockets) return 1; /* success! */ } -/* add a signel to be watched for */ +/** Add a signal to the event engine. + * @param[in] sig Signal to add to engine. + */ static void engine_signal(struct Signal* sig) { struct kevent sigevent; struct sigaction act; - assert(0 != signal); + assert(0 != sig); Debug((DEBUG_ENGINE, "kqueue: Adding filter for signal %d [%p]", sig_signal(sig), sig)); @@ -112,7 +131,11 @@ engine_signal(struct Signal* sig) sigaction(sig_signal(sig), &act, 0); } -/* Figure out what events go with a given state */ +/** Figure out what events go with a given state. + * @param[in] state %Socket state to consider. + * @param[in] events User-specified preferred event set. + * @return Actual set of preferred events. + */ static unsigned int state_to_events(enum SocketState state, unsigned int events) { @@ -135,7 +158,11 @@ state_to_events(enum SocketState state, unsigned int events) return 0; } -/* Activate kqueue filters as appropriate */ +/** Activate kqueue filters as appropriate. + * @param[in] sock Socket structure to operate on. + * @param[in] clear Set of interest events to clear from socket. + * @param[in] set Set of interest events to set on socket. + */ static void set_or_clear(struct Socket* sock, unsigned int clear, unsigned int set) { @@ -177,11 +204,14 @@ set_or_clear(struct Socket* sock, unsigned int clear, unsigned int set) i++; /* advance count... */ } - if (kevent(kqueue_id, chglist, i, 0, 0, 0) < 0) + if (kevent(kqueue_id, chglist, i, 0, 0, 0) < 0 && errno != EBADF) event_generate(ET_ERROR, sock, errno); /* report error */ } -/* add a socket to be listened on */ +/** Add a socket to the event engine. + * @param[in] sock Socket to add to engine. + * @return Non-zero on success, or zero on error. + */ static int engine_add(struct Socket* sock) { @@ -207,7 +237,10 @@ engine_add(struct Socket* sock) return 1; /* success */ } -/* socket switching to new state */ +/** Handle state transition for a socket. + * @param[in] sock Socket changing state. + * @param[in] new_state New state for socket. + */ static void engine_state(struct Socket* sock, enum SocketState new_state) { @@ -224,7 +257,10 @@ engine_state(struct Socket* sock, enum SocketState new_state) } -/* socket events changing */ +/** Handle change to preferred socket events. + * @param[in] sock Socket getting new interest list. + * @param[in] new_events New set of interesting events for socket. + */ static void engine_events(struct Socket* sock, unsigned int new_events) { @@ -240,11 +276,13 @@ engine_events(struct Socket* sock, unsigned int new_events) state_to_events(s_state(sock), new_events)); /* new events */ } -/* socket going away */ +/** Remove a socket from the event engine. + * @param[in] sock Socket being destroyed. + */ static void engine_delete(struct Socket* sock) { - struct kevent dellist[2]; + int ii; assert(0 != sock); assert(sock == sockList[s_fd(sock)]); @@ -252,60 +290,59 @@ engine_delete(struct Socket* sock) Debug((DEBUG_ENGINE, "kqueue: Deleting socket %d [%p], state %s", s_fd(sock), sock, state_to_name(s_state(sock)))); - dellist[0].ident = s_fd(sock); /* set up the delete list */ - dellist[0].filter = EVFILT_READ; /* readable filter */ - dellist[0].flags = EV_DELETE; /* delete it */ - dellist[0].fflags = 0; - dellist[0].data = 0; - dellist[0].udata = 0; - - dellist[1].ident = s_fd(sock); - dellist[1].filter = EVFILT_WRITE; /* writable filter */ - dellist[1].flags = EV_DELETE; /* delete it */ - dellist[1].fflags = 0; - dellist[1].data = 0; - dellist[1].udata = 0; - - /* make it all go away */ - if (kevent(kqueue_id, dellist, 2, 0, 0, 0) < 0) - log_write(LS_SOCKET, L_WARNING, 0, - "Unable to delete kevent items for socket %d", s_fd(sock)); - sockList[s_fd(sock)] = 0; + + /* Drop any unprocessed events citing this socket. */ + for (ii = events_i; ii < events_used; ii++) { + if (events[ii].ident == s_fd(sock)) { + events[ii] = events[--events_used]; + } + } } -/* engine event loop */ +/** Run engine event loop. + * @param[in] gen Lists of generators of various types. + */ static void engine_loop(struct Generators* gen) { - struct kevent events[POLLS_PER_KQUEUE]; + int events_count; + struct kevent *evt; struct Socket* sock; struct timespec wait; - int nevs; int i; int errcode; - size_t codesize; + socklen_t codesize; + + if ((events_count = feature_int(FEAT_POLLS_PER_LOOP)) < 20) + events_count = 20; + events = (struct kevent *)MyMalloc(sizeof(struct kevent) * events_count); while (running) { + if ((i = feature_int(FEAT_POLLS_PER_LOOP)) >= 20 && i != events_count) { + events = (struct kevent *)MyRealloc(events, sizeof(struct kevent) * i); + events_count = i; + } + /* set up the sleep time */ wait.tv_sec = timer_next(gen) ? (timer_next(gen) - CurrentTime) : -1; wait.tv_nsec = 0; - Debug((DEBUG_INFO, "kqueue: delay: %Tu (%Tu) %Tu", timer_next(gen), + Debug((DEBUG_ENGINE, "kqueue: delay: %Tu (%Tu) %Tu", timer_next(gen), CurrentTime, wait.tv_sec)); /* check for active events */ - nevs = kevent(kqueue_id, 0, 0, events, POLLS_PER_KQUEUE, - wait.tv_sec < 0 ? 0 : &wait); + events_used = kevent(kqueue_id, 0, 0, events, events_count, + wait.tv_sec < 0 ? 0 : &wait); CurrentTime = time(0); /* set current time... */ - if (nevs < 0) { + if (events_used < 0) { if (errno != EINTR) { /* ignore kevent interrupts */ /* Log the kqueue error */ log_write(LS_SOCKET, L_ERROR, 0, "kevent() error: %m"); if (!errors++) - timer_add(&clear_error, error_clear, 0, TT_PERIODIC, + timer_add(timer_init(&clear_error), error_clear, 0, TT_PERIODIC, ERROR_EXPIRE_TIME); else if (errors > KQUEUE_ERROR_THRESHOLD) /* too many errors... */ server_restart("too many kevent errors"); @@ -316,21 +353,22 @@ engine_loop(struct Generators* gen) continue; } - for (i = 0; i < nevs; i++) { - if (events[i].filter == EVFILT_SIGNAL) { + for (events_i = 0; events_i < events_used; events_i++) { + evt = &events[events_i]; + + if (evt->filter == EVFILT_SIGNAL) { /* it's a signal; deal appropriately */ - event_generate(ET_SIGNAL, events[i].udata, events[i].ident); + event_generate(ET_SIGNAL, evt->udata, evt->ident); continue; /* skip socket processing loop */ } - assert(events[i].filter == EVFILT_READ || - events[i].filter == EVFILT_WRITE); + assert(evt->filter == EVFILT_READ || evt->filter == EVFILT_WRITE); - sock = sockList[events[i].ident]; + sock = sockList[evt->ident]; if (!sock) /* slots may become empty while processing events */ continue; - assert(s_fd(sock) == events[i].ident); + assert(s_fd(sock) == evt->ident); gen_ref_inc(sock); /* can't have it going away on us */ @@ -356,14 +394,14 @@ engine_loop(struct Generators* gen) switch (s_state(sock)) { case SS_CONNECTING: - if (events[i].filter == EVFILT_WRITE) { /* connection completed */ + if (evt->filter == EVFILT_WRITE) { /* connection completed */ Debug((DEBUG_ENGINE, "kqueue: Connection completed")); event_generate(ET_CONNECT, sock, 0); } break; case SS_LISTENING: - if (events[i].filter == EVFILT_READ) { /* connect. to be accept. */ + if (evt->filter == EVFILT_READ) { /* connect. to be accept. */ Debug((DEBUG_ENGINE, "kqueue: Ready for accept")); event_generate(ET_ACCEPT, sock, 0); } @@ -371,30 +409,28 @@ engine_loop(struct Generators* gen) case SS_NOTSOCK: /* doing nothing socket-specific */ case SS_CONNECTED: - if (events[i].filter == EVFILT_READ) { /* data on socket */ + if (evt->filter == EVFILT_READ) { /* data on socket */ Debug((DEBUG_ENGINE, "kqueue: EOF or data to be read")); - event_generate(events[i].flags & EV_EOF ? ET_EOF : ET_READ, sock, 0); + event_generate(evt->flags & EV_EOF ? ET_EOF : ET_READ, sock, 0); } - if (events[i].filter == EVFILT_WRITE) { /* socket writable */ + if (evt->filter == EVFILT_WRITE) { /* socket writable */ Debug((DEBUG_ENGINE, "kqueue: Data can be written")); event_generate(ET_WRITE, sock, 0); } break; case SS_DATAGRAM: case SS_CONNECTDG: - if (events[i].filter == EVFILT_READ) { /* socket readable */ + if (evt->filter == EVFILT_READ) { /* socket readable */ Debug((DEBUG_ENGINE, "kqueue: Datagram to be read")); event_generate(ET_READ, sock, 0); } - if (events[i].filter == EVFILT_WRITE) { /* socket writable */ + if (evt->filter == EVFILT_WRITE) { /* socket writable */ Debug((DEBUG_ENGINE, "kqueue: Datagram can be written")); event_generate(ET_WRITE, sock, 0); } break; } - assert(s_fd(sock) == events[i].ident); - gen_ref_dec(sock); /* we're done with it */ } @@ -402,6 +438,7 @@ engine_loop(struct Generators* gen) } } +/** Descriptor for kqueue() event engine. */ struct Engine engine_kqueue = { "kqueue()", /* Engine name */ engine_init, /* Engine initialization function */