![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to io.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / ircnowd / src / ngircd|
Return to io.c CVS log | Up to [local] / ircnowd / src / ngircd |
1.1 tomglok 1: /*
2: * ngIRCd -- The Next Generation IRC Daemon
3: * Copyright (c)2005-2006 Florian Westphal (westphal@foo.fh-furtwangen.de)
4: * Copyright (c)2006-2014 Alexander Barton (alex@barton.de) and Contributors.
5: *
6: * This program is free software; you can redistribute it and/or modify
7: * it under the terms of the GNU General Public License as published by
8: * the Free Software Foundation; either version 2 of the License, or
9: * (at your option) any later version.
10: * Please read the file COPYING, README and AUTHORS for more information.
11: */
12:
13: #include "portab.h"
14:
15: /**
16: * @file
17: * I/O abstraction interface.
18: */
19:
20: /* Extra debug messages in event add/delete/callback code: 0=off / 1=on */
21: #define DEBUG_IO 0
22:
23: #include <assert.h>
24: #include <string.h>
25: #include <sys/types.h>
26: #include <unistd.h>
27: #include <sys/stat.h>
28: #include <fcntl.h>
29:
30: #include "array.h"
31: #include "io.h"
32: #include "log.h"
33:
34: typedef struct {
35: #ifdef PROTOTYPES
36: void (*callback)(int, short);
37: #else
38: void (*callback)();
39: #endif
40: short what;
41: } io_event;
42:
43: #define INIT_IOEVENT { NULL, -1, 0, NULL }
44: #define IO_ERROR 4
45: #define MAX_EVENTS 100
46:
47: #ifdef HAVE_EPOLL_CREATE
48: # define IO_USE_EPOLL 1
49: # ifdef HAVE_SELECT
50: # define IO_USE_SELECT 1
51: # endif
52: #else
53: # ifdef HAVE_KQUEUE
54: # define IO_USE_KQUEUE 1
55: # else
56: # ifdef HAVE_SYS_DEVPOLL_H
57: # define IO_USE_DEVPOLL 1
58: # else
59: # if defined(HAVE_POLL) && defined(HAVE_POLL_H)
60: # define IO_USE_POLL 1
61: # else
62: # ifdef HAVE_SELECT
63: # define IO_USE_SELECT 1
64: # else
65: # error "no IO API available!?"
66: # endif /* HAVE_SELECT */
67: # endif /* HAVE_POLL */
68: # endif /* HAVE_SYS_DEVPOLL_H */
69: # endif /* HAVE_KQUEUE */
70: #endif /* HAVE_EPOLL_CREATE */
71:
72: static bool library_initialized = false;
73:
74: #ifdef IO_USE_EPOLL
75: #include <sys/epoll.h>
76:
77: static int io_masterfd = -1;
78: static bool io_event_change_epoll(int fd, short what, const int action);
79: static int io_dispatch_epoll(struct timeval *tv);
80: #endif
81:
82: #ifdef IO_USE_KQUEUE
83: #include <sys/types.h>
84: #include <sys/event.h>
85: static array io_evcache;
86: static int io_masterfd;
87:
88: static int io_dispatch_kqueue(struct timeval *tv);
89: static bool io_event_change_kqueue(int, short, const int action);
90:
91: #ifndef EV_SET
92: /* Taken from /usr/include/sys/event.h of FreeBSD 8.1 and required by all
93: * platforms that have kqueue but lack EV_SET() -- for example FreeBSD 4. */
94: #define EV_SET(kevp, a, b, c, d, e, f) do { \
95: struct kevent *__kevp__ = (kevp); \
96: __kevp__->ident = (a); \
97: __kevp__->filter = (b); \
98: __kevp__->flags = (c); \
99: __kevp__->fflags = (d); \
100: __kevp__->data = (e); \
101: __kevp__->udata = (f); \
102: } while(0)
103: #endif
104: #endif
105:
106: #ifdef IO_USE_POLL
107: #include <poll.h>
108:
109: static array pollfds;
110: static int poll_maxfd;
111:
112: static bool io_event_change_poll PARAMS((int fd, short what));
113: #endif
114:
115: #ifdef IO_USE_DEVPOLL
116: #include <sys/devpoll.h>
117: static int io_masterfd;
118:
119: static bool io_event_change_devpoll(int fd, short what);
120: #endif
121:
122: #ifdef IO_USE_SELECT
123: #include <sys/time.h>
124: #include "defines.h" /* for conn.h */
125: #include "proc.h" /* for PROC_STAT (needed by conf.h) */
126: #include "conn.h" /* for CONN_ID (needed by conf.h) */
127: #include "conf.h" /* for Conf_MaxConnections */
128:
129: static fd_set readers;
130: static fd_set writers;
131: /*
132: * this is the first argument for select(), i.e.
133: * the largest fd registered, plus one.
134: */
135: static int select_maxfd;
136: static int io_dispatch_select PARAMS((struct timeval *tv));
137:
138: #ifndef IO_USE_EPOLL
139: #define io_masterfd -1
140: #endif
141: #endif /* IO_USE_SELECT */
142:
143: static array io_events;
144:
145: static void io_docallback PARAMS((int fd, short what));
146:
147: #if DEBUG_IO
148: static void
149: io_debug(const char *s, int fd, int what)
150: {
151: Log(LOG_DEBUG, "%s: %d, %d\n", s, fd, what);
152: }
153: #else
154: static inline void
155: io_debug(const char UNUSED *s,int UNUSED a, int UNUSED b)
156: { /* NOTHING */ }
157: #endif
158:
159: static io_event *
160: io_event_get(int fd)
161: {
162: io_event *i;
163:
164: assert(fd >= 0);
165:
166: i = (io_event *) array_get(&io_events, sizeof(io_event), (size_t) fd);
167:
168: assert(i != NULL);
169:
170: return i;
171: }
172:
173:
174: #ifdef IO_USE_DEVPOLL
175: static int
176: io_dispatch_devpoll(struct timeval *tv)
177: {
178: struct dvpoll dvp;
179: time_t sec = tv->tv_sec * 1000;
180: int i, ret, timeout = tv->tv_usec + sec;
181: short what;
182: struct pollfd p[MAX_EVENTS];
183:
184: if (timeout < 0)
185: timeout = 1000;
186:
187: dvp.dp_timeout = timeout;
188: dvp.dp_nfds = MAX_EVENTS;
189: dvp.dp_fds = p;
190: ret = ioctl(io_masterfd, DP_POLL, &dvp);
191:
192: for (i=0; i < ret ; i++) {
193: what = 0;
194: if (p[i].revents & (POLLIN|POLLPRI))
195: what = IO_WANTREAD;
196:
197: if (p[i].revents & POLLOUT)
198: what |= IO_WANTWRITE;
199:
200: if (p[i].revents && !what) {
201: /* other flag is set, probably POLLERR */
202: what = IO_ERROR;
203: }
204: io_docallback(p[i].fd, what);
205: }
206:
207: return ret;
208: }
209:
210:
211: static bool
212: io_event_change_devpoll(int fd, short what)
213: {
214: struct pollfd p;
215:
216: p.events = 0;
217:
218: if (what & IO_WANTREAD)
219: p.events = POLLIN | POLLPRI;
220: if (what & IO_WANTWRITE)
221: p.events |= POLLOUT;
222:
223: p.fd = fd;
224: return write(io_masterfd, &p, sizeof p) == (ssize_t)sizeof p;
225: }
226:
227: static void
228: io_close_devpoll(int fd)
229: {
230: struct pollfd p;
231: p.events = POLLREMOVE;
232: p.fd = fd;
233: write(io_masterfd, &p, sizeof p);
234: }
235:
236: static void
237: io_library_init_devpoll(unsigned int eventsize)
238: {
239: io_masterfd = open("/dev/poll", O_RDWR);
240: if (io_masterfd >= 0)
241: library_initialized = true;
242: Log(LOG_INFO, "IO subsystem: /dev/poll (initial maxfd %u, masterfd %d).",
243: eventsize, io_masterfd);
244: }
245: #else
246: static inline void
247: io_close_devpoll(int UNUSED x)
248: { /* NOTHING */ }
249: static inline void
250: io_library_init_devpoll(unsigned int UNUSED ev)
251: { /* NOTHING */ }
252: #endif
253:
254:
255: #ifdef IO_USE_POLL
256: static int
257: io_dispatch_poll(struct timeval *tv)
258: {
259: time_t sec = tv->tv_sec * 1000;
260: int i, ret, timeout = tv->tv_usec + sec;
261: int fds_ready;
262: short what;
263: struct pollfd *p = array_start(&pollfds);
264:
265: if (timeout < 0)
266: timeout = 1000;
267:
268: ret = poll(p, poll_maxfd + 1, timeout);
269: if (ret <= 0)
270: return ret;
271:
272: fds_ready = ret;
273: for (i=0; i <= poll_maxfd; i++) {
274: what = 0;
275: if (p[i].revents & (POLLIN|POLLPRI))
276: what = IO_WANTREAD;
277:
278: if (p[i].revents & POLLOUT)
279: what |= IO_WANTWRITE;
280:
281: if (p[i].revents && !what) {
282: /* other flag is set, probably POLLERR */
283: what = IO_ERROR;
284: }
285: if (what) {
286: fds_ready--;
287: io_docallback(i, what);
288: }
289: if (fds_ready <= 0)
290: break;
291: }
292:
293: return ret;
294: }
295:
296: static bool
297: io_event_change_poll(int fd, short what)
298: {
299: struct pollfd *p;
300: short events = 0;
301:
302: if (what & IO_WANTREAD)
303: events = POLLIN | POLLPRI;
304: if (what & IO_WANTWRITE)
305: events |= POLLOUT;
306:
307: p = array_alloc(&pollfds, sizeof *p, fd);
308: if (p) {
309: p->events = events;
310: p->fd = fd;
311: if (fd > poll_maxfd)
312: poll_maxfd = fd;
313: }
314: return p != NULL;
315: }
316:
317: static void
318: io_close_poll(int fd)
319: {
320: struct pollfd *p;
321: p = array_get(&pollfds, sizeof *p, fd);
322: if (!p) return;
323:
324: p->fd = -1;
325: if (fd == poll_maxfd) {
326: while (poll_maxfd > 0) {
327: --poll_maxfd;
328: p = array_get(&pollfds, sizeof *p, poll_maxfd);
329: if (p && p->fd >= 0)
330: break;
331: }
332: }
333: }
334:
335: static void
336: io_library_init_poll(unsigned int eventsize)
337: {
338: struct pollfd *p;
339: array_init(&pollfds);
340: poll_maxfd = 0;
341: Log(LOG_INFO, "IO subsystem: poll (initial maxfd %u).",
342: eventsize);
343: p = array_alloc(&pollfds, sizeof(struct pollfd), eventsize);
344: if (p) {
345: unsigned i;
346: p = array_start(&pollfds);
347: for (i = 0; i < eventsize; i++)
348: p[i].fd = -1;
349:
350: library_initialized = true;
351: }
352: }
353: #else
354: static inline void
355: io_close_poll(int UNUSED x)
356: { /* NOTHING */ }
357: static inline void
358: io_library_init_poll(unsigned int UNUSED ev)
359: { /* NOTHING */ }
360: #endif
361:
362:
363: #ifdef IO_USE_SELECT
364: static int
365: io_dispatch_select(struct timeval *tv)
366: {
367: fd_set readers_tmp;
368: fd_set writers_tmp;
369: short what;
370: int ret, i;
371: int fds_ready;
372:
373: readers_tmp = readers;
374: writers_tmp = writers;
375:
376: ret = select(select_maxfd + 1, &readers_tmp, &writers_tmp, NULL, tv);
377: if (ret <= 0)
378: return ret;
379:
380: fds_ready = ret;
381:
382: for (i = 0; i <= select_maxfd; i++) {
383: what = 0;
384: if (FD_ISSET(i, &readers_tmp)) {
385: what = IO_WANTREAD;
386: fds_ready--;
387: }
388:
389: if (FD_ISSET(i, &writers_tmp)) {
390: what |= IO_WANTWRITE;
391: fds_ready--;
392: }
393: if (what)
394: io_docallback(i, what);
395: if (fds_ready <= 0)
396: break;
397: }
398:
399: return ret;
400: }
401:
402: static void
403: io_library_init_select(unsigned int eventsize)
404: {
405: if (library_initialized)
406: return;
407: Log(LOG_INFO, "IO subsystem: select (initial maxfd %u).",
408: eventsize);
409: FD_ZERO(&readers);
410: FD_ZERO(&writers);
411: #ifdef FD_SETSIZE
412: if (Conf_MaxConnections >= (int)FD_SETSIZE) {
413: Log(LOG_WARNING,
414: "MaxConnections (%d) exceeds limit (%u), changed MaxConnections to %u.",
415: Conf_MaxConnections, FD_SETSIZE, FD_SETSIZE - 1);
416:
417: Conf_MaxConnections = FD_SETSIZE - 1;
418: }
419: #else
420: Log(LOG_WARNING,
421: "FD_SETSIZE undefined, don't know how many descriptors select() can handle on your platform ...");
422: #endif /* FD_SETSIZE */
423: library_initialized = true;
424: }
425:
426: static void
427: io_close_select(int fd)
428: {
429: io_event *i;
430:
431: if (io_masterfd >= 0) /* Are we using epoll()? */
432: return;
433:
434: FD_CLR(fd, &writers);
435: FD_CLR(fd, &readers);
436:
437: i = io_event_get(fd);
438: if (!i) return;
439:
440: if (fd == select_maxfd) {
441: while (select_maxfd>0) {
442: --select_maxfd; /* find largest fd */
443: i = io_event_get(select_maxfd);
444: if (i && i->callback) break;
445: }
446: }
447: }
448: #else
449: static inline void
450: io_library_init_select(int UNUSED x)
451: { /* NOTHING */ }
452: static inline void
453: io_close_select(int UNUSED x)
454: { /* NOTHING */ }
455: #endif /* SELECT */
456:
457:
458: #ifdef IO_USE_EPOLL
459: static bool
460: io_event_change_epoll(int fd, short what, const int action)
461: {
462: struct epoll_event ev = { 0, {0} };
463: ev.data.fd = fd;
464:
465: if (what & IO_WANTREAD)
466: ev.events = EPOLLIN | EPOLLPRI;
467: if (what & IO_WANTWRITE)
468: ev.events |= EPOLLOUT;
469:
470: return epoll_ctl(io_masterfd, action, fd, &ev) == 0;
471: }
472:
473: static int
474: io_dispatch_epoll(struct timeval *tv)
475: {
476: time_t sec = tv->tv_sec * 1000;
477: int i, ret, timeout = tv->tv_usec + sec;
478: struct epoll_event epoll_ev[MAX_EVENTS];
479: short type;
480:
481: if (timeout < 0)
482: timeout = 1000;
483:
484: ret = epoll_wait(io_masterfd, epoll_ev, MAX_EVENTS, timeout);
485:
486: for (i = 0; i < ret; i++) {
487: type = 0;
488: if (epoll_ev[i].events & (EPOLLERR | EPOLLHUP))
489: type = IO_ERROR;
490:
491: if (epoll_ev[i].events & (EPOLLIN | EPOLLPRI))
492: type |= IO_WANTREAD;
493:
494: if (epoll_ev[i].events & EPOLLOUT)
495: type |= IO_WANTWRITE;
496:
497: io_docallback(epoll_ev[i].data.fd, type);
498: }
499:
500: return ret;
501: }
502:
503: static void
504: io_library_init_epoll(unsigned int eventsize)
505: {
506: int ecreate_hint = (int)eventsize;
507: if (ecreate_hint <= 0)
508: ecreate_hint = 128;
509: io_masterfd = epoll_create(ecreate_hint);
510: if (io_masterfd >= 0) {
511: library_initialized = true;
512: Log(LOG_INFO,
513: "IO subsystem: epoll (hint size %d, initial maxfd %u, masterfd %d).",
514: ecreate_hint, eventsize, io_masterfd);
515: return;
516: }
517: #ifdef IO_USE_SELECT
518: Log(LOG_INFO, "Can't initialize epoll() IO interface, falling back to select() ...");
519: #endif
520: }
521: #else
522: static inline void
523: io_library_init_epoll(unsigned int UNUSED ev)
524: { /* NOTHING */ }
525: #endif /* IO_USE_EPOLL */
526:
527:
528: #ifdef IO_USE_KQUEUE
529: static bool
530: io_event_kqueue_commit_cache(void)
531: {
532: struct kevent *events;
533: bool ret;
534: int len = (int) array_length(&io_evcache, sizeof (struct kevent));
535:
536: if (!len) /* nothing to do */
537: return true;
538:
539: assert(len>0);
540:
541: if (len < 0) {
542: array_free(&io_evcache);
543: return false;
544: }
545:
546: events = array_start(&io_evcache);
547:
548: assert(events != NULL);
549:
550: ret = kevent(io_masterfd, events, len, NULL, 0, NULL) == 0;
551: if (ret)
552: array_trunc(&io_evcache);
553: return ret;
554: }
555:
556: static bool
557: io_event_change_kqueue(int fd, short what, const int action)
558: {
559: struct kevent kev;
560: bool ret = true;
561:
562: if (what & IO_WANTREAD) {
563: EV_SET(&kev, fd, EVFILT_READ, action, 0, 0, 0);
564: ret = array_catb(&io_evcache, (char*) &kev, sizeof (kev));
565: if (!ret)
566: ret = kevent(io_masterfd, &kev,1, NULL, 0, NULL) == 0;
567: }
568:
569: if (ret && (what & IO_WANTWRITE)) {
570: EV_SET(&kev, fd, EVFILT_WRITE, action, 0, 0, 0);
571: ret = array_catb(&io_evcache, (char*) &kev, sizeof (kev));
572: if (!ret)
573: ret = kevent(io_masterfd, &kev, 1, NULL, 0, NULL) == 0;
574: }
575:
576: if (array_length(&io_evcache, sizeof kev) >= 100)
577: io_event_kqueue_commit_cache();
578: return ret;
579: }
580:
581: static int
582: io_dispatch_kqueue(struct timeval *tv)
583: {
584: int i, ret;
585: struct kevent kev[MAX_EVENTS];
586: struct kevent *newevents;
587: struct timespec ts;
588: int newevents_len;
589: ts.tv_sec = tv->tv_sec;
590: ts.tv_nsec = tv->tv_usec * 1000;
591:
592: newevents_len = (int) array_length(&io_evcache, sizeof (struct kevent));
593: newevents = (newevents_len > 0) ? array_start(&io_evcache) : NULL;
594: assert(newevents_len >= 0);
595:
596: ret = kevent(io_masterfd, newevents, newevents_len, kev, MAX_EVENTS, &ts);
597: if (newevents && ret != -1)
598: array_trunc(&io_evcache);
599:
600: for (i = 0; i < ret; i++) {
601: io_debug("dispatch_kqueue: fd, kev.flags", (int)kev[i].ident, kev[i].flags);
602: if (kev[i].flags & (EV_EOF|EV_ERROR)) {
603: if (kev[i].flags & EV_ERROR)
604: Log(LOG_ERR, "kevent fd %d: EV_ERROR (%s)",
605: (int)kev[i].ident, strerror((int)kev[i].data));
606: io_docallback((int)kev[i].ident, IO_ERROR);
607: continue;
608: }
609:
610: switch (kev[i].filter) {
611: case EVFILT_READ:
612: io_docallback((int)kev[i].ident, IO_WANTREAD);
613: break;
614: case EVFILT_WRITE:
615: io_docallback((int)kev[i].ident, IO_WANTWRITE);
616: break;
617: default:
618: LogDebug("Unknown kev.filter number %d for fd %d",
619: kev[i].filter, kev[i].ident);
620: /* Fall through */
621: case EV_ERROR:
622: io_docallback((int)kev[i].ident, IO_ERROR);
623: break;
624: }
625: }
626:
627: return ret;
628: }
629:
630: static void
631: io_library_init_kqueue(unsigned int eventsize)
632: {
633: io_masterfd = kqueue();
634:
635: Log(LOG_INFO,
636: "IO subsystem: kqueue (initial maxfd %u, masterfd %d).",
637: eventsize, io_masterfd);
638: if (io_masterfd >= 0)
639: library_initialized = true;
640: }
641: #else
642: static inline void
643: io_library_init_kqueue(unsigned int UNUSED ev)
644: { /* NOTHING */ }
645: #endif
646:
647:
648: bool
649: io_library_init(unsigned int eventsize)
650: {
651: if (library_initialized)
652: return true;
653:
654: if ((eventsize > 0) && !array_alloc(&io_events, sizeof(io_event), (size_t)eventsize))
655: eventsize = 0;
656:
657: io_library_init_epoll(eventsize);
658: io_library_init_kqueue(eventsize);
659: io_library_init_devpoll(eventsize);
660: io_library_init_poll(eventsize);
661: io_library_init_select(eventsize);
662:
663: return library_initialized;
664: }
665:
666:
667: void
668: io_library_shutdown(void)
669: {
670: #ifdef IO_USE_SELECT
671: FD_ZERO(&readers);
672: FD_ZERO(&writers);
673: #endif
674: #if defined(IO_USE_EPOLL) || defined(IO_USE_KQUEUE) || defined(IO_USE_DEVPOLL)
675: if (io_masterfd >= 0)
676: close(io_masterfd);
677: io_masterfd = -1;
678: #endif
679: #ifdef IO_USE_KQUEUE
680: array_free(&io_evcache);
681: #endif
682: library_initialized = false;
683: }
684:
685:
686: bool
687: io_event_setcb(int fd, void (*cbfunc) (int, short))
688: {
689: io_event *i = io_event_get(fd);
690: if (!i)
691: return false;
692:
693: i->callback = cbfunc;
694: return true;
695: }
696:
697:
698: static bool
699: backend_create_ev(int fd, short what)
700: {
701: bool ret;
702: #ifdef IO_USE_DEVPOLL
703: ret = io_event_change_devpoll(fd, what);
704: #endif
705: #ifdef IO_USE_POLL
706: ret = io_event_change_poll(fd, what);
707: #endif
708: #ifdef IO_USE_EPOLL
709: ret = io_event_change_epoll(fd, what, EPOLL_CTL_ADD);
710: #endif
711: #ifdef IO_USE_KQUEUE
712: ret = io_event_change_kqueue(fd, what, EV_ADD|EV_ENABLE);
713: #endif
714: #ifdef IO_USE_SELECT
715: if (io_masterfd < 0)
716: ret = io_event_add(fd, what);
717: #endif
718: return ret;
719: }
720:
721:
722: bool
723: io_event_create(int fd, short what, void (*cbfunc) (int, short))
724: {
725: bool ret;
726: io_event *i;
727:
728: assert(fd >= 0);
729: #if defined(IO_USE_SELECT) && defined(FD_SETSIZE)
730: if (io_masterfd < 0 && fd >= FD_SETSIZE) {
731: Log(LOG_ERR,
732: "fd %d exceeds FD_SETSIZE (%u) (select can't handle more file descriptors)",
733: fd, FD_SETSIZE);
734: return false;
735: }
736: #endif
737: i = (io_event *) array_alloc(&io_events, sizeof(io_event), (size_t) fd);
738: if (!i) {
739: Log(LOG_WARNING,
740: "array_alloc failed: could not allocate space for %d io_event structures",
741: fd);
742: return false;
743: }
744:
745: i->callback = cbfunc;
746: i->what = 0;
747: ret = backend_create_ev(fd, what);
748: if (ret)
749: i->what = what;
750: return ret;
751: }
752:
753:
754: bool
755: io_event_add(int fd, short what)
756: {
757: io_event *i = io_event_get(fd);
758:
759: if (!i) return false;
760:
761: if ((i->what & what) == what) /* event type is already registered */
762: return true;
763:
764: io_debug("io_event_add: fd, what", fd, what);
765:
766: i->what |= what;
767: #ifdef IO_USE_EPOLL
768: if (io_masterfd >= 0)
769: return io_event_change_epoll(fd, i->what, EPOLL_CTL_MOD);
770: #endif
771: #ifdef IO_USE_KQUEUE
772: return io_event_change_kqueue(fd, what, EV_ADD | EV_ENABLE);
773: #endif
774: #ifdef IO_USE_DEVPOLL
775: return io_event_change_devpoll(fd, i->what);
776: #endif
777: #ifdef IO_USE_POLL
778: return io_event_change_poll(fd, i->what);
779: #endif
780: #ifdef IO_USE_SELECT
781: if (fd > select_maxfd)
782: select_maxfd = fd;
783:
784: if (what & IO_WANTREAD)
785: FD_SET(fd, &readers);
786: if (what & IO_WANTWRITE)
787: FD_SET(fd, &writers);
788:
789: return true;
790: #endif
791: return false;
792: }
793:
794:
795: bool
796: io_setnonblock(int fd)
797: {
798: int flags = fcntl(fd, F_GETFL);
799: if (flags == -1)
800: return false;
801: #ifndef O_NONBLOCK
802: #define O_NONBLOCK O_NDELAY
803: #endif
804: flags |= O_NONBLOCK;
805:
806: return fcntl(fd, F_SETFL, flags) == 0;
807: }
808:
809: bool
810: io_setcloexec(int fd)
811: {
812: int flags = fcntl(fd, F_GETFD);
813: if (flags == -1)
814: return false;
815: #ifdef FD_CLOEXEC
816: flags |= FD_CLOEXEC;
817: #endif
818:
819: return fcntl(fd, F_SETFD, flags) == 0;
820: }
821:
822: bool
823: io_close(int fd)
824: {
825: io_event *i;
826:
827: i = io_event_get(fd);
828: #ifdef IO_USE_KQUEUE
829: if (array_length(&io_evcache, sizeof (struct kevent))) /* pending data in cache? */
830: io_event_kqueue_commit_cache();
831:
832: /* both kqueue and epoll remove fd from all sets automatically on the last close
833: * of the descriptor. since we don't know if this is the last close we'll have
834: * to remove the set explicitly. */
835: if (i) {
836: io_event_change_kqueue(fd, i->what, EV_DELETE);
837: io_event_kqueue_commit_cache();
838: }
839: #endif
840: io_close_devpoll(fd);
841: io_close_poll(fd);
842: io_close_select(fd);
843: #ifdef IO_USE_EPOLL
844: io_event_change_epoll(fd, 0, EPOLL_CTL_DEL);
845: #endif
846: if (i) {
847: i->callback = NULL;
848: i->what = 0;
849: }
850: return close(fd) == 0;
851: }
852:
853:
854: bool
855: io_event_del(int fd, short what)
856: {
857: io_event *i = io_event_get(fd);
858:
859: io_debug("io_event_del: trying to delete eventtype; fd, what", fd, what);
860: if (!i) return false;
861:
862: if (!(i->what & what)) /* event is already disabled */
863: return true;
864:
865: i->what &= ~what;
866: #ifdef IO_USE_DEVPOLL
867: return io_event_change_devpoll(fd, i->what);
868: #endif
869: #ifdef IO_USE_POLL
870: return io_event_change_poll(fd, i->what);
871: #endif
872: #ifdef IO_USE_EPOLL
873: if (io_masterfd >= 0)
874: return io_event_change_epoll(fd, i->what, EPOLL_CTL_MOD);
875: #endif
876: #ifdef IO_USE_KQUEUE
877: return io_event_change_kqueue(fd, what, EV_DISABLE);
878: #endif
879: #ifdef IO_USE_SELECT
880: if (what & IO_WANTWRITE)
881: FD_CLR(fd, &writers);
882:
883: if (what & IO_WANTREAD)
884: FD_CLR(fd, &readers);
885: return true;
886: #endif
887: return false;
888: }
889:
890:
891: int
892: io_dispatch(struct timeval *tv)
893: {
894: #ifdef IO_USE_EPOLL
895: if (io_masterfd >= 0)
896: return io_dispatch_epoll(tv);
897: #endif
898: #ifdef IO_USE_SELECT
899: return io_dispatch_select(tv);
900: #endif
901: #ifdef IO_USE_KQUEUE
902: return io_dispatch_kqueue(tv);
903: #endif
904: #ifdef IO_USE_DEVPOLL
905: return io_dispatch_devpoll(tv);
906: #endif
907: #ifdef IO_USE_POLL
908: return io_dispatch_poll(tv);
909: #endif
910: return -1;
911: }
912:
913:
914: /* call the callback function inside the struct matching fd */
915: static void
916: io_docallback(int fd, short what)
917: {
918: io_event *i = io_event_get(fd);
919:
920: io_debug("io_docallback; fd, what", fd, what);
921:
922: if (i->callback) { /* callback might be NULL if a previous callback function
923: called io_close on this fd */
924: i->callback(fd, (what & IO_ERROR) ? i->what : what);
925: }
926: /* if error indicator is set, we return the event(s) that were registered */
927: }