CVE-2026-99480 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

drm/panthor: Fix TOCTOU race between GROUP_REGISTERED check and erase

panthor_group_destroy() checks the GROUP_REGISTERED mark and then calls xa_erase() without holding the xarray lock across both. If the handle is destroyed by another thread in between, and a concurrent GROUP_CREATE reuses the freed ID, the first destroy erases and releases the new, still-initializing group, leading to a use-after-free in panthor_group_create().

Do the mark check and erase atomically under xa_lock().

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

Analysis

by VulDB Data Team • 11/20/2026

The vulnerability identified within the Linux kernel's DRM Panthor driver represents a classic Time-of-Check-to-Time-of-Use race condition involving concurrent access to shared data structures. Specifically, the flaw resides in the panthor_group_destroy function, which is responsible for cleaning up graphics processing unit group resources. The core technical deficiency lies in the lack of atomicity when verifying and removing an entry from a radix tree implementation known as xarray. The code performs a check on the GROUP_REGISTERED mark to determine if the resource is still valid before proceeding to erase it using xa_erase. However, this verification step and the subsequent erasure operation are not protected by the necessary synchronization primitives during both actions. This separation creates a critical window of vulnerability where another thread can intervene between the initial state validation and the actual modification of the data structure.

In a multi-threaded environment typical of modern operating systems handling graphics workloads, this race condition allows for severe memory corruption scenarios. If one thread initiates the destruction process but is preempted after checking the GROUP_REGISTERED flag yet before calling xa_erase, another thread may destroy the same handle or trigger a group creation that reuses the freed identifier. Because xarray entries are often reused to optimize space and performance, a newly created group might be assigned the exact ID previously held by the object being destroyed. Consequently, when the first thread resumes execution, it proceeds to erase and release what it believes is its original target but is actually the new, still-initializing group structure. This results in a use-after-free condition where memory associated with an active object is freed prematurely, leading to potential kernel panics, data corruption, or arbitrary code execution if an attacker can control the contents of the reused memory region before it is properly initialized by the new owner.

The operational impact of this vulnerability extends beyond simple stability issues. Use-after-free bugs in kernel space are particularly dangerous because they allow for privilege escalation from user-space applications to ring zero. An adversary could potentially exploit this race condition to corrupt critical kernel data structures, bypass security mechanisms such as SELinux or AppArmor by manipulating memory states, or cause a denial of service through system crashes. The Panthor driver manages hardware resources on ARM-based systems utilizing Mali GPUs, meaning that any compromise here affects the integrity of graphical processing operations and potentially other subsystems relying on stable kernel state. This is not merely an isolated bug but reflects a broader class of concurrency errors where lock granularity or scope is insufficient to guarantee data consistency across multiple execution contexts.

To mitigate this vulnerability, developers must ensure that all read-modify-write sequences involving shared resources are performed atomically under the protection of the appropriate locking mechanism. In this specific case, the fix involves holding the xa_lock throughout both the check for the GROUP_REGISTERED mark and the subsequent call to xa_erase. By serializing access to the xarray entry during these critical operations, the race window is eliminated, ensuring that no other thread can modify or reuse the identifier while it is being processed by another thread. This aligns with fundamental principles of concurrent programming where mutual exclusion must cover the entire logical transaction rather than just individual steps within it.

From a classification perspective, this vulnerability maps directly to CWE-367, which defines Time-of-check-Time-of-use (TOCTOU) race conditions in software systems. The failure lies not in the logic itself but in the temporal gap between validation and execution due to insufficient synchronization. Furthermore, from an offensive security standpoint as defined by the MITRE ATT&CK framework, this flaw facilitates techniques associated with privilege escalation via memory corruption or exploitation of kernel vulnerabilities such as CWE-416 Use After Free. Security auditors and developers should review similar patterns in other drivers where resource handles are checked and manipulated without holding locks across both operations. Ensuring that all state checks preceding destructive actions on shared data structures are enclosed within the relevant lock scope is essential for maintaining system integrity against concurrent exploitation attempts.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00168

KEV

no

Activities

very low

Sources

Are you interested in using VulDB?

Download the whitepaper to learn more about our service!