17 files changed, 150 insertions, 136 deletions

diff --git a/mm/backing-dev.c b/mm/backing-dev.c
index 84b2dc76f140..b5f940ce0143 100644
--- a/mm/backing-dev.c
+++ b/mm/backing-dev.c
@@ -882,13 +882,10 @@ int bdi_register_va(struct backing_dev_info *bdi, const char *fmt, va_list args)
         if (IS_ERR(dev))
                 return PTR_ERR(dev);
 
-        if (bdi_debug_register(bdi, dev_name(dev))) {
-                device_destroy(bdi_class, dev->devt);
-                return -ENOMEM;
-        }
         cgwb_bdi_register(bdi);
         bdi->dev = dev;
 
+        bdi_debug_register(bdi, dev_name(dev));
         set_bit(WB_registered, &bdi->wb.state);
 
         spin_lock_bh(&bdi_lock);
diff --git a/mm/early_ioremap.c b/mm/early_ioremap.c
index d04ac1ec0559..1826f191e72c 100644
--- a/mm/early_ioremap.c
+++ b/mm/early_ioremap.c
@@ -111,7 +111,7 @@ __early_ioremap(resource_size_t phys_addr, unsigned long size, pgprot_t prot)
         enum fixed_addresses idx;
         int i, slot;
 
-        WARN_ON(system_state != SYSTEM_BOOTING);
+        WARN_ON(system_state >= SYSTEM_RUNNING);
 
         slot = -1;
         for (i = 0; i < FIX_BTMAPS_SLOTS; i++) {
diff --git a/mm/frame_vector.c b/mm/frame_vector.c
index 297c7238f7d4..c64dca6e27c2 100644
--- a/mm/frame_vector.c
+++ b/mm/frame_vector.c
@@ -62,8 +62,10 @@ int get_vaddr_frames(unsigned long start, unsigned int nr_frames,
          * get_user_pages_longterm() and disallow it for filesystem-dax
          * mappings.
          */
-        if (vma_is_fsdax(vma))
-                return -EOPNOTSUPP;
+        if (vma_is_fsdax(vma)) {
+                ret = -EOPNOTSUPP;
+                goto out;
+        }
 
         if (!(vma->vm_flags & (VM_IO | VM_PFNMAP))) {
                 vec->got_ref = true;
diff --git a/mm/gup.c b/mm/gup.c
index d3fb60e5bfac..3affe7544b0c 100644
--- a/mm/gup.c
+++ b/mm/gup.c
@@ -66,7 +66,7 @@ static int follow_pfn_pte(struct vm_area_struct *vma, unsigned long address,
  */
 static inline bool can_follow_write_pte(pte_t pte, unsigned int flags)
 {
-        return pte_access_permitted(pte, WRITE) ||
+        return pte_write(pte) ||
                 ((flags & FOLL_FORCE) && (flags & FOLL_COW) && pte_dirty(pte));
 }
 
@@ -1410,7 +1410,6 @@ static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end,
 
                 VM_BUG_ON_PAGE(compound_head(page) != head, page);
 
-                put_dev_pagemap(pgmap);
                 SetPageReferenced(page);
                 pages[*nr] = page;
                 (*nr)++;
@@ -1420,6 +1419,8 @@ static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end,
         ret = 1;
 
 pte_unmap:
+        if (pgmap)
+                put_dev_pagemap(pgmap);
         pte_unmap(ptem);
         return ret;
 }
@@ -1459,10 +1460,12 @@ static int __gup_device_huge(unsigned long pfn, unsigned long addr,
                 SetPageReferenced(page);
                 pages[*nr] = page;
                 get_page(page);
-                put_dev_pagemap(pgmap);
                 (*nr)++;
                 pfn++;
         } while (addr += PAGE_SIZE, addr != end);
+
+        if (pgmap)
+                put_dev_pagemap(pgmap);
         return 1;
 }
 
diff --git a/mm/hmm.c b/mm/hmm.c
index 3a5c172af560..320fdc87f064 100644
--- a/mm/hmm.c
+++ b/mm/hmm.c
@@ -391,11 +391,11 @@ again:
                 if (pmd_protnone(pmd))
                         return hmm_vma_walk_clear(start, end, walk);
 
-                if (!pmd_access_permitted(pmd, write_fault))
+                if (write_fault && !pmd_write(pmd))
                         return hmm_vma_walk_clear(start, end, walk);
 
                 pfn = pmd_pfn(pmd) + pte_index(addr);
-                flag |= pmd_access_permitted(pmd, WRITE) ? HMM_PFN_WRITE : 0;
+                flag |= pmd_write(pmd) ? HMM_PFN_WRITE : 0;
                 for (; addr < end; addr += PAGE_SIZE, i++, pfn++)
                         pfns[i] = hmm_pfn_t_from_pfn(pfn) | flag;
                 return 0;
@@ -456,11 +456,11 @@ again:
                         continue;
                 }
 
-                if (!pte_access_permitted(pte, write_fault))
+                if (write_fault && !pte_write(pte))
                         goto fault;
 
                 pfns[i] = hmm_pfn_t_from_pfn(pte_pfn(pte)) | flag;
-                pfns[i] |= pte_access_permitted(pte, WRITE) ? HMM_PFN_WRITE : 0;
+                pfns[i] |= pte_write(pte) ? HMM_PFN_WRITE : 0;
                 continue;
 
 fault:
@@ -838,10 +838,10 @@ static void hmm_devmem_release(struct device *dev, void *data)
 
         mem_hotplug_begin();
         if (resource->desc == IORES_DESC_DEVICE_PRIVATE_MEMORY)
-                __remove_pages(zone, start_pfn, npages);
+                __remove_pages(zone, start_pfn, npages, NULL);
         else
                 arch_remove_memory(start_pfn << PAGE_SHIFT,
-                                   npages << PAGE_SHIFT);
+                                   npages << PAGE_SHIFT, NULL);
         mem_hotplug_done();
 
         hmm_devmem_radix_release(resource);
