mm: fix initialization of struct page for holes in memory layout
Subsystems (3)
v7 cover mm: fix initialization of struct page for holes in memory layout
From: Mike Rapoport <[email protected]>
Hi,
@Andrew, this is based on v5.11-mmotm-2021-02-18-18-29 with the previous version reverted
Commit 73a6e474cb37 ("mm: memmap_init: iterate over memblock regions rather that check each PFN") exposed several issues with the memory map initialization and these patches fix those issues.
Initially there were crashes during compaction that Qian Cai reported back in April [1]. It seemed back then that the problem was fixed, but a few weeks ago Andrea Arcangeli hit the same bug [2] and there was an additional discussion at [3].
I didn't appreciate variety of ways BIOSes can report memory in the first megabyte, so previous versions of this set caused all kinds of troubles.
The last version that implicitly extended node/zone to cover the complete section might also have unexpected side effects, so this time I'm trying to move in forward in baby steps.
This is mostly a return to the fist version that simply merges init_unavailable_pages() into memmap_init() so that the only effective change would be more sensible zone/node links in unavailable struct pages.
For now, I've dropped the patch that tried to make ZONE_DMA to span pfn 0 because it didn't cause any issues for really long time and there are way to many hidden mines around this.
I have an ugly workaround for "pfn 0" issue that IMHO is the safest way to deal with it until it could be gradually fixed properly:
v7:
* add handling of section end that span beyond the populated zones
v6: https://lore.kernel.org/lkml/[email protected]
* only interleave initialization of unavailable pages in memmap_init(), so that it is essentially includes init_unavailable_pages().
v5: https://lore.kernel.org/lkml/[email protected]
* extend node/zone spans to cover complete sections, this allows to interleave the initialization of unavailable pages with "normal" memory map init.
* drop modifications to x86 early setup
v4: https://lore.kernel.org/lkml/[email protected]/
* make sure pages in the range 0 - start_pfn_of_lowest_zone are initialized even if an architecture hides them from the generic mm
* finally make pfn 0 on x86 to be a part of memory visible to the generic mm as reserved memory.
v3: https://lore.kernel.org/lkml/[email protected]
* use architectural zone constraints to set zone links for struct pages corresponding to the holes
* drop implicit update of memblock.memory
* add a patch that sets pfn 0 to E820_TYPE_RAM on x86
v2: https://lore.kernel.org/lkml/[email protected]/):
* added patch that adds all regions in memblock.reserved that do not overlap with memblock.memory to memblock.memory in the beginning of free_area_init()
[1] https://lore.kernel.org/lkml/[email protected]
[2] https://lore.kernel.org/lkml/[email protected]
[3] https://lore.kernel.org/mm-commits/20201206005401.qKuAVgOXr%[email protected]
Mike Rapoport (1):
mm/page_alloc.c: refactor initialization of struct page for holes in
memory layout
mm/page_alloc.c | 147 +++++++++++++++++++++--------------------------- 1 file changed, 64 insertions(+), 83 deletions(-)
Signature · 1 line
2.28.0
PATCH v7 1/1 mm/page_alloc.c: refactor initialization of struct page for holes in memory layout
From: Mike Rapoport <[email protected]>
There could be struct pages that are not backed by actual physical memory. This can happen when the actual memory bank is not a multiple of SECTION_SIZE or when an architecture does not register memory holes reserved by the firmware as memblock.memory.
Such pages are currently initialized using init_unavailable_mem() function that iterates through PFNs in holes in memblock.memory and if there is a struct page corresponding to a PFN, the fields of this page are set to default values and it is marked as Reserved.
init_unavailable_mem() does not take into account zone and node the page belongs to and sets both zone and node links in struct page to zero.
Before commit 73a6e474cb37 ("mm: memmap_init: iterate over memblock regions rather that check each PFN") the holes inside a zone were re-initialized during memmap_init() and got their zone/node links right. However, after that commit nothing updates the struct pages representing such holes.
On a system that has firmware reserved holes in a zone above ZONE_DMA, for instance in a configuration below:
# grep -A1 E820 /proc/iomem 7a17b000-7a216fff : Unknown E820 type 7a217000-7bffffff : System RAM
unset zone link in struct page will trigger
VM_BUG_ON_PAGE(!zone_spans_pfn(page_zone(page), pfn), page);
because there are pages in both ZONE_DMA32 and ZONE_DMA (unset zone link in struct page) in the same pageblock.
Interleave initialization of the unavailable pages with the normal initialization of memory map, so that zone and node information will be properly set on struct pages that are not backed by the actual memory.
With this change the pages for holes inside a zone will get proper zone/node links and the pages that are not spanned by any node will get links to the adjacent zone/node.
--- mm/page_alloc.c | 147 +++++++++++++++++++++--------------------------- 1 file changed, 64 insertions(+), 83 deletions(-)
mm/page_alloc.c +64 -83
@@ -6280,12 +6280,60 @@ static void __meminit zone_init_free_lists(struct zone *zone) } } +#if !defined(CONFIG_FLAT_NODE_MEM_MAP ) +/* +* Only struct pages that correspond to ranges defined by memblock.memory +* are zeroed and initialized by going through __init_single_page() during +* memmap_init_zone(). +* +* But, there could be struct pages that correspond to holes in +* memblock.memory. This can happen because of the following reasons: +* - phyiscal memory bank size is not necessarily the exact multiple of the +* arbitrary section size +* - early reserved memory may not be listed in memblock.memory +* - memory layouts defined with memmap= kernel parameter may not align +* nicely with memmap sections +* +* Explicitly initialize those struct pages so that: +* - PG_Reserved is set +* - zone and node links point to zone and node that span the page +*/ +static u64 __meminit init_unavailable_range (unsigned long spfn, +unsigned long epfn, +int zone,int node) +{ +unsigned long pfn; +u64 pgcnt =0 ; + +for (pfn = spfn; pfn < epfn; pfn++) { +if (!pfn_valid (ALIGN_DOWN (pfn, pageblock_nr_pages))) { + pfn =ALIGN_DOWN (pfn, pageblock_nr_pages) + + pageblock_nr_pages -1 ; +continue ; + } +__init_single_page (pfn_to_page (pfn), pfn, zone, node); +__SetPageReserved (pfn_to_page (pfn)); + pgcnt++; + } + +return pgcnt; +} +#else +static inline u64 init_unavailable_range (unsigned long spfn,unsigned long epfn, +int zone,int node) +{ +return 0 ; +} +#endif +void __meminit __weak memmap_init_zone (struct zone *zone) {unsigned long zone_start_pfn = zone->zone_start_pfn;unsigned long zone_end_pfn = zone_start_pfn + zone->spanned_pages;int i, nid =zone_to_nid (zone), zone_id =zone_idx (zone); +static unsigned long hole_pfn =0 ;unsigned long start_pfn, end_pfn; +u64 pgcnt =0 ;for_each_mem_pfn_range (i, nid, &start_pfn, &end_pfn,NULL ) { start_pfn =clamp (start_pfn, zone_start_pfn, zone_end_pfn);
@@ -6295,7 +6343,23 @@ void __meminit __weak memmap_init_zone(struct zone *zone)memmap_init_range (end_pfn - start_pfn, nid, zone_id, start_pfn, zone_end_pfn,MEMINIT_EARLY ,NULL ,MIGRATE_MOVABLE ); + +if (hole_pfn < start_pfn) + pgcnt +=init_unavailable_range (hole_pfn, start_pfn, + zone_id, nid); + hole_pfn = end_pfn; } + +#ifdef CONFIG_SPARSEMEM + end_pfn =round_up (zone_end_pfn,PAGES_PER_SECTION ); +if (hole_pfn < end_pfn) + pgcnt +=init_unavailable_range (hole_pfn, end_pfn, + zone_id, nid); +#endif + +if (pgcnt) +pr_info (" %s zone: %lld pages in unavailable ranges\n" , + zone->name, pgcnt); }static int zone_batchsize (struct zone *zone)
@@ -7092,88 +7156,6 @@ void __init free_area_init_memoryless_node(int nid)free_area_init_node (nid); } -#if !defined(CONFIG_FLAT_NODE_MEM_MAP ) -/* -* Initialize all valid struct pages in the range [spfn, epfn) and mark them -* PageReserved(). Return the number of struct pages that were initialized. -*/ -static u64 __init init_unavailable_range (unsigned long spfn,unsigned long epfn) -{ -unsigned long pfn; -u64 pgcnt =0 ; - -for (pfn = spfn; pfn < epfn; pfn++) { -if (!pfn_valid (ALIGN_DOWN (pfn, pageblock_nr_pages))) { - pfn =ALIGN_DOWN (pfn, pageblock_nr_pages) - + pageblock_nr_pages -1 ; -continue ; - } -/* -* Use a fake node/zone (0) for now. Some of these pages -* (in memblock.reserved but not in memblock.memory) will -* get re-initialized via reserve_bootmem_region() later. -*/ -__init_single_page (pfn_to_page (pfn), pfn,0 ,0 ); -__SetPageReserved (pfn_to_page (pfn)); - pgcnt++; - } - -return pgcnt; -} - -/* -* Only struct pages that are backed by physical memory are zeroed and -* initialized by going through __init_single_page(). But, there are some -* struct pages which are reserved in memblock allocator and their fields -* may be accessed (for example page_to_pfn() on some configuration accesses -* flags). We must explicitly initialize those struct pages. -* -* This function also addresses a similar issue where struct pages are left -* uninitialized because the physical address range is not covered by -* memblock.memory or memblock.reserved. That could happen when memblock -* layout is manually configured via memmap=, or when the highest physical -* address (max_pfn) does not end on a section boundary. -*/ -static void __init init_unavailable_mem (void ) -{ -phys_addr_t start, end; -u64 i, pgcnt; -phys_addr_t next =0 ; - -/* -* Loop through unavailable ranges not covered by memblock.memory. -*/ - pgcnt =0 ; -for_each_mem_range (i, &start, &end) { -if (next < start) - pgcnt +=init_unavailable_range (PFN_DOWN (next), -PFN_UP (start)); - next = end; - } - -/* -* Early sections always have a fully populated memmap for the whole -* section - see pfn_valid(). If the last section has holes at the -* end and that section is marked "online", the memmap will be -* considered initialized. Make sure that memmap has a well defined -* state. -*/ - pgcnt +=init_unavailable_range (PFN_DOWN (next), -round_up (max_pfn,PAGES_PER_SECTION )); - -/* -* Struct pages that do not have backing memory. This could be because -* firmware is using some of this memory, or for some other reasons. -*/ -if (pgcnt) -pr_info ("Zeroed struct page in unavailable ranges: %lld pages" , pgcnt); -} -#else -static inline void __init init_unavailable_mem (void ) -{ -} -#endif /* !CONFIG_FLAT_NODE_MEM_MAP */ -#if MAX_NUMNODES >1 /* * Figure out the number of possible node ids.
@@ -7597,7 +7579,6 @@ void __init free_area_init(unsigned long *max_zone_pfn)/* Initialise every node */ mminit_verify_pageflags_layout ();setup_nr_node_ids (); -init_unavailable_mem ();for_each_online_node (nid) {pg_data_t *pgdat =NODE_DATA (nid);free_area_init_node (nid);
Signature · 1 line
2.28.0
Re: [PATCH v7 1/1] mm/page_alloc.c: refactor initialization of struct page for holes in memory layout
Quoted 122 lines · Mike Rapoport
From: Mike Rapoport <[email protected]>
There could be struct pages that are not backed by actual physical memory. This can happen when the actual memory bank is not a multiple of
SECTION_SIZEor when an architecture does not register memory holes reserved by the firmware as memblock.memory.Such pages are currently initialized using
init_unavailable_mem()function that iterates through PFNs in holes in memblock.memory and if there is a struct page corresponding to a PFN, the fields of this page are set to default values and it is marked as Reserved.
init_unavailable_mem()does not take into account zone and node the page belongs to and sets both zone and node links in struct page to zero.Before commit
73a6e474cb37("mm:memmap_init: iterate over memblock regions rather that check each PFN") the holes inside a zone were re-initialized duringmemmap_init()and got their zone/node links right. However, after that commit nothing updates the struct pages representing such holes.On a system that has firmware reserved holes in a zone above
ZONE_DMA, for instance in a configuration below:# grep -A1 E820 /proc/iomem 7a17b000-7a216fff : Unknown E820 type 7a217000-7bffffff : System RAMunset zone link in struct page will trigger
VM_BUG_ON_PAGE(!zone_spans_pfn(page_zone(page), pfn), page);because there are pages in both
ZONE_DMA32andZONE_DMA(unset zone link in struct page) in the same pageblock.Interleave initialization of the unavailable pages with the normal initialization of memory map, so that zone and node information will be properly set on struct pages that are not backed by the actual memory.
With this change the pages for holes inside a zone will get proper zone/node links and the pages that are not spanned by any node will get links to the adjacent zone/node.
Fixes 73a6e474cb37 ("mm: memmap_init: iterate over memblock regions rather that check each PFN")Signed-off-by Mike Rapoport <[email protected]>Reported-by Qian Cai <[email protected]>Reported-by Andrea Arcangeli <[email protected]>Reviewed-by Baoquan He <[email protected]>--- mm/page_alloc.c | 147 +++++++++++++++++++++--------------------------- 1 file changed, 64 insertions(+), 83 deletions(-)mm/page_alloc.c +50
-0@@ -6280,12 +6280,60 @@ static void __meminit zone_init_free_lists(struct zone *zone) } } +#if !defined(CONFIG_FLAT_NODE_MEM_MAP ) +/* +* Only struct pages that correspond to ranges defined by memblock.memory +* are zeroed and initialized by going through __init_single_page() during +* memmap_init_zone(). +* +* But, there could be struct pages that correspond to holes in +* memblock.memory. This can happen because of the following reasons: +* - phyiscal memory bank size is not necessarily the exact multiple of the +* arbitrary section size +* - early reserved memory may not be listed in memblock.memory +* - memory layouts defined with memmap= kernel parameter may not align +* nicely with memmap sections +* +* Explicitly initialize those struct pages so that: +* - PG_Reserved is set +* - zone and node links point to zone and node that span the page +*/ +static u64 __meminit init_unavailable_range (unsigned long spfn, +unsigned long epfn, +int zone,int node) +{ +unsigned long pfn; +u64 pgcnt =0 ; + +for (pfn = spfn; pfn < epfn; pfn++) { +if (!pfn_valid (ALIGN_DOWN (pfn, pageblock_nr_pages))) { + pfn =ALIGN_DOWN (pfn, pageblock_nr_pages) + + pageblock_nr_pages -1 ; +continue ; + } +__init_single_page (pfn_to_page (pfn), pfn, zone, node); +__SetPageReserved (pfn_to_page (pfn)); + pgcnt++; + } + +return pgcnt; +} +#else +static inline u64 init_unavailable_range (unsigned long spfn,unsigned long epfn, +int zone,int node) +{ +return 0 ; +} +#endif +void __meminit __weak memmap_init_zone (struct zone *zone) {unsigned long zone_start_pfn = zone->zone_start_pfn;unsigned long zone_end_pfn = zone_start_pfn + zone->spanned_pages;int i, nid =zone_to_nid (zone), zone_id =zone_idx (zone); +static unsigned long hole_pfn =0 ;unsigned long start_pfn, end_pfn; +u64 pgcnt =0 ;for_each_mem_pfn_range (i, nid, &start_pfn, &end_pfn,NULL ) { start_pfn =clamp (start_pfn, zone_start_pfn, zone_end_pfn);@@ -6295,7 +6343,23 @@ void __meminit __weak memmap_init_zone(struct zone *zone)memmap_init_range (end_pfn - start_pfn, nid, zone_id, start_pfn, zone_end_pfn,MEMINIT_EARLY ,NULL ,MIGRATE_MOVABLE ); + +if (hole_pfn < start_pfn)
mm/page_alloc.c void __meminit __weak memmap_init_zone(struct zone *zone) · line 6357
Quoted 10 lines
mm/page_alloc.c +9
-0+ pgcnt +=init_unavailable_range (hole_pfn, start_pfn, + zone_id, nid); + hole_pfn = end_pfn; } + +#ifdef CONFIG_SPARSEMEM + end_pfn =round_up (zone_end_pfn,PAGES_PER_SECTION ); +if (hole_pfn < end_pfn) + pgcnt +=init_unavailable_range (hole_pfn, end_pfn, + zone_id, nid);
We might still double-initialize PFNs when two zones overlap within a section, correct? This might worth documenting - also, you might want to take some of the original comment the accompanied this code.
You should also document (in the patch description?) that node/zone spans are not properly handled yet for such hole pfns and that this might require care in the future.
I played a little with weird setups and expected the memap state using page-types (well, I can't inspect the node/zone that way but at least have a look if the memmap was initialized). No surprises.
Signature · 3 lines
Thanks, David / dhildenb
Re: [PATCH v7 1/1] mm/page_alloc.c: refactor initialization of struct page for holes in memory layout
Quoted 126 lines · David Hildenbrand
Quoted 125 lines · Mike Rapoport
From: Mike Rapoport <[email protected]>
There could be struct pages that are not backed by actual physical memory. This can happen when the actual memory bank is not a multiple of
SECTION_SIZEor when an architecture does not register memory holes reserved by the firmware as memblock.memory.Such pages are currently initialized using
init_unavailable_mem()function that iterates through PFNs in holes in memblock.memory and if there is a struct page corresponding to a PFN, the fields of this page are set to default values and it is marked as Reserved.
init_unavailable_mem()does not take into account zone and node the page belongs to and sets both zone and node links in struct page to zero.Before commit
73a6e474cb37("mm:memmap_init: iterate over memblock regions rather that check each PFN") the holes inside a zone were re-initialized duringmemmap_init()and got their zone/node links right. However, after that commit nothing updates the struct pages representing such holes.On a system that has firmware reserved holes in a zone above
ZONE_DMA, for instance in a configuration below:# grep -A1 E820 /proc/iomem 7a17b000-7a216fff : Unknown E820 type 7a217000-7bffffff : System RAMunset zone link in struct page will trigger
VM_BUG_ON_PAGE(!zone_spans_pfn(page_zone(page), pfn), page);because there are pages in both
ZONE_DMA32andZONE_DMA(unset zone link in struct page) in the same pageblock.Interleave initialization of the unavailable pages with the normal initialization of memory map, so that zone and node information will be properly set on struct pages that are not backed by the actual memory.
With this change the pages for holes inside a zone will get proper zone/node links and the pages that are not spanned by any node will get links to the adjacent zone/node.
Fixes 73a6e474cb37 ("mm: memmap_init: iterate over memblock regions rather that check each PFN")Signed-off-by Mike Rapoport <[email protected]>Reported-by Qian Cai <[email protected]>Reported-by Andrea Arcangeli <[email protected]>Reviewed-by Baoquan He <[email protected]>--- mm/page_alloc.c | 147 +++++++++++++++++++++--------------------------- 1 file changed, 64 insertions(+), 83 deletions(-)mm/page_alloc.c +54
-0@@ -6280,12 +6280,60 @@ static void __meminit zone_init_free_lists(struct zone *zone) } } +#if !defined(CONFIG_FLAT_NODE_MEM_MAP ) +/* +* Only struct pages that correspond to ranges defined by memblock.memory +* are zeroed and initialized by going through __init_single_page() during +* memmap_init_zone(). +* +* But, there could be struct pages that correspond to holes in +* memblock.memory. This can happen because of the following reasons: +* - phyiscal memory bank size is not necessarily the exact multiple of the +* arbitrary section size +* - early reserved memory may not be listed in memblock.memory +* - memory layouts defined with memmap= kernel parameter may not align +* nicely with memmap sections +* +* Explicitly initialize those struct pages so that: +* - PG_Reserved is set +* - zone and node links point to zone and node that span the page +*/ +static u64 __meminit init_unavailable_range (unsigned long spfn, +unsigned long epfn, +int zone,int node) +{ +unsigned long pfn; +u64 pgcnt =0 ; + +for (pfn = spfn; pfn < epfn; pfn++) { +if (!pfn_valid (ALIGN_DOWN (pfn, pageblock_nr_pages))) { + pfn =ALIGN_DOWN (pfn, pageblock_nr_pages) + + pageblock_nr_pages -1 ; +continue ; + } +__init_single_page (pfn_to_page (pfn), pfn, zone, node); +__SetPageReserved (pfn_to_page (pfn)); + pgcnt++; + } + +return pgcnt; +} +#else +static inline u64 init_unavailable_range (unsigned long spfn,unsigned long epfn, +int zone,int node) +{ +return 0 ; +} +#endif +void __meminit __weak memmap_init_zone (struct zone *zone) {unsigned long zone_start_pfn = zone->zone_start_pfn;unsigned long zone_end_pfn = zone_start_pfn + zone->spanned_pages;int i, nid =zone_to_nid (zone), zone_id =zone_idx (zone); +static unsigned long hole_pfn =0 ;unsigned long start_pfn, end_pfn; +u64 pgcnt =0 ;for_each_mem_pfn_range (i, nid, &start_pfn, &end_pfn,NULL ) { start_pfn =clamp (start_pfn, zone_start_pfn, zone_end_pfn);@@ -6295,7 +6343,23 @@ void __meminit __weak memmap_init_zone(struct zone *zone)memmap_init_range (end_pfn - start_pfn, nid, zone_id, start_pfn, zone_end_pfn,MEMINIT_EARLY ,NULL ,MIGRATE_MOVABLE ); + +if (hole_pfn < start_pfn) + pgcnt +=init_unavailable_range (hole_pfn, start_pfn, + zone_id, nid); + hole_pfn = end_pfn; } +
Quoted 8 lines
mm/page_alloc.c void __meminit __weak memmap_init_zone(struct zone *zone) · line 6357
Quoted 5 lines
mm/page_alloc.c +5
-0+#ifdef CONFIG_SPARSEMEM + end_pfn =round_up (zone_end_pfn,PAGES_PER_SECTION ); +if (hole_pfn < end_pfn) + pgcnt +=init_unavailable_range (hole_pfn, end_pfn, + zone_id, nid);We might still double-initialize PFNs when two zones overlap within a section, correct?
You mean that a section crosses zones boundary?
I don't think it's that important.
Quoted 2 lines
This might worth documenting - also, you might want to take some of the original comment the accompanied this code.
The original comment was not exactly right, I believe the comment above init_unavailable_range() better describes what's going on there.
Quoted 3 lines
You should also document (in the patch description?) that node/zone spans are not properly handled yet for such hole pfns and that this might require care in the future.
I think Link: will suffice for this.
Quoted 3 lines
I played a little with weird setups and expected the memap state using page-types (well, I can't inspect the node/zone that way but at least have a look if the memmap was initialized). No surprises.
Great, thanks!
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH v7 1/1] mm/page_alloc.c: refactor initialization of struct page for holes in memory layout
In reply to Mike RapoportQuoted 1 line · Mike Rapoport
From: Mike Rapoport <[email protected]>
Hi, thanks for your efforts. I'll just nit pick on the description/comments as I don't feel confident about judging the implementation correctness, sorry :)
Quoted 21 lines
There could be struct pages that are not backed by actual physical memory. This can happen when the actual memory bank is not a multiple of
SECTION_SIZEor when an architecture does not register memory holes reserved by the firmware as memblock.memory.Such pages are currently initialized using
init_unavailable_mem()function that iterates through PFNs in holes in memblock.memory and if there is a struct page corresponding to a PFN, the fields of this page are set to default values and it is marked as Reserved.
init_unavailable_mem()does not take into account zone and node the page belongs to and sets both zone and node links in struct page to zero.Before commit
73a6e474cb37("mm:memmap_init: iterate over memblock regions rather that check each PFN") the holes inside a zone were re-initialized duringmemmap_init()and got their zone/node links right. However, after that commit nothing updates the struct pages representing such holes.On a system that has firmware reserved holes in a zone above
ZONE_DMA, for instance in a configuration below:
Quoted 7 lines
# grep -A1 E820 /proc/iomem 7a17b000-7a216fff : Unknown E820 type 7a217000-7bffffff : System RAMunset zone link in struct page will trigger
VM_BUG_ON_PAGE(!zone_spans_pfn(page_zone(page), pfn), page);
... in set_pfnblock_flags_mask() when called with a struct page from the "Unknown E820 type" range.
Quoted 2 lines
because there are pages in both
ZONE_DMA32andZONE_DMA(unset zone link in struct page) in the same pageblock.
I would say "there are apparently pages" ... "and ZONE_DMA does not span this range"
Quoted 7 lines
Interleave initialization of the unavailable pages with the normal initialization of memory map, so that zone and node information will be properly set on struct pages that are not backed by the actual memory.
With this change the pages for holes inside a zone will get proper zone/node links and the pages that are not spanned by any node will get links to the adjacent zone/node.
What if two zones are adjacent? I.e. if the hole was at a boundary between two zones.
Quoted 5 lines
Fixes 73a6e474cb37 ("mm: memmap_init: iterate over memblock regions rather that check each PFN")Signed-off-by Mike Rapoport <[email protected]>Reported-by Qian Cai <[email protected]>Reported-by Andrea Arcangeli <[email protected]>Reviewed-by Baoquan He <[email protected]>
For the approach:
Quoted 11 lines
--- mm/page_alloc.c | 147 +++++++++++++++++++++--------------------------- 1 file changed, 64 insertions(+), 83 deletions(-)mm/page_alloc.c +0
-0@@ -6280,12 +6280,60 @@ static void __meminit zone_init_free_lists(struct zone *zone) } }
mm/page_alloc.c static void __meminit zone_init_free_lists(struct zone *zone) · line 6291
Quoted 10 lines
mm/page_alloc.c +9
-0+#if !defined(CONFIG_FLAT_NODE_MEM_MAP ) +/* +* Only struct pages that correspond to ranges defined by memblock.memory +* are zeroed and initialized by going through __init_single_page() during +* memmap_init_zone(). +* +* But, there could be struct pages that correspond to holes in +* memblock.memory. This can happen because of the following reasons: +* - phyiscal memory bank size is not necessarily the exact multiple of the
physical
mm/page_alloc.c static void __meminit zone_init_free_lists(struct zone *zone) · line 6299
Quoted 8 lines
mm/page_alloc.c +8
-0+* arbitrary section size +* - early reserved memory may not be listed in memblock.memory +* - memory layouts defined with memmap= kernel parameter may not align +* nicely with memmap sections +* +* Explicitly initialize those struct pages so that: +* - PG_Reserved is set +* - zone and node links point to zone and node that span the page
Yes spanned pages are the most important, but should you also describe here the adjacent ones, as you do in commit log?
Quoted 162 lines
mm/page_alloc.c +47
-83+*/ +static u64 __meminit init_unavailable_range (unsigned long spfn, +unsigned long epfn, +int zone,int node) +{ +unsigned long pfn; +u64 pgcnt =0 ; + +for (pfn = spfn; pfn < epfn; pfn++) { +if (!pfn_valid (ALIGN_DOWN (pfn, pageblock_nr_pages))) { + pfn =ALIGN_DOWN (pfn, pageblock_nr_pages) + + pageblock_nr_pages -1 ; +continue ; + } +__init_single_page (pfn_to_page (pfn), pfn, zone, node); +__SetPageReserved (pfn_to_page (pfn)); + pgcnt++; + } + +return pgcnt; +} +#else +static inline u64 init_unavailable_range (unsigned long spfn,unsigned long epfn, +int zone,int node) +{ +return 0 ; +} +#endif +void __meminit __weak memmap_init_zone (struct zone *zone) {unsigned long zone_start_pfn = zone->zone_start_pfn;unsigned long zone_end_pfn = zone_start_pfn + zone->spanned_pages;int i, nid =zone_to_nid (zone), zone_id =zone_idx (zone); +static unsigned long hole_pfn =0 ;unsigned long start_pfn, end_pfn; +u64 pgcnt =0 ;for_each_mem_pfn_range (i, nid, &start_pfn, &end_pfn,NULL ) { start_pfn =clamp (start_pfn, zone_start_pfn, zone_end_pfn);@@ -6295,7 +6343,23 @@ void __meminit __weak memmap_init_zone(struct zone *zone)memmap_init_range (end_pfn - start_pfn, nid, zone_id, start_pfn, zone_end_pfn,MEMINIT_EARLY ,NULL ,MIGRATE_MOVABLE ); + +if (hole_pfn < start_pfn) + pgcnt +=init_unavailable_range (hole_pfn, start_pfn, + zone_id, nid); + hole_pfn = end_pfn; } + +#ifdef CONFIG_SPARSEMEM + end_pfn =round_up (zone_end_pfn,PAGES_PER_SECTION ); +if (hole_pfn < end_pfn) + pgcnt +=init_unavailable_range (hole_pfn, end_pfn, + zone_id, nid); +#endif + +if (pgcnt) +pr_info (" %s zone: %lld pages in unavailable ranges\n" , + zone->name, pgcnt); }static int zone_batchsize (struct zone *zone)@@ -7092,88 +7156,6 @@ void __init free_area_init_memoryless_node(int nid)free_area_init_node (nid); } -#if !defined(CONFIG_FLAT_NODE_MEM_MAP ) -/* -* Initialize all valid struct pages in the range [spfn, epfn) and mark them -* PageReserved(). Return the number of struct pages that were initialized. -*/ -static u64 __init init_unavailable_range (unsigned long spfn,unsigned long epfn) -{ -unsigned long pfn; -u64 pgcnt =0 ; - -for (pfn = spfn; pfn < epfn; pfn++) { -if (!pfn_valid (ALIGN_DOWN (pfn, pageblock_nr_pages))) { - pfn =ALIGN_DOWN (pfn, pageblock_nr_pages) - + pageblock_nr_pages -1 ; -continue ; - } -/* -* Use a fake node/zone (0) for now. Some of these pages -* (in memblock.reserved but not in memblock.memory) will -* get re-initialized via reserve_bootmem_region() later. -*/ -__init_single_page (pfn_to_page (pfn), pfn,0 ,0 ); -__SetPageReserved (pfn_to_page (pfn)); - pgcnt++; - } - -return pgcnt; -} - -/* -* Only struct pages that are backed by physical memory are zeroed and -* initialized by going through __init_single_page(). But, there are some -* struct pages which are reserved in memblock allocator and their fields -* may be accessed (for example page_to_pfn() on some configuration accesses -* flags). We must explicitly initialize those struct pages. -* -* This function also addresses a similar issue where struct pages are left -* uninitialized because the physical address range is not covered by -* memblock.memory or memblock.reserved. That could happen when memblock -* layout is manually configured via memmap=, or when the highest physical -* address (max_pfn) does not end on a section boundary. -*/ -static void __init init_unavailable_mem (void ) -{ -phys_addr_t start, end; -u64 i, pgcnt; -phys_addr_t next =0 ; - -/* -* Loop through unavailable ranges not covered by memblock.memory. -*/ - pgcnt =0 ; -for_each_mem_range (i, &start, &end) { -if (next < start) - pgcnt +=init_unavailable_range (PFN_DOWN (next), -PFN_UP (start)); - next = end; - } - -/* -* Early sections always have a fully populated memmap for the whole -* section - see pfn_valid(). If the last section has holes at the -* end and that section is marked "online", the memmap will be -* considered initialized. Make sure that memmap has a well defined -* state. -*/ - pgcnt +=init_unavailable_range (PFN_DOWN (next), -round_up (max_pfn,PAGES_PER_SECTION )); - -/* -* Struct pages that do not have backing memory. This could be because -* firmware is using some of this memory, or for some other reasons. -*/ -if (pgcnt) -pr_info ("Zeroed struct page in unavailable ranges: %lld pages" , pgcnt); -} -#else -static inline void __init init_unavailable_mem (void ) -{ -} -#endif /* !CONFIG_FLAT_NODE_MEM_MAP */ -#if MAX_NUMNODES >1 /* * Figure out the number of possible node ids. @@ -7597,7 +7579,6 @@ void __init free_area_init(unsigned long *max_zone_pfn)/* Initialise every node */ mminit_verify_pageflags_layout ();setup_nr_node_ids (); -init_unavailable_mem ();for_each_online_node (nid) {pg_data_t *pgdat =NODE_DATA (nid);free_area_init_node (nid);
Re: [PATCH v7 1/1] mm/page_alloc.c: refactor initialization of struct page for holes in memory layout
In reply to Mike RapoportQuoted 136 lines · Mike Rapoport
Quoted 126 lines · David Hildenbrand
Quoted 125 lines · Mike Rapoport
From: Mike Rapoport <[email protected]>
There could be struct pages that are not backed by actual physical memory. This can happen when the actual memory bank is not a multiple of
SECTION_SIZEor when an architecture does not register memory holes reserved by the firmware as memblock.memory.Such pages are currently initialized using
init_unavailable_mem()function that iterates through PFNs in holes in memblock.memory and if there is a struct page corresponding to a PFN, the fields of this page are set to default values and it is marked as Reserved.
init_unavailable_mem()does not take into account zone and node the page belongs to and sets both zone and node links in struct page to zero.Before commit
73a6e474cb37("mm:memmap_init: iterate over memblock regions rather that check each PFN") the holes inside a zone were re-initialized duringmemmap_init()and got their zone/node links right. However, after that commit nothing updates the struct pages representing such holes.On a system that has firmware reserved holes in a zone above
ZONE_DMA, for instance in a configuration below:# grep -A1 E820 /proc/iomem 7a17b000-7a216fff : Unknown E820 type 7a217000-7bffffff : System RAMunset zone link in struct page will trigger
VM_BUG_ON_PAGE(!zone_spans_pfn(page_zone(page), pfn), page);because there are pages in both
ZONE_DMA32andZONE_DMA(unset zone link in struct page) in the same pageblock.Interleave initialization of the unavailable pages with the normal initialization of memory map, so that zone and node information will be properly set on struct pages that are not backed by the actual memory.
With this change the pages for holes inside a zone will get proper zone/node links and the pages that are not spanned by any node will get links to the adjacent zone/node.
Fixes 73a6e474cb37 ("mm: memmap_init: iterate over memblock regions rather that check each PFN")Signed-off-by Mike Rapoport <[email protected]>Reported-by Qian Cai <[email protected]>Reported-by Andrea Arcangeli <[email protected]>Reviewed-by Baoquan He <[email protected]>--- mm/page_alloc.c | 147 +++++++++++++++++++++--------------------------- 1 file changed, 64 insertions(+), 83 deletions(-)mm/page_alloc.c +54
-0@@ -6280,12 +6280,60 @@ static void __meminit zone_init_free_lists(struct zone *zone) } } +#if !defined(CONFIG_FLAT_NODE_MEM_MAP ) +/* +* Only struct pages that correspond to ranges defined by memblock.memory +* are zeroed and initialized by going through __init_single_page() during +* memmap_init_zone(). +* +* But, there could be struct pages that correspond to holes in +* memblock.memory. This can happen because of the following reasons: +* - phyiscal memory bank size is not necessarily the exact multiple of the +* arbitrary section size +* - early reserved memory may not be listed in memblock.memory +* - memory layouts defined with memmap= kernel parameter may not align +* nicely with memmap sections +* +* Explicitly initialize those struct pages so that: +* - PG_Reserved is set +* - zone and node links point to zone and node that span the page +*/ +static u64 __meminit init_unavailable_range (unsigned long spfn, +unsigned long epfn, +int zone,int node) +{ +unsigned long pfn; +u64 pgcnt =0 ; + +for (pfn = spfn; pfn < epfn; pfn++) { +if (!pfn_valid (ALIGN_DOWN (pfn, pageblock_nr_pages))) { + pfn =ALIGN_DOWN (pfn, pageblock_nr_pages) + + pageblock_nr_pages -1 ; +continue ; + } +__init_single_page (pfn_to_page (pfn), pfn, zone, node); +__SetPageReserved (pfn_to_page (pfn)); + pgcnt++; + } + +return pgcnt; +} +#else +static inline u64 init_unavailable_range (unsigned long spfn,unsigned long epfn, +int zone,int node) +{ +return 0 ; +} +#endif +void __meminit __weak memmap_init_zone (struct zone *zone) {unsigned long zone_start_pfn = zone->zone_start_pfn;unsigned long zone_end_pfn = zone_start_pfn + zone->spanned_pages;int i, nid =zone_to_nid (zone), zone_id =zone_idx (zone); +static unsigned long hole_pfn =0 ;unsigned long start_pfn, end_pfn; +u64 pgcnt =0 ;for_each_mem_pfn_range (i, nid, &start_pfn, &end_pfn,NULL ) { start_pfn =clamp (start_pfn, zone_start_pfn, zone_end_pfn);@@ -6295,7 +6343,23 @@ void __meminit __weak memmap_init_zone(struct zone *zone)memmap_init_range (end_pfn - start_pfn, nid, zone_id, start_pfn, zone_end_pfn,MEMINIT_EARLY ,NULL ,MIGRATE_MOVABLE ); + +if (hole_pfn < start_pfn) + pgcnt +=init_unavailable_range (hole_pfn, start_pfn, + zone_id, nid); + hole_pfn = end_pfn; } +Quoted 8 lines
mm/page_alloc.c void __meminit __weak memmap_init_zone(struct zone *zone) · line 6357
Quoted 5 lines
mm/page_alloc.c +5
-0+#ifdef CONFIG_SPARSEMEM + end_pfn =round_up (zone_end_pfn,PAGES_PER_SECTION ); +if (hole_pfn < end_pfn) + pgcnt +=init_unavailable_range (hole_pfn, end_pfn, + zone_id, nid);We might still double-initialize PFNs when two zones overlap within a section, correct?
Quoted 8 lines
You mean that a section crosses zones boundary?
I don't think it's that important.Quoted 2 lines
This might worth documenting - also, you might want to take some of the original comment the accompanied this code.
The original comment was not exactly right, I believe the comment above
init_unavailable_range()better describes what's going on there.
Ah, okay - as long as it's documented I'm happy :)
Signature · 3 lines
Thanks, David / dhildenb
Re: [PATCH v7 1/1] mm/page_alloc.c: refactor initialization of struct page for holes in memory layout
In reply to Mike RapoportQuoted 7 lines · Mike Rapoport
Quoted 4 lines
We might still double-initialize PFNs when two zones overlap within a section, correct?
You mean that a section crosses zones boundary?
I don't think it's that important.
What if there was a memory allocation in between that could allocate the once-initialized page?
Maybe it can't happen, or is not an issue for some other reason, but this code has been fragile and had a ton of subtle issues, so maybe worth documenting (or explaining here why it's just not relevant)
Linus
Re: [PATCH v7 1/1] mm/page_alloc.c: refactor initialization of struct page for holes in memory layout
In reply to Vlastimil BabkaQuoted 31 lines · Vlastimil Babka
Quoted 1 line · Mike Rapoport
From: Mike Rapoport <[email protected]>
Hi, thanks for your efforts. I'll just nit pick on the description/comments as I don't feel confident about judging the implementation correctness, sorry :)
Quoted 25 lines
There could be struct pages that are not backed by actual physical memory. This can happen when the actual memory bank is not a multiple of
SECTION_SIZEor when an architecture does not register memory holes reserved by the firmware as memblock.memory.Such pages are currently initialized using
init_unavailable_mem()function that iterates through PFNs in holes in memblock.memory and if there is a struct page corresponding to a PFN, the fields of this page are set to default values and it is marked as Reserved.
init_unavailable_mem()does not take into account zone and node the page belongs to and sets both zone and node links in struct page to zero.Before commit
73a6e474cb37("mm:memmap_init: iterate over memblock regions rather that check each PFN") the holes inside a zone were re-initialized duringmemmap_init()and got their zone/node links right. However, after that commit nothing updates the struct pages representing such holes.On a system that has firmware reserved holes in a zone above
ZONE_DMA, for instance in a configuration below:# grep -A1 E820 /proc/iomem 7a17b000-7a216fff : Unknown E820 type 7a217000-7bffffff : System RAM
Quoted 6 lines
Quoted 3 lines
unset zone link in struct page will trigger
VM_BUG_ON_PAGE(!zone_spans_pfn(page_zone(page), pfn), page);... in
set_pfnblock_flags_mask()when called with a struct page from the "Unknown E820 type" range.
"... in set_pfnblock_flags_mask() when called with a struct page from a range other than E820_TYPE_RAM"
then :)
Quoted 4 lines
Quoted 2 lines
because there are pages in both
ZONE_DMA32andZONE_DMA(unset zone link in struct page) in the same pageblock.I would say "there are apparently pages" ... "and
ZONE_DMAdoes not span this range"
I'd rephrase it differently, something like
"because there are pages in the range of ZONE_DMA32 but the unset zone link in struct page makes them appear as a part of ZONE_DMA"
Quoted 10 lines
Quoted 7 lines
Interleave initialization of the unavailable pages with the normal initialization of memory map, so that zone and node information will be properly set on struct pages that are not backed by the actual memory.
With this change the pages for holes inside a zone will get proper zone/node links and the pages that are not spanned by any node will get links to the adjacent zone/node.
What if two zones are adjacent? I.e. if the hole was at a boundary between two zones.
What do you mean by "adjacent zones"? If there is a hole near the zone boundary, zone span would be clamped to exclude the hole.
Quoted 21 lines
Quoted 5 lines
Fixes 73a6e474cb37 ("mm: memmap_init: iterate over memblock regions rather that check each PFN")Signed-off-by Mike Rapoport <[email protected]>Reported-by Qian Cai <[email protected]>Reported-by Andrea Arcangeli <[email protected]>Reviewed-by Baoquan He <[email protected]>For the approach:
Acked-by Vlastimil Babka <[email protected]>Quoted 12 lines
--- mm/page_alloc.c | 147 +++++++++++++++++++++--------------------------- 1 file changed, 64 insertions(+), 83 deletions(-)mm/page_alloc.c +0
-0@@ -6280,12 +6280,60 @@ static void __meminit zone_init_free_lists(struct zone *zone) } }
Quoted 11 lines
mm/page_alloc.c static void __meminit zone_init_free_lists(struct zone *zone) · line 6291
Quoted 9 lines
mm/page_alloc.c +9
-0+#if !defined(CONFIG_FLAT_NODE_MEM_MAP ) +/* +* Only struct pages that correspond to ranges defined by memblock.memory +* are zeroed and initialized by going through __init_single_page() during +* memmap_init_zone(). +* +* But, there could be struct pages that correspond to holes in +* memblock.memory. This can happen because of the following reasons: +* - phyiscal memory bank size is not necessarily the exact multiple of the physical
Thanks.
Quoted 11 lines
mm/page_alloc.c static void __meminit zone_init_free_lists(struct zone *zone) · line 6299
Quoted 8 lines
mm/page_alloc.c +8
-0+* arbitrary section size +* - early reserved memory may not be listed in memblock.memory +* - memory layouts defined with memmap= kernel parameter may not align +* nicely with memmap sections +* +* Explicitly initialize those struct pages so that: +* - PG_Reserved is set +* - zone and node links point to zone and node that span the page Yes spanned pages are the most important, but should you also describe here the adjacent ones, as you do in commit log?
Will try :)
Quoted 163 lines
Quoted 162 lines
mm/page_alloc.c +47
-83+*/ +static u64 __meminit init_unavailable_range (unsigned long spfn, +unsigned long epfn, +int zone,int node) +{ +unsigned long pfn; +u64 pgcnt =0 ; + +for (pfn = spfn; pfn < epfn; pfn++) { +if (!pfn_valid (ALIGN_DOWN (pfn, pageblock_nr_pages))) { + pfn =ALIGN_DOWN (pfn, pageblock_nr_pages) + + pageblock_nr_pages -1 ; +continue ; + } +__init_single_page (pfn_to_page (pfn), pfn, zone, node); +__SetPageReserved (pfn_to_page (pfn)); + pgcnt++; + } + +return pgcnt; +} +#else +static inline u64 init_unavailable_range (unsigned long spfn,unsigned long epfn, +int zone,int node) +{ +return 0 ; +} +#endif +void __meminit __weak memmap_init_zone (struct zone *zone) {unsigned long zone_start_pfn = zone->zone_start_pfn;unsigned long zone_end_pfn = zone_start_pfn + zone->spanned_pages;int i, nid =zone_to_nid (zone), zone_id =zone_idx (zone); +static unsigned long hole_pfn =0 ;unsigned long start_pfn, end_pfn; +u64 pgcnt =0 ;for_each_mem_pfn_range (i, nid, &start_pfn, &end_pfn,NULL ) { start_pfn =clamp (start_pfn, zone_start_pfn, zone_end_pfn);@@ -6295,7 +6343,23 @@ void __meminit __weak memmap_init_zone(struct zone *zone)memmap_init_range (end_pfn - start_pfn, nid, zone_id, start_pfn, zone_end_pfn,MEMINIT_EARLY ,NULL ,MIGRATE_MOVABLE ); + +if (hole_pfn < start_pfn) + pgcnt +=init_unavailable_range (hole_pfn, start_pfn, + zone_id, nid); + hole_pfn = end_pfn; } + +#ifdef CONFIG_SPARSEMEM + end_pfn =round_up (zone_end_pfn,PAGES_PER_SECTION ); +if (hole_pfn < end_pfn) + pgcnt +=init_unavailable_range (hole_pfn, end_pfn, + zone_id, nid); +#endif + +if (pgcnt) +pr_info (" %s zone: %lld pages in unavailable ranges\n" , + zone->name, pgcnt); }static int zone_batchsize (struct zone *zone)@@ -7092,88 +7156,6 @@ void __init free_area_init_memoryless_node(int nid)free_area_init_node (nid); } -#if !defined(CONFIG_FLAT_NODE_MEM_MAP ) -/* -* Initialize all valid struct pages in the range [spfn, epfn) and mark them -* PageReserved(). Return the number of struct pages that were initialized. -*/ -static u64 __init init_unavailable_range (unsigned long spfn,unsigned long epfn) -{ -unsigned long pfn; -u64 pgcnt =0 ; - -for (pfn = spfn; pfn < epfn; pfn++) { -if (!pfn_valid (ALIGN_DOWN (pfn, pageblock_nr_pages))) { - pfn =ALIGN_DOWN (pfn, pageblock_nr_pages) - + pageblock_nr_pages -1 ; -continue ; - } -/* -* Use a fake node/zone (0) for now. Some of these pages -* (in memblock.reserved but not in memblock.memory) will -* get re-initialized via reserve_bootmem_region() later. -*/ -__init_single_page (pfn_to_page (pfn), pfn,0 ,0 ); -__SetPageReserved (pfn_to_page (pfn)); - pgcnt++; - } - -return pgcnt; -} - -/* -* Only struct pages that are backed by physical memory are zeroed and -* initialized by going through __init_single_page(). But, there are some -* struct pages which are reserved in memblock allocator and their fields -* may be accessed (for example page_to_pfn() on some configuration accesses -* flags). We must explicitly initialize those struct pages. -* -* This function also addresses a similar issue where struct pages are left -* uninitialized because the physical address range is not covered by -* memblock.memory or memblock.reserved. That could happen when memblock -* layout is manually configured via memmap=, or when the highest physical -* address (max_pfn) does not end on a section boundary. -*/ -static void __init init_unavailable_mem (void ) -{ -phys_addr_t start, end; -u64 i, pgcnt; -phys_addr_t next =0 ; - -/* -* Loop through unavailable ranges not covered by memblock.memory. -*/ - pgcnt =0 ; -for_each_mem_range (i, &start, &end) { -if (next < start) - pgcnt +=init_unavailable_range (PFN_DOWN (next), -PFN_UP (start)); - next = end; - } - -/* -* Early sections always have a fully populated memmap for the whole -* section - see pfn_valid(). If the last section has holes at the -* end and that section is marked "online", the memmap will be -* considered initialized. Make sure that memmap has a well defined -* state. -*/ - pgcnt +=init_unavailable_range (PFN_DOWN (next), -round_up (max_pfn,PAGES_PER_SECTION )); - -/* -* Struct pages that do not have backing memory. This could be because -* firmware is using some of this memory, or for some other reasons. -*/ -if (pgcnt) -pr_info ("Zeroed struct page in unavailable ranges: %lld pages" , pgcnt); -} -#else -static inline void __init init_unavailable_mem (void ) -{ -} -#endif /* !CONFIG_FLAT_NODE_MEM_MAP */ -#if MAX_NUMNODES >1 /* * Figure out the number of possible node ids. @@ -7597,7 +7579,6 @@ void __init free_area_init(unsigned long *max_zone_pfn)/* Initialise every node */ mminit_verify_pageflags_layout ();setup_nr_node_ids (); -init_unavailable_mem ();for_each_online_node (nid) {pg_data_t *pgdat =NODE_DATA (nid);free_area_init_node (nid);
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH v7 1/1] mm/page_alloc.c: refactor initialization of struct page for holes in memory layout
In reply to Linus TorvaldsQuoted 11 lines · Linus Torvalds
Quoted 7 lines · Mike Rapoport
Quoted 4 lines
We might still double-initialize PFNs when two zones overlap within a section, correct?
You mean that a section crosses zones boundary?
I don't think it's that important.What if there was a memory allocation in between that could allocate the once-initialized page?
Can't happen because this code runs before any allocation is possible and it is single threaded.
Quoted 3 lines
Maybe it can't happen, or is not an issue for some other reason, but this code has been fragile and had a ton of subtle issues, so maybe worth documenting (or explaining here why it's just not relevant)
Ok, I'll do another pass on the comments in the code.
Quoted 1 line
Linus
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH v7 1/1] mm/page_alloc.c: refactor initialization of struct page for holes in memory layout
In reply to Mike RapoportQuoted 6 lines · Mike Rapoport
Quoted 5 lines · Vlastimil Babka
Quoted 4 lines
unset zone link in struct page will trigger
VM_BUG_ON_PAGE(!zone_spans_pfn(page_zone(page), pfn), page);
Quoted 7 lines
Quoted 2 lines
... in
set_pfnblock_flags_mask()when called with a struct page from the "Unknown E820 type" range."... in
set_pfnblock_flags_mask()when called with a struct page from a range other thanE820_TYPE_RAM"then :)
Better :)
Quoted 9 lines
Quoted 4 lines
Quoted 2 lines
because there are pages in both
ZONE_DMA32andZONE_DMA(unset zone link in struct page) in the same pageblock.I would say "there are apparently pages" ... "and
ZONE_DMAdoes not span this range"I'd rephrase it differently, something like
"because there are pages in the range of
ZONE_DMA32but the unset zone link in struct page makes them appear as a part ofZONE_DMA"
Much better, thanks!
Quoted 8 lines
Quoted 8 lines
Quoted 7 lines
Interleave initialization of the unavailable pages with the normal initialization of memory map, so that zone and node information will be properly set on struct pages that are not backed by the actual memory.
With this change the pages for holes inside a zone will get proper zone/node links and the pages that are not spanned by any node will get links to the adjacent zone/node.
Quoted 5 lines
Quoted 2 lines
What if two zones are adjacent? I.e. if the hole was at a boundary between two zones.
What do you mean by "adjacent zones"? If there is a hole near the zone boundary, zone span would be clamped to exclude the hole.
Yeah, zone span should exclude those pages, but you still somehow handle them? That's how I read "pages that are not spanned by any node will get links to the adjacent zone/node."
So is it always a unique zone/node can be determined?
Let's say we have:
<memory on node 0>
---- pageblock boundary ----
<more memory on node 0>
<a hole>
<memory on node 1>
---- pageblock boundary ----
Now I hope such configurations don't really exist :) But if we simulated them in QEMU, what would be the linkage in struct pages in that hole?
Re: [PATCH v7 1/1] mm/page_alloc.c: refactor initialization of struct page for holes in memory layout
Quoted 22 lines · Vlastimil Babka
Quoted 6 lines · Mike Rapoport
Quoted 3 lines
What if two zones are adjacent? I.e. if the hole was at a boundary between two zones.
What do you mean by "adjacent zones"? If there is a hole near the zone boundary, zone span would be clamped to exclude the hole.
Yeah, zone span should exclude those pages, but you still somehow handle them? That's how I read "pages that are not spanned by any node will get links to the adjacent zone/node."
So is it always a unique zone/node can be determined?Let's say we have:
<memory on node 0>
---- pageblock boundary ----
<more memory on node 0>
<a hole>
<memory on node 1>
---- pageblock boundary ----
Quoted 2 lines
Now I hope such configurations don't really exist :) But if we simulated them in QEMU, what would be the linkage in struct pages in that hole?
I don't think such configuration is possible in practice but it can be forced with e.g memmap="2M hole at 4G - 1M".
The hole in your example the hole will get node1 for node and zone that spans the beginning of node1 for zone.
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH v7 1/1] mm/page_alloc.c: refactor initialization of struct page for holes in memory layout
Quoted 23 lines · Mike Rapoport
Quoted 22 lines · Vlastimil Babka
Quoted 6 lines · Mike Rapoport
Quoted 3 lines
What if two zones are adjacent? I.e. if the hole was at a boundary between two zones.
What do you mean by "adjacent zones"? If there is a hole near the zone boundary, zone span would be clamped to exclude the hole.
Yeah, zone span should exclude those pages, but you still somehow handle them? That's how I read "pages that are not spanned by any node will get links to the adjacent zone/node."
So is it always a unique zone/node can be determined?Let's say we have:
<memory on node 0>
---- pageblock boundary ----
<more memory on node 0>
<a hole>
<memory on node 1>
---- pageblock boundary ----
Quoted 5 lines
Quoted 2 lines
Now I hope such configurations don't really exist :) But if we simulated them in QEMU, what would be the linkage in struct pages in that hole?
I don't think such configuration is possible in practice but it can be forced with e.g memmap="2M hole at 4G - 1M".
Right.
Quoted 2 lines
The hole in your example the hole will get node1 for node and zone that spans the beginning of node1 for zone.
Yeah the comments in v8 make that clear now, thanks!