Skip to contentSkip to conversation

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

PATCH Superseded Breno Leitao 2 participants 11 messages Mar 31 – Apr 13

Subsystems (4)

v2 of 10 Superseded Latest is v10 →

lore
Share & tools
lore
#0 lore raw

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

When the memory failure handler encounters an in-use kernel page that it cannot recover (slab, page tables, kernel stacks, vmalloc, etc.), it currently logs the error as "Ignored" and continues operation.

This leaves corrupted data accessible to the kernel, which will inevitably cause either silent data corruption or a delayed crash when the poisoned memory is next accessed.

This is a common problem on large fleets. We frequently observe multi-bit ECC errors hitting kernel slab pages, where memory_failure() fails to recover them and the system crashes later at an unrelated code path, making root cause analysis unnecessarily difficult.

Here is one specific example from production on an arm64 server: a multi-bit ECC error hit a dentry cache slab page, memory_failure() failed to recover it (slab pages are not supported by the hwpoison recovery mechanism), and 67 seconds later d_lookup() accessed the poisoned cache line causing a synchronous external abort:

    [88690.479680] [Hardware Error]: error_type: 3, multi-bit ECC
    [88690.498473] Memory failure: 0x40272d: unhandlable page.
    [88690.498619] Memory failure: 0x40272d: recovery action for
                   get hwpoison page: Ignored
    ...
    [88757.847126] Internal error: synchronous external abort:
                   0000000096000410 [#1] SMP
    [88758.061075] pc : d_lookup+0x5c/0x220

This series adds a new sysctl vm.panic_on_unrecoverable_memory_failure (default 0) that, when enabled, panics immediately on unrecoverable memory failures. This provides a clean crash dump at the time of the error, which is far more useful for diagnosis than a random crash later at an unrelated code path.

This also categorizes reserved pages as MF_MSG_KERNEL, and panics on unknown page types (MF_MSG_UNKNOWN), so all unrecoverable failure cases are covered.

---
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]

---
Breno Leitao (3):
mm/memory-failure: report MF_MSG_KERNEL for reserved pages mm/memory-failure: add panic_on_unrecoverable_memory_failure sysctl
Documentation: document panic_on_unrecoverable_memory_failure sysctl

 Documentation/admin-guide/sysctl/vm.rst | 27 +++++++++++++++++++++++++++
 mm/memory-failure.c                     | 22 +++++++++++++++++++++-
 2 files changed, 48 insertions(+), 1 deletion(-)

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

Best regards,

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

PATCH v2 1/3 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 by the panic_on_unrecoverable_memory_failure mechanism.

---
 mm/memory-failure.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)
mm/memory-failure.c +5 -1
index ee42d4361309..6ff80e01b91a 100644
@@ -2432,7 +2432,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 (PageReserved(p))
+			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.52.0
maintainer
#2 lore raw

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

Quoted 16 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 by the panic_on_unrecoverable_memory_failure mechanism.

---
 mm/memory-failure.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)
mm/memory-failure.c +0 -0
index ee42d4361309..6ff80e01b91a 100644

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

Quoted 6 lines
mm/memory-failure.c +2 -1
@@ -2432,7 +2432,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 (PageReserved(p))
+			res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);

Is it safe or common to check page flags without holding extra refcnt?

Thanks.
.

#3 lore raw

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

Quoted 12 lines · Miaohe Lin
Quoted 11 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 by the panic_on_unrecoverable_memory_failure mechanism.

---
 mm/memory-failure.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)
Quoted 13 lines

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

Quoted 11 lines
mm/memory-failure.c +2 -1
index ee42d4361309..6ff80e01b91a 100644
@@ -2432,7 +2432,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 (PageReserved(p))
+			res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);

Is it safe or common to check page flags without holding extra refcnt?

Yes, this is safe. At this point the page has HWPoison set, preventing reallocation.

PageReserved is an atomic flag test on struct page memory that's always valid for online PFNs.

Reserved pages are inherently stable (kernel text, firmware, etc.) and don't change status dynamically.

This follows the same pattern as the existing is_free_buddy_page(p) check a few lines above, which also reads page state without an extra refcount.

The result is only used for a detailed classification, so even a theoretical race would not be a bad issue.

maintainer
#4 lore raw

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

Quoted 34 lines · Breno Leitao
Quoted 12 lines · Miaohe Lin
Quoted 11 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 by the panic_on_unrecoverable_memory_failure mechanism.

---
 mm/memory-failure.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)
Quoted 13 lines

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

Quoted 11 lines
mm/memory-failure.c +2 -1
index ee42d4361309..6ff80e01b91a 100644
@@ -2432,7 +2432,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 (PageReserved(p))
+			res = action_result(pfn, MF_MSG_KERNEL, MF_IGNORED);

Is it safe or common to check page flags without holding extra refcnt?

Yes, this is safe. At this point the page has HWPoison set, preventing reallocation.

