epoll: support for disabling items, and a self-test app

Enhanced epoll_ctl to support EPOLL_CTL_DISABLE, which disables an epoll
item.  If epoll_ctl doesn't return -EBUSY in this case, it is then safe to
delete the epoll item in a multi-threaded environment.  Also added a new
test_epoll self- test app to both demonstrate the need for this feature
and test it.

Signed-off-by: Paton J. Lewis <palewis@adobe.com>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
Cc: Jason Baron <jbaron@redhat.com>
Cc: Paul Holland <pholland@adobe.com>
Cc: Davide Libenzi <davidel@xmailserver.org>
Cc: Michael Kerrisk <mtk.manpages@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

3 files changed, 356 insertions, 1 deletions

diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index 85baf11e2acd..43480149119e 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -1,4 +1,4 @@
-TARGETS = breakpoints kcmp mqueue vm cpu-hotplug memory-hotplug
+TARGETS = breakpoints kcmp mqueue vm cpu-hotplug memory-hotplug epoll
 
 all:
         for TARGET in $(TARGETS); do \
diff --git a/tools/testing/selftests/epoll/Makefile b/tools/testing/selftests/epoll/Makefile
new file mode 100644
index 000000000000..19806ed62f50
--- /dev/null
+++ b/tools/testing/selftests/epoll/Makefile
@@ -0,0 +1,11 @@
+# Makefile for epoll selftests
+
+all: test_epoll
+%: %.c
+        gcc -pthread -g -o $@ $^
+
+run_tests: all
+        ./test_epoll
+
+clean:
+        $(RM) test_epoll
diff --git a/tools/testing/selftests/epoll/test_epoll.c b/tools/testing/selftests/epoll/test_epoll.c
new file mode 100644
index 000000000000..e0fcff1e8331
--- /dev/null
+++ b/tools/testing/selftests/epoll/test_epoll.c
@@ -0,0 +1,344 @@
+/*
+ *  tools/testing/selftests/epoll/test_epoll.c
+ *
+ *  Copyright 2012 Adobe Systems Incorporated
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Paton J. Lewis <palewis@adobe.com>
+ *
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/epoll.h>
+#include <sys/socket.h>
+
+/*
+ * A pointer to an epoll_item_private structure will be stored in the epoll
+ * item's event structure so that we can get access to the epoll_item_private
+ * data after calling epoll_wait:
+ */
+struct epoll_item_private {
+        int index;  /* Position of this struct within the epoll_items array. */
+        int fd;
+        uint32_t events;
+        pthread_mutex_t mutex;  /* Guards the following variables... */
+        int stop;
+        int status;  /* Stores any error encountered while handling item. */
+        /* The following variable allows us to test whether we have encountered
+           a problem while attempting to cancel and delete the associated
+           event. When the test program exits, 'deleted' should be exactly
+           one. If it is greater than one, then the failed test reflects a real
+           world situation where we would have tried to access the epoll item's
+           private data after deleting it: */
+        int deleted;
+};
+
+struct epoll_item_private *epoll_items;
+
+/*
+ * Delete the specified item from the epoll set. In a real-world secneario this
+ * is where we would free the associated data structure, but in this testing
+ * environment we retain the structure so that we can test for double-deletion:
+ */
+void delete_item(int index)
+{
+        __sync_fetch_and_add(&epoll_items[index].deleted, 1);
+}
+
+/*
+ * A pointer to a read_thread_data structure will be passed as the argument to
+ * each read thread:
+ */
+struct read_thread_data {
+        int stop;
+        int status;  /* Indicates any error encountered by the read thread. */
+        int epoll_set;
+};
+
+/*
+ * The function executed by the read threads:
+ */
+void *read_thread_function(void *function_data)
+{
+        struct read_thread_data *thread_data =
+                (struct read_thread_data *)function_data;
+        struct epoll_event event_data;
+        struct epoll_item_private *item_data;
+        char socket_data;
+
+        /* Handle events until we encounter an error or this thread's 'stop'
+           condition is set: */
+        while (1) {
+                int result = epoll_wait(thread_data->epoll_set,
+                                        &event_data,
+                                        1,      /* Number of desired events */
+                                        1000);  /* Timeout in ms */
+                if (result < 0) {
+                        /* Breakpoints signal all threads. Ignore that while
+                           debugging: */
+                        if (errno == EINTR)
+                                continue;
+                        thread_data->status = errno;
+                        return 0;
+                } else if (thread_data->stop)
+                        return 0;
+                else if (result == 0)  /* Timeout */
+                        continue;
+
+                /* We need the mutex here because checking for the stop
+                   condition and re-enabling the epoll item need to be done
+                   together as one atomic operation when EPOLL_CTL_DISABLE is
+                   available: */
+                item_data = (struct epoll_item_private *)event_data.data.ptr;
+                pthread_mutex_lock(&item_data->mutex);
+
+                /* Remove the item from the epoll set if we want to stop
+                   handling that event: */
+                if (item_data->stop)
+                        delete_item(item_data->index);
+                else {
+                        /* Clear the data that was written to the other end of
+                           our non-blocking socket: */
+                        do {
+                                if (read(item_data->fd, &socket_data, 1) < 1) {
+                                        if ((errno == EAGAIN) ||
+                                            (errno == EWOULDBLOCK))
+                                                break;
+                                        else
+                                                goto error_unlock;
+                                }
+                        } while (item_data->events & EPOLLET);
+
+                        /* The item was one-shot, so re-enable it: */
+                        event_data.events = item_data->events;
+                        if (epoll_ctl(thread_data->epoll_set,
+                                                  EPOLL_CTL_MOD,
+                                                  item_data->fd,
+                                                  &event_data) < 0)
+                                goto error_unlock;
+                }
+
+                pthread_mutex_unlock(&item_data->mutex);
+        }
+
+error_unlock:
+        thread_data->status = item_data->status = errno;
+        pthread_mutex_unlock(&item_data->mutex);
+        return 0;
+}
+
+/*
+ * A pointer to a write_thread_data structure will be passed as the argument to
+ * the write thread:
+ */
+struct write_thread_data {
+        int stop;
+        int status;  /* Indicates any error encountered by the write thread. */
+        int n_fds;
+        int *fds;
+};
+
+/*
+ * The function executed by the write thread. It writes a single byte to each
+ * socket in turn until the stop condition for this thread is set. If writing to
+ * a socket would block (i.e. errno was EAGAIN), we leave that socket alone for
+ * the moment and just move on to the next socket in the list. We don't care
+ * about the order in which we deliver events to the epoll set. In fact we don't
+ * care about the data we're writing to the pipes at all; we just want to