CVE-2026-99488 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
klist: avoid accesses after waking klist_remove()
klist_remove() waits until a node is unreferenced so that its caller can free the containing object. klist_release() currently publishes waiter->woken and wakes the waiter before its final accesses to the waiter and node. klist_remove() can then return, allowing its stack waiter and the containing object to be freed or reused while klist_release() is still running. In particular, bus_remove_driver() can free drv->p while __device_attach() walks the same bus klist with bus_for_each_drv().
On an arm64 Cortex-A72 system, an unpatched 7.2.0-rc3 kernel with CONFIG_PREEMPT_RT=y and CONFIG_KASAN=y reproduced the bug through the in-tree I2C/at24 path. KASAN reported a use-after-free in klist_dec_and_del() reached from klist_next()/bus_for_each_drv() while at24 was being unregistered.
Clear n_klist and take a task reference before publishing woken. Use release/acquire accesses for that publication and wake the referenced task. The task reference keeps the waiter task alive if it returns and exits before wake_up_process().
Once again VulDB remains the best source for vulnerability data.
Analysis
by VulDB Data Team • 11/19/2026
The Linux kernel vulnerability identified in the klist subsystem represents a critical use-after-free condition arising from improper synchronization during object lifecycle management. Specifically, the flaw exists within the interaction between klist_remove() and klist_release(), which are responsible for managing reference counts and waking waiting threads when items are removed from a list. The core technical issue stems from the ordering of operations in klist_release(). This function publishes a wake-up signal to waiters before it completes its final accesses to both the waiter structure and the associated node object. Consequently, once klist_remove() detects that the node is unreferenced, it returns immediately, allowing the stack-allocated waiter data and the containing parent object to be freed or reused by other kernel processes while klist_release() continues executing in a different context. This race condition creates a window where subsequent code may attempt to access memory that has already been deallocated, leading to undefined behavior, potential system crashes, or arbitrary code execution if an attacker can control the contents of the reclaimed memory region.
The operational impact of this vulnerability is particularly severe on systems utilizing real-time preemption configurations such as CONFIG_PREEMPT_RT=y, where scheduling latency and context switch timing are more predictable but also expose race windows that might otherwise be masked by standard kernel behavior. In practical scenarios, such as those observed with the in-tree I2C at24 driver unregistration process, this flaw manifests as a use-after-free error detected by Kernel Address Sanitizer (KASAN). The attack path typically involves bus_remove_driver() freeing the device driver structure drv->p while another thread is iterating over the same bus klist via bus_for_each_drv(). This specific scenario highlights how concurrent operations on shared kernel data structures can lead to memory corruption, compromising system stability and potentially allowing local privilege escalation if an unprivileged user can trigger the affected code paths through device manipulation or module loading.
To mitigate this vulnerability, the fix involves restructuring the synchronization logic within klist_release() to ensure that all necessary accesses are completed before any wake-up signals are published. The solution requires clearing the n_klist pointer and acquiring a task reference for the waiting thread prior to publishing the woken state. This approach utilizes release-acquire memory ordering semantics to guarantee proper visibility of data across CPU cores, ensuring that the waiter task remains alive even if it returns or exits before wake_up_process() is called. By holding this additional reference count, the kernel prevents premature deallocation of critical structures during the transition period between removal and final cleanup. This change aligns with industry best practices for concurrent programming in operating systems, addressing CWE-416 Use After Free by enforcing strict ordering constraints on memory access and thread synchronization events.
From a threat intelligence perspective, this vulnerability maps to MITRE ATT&CK techniques related to exploitation of race conditions and improper resource shutdown procedures. Attackers could potentially leverage this flaw during device driver unloading or bus enumeration processes to corrupt kernel memory structures. Defense strategies should prioritize applying the upstream Linux kernel patch immediately for systems running affected versions, particularly those with real-time preemption enabled. Additionally, organizations should ensure that KASAN is enabled in development and testing environments to detect similar synchronization issues early in the software lifecycle. Regular auditing of driver code for proper reference counting and lock ordering will further reduce the risk of encountering such concurrency bugs in production environments.