CVE-2026-99341 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

KVM: x86: Request event processing for exception VM-Exits

Request event processing whenever kvm_queue_exception_vmexit() queues an exception VM-Exit. Most callers reach the helper through kvm_multiple_exception(), which already sets KVM_REQ_EVENT, but nested asynchronous page faults call it directly.

Without another event request, vcpu_enter_guest() skips kvm_check_and_inject_events() and re-enters L2. A subsequent VM-Exit can clear the pending exception while reconstructing vectoring state, losing the synthetic #PF VM-Exit. The APF reason remains PAGE_NOT_PRESENT and a later regular #PF can consume the stale value.

Setting KVM_REQ_EVENT in the common helper ensures that L1 receives the queued VM-Exit before KVM re-enters L2.

If you want to get best quality of vulnerability data, you may have to visit VulDB.

Analysis

by VulDB Data Team • 11/20/2026

The vulnerability described involves a logic error within the Linux kernel's Kernel-based Virtual Machine (KVM) subsystem, specifically affecting x86 architecture handling of virtual machine exits and exception processing. The core issue arises from how asynchronous page faults are queued for nested virtualization scenarios. In this context, when an exception VM-Exit is requested via the kvm_queue_exception_vmexit() helper function, it was not consistently triggering the necessary event processing flags in all code paths. While most callers utilize kvm_multiple_exception(), which correctly sets the KVM_REQ_EVENT flag to signal that pending events need injection, nested asynchronous page faults bypass this wrapper and call the lower-level helper directly without setting the required request flag. This inconsistency creates a gap in the state management of virtual CPU execution flow.

The operational impact of this flaw is significant for systems running nested virtualization with heavy reliance on asynchronous page fault mechanisms. When KVM_REQ_EVENT is not set, the vcpu_enter_guest() function proceeds to re-enter the guest environment (L2) without first checking and injecting pending events via kvm_check_and_inject_events(). Consequently, a synthetic page fault VM-Exit intended for the host or upper-level hypervisor may be lost during this transition. The virtual CPU state is reconstructed in a way that clears the pending exception vectoring information before it can be properly delivered to L1. This results in the asynchronous page fault reason remaining stuck at PAGE_NOT_PRESENT, creating a stale condition within the guest's memory management subsystem.

This stale state poses a risk of incorrect behavior during subsequent memory operations. If a regular synchronous page fault occurs later, it may incorrectly consume or interpret the residual PAGE_NOT_PRESENT value from the lost asynchronous event. This misalignment between expected and actual exception handling can lead to unpredictable application crashes, data corruption within virtual machines, or potential denial-of-service conditions for workloads dependent on accurate page fault reporting. The failure to properly sequence event injection before re-entering the guest environment undermines the reliability of memory management abstractions provided by KVM in nested scenarios.

From a vulnerability classification perspective, this issue aligns with CWE-362, Concurrent Execution using Shared Resource with Improper Synchronization, as it involves race-like conditions in state updates during context switches between virtualization layers. It also relates to CWE-401, Missing Release of Memory after Effective Lifetime, if the stale state leads to resource leaks or improper cleanup of exception vectors. In terms of MITRE ATT&CK mapping, this falls under Tactic TA0005 (Defense Evasion) and Technique T1620 Reflective Code Loading, as attackers could potentially exploit the misaligned page fault handling to evade detection mechanisms that rely on accurate memory access monitoring or to manipulate execution flow through corrupted exception states.

Mitigation for this vulnerability requires applying the kernel patch that ensures kvm_queue_exception_vmexit() always requests event processing by setting KVM_REQ_EVENT. This guarantees that L1 receives the queued VM-Exit before KVM re-enters L2, maintaining proper synchronization between virtual CPU state and pending exceptions. Administrators should update their Linux kernels to versions where this fix is included. For environments utilizing nested virtualization with asynchronous page faults enabled, verifying kernel version compliance and monitoring for unusual guest behavior or unhandled page fault errors is recommended until the patch is deployed. Regular security audits of hypervisor configurations can also help identify misconfigurations that might exacerbate such logic flaws in production workloads.

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 need the next level of professionalism?

Upgrade your account now!