Merge branch 'akpm' (patches from Andrew Morton)

Merge second patch-bomb from Andrew Morton:
 - a few hotfixes
 - drivers/dma updates
 - MAINTAINERS updates
 - Quite a lot of lib/ updates
 - checkpatch updates
 - binfmt updates
 - autofs4
 - drivers/rtc/
 - various small tweaks to less used filesystems
 - ipc/ updates
 - kernel/watchdog.c changes

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (135 commits)
  mm: softdirty: enable write notifications on VMAs after VM_SOFTDIRTY cleared
  kernel/param: consolidate __{start,stop}___param[] in <linux/moduleparam.h>
  ia64: remove duplicate declarations of __per_cpu_start[] and __per_cpu_end[]
  frv: remove unused declarations of __start___ex_table and __stop___ex_table
  kvm: ensure hard lockup detection is disabled by default
  kernel/watchdog.c: control hard lockup detection default
  staging: rtl8192u: use %*pEn to escape buffer
  staging: rtl8192e: use %*pEn to escape buffer
  staging: wlan-ng: use %*pEhp to print SN
  lib80211: remove unused print_ssid()
  wireless: hostap: proc: print properly escaped SSID
  wireless: ipw2x00: print SSID via %*pE
  wireless: libertas: print esaped string via %*pE
  lib/vsprintf: add %*pE[achnops] format specifier
  lib / string_helpers: introduce string_escape_mem()
  lib / string_helpers: refactoring the test suite
  lib / string_helpers: move documentation to c-file
  include/linux: remove strict_strto* definitions
  arch/x86/mm/numa.c: fix boot failure when all nodes are hotpluggable
  fs: check bh blocknr earlier when searching lru
  ...

5 files changed, 90 insertions, 46 deletions

diff --git a/mm/cma.c b/mm/cma.c
index 474c644a0dc6..963bc4add9af 100644
--- a/mm/cma.c
+++ b/mm/cma.c
@@ -58,7 +58,9 @@ unsigned long cma_get_size(struct cma *cma)
 
 static unsigned long cma_bitmap_aligned_mask(struct cma *cma, int align_order)
 {
-        return (1UL << (align_order >> cma->order_per_bit)) - 1;
+        if (align_order <= cma->order_per_bit)
+                return 0;
+        return (1UL << (align_order - cma->order_per_bit)) - 1;
 }
 
 static unsigned long cma_bitmap_maxno(struct cma *cma)
