Skip to main content

Linux KVM CVE-2026-89928

| EUVDEUVD-2026-80528 HIGH
2026-09-16 Linux GHSA-f7hc-2wxr-4jfg
8.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Run malicious/local KVM guest on host
  2. Delivery
    Drive concurrent SPTE rmap population and zap
  3. Exploit
    Race lockless aging walk in elision window
  4. Execution
    Walker follows freed pte_list_desc chain
  5. Persist
    Slab use-after-free corrupts host kernel
  6. Impact
    Host crash / denial of service

Vulnerability Assessment

Exploitation Conditions

Exploitation requires the host kernel to be built with CONFIG_KVM_MMU_LOCKLESS_AGING=y, so that kvm_rmap_age_gfn_range() runs the rmap aging walk without holding mmu_lock. The attacker must win a race: a writer holding mmu_lock for write must populate a KVM_RMAP_MANY rmap during the lock-elision window (rmap observed empty) and then free the pte_list_desc chain (e.g. via kvm_zap_all_rmap_sptes on the recycle path or any rmap zap) while the lockless aging walk is in progress. Limiting factors: this is local (AV:L per CVSS) and requires the privilege to operate a KVM guest / drive host MMU state (PR:L, no PR:N); no user interaction; it is timing-dependent (a scheduling-delay-sized race window, not deterministic); and the aging path is invoked by host memory reclaim rather than at attacker will, so triggering is opportunistic. Affected versions are Linux 6.15 through the fixes in 6.18.51, 7.2.5, and 7.3-rc1.

Impact

This is a slab use-after-free arising from a race condition (CWE-416/CWE-362) in KVM x86/mmu's lockless rmap aging path, not a remote-code-execution issue. The vendor CVSS of 8.8 (AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H) overstates real-world risk on two counts. First, AC:L is inconsistent with the description, which centers on a narrow timing window: a writer must populate the rmap between the lock's read and the iterator's re-read while the aging path (kvm_rmap_age_gfn_range) runs lockless - this is a race, so AC:H is more honest. Second, the description is DoS-dominant (walking a freed pte_list_desc chain → slab corruption/crash); C:H/I:H are speculative absent a demonstrated read/write-primitive exploit, so C:N/I:L/A:H better reflects the described impact. No EPSS score, no CISA KEV listing, and no public exploit are present - consistent with a freshly-published upstream Linux fix. Exploitation status: no public exploit identified at time of analysis. The aging path is triggered by host memory reclaim (an MMU notifier), not directly by an attacker clock, further raising the difficulty of deterministic exploitation. CONFLICT TO VERIFY: the input 'RCE' tag contradicts the description, which describes a use-after-free leading to host instability, not remote code execution - treat the RCE label as incorrect. CVSS AV:L is consistent with the local (guest/host) nature of the flaw.

Exploit ScenarioDerived

A local attacker who can run a KVM guest (or otherwise drive host MMU rmap population/zapping) races SPTE writes against the host's lockless page-aging walk while CONFIG_KVM_MMU_LOCKLESS_AGING=y. If a writer installs a KVM_RMAP_MANY rmap in the elision window and then frees the pte_list_desc chain via a zap/recycle path, the unsynchronized aging walker dereferences freed slab memory, corrupting host kernel state and crashing the host. No public proof-of-concept is known; the timing-dependent nature makes reliable triggering difficult.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Sep 16, 2026

Slab use-after-free in the Linux kernel's KVM x86 MMU lockless rmap aging path affects hosts running Linux 6.15 through 6.18.50 and 7.x before 7.2.5 that are built with CONFIG_KVM_MMU_LOCKLESS_AGING=y. A local user able to run or drive a KVM guest (PR:L, no user interaction) can race the lock-elision window so that a writer populates a KVM_RMAP_MANY rmap and later frees its pte_list_desc chain while the lockless aging walk is still traversing it, yielding memory corruption of kernel slab memory; the race is timing-dependent (AC:H) and is driven by host memory reclaim rather than attacker-controlled scheduling, so exploitation is opportunistic rather than deterministic. No proof-of-concept or public exploit code has been identified at time of analysis and there is no evidence of active exploitation. Vendor scoring is 8.8 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H), while independent assessment rates it 6.3 with AC:H and no confidentiality impact, reflecting the narrow, reclaim-triggered race window; it is a local privilege/DoS-class memory-safety bug, not a remote code execution issue despite the 'RCE' tag on the record.

RemediationAI

Vendor-released patch: update to Linux 6.18.51, 7.2.5, or 7.3-rc1 (or later), which contain the lockless-rmap fix; equivalents are the upstream stable commits e428f9779a43737d830111238816f1928b07aefb, 8edb3c09e43f7cd8a5dfd291c6e0fc9c74d4621d and 41debfc98526c0a95c41a62435aca0a70340a26d (see https://git.kernel.org/stable/c/41debfc98526c0a95c41a62435aca0a70340a26d and https://nvd.nist.gov/vuln/detail/CVE-2026-89928). If immediate upgrade is not possible, the most direct compensating control is rebuilding the kernel without CONFIG_KVM_MMU_LOCKLESS_AGING, which disables the lockless aging optimization so the aging walk is serialized by mmu_lock and the race cannot occur; the trade-off is increased mmu_lock contention and reduced memory-reclaim scalability on hosts with heavily shared guest memory. Additionally, restrict KVM use to trusted local accounts (the vector requires PR:L, i.e. the ability to operate or drive a KVM guest), and avoid running untrusted tenants on kernels within the affected range, since the trigger is a memory-reclaim-driven race rather than something a guest can force deterministically. Note that disabling KVM or nested virtualization entirely removes the attack surface but is impractical for virtualization hosts, and monitoring for guest-triggered kernel slab corruption or unexpected host crashes can provide detection coverage while patching is staged.

Affected VersionsENISA

Linux patch: 7.3-rc1
Linux af3b6a9eba48419732b07a0472db7160282f0f39 <e428f9779a43737d830111238816f1928b07aefb
Linux patch: 7.2.5
Linux af3b6a9eba48419732b07a0472db7160282f0f39 <8edb3c09e43f7cd8a5dfd291c6e0fc9c74d4621d
Linux af3b6a9eba48419732b07a0472db7160282f0f39 <41debfc98526c0a95c41a62435aca0a70340a26d
Linux patch: 0
Linux 6.15
Linux patch: 6.18.51

Affected Packages

euvd linux no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

KVM's x86 MMU maintains reverse mappings (rmaps) from guest page-table pages back to the SPTEs that reference them; for highly-shared pages these are stored as a pte_list_desc chain (KVM_RMAP_MANY) allocated from the slab cache. The affected code is the lockless aging walk used to clear the Accessed bit via kvm_rmap_age_gfn_range(), which is only permitted to run without mmu_lock when CONFIG_KVM_MMU_LOCKLESS_AGING=y. __kvm_rmap_lock() deliberately elides the rmap lock when it observes an empty rmap and documents the invariant that only mmu_lock-for-write paths can process empty rmaps, so lockless walkers can never see one appear mid-walk. kvm_rmap_age_gfn_range() broke that invariant by ignoring the lock helper's return value and unconditionally entering for_each_rmap_spte_lockless(); the iterator's rmap_get_first() then re-read rmap_head->val instead of consuming the value the lock had already validated. If a writer installs an rmap between the lock's read and the iterator's re-read, the aging walk follows a pte_list_desc chain it never locked, and because the elided path also re-enables preemption the gap between the two reads can span an arbitrary scheduling delay wide enough for kvm_zap_all_rmap_sptes() or any rmap zap to kmem_cache_free() the same chain. The upstream fix splits rmap_get_first() into __rmap_get_first(), which seeds an iterator from an already-read rmap value, and changes for_each_rmap_spte_lockless() to take that value directly; kvm_rmap_age_gfn_range() now passes the value returned by kvm_rmap_lock_readonly(), so an elided lock (value zero) yields NULL from __rmap_get_first() and the walk is skipped, adding no unbalanced lock()/unlock() path. The record lists CWE as N/A, but the defect class is CWE-416 (use-after-free) compounded by CWE-362 (concurrent execution using shared resource with improper synchronization), and the only CPE in scope is the generic linux:linux kernel product identifier.

Know when KVM gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (Linux) PRIMARY 8.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H
vuln.today AI 6.4 MEDIUM

Local guest/host trigger (AV:L, PR:L); a scheduling-window race gives AC:H; guest→host kernel corruption is S:C; impact is DoS-dominant (A:H) with at most incidental integrity effect and no confidentiality primitive shown.

3.1 AV:L/AC:H/PR:L/UI:N/S:C/C:N/I:L/A:H
4.0 AV:L/AC:H/AT:N/PR:L/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
SUSE 5.8 MEDIUM
AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:L/A:H
Red Hat 7.0 MEDIUM

Primary rating from Vendor (Linux).

CVSS VectorVendor: Linux

Attack Vector
Local
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Changed
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

4
CVSS changed
Sep 16, 2026 - 15:22 NVD
8.8 (HIGH)
Patch available
Sep 16, 2026 - 11:03 EUVD
CVE Published
Sep 16, 2026 - 10:32 cve.org
UNKNOWN (no severity yet)
CVE Published
Sep 16, 2026 - 10:32 cve.org
HIGH 8.8

DescriptionCVE.org

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

KVM: x86/mmu: Consume the locked rmap value in the lockless rmap walk

__kvm_rmap_lock() deliberately elides the rmap lock when it observes an empty rmap. In that case kvm_rmap_lock_readonly() also re-enables preemption and returns zero, so the caller holds neither the rmap lock nor a preemption reference. The elision documents the invariant it relies on:

  • Elide the lock if the rmap is empty, as lockless walkers (read-only
  • mode) don't need to (and can't) walk an empty rmap, nor can they add
  • entries to the rmap. I.e. the only paths that process empty rmaps
  • do so while holding mmu_lock for write, and are mutually exclusive.

kvm_rmap_age_gfn_range() ignores the returned value and unconditionally enters for_each_rmap_spte_lockless(). The iterator started with rmap_get_first(), which re-reads rmap_head->val rather than using the value returned by the lock. If a writer populates the rmap between the lock's read and the iterator's re-read, the aging path walks the newly installed rmap without holding its lock.

For a KVM_RMAP_MANY rmap this leaves the walker following a pte_list_desc chain that it never locked. A writer holding mmu_lock for write may free that chain (e.g. kvm_zap_all_rmap_sptes() on the recycle path, or any rmap zap) via kmem_cache_free() while the walk is in progress, giving a slab use-after-free. Nothing serialises the two: the aging path runs without mmu_lock when CONFIG_KVM_MMU_LOCKLESS_AGING=y, and the rmap lock that would otherwise exclude the writer was elided. Because the empty path re-enables preemption, the interval between the two reads can span an arbitrary scheduling delay.

Fix the class of bug by having the lockless walk consume the value returned by the lock instead of re-reading the rmap. Split rmap_get_first() into __rmap_get_first(), which starts an iterator from an already-read rmap value, and make for_each_rmap_spte_lockless() take that value and call __rmap_get_first() directly. kvm_rmap_age_gfn_range() passes the value returned by kvm_rmap_lock_readonly(): when the lock was elided the value is zero, __rmap_get_first() returns NULL, and the walk is skipped. No lockless walker re-reads the rmap, so the lock-elision invariant cannot be violated, and no lock()-without-paired-unlock() path is added to the aging code.

Executive ViewAI

Why It Matters

A high-severity vulnerability in the Linux kernel's KVM virtualization component affects hosts running Linux 6.15 through 6.18.50 and 7.x before 7.2.5 with CONFIG_KVM_MMU_LOCKLESS_AGING=y. A local authenticated user with the ability to run or drive a KVM guest could exploit a timing-dependent race condition to corrupt kernel memory, potentially leading to host compromise or instability. While no public exploit identified at time of analysis, the flaw poses a significant risk to organizations relying on KVM-based virtualization for multi-tenant or critical workloads, as a successful attack could affect all guests on the host.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 95% exploitable
Prevalence
Medium
KVM x86 is broadly deployed on cloud/virtualization hosts, but flaw needs a specific config and race
Data Quality
5 sources
Confidence: Medium

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

More in KVM

View all
CVE-2026-27211 CRITICAL
10.0 Feb 21

Arbitrary host file exfiltration from Cloud Hypervisor VMM versions 34.0-50.0. CVSS 10.0. Patch available.

CVE-2026-89930 CRITICAL
9.3 Sep 16

Incorrect handling of queued local TLB flushes in the Linux kernel's KVM nested-VMX (nVMX) implementation can leave stal

CVE-2026-89918 CRITICAL
9.3 Sep 16

Address-rollover bug in the Linux kernel's KVM/arm64 TLB-by-VA invalidation path causes the hypervisor to silently skip

CVE-2026-89916 CRITICAL
9.3 Sep 16

Race conditions in the arm64 KVM path that invalidates VNCR translations can leave a stale stage-1 TLB entry installed f

CVE-2026-89915 CRITICAL
9.3 Sep 16

Missed TLB invalidations in the arm64 KVM nested-virtualization path of the Linux kernel can leave stale translations fo

CVE-2026-89914 CRITICAL
9.3 Sep 16

Range-based TLB invalidation in the arm64 KVM hypervisor of the Linux kernel is computed against the wrong address range

CVE-2026-89913 HIGH
8.8 Sep 16

A use-after-free race in the arm64 KVM vGICv3 code path of the Linux kernel (vgic_v3_save_pending_tables) allows a local

CVE-2026-89959 HIGH
8.8 Sep 16

The s390 vfio-ap mediated device (mdev) driver in the Linux kernel fails to actually revoke crypto control-domain access

CVE-2026-89957 HIGH
8.8 Sep 16

Stale hardware access to unplugged crypto resources in Linux KVM guests on IBM Z (s390) stems from a logic error in the

CVE-2026-89932 HIGH
8.8 Sep 16

Stale TLB entries can be reused by an L2 guest in the Linux kernel's KVM nested virtualization (nVMX) implementation on

CVE-2026-89929 HIGH
8.8 Sep 16

Linux kernel's KVM nested-VMX (nVMX) emulation can leave stale L2 guest TLB entries on a physical CPU, because KVM execu

CVE-2026-89908 HIGH
8.8 Sep 16

On LoongArch hosts running KVM, a memory-slot update that changes only flags (KVM_MR_FLAGS_ONLY, most notably toggling K

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Not-Affected
SUSE Linux Enterprise Desktop 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 16.0 Not-Affected

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy