1 files changed, 36 insertions, 45 deletions

diff --git a/mm/filemap.c b/mm/filemap.c
index 1694623a6289..6f1be573a5e6 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -519,7 +519,7 @@ EXPORT_SYMBOL(filemap_write_and_wait);
  *
  * Write out and wait upon file offsets lstart->lend, inclusive.
  *
- * Note that `lend' is inclusive (describes the last byte to be written) so
+ * Note that @lend is inclusive (describes the last byte to be written) so
  * that this function can be used to write to the very end-of-file (end = -1).
  */
 int filemap_write_and_wait_range(struct address_space *mapping,
@@ -1277,12 +1277,14 @@ EXPORT_SYMBOL(find_lock_entry);
  *
  * PCG flags modify how the page is returned.
  *
- * FGP_ACCESSED: the page will be marked accessed
- * FGP_LOCK: Page is return locked
- * FGP_CREAT: If page is not present then a new page is allocated using
- *              @gfp_mask and added to the page cache and the VM's LRU
- *              list. The page is returned locked and with an increased
- *              refcount. Otherwise, %NULL is returned.
+ * @fgp_flags can be:
+ *
+ * - FGP_ACCESSED: the page will be marked accessed
+ * - FGP_LOCK: Page is return locked
+ * - FGP_CREAT: If page is not present then a new page is allocated using
+ *   @gfp_mask and added to the page cache and the VM's LRU
+ *   list. The page is returned locked and with an increased
+ *   refcount. Otherwise, NULL is returned.
  *
  * If FGP_LOCK or FGP_CREAT are specified then the function may sleep even
  * if the GFP flags specified for FGP_CREAT are atomic.
@@ -2033,7 +2035,6 @@ generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
         if (iocb->ki_flags & IOCB_DIRECT) {
                 struct address_space *mapping = file->f_mapping;
                 struct inode *inode = mapping->host;
-                struct iov_iter data = *iter;
                 loff_t size;
 
                 size = i_size_read(inode);
@@ -2044,11 +2045,12 @@ generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
 
                 file_accessed(file);
 
-                retval = mapping->a_ops->direct_IO(iocb, &data);
+                retval = mapping->a_ops->direct_IO(iocb, iter);
                 if (retval >= 0) {
                         iocb->ki_pos += retval;
-                        iov_iter_advance(iter, retval);
+                        count -= retval;
                 }
+                iov_iter_revert(iter, count - iov_iter_count(iter));
 
                 /*
                  * Btrfs can have a short DIO read if we encounter
@@ -2059,7 +2061,7 @@ generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
                  * the rest of the read.  Buffered reads will not work for
                  * DAX files, so don't bother trying.
                  */
-                if (retval < 0 || !iov_iter_count(iter) || iocb->ki_pos >= size ||
+                if (retval < 0 || !count || iocb->ki_pos >= size ||
                     IS_DAX(inode))
                         goto out;
         }
@@ -2202,12 +2204,12 @@ int filemap_fault(struct vm_fault *vmf)
         struct file_ra_state *ra = &file->f_ra;
         struct inode *inode = mapping->host;
         pgoff_t offset = vmf->pgoff;
+        pgoff_t max_off;
         struct page *page;
-        loff_t size;
         int ret = 0;
 
-        size = round_up(i_size_read(inode), PAGE_SIZE);
-        if (offset >= size >> PAGE_SHIFT)
+        max_off = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
+        if (unlikely(offset >= max_off))
                 return VM_FAULT_SIGBUS;
 
         /*
@@ -2256,8 +2258,8 @@ retry_find:
          * Found the page and have a reference on it.
          * We must recheck i_size under page lock.
          */
-        size = round_up(i_size_read(inode), PAGE_SIZE);
-        if (unlikely(offset >= size >> PAGE_SHIFT)) {
+        max_off = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
+        if (unlikely(offset >= max_off)) {
                 unlock_page(page);
                 put_page(page);
                 return VM_FAULT_SIGBUS;
@@ -2323,7 +2325,7 @@ void filemap_map_pages(struct vm_fault *vmf,
         struct file *file = vmf->vma->vm_file;
         struct address_space *mapping = file->f_mapping;
         pgoff_t last_pgoff = start_pgoff;
-        loff_t size;
+        unsigned long max_idx;
         struct page *head, *page;
 
         rcu_read_lock();
@@ -2369,8 +2371,8 @@ repeat:
                 if (page->mapping != mapping || !PageUptodate(page))
                         goto unlock;
 
-                size = round_up(i_size_read(mapping->host), PAGE_SIZE);
-                if (page->index >= size >> PAGE_SHIFT)
+                max_idx = DIV_ROUND_UP(i_size_read(mapping->host), PAGE_SIZE);
+                if (page->index >= max_idx)
                         goto unlock;
 
                 if (file->f_ra.mmap_miss > 0)
@@ -2704,7 +2706,6 @@ generic_file_direct_write(struct kiocb *iocb, struct iov_iter *from)
         ssize_t         written;
         size_t          write_len;
         pgoff_t         end;
-        struct iov_iter data;
 
         write_len = iov_iter_count(from);
         end = (pos + write_len - 1) >> PAGE_SHIFT;
@@ -2719,22 +2720,19 @@ generic_file_direct_write(struct kiocb *iocb, struct iov_iter *from)
          * about to write.  We do this *before* the write so that we can return
          * without clobbering -EIOCBQUEUED from ->direct_IO().
          */
-        if (mapping->nrpages) {
-                written = invalidate_inode_pages2_range(mapping,
+        written = invalidate_inode_pages2_range(mapping,
                                         pos >> PAGE_SHIFT, end);
-                /*
-                 * If a page can not be invalidated, return 0 to fall back
-                 * to buffered write.
-                 */
-                if (written) {
-                        if (written == -EBUSY)
-                                return 0;
-                        goto out;
-                }
+        /*
+         * If a page can not be invalidated, return 0 to fall back
+         * to buffered write.
+         */
+        if (written) {
+                if (written == -EBUSY)
+                        return 0;
+                goto out;
         }
 
-        data = *from;
-        written = mapping->a_ops->direct_IO(iocb, &data);
+        written = mapping->a_ops->direct_IO(iocb, from);
 
         /*
          * Finally, try again to invalidate clean pages which might have been
@@ -2744,20 +2742,19 @@ generic_file_direct_write(struct kiocb *iocb, struct iov_iter *from)
          * so we don't support it 100%.  If this invalidation
          * fails, tough, the write still worked...
          */
-        if (mapping->nrpages) {
-                invalidate_inode_pages2_range(mapping,
-                                              pos >> PAGE_SHIFT, end);
-        }
+        invalidate_inode_pages2_range(mapping,
+                                pos >> PAGE_SHIFT, end);
 
         if (written > 0) {
                 pos += written;
-                iov_iter_advance(from, written);
+                write_len -= written;
                 if (pos > i_size_read(inode) && !S_ISBLK(inode->i_mode)) {
                         i_size_write(inode, pos);
                         mark_inode_dirty(inode);
                 }
                 iocb->ki_pos = pos;
         }
+        iov_iter_revert(from, write_len - iov_iter_count(from));
 out:
         return written;
 }
@@ -2794,12 +2791,6 @@ ssize_t generic_perform_write(struct file *file,
         ssize_t written = 0;
         unsigned int flags = 0;
 
-        /*
-         * Copies from kernel address space cannot fail (NFSD is a big user).
-         */
-        if (!iter_is_iovec(i))
-                flags |= AOP_FLAG_UNINTERRUPTIBLE;
-
         do {
                 struct page *page;
                 unsigned long offset;   /* Offset into pagecache page */
@@ -3001,7 +2992,7 @@ EXPORT_SYMBOL(generic_file_write_iter);
  * @gfp_mask: memory allocation flags (and I/O mode)
  *
  * The address_space is to try to release any data against the page
- * (presumably at page->private).  If the release was successful, return `1'.
+ * (presumably at page->private).  If the release was successful, return '1'.
  * Otherwise return zero.
  *
  * This may also be called if PG_fscache is set on a page, indicating that the