r5194: added support for using epoll instead of select() on systems that have

it. epoll is much more scalable than select(), but only exists on some
systems (such as Linux with the 2.6.x kernel). The code detects any
epoll system call failures at runtime and falls back to select() if
there is a problem, so it should be safe to compile this on a 2.6
kernel and run it on a 2.4.x kernel.

The speedup is quite large. It gains 20% in packet rate in the
BENCH-NBT test, on top of another 20% gain from the better timer
handling I added earlier. The really big gain will be when we are
dealing with large numbers of file descriptors. With epoll we can
handle hundreds of file descriptors all O(1), whereas with select it
is O(n).
(This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)

2 files changed, 223 insertions, 48 deletions

diff --git a/source4/build/m4/rewrite.m4 b/source4/build/m4/rewrite.m4
index a6addcf91a..ca1a68248d 100644
--- a/source4/build/m4/rewrite.m4
+++ b/source4/build/m4/rewrite.m4
@@ -199,6 +199,9 @@ AC_CHECK_FUNCS(setbuffer)
 AC_CHECK_FUNCS(getdents)
 AC_CHECK_FUNCS(pread pwrite)
 
+AC_CHECK_HEADERS(sys/epoll.h)
+AC_CHECK_FUNCS(epoll_create)
+
 # needed for lib/charcnv.c
 AC_CHECK_FUNCS(setlocale)
 
diff --git a/source4/lib/events.c b/source4/lib/events.c
index 10d15d8111..a478fc8a41 100644
--- a/source4/lib/events.c
+++ b/source4/lib/events.c
@@ -38,8 +38,8 @@
 
   2) a timed event. You can register an event that happens at a
      specific time.  You can register as many of these as you
-     like. When they are called the handler can choose to set the time
-     for the next event. If next_event is not set then the event is removed.
+     like. They are single shot - add a new timed event in the event
+     handler to get another event.
 
   To setup a set of events you first need to create a event_context
   structure using the function event_context_init(); This returns a
@@ -60,11 +60,14 @@
 #include "dlinklist.h"
 #include "events.h"
 
+/* use epoll if it is available */
+#if defined(HAVE_EPOLL_CREATE) && defined(HAVE_SYS_EPOLL_H)
+#define WITH_EPOLL 1
+#endif
 
-/*
-  please read the comments in events.c before modifying
-*/
-
+#if WITH_EPOLL
+#include <sys/epoll.h>
+#endif
 
 struct event_context {	
 	/* list of filedescriptor events */
@@ -92,14 +95,21 @@ struct event_context {
 	/* information for exiting from the event loop */
 	int exit_code;
 
-	/* this is changed by the destructors for any event type. It
-	   is used to detect event destruction by event handlers,
-	   which means the code that is calling all event handles
-	   needs to assume that the linked list is no longer valid 
+	/* this is changed by the destructors for the fd event
+	   type. It is used to detect event destruction by event
+	   handlers, which means the code that is calling the event
+	   handler needs to assume that the linked list is no longer
+	   valid
 	*/
 	uint32_t destruction_count;
+
+#if WITH_EPOLL
+	/* when using epoll this is the handle from epoll_create */
+	int epoll_fd;
+#endif
 };
 
+
 /*
   create a event_context structure. This must be the first events
   call, and all subsequent calls pass this event_context as the first
@@ -112,9 +122,14 @@ struct event_context *event_context_init(TALLOC_CTX *mem_ctx)
 	ev = talloc_zero(mem_ctx, struct event_context);
 	if (!ev) return NULL;
 
+#if WITH_EPOLL
+	ev->epoll_fd = epoll_create(64);
+#endif
+
 	return ev;
 }
 
+
 /*
   recalculate the maxfd
 */
@@ -129,20 +144,64 @@ static void calc_maxfd(struct event_context *ev)
 	}
 }
 
+
 /* to mark the ev->maxfd invalid
  * this means we need to recalculate it
  */
 #define EVENT_INVALID_MAXFD (-1)
 
 
