1 files changed, 13 insertions, 58 deletions

diff --git a/mm/filemap.c b/mm/filemap.c
index db26ebc6c62f..69568388c699 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -132,43 +132,28 @@ static int page_cache_tree_insert(struct address_space *mapping,
                 if (!dax_mapping(mapping)) {
                         if (shadowp)
                                 *shadowp = p;
-                        if (node)
-                                workingset_node_shadows_dec(node);
                 } else {
                         /* DAX can replace empty locked entry with a hole */
                         WARN_ON_ONCE(p !=
                                 dax_radix_locked_entry(0, RADIX_DAX_EMPTY));
-                        /* DAX accounts exceptional entries as normal pages */
-                        if (node)
-                                workingset_node_pages_dec(node);
                         /* Wakeup waiters for exceptional entry lock */
                         dax_wake_mapping_entry_waiter(mapping, page->index, p,
                                                       false);
                 }
         }
-        radix_tree_replace_slot(slot, page);
+        __radix_tree_replace(&mapping->page_tree, node, slot, page,
+                             workingset_update_node, mapping);
         mapping->nrpages++;
-        if (node) {
-                workingset_node_pages_inc(node);
-                /*
-                 * Don't track node that contains actual pages.
-                 *
-                 * Avoid acquiring the list_lru lock if already
-                 * untracked.  The list_empty() test is safe as
-                 * node->private_list is protected by
-                 * mapping->tree_lock.
-                 */
-                if (!list_empty(&node->private_list))
-                        list_lru_del(&workingset_shadow_nodes,
-                                     &node->private_list);
-        }
         return 0;
 }
 
 static void page_cache_tree_delete(struct address_space *mapping,
                                    struct page *page, void *shadow)
 {
-        int i, nr = PageHuge(page) ? 1 : hpage_nr_pages(page);
+        int i, nr;
+
+        /* hugetlb pages are represented by one entry in the radix tree */
+        nr = PageHuge(page) ? 1 : hpage_nr_pages(page);
 
         VM_BUG_ON_PAGE(!PageLocked(page), page);
         VM_BUG_ON_PAGE(PageTail(page), page);
@@ -181,44 +166,11 @@ static void page_cache_tree_delete(struct address_space *mapping,
                 __radix_tree_lookup(&mapping->page_tree, page->index + i,
                                     &node, &slot);
 
-                radix_tree_clear_tags(&mapping->page_tree, node, slot);
-
-                if (!node) {
-                        VM_BUG_ON_PAGE(nr != 1, page);
-                        /*
-                         * We need a node to properly account shadow
-                         * entries. Don't plant any without. XXX
-                         */
-                        shadow = NULL;
-                }
-
-                radix_tree_replace_slot(slot, shadow);
+                VM_BUG_ON_PAGE(!node && nr != 1, page);
 
-                if (!node)
-                        break;
-
-                workingset_node_pages_dec(node);
-                if (shadow)
-                        workingset_node_shadows_inc(node);
-                else
-                        if (__radix_tree_delete_node(&mapping->page_tree, node))
-                                continue;
-
-                /*
-                 * Track node that only contains shadow entries. DAX mappings
-                 * contain no shadow entries and may contain other exceptional
-                 * entries so skip those.
-                 *
-                 * Avoid acquiring the list_lru lock if already tracked.
-                 * The list_empty() test is safe as node->private_list is
-                 * protected by mapping->tree_lock.
-                 */
-                if (!dax_mapping(mapping) && !workingset_node_pages(node) &&
-                                list_empty(&node->private_list)) {
-                        node->private_data = mapping;
-                        list_lru_add(&workingset_shadow_nodes,
-                                        &node->private_list);
-                }
+                radix_tree_clear_tags(&mapping->page_tree, node, slot);
+                __radix_tree_replace(&mapping->page_tree, node, slot, shadow,
+                                     workingset_update_node, mapping);
         }
 
         if (shadow) {
@@ -1731,6 +1683,9 @@ find_page:
                         if (inode->i_blkbits == PAGE_SHIFT ||
                                         !mapping->a_ops->is_partially_uptodate)
                                 goto page_not_up_to_date;
+                        /* pipes can't handle partially uptodate pages */
+                        if (unlikely(iter->type & ITER_PIPE))
+                                goto page_not_up_to_date;
                         if (!trylock_page(page))
                                 goto page_not_up_to_date;
                         /* Did it get truncated before we got the lock? */