Skip to contentSkip to conversation

mm/memory-failure: add panic option for unrecoverable pages

PATCH Superseded Breno Leitao 4 participants 18 messages May 11 – May 13

Subsystems (6)

v6 of 10 Superseded Latest is v10 →

lore
Share & tools
lore
#0 lore raw

v6 cover mm/memory-failure: add panic option for unrecoverable pages

Changes from previouis version

* Replaced the late, action-time recheck for MF_MSG_KERNEL_HIGH_ORDER with early failure classification inside get_any_page() (new patch 2/4).

* David Hildenbrand pointed out that the recheck inspected refcount and folio mapping without holding a folio reference, which is unsafe (concurrent split can trigger VM_WARN_ON_FOLIO).

* Lance Yang suggested moving the disambiguation to the call site that still knows *why* the page reference could not be taken, which is what this version does via a new enum mf_get_page_status (MF_GET_PAGE_OK / RACE / UNHANDLABLE) plumbed out through get_hwpoison_page().

---
Changes in v6:
- Dropped the selftest given the value was not clear
- Get the status of the failure from get_any_page()
- Small nits from different people/AIs.
- Link to v5: https://patch.msgid.link/[email protected]

Changes in v5:
- Add vm.panic_on_unrecoverable_memory_failure sysctl to panic on unrecoverable kernel page hwpoison events (reserved pages, refcount-0 non-buddy pages, unknown state), with a recheck to avoid racing with concurrent buddy allocations. (Miaohe)
- Distinguish reserved pages as MF_MSG_KERNEL in memory_failure(), document the new sysctl in Documentation/admin-guide/sysctl/vm.rst, and add a selftest verifying SIGBUS recovery on userspace pages still works when the sysctl is enabled. (Miaohe)
- Added a selftest
- Link to v4:
https://patch.msgid.link/[email protected]

Changes in v4:
- Drop CONFIG_BOOTPARAM_MEMORY_FAILURE_PANIC kernel configuration option.
- Split the reserved page classification (MF_MSG_KERNEL) into its own patch, separate from the panic mechanism.
- Document why the buddy allocator TOCTOU race (between get_hwpoison_page() and is_free_buddy_page()) cannot cause false
positives: PG_hwpoison is set beforehand and check_new_page() in the page allocator rejects hwpoisoned pages.
- Document the narrow LRU isolation race window for MF_MSG_UNKNOWN and its mitigation via identify_page_state()'s two-pass design.
- Explicitly document why MF_MSG_GET_HWPOISON is excluded from the
panic conditions (shared path with transient races and non-reserved kernel memory).
- Link to v3: https://patch.msgid.link/[email protected]

Changes in v3:
- Rename is_unrecoverable_memory_failure() to panic_on_unrecoverable_mf() as suggested by maintainer.
- Add CONFIG_BOOTPARAM_MEMORY_FAILURE_PANIC kernel configuration option, similar to CONFIG_BOOTPARAM_HARDLOCKUP_PANIC.
- Add documentation for the sysctl and CONFIG option.
- Add code comments documenting the panic condition design rationale and how the retry mechanism mitigates false positives from buddy allocator races.
- Link to v2: https://patch.msgid.link/[email protected]

Changes in v2:
- Panic on MF_MSG_KERNEL, MF_MSG_KERNEL_HIGH_ORDER and MF_MSG_UNKNOWN instead of MF_MSG_GET_HWPOISON.
- Report MF_MSG_KERNEL for reserved pages when get_hwpoison_page() fails instead of MF_MSG_GET_HWPOISON.
- Link to v1: https://patch.msgid.link/[email protected]

To: Miaohe Lin <[email protected]>
To: Naoya Horiguchi <[email protected]>
To: Andrew Morton <[email protected]>
To: Steven Rostedt <[email protected]>
To: Masami Hiramatsu <[email protected]>
To: Mathieu Desnoyers <[email protected]>
To: Jonathan Corbet <[email protected]>
To: Shuah Khan <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]

---
Breno Leitao (4):
mm/memory-failure: report MF_MSG_KERNEL for reserved pages mm/memory-failure: classify get_any_page() failures by reason mm/memory-failure: add panic option for unrecoverable pages
Documentation: document panic_on_unrecoverable_memory_failure sysctl

 Documentation/admin-guide/sysctl/vm.rst | 70 ++++++++++++++++++++++++++
 include/trace/events/memory-failure.h   |  2 +-
 mm/memory-failure.c                     | 89 ++++++++++++++++++++++++++++++---
 3 files changed, 152 insertions(+), 9 deletions(-)

---
base-commit: e98d21c170b01ddef366f023bbfcf6b31509fa83
change-id: 20260323-ecc_panic-4e473b83087c

Best regards,

Signature · 1 line
Breno Leitao <[email protected]>
#1 lore raw

PATCH v6 1/4 mm/memory-failure: report MF_MSG_KERNEL for reserved pages

When get_hwpoison_page() returns a negative value, distinguish reserved pages from other failure cases by reporting MF_MSG_KERNEL instead of MF_MSG_GET_HWPOISON. Reserved pages belong to the kernel and should be classified accordingly for proper handling.

Sample PG_reserved before the get_hwpoison_page() call. In the MF_COUNT_INCREASED path get_any_page() can drop the caller's reference before returning -EIO, after which the underlying page may have been freed and reallocated with page->flags reset; reading PageReserved(p) at that point would observe stale or unrelated state. The pre-call snapshot reflects what the page actually was at the time of the failure event.

---
 mm/memory-failure.c | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)
mm/memory-failure.c +18 -1
index 866c4428ac7ef..f112fb27a8ff6 100644
@@ -2348,6 +2348,7 @@ int memory_failure(unsigned long pfn, int flags)
 	unsigned long page_flags;
 	bool retry = true;
 	int hugetlb = 0;
+	bool is_reserved;
 
 	if (!sysctl_memory_failure_recovery)
 		panic("Memory failure on page %lx", pfn);
@@ -2411,6 +2412,18 @@ int memory_failure(unsigned long pfn, int flags)
 	 * In fact it's dangerous to directly bump up page count from 0,
 	 * that may make page_ref_freeze()/page_ref_unfreeze() mismatch.
 	 */
+	/*
+	 * Pages with PG_reserved set are not currently managed by the
+	 * page allocator (memblock-reserved memory, driver reservations,
+	 * etc.), so classify them as kernel-owned for reporting.
+	 *
+	 * Sample the flag before get_hwpoison_page(): in the
+	 * MF_COUNT_INCREASED path, get_any_page() can drop the caller's
+	 * reference before returning -EIO, after which page->flags may
+	 * have been reset by the allocator.
+	 */
+	is_reserved = PageReserved(p);
+
 	res = get_hwpoison_page(p, flags);
 	if (!res) {
 		if (is_free_buddy_page(p)) {
@@ -2432,7 +2445,11 @@ int memory_failure(unsigned long pfn, int flags)
 		}
 		goto unlock_mutex;
 	} else if (res < 0) {
-		res = action_result(pfn, MF_MSG_GET_HWPOISON, MF_IGNORED);
+		if (is_reserved)
+			res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);
+		else
+			res = action_result(pfn, MF_MSG_GET_HWPOISON,
+					    MF_IGNORED);
 		goto unlock_mutex;
 	}
 
Signature · 1 line
2.53.0-Meta
#2 lore raw

Re: [PATCH v6 1/4] mm/memory-failure: report MF_MSG_KERNEL for reserved pages

Quoted 55 lines · Breno Leitao

When get_hwpoison_page() returns a negative value, distinguish reserved pages from other failure cases by reporting MF_MSG_KERNEL instead of MF_MSG_GET_HWPOISON. Reserved pages belong to the kernel and should be classified accordingly for proper handling.

Sample PG_reserved before the get_hwpoison_page() call. In the MF_COUNT_INCREASED path get_any_page() can drop the caller's reference before returning -EIO, after which the underlying page may have been freed and reallocated with page->flags reset; reading PageReserved(p) at that point would observe stale or unrelated state. The pre-call snapshot reflects what the page actually was at the time of the failure event.

---
 mm/memory-failure.c | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)
mm/memory-failure.c +13 -0
index 866c4428ac7ef..f112fb27a8ff6 100644
@@ -2348,6 +2348,7 @@ int memory_failure(unsigned long pfn, int flags)
 	unsigned long page_flags;
 	bool retry = true;
 	int hugetlb = 0;
+	bool is_reserved;
 
 	if (!sysctl_memory_failure_recovery)
 		panic("Memory failure on page %lx", pfn);
@@ -2411,6 +2412,18 @@ int memory_failure(unsigned long pfn, int flags)
 	 * In fact it's dangerous to directly bump up page count from 0,
 	 * that may make page_ref_freeze()/page_ref_unfreeze() mismatch.
 	 */
+	/*
+	 * Pages with PG_reserved set are not currently managed by the
+	 * page allocator (memblock-reserved memory, driver reservations,
+	 * etc.), so classify them as kernel-owned for reporting.
+	 *
+	 * Sample the flag before get_hwpoison_page(): in the
+	 * MF_COUNT_INCREASED path, get_any_page() can drop the caller's
+	 * reference before returning -EIO, after which page->flags may
+	 * have been reset by the allocator.
+	 */
+	is_reserved = PageReserved(p);
+
 	res = get_hwpoison_page(p, flags);
 	if (!res) {
 		if (is_free_buddy_page(p)) {
@@ -2432,7 +2445,11 @@ int memory_failure(unsigned long pfn, int flags)
 		}
 		goto unlock_mutex;

mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2455

Quoted 10 lines
mm/memory-failure.c +5 -1
 	} else if (res < 0) {
-		res = action_result(pfn, MF_MSG_GET_HWPOISON, MF_IGNORED);
+		if (is_reserved)
+			res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);
+		else
+			res = action_result(pfn, MF_MSG_GET_HWPOISON,
+					    MF_IGNORED);
 		goto unlock_mutex;
 	}
 

It's a bit odd that we need this handling when we already have handling for reserved pages in error_states[].

HWPoisonHandlable() would always essentially reject PG_reserved pages. So __get_hwpoison_page() ... would always fail? Making get_hwpoison_page()->get_any_page() always fail?

But then, we never call identify_page_state()? And never call me_kernel()?

This all looks very odd.

Why would you even want to call get_hwpoison_page() in the first place if you find PageReserved?

Signature · 3 lines
Cheers,

David
#3 lore raw

Re: [PATCH v6 1/4] mm/memory-failure: report MF_MSG_KERNEL for reserved pages

Quoted 70 lines · David Hildenbrand (Arm)
Quoted 55 lines · Breno Leitao

When get_hwpoison_page() returns a negative value, distinguish reserved pages from other failure cases by reporting MF_MSG_KERNEL instead of MF_MSG_GET_HWPOISON. Reserved pages belong to the kernel and should be classified accordingly for proper handling.

Sample PG_reserved before the get_hwpoison_page() call. In the MF_COUNT_INCREASED path get_any_page() can drop the caller's reference before returning -EIO, after which the underlying page may have been freed and reallocated with page->flags reset; reading PageReserved(p) at that point would observe stale or unrelated state. The pre-call snapshot reflects what the page actually was at the time of the failure event.

---
 mm/memory-failure.c | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)
mm/memory-failure.c +13 -0
index 866c4428ac7ef..f112fb27a8ff6 100644
@@ -2348,6 +2348,7 @@ int memory_failure(unsigned long pfn, int flags)
 	unsigned long page_flags;
 	bool retry = true;
 	int hugetlb = 0;
+	bool is_reserved;
 
 	if (!sysctl_memory_failure_recovery)
 		panic("Memory failure on page %lx", pfn);
@@ -2411,6 +2412,18 @@ int memory_failure(unsigned long pfn, int flags)
 	 * In fact it's dangerous to directly bump up page count from 0,
 	 * that may make page_ref_freeze()/page_ref_unfreeze() mismatch.
 	 */
+	/*
+	 * Pages with PG_reserved set are not currently managed by the
+	 * page allocator (memblock-reserved memory, driver reservations,
+	 * etc.), so classify them as kernel-owned for reporting.
+	 *
+	 * Sample the flag before get_hwpoison_page(): in the
+	 * MF_COUNT_INCREASED path, get_any_page() can drop the caller's
+	 * reference before returning -EIO, after which page->flags may
+	 * have been reset by the allocator.
+	 */
+	is_reserved = PageReserved(p);
+
 	res = get_hwpoison_page(p, flags);
 	if (!res) {
 		if (is_free_buddy_page(p)) {
@@ -2432,7 +2445,11 @@ int memory_failure(unsigned long pfn, int flags)
 		}
 		goto unlock_mutex;

mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2455

Quoted 10 lines
mm/memory-failure.c +5 -1
 	} else if (res < 0) {
-		res = action_result(pfn, MF_MSG_GET_HWPOISON, MF_IGNORED);
+		if (is_reserved)
+			res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);
+		else
+			res = action_result(pfn, MF_MSG_GET_HWPOISON,
+					    MF_IGNORED);
 		goto unlock_mutex;
 	}
 

It's a bit odd that we need this handling when we already have handling for reserved pages in error_states[].

Quoted 5 lines

HWPoisonHandlable() would always essentially reject PG_reserved pages. So __get_hwpoison_page() ... would always fail? Making get_hwpoison_page()->get_any_page() always fail?

But then, we never call identify_page_state()? And never call me_kernel()?

Looks like we never get that far ...

Quoted 4 lines

This all looks very odd.

Why would you even want to call get_hwpoison_page() in the first place if you find PageReserved?

Ah, I see :)

For a PG_reserved page, I would not expect PageLRU to be set, nor would I expect it to be in the buddy allocator.

include/linux/page-flags.h also says:

"
Once (if ever) freed, PG_reserved is cleared and they will be given to the page allocator.
"

So maybe special-case PageReserved() before get_hwpoison_page()? Something like:

	if (PageReserved(p)){
		res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);
		goto unlock_mutex; 	
	}

	res = get_hwpoison_page(p, flags, &gp_status);

Cheers, Lance

#4 lore raw

Re: [PATCH v6 1/4] mm/memory-failure: report MF_MSG_KERNEL for reserved pages

Quoted 72 lines · Lance Yang
Quoted 70 lines · David Hildenbrand (Arm)
Quoted 55 lines · Breno Leitao

When get_hwpoison_page() returns a negative value, distinguish reserved pages from other failure cases by reporting MF_MSG_KERNEL instead of MF_MSG_GET_HWPOISON. Reserved pages belong to the kernel and should be classified accordingly for proper handling.

Sample PG_reserved before the get_hwpoison_page() call. In the MF_COUNT_INCREASED path get_any_page() can drop the caller's reference before returning -EIO, after which the underlying page may have been freed and reallocated with page->flags reset; reading PageReserved(p) at that point would observe stale or unrelated state. The pre-call snapshot reflects what the page actually was at the time of the failure event.

---
 mm/memory-failure.c | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)
mm/memory-failure.c +13 -0
index 866c4428ac7ef..f112fb27a8ff6 100644
@@ -2348,6 +2348,7 @@ int memory_failure(unsigned long pfn, int flags)
 	unsigned long page_flags;
 	bool retry = true;
 	int hugetlb = 0;
+	bool is_reserved;
 
 	if (!sysctl_memory_failure_recovery)
 		panic("Memory failure on page %lx", pfn);
@@ -2411,6 +2412,18 @@ int memory_failure(unsigned long pfn, int flags)
 	 * In fact it's dangerous to directly bump up page count from 0,
 	 * that may make page_ref_freeze()/page_ref_unfreeze() mismatch.
 	 */
+	/*
+	 * Pages with PG_reserved set are not currently managed by the
+	 * page allocator (memblock-reserved memory, driver reservations,
+	 * etc.), so classify them as kernel-owned for reporting.
+	 *
+	 * Sample the flag before get_hwpoison_page(): in the
+	 * MF_COUNT_INCREASED path, get_any_page() can drop the caller's
+	 * reference before returning -EIO, after which page->flags may
+	 * have been reset by the allocator.
+	 */
+	is_reserved = PageReserved(p);
+
 	res = get_hwpoison_page(p, flags);
 	if (!res) {
 		if (is_free_buddy_page(p)) {
@@ -2432,7 +2445,11 @@ int memory_failure(unsigned long pfn, int flags)
 		}
 		goto unlock_mutex;

mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2455

Quoted 10 lines
mm/memory-failure.c +5 -1
 	} else if (res < 0) {
-		res = action_result(pfn, MF_MSG_GET_HWPOISON, MF_IGNORED);
+		if (is_reserved)
+			res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);
+		else
+			res = action_result(pfn, MF_MSG_GET_HWPOISON,
+					    MF_IGNORED);
 		goto unlock_mutex;
 	}
 

It's a bit odd that we need this handling when we already have handling for reserved pages in error_states[].

Quoted 7 lines
Quoted 5 lines

HWPoisonHandlable() would always essentially reject PG_reserved pages. So __get_hwpoison_page() ... would always fail? Making get_hwpoison_page()->get_any_page() always fail?

But then, we never call identify_page_state()? And never call me_kernel()?

Looks like we never get that far ...

Right, likely that should be removed+cleaned up then.

Signature · 3 lines
Cheers,

David
#5 lore raw

Re: [PATCH v6 1/4] mm/memory-failure: report MF_MSG_KERNEL for reserved pages

In reply to David Hildenbrand (Arm)
Quoted 45 lines · David Hildenbrand (Arm)
Quoted 31 lines
mm/memory-failure.c +13 -0
@@ -2348,6 +2348,7 @@ int memory_failure(unsigned long pfn, int flags)
 	unsigned long page_flags;
 	bool retry = true;
 	int hugetlb = 0;
+	bool is_reserved;
 
 	if (!sysctl_memory_failure_recovery)
 		panic("Memory failure on page %lx", pfn);
@@ -2411,6 +2412,18 @@ int memory_failure(unsigned long pfn, int flags)
 	 * In fact it's dangerous to directly bump up page count from 0,
 	 * that may make page_ref_freeze()/page_ref_unfreeze() mismatch.
 	 */
+	/*
+	 * Pages with PG_reserved set are not currently managed by the
+	 * page allocator (memblock-reserved memory, driver reservations,
+	 * etc.), so classify them as kernel-owned for reporting.
+	 *
+	 * Sample the flag before get_hwpoison_page(): in the
+	 * MF_COUNT_INCREASED path, get_any_page() can drop the caller's
+	 * reference before returning -EIO, after which page->flags may
+	 * have been reset by the allocator.
+	 */
+	is_reserved = PageReserved(p);
+
 	res = get_hwpoison_page(p, flags);
 	if (!res) {
 		if (is_free_buddy_page(p)) {
@@ -2432,7 +2445,11 @@ int memory_failure(unsigned long pfn, int flags)
 		}
 		goto unlock_mutex;

mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2455

Quoted 10 lines
mm/memory-failure.c +5 -1
 	} else if (res < 0) {
-		res = action_result(pfn, MF_MSG_GET_HWPOISON, MF_IGNORED);
+		if (is_reserved)
+			res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);
+		else
+			res = action_result(pfn, MF_MSG_GET_HWPOISON,
+					    MF_IGNORED);
 		goto unlock_mutex;
 	}
 

It's a bit odd that we need this handling when we already have handling for reserved pages in error_states[].

Quoted 5 lines

HWPoisonHandlable() would always essentially reject PG_reserved pages. So __get_hwpoison_page() ... would always fail? Making get_hwpoison_page()->get_any_page() always fail?

But then, we never call identify_page_state()? And never call me_kernel()?

From what I read, it seems that error_states[0] = { reserved, reserved, MF_MSG_KERNEL, me_kernel } has been effectively dead code on the hwpoison-from-MCE path for a
while.

My v6 patch relabels the failure-path output to match what me_kernel() would have reported anyway.

Quoted 4 lines

This all looks very odd.

Why would you even want to call get_hwpoison_page() in the first place if you find PageReserved?

