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 Closes: https://lore.kernel.org/all/arYskzbiaNzBR9MD@kunlun.suse.cz/ Signed-off-by: Amit Machhiwal --- 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)