mm/memory-failure: add panic option for unrecoverable pages
Subsystems (7)
v9 cover mm/memory-failure: add panic option for unrecoverable pages
A multi-bit ECC error on a kernel-owned page that the memory failure handler cannot recover is currently swallowed: PG_hwpoison is set, the event is logged, and the kernel keeps running. The corrupted memory remains accessible to the kernel and either drives silent data corruption or surfaces seconds-to-minutes later as an apparently unrelated crash. In a large fleet that delayed, unattributable crash turns into significant engineering effort to root-cause; in a kdump configuration, by the time the crash happens the original error context (faulting PFN, MCE/GHES record, page state) is long gone.
This series adds an opt-in sysctl, vm.panic_on_unrecoverable_memory_failure, that converts an unrecoverable kernel-page hwpoison event into an immediate panic with a clean dmesg/vmcore that still contains the original failure context. The default is disabled so existing workloads see no change.
There is a selftest that test different cases, and I tested it using the following variants:
┌─────────┬──────────┬───────────────────────────────────────────────────────────┐ │ Variant │ PFN │ Result │ ├─────────┼──────────┼───────────────────────────────────────────────────────────┤ │ rodata │ 0x2600 │ Panic with "Memory failure: 0x2600: unrecoverable page" │ ├─────────┼──────────┼───────────────────────────────────────────────────────────┤ │ slab │ 0x100032 │ Panic with "Memory failure: 0x100032: unrecoverable page" │ ├─────────┼──────────┼───────────────────────────────────────────────────────────┤ │ pgtable │ 0x100000 │ Panic with "Memory failure: 0x100000: unrecoverable page" │ └─────────┴──────────┴───────────────────────────────────────────────────────────┘
Each one shows the same call trace, exactly the path the series builds:
hard_offline_page_store
→ memory_failure
→ action_result
→ panic("Memory failure: %#lx: unrecoverable page")
---
Changes in v9:
- HWPoisonKernelOwned(): wrap the head-page checks in a
compound_head() recheck loop so a concurrent split or compound free cannot leave us trusting a stale view (Miaohe, Lance, David).
- selftest: drop the gawk-only strtonum() in hwpoison-panic.sh; do the hex parsing with a small index()-based helper so the test no longer spuriously skips itself on mawk-based distros (Sashiko).
- selftest: move hwpoison-panic.sh from TEST_FILES to TEST_PROGS_EXTENDED so the script is installed executable rather
than as a non-executable data file (Sashiko).
- Link to v8: https://patch.msgid.link/[email protected]
Changes in v8:
- Commit message rewording (David)
- Add HWPoisonKernelOwned() helper (Lance)
- Removed patch "mm/memory-failure: short-circuit PG_reserved before get_hwpoison_page()"
- Broaden the selftest (Lance)
- Link to v7: https://patch.msgid.link/[email protected]
Changes in v7:
- Move the PG_reserved / unhandlable-kernel-page classification into get_any_page() and surface it via -ENOTRECOVERABLE, per David Hildenbrand's and Lance Yang's review of v6. This drops the is_reserved snapshot in memory_failure() and the mf_get_page_status enum / out-parameter introduced in v6.
- Restructure the post-call branch in memory_failure() as a switch
over the get_hwpoison_page() return code (David).
- Drop the "reserved" qualifier from the MF_MSG_KERNEL label and the matching tracepoint string; the enum now covers both PG_reserved
pages and other unhandlable kernel pages.
- Squash the former patches 1/4 ("MF_MSG_KERNEL for reserved pages")
and 2/4 ("classify get_any_page() failures by reason") into a
single classification patch; the series is now 3 patches.
- Simplify panic_on_unrecoverable_mf() to a single return statement (David).
- Link to v6: https://patch.msgid.link/[email protected]
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]>
To: David Hildenbrand <[email protected]>
To: Lorenzo Stoakes <[email protected]>
To: "Liam R. Howlett" <[email protected]>
To: Vlastimil Babka <[email protected]>
To: Mike Rapoport <[email protected]>
To: Suren Baghdasaryan <[email protected]>
To: Michal Hocko <[email protected]>
To: Shuah Khan <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
---
Breno Leitao (6):
mm/memory-failure: drop dead error_states[] entry for reserved pages mm/memory-failure: surface unhandlable kernel pages as -ENOTRECOVERABLE mm/memory-failure: report MF_MSG_KERNEL for unrecoverable kernel pages mm/memory-failure: add panic option for unrecoverable pages
Documentation: document panic_on_unrecoverable_memory_failure sysctl selftests/mm: add hwpoison-panic destructive test
Documentation/admin-guide/sysctl/vm.rst | 85 +++++++++++ mm/memory-failure.c | 114 ++++++++++++--- tools/testing/selftests/mm/Makefile | 4 + tools/testing/selftests/mm/hwpoison-panic.sh | 208 +++++++++++++++++++++++++++ 4 files changed, 393 insertions(+), 18 deletions(-)
---
base-commit: e7e28506af98ce4e1059e5ec59334b335c00a246
change-id: 20260323-ecc_panic-4e473b83087c
Best regards,
Signature · 1 line
Breno Leitao <[email protected]>
PATCH v9 1/6 mm/memory-failure: drop dead error_states[] entry for reserved pages
The first entry of error_states[],
{ reserved, reserved, MF_MSG_KERNEL, me_kernel },
is unreachable. identify_page_state() has two callers, and neither one can dispatch a PG_reserved page to me_kernel():
* memory_failure() reaches identify_page_state() only after get_hwpoison_page() returned 1. get_any_page() reaches that return only via __get_hwpoison_page(), which only takes a refcount when the page is HWPoisonHandlable(). HWPoisonHandlable() is an allowlist for LRU, free-buddy, and (for soft-offline) movable_ops pages -- PG_reserved pages do not satisfy any of these, so they fail with -EBUSY/-EIO long before identify_page_state() runs.
* try_memory_failure_hugetlb() reaches identify_page_state() only via the MF_HUGETLB_IN_USED branch, where the page is necessarily a hugetlb folio. hugetlb folios don't carry PG_reserved at that
point: hugetlb_folio_init_vmemmap() calls __folio_clear_reserved() during init, so the reserved entry would not match even if it were still present.
me_kernel() never executes and the entry exists only to be matched against by code that cannot see it.
Drop the entry, the me_kernel() helper, and the now-unused "reserved" macro. Leave the MF_MSG_KERNEL enum value in place: it remains part of the tracepoint and pr_err() string tables, and follow-on work to classify unrecoverable kernel pages can reuse it without churning the user-visible enum.
No functional change.
--- mm/memory-failure.c | 14 -------------- 1 file changed, 14 deletions(-)
mm/memory-failure.c +0 -14
@@ -980,17 +980,6 @@ static bool has_extra_refcount(struct page_state *ps, struct page *p,return false; } -/* -* Error hit kernel page. -* Do nothing, try to be lucky and not touch this instead. For a few cases we -* could be more sophisticated. -*/ -static int me_kernel (struct page_state *ps,struct page *p) -{ -unlock_page (p); -return MF_IGNORED ; -} -/* * Page in unknown state. Do nothing. * This is a catch-all in case we fail to make sense of the page state.
@@ -1199,10 +1188,8 @@ static int me_huge_page(struct page_state *ps, struct page *p)#define mlock (1UL << PG_mlocked)#define lru (1UL << PG_lru)#define head (1UL << PG_head) -#define reserved (1UL << PG_reserved)static struct page_state error_states[] = { - { reserved, reserved,MF_MSG_KERNEL , me_kernel },/* * free pages are specially detected outside this table: * PG_buddy pages only make a small fraction of all free pages.
@@ -1234,7 +1221,6 @@ static struct page_state error_states[] = {#undef mlock#undef lru#undef head -#undef reservedstatic void update_per_node_mf_stats (unsigned long pfn,enum mf_result result)
Signature · 1 line
2.53.0-Meta
PATCH v9 2/6 mm/memory-failure: surface unhandlable kernel pages as -ENOTRECOVERABLE
In reply to Breno Leitaoget_any_page() collapses every HWPoisonHandlable() rejection into a single -EIO via the __get_hwpoison_page() -> -EBUSY -> shake_page() -> retry path. That is correct for the transient case (a userspace folio briefly off LRU during migration or compaction, which a later shake can drag back), but wrong for stable kernel-owned pages: slab, page-table, large-kmalloc and PG_reserved pages will never become HWPoisonHandlable(), so the retry loop is wasted work and the final -EIO loses the "this is structurally unrecoverable" information. memory_failure() then maps -EIO into MF_MSG_GET_HWPOISON, which the panic-on-unrecoverable sysctl deliberately does not act on.
Introduce HWPoisonKernelOwned(), a small predicate that positively identifies pages the hwpoison handler cannot recover from:
HWPoisonKernelOwned(p, flags) :=
!(MF_SOFT_OFFLINE && page_has_movable_ops(p)) &&
(PageReserved(p) ||
PageSlab(head) || PageTable(head) || PageLargeKmalloc(head)) where head = compound_head(p).
PG_reserved is a per-page flag (PF_NO_COMPOUND) and is tested on the page directly. The slab, page-table and large-kmalloc page-type bits are only stored on the head page, so those tests resolve the compound head first, then re-read compound_head(page) afterwards: a concurrent split or compound free that moves head invalidates the just-read flags and the loop retries. The lookup still takes no refcount, mirroring the rest of get_any_page(); the recheck closes the common split race, and a residual free->alloc->free in the same window can only mis-tag a genuinely poisoned page, never reclassify a handlable one.
The MF_SOFT_OFFLINE / page_has_movable_ops() opt-out mirrors the same exception in HWPoisonHandlable(): soft-offline is allowed to migrate movable_ops pages even though they are not on the LRU, and we must not pre-empt that with an unrecoverable verdict.
The list is intentionally not exhaustive. vmalloc and kernel-stack pages, for example, do not carry a page_type bit and would need a different oracle; they keep going through the existing retry path unchanged. This is the smallest set we can identify with certainty by page type.
Wire the helper into the top of get_any_page() to short-circuit those pages before the retry loop runs. On a hit, drop the caller's MF_COUNT_INCREASED reference (if any) and return -ENOTRECOVERABLE straight away. Pages outside the helper's positive list still take the existing retry path and return -EIO, leaving operator-visible behaviour for those cases unchanged.
Extend the unhandlable-page pr_err() to fire for either errno and update the get_hwpoison_page() kerneldoc to document the new return.
memory_failure() still folds every negative return into MF_MSG_GET_HWPOISON via its existing "else if (res < 0)" branch, so this patch on its own only changes the errno that soft_offline_page() can propagate to its callers. A follow-up wires -ENOTRECOVERABLE through memory_failure() and reports MF_MSG_KERNEL for the unrecoverable cases, which is what the panic_on_unrecoverable_memory_failure sysctl observes.
--- mm/memory-failure.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 58 insertions(+), 2 deletions(-)
mm/memory-failure.c +58 -2
@@ -1325,6 +1325,46 @@ static inline bool HWPoisonHandlable(struct page *page, unsigned long flags)return PageLRU (page) ||is_free_buddy_page (page); } +/* +* Positive identification of pages the hwpoison handler cannot recover. +* These page types are owned by kernel internals (no userspace mapping +* to unmap, no file mapping to invalidate, no migration target), so the +* shake_page() / retry loop in get_any_page() can never turn them into +* something HWPoisonHandlable() will accept. Short-circuit them to +* -ENOTRECOVERABLE so callers can panic on operator request instead of +* spinning through retries that exit as a transient-looking -EIO. +* +* The MF_SOFT_OFFLINE / page_has_movable_ops() opt-out mirrors +* HWPoisonHandlable(): soft-offline is allowed to migrate movable_ops +* pages even though they are not on the LRU. +*/ +static inline bool HWPoisonKernelOwned (struct page *page,unsigned long flags) +{ +struct page *head; + +if ((flags &MF_SOFT_OFFLINE ) &&page_has_movable_ops (page)) +return false; + +/* PG_reserved is a per-page flag, never set on a compound page. */ +if (PageReserved (page)) +return true; + +/* +* Page-type bits live only on the head page, so resolve any tail +* first. The check takes no refcount; recheck the head afterwards +* so a concurrent split or compound free cannot leave us trusting +* a stale view. A free->alloc->free in the same window is still +* possible but closing it would require taking a reference here. +*/ +retry: + head =compound_head (page); +if (!(PageSlab (head) ||PageTable (head) ||PageLargeKmalloc (head))) +return false; +if (head !=compound_head (page)) + goto retry; +return true; +} +static int __get_hwpoison_page (struct page *page,unsigned long flags) {struct folio *folio =page_folio (page);
@@ -1371,6 +1411,19 @@ static int get_any_page(struct page *p, unsigned long flags)if (flags &MF_COUNT_INCREASED ) count_increased = true; +/* +* Page types we know are kernel-owned and cannot be recovered. +* Short-circuit before the shake_page() / retry loop, which +* cannot turn any of these into something HWPoisonHandlable(). +* Drop the caller's reference if MF_COUNT_INCREASED took one. +*/ +if (HWPoisonKernelOwned (p, flags)) { +if (count_increased) +put_page (p); + ret = -ENOTRECOVERABLE ; + goto out; + } + try_again:if (!count_increased) { ret =__get_hwpoison_page (p, flags);
@@ -1418,7 +1471,7 @@ static int get_any_page(struct page *p, unsigned long flags) ret = -EIO ; } out: -if (ret == -EIO ) +if (ret == -EIO || ret == -ENOTRECOVERABLE )pr_err ("%#lx: unhandlable page.\n" ,page_to_pfn (p));return ret;
@@ -1475,7 +1528,10 @@ static int __get_unpoison_page(struct page *page)* -EIO for pages on which we can not handle memory errors, * -EBUSY when get_hwpoison_page() has raced with page lifecycle * operations like allocation and free, -* -EHWPOISON when the page is hwpoisoned and taken off from buddy. +* -EHWPOISON when the page is hwpoisoned and taken off from buddy, +* -ENOTRECOVERABLE for kernel-owned pages identified by +* HWPoisonKernelOwned() (PG_reserved, slab, +* page-table, large-kmalloc) that the handler cannot recover. */ static int get_hwpoison_page (struct page *p,unsigned long flags) {
Signature · 1 line
2.53.0-Meta
David Hildenbrand (Arm)
maintainerRe: [PATCH v9 2/6] mm/memory-failure: surface unhandlable kernel pages as -ENOTRECOVERABLE
Quoted 85 lines · Breno Leitao
get_any_page()collapses everyHWPoisonHandlable()rejection into a single-EIOvia the__get_hwpoison_page()->-EBUSY->shake_page()-> retry path. That is correct for the transient case (a userspace folio briefly off LRU during migration or compaction, which a later shake can drag back), but wrong for stable kernel-owned pages: slab, page-table, large-kmalloc andPG_reservedpages will never becomeHWPoisonHandlable(), so the retry loop is wasted work and the final-EIOloses the "this is structurally unrecoverable" information.memory_failure()then maps-EIOintoMF_MSG_GET_HWPOISON, which the panic-on-unrecoverable sysctl deliberately does not act on.Introduce
HWPoisonKernelOwned(), a small predicate that positively identifies pages the hwpoison handler cannot recover from:HWPoisonKernelOwned(p, flags) := !(MF_SOFT_OFFLINE && page_has_movable_ops(p)) && (PageReserved(p) || PageSlab(head) || PageTable(head) || PageLargeKmalloc(head))where head =
compound_head(p).
PG_reservedis a per-page flag (PF_NO_COMPOUND) and is tested on the page directly. The slab, page-table and large-kmalloc page-type bits are only stored on the head page, so those tests resolve the compound head first, then re-readcompound_head(page)afterwards: a concurrent split or compound free that moves head invalidates the just-read flags and the loop retries. The lookup still takes no refcount, mirroring the rest ofget_any_page(); the recheck closes the common split race, and a residualfree->alloc->freein the same window can only mis-tag a genuinely poisoned page, never reclassify a handlable one.The
MF_SOFT_OFFLINE/page_has_movable_ops()opt-out mirrors the same exception inHWPoisonHandlable(): soft-offline is allowed to migratemovable_opspages even though they are not on the LRU, and we must not pre-empt that with an unrecoverable verdict.The list is intentionally not exhaustive. vmalloc and kernel-stack pages, for example, do not carry a
page_typebit and would need a different oracle; they keep going through the existing retry path unchanged. This is the smallest set we can identify with certainty by page type.Wire the helper into the top of
get_any_page()to short-circuit those pages before the retry loop runs. On a hit, drop the caller'sMF_COUNT_INCREASEDreference (if any) and return-ENOTRECOVERABLEstraight away. Pages outside the helper's positive list still take the existing retry path and return-EIO, leaving operator-visible behaviour for those cases unchanged.Extend the unhandlable-page
pr_err()to fire for either errno and update theget_hwpoison_page()kerneldoc to document the new return.
memory_failure()still folds every negative return intoMF_MSG_GET_HWPOISONvia its existing "else if (res < 0)" branch, so this patch on its own only changes the errno thatsoft_offline_page()can propagate to its callers. A follow-up wires-ENOTRECOVERABLEthroughmemory_failure()and reportsMF_MSG_KERNELfor the unrecoverable cases, which is what thepanic_on_unrecoverable_memory_failuresysctl observes.Suggested-by David Hildenbrand <[email protected]>Suggested-by Lance Yang <[email protected]>Signed-off-by Breno Leitao <[email protected]>--- mm/memory-failure.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 58 insertions(+), 2 deletions(-)mm/memory-failure.c +10
-0@@ -1325,6 +1325,46 @@ static inline bool HWPoisonHandlable(struct page *page, unsigned long flags)return PageLRU (page) ||is_free_buddy_page (page); } +/* +* Positive identification of pages the hwpoison handler cannot recover. +* These page types are owned by kernel internals (no userspace mapping +* to unmap, no file mapping to invalidate, no migration target), so the +* shake_page() / retry loop in get_any_page() can never turn them into +* something HWPoisonHandlable() will accept. Short-circuit them to +* -ENOTRECOVERABLE so callers can panic on operator request instead of +* spinning through retries that exit as a transient-looking -EIO. +* +* The MF_SOFT_OFFLINE / page_has_movable_ops() opt-out mirrors
mm/memory-failure.c static inline bool HWPoisonHandlable(struct page *page, unsigned long flags) · line 1347
Quoted 10 lines
mm/memory-failure.c +10
-0+* HWPoisonHandlable(): soft-offline is allowed to migrate movable_ops +* pages even though they are not on the LRU. +*/ +static inline bool HWPoisonKernelOwned (struct page *page,unsigned long flags) +{ +struct page *head; + +if ((flags &MF_SOFT_OFFLINE ) &&page_has_movable_ops (page)) +return false; +
On a second look: Do we really need that? The page types below never support migration. So I guess that check is not required?
Apart from that, looks good with two comments:
a) HWPoisonKernelOwned: this is not the common style for us to name functions.
is_kernel_owned_page() or sth like that would do.
b) The function doc can likely be simplified a bit. No need to mention the short-circuit stuff, for example, IMHO.
Signature · 3 lines
Cheers, David
Re: [PATCH v9 2/6] mm/memory-failure: surface unhandlable kernel pages as -ENOTRECOVERABLE
Quoted 100 lines · David Hildenbrand (Arm)
Quoted 85 lines · Breno Leitao
get_any_page()collapses everyHWPoisonHandlable()rejection into a single-EIOvia the__get_hwpoison_page()->-EBUSY->shake_page()-> retry path. That is correct for the transient case (a userspace folio briefly off LRU during migration or compaction, which a later shake can drag back), but wrong for stable kernel-owned pages: slab, page-table, large-kmalloc andPG_reservedpages will never becomeHWPoisonHandlable(), so the retry loop is wasted work and the final-EIOloses the "this is structurally unrecoverable" information.memory_failure()then maps-EIOintoMF_MSG_GET_HWPOISON, which the panic-on-unrecoverable sysctl deliberately does not act on.Introduce
HWPoisonKernelOwned(), a small predicate that positively identifies pages the hwpoison handler cannot recover from:HWPoisonKernelOwned(p, flags) := !(MF_SOFT_OFFLINE && page_has_movable_ops(p)) && (PageReserved(p) || PageSlab(head) || PageTable(head) || PageLargeKmalloc(head))where head =
compound_head(p).
PG_reservedis a per-page flag (PF_NO_COMPOUND) and is tested on the page directly. The slab, page-table and large-kmalloc page-type bits are only stored on the head page, so those tests resolve the compound head first, then re-readcompound_head(page)afterwards: a concurrent split or compound free that moves head invalidates the just-read flags and the loop retries. The lookup still takes no refcount, mirroring the rest ofget_any_page(); the recheck closes the common split race, and a residualfree->alloc->freein the same window can only mis-tag a genuinely poisoned page, never reclassify a handlable one.The
MF_SOFT_OFFLINE/page_has_movable_ops()opt-out mirrors the same exception inHWPoisonHandlable(): soft-offline is allowed to migratemovable_opspages even though they are not on the LRU, and we must not pre-empt that with an unrecoverable verdict.The list is intentionally not exhaustive. vmalloc and kernel-stack pages, for example, do not carry a
page_typebit and would need a different oracle; they keep going through the existing retry path unchanged. This is the smallest set we can identify with certainty by page type.Wire the helper into the top of
get_any_page()to short-circuit those pages before the retry loop runs. On a hit, drop the caller'sMF_COUNT_INCREASEDreference (if any) and return-ENOTRECOVERABLEstraight away. Pages outside the helper's positive list still take the existing retry path and return-EIO, leaving operator-visible behaviour for those cases unchanged.Extend the unhandlable-page
pr_err()to fire for either errno and update theget_hwpoison_page()kerneldoc to document the new return.
memory_failure()still folds every negative return intoMF_MSG_GET_HWPOISONvia its existing "else if (res < 0)" branch, so this patch on its own only changes the errno thatsoft_offline_page()can propagate to its callers. A follow-up wires-ENOTRECOVERABLEthroughmemory_failure()and reportsMF_MSG_KERNELfor the unrecoverable cases, which is what thepanic_on_unrecoverable_memory_failuresysctl observes.Suggested-by David Hildenbrand <[email protected]>Suggested-by Lance Yang <[email protected]>Signed-off-by Breno Leitao <[email protected]>--- mm/memory-failure.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 58 insertions(+), 2 deletions(-)mm/memory-failure.c +10
-0@@ -1325,6 +1325,46 @@ static inline bool HWPoisonHandlable(struct page *page, unsigned long flags)return PageLRU (page) ||is_free_buddy_page (page); } +/* +* Positive identification of pages the hwpoison handler cannot recover. +* These page types are owned by kernel internals (no userspace mapping +* to unmap, no file mapping to invalidate, no migration target), so the +* shake_page() / retry loop in get_any_page() can never turn them into +* something HWPoisonHandlable() will accept. Short-circuit them to +* -ENOTRECOVERABLE so callers can panic on operator request instead of +* spinning through retries that exit as a transient-looking -EIO. +* +* The MF_SOFT_OFFLINE / page_has_movable_ops() opt-out mirrors mm/memory-failure.c static inline bool HWPoisonHandlable(struct page *page, unsigned long flags) · line 1347
Quoted 10 lines
mm/memory-failure.c +10
-0+* HWPoisonHandlable(): soft-offline is allowed to migrate movable_ops +* pages even though they are not on the LRU. +*/ +static inline bool HWPoisonKernelOwned (struct page *page,unsigned long flags) +{ +struct page *head; + +if ((flags &MF_SOFT_OFFLINE ) &&page_has_movable_ops (page)) +return false; +On a second look: Do we really need that? The page types below never support migration. So I guess that check is not required?
Quoted 5 lines
Apart from that, looks good with two comments:
a) HWPoisonKernelOwned: this is not the common style for us to name functions.
is_kernel_owned_page()or sth like that would do.
Ack, I will rename it is_kernel_owned_page()
In my defence, most of the functions similar to HWPoisonKernelOwned() has this name format, and I got this discussion earlier (with Lance? I think). Here are the similar function names in that file:
* HWPoisonHandlable
* PageHWPoisonTakenOff()
* SetPageHWPoisonTakenOff
I will update in the new version.
Quoted 2 lines
b) The function doc can likely be simplified a bit. No need to mention the short-circuit stuff, for example, IMHO.
Ack
Thanks for the review,
--breno
David Hildenbrand (Arm)
maintainerRe: [PATCH v9 2/6] mm/memory-failure: surface unhandlable kernel pages as -ENOTRECOVERABLE
Quoted 109 lines · Breno Leitao
Quoted 100 lines · David Hildenbrand (Arm)
Quoted 85 lines · Breno Leitao
get_any_page()collapses everyHWPoisonHandlable()rejection into a single-EIOvia the__get_hwpoison_page()->-EBUSY->shake_page()-> retry path. That is correct for the transient case (a userspace folio briefly off LRU during migration or compaction, which a later shake can drag back), but wrong for stable kernel-owned pages: slab, page-table, large-kmalloc andPG_reservedpages will never becomeHWPoisonHandlable(), so the retry loop is wasted work and the final-EIOloses the "this is structurally unrecoverable" information.memory_failure()then maps-EIOintoMF_MSG_GET_HWPOISON, which the panic-on-unrecoverable sysctl deliberately does not act on.Introduce
HWPoisonKernelOwned(), a small predicate that positively identifies pages the hwpoison handler cannot recover from:HWPoisonKernelOwned(p, flags) := !(MF_SOFT_OFFLINE && page_has_movable_ops(p)) && (PageReserved(p) || PageSlab(head) || PageTable(head) || PageLargeKmalloc(head))where head =
compound_head(p).
PG_reservedis a per-page flag (PF_NO_COMPOUND) and is tested on the page directly. The slab, page-table and large-kmalloc page-type bits are only stored on the head page, so those tests resolve the compound head first, then re-readcompound_head(page)afterwards: a concurrent split or compound free that moves head invalidates the just-read flags and the loop retries. The lookup still takes no refcount, mirroring the rest ofget_any_page(); the recheck closes the common split race, and a residualfree->alloc->freein the same window can only mis-tag a genuinely poisoned page, never reclassify a handlable one.The
MF_SOFT_OFFLINE/page_has_movable_ops()opt-out mirrors the same exception inHWPoisonHandlable(): soft-offline is allowed to migratemovable_opspages even though they are not on the LRU, and we must not pre-empt that with an unrecoverable verdict.The list is intentionally not exhaustive. vmalloc and kernel-stack pages, for example, do not carry a
page_typebit and would need a different oracle; they keep going through the existing retry path unchanged. This is the smallest set we can identify with certainty by page type.Wire the helper into the top of
get_any_page()to short-circuit those pages before the retry loop runs. On a hit, drop the caller'sMF_COUNT_INCREASEDreference (if any) and return-ENOTRECOVERABLEstraight away. Pages outside the helper's positive list still take the existing retry path and return-EIO, leaving operator-visible behaviour for those cases unchanged.Extend the unhandlable-page
pr_err()to fire for either errno and update theget_hwpoison_page()kerneldoc to document the new return.
memory_failure()still folds every negative return intoMF_MSG_GET_HWPOISONvia its existing "else if (res < 0)" branch, so this patch on its own only changes the errno thatsoft_offline_page()can propagate to its callers. A follow-up wires-ENOTRECOVERABLEthroughmemory_failure()and reportsMF_MSG_KERNELfor the unrecoverable cases, which is what thepanic_on_unrecoverable_memory_failuresysctl observes.Suggested-by David Hildenbrand <[email protected]>Suggested-by Lance Yang <[email protected]>Signed-off-by Breno Leitao <[email protected]>--- mm/memory-failure.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 58 insertions(+), 2 deletions(-)mm/memory-failure.c +10
-0@@ -1325,6 +1325,46 @@ static inline bool HWPoisonHandlable(struct page *page, unsigned long flags)return PageLRU (page) ||is_free_buddy_page (page); } +/* +* Positive identification of pages the hwpoison handler cannot recover. +* These page types are owned by kernel internals (no userspace mapping +* to unmap, no file mapping to invalidate, no migration target), so the +* shake_page() / retry loop in get_any_page() can never turn them into +* something HWPoisonHandlable() will accept. Short-circuit them to +* -ENOTRECOVERABLE so callers can panic on operator request instead of +* spinning through retries that exit as a transient-looking -EIO. +* +* The MF_SOFT_OFFLINE / page_has_movable_ops() opt-out mirrors mm/memory-failure.c static inline bool HWPoisonHandlable(struct page *page, unsigned long flags) · line 1347
Quoted 10 lines
mm/memory-failure.c +10
-0+* HWPoisonHandlable(): soft-offline is allowed to migrate movable_ops +* pages even though they are not on the LRU. +*/ +static inline bool HWPoisonKernelOwned (struct page *page,unsigned long flags) +{ +struct page *head; + +if ((flags &MF_SOFT_OFFLINE ) &&page_has_movable_ops (page)) +return false; +On a second look: Do we really need that? The page types below never support migration. So I guess that check is not required?
Quoted 5 lines
Apart from that, looks good with two comments:
a) HWPoisonKernelOwned: this is not the common style for us to name functions.
is_kernel_owned_page()or sth like that would do.Ack, I will rename it
is_kernel_owned_page()
Quoted 7 lines
In my defence, most of the functions similar to
HWPoisonKernelOwned()has this name format, and I got this discussion earlier (with Lance? I think). Here are the similar function names in that file:* HWPoisonHandlable
*PageHWPoisonTakenOff()
* SetPageHWPoisonTakenOff
Some of these probably date back to our old way of handling page flags and things, like PageLRU.
But we really should stop :)
Quoted 2 lines
I will update in the new version.
Thanks! Probably best to wait a bit, the merge window is coming up either way, so this will have to wait a bit either way.
Signature · 3 lines
Cheers, David
Re: [PATCH v9 2/6] mm/memory-failure: surface unhandlable kernel pages as -ENOTRECOVERABLE
Quoted 13 lines · David Hildenbrand (Arm)
Quoted 12 lines · Breno Leitao
Quoted 3 lines · David Hildenbrand (Arm)
a) HWPoisonKernelOwned: this is not the common style for us to name functions.
is_kernel_owned_page()or sth like that would do.Ack, I will rename it
is_kernel_owned_page()In my defence, most of the functions similar to
HWPoisonKernelOwned()has this name format, and I got this discussion earlier (with Lance? I think). Here are the similar function names in that file:
Quoted 8 lines
Quoted 3 lines
* HWPoisonHandlable
*PageHWPoisonTakenOff()
* SetPageHWPoisonTakenOffSome of these probably date back to our old way of handling page flags and things, like PageLRU.
But we really should stop :)
Ack!
Quoted 4 lines
Quoted 1 line
I will update in the new version.
Thanks! Probably best to wait a bit, the merge window is coming up either way, so this will have to wait a bit either way.
no hurry at all,
Thanks for the review,
--breno
Miaohe Lin
maintainerRe: [PATCH v9 2/6] mm/memory-failure: surface unhandlable kernel pages as -ENOTRECOVERABLE
In reply to Breno LeitaoQuoted 102 lines · Breno Leitao
get_any_page()collapses everyHWPoisonHandlable()rejection into a single-EIOvia the__get_hwpoison_page()->-EBUSY->shake_page()-> retry path. That is correct for the transient case (a userspace folio briefly off LRU during migration or compaction, which a later shake can drag back), but wrong for stable kernel-owned pages: slab, page-table, large-kmalloc andPG_reservedpages will never becomeHWPoisonHandlable(), so the retry loop is wasted work and the final-EIOloses the "this is structurally unrecoverable" information.memory_failure()then maps-EIOintoMF_MSG_GET_HWPOISON, which the panic-on-unrecoverable sysctl deliberately does not act on.Introduce
HWPoisonKernelOwned(), a small predicate that positively identifies pages the hwpoison handler cannot recover from:HWPoisonKernelOwned(p, flags) := !(MF_SOFT_OFFLINE && page_has_movable_ops(p)) && (PageReserved(p) || PageSlab(head) || PageTable(head) || PageLargeKmalloc(head))where head =
compound_head(p).
PG_reservedis a per-page flag (PF_NO_COMPOUND) and is tested on the page directly. The slab, page-table and large-kmalloc page-type bits are only stored on the head page, so those tests resolve the compound head first, then re-readcompound_head(page)afterwards: a concurrent split or compound free that moves head invalidates the just-read flags and the loop retries. The lookup still takes no refcount, mirroring the rest ofget_any_page(); the recheck closes the common split race, and a residualfree->alloc->freein the same window can only mis-tag a genuinely poisoned page, never reclassify a handlable one.The
MF_SOFT_OFFLINE/page_has_movable_ops()opt-out mirrors the same exception inHWPoisonHandlable(): soft-offline is allowed to migratemovable_opspages even though they are not on the LRU, and we must not pre-empt that with an unrecoverable verdict.The list is intentionally not exhaustive. vmalloc and kernel-stack pages, for example, do not carry a
page_typebit and would need a different oracle; they keep going through the existing retry path unchanged. This is the smallest set we can identify with certainty by page type.Wire the helper into the top of
get_any_page()to short-circuit those pages before the retry loop runs. On a hit, drop the caller'sMF_COUNT_INCREASEDreference (if any) and return-ENOTRECOVERABLEstraight away. Pages outside the helper's positive list still take the existing retry path and return-EIO, leaving operator-visible behaviour for those cases unchanged.Extend the unhandlable-page
pr_err()to fire for either errno and update theget_hwpoison_page()kerneldoc to document the new return.
memory_failure()still folds every negative return intoMF_MSG_GET_HWPOISONvia its existing "else if (res < 0)" branch, so this patch on its own only changes the errno thatsoft_offline_page()can propagate to its callers. A follow-up wires-ENOTRECOVERABLEthroughmemory_failure()and reportsMF_MSG_KERNELfor the unrecoverable cases, which is what thepanic_on_unrecoverable_memory_failuresysctl observes.Suggested-by David Hildenbrand <[email protected]>Suggested-by Lance Yang <[email protected]>Signed-off-by Breno Leitao <[email protected]>--- mm/memory-failure.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 58 insertions(+), 2 deletions(-)mm/memory-failure.c +27
-0@@ -1325,6 +1325,46 @@ static inline bool HWPoisonHandlable(struct page *page, unsigned long flags)return PageLRU (page) ||is_free_buddy_page (page); } +/* +* Positive identification of pages the hwpoison handler cannot recover. +* These page types are owned by kernel internals (no userspace mapping +* to unmap, no file mapping to invalidate, no migration target), so the +* shake_page() / retry loop in get_any_page() can never turn them into +* something HWPoisonHandlable() will accept. Short-circuit them to +* -ENOTRECOVERABLE so callers can panic on operator request instead of +* spinning through retries that exit as a transient-looking -EIO. +* +* The MF_SOFT_OFFLINE / page_has_movable_ops() opt-out mirrors +* HWPoisonHandlable(): soft-offline is allowed to migrate movable_ops +* pages even though they are not on the LRU. +*/ +static inline bool HWPoisonKernelOwned (struct page *page,unsigned long flags) +{ +struct page *head; + +if ((flags &MF_SOFT_OFFLINE ) &&page_has_movable_ops (page)) +return false; + +/* PG_reserved is a per-page flag, never set on a compound page. */ +if (PageReserved (page)) +return true; + +/* +* Page-type bits live only on the head page, so resolve any tail +* first. The check takes no refcount; recheck the head afterwards
mm/memory-failure.c static inline bool HWPoisonHandlable(struct page *page, unsigned long flags) · line 1364
Quoted 10 lines
mm/memory-failure.c +10
-0+* so a concurrent split or compound free cannot leave us trusting +* a stale view. A free->alloc->free in the same window is still +* possible but closing it would require taking a reference here. +*/ +retry: + head =compound_head (page); +if (!(PageSlab (head) ||PageTable (head) ||PageLargeKmalloc (head))) +return false; +if (head !=compound_head (page)) + goto retry;
Looks good to me with one comment: should we write above as something like below:
bool kernel_owned; retry: head = compound_head(page); kernel_owned = PageSlab(head) || PageTable(head) || PageLargeKmalloc(head); if (head != compound_head(page)) goto retry;
I.e. we should always check whether compound_head has changed, regardless of whether the page is owned by the kernel, so we can obtain a relatively stable result?
Thanks.
.
PATCH v9 3/6 mm/memory-failure: report MF_MSG_KERNEL for unrecoverable kernel pages
In reply to Breno LeitaoThe previous patch teaches get_any_page() to return -ENOTRECOVERABLE for stable unhandlable kernel pages (PG_reserved, slab, page tables, large-kmalloc). memory_failure() still folds every negative return into MF_MSG_GET_HWPOISON, so callers that want to react to the unrecoverable cases (a panic option, smarter logging) cannot tell them apart from transient page-allocator races.
Turn the post-call branch into a switch over the get_hwpoison_page() return code: map -ENOTRECOVERABLE to MF_MSG_KERNEL and any other negative return to MF_MSG_GET_HWPOISON. case 0 keeps the existing free-buddy / kernel-high-order handling and case 1 falls through to the rest of memory_failure() unchanged.
The MF_MSG_KERNEL label and tracepoint string are kept as "reserved kernel page" to avoid breaking userspace tools that match on those literals; the enum value still adequately tags the failure even though it now also covers slab, page tables and large-kmalloc pages.
--- mm/memory-failure.c | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-)
mm/memory-failure.c +15 -2
@@ -2444,7 +2444,8 @@ int memory_failure(unsigned long pfn, int flags)* that may make page_ref_freeze()/page_ref_unfreeze() mismatch. */ res =get_hwpoison_page (p, flags); -if (!res) { +switch (res) { +case 0 :if (is_free_buddy_page (p)) {if (take_page_off_buddy (p)) {page_ref_inc (p);
@@ -2463,7 +2464,19 @@ 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 <0 ) { +case 1 : +/* Got a refcount on a handlable page. */ +break ; +case -ENOTRECOVERABLE : +/* +* Stable unhandlable kernel-owned page (PG_reserved, +* slab, page tables, large-kmalloc). +* No recovery possible. +*/ + res =action_result (pfn,MF_MSG_KERNEL ,MF_IGNORED ); + goto unlock_mutex; +default : +/* Transient lifecycle race with the page allocator. */ res =action_result (pfn,MF_MSG_GET_HWPOISON ,MF_IGNORED ); goto unlock_mutex; }
Signature · 1 line
2.53.0-Meta
PATCH v9 4/6 mm/memory-failure: add panic option for unrecoverable pages
In reply to Breno LeitaoAdd a sysctl panic_on_unrecoverable_memory_failure (disabled by default) 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. After the previous patch, MF_MSG_KERNEL covers PG_reserved pages and the kernel-owned pages promoted from get_hwpoison_page() via -ENOTRECOVERABLE (slab, page tables, large-kmalloc).
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 | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+)
mm/memory-failure.c +23 -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, } };
@@ -1255,6 +1266,15 @@ 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) +return false; + +return type ==MF_MSG_KERNEL && result ==MF_IGNORED ; +} +/* * "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().
@@ -1272,6 +1292,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
Quoted 20 lines · Breno Leitao
Add a sysctl
panic_on_unrecoverable_memory_failure(disabled by default) that triggers a kernel panic whenmemory_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_KERNELwith result ==MF_IGNOREDpanics. After the previous patch,MF_MSG_KERNELcoversPG_reservedpages and the kernel-owned pages promoted fromget_hwpoison_page()via-ENOTRECOVERABLE(slab, page tables, large-kmalloc).All other action types are excluded:
-
MF_MSG_GET_HWPOISONandMF_MSG_KERNEL_HIGH_ORDERcan 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.
Quoted 4 lines
-
MF_MSG_UNKNOWNmeansidentify_page_state()could not classify the page; that is precisely the wrong basis for a panic decision.Signed-off-by Breno Leitao <[email protected]>
Thanks.
.
PATCH v9 5/6 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 | 85 +++++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+)
Documentation/admin-guide/sysctl/vm.rst +85 -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,90 @@ 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 memory failure events +hitting kernel-owned pages that the handler cannot recover: +``PageReserved`` (firmware reservations, kernel image, vDSO, zero +page, and similar memblock-reserved regions), ``PageSlab``, +``PageTable``, and ``PageLargeKmalloc``. These are owned by the +kernel and the memory failure handler cannot reliably evict their +contents. + +For soft offline (``madvise(MADV_SOFT_OFFLINE)``, +``/sys/devices/system/memory/soft_offline_page``), pages owned by +``movable_ops`` are exempted, since soft offline is allowed to +migrate them even though they are not on the LRU. + +Other unrecoverable kernel-owned populations (vmalloc allocations, +kernel stack pages, ...) are not currently covered because the +handler has no page-type signal that distinguishes them from a +userspace folio temporarily off the LRU during migration or +compaction. Such pages still go through the standard +MF_MSG_GET_HWPOISON path: ``PG_hwpoison`` is set on them and a +delayed crash on the next access remains possible. Coverage may +grow as the handler gains stronger kernel-ownership signals. + +Recoverable failure paths are also intentionally left out: in-flight +buddy allocations and other transient races with the page allocator +can reach the same diagnostic, and panicking on them would risk +killing the box for a page destined for userspace where the standard +SIGBUS recovery path applies. Pages whose state could not be +classified at all are not covered either, 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
PATCH v9 6/6 selftests/mm: add hwpoison-panic destructive test
In reply to Breno LeitaoAdd a destructive selftest that verifies vm.panic_on_unrecoverable_memory_failure actually panics when a hwpoison error hits a kernel-owned page.
Three "kinds" of kernel-owned page can be targeted, selectable via the script's first positional argument (default: rodata):
rodata - a PG_reserved page in the kernel rodata range, sourced
from the "Kernel rodata" sub-resource of "System RAM" in /proc/iomem. That entry is reported on every major architecture and guarantees the chosen PFN is backed by struct page (an online System RAM range, not a firmware hole), is PG_reserved, and is read-only -- so even if the panic fails to fire for some reason, the resulting PG_hwpoison marker on rodata does not corrupt writable kernel state.
slab - a slab page found by walking /proc/kpageflags for the
first PFN with KPF_SLAB set (and KPF_HWPOISON / KPF_NOPAGE / KPF_COMPOUND_TAIL clear). Exercises the get_any_page() path on a non PG_reserved kernel-owned page and so catches regressions where get_any_page() collapses kernel-owned pages into a transient -EIO instead of -ENOTRECOVERABLE.
pgtable - same as slab, but the PFN is selected via KPF_PGTABLE.
PageLargeKmalloc, the fourth page type matched by HWPoisonKernelOwned(), is intentionally not covered: it is a PAGE_TYPE_OPS flag with no /proc/kpageflags bit, so selecting such a PFN from userspace is not feasible. The slab and pgtable variants already exercise the same get_any_page() positive-check branch.
The script enables the sysctl and writes the selected physical address to /sys/devices/system/memory/hard_offline_page. A successful run crashes the kernel with
Memory failure: <pfn>: unrecoverable page
A return from the inject means the panic did not fire and the test fails. Test outcome is therefore observed externally (serial console, kdump) rather than from the script's own exit code.
The script is intentionally NOT wired into run_vmtests.sh: every successful run panics the kernel, which is incompatible with the sequential "run each category in the same VM" model that run_vmtests.sh assumes. It is also not registered as a TEST_PROGS / ksft_* wrapper so a default kselftest run does not opt itself into a panic. The script is meant to be executed manually inside a disposable VM (e.g. virtme-ng), one variant per VM boot, and requires RUN_DESTRUCTIVE=1 in the environment as a safety net.
--- tools/testing/selftests/mm/Makefile | 4 + tools/testing/selftests/mm/hwpoison-panic.sh | 208 +++++++++++++++++++++++++++ 2 files changed, 212 insertions(+)
tools/testing/selftests/mm/Makefile +4 -0
@@ -174,6 +174,10 @@ TEST_PROGS += ksft_userfaultfd.sh TEST_PROGS += ksft_vma_merge.sh TEST_PROGS += ksft_vmalloc.sh +# Destructive: every successful run panics the kernel. Installed and +# kept executable, but not run from a default kselftest invocation. +TEST_PROGS_EXTENDED += hwpoison-panic.sh + TEST_FILES := test_vmalloc.sh TEST_FILES += test_hmm.sh TEST_FILES += va_high_addr_switch.sh
tools/testing/selftests/mm/hwpoison-panic.sh new file +208 -0
208 lines not on this page · raw message
Signature · 1 line
2.53.0-Meta
Miaohe Lin
maintainerRe: [PATCH v9 6/6] selftests/mm: add hwpoison-panic destructive test
Quoted 53 lines · Breno Leitao
Add a destructive selftest that verifies vm.panic_on_unrecoverable_memory_failure actually panics when a hwpoison error hits a kernel-owned page.
Three "kinds" of kernel-owned page can be targeted, selectable via the script's first positional argument (default: rodata):
rodata - a
PG_reservedpage in the kernel rodata range, sourced
from the "Kernel rodata" sub-resource of "System RAM" in/proc/iomem. That entry is reported on every major architecture and guarantees the chosen PFN is backed by struct page (an online System RAM range, not a firmware hole), isPG_reserved, and is read-only -- so even if the panic fails to fire for some reason, the resultingPG_hwpoisonmarker on rodata does not corrupt writable kernel state.slab - a slab page found by walking
/proc/kpageflagsfor the
first PFN withKPF_SLABset (andKPF_HWPOISON/KPF_NOPAGE/KPF_COMPOUND_TAILclear). Exercises theget_any_page()path on a nonPG_reservedkernel-owned page and so catches regressions whereget_any_page()collapses kernel-owned pages into a transient-EIOinstead of-ENOTRECOVERABLE.pgtable - same as slab, but the PFN is selected via
KPF_PGTABLE.PageLargeKmalloc, the fourth page type matched by
HWPoisonKernelOwned(), is intentionally not covered: it is aPAGE_TYPE_OPSflag with no/proc/kpageflagsbit, so selecting such a PFN from userspace is not feasible. The slab and pgtable variants already exercise the sameget_any_page()positive-check branch.The script enables the sysctl and writes the selected physical address to
/sys/devices/system/memory/hard_offline_page. A successful run crashes the kernel withMemory failure: <pfn>: unrecoverable page
A return from the inject means the panic did not fire and the test fails. Test outcome is therefore observed externally (serial console, kdump) rather than from the script's own exit code.
The script is intentionally NOT wired into
run_vmtests.sh: every successful run panics the kernel, which is incompatible with the sequential "run each category in the same VM" model thatrun_vmtests.shassumes. It is also not registered as aTEST_PROGS/ ksft_* wrapper so a default kselftest run does not opt itself into a panic. The script is meant to be executed manually inside a disposable VM (e.g. virtme-ng), one variant per VM boot, and requires RUN_DESTRUCTIVE=1 in the environment as a safety net.
Quoted 1 line
Signed-off-by Breno Leitao <[email protected]>
Looks good to me with two comments below.
Quoted 218 lines
--- tools/testing/selftests/mm/Makefile | 4 + tools/testing/selftests/mm/hwpoison-panic.sh | 208 +++++++++++++++++++++++++++ 2 files changed, 212 insertions(+)tools/testing/selftests/mm/Makefile +4
-0@@ -174,6 +174,10 @@ TEST_PROGS += ksft_userfaultfd.sh TEST_PROGS += ksft_vma_merge.sh TEST_PROGS += ksft_vmalloc.sh +# Destructive: every successful run panics the kernel. Installed and +# kept executable, but not run from a default kselftest invocation. +TEST_PROGS_EXTENDED += hwpoison-panic.sh + TEST_FILES := test_vmalloc.sh TEST_FILES += test_hmm.sh TEST_FILES += va_high_addr_switch.shtools/testing/selftests/mm/hwpoison-panic.sh new file +192
-0@@ -0,0 +1,208 @@ +#!/bin/bash +# SPDX-License-Identifier: GPL-2.0 +# +# Verify vm.panic_on_unrecoverable_memory_failure by injecting a hwpoison +# error on a kernel-owned page and confirming the kernel panics. +# +# Three "kinds" of kernel-owned page can be targeted, selectable via the +# first positional argument (default: rodata): +# +# rodata - a PG_reserved page in the kernel rodata range +# (sourced from /proc/iomem "Kernel rodata"). Exercises +# memory_failure() -> get_any_page() on a PageReserved page. +# +# slab - a slab page found via /proc/kpageflags (KPF_SLAB). +# Exercises memory_failure() -> get_any_page() on a non +# PG_reserved kernel-owned page. This path is what catches +# regressions where get_any_page() collapses kernel-owned +# pages into a transient -EIO instead of -ENOTRECOVERABLE. +# +# pgtable - a page-table page found via /proc/kpageflags (KPF_PGTABLE). +# Same path as slab, different page type. +# +# This test is DESTRUCTIVE: a successful run crashes the kernel. It is +# meant to be executed inside a disposable VM (e.g. virtme-ng) with a +# serial console captured by the harness. It is skipped unless the +# caller opts in via RUN_DESTRUCTIVE=1. +# +# Test passes externally: the kernel must panic with +# "Memory failure: <pfn>: unrecoverable page" +# A return from the inject means the panic did not fire and the test +# fails. +# +# Author: Breno Leitao <[email protected]> + +set -u + +ksft_skip=4 +sysctl_path=/proc/sys/vm/panic_on_unrecoverable_memory_failure +inject_path=/sys/devices/system/memory/hard_offline_page +kpageflags_path=/proc/kpageflags + +# /proc/kpageflags bit positions (see include/uapi/linux/kernel-page-flags.h) +KPF_SLAB=7 +KPF_COMPOUND_TAIL=16 +KPF_HWPOISON=19 +KPF_NOPAGE=20 +KPF_PGTABLE=26 + +kind=${1:-rodata} + +ksft_print() { echo "# $*"; } +ksft_exit_skip() { ksft_print "$*"; exit "$ksft_skip"; } +ksft_exit_fail() { echo "not ok 1 $*"; exit 1; } + +if [ "$(id -u)" -ne 0 ]; then + ksft_exit_skip "must run as root" +fi + +if [ ! -w "$sysctl_path" ]; then + ksft_exit_skip "$sysctl_path not present (kernel without the sysctl?)" +fi + +if [ ! -w "$inject_path" ]; then + ksft_exit_skip "$inject_path not present (no MEMORY_HOTPLUG?)" +fi + +if [ "${RUN_DESTRUCTIVE:-0}" != "1" ]; then + ksft_exit_skip "destructive test; re-run with RUN_DESTRUCTIVE=1 inside a disposable VM" +fi + +# Pick a PFN inside the kernel image rodata region of /proc/iomem. +# This is preferred over a top-level "Reserved" entry because top-level +# Reserved ranges are often firmware holes that have no backing struct +# page; pfn_to_online_page() returns NULL on those and memory_failure() +# bails out with -ENXIO before reaching the panic path. +# +# "Kernel rodata" is reported as a sub-resource of "System RAM" on every +# major architecture, which guarantees: +# - the PFN is backed by struct page (within an online memory range); +# - PG_reserved is set on the page (kernel image area); +# - the memory is read-only, so setting PG_hwpoison on it does not +# corrupt writable kernel state if the panic somehow does not fire. +# +# /proc/iomem entries look like (indented for sub-resources): +# " 02500000-02ffffff : Kernel rodata" +pick_rodata_phys_addr() { + awk -v pagesize="$(getconf PAGE_SIZE)" ' + # Convert a hex string to a number without relying on the gawk-only + # strtonum(). mawk lacks it and would otherwise spuriously skip + # this test on distros that ship mawk as /usr/bin/awk. + function hex2num(s, n, i, c, v) { + n = 0 + for (i = 1; i <= length(s); i++) { + c = tolower(substr(s, i, 1)) + v = index("0123456789abcdef", c) - 1 + if (v < 0) + return -1 + n = n * 16 + v + } + return n + } + /: Kernel rodata[[:space:]]*$/ { + sub(/^[[:space:]]+/, "") + n = split($0, a, /[- ]/) + start = hex2num(a[1]) + end = hex2num(a[2]) + if (end <= start) + next + # Page-align upward and emit the first byte of that page. + pfn = int((start + pagesize - 1) / pagesize) + printf "0x%x\n", pfn * pagesize + exit 0 + } + ' /proc/iomem +} + +# Walk /proc/kpageflags and return the phys addr of the first PFN that +# has bit $1 set, with KPF_HWPOISON, KPF_NOPAGE and KPF_COMPOUND_TAIL +# all clear (so we attack a real, non-tail, not-already-poisoned page). +# +# We skip the first 16 MiB of PFNs to step past low-memory special +# ranges (BIOS/EFI/ACPI/etc.) that often are PG_reserved and would not +# exhibit the slab/pgtable type we are looking for. +pick_kpageflags_phys_addr() { + local want_bit=$1 + local pagesize skip_pfn + + [ -r "$kpageflags_path" ] || return + + pagesize=$(getconf PAGE_SIZE) + skip_pfn=$(((16 * 1024 * 1024) / pagesize)) + + od -An -tx8 -v -w8 -j "$((skip_pfn * 8))" "$kpageflags_path" 2>/dev/null | \ + awk -v want_bit="$want_bit" \ + -v hwp_bit="$KPF_HWPOISON" \ + -v nopage_bit="$KPF_NOPAGE" \ + -v tail_bit="$KPF_COMPOUND_TAIL" \ + -v base_pfn="$skip_pfn" \ + -v pagesize="$pagesize" ' + # Test whether bit "b" is set in the 16-hex-digit value "hex". + # Done with substring + per-digit lookup so we never rely on awk + # bitwise operators (mawk lacks them), 64-bit FP precision or the + # gawk-only strtonum(). + function bit_set(hex, b, di, bi, c, v) { + di = int(b / 4) + bi = b - di * 4 + c = substr(hex, length(hex) - di, 1) + v = index("0123456789abcdef", tolower(c)) - 1 + if (bi == 0) return (v % 2) == 1 + if (bi == 1) return int(v / 2) % 2 == 1 + if (bi == 2) return int(v / 4) % 2 == 1 + return int(v / 8) % 2 == 1 + } + { + gsub(/^[[:space:]]+/, "") + h = $1 + if (bit_set(h, want_bit) && + !bit_set(h, hwp_bit) && + !bit_set(h, nopage_bit) && + !bit_set(h, tail_bit)) { + pfn = base_pfn + NR - 1 + printf "0x%x\n", pfn * pagesize + exit 0 + } + } + ' +} + +case "$kind" in +rodata) + phys_addr=$(pick_rodata_phys_addr) + missing_msg='no "Kernel rodata" entry in /proc/iomem' + ;; +slab) + phys_addr=$(pick_kpageflags_phys_addr "$KPF_SLAB") + missing_msg="no usable slab PFN found in $kpageflags_path" + ;; +pgtable) + phys_addr=$(pick_kpageflags_phys_addr "$KPF_PGTABLE") + missing_msg="no usable page-table PFN found in $kpageflags_path" + ;; +*) + ksft_exit_fail "unknown kind '$kind' (expected: rodata|slab|pgtable)" + ;; +esac + +if [ -z "$phys_addr" ]; then + ksft_exit_skip "$missing_msg" +fi + +ksft_print "enabling $sysctl_path" +prior=$(cat "$sysctl_path")
tools/testing/selftests/mm/hwpoison-panic.sh line 202
Quoted 10 lines
tools/testing/selftests/mm/hwpoison-panic.sh new file +10
-0+echo 1 > "$sysctl_path" || ksft_exit_fail "failed to enable sysctl" + +ksft_print "injecting hwpoison at phys 0x$(printf '%x' "$phys_addr") (kind=$kind)" +ksft_print "expecting kernel panic: 'Memory failure: <pfn>: unrecoverable page'" + +# If this returns, the kernel did not panic → test failed. Restore the +# sysctl before reporting so the system is left as we found it. +if echo "$phys_addr" > "$inject_path"; then + echo "$prior" > "$sysctl_path" + ksft_exit_fail "inject returned without panic; sysctl ineffective"
In case of failure, should we recheck the page type? There is a window between we get the phys_addr and inject the hwpoison.
tools/testing/selftests/mm/hwpoison-panic.sh line 208
Quoted 6 lines
tools/testing/selftests/mm/hwpoison-panic.sh new file +6
-0+fi + +# Write failed (e.g. -EINVAL on offlining a non-online region): also a +# failure for this test, since we expected the panic path. +echo "$prior" > "$sysctl_path" +ksft_exit_fail "inject failed before reaching the panic path"
Should we unpoison the pfn in case of failure?
Thanks.
.
Quoted 30 lines · Breno Leitao
A multi-bit ECC error on a kernel-owned page that the memory failure handler cannot recover is currently swallowed:
PG_hwpoisonis set, the event is logged, and the kernel keeps running. The corrupted memory remains accessible to the kernel and either drives silent data corruption or surfaces seconds-to-minutes later as an apparently unrelated crash. In a large fleet that delayed, unattributable crash turns into significant engineering effort to root-cause; in a kdump configuration, by the time the crash happens the original error context (faulting PFN, MCE/GHES record, page state) is long gone.This series adds an opt-in sysctl, vm.panic_on_unrecoverable_memory_failure, that converts an unrecoverable kernel-page hwpoison event into an immediate panic with a clean dmesg/vmcore that still contains the original failure context. The default is disabled so existing workloads see no change.
There is a selftest that test different cases, and I tested it using the following variants:
┌─────────┬──────────┬───────────────────────────────────────────────────────────┐ │ Variant │ PFN │ Result │ ├─────────┼──────────┼───────────────────────────────────────────────────────────┤ │ rodata │ 0x2600 │ Panic with "Memory failure: 0x2600: unrecoverable page" │ ├─────────┼──────────┼───────────────────────────────────────────────────────────┤ │ slab │ 0x100032 │ Panic with "Memory failure: 0x100032: unrecoverable page" │ ├─────────┼──────────┼───────────────────────────────────────────────────────────┤ │ pgtable │ 0x100000 │ Panic with "Memory failure: 0x100000: unrecoverable page" │ └─────────┴──────────┴───────────────────────────────────────────────────────────┘
Quoted 6 lines
Each one shows the same call trace, exactly the path the series builds:
hard_offline_page_store
→memory_failure
→action_result
→panic("Memory failure: %#lx: unrecoverable page")
Debugging another issue earlier today, just found a kernel crash that is hitting a ignored page later in the day, and randomly misbehaving/crashing.
Memory failure: 0x140ae: unhandlable page.
Memory failure: 0x140ae: recovery action for get hwpoison page: Ignored <-- Ignored
loop0: detected capacity change from 0 to 15241056
EDAC MC0: 1 UE multi-bit ECC on LP5x_0 LP5x_0 (node:0 card:0 module:0 rank:0 bank:2 device:28 row:42700 column:96 {3}[Hardware Error]: Hardware error from APEI Generic Hardware Error Source: 308
{3}[Hardware Error]: event severity: recoverable
{3}[Hardware Error]: imprecise tstamp: 2026-06-16 02:50:03
{3}[Hardware Error]: Error 0, type: recoverable
{3}[Hardware Error]: section_type: memory error
{3}[Hardware Error]: physical_address: 0x0000000aeccde180
{3}[Hardware Error]: physical_address_mask: 0xfffffffffffff000
{3}[Hardware Error]: node:0 card:0 module:0 rank:0 bank:2 device:28 row:42700 column:960 requestor_id:0x0000000
{3}[Hardware Error]: error_type: 3, multi-bit ECC
{3}[Hardware Error]: DIMM location: LP5x_0 LP5x_0 Memory failure: 0xaeccd: recovery action for dirty LRU page: Recovered
Internal error: synchronous external abort: 0000000096000410 [#1] SMP Modules linked in: ghes_edac(E) squashfs(E) act_gact(E) sch_fq(E) tcp_diag(E) inet_diag(E) cls_bpf(E) evdev(E) sm CPU: 51 UID: 0 PID: 1 Comm: systemd Kdump: loaded Tainted: G M OE K 6.16.1-0_fbk2_0_gf40efc324cc8 #1 Tainted: [M]=MACHINE_CHECK, [O]=OOT_MODULE, [E]=UNSIGNED_MODULE, [K]=LIVEPATCH pstate: 834010c9 (Nzcv daIF +PAN -UAO +TCO +DIT +SSBS BTYPE=--) pc : clear_inode+0x34/0x108 lr : proc_evict_inode.llvm.1771226604092943895+0x28/0x68 sp : ffff800083f6f8d0 x29: ffff800083f6f8e0 x28: 0000000000000011 x27: ffff0000c1378788 x26: ffffffffffffffff x25: ffff800082747de0 x24: ffff0000c0ae9898 x23: ffff8000819155f8 x22: ffff0000c0ae9888 x21: ffff0000c0ae9808 x20: ffff0000c0ae9818 x19: ffff0000c0ae9788 x18: 000000000000001c x17: 0000000000000018 x16: 0000000000000040 x15: 0000000000000000 x14: 0000000000000001 x13: 0000000000000000 x12: 0000000000002710 x11: ffff0000c0ae9898 x10: ffff0000c1299b58 x9 : 0000000000000001 x8 : ffff0000c0ae9900 x7 : ffff8000828db000 x6 : 0000000000005040 x5 : ffffffffffffffff x4 : ffffffdfc05c8aa0 x3 : ffff000126470000 x2 : ffffffffffffffff x1 : 0000000000000000 x0 : ffff0000c0ae9788 Call trace: clear_inode+0x34/0x108 (P) proc_evict_inode.llvm.1771226604092943895+0x28/0x68 evict+0xec/0x328 iput+0xa8/0x310 dentry_unlink_inode+0xa4/0x188 __dentry_kill+0x74/0x358 shrink_dentry_list+0xc8/0x198 ....