PageReserved is an atomic flag test on struct page memory that's always valid for online PFNs.

Quoted 6 lines

Reserved pages are inherently stable (kernel text, firmware, etc.) and don't change status dynamically.

This follows the same pattern as the existing is_free_buddy_page(p) check a few lines above, which also reads page state without an extra refcount.

Got it. Thanks for your explanation.

Thanks.
.

#5 lore raw

PATCH v2 2/3 mm/memory-failure: add panic_on_unrecoverable_memory_failure sysctl

In reply to Breno Leitao

Add a sysctl that allows the system to panic when an unrecoverable memory failure is detected. This covers kernel pages, high-order kernel pages, and unknown page types that cannot be recovered.

---
 mm/memory-failure.c | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
mm/memory-failure.c +16 -0
index 6ff80e01b91a..d0d911c54ff1 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,
 	}
 };
 
@@ -1298,6 +1309,11 @@ 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 (sysctl_panic_on_unrecoverable_mf && result == MF_IGNORED &&
+	    (type == MF_MSG_KERNEL || type == MF_MSG_KERNEL_HIGH_ORDER ||
+	     type == MF_MSG_UNKNOWN))
+		panic("Memory failure: %#lx: unrecoverable page", pfn);
+
 	return (result == MF_RECOVERED || result == MF_DELAYED) ? 0 : -EBUSY;
 }
 
Signature · 1 line
2.52.0
maintainer
#6 lore raw

Re: [PATCH v2 2/3] mm/memory-failure: add panic_on_unrecoverable_memory_failure sysctl

Quoted 39 lines · Breno Leitao

Add a sysctl that allows the system to panic when an unrecoverable memory failure is detected. This covers kernel pages, high-order kernel pages, and unknown page types that cannot be recovered.

---
 mm/memory-failure.c | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
mm/memory-failure.c +11 -0
index 6ff80e01b91a..d0d911c54ff1 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,
 	}
 };
 

