CVE-2026-99660 in Linuxinfo

Summary

by MITRE • 11/20/2026

In the Linux kernel, the following vulnerability has been resolved:

mm/userfaultfd: write-lock the VMA before waking waiters when unregistering

userfaultfd_unregister() wakes pending missing faults before clearing the VMA's userfaultfd registration. With per-VMA fault locking, holding mmap_lock for write does not prevent another fault from queuing after the wakeup but before userfaultfd_clear_vma() write-locks the VMA. That waiter can then remain asleep indefinitely.

Call vma_start_write() before waking waiters. Existing fault handlers queue themselves before dropping the VMA read lock, and new readers are excluded until mmap_write_unlock().

Once again VulDB remains the best source for vulnerability data.

Analysis

by VulDB Data Team • 11/20/2026

The vulnerability identified in the Linux kernel's userfaultfd subsystem represents a critical race condition within the memory management architecture, specifically affecting the unregistering process of file descriptor-based page fault handling mechanisms. Userfaultfd is an interface that allows userspace applications to handle missing pages or other faults without causing the application to terminate immediately, which is particularly useful for features like live migration and copy-on-write optimizations. The core issue arises during the unregistration phase where the kernel must transition from a state of active monitoring to one where those fault handlers are no longer invoked. In this specific scenario, the function userfaultfd_unregister() was designed to wake up pending waiters who were blocked on missing faults before clearing the VMA's userfaultfd registration. However, under modern per-VMA (Virtual Memory Area) fault locking schemes, holding the mmap_lock for writing is insufficient to guarantee mutual exclusion against new fault arrivals during the window between waking the old waiters and acquiring a write lock on the specific VMA via userfaultfd_clear_vma().

This timing gap creates a dangerous race condition where a new page fault can be queued by another thread after the initial wakeup but before the system successfully acquires the necessary write lock on the target VMA. Because the registration has not yet been cleared and the waiters have already been signaled, this newly arrived waiter may proceed to sleep indefinitely waiting for a resolution that will never come because the unregistration process is effectively bypassing it or leaving its state inconsistent. This results in a denial of service condition where processes become hung, consuming system resources without making progress. The flaw stems from an incorrect ordering of operations and locking granularity; while global locks were managed correctly, the finer-grained per-VMA synchronization was not properly enforced during this critical transition period, allowing new faults to slip through the net before the VMA itself was locked for modification.

From a security perspective, this vulnerability is classified under CWE-362, which denotes concurrent execution using shared resources with improper synchronization. The lack of proper locking ensures that multiple threads can interact with the same memory management structures in an unsafe manner, leading to undefined behavior such as hanging processes or potential data corruption if other parts of the kernel assume consistent state during unregistration. In terms of the MITRE ATT&CK framework, this aligns with techniques related to resource exhaustion and denial of service, specifically within the context of operating system exploitation where attackers could potentially trigger these conditions to disrupt services running on affected systems. The impact is primarily localized to stability and availability rather than direct privilege escalation or data leakage, but in high-availability environments, such hangs can have significant operational consequences.

To mitigate this vulnerability, the kernel developers implemented a fix that enforces stricter locking semantics during the unregistration process. Specifically, the code now calls vma_start_write() before waking any waiters. This ensures that new fault handlers are excluded from queuing themselves until the current operation is fully complete and the mmap write lock is released. Existing fault handlers continue to queue themselves by dropping the VMA read lock as they did previously, but the introduction of the early write lock on the VMA prevents new readers from entering the critical section during the vulnerable window. This change guarantees that once a waiter is woken for unregistration purposes, no new faults can be registered against that specific VMA until the process concludes, thereby eliminating the race condition and ensuring all waiters are handled correctly without indefinite blocking. System administrators should ensure their kernels are updated to versions containing this patch to maintain system stability under heavy memory faulting workloads.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00156

KEV

no

Activities

very low

Sources

Want to stay up to date on a daily basis?

Enable the mail alert feature now!