mm: page_alloc: dump migrate-failed pages
Subsystems (2)
PATCH v3 1/1 mm: page_alloc: dump migrate-failed pages
Currently, debugging CMA allocation failures is quite limited. The most commong source of these failures seems to be page migration which doesn't provide any useful information on the reason of the failure by itself. alloc_contig_range can report those failures as it holds a list of migrate-failed pages.
page refcount, mapcount with page flags on dump_page are helpful information to deduce the culprit. Furthermore, dump_page_owner was super helpful to find long term pinner who initiated the page allocation.
The reason it approach with dynamic debug is the debug message could emit lots of noises as alloc_contig_range calls more frequently since it's a best effort allocator.
There are two ifdefery conditions to support common dyndbg options:
- CONFIG_DYNAMIC_DEBUG_CORE && DYNAMIC_DEBUG_MODULE It aims for supporting the feature with only specific file with adding ccflags.
- CONFIG_DYNAMIC_DEBUG
It aims for supporting the feature with system wide globally.
A simple example to enable the feature:
Admin could enable the dump like this(by default, disabled)
echo "func dump_migrate_failure_pages +p" > control
Admin could disable it.
echo "func dump_migrate_failure_pages =_" > control
Detail goes Documentation/admin-guide/dynamic-debug-howto.rst
A concern is utility functions in dump_page uses inconsistent loglevels.
__dump_page: KERN_WARNING__dump_page_owner: KERN_ALERT
stack_trace_print: KERN_DEFAULT
There are bunch of places to use the inconsistent loglevel utility functions(e.g., just grep dump_page/strace_trace_print). It's unfortunate but here we are. It could be addressed different patchset.
---
* from v2 - https://lore.kernel.org/linux-mm/[email protected]/
* remove ratelimit - mhocko
* from v1 - https://lore.kernel.org/linux-mm/[email protected]/
* use dynamic debugging with system wide instead of per-call site - mhocko
mm/page_alloc.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+)
mm/page_alloc.c +22 -0
@@ -8453,6 +8453,27 @@ static unsigned long pfn_max_align_up(unsigned long pfn) pageblock_nr_pages)); } +#if defined(CONFIG_DYNAMIC_DEBUG ) || \ + (defined(CONFIG_DYNAMIC_DEBUG_CORE ) && defined(DYNAMIC_DEBUG_MODULE )) +static void alloc_contig_dump_pages (struct list_head *page_list) +{ +DEFINE_DYNAMIC_DEBUG_METADATA (descriptor, +"migrate failure" ); + +if (DYNAMIC_DEBUG_BRANCH (descriptor)) { +struct page *page; + +WARN (1 ,"failed callstack" ); +list_for_each_entry (page, page_list, lru) +dump_page (page,"migration failure" ); + } +} +#else +static inline void alloc_contig_dump_pages (struct list_head *page_list) +{ +} +#endif +/* [start, end) must belong to a single zone. */ static int __alloc_contig_migrate_range (struct compact_control *cc,unsigned long start,unsigned long end)
@@ -8496,6 +8517,7 @@ static int __alloc_contig_migrate_range(struct compact_control *cc, NULL, (unsigned long)&mtc, cc->mode, MR_CONTIG_RANGE); }if (ret <0 ) { +alloc_contig_dump_pages (&cc->migratepages);putback_movable_pages (&cc->migratepages);return ret; }
Signature · 1 line
2.30.1.766.gb4fecdf3b7-goog
Andrew Morton
maintainerQuoted 26 lines · On Wed, 10 Mar 2021 10:01:04 -0800 Minchan Kim <[email protected]> wrote:
Currently, debugging CMA allocation failures is quite limited. The most commong source of these failures seems to be page migration which doesn't provide any useful information on the reason of the failure by itself.
alloc_contig_rangecan report those failures as it holds a list of migrate-failed pages.page refcount, mapcount with page flags on
dump_pageare helpful information to deduce the culprit. Furthermore,dump_page_ownerwas super helpful to find long term pinner who initiated the page allocation.The reason it approach with dynamic debug is the debug message could emit lots of noises as
alloc_contig_rangecalls more frequently since it's a best effort allocator.There are two ifdefery conditions to support common dyndbg options:
-
CONFIG_DYNAMIC_DEBUG_CORE&&DYNAMIC_DEBUG_MODULEIt aims for supporting the feature with only specific file with adding ccflags.-
CONFIG_DYNAMIC_DEBUG
It aims for supporting the feature with system wide globally.A simple example to enable the feature:
Quoted 7 lines
Admin could enable the dump like
this(by default, disabled)echo "func
dump_migrate_failure_pages+p" > controlAdmin could disable it.
echo "func
dump_migrate_failure_pages=_" > control
I think the changelog is out of sync. Did you mean "alloc_contig_dump_pages" here?
Quoted 11 lines
mm/page_alloc.c +5
-0@@ -8453,6 +8453,27 @@ static unsigned long pfn_max_align_up(unsigned long pfn) pageblock_nr_pages)); } +#if defined(CONFIG_DYNAMIC_DEBUG ) || \ + (defined(CONFIG_DYNAMIC_DEBUG_CORE ) && defined(DYNAMIC_DEBUG_MODULE )) +static void alloc_contig_dump_pages (struct list_head *page_list) +{ + DEFINE_DYNAMIC_DEBUG_METADATA(descriptor,
mm/page_alloc.c static unsigned long pfn_max_align_up(unsigned long pfn) · line 8470
Quoted 10 lines
mm/page_alloc.c +10
-0+ "migrate failure"); + +if (DYNAMIC_DEBUG_BRANCH (descriptor)) { +struct page *page; + +WARN (1 ,"failed callstack" ); +list_for_each_entry (page, page_list, lru) +dump_page (page,"migration failure" ); + } +}
I doubt if everyone is familiar with dynamic debug. It might be kind to add a little comment over this, telling people how to turn it on and off.
Quoted 30 lines · Andrew Morton
Quoted 28 lines · On Wed, 10 Mar 2021 10:01:04 -0800 Minchan Kim <[email protected]> wrote:
Currently, debugging CMA allocation failures is quite limited. The most commong source of these failures seems to be page migration which doesn't provide any useful information on the reason of the failure by itself.
alloc_contig_rangecan report those failures as it holds a list of migrate-failed pages.page refcount, mapcount with page flags on
dump_pageare helpful information to deduce the culprit. Furthermore,dump_page_ownerwas super helpful to find long term pinner who initiated the page allocation.The reason it approach with dynamic debug is the debug message could emit lots of noises as
alloc_contig_rangecalls more frequently since it's a best effort allocator.There are two ifdefery conditions to support common dyndbg options:
-
CONFIG_DYNAMIC_DEBUG_CORE&&DYNAMIC_DEBUG_MODULEIt aims for supporting the feature with only specific file with adding ccflags.-
CONFIG_DYNAMIC_DEBUG
It aims for supporting the feature with system wide globally.A simple example to enable the feature:
Admin could enable the dump like
this(by default, disabled)
Quoted 8 lines
Quoted 5 lines
echo "func
dump_migrate_failure_pages+p" > controlAdmin could disable it.
echo "func
dump_migrate_failure_pages=_" > controlI think the changelog is out of sync. Did you mean "
alloc_contig_dump_pages" here?
Oops. Now fixed.
Quoted 18 lines
Quoted 18 lines
mm/page_alloc.c +11
-0@@ -8453,6 +8453,27 @@ static unsigned long pfn_max_align_up(unsigned long pfn) pageblock_nr_pages)); } +#if defined(CONFIG_DYNAMIC_DEBUG ) || \ + (defined(CONFIG_DYNAMIC_DEBUG_CORE ) && defined(DYNAMIC_DEBUG_MODULE )) +static void alloc_contig_dump_pages (struct list_head *page_list) +{ +DEFINE_DYNAMIC_DEBUG_METADATA (descriptor, +"migrate failure" ); + +if (DYNAMIC_DEBUG_BRANCH (descriptor)) { +struct page *page; + +WARN (1 ,"failed callstack" );
Quoted 8 lines
mm/page_alloc.c static unsigned long pfn_max_align_up(unsigned long pfn) · line 8470
Quoted 4 lines
mm/page_alloc.c +4
-0+list_for_each_entry (page, page_list, lru) +dump_page (page,"migration failure" ); + } +}I doubt if everyone is familiar with dynamic debug. It might be kind to add a little comment over this, telling people how to turn it on and off.
Something like this?
#if defined(CONFIG_DYNAMIC_DEBUG) || \
(defined(CONFIG_DYNAMIC_DEBUG_CORE) && defined(DYNAMIC_DEBUG_MODULE))/*
* dyndbg_dir="/sys/kernel/debug/dynamic_debug"
* To enable:
* echo "func dump_migrate_failure_pages +p" > $dyndbg_dir/control
* To disable:
* echo "func dump_migrate_failure_pages =_" > $dyndbg_dir/control
*/
Quoted 68 lines · Minchan Kim
Currently, debugging CMA allocation failures is quite limited. The most commong source of these failures seems to be page migration which doesn't provide any useful information on the reason of the failure by itself.
alloc_contig_rangecan report those failures as it holds a list of migrate-failed pages.page refcount, mapcount with page flags on
dump_pageare helpful information to deduce the culprit. Furthermore,dump_page_ownerwas super helpful to find long term pinner who initiated the page allocation.The reason it approach with dynamic debug is the debug message could emit lots of noises as
alloc_contig_rangecalls more frequently since it's a best effort allocator.There are two ifdefery conditions to support common dyndbg options:
-
CONFIG_DYNAMIC_DEBUG_CORE&&DYNAMIC_DEBUG_MODULEIt aims for supporting the feature with only specific file with adding ccflags.-
CONFIG_DYNAMIC_DEBUG
It aims for supporting the feature with system wide globally.A simple example to enable the feature:
Admin could enable the dump like
this(by default, disabled)echo "func
dump_migrate_failure_pages+p" > controlAdmin could disable it.
echo "func
dump_migrate_failure_pages=_" > controlDetail goes
Documentation/admin-guide/dynamic-debug-howto.rstA concern is utility functions in
dump_pageuses inconsistent loglevels.
__dump_page:KERN_WARNING__dump_page_owner:KERN_ALERT
stack_trace_print:KERN_DEFAULTThere are bunch of places to use the inconsistent loglevel utility
functions(e.g., just grep dump_page/strace_trace_print). It's unfortunate but here we are. It could be addressed different patchset.Signed-off-by Minchan Kim <[email protected]>---
* from v2 - https://lore.kernel.org/linux-mm/[email protected]/
* remove ratelimit - mhocko* from v1 - https://lore.kernel.org/linux-mm/[email protected]/
* use dynamic debugging with system wide instead of per-call site - mhockomm/page_alloc.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+)mm/page_alloc.c +1
-0@@ -8453,6 +8453,27 @@ static unsigned long pfn_max_align_up(unsigned long pfn) pageblock_nr_pages)); } +#if defined(CONFIG_DYNAMIC_DEBUG) || \
mm/page_alloc.c static unsigned long pfn_max_align_up(unsigned long pfn) · line 8466
Quoted 10 lines
mm/page_alloc.c +10
-0+ (defined(CONFIG_DYNAMIC_DEBUG_CORE) && defined(DYNAMIC_DEBUG_MODULE)) +static void alloc_contig_dump_pages (struct list_head *page_list) +{ +DEFINE_DYNAMIC_DEBUG_METADATA (descriptor, +"migrate failure" ); + +if (DYNAMIC_DEBUG_BRANCH (descriptor)) { +struct page *page; + +WARN (1 ,"failed callstack" );
Not sure if we want that here. You can deterministically crash a kernel with panic_on_warn set - which is what some distros already do.
Some other way to dump the current call stack would be handy ...
Quoted 15 lines
mm/page_alloc.c +10
-0+list_for_each_entry (page, page_list, lru) + dump_page(page, "migration failure"); + } +} +#else +static inline void alloc_contig_dump_pages (struct list_head *page_list) +{ +} +#endif +/* [start, end) must belong to a single zone. */ static int __alloc_contig_migrate_range (struct compact_control *cc,unsigned long start,unsigned long end)
mm/page_alloc.c static int __alloc_contig_migrate_range(struct compact_control *cc, · line 8523
Quoted 7 lines
mm/page_alloc.c +1
-0@@ -8496,6 +8517,7 @@ static int __alloc_contig_migrate_range(struct compact_control *cc, NULL, (unsigned long)&mtc, cc->mode, MR_CONTIG_RANGE); }if (ret <0 ) { +alloc_contig_dump_pages (&cc->migratepages);putback_movable_pages (&cc->migratepages);return ret; }
For me, this is good enough for now.
Signature · 3 lines
Thanks, David / dhildenb
Quoted 73 lines · David Hildenbrand
Quoted 72 lines · Minchan Kim
Currently, debugging CMA allocation failures is quite limited. The most commong source of these failures seems to be page migration which doesn't provide any useful information on the reason of the failure by itself.
alloc_contig_rangecan report those failures as it holds a list of migrate-failed pages.page refcount, mapcount with page flags on
dump_pageare helpful information to deduce the culprit. Furthermore,dump_page_ownerwas super helpful to find long term pinner who initiated the page allocation.The reason it approach with dynamic debug is the debug message could emit lots of noises as
alloc_contig_rangecalls more frequently since it's a best effort allocator.There are two ifdefery conditions to support common dyndbg options:
-
CONFIG_DYNAMIC_DEBUG_CORE&&DYNAMIC_DEBUG_MODULEIt aims for supporting the feature with only specific file with adding ccflags.-
CONFIG_DYNAMIC_DEBUG
It aims for supporting the feature with system wide globally.A simple example to enable the feature:
Admin could enable the dump like
this(by default, disabled)echo "func
dump_migrate_failure_pages+p" > controlAdmin could disable it.
echo "func
dump_migrate_failure_pages=_" > controlDetail goes
Documentation/admin-guide/dynamic-debug-howto.rstA concern is utility functions in
dump_pageuses inconsistent loglevels.
__dump_page:KERN_WARNING__dump_page_owner:KERN_ALERT
stack_trace_print:KERN_DEFAULTThere are bunch of places to use the inconsistent loglevel utility
functions(e.g., just grep dump_page/strace_trace_print). It's unfortunate but here we are. It could be addressed different patchset.Signed-off-by Minchan Kim <[email protected]>---
* from v2 - https://lore.kernel.org/linux-mm/[email protected]/
* remove ratelimit - mhocko* from v1 - https://lore.kernel.org/linux-mm/[email protected]/
* use dynamic debugging with system wide instead of per-call site - mhockomm/page_alloc.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+)mm/page_alloc.c +6
-0@@ -8453,6 +8453,27 @@ static unsigned long pfn_max_align_up(unsigned long pfn) pageblock_nr_pages)); } +#if defined(CONFIG_DYNAMIC_DEBUG ) || \ + (defined(CONFIG_DYNAMIC_DEBUG_CORE ) && defined(DYNAMIC_DEBUG_MODULE )) +static void alloc_contig_dump_pages (struct list_head *page_list) +{ +DEFINE_DYNAMIC_DEBUG_METADATA (descriptor, +"migrate failure" );
Quoted 8 lines
mm/page_alloc.c static unsigned long pfn_max_align_up(unsigned long pfn) · line 8466
Quoted 5 lines
mm/page_alloc.c +5
-0+ +if (DYNAMIC_DEBUG_BRANCH (descriptor)) { +struct page *page; + +WARN (1 ,"failed callstack" );Not sure if we want that here. You can deterministically crash a kernel with
panic_on_warnset - which is what some distros already do.
Good point.
Quoted 2 lines
Some other way to dump the current call stack would be handy ...
Yub, let's go with dump_stack.
Quoted 17 lines
Quoted 17 lines
mm/page_alloc.c +10
-0+list_for_each_entry (page, page_list, lru) + dump_page(page, "migration failure"); + } +} +#else +static inline void alloc_contig_dump_pages (struct list_head *page_list) +{ +} +#endif +/* [start, end) must belong to a single zone. */ static int __alloc_contig_migrate_range (struct compact_control *cc,unsigned long start,unsigned long end)@@ -8496,6 +8517,7 @@ static int __alloc_contig_migrate_range(struct compact_control *cc, NULL, (unsigned long)&mtc, cc->mode, MR_CONTIG_RANGE); }
Quoted 8 lines
mm/page_alloc.c static int __alloc_contig_migrate_range(struct compact_control *cc, · line 8523
Quoted 6 lines
mm/page_alloc.c +1
-0if (ret <0 ) { +alloc_contig_dump_pages (&cc->migratepages);putback_movable_pages (&cc->migratepages);return ret; }For me, this is good enough for now.
Thanks.
Let me send next revision with addressing your point and Andrew's one.