posix: upgrade libevent from 1.4.7 to 1.4.13

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 16 matching lines @@
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <stdint.h>
 #include <sys/types.h>
 #include <sys/resource.h>
 #ifdef HAVE_SYS_TIME_H
 #include <sys/time.h>
 #else
-#include <sys/_time.h>
+#include <sys/_libevent_time.h>
 #endif
 #include <sys/queue.h>
 #include <sys/epoll.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <errno.h>
 #ifdef HAVE_FCNTL_H
@@ skipping 39 matching lines @@
 
 #ifdef HAVE_SETFD
 #define FD_CLOSEONEXEC(x) do { \
         if (fcntl(x, F_SETFD, 1) == -1) \
                 event_warn("fcntl(%d, F_SETFD)", x); \
 } while (0)
 #else
 #define FD_CLOSEONEXEC(x)
 #endif
 
-#define NEVENT  32
-
 /* On Linux kernels at least up to 2.6.24.4, epoll can't handle timeout
  * values bigger than (LONG_MAX - 999ULL)/HZ.  HZ in the wild can be
  * as big as 1000, and LONG_MAX can be as small as (1<<31)-1, so the
  * largest number of msec we can support here is 2147482.  Let's
  * round that down by 47 seconds.
  */
 #define MAX_EPOLL_TIMEOUT_MSEC (35*60*1000)
 
+#define INITIAL_NFILES 32
+#define INITIAL_NEVENTS 32
+#define MAX_NEVENTS 4096
+
 static void *
 epoll_init(struct event_base *base)
 {
-        int epfd, nfiles = NEVENT;
-        struct rlimit rl;
+        int epfd;
         struct epollop *epollop;
 
         /* Disable epollueue when this environment variable is set */
-        if (getenv("EVENT_NOEPOLL"))
+        if (evutil_getenv("EVENT_NOEPOLL"))
                 return (NULL);
 
         /* Initalize the kernel queue */
-
-        if ((epfd = epoll_create(nfiles)) == -1) {
+        if ((epfd = epoll_create(32000)) == -1) {
                 if (errno != ENOSYS)
                         event_warn("epoll_create");
                 return (NULL);
         }
 
         FD_CLOSEONEXEC(epfd);
 
         if (!(epollop = calloc(1, sizeof(struct epollop))))
                 return (NULL);
 
         epollop->epfd = epfd;
 
         /* Initalize fields */
-        epollop->events = malloc(nfiles * sizeof(struct epoll_event));
+        epollop->events = malloc(INITIAL_NEVENTS * sizeof(struct epoll_event));
         if (epollop->events == NULL) {
                 free(epollop);
                 return (NULL);
         }
-        epollop->nevents = nfiles;
+        epollop->nevents = INITIAL_NEVENTS;
 
-        epollop->fds = calloc(nfiles, sizeof(struct evepoll));
+        epollop->fds = calloc(INITIAL_NFILES, sizeof(struct evepoll));
         if (epollop->fds == NULL) {
                 free(epollop->events);
                 free(epollop);
                 return (NULL);
         }
-        epollop->nfds = nfiles;
+        epollop->nfds = INITIAL_NFILES;
 
         evsignal_init(base);
 
         return (epollop);
 }
 
 static int
 epoll_recalc(struct event_base *base, void *arg, int max)
 {
         struct epollop *epollop = arg;
@@ skipping 77 matching lines @@
 
                 if (!(evread||evwrite))
                         continue;
 
                 if (evread != NULL)
                         event_active(evread, EV_READ, 1);
                 if (evwrite != NULL)
                         event_active(evwrite, EV_WRITE, 1);
         }
 
+        if (res == epollop->nevents && epollop->nevents < MAX_NEVENTS) {
+                /* We used all of the event space this time.  We should
+                   be ready for more events next time. */
+                int new_nevents = epollop->nevents * 2;
+                struct epoll_event *new_events;
+
+                new_events = realloc(epollop->events,
+                    new_nevents * sizeof(struct epoll_event));
+                if (new_events) {
+                        epollop->events = new_events;
+                        epollop->nevents = new_nevents;
+                }
+        }
+
         return (0);
 }
 
 
 static int
 epoll_add(void *arg, struct event *ev)
 {
         struct epollop *epollop = arg;
         struct epoll_event epev = {0, {0}};
         struct evepoll *evep;
@@ skipping 99 matching lines @@
         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);
 }