7 files changed, 96 insertions, 95 deletions

diff --git a/mm/gup.c b/mm/gup.c
index e0d82b6706d7..3affe7544b0c 100644
--- a/mm/gup.c
+++ b/mm/gup.c
@@ -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 ea19742a5d60..320fdc87f064 100644
--- a/mm/hmm.c
+++ b/mm/hmm.c
@@ -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/memory.c b/mm/memory.c
index ca5674cbaff2..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;
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/page_alloc.c b/mm/page_alloc.c
index 76c9688b6a0a..2bb7f163baca 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -5314,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;
@@ -5417,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/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 2609aba121e8..2583174b1d62 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 */