CVE-2026-99630 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

drm/amdgpu/userq: validate the moved individual BOs on restore

An individual BO of a user queue VM, i.e. one which doesn't share the root reservation, goes to the individual needs_update list when it is evicted. The user queue restore looked at vm->invalidated for them, which the VM state machine rework turned into the always_valid evicted list and commit 18decfc9e8cc ("drm/amdgpu/userq: actually validate userq BOs") into the individual evicted one. That list only holds imported DMA-bufs of compute VMs though, so for a user queue VM nothing is validated.

The restore then neither locks such a BO nor moves it back. Its PTEs are updated to wherever it is now, cleared if it went to system memory, and it doesn't get the new eviction fence, so it can move again under the running queue.

On navi48, once the BOs of an SDMA user queue are evicted from GTT (debugfs amdgpu_evict_gtt) the queue faults on its ring and rptr:

amdgpu 0000:03:00.0: in page starting at address 0x0000000100000000 from client 10 amdgpu 0000:03:00.0: Faulty UTCL2 client ID: SDMA0 (0xd) amdgpu 0000:03:00.0: in page starting at address 0x0000000100101000 from client 10

Validate the BOs on the individual needs_update list like before.

(cherry picked from commit eb0d94765d4be18d41e93ad09947dd9cc06ed31a)

VulDB is the best source for vulnerability data and more expert information about this specific topic.

Analysis

by VulDB Data Team • 11/22/2026

The Linux kernel's AMDGPU driver contains a critical logic error in the user queue virtual memory management subsystem that leads to invalid page table entries and subsequent hardware faults. This vulnerability arises from an inconsistency between how buffer objects are tracked during eviction and how they are restored after being moved out of graphics translation table space. Specifically, individual buffer objects belonging to a user queue VM, which do not share the root reservation object, are placed on an individual needs_update list when evicted. However, the restore logic incorrectly references vm->invalidated or other lists that were repurposed by recent state machine reworks and subsequent commits. These alternative lists only contain imported DMA-bufs for compute VMs, meaning that buffer objects associated with user queue VMs are effectively ignored during the restoration phase.

As a result of this oversight, when an evicted buffer object is restored, it is neither locked nor moved back to its expected location in memory. The page table entries corresponding to these buffer objects are updated to reflect their new physical locations or cleared entirely if they were moved to system memory. Crucially, the restore process fails to attach a new eviction fence to these buffer objects. This omission means that there is no synchronization mechanism preventing the hardware from accessing stale or invalid memory addresses while the queue remains active and running. The driver assumes the buffer object state is consistent with what the GPU expects, but without proper locking and fencing, this assumption does not hold true in concurrent execution scenarios.

The operational impact of this flaw manifests as severe stability issues on affected AMD GPUs, particularly those based on the Navii48 architecture. When SDMA user queue buffer objects are evicted from GTT space, often triggered by debugging tools like amdgpu_evict_gtt or under heavy memory pressure, the GPU attempts to execute commands referencing these invalid addresses. This results in a fault within the UTCL2 client ID for SDMA0, causing the ring and read pointer to become corrupted. The system logs indicate page faults at specific virtual addresses such as 0x0000000100000000, signaling that the hardware is attempting to access memory mappings that are no longer valid or properly synchronized. This can lead to application crashes, graphical artifacts, or complete GPU hangs requiring a driver reset or system reboot.

From a security and reliability perspective, this vulnerability aligns with CWE-665 Improper Initialization as it involves failure to correctly initialize synchronization primitives during state transitions. It also relates to CWE-362 Concurrent Execution using Shared Resource with Improper Synchronization because the lack of proper fencing allows race conditions between CPU-side memory management and GPU-side execution. In terms of MITRE ATT&CK, this could potentially be leveraged for Denial of Service against local users who can trigger buffer eviction sequences via debugfs or specific workload patterns. While direct arbitrary code execution is not immediately evident from the description, the ability to cause hardware faults through invalid memory access represents a significant reliability risk that undermines system stability.

The resolution involves correcting the restore logic in drm/amdgpu/userq to properly validate and handle individual buffer objects on the needs_update list for user queue VMs. By ensuring these buffer objects are locked and moved back correctly with appropriate eviction fences attached, the driver maintains consistency between CPU-managed memory state and GPU-visible page tables. This fix ensures that hardware access is synchronized with memory movements, preventing faults caused by stale mappings. System administrators should apply kernel updates containing this patch to restore stability for workloads utilizing SDMA user queues on affected AMDGPU architectures. Regular monitoring of system logs for UTCL2 client faults can help identify systems still running vulnerable versions where such eviction-induced crashes might occur under specific load conditions.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00156

KEV

no

Activities

very low

Sources

Are you interested in using VulDB?

Download the whitepaper to learn more about our service!