OLD | NEW |
| (Empty) |
1 /* | |
2 * Submitted by David Pacheco (dp.spambait@gmail.com) | |
3 * | |
4 * Redistribution and use in source and binary forms, with or without | |
5 * modification, are permitted provided that the following conditions | |
6 * are met: | |
7 * 1. Redistributions of source code must retain the above copyright | |
8 * notice, this list of conditions and the following disclaimer. | |
9 * 2. Redistributions in binary form must reproduce the above copyright | |
10 * notice, this list of conditions and the following disclaimer in the | |
11 * documentation and/or other materials provided with the distribution. | |
12 * 3. The name of the author may not be used to endorse or promote products | |
13 * derived from this software without specific prior written permission. | |
14 * | |
15 * THIS SOFTWARE IS PROVIDED BY SUN MICROSYSTEMS, INC. ``AS IS'' AND ANY | |
16 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |
17 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
18 * DISCLAIMED. IN NO EVENT SHALL SUN MICROSYSTEMS, INC. BE LIABLE FOR ANY | |
19 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | |
20 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
21 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | |
22 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | |
24 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
25 */ | |
26 | |
27 /* | |
28 * Copyright (c) 2007 Sun Microsystems. All rights reserved. | |
29 * Use is subject to license terms. | |
30 */ | |
31 | |
32 /* | |
33 * evport.c: event backend using Solaris 10 event ports. See port_create(3C). | |
34 * This implementation is loosely modeled after the one used for select(2) (in | |
35 * select.c). | |
36 * | |
37 * The outstanding events are tracked in a data structure called evport_data. | |
38 * Each entry in the ed_fds array corresponds to a file descriptor, and contains | |
39 * pointers to the read and write events that correspond to that fd. (That is, | |
40 * when the file is readable, the "read" event should handle it, etc.) | |
41 * | |
42 * evport_add and evport_del update this data structure. evport_dispatch uses it | |
43 * to determine where to callback when an event occurs (which it gets from | |
44 * port_getn). | |
45 * | |
46 * Helper functions are used: grow() grows the file descriptor array as | |
47 * necessary when large fd's come in. reassociate() takes care of maintaining | |
48 * the proper file-descriptor/event-port associations. | |
49 * | |
50 * As in the select(2) implementation, signals are handled by evsignal. | |
51 */ | |
52 | |
53 #ifdef HAVE_CONFIG_H | |
54 #include "config.h" | |
55 #endif | |
56 | |
57 #include <sys/time.h> | |
58 #include <assert.h> | |
59 #include <sys/queue.h> | |
60 #include <errno.h> | |
61 #include <poll.h> | |
62 #include <port.h> | |
63 #include <signal.h> | |
64 #include <stdio.h> | |
65 #include <stdlib.h> | |
66 #include <string.h> | |
67 #include <time.h> | |
68 #include <unistd.h> | |
69 #ifdef CHECK_INVARIANTS | |
70 #include <assert.h> | |
71 #endif | |
72 | |
73 #include "event.h" | |
74 #include "event-internal.h" | |
75 #include "log.h" | |
76 #include "evsignal.h" | |
77 | |
78 | |
79 /* | |
80 * Default value for ed_nevents, which is the maximum file descriptor number we | |
81 * can handle. If an event comes in for a file descriptor F > nevents, we will | |
82 * grow the array of file descriptors, doubling its size. | |
83 */ | |
84 #define DEFAULT_NFDS 16 | |
85 | |
86 | |
87 /* | |
88 * EVENTS_PER_GETN is the maximum number of events to retrieve from port_getn on | |
89 * any particular call. You can speed things up by increasing this, but it will | |
90 * (obviously) require more memory. | |
91 */ | |
92 #define EVENTS_PER_GETN 8 | |
93 | |
94 /* | |
95 * Per-file-descriptor information about what events we're subscribed to. These | |
96 * fields are NULL if no event is subscribed to either of them. | |
97 */ | |
98 | |
99 struct fd_info { | |
100 struct event* fdi_revt; /* the event responsible for the "read" */ | |
101 struct event* fdi_wevt; /* the event responsible for the "write" */ | |
102 }; | |
103 | |
104 #define FDI_HAS_READ(fdi) ((fdi)->fdi_revt != NULL) | |
105 #define FDI_HAS_WRITE(fdi) ((fdi)->fdi_wevt != NULL) | |
106 #define FDI_HAS_EVENTS(fdi) (FDI_HAS_READ(fdi) || FDI_HAS_WRITE(fdi)) | |
107 #define FDI_TO_SYSEVENTS(fdi) (FDI_HAS_READ(fdi) ? POLLIN : 0) | \ | |
108 (FDI_HAS_WRITE(fdi) ? POLLOUT : 0) | |
109 | |
110 struct evport_data { | |
111 int ed_port; /* event port for system events */ | |
112 int ed_nevents; /* number of allocated fdi's */ | |
113 struct fd_info *ed_fds; /* allocated fdi table */ | |
114 /* fdi's that we need to reassoc */ | |
115 int ed_pending[EVENTS_PER_GETN]; /* fd's with pending events */ | |
116 }; | |
117 | |
118 static void* evport_init (struct event_base *); | |
119 static int evport_add (void *, struct event *); | |
120 static int evport_del (void *, struct event *); | |
121 static int evport_dispatch (struct event_base *, void *, struct timeval *); | |
122 static void evport_dealloc (struct event_base *, void *); | |
123 | |
124 const struct eventop evportops = { | |
125 "evport", | |
126 evport_init, | |
127 evport_add, | |
128 evport_del, | |
129 evport_dispatch, | |
130 evport_dealloc, | |
131 1 /* need reinit */ | |
132 }; | |
133 | |
134 /* | |
135 * Initialize the event port implementation. | |
136 */ | |
137 | |
138 static void* | |
139 evport_init(struct event_base *base) | |
140 { | |
141 struct evport_data *evpd; | |
142 int i; | |
143 /* | |
144 * Disable event ports when this environment variable is set | |
145 */ | |
146 if (evutil_getenv("EVENT_NOEVPORT")) | |
147 return (NULL); | |
148 | |
149 if (!(evpd = calloc(1, sizeof(struct evport_data)))) | |
150 return (NULL); | |
151 | |
152 if ((evpd->ed_port = port_create()) == -1) { | |
153 free(evpd); | |
154 return (NULL); | |
155 } | |
156 | |
157 /* | |
158 * Initialize file descriptor structure | |
159 */ | |
160 evpd->ed_fds = calloc(DEFAULT_NFDS, sizeof(struct fd_info)); | |
161 if (evpd->ed_fds == NULL) { | |
162 close(evpd->ed_port); | |
163 free(evpd); | |
164 return (NULL); | |
165 } | |
166 evpd->ed_nevents = DEFAULT_NFDS; | |
167 for (i = 0; i < EVENTS_PER_GETN; i++) | |
168 evpd->ed_pending[i] = -1; | |
169 | |
170 evsignal_init(base); | |
171 | |
172 return (evpd); | |
173 } | |
174 | |
175 #ifdef CHECK_INVARIANTS | |
176 /* | |
177 * Checks some basic properties about the evport_data structure. Because it | |
178 * checks all file descriptors, this function can be expensive when the maximum | |
179 * file descriptor ever used is rather large. | |
180 */ | |
181 | |
182 static void | |
183 check_evportop(struct evport_data *evpd) | |
184 { | |
185 assert(evpd); | |
186 assert(evpd->ed_nevents > 0); | |
187 assert(evpd->ed_port > 0); | |
188 assert(evpd->ed_fds > 0); | |
189 | |
190 /* | |
191 * Verify the integrity of the fd_info struct as well as the events to | |
192 * which it points (at least, that they're valid references and correct | |
193 * for their position in the structure). | |
194 */ | |
195 int i; | |
196 for (i = 0; i < evpd->ed_nevents; ++i) { | |
197 struct event *ev; | |
198 struct fd_info *fdi; | |
199 | |
200 fdi = &evpd->ed_fds[i]; | |
201 if ((ev = fdi->fdi_revt) != NULL) { | |
202 assert(ev->ev_fd == i); | |
203 } | |
204 if ((ev = fdi->fdi_wevt) != NULL) { | |
205 assert(ev->ev_fd == i); | |
206 } | |
207 } | |
208 } | |
209 | |
210 /* | |
211 * Verifies very basic integrity of a given port_event. | |
212 */ | |
213 static void | |
214 check_event(port_event_t* pevt) | |
215 { | |
216 /* | |
217 * We've only registered for PORT_SOURCE_FD events. The only | |
218 * other thing we can legitimately receive is PORT_SOURCE_ALERT, | |
219 * but since we're not using port_alert either, we can assume | |
220 * PORT_SOURCE_FD. | |
221 */ | |
222 assert(pevt->portev_source == PORT_SOURCE_FD); | |
223 assert(pevt->portev_user == NULL); | |
224 } | |
225 | |
226 #else | |
227 #define check_evportop(epop) | |
228 #define check_event(pevt) | |
229 #endif /* CHECK_INVARIANTS */ | |
230 | |
231 /* | |
232 * Doubles the size of the allocated file descriptor array. | |
233 */ | |
234 static int | |
235 grow(struct evport_data *epdp, int factor) | |
236 { | |
237 struct fd_info *tmp; | |
238 int oldsize = epdp->ed_nevents; | |
239 int newsize = factor * oldsize; | |
240 assert(factor > 1); | |
241 | |
242 check_evportop(epdp); | |
243 | |
244 tmp = realloc(epdp->ed_fds, sizeof(struct fd_info) * newsize); | |
245 if (NULL == tmp) | |
246 return -1; | |
247 epdp->ed_fds = tmp; | |
248 memset((char*) (epdp->ed_fds + oldsize), 0, | |
249 (newsize - oldsize)*sizeof(struct fd_info)); | |
250 epdp->ed_nevents = newsize; | |
251 | |
252 check_evportop(epdp); | |
253 | |
254 return 0; | |
255 } | |
256 | |
257 | |
258 /* | |
259 * (Re)associates the given file descriptor with the event port. The OS events | |
260 * are specified (implicitly) from the fd_info struct. | |
261 */ | |
262 static int | |
263 reassociate(struct evport_data *epdp, struct fd_info *fdip, int fd) | |
264 { | |
265 int sysevents = FDI_TO_SYSEVENTS(fdip); | |
266 | |
267 if (sysevents != 0) { | |
268 if (port_associate(epdp->ed_port, PORT_SOURCE_FD, | |
269 fd, sysevents, NULL) == -1) { | |
270 event_warn("port_associate"); | |
271 return (-1); | |
272 } | |
273 } | |
274 | |
275 check_evportop(epdp); | |
276 | |
277 return (0); | |
278 } | |
279 | |
280 /* | |
281 * Main event loop - polls port_getn for some number of events, and processes | |
282 * them. | |
283 */ | |
284 | |
285 static int | |
286 evport_dispatch(struct event_base *base, void *arg, struct timeval *tv) | |
287 { | |
288 int i, res; | |
289 struct evport_data *epdp = arg; | |
290 port_event_t pevtlist[EVENTS_PER_GETN]; | |
291 | |
292 /* | |
293 * port_getn will block until it has at least nevents events. It will | |
294 * also return how many it's given us (which may be more than we asked | |
295 * for, as long as it's less than our maximum (EVENTS_PER_GETN)) in | |
296 * nevents. | |
297 */ | |
298 int nevents = 1; | |
299 | |
300 /* | |
301 * We have to convert a struct timeval to a struct timespec | |
302 * (only difference is nanoseconds vs. microseconds). If no time-based | |
303 * events are active, we should wait for I/O (and tv == NULL). | |
304 */ | |
305 struct timespec ts; | |
306 struct timespec *ts_p = NULL; | |
307 if (tv != NULL) { | |
308 ts.tv_sec = tv->tv_sec; | |
309 ts.tv_nsec = tv->tv_usec * 1000; | |
310 ts_p = &ts; | |
311 } | |
312 | |
313 /* | |
314 * Before doing anything else, we need to reassociate the events we hit | |
315 * last time which need reassociation. See comment at the end of the | |
316 * loop below. | |
317 */ | |
318 for (i = 0; i < EVENTS_PER_GETN; ++i) { | |
319 struct fd_info *fdi = NULL; | |
320 if (epdp->ed_pending[i] != -1) { | |
321 fdi = &(epdp->ed_fds[epdp->ed_pending[i]]); | |
322 } | |
323 | |
324 if (fdi != NULL && FDI_HAS_EVENTS(fdi)) { | |
325 int fd = FDI_HAS_READ(fdi) ? fdi->fdi_revt->ev_fd : | |
326 fdi->fdi_wevt->ev_fd; | |
327 reassociate(epdp, fdi, fd); | |
328 epdp->ed_pending[i] = -1; | |
329 } | |
330 } | |
331 | |
332 if ((res = port_getn(epdp->ed_port, pevtlist, EVENTS_PER_GETN, | |
333 (unsigned int *) &nevents, ts_p)) == -1) { | |
334 if (errno == EINTR || errno == EAGAIN) { | |
335 evsignal_process(base); | |
336 return (0); | |
337 } else if (errno == ETIME) { | |
338 if (nevents == 0) | |
339 return (0); | |
340 } else { | |
341 event_warn("port_getn"); | |
342 return (-1); | |
343 } | |
344 } else if (base->sig.evsignal_caught) { | |
345 evsignal_process(base); | |
346 } | |
347 | |
348 event_debug(("%s: port_getn reports %d events", __func__, nevents)); | |
349 | |
350 for (i = 0; i < nevents; ++i) { | |
351 struct event *ev; | |
352 struct fd_info *fdi; | |
353 port_event_t *pevt = &pevtlist[i]; | |
354 int fd = (int) pevt->portev_object; | |
355 | |
356 check_evportop(epdp); | |
357 check_event(pevt); | |
358 epdp->ed_pending[i] = fd; | |
359 | |
360 /* | |
361 * Figure out what kind of event it was | |
362 * (because we have to pass this to the callback) | |
363 */ | |
364 res = 0; | |
365 if (pevt->portev_events & POLLIN) | |
366 res |= EV_READ; | |
367 if (pevt->portev_events & POLLOUT) | |
368 res |= EV_WRITE; | |
369 | |
370 /* | |
371 * Check for the error situations or a hangup situation | |
372 */ | |
373 if (pevt->portev_events & (POLLERR|POLLHUP|POLLNVAL)) | |
374 res |= EV_READ|EV_WRITE; | |
375 | |
376 assert(epdp->ed_nevents > fd); | |
377 fdi = &(epdp->ed_fds[fd]); | |
378 | |
379 /* | |
380 * We now check for each of the possible events (READ | |
381 * or WRITE). Then, we activate the event (which will | |
382 * cause its callback to be executed). | |
383 */ | |
384 | |
385 if ((res & EV_READ) && ((ev = fdi->fdi_revt) != NULL)) { | |
386 event_active(ev, res, 1); | |
387 } | |
388 | |
389 if ((res & EV_WRITE) && ((ev = fdi->fdi_wevt) != NULL)) { | |
390 event_active(ev, res, 1); | |
391 } | |
392 } /* end of all events gotten */ | |
393 | |
394 check_evportop(epdp); | |
395 | |
396 return (0); | |
397 } | |
398 | |
399 | |
400 /* | |
401 * Adds the given event (so that you will be notified when it happens via | |
402 * the callback function). | |
403 */ | |
404 | |
405 static int | |
406 evport_add(void *arg, struct event *ev) | |
407 { | |
408 struct evport_data *evpd = arg; | |
409 struct fd_info *fdi; | |
410 int factor; | |
411 | |
412 check_evportop(evpd); | |
413 | |
414 /* | |
415 * Delegate, if it's not ours to handle. | |
416 */ | |
417 if (ev->ev_events & EV_SIGNAL) | |
418 return (evsignal_add(ev)); | |
419 | |
420 /* | |
421 * If necessary, grow the file descriptor info table | |
422 */ | |
423 | |
424 factor = 1; | |
425 while (ev->ev_fd >= factor * evpd->ed_nevents) | |
426 factor *= 2; | |
427 | |
428 if (factor > 1) { | |
429 if (-1 == grow(evpd, factor)) { | |
430 return (-1); | |
431 } | |
432 } | |
433 | |
434 fdi = &evpd->ed_fds[ev->ev_fd]; | |
435 if (ev->ev_events & EV_READ) | |
436 fdi->fdi_revt = ev; | |
437 if (ev->ev_events & EV_WRITE) | |
438 fdi->fdi_wevt = ev; | |
439 | |
440 return reassociate(evpd, fdi, ev->ev_fd); | |
441 } | |
442 | |
443 /* | |
444 * Removes the given event from the list of events to wait for. | |
445 */ | |
446 | |
447 static int | |
448 evport_del(void *arg, struct event *ev) | |
449 { | |
450 struct evport_data *evpd = arg; | |
451 struct fd_info *fdi; | |
452 int i; | |
453 int associated = 1; | |
454 | |
455 check_evportop(evpd); | |
456 | |
457 /* | |
458 * Delegate, if it's not ours to handle | |
459 */ | |
460 if (ev->ev_events & EV_SIGNAL) { | |
461 return (evsignal_del(ev)); | |
462 } | |
463 | |
464 if (evpd->ed_nevents < ev->ev_fd) { | |
465 return (-1); | |
466 } | |
467 | |
468 for (i = 0; i < EVENTS_PER_GETN; ++i) { | |
469 if (evpd->ed_pending[i] == ev->ev_fd) { | |
470 associated = 0; | |
471 break; | |
472 } | |
473 } | |
474 | |
475 fdi = &evpd->ed_fds[ev->ev_fd]; | |
476 if (ev->ev_events & EV_READ) | |
477 fdi->fdi_revt = NULL; | |
478 if (ev->ev_events & EV_WRITE) | |
479 fdi->fdi_wevt = NULL; | |
480 | |
481 if (associated) { | |
482 if (!FDI_HAS_EVENTS(fdi) && | |
483 port_dissociate(evpd->ed_port, PORT_SOURCE_FD, | |
484 ev->ev_fd) == -1) { | |
485 /* | |
486 * Ignre EBADFD error the fd could have been closed | |
487 * before event_del() was called. | |
488 */ | |
489 if (errno != EBADFD) { | |
490 event_warn("port_dissociate"); | |
491 return (-1); | |
492 } | |
493 } else { | |
494 if (FDI_HAS_EVENTS(fdi)) { | |
495 return (reassociate(evpd, fdi, ev->ev_fd)); | |
496 } | |
497 } | |
498 } else { | |
499 if (fdi->fdi_revt == NULL && fdi->fdi_wevt == NULL) { | |
500 evpd->ed_pending[i] = -1; | |
501 } | |
502 } | |
503 return 0; | |
504 } | |
505 | |
506 | |
507 static void | |
508 evport_dealloc(struct event_base *base, void *arg) | |
509 { | |
510 struct evport_data *evpd = arg; | |
511 | |
512 evsignal_dealloc(base); | |
513 | |
514 close(evpd->ed_port); | |
515 | |
516 if (evpd->ed_fds) | |
517 free(evpd->ed_fds); | |
518 free(evpd); | |
519 } | |
OLD | NEW |