Merge branch 'akpm' (patches from Andrew)

Merge more updates from Andrew Morton:
 "VM:
   - z3fold fixes and enhancements by Henry Burns and Vitaly Wool

   - more accurate reclaimed slab caches calculations by Yafang Shao

   - fix MAP_UNINITIALIZED UAPI symbol to not depend on config, by
     Christoph Hellwig

   - !CONFIG_MMU fixes by Christoph Hellwig

   - new novmcoredd parameter to omit device dumps from vmcore, by
     Kairui Song

   - new test_meminit module for testing heap and pagealloc
     initialization, by Alexander Potapenko

   - ioremap improvements for huge mappings, by Anshuman Khandual

   - generalize kprobe page fault handling, by Anshuman Khandual

   - device-dax hotplug fixes and improvements, by Pavel Tatashin

   - enable synchronous DAX fault on powerpc, by Aneesh Kumar K.V

   - add pte_devmap() support for arm64, by Robin Murphy

   - unify locked_vm accounting with a helper, by Daniel Jordan

   - several misc fixes

  core/lib:
   - new typeof_member() macro including some users, by Alexey Dobriyan

   - make BIT() and GENMASK() available in asm, by Masahiro Yamada

   - changed LIST_POISON2 on x86_64 to 0xdead000000000122 for better
     code generation, by Alexey Dobriyan

   - rbtree code size optimizations, by Michel Lespinasse

   - convert struct pid count to refcount_t, by Joel Fernandes

  get_maintainer.pl:
   - add --no-moderated switch to skip moderated ML's, by Joe Perches

  misc:
   - ptrace PTRACE_GET_SYSCALL_INFO interface

   - coda updates

   - gdb scripts, various"

[ Using merge message suggestion from Vlastimil Babka, with some editing - Linus ]

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (100 commits)
  fs/select.c: use struct_size() in kmalloc()
  mm: add account_locked_vm utility function
  arm64: mm: implement pte_devmap support
  mm: introduce ARCH_HAS_PTE_DEVMAP
  mm: clean up is_device_*_page() definitions
  mm/mmap: move common defines to mman-common.h
  mm: move MAP_SYNC to asm-generic/mman-common.h
  device-dax: "Hotremove" persistent memory that is used like normal RAM
  mm/hotplug: make remove_memory() interface usable
  device-dax: fix memory and resource leak if hotplug fails
  include/linux/lz4.h: fix spelling and copy-paste errors in documentation
  ipc/mqueue.c: only perform resource calculation if user valid
  include/asm-generic/bug.h: fix "cut here" for WARN_ON for __WARN_TAINT architectures
  scripts/gdb: add helpers to find and list devices
  scripts/gdb: add lx-genpd-summary command
  drivers/pps/pps.c: clear offset flags in PPS_SETPARAMS ioctl
  kernel/pid.c: convert struct pid count to refcount_t
  drivers/rapidio/devices/rio_mport_cdev.c: NUL terminate some strings
  select: shift restore_saved_sigmask_unless() into poll_select_copy_remaining()
  select: change do_poll() to return -ERESTARTNOHAND rather than -EINTR
  ...

1 files changed, 29 insertions, 15 deletions

diff --git a/mm/vmscan.c b/mm/vmscan.c
index f8e3dcd527b8..44df66a98f2a 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -131,6 +131,9 @@ struct scan_control {
                 unsigned int file_taken;
                 unsigned int taken;
         } nr;
+
+        /* for recording the reclaimed slab by now */
+        struct reclaim_state reclaim_state;
 };
 
 #ifdef ARCH_HAS_PREFETCH
@@ -238,6 +241,18 @@ static void unregister_memcg_shrinker(struct shrinker *shrinker)
 }
 #endif /* CONFIG_MEMCG_KMEM */
 
+static void set_task_reclaim_state(struct task_struct *task,
+                                   struct reclaim_state *rs)
+{
+        /* Check for an overwrite */
+        WARN_ON_ONCE(rs && task->reclaim_state);
+
+        /* Check for the nulling of an already-nulled member */
+        WARN_ON_ONCE(!rs && !task->reclaim_state);
+
+        task->reclaim_state = rs;
+}
+
 #ifdef CONFIG_MEMCG
 static bool global_reclaim(struct scan_control *sc)
 {
@@ -3191,11 +3206,13 @@ unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
         if (throttle_direct_reclaim(sc.gfp_mask, zonelist, nodemask))
                 return 1;
 
+        set_task_reclaim_state(current, &sc.reclaim_state);
         trace_mm_vmscan_direct_reclaim_begin(order, sc.gfp_mask);
 
         nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
 
         trace_mm_vmscan_direct_reclaim_end(nr_reclaimed);
+        set_task_reclaim_state(current, NULL);
 
         return nr_reclaimed;
 }
@@ -3218,6 +3235,7 @@ unsigned long mem_cgroup_shrink_node(struct mem_cgroup *memcg,
         };
         unsigned long lru_pages;
 
+        set_task_reclaim_state(current, &sc.reclaim_state);
         sc.gfp_mask = (gfp_mask & GFP_RECLAIM_MASK) |
                         (GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK);
 
