CVE-2026-99619 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
drm/amdgpu: don't drop the gang dependency fence twice
drm_sched_job_add_dependency() drops the fence reference when it fails, but amdgpu_cs_submit() drops it again, so the scheduled fence of a gang member loses a reference it still needs.
A GFX+COMPUTE gang waiting for another context, with the xarray node allocation for the leader's dependency failed through failslab:
WARNING: drivers/dma-buf/dma-fence.c:589 at dma_fence_release+0x34d/0x730, CPU#1: amd_uapi_regres/2993 drm_sched_job_cleanup+0x2c2/0x340 [gpu_sched]
amdgpu_job_free+0xcb/0x3e0 [amdgpu]
amdgpu_cs_parser_fini+0x435/0x710 [amdgpu]
amdgpu_cs_ioctl+0xcd2/0x7a60 [amdgpu]
Oops: general protection fault, probably for non-canonical address 0xdffffc0000000001: 0000 [#1] SMP KASAN NOPTI
KASAN: null-ptr-deref in range [0x0000000000000008-0x000000000000000f]
RIP: 0010:dma_fence_signal_timestamp_locked+0x1b8/0x610
(cherry picked from commit 5aa070a83c8378810b906cc8bfc650ce69822a7c)
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 Direct Rendering Manager subsystem, specifically the AMDGPU driver component responsible for handling graphics and compute operations, contained a reference counting error within its command submission path. This vulnerability manifests as a double-free condition affecting synchronization fences used to manage dependencies between GPU jobs. The core issue lies in the interaction between the scheduler job dependency management logic and the user-space command submission handler. When amdgpu_cs_submit processes a request involving a gang of scheduled jobs, it relies on drm_sched_job_add_dependency to establish relationships between these jobs. This function is designed to drop its reference count on a fence if the addition fails due to resource allocation issues or other errors. However, the calling context in amdgpu_cs_submit incorrectly assumes that it retains ownership and proceeds to release the same reference again upon error handling paths.
This double decrement of the reference counter leads to premature deallocation of critical kernel objects known as dma_fences. These fences are essential for coordinating execution order between different contexts on the GPU, particularly when a graphics plus compute gang waits for another context to complete its tasks. Under normal operation, these references ensure that resources remain valid until all dependent operations have finished. When the reference count is erroneously reduced below zero or prematurely to zero due to this double drop, the underlying memory structure associated with the scheduled fence becomes invalid while it may still be accessed by other parts of the kernel scheduler. This creates a race condition where subsequent attempts to access or signal these fences operate on freed or corrupted memory regions.
The operational impact of this flaw is severe, potentially leading to system instability and denial of service conditions for local users with appropriate privileges. As evidenced by crash traces from similar instances involving failslab injection testing, the error triggers a general protection fault often associated with non-canonical addresses or null pointer dereferences within dma_fence_signal_timestamp_locked. The kernel's KASAN tool detects this as a null-pointer dereference in ranges indicating corrupted pointers derived from use-after-free scenarios. Such faults can cause immediate kernel panics, resulting in system crashes and loss of unsaved work. Furthermore, because the vulnerability resides in the GPU driver which is frequently loaded with high privileges, it represents a significant stability risk for desktop and server environments relying on AMD hardware acceleration.
From a classification perspective, this issue aligns with CWE-415 Double Free, where an object is freed more than once leading to undefined behavior. It also relates to CWE-362 Concurrent Execution using Shared Resource with Improper Synchronization, as the race condition arises from improper handling of shared reference counts in concurrent execution paths. In terms of MITRE ATT&CK mapping for Linux systems, this falls under T1059 Command and Scripting Interpreter if exploited via crafted ioctl calls to trigger the fault, though primarily it is a stability vulnerability rather than an exploit vector for privilege escalation unless combined with other flaws. The root cause stems from incorrect ownership semantics in error handling paths within the DRM scheduler infrastructure.
Mitigation strategies involve applying upstream kernel patches that correct the reference counting logic in amdgpu_cs_submit and drm_sched_job_add_dependency. System administrators should ensure their systems are updated to versions of the Linux kernel containing this fix, typically identified by commit 5aa070a83c8378810b906cc8bfc650ce69822a7c or later stable releases incorporating it. For environments unable to update immediately, restricting access to GPU devices via cgroups or DAC permissions can limit the attack surface for local users attempting to trigger these code paths. Additionally, enabling kernel hardening features such as KASAN in development builds helps detect similar reference counting errors early in the software lifecycle before they reach production deployments.