mm/memory-failure.c static int action_result(unsigned long pfn, enum mf_action_page_type type, · line 1315

Quoted 7 lines
mm/memory-failure.c +4 -0
@@ -1298,6 +1309,11 @@ 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 (sysctl_panic_on_unrecoverable_mf && result == MF_IGNORED &&
+	    (type == MF_MSG_KERNEL || type == MF_MSG_KERNEL_HIGH_ORDER ||
+	     type == MF_MSG_UNKNOWN))
+		panic("Memory failure: %#lx: unrecoverable page", pfn);

Will it be better to add a helper here?

Thanks.
.

#7 lore raw

Re: [PATCH v2 2/3] mm/memory-failure: add panic_on_unrecoverable_memory_failure sysctl

Quoted 7 lines · Miaohe Lin

Review

Quoted 4 lines · Breno Leitao
(quoted diff) +4 -0
+	if (sysctl_panic_on_unrecoverable_mf && result == MF_IGNORED &&
+	    (type == MF_MSG_KERNEL || type == MF_MSG_KERNEL_HIGH_ORDER ||
+	     type == MF_MSG_UNKNOWN))
+		panic("Memory failure: %#lx: unrecoverable page", pfn);

Will it be better to add a helper here?

Yes, a helper would make things easier to read and digest. Thanks for the feedback. This is what I have in mind:

commit 36d5b3cbbe6d6abfe3296b7b21135a5f01e743eb

Author: Breno Leitao <[email protected]>
Date:   Mon Mar 23 08:00:29 2026 -0700

mm/memory-failure: add panic_on_unrecoverable_memory_failure sysctl

Add a sysctl that allows the system to panic when an unrecoverable memory failure is detected. This covers kernel pages, high-order kernel pages, and unknown page types that cannot be recovered.

mm/memory-failure.c +24 -0
index 6ff80e01b91a4..a29b6688fe2d3 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,16 @@ static void update_per_node_mf_stats(unsigned long pfn,
 	++mf_stats->total;
 }
 
+static bool is_unrecoverable_memory_failure(enum mf_action_page_type type,
+					    enum mf_result result)
+{
+	return sysctl_panic_on_unrecoverable_mf &&
+	       result == MF_IGNORED &&
+	       (type == MF_MSG_KERNEL ||
+		type == MF_MSG_KERNEL_HIGH_ORDER ||
+		type == MF_MSG_UNKNOWN);
+}
+
 /*
  * "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 +1319,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 (is_unrecoverable_memory_failure(type, result))
+		panic("Memory failure: %#lx: unrecoverable page", pfn);
+
 	return (result == MF_RECOVERED || result == MF_DELAYED) ? 0 : -EBUSY;
 }
 
maintainer
#8 lore raw

Re: [PATCH v2 2/3] mm/memory-failure: add panic_on_unrecoverable_memory_failure sysctl

Quoted 54 lines · Breno Leitao
Quoted 7 lines · Miaohe Lin

Review

Quoted 4 lines · Breno Leitao
(quoted diff) +4 -0
+	if (sysctl_panic_on_unrecoverable_mf && result == MF_IGNORED &&
+	    (type == MF_MSG_KERNEL || type == MF_MSG_KERNEL_HIGH_ORDER ||
+	     type == MF_MSG_UNKNOWN))
+		panic("Memory failure: %#lx: unrecoverable page", pfn);

Will it be better to add a helper here?

Yes, a helper would make things easier to read and digest. Thanks for the feedback. This is what I have in mind:

commit 36d5b3cbbe6d6abfe3296b7b21135a5f01e743eb

Author: Breno Leitao <[email protected]>
Date:   Mon Mar 23 08:00:29 2026 -0700

mm/memory-failure: add panic_on_unrecoverable_memory_failure sysctl

Add a sysctl that allows the system to panic when an unrecoverable memory failure is detected. This covers kernel pages, high-order kernel pages, and unknown page types that cannot be recovered.

mm/memory-failure.c +11 -0
index 6ff80e01b91a4..a29b6688fe2d3 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,
 	}
 };
 

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

Quoted 5 lines
mm/memory-failure.c +2 -0
@@ -1281,6 +1292,16 @@ static void update_per_node_mf_stats(unsigned long pfn,
 	++mf_stats->total;
 }
 
+static bool is_unrecoverable_memory_failure(enum mf_action_page_type type,
+					    enum mf_result result)

Thanks for your update.

Quoted 12 lines
mm/memory-failure.c +8 -0
+{
+	return sysctl_panic_on_unrecoverable_mf &&
+	       result == MF_IGNORED &&
+	       (type == MF_MSG_KERNEL ||
+		type == MF_MSG_KERNEL_HIGH_ORDER ||
+		type == MF_MSG_UNKNOWN);
+}
+
 /*
  * "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().

mm/memory-failure.c static int action_result(unsigned long pfn, enum mf_action_page_type type, · line 1322

Quoted 4 lines
mm/memory-failure.c +1 -0
@@ -1298,6 +1319,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 (is_unrecoverable_memory_failure(type, result))

Would it be better to name it as panic_on_unrecoverable_mf() or something like it? This function determines whether panic on the specified memory error.

Thanks.
.

#9 lore raw

Re: [PATCH v2 2/3] mm/memory-failure: add panic_on_unrecoverable_memory_failure sysctl

Quoted 18 lines · Miaohe Lin
Quoted 17 lines · Breno Leitao
Quoted 1 line · Miaohe Lin

On 2026/3/31 19:00, Breno Leitao wrote:

mm/memory-failure.c +8 -0
+{
+	return sysctl_panic_on_unrecoverable_mf &&
+	       result == MF_IGNORED &&
+	       (type == MF_MSG_KERNEL ||
+		type == MF_MSG_KERNEL_HIGH_ORDER ||
+		type == MF_MSG_UNKNOWN);
+}
+
 /*
  * "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 +1319,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]);
 
Quoted 4 lines

mm/memory-failure.c static int action_result(unsigned long pfn, enum mf_action_page_type type, · line 1322

Quoted 1 line
mm/memory-failure.c +1 -0
+	if (is_unrecoverable_memory_failure(type, result))

Would it be better to name it as panic_on_unrecoverable_mf() or something like it? This function determines whether panic on the specified memory error.

Acknowledged. I'll rename the function to panic_on_unrecoverable_mf() in the next version.

After extensive testing, I'm considering adding a boot-time configuration parameter for this feature, similar to BOOTPARAM_WQ_STALL_PANIC, BOOTPARAM_SOFTLOCKUP_PANIC, BOOTPARAM_HARDLOCKUP_PANIC, and BOOTPARAM_HUNG_TASK_PANIC. This would make the panic behavior available from early boot without requiring runtime sysctl configuration, ensuring the system crashes on unrecoverable ECC errors rather than ignoring them.

I'll prepare and send the updated version shortly.

Thanks for your feedback,
--breno

#10 lore raw

PATCH v2 3/3 Documentation: document panic_on_unrecoverable_memory_failure sysctl

In reply to Breno Leitao

Document the new vm.panic_on_unrecoverable_memory_failure sysctl in the admin guide, following the same format as panic_on_unrecovered_nmi.

---
 Documentation/admin-guide/sysctl/vm.rst | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
Documentation/admin-guide/sysctl/vm.rst +27 -0
index 97e12359775c..a811f503bca6 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,32 @@ 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 an in-use 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.
+
+Pages that reach this path include slab objects (dentry cache, inode
+cache, etc.), page tables, kernel stacks, and other kernel allocations
+that lack the reverse mapping needed to isolate all references.
+
+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.
+
+= =====================================================================
+0 Try to continue operation (default).
+1 Panic immediately.  If the ``panic`` sysctl is also non-zero then the
+  machine will be rebooted.
+= =====================================================================
+
+
 percpu_pagelist_high_fraction
 =============================
 
Signature · 1 line
2.52.0