@@ -882,7 +882,7 @@ static int hmm_devmem_pages_create(struct hmm_devmem *devmem)
         else
                 devmem->pagemap.type = MEMORY_DEVICE_PRIVATE;
 
-        devmem->pagemap.res = devmem->resource;
+        devmem->pagemap.res = *devmem->resource;
         devmem->pagemap.page_fault = hmm_devmem_fault;
         devmem->pagemap.page_free = hmm_devmem_free;
         devmem->pagemap.dev = devmem->device;
@@ -931,17 +931,18 @@ static int hmm_devmem_pages_create(struct hmm_devmem *devmem)
          * want the linear mapping and thus use arch_add_memory().
          */
         if (devmem->pagemap.type == MEMORY_DEVICE_PUBLIC)
-                ret = arch_add_memory(nid, align_start, align_size, false);
+                ret = arch_add_memory(nid, align_start, align_size, NULL,
+                                false);
         else
                 ret = add_pages(nid, align_start >> PAGE_SHIFT,
-                                align_size >> PAGE_SHIFT, false);
+                                align_size >> PAGE_SHIFT, NULL, false);
         if (ret) {
                 mem_hotplug_done();
                 goto error_add_memory;
         }
         move_pfn_range_to_zone(&NODE_DATA(nid)->node_zones[ZONE_DEVICE],
                                 align_start >> PAGE_SHIFT,
-                                align_size >> PAGE_SHIFT);
+                                align_size >> PAGE_SHIFT, NULL);
         mem_hotplug_done();
 
         for (pfn = devmem->pfn_first; pfn < devmem->pfn_last; pfn++) {
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index 2f2f5e774902..0e7ded98d114 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -870,7 +870,7 @@ struct page *follow_devmap_pmd(struct vm_area_struct *vma, unsigned long addr,
          */
         WARN_ONCE(flags & FOLL_COW, "mm: In follow_devmap_pmd with FOLL_COW set");
 
-        if (!pmd_access_permitted(*pmd, flags & FOLL_WRITE))
+        if (flags & FOLL_WRITE && !pmd_write(*pmd))
                 return NULL;
 
         if (pmd_present(*pmd) && pmd_devmap(*pmd))
@@ -1012,7 +1012,7 @@ struct page *follow_devmap_pud(struct vm_area_struct *vma, unsigned long addr,
 
         assert_spin_locked(pud_lockptr(mm, pud));
 
-        if (!pud_access_permitted(*pud, flags & FOLL_WRITE))
+        if (flags & FOLL_WRITE && !pud_write(*pud))
                 return NULL;
 
         if (pud_present(*pud) && pud_devmap(*pud))
@@ -1386,7 +1386,7 @@ out_unlock:
  */
 static inline bool can_follow_write_pmd(pmd_t pmd, unsigned int flags)
 {
-        return pmd_access_permitted(pmd, WRITE) ||
+        return pmd_write(pmd) ||
                ((flags & FOLL_FORCE) && (flags & FOLL_COW) && pmd_dirty(pmd));
 }
 
diff --git a/mm/kmemcheck.c b/mm/kmemcheck.c
deleted file mode 100644
index cec594032515..000000000000
--- a/mm/kmemcheck.c
+++ /dev/null
@@ -1 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
diff --git a/mm/kmemleak.c b/mm/kmemleak.c
index 3d4781756d50..d73c14294f3a 100644
--- a/mm/kmemleak.c
+++ b/mm/kmemleak.c
@@ -1523,7 +1523,7 @@ static void kmemleak_scan(void)
                         if (page_count(page) == 0)
                                 continue;
                         scan_block(page, page + 1, NULL);
-                        if (!(pfn % (MAX_SCAN_SIZE / sizeof(*page))))
+                        if (!(pfn & 63))
                                 cond_resched();
                 }
         }
diff --git a/mm/memory.c b/mm/memory.c
index 5eb3d2524bdc..46b6c33b7f04 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -1897,12 +1897,26 @@ int vm_insert_pfn_prot(struct vm_area_struct *vma, unsigned long addr,
 }
 EXPORT_SYMBOL(vm_insert_pfn_prot);
 
+static bool vm_mixed_ok(struct vm_area_struct *vma, pfn_t pfn)
+{
+        /* these checks mirror the abort conditions in vm_normal_page */
+        if (vma->vm_flags & VM_MIXEDMAP)
+                return true;
+        if (pfn_t_devmap(pfn))
+                return true;
+        if (pfn_t_special(pfn))
+                return true;
+        if (is_zero_pfn(pfn_t_to_pfn(pfn)))
+                return true;
+        return false;
+}
+
 static int __vm_insert_mixed(struct vm_area_struct *vma, unsigned long addr,
                         pfn_t pfn, bool mkwrite)
 {
         pgprot_t pgprot = vma->vm_page_prot;
 
-        BUG_ON(!(vma->vm_flags & VM_MIXEDMAP));
+        BUG_ON(!vm_mixed_ok(vma, pfn));
 
         if (addr < vma->vm_start || addr >= vma->vm_end)
                 return -EFAULT;
@@ -3831,7 +3845,8 @@ static inline int create_huge_pmd(struct vm_fault *vmf)
         return VM_FAULT_FALLBACK;
 }
 
-static int wp_huge_pmd(struct vm_fault *vmf, pmd_t orig_pmd)
+/* `inline' is required to avoid gcc 4.1.2 build error */
+static inline int wp_huge_pmd(struct vm_fault *vmf, pmd_t orig_pmd)
 {
         if (vma_is_anonymous(vmf->vma))
                 return do_huge_pmd_wp_page(vmf, orig_pmd);
@@ -3948,7 +3963,7 @@ static int handle_pte_fault(struct vm_fault *vmf)
         if (unlikely(!pte_same(*vmf->pte, entry)))
                 goto unlock;
         if (vmf->flags & FAULT_FLAG_WRITE) {
-                if (!pte_access_permitted(entry, WRITE))
+                if (!pte_write(entry))
                         return do_wp_page(vmf);
                 entry = pte_mkdirty(entry);
         }
@@ -4013,7 +4028,7 @@ static int __handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
 
                         /* NUMA case for anonymous PUDs would go here */
 
-                        if (dirty && !pud_access_permitted(orig_pud, WRITE)) {
+                        if (dirty && !pud_write(orig_pud)) {
                                 ret = wp_huge_pud(&vmf, orig_pud);
                                 if (!(ret & VM_FAULT_FALLBACK))
                                         return ret;
@@ -4046,7 +4061,7 @@ static int __handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
                         if (pmd_protnone(orig_pmd) && vma_is_accessible(vma))
                                 return do_huge_pmd_numa_page(&vmf, orig_pmd);
 
-                        if (dirty && !pmd_access_permitted(orig_pmd, WRITE)) {
+                        if (dirty && !pmd_write(orig_pmd)) {
                                 ret = wp_huge_pmd(&vmf, orig_pmd);
                                 if (!(ret & VM_FAULT_FALLBACK))
                                         return ret;
@@ -4336,7 +4351,7 @@ int follow_phys(struct vm_area_struct *vma,
                 goto out;
         pte = *ptep;
 
-        if (!pte_access_permitted(pte, flags & FOLL_WRITE))
+        if ((flags & FOLL_WRITE) && !pte_write(pte))
                 goto unlock;
 
         *prot = pgprot_val(pte_pgprot(pte));
diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index c52aa05b106c..12df8a5fadcc 100644
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -250,7 +250,7 @@ void __init register_page_bootmem_info_node(struct pglist_data *pgdat)
 #endif /* CONFIG_HAVE_BOOTMEM_INFO_NODE */
 
 static int __meminit __add_section(int nid, unsigned long phys_start_pfn,
-                bool want_memblock)
+                struct vmem_altmap *altmap, bool want_memblock)
 {
         int ret;
         int i;
@@ -258,7 +258,7 @@ static int __meminit __add_section(int nid, unsigned long phys_start_pfn,
         if (pfn_valid(phys_start_pfn))
                 return -EEXIST;
 
-        ret = sparse_add_one_section(NODE_DATA(nid), phys_start_pfn);
+        ret = sparse_add_one_section(NODE_DATA(nid), phys_start_pfn, altmap);
         if (ret < 0)
                 return ret;
 
@@ -292,18 +292,17 @@ static int __meminit __add_section(int nid, unsigned long phys_start_pfn,
  * add the new pages.
  */
 int __ref __add_pages(int nid, unsigned long phys_start_pfn,
-                        unsigned long nr_pages, bool want_memblock)
+                unsigned long nr_pages, struct vmem_altmap *altmap,
+                bool want_memblock)
 {
         unsigned long i;
         int err = 0;
         int start_sec, end_sec;
-        struct vmem_altmap *altmap;
 
         /* during initialize mem_map, align hot-added range to section */
         start_sec = pfn_to_section_nr(phys_start_pfn);
         end_sec = pfn_to_section_nr(phys_start_pfn + nr_pages - 1);
 
-        altmap = to_vmem_altmap((unsigned long) pfn_to_page(phys_start_pfn));
         if (altmap) {
                 /*
                  * Validate altmap is within bounds of the total request
@@ -318,7 +317,8 @@ int __ref __add_pages(int nid, unsigned long phys_start_pfn,
         }
 
         for (i = start_sec; i <= end_sec; i++) {
-                err = __add_section(nid, section_nr_to_pfn(i), want_memblock);
+                err = __add_section(nid, section_nr_to_pfn(i), altmap,
+                                want_memblock);
 
                 /*
                  * EEXIST is finally dealt with by ioresource collision
@@ -334,7 +334,6 @@ int __ref __add_pages(int nid, unsigned long phys_start_pfn,
 out:
         return err;
 }
-EXPORT_SYMBOL_GPL(__add_pages);
 
 #ifdef CONFIG_MEMORY_HOTREMOVE
 /* find the smallest valid pfn in the range [start_pfn, end_pfn) */
@@ -537,7 +536,7 @@ static void __remove_zone(struct zone *zone, unsigned long start_pfn)
 }
 
 static int __remove_section(struct zone *zone, struct mem_section *ms,
-                unsigned long map_offset)
+                unsigned long map_offset, struct vmem_altmap *altmap)
 {
         unsigned long start_pfn;
         int scn_nr;
@@ -554,7 +553,7 @@ static int __remove_section(struct zone *zone, struct mem_section *ms,
         start_pfn = section_nr_to_pfn((unsigned long)scn_nr);
         __remove_zone(zone, start_pfn);
 
-        sparse_remove_one_section(zone, ms, map_offset);
+        sparse_remove_one_section(zone, ms, map_offset, altmap);
         return 0;
 }
 
@@ -570,7 +569,7 @@ static int __remove_section(struct zone *zone, struct mem_section *ms,
  * calling offline_pages().
  */
 int __remove_pages(struct zone *zone, unsigned long phys_start_pfn,
-                 unsigned long nr_pages)
+                 unsigned long nr_pages, struct vmem_altmap *altmap)
 {
         unsigned long i;
         unsigned long map_offset = 0;
@@ -578,10 +577,6 @@ int __remove_pages(struct zone *zone, unsigned long phys_start_pfn,
 
         /* In the ZONE_DEVICE case device driver owns the memory region */
         if (is_dev_zone(zone)) {
-                struct page *page = pfn_to_page(phys_start_pfn);
-                struct vmem_altmap *altmap;
-
-                altmap = to_vmem_altmap((unsigned long) page);
                 if (altmap)
                         map_offset = vmem_altmap_offset(altmap);
         } else {
@@ -612,7 +607,8 @@ int __remove_pages(struct zone *zone, unsigned long phys_start_pfn,
         for (i = 0; i < sections_to_remove; i++) {
                 unsigned long pfn = phys_start_pfn + i*PAGES_PER_SECTION;
 
-                ret = __remove_section(zone, __pfn_to_section(pfn), map_offset);
+                ret = __remove_section(zone, __pfn_to_section(pfn), map_offset,
+                                altmap);
                 map_offset = 0;
                 if (ret)
                         break;
@@ -802,8 +798,8 @@ static void __meminit resize_pgdat_range(struct pglist_data *pgdat, unsigned lon
         pgdat->node_spanned_pages = max(start_pfn + nr_pages, old_end_pfn) - pgdat->node_start_pfn;
 }
 
-void __ref move_pfn_range_to_zone(struct zone *zone,
-                unsigned long start_pfn, unsigned long nr_pages)
+void __ref move_pfn_range_to_zone(struct zone *zone, unsigned long start_pfn,
+                unsigned long nr_pages, struct vmem_altmap *altmap)
 {
         struct pglist_data *pgdat = zone->zone_pgdat;
         int nid = pgdat->node_id;
@@ -828,7 +824,8 @@ void __ref move_pfn_range_to_zone(struct zone *zone,
          * expects the zone spans the pfn range. All the pages in the range
          * are reserved so nobody should be touching them so we should be safe
          */
-        memmap_init_zone(nr_pages, nid, zone_idx(zone), start_pfn, MEMMAP_HOTPLUG);
+        memmap_init_zone(nr_pages, nid, zone_idx(zone), start_pfn,
+                        MEMMAP_HOTPLUG, altmap);
 
         set_zone_contiguous(zone);
 }
@@ -900,7 +897,7 @@ static struct zone * __meminit move_pfn_range(int online_type, int nid,
         struct zone *zone;
 
         zone = zone_for_pfn_range(online_type, nid, start_pfn, nr_pages);
-        move_pfn_range_to_zone(zone, start_pfn, nr_pages);
+        move_pfn_range_to_zone(zone, start_pfn, nr_pages, NULL);
         return zone;
 }
 
@@ -1149,7 +1146,7 @@ int __ref add_memory_resource(int nid, struct resource *res, bool online)
         }
 
         /* call arch's memory hotadd */
-        ret = arch_add_memory(nid, start, size, true);
+        ret = arch_add_memory(nid, start, size, NULL, true);
 
         if (ret < 0)
                 goto error;
@@ -1891,7 +1888,7 @@ void __ref remove_memory(int nid, u64 start, u64 size)
         memblock_free(start, size);
         memblock_remove(start, size);
 
-        arch_remove_memory(start, size);
+        arch_remove_memory(start, size, NULL);
 
         try_offline_node(nid);
 
diff --git a/mm/mmap.c b/mm/mmap.c
index a4d546821214..9efdc021ad22 100644
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -3019,20 +3019,20 @@ void exit_mmap(struct mm_struct *mm)
         /* Use -1 here to ensure all VMAs in the mm are unmapped */
         unmap_vmas(&tlb, vma, 0, -1);
 
-        set_bit(MMF_OOM_SKIP, &mm->flags);
-        if (unlikely(tsk_is_oom_victim(current))) {
+        if (unlikely(mm_is_oom_victim(mm))) {
                 /*
                  * Wait for oom_reap_task() to stop working on this
                  * mm. Because MMF_OOM_SKIP is already set before
                  * calling down_read(), oom_reap_task() will not run
                  * on this "mm" post up_write().
                  *
-                 * tsk_is_oom_victim() cannot be set from under us
-                 * either because current->mm is already set to NULL
+                 * mm_is_oom_victim() cannot be set from under us
+                 * either because victim->mm is already set to NULL
                  * under task_lock before calling mmput and oom_mm is
-                 * set not NULL by the OOM killer only if current->mm
+                 * set not NULL by the OOM killer only if victim->mm
                  * is found not NULL while holding the task_lock.
                  */
+                set_bit(MMF_OOM_SKIP, &mm->flags);
                 down_write(&mm->mmap_sem);
                 up_write(&mm->mmap_sem);
         }
diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index c957be32b27a..29f855551efe 100644
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -683,8 +683,10 @@ static void mark_oom_victim(struct task_struct *tsk)
                 return;
 
         /* oom_mm is bound to the signal struct life time. */
-        if (!cmpxchg(&tsk->signal->oom_mm, NULL, mm))
+        if (!cmpxchg(&tsk->signal->oom_mm, NULL, mm)) {
                 mmgrab(tsk->signal->oom_mm);
+                set_bit(MMF_OOM_VICTIM, &mm->flags);
+        }
 
         /*
          * Make sure that the task is woken up from uninterruptible sleep
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 73f5d4556b3d..1748dd4a4b1b 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -2684,6 +2684,7 @@ void free_unref_page_list(struct list_head *list)
 {
         struct page *page, *next;
         unsigned long flags, pfn;
+        int batch_count = 0;
 
         /* Prepare pages for freeing */
         list_for_each_entry_safe(page, next, list, lru) {
@@ -2700,6 +2701,16 @@ void free_unref_page_list(struct list_head *list)
                 set_page_private(page, 0);
                 trace_mm_page_free_batched(page);
                 free_unref_page_commit(page, pfn);
+
+                /*
+                 * Guard against excessive IRQ disabled times when we get
+                 * a large list of pages to free.
+                 */
+                if (++batch_count == SWAP_CLUSTER_MAX) {
+                        local_irq_restore(flags);
+                        batch_count = 0;
+                        local_irq_save(flags);
+                }
         }
         local_irq_restore(flags);
 }
@@ -5303,9 +5314,9 @@ void __ref build_all_zonelists(pg_data_t *pgdat)
  * done. Non-atomic initialization, single-pass.
  */
 void __meminit memmap_init_zone(unsigned long size, int nid, unsigned long zone,
-                unsigned long start_pfn, enum memmap_context context)
+                unsigned long start_pfn, enum memmap_context context,
+                struct vmem_altmap *altmap)
 {
-        struct vmem_altmap *altmap = to_vmem_altmap(__pfn_to_phys(start_pfn));
         unsigned long end_pfn = start_pfn + size;
         pg_data_t *pgdat = NODE_DATA(nid);
         unsigned long pfn;
@@ -5406,7 +5417,7 @@ static void __meminit zone_init_free_lists(struct zone *zone)
 
 #ifndef __HAVE_ARCH_MEMMAP_INIT
 #define memmap_init(size, nid, zone, start_pfn) \
-        memmap_init_zone((size), (nid), (zone), (start_pfn), MEMMAP_EARLY)
+        memmap_init_zone((size), (nid), (zone), (start_pfn), MEMMAP_EARLY, NULL)
 #endif
 
 static int zone_batchsize(struct zone *zone)
diff --git a/mm/percpu.c b/mm/percpu.c
index 79e3549cab0f..50e7fdf84055 100644
--- a/mm/percpu.c
+++ b/mm/percpu.c
@@ -2719,7 +2719,11 @@ void __init setup_per_cpu_areas(void)
 
         if (pcpu_setup_first_chunk(ai, fc) < 0)
                 panic("Failed to initialize percpu areas.");
+#ifdef CONFIG_CRIS
+#warning "the CRIS architecture has physical and virtual addresses confused"
+#else
         pcpu_free_alloc_info(ai);
+#endif
 }
 
 #endif  /* CONFIG_SMP */
diff --git a/mm/slab.c b/mm/slab.c
index 183e996dde5f..4e51ef954026 100644
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -1584,11 +1584,8 @@ static void print_objinfo(struct kmem_cache *cachep, void *objp, int lines)
                        *dbg_redzone2(cachep, objp));
         }
 
-        if (cachep->flags & SLAB_STORE_USER) {
-                pr_err("Last user: [<%p>](%pSR)\n",
-                       *dbg_userword(cachep, objp),
-                       *dbg_userword(cachep, objp));
-        }
+        if (cachep->flags & SLAB_STORE_USER)
+                pr_err("Last user: (%pSR)\n", *dbg_userword(cachep, objp));
         realobj = (char *)objp + obj_offset(cachep);
         size = cachep->object_size;
         for (i = 0; i < size && lines; i += 16, lines--) {
@@ -1621,7 +1618,7 @@ static void check_poison_obj(struct kmem_cache *cachep, void *objp)
                         /* Mismatch ! */
                         /* Print header */
                         if (lines == 0) {
-                                pr_err("Slab corruption (%s): %s start=%p, len=%d\n",
+                                pr_err("Slab corruption (%s): %s start=%px, len=%d\n",
                                        print_tainted(), cachep->name,
                                        realobj, size);
                                 print_objinfo(cachep, objp, 0);
@@ -1650,13 +1647,13 @@ static void check_poison_obj(struct kmem_cache *cachep, void *objp)
                 if (objnr) {
                         objp = index_to_obj(cachep, page, objnr - 1);
                         realobj = (char *)objp + obj_offset(cachep);
-                        pr_err("Prev obj: start=%p, len=%d\n", realobj, size);
+                        pr_err("Prev obj: start=%px, len=%d\n", realobj, size);
                         print_objinfo(cachep, objp, 2);
                 }
                 if (objnr + 1 < cachep->num) {
                         objp = index_to_obj(cachep, page, objnr + 1);
                         realobj = (char *)objp + obj_offset(cachep);
-                        pr_err("Next obj: start=%p, len=%d\n", realobj, size);
+                        pr_err("Next obj: start=%px, len=%d\n", realobj, size);
                         print_objinfo(cachep, objp, 2);
                 }
         }
@@ -2608,7 +2605,7 @@ static void slab_put_obj(struct kmem_cache *cachep,
         /* Verify double free bug */
         for (i = page->active; i < cachep->num; i++) {
                 if (get_free_obj(page, i) == objnr) {
-                        pr_err("slab: double free detected in cache '%s', objp %p\n",
+                        pr_err("slab: double free detected in cache '%s', objp %px\n",
                                cachep->name, objp);
                         BUG();
                 }
@@ -2772,7 +2769,7 @@ static inline void verify_redzone_free(struct kmem_cache *cache, void *obj)
         else
                 slab_error(cache, "memory outside object was overwritten");
 
-        pr_err("%p: redzone 1:0x%llx, redzone 2:0x%llx\n",
+        pr_err("%px: redzone 1:0x%llx, redzone 2:0x%llx\n",
                obj, redzone1, redzone2);
 }
 
@@ -3078,7 +3075,7 @@ static void *cache_alloc_debugcheck_after(struct kmem_cache *cachep,
                 if (*dbg_redzone1(cachep, objp) != RED_INACTIVE ||
                                 *dbg_redzone2(cachep, objp) != RED_INACTIVE) {
                         slab_error(cachep, "double free, or memory outside object was overwritten");
-                        pr_err("%p: redzone 1:0x%llx, redzone 2:0x%llx\n",
+                        pr_err("%px: redzone 1:0x%llx, redzone 2:0x%llx\n",
                                objp, *dbg_redzone1(cachep, objp),
                                *dbg_redzone2(cachep, objp));
                 }
@@ -3091,7 +3088,7 @@ static void *cache_alloc_debugcheck_after(struct kmem_cache *cachep,
                 cachep->ctor(objp);
         if (ARCH_SLAB_MINALIGN &&
             ((unsigned long)objp & (ARCH_SLAB_MINALIGN-1))) {
-                pr_err("0x%p: not aligned to ARCH_SLAB_MINALIGN=%d\n",
+                pr_err("0x%px: not aligned to ARCH_SLAB_MINALIGN=%d\n",
                        objp, (int)ARCH_SLAB_MINALIGN);
         }
         return objp;
@@ -4283,7 +4280,7 @@ static void show_symbol(struct seq_file *m, unsigned long address)
                 return;
         }
 #endif
-        seq_printf(m, "%p", (void *)address);
+        seq_printf(m, "%px", (void *)address);
 }
 
 static int leaks_show(struct seq_file *m, void *p)
diff --git a/mm/sparse-vmemmap.c b/mm/sparse-vmemmap.c
index 17acf01791fa..bd0276d5f66b 100644
--- a/mm/sparse-vmemmap.c
+++ b/mm/sparse-vmemmap.c
@@ -74,7 +74,7 @@ void * __meminit vmemmap_alloc_block(unsigned long size, int node)
 }
 
 /* need to make sure size is all the same during early stage */
-static void * __meminit alloc_block_buf(unsigned long size, int node)
+void * __meminit vmemmap_alloc_block_buf(unsigned long size, int node)
 {
         void *ptr;
 
@@ -107,33 +107,16 @@ static unsigned long __meminit vmem_altmap_nr_free(struct vmem_altmap *altmap)
 }
 
 /**
- * vmem_altmap_alloc - allocate pages from the vmem_altmap reservation
- * @altmap - reserved page pool for the allocation
- * @nr_pfns - size (in pages) of the allocation
+ * altmap_alloc_block_buf - allocate pages from the device page map
+ * @altmap:     device page map
+ * @size:       size (in bytes) of the allocation
  *
- * Allocations are aligned to the size of the request
+ * Allocations are aligned to the size of the request.
  */
-static unsigned long __meminit vmem_altmap_alloc(struct vmem_altmap *altmap,
-                unsigned long nr_pfns)
-{
-        unsigned long pfn = vmem_altmap_next_pfn(altmap);
-        unsigned long nr_align;
-
-        nr_align = 1UL << find_first_bit(&nr_pfns, BITS_PER_LONG);
-        nr_align = ALIGN(pfn, nr_align) - pfn;
-
-        if (nr_pfns + nr_align > vmem_altmap_nr_free(altmap))
-                return ULONG_MAX;
-        altmap->alloc += nr_pfns;
-        altmap->align += nr_align;
-        return pfn + nr_align;
-}
-
-static void * __meminit altmap_alloc_block_buf(unsigned long size,
+void * __meminit altmap_alloc_block_buf(unsigned long size,
                 struct vmem_altmap *altmap)
 {
-        unsigned long pfn, nr_pfns;
-        void *ptr;
+        unsigned long pfn, nr_pfns, nr_align;
 
         if (size & ~PAGE_MASK) {
                 pr_warn_once("%s: allocations must be multiple of PAGE_SIZE (%ld)\n",
@@ -141,25 +124,20 @@ static void * __meminit altmap_alloc_block_buf(unsigned long size,
                 return NULL;
         }
 
+        pfn = vmem_altmap_next_pfn(altmap);
         nr_pfns = size >> PAGE_SHIFT;
-        pfn = vmem_altmap_alloc(altmap, nr_pfns);
-        if (pfn < ULONG_MAX)
-                ptr = __va(__pfn_to_phys(pfn));
-        else
-                ptr = NULL;
-        pr_debug("%s: pfn: %#lx alloc: %ld align: %ld nr: %#lx\n",
-                        __func__, pfn, altmap->alloc, altmap->align, nr_pfns);
+        nr_align = 1UL << find_first_bit(&nr_pfns, BITS_PER_LONG);
+        nr_align = ALIGN(pfn, nr_align) - pfn;
+        if (nr_pfns + nr_align > vmem_altmap_nr_free(altmap))
+                return NULL;
 
-        return ptr;
-}
+        altmap->alloc += nr_pfns;
+        altmap->align += nr_align;
+        pfn += nr_align;
 
-/* need to make sure size is all the same during early stage */
-void * __meminit __vmemmap_alloc_block_buf(unsigned long size, int node,
-                struct vmem_altmap *altmap)
-{
-        if (altmap)
-                return altmap_alloc_block_buf(size, altmap);
-        return alloc_block_buf(size, node);
+        pr_debug("%s: pfn: %#lx alloc: %ld align: %ld nr: %#lx\n",
+                        __func__, pfn, altmap->alloc, altmap->align, nr_pfns);
+        return __va(__pfn_to_phys(pfn));
 }
 
 void __meminit vmemmap_verify(pte_t *pte, int node,
@@ -178,7 +156,7 @@ pte_t * __meminit vmemmap_pte_populate(pmd_t *pmd, unsigned long addr, int node)
         pte_t *pte = pte_offset_kernel(pmd, addr);
         if (pte_none(*pte)) {
                 pte_t entry;
-                void *p = alloc_block_buf(PAGE_SIZE, node);
+                void *p = vmemmap_alloc_block_buf(PAGE_SIZE, node);
                 if (!p)
                         return NULL;
                 entry = pfn_pte(__pa(p) >> PAGE_SHIFT, PAGE_KERNEL);
@@ -278,7 +256,8 @@ int __meminit vmemmap_populate_basepages(unsigned long start,
         return 0;
 }
 
-struct page * __meminit sparse_mem_map_populate(unsigned long pnum, int nid)
+struct page * __meminit sparse_mem_map_populate(unsigned long pnum, int nid,
+                struct vmem_altmap *altmap)
 {
         unsigned long start;
         unsigned long end;
@@ -288,7 +267,7 @@ struct page * __meminit sparse_mem_map_populate(unsigned long pnum, int nid)
         start = (unsigned long)map;
         end = (unsigned long)(map + PAGES_PER_SECTION);
 
-        if (vmemmap_populate(start, end, nid))
+        if (vmemmap_populate(start, end, nid, altmap))
                 return NULL;
 
         return map;
@@ -318,7 +297,7 @@ void __init sparse_mem_maps_populate_node(struct page **map_map,
                 if (!present_section_nr(pnum))
                         continue;
 
-                map_map[pnum] = sparse_mem_map_populate(pnum, nodeid);
+                map_map[pnum] = sparse_mem_map_populate(pnum, nodeid, NULL);
                 if (map_map[pnum])
                         continue;
                 ms = __nr_to_section(pnum);
diff --git a/mm/sparse.c b/mm/sparse.c
index 7a5dacaa06e3..06130c13dc99 100644
--- a/mm/sparse.c
+++ b/mm/sparse.c
@@ -417,7 +417,8 @@ static void __init sparse_early_usemaps_alloc_node(void *data,
 }
 
 #ifndef CONFIG_SPARSEMEM_VMEMMAP
-struct page __init *sparse_mem_map_populate(unsigned long pnum, int nid)
+struct page __init *sparse_mem_map_populate(unsigned long pnum, int nid,
+                struct vmem_altmap *altmap)
 {
         struct page *map;
         unsigned long size;
@@ -472,7 +473,7 @@ void __init sparse_mem_maps_populate_node(struct page **map_map,
 
                 if (!present_section_nr(pnum))
                         continue;
-                map_map[pnum] = sparse_mem_map_populate(pnum, nodeid);
+                map_map[pnum] = sparse_mem_map_populate(pnum, nodeid, NULL);
                 if (map_map[pnum])
                         continue;
                 ms = __nr_to_section(pnum);
@@ -500,7 +501,7 @@ static struct page __init *sparse_early_mem_map_alloc(unsigned long pnum)
         struct mem_section *ms = __nr_to_section(pnum);
         int nid = sparse_early_nid(ms);
 
-        map = sparse_mem_map_populate(pnum, nid);
+        map = sparse_mem_map_populate(pnum, nid, NULL);
         if (map)
                 return map;
 
@@ -678,17 +679,19 @@ void offline_mem_sections(unsigned long start_pfn, unsigned long end_pfn)
 #endif
 
 #ifdef CONFIG_SPARSEMEM_VMEMMAP
-static inline struct page *kmalloc_section_memmap(unsigned long pnum, int nid)
+static inline struct page *kmalloc_section_memmap(unsigned long pnum, int nid,
+                struct vmem_altmap *altmap)
 {
         /* This will make the necessary allocations eventually. */
-        return sparse_mem_map_populate(pnum, nid);
+        return sparse_mem_map_populate(pnum, nid, altmap);
 }
-static void __kfree_section_memmap(struct page *memmap)
+static void __kfree_section_memmap(struct page *memmap,
+                struct vmem_altmap *altmap)
 {
         unsigned long start = (unsigned long)memmap;
         unsigned long end = (unsigned long)(memmap + PAGES_PER_SECTION);
 
-        vmemmap_free(start, end);
+        vmemmap_free(start, end, altmap);
 }
 #ifdef CONFIG_MEMORY_HOTREMOVE
 static void free_map_bootmem(struct page *memmap)
@@ -696,7 +699,7 @@ static void free_map_bootmem(struct page *memmap)
         unsigned long start = (unsigned long)memmap;
         unsigned long end = (unsigned long)(memmap + PAGES_PER_SECTION);
 
-        vmemmap_free(start, end);
+        vmemmap_free(start, end, NULL);
 }
 #endif /* CONFIG_MEMORY_HOTREMOVE */
 #else
@@ -721,12 +724,14 @@ got_map_ptr:
         return ret;
 }
 
-static inline struct page *kmalloc_section_memmap(unsigned long pnum, int nid)
+static inline struct page *kmalloc_section_memmap(unsigned long pnum, int nid,
+                struct vmem_altmap *altmap)
 {
         return __kmalloc_section_memmap();
 }
 
-static void __kfree_section_memmap(struct page *memmap)
+static void __kfree_section_memmap(struct page *memmap,
+                struct vmem_altmap *altmap)
 {
         if (is_vmalloc_addr(memmap))
                 vfree(memmap);
@@ -773,7 +778,8 @@ static void free_map_bootmem(struct page *memmap)
  * set.  If this is <=0, then that means that the passed-in
  * map was not consumed and must be freed.
  */
-int __meminit sparse_add_one_section(struct pglist_data *pgdat, unsigned long start_pfn)
+int __meminit sparse_add_one_section(struct pglist_data *pgdat,
+                unsigned long start_pfn, struct vmem_altmap *altmap)
 {
         unsigned long section_nr = pfn_to_section_nr(start_pfn);
         struct mem_section *ms;
@@ -789,12 +795,12 @@ int __meminit sparse_add_one_section(struct pglist_data *pgdat, unsigned long st
         ret = sparse_index_init(section_nr, pgdat->node_id);
         if (ret < 0 && ret != -EEXIST)
                 return ret;
-        memmap = kmalloc_section_memmap(section_nr, pgdat->node_id);
+        memmap = kmalloc_section_memmap(section_nr, pgdat->node_id, altmap);
         if (!memmap)
                 return -ENOMEM;
         usemap = __kmalloc_section_usemap();
         if (!usemap) {
-                __kfree_section_memmap(memmap);
+                __kfree_section_memmap(memmap, altmap);
                 return -ENOMEM;
         }
 
@@ -816,7 +822,7 @@ out:
         pgdat_resize_unlock(pgdat, &flags);
         if (ret <= 0) {
                 kfree(usemap);
-                __kfree_section_memmap(memmap);
+                __kfree_section_memmap(memmap, altmap);
         }
         return ret;
 }
@@ -843,7 +849,8 @@ static inline void clear_hwpoisoned_pages(struct page *memmap, int nr_pages)
 }
 #endif
 
-static void free_section_usemap(struct page *memmap, unsigned long *usemap)
+static void free_section_usemap(struct page *memmap, unsigned long *usemap,
+                struct vmem_altmap *altmap)
 {
         struct page *usemap_page;
 
@@ -857,7 +864,7 @@ static void free_section_usemap(struct page *memmap, unsigned long *usemap)
         if (PageSlab(usemap_page) || PageCompound(usemap_page)) {
                 kfree(usemap);
                 if (memmap)
-                        __kfree_section_memmap(memmap);
+                        __kfree_section_memmap(memmap, altmap);
                 return;
         }
 
@@ -871,7 +878,7 @@ static void free_section_usemap(struct page *memmap, unsigned long *usemap)
 }
 
 void sparse_remove_one_section(struct zone *zone, struct mem_section *ms,
-                unsigned long map_offset)
+                unsigned long map_offset, struct vmem_altmap *altmap)
 {
         struct page *memmap = NULL;
         unsigned long *usemap = NULL, flags;
@@ -889,7 +896,7 @@ void sparse_remove_one_section(struct zone *zone, struct mem_section *ms,
 
         clear_hwpoisoned_pages(memmap + map_offset,
                         PAGES_PER_SECTION - map_offset);
-        free_section_usemap(memmap, usemap);
+        free_section_usemap(memmap, usemap, altmap);
 }
 #endif /* CONFIG_MEMORY_HOTREMOVE */
 #endif /* CONFIG_MEMORY_HOTPLUG */