CVE-2026-99773 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

drm/drm_crtc: ensure dma_fence_ops remain valid during device unbind

In [1], sashiko reported the following issue:

=== snip === Looking at how these fences are managed, drm_crtc_create_fence() creates a dma_fence without taking a reference to the drm_device or drm_crtc. Because the sync_file framework exposes this fence to userspace, the fence can outlive the CRTC.

The dma_fence contract requires that data accessed by dma_fence_ops (like get_driver_name) must remain valid for an RCU grace period after the fence is signaled. However, drm_crtc_cleanup() and the subsequent freeing of the device do not wait for an RCU grace period via synchronize_rcu().

If userspace calls ioctl(SYNC_IOC_FILE_INFO) concurrently with a device hot-unplug:

CPU1 (Userspace) sync_file_get_name() ops = rcu_dereference(fence->ops); if (!dma_fence_test_signaled_flag()) // Preempted or delayed here

CPU2 (Driver Teardown) Signals the fence (setting fence->ops = NULL) Destroys and frees the CRTC without waiting for an RCU grace period

CPU1 (Resumes) ops->get_driver_name(fence) -> drm_crtc_fence_get_driver_name() crtc = fence_to_crtc(fence); // Casts to the freed CRTC return crtc->dev->driver->name; // Use-after-free

...

Does the CRTC or DRM device need to be kept alive for the RCU grace period, or should the fence hold a proper reference to prevent the use-after-free when get_driver_name() and get_timeline_name() access the freed CRTC structure? === snap ===

I believe this to be a correct observation and this patch implements the suggestion of waiting for an RCU grace period before proceeding with destruction of the drm_crtc, so that get_driver_name() and get_timeline_name() can still work.

Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.

Analysis

by VulDB Data Team • 11/21/2026

The Linux kernel contains a critical use-after-free vulnerability within the Direct Rendering Manager subsystem, specifically affecting the management of display controller resources during device unbinding operations. This flaw arises from an inconsistency in reference counting and lifecycle management between dma_fence objects and their associated drm_crtc structures. When a userspace application creates a sync_file through the DRM interface, it obtains a file descriptor referencing a dma_fence object that is tied to a specific CRTC. The kernel exposes this fence to userspace via the sync_file framework, allowing applications to query metadata about the synchronization primitive even after the underlying hardware context has been logically removed from active use.

The technical root cause lies in the asynchronous nature of memory reclamation and the requirements imposed by the dma_fence contract. According to established concurrency models within the kernel, any data accessed through function pointers stored in a dma_fence_ops structure must remain valid for at least one RCU grace period after the fence is signaled. This ensures that concurrent readers can safely dereference these operations without encountering corrupted memory or null pointer exceptions. However, the implementation of drm_crtc_cleanup and subsequent device teardown sequences fails to adhere to this requirement by freeing the CRTC structure immediately upon unbind, rather than deferring its destruction until all pending RCU read-side critical sections have completed.

This architectural oversight creates a race condition that can be triggered during concurrent operations involving userspace synchronization queries and kernel-side driver teardowns. In a typical exploitation scenario, an attacker or malicious application might invoke the SYNC_IOC_FILE_INFO ioctl to retrieve information about a fence while simultaneously triggering a device hot-unplug event from another thread or context. The sequence begins with the userspace process reading the fence's operations pointer via rcu_dereference and checking its signaled status. If this operation is preempted or delayed, it leaves the CPU core in an intermediate state where the fence object still exists but the underlying CRTC structure may have already been deallocated by the driver teardown thread on another processor.

When the userspace context resumes execution after being scheduled back onto a CPU core, it proceeds to call functions such as get_driver_name or get_timeline_name through the previously obtained ops pointer. These function pointers point into memory that has already been freed and potentially reallocated for other kernel purposes. The code attempts to cast the fence data back to a CRTC structure and dereference its device member to retrieve the driver name. Because this access occurs after the free operation, it results in a classic use-after-free condition. This can lead to arbitrary code execution if an attacker controls the contents of the freed memory region, or more commonly, cause kernel panics and system instability due to invalid memory accesses.

From a classification perspective, this vulnerability aligns with CWE-416, which describes Use After Free errors where software continues to use memory after it has been reused for another purpose. It also maps to MITRE ATT&CK techniques related to privilege escalation via kernel vulnerabilities, as gaining control over the execution flow in ring zero allows an attacker to bypass standard security boundaries and escalate privileges to root level. The lack of proper synchronization primitives during resource cleanup represents a significant deviation from secure coding practices expected in operating system kernels.

To mitigate this vulnerability, the Linux kernel developers implemented a fix that ensures the drm_crtc structure remains valid for the duration required by RCU semantics. Specifically, the teardown process now waits for an RCU grace period before proceeding with the actual destruction of the CRTC object. This delay guarantees that any concurrent readers accessing the fence operations will complete their execution and exit their critical sections before the memory is reclaimed. By enforcing this synchronization barrier, the kernel ensures data integrity during high-concurrency scenarios involving device removal and userspace interaction.

System administrators should ensure they are running a patched version of the Linux kernel to prevent exploitation of this flaw. Since this issue involves low-level driver interactions, it primarily affects systems with active GPU or display subsystems where dynamic unbinding occurs frequently. Regular updates to the base operating system provide the necessary code changes that enforce proper reference counting and RCU synchronization protocols during resource lifecycle management. Maintaining up-to-date kernel versions is essential for preserving the stability and security of modern computing environments against such concurrency-related memory corruption bugs.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00157

KEV

no

Activities

very low

Sources

Interested in the pricing of exploits?

See the underground prices here!