lib: Fixed bioprintf bug.
[ashd.git] / lib / mtio-kqueue.c
... / ...
CommitLineData
1/*
2 ashd - A Sane HTTP Daemon
3 Copyright (C) 2008 Fredrik Tolf <fredrik@dolda2000.com>
4
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17*/
18
19#include <stdlib.h>
20#include <unistd.h>
21#include <time.h>
22#include <fcntl.h>
23#include <string.h>
24#include <sys/event.h>
25#include <errno.h>
26
27#ifdef HAVE_CONFIG_H
28#include <config.h>
29#endif
30#include <log.h>
31#include <utils.h>
32#include <mt.h>
33#include <mtio.h>
34
35static struct blocker *blockers;
36
37struct blocker {
38 struct blocker *n, *p, *n2, *p2;
39 int fd, reg;
40 int ev, rev, id;
41 time_t to;
42 struct muth *th;
43};
44
45static int qfd = -1, fdln = 0;
46static int exitstatus;
47static struct blocker **fdlist;
48
49static int regfd(struct blocker *bl)
50{
51 struct blocker *o;
52 int prev;
53 struct kevent evd;
54
55 if(bl->fd >= fdln) {
56 if(fdlist) {
57 fdlist = srealloc(fdlist, sizeof(*fdlist) * (bl->fd + 1));
58 memset(fdlist + fdln, 0, sizeof(*fdlist) * (bl->fd + 1 - fdln));
59 fdln = bl->fd + 1;
60 } else {
61 fdlist = szmalloc(sizeof(*fdlist) * (fdln = (bl->fd + 1)));
62 }
63 }
64 for(prev = 0, o = fdlist[bl->fd]; o; o = o->n2)
65 prev |= o->ev;
66 if((bl->ev & EV_READ) && !(prev & EV_READ)) {
67 evd = (struct kevent) {
68 .flags = EV_ADD,
69 .ident = bl->fd,
70 .filter = EVFILT_READ,
71 };
72 if(kevent(qfd, &evd, 1, NULL, 0, NULL) < 0) {
73 /* XXX?! Whatever to do, really? */
74 flog(LOG_ERR, "kevent(EV_ADD, EVFILT_READ) on fd %i: %s", bl->fd, strerror(errno));
75 return(-1);
76 }
77 }
78 if((bl->ev & EV_WRITE) && !(prev & EV_WRITE)) {
79 evd = (struct kevent) {
80 .flags = EV_ADD,
81 .ident = bl->fd,
82 .filter = EVFILT_WRITE,
83 };
84 if(kevent(qfd, &evd, 1, NULL, 0, NULL) < 0) {
85 /* XXX?! Whatever to do, really? */
86 flog(LOG_ERR, "kevent(EV_ADD, EVFILT_WRITE) on fd %i: %s", bl->fd, strerror(errno));
87 return(-1);
88 }
89 }
90 bl->n2 = fdlist[bl->fd];
91 bl->p2 = NULL;
92 if(fdlist[bl->fd] != NULL)
93 fdlist[bl->fd]->p2 = bl;
94 fdlist[bl->fd] = bl;
95 bl->reg = 1;
96 return(0);
97}
98
99static void remfd(struct blocker *bl)
100{
101 struct blocker *o;
102 struct kevent evd;
103 int left;
104
105 if(!bl->reg)
106 return;
107 if(bl->n2)
108 bl->n2->p2 = bl->p2;
109 if(bl->p2)
110 bl->p2->n2 = bl->n2;
111 if(bl == fdlist[bl->fd])
112 fdlist[bl->fd] = bl->n2;
113 for(left = 0, o = fdlist[bl->fd]; o; o = o->n2)
114 left |= o->ev;
115 if((bl->ev & EV_READ) && !(left & EV_READ)) {
116 evd = (struct kevent) {
117 .flags = EV_DELETE,
118 .ident = bl->fd,
119 .filter = EVFILT_READ,
120 };
121 if(kevent(qfd, &evd, 1, NULL, 0, NULL) < 0) {
122 /* XXX?! Whatever to do, really? */
123 flog(LOG_ERR, "kevent(EV_DELETE, EVFILT_READ) on fd %i: %s", bl->fd, strerror(errno));
124 }
125 }
126 if((bl->ev & EV_WRITE) && !(left & EV_WRITE)) {
127 evd = (struct kevent) {
128 .flags = EV_DELETE,
129 .ident = bl->fd,
130 .filter = EVFILT_WRITE,
131 };
132 if(kevent(qfd, &evd, 1, NULL, 0, NULL) < 0) {
133 /* XXX?! Whatever to do, really? */
134 flog(LOG_ERR, "kevent(EV_DELETE, EVFILT_WRITE) on fd %i: %s", bl->fd, strerror(errno));
135 }
136 }
137 bl->reg = 0;
138}
139
140static int addblock(struct blocker *bl)
141{
142 if((qfd >= 0) && regfd(bl))
143 return(-1);
144 bl->n = blockers;
145 if(blockers)
146 blockers->p = bl;
147 blockers = bl;
148 return(0);
149}
150
151static void remblock(struct blocker *bl)
152{
153 if(bl->n)
154 bl->n->p = bl->p;
155 if(bl->p)
156 bl->p->n = bl->n;
157 if(bl == blockers)
158 blockers = bl->n;
159 remfd(bl);
160}
161
162struct selected mblock(time_t to, int n, struct selected *spec)
163{
164 int i, id;
165 struct blocker bls[n];
166
167 to = (to > 0)?(time(NULL) + to):0;
168 for(i = 0; i < n; i++) {
169 bls[i] = (struct blocker) {
170 .fd = spec[i].fd,
171 .ev = spec[i].ev,
172 .id = i,
173 .to = to,
174 .th = current,
175 };
176 if(addblock(&bls[i])) {
177 for(i--; i >= 0; i--)
178 remblock(&bls[i]);
179 return((struct selected){.fd = -1, .ev = -1});
180 }
181 }
182 id = yield();
183 for(i = 0; i < n; i++)
184 remblock(&bls[i]);
185 if(id < 0)
186 return((struct selected){.fd = -1, .ev = -1});
187 return((struct selected){.fd = bls[id].fd, .ev = bls[id].rev});
188}
189
190int block(int fd, int ev, time_t to)
191{
192 struct blocker bl;
193 int rv;
194
195 bl = (struct blocker) {
196 .fd = fd,
197 .ev = ev,
198 .id = -1,
199 .to = (to > 0)?(time(NULL) + to):0,
200 .th = current,
201 };
202 addblock(&bl);
203 rv = yield();
204 remblock(&bl);
205 return(rv);
206}
207
208int ioloop(void)
209{
210 struct blocker *bl, *nbl;
211 struct kevent evs[16];
212 int i, fd, nev, ev;
213 time_t now, timeout;
214 struct timespec *toval;
215
216 exitstatus = 0;
217 qfd = kqueue();
218 fcntl(qfd, F_SETFD, FD_CLOEXEC);
219 for(bl = blockers; bl; bl = nbl) {
220 nbl = bl->n;
221 if(regfd(bl))
222 resume(bl->th, -1);
223 }
224 while(blockers != NULL) {
225 timeout = 0;
226 for(bl = blockers; bl; bl = bl->n) {
227 if((bl->to != 0) && ((timeout == 0) || (timeout > bl->to)))
228 timeout = bl->to;
229 }
230 now = time(NULL);
231 if(timeout == 0)
232 toval = NULL;
233 else if(timeout > now)
234 toval = &(struct timespec){.tv_sec = timeout - now};
235 else
236 toval = &(struct timespec){.tv_sec = 1};
237 if(exitstatus)
238 break;
239 nev = kevent(qfd, NULL, 0, evs, sizeof(evs) / sizeof(*evs), toval);
240 if(nev < 0) {
241 if(errno != EINTR) {
242 flog(LOG_CRIT, "ioloop: kevent errored out: %s", strerror(errno));
243 /* To avoid CPU hogging in case it's bad, which it
244 * probably is. */
245 sleep(1);
246 }
247 continue;
248 }
249 for(i = 0; i < nev; i++) {
250 fd = (int)evs[i].ident;
251 ev = (evs[i].filter == EVFILT_READ)?EV_READ:EV_WRITE;
252 for(bl = fdlist[fd]; bl; bl = nbl) {
253 nbl = bl->n2;
254 if(ev & bl->ev) {
255 if(bl->id < 0) {
256 resume(bl->th, ev);
257 } else {
258 bl->rev = ev;
259 resume(bl->th, bl->id);
260 }
261 }
262 }
263 }
264 now = time(NULL);
265 for(bl = blockers; bl; bl = nbl) {
266 nbl = bl->n;
267 if((bl->to != 0) && (bl->to <= now)) {
268 if(bl->id < 0) {
269 resume(bl->th, 0);
270 } else {
271 bl->rev = 0;
272 resume(bl->th, bl->id);
273 }
274 }
275 }
276 }
277 for(bl = blockers; bl; bl = bl->n)
278 remfd(bl);
279 close(qfd);
280 qfd = -1;
281 return(exitstatus);
282}
283
284void exitioloop(int status)
285{
286 exitstatus = status;
287}