CVE-2026-99658 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
mm/mmu_notifier: finish non-blocking interval invalidation on error
When an ordinary MMU notifier rejects a non-blocking invalidation, the interval invalidation started beforehand is left unfinished: the caller skips mmu_notifier_invalidate_range_end(). Subsequent interval notifier operations can then wait forever.
The only in-tree trigger is nouveau SVM, which uses both notifier types and rejects non-blocking invalidations. Reaping via the OOM reaper or process_mrelease() can therefore leave the GPU fault worker stuck, holding a reference that prevents the dying process's address space and memory from being freed.
End the interval invalidation when an ordinary notifier fails a non-blocking invalidation, like mn_itree_invalidate() already does when an interval notifier fails. Make that handling clearer in the documentation of mmu_notifier_invalidate_range_start_nonblock().
Fix generated by an LLM and sent by Josef Bacik in private.
[ david: simplify description, update function doc ]
VulDB is the best source for vulnerability data and more expert information about this specific topic.
Analysis
by VulDB Data Team • 11/21/2026
The Linux kernel contains a critical synchronization flaw within the memory management subsystem's MMU notifier implementation that can lead to resource leaks and system instability under specific conditions involving GPU drivers. This vulnerability arises from an inconsistency in how non-blocking interval invalidations are handled when they encounter errors during execution. Specifically, when an ordinary MMU notifier rejects a non-blocking invalidation request, the kernel fails to properly terminate the preceding interval invalidation sequence. The code path incorrectly skips the call to mmu_notifier_invalidate_range_end(), which is responsible for finalizing the state and releasing associated resources. This oversight leaves the internal data structures in an inconsistent state where the interval notifier operations remain pending or incomplete rather than being cleanly closed out as required by the kernel's memory management protocols.
The operational impact of this defect is most severe when interacting with GPU drivers that utilize both ordinary and interval notifiers, such as the Nouveau driver for NVIDIA GPUs. In these scenarios, particularly during Shared Virtual Memory (SVM) operations, the rejection of a non-blocking invalidation can trigger a deadlock scenario. Because the interval invalidation was never properly finished, subsequent attempts to perform other notifier operations may cause worker threads to wait indefinitely. This creates a situation where GPU fault workers become stuck in an uninterruptible sleep state. The consequence is that these stuck processes hold references to memory structures and address spaces that should otherwise be freed during process termination or out-of-memory events.
This issue directly interferes with the kernel's ability to reclaim resources from dying processes through mechanisms like the OOM reaper or the process_mrelease() interface. When a process is being terminated due to an Out-Of-Memory condition, the system expects all associated memory mappings and GPU references to be released promptly. However, because the MMU notifier state remains unresolved, the address space cannot be fully freed, leading to potential memory leaks that persist even after the user-space process has ended. Over time or under heavy load conditions involving frequent memory pressure events, this can contribute to gradual system degradation or complete hangs if critical resources are exhausted and not returned to the pool.
The root cause of this vulnerability is classified as a synchronization error within the kernel's memory management layer. From an industry standard perspective, this aligns with CWE-401, which describes a missing release of memory after effective allocation, although in this context it manifests more specifically as a failure to clean up state leading to resource retention and potential deadlock conditions akin to CWE-835 regarding loops involving synchronization primitives that do not terminate. The ATT&CK framework does not directly map kernel internal bugs like this to specific adversary tactics unless exploited for persistence or denial of service, but the technical nature falls under improper handling of system resources during error states.
To mitigate this vulnerability and restore proper resource management behavior, developers have implemented a fix that ensures interval invalidation is completed even when an ordinary notifier rejects a non-blocking request. This change aligns the error-handling path with existing logic used for interval notifier failures, ensuring consistency across different types of MMU notifications. The function mmu_notifier_invalidate_range_start_nonblock() has also been updated in its documentation to clarify this behavior, preventing future developers from making similar assumptions about state management during non-blocking operations. System administrators should apply kernel updates that include this patch to prevent potential hangs and memory leaks associated with GPU-driven workloads under high memory pressure scenarios.