@@ -141,6 +143,54 @@ static int __init cma_init_reserved_areas(void)
 core_initcall(cma_init_reserved_areas);
 
 /**
+ * cma_init_reserved_mem() - create custom contiguous area from reserved memory
+ * @base: Base address of the reserved area
+ * @size: Size of the reserved area (in bytes),
+ * @order_per_bit: Order of pages represented by one bit on bitmap.
+ * @res_cma: Pointer to store the created cma region.
+ *
+ * This function creates custom contiguous area from already reserved memory.
+ */
+int __init cma_init_reserved_mem(phys_addr_t base, phys_addr_t size,
+                                 int order_per_bit, struct cma **res_cma)
+{
+        struct cma *cma;
+        phys_addr_t alignment;
+
+        /* Sanity checks */
+        if (cma_area_count == ARRAY_SIZE(cma_areas)) {
+                pr_err("Not enough slots for CMA reserved regions!\n");
+                return -ENOSPC;
+        }
+
+        if (!size || !memblock_is_region_reserved(base, size))
+                return -EINVAL;
+
+        /* ensure minimal alignment requied by mm core */
+        alignment = PAGE_SIZE << max(MAX_ORDER - 1, pageblock_order);
+
+        /* alignment should be aligned with order_per_bit */
+        if (!IS_ALIGNED(alignment >> PAGE_SHIFT, 1 << order_per_bit))
+                return -EINVAL;
+
+        if (ALIGN(base, alignment) != base || ALIGN(size, alignment) != size)
+                return -EINVAL;
+
+        /*
+         * Each reserved area must be initialised later, when more kernel
+         * subsystems (like slab allocator) are available.
+         */
+        cma = &cma_areas[cma_area_count];
+        cma->base_pfn = PFN_DOWN(base);
+        cma->count = size >> PAGE_SHIFT;
+        cma->order_per_bit = order_per_bit;
+        *res_cma = cma;
+        cma_area_count++;
+
+        return 0;
+}
+
+/**
  * cma_declare_contiguous() - reserve custom contiguous area
  * @base: Base address of the reserved area optional, use 0 for any
  * @size: Size of the reserved area (in bytes),
@@ -163,7 +213,6 @@ int __init cma_declare_contiguous(phys_addr_t base,
                         phys_addr_t alignment, unsigned int order_per_bit,
                         bool fixed, struct cma **res_cma)
 {
-        struct cma *cma;
         phys_addr_t memblock_end = memblock_end_of_DRAM();
         phys_addr_t highmem_start = __pa(high_memory);
         int ret = 0;
@@ -235,16 +284,9 @@ int __init cma_declare_contiguous(phys_addr_t base,
                 }
         }
 
-        /*
-         * Each reserved area must be initialised later, when more kernel
-         * subsystems (like slab allocator) are available.
-         */
-        cma = &cma_areas[cma_area_count];
-        cma->base_pfn = PFN_DOWN(base);
-        cma->count = size >> PAGE_SHIFT;
-        cma->order_per_bit = order_per_bit;
-        *res_cma = cma;
-        cma_area_count++;
+        ret = cma_init_reserved_mem(base, size, order_per_bit, res_cma);
+        if (ret)
+                goto err;
 
         pr_info("Reserved %ld MiB at %08lx\n", (unsigned long)size / SZ_1M,
                 (unsigned long)base);
diff --git a/mm/memory.c b/mm/memory.c
index e229970e4223..1cc6bfbd872e 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -2053,7 +2053,8 @@ static int do_wp_page(struct mm_struct *mm, struct vm_area_struct *vma,
         old_page = vm_normal_page(vma, address, orig_pte);
         if (!old_page) {
                 /*
-                 * VM_MIXEDMAP !pfn_valid() case
+                 * VM_MIXEDMAP !pfn_valid() case, or VM_SOFTDIRTY clear on a
+                 * VM_PFNMAP VMA.
                  *
                  * We should not cow pages in a shared writeable mapping.
                  * Just mark the pages writable as we can't do any dirty
diff --git a/mm/mmap.c b/mm/mmap.c
index 93d28c7e5420..7f855206e7fb 100644
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -89,6 +89,25 @@ pgprot_t vm_get_page_prot(unsigned long vm_flags)
 }
 EXPORT_SYMBOL(vm_get_page_prot);
 
+static pgprot_t vm_pgprot_modify(pgprot_t oldprot, unsigned long vm_flags)
+{
+        return pgprot_modify(oldprot, vm_get_page_prot(vm_flags));
+}
+
+/* Update vma->vm_page_prot to reflect vma->vm_flags. */
+void vma_set_page_prot(struct vm_area_struct *vma)
+{
+        unsigned long vm_flags = vma->vm_flags;
+
+        vma->vm_page_prot = vm_pgprot_modify(vma->vm_page_prot, vm_flags);
+        if (vma_wants_writenotify(vma)) {
+                vm_flags &= ~VM_SHARED;
+                vma->vm_page_prot = vm_pgprot_modify(vma->vm_page_prot,
+                                                     vm_flags);
+        }
+}
+
+
 int sysctl_overcommit_memory __read_mostly = OVERCOMMIT_GUESS;  /* heuristic overcommit */
 int sysctl_overcommit_ratio __read_mostly = 50; /* default is 50% */
 unsigned long sysctl_overcommit_kbytes __read_mostly;
@@ -1475,11 +1494,16 @@ int vma_wants_writenotify(struct vm_area_struct *vma)
         if (vma->vm_ops && vma->vm_ops->page_mkwrite)
                 return 1;
 
-        /* The open routine did something to the protections already? */
+        /* The open routine did something to the protections that pgprot_modify
+         * won't preserve? */
         if (pgprot_val(vma->vm_page_prot) !=
-            pgprot_val(vm_get_page_prot(vm_flags)))
+            pgprot_val(vm_pgprot_modify(vma->vm_page_prot, vm_flags)))
                 return 0;
 
+        /* Do we need to track softdirty? */
+        if (IS_ENABLED(CONFIG_MEM_SOFT_DIRTY) && !(vm_flags & VM_SOFTDIRTY))
+                return 1;
+
         /* Specialty mapping? */
         if (vm_flags & VM_PFNMAP)
                 return 0;
@@ -1615,21 +1639,6 @@ munmap_back:
                         goto free_vma;
         }
 
