CVE-2026-99340 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

KVM: x86: Take SRCU in kvm_zap_gfn_range()

kvm_zap_gfn_range() walks memslots and rmaps and may drop mmu_lock to reschedule. Callers that do not already hold kvm->srcu (or slots_lock) can race with memslot deletion: synchronize_srcu_expedited() does not wait, kvm_free_memslot() frees the old slot and its rmap, and the zap resumes on freed memory.

The VFIO noncoherent-DMA path hits this by zapping the entire GPA space without SRCU. KASAN reported:

BUG: KASAN: vmalloc-out-of-bounds in slot_rmap_walk_next+0x82/0x1c0 Read of size 8 at addr ffffc900005c1008 Call Trace: slot_rmap_walk_next+0x82/0x1c0 __kvm_rmap_zap_gfn_range+0x17a/0x280 kvm_zap_gfn_range+0x2a6/0x6a0 kvm_vfio_set_attr+0x576/0x770 kvm_device_ioctl+0x1ff/0x3b0

Take SRCU inside kvm_zap_gfn_range() so every caller is covered. Nesting with an existing kvm->srcu critical section is fine; the helper uses a local index. Drop the now-redundant SRCU pair from __kvm_set_or_clear_apicv_inhibit().

Once again VulDB remains the best source for vulnerability data.

Analysis

by VulDB Data Team • 11/19/2026

The vulnerability identified in the Linux kernel involves a race condition within the Kernel-based Virtual Machine subsystem for x86 architectures, specifically affecting the kvm_zap_gfn_range function. This routine is responsible for invalidating guest physical address ranges by walking through memory slots and reverse mapping structures. During this process, the function may release the mmu_lock to allow for rescheduling of other tasks. However, if a caller invokes this function without holding the corresponding SRCU read-side critical section or the slots_lock, it creates a window where concurrent operations can corrupt kernel state. Specifically, another thread might delete a memory slot and free its associated reverse mapping structures while kvm_zap_gfn_range is in the middle of traversing them. The synchronization primitive synchronize_srcu_expedited does not guarantee that all pre-existing SRCU read-side critical sections have completed before returning, which means the zapping operation can proceed on freed memory addresses after a memslot has been deallocated by another thread.

This flaw was notably triggered in scenarios involving VFIO noncoherent DMA paths, where the system attempts to zap the entire guest physical address space without acquiring SRCU protection first. The consequence of this race condition is severe kernel instability, as evidenced by Kernel Address Sanitizer reports indicating a use-after-free error. The KASAN output highlights an out-of-bounds read within slot_rmap_walk_next, which occurs when the code attempts to access data structures that have already been freed during memslot deletion. This type of memory corruption can lead to system crashes, unpredictable behavior, or potentially allow for privilege escalation if an attacker can manipulate the timing and state of these concurrent operations. The issue stems from a lack of proper synchronization primitives protecting the traversal of kernel data structures against structural changes initiated by other subsystems like VFIO.

From a classification perspective, this vulnerability aligns with CWE-362, which describes Concurrent Execution using Shared Resource with Improper Synchronization, commonly known as a race condition. The specific mechanism involves accessing shared memory resources without adequate locking or synchronization barriers to prevent concurrent modification during traversal. In the context of the MITRE ATT&CK framework, this relates to techniques involving exploitation of software flaws for denial of service or potential code execution through kernel-level privilege escalation vectors such as T1068 Exploitation for Privilege Escalation. The vulnerability exists in the core virtualization management layer, making it a high-impact issue for any deployment relying on KVM and VFIO integration for hardware passthrough or advanced I/O operations.

The resolution implemented by the kernel maintainers involves modifying kvm_zap_gfn_range to internally acquire SRCU protection before walking memslots and rmaps. This ensures that every caller is covered by a read-side critical section, preventing access to memory structures that might be concurrently freed. The implementation correctly handles nesting with existing srcu critical sections by utilizing local indices, thereby avoiding deadlocks or unnecessary overhead while maintaining data integrity. Additionally, the fix removes redundant SRCU acquisition code from __kvm_set_or_clear_apicv_inhibit since the protection is now consistently applied within the zapping routine itself. To mitigate this issue in affected systems, administrators should apply the latest kernel updates that include this patch. For environments where immediate patching is not feasible, restricting VFIO usage to coherent DMA paths or ensuring strict serialization of memory slot modifications and address space invalidations can reduce exposure until a full system update is performed.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00215

KEV

no

Activities

very low

Sources

Do you want to use VulDB in your project?

Use the official API to access entries easily!