![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to poll.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 poll.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libevent |
1.1 misho 1: /* $OpenBSD: poll.c,v 1.2 2002/06/25 15:50:15 mickey Exp $ */
2:
3: /*
4: * Copyright 2000-2003 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: #include <sys/types.h>
34: #ifdef HAVE_SYS_TIME_H
35: #include <sys/time.h>
36: #else
37: #include <sys/_libevent_time.h>
38: #endif
39: #include <sys/queue.h>
40: #include <poll.h>
41: #include <signal.h>
42: #include <stdio.h>
43: #include <stdlib.h>
44: #include <string.h>
45: #include <unistd.h>
46: #include <errno.h>
47: #ifdef CHECK_INVARIANTS
48: #include <assert.h>
49: #endif
50:
51: #include "event.h"
52: #include "event-internal.h"
53: #include "evsignal.h"
54: #include "log.h"
55:
56: struct pollop {
57: int event_count; /* Highest number alloc */
58: int nfds; /* Size of event_* */
59: int fd_count; /* Size of idxplus1_by_fd */
60: struct pollfd *event_set;
61: struct event **event_r_back;
62: struct event **event_w_back;
63: int *idxplus1_by_fd; /* Index into event_set by fd; we add 1 so
64: * that 0 (which is easy to memset) can mean
65: * "no entry." */
66: };
67:
68: static void *poll_init (struct event_base *);
69: static int poll_add (void *, struct event *);
70: static int poll_del (void *, struct event *);
71: static int poll_dispatch (struct event_base *, void *, struct timeval *);
72: static void poll_dealloc (struct event_base *, void *);
73:
74: const struct eventop pollops = {
75: "poll",
76: poll_init,
77: poll_add,
78: poll_del,
79: poll_dispatch,
80: poll_dealloc,
81: 0
82: };
83:
84: static void *
85: poll_init(struct event_base *base)
86: {
87: struct pollop *pollop;
88:
89: /* Disable poll when this environment variable is set */
90: if (evutil_getenv("EVENT_NOPOLL"))
91: return (NULL);
92:
93: if (!(pollop = calloc(1, sizeof(struct pollop))))
94: return (NULL);
95:
96: evsignal_init(base);
97:
98: return (pollop);
99: }
100:
101: #ifdef CHECK_INVARIANTS
102: static void
103: poll_check_ok(struct pollop *pop)
104: {
105: int i, idx;
106: struct event *ev;
107:
108: for (i = 0; i < pop->fd_count; ++i) {
109: idx = pop->idxplus1_by_fd[i]-1;
110: if (idx < 0)
111: continue;
112: assert(pop->event_set[idx].fd == i);
113: if (pop->event_set[idx].events & POLLIN) {
114: ev = pop->event_r_back[idx];
115: assert(ev);
116: assert(ev->ev_events & EV_READ);
117: assert(ev->ev_fd == i);
118: }
119: if (pop->event_set[idx].events & POLLOUT) {
120: ev = pop->event_w_back[idx];
121: assert(ev);
122: assert(ev->ev_events & EV_WRITE);
123: assert(ev->ev_fd == i);
124: }
125: }
126: for (i = 0; i < pop->nfds; ++i) {
127: struct pollfd *pfd = &pop->event_set[i];
128: assert(pop->idxplus1_by_fd[pfd->fd] == i+1);
129: }
130: }
131: #else
132: #define poll_check_ok(pop)
133: #endif
134:
135: static int
136: poll_dispatch(struct event_base *base, void *arg, struct timeval *tv)
137: {
138: int res, i, j, msec = -1, nfds;
139: struct pollop *pop = arg;
140:
141: poll_check_ok(pop);
142:
143: if (tv != NULL)
144: msec = tv->tv_sec * 1000 + (tv->tv_usec + 999) / 1000;
145:
146: nfds = pop->nfds;
147: res = poll(pop->event_set, nfds, msec);
148:
149: if (res == -1) {
150: if (errno != EINTR) {
151: event_warn("poll");
152: return (-1);
153: }
154:
155: evsignal_process(base);
156: return (0);
157: } else if (base->sig.evsignal_caught) {
158: evsignal_process(base);
159: }
160:
161: event_debug(("%s: poll reports %d", __func__, res));
162:
163: if (res == 0 || nfds == 0)
164: return (0);
165:
166: i = random() % nfds;
167: for (j = 0; j < nfds; j++) {
168: struct event *r_ev = NULL, *w_ev = NULL;
169: int what;
170: if (++i == nfds)
171: i = 0;
172: what = pop->event_set[i].revents;
173:
174: if (!what)
175: continue;
176:
177: res = 0;
178:
179: /* If the file gets closed notify */
180: if (what & (POLLHUP|POLLERR))
181: what |= POLLIN|POLLOUT;
182: if (what & POLLIN) {
183: res |= EV_READ;
184: r_ev = pop->event_r_back[i];
185: }
186: if (what & POLLOUT) {
187: res |= EV_WRITE;
188: w_ev = pop->event_w_back[i];
189: }
190: if (res == 0)
191: continue;
192:
193: if (r_ev && (res & r_ev->ev_events)) {
194: event_active(r_ev, res & r_ev->ev_events, 1);
195: }
196: if (w_ev && w_ev != r_ev && (res & w_ev->ev_events)) {
197: event_active(w_ev, res & w_ev->ev_events, 1);
198: }
199: }
200:
201: return (0);
202: }
203:
204: static int
205: poll_add(void *arg, struct event *ev)
206: {
207: struct pollop *pop = arg;
208: struct pollfd *pfd = NULL;
209: int i;
210:
211: if (ev->ev_events & EV_SIGNAL)
212: return (evsignal_add(ev));
213: if (!(ev->ev_events & (EV_READ|EV_WRITE)))
214: return (0);
215:
216: poll_check_ok(pop);
217: if (pop->nfds + 1 >= pop->event_count) {
218: struct pollfd *tmp_event_set;
219: struct event **tmp_event_r_back;
220: struct event **tmp_event_w_back;
221: int tmp_event_count;
222:
223: if (pop->event_count < 32)
224: tmp_event_count = 32;
225: else
226: tmp_event_count = pop->event_count * 2;
227:
228: /* We need more file descriptors */
229: tmp_event_set = realloc(pop->event_set,
230: tmp_event_count * sizeof(struct pollfd));
231: if (tmp_event_set == NULL) {
232: event_warn("realloc");
233: return (-1);
234: }
235: pop->event_set = tmp_event_set;
236:
237: tmp_event_r_back = realloc(pop->event_r_back,
238: tmp_event_count * sizeof(struct event *));
239: if (tmp_event_r_back == NULL) {
240: /* event_set overallocated; that's okay. */
241: event_warn("realloc");
242: return (-1);
243: }
244: pop->event_r_back = tmp_event_r_back;
245:
246: tmp_event_w_back = realloc(pop->event_w_back,
247: tmp_event_count * sizeof(struct event *));
248: if (tmp_event_w_back == NULL) {
249: /* event_set and event_r_back overallocated; that's
250: * okay. */
251: event_warn("realloc");
252: return (-1);
253: }
254: pop->event_w_back = tmp_event_w_back;
255:
256: pop->event_count = tmp_event_count;
257: }
258: if (ev->ev_fd >= pop->fd_count) {
259: int *tmp_idxplus1_by_fd;
260: int new_count;
261: if (pop->fd_count < 32)
262: new_count = 32;
263: else
264: new_count = pop->fd_count * 2;
265: while (new_count <= ev->ev_fd)
266: new_count *= 2;
267: tmp_idxplus1_by_fd =
268: realloc(pop->idxplus1_by_fd, new_count * sizeof(int));
269: if (tmp_idxplus1_by_fd == NULL) {
270: event_warn("realloc");
271: return (-1);
272: }
273: pop->idxplus1_by_fd = tmp_idxplus1_by_fd;
274: memset(pop->idxplus1_by_fd + pop->fd_count,
275: 0, sizeof(int)*(new_count - pop->fd_count));
276: pop->fd_count = new_count;
277: }
278:
279: i = pop->idxplus1_by_fd[ev->ev_fd] - 1;
280: if (i >= 0) {
281: pfd = &pop->event_set[i];
282: } else {
283: i = pop->nfds++;
284: pfd = &pop->event_set[i];
285: pfd->events = 0;
286: pfd->fd = ev->ev_fd;
287: pop->event_w_back[i] = pop->event_r_back[i] = NULL;
288: pop->idxplus1_by_fd[ev->ev_fd] = i + 1;
289: }
290:
291: pfd->revents = 0;
292: if (ev->ev_events & EV_WRITE) {
293: pfd->events |= POLLOUT;
294: pop->event_w_back[i] = ev;
295: }
296: if (ev->ev_events & EV_READ) {
297: pfd->events |= POLLIN;
298: pop->event_r_back[i] = ev;
299: }
300: poll_check_ok(pop);
301:
302: return (0);
303: }
304:
305: /*
306: * Nothing to be done here.
307: */
308:
309: static int
310: poll_del(void *arg, struct event *ev)
311: {
312: struct pollop *pop = arg;
313: struct pollfd *pfd = NULL;
314: int i;
315:
316: if (ev->ev_events & EV_SIGNAL)
317: return (evsignal_del(ev));
318:
319: if (!(ev->ev_events & (EV_READ|EV_WRITE)))
320: return (0);
321:
322: poll_check_ok(pop);
323: i = pop->idxplus1_by_fd[ev->ev_fd] - 1;
324: if (i < 0)
325: return (-1);
326:
327: /* Do we still want to read or write? */
328: pfd = &pop->event_set[i];
329: if (ev->ev_events & EV_READ) {
330: pfd->events &= ~POLLIN;
331: pop->event_r_back[i] = NULL;
332: }
333: if (ev->ev_events & EV_WRITE) {
334: pfd->events &= ~POLLOUT;
335: pop->event_w_back[i] = NULL;
336: }
337: poll_check_ok(pop);
338: if (pfd->events)
339: /* Another event cares about that fd. */
340: return (0);
341:
342: /* Okay, so we aren't interested in that fd anymore. */
343: pop->idxplus1_by_fd[ev->ev_fd] = 0;
344:
345: --pop->nfds;
346: if (i != pop->nfds) {
347: /*
348: * Shift the last pollfd down into the now-unoccupied
349: * position.
350: */
351: memcpy(&pop->event_set[i], &pop->event_set[pop->nfds],
352: sizeof(struct pollfd));
353: pop->event_r_back[i] = pop->event_r_back[pop->nfds];
354: pop->event_w_back[i] = pop->event_w_back[pop->nfds];
355: pop->idxplus1_by_fd[pop->event_set[i].fd] = i + 1;
356: }
357:
358: poll_check_ok(pop);
359: return (0);
360: }
361:
362: static void
363: poll_dealloc(struct event_base *base, void *arg)
364: {
365: struct pollop *pop = arg;
366:
367: evsignal_dealloc(base);
368: if (pop->event_set)
369: free(pop->event_set);
370: if (pop->event_r_back)
371: free(pop->event_r_back);
372: if (pop->event_w_back)
373: free(pop->event_w_back);
374: if (pop->idxplus1_by_fd)
375: free(pop->idxplus1_by_fd);
376:
377: memset(pop, 0, sizeof(struct pollop));
378: free(pop);
379: }