Skip to contentSkip to conversation

Double check memmap is actually valid with a memmap has unexpected holes

PATCH In review Mel Gorman 6 participants 13 messages May 5, 2009 – May 17, 2009

Subsystems (5)
lore
Share & tools
lore

Mel Gorman

author
#0 lore raw

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
index e02b893..6d79051 100644
@@ -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
index 1ff59fd..d20513a 100644
@@ -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
index 16ce8b9..f5b7d17 100644
@@ -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
index 17f2abb..03ee651 100644
@@ -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>

#1 lore raw

arch/arm/Kconfig config OABI_COMPAT · line 928

Quoted 10 lines · Mel Gorman
arch/arm/Kconfig +1 -1
index e02b893..6d79051 100644
@@ -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>

author
#2 lore raw
Quoted 9 lines · Russell King - ARM Linux
Quoted 8 lines · Mel Gorman
arch/arm/Kconfig +0 -0
index e02b893..6d79051 100644
@@ -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_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.

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
index 6d79051..a4c195c 100644
@@ -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>

author
#3 lore raw

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
index e02b893..6d79051 100644
@@ -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_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.

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."

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
index e02b893..a4c195c 100644
@@ -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
index 1ff59fd..d20513a 100644
@@ -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
index 16ce8b9..f5b7d17 100644
@@ -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
index 17f2abb..03ee651 100644
@@ -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>

maintainer
#4 lore raw

Re: [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_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.

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 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.

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>

author
#5 lore raw

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_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.

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 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

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>
#6 lore raw

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>

#7 lore raw
In reply to Mel Gorman

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 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.

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.

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
index 238e72a..ed3c3ec 100644
@@ -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>
author
#8 lore raw
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 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.

Quoted 3 lines
Quoted 1 line

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: 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 +0 -1
index 238e72a..ed3c3ec 100644
@@ -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>
#9 lore raw
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 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.

Quoted 6 lines
Quoted 3 lines
Quoted 1 line

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.

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: 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 +0 -1
index 238e72a..ed3c3ec 100644
@@ -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 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.

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 using pfn_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 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.

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>

#10 lore raw

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>
#11 lore raw
In reply to Johannes Weiner
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 using lib/show_mem.c even 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>

#12 lore raw
In reply to Mel Gorman
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 using lib/show_mem.c even 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>