mm/memory-failure: add panic option for unrecoverable pages
Subsystems (6)
v6 cover mm/memory-failure: add panic option for unrecoverable pages
Changes from previouis version
* Replaced the late, action-time recheck for MF_MSG_KERNEL_HIGH_ORDER with early failure classification inside get_any_page() (new patch 2/4).
* David Hildenbrand pointed out that the recheck inspected refcount and folio mapping without holding a folio reference, which is unsafe (concurrent split can trigger VM_WARN_ON_FOLIO).
* Lance Yang suggested moving the disambiguation to the call site that still knows *why* the page reference could not be taken, which is what this version does via a new enum mf_get_page_status (MF_GET_PAGE_OK / RACE / UNHANDLABLE) plumbed out through get_hwpoison_page().
---
Changes in v6:
- Dropped the selftest given the value was not clear
- Get the status of the failure from get_any_page()
- Small nits from different people/AIs.
- Link to v5: https://patch.msgid.link/[email protected]
Changes in v5:
- Add vm.panic_on_unrecoverable_memory_failure sysctl to panic on unrecoverable kernel page hwpoison events (reserved pages, refcount-0 non-buddy pages, unknown state), with a recheck to avoid racing with concurrent buddy allocations. (Miaohe)
- Distinguish reserved pages as MF_MSG_KERNEL in memory_failure(), document the new sysctl in Documentation/admin-guide/sysctl/vm.rst, and add a selftest verifying SIGBUS recovery on userspace pages still works when the sysctl is enabled. (Miaohe)
- Added a selftest
- Link to v4:
https://patch.msgid.link/[email protected]
Changes in v4:
- Drop CONFIG_BOOTPARAM_MEMORY_FAILURE_PANIC kernel configuration option.
- Split the reserved page classification (MF_MSG_KERNEL) into its own patch, separate from the panic mechanism.
- Document why the buddy allocator TOCTOU race (between get_hwpoison_page() and is_free_buddy_page()) cannot cause false
positives: PG_hwpoison is set beforehand and check_new_page() in the page allocator rejects hwpoisoned pages.
- Document the narrow LRU isolation race window for MF_MSG_UNKNOWN and its mitigation via identify_page_state()'s two-pass design.
- Explicitly document why MF_MSG_GET_HWPOISON is excluded from the
panic conditions (shared path with transient races and non-reserved kernel memory).
- Link to v3: https://patch.msgid.link/[email protected]
Changes in v3:
- Rename is_unrecoverable_memory_failure() to panic_on_unrecoverable_mf() as suggested by maintainer.
- Add CONFIG_BOOTPARAM_MEMORY_FAILURE_PANIC kernel configuration option, similar to CONFIG_BOOTPARAM_HARDLOCKUP_PANIC.
- Add documentation for the sysctl and CONFIG option.
- Add code comments documenting the panic condition design rationale and how the retry mechanism mitigates false positives from buddy allocator races.
- Link to v2: https://patch.msgid.link/[email protected]
Changes in v2:
- Panic on MF_MSG_KERNEL, MF_MSG_KERNEL_HIGH_ORDER and MF_MSG_UNKNOWN instead of MF_MSG_GET_HWPOISON.
- Report MF_MSG_KERNEL for reserved pages when get_hwpoison_page() fails instead of MF_MSG_GET_HWPOISON.
- Link to v1: https://patch.msgid.link/[email protected]
To: Miaohe Lin <[email protected]>
To: Naoya Horiguchi <[email protected]>
To: Andrew Morton <[email protected]>
To: Steven Rostedt <[email protected]>
To: Masami Hiramatsu <[email protected]>
To: Mathieu Desnoyers <[email protected]>
To: Jonathan Corbet <[email protected]>
To: Shuah Khan <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
---
Breno Leitao (4):
mm/memory-failure: report MF_MSG_KERNEL for reserved pages mm/memory-failure: classify get_any_page() failures by reason mm/memory-failure: add panic option for unrecoverable pages
Documentation: document panic_on_unrecoverable_memory_failure sysctl
Documentation/admin-guide/sysctl/vm.rst | 70 ++++++++++++++++++++++++++ include/trace/events/memory-failure.h | 2 +- mm/memory-failure.c | 89 ++++++++++++++++++++++++++++++--- 3 files changed, 152 insertions(+), 9 deletions(-)
---
base-commit: e98d21c170b01ddef366f023bbfcf6b31509fa83
change-id: 20260323-ecc_panic-4e473b83087c
Best regards,
Signature · 1 line
Breno Leitao <[email protected]>
PATCH v6 1/4 mm/memory-failure: report MF_MSG_KERNEL for reserved pages
When get_hwpoison_page() returns a negative value, distinguish reserved pages from other failure cases by reporting MF_MSG_KERNEL instead of MF_MSG_GET_HWPOISON. Reserved pages belong to the kernel and should be classified accordingly for proper handling.
Sample PG_reserved before the get_hwpoison_page() call. In the MF_COUNT_INCREASED path get_any_page() can drop the caller's reference before returning -EIO, after which the underlying page may have been freed and reallocated with page->flags reset; reading PageReserved(p) at that point would observe stale or unrelated state. The pre-call snapshot reflects what the page actually was at the time of the failure event.
--- mm/memory-failure.c | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-)
mm/memory-failure.c +18 -1
@@ -2348,6 +2348,7 @@ int memory_failure(unsigned long pfn, int flags)unsigned long page_flags;bool retry = true;int hugetlb =0 ; +bool is_reserved;if (!sysctl_memory_failure_recovery)panic ("Memory failure on page %lx" , pfn);
@@ -2411,6 +2412,18 @@ int memory_failure(unsigned long pfn, int flags)* In fact it's dangerous to directly bump up page count from 0, * that may make page_ref_freeze()/page_ref_unfreeze() mismatch. */ +/* +* Pages with PG_reserved set are not currently managed by the +* page allocator (memblock-reserved memory, driver reservations, +* etc.), so classify them as kernel-owned for reporting. +* +* Sample the flag before get_hwpoison_page(): in the +* MF_COUNT_INCREASED path, get_any_page() can drop the caller's +* reference before returning -EIO, after which page->flags may +* have been reset by the allocator. +*/ + is_reserved =PageReserved (p); + res =get_hwpoison_page (p, flags);if (!res) {if (is_free_buddy_page (p)) {
@@ -2432,7 +2445,11 @@ int memory_failure(unsigned long pfn, int flags) } goto unlock_mutex; }else if (res <0 ) { - res =action_result (pfn,MF_MSG_GET_HWPOISON ,MF_IGNORED ); +if (is_reserved) + res =action_result (pfn,MF_MSG_KERNEL ,MF_IGNORED ); +else + res =action_result (pfn,MF_MSG_GET_HWPOISON , +MF_IGNORED ); goto unlock_mutex; }
Signature · 1 line
2.53.0-Meta
David Hildenbrand (Arm)
maintainerRe: [PATCH v6 1/4] mm/memory-failure: report MF_MSG_KERNEL for reserved pages
Quoted 55 lines · Breno Leitao
When
get_hwpoison_page()returns a negative value, distinguish reserved pages from other failure cases by reportingMF_MSG_KERNELinstead ofMF_MSG_GET_HWPOISON. Reserved pages belong to the kernel and should be classified accordingly for proper handling.Sample
PG_reservedbefore theget_hwpoison_page()call. In theMF_COUNT_INCREASEDpathget_any_page()can drop the caller's reference before returning-EIO, after which the underlying page may have been freed and reallocated withpage->flagsreset; reading PageReserved(p) at that point would observe stale or unrelated state. The pre-call snapshot reflects what the page actually was at the time of the failure event.Acked-by Miaohe Lin <[email protected]>Reviewed-by Lance Yang <[email protected]>Signed-off-by Breno Leitao <[email protected]>--- mm/memory-failure.c | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-)mm/memory-failure.c +13
-0@@ -2348,6 +2348,7 @@ int memory_failure(unsigned long pfn, int flags)unsigned long page_flags;bool retry = true;int hugetlb =0 ; +bool is_reserved;if (!sysctl_memory_failure_recovery)panic ("Memory failure on page %lx" , pfn);@@ -2411,6 +2412,18 @@ int memory_failure(unsigned long pfn, int flags)* In fact it's dangerous to directly bump up page count from 0, * that may make page_ref_freeze()/page_ref_unfreeze() mismatch. */ +/* +* Pages with PG_reserved set are not currently managed by the +* page allocator (memblock-reserved memory, driver reservations, +* etc.), so classify them as kernel-owned for reporting. +* +* Sample the flag before get_hwpoison_page(): in the +* MF_COUNT_INCREASED path, get_any_page() can drop the caller's +* reference before returning -EIO, after which page->flags may +* have been reset by the allocator. +*/ + is_reserved =PageReserved (p); + res =get_hwpoison_page (p, flags);if (!res) {if (is_free_buddy_page (p)) {@@ -2432,7 +2445,11 @@ int memory_failure(unsigned long pfn, int flags) } goto unlock_mutex;
mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2455
Quoted 10 lines
mm/memory-failure.c +5
-1}else if (res <0 ) { - res =action_result (pfn,MF_MSG_GET_HWPOISON ,MF_IGNORED ); +if (is_reserved) + res =action_result (pfn,MF_MSG_KERNEL ,MF_IGNORED ); +else + res =action_result (pfn,MF_MSG_GET_HWPOISON , +MF_IGNORED ); goto unlock_mutex; }
It's a bit odd that we need this handling when we already have handling for reserved pages in error_states[].
HWPoisonHandlable() would always essentially reject PG_reserved pages. So __get_hwpoison_page() ... would always fail? Making get_hwpoison_page()->get_any_page() always fail?
But then, we never call identify_page_state()? And never call me_kernel()?
This all looks very odd.
Why would you even want to call get_hwpoison_page() in the first place if you find PageReserved?
Signature · 3 lines
Cheers, David
Re: [PATCH v6 1/4] mm/memory-failure: report MF_MSG_KERNEL for reserved pages
Quoted 70 lines · David Hildenbrand (Arm)
Quoted 55 lines · Breno Leitao
When
get_hwpoison_page()returns a negative value, distinguish reserved pages from other failure cases by reportingMF_MSG_KERNELinstead ofMF_MSG_GET_HWPOISON. Reserved pages belong to the kernel and should be classified accordingly for proper handling.Sample
PG_reservedbefore theget_hwpoison_page()call. In theMF_COUNT_INCREASEDpathget_any_page()can drop the caller's reference before returning-EIO, after which the underlying page may have been freed and reallocated withpage->flagsreset; reading PageReserved(p) at that point would observe stale or unrelated state. The pre-call snapshot reflects what the page actually was at the time of the failure event.Acked-by Miaohe Lin <[email protected]>Reviewed-by Lance Yang <[email protected]>Signed-off-by Breno Leitao <[email protected]>--- mm/memory-failure.c | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-)mm/memory-failure.c +13
-0@@ -2348,6 +2348,7 @@ int memory_failure(unsigned long pfn, int flags)unsigned long page_flags;bool retry = true;int hugetlb =0 ; +bool is_reserved;if (!sysctl_memory_failure_recovery)panic ("Memory failure on page %lx" , pfn);@@ -2411,6 +2412,18 @@ int memory_failure(unsigned long pfn, int flags)* In fact it's dangerous to directly bump up page count from 0, * that may make page_ref_freeze()/page_ref_unfreeze() mismatch. */ +/* +* Pages with PG_reserved set are not currently managed by the +* page allocator (memblock-reserved memory, driver reservations, +* etc.), so classify them as kernel-owned for reporting. +* +* Sample the flag before get_hwpoison_page(): in the +* MF_COUNT_INCREASED path, get_any_page() can drop the caller's +* reference before returning -EIO, after which page->flags may +* have been reset by the allocator. +*/ + is_reserved =PageReserved (p); + res =get_hwpoison_page (p, flags);if (!res) {if (is_free_buddy_page (p)) {@@ -2432,7 +2445,11 @@ int memory_failure(unsigned long pfn, int flags) } goto unlock_mutex;mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2455
Quoted 10 lines
mm/memory-failure.c +5
-1}else if (res <0 ) { - res =action_result (pfn,MF_MSG_GET_HWPOISON ,MF_IGNORED ); +if (is_reserved) + res =action_result (pfn,MF_MSG_KERNEL ,MF_IGNORED ); +else + res =action_result (pfn,MF_MSG_GET_HWPOISON , +MF_IGNORED ); goto unlock_mutex; }It's a bit odd that we need this handling when we already have handling for reserved pages in error_states[].
Quoted 5 lines
HWPoisonHandlable()would always essentially rejectPG_reservedpages. So__get_hwpoison_page()... would always fail? Making get_hwpoison_page()->get_any_page() always fail?But then, we never call
identify_page_state()? And never callme_kernel()?
Looks like we never get that far ...
Quoted 4 lines
This all looks very odd.
Why would you even want to call
get_hwpoison_page()in the first place if you find PageReserved?
Ah, I see :)
For a PG_reserved page, I would not expect PageLRU to be set, nor would I expect it to be in the buddy allocator.
include/linux/page-flags.h also says:
"
Once (if ever) freed, PG_reserved is cleared and they will be given to the page allocator.
"
So maybe special-case PageReserved() before get_hwpoison_page()? Something like:
if (PageReserved(p)){
res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);
goto unlock_mutex;
}
res = get_hwpoison_page(p, flags, &gp_status);Cheers, Lance
David Hildenbrand (Arm)
maintainerRe: [PATCH v6 1/4] mm/memory-failure: report MF_MSG_KERNEL for reserved pages
Quoted 72 lines · Lance Yang
Quoted 70 lines · David Hildenbrand (Arm)
Quoted 55 lines · Breno Leitao
When
get_hwpoison_page()returns a negative value, distinguish reserved pages from other failure cases by reportingMF_MSG_KERNELinstead ofMF_MSG_GET_HWPOISON. Reserved pages belong to the kernel and should be classified accordingly for proper handling.Sample
PG_reservedbefore theget_hwpoison_page()call. In theMF_COUNT_INCREASEDpathget_any_page()can drop the caller's reference before returning-EIO, after which the underlying page may have been freed and reallocated withpage->flagsreset; reading PageReserved(p) at that point would observe stale or unrelated state. The pre-call snapshot reflects what the page actually was at the time of the failure event.Acked-by Miaohe Lin <[email protected]>Reviewed-by Lance Yang <[email protected]>Signed-off-by Breno Leitao <[email protected]>--- mm/memory-failure.c | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-)mm/memory-failure.c +13
-0@@ -2348,6 +2348,7 @@ int memory_failure(unsigned long pfn, int flags)unsigned long page_flags;bool retry = true;int hugetlb =0 ; +bool is_reserved;if (!sysctl_memory_failure_recovery)panic ("Memory failure on page %lx" , pfn);@@ -2411,6 +2412,18 @@ int memory_failure(unsigned long pfn, int flags)* In fact it's dangerous to directly bump up page count from 0, * that may make page_ref_freeze()/page_ref_unfreeze() mismatch. */ +/* +* Pages with PG_reserved set are not currently managed by the +* page allocator (memblock-reserved memory, driver reservations, +* etc.), so classify them as kernel-owned for reporting. +* +* Sample the flag before get_hwpoison_page(): in the +* MF_COUNT_INCREASED path, get_any_page() can drop the caller's +* reference before returning -EIO, after which page->flags may +* have been reset by the allocator. +*/ + is_reserved =PageReserved (p); + res =get_hwpoison_page (p, flags);if (!res) {if (is_free_buddy_page (p)) {@@ -2432,7 +2445,11 @@ int memory_failure(unsigned long pfn, int flags) } goto unlock_mutex;mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2455
Quoted 10 lines
mm/memory-failure.c +5
-1}else if (res <0 ) { - res =action_result (pfn,MF_MSG_GET_HWPOISON ,MF_IGNORED ); +if (is_reserved) + res =action_result (pfn,MF_MSG_KERNEL ,MF_IGNORED ); +else + res =action_result (pfn,MF_MSG_GET_HWPOISON , +MF_IGNORED ); goto unlock_mutex; }It's a bit odd that we need this handling when we already have handling for reserved pages in error_states[].
Quoted 7 lines
Quoted 5 lines
HWPoisonHandlable()would always essentially rejectPG_reservedpages. So__get_hwpoison_page()... would always fail? Making get_hwpoison_page()->get_any_page() always fail?But then, we never call
identify_page_state()? And never callme_kernel()?Looks like we never get that far ...
Right, likely that should be removed+cleaned up then.
Signature · 3 lines
Cheers, David
Re: [PATCH v6 1/4] mm/memory-failure: report MF_MSG_KERNEL for reserved pages
In reply to David Hildenbrand (Arm)Quoted 45 lines · David Hildenbrand (Arm)
Quoted 31 lines
mm/memory-failure.c +13
-0@@ -2348,6 +2348,7 @@ int memory_failure(unsigned long pfn, int flags)unsigned long page_flags;bool retry = true;int hugetlb =0 ; +bool is_reserved;if (!sysctl_memory_failure_recovery)panic ("Memory failure on page %lx" , pfn);@@ -2411,6 +2412,18 @@ int memory_failure(unsigned long pfn, int flags)* In fact it's dangerous to directly bump up page count from 0, * that may make page_ref_freeze()/page_ref_unfreeze() mismatch. */ +/* +* Pages with PG_reserved set are not currently managed by the +* page allocator (memblock-reserved memory, driver reservations, +* etc.), so classify them as kernel-owned for reporting. +* +* Sample the flag before get_hwpoison_page(): in the +* MF_COUNT_INCREASED path, get_any_page() can drop the caller's +* reference before returning -EIO, after which page->flags may +* have been reset by the allocator. +*/ + is_reserved =PageReserved (p); + res =get_hwpoison_page (p, flags);if (!res) {if (is_free_buddy_page (p)) {@@ -2432,7 +2445,11 @@ int memory_failure(unsigned long pfn, int flags) } goto unlock_mutex;mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2455
Quoted 10 lines
mm/memory-failure.c +5
-1}else if (res <0 ) { - res =action_result (pfn,MF_MSG_GET_HWPOISON ,MF_IGNORED ); +if (is_reserved) + res =action_result (pfn,MF_MSG_KERNEL ,MF_IGNORED ); +else + res =action_result (pfn,MF_MSG_GET_HWPOISON , +MF_IGNORED ); goto unlock_mutex; }It's a bit odd that we need this handling when we already have handling for reserved pages in error_states[].
Quoted 5 lines
HWPoisonHandlable()would always essentially rejectPG_reservedpages. So__get_hwpoison_page()... would always fail? Making get_hwpoison_page()->get_any_page() always fail?But then, we never call
identify_page_state()? And never callme_kernel()?
From what I read, it seems that error_states[0] = { reserved, reserved, MF_MSG_KERNEL, me_kernel } has been effectively dead code on the hwpoison-from-MCE path for a
while.
My v6 patch relabels the failure-path output to match what me_kernel() would have reported anyway.
Quoted 4 lines
This all looks very odd.
Why would you even want to call
get_hwpoison_page()in the first place if you find PageReserved?
Are you suggesting we should all the page action as soon as we detect the page is reserved and get out?
Something as:
if (PageReserved(p)) {
res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);
goto unlock_mutex;
}
res = get_hwpoison_page(p, flags);Thanks for the review,
--breno
David Hildenbrand (Arm)
maintainerRe: [PATCH v6 1/4] mm/memory-failure: report MF_MSG_KERNEL for reserved pages
Quoted 67 lines · Breno Leitao
Quoted 45 lines · David Hildenbrand (Arm)
Quoted 31 lines
mm/memory-failure.c +13
-0@@ -2348,6 +2348,7 @@ int memory_failure(unsigned long pfn, int flags)unsigned long page_flags;bool retry = true;int hugetlb =0 ; +bool is_reserved;if (!sysctl_memory_failure_recovery)panic ("Memory failure on page %lx" , pfn);@@ -2411,6 +2412,18 @@ int memory_failure(unsigned long pfn, int flags)* In fact it's dangerous to directly bump up page count from 0, * that may make page_ref_freeze()/page_ref_unfreeze() mismatch. */ +/* +* Pages with PG_reserved set are not currently managed by the +* page allocator (memblock-reserved memory, driver reservations, +* etc.), so classify them as kernel-owned for reporting. +* +* Sample the flag before get_hwpoison_page(): in the +* MF_COUNT_INCREASED path, get_any_page() can drop the caller's +* reference before returning -EIO, after which page->flags may +* have been reset by the allocator. +*/ + is_reserved =PageReserved (p); + res =get_hwpoison_page (p, flags);if (!res) {if (is_free_buddy_page (p)) {@@ -2432,7 +2445,11 @@ int memory_failure(unsigned long pfn, int flags) } goto unlock_mutex;mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2455
Quoted 10 lines
mm/memory-failure.c +5
-1}else if (res <0 ) { - res =action_result (pfn,MF_MSG_GET_HWPOISON ,MF_IGNORED ); +if (is_reserved) + res =action_result (pfn,MF_MSG_KERNEL ,MF_IGNORED ); +else + res =action_result (pfn,MF_MSG_GET_HWPOISON , +MF_IGNORED ); goto unlock_mutex; }It's a bit odd that we need this handling when we already have handling for reserved pages in error_states[].
Quoted 5 lines
HWPoisonHandlable()would always essentially rejectPG_reservedpages. So__get_hwpoison_page()... would always fail? Making get_hwpoison_page()->get_any_page() always fail?But then, we never call
identify_page_state()? And never callme_kernel()?From what I read, it seems that error_states[0] = { reserved, reserved,
MF_MSG_KERNEL,me_kernel} has been effectively dead code on the hwpoison-from-MCE path for a
while.My v6 patch relabels the failure-path output to match what
me_kernel()would have reported anyway.Quoted 4 lines
This all looks very odd.
Why would you even want to call
get_hwpoison_page()in the first place if you find PageReserved?Are you suggesting we should all the page action as soon as we detect the page is reserved and get out?
Quoted 8 lines
Something as:
if (PageReserved(p)) { res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED); goto unlock_mutex; } res = get_hwpoison_page(p, flags);
Or you combine this patch with the other patch and let simply get_hwpoison_page() check that, and return an appropriate error code for unhandable that you can process here?
Like, maybe, returning -EIO directly?
res = get_hwpoison_page(p, flags);
switch (res) {
case 0: /* Success */
... break case -EIO: /* Unhandable kernel page. */ ... break; case -EBUSY: /* Race, try again? */ ... break;
case ...
}
You can add more return codes as you see fit.
Signature · 3 lines
Cheers, David
Re: [PATCH v6 1/4] mm/memory-failure: report MF_MSG_KERNEL for reserved pages
In reply to David Hildenbrand (Arm)Quoted 74 lines · David Hildenbrand (Arm)
Quoted 55 lines · Breno Leitao
When
get_hwpoison_page()returns a negative value, distinguish reserved pages from other failure cases by reportingMF_MSG_KERNELinstead ofMF_MSG_GET_HWPOISON. Reserved pages belong to the kernel and should be classified accordingly for proper handling.Sample
PG_reservedbefore theget_hwpoison_page()call. In theMF_COUNT_INCREASEDpathget_any_page()can drop the caller's reference before returning-EIO, after which the underlying page may have been freed and reallocated withpage->flagsreset; reading PageReserved(p) at that point would observe stale or unrelated state. The pre-call snapshot reflects what the page actually was at the time of the failure event.Acked-by Miaohe Lin <[email protected]>Reviewed-by Lance Yang <[email protected]>Signed-off-by Breno Leitao <[email protected]>--- mm/memory-failure.c | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-)mm/memory-failure.c +13
-0@@ -2348,6 +2348,7 @@ int memory_failure(unsigned long pfn, int flags)unsigned long page_flags;bool retry = true;int hugetlb =0 ; +bool is_reserved;if (!sysctl_memory_failure_recovery)panic ("Memory failure on page %lx" , pfn);@@ -2411,6 +2412,18 @@ int memory_failure(unsigned long pfn, int flags)* In fact it's dangerous to directly bump up page count from 0, * that may make page_ref_freeze()/page_ref_unfreeze() mismatch. */ +/* +* Pages with PG_reserved set are not currently managed by the +* page allocator (memblock-reserved memory, driver reservations, +* etc.), so classify them as kernel-owned for reporting. +* +* Sample the flag before get_hwpoison_page(): in the +* MF_COUNT_INCREASED path, get_any_page() can drop the caller's +* reference before returning -EIO, after which page->flags may +* have been reset by the allocator. +*/ + is_reserved =PageReserved (p); + res =get_hwpoison_page (p, flags);if (!res) {if (is_free_buddy_page (p)) {@@ -2432,7 +2445,11 @@ int memory_failure(unsigned long pfn, int flags) } goto unlock_mutex;mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2455
Quoted 10 lines
mm/memory-failure.c +5
-1}else if (res <0 ) { - res =action_result (pfn,MF_MSG_GET_HWPOISON ,MF_IGNORED ); +if (is_reserved) + res =action_result (pfn,MF_MSG_KERNEL ,MF_IGNORED ); +else + res =action_result (pfn,MF_MSG_GET_HWPOISON , +MF_IGNORED ); goto unlock_mutex; }It's a bit odd that we need this handling when we already have handling for reserved pages in error_states[].
HWPoisonHandlable()would always essentially rejectPG_reservedpages. So__get_hwpoison_page()... would always fail? Making get_hwpoison_page()->get_any_page() always fail?
Quoted 7 lines
But then, we never call
identify_page_state()? And never callme_kernel()?This all looks very odd.
Why would you even want to call
get_hwpoison_page()in the first place if you find PageReserved?
Ah, good point!
It seems to me that all unhandable pages should head out to identify_page_state:
mm/memory-failure.c +4 -0
@@ -2411,6 +2411,10 @@ int memory_failure(unsigned long pfn, int flags)* In fact it's dangerous to directly bump up page count from 0, * that may make page_ref_freeze()/page_ref_unfreeze() mismatch. */ + + if (!HWPoisonHandlable(page, flags) + goto identify_page_state; + res =get_hwpoison_page (p, flags);if (!res) {if (is_free_buddy_page (p)) {
thanks,
-jane
David Hildenbrand (Arm)
maintainerRe: [PATCH v6 1/4] mm/memory-failure: report MF_MSG_KERNEL for reserved pages
Quoted 89 lines · On 5/12/26 19:58, [email protected] wrote:
Quoted 72 lines · David Hildenbrand (Arm)
Quoted 62 lines · Breno Leitao
When
get_hwpoison_page()returns a negative value, distinguish reserved pages from other failure cases by reportingMF_MSG_KERNELinstead ofMF_MSG_GET_HWPOISON. Reserved pages belong to the kernel and should be classified accordingly for proper handling.Sample
PG_reservedbefore theget_hwpoison_page()call. In theMF_COUNT_INCREASEDpathget_any_page()can drop the caller's reference before returning-EIO, after which the underlying page may have been freed and reallocated withpage->flagsreset; reading PageReserved(p) at that point would observe stale or unrelated state. The pre-call snapshot reflects what the page actually was at the time of the failure event.Acked-by Miaohe Lin <[email protected]>Reviewed-by Lance Yang <[email protected]>Signed-off-by Breno Leitao <[email protected]>---
mm/memory-failure.c| 19 ++++++++++++++++++-1 file changed, 18 insertions(+), 1 deletion(-)mm/memory-failure.c +18
-1@@ -2348,6 +2348,7 @@ int memory_failure(unsigned long pfn, int flags) unsigned long page_flags; bool retry = true; int hugetlb = 0; + bool is_reserved; if (!sysctl_memory_failure_recovery) panic("Memory failure on page %lx", pfn);@@ -2411,6 +2412,18 @@ int memory_failure(unsigned long pfn, int flags)* In fact it's dangerous to directly bump up page count from 0, * that may make page_ref_freeze()/page_ref_unfreeze() mismatch. */ + /* + * Pages with PG_reserved set are not currently managed by the + * page allocator (memblock-reserved memory, driver reservations, + * etc.), so classify them as kernel-owned for reporting. + * + * Sample the flag before get_hwpoison_page(): in the + * MF_COUNT_INCREASED path, get_any_page() can drop the caller's + * reference before returning -EIO, after which page->flags may + * have been reset by the allocator. + */ + is_reserved = PageReserved(p); + res = get_hwpoison_page(p, flags); if (!res) { if (is_free_buddy_page(p)) {@@ -2432,7 +2445,11 @@ int memory_failure(unsigned long pfn, int flags) } goto unlock_mutex; } else if (res < 0) { - res = action_result(pfn, MF_MSG_GET_HWPOISON, MF_IGNORED); + if (is_reserved) + res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED); + else + res = action_result(pfn, MF_MSG_GET_HWPOISON, + MF_IGNORED); goto unlock_mutex; }Quoted 1 line
It's a bit odd that we need this handling when we already have handling for reserved pages in error_states[].
HWPoisonHandlable()would always essentially rejectPG_reservedpages. So__get_hwpoison_page()... would always fail? Making get_hwpoison_page()->get_any_page() always fail?Quoted 7 lines
But then, we never call
identify_page_state()? And never callme_kernel()?This all looks very odd.
Why would you even want to call
get_hwpoison_page()in the first place if you find PageReserved?Ah, good point!
It seems to me that all unhandable pages should head out toidentify_page_state:
mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2420
Quoted 10 lines
mm/memory-failure.c +4
-0@@ -2411,6 +2411,10 @@ int memory_failure(unsigned long pfn, int flags)* In fact it's dangerous to directly bump up page count from 0, * that may make page_ref_freeze()/page_ref_unfreeze() mismatch. */ + + if (!HWPoisonHandlable(page, flags) + goto identify_page_state; + res = get_hwpoison_page(p, flags); if (!res) { if (is_free_buddy_page(p)) {
That's one option, or we just let get_hwpoison_page() return clearer error codes, let it take care of checking PageReserved, and process the error codes return by get_hwpoison_page() in a better way.
Signature · 3 lines
Cheers, David
PATCH v6 2/4 mm/memory-failure: classify get_any_page() failures by reason
In reply to Breno LeitaoWhen get_any_page() fails to grab a page reference, the *reason* it failed is known at the call site but is not surfaced to callers: the HWPoisonHandlable() rejection path (a stable kernel page hwpoison cannot handle — slab, vmalloc, page tables, kernel stacks, ...) and the page_count() / put_page race paths (a transient page-allocator lifecycle race) all collapse to a single negative errno by the time memory_failure() sees them. memory_failure() can only observe the conflated result and reports both as MF_MSG_GET_HWPOISON.
Surface the diagnosis explicitly. Add an mf_get_page_status enum, plumbed out through get_any_page() and get_hwpoison_page() (NULL is accepted by callers that do not care — unpoison_memory() and soft_offline_page() pass NULL). get_any_page() sets the status at the moment it gives up:
MF_GET_PAGE_UNHANDLABLE — HWPoisonHandlable() rejected the page
after retries.
MF_GET_PAGE_RACE — exhausted retries on a refcount /
lifecycle race with the allocator.
memory_failure() then promotes the unhandlable case to MF_MSG_KERNEL alongside the existing PageReserved branch, and leaves the transient-race case as MF_MSG_GET_HWPOISON. This forms the foundation a later patch will rely on to decide whether an unrecoverable failure should panic.
Drop the "reserved" qualifier from action_page_types[MF_MSG_KERNEL] and the matching tracepoint string in MF_PAGE_TYPE: the enum value now covers both PageReserved pages and unhandlable kernel pages (slab, vmalloc, page tables, kernel stacks, ...), so "kernel page" is the accurate label for both populations.
--- include/trace/events/memory-failure.h | 2 +- mm/memory-failure.c | 46 +++++++++++++++++++++++++++++------ 2 files changed, 39 insertions(+), 9 deletions(-)
include/trace/events/memory-failure.h +1 -1
@@ -24,7 +24,7 @@ EMe ( MF_RECOVERED, "Recovered" )#define MF_PAGE_TYPE \ - EM ( MF_MSG_KERNEL, "reserved kernel page" ) \ + EM ( MF_MSG_KERNEL, "kernel page" ) \ EM ( MF_MSG_KERNEL_HIGH_ORDER, "high-order kernel page" ) \ EM ( MF_MSG_HUGE, "huge page" ) \ EM ( MF_MSG_FREE_HUGE, "free huge page" ) \
mm/memory-failure.c +38 -8
133 lines not on this page · raw message
Signature · 1 line
2.53.0-Meta
David Hildenbrand (Arm)
maintainerRe: [PATCH v6 2/4] mm/memory-failure: classify get_any_page() failures by reason
mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2479
Quoted 12 lines
mm/memory-failure.c +6
-1} goto unlock_mutex; }else if (res <0 ) { -if (is_reserved) +/* +* Promote a stable unhandlable kernel page diagnosed by +* get_hwpoison_page() to MF_MSG_KERNEL alongside reserved +* pages; transient lifecycle races stay as MF_MSG_GET_HWPOISON. +*/ +if (is_reserved || gp_status ==MF_GET_PAGE_UNHANDLABLE ) res =action_result (pfn,MF_MSG_KERNEL ,MF_IGNORED );
It's all a bit of a mess. get_hwpoison_page() should just indicate that a page is unhandable if it is PG_reserved?
Why can't we just return a special error code from get_hwpoison_page()? We ahve plenty of errno values to chose from.
Signature · 3 lines
Cheers, David
Re: [PATCH v6 2/4] mm/memory-failure: classify get_any_page() failures by reason
Quoted 16 lines · David Hildenbrand (Arm)
Review
Quoted 12 lines
(quoted diff) +6
-1} goto unlock_mutex; } else if (res < 0) { - if (is_reserved) + /* + * Promote a stable unhandlable kernel page diagnosed by + * get_hwpoison_page() to MF_MSG_KERNEL alongside reserved + * pages; transient lifecycle races stay as MF_MSG_GET_HWPOISON. + */ + if (is_reserved || gp_status == MF_GET_PAGE_UNHANDLABLE) res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);It's all a bit of a mess.
get_hwpoison_page()should just indicate that a page is unhandable if it isPG_reserved?
Are you saying that we should identify if the page is PG_reserved in get_hwpoison_page() instead of in memory_failure(), as done in the previous patch ("mm/memory-failure: report MF_MSG_KERNEL for reserved pages") ?
Quoted 2 lines
Why can't we just return a special error code from
get_hwpoison_page()? We ahve plenty of errno values to chose from.
Something like:
mm/memory-failure.c +12 -4
@@ -878,7 +878,7 @@ static const char *action_name[] = { };static const char *const action_page_types[] = { - [MF_MSG_KERNEL ] ="reserved kernel page" , + [MF_MSG_KERNEL ] ="unrecoverable kernel page" , [MF_MSG_KERNEL_HIGH_ORDER ] ="high-order kernel page" , [MF_MSG_HUGE ] ="huge page" , [MF_MSG_FREE_HUGE ] ="free huge page" ,
@@ -1394,6 +1394,21 @@ static int get_any_page(struct page *p, unsigned long flags)int ret =0 , pass =0 ;bool count_increased = false; +if (PageReserved (p)) { + ret = -ENOTRECOVERABLE ; + goto out; + } +if (flags &MF_COUNT_INCREASED ) count_increased = true;
@@ -1422,7 +1437,7 @@ static int get_any_page(struct page *p, unsigned long flags)shake_page (p); goto try_again; } - ret = -EIO ; + ret = -ENOTRECOVERABLE ; goto out; } }
@@ -1441,10 +1456,10 @@ static int get_any_page(struct page *p, unsigned long flags) goto try_again; }put_page (p); - ret = -EIO ; + ret = -ENOTRECOVERABLE ; } out: -if (ret == -EIO ) +if (ret == -EIO || ret == -ENOTRECOVERABLE )pr_err ("%#lx: unhandlable page.\n" ,page_to_pfn (p));return ret;
@@ -2431,6 +2448,9 @@ int memory_failure(unsigned long pfn, int flags) res =action_result (pfn,MF_MSG_KERNEL_HIGH_ORDER ,MF_IGNORED ); } goto unlock_mutex; + }else if (res == -ENOTRECOVERABLE ) { + res =action_result (pfn,MF_MSG_KERNEL ,MF_IGNORED ); + goto unlock_mutex; }else if (res <0 ) { res =action_result (pfn,MF_MSG_GET_HWPOISON ,MF_IGNORED ); goto unlock_mutex;
If that is what you are suggestion, maybe we can create another MF_MSG_RESERVED? and another return value for get_any_page() to track the reserve pages ?
Thanks for the review and suggestions,
--breno
David Hildenbrand (Arm)
maintainerRe: [PATCH v6 2/4] mm/memory-failure: classify get_any_page() failures by reason
Quoted 77 lines · Breno Leitao
Quoted 16 lines · David Hildenbrand (Arm)
Review
Quoted 12 lines
(quoted diff) +6
-1} goto unlock_mutex; } else if (res < 0) { - if (is_reserved) + /* + * Promote a stable unhandlable kernel page diagnosed by + * get_hwpoison_page() to MF_MSG_KERNEL alongside reserved + * pages; transient lifecycle races stay as MF_MSG_GET_HWPOISON. + */ + if (is_reserved || gp_status == MF_GET_PAGE_UNHANDLABLE) res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);It's all a bit of a mess.
get_hwpoison_page()should just indicate that a page is unhandable if it isPG_reserved?Are you saying that we should identify if the page is
PG_reservedinget_hwpoison_page()instead of inmemory_failure(), as done in the previous patch ("mm/memory-failure: reportMF_MSG_KERNELfor reserved pages") ?Quoted 2 lines
Why can't we just return a special error code from
get_hwpoison_page()? We ahve plenty of errno values to chose from.Something like:
mm/memory-failure.c +9
-4@@ -878,7 +878,7 @@ static const char *action_name[] = { };static const char *const action_page_types[] = { - [MF_MSG_KERNEL ] ="reserved kernel page" , + [MF_MSG_KERNEL ] ="unrecoverable kernel page" , [MF_MSG_KERNEL_HIGH_ORDER ] ="high-order kernel page" , [MF_MSG_HUGE ] ="huge page" , [MF_MSG_FREE_HUGE ] ="free huge page" ,@@ -1394,6 +1394,21 @@ static int get_any_page(struct page *p, unsigned long flags)int ret =0 , pass =0 ;bool count_increased = false; +if (PageReserved (p)) { + ret = -ENOTRECOVERABLE ; + goto out; + } +if (flags &MF_COUNT_INCREASED ) count_increased = true;@@ -1422,7 +1437,7 @@ static int get_any_page(struct page *p, unsigned long flags)shake_page (p); goto try_again; } - ret = -EIO ; + ret = -ENOTRECOVERABLE ; goto out; } }@@ -1441,10 +1456,10 @@ static int get_any_page(struct page *p, unsigned long flags) goto try_again; }put_page (p); - ret = -EIO ; + ret = -ENOTRECOVERABLE ; } out: -if (ret == -EIO ) +if (ret == -EIO || ret == -ENOTRECOVERABLE )pr_err ("%#lx: unhandlable page.\n" ,page_to_pfn (p));return ret;
mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2456
Quoted 9 lines
mm/memory-failure.c +3
-0@@ -2431,6 +2448,9 @@ int memory_failure(unsigned long pfn, int flags) res =action_result (pfn,MF_MSG_KERNEL_HIGH_ORDER ,MF_IGNORED ); } goto unlock_mutex; + }else if (res == -ENOTRECOVERABLE ) { + res =action_result (pfn,MF_MSG_KERNEL ,MF_IGNORED ); + goto unlock_mutex; }else if (res <0 ) { res =action_result (pfn,MF_MSG_GET_HWPOISON ,MF_IGNORED ); goto unlock_mutex;
That might probably read nicer as
switch (res) {
case 0: ...
case 1: ...
case -ENOTRECOVERABLE: ...
case ...
default:
}
Quoted 5 lines
If that is what you are suggestion, maybe we can create another
MF_MSG_RESERVED? and another return value forget_any_page()to track the reserve pages ?
I guess "reserved" is really just like most other kernel pages. So I wouldn't special-case them here.
Or would there be a good reason?
Signature · 3 lines
Cheers, David
Re: [PATCH v6 2/4] mm/memory-failure: classify get_any_page() failures by reason
Quoted 36 lines · David Hildenbrand (Arm)
Quoted 14 lines
mm/memory-failure.c +2
-2@@ -1441,10 +1456,10 @@ static int get_any_page(struct page *p, unsigned long flags) goto try_again; }put_page (p); - ret = -EIO ; + ret = -ENOTRECOVERABLE ; } out: -if (ret == -EIO ) +if (ret == -EIO || ret == -ENOTRECOVERABLE )pr_err ("%#lx: unhandlable page.\n" ,page_to_pfn (p));return ret;mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2456
Quoted 9 lines
mm/memory-failure.c +3
-0@@ -2431,6 +2448,9 @@ int memory_failure(unsigned long pfn, int flags) res =action_result (pfn,MF_MSG_KERNEL_HIGH_ORDER ,MF_IGNORED ); } goto unlock_mutex; + }else if (res == -ENOTRECOVERABLE ) { + res =action_result (pfn,MF_MSG_KERNEL ,MF_IGNORED ); + goto unlock_mutex; }else if (res <0 ) { res =action_result (pfn,MF_MSG_GET_HWPOISON ,MF_IGNORED ); goto unlock_mutex;That might probably read nicer as
switch (res) {
case 0: ...
case 1: ...
case-ENOTRECOVERABLE: ...
case ...
default:
}Quoted 2 lines
Quoted 8 lines
Quoted 3 lines
If that is what you are suggestion, maybe we can create another
MF_MSG_RESERVED? and another return value forget_any_page()to track the reserve pages ?I guess "reserved" is really just like most other kernel pages. So I wouldn't special-case them here.
Or would there be a good reason?
Not really, treating them as MF_MSG_KERNEL is sufficient for my use case.
Thank you for the review. I'm digesting all the feedback and will send out a new revision shortly, where we can continue the discussion.
--breno
PATCH v6 3/4 mm/memory-failure: add panic option for unrecoverable pages
In reply to Breno LeitaoAdd a sysctl panic_on_unrecoverable_memory_failure that triggers a kernel panic when memory_failure() encounters pages that cannot be recovered. This provides a clean crash with useful debug information rather than allowing silent data corruption or a delayed crash at an unrelated code path.
Panic eligibility is intentionally narrow: only MF_MSG_KERNEL with result == MF_IGNORED panics. That covers reserved pages (PageReserved) and the kernel page types that the prior patch promotes from MF_MSG_GET_HWPOISON via MF_GET_PAGE_UNHANDLABLE — slab, vmalloc, page tables, kernel stacks, and similar non-LRU/non-buddy kernel-owned pages.
All other action types are excluded:
- MF_MSG_GET_HWPOISON and MF_MSG_KERNEL_HIGH_ORDER can be reached by transient refcount races with the page allocator (an in-flight buddy allocation has refcount 0 and is no longer on the buddy free list, briefly), and panicking on them would risk killing the box for what is actually a recoverable userspace page.
- MF_MSG_UNKNOWN means identify_page_state() could not classify the page; that is precisely the wrong basis for a panic decision.
--- mm/memory-failure.c | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+)
mm/memory-failure.c +26 -0
@@ -74,6 +74,8 @@ static int sysctl_memory_failure_recovery __read_mostly = 1;static int sysctl_enable_soft_offline__read_mostly =1 ; +static int sysctl_panic_on_unrecoverable_mf__read_mostly ; +atomic_long_t num_poisoned_pages__read_mostly =ATOMIC_LONG_INIT (0 );static bool hw_memory_failure__read_mostly = false;
@@ -155,6 +157,15 @@ static const struct ctl_table memory_failure_table[] = { .proc_handler = proc_dointvec_minmax, .extra1 = SYSCTL_ZERO, .extra2 = SYSCTL_ONE, + }, + { + .procname = "panic_on_unrecoverable_memory_failure", + .data = &sysctl_panic_on_unrecoverable_mf, + .maxlen = sizeof(sysctl_panic_on_unrecoverable_mf), + .mode = 0644, + .proc_handler = proc_dointvec_minmax, + .extra1 = SYSCTL_ZERO, + .extra2 = SYSCTL_ONE, } };
@@ -1281,6 +1292,18 @@ static void update_per_node_mf_stats(unsigned long pfn, ++mf_stats->total; } +static bool panic_on_unrecoverable_mf (enum mf_action_page_type type, +enum mf_result result) +{ +if (!sysctl_panic_on_unrecoverable_mf || result !=MF_IGNORED ) +return false; + +if (type ==MF_MSG_KERNEL ) +return true; + +return false; +} +/* * "Dirty/Clean" indication is not 100% accurate due to the possibility of * setting PG_dirty outside page lock. See also comment above set_page_dirty().
@@ -1298,6 +1321,9 @@ static int action_result(unsigned long pfn, enum mf_action_page_type type,pr_err ("%#lx: recovery action for %s: %s\n" , pfn, action_page_types[type], action_name[result]); +if (panic_on_unrecoverable_mf (type, result)) +panic ("Memory failure: %#lx: unrecoverable page" , pfn); +return (result ==MF_RECOVERED || result ==MF_DELAYED ) ?0 : -EBUSY ; }
Signature · 1 line
2.53.0-Meta
David Hildenbrand (Arm)
maintainerQuoted 5 lines
mm/memory-failure.c +0
-0@@ -1281,6 +1292,18 @@ static void update_per_node_mf_stats(unsigned long pfn, ++mf_stats->total; }
mm/memory-failure.c static void update_per_node_mf_stats(unsigned long pfn, · line 1304
Quoted 10 lines
mm/memory-failure.c +10
-0+static bool panic_on_unrecoverable_mf (enum mf_action_page_type type, +enum mf_result result) +{ +if (!sysctl_panic_on_unrecoverable_mf || result !=MF_IGNORED ) +return false; + +if (type ==MF_MSG_KERNEL ) +return true; + +return false;
return type == MF_MSG_KERNEL;
might be simpler.
Signature · 3 lines
Cheers, David
Quoted 18 lines · David Hildenbrand (Arm)
Quoted 5 lines
mm/memory-failure.c +0
-0@@ -1281,6 +1292,18 @@ static void update_per_node_mf_stats(unsigned long pfn, ++mf_stats->total; }mm/memory-failure.c static void update_per_node_mf_stats(unsigned long pfn, · line 1304
Quoted 10 lines
mm/memory-failure.c +10
-0+static bool panic_on_unrecoverable_mf (enum mf_action_page_type type, +enum mf_result result) +{ +if (!sysctl_panic_on_unrecoverable_mf || result !=MF_IGNORED ) +return false; + +if (type ==MF_MSG_KERNEL ) +return true; + +return false;return type ==
MF_MSG_KERNEL;
Quoted 1 line
might be simpler.
Ack, I will update once we decide about the other pendencies.
PATCH v6 4/4 Documentation: document panic_on_unrecoverable_memory_failure sysctl
In reply to Breno LeitaoAdd documentation for the new vm.panic_on_unrecoverable_memory_failure sysctl, describing which failures trigger a panic (kernel-owned pages the handler cannot recover) and which are intentionally left out (transient allocator races and unclassified pages).
--- Documentation/admin-guide/sysctl/vm.rst | 70 +++++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+)
Documentation/admin-guide/sysctl/vm.rst +70 -0
@@ -67,6 +67,7 @@ Currently, these files are in /proc/sys/vm: - page-cluster - page_lock_unfairness - panic_on_oom +- panic_on_unrecoverable_memory_failure - percpu_pagelist_high_fraction - stat_interval - stat_refresh
@@ -925,6 +926,75 @@ panic_on_oom=2+kdump gives you very strong tool to investigate why oom happens. You can get snapshot. +panic_on_unrecoverable_memory_failure +====================================== + +When a hardware memory error (e.g. multi-bit ECC) hits a kernel page +that cannot be recovered by the memory failure handler, the default +behaviour is to ignore the error and continue operation. This is +dangerous because the corrupted data remains accessible to the kernel, +risking silent data corruption or a delayed crash when the poisoned +memory is next accessed. + +When enabled, this sysctl triggers a panic on kernel-owned pages that +the memory failure handler cannot recover: reserved pages +(``PageReserved``) and stable kernel pages that hwpoison cannot handle +(slab, vmalloc, page tables, kernel stacks, and similar non-LRU, +non-buddy pages). + +Other failure paths are intentionally left out because they can be +reached by transient races with the page allocator (an in-flight +buddy allocation has refcount 0 and is no longer on the buddy free +list, briefly), and panicking on them would risk killing the box for +a page that was actually destined for userspace where the standard +SIGBUS recovery path applies. Pages whose state could not be +classified at all are also not covered, since an unknown state is +not a sound basis for a panic decision. + +For many environments it is preferable to panic immediately with a clean +crash dump that captures the original error context, rather than to +continue and face a random crash later whose cause is difficult to +diagnose. + +Use cases +--------- + +This option is most useful in environments where unattributed crashes +are expensive to debug or where data integrity must take precedence +over availability: + +* Large fleets, where multi-bit ECC errors on kernel pages are observed + regularly and post-mortem analysis of an unrelated downstream crash + (often seconds to minutes after the original error) consumes + significant engineering effort. + +* Systems configured with kdump, where panicking at the moment of the + hardware error produces a vmcore that still contains the faulting + address, the affected page state, and the originating MCE/GHES + record — context that is typically lost by the time a delayed crash + occurs. + +* High-availability clusters that rely on fast, deterministic node + failure for failover, and prefer an immediate panic over silent data + corruption propagating to replicas or persistent storage. + +* Kernel and platform developers reproducing hwpoison issues with + tools such as ``mce-inject`` or error-injection debugfs interfaces, + where panicking on the unrecoverable path makes regressions + immediately visible instead of surfacing as later, unrelated + failures. + += ===================================================================== +0 Try to continue operation (default). +1 Panic immediately. If the ``panic`` sysctl is also non-zero then the + machine will be rebooted. += ===================================================================== + +Example:: + + echo 1 > /proc/sys/vm/panic_on_unrecoverable_memory_failure + + percpu_pagelist_high_fraction =============================
Signature · 1 line
2.53.0-Meta