+#if WITH_EPOLL
+/*
+  called when a epoll call fails, and we should fallback
+  to using select
+*/
+static void epoll_fallback_to_select(struct event_context *ev, const char *reason)
+{
+	DEBUG(0,("%s - using select() - %s\n", reason, strerror(errno)));
+	close(ev->epoll_fd);
+	ev->epoll_fd = -1;
+}
+#endif
+
+
+#if WITH_EPOLL
+/*
+  map from EVENT_FD_* to EPOLLIN/EPOLLOUT
+*/
+static uint32_t epoll_map_flags(uint16_t flags)
+{
+	uint32_t ret = 0;
+	if (flags & EVENT_FD_READ) ret |= EPOLLIN;
+	if (flags & EVENT_FD_WRITE) ret |= EPOLLOUT;
+	return ret;
+}
+#endif
+
+/*
+  destroy an fd_event
+*/
 static int event_fd_destructor(void *ptr)
 {
 	struct fd_event *fde = talloc_get_type(ptr, struct fd_event);
-	if (fde->event_ctx->maxfd == fde->fd) {
-		fde->event_ctx->maxfd = EVENT_INVALID_MAXFD;
+	struct event_context *ev = fde->event_ctx;
+
+	if (ev->maxfd == fde->fd) {
+		ev->maxfd = EVENT_INVALID_MAXFD;
 	}
-	DLIST_REMOVE(fde->event_ctx->fd_events, fde);
-	fde->event_ctx->destruction_count++;
+	DLIST_REMOVE(ev->fd_events, fde);
+	ev->destruction_count++;
+#if WITH_EPOLL
+	if (ev->epoll_fd != -1) {
+		struct epoll_event event;
+		ZERO_STRUCT(event);
+		event.events = epoll_map_flags(fde->flags);
+		event.data.ptr = fde;
+		if (epoll_ctl(ev->epoll_fd, EPOLL_CTL_DEL, fde->fd, &event) != 0) {
+			epoll_fallback_to_select(ev, "EPOLL_CTL_DEL failed");
+		}
+	}
+#endif
 	return 0;
 }
 
@@ -173,6 +232,19 @@ struct fd_event *event_add_fd(struct event_context *ev, TALLOC_CTX *mem_ctx,
 	if (mem_ctx) {
 		talloc_steal(mem_ctx, e);
 	}
+
+#if WITH_EPOLL
+	if (ev->epoll_fd != -1) {
+		struct epoll_event event;
+		ZERO_STRUCT(event);
+		event.events = epoll_map_flags(flags);
+		event.data.ptr = e;
+		if (epoll_ctl(ev->epoll_fd, EPOLL_CTL_ADD, e->fd, &event) != 0) {
+			epoll_fallback_to_select(ev, "EPOLL_CTL_ADD failed");
+		}
+	}
+#endif
+
 	return e;
 }
 
@@ -182,7 +254,7 @@ struct fd_event *event_add_fd(struct event_context *ev, TALLOC_CTX *mem_ctx,
 */
 uint16_t event_fd_flags(struct fd_event *fde)
 {
-	return fde->flags;
+	return fde?fde->flags:0;
 }
 
 /*
@@ -190,7 +262,23 @@ uint16_t event_fd_flags(struct fd_event *fde)
 */
 void event_fd_setflags(struct fd_event *fde, uint16_t flags)
 {
-	fde->flags = flags;
+#if WITH_EPOLL
+	struct event_context *ev;
+	if (fde == NULL) return;
+	ev = fde->event_ctx;
+	if (ev->epoll_fd != -1) {
+		struct epoll_event event;
+		ZERO_STRUCT(event);
+		event.events = epoll_map_flags(flags);
+		event.data.ptr = fde;
+		if (epoll_ctl(ev->epoll_fd, EPOLL_CTL_MOD, fde->fd, &event) != 0) {
+			epoll_fallback_to_select(ev, "EPOLL_CTL_MOD failed");
+		}
+	}
+#endif
+	if (fde) {
+		fde->flags = flags;
+	}
 }
 
 /*
@@ -242,16 +330,93 @@ struct timed_event *event_add_timed(struct event_context *ev, TALLOC_CTX *mem_ct
 }
 
 /*
-  do a single event loop using the events defined in ev this function
+  a timer has gone off - call it
 */
-int event_loop_once(struct event_context *ev)
+static void event_loop_timer(struct event_context *ev)
+{
+	struct timeval t = timeval_current();
+	struct timed_event *te = ev->timed_events;
+
+	te->next_event = timeval_zero();
+
+	te->handler(ev, te, t, te->private);
+
+	/* note the care taken to prevent referencing a event
+	   that could have been freed by the handler */
+	if (ev->timed_events && timeval_is_zero(&ev->timed_events->next_event)) {
+		talloc_free(ev->timed_events);
+	}
+}
+
+#if WITH_EPOLL
+/*
+  event loop handling using epoll
+*/
+static int event_loop_epoll(struct event_context *ev, struct timeval *tvalp)
+{
+	int ret, i;
+	const int maxevents = 8;
+	struct epoll_event events[maxevents];
+	uint32_t destruction_count = ev->destruction_count;
+	int timeout = -1;
+	struct timeval t;
+
+	if (tvalp) {
+		timeout = (tvalp->tv_usec / 1000) + (tvalp->tv_sec*1000);
+	}
+
+	ret = epoll_wait(ev->epoll_fd, events, maxevents, timeout);
+
+	if (ret == -1) {
+		epoll_fallback_to_select(ev, "epoll_wait() failed");
+		return -1;
+	}
+
+	if (ret == 0 && tvalp) {
+		event_loop_timer(ev);
+		return 0;
+	}
+
+	t = timeval_current();
+
+	for (i=0;i<ret;i++) {
+		struct fd_event *fde = talloc_get_type(events[i].data.ptr, 
+						       struct fd_event);
+		uint16_t flags = 0;
+
+		if (fde == NULL) {
+			epoll_fallback_to_select(ev, "epoll_wait() gave bad data");
+			return -1;
+		}
+		if (events[i].events & EPOLLIN) flags |= EVENT_FD_READ;
+		if (events[i].events & EPOLLOUT) flags |= EVENT_FD_WRITE;
+		if (flags) {
+			fde->handler(ev, fde, t, flags, fde->private);
+			if (destruction_count != ev->destruction_count) {
+				break;
+			}
+		}
+	}
+
+	return 0;
+}		
+#endif
+
+/*
+  event loop handling using select()
+*/
+static int event_loop_select(struct event_context *ev, struct timeval *tvalp)
 {
 	fd_set r_fds, w_fds;
-	struct fd_event *fe;
 	int selrtn;
-	struct timeval tval, *tvalp;
 	uint32_t destruction_count = ev->destruction_count;
+	struct fd_event *fe;
 
+	/* we maybe need to recalculate the maxfd */
+	if (ev->maxfd == EVENT_INVALID_MAXFD) {
+		calc_maxfd(ev);
+	}
+		
 	FD_ZERO(&r_fds);
 	FD_ZERO(&w_fds);
 
@@ -267,20 +432,6 @@ int event_loop_once(struct event_context *ev)
 		fe = next;
 	}
 
-	tvalp = NULL;
-		
-	/* work out the right timeout for all timed events */
-	if (ev->timed_events) {
-		struct timeval t = timeval_current();
-		tval = timeval_diff(&ev->timed_events->next_event, &t);
-		tvalp = &tval;
-	}
-
-	/* we maybe need to recalculate the maxfd */
-	if (ev->maxfd == EVENT_INVALID_MAXFD) {
-		calc_maxfd(ev);
-	}
-		
 	selrtn = select(ev->maxfd+1, &r_fds, &w_fds, NULL, tvalp);
 		
 	if (selrtn == -1 && errno == EBADF) {
@@ -293,22 +444,12 @@ int event_loop_once(struct event_context *ev)
 		ev->exit_code = EBADF;
 		return -1;
 	}
-		
-	if (selrtn == 0) {
-		struct timeval t = timeval_current();
-		struct timed_event *te = ev->timed_events;
-
-		te->next_event = timeval_zero();
 
-		te->handler(ev, te, t, te->private);
-
-		/* note the care taken to prevent referencing a event
-		   that could have been freed by the handler */
-		if (ev->timed_events && timeval_is_zero(&ev->timed_events->next_event)) {
-			talloc_free(ev->timed_events);
-		}
+	if (selrtn == 0 && tvalp) {
+		event_loop_timer(ev);
+		return 0;
 	}
-	
+
 	if (selrtn > 0) {
 		struct timeval t = timeval_current();
 		/* at least one file descriptor is ready - check
@@ -328,6 +469,37 @@ int event_loop_once(struct event_context *ev)
 	}
 
 	return 0;
+}		
+
+/*
+  do a single event loop using the events defined in ev this function
+*/
+int event_loop_once(struct event_context *ev)
+{
+	struct timeval tval, *tvalp;
+
+	tvalp = NULL;
+		
+	/* work out the right timeout for all timed events */
+	if (ev->timed_events) {
+		struct timeval t = timeval_current();
+		tval = timeval_diff(&ev->timed_events->next_event, &t);
+		tvalp = &tval;
+		if (timeval_is_zero(tvalp)) {
+			event_loop_timer(ev);
+			return 0;
+		}
+	}
+
+#if WITH_EPOLL
+	if (ev->epoll_fd != -1) {
+		if (event_loop_epoll(ev, tvalp) == 0) {
+			return 0;
+		}
+	}
+#endif
+
+	return event_loop_select(ev, tvalp);
 }
 
 /*