Double check memmap is actually valid with a memmap has unexpected holes
Subsystems (5)
PATCH 1/1 Double check memmap is actually valid with a memmap has unexpected holes
pfn_valid() is meant to be able to tell if a given PFN has valid memmap associated with it or not. In FLATMEM, it is expected that holes always have valid memmap as long as there is valid PFNs either side of the hole. In SPARSEMEM, it is assumed that a valid section has a memmap for the entire section.
However, ARM and maybe other embedded architectures in the future free memmap backing holes to save memory on the assumption the memmap is never used. The page_zone() linkages are then broken even though pfn_valid() returns true. A walker of the full memmap in this case must do additional check to ensure the memmap they are looking at is sane by making sure the zone and PFN linkages are still valid. This is expensive, but walkers of the full memmap are extremely rare.
This was caught before for FLATMEM and hacked around but it hits again for SPARSEMEM because the page_zone() linkages can look ok where the PFN linkages are totally screwed. This looks like a hatchet job but the reality is that any clean solution would end up consuming all the memory saved by punching these unexpected holes in the memmap. For example, we tried marking the memmap within the section invalid but the section size exceeds the size of the hole in most cases so pfn_valid() starts returning false where valid memmap exists. Shrinking the size of the section would increase memory consumption offsetting the gains.
This patch identifies when an architecture is punching unexpected holes in the memmap that the memory model cannot automatically detect. When set, walkers of the full memmap must call memmap_valid_within() for each PFN and passing in what it expects the page and zone to be for that PFN. If it finds the linkages to be broken, it assumes the memmap is invalid for that PFN.
---
arch/arm/Kconfig | 3 +-- include/linux/mmzone.h | 26 ++++++++++++++++++++++++++ mm/mmzone.c | 15 +++++++++++++++ mm/vmstat.c | 19 ++++--------------- 4 files changed, 46 insertions(+), 17 deletions(-)
arch/arm/Kconfig +1 -2
@@ -925,10 +925,9 @@ config OABI_COMPAT UNPREDICTABLE (in fact it can be predicted that it won't work at all). If in doubt say Y. -config ARCH_FLATMEM_HAS_HOLES +config ARCH_HAS_HOLES_MEMORYMODEL bool default y - depends on FLATMEM # Discontigmem is deprecated config ARCH_DISCONTIGMEM_ENABLE
include/linux/mmzone.h +26 -0
@@ -1104,6 +1104,32 @@ unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);#define pfn_valid_within (pfn) (1)#endif +#ifdef CONFIG_ARCH_HAS_HOLES_MEMORYMODEL +/* +* pfn_valid() is meant to be able to tell if a given PFN has valid memmap +* associated with it or not. In FLATMEM, it is expected that holes always +* have valid memmap as long as there is valid PFNs either side of the hole. +* In SPARSEMEM, it is assumed that a valid section has a memmap for the +* entire section. +* +* However, an ARM, and maybe other embedded architectures in the future +* free memmap backing holes to save memory on the assumption the memmap is +* never used. The page_zone linkages are then broken even though pfn_valid() +* returns true. A walker of the full memmap must then do this additional +* check to ensure the memmap they are looking at is sane by making sure +* the zone and PFN linkages are still valid. This is expensive, but walkers +* of the full memmap are extremely rare. +*/ +int memmap_valid_within (unsigned long pfn, +struct page *page,struct zone *zone); +#else +static inline int memmap_valid_within (unsigned long pfn, +struct page *page,struct zone *zone) +{ +return 1 ; +} +#endif /* CONFIG_ARCH_HAS_HOLES_MEMORYMODEL */ +#endif /* !__GENERATING_BOUNDS.H */ #endif /* !__ASSEMBLY__ */ #endif /* _LINUX_MMZONE_H */
mm/mmzone.c +15 -0
@@ -6,6 +6,7 @@#include <linux/stddef.h> +#include <linux/mm.h> #include <linux/mmzone.h> #include <linux/module.h>
@@ -72,3 +73,17 @@ struct zoneref *next_zones_zonelist(struct zoneref *z, *zone =zonelist_zone (z);return z; } + +#ifdef CONFIG_ARCH_HAS_HOLES_MEMORYMODEL +int memmap_valid_within (unsigned long pfn, +struct page *page,struct zone *zone) +{ +if (page_to_pfn (page) != pfn) +return 0 ; + +if (page_zone (page) != zone) +return 0 ; + +return 1 ; +} +#endif /* CONFIG_ARCH_HAS_HOLES_MEMORYMODEL */
mm/vmstat.c +4 -15
@@ -509,22 +509,11 @@ static void pagetypeinfo_showblockcount_print(struct seq_file *m,continue ; page =pfn_to_page (pfn); -#ifdef CONFIG_ARCH_FLATMEM_HAS_HOLES -/* -* Ordinarily, memory holes in flatmem still have a valid -* memmap for the PFN range. However, an architecture for -* embedded systems (e.g. ARM) can free up the memmap backing -* holes to save memory on the assumption the memmap is -* never used. The page_zone linkages are then broken even -* though pfn_valid() returns true. Skip the page if the -* linkages are broken. Even if this test passed, the impact -* is that the counters for the movable type are off but -* fragmentation monitoring is likely meaningless on small -* systems. -*/ -if (page_zone (page) != zone) + +/* Watch for unexpected holes punched in the memmap */ +if (!memmap_valid_within (pfn, page, zone))continue ; -#endif + mtype =get_pageblock_migratetype (page);if (mtype <MIGRATE_TYPES )
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
arch/arm/Kconfig config OABI_COMPAT · line 928
Quoted 10 lines · Mel Gorman
arch/arm/Kconfig +1
-1@@ -925,10 +925,9 @@ config OABI_COMPAT UNPREDICTABLE (in fact it can be predicted that it won't work at all). If in doubt say Y. -config ARCH_FLATMEM_HAS_HOLES +config ARCH_HAS_HOLES_MEMORYMODEL
Can we arrange for EP93xx to select this so we don't have it enabled for everyone.
The other user of this was RPC when it was flatmem only, but since it has been converted to sparsemem it's no longer an issue there.
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Quoted 9 lines · Russell King - ARM Linux
Quoted 8 lines · Mel Gorman
arch/arm/Kconfig +0
-0@@ -925,10 +925,9 @@ config OABI_COMPAT UNPREDICTABLE (in fact it can be predicted that it won't work at all). If in doubt say Y.
Quoted 9 lines
arch/arm/Kconfig config OABI_COMPAT · line 928
Quoted 2 lines
arch/arm/Kconfig +1
-1-config ARCH_FLATMEM_HAS_HOLES +config ARCH_HAS_HOLES_MEMORYMODELCan we arrange for EP93xx to select this so we don't have it enabled for everyone.
The other user of this was RPC when it was flatmem only, but since it has been converted to sparsemem it's no longer an issue there.
This problem is hitting SPARSEMEM, at least according to reports I have been cc'd on so it's not a SPARSEMEM vs FLATMEM thing. From the leader -- "This was caught before for FLATMEM and hacked around but it hits again for SPARSEMEM because the page_zone linkages can look ok where the PFN linkages are totally screwed."
If you feel that this problem is only encountered on the EP93xx, then the option could be made more conservative with the following (untested) patch and then wait to see who complains.
==== CUT HERE ====
arm: Only select ARCH_HAS_HOLES_MEMORYMODEL on the EP93xx
ARM frees unused memmap to save memory but this can collide with the core VM's view of the memory model when walking what it views to be valid PFNs in the system. ARM selects ARCH_HAS_HOLES_MEMORYMODEL for all architectures to double check the memmap being examined is valid but it has been asserted that this may only be needed on EP93xx in practice. This patch selects ARCH_HAS_HOLES_MEMORYMODEL only for that sub-architecture.
---
arch/arm/Kconfig | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
arch/arm/Kconfig +2 -1
@@ -273,6 +273,7 @@ config ARCH_EP93XX select HAVE_CLK select COMMON_CLKDEV select ARCH_REQUIRE_GPIOLIB + select ARCH_HAS_HOLES_MEMORYMODEL help This enables support for the Cirrus EP93xx series of CPUs.
@@ -927,7 +928,7 @@ config OABI_COMPAT config ARCH_HAS_HOLES_MEMORYMODEL bool - default y + default n # Discontigmem is deprecated config ARCH_DISCONTIGMEM_ENABLE
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
PATCH 1/1 Double check memmap is actually valid with a memmap has unexpected holes V2
Quoted 26 lines · Mel Gorman
Quoted 9 lines · Russell King - ARM Linux
Quoted 8 lines · Mel Gorman
arch/arm/Kconfig +0
-0@@ -925,10 +925,9 @@ config OABI_COMPAT UNPREDICTABLE (in fact it can be predicted that it won't work at all). If in doubt say Y.Quoted 9 lines
arch/arm/Kconfig config OABI_COMPAT · line 928
Quoted 2 lines
arch/arm/Kconfig +1
-1-config ARCH_FLATMEM_HAS_HOLES +config ARCH_HAS_HOLES_MEMORYMODELCan we arrange for EP93xx to select this so we don't have it enabled for everyone.
The other user of this was RPC when it was flatmem only, but since it has been converted to sparsemem it's no longer an issue there.
This problem is hitting SPARSEMEM, at least according to reports I have been cc'd on so it's not a SPARSEMEM vs FLATMEM thing. From the leader -- "This was caught before for FLATMEM and hacked around but it hits again for SPARSEMEM because the
page_zonelinkages can look ok where the PFN linkages are totally screwed."
Quoted 4 lines
If you feel that this problem is only encountered on the EP93xx, then the option could be made more conservative with the following (untested) patch and then wait to see who complains.
This problem is still there. Russell, would you be ok with picking up this version of the fix? There were suggestions for modifying the generic code further but they are not critical to the problem on ARM and could be done as a follow-up patch.
==== CUT HERE ====
Double check memmap is actually valid with a memmap has unexpected holes V2
Changelog since V1
o Restrict to EP93xx
pfn_valid() is meant to be able to tell if a given PFN has valid memmap associated with it or not. In FLATMEM, it is expected that holes always have valid memmap as long as there is valid PFNs either side of the hole. In SPARSEMEM, it is assumed that a valid section has a memmap for the entire section.
However, ARM and maybe other embedded architectures in the future free memmap backing holes to save memory on the assumption the memmap is never used. The page_zone linkages are then broken even though pfn_valid() returns true. A walker of the full memmap must then do this additional check to ensure the memmap they are looking at is sane by making sure the zone and PFN linkages are still valid. This is expensive, but walkers of the full memmap are extremely rare.
This was caught before for FLATMEM and hacked around but it hits again for SPARSEMEM because the page_zone linkages can look ok where the PFN linkages are totally screwed. This looks like a hatchet job but the reality is that any clean solution would end up consumning all the memory saved by punching these unexpected holes in the memmap. For example, we tried marking the memmap within the section invalid but the section size exceeds the size of the hole in most cases so pfn_valid() starts returning false where valid memmap exists. Shrinking the size of the section would increase memory consumption offsetting the gains.
This patch identifies when an architecture is punching unexpected holes in the memmap that the memory model cannot automatically detect and sets ARCH_HAS_HOLES_MEMORYMODEL. At the moment, this is restricted to EP93xx which is the model sub-architecture this has been reported on but may expand later. When set, walkers of the full memmap must call memmap_valid_within() for each PFN and passing in what it expects the page and zone to be for that PFN. If it finds the linkages to be broken, it assumes the memmap is invalid for that PFN.
---
arch/arm/Kconfig | 6 +++--- include/linux/mmzone.h | 26 ++++++++++++++++++++++++++ mm/mmzone.c | 15 +++++++++++++++ mm/vmstat.c | 19 ++++--------------- 4 files changed, 48 insertions(+), 18 deletions(-)
arch/arm/Kconfig +3 -3
@@ -273,6 +273,7 @@ config ARCH_EP93XX select HAVE_CLK select COMMON_CLKDEV select ARCH_REQUIRE_GPIOLIB + select ARCH_HAS_HOLES_MEMORYMODEL help This enables support for the Cirrus EP93xx series of CPUs.
@@ -925,10 +926,9 @@ config OABI_COMPAT UNPREDICTABLE (in fact it can be predicted that it won't work at all). If in doubt say Y. -config ARCH_FLATMEM_HAS_HOLES +config ARCH_HAS_HOLES_MEMORYMODEL bool - default y - depends on FLATMEM + default n # Discontigmem is deprecated config ARCH_DISCONTIGMEM_ENABLE
include/linux/mmzone.h +26 -0
@@ -1104,6 +1104,32 @@ unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);#define pfn_valid_within (pfn) (1)#endif +#ifdef CONFIG_ARCH_HAS_HOLES_MEMORYMODEL +/* +* pfn_valid() is meant to be able to tell if a given PFN has valid memmap +* associated with it or not. In FLATMEM, it is expected that holes always +* have valid memmap as long as there is valid PFNs either side of the hole. +* In SPARSEMEM, it is assumed that a valid section has a memmap for the +* entire section. +* +* However, an ARM, and maybe other embedded architectures in the future +* free memmap backing holes to save memory on the assumption the memmap is +* never used. The page_zone linkages are then broken even though pfn_valid() +* returns true. A walker of the full memmap must then do this additional +* check to ensure the memmap they are looking at is sane by making sure +* the zone and PFN linkages are still valid. This is expensive, but walkers +* of the full memmap are extremely rare. +*/ +int memmap_valid_within (unsigned long pfn, +struct page *page,struct zone *zone); +#else +static inline int memmap_valid_within (unsigned long pfn, +struct page *page,struct zone *zone) +{ +return 1 ; +} +#endif /* CONFIG_ARCH_HAS_HOLES_MEMORYMODEL */ +#endif /* !__GENERATING_BOUNDS.H */ #endif /* !__ASSEMBLY__ */ #endif /* _LINUX_MMZONE_H */
mm/mmzone.c +15 -0
@@ -6,6 +6,7 @@#include <linux/stddef.h> +#include <linux/mm.h> #include <linux/mmzone.h> #include <linux/module.h>
@@ -72,3 +73,17 @@ struct zoneref *next_zones_zonelist(struct zoneref *z, *zone =zonelist_zone (z);return z; } + +#ifdef CONFIG_ARCH_HAS_HOLES_MEMORYMODEL +int memmap_valid_within (unsigned long pfn, +struct page *page,struct zone *zone) +{ +if (page_to_pfn (page) != pfn) +return 0 ; + +if (page_zone (page) != zone) +return 0 ; + +return 1 ; +} +#endif /* CONFIG_ARCH_HAS_HOLES_MEMORYMODEL */
mm/vmstat.c +4 -15
@@ -509,22 +509,11 @@ static void pagetypeinfo_showblockcount_print(struct seq_file *m,continue ; page =pfn_to_page (pfn); -#ifdef CONFIG_ARCH_FLATMEM_HAS_HOLES -/* -* Ordinarily, memory holes in flatmem still have a valid -* memmap for the PFN range. However, an architecture for -* embedded systems (e.g. ARM) can free up the memmap backing -* holes to save memory on the assumption the memmap is -* never used. The page_zone linkages are then broken even -* though pfn_valid() returns true. Skip the page if the -* linkages are broken. Even if this test passed, the impact -* is that the counters for the movable type are off but -* fragmentation monitoring is likely meaningless on small -* systems. -*/ -if (page_zone (page) != zone) + +/* Watch for unexpected holes punched in the memmap */ +if (!memmap_valid_within (pfn, page, zone))continue ; -#endif + mtype =get_pageblock_migratetype (page);if (mtype <MIGRATE_TYPES )
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Andrew Morton
maintainerRe: [PATCH] Double check memmap is actually valid with a memmap has unexpected holes V2
Quoted 24 lines · On Wed, 13 May 2009 17:34:48 +0100 Mel Gorman <[email protected]> wrote:
pfn_valid()is meant to be able to tell if a given PFN has valid memmap associated with it or not. In FLATMEM, it is expected that holes always have valid memmap as long as there is valid PFNs either side of the hole. In SPARSEMEM, it is assumed that a valid section has a memmap for the entire section.However, ARM and maybe other embedded architectures in the future free memmap backing holes to save memory on the assumption the memmap is never used. The
page_zonelinkages are then broken even thoughpfn_valid()returns true. A walker of the full memmap must then do this additional check to ensure the memmap they are looking at is sane by making sure the zone and PFN linkages are still valid. This is expensive, but walkers of the full memmap are extremely rare.This was caught before for FLATMEM and hacked around but it hits again for SPARSEMEM because the
page_zonelinkages can look ok where the PFN linkages are totally screwed. This looks like a hatchet job but the reality is that any clean solution would end up consumning all the memory saved by punching these unexpected holes in the memmap. For example, we tried marking the memmap within the section invalid but the section size exceeds the size of the hole in most cases sopfn_valid()starts returning false where valid memmap exists. Shrinking the size of the section would increase memory consumption offsetting the gains.
Quoted 8 lines
This patch identifies when an architecture is punching unexpected holes in the memmap that the memory model cannot automatically detect and sets
ARCH_HAS_HOLES_MEMORYMODEL. At the moment, this is restricted to EP93xx which is the model sub-architecture this has been reported on but may expand later. When set, walkers of the full memmap must callmemmap_valid_within()for each PFN and passing in what it expects the page and zone to be for that PFN. If it finds the linkages to be broken, it assumes the memmap is invalid for that PFN.
It's unclear to me whether this patch is needed in 2.6.30 or even 2.6.29 or whatever.
It applies OK to 2.6.28, 2.6.29, current mainline and mmotm, so I'll just sit tight until I'm told what to do.
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [PATCH] Double check memmap is actually valid with a memmap has unexpected holes V2
Quoted 36 lines · Andrew Morton
Quoted 24 lines · On Wed, 13 May 2009 17:34:48 +0100 Mel Gorman <[email protected]> wrote:
pfn_valid()is meant to be able to tell if a given PFN has valid memmap associated with it or not. In FLATMEM, it is expected that holes always have valid memmap as long as there is valid PFNs either side of the hole. In SPARSEMEM, it is assumed that a valid section has a memmap for the entire section.However, ARM and maybe other embedded architectures in the future free memmap backing holes to save memory on the assumption the memmap is never used. The
page_zonelinkages are then broken even thoughpfn_valid()returns true. A walker of the full memmap must then do this additional check to ensure the memmap they are looking at is sane by making sure the zone and PFN linkages are still valid. This is expensive, but walkers of the full memmap are extremely rare.This was caught before for FLATMEM and hacked around but it hits again for SPARSEMEM because the
page_zonelinkages can look ok where the PFN linkages are totally screwed. This looks like a hatchet job but the reality is that any clean solution would end up consumning all the memory saved by punching these unexpected holes in the memmap. For example, we tried marking the memmap within the section invalid but the section size exceeds the size of the hole in most cases sopfn_valid()starts returning false where valid memmap exists. Shrinking the size of the section would increase memory consumption offsetting the gains.Quoted 8 lines
This patch identifies when an architecture is punching unexpected holes in the memmap that the memory model cannot automatically detect and sets
ARCH_HAS_HOLES_MEMORYMODEL. At the moment, this is restricted to EP93xx which is the model sub-architecture this has been reported on but may expand later. When set, walkers of the full memmap must callmemmap_valid_within()for each PFN and passing in what it expects the page and zone to be for that PFN. If it finds the linkages to be broken, it assumes the memmap is invalid for that PFN.
Quoted 3 lines
It's unclear to me whether this patch is needed in 2.6.30 or even 2.6.29 or whatever.
It affected at least 2.6.28.4 so minimally, I'd like to see it in for 2.6.30. I think it's a -stable candidate but I'd like to hear from the ARM maintainer on whether he wants to push it or not to that tree.
Quoted 3 lines
It applies OK to 2.6.28, 2.6.29, current mainline and mmotm, so I'll just sit tight until I'm told what to do.
Please merge for 2.6.30 at least. Russell, are you ok with that? Are you ok with this being pushed to -stable?
Thanks
Signature · 9 lines
Mel Gorman Part-time Phd Student Linux Technology Center University of Limerick IBM Dublin Software Lab -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [PATCH] Double check memmap is actually valid with a memmap has unexpected holes V2
Quoted 3 lines · Mel Gorman
It affected at least 2.6.28.4 so minimally, I'd like to see it in for 2.6.30. I think it's a -stable candidate but I'd like to hear from the ARM maintainer on whether he wants to push it or not to that tree.
I'm inclined to agree.
Quoted 6 lines
Quoted 3 lines
It applies OK to 2.6.28, 2.6.29, current mainline and mmotm, so I'll just sit tight until I'm told what to do.
Please merge for 2.6.30 at least. Russell, are you ok with that? Are you ok with this being pushed to -stable?
I'll merge it into my master branch, which'll be going to Linus in the next few days.
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Hi Mel,
Quoted 24 lines · Mel Gorman
pfn_valid()is meant to be able to tell if a given PFN has valid memmap associated with it or not. In FLATMEM, it is expected that holes always have valid memmap as long as there is valid PFNs either side of the hole. In SPARSEMEM, it is assumed that a valid section has a memmap for the entire section.However, ARM and maybe other embedded architectures in the future free memmap backing holes to save memory on the assumption the memmap is never used. The
page_zone()linkages are then broken even thoughpfn_valid()returns true. A walker of the full memmap in this case must do additional check to ensure the memmap they are looking at is sane by making sure the zone and PFN linkages are still valid. This is expensive, but walkers of the full memmap are extremely rare.This was caught before for FLATMEM and hacked around but it hits again for SPARSEMEM because the
page_zone()linkages can look ok where the PFN linkages are totally screwed. This looks like a hatchet job but the reality is that any clean solution would end up consuming all the memory saved by punching these unexpected holes in the memmap. For example, we tried marking the memmap within the section invalid but the section size exceeds the size of the hole in most cases sopfn_valid()starts returning false where valid memmap exists. Shrinking the size of the section would increase memory consumption offsetting the gains.
Quoted 7 lines
This patch identifies when an architecture is punching unexpected holes in the memmap that the memory model cannot automatically detect. When set, walkers of the full memmap must call
memmap_valid_within()for each PFN and passing in what it expects the page and zone to be for that PFN. If it finds the linkages to be broken, it assumes the memmap is invalid for that PFN.Signed-off-by Mel Gorman <[email protected]>
I think we also need to fix up show_mem(). Attached is a compile-tested patch, please have a look. I am not sure about memory hotplug issues but on a quick glance the vmstat stuff seems to be optimistic as well.
---
From: Johannes Weiner <[email protected]>
Subject: lib: adjust show_mem() to support memmap holes
Some architectures free the backing of mem_map holes. pfn_valid() is not able to report this properly, so a stronger check is needed if the caller is about to use the page descriptor derived from a pfn.
Change the node walking to zone walking and use memmap_valid_within() to check for holes. This is reliable as it additionally checks for page_zone() and page_to_pfn() coherency.
--- lib/show_mem.c | 21 +++++++++------------ 1 files changed, 9 insertions(+), 12 deletions(-)
lib/show_mem.c +9 -12
@@ -11,29 +11,27 @@void show_mem (void ) { -pg_data_t *pgdat;unsigned long total =0 , reserved =0 , shared =0 , nonshared =0 , highmem =0 ; +struct zone *zone;printk (KERN_INFO "Mem-Info:\n" );show_free_areas (); -for_each_online_pgdat (pgdat) { -unsigned long i, flags; +for_each_populated_zone (zone) { +unsigned long start = zone->zone_start_pfn; +unsigned long end = start + zone->spanned_pages; +unsigned long pfn; -pgdat_resize_lock (pgdat, &flags); -for (i =0 ; i < pgdat->node_spanned_pages; i++) { -struct page *page; -unsigned long pfn = pgdat->node_start_pfn + i; +for (pfn = start; pfn < end; pfn++) { +struct page *page =pfn_to_page (pfn); -if (unlikely (!(i %MAX_ORDER_NR_PAGES ))) +if (unlikely (!(pfn %MAX_ORDER_NR_PAGES )))touch_nmi_watchdog (); -if (!pfn_valid (pfn)) +if (!memmap_valid_within (pfn, page, zone))continue ; - page =pfn_to_page (pfn); -if (PageHighMem (page)) highmem++;
@@ -46,7 +44,6 @@ void show_mem(void) total++; } -pgdat_resize_unlock (pgdat, &flags); }printk (KERN_INFO "%lu pages RAM\n" , total);
Signature · 7 lines
1.6.2.1.135.gde769 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Quoted 33 lines · Johannes Weiner
Hi Mel,
Quoted 30 lines · Mel Gorman
pfn_valid()is meant to be able to tell if a given PFN has valid memmap associated with it or not. In FLATMEM, it is expected that holes always have valid memmap as long as there is valid PFNs either side of the hole. In SPARSEMEM, it is assumed that a valid section has a memmap for the entire section.However, ARM and maybe other embedded architectures in the future free memmap backing holes to save memory on the assumption the memmap is never used. The
page_zone()linkages are then broken even thoughpfn_valid()returns true. A walker of the full memmap in this case must do additional check to ensure the memmap they are looking at is sane by making sure the zone and PFN linkages are still valid. This is expensive, but walkers of the full memmap are extremely rare.This was caught before for FLATMEM and hacked around but it hits again for SPARSEMEM because the
page_zone()linkages can look ok where the PFN linkages are totally screwed. This looks like a hatchet job but the reality is that any clean solution would end up consuming all the memory saved by punching these unexpected holes in the memmap. For example, we tried marking the memmap within the section invalid but the section size exceeds the size of the hole in most cases sopfn_valid()starts returning false where valid memmap exists. Shrinking the size of the section would increase memory consumption offsetting the gains.This patch identifies when an architecture is punching unexpected holes in the memmap that the memory model cannot automatically detect. When set, walkers of the full memmap must call
memmap_valid_within()for each PFN and passing in what it expects the page and zone to be for that PFN. If it finds the linkages to be broken, it assumes the memmap is invalid for that PFN.
Quoted 3 lines
Quoted 1 line
Signed-off-by Mel Gorman <[email protected]>I think we also need to fix up
show_mem().
As it turns out, ARM has its own show_mem(). I don't see how, but ARM must not be using lib/show_mem.c even though it compiles it.
Quoted 33 lines
Attached is a
compile-tested patch, please have a look. I am not sure about memory hotplug issues but on a quick glance the vmstat stuff seems to be optimistic as well.---
From: Johannes Weiner <[email protected]>
Subject: lib: adjustshow_mem()to support memmap holesSome architectures free the backing of
mem_mapholes.pfn_valid()is not able to report this properly, so a stronger check is needed if the caller is about to use the page descriptor derived from a pfn.Change the node walking to zone walking and use
memmap_valid_within()to check for holes. This is reliable as it additionally checks forpage_zone()andpage_to_pfn()coherency.Not-yet-signed-off-by Johannes Weiner <[email protected]>--- lib/show_mem.c | 21 +++++++++------------ 1 files changed, 9 insertions(+), 12 deletions(-)lib/show_mem.c +0
-1@@ -11,29 +11,27 @@void show_mem (void ) { -pg_data_t *pgdat;unsigned long total =0 , reserved =0 , shared =0 , nonshared =0 , highmem =0 ;
lib/show_mem.c line 23
Quoted 10 lines
lib/show_mem.c +4
-2+struct zone *zone;printk (KERN_INFO "Mem-Info:\n" );show_free_areas (); -for_each_online_pgdat (pgdat) { -unsigned long i, flags; +for_each_populated_zone (zone) { +unsigned long start = zone->zone_start_pfn; +unsigned long end = start + zone->spanned_pages;
The patch appears to be doing two things
o Scanning zones instead of pgdats
o Adding the use of memmap_valid_within()
Scanning zones instead of pgdats seems like a good idea on its own and should be split out for separate consideration.
lib/show_mem.c line 24
Quoted 3 lines
lib/show_mem.c +1
-1+unsigned long pfn; -pgdat_resize_lock (pgdat, &flags);
How sure are you about removing the acquisition of this lock? If anything, it appears that pagetypeinfo_showblockcount_print() should be taking this lock.
lib/show_mem.c line 28
Quoted 6 lines
lib/show_mem.c +2
-3-for (i =0 ; i < pgdat->node_spanned_pages; i++) { -struct page *page; -unsigned long pfn = pgdat->node_start_pfn + i; +for (pfn = start; pfn < end; pfn++) { +struct page *page =pfn_to_page (pfn);
You need to check pfn_valid() before using pfn_to_page().
lib/show_mem.c line 34
Quoted 8 lines
lib/show_mem.c +2
-2-if (unlikely (!(i %MAX_ORDER_NR_PAGES ))) +if (unlikely (!(pfn %MAX_ORDER_NR_PAGES )))touch_nmi_watchdog (); -if (!pfn_valid (pfn)) +if (!memmap_valid_within (pfn, page, zone))continue ;
You need both the pfn_valid() check and the memmap_valid_within() as memmap_valid_within() unconditionally returns 1 for most architectures. If you applied this patch as-is, memory holes in a zone will cause big problems - random results at best and invalid memory references at worst.
Quoted 16 lines
lib/show_mem.c +0
-3- page =pfn_to_page (pfn); -if (PageHighMem (page)) highmem++;@@ -46,7 +44,6 @@ void show_mem(void) total++; } -pgdat_resize_unlock (pgdat, &flags); }printk (KERN_INFO "%lu pages RAM\n" , total);Signature · 1 line
1.6.2.1.135.gde769
Signature · 9 lines
Mel Gorman Part-time Phd Student Linux Technology Center University of Limerick IBM Dublin Software Lab -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Quoted 34 lines · Mel Gorman
Quoted 33 lines · Johannes Weiner
Hi Mel,
Quoted 30 lines · Mel Gorman
pfn_valid()is meant to be able to tell if a given PFN has valid memmap associated with it or not. In FLATMEM, it is expected that holes always have valid memmap as long as there is valid PFNs either side of the hole. In SPARSEMEM, it is assumed that a valid section has a memmap for the entire section.However, ARM and maybe other embedded architectures in the future free memmap backing holes to save memory on the assumption the memmap is never used. The
page_zone()linkages are then broken even thoughpfn_valid()returns true. A walker of the full memmap in this case must do additional check to ensure the memmap they are looking at is sane by making sure the zone and PFN linkages are still valid. This is expensive, but walkers of the full memmap are extremely rare.This was caught before for FLATMEM and hacked around but it hits again for SPARSEMEM because the
page_zone()linkages can look ok where the PFN linkages are totally screwed. This looks like a hatchet job but the reality is that any clean solution would end up consuming all the memory saved by punching these unexpected holes in the memmap. For example, we tried marking the memmap within the section invalid but the section size exceeds the size of the hole in most cases sopfn_valid()starts returning false where valid memmap exists. Shrinking the size of the section would increase memory consumption offsetting the gains.This patch identifies when an architecture is punching unexpected holes in the memmap that the memory model cannot automatically detect. When set, walkers of the full memmap must call
memmap_valid_within()for each PFN and passing in what it expects the page and zone to be for that PFN. If it finds the linkages to be broken, it assumes the memmap is invalid for that PFN.
Quoted 6 lines
Quoted 3 lines
Quoted 1 line
Signed-off-by Mel Gorman <[email protected]>I think we also need to fix up
show_mem().As it turns out, ARM has its own
show_mem(). I don't see how, but ARM must not be usinglib/show_mem.ceven though it compiles it.
It's some linker magic for lib/. It compiles both but treats the library version as weak symbol (or something).
But with the zone-walking show_mem, I think it should be able to use the generic version.
Quoted 46 lines
Quoted 33 lines
Attached is a
compile-tested patch, please have a look. I am not sure about memory hotplug issues but on a quick glance the vmstat stuff seems to be optimistic as well.---
From: Johannes Weiner <[email protected]>
Subject: lib: adjustshow_mem()to support memmap holesSome architectures free the backing of
mem_mapholes.pfn_valid()is not able to report this properly, so a stronger check is needed if the caller is about to use the page descriptor derived from a pfn.Change the node walking to zone walking and use
memmap_valid_within()to check for holes. This is reliable as it additionally checks forpage_zone()andpage_to_pfn()coherency.Not-yet-signed-off-by Johannes Weiner <[email protected]>--- lib/show_mem.c | 21 +++++++++------------ 1 files changed, 9 insertions(+), 12 deletions(-)lib/show_mem.c +0
-1@@ -11,29 +11,27 @@void show_mem (void ) { -pg_data_t *pgdat;unsigned long total =0 , reserved =0 , shared =0 , nonshared =0 , highmem =0 ;lib/show_mem.c line 23
Quoted 10 lines
lib/show_mem.c +4
-2+struct zone *zone;printk (KERN_INFO "Mem-Info:\n" );show_free_areas (); -for_each_online_pgdat (pgdat) { -unsigned long i, flags; +for_each_populated_zone (zone) { +unsigned long start = zone->zone_start_pfn; +unsigned long end = start + zone->spanned_pages;The patch appears to be doing two things
Quoted 5 lines
o Scanning zones instead of pgdats
o Adding the use ofmemmap_valid_within()Scanning zones instead of pgdats seems like a good idea on its own and should be split out for separate consideration.
Good idea. Will do.
Quoted 6 lines
lib/show_mem.c line 24
Quoted 3 lines
lib/show_mem.c +1
-1+unsigned long pfn; -pgdat_resize_lock (pgdat, &flags);How sure are you about removing the acquisition of this lock? If anything, it appears that
pagetypeinfo_showblockcount_print()should be taking this lock.
I'm completely unsure about it.
<adds memory hotplug guys to CC>
Quoted 13 lines
lib/show_mem.c line 28
Quoted 6 lines
lib/show_mem.c +2
-3-for (i =0 ; i < pgdat->node_spanned_pages; i++) { -struct page *page; -unsigned long pfn = pgdat->node_start_pfn + i; +for (pfn = start; pfn < end; pfn++) { +struct page *page =pfn_to_page (pfn);You need to check
pfn_valid()before usingpfn_to_page().Quoted 4 lines
lib/show_mem.c +1
-1-if (unlikely (!(i %MAX_ORDER_NR_PAGES ))) +if (unlikely (!(pfn %MAX_ORDER_NR_PAGES )))touch_nmi_watchdog ();
Quoted 9 lines
lib/show_mem.c line 34
Quoted 4 lines
lib/show_mem.c +1
-1-if (!pfn_valid (pfn)) +if (!memmap_valid_within (pfn, page, zone))continue ;You need both the
pfn_valid()check and thememmap_valid_within()asmemmap_valid_within()unconditionally returns 1 for most architectures. If you applied this patch as-is, memory holes in a zone will cause big problems - random results at best and invalid memory references at worst.
Ah, zone holes. More reading up needed. Thanks, Mel.
Hannes
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Hi.
Quoted 10 lines
Quoted 6 lines
lib/show_mem.c line 24
Quoted 3 lines
lib/show_mem.c +1
-1+unsigned long pfn; -pgdat_resize_lock (pgdat, &flags);How sure are you about removing the acquisition of this lock? If anything, it appears that
pagetypeinfo_showblockcount_print()should be taking this lock.I'm completely unsure about it.
<adds memory hotplug guys to CC>
zone->zone_start_pfn and zone->spanned_pages may be changed by memory hotplug. The lock must be acquired before getting their values as Mel-san said.
Thanks.
Signature · 8 lines
Yasunori Goto -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Quoted 7 lines · Johannes Weiner
Quoted 2 lines · Mel Gorman
As it turns out, ARM has its own
show_mem(). I don't see how, but ARM must not be usinglib/show_mem.ceven though it compiles it.It's some linker magic for
lib/. It compiles both but treats the library version as weak symbol (or something).
This is true for lib-y handling in general, which lib/show_mem.o falls under. Much of lib/ is obj-y though due to the fact that EXPORT_SYMBOL's from lib-y are ineffective (people seem to get bitten by this at least once a week), as a result, many things that start out as lib-y are gradually moved over to obj-y, meaning that __weak annotations in obj-y objects start to take precedent over lib-y magic anyways.. :-)
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Quoted 5 lines · Mel Gorman
Quoted 1 line · Johannes Weiner
I think we also need to fix up
show_mem().As it turns out, ARM has its own
show_mem(). I don't see how, but ARM must not be usinglib/show_mem.ceven though it compiles it.
That happens because lib/show_mem.c is a library file, and since there isn't an unresolved reference to show_mem in from within the object files ld is asked to link, the version in the .a library won't be brought in.
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>