Merge drm/drm-next into drm-intel-next-queued

[linux-2.6-block.git] / mm / vmscan.c

diff --git a/mm/vmscan.c b/mm/vmscan.c
index 0dbc493026a27d4f59b7ca6d83a4c864340f99a1..24ab1f7394abaafa9e0dccac37597ae65ef77e0f 100644 (file)
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -50,6 +50,7 @@
 #include <linux/prefetch.h>
 #include <linux/printk.h>
 #include <linux/dax.h>
+#include <linux/psi.h>
 
 #include <asm/tlbflush.h>
 #include <asm/div64.h>
@@ -474,9 +475,18 @@ static unsigned long do_shrink_slab(struct shrink_control *shrinkctl,
        nr = atomic_long_xchg(&shrinker->nr_deferred[nid], 0);
 
        total_scan = nr;
-       delta = freeable >> priority;
-       delta *= 4;
-       do_div(delta, shrinker->seeks);
+       if (shrinker->seeks) {
+               delta = freeable >> priority;
+               delta *= 4;
+               do_div(delta, shrinker->seeks);
+       } else {
+               /*
+                * These objects don't require any IO to create. Trim
+                * them aggressively under memory pressure to keep
+                * them from causing refetches in the IO caches.
+                */
+               delta = freeable / 2;
+       }
 
        /*
         * Make sure we apply some minimal pressure on default priority
@@ -581,8 +591,8 @@ static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
                        struct mem_cgroup *memcg, int priority)
 {
        struct memcg_shrinker_map *map;
-       unsigned long freed = 0;
-       int ret, i;
+       unsigned long ret, freed = 0;
+       int i;
 
        if (!memcg_kmem_enabled() || !mem_cgroup_online(memcg))
                return 0;
@@ -678,9 +688,8 @@ static unsigned long shrink_slab(gfp_t gfp_mask, int nid,
                                 struct mem_cgroup *memcg,
                                 int priority)
 {
+       unsigned long ret, freed = 0;
        struct shrinker *shrinker;
-       unsigned long freed = 0;
-       int ret;
 
        if (!mem_cgroup_is_root(memcg))
                return shrink_slab_memcg(gfp_mask, nid, memcg, priority);
@@ -743,12 +752,12 @@ static inline int is_page_cache_freeable(struct page *page)
 {
        /*
         * A freeable page cache page is referenced only by the caller
-        * that isolated the page, the page cache radix tree and
-        * optional buffer heads at page->private.
+        * that isolated the page, the page cache and optional buffer
+        * heads at page->private.
         */
-       int radix_pins = PageTransHuge(page) && PageSwapCache(page) ?
+       int page_cache_pins = PageTransHuge(page) && PageSwapCache(page) ?
                HPAGE_PMD_NR : 1;
-       return page_count(page) - page_has_private(page) == 1 + radix_pins;
+       return page_count(page) - page_has_private(page) == 1 + page_cache_pins;
 }
 
 static int may_write_to_inode(struct inode *inode, struct scan_control *sc)
@@ -924,7 +933,7 @@ static int __remove_mapping(struct address_space *mapping, struct page *page,
        if (PageSwapCache(page)) {
                swp_entry_t swap = { .val = page_private(page) };
                mem_cgroup_swapout(page, swap);
-               __delete_from_swap_cache(page);
+               __delete_from_swap_cache(page, swap);
                xa_unlock_irqrestore(&mapping->i_pages, flags);
                put_swap_page(page, swap);
        } else {
@@ -2147,6 +2156,7 @@ static void shrink_active_list(unsigned long nr_to_scan,
                }
 
                ClearPageActive(page);  /* we are de-activating */
+               SetPageWorkingset(page);
                list_add(&page->lru, &l_inactive);
        }
 
@@ -2458,9 +2468,11 @@ out:
                        /*
                         * Scan types proportional to swappiness and
                         * their relative recent reclaim efficiency.
+                        * Make sure we don't miss the last page
+                        * because of a round-off error.
                         */
-                       scan = div64_u64(scan * fraction[file],
-                                        denominator);
+                       scan = DIV64_U64_ROUND_UP(scan * fraction[file],
+                                                 denominator);
                        break;
                case SCAN_FILE:
                case SCAN_ANON:
@@ -3304,6 +3316,7 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
 {
        struct zonelist *zonelist;
        unsigned long nr_reclaimed;
+       unsigned long pflags;
        int nid;
        unsigned int noreclaim_flag;
        struct scan_control sc = {
@@ -3332,9 +3345,13 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
                                            sc.gfp_mask,
                                            sc.reclaim_idx);
 
+       psi_memstall_enter(&pflags);
        noreclaim_flag = memalloc_noreclaim_save();
+
        nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
+
        memalloc_noreclaim_restore(noreclaim_flag);
+       psi_memstall_leave(&pflags);
 
        trace_mm_vmscan_memcg_reclaim_end(nr_reclaimed);
 
@@ -3499,6 +3516,7 @@ static int balance_pgdat(pg_data_t *pgdat, int order, int classzone_idx)
        int i;
        unsigned long nr_soft_reclaimed;
        unsigned long nr_soft_scanned;
+       unsigned long pflags;
        struct zone *zone;
        struct scan_control sc = {
                .gfp_mask = GFP_KERNEL,
@@ -3509,6 +3527,7 @@ static int balance_pgdat(pg_data_t *pgdat, int order, int classzone_idx)
                .may_swap = 1,
        };
 
+       psi_memstall_enter(&pflags);
        __fs_reclaim_acquire();
 
        count_vm_event(PAGEOUTRUN);
@@ -3610,6 +3629,7 @@ static int balance_pgdat(pg_data_t *pgdat, int order, int classzone_idx)
 out:
        snapshot_refaults(NULL, pgdat);
        __fs_reclaim_release();
+       psi_memstall_leave(&pflags);
        /*
         * Return the order kswapd stopped reclaiming at as
         * prepare_kswapd_sleep() takes it into account. If another caller