* Re: [PATCH 2/2] ring-buffer: Do not check si_mem_available() during SYSTEM_BOOTING
2026-10-09 16:35 ` [PATCH 2/2] ring-buffer: Do not check si_mem_available() during SYSTEM_BOOTING Amit Machhiwal
@ 2026-10-09 16:45 ` sashiko-bot
2026-10-12 10:06 ` Michal Suchánek
` (2 subsequent siblings)
3 siblings, 0 replies; 11+ messages in thread
From: sashiko-bot @ 2026-10-09 16:45 UTC (permalink / raw)
To: Amit Machhiwal; +Cc: linux-trace-kernel, kvm
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] trace/ring_buffer: SMP boot failure due to premature si_mem_available() check
--
commit b21cf9115adfbd1fd082e26d147a363a37bad846
Author: Amit Machhiwal <amachhiw@linux.ibm.com>
ring-buffer: Do not check si_mem_available() during SYSTEM_BOOTING
This commit modifies early boot tracing allocation to bypass the
si_mem_available() check when system_state is SYSTEM_BOOTING. It aims to
prevent premature -ENOMEM failures on systems with deferred page
initialization.
Link: https://lore.kernel.org/all/arYskzbiaNzBR9MD@kunlun.suse.cz/
> diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
> index 04bb94c29f587..a9f82e2f8fad2 100644
> --- a/kernel/trace/ring_buffer.c
> +++ b/kernel/trace/ring_buffer.c
> @@ -2452,9 +2452,15 @@ static int __rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,
> * memory. It may not be accurate. But we don't care, we just want
> * to prevent doing any allocation when it is obvious that it is
> * not going to succeed.
> + *
> + * Skip this check during early boot: with CONFIG_DEFERRED_STRUCT_PAGE_INIT,
> + * NR_FREE_PAGES only reflects the initial non-deferred pool at this
> + * stage. si_mem_available() returns a false negative while actual
> + * allocations succeed by growing the zone on demand via
> + * deferred_grow_zone().
> */
> i = si_mem_available();
> - if (i < nr_pages)
> + if (system_state != SYSTEM_BOOTING && i < nr_pages)
[Severity: High]
Could this condition cause an SMP boot failure by re-enabling the check
too early?
The system transitions to SYSTEM_SCHEDULING in rest_init() before the init
thread starts. When the init thread runs kernel_init_freeable(), it sets up
secondary CPUs via smp_init() before deferred memory is initialized:
init/main.c:kernel_init_freeable() {
...
smp_init();
...
page_alloc_init_late();
...
}
When smp_init() brings up a CPU, it triggers the CPU hotplug callback
trace_rb_cpu_prepare(), which eventually calls __rb_allocate_pages().
Since system_state is now SYSTEM_SCHEDULING (not SYSTEM_BOOTING) when
__rb_allocate_pages() is called, the new check evaluates to true and
si_mem_available() executes. Because page_alloc_init_late() hasn't run yet,
deferred memory is still uninitialized, which means si_mem_available() will
return a false negative and abort the allocation with -ENOMEM.
Would this failure propagate through the CPU hotplug state machine and
abort the bring-up of secondary CPUs when CONFIG_DEFERRED_STRUCT_PAGE_INIT
is enabled?
> return -ENOMEM;
>
> /*
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261009163557.88467-1-amachhiw@linux.ibm.com?part=2
^ permalink raw reply [flat|nested] 11+ messages in thread* Re: [PATCH 2/2] ring-buffer: Do not check si_mem_available() during SYSTEM_BOOTING
2026-10-09 16:35 ` [PATCH 2/2] ring-buffer: Do not check si_mem_available() during SYSTEM_BOOTING Amit Machhiwal
2026-10-09 16:45 ` sashiko-bot
@ 2026-10-12 10:06 ` Michal Suchánek
2026-10-12 16:38 ` Vincent Donnefort
2026-10-16 13:42 ` [PATCH v2] ring-buffer: Do not check si_mem_available() before deferred init completes Amit Machhiwal
3 siblings, 0 replies; 11+ messages in thread
From: Michal Suchánek @ 2026-10-12 10:06 UTC (permalink / raw)
To: Amit Machhiwal
Cc: Steven Rostedt, Masami Hiramatsu, linux-trace-kernel,
linuxppc-dev, Mathieu Desnoyers, Madhavan Srinivasan,
Ritesh Harjani (IBM), Harsh Prateek Bora, linux-kernel, kvm,
kvm-ppc, Mark-PK Tsai, stable
On Fri, Oct 09, 2026 at 10:05:57PM +0530, Amit Machhiwal wrote:
> During early boot (early_trace_init() called from start_kernel()),
> tracing allocates initial ring buffers (temp_buffer, array_buffer, and
> snapshot_buffer) for CPU 0.
>
> Before attempting page allocation, __rb_allocate_pages() performs a
> heuristic check using si_mem_available() to return early with -ENOMEM if
> memory appears insufficient.
>
> However, on kernels built with CONFIG_DEFERRED_STRUCT_PAGE_INIT=y,
> defer_init() leaves only a single section per node (e.g. 16 MiB with 64
> KB pages) initialized up-front. On kernels with large static binary
> footprints (such as debug configurations enabling PAGE_OWNER,
> DEBUG_PAGEALLOC, KFENCE, or SLUB_DEBUG), the static kernel image and
> early core initialisations (SLUB caches, vmalloc, static ftrace records)
> consume virtually all managed pages in this initial pool.
>
> At T=0.000000, watermarks have not yet been established
> (totalreserve_pages = 0), so si_mem_available() returns the raw free
> page count (often 0-1 pages). When the snapshot buffer or global trace
> buffer attempts to allocate 2 sub-pages, si_mem_available() returns <
> nr_pages and prematurely aborts with -ENOMEM.
>
> This failure is false: if the page allocation were actually attempted
> via alloc_pages_node(), the page allocator would trigger
> deferred_grow_zone() on demand to initialise additional deferred memory
> sections. Checking si_mem_available() before attempting the allocation
> short-circuits this on-demand growth.
>
> Skip the si_mem_available() check when system_state == SYSTEM_BOOTING.
> Once the system transitions past early boot and page_alloc_init_late()
> initialises all deferred memory, si_mem_available() accurately reflects
> system-wide free memory and the check operates as intended for runtime
> allocations.
Tested-by: Michal Suchánek <msuchanek@suse.de>
>
> Fixes: 2a872fa4e9c8 ("ring-buffer: Check if memory is available before allocation")
> Cc: stable@vger.kernel.org
> Reported-by: Michal Suchánek <msuchanek@suse.de>
> Closes: https://lore.kernel.org/all/arYskzbiaNzBR9MD@kunlun.suse.cz/
> Signed-off-by: Amit Machhiwal <amachhiw@linux.ibm.com>
> ---
> kernel/trace/ring_buffer.c | 8 +++++++-
> 1 file changed, 7 insertions(+), 1 deletion(-)
>
> diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
> index 04bb94c29f58..a9f82e2f8fad 100644
> --- a/kernel/trace/ring_buffer.c
> +++ b/kernel/trace/ring_buffer.c
> @@ -2452,9 +2452,15 @@ static int __rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,
> * memory. It may not be accurate. But we don't care, we just want
> * to prevent doing any allocation when it is obvious that it is
> * not going to succeed.
> + *
> + * Skip this check during early boot: with CONFIG_DEFERRED_STRUCT_PAGE_INIT,
> + * NR_FREE_PAGES only reflects the initial non-deferred pool at this
> + * stage. si_mem_available() returns a false negative while actual
> + * allocations succeed by growing the zone on demand via
> + * deferred_grow_zone().
> */
> i = si_mem_available();
> - if (i < nr_pages)
> + if (system_state != SYSTEM_BOOTING && i < nr_pages)
> return -ENOMEM;
>
> /*
> --
> 2.54.0 (Apple Git-157)
>
>
^ permalink raw reply [flat|nested] 11+ messages in thread* Re: [PATCH 2/2] ring-buffer: Do not check si_mem_available() during SYSTEM_BOOTING
2026-10-09 16:35 ` [PATCH 2/2] ring-buffer: Do not check si_mem_available() during SYSTEM_BOOTING Amit Machhiwal
2026-10-09 16:45 ` sashiko-bot
2026-10-12 10:06 ` Michal Suchánek
@ 2026-10-12 16:38 ` Vincent Donnefort
2026-10-16 13:33 ` Amit Machhiwal
2026-10-16 13:42 ` [PATCH v2] ring-buffer: Do not check si_mem_available() before deferred init completes Amit Machhiwal
3 siblings, 1 reply; 11+ messages in thread
From: Vincent Donnefort @ 2026-10-12 16:38 UTC (permalink / raw)
To: Amit Machhiwal
Cc: Steven Rostedt, Masami Hiramatsu, linux-trace-kernel,
linuxppc-dev, Michal Suchánek, Mathieu Desnoyers,
Madhavan Srinivasan, Ritesh Harjani (IBM), Harsh Prateek Bora,
linux-kernel, kvm, kvm-ppc, Mark-PK Tsai, stable
On Fri, Oct 09, 2026 at 10:05:57PM +0530, Amit Machhiwal wrote:
> During early boot (early_trace_init() called from start_kernel()),
> tracing allocates initial ring buffers (temp_buffer, array_buffer, and
> snapshot_buffer) for CPU 0.
>
> Before attempting page allocation, __rb_allocate_pages() performs a
> heuristic check using si_mem_available() to return early with -ENOMEM if
> memory appears insufficient.
>
> However, on kernels built with CONFIG_DEFERRED_STRUCT_PAGE_INIT=y,
> defer_init() leaves only a single section per node (e.g. 16 MiB with 64
> KB pages) initialized up-front. On kernels with large static binary
> footprints (such as debug configurations enabling PAGE_OWNER,
> DEBUG_PAGEALLOC, KFENCE, or SLUB_DEBUG), the static kernel image and
> early core initialisations (SLUB caches, vmalloc, static ftrace records)
> consume virtually all managed pages in this initial pool.
>
> At T=0.000000, watermarks have not yet been established
> (totalreserve_pages = 0), so si_mem_available() returns the raw free
> page count (often 0-1 pages). When the snapshot buffer or global trace
> buffer attempts to allocate 2 sub-pages, si_mem_available() returns <
> nr_pages and prematurely aborts with -ENOMEM.
>
> This failure is false: if the page allocation were actually attempted
> via alloc_pages_node(), the page allocator would trigger
> deferred_grow_zone() on demand to initialise additional deferred memory
> sections. Checking si_mem_available() before attempting the allocation
> short-circuits this on-demand growth.
>
> Skip the si_mem_available() check when system_state == SYSTEM_BOOTING.
> Once the system transitions past early boot and page_alloc_init_late()
> initialises all deferred memory, si_mem_available() accurately reflects
> system-wide free memory and the check operates as intended for runtime
> allocations.
>
> Fixes: 2a872fa4e9c8 ("ring-buffer: Check if memory is available before allocation")
> Cc: stable@vger.kernel.org
> Reported-by: Michal Suchánek <msuchanek@suse.de>
> Closes: https://lore.kernel.org/all/arYskzbiaNzBR9MD@kunlun.suse.cz/
> Signed-off-by: Amit Machhiwal <amachhiw@linux.ibm.com>
> ---
> kernel/trace/ring_buffer.c | 8 +++++++-
> 1 file changed, 7 insertions(+), 1 deletion(-)
>
> diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
> index 04bb94c29f58..a9f82e2f8fad 100644
> --- a/kernel/trace/ring_buffer.c
> +++ b/kernel/trace/ring_buffer.c
> @@ -2452,9 +2452,15 @@ static int __rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,
> * memory. It may not be accurate. But we don't care, we just want
> * to prevent doing any allocation when it is obvious that it is
> * not going to succeed.
> + *
> + * Skip this check during early boot: with CONFIG_DEFERRED_STRUCT_PAGE_INIT,
> + * NR_FREE_PAGES only reflects the initial non-deferred pool at this
> + * stage. si_mem_available() returns a false negative while actual
> + * allocations succeed by growing the zone on demand via
> + * deferred_grow_zone().
As Sashiko pointed-out, if si_mem_available() is only ready after
page_alloc_init_late() when CONFIG_DEFERRED_STRUCT_PAGE_INIT, then checking for
system_state >= SYSTEM_FREEING_INITMEM might be more correct.
Also I wonder if we don't want to guard with CONFIG_DEFERRED_STRUCT_PAGE_INIT,
to keep the verification when CONFIG_DEFERRED_STRUCT_PAGE_INIT is unset.
> */
> i = si_mem_available();
> - if (i < nr_pages)
> + if (system_state != SYSTEM_BOOTING && i < nr_pages)
> return -ENOMEM;
>
> /*
> --
> 2.54.0 (Apple Git-157)
>
>
--
Vincent
^ permalink raw reply [flat|nested] 11+ messages in thread* Re: [PATCH 2/2] ring-buffer: Do not check si_mem_available() during SYSTEM_BOOTING
2026-10-12 16:38 ` Vincent Donnefort
@ 2026-10-16 13:33 ` Amit Machhiwal
0 siblings, 0 replies; 11+ messages in thread
From: Amit Machhiwal @ 2026-10-16 13:33 UTC (permalink / raw)
To: Vincent Donnefort
Cc: Amit Machhiwal, Steven Rostedt, Masami Hiramatsu,
linux-trace-kernel, linuxppc-dev, Michal Suchánek,
Mathieu Desnoyers, Madhavan Srinivasan, Ritesh Harjani (IBM),
Harsh Prateek Bora, linux-kernel, kvm, kvm-ppc, Mark-PK Tsai,
stable
Hi Vincent,
Thanks for reviewing this patch.
On 2026/10/12 05:38 PM, Vincent Donnefort wrote:
> On Fri, Oct 09, 2026 at 10:05:57PM +0530, Amit Machhiwal wrote:
> > During early boot (early_trace_init() called from start_kernel()),
> > tracing allocates initial ring buffers (temp_buffer, array_buffer, and
> > snapshot_buffer) for CPU 0.
> >
> > Before attempting page allocation, __rb_allocate_pages() performs a
> > heuristic check using si_mem_available() to return early with -ENOMEM if
> > memory appears insufficient.
> >
> > However, on kernels built with CONFIG_DEFERRED_STRUCT_PAGE_INIT=y,
> > defer_init() leaves only a single section per node (e.g. 16 MiB with 64
> > KB pages) initialized up-front. On kernels with large static binary
> > footprints (such as debug configurations enabling PAGE_OWNER,
> > DEBUG_PAGEALLOC, KFENCE, or SLUB_DEBUG), the static kernel image and
> > early core initialisations (SLUB caches, vmalloc, static ftrace records)
> > consume virtually all managed pages in this initial pool.
> >
> > At T=0.000000, watermarks have not yet been established
> > (totalreserve_pages = 0), so si_mem_available() returns the raw free
> > page count (often 0-1 pages). When the snapshot buffer or global trace
> > buffer attempts to allocate 2 sub-pages, si_mem_available() returns <
> > nr_pages and prematurely aborts with -ENOMEM.
> >
> > This failure is false: if the page allocation were actually attempted
> > via alloc_pages_node(), the page allocator would trigger
> > deferred_grow_zone() on demand to initialise additional deferred memory
> > sections. Checking si_mem_available() before attempting the allocation
> > short-circuits this on-demand growth.
> >
> > Skip the si_mem_available() check when system_state == SYSTEM_BOOTING.
> > Once the system transitions past early boot and page_alloc_init_late()
> > initialises all deferred memory, si_mem_available() accurately reflects
> > system-wide free memory and the check operates as intended for runtime
> > allocations.
> >
> > Fixes: 2a872fa4e9c8 ("ring-buffer: Check if memory is available before allocation")
> > Cc: stable@vger.kernel.org
> > Reported-by: Michal Suchánek <msuchanek@suse.de>
> > Closes: https://lore.kernel.org/all/arYskzbiaNzBR9MD@kunlun.suse.cz/
> > Signed-off-by: Amit Machhiwal <amachhiw@linux.ibm.com>
> > ---
> > kernel/trace/ring_buffer.c | 8 +++++++-
> > 1 file changed, 7 insertions(+), 1 deletion(-)
> >
> > diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
> > index 04bb94c29f58..a9f82e2f8fad 100644
> > --- a/kernel/trace/ring_buffer.c
> > +++ b/kernel/trace/ring_buffer.c
> > @@ -2452,9 +2452,15 @@ static int __rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,
> > * memory. It may not be accurate. But we don't care, we just want
> > * to prevent doing any allocation when it is obvious that it is
> > * not going to succeed.
> > + *
> > + * Skip this check during early boot: with CONFIG_DEFERRED_STRUCT_PAGE_INIT,
> > + * NR_FREE_PAGES only reflects the initial non-deferred pool at this
> > + * stage. si_mem_available() returns a false negative while actual
> > + * allocations succeed by growing the zone on demand via
> > + * deferred_grow_zone().
>
> As Sashiko pointed-out, if si_mem_available() is only ready after
> page_alloc_init_late() when CONFIG_DEFERRED_STRUCT_PAGE_INIT, then checking for
> system_state >= SYSTEM_FREEING_INITMEM might be more correct.
>
> Also I wonder if we don't want to guard with CONFIG_DEFERRED_STRUCT_PAGE_INIT,
> to keep the verification when CONFIG_DEFERRED_STRUCT_PAGE_INIT is unset.
Both suggestions adopted in v2 — using system_state >= SYSTEM_FREEING_INITMEM
and wrapping in #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT.
Thanks,
Amit
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH v2] ring-buffer: Do not check si_mem_available() before deferred init completes
2026-10-09 16:35 ` [PATCH 2/2] ring-buffer: Do not check si_mem_available() during SYSTEM_BOOTING Amit Machhiwal
` (2 preceding siblings ...)
2026-10-12 16:38 ` Vincent Donnefort
@ 2026-10-16 13:42 ` Amit Machhiwal
2026-10-16 13:52 ` sashiko-bot
3 siblings, 1 reply; 11+ messages in thread
From: Amit Machhiwal @ 2026-10-16 13:42 UTC (permalink / raw)
To: Steven Rostedt, Masami Hiramatsu, linux-trace-kernel,
linuxppc-dev
Cc: Amit Machhiwal, Michal Suchánek, Vincent Donnefort,
Mathieu Desnoyers, Madhavan Srinivasan, Ritesh Harjani (IBM),
Harsh Prateek Bora, linux-kernel, kvm, kvm-ppc, stable
During early boot (early_trace_init() called from start_kernel()),
tracing allocates initial ring buffers (temp_buffer, array_buffer, and
snapshot_buffer) for CPU 0. Later, as secondary CPUs come online during
smp_init(), each CPU's ring buffer is allocated via trace_rb_cpu_prepare().
Before attempting page allocation, __rb_allocate_pages() performs a
heuristic check using si_mem_available() to return early with -ENOMEM if
memory appears insufficient.
However, on kernels built with CONFIG_DEFERRED_STRUCT_PAGE_INIT=y,
NR_FREE_PAGES only reflects the initial non-deferred pool across the entire
period from early_trace_init() through smp_init(). defer_init() leaves
only a single section per node (e.g. 16 MiB with 64 KB pages) initialized
up-front, and on kernels with large static binary footprints (debug
configurations enabling PAGE_OWNER, DEBUG_PAGEALLOC, KFENCE, or SLUB_DEBUG),
early core initialisations (SLUB caches, vmalloc, static ftrace records)
consume virtually all managed pages in this pool.
si_mem_available() therefore returns a false negative (often 0-1 pages)
across both SYSTEM_BOOTING (for the initial CPU 0 buffers) and
SYSTEM_SCHEDULING (for secondary CPU buffers via trace_rb_cpu_prepare()),
causing __rb_allocate_pages() to prematurely abort with -ENOMEM.
This failure is false: the buddy allocator is designed to replenish
ZONE_NORMAL on demand via deferred_grow_zone() when an actual allocation
is attempted. Checking si_mem_available() before calling alloc_pages_node()
short-circuits this on-demand growth entirely.
deferred_grow_zone() is only permanently disabled after page_alloc_init_late()
completes (it spawns per-node kthreads and blocks until done), which happens
inside kernel_init_freeable() — before system_state is set to
SYSTEM_FREEING_INITMEM. Skip the si_mem_available() check until
SYSTEM_FREEING_INITMEM, at which point all deferred pages are initialized
and si_mem_available() is accurate.
Wrap the guard in #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT so that on kernels
without deferred init the original check is preserved unchanged.
Fixes: 2a872fa4e9c8 ("ring-buffer: Check if memory is available before allocation")
Cc: stable@vger.kernel.org
Reported-by: Michal Suchánek <msuchanek@suse.de>
Closes: https://lore.kernel.org/all/arYskzbiaNzBR9MD@kunlun.suse.cz/
Link: https://lore.kernel.org/all/arYskzbiaNzBR9MD@kunlun.suse.cz/
Signed-off-by: Amit Machhiwal <amachhiw@linux.ibm.com>
---
Changes since v1:
- Extend the guard to cover SYSTEM_SCHEDULING as well: smp_init() calls
trace_rb_cpu_prepare() -> __rb_allocate_pages() before page_alloc_init_late()
completes, so the false negative window spans both SYSTEM_BOOTING and
SYSTEM_SCHEDULING. Use system_state >= SYSTEM_FREEING_INITMEM as the correct
boundary. (Sashiko, Vincent Donnefort)
- Wrap in #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT to preserve the original
check unchanged on non-deferred kernels. (Vincent Donnefort)
- Drop Tested-by: guard condition changed, requesting fresh test.
kernel/trace/ring_buffer.c | 14 ++++++++++++++
1 file changed, 14 insertions(+)
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 04bb94c29f58..aa877a272c89 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -2452,10 +2452,24 @@ static int __rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,
* memory. It may not be accurate. But we don't care, we just want
* to prevent doing any allocation when it is obvious that it is
* not going to succeed.
+ *
+ * With CONFIG_DEFERRED_STRUCT_PAGE_INIT, NR_FREE_PAGES only reflects
+ * the initial non-deferred pool during early boot and throughout SMP
+ * bring-up (smp_init() runs before page_alloc_init_late() completes
+ * deferred initialization). si_mem_available() returns a false negative
+ * across this entire window while actual allocations succeed by growing
+ * the zone on demand via deferred_grow_zone(). Only re-enable the check
+ * from SYSTEM_FREEING_INITMEM onward, after page_alloc_init_late() has
+ * finished and si_mem_available() is accurate.
*/
i = si_mem_available();
+#ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
+ if (system_state >= SYSTEM_FREEING_INITMEM && i < nr_pages)
+ return -ENOMEM;
+#else
if (i < nr_pages)
return -ENOMEM;
+#endif
/*
* If a user thread allocates too much, and si_mem_available()
base-commit: 2f2f7eeef8b0a1a9b9ca998231419873ccae8d4e
--
2.54.0 (Apple Git-157)
^ permalink raw reply related [flat|nested] 11+ messages in thread* Re: [PATCH v2] ring-buffer: Do not check si_mem_available() before deferred init completes
2026-10-16 13:42 ` [PATCH v2] ring-buffer: Do not check si_mem_available() before deferred init completes Amit Machhiwal
@ 2026-10-16 13:52 ` sashiko-bot
0 siblings, 0 replies; 11+ messages in thread
From: sashiko-bot @ 2026-10-16 13:52 UTC (permalink / raw)
To: Amit Machhiwal, linux-trace-kernel; +Cc: kvm
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] mm/trace: OOM panic via GFP_KERNEL metadata allocations
--
commit 5164ff519a3f7b78b5e2f07fc662c8cbbef0267e
Author: Amit Machhiwal <amachhiw@linux.ibm.com>
ring-buffer: Do not check si_mem_available() before deferred init completes
During early boot, si_mem_available() can return a false negative on kernels
built with CONFIG_DEFERRED_STRUCT_PAGE_INIT. Skip the si_mem_available()
check until SYSTEM_FREEING_INITMEM, when deferred pages are fully
initialized.
Link: https://lore.kernel.org/all/arYskzbiaNzBR9MD@kunlun.suse.cz/
> diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
> index 04bb94c29f587..aa877a272c894 100644
> --- a/kernel/trace/ring_buffer.c
> +++ b/kernel/trace/ring_buffer.c
> @@ -2452,10 +2452,24 @@ static int __rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,
> * memory. It may not be accurate. But we don't care, we just want
> * to prevent doing any allocation when it is obvious that it is
> * not going to succeed.
> + *
> + * With CONFIG_DEFERRED_STRUCT_PAGE_INIT, NR_FREE_PAGES only reflects
> + * the initial non-deferred pool during early boot and throughout SMP
> + * bring-up (smp_init() runs before page_alloc_init_late() completes
> + * deferred initialization). si_mem_available() returns a false negative
> + * across this entire window while actual allocations succeed by growing
> + * the zone on demand via deferred_grow_zone(). Only re-enable the check
> + * from SYSTEM_FREEING_INITMEM onward, after page_alloc_init_late() has
> + * finished and si_mem_available() is accurate.
> */
> i = si_mem_available();
> +#ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
> + if (system_state >= SYSTEM_FREEING_INITMEM && i < nr_pages)
> + return -ENOMEM;
[Severity: High]
Does bypassing the si_mem_available() check during early boot expose the
kernel to an out of memory panic?
By skipping this check, __rb_allocate_pages() will proceed to the allocation
loop even if the requested nr_pages exceeds available memory. The loop
contains metadata allocations via alloc_cpu_page():
kernel/trace/ring_buffer.c:__rb_allocate_pages() {
...
for (i = 0; i < nr_pages; i++) {
bpage = alloc_cpu_page(cpu_buffer->cpu);
if (!bpage)
goto free_pages;
...
}
alloc_cpu_page() uses GFP_KERNEL without __GFP_RETRY_MAYFAIL:
#define alloc_cpu_page(cpu) (struct buffer_page *) \
kzalloc_node(ALIGN(sizeof(struct buffer_page), \
cache_line_size()), GFP_KERNEL, cpu_to_node(cpu))
If the loop exhausts the buddy allocator, won't the slab allocator's
subsequent attempt to allocate a new page for the metadata struct using
GFP_KERNEL trigger a kernel panic during early boot?
> +#else
> if (i < nr_pages)
> return -ENOMEM;
> +#endif
>
> /*
> * If a user thread allocates too much, and si_mem_available()
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261016134247.70722-1-amachhiw@linux.ibm.com?part=1
^ permalink raw reply [flat|nested] 11+ messages in thread