source: trunk/packages/xen-3.1/xen-3.1/patches/linux-2.6.18/blktap-aio-16_03_06.patch @ 34

fs/aio.c

@@ -34 +34 @@
 #include <asm/uaccess.h>
 #include <asm/mmu_context.h>
 
+#ifdef CONFIG_EPOLL
+#include <linux/poll.h>
+#include <linux/eventpoll.h>
+#endif
+
 #if DEBUG > 1
 #define dprintk         printk
 #else
@@ -1015 +1020 @@
         if (waitqueue_active(&ctx->wait))
                 wake_up(&ctx->wait);
 
+#ifdef CONFIG_EPOLL
+        if (ctx->file && waitqueue_active(&ctx->poll_wait))
+                wake_up(&ctx->poll_wait);
+#endif
         if (ret)
                 put_ioctx(ctx);
 
@@ -1024 +1033 @@
 /* aio_read_evt
  *      Pull an event off of the ioctx's event ring.  Returns the number of 
  *      events fetched (0 or 1 ;-)
+ *      If ent parameter is 0, just returns the number of events that would
+ *      be fetched.
  *      FIXME: make this use cmpxchg.
  *      TODO: make the ringbuffer user mmap()able (requires FIXME).
  */
@@ -1046 +1057 @@
 
         head = ring->head % info->nr;
         if (head != ring->tail) {
-                struct io_event *evp = aio_ring_event(info, head, KM_USER1);
-                *ent = *evp;
-                head = (head + 1) % info->nr;
-                smp_mb(); /* finish reading the event before updatng the head */
-                ring->head = head;
-                ret = 1;
-                put_aio_ring_event(evp, KM_USER1);
+                if (ent) { /* event requested */
+                        struct io_event *evp =
+                                aio_ring_event(info, head, KM_USER1);
+                        *ent = *evp;
+                        head = (head + 1) % info->nr;
+                        /* finish reading the event before updatng the head */
+                        smp_mb();
+                        ring->head = head;
+                        ret = 1;
+                        put_aio_ring_event(evp, KM_USER1);
+                } else /* only need to know availability */
+                        ret = 1;
         }
         spin_unlock(&info->ring_lock);
 
@@ -1235 +1251 @@
 
         aio_cancel_all(ioctx);
         wait_for_all_aios(ioctx);
+#ifdef CONFIG_EPOLL
+        /* forget the poll file, but it's up to the user to close it */
+        if (ioctx->file) {
+                ioctx->file->private_data = 0;
+                ioctx->file = 0;
+        }
+#endif
         put_ioctx(ioctx);       /* once for the lookup */
 }
 