-        if (vma_wants_writenotify(vma)) {
-                pgprot_t pprot = vma->vm_page_prot;
-
-                /* Can vma->vm_page_prot have changed??
-                 *
-                 * Answer: Yes, drivers may have changed it in their
-                 *         f_op->mmap method.
-                 *
-                 * Ensures that vmas marked as uncached stay that way.
-                 */
-                vma->vm_page_prot = vm_get_page_prot(vm_flags & ~VM_SHARED);
-                if (pgprot_val(pprot) == pgprot_val(pgprot_noncached(pprot)))
-                        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
-        }
-
         vma_link(mm, vma, prev, rb_link, rb_parent);
         /* Once vma denies write, undo our temporary denial count */
         if (file) {
@@ -1663,6 +1672,8 @@ out:
          */
         vma->vm_flags |= VM_SOFTDIRTY;
 
+        vma_set_page_prot(vma);
+
         return addr;
 
 unmap_and_free_vma:
diff --git a/mm/mprotect.c b/mm/mprotect.c
index c43d557941f8..ace93454ce8e 100644
--- a/mm/mprotect.c
+++ b/mm/mprotect.c
@@ -29,13 +29,6 @@
 #include <asm/cacheflush.h>
 #include <asm/tlbflush.h>
 
-#ifndef pgprot_modify
-static inline pgprot_t pgprot_modify(pgprot_t oldprot, pgprot_t newprot)
-{
-        return newprot;
-}
-#endif
-
 /*
  * For a prot_numa update we only hold mmap_sem for read so there is a
  * potential race with faulting where a pmd was temporarily none. This
@@ -93,7 +86,9 @@ static unsigned long change_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
                                  * Avoid taking write faults for pages we
                                  * know to be dirty.
                                  */
-                                if (dirty_accountable && pte_dirty(ptent))
+                                if (dirty_accountable && pte_dirty(ptent) &&
+                                    (pte_soft_dirty(ptent) ||
+                                     !(vma->vm_flags & VM_SOFTDIRTY)))
                                         ptent = pte_mkwrite(ptent);
                                 ptep_modify_prot_commit(mm, addr, pte, ptent);
                                 updated = true;
@@ -320,13 +315,8 @@ success:
          * held in write mode.
          */
         vma->vm_flags = newflags;
-        vma->vm_page_prot = pgprot_modify(vma->vm_page_prot,
-                                          vm_get_page_prot(newflags));
-
-        if (vma_wants_writenotify(vma)) {
-                vma->vm_page_prot = vm_get_page_prot(newflags & ~VM_SHARED);
-                dirty_accountable = 1;
-        }
+        dirty_accountable = vma_wants_writenotify(vma);
+        vma_set_page_prot(vma);
 
         change_protection(vma, start, end, vma->vm_page_prot,
                           dirty_accountable, 0);
diff --git a/mm/slab.c b/mm/slab.c
index 154aac8411c5..eb2b2ea30130 100644
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -1992,7 +1992,7 @@ static struct array_cache __percpu *alloc_kmem_cache_cpus(
         struct array_cache __percpu *cpu_cache;
 
         size = sizeof(void *) * entries + sizeof(struct array_cache);
-        cpu_cache = __alloc_percpu(size, 0);
+        cpu_cache = __alloc_percpu(size, sizeof(void *));
 
         if (!cpu_cache)
                 return NULL;