[PATCH v3 17/21] mm/mm_init: don't rely on memblock to get KHO scratch migratetype
Mike Rapoport
rppt at kernel.org
Wed Jul 15 02:35:19 PDT 2026
> Currently struct page init via memmap_init() or deferred_init_memmap()
> only queries the migrate type from KHO for each discrete memory range.
> That works currently since KHO scratch memory has a different memory
> type so it is always it its own region.
>
> An upcoming patch will add support for discovering blocks of memory with
> no preservations and it will mark it as MEMBLOCK_KHO_SCRATCH to allow
> allocations from them. This can lead to the bootmem KHO scratch areas to
> be merged into larger free ranges. This merging breaks the selection of
> migrate type.
>
> Get rid of kho_scratch_migratetype(). Instead, let the struct page init
> logic set the migratetype to MIGRATE_MOVABLE for all pages, and then
> give KHO a chance to update the migrate type of its bootmem scratch
> areas to MIGRATE_CMA. Since scratch areas should be a few order of
> magnitues smaller than the total system memory, doing it this way is
> more efficient than searching the kho_scratch array for every pageblock.
It's true for non-deferred case, but with deferred initialization of
struct pages the static part is small and deferred chunks are small, so
we are going to update the migratetype nearly as much as we would check
it with kho_scratch_migratetype().
For simplicity of this patchset I'd keep kho_scratch_migratetype(), just
move it over to kexec_handover.h and make it rely on kho_scratch_overlap().
The bulk optimization can be a separate patch on top.
> Since kho_scratch_migratetype() no longer exists, drop the migratetype
> argument to memmap_init_zone_range() and deferred_init_pages().
>
> Signed-off-by: Pratyush Yadav (Google) <pratyush at kernel.org>
>
> diff --git a/include/linux/kexec_handover.h b/include/linux/kexec_handover.h
> index 18ba417f1ada6..30a71710565a3 100644
> --- a/include/linux/kexec_handover.h
> +++ b/include/linux/kexec_handover.h
> @@ -39,6 +39,7 @@ void kho_populate(phys_addr_t fdt_phys, u64 fdt_len, phys_addr_t scratch_phys,
> u64 scratch_len);
>
> bool kho_scratch_overlap(phys_addr_t phys, size_t size);
> +void kho_init_scratch_migratetype(unsigned long start_pfn, unsigned long end_pfn);
> #else
> static inline bool kho_is_enabled(void)
> {
> @@ -122,6 +123,11 @@ static inline bool kho_scratch_overlap(phys_addr_t phys, size_t size)
> {
> return false;
> }
> +
> +static inline void kho_init_scratch_migratetype(unsigned long start_pfn,
> + unsigned long end_pfn);
> +{
> +}
> #endif /* CONFIG_KEXEC_HANDOVER */
>
> #endif /* LINUX_KEXEC_HANDOVER_H */
> diff --git a/include/linux/memblock.h b/include/linux/memblock.h
> index 5afcd99aa8c14..f142c8a8cd5b7 100644
> --- a/include/linux/memblock.h
> +++ b/include/linux/memblock.h
> @@ -613,28 +613,9 @@ static inline void memtest_report_meminfo(struct seq_file *m) { }
> #ifdef CONFIG_MEMBLOCK_KHO_SCRATCH
> void memblock_set_kho_scratch_only(void);
> void memblock_clear_kho_scratch_only(void);
> -bool memblock_is_kho_scratch_memory(phys_addr_t addr);
> -
> -static inline enum migratetype kho_scratch_migratetype(unsigned long pfn,
> - enum migratetype mt)
> -{
> - if (memblock_is_kho_scratch_memory(PFN_PHYS(pfn)))
> - return MIGRATE_CMA;
> - return mt;
> -}
> #else
> static inline void memblock_set_kho_scratch_only(void) { }
> static inline void memblock_clear_kho_scratch_only(void) { }
> -static inline bool memblock_is_kho_scratch_memory(phys_addr_t addr)
> -{
> - return false;
> -}
> -
> -static inline enum migratetype kho_scratch_migratetype(unsigned long pfn,
> - enum migratetype mt)
> -{
> - return mt;
> -}
> #endif
>
> #endif /* _LINUX_MEMBLOCK_H */
> diff --git a/kernel/liveupdate/kexec_handover.c b/kernel/liveupdate/kexec_handover.c
> index 6e8682469bd7c..b400976851e76 100644
> --- a/kernel/liveupdate/kexec_handover.c
> +++ b/kernel/liveupdate/kexec_handover.c
> @@ -781,6 +781,33 @@ bool kho_scratch_overlap(phys_addr_t phys, size_t size)
> return false;
> }
>
> +/*
> + * Mark all KHO scratch pageblocks between start_pfn and end_pfn as
> + * MIGRATE_CMA.
> + */
> +void kho_init_scratch_migratetype(unsigned long start_pfn, unsigned long end_pfn)
> +{
> + for (unsigned int i = 0; i < kho_scratch_cnt; i++) {
> + unsigned long scratch_start, scratch_end, pfn;
> +
> + scratch_start = PHYS_PFN(kho_scratch[i].addr);
> + scratch_end = PHYS_PFN(kho_scratch[i].addr + kho_scratch[i].size);
> +
> + /* Target range doesn't overlap with scratch. */
> + if (start_pfn >= scratch_end || end_pfn <= scratch_start)
> + continue;
> +
> + pfn = max_t(unsigned long, start_pfn, scratch_start);
> + pfn = pageblock_start_pfn(pfn);
> +
> + while (pfn < end_pfn && pfn < scratch_end) {
> + init_pageblock_migratetype(pfn_to_page(pfn),
> + MIGRATE_CMA, false);
> + pfn += pageblock_nr_pages;
> + }
> + }
> +}
static inline enum migratetype kho_scratch_migratetype(unsigned long pfn,
enum migratetype mt)
{
if (kho_scratch_overlap(PFN_PHYS(pfn)), PAGE_SIZE)
return MIGRATE_CMA;
return mt;
}
Is way easier to parse and reason about ;-)
> +
> /**
> * kho_reserve_scratch - Reserve a contiguous chunk of memory for kexec
> *
> diff --git a/mm/memblock.c b/mm/memblock.c
> index 6349c48154f4b..8b2e551435ae9 100644
> --- a/mm/memblock.c
> +++ b/mm/memblock.c
> @@ -2511,16 +2511,6 @@ __init void memblock_clear_kho_scratch_only(void)
> {
> kho_scratch_only = false;
> }
> -
> -bool __init_memblock memblock_is_kho_scratch_memory(phys_addr_t addr)
> -{
> - int i = memblock_search(&memblock.memory, addr);
> -
> - if (i == -1)
> - return false;
> -
> - return memblock_is_kho_scratch(&memblock.memory.regions[i]);
> -}
> #endif
>
> #ifdef CONFIG_KEXEC_HANDOVER
> diff --git a/mm/mm_init.c b/mm/mm_init.c
> index bd9dc1829005b..1d2f302d8cd9c 100644
> --- a/mm/mm_init.c
> +++ b/mm/mm_init.c
> @@ -707,9 +707,10 @@ void __meminit __init_page_from_nid(unsigned long pfn, int nid)
> __init_single_page(pfn_to_page(pfn), pfn, zid, nid);
>
> if (pageblock_aligned(pfn)) {
> - enum migratetype mt =
> - kho_scratch_migratetype(pfn, MIGRATE_MOVABLE);
> - init_pageblock_migratetype(pfn_to_page(pfn), mt, false);
> + init_pageblock_migratetype(pfn_to_page(pfn), MIGRATE_MOVABLE,
> + false);
> + /* Update the migrate type in case it is KHO scratch. */
> + kho_init_scratch_migratetype(pfn, pfn + 1);
Calling kho_init_scratch_migratetype() instead of
kho_scratch_migratetype() here won't have any benefit, right?
A better optimization would be to call kho_init_scratch_migratetype()
from memmap_init_reserved_range() I think.
> }
> }
>
> @@ -938,13 +939,22 @@ void __meminit memmap_init_range(unsigned long size, int nid, unsigned long zone
> }
> pfn++;
> }
> +
> + /*
> + * Update the migrate type for any pageblocks that fall in a KHO scratch
> + * area. Do this here outside the loop because most pageblocks will not
> + * be KHO scratch, so only search once.
> + *
> + * Only pageblocks up to pfn are updated, deferred pageblocks will be
> + * updated later.
> + */
> + kho_init_scratch_migratetype(start_pfn, pfn);
It's no relevant for memory hotplug or ZONE_DEVICE so ideally this
should have been in memmap_init_zone_range() and somehow take into
account first_deferred_pfn. And then it becomes hairy :)
> }
>
> static void __init memmap_init_zone_range(struct zone *zone,
> unsigned long start_pfn,
> unsigned long end_pfn,
> - unsigned long *hole_pfn,
> - enum migratetype mt)
> + unsigned long *hole_pfn)
> {
> unsigned long zone_start_pfn = zone->zone_start_pfn;
> unsigned long zone_end_pfn = zone_start_pfn + zone->spanned_pages;
> @@ -957,7 +967,8 @@ static void __init memmap_init_zone_range(struct zone *zone,
> return;
>
> memmap_init_range(end_pfn - start_pfn, nid, zone_id, start_pfn,
> - zone_end_pfn, MEMINIT_EARLY, NULL, mt, false);
> + zone_end_pfn, MEMINIT_EARLY, NULL, MIGRATE_MOVABLE,
> + false);
>
> if (*hole_pfn < start_pfn)
> init_unavailable_range(*hole_pfn, start_pfn, zone_id, nid);
> @@ -973,8 +984,6 @@ static void __init memmap_init(void)
>
> for_each_mem_pfn_range(i, MAX_NUMNODES, &start_pfn, &end_pfn, &nid) {
> struct pglist_data *node = NODE_DATA(nid);
> - enum migratetype mt =
> - kho_scratch_migratetype(start_pfn, MIGRATE_MOVABLE);
>
> for (j = 0; j < MAX_NR_ZONES; j++) {
> struct zone *zone = node->node_zones + j;
> @@ -983,7 +992,7 @@ static void __init memmap_init(void)
> continue;
>
> memmap_init_zone_range(zone, start_pfn, end_pfn,
> - &hole_pfn, mt);
> + &hole_pfn);
> zone_id = j;
> }
> }
> @@ -1973,7 +1982,7 @@ unsigned long __init node_map_pfn_alignment(void)
>
> #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
> static void __init deferred_free_pages(unsigned long pfn,
> - unsigned long nr_pages, enum migratetype mt)
> + unsigned long nr_pages)
> {
> struct page *page;
> unsigned long i;
> @@ -2012,8 +2021,7 @@ static inline void __init pgdat_init_report_one_done(void)
> * Return number of pages initialized.
> */
> static unsigned long __init deferred_init_pages(struct zone *zone,
> - unsigned long start_pfn, unsigned long end_pfn,
> - enum migratetype mt)
> + unsigned long start_pfn, unsigned long end_pfn)
> {
> int nid = zone_to_nid(zone);
> unsigned long nr_pages = end_pfn - start_pfn, pfn = start_pfn;
> @@ -2027,7 +2035,14 @@ static unsigned long __init deferred_init_pages(struct zone *zone,
> pfn = pageblock_align(start_pfn);
> page = pfn_to_page(pfn);
> for (; pfn < end_pfn; pfn += pageblock_nr_pages, page += pageblock_nr_pages)
> - init_pageblock_migratetype(page, mt, false);
> + init_pageblock_migratetype(page, MIGRATE_MOVABLE, false);
> +
> + /*
> + * Update the migrate type for any pageblocks that fall in a KHO scratch
> + * area. Since most pageblocks will not be KHO scratch, do it outside
> + * the loop to only do the search once.
> + */
> + kho_init_scratch_migratetype(start_pfn, end_pfn);
And here the chunks are at most MAX_ORDER_NR_PAGES, so bulk init also
wouldn't save much.
--
Sincerely yours,
Mike.
More information about the kexec
mailing list