CVE-2026-99770 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
drm/vc4: Publish the output fence outside of job_lock
job_lock is taken by the V3D interrupt handler, so nesting an IRQ-unsafe lock under it creates an inversion. drm_syncobj_replace_fence() takes drm_syncobj::lock, which other paths acquire with interrupts enabled. For example, a thread interrupted while holding it blocks the handler on job_lock, and the handler can only make progress once the submit path releases job_lock, which it cannot do while waiting for drm_syncobj::lock.
This is reported by lockdep:
[ 188.139076] ========================================================
[ 188.139086] WARNING: possible irq lock inversion dependency detected
[ 188.139096] 7.3.0-rc3-00067-gc4f3feeaf60f #67 Tainted: G C
[ 188.139108] --------------------------------------------------------
[ 188.139116] swapper/0/0 just changed the state of lock:
[ 188.139125] ffff0000054f8ff8 (&vc4->job_lock){-...}-{3:3}, at: vc4_irq+0xa8/0x28c [vc4]
[ 188.139234] but this lock took another, HARDIRQ-unsafe lock in the past:
[ 188.139242] (&syncobj->lock){+.+.}-{3:3}
[ 188.139256] and interrupts could create inverse lock ordering between them.
[ 188.139267] other info that might help us debug this:
[ 188.139275] Possible interrupt unsafe locking scenario:
[ 188.139284] CPU0 CPU1
[ 188.139291] ---- ----
[ 188.139299] lock(&syncobj->lock);
[ 188.139312] local_irq_disable();
[ 188.139320] lock(&vc4->job_lock);
[ 188.139335] lock(&syncobj->lock);
[ 188.139350] <Interrupt>
[ 188.139358] lock(&vc4->job_lock);
[ 188.139372] *** DEADLOCK ***
Hand the fence over after job_lock is dropped. The job can complete and drop exec->fence in that window, so take a reference first and publish through the local pointer, as exec may already be gone.
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 Linux kernel driver for Broadcom VC4 graphics hardware contains a concurrency vulnerability rooted in improper lock ordering within its synchronization primitives. Specifically, the function drm_syncobj_replace_fence acquires the drm_syncobj::lock while interrupts are enabled on certain execution paths. However, this operation is invoked from contexts where job_lock is already held by the V3D interrupt handler. Since job_lock is acquired inside an IRQ context via vc4_irq, nesting a lock that requires sleeping or can be contended with interrupts enabled underneath it creates a classic lock inversion scenario. This violates kernel locking rules which mandate that locks taken in softirq or hardirq contexts must not acquire other locks that might sleep or contend under interrupt-disabled conditions elsewhere in the call stack.
The operational impact of this flaw is severe, manifesting as potential deadlocks and system hangs. When a user-space thread holds drm_syncobj::lock and gets interrupted while holding it, the CPU switches to an IRQ context where vc4_irq attempts to acquire job_lock. If another execution path holds job_lock and waits for drm_syncobj::lock, which is held by the interrupted thread that cannot proceed because interrupts are disabled during its critical section, a circular dependency forms. This deadlock prevents both paths from making progress, effectively freezing the graphics subsystem or causing broader system instability depending on how deeply this lock contention propagates through the kernel scheduler and memory management layers.
This vulnerability maps directly to CWE-833 Lock Inversion, where two locks are acquired in different orders by concurrent threads leading to a deadlock condition. From an ATT&CK perspective, while not an exploit technique itself, such concurrency bugs can be leveraged for Denial of Service attacks against the operating system or potentially escalated if combined with other race conditions affecting kernel memory integrity. The lockdep output confirms this is a hardirq-unsafe locking scenario where interrupt handlers and process contexts interact in ways that violate expected precedence rules established by the Linux kernel's synchronization model.
The resolution involves restructuring the code to ensure that fence publication occurs outside of job_lock protection. By dropping job_lock before publishing the output fence, the inversion risk is eliminated because the contested locks are no longer held simultaneously across interrupt and process contexts. Additionally, since the job structure may be freed during the window where job_lock is released but before the fence reference is fully established, a temporary local pointer with an incremented reference count is used to safely hand over ownership of the fence object. This ensures memory safety while maintaining correct synchronization semantics without requiring complex lock reordering that could introduce other subtle bugs.
To mitigate similar issues in kernel development, engineers should strictly adhere to locking hierarchy guidelines and utilize tools like lockdep during testing phases to detect potential inversion dependencies early. Code reviews must scrutinize any interaction between interrupt handlers and process-context locks for proper nesting order. In this specific case, the fix demonstrates a common pattern of using reference counting to decouple object lifetime from synchronization scope, thereby reducing contention windows and preventing deadlocks arising from complex multi-lock interactions in high-frequency driver code paths.