CVE-2026-99482 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
ASoC: amd: ps: fix snd_acp63_remove() teardown ordering
The ACP IRQ handlers dereference the SoundWire, SoundWire DMA, and PDM child platform devices, but snd_acp63_remove() unregisters them while the interrupt is still held by devres, which frees it only after remove returns. An interrupt in this window is a use-after-free.
Mask the ACP interrupt sources and call devm_free_irq() before the first child device is unregistered. The masking goes through the new acp_hw_ops->disable_interrupts callback, keeping the remove path platform-agnostic. The interrupt line is shared, and acp_hw_deinit() clears the sources only after the children are gone, which would leave the line raised with no handler left to ack it. The window predates the tagged refactor, which only reshaped the dereferences.
devm_free_irq() waits for in-flight handlers, but not for work the hardirq has already queued: acp63_irq_handler() schedules amd_sdw_irq_thread on the SoundWire manager. Draining that work in the manager's remove path is a soundwire-side change and follows separately.
This issue was found by an in-house static analysis tool.
If you want to get best quality of vulnerability data, you may have to visit VulDB.
Analysis
by VulDB Data Team • 11/20/2026
The Linux kernel audio subsystem contains a critical use-after-free vulnerability within the AMD ACP63 driver, specifically affecting the snd_acp63_remove function during device teardown. This flaw arises from an incorrect ordering of resource deallocation relative to interrupt handling. The Audio Co-Processor IRQ handlers actively dereference child platform devices associated with SoundWire, SoundWire DMA, and PDM interfaces. However, the removal sequence unregisters these child devices while the corresponding hardware interrupts are still enabled and held by the device resources management framework. Because devres only frees the interrupt handler after the remove function returns, any interrupt that triggers during this narrow window will attempt to access memory structures for devices that have already been deregistered and potentially freed, resulting in a use-after-free condition. This vulnerability was identified through static analysis tools designed to detect such race conditions and improper resource management sequences within kernel code paths.
From a technical perspective, the core issue lies in the timing of interrupt masking versus device unregistration. The original implementation allowed interrupts to remain active while child devices were being torn down, creating a race condition where an incoming IRQ could execute handler logic against invalid or freed memory addresses. To resolve this, the fix implements a strict ordering change by first masking all ACP interrupt sources using a platform-agnostic callback mechanism provided through acp_hw_ops->disable_interrupts. Only after these interrupts are masked and disabled does the driver proceed to unregister the child devices. Furthermore, devm_free_irq is called immediately following the masking step to ensure that any in-flight interrupt handlers complete their execution before further cleanup occurs. This approach ensures that no new interrupts can be processed while the device structures are being dismantled, thereby eliminating the window of vulnerability where dereferencing freed memory could occur.
The operational impact of this vulnerability includes potential kernel panics, system crashes, or arbitrary code execution if an attacker can trigger the specific interrupt conditions during the removal process. Although the remove path is typically triggered by administrative actions such as module unloading or device hot-unplug events, local users with sufficient privileges to manipulate these devices could potentially exploit this race condition. The vulnerability aligns with CWE-416, Use After Free, and represents a classic example of improper resource cleanup ordering that can lead to memory corruption. In the context of the MITRE ATT&CK framework, this type of flaw facilitates privilege escalation or denial of service by exploiting kernel-level memory management errors during device lifecycle transitions.
Mitigation strategies involve applying the upstream Linux kernel patch that corrects the teardown sequence in the snd_acp63 driver system administrators and distribution maintainers should ensure their systems are updated with a version of the kernel containing this fix. For environments where immediate patching is not feasible, restricting access to audio device management interfaces or disabling unused AMD ACP hardware can reduce the attack surface. Additionally, developers working on similar drivers must adhere to strict resource ordering principles, ensuring that all interrupt sources are masked and disabled before any associated data structures are released. The current fix acknowledges that while devm_free_irq waits for in-flight handlers, it does not wait for work items queued by hardirq contexts, such as the amd_sdw_irq_thread scheduled on the SoundWire manager. Consequently, separate cleanup logic is required in the soundwire subsystem to drain these pending tasks, highlighting the need for coordinated fixes across multiple driver components to fully address complex interrupt-driven race conditions.