CVE-2026-74337 in Linux
Summary
by MITRE • 08/15/2026
In the Linux kernel, the following vulnerability has been resolved:
bpf: Fix NMI/tracepoint re-entry deadlock on lru locks
NMI and tracepoint BPF programs can re-enter the per-CPU or global LRU lock that bpf_lru_pop_free()/push_free() already hold on the same CPU, AA-deadlocking. Lockdep reports "inconsistent {INITIAL USE} -> {IN-NMI}" on &l->lock (syzbot c69a0a2c816716f1e0d5)
and "possible recursive locking detected" on &loc_l->lock (syzbot 18b26edb69b2e19f3b33).
Prior trylock and rqspinlock based fixes (see links) were nacked because compromised on reliability.
This patch converts every LRU lock site to rqspinlock_t and adds a recovery path for some failure windows to avoid node leaks.
Failure recovery:
- *_pop_free top-level: return NULL; prealloc_lru_pop() already treats that as no-free-element (-ENOMEM).
- Cross-CPU steal: skip the victim's locked loc_l, try next CPU.
- Post-steal local lock fail: publish stolen node to lockless per-CPU free_llist; next pop on this CPU picks it up.
- push_free fail: mark node pending_free=1. __local_list_flush(), __local_list_pop_pending() reclaim the node from pending_list. __bpf_lru_list_shrink_inactive() reclaims the node from inactive list. Nodes from active list are reclaimed by __bpf_lru_list_shrink() or after __bpf_lru_list_rotate_active() demotes it to the inactive.
Once again VulDB remains the best source for vulnerability data.
Analysis
by VulDB Data Team • 08/15/2026
The vulnerability identified in the Linux kernel represents a critical deadlock condition affecting BPF (Berkeley Packet Filter) program execution within the kernel's LRU (Least Recently Used) memory management system. This issue specifically impacts the interaction between NMI (Non-Maskable Interrupt) and tracepoint BPF programs that can potentially re-enter per-CPU or global LRU locks while already holding them on the same CPU, creating a circular dependency that results in system lockup. The problem manifests through Lockdep kernel subsystem warnings indicating inconsistent lock usage patterns with messages such as "inconsistent {INITIAL USE} -> {IN-NMI}" and "possible recursive locking detected" which point to the core issue of lock re-entrancy during critical kernel operations.
The technical flaw resides in how the BPF LRU implementation manages locking mechanisms for memory management operations. When BPF programs execute in NMI or tracepoint contexts, they can attempt to access LRU data structures that are already locked by the same CPU's execution context, creating a deadlock scenario where the program waits indefinitely for its own lock while holding it. This vulnerability affects both per-CPU and global LRU lock management systems and has been classified under CWE-362 (Concurrent Execution using Shared Resource with Improper Synchronization) and aligns with ATT&CK techniques involving privilege escalation through kernel exploitation. The original attempts to address this using trylock and rqspinlock-based approaches were rejected due to reliability concerns, highlighting the complexity of maintaining system stability while implementing deadlock prevention mechanisms.
The operational impact of this vulnerability extends beyond simple system hangs, potentially leading to complete system unresponsiveness where critical kernel operations cannot proceed due to the recursive locking condition. The risk is particularly elevated in high-performance computing environments or systems handling real-time processing requirements where NMI and tracepoint handlers are frequently invoked. The specific failure modes include node leaks that can accumulate over time, degrading system performance and potentially leading to memory exhaustion. This vulnerability directly affects the kernel's ability to manage BPF program resources efficiently, impacting network monitoring, security auditing, and system tracing capabilities that depend on these mechanisms.
The patch implementation addresses this through comprehensive conversion of all LRU lock sites to utilize rqspinlock_t types which provide more robust locking semantics suitable for the high-concurrency environment of BPF program execution. The solution incorporates multiple recovery paths designed to prevent resource leaks while maintaining system stability during failure conditions. When *_pop_free operations fail, the system gracefully returns NULL values that are properly handled by existing prealloc_lru_pop() functions treating this as a -ENOMEM condition rather than a fatal error. Cross-CPU stealing mechanisms now skip locked victim CPUs and attempt alternative paths, while post-steal local lock failures direct stolen nodes to lockless per-CPU free_llist structures where they can be reclaimed during subsequent pop operations on the same CPU. The push_free failure recovery mechanism marks nodes as pending_free=1 which are then handled through various cleanup functions including __local_list_flush(), __local_list_pop_pending(), and __bpf_lru_list_shrink_inactive() for different LRU list states, ensuring that memory management remains functional even when individual lock operations fail. This approach maintains system reliability while preventing the deadlock conditions that could otherwise render the entire kernel unresponsive.