Linux: sync libevent/epoll.c to upstream's version

third_party/libevent/epoll.c

 /*
  * Copyright 2000-2003 Niels Provos <provos@citi.umich.edu>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 57 matching lines @@
         int nevents;
         int epfd;
 };
 
 static void *epoll_init (struct event_base *);
 static int epoll_add    (void *, struct event *);
 static int epoll_del    (void *, struct event *);
 static int epoll_dispatch       (struct event_base *, void *, struct timeval *);
 static void epoll_dealloc       (struct event_base *, void *);
 
-struct eventop epollops = {
+const struct eventop epollops = {
         "epoll",
         epoll_init,
         epoll_add,
         epoll_del,
         epoll_dispatch,
         epoll_dealloc,
         1 /* need reinit */
 };
 
 #ifdef HAVE_SETFD
@@ skipping 70 matching lines @@
         evsignal_init(base);
 
         return (epollop);
 }
 
 static int
 epoll_recalc(struct event_base *base, void *arg, int max)
 {
         struct epollop *epollop = arg;
 
-        if (max > epollop->nfds) {
+        if (max >= epollop->nfds) {
                 struct evepoll *fds;
                 int nfds;
 
                 nfds = epollop->nfds;
                 while (nfds < max)
                         nfds <<= 1;
 
                 fds = realloc(epollop->fds, nfds * sizeof(struct evepoll));
                 if (fds == NULL) {
                         event_warn("realloc");
@@ skipping 37 matching lines @@
                 return (0);
         } else if (base->sig.evsignal_caught) {
                 evsignal_process(base);
         }
 
         event_debug(("%s: epoll_wait reports %d", __func__, res));
 
         for (i = 0; i < res; i++) {
                 int what = events[i].events;
                 struct event *evread = NULL, *evwrite = NULL;
+                int fd = events[i].data.fd;
 
-                evep = (struct evepoll *)events[i].data.ptr;
+                if (fd < 0 && fd >= epollop->nfds)
+                        continue;
+                evep = &epollop->fds[fd];
 
                 if (what & (EPOLLHUP|EPOLLERR)) {
                         evread = evep->evread;
                         evwrite = evep->evwrite;
                 } else {
                         if (what & EPOLLIN) {
                                 evread = evep->evread;
                         }
 
                         if (what & EPOLLOUT) {
@@ skipping 41 matching lines @@
         if (evep->evwrite != NULL) {
                 events |= EPOLLOUT;
                 op = EPOLL_CTL_MOD;
         }
 
         if (ev->ev_events & EV_READ)
                 events |= EPOLLIN;
         if (ev->ev_events & EV_WRITE)
                 events |= EPOLLOUT;
 
-        epev.data.ptr = evep;
+        epev.data.fd = fd;
         epev.events = events;
         if (epoll_ctl(epollop->epfd, op, ev->ev_fd, &epev) == -1)
                         return (-1);
 
         /* Update events responsible */
         if (ev->ev_events & EV_READ)
                 evep->evread = ev;
         if (ev->ev_events & EV_WRITE)
                 evep->evwrite = ev;
 
@@ skipping 31 matching lines @@
                         events = EPOLLOUT;
                         op = EPOLL_CTL_MOD;
                 } else if ((events & EPOLLOUT) && evep->evread != NULL) {
                         needreaddelete = 0;
                         events = EPOLLIN;
                         op = EPOLL_CTL_MOD;
                 }
         }
 
         epev.events = events;
-        epev.data.ptr = evep;
+        epev.data.fd = fd;
 
         if (needreaddelete)
                 evep->evread = NULL;
         if (needwritedelete)
                 evep->evwrite = NULL;
 
         if (epoll_ctl(epollop->epfd, op, fd, &epev) == -1)
                 return (-1);
 
         return (0);
 }
 
 static void
 epoll_dealloc(struct event_base *base, void *arg)
 {
         struct epollop *epollop = arg;
 
         evsignal_dealloc(base);
         if (epollop->fds)
                 free(epollop->fds);
         if (epollop->events)
                 free(epollop->events);
         if (epollop->epfd >= 0)
                 close(epollop->epfd);
 
         memset(epollop, 0, sizeof(struct epollop));
         free(epollop);
 }