43 files changed, 239 insertions, 66 deletions

diff --git a/mm/Kconfig.debug b/mm/Kconfig.debug
index afcc550877ff..79d0fd13b5b3 100644
--- a/mm/Kconfig.debug
+++ b/mm/Kconfig.debug
@@ -90,3 +90,9 @@ config DEBUG_PAGE_REF
           careful when enabling this feature because it adds about 30 KB to the
           kernel code.  However the runtime performance overhead is virtually
           nil until the tracepoints are actually enabled.
+
+config DEBUG_RODATA_TEST
+    bool "Testcase for the marking rodata read-only"
+    depends on STRICT_KERNEL_RWX
+    ---help---
+      This option enables a testcase for the setting rodata read-only.
diff --git a/mm/Makefile b/mm/Makefile
index aa0aa17cb413..026f6a828a50 100644
--- a/mm/Makefile
+++ b/mm/Makefile
@@ -85,6 +85,7 @@ obj-$(CONFIG_MEMORY_FAILURE) += memory-failure.o
 obj-$(CONFIG_HWPOISON_INJECT) += hwpoison-inject.o
 obj-$(CONFIG_DEBUG_KMEMLEAK) += kmemleak.o
 obj-$(CONFIG_DEBUG_KMEMLEAK_TEST) += kmemleak-test.o
+obj-$(CONFIG_DEBUG_RODATA_TEST) += rodata_test.o
 obj-$(CONFIG_PAGE_OWNER) += page_owner.o
 obj-$(CONFIG_CLEANCACHE) += cleancache.o
 obj-$(CONFIG_MEMORY_ISOLATION) += page_isolation.o
diff --git a/mm/compaction.c b/mm/compaction.c
index 0fdfde016ee2..81e1eaa2a2cf 100644
--- a/mm/compaction.c
+++ b/mm/compaction.c
@@ -12,6 +12,7 @@
 #include <linux/migrate.h>
 #include <linux/compaction.h>
 #include <linux/mm_inline.h>
+#include <linux/sched/signal.h>
 #include <linux/backing-dev.h>
 #include <linux/sysctl.h>
 #include <linux/sysfs.h>
diff --git a/mm/dmapool.c b/mm/dmapool.c
index cef82b8a9291..4d90a64b2fdc 100644
--- a/mm/dmapool.c
+++ b/mm/dmapool.c
@@ -93,7 +93,7 @@ show_pools(struct device *dev, struct device_attribute *attr, char *buf)
                 spin_unlock_irq(&pool->lock);
 
                 /* per-pool info, no real statistics yet */
