CVE-2026-99573 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

KVM: arm64: vgic: Stop the target vcpu when disabling LPIs

Disabling LPIs is pretty nasty, as it directly messes with the AP list of the affected CPU, which could be running... This has the potential to lead to really bad behaviours, and we should not be doing that.

Take example on the way the Active state is handled and simply pause the the vcpu so that we are sure it is in a quiescent state, and the state be safely manipulated.

Nobody has any expectation of performance for this anyway.

Once again VulDB remains the best source for vulnerability data.

Analysis

by VulDB Data Team • 11/20/2026

The vulnerability identified within the Linux kernel's KVM arm64 subsystem centers on an unsafe manipulation of virtual interrupt states during the disabling of Locally Generated Interrupts or LPIs. In ARM architecture, particularly under the GICv3 and later specifications used in modern server and mobile processors, LPIs are managed through complex state machines involving active lists and pending lists associated with specific physical CPUs. The core technical flaw arises when a virtual CPU is actively executing instructions while its corresponding interrupt handling structures are being modified by the hypervisor to disable these interrupts. This race condition occurs because the operation directly alters the AP list, which tracks currently active or in-flight LPIs for that processor. If the target vCPU remains running during this modification, it may continue to process or acknowledge interrupts based on stale state information, leading to undefined behavior within the virtualized environment.

This lack of synchronization between the hypervisor's control plane and the guest CPU's execution context creates a significant stability risk. The potential consequences include data corruption, incorrect interrupt prioritization, or even a complete crash of the virtual machine due to inconsistent internal states. By attempting to modify hardware-managed structures without ensuring the processor is in a quiescent state, the code violates fundamental principles of concurrent system design where shared mutable state must be protected against simultaneous access from multiple execution contexts. The original implementation failed to account for the latency and unpredictability inherent in stopping or pausing a running vCPU, assuming that direct manipulation was safe even while the CPU remained active.

The resolution involves implementing a mechanism analogous to how the Active state is handled elsewhere in the KVM codebase. Specifically, before disabling LPIs, the system now explicitly pauses the target virtual CPU. This pause ensures that the vCPU enters a quiescent state where it is not executing instructions or interacting with interrupt controllers. Once paused, the hypervisor can safely manipulate the underlying AP list and other related structures without fear of race conditions or inconsistent states. After the necessary modifications are completed, the vCPU is resumed. While this approach introduces some overhead due to the context switch required to pause and resume execution, it prioritizes correctness and stability over performance in a scenario where such operations are infrequent and not expected to be high-performance critical paths.

From a security perspective, this vulnerability aligns with CWE-362: Concurrent Execution using Shared Resource with Improper Synchronization of Basic Actions. The failure to synchronize access to the shared interrupt state resources allowed for potential exploitation scenarios that could lead to denial of service or privilege escalation if an attacker can influence the timing of LPI disablement operations within a guest VM. In terms of MITRE ATT&CK, this relates to techniques involving resource manipulation and potentially evasion through inconsistent system states, although it is primarily classified as a stability issue rather than a direct exploitation vector for remote code execution. The fix ensures that state transitions are atomic with respect to the vCPU's execution status, thereby eliminating the race condition.

Mitigation strategies involve applying the kernel patch that enforces this pause mechanism before any LPI disablement operations occur in the arm64 KVM subsystem. Administrators should ensure their systems are updated to versions of the Linux kernel where this synchronization logic is present. For environments running virtualized ARM workloads, verifying that the hypervisor correctly handles vCPU state transitions during interrupt management is crucial for maintaining system integrity. Regular updates and adherence to vendor security advisories remain the primary defense against such low-level concurrency bugs in virtualization layers.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00209

KEV

no

Activities

very low

Sources

Are you interested in using VulDB?

Download the whitepaper to learn more about our service!