Merge branch 'akpm' (patches from Andrew)

Merge updates from Andrew Morton:

 - various misc bits

 - DAX updates

 - OCFS2

 - most of MM

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (119 commits)
  mm,fork: introduce MADV_WIPEONFORK
  x86,mpx: make mpx depend on x86-64 to free up VMA flag
  mm: add /proc/pid/smaps_rollup
  mm: hugetlb: clear target sub-page last when clearing huge page
  mm: oom: let oom_reap_task and exit_mmap run concurrently
  swap: choose swap device according to numa node
  mm: replace TIF_MEMDIE checks by tsk_is_oom_victim
  mm, oom: do not rely on TIF_MEMDIE for memory reserves access
  z3fold: use per-cpu unbuddied lists
  mm, swap: don't use VMA based swap readahead if HDD is used as swap
  mm, swap: add sysfs interface for VMA based swap readahead
  mm, swap: VMA based swap readahead
  mm, swap: fix swap readahead marking
  mm, swap: add swap readahead hit statistics
  mm/vmalloc.c: don't reinvent the wheel but use existing llist API
  mm/vmstat.c: fix wrong comment
  selftests/memfd: add memfd_create hugetlbfs selftest
  mm/shmem: add hugetlbfs support to memfd_create()
  mm, devm_memremap_pages: use multi-order radix for ZONE_DEVICE lookups
  mm/vmalloc.c: halve the number of comparisons performed in pcpu_get_vm_areas()
  ...

1 files changed, 39 insertions, 28 deletions

diff --git a/mm/filemap.c b/mm/filemap.c
index 1e01cb6e5173..9d21afd692b9 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -130,17 +130,8 @@ static int page_cache_tree_insert(struct address_space *mapping,
                         return -EEXIST;
 
                 mapping->nrexceptional--;
-                if (!dax_mapping(mapping)) {
-                        if (shadowp)
-                                *shadowp = p;
-                } else {
-                        /* DAX can replace empty locked entry with a hole */
-                        WARN_ON_ONCE(p !=
-                                dax_radix_locked_entry(0, RADIX_DAX_EMPTY));
-                        /* Wakeup waiters for exceptional entry lock */
-                        dax_wake_mapping_entry_waiter(mapping, page->index, p,
-                                                      true);
-                }
+                if (shadowp)
+                        *shadowp = p;
         }
         __radix_tree_replace(&mapping->page_tree, node, slot, page,
                              workingset_update_node, mapping);
@@ -402,8 +393,7 @@ bool filemap_range_has_page(struct address_space *mapping,
 {
         pgoff_t index = start_byte >> PAGE_SHIFT;
         pgoff_t end = end_byte >> PAGE_SHIFT;
-        struct pagevec pvec;
-        bool ret;
+        struct page *page;
 
         if (end_byte < start_byte)
                 return false;
@@ -411,12 +401,10 @@ bool filemap_range_has_page(struct address_space *mapping,
         if (mapping->nrpages == 0)
                 return false;
 
-        pagevec_init(&pvec, 0);
-        if (!pagevec_lookup(&pvec, mapping, index, 1))
+        if (!find_get_pages_range(mapping, &index, end, 1, &page))
                 return false;
-        ret = (pvec.pages[0]->index <= end);
-        pagevec_release(&pvec);
-        return ret;
+        put_page(page);
+        return true;
 }
 EXPORT_SYMBOL(filemap_range_has_page);
 
@@ -1564,23 +1552,29 @@ export:
 }
 
 /**
- * find_get_pages - gang pagecache lookup
+ * find_get_pages_range - gang pagecache lookup
  * @mapping:    The address_space to search
  * @start:      The starting page index
+ * @end:        The final page index (inclusive)
  * @nr_pages:   The maximum number of pages
  * @pages:      Where the resulting pages are placed
  *
- * find_get_pages() will search for and return a group of up to
- * @nr_pages pages in the mapping.  The pages are placed at @pages.
- * find_get_pages() takes a reference against the returned pages.
+ * find_get_pages_range() will search for and return a group of up to @nr_pages
+ * pages in the mapping starting at index @start and up to index @end
+ * (inclusive).  The pages are placed at @pages.  find_get_pages_range() takes
+ * a reference against the returned pages.
  *
  * The search returns a group of mapping-contiguous pages with ascending
  * indexes.  There may be holes in the indices due to not-present pages.
+ * We also update @start to index the next page for the traversal.
  *
- * find_get_pages() returns the number of pages which were found.
+ * find_get_pages_range() returns the number of pages which were found. If this
+ * number is smaller than @nr_pages, the end of specified range has been
+ * reached.
  */
-unsigned find_get_pages(struct address_space *mapping, pgoff_t start,
-                            unsigned int nr_pages, struct page **pages)
+unsigned find_get_pages_range(struct address_space *mapping, pgoff_t *start,
+                              pgoff_t end, unsigned int nr_pages,
+                              struct page **pages)
 {
         struct radix_tree_iter iter;
         void **slot;
@@ -1590,8 +1584,11 @@ unsigned find_get_pages(struct address_space *mapping, pgoff_t start,
                 return 0;
 
         rcu_read_lock();
-        radix_tree_for_each_slot(slot, &mapping->page_tree, &iter, start) {
+        radix_tree_for_each_slot(slot, &mapping->page_tree, &iter, *start) {
                 struct page *head, *page;
+
+                if (iter.index > end)
+                        break;
 repeat:
                 page = radix_tree_deref_slot(slot);
                 if (unlikely(!page))
@@ -1627,11 +1624,25 @@ repeat:
                 }
 
                 pages[ret] = page;
-                if (++ret == nr_pages)
-                        break;
+                if (++ret == nr_pages) {
+                        *start = pages[ret - 1]->index + 1;
+                        goto out;
+                }
         }
 
+        /*
+         * We come here when there is no page beyond @end. We take care to not
+         * overflow the index @start as it confuses some of the callers. This
+         * breaks the iteration when there is page at index -1 but that is
+         * already broken anyway.
+         */
+        if (end == (pgoff_t)-1)
+                *start = (pgoff_t)-1;
+        else
+                *start = end + 1;
+out:
         rcu_read_unlock();
+
         return ret;
 }