1 files changed, 82 insertions, 55 deletions

diff --git a/mm/filemap.c b/mm/filemap.c
index f820e600f1ad..c0018f2d50e0 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -9,7 +9,7 @@
  * most "normal" filesystems (but you don't /have/ to use this:
  * the NFS filesystem used to do this differently, for example)
  */
-#include <linux/module.h>
+#include <linux/export.h>
 #include <linux/compiler.h>
 #include <linux/fs.h>
 #include <linux/uaccess.h>
@@ -33,7 +33,6 @@
 #include <linux/cpuset.h>
 #include <linux/hardirq.h> /* for BUG_ON(!in_atomic()) only */
 #include <linux/memcontrol.h>
-#include <linux/mm_inline.h> /* for page_is_file_cache() */
 #include <linux/cleancache.h>
 #include "internal.h"
 
@@ -78,7 +77,7 @@
  *  ->i_mutex                   (generic_file_buffered_write)
  *    ->mmap_sem                (fault_in_pages_readable->do_page_fault)
  *
- *  inode_wb_list_lock
+ *  bdi->wb.list_lock
  *    sb_lock                   (fs/fs-writeback.c)
  *    ->mapping->tree_lock      (__sync_single_inode)
  *
@@ -96,9 +95,9 @@
  *    ->zone.lru_lock           (check_pte_range->isolate_lru_page)
  *    ->private_lock            (page_remove_rmap->set_page_dirty)
  *    ->tree_lock               (page_remove_rmap->set_page_dirty)
- *    inode_wb_list_lock        (page_remove_rmap->set_page_dirty)
+ *    bdi.wb->list_lock         (page_remove_rmap->set_page_dirty)
  *    ->inode->i_lock           (page_remove_rmap->set_page_dirty)
- *    inode_wb_list_lock        (zap_pte_range->set_page_dirty)
+ *    bdi.wb->list_lock         (zap_pte_range->set_page_dirty)
  *    ->inode->i_lock           (zap_pte_range->set_page_dirty)
  *    ->private_lock            (zap_pte_range->__set_page_dirty_buffers)
  *
@@ -128,6 +127,7 @@ void __delete_from_page_cache(struct page *page)
 
         radix_tree_delete(&mapping->page_tree, page->index);
         page->mapping = NULL;
+        /* Leave page->index set: truncation lookup relies upon it */
         mapping->nrpages--;
         __dec_zone_page_state(page, NR_FILE_PAGES);
         if (PageSwapBacked(page))
