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

Pull in v4.20-rc3 via drm-next.

Signed-off-by: Jani Nikula <jani.nikula@intel.com>

1 files changed, 34 insertions, 14 deletions

diff --git a/mm/vmscan.c b/mm/vmscan.c
index 0dbc493026a2..24ab1f7394ab 100644
--- 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