Merge tag 'xfs-for-linus-4.1-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git...

[cascardo/linux.git] / fs / xfs / xfs_file.c

diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 3a5d305..8121e75 100644 (file)
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -38,7 +38,6 @@
 #include "xfs_icache.h"
 #include "xfs_pnfs.h"
 
-#include <linux/aio.h>
 #include <linux/dcache.h>
 #include <linux/falloc.h>
 #include <linux/pagevec.h>
@@ -280,7 +279,7 @@ xfs_file_read_iter(
 
        XFS_STATS_INC(xs_read_calls);
 
-       if (unlikely(file->f_flags & O_DIRECT))
+       if (unlikely(iocb->ki_flags & IOCB_DIRECT))
                ioflags |= XFS_IO_ISDIRECT;
        if (file->f_mode & FMODE_NOCMTIME)
                ioflags |= XFS_IO_INVIS;
@@ -545,18 +544,19 @@ xfs_zero_eof(
  */
 STATIC ssize_t
 xfs_file_aio_write_checks(
-       struct file             *file,
-       loff_t                  *pos,
-       size_t                  *count,
+       struct kiocb            *iocb,
+       struct iov_iter         *from,
        int                     *iolock)
 {
+       struct file             *file = iocb->ki_filp;
        struct inode            *inode = file->f_mapping->host;
        struct xfs_inode        *ip = XFS_I(inode);
-       int                     error = 0;
+       ssize_t                 error = 0;
+       size_t                  count = iov_iter_count(from);
 
 restart:
-       error = generic_write_checks(file, pos, count, S_ISBLK(inode->i_mode));
-       if (error)
+       error = generic_write_checks(iocb, from);
+       if (error <= 0)
                return error;
 
        error = xfs_break_layouts(inode, iolock, true);
@@ -579,7 +579,7 @@ restart:
         * and hence be able to correctly determine if we need to run zeroing.
         */
        spin_lock(&ip->i_flags_lock);
-       if (*pos > i_size_read(inode)) {
+       if (iocb->ki_pos > i_size_read(inode)) {
                bool    zero = false;
 
                spin_unlock(&ip->i_flags_lock);
@@ -587,6 +587,7 @@ restart:
                        xfs_rw_iunlock(ip, *iolock);
                        *iolock = XFS_IOLOCK_EXCL;
                        xfs_rw_ilock(ip, *iolock);
+                       iov_iter_reexpand(from, count);
 
                        /*
                         * We now have an IO submission barrier in place, but
@@ -599,7 +600,7 @@ restart:
                        inode_dio_wait(inode);
                        goto restart;
                }
-               error = xfs_zero_eof(ip, *pos, i_size_read(inode), &zero);
+               error = xfs_zero_eof(ip, iocb->ki_pos, i_size_read(inode), &zero);
                if (error)
                        return error;
        } else
@@ -702,10 +703,11 @@ xfs_file_dio_aio_write(
                xfs_rw_ilock(ip, iolock);
        }
 
-       ret = xfs_file_aio_write_checks(file, &pos, &count, &iolock);
+       ret = xfs_file_aio_write_checks(iocb, from, &iolock);
        if (ret)
                goto out;
-       iov_iter_truncate(from, count);
+       count = iov_iter_count(from);
+       pos = iocb->ki_pos;
        end = pos + count - 1;
 
        if (mapping->nrpages) {
@@ -739,7 +741,7 @@ xfs_file_dio_aio_write(
        trace_xfs_file_direct_write(ip, count, iocb->ki_pos, 0);
 
        data = *from;
-       ret = mapping->a_ops->direct_IO(WRITE, iocb, &data, pos);
+       ret = mapping->a_ops->direct_IO(iocb, &data, pos);
 
        /* see generic_file_direct_write() for why this is necessary */
        if (mapping->nrpages) {
@@ -773,24 +775,22 @@ xfs_file_buffered_aio_write(
        ssize_t                 ret;
        int                     enospc = 0;
        int                     iolock = XFS_IOLOCK_EXCL;
-       loff_t                  pos = iocb->ki_pos;
-       size_t                  count = iov_iter_count(from);
 
        xfs_rw_ilock(ip, iolock);
 
-       ret = xfs_file_aio_write_checks(file, &pos, &count, &iolock);
+       ret = xfs_file_aio_write_checks(iocb, from, &iolock);
        if (ret)
                goto out;
 
-       iov_iter_truncate(from, count);
        /* We can write back this queue in page reclaim */
        current->backing_dev_info = inode_to_bdi(inode);
 
 write_retry:
-       trace_xfs_file_buffered_write(ip, count, iocb->ki_pos, 0);
-       ret = generic_perform_write(file, from, pos);
+       trace_xfs_file_buffered_write(ip, iov_iter_count(from),
+                                     iocb->ki_pos, 0);
+       ret = generic_perform_write(file, from, iocb->ki_pos);
        if (likely(ret >= 0))
-               iocb->ki_pos = pos + ret;
+               iocb->ki_pos += ret;
 
        /*
         * If we hit a space limit, try to free up some lingering preallocated
@@ -842,7 +842,7 @@ xfs_file_write_iter(
        if (XFS_FORCED_SHUTDOWN(ip->i_mount))
                return -EIO;
 
-       if (unlikely(file->f_flags & O_DIRECT))
+       if (unlikely(iocb->ki_flags & IOCB_DIRECT))
                ret = xfs_file_dio_aio_write(iocb, from);
        else
                ret = xfs_file_buffered_aio_write(iocb, from);
@@ -1500,8 +1500,6 @@ xfs_filemap_page_mkwrite(
 
 const struct file_operations xfs_file_operations = {
        .llseek         = xfs_file_llseek,
-       .read           = new_sync_read,
-       .write          = new_sync_write,
        .read_iter      = xfs_file_read_iter,
        .write_iter     = xfs_file_write_iter,
        .splice_read    = xfs_file_splice_read,