CVE-2026-99515 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
iommufd: Fix event queue release use-after-free
iommufd_eventq_fops_release() drops the file's users reference before reading eventq->ictx. Once that reference is dropped, IOMMU_DESTROY in another thread can remove and free the event queue, so the later load accesses freed memory.
Read ictx while the users reference still pins the event queue, then drop the reference and put the saved context. The context reference taken by iommufd_eventq_init() keeps ictx valid until the put. Fault and vEVENTQ file descriptors share this release path.
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 iommufd subsystem represents a critical use-after-free condition within the event queue management logic, specifically affecting the file operations release path. This flaw arises from an incorrect ordering of reference counting operations during the cleanup phase of IOMMU user-space device interface files. The core issue is located in the iommufd_eventq_fops_release function, which is responsible for cleaning up resources when a process closes its handle to an event queue file descriptor. In this routine, the code prematurely drops the users reference count associated with the file before accessing the internal context pointer stored within the event queue structure. This sequence of operations creates a race condition window where the structural integrity of the object being accessed is no longer guaranteed by the current thread's hold on it.
The operational mechanism of this vulnerability relies on concurrent execution paths interacting with the same IOMMU device and its associated resources. When the users reference is released, the kernel's internal refcounting logic may determine that there are no more active holders of the event queue object if other references have also been dropped or are in the process of being released. Consequently, another thread executing an IOMMU_DESTROY operation can trigger the deallocation and freeing of the memory occupied by the event queue structure. Because the original thread has already relinquished its protective reference but continues execution to read the ictx pointer from that now-freed memory block, it performs a load operation on invalid memory addresses. This constitutes a classic use-after-free scenario where stale pointers are dereferenced after their underlying storage has been reclaimed by the kernel allocator for other purposes.
The impact of this vulnerability is severe and multifaceted, primarily affecting system stability and potentially security posture. From a reliability standpoint, accessing freed memory typically results in immediate kernel panics or oopses, leading to denial of service conditions where the entire host system becomes unresponsive due to critical kernel data corruption. Furthermore, from a security perspective, use-after-free vulnerabilities are historically among the most dangerous classes because they allow for arbitrary read and write primitives under specific heap layout conditions. An attacker who can trigger this race condition might be able to leak sensitive kernel memory contents or overwrite adjacent objects in the slab allocator, potentially leading to remote code execution with kernel privileges. The vulnerability affects both fault event queues and vEVENTQ file descriptors, meaning any user-space application utilizing these IOMMU features for hardware interrupt handling or virtualization contexts is susceptible to exploitation if it can influence timing relative to device destruction events.
This flaw aligns directly with CWE-416, which defines use-after-free errors as a category of memory corruption vulnerabilities where software continues to use a pointer after it has been freed. In the context of modern exploit mitigation techniques and threat modeling, this vulnerability maps to ATT&CK technique T1203, specifically relating to exploitation for defense evasion or privilege escalation through kernel-level memory manipulation. The lack of proper synchronization between reference counting and resource access violates fundamental principles of safe concurrent programming in operating system kernels. To mitigate such issues, developers must ensure that all accesses to shared data structures are protected by holding the appropriate references until those accesses are complete.
The resolution implemented for this vulnerability corrects the ordering within the release function by ensuring that the ictx context pointer is read and saved while the users reference still actively pins the event queue in memory. Only after this critical data has been safely retrieved does the code proceed to drop the user's reference count. Subsequently, the saved context reference, which was originally taken during initialization via iommufd_eventq_init, is properly released using put operations. This adjustment guarantees that the event queue structure remains valid throughout the entire duration of the release procedure, effectively eliminating the race window where another thread could free the memory while it is still being accessed. This fix reinforces the importance of strict reference counting discipline in kernel subsystems to prevent data races and memory corruption issues.