direct-io: Handle O_(D)SYNC AIO

Call generic_write_sync() from the deferred I/O completion handler if
O_DSYNC is set for a write request.  Also make sure various callers
don't call generic_write_sync if the direct I/O code returns
-EIOCBQUEUED.

Based on an earlier patch from Jan Kara <jack@suse.cz> with updates from
Jeff Moyer <jmoyer@redhat.com> and Darrick J. Wong <darrick.wong@oracle.com>.

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, 36 insertions, 9 deletions

diff --git a/fs/direct-io.c b/fs/direct-io.c
index 8b31b9f449f4..1782023bd68a 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -266,8 +266,18 @@ static ssize_t dio_complete(struct dio *dio, loff_t offset, ssize_t ret,
                 dio->end_io(dio->iocb, offset, transferred, dio->private);
 
         inode_dio_done(dio->inode);
-        if (is_async)
+        if (is_async) {
+                if (dio->rw & WRITE) {
+                        int err;
+
+                        err = generic_write_sync(dio->iocb->ki_filp, offset,
+                                                 transferred);
+                        if (err < 0 && ret > 0)
+                                ret = err;
+                }
+
                 aio_complete(dio->iocb, ret, 0);
+        }
 
         kmem_cache_free(dio_cache, dio);
         return ret;
@@ -1183,11 +1193,6 @@ do_blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
         }
 
         /*
-         * Will be decremented at I/O completion time.
-         */
-        atomic_inc(&inode->i_dio_count);
-
-        /*
          * For file extending writes updating i_size before data
          * writeouts complete can expose uninitialized blocks. So
          * even for AIO, we need to wait for i/o to complete before
@@ -1195,11 +1200,33 @@ do_blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
          */
         dio->is_async = !is_sync_kiocb(iocb) && !((rw & WRITE) &&
                 (end > i_size_read(inode)));
-
-        retval = 0;
-
         dio->inode = inode;
         dio->rw = rw;
+
+        /*
+         * For AIO O_(D)SYNC writes we need to defer completions to a workqueue
+         * so that we can call ->fsync.
+         */
+        if (dio->is_async && (rw & WRITE) &&
+            ((iocb->ki_filp->f_flags & O_DSYNC) ||
+             IS_SYNC(iocb->ki_filp->f_mapping->host))) {
+                retval = dio_set_defer_completion(dio);
+                if (retval) {
+                        /*
+                         * We grab i_mutex only for reads so we don't have
+                         * to release it here
+                         */
+                        kmem_cache_free(dio_cache, dio);
+                        goto out;
+                }
+        }
+
+        /*
+         * Will be decremented at I/O completion time.
+         */
+        atomic_inc(&inode->i_dio_count);
+
+        retval = 0;
         sdio.blkbits = blkbits;
         sdio.blkfactor = i_blkbits - blkbits;
         sdio.block_in_file = offset >> blkbits;