CVE-2026-46295: Linux KVM Posted Interrupt Race Condition

Technical summary

CVE-2026-46295 addresses a synchronization race in KVM's Posted Interrupt Descriptor (PID) mechanism on x86 platforms. The vulnerability arises from a non-atomic two-step sequence in __vmx_deliver_posted_interrupt(): setting a bit in the Posted Interrupt Request (PIR) register, then setting the PID.ON flag. A target vCPU executing vmx_sync_pir_to_irr() can observe PID.ON=1 after the PIR has already been harvested and cleared by an intervening sync operation, causing the second sync to return max_irr=-1 without scanning the Interrupt Request Register (IRR). The interrupt remains correctly recorded in the IRR from the prior sync cycle, but the incorrect max_irr value causes vmx_check_nested_events() to detect a mismatch: kvm_cpu_has_interrupt() reports pending while kvm_apic_has_interrupt() returns -1, triggering the WARNING. The fix ensures __kvm_apic_update_irr() always falls back to apic_find_highest_vector() to scan the IRR when PID.ON is set, even if PIR is empty, guaranteeing accurate reporting of the highest pending interrupt vector.

Business impact

Organizations running nested virtualization workloads (such as cloud providers offering VM-on-VM capabilities or container orchestration platforms with nested KVM) will experience spurious kernel warnings and unnecessary vCPU context switch overhead during stress conditions. While data integrity and security are not directly compromised, the availability impact manifests as degraded performance and log noise that obscures genuine issues. Production environments with high-density nested KVM deployments may see measurable latency inflation and diagnostic complexity. The warning spam can trigger automated alerting systems, creating operational burden for teams relying on kernel logs for health monitoring.

Affected systems

Any Linux system running the KVM hypervisor with x86 architecture is potentially affected. The vulnerability is most pronounced in nested virtualization setups—scenarios where virtual machines themselves host additional virtual machines. This includes public cloud platforms offering nested VM capabilities, on-premises hypervisor clusters supporting nested workloads, and lab/test environments using nested KVM. Systems with high vCPU counts and dense VM packing are at greatest risk of triggering the race condition. The vulnerability does not affect non-KVM systems, ARM-based KVM deployments, or single-level virtualization without nesting, though all KVM installations contain the vulnerable code path.

Exploitability

Exploiting this vulnerability requires local system access to trigger nested KVM workloads and sustained stress to reliably hit the race condition timing window. There is no remote attack vector; an attacker cannot trigger the flaw from outside the system or across a network. Proof-of-concept reproduction typically requires specialized stress testing tools targeting the Posted Interrupt mechanism under concurrent vCPU load. The race condition is probabilistic—it manifests sporadically under specific load patterns—which makes weaponization impractical for targeted attacks. No known public exploits exist, and the condition does not enable privilege escalation or data exfiltration; it causes incorrect reporting and performance degradation only.

Remediation

Patch the Linux kernel to a version containing the fix to __kvm_apic_update_irr(). The patch modifies the function to invoke apic_find_highest_vector() as a fallback whenever PID.ON is set but the PIR is empty, ensuring the IRR is always scanned for the highest pending interrupt. Verify against the vendor advisory for the specific kernel version numbers and branches affected in your distribution. After patching, no configuration changes or workarounds are required. Systems should be rebooted to load the updated kernel. If immediate patching is not feasible, disabling nested virtualization (setting kvm-intel.nested=0 or equivalent) eliminates the attack surface, though this removes support for nested VM capabilities.

Patch guidance

Consult your Linux distribution's security advisories and kernel repositories for the patched kernel version addressing CVE-2026-46295. Mainstream distributions (Red Hat, Debian, Ubuntu, SUSE, etc.) will provide backported fixes for stable kernel branches. Apply patches according to your organization's change management procedures and kernel update cadence. Test patched kernels in non-production nested KVM environments first to validate stability. Reboot systems at a maintenance window to activate the patched kernel. Verify the fix by running nested virtualization workloads and confirming the absence of vmx_check_nested_events() warnings in kernel logs.

Detection guidance

Monitor kernel logs (dmesg, journalctl) for the specific WARNING message originating from arch/x86/kvm/vmx/nested.c line 4449 in vmx_check_nested_events(), which triggers when kvm_cpu_has_interrupt() reports a pending interrupt but kvm_apic_has_interrupt() returns -1. Elevated warning frequency correlates with nested KVM stress load. No userspace artifacts or application-level indicators exist; detection is kernel-log dependent. Hypervisor monitoring tools that parse kernel warnings can be tuned to flag this specific message. Note that warning presence alone indicates the race occurred, not exploitation or compromise; the race is a kernel internal consistency issue rather than a security boundary violation. After patching, absence of this warning pattern indicates successful remediation.

Why prioritize this

While the CVSS score of 5.5 (Medium) reflects availability impact without confidentiality or integrity compromise, nested KVM environments should prioritize this patch above typical medium-severity issues because the race condition directly undermines system reliability and observability. Organizations dense-packing VMs or offering nested capabilities as a service should treat this as high-priority. The fix is low-risk and non-disruptive. Conversely, traditional single-level hypervisor deployments without nested workloads may defer patching to routine kernel update cycles. The absence of KEV inclusion reflects low external exploitability, further reducing risk for organizations focused on attack surface exposure.

Risk score, explained

The CVSS 3.1 score of 5.5 (Medium, AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H) reflects: local attack vector only (hypervisor host access required), low attack complexity (race condition is deterministic once nested KVM load is applied), low privileges (any user able to spawn nested VMs), no user interaction needed, no impact on other systems (S:U), zero confidentiality or integrity impact, and high availability impact (spurious warnings, wasted cycles). The score appropriately discounts remote attack scenarios. The lack of data compromise keeps severity at Medium despite the availability hit. Real-world impact varies: organizations relying on nested KVM operationally will experience higher actual risk than those without nested workloads.

Frequently asked questions