lift generic_write_checks() into callers of __generic_file_write_iter()

[cascardo/linux.git] / mm / filemap.c

diff --git a/mm/filemap.c b/mm/filemap.c
index ad72420..a794a7f 100644 (file)
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -13,7 +13,6 @@
 #include <linux/compiler.h>
 #include <linux/fs.h>
 #include <linux/uaccess.h>
-#include <linux/aio.h>
 #include <linux/capability.h>
 #include <linux/kernel_stat.h>
 #include <linux/gfp.h>
@@ -1708,7 +1707,7 @@ generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
                                        pos + count - 1);
                if (!retval) {
                        struct iov_iter data = *iter;
-                       retval = mapping->a_ops->direct_IO(READ, iocb, &data, pos);
+                       retval = mapping->a_ops->direct_IO(iocb, &data, pos);
                }
 
                if (retval > 0) {
@@ -2396,7 +2395,7 @@ generic_file_direct_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos)
        }
 
        data = *from;
-       written = mapping->a_ops->direct_IO(WRITE, iocb, &data, pos);
+       written = mapping->a_ops->direct_IO(iocb, &data, pos);
 
        /*
         * Finally, try again to invalidate clean pages which might have been
@@ -2558,23 +2557,12 @@ ssize_t __generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        struct file *file = iocb->ki_filp;
        struct address_space * mapping = file->f_mapping;
        struct inode    *inode = mapping->host;
-       loff_t          pos = iocb->ki_pos;
        ssize_t         written = 0;
        ssize_t         err;
        ssize_t         status;
-       size_t          count = iov_iter_count(from);
 
        /* We can write back this queue in page reclaim */
        current->backing_dev_info = inode_to_bdi(inode);
-       err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
-       if (err)
-               goto out;
-
-       if (count == 0)
-               goto out;
-
-       iov_iter_truncate(from, count);
-
        err = file_remove_suid(file);
        if (err)
                goto out;
@@ -2584,9 +2572,9 @@ ssize_t __generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
                goto out;
 
        if (io_is_direct(file)) {
-               loff_t endbyte;
+               loff_t pos, endbyte;
 
-               written = generic_file_direct_write(iocb, from, pos);
+               written = generic_file_direct_write(iocb, from, iocb->ki_pos);
                /*
                 * If the write stopped short of completing, fall back to
                 * buffered writes.  Some filesystems do this for writes to
@@ -2594,13 +2582,10 @@ ssize_t __generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
                 * not succeed (even if it did, DAX does not handle dirty
                 * page-cache pages correctly).
                 */
-               if (written < 0 || written == count || IS_DAX(inode))
+               if (written < 0 || !iov_iter_count(from) || IS_DAX(inode))
                        goto out;
 
-               pos += written;
-               count -= written;
-
-               status = generic_perform_write(file, from, pos);
+               status = generic_perform_write(file, from, pos = iocb->ki_pos);
                /*
                 * If generic_perform_write() returned a synchronous error
                 * then we want to return the number of bytes which were
@@ -2612,15 +2597,15 @@ ssize_t __generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
                        err = status;
                        goto out;
                }
-               iocb->ki_pos = pos + status;
                /*
                 * We need to ensure that the page cache pages are written to
                 * disk and invalidated to preserve the expected O_DIRECT
                 * semantics.
                 */
                endbyte = pos + status - 1;
-               err = filemap_write_and_wait_range(file->f_mapping, pos, endbyte);
+               err = filemap_write_and_wait_range(mapping, pos, endbyte);
                if (err == 0) {
+                       iocb->ki_pos = endbyte + 1;
                        written += status;
                        invalidate_mapping_pages(mapping,
                                                 pos >> PAGE_CACHE_SHIFT,
@@ -2632,9 +2617,9 @@ ssize_t __generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
                         */
                }
        } else {
-               written = generic_perform_write(file, from, pos);
-               if (likely(written >= 0))
-                       iocb->ki_pos = pos + written;
+               written = generic_perform_write(file, from, iocb->ki_pos);
+               if (likely(written > 0))
+                       iocb->ki_pos += written;
        }
 out:
        current->backing_dev_info = NULL;
@@ -2656,9 +2641,14 @@ ssize_t generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        struct file *file = iocb->ki_filp;
        struct inode *inode = file->f_mapping->host;
        ssize_t ret;
+       size_t count = iov_iter_count(from);
 
        mutex_lock(&inode->i_mutex);
-       ret = __generic_file_write_iter(iocb, from);
+       ret = generic_write_checks(file, &iocb->ki_pos, &count, 0);
+       if (!ret && count) {
+               iov_iter_truncate(from, count);
+               ret = __generic_file_write_iter(iocb, from);
+       }
        mutex_unlock(&inode->i_mutex);
 
        if (ret > 0) {