CVE-2026-99753 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
drm/loongson: Fix double free on BO initialization failure
If ttm_bo_init_validate() fails, it drops the buffer object's reference and cleans it up through the supplied destroy callback. lsdc_bo_destroy() releases the GEM object and frees the enclosing lsdc_bo, so freeing it again in lsdc_bo_create() causes a double free on a synchronous failure path.
Let TTM own the cleanup after initialization has started and return the error directly. Keep the explicit free on drm_gem_object_init() failure, which occurs before ownership is passed to TTM.
Tested on LS7A2000 by making drm_vma_offset_add() return -ENOSPC for one selected dumb-buffer creation. The error reached userspace, the destroy callback ran once, and no handle was published or tracked BO retained. Normal buffer creation, zeroing, mapping, readback and release passed.
AI assistance was used for the ownership analysis, fix, fault-injection tools, build and test execution.
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 11/20/2026
The Linux kernel vulnerability identified in the DRM Loongson driver involves a critical memory management flaw known as a double free condition during buffer object initialization. This issue arises specifically within the lsdc_bo_create function when the underlying TTM (Translation Table Maps) subsystem fails to validate or initialize a buffer object via ttm_bo_init_validate. In this specific error path, the kernel incorrectly manages the lifecycle of the buffer object and its associated GEM (Graphics Execution Manager) structures, leading to undefined behavior that can compromise system stability and security. The root cause lies in an incorrect division of responsibility between the driver-specific cleanup logic and the generic TTM subsystem regarding when ownership of the resource is transferred and who is responsible for final deallocation.
Technically, the flaw occurs because ttm_bo_init_validate, upon encountering a failure after partially initializing the buffer object, assumes it has taken over management responsibilities and proceeds to drop the reference count while invoking the supplied destroy callback. The lsdc_bo_destroy function acts as this callback and consequently releases the GEM object along with freeing the enclosing lsdc_bo structure. However, the calling code in lsdc_bo_create does not account for this internal cleanup performed by TTM on failure paths. As a result, when control returns to lsdc_bo_create after detecting the error from ttm_bo_init_validate, it proceeds to execute its own explicit free operation on the same memory region. This results in a double free vulnerability where the kernel attempts to deallocate memory that has already been returned to the allocator or is in an inconsistent state due to prior cleanup by the TTM subsystem.
The operational impact of this vulnerability extends beyond simple application crashes, although local denial-of-service conditions are the most immediate consequence. A successful exploitation could allow a local user with access to graphics resources to trigger kernel memory corruption through repeated allocation failures or crafted fault injection scenarios. This type of memory safety violation is classified under CWE-415 Double Free, which represents one of the more dangerous classes of bugs in systems programming because it can lead to heap metadata corruption. Such corruption may potentially be leveraged for arbitrary code execution if an attacker can carefully control the state of the kernel heap following the double free event, although achieving this typically requires precise timing and knowledge of internal memory layout structures.
From a threat intelligence perspective, this vulnerability aligns with MITRE ATT&CK techniques related to resource manipulation and potential privilege escalation vectors where attackers exploit improper input validation or error handling in system-level drivers. The lack of proper state management during the initialization phase creates an attack surface that can be targeted by malicious applications seeking to destabilize the graphics subsystem or escalate privileges within the kernel space. While the immediate risk is often limited to local users who have permission to create dumb buffers, the severity is heightened by the fact that it occurs in core display infrastructure code present across multiple architectures supported by Loongson processors.
To mitigate this vulnerability, the fix involves restructuring the ownership semantics of buffer object cleanup within the driver implementation. The solution ensures that TTM retains full responsibility for cleaning up resources once initialization has commenced and ttm_bo_init_validate is invoked. Consequently, if validation fails, TTM handles all necessary deallocation through its destroy callback without requiring further action from lsdc_bo_create. This change prevents the redundant free operation by ensuring that only one entity manages the lifecycle of the object after a certain point in the initialization sequence. For cases where drm_gem_object_init fails prior to handing over ownership to TTM, explicit freeing remains appropriate since TTM has not yet assumed control.
System administrators and developers should prioritize applying kernel updates that include this patch to maintain system integrity on affected Loongson platforms such as LS7A2000. Verification of the fix can be performed by monitoring for proper error propagation to userspace without subsequent crashes or memory leaks during buffer creation attempts under constrained conditions like ENOSPC errors. Maintaining strict adherence to resource ownership rules in kernel driver development is essential to preventing similar vulnerabilities, emphasizing the need for rigorous testing using fault injection tools and static analysis techniques that track reference counting and deallocation paths throughout complex initialization routines.