1 /* 2 * Copyright 2000-2004 Niels Provos <provos (at) citi.umich.edu> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 #ifdef HAVE_CONFIG_H 28 #include "config.h" 29 #endif 30 31 #include <sys/types.h> 32 #include <sys/resource.h> 33 #ifdef HAVE_SYS_TIME_H 34 #include <sys/time.h> 35 #else 36 #include <sys/_libevent_time.h> 37 #endif 38 #include <sys/queue.h> 39 #include <sys/devpoll.h> 40 #include <signal.h> 41 #include <stdio.h> 42 #include <stdlib.h> 43 #include <string.h> 44 #include <unistd.h> 45 #include <fcntl.h> 46 #include <errno.h> 47 #include <assert.h> 48 49 #include "event.h" 50 #include "event-internal.h" 51 #include "evsignal.h" 52 #include "log.h" 53 54 /* due to limitations in the devpoll interface, we need to keep track of 55 * all file descriptors outself. 56 */ 57 struct evdevpoll { 58 struct event *evread; 59 struct event *evwrite; 60 }; 61 62 struct devpollop { 63 struct evdevpoll *fds; 64 int nfds; 65 struct pollfd *events; 66 int nevents; 67 int dpfd; 68 struct pollfd *changes; 69 int nchanges; 70 }; 71 72 static void *devpoll_init (struct event_base *); 73 static int devpoll_add (void *, struct event *); 74 static int devpoll_del (void *, struct event *); 75 static int devpoll_dispatch (struct event_base *, void *, struct timeval *); 76 static void devpoll_dealloc (struct event_base *, void *); 77 78 const struct eventop devpollops = { 79 "devpoll", 80 devpoll_init, 81 devpoll_add, 82 devpoll_del, 83 devpoll_dispatch, 84 devpoll_dealloc, 85 1 /* need reinit */ 86 }; 87 88 #define NEVENT 32000 89 90 static int 91 devpoll_commit(struct devpollop *devpollop) 92 { 93 /* 94 * Due to a bug in Solaris, we have to use pwrite with an offset of 0. 95 * Write is limited to 2GB of data, until it will fail. 96 */ 97 if (pwrite(devpollop->dpfd, devpollop->changes, 98 sizeof(struct pollfd) * devpollop->nchanges, 0) == -1) 99 return(-1); 100 101 devpollop->nchanges = 0; 102 return(0); 103 } 104 105 static int 106 devpoll_queue(struct devpollop *devpollop, int fd, int events) { 107 struct pollfd *pfd; 108 109 if (devpollop->nchanges >= devpollop->nevents) { 110 /* 111 * Change buffer is full, must commit it to /dev/poll before 112 * adding more 113 */ 114 if (devpoll_commit(devpollop) != 0) 115 return(-1); 116 } 117 118 pfd = &devpollop->changes[devpollop->nchanges++]; 119 pfd->fd = fd; 120 pfd->events = events; 121 pfd->revents = 0; 122 123 return(0); 124 } 125 126 static void * 127 devpoll_init(struct event_base *base) 128 { 129 int dpfd, nfiles = NEVENT; 130 struct rlimit rl; 131 struct devpollop *devpollop; 132 133 /* Disable devpoll when this environment variable is set */ 134 if (evutil_getenv("EVENT_NODEVPOLL")) 135 return (NULL); 136 137 if (!(devpollop = calloc(1, sizeof(struct devpollop)))) 138 return (NULL); 139 140 if (getrlimit(RLIMIT_NOFILE, &rl) == 0 && 141 rl.rlim_cur != RLIM_INFINITY) 142 nfiles = rl.rlim_cur; 143 144 /* Initialize the kernel queue */ 145 if ((dpfd = open("/dev/poll", O_RDWR)) == -1) { 146 event_warn("open: /dev/poll"); 147 free(devpollop); 148 return (NULL); 149 } 150 151 devpollop->dpfd = dpfd; 152 153 /* Initialize fields */ 154 devpollop->events = calloc(nfiles, sizeof(struct pollfd)); 155 if (devpollop->events == NULL) { 156 free(devpollop); 157 close(dpfd); 158 return (NULL); 159 } 160 devpollop->nevents = nfiles; 161 162 devpollop->fds = calloc(nfiles, sizeof(struct evdevpoll)); 163 if (devpollop->fds == NULL) { 164 free(devpollop->events); 165 free(devpollop); 166 close(dpfd); 167 return (NULL); 168 } 169 devpollop->nfds = nfiles; 170 171 devpollop->changes = calloc(nfiles, sizeof(struct pollfd)); 172 if (devpollop->changes == NULL) { 173 free(devpollop->fds); 174 free(devpollop->events); 175 free(devpollop); 176 close(dpfd); 177 return (NULL); 178 } 179 180 evsignal_init(base); 181 182 return (devpollop); 183 } 184 185 static int 186 devpoll_recalc(struct event_base *base, void *arg, int max) 187 { 188 struct devpollop *devpollop = arg; 189 190 if (max >= devpollop->nfds) { 191 struct evdevpoll *fds; 192 int nfds; 193 194 nfds = devpollop->nfds; 195 while (nfds <= max) 196 nfds <<= 1; 197 198 fds = realloc(devpollop->fds, nfds * sizeof(struct evdevpoll)); 199 if (fds == NULL) { 200 event_warn("realloc"); 201 return (-1); 202 } 203 devpollop->fds = fds; 204 memset(fds + devpollop->nfds, 0, 205 (nfds - devpollop->nfds) * sizeof(struct evdevpoll)); 206 devpollop->nfds = nfds; 207 } 208 209 return (0); 210 } 211 212 static int 213 devpoll_dispatch(struct event_base *base, void *arg, struct timeval *tv) 214 { 215 struct devpollop *devpollop = arg; 216 struct pollfd *events = devpollop->events; 217 struct dvpoll dvp; 218 struct evdevpoll *evdp; 219 int i, res, timeout = -1; 220 221 if (devpollop->nchanges) 222 devpoll_commit(devpollop); 223 224 if (tv != NULL) 225 timeout = tv->tv_sec * 1000 + (tv->tv_usec + 999) / 1000; 226 227 dvp.dp_fds = devpollop->events; 228 dvp.dp_nfds = devpollop->nevents; 229 dvp.dp_timeout = timeout; 230 231 res = ioctl(devpollop->dpfd, DP_POLL, &dvp); 232 233 if (res == -1) { 234 if (errno != EINTR) { 235 event_warn("ioctl: DP_POLL"); 236 return (-1); 237 } 238 239 evsignal_process(base); 240 return (0); 241 } else if (base->sig.evsignal_caught) { 242 evsignal_process(base); 243 } 244 245 event_debug(("%s: devpoll_wait reports %d", __func__, res)); 246 247 for (i = 0; i < res; i++) { 248 int which = 0; 249 int what = events[i].revents; 250 struct event *evread = NULL, *evwrite = NULL; 251 252 assert(events[i].fd < devpollop->nfds); 253 evdp = &devpollop->fds[events[i].fd]; 254 255 if (what & POLLHUP) 256 what |= POLLIN | POLLOUT; 257 else if (what & POLLERR) 258 what |= POLLIN | POLLOUT; 259 260 if (what & POLLIN) { 261 evread = evdp->evread; 262 which |= EV_READ; 263 } 264 265 if (what & POLLOUT) { 266 evwrite = evdp->evwrite; 267 which |= EV_WRITE; 268 } 269 270 if (!which) 271 continue; 272 273 if (evread != NULL && !(evread->ev_events & EV_PERSIST)) 274 event_del(evread); 275 if (evwrite != NULL && evwrite != evread && 276 !(evwrite->ev_events & EV_PERSIST)) 277 event_del(evwrite); 278 279 if (evread != NULL) 280 event_active(evread, EV_READ, 1); 281 if (evwrite != NULL) 282 event_active(evwrite, EV_WRITE, 1); 283 } 284 285 return (0); 286 } 287 288 289 static int 290 devpoll_add(void *arg, struct event *ev) 291 { 292 struct devpollop *devpollop = arg; 293 struct evdevpoll *evdp; 294 int fd, events; 295 296 if (ev->ev_events & EV_SIGNAL) 297 return (evsignal_add(ev)); 298 299 fd = ev->ev_fd; 300 if (fd >= devpollop->nfds) { 301 /* Extend the file descriptor array as necessary */ 302 if (devpoll_recalc(ev->ev_base, devpollop, fd) == -1) 303 return (-1); 304 } 305 evdp = &devpollop->fds[fd]; 306 307 /* 308 * It's not necessary to OR the existing read/write events that we 309 * are currently interested in with the new event we are adding. 310 * The /dev/poll driver ORs any new events with the existing events 311 * that it has cached for the fd. 312 */ 313 314 events = 0; 315 if (ev->ev_events & EV_READ) { 316 if (evdp->evread && evdp->evread != ev) { 317 /* There is already a different read event registered */ 318 return(-1); 319 } 320 events |= POLLIN; 321 } 322 323 if (ev->ev_events & EV_WRITE) { 324 if (evdp->evwrite && evdp->evwrite != ev) { 325 /* There is already a different write event registered */ 326 return(-1); 327 } 328 events |= POLLOUT; 329 } 330 331 if (devpoll_queue(devpollop, fd, events) != 0) 332 return(-1); 333 334 /* Update events responsible */ 335 if (ev->ev_events & EV_READ) 336 evdp->evread = ev; 337 if (ev->ev_events & EV_WRITE) 338 evdp->evwrite = ev; 339 340 return (0); 341 } 342 343 static int 344 devpoll_del(void *arg, struct event *ev) 345 { 346 struct devpollop *devpollop = arg; 347 struct evdevpoll *evdp; 348 int fd, events; 349 int needwritedelete = 1, needreaddelete = 1; 350 351 if (ev->ev_events & EV_SIGNAL) 352 return (evsignal_del(ev)); 353 354 fd = ev->ev_fd; 355 if (fd >= devpollop->nfds) 356 return (0); 357 evdp = &devpollop->fds[fd]; 358 359 events = 0; 360 if (ev->ev_events & EV_READ) 361 events |= POLLIN; 362 if (ev->ev_events & EV_WRITE) 363 events |= POLLOUT; 364 365 /* 366 * The only way to remove an fd from the /dev/poll monitored set is 367 * to use POLLREMOVE by itself. This removes ALL events for the fd 368 * provided so if we care about two events and are only removing one 369 * we must re-add the other event after POLLREMOVE. 370 */ 371 372 if (devpoll_queue(devpollop, fd, POLLREMOVE) != 0) 373 return(-1); 374 375 if ((events & (POLLIN|POLLOUT)) != (POLLIN|POLLOUT)) { 376 /* 377 * We're not deleting all events, so we must resubmit the 378 * event that we are still interested in if one exists. 379 */ 380 381 if ((events & POLLIN) && evdp->evwrite != NULL) { 382 /* Deleting read, still care about write */ 383 devpoll_queue(devpollop, fd, POLLOUT); 384 needwritedelete = 0; 385 } else if ((events & POLLOUT) && evdp->evread != NULL) { 386 /* Deleting write, still care about read */ 387 devpoll_queue(devpollop, fd, POLLIN); 388 needreaddelete = 0; 389 } 390 } 391 392 if (needreaddelete) 393 evdp->evread = NULL; 394 if (needwritedelete) 395 evdp->evwrite = NULL; 396 397 return (0); 398 } 399 400 static void 401 devpoll_dealloc(struct event_base *base, void *arg) 402 { 403 struct devpollop *devpollop = arg; 404 405 evsignal_dealloc(base); 406 if (devpollop->fds) 407 free(devpollop->fds); 408 if (devpollop->events) 409 free(devpollop->events); 410 if (devpollop->changes) 411 free(devpollop->changes); 412 if (devpollop->dpfd >= 0) 413 close(devpollop->dpfd); 414 415 memset(devpollop, 0, sizeof(struct devpollop)); 416 free(devpollop); 417 } 418
