direct-io: Implement generic deferred AIO completions

Add support to the core direct-io code to defer AIO completions to user
context using a workqueue.  This replaces opencoded and less efficient
code in XFS and ext4 (we save a memory allocation for each direct IO)
and will be needed to properly support O_(D)SYNC for AIO.

The communication between the filesystem and the direct I/O code requires
a new buffer head flag, which is a bit ugly but not avoidable until the
direct I/O code stops abusing the buffer_head structure for communicating
with the filesystems.

Currently this creates a per-superblock unbound workqueue for these
completions, which is taken from an earlier patch by Jan Kara.  I'm
not really convinced about this use and would prefer a "normal" global
workqueue with a high concurrency limit, but this needs further discussion.

JK: Fixed ext4 part, dynamic allocation of the workqueue.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

1 files changed, 7 insertions, 21 deletions

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index c2ca04e67a4f..123bd81692d1 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -727,8 +727,12 @@ static int _ext4_get_block(struct inode *inode, sector_t iblock,
 
         ret = ext4_map_blocks(handle, inode, &map, flags);
         if (ret > 0) {
+                ext4_io_end_t *io_end = ext4_inode_aio(inode);
+
                 map_bh(bh, inode->i_sb, map.m_pblk);
                 bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags;
+                if (io_end && io_end->flag & EXT4_IO_END_UNWRITTEN)
+                        set_buffer_defer_completion(bh);
                 bh->b_size = inode->i_sb->s_blocksize * map.m_len;
                 ret = 0;
         }
@@ -2991,19 +2995,13 @@ static int ext4_get_block_write_nolock(struct inode *inode, sector_t iblock,
 }
 
 static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
-                            ssize_t size, void *private, int ret,
-                            bool is_async)
+                            ssize_t size, void *private)
 {
-        struct inode *inode = file_inode(iocb->ki_filp);
         ext4_io_end_t *io_end = iocb->private;
 
         /* if not async direct IO just return */
-        if (!io_end) {
-                inode_dio_done(inode);
-                if (is_async)
-                        aio_complete(iocb, ret, 0);
+        if (!io_end)
                 return;
-        }
 
         ext_debug("ext4_end_io_dio(): io_end 0x%p "
                   "for inode %lu, iocb 0x%p, offset %llu, size %zd\n",
@@ -3013,11 +3011,7 @@ static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
         iocb->private = NULL;
         io_end->offset = offset;
         io_end->size = size;
-        if (is_async) {
-                io_end->iocb = iocb;
-                io_end->result = ret;
-        }
-        ext4_put_io_end_defer(io_end);
+        ext4_put_io_end(io_end);
 }
 
 /*
@@ -3102,7 +3096,6 @@ static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
                         ret = -ENOMEM;
                         goto retake_lock;
                 }
-                io_end->flag |= EXT4_IO_END_DIRECT;
                 /*
                  * Grab reference for DIO. Will be dropped in ext4_end_io_dio()
                  */
@@ -3147,13 +3140,6 @@ static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
                 if (ret <= 0 && ret != -EIOCBQUEUED && iocb->private) {
                         WARN_ON(iocb->private != io_end);
                         WARN_ON(io_end->flag & EXT4_IO_END_UNWRITTEN);
-                        WARN_ON(io_end->iocb);
-                        /*
-                         * Generic code already did inode_dio_done() so we
-                         * have to clear EXT4_IO_END_DIRECT to not do it for
-                         * the second time.
-                         */
-                        io_end->flag = 0;
                         ext4_put_io_end(io_end);
                         iocb->private = NULL;
                 }