1 files changed, 29 insertions, 37 deletions

diff --git a/mm/filemap.c b/mm/filemap.c
index d6e67be1802e..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.
@@ -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)
@@ -2718,18 +2720,16 @@ 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;
         }
 
         written = mapping->a_ops->direct_IO(iocb, from);
@@ -2742,10 +2742,8 @@ 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;
@@ -2793,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 */
@@ -3000,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