CVE-2026-99629 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

drm/amdgpu: clear RB_OVERFLOW bit when enabling interrupts for navi10_ih

Port this change to navi10_ih.c: commit afbf7955ff01 ("drm/amdgpu: clear RB_OVERFLOW bit when enabling interrupts")

Setting IH_RB_WPTR to 0 does not clear RB_OVERFLOW if RB_ENABLE is not set. Pulse WPTR_OVERFLOW_CLEAR after RB_ENABLE (and with WPTR_OVERFLOW_ENABLE) so overflow is cleared when interrupts are enabled.

(cherry picked from commit 713fb4ab04f4d2af6120f8eb607c5673b2759b38)

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 driver for AMD graphics processing units, specifically the amdgpu subsystem responsible for managing hardware interrupts on Navii 10 architecture GPUs, contained a logic flaw in its interrupt handler initialization sequence. This vulnerability stems from an incorrect ordering of register operations when enabling the Interrupt Handler (IH) ring buffer. The core issue lies in how the Ring Buffer Write Pointer is managed relative to the RB_ENABLE bit. Specifically, writing zero to the IH_RB_WPTR register was intended to clear any existing overflow conditions within the interrupt handler's circular buffer. However, this operation fails to reset the RB_OVERFLOW flag if the RB_ENABLE bit has not yet been set by the hardware controller. This creates a race condition or state inconsistency where residual overflow states from previous sessions or prior error conditions persist even after the driver attempts to reinitialize the interrupt handling mechanism.

From a technical perspective, the flaw is rooted in the specific behavior of the AMD GPU's Interrupt Handler hardware block. The RB_OVERFLOW bit serves as a status indicator that signals when the ring buffer has wrapped around and overwritten unread data, potentially leading to lost interrupts or corrupted state if not properly cleared before operation resumes. By attempting to clear this flag via WPTR manipulation prior to enabling the interrupt processing engine with RB_ENABLE, the driver ensures that the hardware does not recognize the write pointer reset as a valid operational command until the system is fully active. The corrective patch modifies the initialization flow in navi10_ih.c to pulse the WPTR_OVERFLOW_CLEAR signal only after RB_ENABLE has been asserted and while WPTR_OVERFLOW_ENABLE is also set. This guarantees that the overflow state is effectively cleared at the correct moment when the hardware is ready to process interrupt events, thereby preventing stale error flags from triggering false positives or blocking legitimate interrupt processing during subsequent GPU operations.

The operational impact of this vulnerability primarily affects system stability and reliability rather than direct security exploitation in the traditional sense of privilege escalation or remote code execution. However, persistent RB_OVERFLOW states can lead to intermittent display artifacts, screen freezes, or complete driver crashes when the GPU attempts to process interrupts after a reset or resume from suspend. In high-load scenarios or during rapid state transitions such as switching between desktop and gaming modes, these uncleared overflow bits could cause the interrupt handler to malfunction, resulting in dropped events that prevent proper rendering updates or power management actions. While not typically classified as a critical security vulnerability allowing external attack vectors, it represents a significant reliability defect that can degrade user experience and potentially lead to denial of service conditions for local users interacting with the graphical subsystem through resource exhaustion via repeated crash-and-recovery cycles.

This issue aligns with CWE-362, which describes concurrent execution issues leading to race conditions or improper synchronization, as well as CWE-829 regarding the inclusion of functionality from untrusted control sources if one considers the hardware state as an external input that must be validated and reset properly before use. In terms of MITRE ATT&CK mapping, while this is not a direct attack technique, it relates to T1496 Resource Hijacking in the context of local resource denial due to driver instability, though more accurately it falls under general software defects affecting availability rather than malicious exploitation. Mitigation involves applying the upstream kernel patch that corrects the initialization sequence for Navii 10 GPUs. System administrators should ensure their Linux kernels are updated to versions containing commit afbf7955ff01 or its cherry-picked equivalent in stable releases. For environments where immediate patching is not feasible, monitoring GPU driver logs for overflow-related errors and ensuring proper power state transitions can help mitigate the frequency of these instability events until a permanent fix is deployed.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00168

KEV

no

Activities

very low

Sources

Do you want to use VulDB in your project?

Use the official API to access entries easily!