CVE-2026-99597 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
srcu: Add list_splice_init_srcu()
list_splice_init_rcu() makes a list look empty to new readers, waits for the current ones with the given sync function, and only then links the entries into the new list. The sync function takes no argument, so it can wait for RCU readers but not for the readers of an srcu_struct.
Passing synchronize_rcu() for a list read under SRCU still builds, but leaves SRCU readers on the entries while the last one's next pointer is moved onto the new list head. nvme_remove_namespaces() does this today.
Add list_splice_init_srcu(), which waits for the readers of the given srcu_struct instead.
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 11/21/2026
The Linux kernel’s Read-Copy-Update (RCU) and Synchronize RCU Readers (SRCU) mechanisms are critical subsystems designed to manage concurrent access to shared data structures without requiring traditional locking primitives, thereby improving performance in high-concurrency environments. A subtle but significant synchronization flaw existed within the list manipulation utilities that interact with these grace period mechanisms. Specifically, the function list_splice_init_rcu() was historically used to splice a source list into a destination list while ensuring safety for concurrent readers. This function operates by making the original list appear empty to new readers and then waiting for all currently active RCU read-side critical sections to complete before linking the entries into the new list structure. However, this mechanism relies on passing a specific synchronization callback, typically synchronize_rcu(), which only waits for RCU-based grace periods. It does not account for SRCU-specific reader contexts, creating a mismatch when lists are accessed under SRCU protection rather than standard RCU protection.
This architectural oversight leads to a race condition where the kernel may proceed with modifying list pointers while active readers protected by an srcu_struct are still traversing those same entries. In this scenario, although the code compiles and appears syntactically correct because synchronize_rcu() is a valid function pointer type for the expected argument, it fails semantically to provide the necessary memory ordering guarantees required by SRCU users. The core issue arises when the last reader’s next pointer is moved onto the new list head before all SRCU readers have finished their traversal. This premature modification can result in use-after-free conditions or data corruption because a reader might dereference a pointer that has been reallocated or repurposed for a different structural role within the kernel memory management subsystems.
The operational impact of this vulnerability is particularly acute in storage drivers and other high-throughput subsystems where SRCU is preferred due to its ability to allow read-side critical sections to sleep, which RCU does not permit. A concrete example of this flaw was identified in the nvme_remove_namespaces() function within the NVMe driver codebase. When namespaces are removed from an NVMe controller, the kernel must safely detach them from internal lists while ensuring that any ongoing I/O operations or metadata reads initiated by user space or other kernel threads have completed. By incorrectly using synchronize_rcu(), the system risked exposing stale pointers to active SRCU readers, potentially leading to kernel panics, data integrity violations, or security exploits where an attacker could leverage the race condition to execute arbitrary code via a crafted I/O request that triggers the vulnerable path during namespace removal.
To resolve this issue and restore correct synchronization semantics, developers introduced list_splice_init_srcu(). This new utility function is specifically designed for lists protected by SRCU mechanisms. It accepts the srcu_struct as an argument and utilizes synchronize_srcu() to wait for all active readers associated with that specific source structure before performing the splice operation. By aligning the grace period mechanism with the actual protection scheme used on the data structures, this fix ensures that no reader can access freed or repurposed memory during the transition. This change adheres to best practices in concurrent programming by ensuring that synchronization primitives match the locking model of the protected resource, thereby eliminating the race condition entirely and maintaining system stability under heavy load conditions involving dynamic list manipulation.
From a vulnerability classification perspective, this flaw aligns with CWE-362, which describes Concurrent Execution using Shared Resource with Improper Synchronization. The failure to properly synchronize access to shared data structures during modification operations is a classic example of this category. Furthermore, in the context of the MITRE ATT&CK framework for enterprise security, such vulnerabilities can be associated with T1059, Command and Scripting Interpreter, if an attacker successfully exploits the race condition to achieve arbitrary code execution within the kernel space. Kernel-level exploitation often leads to full system compromise, making the remediation of this synchronization error critical for maintaining the integrity and confidentiality of Linux-based systems. The fix ensures that the kernel maintains strict memory safety guarantees even in complex multi-threaded environments where SRCU is utilized for its flexibility regarding sleeping readers.