-                temp = scnprintf(next, size, "%-16s %4u %4Zu %4Zu %2u\n",
+                temp = scnprintf(next, size, "%-16s %4u %4zu %4zu %2u\n",
                                  pool->name, blocks,
                                  pages * (pool->allocation / pool->size),
                                  pool->size, pages);
diff --git a/mm/filemap.c b/mm/filemap.c
index 1944c631e3e6..1694623a6289 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -13,6 +13,7 @@
 #include <linux/compiler.h>
 #include <linux/dax.h>
 #include <linux/fs.h>
+#include <linux/sched/signal.h>
 #include <linux/uaccess.h>
 #include <linux/capability.h>
 #include <linux/kernel_stat.h>
diff --git a/mm/gup.c b/mm/gup.c
index 94fab8fa432b..9c047e951aa3 100644
--- a/mm/gup.c
+++ b/mm/gup.c
@@ -10,7 +10,7 @@
 #include <linux/swap.h>
 #include <linux/swapops.h>
 
-#include <linux/sched.h>
+#include <linux/sched/signal.h>
 #include <linux/rwsem.h>
 #include <linux/hugetlb.h>
 
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index 71e3dede95b4..d36b2af4d1bf 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -9,6 +9,8 @@
 
 #include <linux/mm.h>
 #include <linux/sched.h>
+#include <linux/sched/coredump.h>
+#include <linux/sched/numa_balancing.h>
 #include <linux/highmem.h>
 #include <linux/hugetlb.h>
 #include <linux/mmu_notifier.h>
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index 2e0e8159ce8e..a7aa811b7d14 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -18,6 +18,7 @@
 #include <linux/bootmem.h>
 #include <linux/sysfs.h>
 #include <linux/slab.h>
+#include <linux/sched/signal.h>
 #include <linux/rmap.h>
 #include <linux/swap.h>
 #include <linux/swapops.h>
diff --git a/mm/kasan/kasan.c b/mm/kasan/kasan.c
index 25f0e6521f36..98b27195e38b 100644
--- a/mm/kasan/kasan.c
+++ b/mm/kasan/kasan.c
@@ -29,6 +29,7 @@
 #include <linux/module.h>
 #include <linux/printk.h>
 #include <linux/sched.h>
+#include <linux/sched/task_stack.h>
 #include <linux/slab.h>
 #include <linux/stacktrace.h>
 #include <linux/string.h>
@@ -39,6 +40,16 @@
 #include "kasan.h"
 #include "../slab.h"
 
+void kasan_enable_current(void)
+{
+        current->kasan_depth++;
+}
+
+void kasan_disable_current(void)
+{
+        current->kasan_depth--;
+}
+
 /*
  * Poisons the shadow memory for 'size' bytes starting from 'addr'.
  * Memory addresses should be aligned to KASAN_SHADOW_SCALE_SIZE.
diff --git a/mm/khugepaged.c b/mm/khugepaged.c
index 77ae3239c3de..ba40b7f673f4 100644
--- a/mm/khugepaged.c
+++ b/mm/khugepaged.c
@@ -2,6 +2,8 @@
 
 #include <linux/mm.h>
 #include <linux/sched.h>
+#include <linux/sched/mm.h>
+#include <linux/sched/coredump.h>
 #include <linux/mmu_notifier.h>
 #include <linux/rmap.h>
 #include <linux/swap.h>
@@ -420,7 +422,7 @@ int __khugepaged_enter(struct mm_struct *mm)
         list_add_tail(&mm_slot->mm_node, &khugepaged_scan.mm_head);
         spin_unlock(&khugepaged_mm_lock);
 
-        atomic_inc(&mm->mm_count);
+        mmgrab(mm);
         if (wakeup)
                 wake_up_interruptible(&khugepaged_wait);
 
diff --git a/mm/kmemleak.c b/mm/kmemleak.c
index da3436953022..26c874e90b12 100644
--- a/mm/kmemleak.c
+++ b/mm/kmemleak.c
@@ -73,7 +73,9 @@
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
-#include <linux/sched.h>
+#include <linux/sched/signal.h>
+#include <linux/sched/task.h>
+#include <linux/sched/task_stack.h>
 #include <linux/jiffies.h>
 #include <linux/delay.h>
 #include <linux/export.h>
diff --git a/mm/ksm.c b/mm/ksm.c
index cf211c01ceac..19b4f2dea7a5 100644
--- a/mm/ksm.c
+++ b/mm/ksm.c
@@ -19,6 +19,8 @@
 #include <linux/fs.h>
 #include <linux/mman.h>
 #include <linux/sched.h>
+#include <linux/sched/mm.h>
+#include <linux/sched/coredump.h>
 #include <linux/rwsem.h>
 #include <linux/pagemap.h>
 #include <linux/rmap.h>
@@ -1854,7 +1856,7 @@ int __ksm_enter(struct mm_struct *mm)
         spin_unlock(&ksm_mmlist_lock);
 
         set_bit(MMF_VM_MERGEABLE, &mm->flags);
-        atomic_inc(&mm->mm_count);
+        mmgrab(mm);
 
         if (needs_wakeup)
                 wake_up_interruptible(&ksm_thread_wait);
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 45867e439d31..c52ec893e241 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -35,6 +35,7 @@
 #include <linux/memcontrol.h>
 #include <linux/cgroup.h>
 #include <linux/mm.h>
+#include <linux/sched/mm.h>
 #include <linux/shmem_fs.h>
 #include <linux/hugetlb.h>
 #include <linux/pagemap.h>
diff --git a/mm/memory-failure.c b/mm/memory-failure.c
index 3d0f2fd4bf73..27f7210e7fab 100644
--- a/mm/memory-failure.c
+++ b/mm/memory-failure.c
@@ -40,7 +40,8 @@
 #include <linux/mm.h>
 #include <linux/page-flags.h>
 #include <linux/kernel-page-flags.h>
-#include <linux/sched.h>
+#include <linux/sched/signal.h>
+#include <linux/sched/task.h>
 #include <linux/ksm.h>
 #include <linux/rmap.h>
 #include <linux/export.h>
diff --git a/mm/memory.c b/mm/memory.c
index 14fc0b40f0bb..a97a4cec2e1f 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -40,6 +40,10 @@
 
 #include <linux/kernel_stat.h>
 #include <linux/mm.h>
+#include <linux/sched/mm.h>
+#include <linux/sched/coredump.h>
+#include <linux/sched/numa_balancing.h>
+#include <linux/sched/task.h>
 #include <linux/hugetlb.h>
 #include <linux/mman.h>
 #include <linux/swap.h>
diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index 1d3ed58f92ab..295479b792ec 100644
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -6,6 +6,7 @@
 
 #include <linux/stddef.h>
 #include <linux/mm.h>
+#include <linux/sched/signal.h>
 #include <linux/swap.h>
 #include <linux/interrupt.h>
 #include <linux/pagemap.h>
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index 1e7873e40c9a..75b2745bac41 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -73,6 +73,9 @@
 #include <linux/hugetlb.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
+#include <linux/sched/mm.h>
+#include <linux/sched/numa_balancing.h>
+#include <linux/sched/task.h>
 #include <linux/nodemask.h>
 #include <linux/cpuset.h>
 #include <linux/slab.h>
diff --git a/mm/migrate.c b/mm/migrate.c
index 2c63ac06791b..9a0897a14d37 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -40,6 +40,7 @@
 #include <linux/mmu_notifier.h>
 #include <linux/page_idle.h>
 #include <linux/page_owner.h>
+#include <linux/sched/mm.h>
 
 #include <asm/tlbflush.h>
 
diff --git a/mm/mlock.c b/mm/mlock.c
index cdbed8aaa426..1050511f8b2b 100644
--- a/mm/mlock.c
+++ b/mm/mlock.c
@@ -8,6 +8,7 @@
 #include <linux/capability.h>
 #include <linux/mman.h>
 #include <linux/mm.h>
+#include <linux/sched/user.h>
 #include <linux/swap.h>
 #include <linux/swapops.h>
 #include <linux/pagemap.h>
diff --git a/mm/mmap.c b/mm/mmap.c
index 499b988b1639..bfbe8856d134 100644
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -1672,7 +1672,7 @@ unsigned long mmap_region(struct file *file, unsigned long addr,
                  * new file must not have been exposed to user-space, yet.
                  */
                 vma->vm_file = get_file(file);
-                error = file->f_op->mmap(file, vma);
+                error = call_mmap(file, vma);
                 if (error)
                         goto unmap_and_free_vma;
 
diff --git a/mm/mmu_context.c b/mm/mmu_context.c
index 6f4d27c5bb32..3e612ae748e9 100644
--- a/mm/mmu_context.c
+++ b/mm/mmu_context.c
@@ -5,6 +5,8 @@
 
 #include <linux/mm.h>
 #include <linux/sched.h>
+#include <linux/sched/mm.h>
+#include <linux/sched/task.h>
 #include <linux/mmu_context.h>
 #include <linux/export.h>
 
@@ -25,7 +27,7 @@ void use_mm(struct mm_struct *mm)
         task_lock(tsk);
         active_mm = tsk->active_mm;
         if (active_mm != mm) {
-                atomic_inc(&mm->mm_count);
+                mmgrab(mm);
                 tsk->active_mm = mm;
         }
         tsk->mm = mm;
diff --git a/mm/mmu_notifier.c b/mm/mmu_notifier.c
index f4259e496f83..a7652acd2ab9 100644
--- a/mm/mmu_notifier.c
+++ b/mm/mmu_notifier.c
@@ -17,6 +17,7 @@
 #include <linux/srcu.h>
 #include <linux/rcupdate.h>
 #include <linux/sched.h>
+#include <linux/sched/mm.h>
 #include <linux/slab.h>
 
 /* global SRCU for all MMs */
@@ -275,7 +276,7 @@ static int do_mmu_notifier_register(struct mmu_notifier *mn,
                 mm->mmu_notifier_mm = mmu_notifier_mm;
                 mmu_notifier_mm = NULL;
         }
-        atomic_inc(&mm->mm_count);
+        mmgrab(mm);
 
         /*
          * Serialize the update against mmu_notifier_unregister. A
diff --git a/mm/nommu.c b/mm/nommu.c
index fe9f4fa4a7a7..2d131b97a851 100644
--- a/mm/nommu.c
+++ b/mm/nommu.c
@@ -17,6 +17,7 @@
 
 #include <linux/export.h>
 #include <linux/mm.h>
+#include <linux/sched/mm.h>
 #include <linux/vmacache.h>
 #include <linux/mman.h>
 #include <linux/swap.h>
@@ -757,7 +758,7 @@ static void delete_vma_from_mm(struct vm_area_struct *vma)
         mm->map_count--;
         for (i = 0; i < VMACACHE_SIZE; i++) {
                 /* if the vma is cached, invalidate the entire cache */
-                if (curr->vmacache[i] == vma) {
+                if (curr->vmacache.vmas[i] == vma) {
                         vmacache_invalidate(mm);
                         break;
                 }
@@ -1084,7 +1085,7 @@ static int do_mmap_shared_file(struct vm_area_struct *vma)
 {
         int ret;
 
-        ret = vma->vm_file->f_op->mmap(vma->vm_file, vma);
+        ret = call_mmap(vma->vm_file, vma);
         if (ret == 0) {
                 vma->vm_region->vm_top = vma->vm_region->vm_end;
                 return 0;
@@ -1115,7 +1116,7 @@ static int do_mmap_private(struct vm_area_struct *vma,
          * - VM_MAYSHARE will be set if it may attempt to share
          */
         if (capabilities & NOMMU_MAP_DIRECT) {
-                ret = vma->vm_file->f_op->mmap(vma->vm_file, vma);
+                ret = call_mmap(vma->vm_file, vma);
                 if (ret == 0) {
                         /* shouldn't return success if we're not sharing */
                         BUG_ON(!(vma->vm_flags & VM_MAYSHARE));
diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index 578321f1c070..d083714a2bb9 100644
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -22,6 +22,9 @@
 #include <linux/err.h>
 #include <linux/gfp.h>
 #include <linux/sched.h>
+#include <linux/sched/mm.h>
+#include <linux/sched/coredump.h>
+#include <linux/sched/task.h>
 #include <linux/swap.h>
 #include <linux/timex.h>
 #include <linux/jiffies.h>
@@ -653,7 +656,7 @@ static void mark_oom_victim(struct task_struct *tsk)
 
         /* oom_mm is bound to the signal struct life time. */
         if (!cmpxchg(&tsk->signal->oom_mm, NULL, mm))
-                atomic_inc(&tsk->signal->oom_mm->mm_count);
+                mmgrab(tsk->signal->oom_mm);
 
         /*
          * Make sure that the task is woken up from uninterruptible sleep
@@ -870,7 +873,7 @@ static void oom_kill_process(struct oom_control *oc, const char *message)
 
         /* Get a reference to safely compare mm after task_unlock(victim) */
         mm = victim->mm;
-        atomic_inc(&mm->mm_count);
+        mmgrab(mm);
         /*
          * We should send SIGKILL before setting TIF_MEMDIE in order to prevent
          * the OOM victim from depleting the memory reserves from the user
diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index ae6e601f0a58..d8ac2a7fb9e7 100644
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -36,6 +36,7 @@
 #include <linux/pagevec.h>
 #include <linux/timer.h>
 #include <linux/sched/rt.h>
+#include <linux/sched/signal.h>
 #include <linux/mm_inline.h>
 #include <trace/events/writeback.h>
 
@@ -1797,7 +1798,7 @@ pause:
                  * pages exceeds dirty_thresh, give the other good wb's a pipe
                  * to go through, so that tasks on them still remain responsive.
                  *
-                 * In theory 1 page is enough to keep the comsumer-producer
+                 * In theory 1 page is enough to keep the consumer-producer
                  * pipe going: the flusher cleans 1 page => the task dirties 1
                  * more page. However wb_dirty has accounting errors.  So use
                  * the larger and more IO friendly wb_stat_error.
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 9f9623d690d6..eaa64d2ffdc5 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -61,6 +61,7 @@
 #include <linux/migrate.h>
 #include <linux/hugetlb.h>
 #include <linux/sched/rt.h>
+#include <linux/sched/mm.h>
 #include <linux/page_owner.h>
 #include <linux/kthread.h>
 #include <linux/memcontrol.h>
@@ -5925,7 +5926,7 @@ static unsigned long __paginginit calc_memmap_size(unsigned long spanned_pages,
          * the zone and SPARSEMEM is in use. If there are holes within the
          * zone, each populated memory region may cost us one or two extra
          * memmap pages due to alignment because memmap pages for each
-         * populated regions may not naturally algined on page boundary.
+         * populated regions may not be naturally aligned on page boundary.
          * So the (present_pages >> 4) heuristic is a tradeoff for that.
          */
         if (spanned_pages > present_pages + (present_pages >> 4) &&
diff --git a/mm/percpu.c b/mm/percpu.c
index 0686f566d347..5696039b5c07 100644
--- a/mm/percpu.c
+++ b/mm/percpu.c
@@ -43,7 +43,7 @@
  * Chunks can be determined from the address using the index field
  * in the page struct. The index field contains a pointer to the chunk.
  *
- * To use this allocator, arch code should do the followings.
+ * To use this allocator, arch code should do the following:
  *
  * - define __addr_to_pcpu_ptr() and __pcpu_ptr_to_addr() to translate
  *   regular address to percpu pointer and back if they need to be
diff --git a/mm/process_vm_access.c b/mm/process_vm_access.c
index 84d0c7eada2b..8973cd231ece 100644
--- a/mm/process_vm_access.c
+++ b/mm/process_vm_access.c
@@ -12,6 +12,7 @@
 #include <linux/mm.h>
 #include <linux/uio.h>
 #include <linux/sched.h>
+#include <linux/sched/mm.h>
 #include <linux/highmem.h>
 #include <linux/ptrace.h>
 #include <linux/slab.h>
diff --git a/mm/rmap.c b/mm/rmap.c
index 8774791e2809..2da487d6cea8 100644
--- a/mm/rmap.c
+++ b/mm/rmap.c
@@ -46,6 +46,8 @@
  */
 
 #include <linux/mm.h>
+#include <linux/sched/mm.h>
+#include <linux/sched/task.h>
 #include <linux/pagemap.h>
 #include <linux/swap.h>
 #include <linux/swapops.h>
diff --git a/mm/rodata_test.c b/mm/rodata_test.c
new file mode 100644
index 000000000000..0fd21670b513
--- /dev/null
+++ b/mm/rodata_test.c
@@ -0,0 +1,56 @@
+/*
+ * rodata_test.c: functional test for mark_rodata_ro function
+ *
+ * (C) Copyright 2008 Intel Corporation
+ * Author: Arjan van de Ven <arjan@linux.intel.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; version 2
+ * of the License.
+ */
+#include <linux/uaccess.h>
+#include <asm/sections.h>
+
+const int rodata_test_data = 0xC3;
+EXPORT_SYMBOL_GPL(rodata_test_data);
+
+void rodata_test(void)
+{
+        unsigned long start, end;
+        int zero = 0;
+
+        /* test 1: read the value */
+        /* If this test fails, some previous testrun has clobbered the state */
+        if (!rodata_test_data) {
+                pr_err("rodata_test: test 1 fails (start data)\n");
+                return;
+        }
+
+        /* test 2: write to the variable; this should fault */
+        if (!probe_kernel_write((void *)&rodata_test_data,
+                                                (void *)&zero, sizeof(zero))) {
+                pr_err("rodata_test: test data was not read only\n");
+                return;
+        }
+
+        /* test 3: check the value hasn't changed */
+        if (rodata_test_data == zero) {
+                pr_err("rodata_test: test data was changed\n");
+                return;
+        }
+
+        /* test 4: check if the rodata section is PAGE_SIZE aligned */
+        start = (unsigned long)__start_rodata;
+        end = (unsigned long)__end_rodata;
+        if (start & (PAGE_SIZE - 1)) {
+                pr_err("rodata_test: start of .rodata is not page size aligned\n");
+                return;
+        }
+        if (end & (PAGE_SIZE - 1)) {
+                pr_err("rodata_test: end of .rodata is not page size aligned\n");
+                return;
+        }
+
+        pr_info("rodata_test: all tests were successful\n");
+}
diff --git a/mm/shmem.c b/mm/shmem.c
index a26649a6633f..e67d6ba4e98e 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -29,6 +29,7 @@
 #include <linux/pagemap.h>
 #include <linux/file.h>
 #include <linux/mm.h>
+#include <linux/sched/signal.h>
 #include <linux/export.h>
 #include <linux/swap.h>
 #include <linux/uio.h>
@@ -958,10 +959,10 @@ void shmem_truncate_range(struct inode *inode, loff_t lstart, loff_t lend)
 }
 EXPORT_SYMBOL_GPL(shmem_truncate_range);
 
-static int shmem_getattr(struct vfsmount *mnt, struct dentry *dentry,
-                         struct kstat *stat)
+static int shmem_getattr(const struct path *path, struct kstat *stat,
+                         u32 request_mask, unsigned int query_flags)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = path->dentry->d_inode;
         struct shmem_inode_info *info = SHMEM_I(inode);
 
         if (info->alloced - info->swapped != inode->i_mapping->nrpages) {
diff --git a/mm/slab.c b/mm/slab.c
index bd63450a9b16..807d86c76908 100644
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -116,6 +116,7 @@
 #include        <linux/kmemcheck.h>
 #include        <linux/memory.h>
 #include        <linux/prefetch.h>
+#include        <linux/sched/task_stack.h>
 
 #include        <net/sock.h>
 
diff --git a/mm/swapfile.c b/mm/swapfile.c
index 2cac12cc9abe..521ef9b6064f 100644
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -6,6 +6,8 @@
  */
 
 #include <linux/mm.h>
+#include <linux/sched/mm.h>
+#include <linux/sched/task.h>
 #include <linux/hugetlb.h>
 #include <linux/mman.h>
 #include <linux/slab.h>
@@ -1671,7 +1673,7 @@ int try_to_unuse(unsigned int type, bool frontswap,
          * that.
          */
         start_mm = &init_mm;
-        atomic_inc(&init_mm.mm_users);
+        mmget(&init_mm);
 
         /*
          * Keep on scanning until all entries have gone.  Usually,
@@ -1720,7 +1722,7 @@ int try_to_unuse(unsigned int type, bool frontswap,
                 if (atomic_read(&start_mm->mm_users) == 1) {
                         mmput(start_mm);
                         start_mm = &init_mm;
-                        atomic_inc(&init_mm.mm_users);
+                        mmget(&init_mm);
                 }
 
                 /*
@@ -1757,13 +1759,13 @@ int try_to_unuse(unsigned int type, bool frontswap,
                         struct mm_struct *prev_mm = start_mm;
                         struct mm_struct *mm;
 
-                        atomic_inc(&new_start_mm->mm_users);
-                        atomic_inc(&prev_mm->mm_users);
+                        mmget(new_start_mm);
+                        mmget(prev_mm);
                         spin_lock(&mmlist_lock);
                         while (swap_count(*swap_map) && !retval &&
                                         (p = p->next) != &start_mm->mmlist) {
                                 mm = list_entry(p, struct mm_struct, mmlist);
-                                if (!atomic_inc_not_zero(&mm->mm_users))
+                                if (!mmget_not_zero(mm))
                                         continue;
                                 spin_unlock(&mmlist_lock);
                                 mmput(prev_mm);
@@ -1781,7 +1783,7 @@ int try_to_unuse(unsigned int type, bool frontswap,
 
                                 if (set_start_mm && *swap_map < swcount) {
                                         mmput(new_start_mm);
-                                        atomic_inc(&mm->mm_users);
+                                        mmget(mm);
                                         new_start_mm = mm;
                                         set_start_mm = 0;
                                 }
diff --git a/mm/truncate.c b/mm/truncate.c
index f2db67465495..6263affdef88 100644
--- a/mm/truncate.c
+++ b/mm/truncate.c
@@ -786,7 +786,7 @@ EXPORT_SYMBOL(truncate_setsize);
  */
 void pagecache_isize_extended(struct inode *inode, loff_t from, loff_t to)
 {
-        int bsize = 1 << inode->i_blkbits;
+        int bsize = i_blocksize(inode);
         loff_t rounded_from;
         struct page *page;
         pgoff_t index;
diff --git a/mm/usercopy.c b/mm/usercopy.c
index 8345299e3e3b..d155e12563b1 100644
--- a/mm/usercopy.c
+++ b/mm/usercopy.c
@@ -16,6 +16,9 @@
 
 #include <linux/mm.h>
 #include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/sched/task.h>
+#include <linux/sched/task_stack.h>
 #include <asm/sections.h>
 
 enum {
diff --git a/mm/userfaultfd.c b/mm/userfaultfd.c
index 9f0ad2a4f102..479e631d43c2 100644
--- a/mm/userfaultfd.c
+++ b/mm/userfaultfd.c
@@ -8,6 +8,7 @@
  */
 
 #include <linux/mm.h>
+#include <linux/sched/signal.h>
 #include <linux/pagemap.h>
 #include <linux/rmap.h>
 #include <linux/swap.h>
diff --git a/mm/util.c b/mm/util.c
index b8f538863b5a..656dc5e37a87 100644
--- a/mm/util.c
+++ b/mm/util.c
@@ -5,6 +5,8 @@
 #include <linux/export.h>
 #include <linux/err.h>
 #include <linux/sched.h>
+#include <linux/sched/mm.h>
+#include <linux/sched/task_stack.h>
 #include <linux/security.h>
 #include <linux/swap.h>
 #include <linux/swapops.h>
diff --git a/mm/vmacache.c b/mm/vmacache.c
index 035fdeb35b43..7ffa0ee341b5 100644
--- a/mm/vmacache.c
+++ b/mm/vmacache.c
@@ -1,7 +1,8 @@
 /*
  * Copyright (C) 2014 Davidlohr Bueso.
  */
-#include <linux/sched.h>
+#include <linux/sched/signal.h>
+#include <linux/sched/task.h>
 #include <linux/mm.h>
 #include <linux/vmacache.h>
 
@@ -60,7 +61,7 @@ static inline bool vmacache_valid_mm(struct mm_struct *mm)
 void vmacache_update(unsigned long addr, struct vm_area_struct *newvma)
 {
         if (vmacache_valid_mm(newvma->vm_mm))
-                current->vmacache[VMACACHE_HASH(addr)] = newvma;
+                current->vmacache.vmas[VMACACHE_HASH(addr)] = newvma;
 }
 
 static bool vmacache_valid(struct mm_struct *mm)
@@ -71,12 +72,12 @@ static bool vmacache_valid(struct mm_struct *mm)
                 return false;
 
         curr = current;
-        if (mm->vmacache_seqnum != curr->vmacache_seqnum) {
+        if (mm->vmacache_seqnum != curr->vmacache.seqnum) {
                 /*
                  * First attempt will always be invalid, initialize
                  * the new cache for this task here.
                  */
-                curr->vmacache_seqnum = mm->vmacache_seqnum;
+                curr->vmacache.seqnum = mm->vmacache_seqnum;
                 vmacache_flush(curr);
                 return false;
         }
@@ -93,7 +94,7 @@ struct vm_area_struct *vmacache_find(struct mm_struct *mm, unsigned long addr)
                 return NULL;
 
         for (i = 0; i < VMACACHE_SIZE; i++) {
-                struct vm_area_struct *vma = current->vmacache[i];
+                struct vm_area_struct *vma = current->vmacache.vmas[i];
 
                 if (!vma)
                         continue;
@@ -121,7 +122,7 @@ struct vm_area_struct *vmacache_find_exact(struct mm_struct *mm,
                 return NULL;
 
         for (i = 0; i < VMACACHE_SIZE; i++) {
-                struct vm_area_struct *vma = current->vmacache[i];
+                struct vm_area_struct *vma = current->vmacache.vmas[i];
 
                 if (vma && vma->vm_start == start && vma->vm_end == end) {
                         count_vm_vmacache_event(VMACACHE_FIND_HITS);
diff --git a/mm/vmalloc.c b/mm/vmalloc.c
index be93949b4885..b4024d688f38 100644
--- a/mm/vmalloc.c
+++ b/mm/vmalloc.c
@@ -12,7 +12,7 @@
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/highmem.h>
-#include <linux/sched.h>
+#include <linux/sched/signal.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
diff --git a/mm/vmscan.c b/mm/vmscan.c
index 70aa739c6b68..bc8031ef994d 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -14,6 +14,7 @@
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/mm.h>
+#include <linux/sched/mm.h>
 #include <linux/module.h>
 #include <linux/gfp.h>
 #include <linux/kernel_stat.h>
diff --git a/mm/workingset.c b/mm/workingset.c
index 79ed5364375d..ac839fca0e76 100644
--- a/mm/workingset.c
+++ b/mm/workingset.c
@@ -355,10 +355,8 @@ void workingset_update_node(struct radix_tree_node *node, void *private)
          * as node->private_list is protected by &mapping->tree_lock.
          */
         if (node->count && node->count == node->exceptional) {
-                if (list_empty(&node->private_list)) {
-                        node->private_data = mapping;
+                if (list_empty(&node->private_list))
                         list_lru_add(&shadow_nodes, &node->private_list);
-                }
         } else {
                 if (!list_empty(&node->private_list))
                         list_lru_del(&shadow_nodes, &node->private_list);
@@ -436,7 +434,7 @@ static enum lru_status shadow_lru_isolate(struct list_head *item,
          */
 
         node = container_of(item, struct radix_tree_node, private_list);
-        mapping = node->private_data;
+        mapping = container_of(node->root, struct address_space, page_tree);
 
         /* Coming from the list, invert the lock order */
         if (!spin_trylock(&mapping->tree_lock)) {
diff --git a/mm/zsmalloc.c b/mm/zsmalloc.c
index b7b1fb6c8c21..b7ee9c34dbd6 100644
--- a/mm/zsmalloc.c
+++ b/mm/zsmalloc.c
@@ -33,6 +33,7 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
+#include <linux/magic.h>
 #include <linux/bitops.h>
 #include <linux/errno.h>
 #include <linux/highmem.h>
diff --git a/mm/zswap.c b/mm/zswap.c
index cabf09e0128b..eedc27894b10 100644
--- a/mm/zswap.c
+++ b/mm/zswap.c
@@ -76,6 +76,8 @@ static u64 zswap_duplicate_entry;
 * tunables
 **********************************/
 
+#define ZSWAP_PARAM_UNSET ""
+
 /* Enable/disable zswap (disabled by default) */
 static bool zswap_enabled;
 static int zswap_enabled_param_set(const char *,
@@ -185,6 +187,9 @@ static bool zswap_init_started;
 /* fatal error during init */
 static bool zswap_init_failed;
 
+/* init completed, but couldn't create the initial pool */
+static bool zswap_has_pool;
+
 /*********************************
 * helpers and fwd declarations
 **********************************/
@@ -424,7 +429,8 @@ static struct zswap_pool *__zswap_pool_current(void)
         struct zswap_pool *pool;
 
         pool = list_first_or_null_rcu(&zswap_pools, typeof(*pool), list);
-        WARN_ON(!pool);
+        WARN_ONCE(!pool && zswap_has_pool,
+                  "%s: no page storage pool!\n", __func__);
 
         return pool;
 }
@@ -443,7 +449,7 @@ static struct zswap_pool *zswap_pool_current_get(void)
         rcu_read_lock();
 
         pool = __zswap_pool_current();
-        if (!pool || !zswap_pool_get(pool))
+        if (!zswap_pool_get(pool))
                 pool = NULL;
 
         rcu_read_unlock();
@@ -459,7 +465,9 @@ static struct zswap_pool *zswap_pool_last_get(void)
 
         list_for_each_entry_rcu(pool, &zswap_pools, list)
                 last = pool;
-        if (!WARN_ON(!last) && !zswap_pool_get(last))
+        WARN_ONCE(!last && zswap_has_pool,
+                  "%s: no page storage pool!\n", __func__);
+        if (!zswap_pool_get(last))
                 last = NULL;
 
         rcu_read_unlock();
@@ -495,6 +503,17 @@ static struct zswap_pool *zswap_pool_create(char *type, char *compressor)
         gfp_t gfp = __GFP_NORETRY | __GFP_NOWARN | __GFP_KSWAPD_RECLAIM;
         int ret;
 
+        if (!zswap_has_pool) {
+                /* if either are unset, pool initialization failed, and we
+                 * need both params to be set correctly before trying to
+                 * create a pool.
+                 */
+                if (!strcmp(type, ZSWAP_PARAM_UNSET))
+                        return NULL;
+                if (!strcmp(compressor, ZSWAP_PARAM_UNSET))
+                        return NULL;
+        }
+
         pool = kzalloc(sizeof(*pool), GFP_KERNEL);
         if (!pool) {
                 pr_err("pool alloc failed\n");
@@ -544,29 +563,41 @@ error:
 
 static __init struct zswap_pool *__zswap_pool_create_fallback(void)
 {
-        if (!crypto_has_comp(zswap_compressor, 0, 0)) {
-                if (!strcmp(zswap_compressor, ZSWAP_COMPRESSOR_DEFAULT)) {
-                        pr_err("default compressor %s not available\n",
-                               zswap_compressor);
-                        return NULL;
-                }
+        bool has_comp, has_zpool;
+
+        has_comp = crypto_has_comp(zswap_compressor, 0, 0);
+        if (!has_comp && strcmp(zswap_compressor, ZSWAP_COMPRESSOR_DEFAULT)) {
                 pr_err("compressor %s not available, using default %s\n",
                        zswap_compressor, ZSWAP_COMPRESSOR_DEFAULT);
                 param_free_charp(&zswap_compressor);
                 zswap_compressor = ZSWAP_COMPRESSOR_DEFAULT;
+                has_comp = crypto_has_comp(zswap_compressor, 0, 0);
         }
-        if (!zpool_has_pool(zswap_zpool_type)) {
-                if (!strcmp(zswap_zpool_type, ZSWAP_ZPOOL_DEFAULT)) {
-                        pr_err("default zpool %s not available\n",
-                               zswap_zpool_type);
-                        return NULL;
-                }
+        if (!has_comp) {
+                pr_err("default compressor %s not available\n",
+                       zswap_compressor);
+                param_free_charp(&zswap_compressor);
+                zswap_compressor = ZSWAP_PARAM_UNSET;
+        }
+
+        has_zpool = zpool_has_pool(zswap_zpool_type);
+        if (!has_zpool && strcmp(zswap_zpool_type, ZSWAP_ZPOOL_DEFAULT)) {
                 pr_err("zpool %s not available, using default %s\n",
                        zswap_zpool_type, ZSWAP_ZPOOL_DEFAULT);
                 param_free_charp(&zswap_zpool_type);
                 zswap_zpool_type = ZSWAP_ZPOOL_DEFAULT;
+                has_zpool = zpool_has_pool(zswap_zpool_type);
+        }
+        if (!has_zpool) {
+                pr_err("default zpool %s not available\n",
+                       zswap_zpool_type);
+                param_free_charp(&zswap_zpool_type);
+                zswap_zpool_type = ZSWAP_PARAM_UNSET;
         }
 
+        if (!has_comp || !has_zpool)
+                return NULL;
+
         return zswap_pool_create(zswap_zpool_type, zswap_compressor);
 }
 
@@ -582,6 +613,9 @@ static void zswap_pool_destroy(struct zswap_pool *pool)
 
 static int __must_check zswap_pool_get(struct zswap_pool *pool)
 {
+        if (!pool)
+                return 0;
+
         return kref_get_unless_zero(&pool->kref);
 }
 
@@ -639,7 +673,7 @@ static int __zswap_param_set(const char *val, const struct kernel_param *kp,
         }
 
         /* no change required */
-        if (!strcmp(s, *(char **)kp->arg))
+        if (!strcmp(s, *(char **)kp->arg) && zswap_has_pool)
                 return 0;
 
         /* if this is load-time (pre-init) param setting,
@@ -670,21 +704,26 @@ static int __zswap_param_set(const char *val, const struct kernel_param *kp,
         pool = zswap_pool_find_get(type, compressor);
         if (pool) {
                 zswap_pool_debug("using existing", pool);
+                WARN_ON(pool == zswap_pool_current());
                 list_del_rcu(&pool->list);
-        } else {
-                spin_unlock(&zswap_pools_lock);
-                pool = zswap_pool_create(type, compressor);
-                spin_lock(&zswap_pools_lock);
         }
 
+        spin_unlock(&zswap_pools_lock);
+
+        if (!pool)
+                pool = zswap_pool_create(type, compressor);
+
         if (pool)
                 ret = param_set_charp(s, kp);
         else
                 ret = -EINVAL;
 
+        spin_lock(&zswap_pools_lock);
+
         if (!ret) {
                 put_pool = zswap_pool_current();
                 list_add_rcu(&pool->list, &zswap_pools);
+                zswap_has_pool = true;
         } else if (pool) {
                 /* add the possibly pre-existing pool to the end of the pools
                  * list; if it's new (and empty) then it'll be removed and
@@ -696,6 +735,17 @@ static int __zswap_param_set(const char *val, const struct kernel_param *kp,
 
         spin_unlock(&zswap_pools_lock);
 
+        if (!zswap_has_pool && !pool) {
+                /* if initial pool creation failed, and this pool creation also
+                 * failed, maybe both compressor and zpool params were bad.
+                 * Allow changing this param, so pool creation will succeed
+                 * when the other param is changed. We already verified this
+                 * param is ok in the zpool_has_pool() or crypto_has_comp()
+                 * checks above.
+                 */
+                ret = param_set_charp(s, kp);
+        }
+
         /* drop the ref from either the old current pool,
          * or the new pool we failed to add
          */
@@ -724,6 +774,10 @@ static int zswap_enabled_param_set(const char *val,
                 pr_err("can't enable, initialization failed\n");
                 return -ENODEV;
         }
+        if (!zswap_has_pool && zswap_init_started) {
+                pr_err("can't enable, no pool configured\n");
+                return -ENODEV;
+        }
 
         return param_set_bool(val, kp);
 }
@@ -1205,22 +1259,21 @@ static int __init init_zswap(void)
                 goto hp_fail;
 
         pool = __zswap_pool_create_fallback();
-        if (!pool) {
+        if (pool) {
+                pr_info("loaded using pool %s/%s\n", pool->tfm_name,
+                        zpool_get_type(pool->zpool));
+                list_add(&pool->list, &zswap_pools);
+                zswap_has_pool = true;
+        } else {
                 pr_err("pool creation failed\n");
-                goto pool_fail;
+                zswap_enabled = false;
         }
-        pr_info("loaded using pool %s/%s\n", pool->tfm_name,
-                zpool_get_type(pool->zpool));
-
-        list_add(&pool->list, &zswap_pools);
 
         frontswap_register_ops(&zswap_frontswap_ops);
         if (zswap_debugfs_init())
                 pr_warn("debugfs initialization failed\n");
         return 0;
 
-pool_fail:
-        cpuhp_remove_state_nocalls(CPUHP_MM_ZSWP_POOL_PREPARE);
 hp_fail:
         cpuhp_remove_state(CPUHP_MM_ZSWP_MEM_PREPARE);
 dstmem_fail: