CVE-2026-52987: Linux AMD GPU Double-Free Kernel Vulnerability

Technical summary

CVE-2026-52987 is a double-free vulnerability in amdgpu's userspace queue (userq) validation logic within the Linux kernel DRM subsystem. Specifically, in the amdgpu_userq_vm_validate() function, when the new_addition flag is set to true, drm_exec_fini() is called prematurely to finalize an execution context. If subsequent calls to amdgpu_ttm_tt_get_user_pages() fail while iterating over HMM (heterogeneous memory management) ranges, the error handler incorrectly invokes drm_exec_fini() a second time on the same exec object. Since drm_exec_fini() deallocates exec->objects and manipulates the acquire context without idempotent safeguards, this double-finalization corrupts kernel data structures. The fix routes the error path directly to range cleanup after the first finalization, preventing the duplicate call.

Business impact

Organizations running AMD GPU-accelerated workloads on Linux systems face localized stability and security risks. Exploitation could lead to system crashes, denial of service to GPU-dependent applications, or privilege escalation depending on kernel memory layout and attack sophistication. For enterprises using AMD GPUs for high-performance computing, machine learning, or rendering pipelines, unpatched systems may experience unexpected service interruptions or, in worst-case scenarios, container escape or kernel privilege escalation if the double-free is weaponized.

Affected systems

The vulnerability affects the Linux kernel's AMD GPU (amdgpu) driver. Specifically, it impacts systems with AMD discrete or integrated GPUs that use the userspace queue validation feature in the DRM (Direct Rendering Manager) subsystem. The vulnerability exists in kernel versions containing the affected amdgpu_userq_vm_validate() code path and only manifests when userspace GPU operations trigger the new_addition validation logic. Verify your kernel version against the Linux distribution's advisory for precise affected ranges.

Exploitability

Exploitation requires local system access with standard user-level privileges. An attacker cannot exploit this remotely. The attack surface is limited to scenarios where a user with GPU access can trigger the userq validation path—typically through graphics applications or compute frameworks that use the AMD GPU driver's user-mode queues. The double-free condition is triggered by intentionally causing amdgpu_ttm_tt_get_user_pages() to fail during validation, which may be feasible by manipulating memory availability or passing crafted GPU commands. While a CVSS score of 7.8 reflects high severity, actual exploitation for privilege escalation depends on kernel memory layout and protection mechanisms in place.

Remediation

Apply the upstream Linux kernel patch cherry-picked from commit 2802952e4a07306da6ebe813ff1acacc5691851a. This patch restructures the error-handling path in amdgpu_userq_vm_validate() to skip the redundant drm_exec_fini() call when exec has already been finalized, ensuring the error path routes directly to HMM range cleanup. Consult your Linux distribution (Ubuntu, Red Hat, SUSE, etc.) for backported kernel updates that include this fix. If running a custom kernel, apply the patch directly to the amdgpu driver code.

Patch guidance

Contact your Linux distribution maintainer for the exact kernel version incorporating this fix. Major distributions typically track upstream Linux kernel patches and release them in regular kernel updates. For Red Hat-based systems, check errata advisories; for Ubuntu, monitor security updates; for SUSE, consult the SUSE Security Advisories. If you maintain a custom kernel, apply the commit 2802952e4a07306da6ebe813ff1acacc5691851a directly to your amdgpu driver source tree, recompile, and validate in a test environment before production deployment. Verify functionality of GPU workloads post-patching.

Detection guidance

Monitor kernel logs for messages related to amdgpu driver failures, HMM range management errors, or GPU validation timeouts that correlate with application crashes or system instability. Use tools like dmesg and journalctl to examine DRM subsystem warnings and errors. In live systems, kprobes or eBPF-based tools can hook drm_exec_fini() calls to detect multiple invocations on the same exec object. Performance monitoring of GPU applications for unexpected terminations or resource leaks may indicate exploitation attempts. Audit access to /dev/dri/* device nodes to understand which users and processes interact with the GPU driver.

Why prioritize this

This vulnerability merits high priority because: (1) it affects a widely-used kernel subsystem with HIGH severity; (2) it requires only local user-level access, lowering the attack bar; (3) exploitation can lead to denial of service or kernel privilege escalation; (4) GPU-accelerated computing is increasingly common in data centers and developer workstations; (5) the double-free pattern is a well-understood kernel exploitation vector. Organizations relying on AMD GPUs should prioritize patching.

Risk score, explained

The CVSS 3.1 score of 7.8 (HIGH) reflects: Attack Vector Local (system access required), Attack Complexity Low (no special conditions beyond triggering the validation path), Privileges Required Low (standard user access sufficient), User Interaction None (automatic exploitation possible), Scope Unchanged (impact confined to the affected system), and impacts all three CIA triad pillars—Confidentiality High (kernel memory may be read), Integrity High (memory corruption possible), Availability High (denial of service or system crash). The score does not account for mitigation by SMEP/SMAP if present, but those protections may be circumvented through sophisticated exploitation.

Frequently asked questions