CVE-2026-23138 in Linux
Summary
by MITRE • 02/14/2026
In the Linux kernel, the following vulnerability has been resolved:
tracing: Add recursion protection in kernel stack trace recording
A bug was reported about an infinite recursion caused by tracing the rcu events with the kernel stack trace trigger enabled. The stack trace code called back into RCU which then called the stack trace again.
Expand the ftrace recursion protection to add a set of bits to protect events from recursion. Each bit represents the context that the event is in (normal, softirq, interrupt and NMI).
Have the stack trace code use the interrupt context to protect against recursion.
Note, the bug showed an issue in both the RCU code as well as the tracing stacktrace code. This only handles the tracing stack trace side of the bug. The RCU fix will be handled separately.
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 03/18/2026
The vulnerability CVE-2026-23138 addresses a critical recursion issue within the Linux kernel's tracing subsystem that could lead to system instability and potential denial of service conditions. This flaw specifically manifests when tracing RCU (Read-Copy-Update) events with kernel stack trace triggers enabled, creating a dangerous feedback loop where the stack trace recording mechanism invokes RCU functions, which in turn trigger the stack trace mechanism again, resulting in infinite recursion. The issue represents a fundamental design flaw in the kernel's event handling and tracing infrastructure, where the boundaries between different kernel execution contexts were not properly enforced during trace operations.
The technical implementation of this vulnerability stems from insufficient recursion protection mechanisms within the ftrace subsystem, which is responsible for kernel function tracing and debugging. The original ftrace recursion protection was inadequate for handling complex scenarios involving RCU operations, as it did not account for the multiple execution contexts that can occur during kernel operation. The fix implements a sophisticated bit-based protection system that assigns specific bits to represent different kernel contexts including normal execution, softirq processing, interrupt handling, and NMI (Non-Maskable Interrupt) processing. This approach aligns with the CWE-674 principle of "Uncontrolled Recursion" and addresses the fundamental flaw in the kernel's context management during tracing operations.
The operational impact of this vulnerability is significant as it can cause system crashes, infinite loops, and complete system lockups when RCU tracing is enabled in environments where such tracing is actively used. Systems running with kernel stack trace triggers enabled for debugging or monitoring purposes are particularly at risk, as the infinite recursion can bring the entire system to a halt. The vulnerability affects the kernel's ability to maintain stable operation during tracing events, potentially compromising system reliability in production environments where detailed kernel tracing is required for performance monitoring or debugging purposes. This issue directly impacts the kernel's fault tolerance and operational stability under tracing workloads.
The mitigation strategy implemented in this fix expands the existing ftrace recursion protection mechanisms to include comprehensive context-aware protection for different kernel execution modes. By adding specific bits to represent each execution context and utilizing interrupt context protection for stack trace code, the solution prevents the recursive call patterns that led to the vulnerability. This approach follows established security practices for preventing infinite recursion in kernel space and aligns with ATT&CK technique T1489, which addresses system resource hijacking through kernel-level recursion attacks. The fix specifically addresses the tracing stack trace side of the issue while acknowledging that the underlying RCU code requires separate remediation, demonstrating a targeted approach to vulnerability resolution that maintains system stability while addressing the root cause of the recursion problem.