mm/memory-failure: add panic option for unrecoverable pages
Subsystems (7)
v10 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 v10:
- Reuse kselftest declarations
- Residual race harmless documentation
- Link to v9: https://lore.kernel.org/r/[email protected]
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 | 80 +++++++++ mm/memory-failure.c | 106 +++++++++-- tools/testing/selftests/mm/Makefile | 4 + tools/testing/selftests/mm/hwpoison-panic.sh | 255 +++++++++++++++++++++++++++ 4 files changed, 427 insertions(+), 18 deletions(-)
---
base-commit: 30ffa8de54e5cc80d93fd211ca134d1764a7011f
change-id: 20260323-ecc_panic-4e473b83087c
Best regards,
Signature · 1 line
Breno Leitao <[email protected]>
PATCH v10 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 v10 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 is_kernel_owned_page(), a small predicate that positively identifies pages the hwpoison handler cannot recover from:
is_kernel_owned_page(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.
No MF_SOFT_OFFLINE / page_has_movable_ops() opt-out is needed: a movable_ops page is always PageOffline or PageZsmalloc, whose page_type is mutually exclusive with slab, page-table and large-kmalloc, and it never carries PG_reserved, so it can never match any of the checks above.
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 | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 50 insertions(+), 2 deletions(-)
mm/memory-failure.c +50 -2
@@ -1325,6 +1325,38 @@ 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: +* pages owned by kernel internals with no userspace mapping to unmap, no +* file mapping to invalidate, and no migration target. +*/ +static inline bool is_kernel_owned_page (struct page *page) +{ +struct page *head; +bool kernel_owned; + +/* 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 residual free->alloc->free cannot be closed here +* (frozen slab and large-kmalloc pages cannot be pinned), but is +* harmless: where a wrong verdict could panic, memory_failure() has +* already set PageHWPoison, which bars the page from the allocator. +*/ +retry: + head =compound_head (page); + kernel_owned =PageSlab (head) ||PageTable (head) || +PageLargeKmalloc (head); +if (head !=compound_head (page)) + goto retry; +return kernel_owned; +} +static int __get_hwpoison_page (struct page *page,unsigned long flags) {struct folio *folio =page_folio (page);
@@ -1371,6 +1403,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 (is_kernel_owned_page (p)) { +if (count_increased) +put_page (p); + ret = -ENOTRECOVERABLE ; + goto out; + } + try_again:if (!count_increased) { ret =__get_hwpoison_page (p, flags);
@@ -1418,7 +1463,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 +1520,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 +* is_kernel_owned_page() (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
PATCH v10 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
@@ -2436,7 +2436,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);
@@ -2455,7 +2456,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 v10 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
PATCH v10 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 | 80 +++++++++++++++++++++++++++++++++ 1 file changed, 80 insertions(+)
Documentation/admin-guide/sysctl/vm.rst +80 -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,85 @@ 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. + +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 v10 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 is_kernel_owned_page(), 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 no panic fired. Before reporting, the script restores the sysctl and best-effort unpoisons the target PFN through the hwpoison debugfs interface (hard_offline_page() injects with MF_SW_SIMULATED, so the page stays unpoisonable), then re-reads /proc/kpageflags: a PFN that is still the kernel-owned type it selected is a genuine failure, while one that raced to a different type before the inject is skipped as inconclusive. 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 | 255 +++++++++++++++++++++++++++ 2 files changed, 259 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 +255 -0
255 lines not on this page · raw message
Signature · 1 line
2.53.0-Meta
Andrew Morton
maintainerQuoted 10 lines · On Tue, 30 Jun 2026 05:46:03 -0700 Breno Leitao <[email protected]> wrote:
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.
Quoted 6 lines
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.
Updated, thanks.
Sashiko said things:
https://sashiko.dev/#/patchset/[email protected]
Quoted 4 lines
Changes in v10:
- Reuse kselftest declarations
- Residual race harmless documentation
- Link to v9: https://lore.kernel.org/r/[email protected]
Here's how v10 altered mm.git:
mm/memory-failure.c | 6 +- tools/testing/selftests/mm/hwpoison-panic.sh | 42 +++++++++-------- 2 files changed, 28 insertions(+), 20 deletions(-)
mm/memory-failure.c renamed from mm/memory-failure.c~b +4 -2
@@ -1366,8 +1366,10 @@ static inline bool is_kernel_owned_page(* 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. +* a stale view. A residual free->alloc->free cannot be closed here +* (frozen slab and large-kmalloc pages cannot be pinned), but is +* harmless: where a wrong verdict could panic, memory_failure() has +* already set PageHWPoison, which bars the page from the allocator. */ retry: head =compound_head (page);
tools/testing/selftests/mm/hwpoison-panic.sh renamed from tools/testing/selftests/mm/hwpoison-panic.sh~b +24 -18
83 lines not on this page · raw message
_
Mike Rapoport
reviewerRe: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
In reply to Breno LeitaoHi Breno,
Quoted 250 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
is_kernel_owned_page(), 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 no panic fired. Before reporting, the script restores the sysctl and best-effort unpoisons the target PFN through the hwpoison debugfs interface (
hard_offline_page()injects withMF_SW_SIMULATED, so the page stays unpoisonable), then re-reads/proc/kpageflags: a PFN that is still the kernel-owned type it selected is a genuine failure, while one that raced to a different type before the inject is skipped as inconclusive. 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.Signed-off-by Breno Leitao <[email protected]>--- tools/testing/selftests/mm/Makefile | 4 + tools/testing/selftests/mm/hwpoison-panic.sh | 255 +++++++++++++++++++++++++++ 2 files changed, 259 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 +164
-0@@ -0,0 +1,255 @@ +#!/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 no panic fired: that is a failure, +# unless the target PFN raced to a different page type before injection, +# in which case the run is inconclusive and is skipped. +# +# Author: Breno Leitao <[email protected]> + +set -u + +# KTAP output helpers (ktap_print_msg, ktap_skip_all, ktap_exit_fail_msg, ...). +DIR="$(dirname "$(readlink -f "$0")")" +# shellcheck source=../kselftest/ktap_helpers.sh +source "${DIR}"/../kselftest/ktap_helpers.sh + +sysctl_path=/proc/sys/vm/panic_on_unrecoverable_memory_failure +inject_path=/sys/devices/system/memory/hard_offline_page +kpageflags_path=/proc/kpageflags +unpoison_path=/sys/kernel/debug/hwpoison/unpoison-pfn + +# /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 +KPF_RESERVED=32 + +pagesize=$(getconf PAGE_SIZE) + +kind=${1:-rodata} + +if [ "$(id -u)" -ne 0 ]; then + ktap_skip_all "must run as root" + exit "$KSFT_SKIP" +fi + +if [ ! -w "$sysctl_path" ]; then + ktap_skip_all "$sysctl_path not present (kernel without the sysctl?)" + exit "$KSFT_SKIP" +fi + +if [ ! -w "$inject_path" ]; then + ktap_skip_all "$inject_path not present (no MEMORY_HOTPLUG?)" + exit "$KSFT_SKIP" +fi + +if [ "${RUN_DESTRUCTIVE:-0}" != "1" ]; then + ktap_skip_all "destructive test; re-run with RUN_DESTRUCTIVE=1 inside a disposable VM" + exit "$KSFT_SKIP" +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:]]+/, "")
tools/testing/selftests/mm/hwpoison-panic.sh line 174
Quoted 10 lines
tools/testing/selftests/mm/hwpoison-panic.sh new file +10
-0+ 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 + } + }
I'm looking at these awk scripts and od encodings and I wonder if wasn't it simpler to write the test in C.
We have a bunch of helpers in tools/testing/selftests/mm/vm_utils.h for accessing /proc files and there is already /proc/iomem parser in tools/testing/selftests/mm/pfnmap.c that also could be lifter to vm_util
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH v10 2/6] mm/memory-failure: surface unhandlable kernel pages as -ENOTRECOVERABLE
In reply to Breno LeitaoQuoted 90 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
is_kernel_owned_page(), a small predicate that positively identifies pages the hwpoison handler cannot recover from:is_kernel_owned_page(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.No
MF_SOFT_OFFLINE/page_has_movable_ops()opt-out is needed: amovable_opspage is always PageOffline or PageZsmalloc, whosepage_typeis mutually exclusive with slab, page-table and large-kmalloc, and it never carriesPG_reserved, so it can never match any of the checks above.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 | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 50 insertions(+), 2 deletions(-)mm/memory-failure.c +15
-0@@ -1325,6 +1325,38 @@ 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: +* pages owned by kernel internals with no userspace mapping to unmap, no +* file mapping to invalidate, and no migration target. +*/ +static inline bool is_kernel_owned_page (struct page *page) +{ +struct page *head; +bool kernel_owned; + +/* PG_reserved is a per-page flag, never set on a compound page. */ +if (PageReserved (page)) +return true; + +/*
mm/memory-failure.c static inline bool HWPoisonHandlable(struct page *page, unsigned long flags) · line 1352
Quoted 10 lines
mm/memory-failure.c +10
-0+* 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 residual free->alloc->free cannot be closed here +* (frozen slab and large-kmalloc pages cannot be pinned), but is +* harmless: where a wrong verdict could panic, memory_failure() has +* already set PageHWPoison, which bars the page from the allocator. +*/ +retry: + head =compound_head (page);
It's irrelevant to this issue but should we use folio? Anyway, this patch looks good to me.
Thanks.
.
Re: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
In reply to Mike RapoportHello Mike,
Quoted 8 lines · Mike Rapoport
On Tue, Jun 30, 2026 at 05:46:09AM -0700, Breno Leitao wrote:
I'm looking at these awk scripts and od encodings and I wonder if wasn't it simpler to write the test in C.
We have a bunch of helpers in
tools/testing/selftests/mm/vm_utils.hfor accessing /proc files and there is already/proc/iomemparser intools/testing/selftests/mm/pfnmap.cthat also could be lifter tovm_util
I'm fine with either approach.
My main concern is keeping the selftest decoupled from the feature itself, so that review of the test doesn't block the feature from landing. Would that work for you?
Thanks
--breno
Mike Rapoport
reviewerRe: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
Quoted 12 lines · Breno Leitao
Hello Mike,
Quoted 8 lines · Mike Rapoport
On Tue, Jun 30, 2026 at 05:46:09AM -0700, Breno Leitao wrote:
I'm looking at these awk scripts and od encodings and I wonder if wasn't it simpler to write the test in C.
We have a bunch of helpers in
tools/testing/selftests/mm/vm_utils.hfor accessing /proc files and there is already/proc/iomemparser intools/testing/selftests/mm/pfnmap.cthat also could be lifter tovm_util
Quoted 5 lines
I'm fine with either approach.
My main concern is keeping the selftest decoupled from the feature itself, so that review of the test doesn't block the feature from landing. Would that work for you?
Sure.
Quoted 2 lines
Thanks
--breno
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH v10 5/6] Documentation: document panic_on_unrecoverable_memory_failure sysctl
In reply to Breno LeitaoQuoted 6 lines · Breno Leitao
Add 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).
Signed-off-by Breno Leitao <[email protected]>
Thanks.
.
Re: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
In reply to Breno LeitaoQuoted 59 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
is_kernel_owned_page(), 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 no panic fired. Before reporting, the script restores the sysctl and best-effort unpoisons the target PFN through the hwpoison debugfs interface (
hard_offline_page()injects withMF_SW_SIMULATED, so the page stays unpoisonable), then re-reads/proc/kpageflags: a PFN that is still the kernel-owned type it selected is a genuine failure, while one that raced to a different type before the inject is skipped as inconclusive. 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]>
With Mike's comment addressed:
Thanks.
.
Andrew Morton
maintainerRe: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
Quoted 9 lines · On Thu, 9 Jul 2026 11:34:05 +0800 Miaohe Lin <[email protected]> wrote:
Quoted 9 lines
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 5 lines
Quoted 1 line
Signed-off-by Breno Leitao <[email protected]>With Mike's comment addressed:
Acked-by Miaohe Lin <[email protected]>
As I understand it, Breno would prefer not to rewrite the selftest in C at this time. IOW, we stick with the bash version for now and add "convert this to C" to the todo list, OK?
Miaohe Lin
maintainerRe: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
Quoted 13 lines · Andrew Morton
Quoted 11 lines · On Thu, 9 Jul 2026 11:34:05 +0800 Miaohe Lin <[email protected]> wrote:
Quoted 10 lines
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.Signed-off-by Breno Leitao <[email protected]>
Quoted 7 lines
Quoted 3 lines
With Mike's comment addressed:
Acked-by Miaohe Lin <[email protected]>As I understand it, Breno would prefer not to rewrite the selftest in C at this time. IOW, we stick with the bash version for now and add "convert this to C" to the todo list, OK?
Sure. Should I make this change or should we wait until Breno has time to do it?
Thanks.
.
Re: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
Quoted 16 lines · Miaohe Lin
Quoted 15 lines · Andrew Morton
Quoted 13 lines · On Thu, 9 Jul 2026 11:34:05 +0800 Miaohe Lin <[email protected]> wrote:
Quoted 10 lines
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.Signed-off-by Breno Leitao <[email protected]>With Mike's comment addressed:
Quoted 7 lines
Quoted 5 lines
Quoted 1 line
Acked-by Miaohe Lin <[email protected]>As I understand it, Breno would prefer not to rewrite the selftest in C at this time. IOW, we stick with the bash version for now and add "convert this to C" to the todo list, OK?
Sure. Should I make this change or should we wait until Breno has time to do it?
Apologies for the delay. This is on my TODO list, and I'll prioritize it.
Just to confirm: the feature is already in mm-next without the selftest, so I only need to submit the C version of the test, correct?
David Hildenbrand (Arm)
maintainerRe: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
In reply to Andrew MortonQuoted 13 lines · Andrew Morton
Quoted 11 lines · On Thu, 9 Jul 2026 11:34:05 +0800 Miaohe Lin <[email protected]> wrote:
Quoted 10 lines
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.Signed-off-by Breno Leitao <[email protected]>
Quoted 8 lines
Quoted 3 lines
With Mike's comment addressed:
Acked-by Miaohe Lin <[email protected]>As I understand it, Breno would prefer not to rewrite the selftest in C at this time. IOW, we stick with the bash version for now and add "convert this to C" to the todo list, OK?
No, seriously, this is code we have to maintain. Better to not have this test than have it.
Signature · 3 lines
Cheers, David
Andrew Morton
maintainerRe: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
In reply to Breno LeitaoQuoted 23 lines · On Tue, 28 Jul 2026 02:29:39 -0700 Breno Leitao <[email protected]> wrote:
Quoted 22 lines · Miaohe Lin
Quoted 20 lines · Andrew Morton
Quoted 9 lines · On Thu, 9 Jul 2026 11:34:05 +0800 Miaohe Lin <[email protected]> wrote:
Quoted 9 lines
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 5 lines
Quoted 1 line
Signed-off-by Breno Leitao <[email protected]>With Mike's comment addressed:
Acked-by Miaohe Lin <[email protected]>As I understand it, Breno would prefer not to rewrite the selftest in C at this time. IOW, we stick with the bash version for now and add "convert this to C" to the todo list, OK?
Quoted 6 lines
Quoted 1 line
Sure. Should I make this change or should we wait until Breno has time to do it?
Apologies for the delay. This is on my TODO list, and I'll prioritize it.
Just to confirm: the feature is already in mm-next without the selftest, so I only need to submit the C version of the test, correct?
The bash script is still there, no known issues.
We have the thing and tests are useful. I'd say retain it until the rewrite-in-C happens?
Re: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
Quoted 8 lines · Andrew Morton
Quoted 6 lines · On Tue, 28 Jul 2026 02:29:39 -0700 Breno Leitao <[email protected]> wrote:
Quoted 2 lines · Miaohe Lin
Sure. Should I make this change or should we wait until Breno has time to do it?
Apologies for the delay. This is on my TODO list, and I'll prioritize it.
Quoted 7 lines
Quoted 2 lines
Just to confirm: the feature is already in mm-next without the selftest, so I only need to submit the C version of the test, correct?
The bash script is still there, no known issues.
We have the thing and tests are useful. I'd say retain it until the rewrite-in-C happens?
Signature · 3 lines
Cheers, David
Re: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
Quoted 12 lines · David Hildenbrand (Arm)
Quoted 11 lines · Andrew Morton
Quoted 8 lines · On Tue, 28 Jul 2026 02:29:39 -0700 Breno Leitao <[email protected]> wrote:
Quoted 2 lines · Miaohe Lin
Sure. Should I make this change or should we wait until Breno has time to do it?
Apologies for the delay. This is on my TODO list, and I'll prioritize it.
Just to confirm: the feature is already in mm-next without the selftest, so I only need to submit the C version of the test, correct?
Quoted 6 lines
Quoted 4 lines
The bash script is still there, no known issues.
We have the thing and tests are useful. I'd say retain it until the rewrite-in-C happens?
Nacked-by David Hildenbrand <[email protected]>
I have a draft of the selftest in C already and I will give it more bake time, and I will submit it until EOW.
Sorry for the noise,
--breno
David Hildenbrand (Arm)
maintainerRe: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
Quoted 6 lines · Breno Leitao
Quoted 5 lines · David Hildenbrand (Arm)
Quoted 4 lines · Andrew Morton
The bash script is still there, no known issues.
Quoted 7 lines
Quoted 4 lines
Quoted 2 lines
We have the thing and tests are useful. I'd say retain it until the rewrite-in-C happens?
Nacked-by David Hildenbrand <[email protected]>I have a draft of the selftest in C already and I will give it more bake time, and I will submit it until EOW.
IMHO there is no need to rush this test here, we could merge it after the main work.
We neglected our selftests quite a bit in the past, and that is biting us now.
That's why I push back hard now (sorry) against stuff that is different than the rest and not easy to maintain.
I know, hwpoison-panic is a destructive test, but I really don't think we should just merge mostly unreviewed bash tests that will just bitrot.
Which makes me wonder now: should this actually be a selftest? It's nothing one would just want to run in a CI. It will crash your machine.
Maybe this should just be a tool in tools/mm? I really think so. So having a nice C-level hwpoison-panic.c in tools/mm might be the way to go.
So let's rather make this test well maintainable and have it properly reviewed than rushing something suboptimal.
Signature · 3 lines
Cheers, David
Re: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
Quoted 11 lines · David Hildenbrand (Arm)
Quoted 2 lines · Breno Leitao
I have a draft of the selftest in C already and I will give it more bake time, and I will submit it until EOW.
IMHO there is no need to rush this test here, we could merge it after the main work.
We neglected our selftests quite a bit in the past, and that is biting us now.
That's why I push back hard now (sorry) against stuff that is different than the rest and not easy to maintain.
Quoted 8 lines
I know, hwpoison-panic is a destructive test, but I really don't think we should just merge mostly unreviewed bash tests that will just bitrot.
Which makes me wonder now: should this actually be a selftest? It's nothing one would just want to run in a CI. It will crash your machine.
Maybe this should just be a tool in
tools/mm? I really think so. So having a nice C-levelhwpoison-panic.cintools/mmmight be the way to go.
Agreed. In v6 [0] I actually removed the selftest entirely, since the value wasn't clear and it seemed like an ugly duckling.
It seems tools/mm would be a good fit, and make a better home for this type of "test".
Given more changes coming in memory failure (at least from my side [1][2]), I think it would be a good idea to create a subdirectory (tools/mm/memory-failure) and keep these semi-destructive tools in there. Is this the right direction?
Quoted 2 lines
So let's rather make this test well maintainable and have it properly reviewed than rushing something suboptimal.
Sounds good. I'll move this to tools/mm and resubmit. Given Andrew has removed the selftest from mm-unstable while keeping the rest of the series (which is fully reviewed and frictionless), so I'll focus on the test tool now and send it separately.
Thanks for the discussion,
--breno
David Hildenbrand (Arm)
maintainerRe: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
Quoted 24 lines · Breno Leitao
Quoted 11 lines · David Hildenbrand (Arm)
Quoted 2 lines · Breno Leitao
I have a draft of the selftest in C already and I will give it more bake time, and I will submit it until EOW.
IMHO there is no need to rush this test here, we could merge it after the main work.
We neglected our selftests quite a bit in the past, and that is biting us now.
That's why I push back hard now (sorry) against stuff that is different than the rest and not easy to maintain.
Quoted 8 lines
I know, hwpoison-panic is a destructive test, but I really don't think we should just merge mostly unreviewed bash tests that will just bitrot.
Which makes me wonder now: should this actually be a selftest? It's nothing one would just want to run in a CI. It will crash your machine.
Maybe this should just be a tool in
tools/mm? I really think so. So having a nice C-levelhwpoison-panic.cintools/mmmight be the way to go.Agreed. In v6 [0] I actually removed the selftest entirely, since the value wasn't clear and it seemed like an ugly duckling.
Quoted 7 lines
It seems
tools/mmwould be a good fit, and make a better home for this type of "test".Given more changes coming in memory failure (at least from my side [1][2]), I think it would be a good idea to create a subdirectory (
tools/mm/memory-failure) and keep these semi-destructive tools in there. Is this the right direction?
Makes sense to me.
Quoted 8 lines
Quoted 3 lines
So let's rather make this test well maintainable and have it properly reviewed than rushing something suboptimal.
Sounds good. I'll move this to
tools/mmand resubmit. Given Andrew has removed the selftest from mm-unstable while keeping the rest of the series (which is fully reviewed and frictionless), so I'll focus on the test tool now and send it separately.
Avoid bash scripts, please :)
Signature · 3 lines
Cheers, David
Re: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
Quoted 1 line · David Hildenbrand (Arm)
Avoid bash scripts, please :)
Sorry, I will try to control my fingers next time.
Jokes aside, all the selftests I maintain (tools/testing/selftests/drivers/net/netconsole) were done in bash, so, I got totally biased.
David Hildenbrand (Arm)
maintainerRe: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
Quoted 8 lines · Breno Leitao
Quoted 1 line · David Hildenbrand (Arm)
Avoid bash scripts, please :)
Sorry, I will try to control my fingers next time.
Jokes aside, all the selftests I maintain (
tools/testing/selftests/drivers/net/netconsole) were done in bash, so, I got totally biased.
Ah, I see. The MM folks are not known to be bash experts, which is why we limit our bash scripts to a bare minimum (and focus on C tests).
We do have some rather simple bash tests that are mostly used to load special test kernel modules, where the real test logic resides.
For smaller things, I wouldn't mind a bash script in tools/mm. But the parsing of pageflags is a bit ... advanced :)
Note that we already have some kpageflags processing in tools/mm/page-types.c, not sure whether some of that could just easily be reused.
Signature · 3 lines
Cheers, David
Re: [PATCH v10 6/6] selftests/mm: add hwpoison-panic destructive test
Quoted 4 lines · David Hildenbrand (Arm)
Quoted 3 lines · Breno Leitao
Quoted 1 line · David Hildenbrand (Arm)
Avoid bash scripts, please :)
Quoted 8 lines
Quoted 5 lines
Sorry, I will try to control my fingers next time.
Jokes aside, all the selftests I maintain (
tools/testing/selftests/drivers/net/netconsole) were done in bash, so, I got totally biased.Ah, I see. The MM folks are not known to be bash experts, which is why we limit our bash scripts to a bare minimum (and focus on C tests).
Thanks for the guidance. I've rewritten the test in C and posted it:
https://lore.kernel.org/all/20260731-memory_failure_rewrite_test-v1-1-6aa8c6435693@debian.org/