@@ -461,6 +461,7 @@ int add_to_page_cache_locked(struct page *page, struct address_space *mapping,
         int error;
 
         VM_BUG_ON(!PageLocked(page));
+        VM_BUG_ON(PageSwapBacked(page));
 
         error = mem_cgroup_cache_charge(page, current->mm,
                                         gfp_mask & GFP_RECLAIM_MASK);
@@ -478,11 +479,10 @@ int add_to_page_cache_locked(struct page *page, struct address_space *mapping,
                 if (likely(!error)) {
                         mapping->nrpages++;
                         __inc_zone_page_state(page, NR_FILE_PAGES);
-                        if (PageSwapBacked(page))
-                                __inc_zone_page_state(page, NR_SHMEM);
                         spin_unlock_irq(&mapping->tree_lock);
                 } else {
                         page->mapping = NULL;
+                        /* Leave page->index set: truncation relies upon it */
                         spin_unlock_irq(&mapping->tree_lock);
                         mem_cgroup_uncharge_cache_page(page);
                         page_cache_release(page);
@@ -500,22 +500,9 @@ int add_to_page_cache_lru(struct page *page, struct address_space *mapping,
 {
         int ret;
 
-        /*
-         * Splice_read and readahead add shmem/tmpfs pages into the page cache
-         * before shmem_readpage has a chance to mark them as SwapBacked: they
-         * need to go on the anon lru below, and mem_cgroup_cache_charge
-         * (called in add_to_page_cache) needs to know where they're going too.
-         */
-        if (mapping_cap_swap_backed(mapping))
-                SetPageSwapBacked(page);
-
         ret = add_to_page_cache(page, mapping, offset, gfp_mask);
-        if (ret == 0) {
-                if (page_is_file_cache(page))
-                        lru_cache_add_file(page);
-                else
-                        lru_cache_add_anon(page);
-        }
+        if (ret == 0)
+                lru_cache_add_file(page);
         return ret;
 }
 EXPORT_SYMBOL_GPL(add_to_page_cache_lru);
@@ -712,9 +699,16 @@ repeat:
                 page = radix_tree_deref_slot(pagep);
                 if (unlikely(!page))
                         goto out;
-                if (radix_tree_deref_retry(page))
-                        goto repeat;
-
+                if (radix_tree_exception(page)) {
+                        if (radix_tree_deref_retry(page))
+                                goto repeat;
+                        /*
+                         * Otherwise, shmem/tmpfs must be storing a swap entry
+                         * here as an exceptional entry: so return it without
+                         * attempting to raise page count.
+                         */
+                        goto out;
+                }
                 if (!page_cache_get_speculative(page))
                         goto repeat;
 
@@ -751,7 +745,7 @@ struct page *find_lock_page(struct address_space *mapping, pgoff_t offset)
 
 repeat:
         page = find_get_page(mapping, offset);
-        if (page) {
+        if (page && !radix_tree_exception(page)) {
                 lock_page(page);
                 /* Has the page been truncated? */
                 if (unlikely(page->mapping != mapping)) {
@@ -833,13 +827,14 @@ unsigned find_get_pages(struct address_space *mapping, pgoff_t start,
 {
         unsigned int i;
         unsigned int ret;
-        unsigned int nr_found;
+        unsigned int nr_found, nr_skip;
 
         rcu_read_lock();
 restart:
         nr_found = radix_tree_gang_lookup_slot(&mapping->page_tree,
-                                (void ***)pages, start, nr_pages);
+                                (void ***)pages, NULL, start, nr_pages);
         ret = 0;
+        nr_skip = 0;
         for (i = 0; i < nr_found; i++) {
                 struct page *page;
 repeat:
@@ -847,13 +842,23 @@ repeat:
                 if (unlikely(!page))
                         continue;
 
-                /*
-                 * This can only trigger when the entry at index 0 moves out
-                 * of or back to the root: none yet gotten, safe to restart.
-                 */
-                if (radix_tree_deref_retry(page)) {
-                        WARN_ON(start | i);
-                        goto restart;
+                if (radix_tree_exception(page)) {
+                        if (radix_tree_deref_retry(page)) {
+                                /*
+                                 * Transient condition which can only trigger
+                                 * when entry at index 0 moves out of or back
+                                 * to root: none yet gotten, safe to restart.
+                                 */
+                                WARN_ON(start | i);
+                                goto restart;
+                        }
+                        /*
+                         * Otherwise, shmem/tmpfs must be storing a swap entry
+                         * here as an exceptional entry: so skip over it -
+                         * we only reach this from invalidate_mapping_pages().
+                         */
+                        nr_skip++;
+                        continue;
                 }
 
                 if (!page_cache_get_speculative(page))
@@ -873,7 +878,7 @@ repeat:
          * If all entries were removed before we could secure them,
          * try again, because callers stop trying once 0 is returned.
          */
-        if (unlikely(!ret && nr_found))
+        if (unlikely(!ret && nr_found > nr_skip))
                 goto restart;
         rcu_read_unlock();
         return ret;
@@ -901,7 +906,7 @@ unsigned find_get_pages_contig(struct address_space *mapping, pgoff_t index,
         rcu_read_lock();
 restart:
         nr_found = radix_tree_gang_lookup_slot(&mapping->page_tree,
-                                (void ***)pages, index, nr_pages);
+                                (void ***)pages, NULL, index, nr_pages);
         ret = 0;
         for (i = 0; i < nr_found; i++) {
                 struct page *page;
@@ -910,12 +915,22 @@ repeat:
                 if (unlikely(!page))
                         continue;
 
-                /*
-                 * This can only trigger when the entry at index 0 moves out
-                 * of or back to the root: none yet gotten, safe to restart.
-                 */
-                if (radix_tree_deref_retry(page))
-                        goto restart;
+                if (radix_tree_exception(page)) {
+                        if (radix_tree_deref_retry(page)) {
+                                /*
+                                 * Transient condition which can only trigger
+                                 * when entry at index 0 moves out of or back
+                                 * to root: none yet gotten, safe to restart.
+                                 */
+                                goto restart;
+                        }
+                        /*
+                         * Otherwise, shmem/tmpfs must be storing a swap entry
+                         * here as an exceptional entry: so stop looking for
+                         * contiguous pages.
+                         */
+                        break;
+                }
 
                 if (!page_cache_get_speculative(page))
                         goto repeat;
@@ -975,12 +990,21 @@ repeat:
                 if (unlikely(!page))
                         continue;
 
-                /*
-                 * This can only trigger when the entry at index 0 moves out
-                 * of or back to the root: none yet gotten, safe to restart.
-                 */
-                if (radix_tree_deref_retry(page))
-                        goto restart;
+                if (radix_tree_exception(page)) {
+                        if (radix_tree_deref_retry(page)) {
+                                /*
+                                 * Transient condition which can only trigger
+                                 * when entry at index 0 moves out of or back
+                                 * to root: none yet gotten, safe to restart.
+                                 */
+                                goto restart;
+                        }
+                        /*
+                         * This function is never used on a shmem/tmpfs
+                         * mapping, so a swap entry won't be found here.
+                         */
+                        BUG();
+                }
 
                 if (!page_cache_get_speculative(page))
                         goto repeat;
@@ -1792,7 +1816,7 @@ EXPORT_SYMBOL(generic_file_readonly_mmap);
 
 static struct page *__read_cache_page(struct address_space *mapping,
                                 pgoff_t index,
-                                int (*filler)(void *,struct page*),
+                                int (*filler)(void *, struct page *),
                                 void *data,
                                 gfp_t gfp)
 {
@@ -1823,7 +1847,7 @@ repeat:
 
 static struct page *do_read_cache_page(struct address_space *mapping,
                                 pgoff_t index,
-                                int (*filler)(void *,struct page*),
+                                int (*filler)(void *, struct page *),
                                 void *data,
                                 gfp_t gfp)
 
@@ -1863,7 +1887,7 @@ out:
  * @mapping:    the page's address_space
  * @index:      the page index
  * @filler:     function to perform the read
- * @data:       destination for read data
+ * @data:       first arg to filler(data, page) function, often left as NULL
  *
  * Same as read_cache_page, but don't wait for page to become unlocked
  * after submitting it to the filler.
@@ -1875,7 +1899,7 @@ out:
  */
 struct page *read_cache_page_async(struct address_space *mapping,
                                 pgoff_t index,
-                                int (*filler)(void *,struct page*),
+                                int (*filler)(void *, struct page *),
                                 void *data)
 {
         return do_read_cache_page(mapping, index, filler, data, mapping_gfp_mask(mapping));
@@ -1923,7 +1947,7 @@ EXPORT_SYMBOL(read_cache_page_gfp);
  * @mapping:    the page's address_space
  * @index:      the page index
  * @filler:     function to perform the read
- * @data:       destination for read data
+ * @data:       first arg to filler(data, page) function, often left as NULL
  *
  * Read into the page cache. If a page already exists, and PageUptodate() is
  * not set, try to fill the page then wait for it to become unlocked.
@@ -1932,7 +1956,7 @@ EXPORT_SYMBOL(read_cache_page_gfp);
  */
 struct page *read_cache_page(struct address_space *mapping,
                                 pgoff_t index,
-                                int (*filler)(void *,struct page*),
+                                int (*filler)(void *, struct page *),
                                 void *data)
 {
         return wait_on_page_read(read_cache_page_async(mapping, index, filler, data));
@@ -2091,6 +2115,7 @@ void iov_iter_advance(struct iov_iter *i, size_t bytes)
         } else {
                 const struct iovec *iov = i->iov;
                 size_t base = i->iov_offset;
+                unsigned long nr_segs = i->nr_segs;
 
                 /*
                  * The !iov->iov_len check ensures we skip over unlikely
@@ -2106,11 +2131,13 @@ void iov_iter_advance(struct iov_iter *i, size_t bytes)
                         base += copy;
                         if (iov->iov_len == base) {
                                 iov++;
+                                nr_segs--;
                                 base = 0;
                         }
                 }
                 i->iov = iov;
                 i->iov_offset = base;
+                i->nr_segs = nr_segs;
         }
 }
 EXPORT_SYMBOL(iov_iter_advance);