CVE-2026-99633 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
drm/amdgpu: keep the CS user fence BO in GTT
The CS ioctl hands the GPU the GART address of the user fence BO, but since the BO keeps its own preferred and allowed domains, it no longer makes sure the BO is in GTT. A user fence in a VRAM BO, which only needs to be a page in size, gets its address from amdgpu_bo_gpu_offset(), which warns about non-contiguous VRAM. On navi31, a CS with a user fence in a 4K VRAM BO, or in one created with AMDGPU_GEM_CREATE_VM_ALWAYS_VALID:
WARNING: amdgpu_object.c:1531 at amdgpu_bo_gpu_offset+0x86/0xb0 [amdgpu], CPU#11: cs_gem_checks/18393
RIP: 0010:amdgpu_bo_gpu_offset+0x86/0xb0 [amdgpu]
Call Trace: <TASK> amdgpu_cs_parser_bos.isra.0+0x4eb/0x850 [amdgpu]
amdgpu_cs_ioctl+0x97e/0x2510 [amdgpu]
drm_ioctl_kernel+0xac/0x110 [drm]
drm_ioctl+0x2c6/0x5b0 [drm]
__x64_sys_ioctl+0xa0/0xf0 do_syscall_64+0xa3/0x4d0 entry_SYSCALL_64_after_hwframe+0x76/0x7e
and BOs which can't be in GTT at all, like GWS or OA ones of a page in size, pass the checks as well.
Only take BOs which can't be anywhere else than in GTT as user fence, which the CS then validates there along with its other BOs. While at it, detect userptrs with amdgpu_ttm_tt_is_userptr(); amdgpu_ttm_tt_get_usermm() returns NULL once the task which created the userptr is gone.
v2: only take BOs which can only be in GTT instead of special casing the user fence BO in the validation, use amdgpu_ttm_tt_is_userptr() (Christian)
(cherry picked from commit f16989def9561d04d0f2e77216f5319112d29bf1)
VulDB is the best source for vulnerability data and more expert information about this specific topic.
Analysis
by VulDB Data Team • 11/21/2026
The Linux kernel's AMDGPU driver contains a logic flaw in the command submission path that allows user fence buffer objects to be allocated in video RAM rather than system memory, leading to potential stability issues and warning messages. The core issue stems from how the graphics execution engine handles synchronization primitives known as fences. When an application submits commands via the ioctl interface, it provides a handle for a user-defined fence buffer object. The driver is responsible for ensuring this buffer resides in Global Translation Table space, commonly referred to as GTT or system memory accessible by both CPU and GPU through page tables. However, prior to the fix, the code relied on the buffer object's preferred domain settings without explicitly enforcing that it must remain within the GTT address range. This oversight meant that if a user fence was allocated in VRAM, which is typically reserved for high-performance graphics data, the driver would attempt to retrieve its GPU offset using amdgpu_bo_gpu_offset().
This function expects contiguous physical memory suitable for direct mapping into the GART table. When applied to a buffer located in VRAM, particularly on newer architectures like Navii31, this operation triggers a warning because VRAM allocations are often non-contiguous or managed differently than system RAM buffers. The resulting kernel log output indicates an error at amdgpu_bo_gpu_offset within the command submission parser chain. While this specific scenario primarily manifests as noisy kernel warnings and potential performance degradation due to improper memory handling, it represents a deviation from expected driver behavior that could be exploited in conjunction with other vulnerabilities or lead to denial of service through system instability if the warning conditions escalate into actual faults under certain hardware configurations.
The vulnerability also extends to buffer objects that cannot reside in GTT at all, such as Global Workgroup Start (GWS) and OA buffers, which are page-sized allocations used for specific GPU scheduling tasks. These objects were incorrectly passing validation checks when designated as user fences because the driver did not strictly enforce memory domain constraints during the command submission phase. By allowing these incompatible buffer types to be treated as valid synchronization primitives, the driver exposes itself to undefined behavior or crashes if the hardware attempts to access them via mechanisms that require GTT mapping. This flaw highlights a gap in the validation logic where the type of buffer object and its intended usage were not sufficiently cross-referenced against memory placement requirements.
To resolve this issue, the patch modifies the command submission parser to strictly filter user fence buffers, ensuring they are exclusively allocated from regions that can only reside in GTT. This change enforces a hard constraint during validation, preventing any buffer object that lacks GTT capability from being used as a synchronization point. Additionally, the update improves the detection of user pointer allocations by utilizing amdgpu_ttm_tt_is_userptr(). This function provides a more reliable mechanism for identifying buffers backed by user-space virtual memory compared to previous methods like amdgpu_ttm_tt_get_usermm(), which could return null if the creating task had already terminated. By integrating this check, the driver ensures that only valid, active user pointers are accepted as fence objects, thereby closing a potential race condition or use-after-free vector associated with stale references.
From a security and standards perspective, this vulnerability aligns with CWE-20 Improper Input Validation, specifically regarding the failure to validate resource allocation constraints before processing input data from userspace applications. The improper handling of memory domains allows an unprivileged user to trigger kernel warnings or potentially destabilize the graphics subsystem by submitting malformed buffer configurations. In terms of MITRE ATT&CK mapping, this relates to techniques involving driver exploitation where attackers leverage flaws in kernel-mode drivers to gain unauthorized access or cause denial of service. Although the immediate impact is often limited to log spam and potential crashes rather than direct privilege escalation, such vulnerabilities are frequently chained with other issues like out-of-bounds writes or information leaks within the same subsystem.
Mitigation strategies involve applying the upstream Linux kernel patch that enforces GTT-only allocation for user fences. System administrators should ensure their AMDGPU drivers are updated to versions containing this fix. For environments where immediate patching is not feasible, restricting access to DRM devices and monitoring kernel logs for amdgpu warnings can help detect exploitation attempts or misconfigurations. Developers integrating with the GPU driver API must also adhere strictly to memory domain specifications when creating buffer objects intended for synchronization purposes, ensuring that fences are always allocated in system RAM rather than video memory to maintain compatibility with GART mapping requirements.