Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain local user access to msm DRM device
-
DeliveryExport GPU submit/VM_BIND fence to userspace
-
ExploitTrigger ringbuffer/VM object free
-
ExecutionCall SYNC_IOC_FILE_INFO on stale fence
-
ImpactRead freed kernel slab memory
Vulnerability Assessment
| Exploitation Conditions | Requires local access to the msm DRM device node (/dev/dri/*) on a system running the Linux kernel's drm/msm driver - i.e., Qualcomm Adreno GPU hardware; this flaw is NOT present on x86 or non-Qualcomm configurations where the msm driver is not loaded. The attacker must (1) obtain a fence exported to userspace - a submit out-fence or a VM_BIND fence delivered via sync_file or drm_syncobj - and (2) cause the containing msm_ringbuffer or msm_gem_vm object to be freed, then (3) invoke SYNC_IOC_FILE_INFO against the stale fence to reach drm_sched_fence_get_timeline_name(). Limiting factors: exploitation is strictly local (AV:L), needs a valid local login/session with GPU access, depends on the specific msm driver being built/loaded, and is bounded by the RCU timing window the fix closes; no user interaction by a victim is required. |
| Impact | This is a genuine but comparatively low-urgency flaw. The CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:H, base 7.1 HIGH) correctly reflects that exploitation is LOCAL and requires a logged-in, low-privileged user - not remotely reachable. All real-world exploitation signals point low: EPSS is 0.21% (10th percentile), it is NOT listed in CISA KEV, and no public exploit code was identified in the provided data. These signals are mutually consistent - a local-only kernel info-leak in a hardware-specific driver is exactly the kind of issue that scores HIGH on technical impact (C:H kernel memory disclosure, A:H potential kernel crash) yet shows negligible mass-exploitation probability. The practical risk is as a secondary primitive: a local attacker or malicious app on affected Qualcomm/Adreno hardware could chain this slab use-after-free read into a broader privilege-escalation or KASLR-defeat effort, but it is not a standalone remote threat. Note the description emphasizes an information-disclosure READ (KASAN slab-use-after-free read), which aligns with C:H; the A:H rating is plausible because a UAF dereference of freed slab can also crash the kernel, though the writeup does not explicitly claim a weaponized DoS - treat A:H as inferred rather than demonstrated. |
| Exploit ScenarioDerived | A local unprivileged user (or malicious Android app) with access to the msm DRM device opens the GPU, submits work to obtain an exported out-fence (or a VM_BIND fence) via sync_file/drm_syncobj, then causes the containing ringbuffer or GEM VM object to be freed. Issuing SYNC_IOC_FILE_INFO on the still-held fence then triggers drm_sched_fence_get_timeline_name() to dereference the freed scheduler, reading stale kernel slab memory. No public proof-of-concept was identified at time of analysis, but the path is described concretely and is reachable without privilege. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 07, 2026
A slab use-after-free read in the Linux kernel's drm/msm driver (Qualcomm Adreno GPUs) allows a local, low-privileged user with access to the DRM device node to leak or corrupt freed kernel memory. The flaw arises because msm_ringbuffer_destroy() and msm_gem_vm_free() call drm_sched_fini() and then free objects that still embed a drm_gpu_scheduler with plain kfree(), while a signalled fence exported to userspace (submit out-fence or VM_BIND fence via sync_file/drm_syncobj) still points at that embedded scheduler; an unprivileged SYNC_IOC_FILE_INFO call then reaches drm_sched_fence_get_timeline_name() and dereferences the freed slab. Rated CVSS 7.1 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:H) with EPSS of only 0.21% (10th percentile) and no public exploit identified at time of analysis; the issue is confined to systems where the msm driver is built and loaded, and is fixed by freeing these scheduler-containing objects with kfree_rcu().
RemediationAI
Apply the upstream fix by updating to a kernel that free the scheduler-containing msm objects with kfree_rcu(): vendor-released patches are present in Linux 6.18.54, 7.2.8, and 7.3-rc4, and the corresponding stable backports are https://git.kernel.org/stable/c/d81bf4581903b0cba0698cd4d1c07fc6be21754a, https://git.kernel.org/stable/c/713abac5c04ccbae67f9ac68c3921845535388e7, and https://git.kernel.org/stable/c/01c8d1f385f788f1bbbbb7687c4386d614281218 (see also the advisory at https://nvd.nist.gov/vuln/detail/CVE-2026-98180 and the Patchwork submission https://patchwork.freedesktop.org/patch/750234/); pick the backport matching your distribution's kernel branch or apply the distro-supplied update when it lands. Where patching must be deferred, the most effective compensating control is to restrict access to the DRM device nodes (/dev/dri/card* and /dev/dri/renderD*) to trusted local users or groups, since exploitation is strictly local and requires opening the msm device and exporting a fence; this trade-off removes GPU access for untrusted local sessions and may break desktop or compute workloads that rely on them. On servers that do not need Adreno acceleration, blacklisting or not building the msm module removes the attack surface entirely, at the cost of disabling the GPU subsystem. Because the underlying defect is a use-after-free tied to the RCU grace period, there is no reliable runtime toggle to close it short of the fix, and monitoring for SYNC_IOC_FILE_INFO abuse after fence teardown provides only detection, not prevention. Note that no public exploit code was identified at time of analysis and EPSS is low (0.21%, 10th percentile), so prioritise patching according to exposure of Adreno-based systems rather than as an emergency.
Affected VersionsENISA
Affected Packages
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 drm/msm driver embeds a struct drm_gpu_scheduler inside both struct msm_ringbuffer and struct msm_gem_vm. On teardown, msm_ringbuffer_destroy() and the VM free callback msm_gem_vm_free() call drm_sched_fini() on the embedded scheduler and then release the container with plain kfree(). This violates the dma-fence lifetime contract, which requires the exporter to keep the data backing a signalled fence alive for an RCU grace period: drm_sched_fence_get_timeline_name() returns fence->sched->name, and the scheduler fence deliberately keeps its .release callback so it is not ops-detached on signalling. A finished fence already exported to userspace through sync_file or drm_syncobj therefore continues to reference the embedded scheduler after the ring or VM object has been freed. When userspace later queries that fence - reachable unprivileged via the SYNC_IOC_FILE_INFO ioctl on the sync_file/syncobj - the driver reads fence->sched->name from reclaimed slab memory, which KASAN reports as a slab-use-after-free read. The root cause class is use-after-free (no CWE was assigned in the input data); the correct fix is to defer reclamation with kfree_rcu() so objects containing a drm_gpu_scheduler survive the required RCU grace period. Because the affected structures are specific to drm/msm, the weakness is not present on x86 or other non-Qualcomm configurations where the msm driver is not loaded.
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
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:H
Reachable only via local ioctl by a logged-in low-privileged user (AV:L/PR:L), deterministic enough for AC:L; freed-slab read discloses kernel memory (C:H) and can crash the kernel (A:H), with no integrity impact (I:N).
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
4DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
drm/msm: RCU-free the scheduler-containing ring and VM objects
Both struct msm_ringbuffer and struct msm_gem_vm embed a struct drm_gpu_scheduler. msm_ringbuffer_destroy() and the VM free callback msm_gem_vm_free() call drm_sched_fini() on the embedded scheduler and then free the containing object with plain kfree().
drm_sched_fence_get_timeline_name() returns fence->sched->name, and the scheduler fence keeps a .release callback so it is not ops-detached on signalling. A finished fence exported to userspace (the submit out-fence, or a VM_BIND fence, via sync_file / drm_syncobj) keeps pointing at the embedded scheduler after the ring/VM is freed, so a later get_timeline_name() -- reachable unprivileged through SYNC_IOC_FILE_INFO -- dereferences freed slab memory (KASAN slab-use-after-free read).
Per the dma-fence lifetime contract the exporter must keep the data backing a signalled fence alive for an RCU grace period. Free the scheduler-containing objects with kfree_rcu() instead of kfree().
Patchwork: https://patchwork.freedesktop.org/patch/750234/
Executive ViewAI
Organizations using Linux-based devices with Qualcomm Adreno GPUs are exposed to a high-severity kernel memory corruption flaw in the drm/msm driver, which a local low-privileged user could exploit to leak or corrupt freed kernel memory. This could affect confidentiality and availability of affected devices, particularly Android, ChromeOS, or embedded systems. A vendor patch is available, and no public exploit identified at time of analysis, so remediation should be prioritized for systems where the msm driver is loaded.
Apply vendor patch.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-93108
GHSA-h748-767h-vm7p
NVD
CVE.org
EPSS
VulDB
Exploit-DB