CVE-2026-52951: Linux Xe DRM DMA-buf Race Condition – Local DoS via GPU Memory Import

Technical summary

CVE-2026-52951 addresses two distinct race conditions in the xe DRM driver's DMA buffer handling code. First, the driver performs xe_bo_alloc() and attach operations before completing the full buffer object initialization in xe_dma_buf_init_obj(). Since the buffer becomes visible on the attachments list post-attach, external exporter drivers can invoke the invalidate_mappings callback with an incomplete buffer object. Second, if xe_bo_init_locked() fails after attachment but before full initialization, the buffer is freed while still referenced by the DMA-buf subsystem, leading to use-after-free when invalidate_mappings is subsequently triggered. The fix reorders operations to defer the attach step until after full buffer object initialization, eliminating both race windows. The vulnerability is rooted in initialization ordering issues rather than logical flaws in the core invalidation logic.

Business impact

This vulnerability poses a denial-of-service risk to systems using Intel Xe GPUs with AMD GPU memory imports. Customer reports indicate null pointer dereferences in the evict_flags code path during GPU memory eviction, resulting in kernel crashes. While the race condition has a low hit rate, it affects production workloads involving GPU memory sharing between vendors. Systems relying on GPU compute or graphics tasks leveraging cross-vendor memory imports face service interruption risk until patched.

Affected systems

The vulnerability affects Linux kernel systems running the Xe DRM driver with Intel discrete GPUs, specifically in scenarios where GPU memory is imported from AMD GPUs via DMA-buf. The impact is isolated to the kernel's graphics subsystem and requires active GPU memory sharing between Intel and AMD devices. Systems using only Intel or only AMD GPUs, or those not utilizing DMA-buf-based memory sharing, are unaffected. The vulnerability was likely introduced in earlier Xe driver versions and persists until the ordering fix is applied.

Exploitability

Exploitation requires local system access and an active DMA-buf memory import operation between Intel Xe and AMD GPU drivers. The race condition cannot be reliably triggered remotely or without GPU compute/graphics workload execution. However, the low reported hit rate suggests the race window is narrow but inevitable under certain timing conditions. An attacker with local access capable of triggering GPU memory imports could craft workloads to increase collision probability, but this requires elevated privileges or user-level access to GPU drivers. The vulnerability is not listed in the CISA Known Exploited Vulnerabilities catalog.

Remediation

Apply the Linux kernel patch that reorders buffer object initialization and attachment operations. The fix ensures xe_bo_alloc(), xe_bo_init_locked(), and full initialization complete before the attach step is performed. This eliminates the window where external drivers can access incomplete or freed buffer objects. Verify the fix is present in your kernel build via commit af1f2ad0c59fe4e2f924c526f66e968289d77971 or later Xe driver updates. No workarounds are available for unpatched systems beyond disabling GPU memory imports or restricting GPU workloads.

Patch guidance

Identify your Linux kernel version and Xe driver build date. Check the kernel changelog or git log for commit af1f2ad0c59fe4e2f924c526f66e968289d77971 or later Xe-related initialization fixes. For enterprise distributions, monitor vendor advisories for stable kernel updates incorporating this patch. Test patched kernels in a non-production environment with GPU memory import workloads to confirm stability before deployment. If running a vendor-provided kernel (RHEL, Ubuntu, etc.), await the distribution's official patched kernel release; do not manually backport without validation.

Detection guidance

Monitor kernel logs for null pointer dereferences in the Xe DRM driver's evict_flags or invalidate_mappings code paths, particularly when importing GPU memory from AMD devices. Enable kernel debugging and collect crash dumps if available. Use `dmesg` to identify patterns of GPU-related faults during memory-intensive compute or graphics workloads involving cross-vendor GPU memory sharing. Systems without active DMA-buf imports between Intel Xe and AMD GPUs are unlikely to exhibit symptoms. Kernel subsystem-level tracing (via perf or ftrace) of DMA-buf attachment operations can reveal timing anomalies in reproduction environments.

Why prioritize this

Prioritize patching based on GPU workload criticality and cross-vendor GPU memory usage. Systems exclusively using single-vendor GPUs or without GPU compute/graphics acceleration can defer patching with lower risk. Systems with active Intel Xe and AMD GPU memory sharing—particularly in data center, AI/ML, or graphics-intensive environments—should prioritize immediate patching due to reported real-world crashes and the low hit rate suggesting the race is not easily mitigated operationally. The CVSS 7.8 (HIGH) score reflects local privilege escalation potential and system availability impact.

Risk score, explained

CVSS 3.1 score of 7.8 (HIGH) is assigned under CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H. The attack vector is Local (AV:L), reflecting the requirement for local system access and GPU workload execution. Attack Complexity is Low (AC:L), indicating the race condition is inherent to the code path and does not require exotic conditions. Privileges Required (PR:L) and no User Interaction (UI:N) reflect the need for local user-level access to GPU drivers. Scope is Unchanged (S:U), and the vulnerability impacts Confidentiality, Integrity, and Availability (C:H/I:H/A:H) through potential data corruption, kernel crashes, and information leakage via memory access violations.

Frequently asked questions