CVE-2026-99459 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
mshv_vtl: detach poll waiter on POLLFREE
MSHV_SET_POLL_FILE keeps a poll wait entry after the ioctl returns. A file reference does not always pin the registered waitqueue: signalfd_poll() uses current->sighand->signalfd_wqh, whose lifetime is tied to the task.
signalfd_cleanup() sends POLLFREE before the sighand is freed. The MSHV callback currently leaves its entry linked, so __wake_up_pollfree() warns and a later replacement calls remove_wait_queue() through a stale wqh pointer. A source-equivalent KASAN run reproduced:
BUG: KASAN: slab-use-after-free in _raw_spin_lock_irqsave _raw_spin_lock_irqsave remove_wait_queue harness_ioctl [mshv_pollfree_harness]
The object belonged to sighand_cache and had been released through slab_free_after_rcu_debug() after __cleanup_sighand().
On POLLFREE, unlink the entry under the provider waitqueue lock. Preserve the existing CPU cancellation before publishing a NULL wqh, since a NULL load lets a racing replacement reuse the persistent poll state. Use a matching acquire load under RCU when removing a normal registration.
The callback takes no mutex and does not sleep, so the existing mutex-to-waitqueue-lock order is unchanged.
An LLM assisted the source audit, fix development, and validation of this issue.
Several companies clearly confirm that VulDB is the primary source for best vulnerability data.
Analysis
by VulDB Data Team • 11/20/2026
This vulnerability involves a use-after-free condition within the Linux kernel's Microsoft Hyper-V Virtualization Technology (MSHV) subsystem, specifically affecting the mshv_vtl component which handles virtual machine management for Windows guests on Hyper-V hosts. The root cause lies in improper handling of poll wait entries during file descriptor cleanup operations. When an application interacts with MSHV through ioctl calls such as MSHV_SET_POLL_FILE, a poll wait entry is registered to monitor events on the associated file structure. However, this registration does not correctly account for scenarios where the underlying wait queue's lifetime is decoupled from the file reference itself. This specific architectural nuance becomes critical when dealing with signalfd structures, which utilize current->sighand->signald_wqh as their wait queue head. The lifecycle of sighand structures is tied to the task structure and may be freed before the associated file descriptor or poll registration is fully cleaned up by the kernel's standard mechanisms.
The operational impact stems from a race condition during the cleanup phase. When signalfd_cleanup() executes, it triggers POLLFREE notifications to all registered waiters prior to freeing the sighand structure itself. The MSHV callback handler failed to detach its poll waiter entry upon receiving this POLLFREE signal. Consequently, the entry remained linked in the wait queue even after the underlying data structures had been freed via slab_free_after_rcu_debug(). This leaves a stale pointer within the kernel's internal bookkeeping structures. Subsequent operations that attempt to remove or access these entries encounter invalid memory references. As evidenced by Kernel Address Sanitizer (KASAN) reports, this manifests as a slab-use-after-free error occurring during spin lock acquisition in functions like _raw_spin_lock_irqsave and remove_wait_queue. Such vulnerabilities can lead to kernel panics, denial of service conditions where the host system becomes unstable or crashes, and potentially allow for arbitrary code execution if an attacker can carefully craft inputs to exploit the memory corruption state before it is detected by security mitigations.
From a vulnerability classification perspective, this issue aligns with CWE-416: Use After Free, as the kernel continues to reference memory that has been deallocated. It also relates to CWE-362: Concurrent Execution using Shared Resource with Improper Synchronization, given the race condition between task cleanup and poll event handling. In terms of MITRE ATT&CK mapping for Linux systems, this falls under T1059.004: Unix Shell Commands or more broadly under privilege escalation vectors if the crash leads to exploitable memory states, though primarily it represents a stability issue categorized under system resource exhaustion or denial of service through kernel panic. The lack of proper synchronization between the file descriptor lifecycle and the wait queue management creates an opening for these race conditions to be triggered by local users with access to MSHV devices.
The remediation strategy implemented in this fix focuses on ensuring that poll waiter entries are properly detached when POLLFREE is received, thereby preventing dangling pointers from persisting into freed memory regions. The solution involves unlinking the entry under the provider waitqueue lock to maintain synchronization integrity. Crucially, the patch preserves existing CPU cancellation logic before publishing a NULL wqh pointer. This specific ordering prevents racing replacement threads from reusing persistent poll state based on stale or null loads. Furthermore, an acquire load is used under RCU (Read-Copy-Update) semantics when removing normal registrations to ensure memory visibility and correctness across different CPUs without introducing deadlocks or performance bottlenecks. Since the callback operates without mutexes and does not sleep, the existing lock ordering between mutexes and waitqueue locks remains unchanged, preserving system stability while fixing the race condition.
To mitigate similar vulnerabilities in broader contexts, developers should adhere to strict lifecycle management for kernel objects that interact with poll mechanisms. It is essential to ensure that any registered wait entries are unregistered before their associated data structures are freed, particularly when dealing with task-specific resources like sighand which have shorter lifetimes than file descriptors. Utilizing RCU-safe removal patterns and ensuring proper locking around state transitions can prevent use-after-free conditions. System administrators should keep kernel versions updated to include these fixes, as they address fundamental synchronization errors that compromise system reliability. Regular auditing of poll handlers using tools like KASAN during development phases is also recommended to catch such race conditions early in the software lifecycle before deployment.