@@ -3235,7 +3253,9 @@ unsigned long mem_cgroup_shrink_node(struct mem_cgroup *memcg,
 
         trace_mm_vmscan_memcg_softlimit_reclaim_end(sc.nr_reclaimed);
 
+        set_task_reclaim_state(current, NULL);
         *nr_scanned = sc.nr_scanned;
+
         return sc.nr_reclaimed;
 }
 
@@ -3262,6 +3282,7 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
                 .may_shrinkslab = 1,
         };
 
+        set_task_reclaim_state(current, &sc.reclaim_state);
         /*
          * Unlike direct reclaim via alloc_pages(), memcg's reclaim doesn't
          * take care of from where we get pages. So the node where we start the
@@ -3282,6 +3303,7 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
         psi_memstall_leave(&pflags);
 
         trace_mm_vmscan_memcg_reclaim_end(nr_reclaimed);
+        set_task_reclaim_state(current, NULL);
 
         return nr_reclaimed;
 }
@@ -3483,6 +3505,7 @@ static int balance_pgdat(pg_data_t *pgdat, int order, int classzone_idx)
                 .may_unmap = 1,
         };
 
+        set_task_reclaim_state(current, &sc.reclaim_state);
         psi_memstall_enter(&pflags);
         __fs_reclaim_acquire();
 
@@ -3664,6 +3687,8 @@ out:
         snapshot_refaults(NULL, pgdat);
         __fs_reclaim_release();
         psi_memstall_leave(&pflags);
+        set_task_reclaim_state(current, NULL);
+
         /*
          * Return the order kswapd stopped reclaiming at as
          * prepare_kswapd_sleep() takes it into account. If another caller
@@ -3787,15 +3812,10 @@ static int kswapd(void *p)
         unsigned int classzone_idx = MAX_NR_ZONES - 1;
         pg_data_t *pgdat = (pg_data_t*)p;
         struct task_struct *tsk = current;
-
-        struct reclaim_state reclaim_state = {
-                .reclaimed_slab = 0,
-        };
         const struct cpumask *cpumask = cpumask_of_node(pgdat->node_id);
 
         if (!cpumask_empty(cpumask))
                 set_cpus_allowed_ptr(tsk, cpumask);
-        current->reclaim_state = &reclaim_state;
 
         /*
          * Tell the memory management that we're a "memory allocator",
@@ -3857,7 +3877,6 @@ kswapd_try_sleep:
         }
 
         tsk->flags &= ~(PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD);
-        current->reclaim_state = NULL;
 
         return 0;
 }
@@ -3922,7 +3941,6 @@ void wakeup_kswapd(struct zone *zone, gfp_t gfp_flags, int order,
  */
 unsigned long shrink_all_memory(unsigned long nr_to_reclaim)
 {
-        struct reclaim_state reclaim_state;
         struct scan_control sc = {
                 .nr_to_reclaim = nr_to_reclaim,
                 .gfp_mask = GFP_HIGHUSER_MOVABLE,
@@ -3934,18 +3952,16 @@ unsigned long shrink_all_memory(unsigned long nr_to_reclaim)
                 .hibernation_mode = 1,
         };
         struct zonelist *zonelist = node_zonelist(numa_node_id(), sc.gfp_mask);
-        struct task_struct *p = current;
         unsigned long nr_reclaimed;
         unsigned int noreclaim_flag;
 
         fs_reclaim_acquire(sc.gfp_mask);
         noreclaim_flag = memalloc_noreclaim_save();
-        reclaim_state.reclaimed_slab = 0;
-        p->reclaim_state = &reclaim_state;
+        set_task_reclaim_state(current, &sc.reclaim_state);
 
         nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
 
-        p->reclaim_state = NULL;
+        set_task_reclaim_state(current, NULL);
         memalloc_noreclaim_restore(noreclaim_flag);
         fs_reclaim_release(sc.gfp_mask);
 
@@ -4110,7 +4126,6 @@ static int __node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned in
         /* Minimum pages needed in order to stay on node */
         const unsigned long nr_pages = 1 << order;
         struct task_struct *p = current;
-        struct reclaim_state reclaim_state;
         unsigned int noreclaim_flag;
         struct scan_control sc = {
                 .nr_to_reclaim = max(nr_pages, SWAP_CLUSTER_MAX),
@@ -4135,8 +4150,7 @@ static int __node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned in
          */
         noreclaim_flag = memalloc_noreclaim_save();
         p->flags |= PF_SWAPWRITE;
-        reclaim_state.reclaimed_slab = 0;
-        p->reclaim_state = &reclaim_state;
+        set_task_reclaim_state(p, &sc.reclaim_state);
 
         if (node_pagecache_reclaimable(pgdat) > pgdat->min_unmapped_pages) {
                 /*
@@ -4148,7 +4162,7 @@ static int __node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned in
                 } while (sc.nr_reclaimed < nr_pages && --sc.priority >= 0);
         }
 
-        p->reclaim_state = NULL;
+        set_task_reclaim_state(p, NULL);
         current->flags &= ~PF_SWAPWRITE;
         memalloc_noreclaim_restore(noreclaim_flag);
         fs_reclaim_release(sc.gfp_mask);