Skip to main content

Linux Kernel CVE-2026-98520

| EUVDEUVD-2026-103760 HIGH
2026-10-18 Linux GHSA-x886-mwj9-qhhg
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Gain local access to /dev/kfd in SRIOV guest
  2. Delivery
    Map doorbell and MMIO ranges
  3. Exploit
    First container exits, freeing cached inode
  4. Execution
    GPU reset dereferences dangling address_space
  5. Impact
    Reset workqueue hangs; stale MMIO/doorbell pages remain exposed

Vulnerability Assessment

Exploitation Conditions

Exploitation requires an AMD GPU operating in SRIOV (virtual function) mode with MULTIPLE containers each opening /dev/kfd - the description states both bugs 'manifest under SRIOV with multiple containers.' The use-after-free is triggered when the first /dev/kfd opener's container exits (releasing the inode whose address_space was cached in kfd_dev_mapping) and a GPU reset subsequently calls unmap_mapping_range() on the freed inode. Limiting factors that reduce real-world risk: the attacker needs local access to the /dev/kfd device (not remote), the deployment must use AMD KFD under SRIOV with container isolation (a datacenter-GPU-virtualization-specific configuration, not a default desktop/server setup), and the dangling-pointer dereference depends on a GPU reset occurring after container teardown. Single-container or non-SRIOV deployments are not affected by the manifested bugs.

Impact

Signals point consistently to a moderate, environment-specific priority rather than a broad emergency. The provided CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N, C:H/I:H/A:H = 7.8 High) establishes a local, authenticated attack surface - not network-reachable - which already caps real-world exposure. EPSS reinforces this: 0.20% (9th percentile) indicates very low predicted exploitation probability. There is no CISA KEV listing and no exploit/PoC reference in the input (the only references are the upstream kernel.org fix commits), so exploitation status is 'no public exploit identified at time of analysis.' The vuln.today decision label is 'this_week,' consistent with a patch-promptly posture rather than act_now/emergency. The crucial contextualizing fact from the description is that both bugs 'manifest under SRIOV with multiple containers' - the dangling address_space (use-after-free / i_mmap_rwsem deadlock) and the multi-container mapping gap are only reachable in AMD GPU SRIOV virtualization deployments where multiple containers open /dev/kfd. One tension to flag explicitly: the input Tags label this 'Information Disclosure,' but the description primarily documents a use-after-free leading to an uninterruptible kernel hang (NMI panic on the GPU reset workqueue) plus stale doorbell/MMIO exposure - the dominant observed impact is availability/DoS, with information exposure as a secondary effect. CWE is N/A in the input, so the weakness classification is not independently confirmed. Net: a legitimately serious kernel UAF for the narrow set of AMD datacenter-GPU SRIOV operators, but low urgency for the general Linux population.

Exploit ScenarioDerived