Are you suggesting we should all the page action as soon as we detect the page is reserved and get out?

Something as:

    if (PageReserved(p)) {
        res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);
        goto unlock_mutex;
    }

    res = get_hwpoison_page(p, flags);

Thanks for the review,
--breno

#6 lore raw

Re: [PATCH v6 1/4] mm/memory-failure: report MF_MSG_KERNEL for reserved pages

Quoted 67 lines · Breno Leitao
Quoted 45 lines · David Hildenbrand (Arm)
Quoted 31 lines
mm/memory-failure.c +13 -0
@@ -2348,6 +2348,7 @@ int memory_failure(unsigned long pfn, int flags)
 	unsigned long page_flags;
 	bool retry = true;
 	int hugetlb = 0;
+	bool is_reserved;
 
 	if (!sysctl_memory_failure_recovery)
 		panic("Memory failure on page %lx", pfn);
@@ -2411,6 +2412,18 @@ int memory_failure(unsigned long pfn, int flags)
 	 * In fact it's dangerous to directly bump up page count from 0,
 	 * that may make page_ref_freeze()/page_ref_unfreeze() mismatch.
 	 */
+	/*
+	 * Pages with PG_reserved set are not currently managed by the
+	 * page allocator (memblock-reserved memory, driver reservations,
+	 * etc.), so classify them as kernel-owned for reporting.
+	 *
+	 * Sample the flag before get_hwpoison_page(): in the
+	 * MF_COUNT_INCREASED path, get_any_page() can drop the caller's
+	 * reference before returning -EIO, after which page->flags may
+	 * have been reset by the allocator.
+	 */
+	is_reserved = PageReserved(p);
+
 	res = get_hwpoison_page(p, flags);
 	if (!res) {
 		if (is_free_buddy_page(p)) {
@@ -2432,7 +2445,11 @@ int memory_failure(unsigned long pfn, int flags)
 		}
 		goto unlock_mutex;

mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2455

Quoted 10 lines
mm/memory-failure.c +5 -1
 	} else if (res < 0) {
-		res = action_result(pfn, MF_MSG_GET_HWPOISON, MF_IGNORED);
+		if (is_reserved)
+			res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);
+		else
+			res = action_result(pfn, MF_MSG_GET_HWPOISON,
+					    MF_IGNORED);
 		goto unlock_mutex;
 	}
 

It's a bit odd that we need this handling when we already have handling for reserved pages in error_states[].

Quoted 5 lines

HWPoisonHandlable() would always essentially reject PG_reserved pages. So __get_hwpoison_page() ... would always fail? Making get_hwpoison_page()->get_any_page() always fail?

But then, we never call identify_page_state()? And never call me_kernel()?

From what I read, it seems that error_states[0] = { reserved, reserved, MF_MSG_KERNEL, me_kernel } has been effectively dead code on the hwpoison-from-MCE path for a
while.

My v6 patch relabels the failure-path output to match what me_kernel() would have reported anyway.

Quoted 4 lines

This all looks very odd.

Why would you even want to call get_hwpoison_page() in the first place if you find PageReserved?

Are you suggesting we should all the page action as soon as we detect the page is reserved and get out?

Quoted 8 lines

Something as:

    if (PageReserved(p)) {
        res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);
        goto unlock_mutex;
    }

    res = get_hwpoison_page(p, flags);

Or you combine this patch with the other patch and let simply get_hwpoison_page() check that, and return an appropriate error code for unhandable that you can process here?

Like, maybe, returning -EIO directly?

res = get_hwpoison_page(p, flags);
switch (res) {
case 0: /* Success */

	...
	break
case -EIO: /* Unhandable kernel page. */
	...
	break;
case -EBUSY: /* Race, try again? */
	...
	break;

case ...
}

You can add more return codes as you see fit.

Signature · 3 lines
Cheers,

David
#7 lore raw

Re: [PATCH v6 1/4] mm/memory-failure: report MF_MSG_KERNEL for reserved pages

In reply to David Hildenbrand (Arm)
Quoted 74 lines · David Hildenbrand (Arm)
Quoted 55 lines · Breno Leitao

When get_hwpoison_page() returns a negative value, distinguish reserved pages from other failure cases by reporting MF_MSG_KERNEL instead of MF_MSG_GET_HWPOISON. Reserved pages belong to the kernel and should be classified accordingly for proper handling.

Sample PG_reserved before the get_hwpoison_page() call. In the MF_COUNT_INCREASED path get_any_page() can drop the caller's reference before returning -EIO, after which the underlying page may have been freed and reallocated with page->flags reset; reading PageReserved(p) at that point would observe stale or unrelated state. The pre-call snapshot reflects what the page actually was at the time of the failure event.

---
  mm/memory-failure.c | 19 ++++++++++++++++++-
  1 file changed, 18 insertions(+), 1 deletion(-)
mm/memory-failure.c +13 -0
index 866c4428ac7ef..f112fb27a8ff6 100644
@@ -2348,6 +2348,7 @@ int memory_failure(unsigned long pfn, int flags)
  	unsigned long page_flags;
  	bool retry = true;
  	int hugetlb = 0;
+	bool is_reserved;
 
  	if (!sysctl_memory_failure_recovery)
  		panic("Memory failure on page %lx", pfn);
@@ -2411,6 +2412,18 @@ int memory_failure(unsigned long pfn, int flags)
  	 * In fact it's dangerous to directly bump up page count from 0,
  	 * that may make page_ref_freeze()/page_ref_unfreeze() mismatch.
  	 */
+	/*
+	 * Pages with PG_reserved set are not currently managed by the
+	 * page allocator (memblock-reserved memory, driver reservations,
+	 * etc.), so classify them as kernel-owned for reporting.
+	 *
+	 * Sample the flag before get_hwpoison_page(): in the
+	 * MF_COUNT_INCREASED path, get_any_page() can drop the caller's
+	 * reference before returning -EIO, after which page->flags may
+	 * have been reset by the allocator.
+	 */
+	is_reserved = PageReserved(p);
+
  	res = get_hwpoison_page(p, flags);
  	if (!res) {
  		if (is_free_buddy_page(p)) {
@@ -2432,7 +2445,11 @@ int memory_failure(unsigned long pfn, int flags)
  		}
  		goto unlock_mutex;

mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2455

Quoted 10 lines
mm/memory-failure.c +5 -1
  	} else if (res < 0) {
-		res = action_result(pfn, MF_MSG_GET_HWPOISON, MF_IGNORED);
+		if (is_reserved)
+			res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);
+		else
+			res = action_result(pfn, MF_MSG_GET_HWPOISON,
+					    MF_IGNORED);
  		goto unlock_mutex;
  	}
 

It's a bit odd that we need this handling when we already have handling for reserved pages in error_states[].

HWPoisonHandlable() would always essentially reject PG_reserved pages. So __get_hwpoison_page() ... would always fail? Making get_hwpoison_page()->get_any_page() always fail?

Quoted 7 lines

But then, we never call identify_page_state()? And never call me_kernel()?

This all looks very odd.

Why would you even want to call get_hwpoison_page() in the first place if you find PageReserved?

Ah, good point!
It seems to me that all unhandable pages should head out to identify_page_state:

mm/memory-failure.c +4 -0
@@ -2411,6 +2411,10 @@ int memory_failure(unsigned long pfn, int flags)
         * In fact it's dangerous to directly bump up page count from 0,
         * that may make page_ref_freeze()/page_ref_unfreeze() mismatch.
         */
+
+       if (!HWPoisonHandlable(page, flags)
+               goto identify_page_state;
+
        res = get_hwpoison_page(p, flags);
        if (!res) {
                if (is_free_buddy_page(p)) {

thanks,
-jane

#8 lore raw

Re: [PATCH v6 1/4] mm/memory-failure: report MF_MSG_KERNEL for reserved pages

Quoted 89 lines · On 5/12/26 19:58, [email protected] wrote:
Quoted 72 lines · David Hildenbrand (Arm)
Quoted 62 lines · Breno Leitao

When get_hwpoison_page() returns a negative value, distinguish reserved pages from other failure cases by reporting MF_MSG_KERNEL instead of MF_MSG_GET_HWPOISON. Reserved pages belong to the kernel and should be classified accordingly for proper handling.

Sample PG_reserved before the get_hwpoison_page() call. In the MF_COUNT_INCREASED path get_any_page() can drop the caller's reference before returning -EIO, after which the underlying page may have been freed and reallocated with page->flags reset; reading PageReserved(p) at that point would observe stale or unrelated state. The pre-call snapshot reflects what the page actually was at the time of the failure event.

---
  mm/memory-failure.c | 19 ++++++++++++++++++-

  1 file changed, 18 insertions(+), 1 deletion(-)
mm/memory-failure.c +18 -1
index 866c4428ac7ef..f112fb27a8ff6 100644
@@ -2348,6 +2348,7 @@ int memory_failure(unsigned long pfn, int flags)
       unsigned long page_flags;
       bool retry = true;
       int hugetlb = 0;
+    bool is_reserved;
         if (!sysctl_memory_failure_recovery)
           panic("Memory failure on page %lx", pfn);
@@ -2411,6 +2412,18 @@ int memory_failure(unsigned long pfn, int flags)
        * In fact it's dangerous to directly bump up page count from 0,
        * that may make page_ref_freeze()/page_ref_unfreeze() mismatch.
        */
+    /*
+     * Pages with PG_reserved set are not currently managed by the
+     * page allocator (memblock-reserved memory, driver reservations,
+     * etc.), so classify them as kernel-owned for reporting.
+     *
+     * Sample the flag before get_hwpoison_page(): in the
+     * MF_COUNT_INCREASED path, get_any_page() can drop the caller's
+     * reference before returning -EIO, after which page->flags may
+     * have been reset by the allocator.
+     */
+    is_reserved = PageReserved(p);
+
       res = get_hwpoison_page(p, flags);
       if (!res) {
           if (is_free_buddy_page(p)) {
@@ -2432,7 +2445,11 @@ int memory_failure(unsigned long pfn, int flags)
           }
           goto unlock_mutex;
       } else if (res < 0) {
-        res = action_result(pfn, MF_MSG_GET_HWPOISON, MF_IGNORED);
+        if (is_reserved)
+            res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);
+        else
+            res = action_result(pfn, MF_MSG_GET_HWPOISON,
+                        MF_IGNORED);
           goto unlock_mutex;
       }
Quoted 1 line

It's a bit odd that we need this handling when we already have handling for reserved pages in error_states[].

HWPoisonHandlable() would always essentially reject PG_reserved pages. So __get_hwpoison_page() ... would always fail? Making get_hwpoison_page()->get_any_page() always fail?

Quoted 7 lines

But then, we never call identify_page_state()? And never call me_kernel()?

This all looks very odd.

Why would you even want to call get_hwpoison_page() in the first place if you find PageReserved?

Ah, good point!
It seems to me that all unhandable pages should head out to identify_page_state:

mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2420

Quoted 10 lines
mm/memory-failure.c +4 -0
@@ -2411,6 +2411,10 @@ int memory_failure(unsigned long pfn, int flags)
          * In fact it's dangerous to directly bump up page count from 0,
          * that may make page_ref_freeze()/page_ref_unfreeze() mismatch.
          */
+
+       if (!HWPoisonHandlable(page, flags)
+               goto identify_page_state;
+
         res = get_hwpoison_page(p, flags);
         if (!res) {
                 if (is_free_buddy_page(p)) {

That's one option, or we just let get_hwpoison_page() return clearer error codes, let it take care of checking PageReserved, and process the error codes return by get_hwpoison_page() in a better way.

Signature · 3 lines
Cheers,

David
#9 lore raw

PATCH v6 2/4 mm/memory-failure: classify get_any_page() failures by reason

In reply to Breno Leitao

When get_any_page() fails to grab a page reference, the *reason* it failed is known at the call site but is not surfaced to callers: the HWPoisonHandlable() rejection path (a stable kernel page hwpoison cannot handle — slab, vmalloc, page tables, kernel stacks, ...) and the page_count() / put_page race paths (a transient page-allocator lifecycle race) all collapse to a single negative errno by the time memory_failure() sees them. memory_failure() can only observe the conflated result and reports both as MF_MSG_GET_HWPOISON.

Surface the diagnosis explicitly. Add an mf_get_page_status enum, plumbed out through get_any_page() and get_hwpoison_page() (NULL is accepted by callers that do not care — unpoison_memory() and soft_offline_page() pass NULL). get_any_page() sets the status at the moment it gives up:

MF_GET_PAGE_UNHANDLABLE — HWPoisonHandlable() rejected the page
after retries.
MF_GET_PAGE_RACE — exhausted retries on a refcount /
lifecycle race with the allocator.

memory_failure() then promotes the unhandlable case to MF_MSG_KERNEL alongside the existing PageReserved branch, and leaves the transient-race case as MF_MSG_GET_HWPOISON. This forms the foundation a later patch will rely on to decide whether an unrecoverable failure should panic.

Drop the "reserved" qualifier from action_page_types[MF_MSG_KERNEL] and the matching tracepoint string in MF_PAGE_TYPE: the enum value now covers both PageReserved pages and unhandlable kernel pages (slab, vmalloc, page tables, kernel stacks, ...), so "kernel page" is the accurate label for both populations.

---
 include/trace/events/memory-failure.h |  2 +-
 mm/memory-failure.c                   | 46 +++++++++++++++++++++++++++++------
 2 files changed, 39 insertions(+), 9 deletions(-)
include/trace/events/memory-failure.h +1 -1
index aa57cc8f896be..8a860e6fcb4e9 100644
@@ -24,7 +24,7 @@
 	EMe ( MF_RECOVERED, "Recovered" )
 
 #define MF_PAGE_TYPE		\
-	EM ( MF_MSG_KERNEL, "reserved kernel page" )			\
+	EM ( MF_MSG_KERNEL, "kernel page" )				\
 	EM ( MF_MSG_KERNEL_HIGH_ORDER, "high-order kernel page" )	\
 	EM ( MF_MSG_HUGE, "huge page" )					\
 	EM ( MF_MSG_FREE_HUGE, "free huge page" )			\
mm/memory-failure.c +38 -8

133 lines not on this page · raw message

Signature · 1 line
2.53.0-Meta
#10 lore raw

Re: [PATCH v6 2/4] mm/memory-failure: classify get_any_page() failures by reason

mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2479

Quoted 12 lines
mm/memory-failure.c +6 -1
 		}
 		goto unlock_mutex;
 	} else if (res < 0) {
-		if (is_reserved)
+		/*
+		 * Promote a stable unhandlable kernel page diagnosed by
+		 * get_hwpoison_page() to MF_MSG_KERNEL alongside reserved
+		 * pages; transient lifecycle races stay as MF_MSG_GET_HWPOISON.
+		 */
+		if (is_reserved || gp_status == MF_GET_PAGE_UNHANDLABLE)
 			res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);

It's all a bit of a mess. get_hwpoison_page() should just indicate that a page is unhandable if it is PG_reserved?

Why can't we just return a special error code from get_hwpoison_page()? We ahve plenty of errno values to chose from.

Signature · 3 lines
Cheers,

David
#11 lore raw

Re: [PATCH v6 2/4] mm/memory-failure: classify get_any_page() failures by reason

Quoted 16 lines · David Hildenbrand (Arm)

Review

Quoted 12 lines
(quoted diff) +6 -1
 		}
 		goto unlock_mutex;
 	} else if (res < 0) {
-		if (is_reserved)
+		/*
+		 * Promote a stable unhandlable kernel page diagnosed by
+		 * get_hwpoison_page() to MF_MSG_KERNEL alongside reserved
+		 * pages; transient lifecycle races stay as MF_MSG_GET_HWPOISON.
+		 */
+		if (is_reserved || gp_status == MF_GET_PAGE_UNHANDLABLE)
 			res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);

It's all a bit of a mess. get_hwpoison_page() should just indicate that a page is unhandable if it is PG_reserved?

Are you saying that we should identify if the page is PG_reserved in get_hwpoison_page() instead of in memory_failure(), as done in the previous patch ("mm/memory-failure: report MF_MSG_KERNEL for reserved pages") ?

Quoted 2 lines

Why can't we just return a special error code from get_hwpoison_page()? We ahve plenty of errno values to chose from.

Something like:

mm/memory-failure.c +12 -4
index 866c4428ac7ef..0a6d83575833e 100644
@@ -878,7 +878,7 @@ static const char *action_name[] = {
 };
 
 static const char * const action_page_types[] = {
-	[MF_MSG_KERNEL]			= "reserved kernel page",
+	[MF_MSG_KERNEL]			= "unrecoverable kernel page",
 	[MF_MSG_KERNEL_HIGH_ORDER]	= "high-order kernel page",
 	[MF_MSG_HUGE]			= "huge page",
 	[MF_MSG_FREE_HUGE]		= "free huge page",
@@ -1394,6 +1394,21 @@ static int get_any_page(struct page *p, unsigned long flags)
 	int ret = 0, pass = 0;
 	bool count_increased = false;
 
+	if (PageReserved(p)) {
+		ret = -ENOTRECOVERABLE;
+		goto out;
+	}
+
 	if (flags & MF_COUNT_INCREASED)
 		count_increased = true;
 
@@ -1422,7 +1437,7 @@ static int get_any_page(struct page *p, unsigned long flags)
 				shake_page(p);
 				goto try_again;
 			}
-			ret = -EIO;
+			ret = -ENOTRECOVERABLE;
 			goto out;
 		}
 	}
