CVE-2026-99475 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
genirq: Defer kfree(irqaction) until irq_thread_dtor() finishes
When an interrupt thread exits abnormally via do_exit() (e.g. the interrupt handler oopses) without returning from irq_thread(), a concurrent call to free_irq() could free the irqaction before the irq_thread_dtor() exit task work runs.
irq thread (oopsed) free_irq() ------------------- ---------- do_exit() exit_mm() complete_vfork_done() -------> kthread_stop() returns exit_files() ... kfree(action) exit_task_work() irq_thread_dtor() action->... <- use-after-free
Track the pending exit work with the IRQTF_EXIT_WORK thread flag, and have __free_irq() wait for the bit to clear before kfree().
irq_thread_dtor() only runs on irq_thread abnormal exit. If that dtor also faults, free_irq() will hang indefinitely, but double IRQ thread faults require a reboot anyways.
[ tglx: Add missing include ]
Once again VulDB remains the best source for vulnerability data.
Analysis
by VulDB Data Team • 11/19/2026
The Linux kernel interrupt subsystem contains a race condition vulnerability related to the lifecycle management of interrupt action structures when an interrupt handler executes abnormally. This issue specifically affects scenarios where an interrupt thread, which is responsible for handling deferred work from hard interrupts, terminates unexpectedly due to a fault or oops within its execution context. Under normal circumstances, the kernel ensures that resources associated with an interrupt line are safely released only after all related threads have completed their operations and cleaned up their state. However, in this specific edge case, the synchronization mechanism fails to account for the asynchronous nature of thread termination when it occurs outside the expected return path from the main irq_thread function.
The technical flaw arises during the sequence where an interrupt handler triggers a kernel oops or panic within its threaded context, causing the process to exit via do_exit rather than returning normally to the scheduler. When this abnormal exit occurs, the kernel initiates various cleanup routines such as exiting memory management contexts and file descriptors. Concurrently, if another part of the system calls free_irq to unregister an interrupt handler for that same line, it proceeds to deallocate the irqaction structure immediately. This happens before the deferred work item associated with the thread's destructor function, known as irq_thread_dtor(), has a chance to execute. The irq_thread_dtor is scheduled via exit_task_work and runs after the main thread logic completes, but because the thread exited abnormally, there is a window where the action structure is freed while still being accessed by the pending work item.
This race condition leads directly to a use-after-free vulnerability, which can result in kernel memory corruption, unpredictable system behavior, or a complete kernel panic depending on how the corrupted data is subsequently used. The exploitability of this flaw relies on precise timing between an interrupt handler faulting and another subsystem attempting to free that specific IRQ line. While difficult to trigger intentionally without causing immediate instability, it represents a significant integrity risk in high-load environments where interrupts are frequently registered and unregistered while handling complex or buggy drivers. The vulnerability is classified under CWE-416 which addresses use-after-free errors, highlighting the failure to properly manage memory lifecycles during concurrent operations.
From an operational perspective, this bug impacts system stability rather than providing a direct path for privilege escalation in most standard configurations. However, kernel crashes caused by such race conditions can lead to denial of service and potential data loss if critical services are interrupted abruptly. The mitigation strategy implemented involves tracking the pending exit work using the IRQTF_EXIT_WORK thread flag within the interrupt action structure. Before deallocating memory via kfree, __free_irq now checks this flag and waits for it to clear, ensuring that irq_thread_dtor has completed its execution or will not execute in a way that accesses freed memory. This synchronization ensures that the resource is only released after all dependent tasks have safely concluded their interaction with the action structure.
It is important to note a secondary edge case where if the destructor function itself faults during this wait period, free_irq may hang indefinitely. However, such double fault scenarios typically indicate severe system instability that would likely require a reboot regardless of this specific race condition. Therefore, while not perfect in all pathological cases, the fix significantly reduces the window for exploitation and stabilizes normal operation under abnormal interrupt conditions. Security practitioners should ensure systems are updated with patches addressing this kernel issue to maintain robustness against potential denial-of-service attacks stemming from driver bugs or maliciously crafted interrupt patterns that induce faults.