![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to kqueue.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libevent|
Return to kqueue.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libevent |
1.1 misho 1: /* $OpenBSD: kqueue.c,v 1.5 2002/07/10 14:41:31 art Exp $ */
2:
3: /*
4: * Copyright 2000-2002 Niels Provos <provos@citi.umich.edu>
5: * All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. The name of the author may not be used to endorse or promote products
16: * derived from this software without specific prior written permission.
17: *
18: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28: */
29: #ifdef HAVE_CONFIG_H
30: #include "config.h"
31: #endif
32:
33: #define _GNU_SOURCE 1
34:
35: #include <sys/types.h>
36: #ifdef HAVE_SYS_TIME_H
37: #include <sys/time.h>
38: #else
39: #include <sys/_libevent_time.h>
40: #endif
41: #include <sys/queue.h>
42: #include <sys/event.h>
43: #include <signal.h>
44: #include <stdio.h>
45: #include <stdlib.h>
46: #include <string.h>
47: #include <unistd.h>
48: #include <errno.h>
49: #include <assert.h>
50: #ifdef HAVE_INTTYPES_H
51: #include <inttypes.h>
52: #endif
53:
54: /* Some platforms apparently define the udata field of struct kevent as
55: * intptr_t, whereas others define it as void*. There doesn't seem to be an
56: * easy way to tell them apart via autoconf, so we need to use OS macros. */
57: #if defined(HAVE_INTTYPES_H) && !defined(__OpenBSD__) && !defined(__FreeBSD__) && !defined(__darwin__) && !defined(__APPLE__)
58: #define PTR_TO_UDATA(x) ((intptr_t)(x))
59: #else
60: #define PTR_TO_UDATA(x) (x)
61: #endif
62:
63: #include "event.h"
64: #include "event-internal.h"
65: #include "log.h"
66: #include "evsignal.h"
67:
68: #define EVLIST_X_KQINKERNEL 0x1000
69:
70: #define NEVENT 64
71:
72: struct kqop {
73: struct kevent *changes;
74: int nchanges;
75: struct kevent *events;
76: struct event_list evsigevents[NSIG];
77: int nevents;
78: int kq;
79: pid_t pid;
80: };
81:
82: static void *kq_init (struct event_base *);
83: static int kq_add (void *, struct event *);
84: static int kq_del (void *, struct event *);
85: static int kq_dispatch (struct event_base *, void *, struct timeval *);
86: static int kq_insert (struct kqop *, struct kevent *);
87: static void kq_dealloc (struct event_base *, void *);
88:
89: const struct eventop kqops = {
90: "kqueue",
91: kq_init,
92: kq_add,
93: kq_del,
94: kq_dispatch,
95: kq_dealloc,
96: 1 /* need reinit */
97: };
98:
99: static void *
100: kq_init(struct event_base *base)
101: {
102: int i, kq;
103: struct kqop *kqueueop;
104:
105: /* Disable kqueue when this environment variable is set */
106: if (evutil_getenv("EVENT_NOKQUEUE"))
107: return (NULL);
108:
109: if (!(kqueueop = calloc(1, sizeof(struct kqop))))
110: return (NULL);
111:
112: /* Initalize the kernel queue */
113:
114: if ((kq = kqueue()) == -1) {
115: event_warn("kqueue");
116: free (kqueueop);
117: return (NULL);
118: }
119:
120: kqueueop->kq = kq;
121:
122: kqueueop->pid = getpid();
123:
124: /* Initalize fields */
125: kqueueop->changes = malloc(NEVENT * sizeof(struct kevent));
126: if (kqueueop->changes == NULL) {
127: free (kqueueop);
128: return (NULL);
129: }
130: kqueueop->events = malloc(NEVENT * sizeof(struct kevent));
131: if (kqueueop->events == NULL) {
132: free (kqueueop->changes);
133: free (kqueueop);
134: return (NULL);
135: }
136: kqueueop->nevents = NEVENT;
137:
138: /* we need to keep track of multiple events per signal */
139: for (i = 0; i < NSIG; ++i) {
140: TAILQ_INIT(&kqueueop->evsigevents[i]);
141: }
142:
143: /* Check for Mac OS X kqueue bug. */
144: memset(&kqueueop->changes[0], 0, sizeof kqueueop->changes[0]);
145: kqueueop->changes[0].ident = -1;
146: kqueueop->changes[0].filter = EVFILT_READ;
147: kqueueop->changes[0].flags = EV_ADD;
148: /*
149: * If kqueue works, then kevent will succeed, and it will
150: * stick an error in events[0]. If kqueue is broken, then
151: * kevent will fail.
152: */
153: if (kevent(kq,
154: kqueueop->changes, 1, kqueueop->events, NEVENT, NULL) != 1 ||
155: kqueueop->events[0].ident != -1 ||
156: kqueueop->events[0].flags != EV_ERROR) {
157: event_warn("%s: detected broken kqueue; not using.", __func__);
158: free(kqueueop->changes);
159: free(kqueueop->events);
160: free(kqueueop);
161: close(kq);
162: return (NULL);
163: }
164:
165: return (kqueueop);
166: }
167:
168: static int
169: kq_insert(struct kqop *kqop, struct kevent *kev)
170: {
171: int nevents = kqop->nevents;
172:
173: if (kqop->nchanges == nevents) {
174: struct kevent *newchange;
175: struct kevent *newresult;
176:
177: nevents *= 2;
178:
179: newchange = realloc(kqop->changes,
180: nevents * sizeof(struct kevent));
181: if (newchange == NULL) {
182: event_warn("%s: malloc", __func__);
183: return (-1);
184: }
185: kqop->changes = newchange;
186:
187: newresult = realloc(kqop->events,
188: nevents * sizeof(struct kevent));
189:
190: /*
191: * If we fail, we don't have to worry about freeing,
192: * the next realloc will pick it up.
193: */
194: if (newresult == NULL) {
195: event_warn("%s: malloc", __func__);
196: return (-1);
197: }
198: kqop->events = newresult;
199:
200: kqop->nevents = nevents;
201: }
202:
203: memcpy(&kqop->changes[kqop->nchanges++], kev, sizeof(struct kevent));
204:
205: event_debug(("%s: fd %d %s%s",
206: __func__, (int)kev->ident,
207: kev->filter == EVFILT_READ ? "EVFILT_READ" : "EVFILT_WRITE",
208: kev->flags == EV_DELETE ? " (del)" : ""));
209:
210: return (0);
211: }
212:
213: static void
214: kq_sighandler(int sig)
215: {
216: /* Do nothing here */
217: }
218:
219: static int
220: kq_dispatch(struct event_base *base, void *arg, struct timeval *tv)
221: {
222: struct kqop *kqop = arg;
223: struct kevent *changes = kqop->changes;
224: struct kevent *events = kqop->events;
225: struct event *ev;
226: struct timespec ts, *ts_p = NULL;
227: int i, res;
228:
229: if (tv != NULL) {
230: TIMEVAL_TO_TIMESPEC(tv, &ts);
231: ts_p = &ts;
232: }
233:
234: res = kevent(kqop->kq, changes, kqop->nchanges,
235: events, kqop->nevents, ts_p);
236: kqop->nchanges = 0;
237: if (res == -1) {
238: if (errno != EINTR) {
239: event_warn("kevent");
240: return (-1);
241: }
242:
243: return (0);
244: }
245:
246: event_debug(("%s: kevent reports %d", __func__, res));
247:
248: for (i = 0; i < res; i++) {
249: int which = 0;
250:
251: if (events[i].flags & EV_ERROR) {
252: /*
253: * Error messages that can happen, when a delete fails.
254: * EBADF happens when the file discriptor has been
255: * closed,
256: * ENOENT when the file discriptor was closed and
257: * then reopened.
258: * EINVAL for some reasons not understood; EINVAL
259: * should not be returned ever; but FreeBSD does :-\
260: * An error is also indicated when a callback deletes
261: * an event we are still processing. In that case
262: * the data field is set to ENOENT.
263: */
264: if (events[i].data == EBADF ||
265: events[i].data == EINVAL ||
266: events[i].data == ENOENT)
267: continue;
268: errno = events[i].data;
269: return (-1);
270: }
271:
272: if (events[i].filter == EVFILT_READ) {
273: which |= EV_READ;
274: } else if (events[i].filter == EVFILT_WRITE) {
275: which |= EV_WRITE;
276: } else if (events[i].filter == EVFILT_SIGNAL) {
277: which |= EV_SIGNAL;
278: }
279:
280: if (!which)
281: continue;
282:
283: if (events[i].filter == EVFILT_SIGNAL) {
284: struct event_list *head =
285: (struct event_list *)events[i].udata;
286: TAILQ_FOREACH(ev, head, ev_signal_next) {
287: event_active(ev, which, events[i].data);
288: }
289: } else {
290: ev = (struct event *)events[i].udata;
291:
292: if (!(ev->ev_events & EV_PERSIST))
293: ev->ev_flags &= ~EVLIST_X_KQINKERNEL;
294:
295: event_active(ev, which, 1);
296: }
297: }
298:
299: return (0);
300: }
301:
302:
303: static int
304: kq_add(void *arg, struct event *ev)
305: {
306: struct kqop *kqop = arg;
307: struct kevent kev;
308:
309: if (ev->ev_events & EV_SIGNAL) {
310: int nsignal = EVENT_SIGNAL(ev);
311:
312: assert(nsignal >= 0 && nsignal < NSIG);
313: if (TAILQ_EMPTY(&kqop->evsigevents[nsignal])) {
314: struct timespec timeout = { 0, 0 };
315:
316: memset(&kev, 0, sizeof(kev));
317: kev.ident = nsignal;
318: kev.filter = EVFILT_SIGNAL;
319: kev.flags = EV_ADD;
320: kev.udata = PTR_TO_UDATA(&kqop->evsigevents[nsignal]);
321:
322: /* Be ready for the signal if it is sent any
323: * time between now and the next call to
324: * kq_dispatch. */
325: if (kevent(kqop->kq, &kev, 1, NULL, 0, &timeout) == -1)
326: return (-1);
327:
328: if (_evsignal_set_handler(ev->ev_base, nsignal,
329: kq_sighandler) == -1)
330: return (-1);
331: }
332:
333: TAILQ_INSERT_TAIL(&kqop->evsigevents[nsignal], ev,
334: ev_signal_next);
335: ev->ev_flags |= EVLIST_X_KQINKERNEL;
336: return (0);
337: }
338:
339: if (ev->ev_events & EV_READ) {
340: memset(&kev, 0, sizeof(kev));
341: kev.ident = ev->ev_fd;
342: kev.filter = EVFILT_READ;
343: #ifdef NOTE_EOF
344: /* Make it behave like select() and poll() */
345: kev.fflags = NOTE_EOF;
346: #endif
347: kev.flags = EV_ADD;
348: if (!(ev->ev_events & EV_PERSIST))
349: kev.flags |= EV_ONESHOT;
350: kev.udata = PTR_TO_UDATA(ev);
351:
352: if (kq_insert(kqop, &kev) == -1)
353: return (-1);
354:
355: ev->ev_flags |= EVLIST_X_KQINKERNEL;
356: }
357:
358: if (ev->ev_events & EV_WRITE) {
359: memset(&kev, 0, sizeof(kev));
360: kev.ident = ev->ev_fd;
361: kev.filter = EVFILT_WRITE;
362: kev.flags = EV_ADD;
363: if (!(ev->ev_events & EV_PERSIST))
364: kev.flags |= EV_ONESHOT;
365: kev.udata = PTR_TO_UDATA(ev);
366:
367: if (kq_insert(kqop, &kev) == -1)
368: return (-1);
369:
370: ev->ev_flags |= EVLIST_X_KQINKERNEL;
371: }
372:
373: return (0);
374: }
375:
376: static int
377: kq_del(void *arg, struct event *ev)
378: {
379: struct kqop *kqop = arg;
380: struct kevent kev;
381:
382: if (!(ev->ev_flags & EVLIST_X_KQINKERNEL))
383: return (0);
384:
385: if (ev->ev_events & EV_SIGNAL) {
386: int nsignal = EVENT_SIGNAL(ev);
387: struct timespec timeout = { 0, 0 };
388:
389: assert(nsignal >= 0 && nsignal < NSIG);
390: TAILQ_REMOVE(&kqop->evsigevents[nsignal], ev, ev_signal_next);
391: if (TAILQ_EMPTY(&kqop->evsigevents[nsignal])) {
392: memset(&kev, 0, sizeof(kev));
393: kev.ident = nsignal;
394: kev.filter = EVFILT_SIGNAL;
395: kev.flags = EV_DELETE;
396:
397: /* Because we insert signal events
398: * immediately, we need to delete them
399: * immediately, too */
400: if (kevent(kqop->kq, &kev, 1, NULL, 0, &timeout) == -1)
401: return (-1);
402:
403: if (_evsignal_restore_handler(ev->ev_base,
404: nsignal) == -1)
405: return (-1);
406: }
407:
408: ev->ev_flags &= ~EVLIST_X_KQINKERNEL;
409: return (0);
410: }
411:
412: if (ev->ev_events & EV_READ) {
413: memset(&kev, 0, sizeof(kev));
414: kev.ident = ev->ev_fd;
415: kev.filter = EVFILT_READ;
416: kev.flags = EV_DELETE;
417:
418: if (kq_insert(kqop, &kev) == -1)
419: return (-1);
420:
421: ev->ev_flags &= ~EVLIST_X_KQINKERNEL;
422: }
423:
424: if (ev->ev_events & EV_WRITE) {
425: memset(&kev, 0, sizeof(kev));
426: kev.ident = ev->ev_fd;
427: kev.filter = EVFILT_WRITE;
428: kev.flags = EV_DELETE;
429:
430: if (kq_insert(kqop, &kev) == -1)
431: return (-1);
432:
433: ev->ev_flags &= ~EVLIST_X_KQINKERNEL;
434: }
435:
436: return (0);
437: }
438:
439: static void
440: kq_dealloc(struct event_base *base, void *arg)
441: {
442: struct kqop *kqop = arg;
443:
444: evsignal_dealloc(base);
445:
446: if (kqop->changes)
447: free(kqop->changes);
448: if (kqop->events)
449: free(kqop->events);
450: if (kqop->kq >= 0 && kqop->pid == getpid())
451: close(kqop->kq);
452:
453: memset(kqop, 0, sizeof(struct kqop));
454: free(kqop);
455: }