In an AMD GPU SRIOV deployment running multiple containers, a local user in the first container opens /dev/kfd (caching its inode's address_space) and then that container exits, freeing the inode. A later GPU reset path calls unmap_mapping_range() on the now-dangling pointer, taking i_mmap_rwsem on freed memory and hanging the reset workqueue (NMI panic); separately, mappings from other containers are never zapped, leaving doorbell/MMIO pages accessible with no GPU behind them. No public exploit code is referenced - only the upstream fix commits are provided.

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 – Oct 24, 2026

A use-after-free and a mapping-coverage gap in the Linux kernel's amdgpu/amdkfd driver (kfd_dev_mapping) can hang or destabilize AMD GPUs running under SRIOV with multiple containers. The driver caches the address_space of only the first /dev/kfd opener, so when that container exits the cached inode is freed while the GPU reset path still dereferences it in unmap_mapping_range(), producing an uninterruptible i_mmap_rwsem wait; VMAs belonging to later openers are also never zapped, leaving stale doorbell and MMIO pages mapped after a reset. The vendor-rated score is 7.8 (High) while the independent assessment applies AC:H, reflecting that exploitation is authenticated/local and requires a specific SRIOV multi-container AMD KFD deployment plus a GPU reset after container teardown. No public exploit has been identified at time of analysis (EPSS 0.20%, 9th percentile, no KEV), and vendor patches are available.

RemediationAI

Vendor-released patch: Linux 7.2.9 and Linux 7.3-rc5, delivered through the stable commits https://git.kernel.org/stable/c/c3a31087b1c8df679b653c1a09d9abe5ff7ec8ef and https://git.kernel.org/stable/c/02b74891624e09a5512c6d84f267d01fcc306a3b (the former is the cherry-picked fix from commit 1128b4a52de1572e87431de837fd9850cb99542c); apply the kernel update on any host or guest exposing an AMD GPU to KFD, particularly SRIOV virtual-function deployments running multiple containers. The available references document no vendor-supplied workaround, and the change replaces the cached first-opener address_space with a module-owned anonymous inode, so updating is the only complete fix. As operational hedging until the update is applied, limit which containers receive /dev/kfd - restricting the device to a single container at a time avoids both the container-exit dangling-pointer sequence and the unzapped-VMA gap, at the cost of losing multi-tenant GPU sharing - and avoid triggering GPU resets while a container that previously opened /dev/kfd is being torn down.

Affected VersionsENISA

Linux 7.2
Linux 70cadefcc6160c575b04f763ada34c20e868d577 <c3a31087b1c8df679b653c1a09d9abe5ff7ec8ef
Linux patch: 0
Linux patch: 7.2.9
Linux patch: 7.3-rc5
Linux 70cadefcc6160c575b04f763ada34c20e868d577 <02b74891624e09a5512c6d84f267d01fcc306a3b

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

The affected code is the Kernel Fusion Driver (KFD) within the amdgpu DRM driver, which exposes /dev/kfd to userspace and maps GPU doorbell and MMIO ranges into process address spaces. kfd_dev_mapping was designed to retain the address_space of the first /dev/kfd opener so that the GPU reset worker (amdgpu_device_gpu_recover -> amdgpu_amdkfd_clear_kfd_mapping -> kfd_dev_unmap_mapping_range) could call unmap_mapping_range() and invalidate those userspace mappings. This is a lifetime and aliasing defect in the use-after-free class (no CWE identifier was supplied in the input): the cached pointer references an inode owned by the first opener's container, so container exit frees the inode and any subsequent reset dereferences a dangling pointer, taking i_mmap_rwsem on freed memory and hanging the reset workqueue in rwsem_down_read_slowpath. Separately, because only one address_space is cached, VMAs created by additional openers live in different address_spaces and are never reached by unmap_mapping_range(), so stale doorbell/MMIO mappings survive a reset and can cause PCIe transaction timeouts or NMI panics. The upstream fix mirrors drm_drv.c: a private pseudo-filesystem is created at module init, an anonymous inode is allocated from it, and every opener's file->f_mapping is redirected to that single module-owned address_space, collecting all VMAs in one place with no dangling-pointer exposure. The trigger path described in the sources requires SRIOV virtualization with multiple containers each opening /dev/kfd; single-container and non-SRIOV deployments are not described as exhibiting either bug.

Know when the next one hits your stack

  • 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 7.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 7.0 HIGH

Local /dev/kfd access (AV:L/PR:L); UAF depends on a race between container/inode teardown and GPU reset (AC:H); kernel-memory corruption plus hang justify C/I/A:H.

3.1 AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:P/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (Linux).

CVSS VectorVendor: Linux

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

Lifecycle Timeline

4
CVSS changed
Oct 24, 2026 - 14:22 NVD
7.8 (HIGH)
Patch available
Oct 18, 2026 - 16:02 EUVD
CVE Published
Oct 18, 2026 - 15:17 cve.org
HIGH 7.8
CVE Published
Oct 18, 2026 - 15:17 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

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

drm/amdkfd: fix use-after-free and multi-container gap in kfd_dev_mapping

kfd_dev_mapping caches the address_space of the first /dev/kfd opener so that the GPU reset path can call unmap_mapping_range() to zap all userspace mappings of doorbell and MMIO ranges. This design has two bugs that both manifest under SRIOV with multiple containers:

  1. Use-after-free / rwsem deadlock. The cached pointer refers to an

inode owned by the first opener's container. When that container exits and its inode is released, kfd_dev_mapping becomes a dangling pointer. A subsequent GPU reset dereferences it inside unmap_mapping_range(), which takes i_mmap_rwsem on the freed inode, causing a hard hang observable as an uninterruptible rwsem wait.

  1. Multi-container gap. Only the first opener's address_space is cached;

VMAs created by later openers live in a different address_space and are never reached by unmap_mapping_range(). After a GPU reset those stale mappings keep doorbell and MMIO pages accessible to guest userspace with no GPU behind them, risking PCIe transaction timeouts and NMI panics.

Fix both bugs with the same approach used by DRM core (drm_drv.c): create a private pseudo-filesystem at module init time and allocate one anonymous inode from it. In kfd_open() redirect every opener's file->f_mapping to that inode's address_space. The inode is module-owned, lives exactly as long as the amdgpu module, and collects VMAs from all openers in one address_space. A single unmap_mapping_range() call in the reset path then correctly reaches every container's mappings with no dangling pointer risk.

The hang manifests as an NMI backtrace on the GPU reset workqueue stuck spinning in rwsem_down_read_slowpath() with a corrupted i_mmap_rwsem:

Workqueue: amdgpu-reset-dev xgpu_ai_mailbox_flr_work [amdgpu] Call Trace: <TASK> kvm_wait+0x1f/0x40 __pv_queued_spin_lock_slowpath+0x31d/0x3a0 _raw_spin_lock_irq+0x51/0x80 rwsem_down_read_slowpath+0xb3/0x550 down_read+0x48/0xd0 unmap_mapping_range+0x71/0x140 kfd_dev_unmap_mapping_range+0x5b/0x140 [amdgpu] amdgpu_amdkfd_clear_kfd_mapping+0xd8/0x190 [amdgpu] amdgpu_device_gpu_recover+0x232/0x450 [amdgpu] xgpu_ai_mailbox_flr_work+0xb5/0xc0 [amdgpu] process_one_work+0x18e/0x3e0 worker_thread+0x2e3/0x420 kthread+0x10a/0x230

(cherry picked from commit 1128b4a52de1572e87431de837fd9850cb99542c)

Executive ViewAI

Why It Matters

CVE-2026-98520 is a high-severity flaw in the Linux kernel's AMD GPU driver that can cause GPU instability or unresponsiveness on systems using AMD SRIOV with multiple containers. Only organizations running such specialized deployments are affected, but for those, a container exit followed by a GPU reset can disrupt AI/ML or VDI workloads, requiring manual recovery. Leadership should ensure timely patching to prevent operational disruption.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 91% exploitable
Prevalence
Low
only reachable in niche AMD GPU SRIOV multi-container virtualization deployments
Data Quality
4 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
Medium

Priority Score

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

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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