@@ -1441,10 +1456,10 @@ static int get_any_page(struct page *p, unsigned long flags)
 			goto try_again;
 		}
 		put_page(p);
-		ret = -EIO;
+		ret = -ENOTRECOVERABLE;
 	}
 out:
-	if (ret == -EIO)
+	if (ret == -EIO || ret == -ENOTRECOVERABLE)
 		pr_err("%#lx: unhandlable page.\n", page_to_pfn(p));
 
 	return ret;
@@ -2431,6 +2448,9 @@ int memory_failure(unsigned long pfn, int flags)
 			res = action_result(pfn, MF_MSG_KERNEL_HIGH_ORDER, MF_IGNORED);
 		}
 		goto unlock_mutex;
+	} else if (res == -ENOTRECOVERABLE) {
+		res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);
+		goto unlock_mutex;
 	} else if (res < 0) {
 		res = action_result(pfn, MF_MSG_GET_HWPOISON, MF_IGNORED);
 		goto unlock_mutex;

If that is what you are suggestion, maybe we can create another MF_MSG_RESERVED? and another return value for get_any_page() to track the reserve pages ?

Thanks for the review and suggestions,
--breno

#12 lore raw

Re: [PATCH v6 2/4] mm/memory-failure: classify get_any_page() failures by reason

Quoted 77 lines · Breno Leitao
Quoted 16 lines · David Hildenbrand (Arm)

Review

Quoted 12 lines
(quoted diff) +6 -1
 		}
 		goto unlock_mutex;
 	} else if (res < 0) {
-		if (is_reserved)
+		/*
+		 * Promote a stable unhandlable kernel page diagnosed by
+		 * get_hwpoison_page() to MF_MSG_KERNEL alongside reserved
+		 * pages; transient lifecycle races stay as MF_MSG_GET_HWPOISON.
+		 */
+		if (is_reserved || gp_status == MF_GET_PAGE_UNHANDLABLE)
 			res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);

It's all a bit of a mess. get_hwpoison_page() should just indicate that a page is unhandable if it is PG_reserved?

Are you saying that we should identify if the page is PG_reserved in get_hwpoison_page() instead of in memory_failure(), as done in the previous patch ("mm/memory-failure: report MF_MSG_KERNEL for reserved pages") ?

Quoted 2 lines

Why can't we just return a special error code from get_hwpoison_page()? We ahve plenty of errno values to chose from.

Something like:

mm/memory-failure.c +9 -4
index 866c4428ac7ef..0a6d83575833e 100644
@@ -878,7 +878,7 @@ static const char *action_name[] = {
 };
 
 static const char * const action_page_types[] = {
-	[MF_MSG_KERNEL]			= "reserved kernel page",
+	[MF_MSG_KERNEL]			= "unrecoverable kernel page",
 	[MF_MSG_KERNEL_HIGH_ORDER]	= "high-order kernel page",
 	[MF_MSG_HUGE]			= "huge page",
 	[MF_MSG_FREE_HUGE]		= "free huge page",
@@ -1394,6 +1394,21 @@ static int get_any_page(struct page *p, unsigned long flags)
 	int ret = 0, pass = 0;
 	bool count_increased = false;
 
+	if (PageReserved(p)) {
+		ret = -ENOTRECOVERABLE;
+		goto out;
+	}
+
 	if (flags & MF_COUNT_INCREASED)
 		count_increased = true;
 
@@ -1422,7 +1437,7 @@ static int get_any_page(struct page *p, unsigned long flags)
 				shake_page(p);
 				goto try_again;
 			}
-			ret = -EIO;
+			ret = -ENOTRECOVERABLE;
 			goto out;
 		}
 	}
@@ -1441,10 +1456,10 @@ static int get_any_page(struct page *p, unsigned long flags)
 			goto try_again;
 		}
 		put_page(p);
-		ret = -EIO;
+		ret = -ENOTRECOVERABLE;
 	}
 out:
-	if (ret == -EIO)
+	if (ret == -EIO || ret == -ENOTRECOVERABLE)
 		pr_err("%#lx: unhandlable page.\n", page_to_pfn(p));
 
 	return ret;

mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2456

Quoted 9 lines
mm/memory-failure.c +3 -0
@@ -2431,6 +2448,9 @@ int memory_failure(unsigned long pfn, int flags)
 			res = action_result(pfn, MF_MSG_KERNEL_HIGH_ORDER, MF_IGNORED);
 		}
 		goto unlock_mutex;
+	} else if (res == -ENOTRECOVERABLE) {
+		res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);
+		goto unlock_mutex;
 	} else if (res < 0) {
 		res = action_result(pfn, MF_MSG_GET_HWPOISON, MF_IGNORED);
 		goto unlock_mutex;

That might probably read nicer as

switch (res) {
case 0: ...
case 1: ...
case -ENOTRECOVERABLE: ...
case ...
default:
}

Quoted 5 lines

If that is what you are suggestion, maybe we can create another MF_MSG_RESERVED? and another return value for get_any_page() to track the reserve pages ?

I guess "reserved" is really just like most other kernel pages. So I wouldn't special-case them here.

Or would there be a good reason?

Signature · 3 lines
Cheers,

David
#13 lore raw

Re: [PATCH v6 2/4] mm/memory-failure: classify get_any_page() failures by reason

Quoted 36 lines · David Hildenbrand (Arm)
Quoted 14 lines
mm/memory-failure.c +2 -2
@@ -1441,10 +1456,10 @@ static int get_any_page(struct page *p, unsigned long flags)
 			goto try_again;
 		}
 		put_page(p);
-		ret = -EIO;
+		ret = -ENOTRECOVERABLE;
 	}
 out:
-	if (ret == -EIO)
+	if (ret == -EIO || ret == -ENOTRECOVERABLE)
 		pr_err("%#lx: unhandlable page.\n", page_to_pfn(p));
 
 	return ret;

mm/memory-failure.c int memory_failure(unsigned long pfn, int flags) · line 2456

Quoted 9 lines
mm/memory-failure.c +3 -0
@@ -2431,6 +2448,9 @@ int memory_failure(unsigned long pfn, int flags)
 			res = action_result(pfn, MF_MSG_KERNEL_HIGH_ORDER, MF_IGNORED);
 		}
 		goto unlock_mutex;
+	} else if (res == -ENOTRECOVERABLE) {
+		res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);
+		goto unlock_mutex;
 	} else if (res < 0) {
 		res = action_result(pfn, MF_MSG_GET_HWPOISON, MF_IGNORED);
 		goto unlock_mutex;

That might probably read nicer as

switch (res) {
case 0: ...
case 1: ...
case -ENOTRECOVERABLE: ...
case ...
default:
}

Quoted 2 lines
Quoted 8 lines
Quoted 3 lines

If that is what you are suggestion, maybe we can create another MF_MSG_RESERVED? and another return value for get_any_page() to track the reserve pages ?

I guess "reserved" is really just like most other kernel pages. So I wouldn't special-case them here.

Or would there be a good reason?

Not really, treating them as MF_MSG_KERNEL is sufficient for my use case.

Thank you for the review. I'm digesting all the feedback and will send out a new revision shortly, where we can continue the discussion.

--breno

#14 lore raw

PATCH v6 3/4 mm/memory-failure: add panic option for unrecoverable pages

In reply to Breno Leitao

Add a sysctl panic_on_unrecoverable_memory_failure that triggers a kernel panic when memory_failure() encounters pages that cannot be recovered. This provides a clean crash with useful debug information rather than allowing silent data corruption or a delayed crash at an unrelated code path.

Panic eligibility is intentionally narrow: only MF_MSG_KERNEL with result == MF_IGNORED panics. That covers reserved pages (PageReserved) and the kernel page types that the prior patch promotes from MF_MSG_GET_HWPOISON via MF_GET_PAGE_UNHANDLABLE — slab, vmalloc, page tables, kernel stacks, and similar non-LRU/non-buddy kernel-owned pages.

All other action types are excluded:

- MF_MSG_GET_HWPOISON and MF_MSG_KERNEL_HIGH_ORDER can be reached by transient refcount races with the page allocator (an in-flight buddy allocation has refcount 0 and is no longer on the buddy free list, briefly), and panicking on them would risk killing the box for what is actually a recoverable userspace page.

- MF_MSG_UNKNOWN means identify_page_state() could not classify the page; that is precisely the wrong basis for a panic decision.

---
 mm/memory-failure.c | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
mm/memory-failure.c +26 -0
index 4210173060aac..e4a9ceacaf36b 100644
@@ -74,6 +74,8 @@ static int sysctl_memory_failure_recovery __read_mostly = 1;
 
 static int sysctl_enable_soft_offline __read_mostly = 1;
 
+static int sysctl_panic_on_unrecoverable_mf __read_mostly;
+
 atomic_long_t num_poisoned_pages __read_mostly = ATOMIC_LONG_INIT(0);
 
 static bool hw_memory_failure __read_mostly = false;
@@ -155,6 +157,15 @@ static const struct ctl_table memory_failure_table[] = {
 		.proc_handler	= proc_dointvec_minmax,
 		.extra1		= SYSCTL_ZERO,
 		.extra2		= SYSCTL_ONE,
+	},
+	{
+		.procname	= "panic_on_unrecoverable_memory_failure",
+		.data		= &sysctl_panic_on_unrecoverable_mf,
+		.maxlen		= sizeof(sysctl_panic_on_unrecoverable_mf),
+		.mode		= 0644,
+		.proc_handler	= proc_dointvec_minmax,
+		.extra1		= SYSCTL_ZERO,
+		.extra2		= SYSCTL_ONE,
 	}
 };
 