+#ifdef CONFIG_EPOLL
+
+static int aio_queue_fd_close(struct inode *inode, struct file *file)
+{
+        struct kioctx *ioctx = file->private_data;
+        if (ioctx) {
+                file->private_data = 0;
+                spin_lock_irq(&ioctx->ctx_lock);
+                ioctx->file = 0;
+                spin_unlock_irq(&ioctx->ctx_lock);
+        }
+        return 0;
+}
+
+static unsigned int aio_queue_fd_poll(struct file *file, poll_table *wait)
+{       unsigned int pollflags = 0;
+        struct kioctx *ioctx = file->private_data;
+
+        if (ioctx) {
+
+                spin_lock_irq(&ioctx->ctx_lock);
+                /* Insert inside our poll wait queue */
+                poll_wait(file, &ioctx->poll_wait, wait);
+
+                /* Check our condition */
+                if (aio_read_evt(ioctx, 0))
+                        pollflags = POLLIN | POLLRDNORM;
+                spin_unlock_irq(&ioctx->ctx_lock);
+        }
+
+        return pollflags;
+}
+
+static const struct file_operations aioq_fops = {
+        .release        = aio_queue_fd_close,
+        .poll           = aio_queue_fd_poll
+};
+
+/* make_aio_fd:
+ *  Create a file descriptor that can be used to poll the event queue.
+ *  Based and piggybacked on the excellent epoll code.
+ */
+
+static int make_aio_fd(struct kioctx *ioctx)
+{
+        int error, fd;
+        struct inode *inode;
+        struct file *file;
+
+        error = ep_getfd(&fd, &inode, &file, NULL, &aioq_fops);
+        if (error)
+                return error;
+
+        /* associate the file with the IO context */
+        file->private_data = ioctx;
+        ioctx->file = file;
+        init_waitqueue_head(&ioctx->poll_wait);
+        return fd;
+}
+#endif
+
+
 /* sys_io_setup:
  *      Create an aio_context capable of receiving at least nr_events.
  *      ctxp must not point to an aio_context that already exists, and
@@ -1250 +1335 @@
  *      resources are available.  May fail with -EFAULT if an invalid
  *      pointer is passed for ctxp.  Will fail with -ENOSYS if not
  *      implemented.
+ *
+ *      To request a selectable fd, the user context has to be initialized
+ *      to 1, instead of 0, and the return value is the fd.
+ *      This keeps the system call compatible, since a non-zero value
+ *      was not allowed so far.
  */
 asmlinkage long sys_io_setup(unsigned nr_events, aio_context_t __user *ctxp)
 {
         struct kioctx *ioctx = NULL;
         unsigned long ctx;
         long ret;
+        int make_fd = 0;
 
         ret = get_user(ctx, ctxp);
         if (unlikely(ret))
                 goto out;
 
         ret = -EINVAL;
+#ifdef CONFIG_EPOLL
+        if (ctx == 1) {
+                make_fd = 1;
+                ctx = 0;
+        }
+#endif
         if (unlikely(ctx || nr_events == 0)) {
                 pr_debug("EINVAL: io_setup: ctx %lu nr_events %u\n",
                          ctx, nr_events);
@@ -1272 +1369 @@
         ret = PTR_ERR(ioctx);
         if (!IS_ERR(ioctx)) {
                 ret = put_user(ioctx->user_id, ctxp);
-                if (!ret)
-                        return 0;
+#ifdef CONFIG_EPOLL
+                if (make_fd && ret >= 0)
+                        ret = make_aio_fd(ioctx);
+#endif
+                if (ret >= 0)
+                        return ret;
 
                 get_ioctx(ioctx); /* io_destroy() expects us to hold a ref */
                 io_destroy(ioctx);

fs/eventpoll.c

@@ -236 +236 @@
 
 static void ep_poll_safewake_init(struct poll_safewake *psw);
 static void ep_poll_safewake(struct poll_safewake *psw, wait_queue_head_t *wq);
-static int ep_getfd(int *efd, struct inode **einode, struct file **efile,
-                    struct eventpoll *ep);
 static int ep_alloc(struct eventpoll **pep);
 static void ep_free(struct eventpoll *ep);
 static struct epitem *ep_find(struct eventpoll *ep, struct file *file, int fd);
@@ -267 +265 @@
 static int ep_poll(struct eventpoll *ep, struct epoll_event __user *events,
                    int maxevents, long timeout);
 static int eventpollfs_delete_dentry(struct dentry *dentry);
-static struct inode *ep_eventpoll_inode(void);
+static struct inode *ep_eventpoll_inode(const struct file_operations *fops);
 static int eventpollfs_get_sb(struct file_system_type *fs_type,
                               int flags, const char *dev_name,
                               void *data, struct vfsmount *mnt);
@@ -517 +515 @@
          * Creates all the items needed to setup an eventpoll file. That is,
          * a file structure, and inode and a free file descriptor.
          */
-        error = ep_getfd(&fd, &inode, &file, ep);
+        error = ep_getfd(&fd, &inode, &file, ep, &eventpoll_fops);
         if (error)
                 goto eexit_2;
 
@@ -702 +700 @@
 /*
  * Creates the file descriptor to be used by the epoll interface.
  */
-static int ep_getfd(int *efd, struct inode **einode, struct file **efile,
-                    struct eventpoll *ep)
+int ep_getfd(int *efd, struct inode **einode, struct file **efile,
+                    struct eventpoll *ep, const struct file_operations *fops)
 {
         struct qstr this;
         char name[32];
@@ -719 +717 @@
                 goto eexit_1;
 
         /* Allocates an inode from the eventpoll file system */
-        inode = ep_eventpoll_inode();
+        inode = ep_eventpoll_inode(fops);
         error = PTR_ERR(inode);
         if (IS_ERR(inode))
                 goto eexit_2;
@@ -750 +748 @@
 
         file->f_pos = 0;
         file->f_flags = O_RDONLY;
-        file->f_op = &eventpoll_fops;
+        file->f_op = fops;
         file->f_mode = FMODE_READ;
         file->f_version = 0;
         file->private_data = ep;
@@ -1569 +1567 @@
 }
 
 
-static struct inode *ep_eventpoll_inode(void)
+static struct inode *ep_eventpoll_inode(const struct file_operations *fops)
 {
         int error = -ENOMEM;
         struct inode *inode = new_inode(eventpoll_mnt->mnt_sb);
@@ -1577 +1575 @@
         if (!inode)
                 goto eexit_1;
 
-        inode->i_fop = &eventpoll_fops;
+        inode->i_fop = fops;
 
         /*
          * Mark the inode dirty from the very beginning,

include/linux/aio.h

@@ -191 +191 @@
         struct aio_ring_info    ring_info;
 
         struct work_struct      wq;
+#ifdef CONFIG_EPOLL
+        // poll integration
+        wait_queue_head_t       poll_wait;
+        struct file             *file;
+#endif
 };
 
 /* prototypes */

include/linux/eventpoll.h

@@ -90 +90 @@
         eventpoll_release_file(file);
 }
 
+/*
+ * called by aio code to create fd that can poll the  aio event queueQ
+ */
+struct eventpoll;
+int ep_getfd(int *efd, struct inode **einode, struct file **efile,
+             struct eventpoll *ep, const struct file_operations *fops);
 #else
 
 static inline void eventpoll_init_file(struct file *file) {}