Merge branch 'akpm' (patches from Andrew)

Merge updates from Andrew Morton:

 - a few hot fixes

 - ocfs2 updates

 - almost all of -mm (slab-generic, slab, slub, kmemleak, kasan,
   cleanups, debug, pagecache, memcg, gup, pagemap, memory-hotplug,
   sparsemem, vmalloc, initialization, z3fold, compaction, mempolicy,
   oom-kill, hugetlb, migration, thp, mmap, madvise, shmem, zswap,
   zsmalloc)

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (132 commits)
  mm/zsmalloc.c: fix a -Wunused-function warning
  zswap: do not map same object twice
  zswap: use movable memory if zpool support allocate movable memory
  zpool: add malloc_support_movable to zpool_driver
  shmem: fix obsolete comment in shmem_getpage_gfp()
  mm/madvise: reduce code duplication in error handling paths
  mm: mmap: increase sockets maximum memory size pgoff for 32bits
  mm/mmap.c: refine find_vma_prev() with rb_last()
  riscv: make mmap allocation top-down by default
  mips: use generic mmap top-down layout and brk randomization
  mips: replace arch specific way to determine 32bit task with generic version
  mips: adjust brk randomization offset to fit generic version
  mips: use STACK_TOP when computing mmap base address
  mips: properly account for stack randomization and stack guard gap
  arm: use generic mmap top-down layout and brk randomization
  arm: use STACK_TOP when computing mmap base address
  arm: properly account for stack randomization and stack guard gap
  arm64, mm: make randomization selected by generic topdown mmap layout
  arm64, mm: move generic mmap layout functions to mm
  arm64: consider stack randomization for mmap base only when necessary
  ...

1 files changed, 120 insertions, 2 deletions

diff --git a/mm/util.c b/mm/util.c
index e6351a80f248..3ad6db9a722e 100644
--- a/mm/util.c
+++ b/mm/util.c
@@ -16,6 +16,13 @@
 #include <linux/hugetlb.h>
 #include <linux/vmalloc.h>
 #include <linux/userfaultfd_k.h>
+#include <linux/elf.h>
+#include <linux/elf-randomize.h>
+#include <linux/personality.h>
+#include <linux/random.h>
+#include <linux/processor.h>
+#include <linux/sizes.h>
+#include <linux/compat.h>
 
 #include <linux/uaccess.h>
 
@@ -293,7 +300,105 @@ int vma_is_stack_for_current(struct vm_area_struct *vma)
         return (vma->vm_start <= KSTK_ESP(t) && vma->vm_end >= KSTK_ESP(t));
 }
 
-#if defined(CONFIG_MMU) && !defined(HAVE_ARCH_PICK_MMAP_LAYOUT)
+#ifndef STACK_RND_MASK
+#define STACK_RND_MASK (0x7ff >> (PAGE_SHIFT - 12))     /* 8MB of VA */
+#endif
+
+unsigned long randomize_stack_top(unsigned long stack_top)
+{
+        unsigned long random_variable = 0;
+
+        if (current->flags & PF_RANDOMIZE) {
+                random_variable = get_random_long();
+                random_variable &= STACK_RND_MASK;
+                random_variable <<= PAGE_SHIFT;
+        }
+#ifdef CONFIG_STACK_GROWSUP
+        return PAGE_ALIGN(stack_top) + random_variable;
+#else
+        return PAGE_ALIGN(stack_top) - random_variable;
+#endif
+}
+
+#ifdef CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT
+unsigned long arch_randomize_brk(struct mm_struct *mm)
+{
+        /* Is the current task 32bit ? */
+        if (!IS_ENABLED(CONFIG_64BIT) || is_compat_task())
+                return randomize_page(mm->brk, SZ_32M);
+
+        return randomize_page(mm->brk, SZ_1G);
+}
+
+unsigned long arch_mmap_rnd(void)
+{
+        unsigned long rnd;
+
+#ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS
+        if (is_compat_task())
+                rnd = get_random_long() & ((1UL << mmap_rnd_compat_bits) - 1);
+        else
+#endif /* CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS */
+                rnd = get_random_long() & ((1UL << mmap_rnd_bits) - 1);
+
+        return rnd << PAGE_SHIFT;
+}
+
+static int mmap_is_legacy(struct rlimit *rlim_stack)
+{
+        if (current->personality & ADDR_COMPAT_LAYOUT)
+                return 1;
+
+        if (rlim_stack->rlim_cur == RLIM_INFINITY)
+                return 1;
+
+        return sysctl_legacy_va_layout;
+}
+
+/*
+ * Leave enough space between the mmap area and the stack to honour ulimit in
+ * the face of randomisation.
+ */
+#define MIN_GAP         (SZ_128M)
+#define MAX_GAP         (STACK_TOP / 6 * 5)
+
+static unsigned long mmap_base(unsigned long rnd, struct rlimit *rlim_stack)
+{
+        unsigned long gap = rlim_stack->rlim_cur;
+        unsigned long pad = stack_guard_gap;
+
+        /* Account for stack randomization if necessary */
+        if (current->flags & PF_RANDOMIZE)
+                pad += (STACK_RND_MASK << PAGE_SHIFT);
+
+        /* Values close to RLIM_INFINITY can overflow. */
+        if (gap + pad > gap)
+                gap += pad;
+
+        if (gap < MIN_GAP)
+                gap = MIN_GAP;
+        else if (gap > MAX_GAP)
+                gap = MAX_GAP;
+
+        return PAGE_ALIGN(STACK_TOP - gap - rnd);
+}
+
+void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack)
+{
+        unsigned long random_factor = 0UL;
+
+        if (current->flags & PF_RANDOMIZE)
+                random_factor = arch_mmap_rnd();
+
+        if (mmap_is_legacy(rlim_stack)) {
+                mm->mmap_base = TASK_UNMAPPED_BASE + random_factor;
+                mm->get_unmapped_area = arch_get_unmapped_area;
+        } else {
+                mm->mmap_base = mmap_base(random_factor, rlim_stack);
+                mm->get_unmapped_area = arch_get_unmapped_area_topdown;
+        }
+}
+#elif defined(CONFIG_MMU) && !defined(HAVE_ARCH_PICK_MMAP_LAYOUT)
 void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack)
 {
         mm->mmap_base = TASK_UNMAPPED_BASE;
@@ -521,7 +626,7 @@ bool page_mapped(struct page *page)
                 return true;
         if (PageHuge(page))
                 return false;
-        for (i = 0; i < (1 << compound_order(page)); i++) {
+        for (i = 0; i < compound_nr(page); i++) {
                 if (atomic_read(&page[i]._mapcount) >= 0)
                         return true;
         }
@@ -783,3 +888,16 @@ out_mm:
 out:
         return res;
 }
+
+int memcmp_pages(struct page *page1, struct page *page2)
+{
+        char *addr1, *addr2;
+        int ret;
+
+        addr1 = kmap_atomic(page1);
+        addr2 = kmap_atomic(page2);
+        ret = memcmp(addr1, addr2, PAGE_SIZE);
+        kunmap_atomic(addr2);
+        kunmap_atomic(addr1);
+        return ret;
+}