@@ -1281,6 +1292,18 @@ static void update_per_node_mf_stats(unsigned long pfn,
 	++mf_stats->total;
 }
 
+static bool panic_on_unrecoverable_mf(enum mf_action_page_type type,
+				      enum mf_result result)
+{
+	if (!sysctl_panic_on_unrecoverable_mf || result != MF_IGNORED)
+		return false;
+
+	if (type == MF_MSG_KERNEL)
+		return true;
+
+	return false;
+}
+
 /*
  * "Dirty/Clean" indication is not 100% accurate due to the possibility of
  * setting PG_dirty outside page lock. See also comment above set_page_dirty().
@@ -1298,6 +1321,9 @@ static int action_result(unsigned long pfn, enum mf_action_page_type type,
 	pr_err("%#lx: recovery action for %s: %s\n",
 		pfn, action_page_types[type], action_name[result]);
 
+	if (panic_on_unrecoverable_mf(type, result))
+		panic("Memory failure: %#lx: unrecoverable page", pfn);
+
 	return (result == MF_RECOVERED || result == MF_DELAYED) ? 0 : -EBUSY;
 }
 
Signature · 1 line
2.53.0-Meta
#15 lore raw
Quoted 5 lines
mm/memory-failure.c +0 -0
@@ -1281,6 +1292,18 @@ static void update_per_node_mf_stats(unsigned long pfn,
 	++mf_stats->total;
 }
 

mm/memory-failure.c static void update_per_node_mf_stats(unsigned long pfn, · line 1304

Quoted 10 lines
mm/memory-failure.c +10 -0
+static bool panic_on_unrecoverable_mf(enum mf_action_page_type type,
+				      enum mf_result result)
+{
+	if (!sysctl_panic_on_unrecoverable_mf || result != MF_IGNORED)
+		return false;
+
+	if (type == MF_MSG_KERNEL)
+		return true;
+
+	return false;

return type == MF_MSG_KERNEL;

might be simpler.

Signature · 3 lines
Cheers,

David
#16 lore raw
Quoted 18 lines · David Hildenbrand (Arm)
Quoted 5 lines
mm/memory-failure.c +0 -0
@@ -1281,6 +1292,18 @@ static void update_per_node_mf_stats(unsigned long pfn,
 	++mf_stats->total;
 }
 

mm/memory-failure.c static void update_per_node_mf_stats(unsigned long pfn, · line 1304

Quoted 10 lines
mm/memory-failure.c +10 -0
+static bool panic_on_unrecoverable_mf(enum mf_action_page_type type,
+				      enum mf_result result)
+{
+	if (!sysctl_panic_on_unrecoverable_mf || result != MF_IGNORED)
+		return false;
+
+	if (type == MF_MSG_KERNEL)
+		return true;
+
+	return false;

return type == MF_MSG_KERNEL;

Quoted 1 line

might be simpler.

Ack, I will update once we decide about the other pendencies.

#17 lore raw

PATCH v6 4/4 Documentation: document panic_on_unrecoverable_memory_failure sysctl

In reply to 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).

---
 Documentation/admin-guide/sysctl/vm.rst | 70 +++++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)
Documentation/admin-guide/sysctl/vm.rst +70 -0
index 97e12359775c9..802c51ba8c43b 100644
@@ -67,6 +67,7 @@ Currently, these files are in /proc/sys/vm:
 - page-cluster
 - page_lock_unfairness
 - panic_on_oom
+- panic_on_unrecoverable_memory_failure
 - percpu_pagelist_high_fraction
 - stat_interval
 - stat_refresh
@@ -925,6 +926,75 @@ panic_on_oom=2+kdump gives you very strong tool to investigate
 why oom happens. You can get snapshot.
 
 
+panic_on_unrecoverable_memory_failure
+======================================
+
+When a hardware memory error (e.g. multi-bit ECC) hits a kernel page
+that cannot be recovered by the memory failure handler, the default
+behaviour is to ignore the error and continue operation.  This is
+dangerous because the corrupted data remains accessible to the kernel,
+risking silent data corruption or a delayed crash when the poisoned
+memory is next accessed.
+
+When enabled, this sysctl triggers a panic on kernel-owned pages that
+the memory failure handler cannot recover: reserved pages
+(``PageReserved``) and stable kernel pages that hwpoison cannot handle
+(slab, vmalloc, page tables, kernel stacks, and similar non-LRU,
+non-buddy pages).
+
+Other failure paths are intentionally left out because they can be
+reached by transient races with the page allocator (an in-flight
+buddy allocation has refcount 0 and is no longer on the buddy free
+list, briefly), and panicking on them would risk killing the box for
+a page that was actually destined for userspace where the standard
+SIGBUS recovery path applies. Pages whose state could not be
+classified at all are also not covered, since an unknown state is
+not a sound basis for a panic decision.
+
+For many environments it is preferable to panic immediately with a clean
+crash dump that captures the original error context, rather than to
+continue and face a random crash later whose cause is difficult to
+diagnose.
+
+Use cases
+---------
+
+This option is most useful in environments where unattributed crashes
+are expensive to debug or where data integrity must take precedence
+over availability:
+
+* Large fleets, where multi-bit ECC errors on kernel pages are observed
+  regularly and post-mortem analysis of an unrelated downstream crash
+  (often seconds to minutes after the original error) consumes
+  significant engineering effort.
+
+* Systems configured with kdump, where panicking at the moment of the
+  hardware error produces a vmcore that still contains the faulting
+  address, the affected page state, and the originating MCE/GHES
+  record — context that is typically lost by the time a delayed crash
+  occurs.
+
+* High-availability clusters that rely on fast, deterministic node
+  failure for failover, and prefer an immediate panic over silent data
+  corruption propagating to replicas or persistent storage.
+
+* Kernel and platform developers reproducing hwpoison issues with
+  tools such as ``mce-inject`` or error-injection debugfs interfaces,
+  where panicking on the unrecoverable path makes regressions
+  immediately visible instead of surfacing as later, unrelated
+  failures.
+
+= =====================================================================
+0 Try to continue operation (default).
+1 Panic immediately.  If the ``panic`` sysctl is also non-zero then the
+  machine will be rebooted.
+= =====================================================================
+
+Example::
+
+     echo 1 > /proc/sys/vm/panic_on_unrecoverable_memory_failure
+
+
 percpu_pagelist_high_fraction
 =============================
 
Signature · 1 line
2.53.0-Meta