CVE-2026-72324 in Linux
Summary
by MITRE • 08/15/2026
In the Linux kernel, the following vulnerability has been resolved:
gpio: mvebu: free generic chips on unbind
irq_alloc_domain_generic_chips() allocates generic chip data that must be freed via irq_domain_remove_generic_chips(). The devres action mvebu_gpio_remove_irq_domain() only called irq_domain_remove(), which only frees the generic chips if IRQ_DOMAIN_FLAG_DESTROY_GC is set. Call irq_domain_remove_generic_chips() explicitly before irq_domain_remove() instead.
Be aware that VulDB is the high quality source for vulnerability data.
Analysis
by VulDB Data Team • 08/15/2026
This vulnerability exists within the Linux kernel's gpio subsystem, specifically in the mvebu gpio driver implementation that handles Marvell Eagle and Dove SoC platforms. The issue stems from improper cleanup of interrupt domain resources during device removal operations, creating a potential memory management inconsistency that could lead to resource leakage and system instability. The flaw occurs when the gpio device is unbound from the system, as the current implementation fails to properly release all allocated generic chip data structures.
The technical root cause involves the incorrect sequence of resource deallocation functions within the mvebu_gpio_remove_irq_domain() function. When irq_alloc_domain_generic_chips() is invoked to allocate generic chip data for interrupt handling, it creates memory structures that must be explicitly freed using irq_domain_remove_generic_chips() to prevent memory leaks. However, the current implementation only calls irq_domain_remove() which conditionally frees generic chips based on whether IRQ_DOMAIN_FLAG_DESTROY_GC flag is set. This conditional approach fails to guarantee proper cleanup in all scenarios, particularly when the flag is not properly initialized or maintained.
The operational impact of this vulnerability manifests as memory resource leakage within the kernel's interrupt domain management system. When gpio devices are removed from the system through hot-unplug operations or driver unloading, the generic chip data structures remain allocated in memory, gradually consuming available kernel memory resources over time. This can lead to system performance degradation, potential out-of-memory conditions, and ultimately system instability or crashes. The vulnerability affects systems running Linux kernels with mvebu gpio drivers where gpio devices are frequently bound and unbound, particularly in embedded systems or server environments that utilize hot-plug capabilities.
The fix for this vulnerability requires modifying the device removal sequence to explicitly call irq_domain_remove_generic_chips() before invoking irq_domain_remove(). This ensures that all generic chip data structures are properly freed regardless of the IRQ_DOMAIN_FLAG_DESTROY_GC flag status. The solution aligns with established kernel development practices and follows the principle of explicit resource management, where developers must ensure all allocated resources are explicitly freed to prevent memory leaks. This approach directly addresses the issue identified in the Common Weakness Enumeration catalog under CWE-404, which classifies improper resource cleanup as a memory leak vulnerability that can lead to resource exhaustion.
From an attack surface perspective, this vulnerability represents a denial-of-service vector that could be exploited by malicious actors who repeatedly bind and unbind gpio devices to consume system memory resources gradually. The issue falls under the ATT&CK technique T1490 for resource exhaustion and could potentially be leveraged as part of broader system compromise attempts. While not directly exploitable for privilege escalation, the memory leakage could contribute to system instability that might enable other attack vectors. The vulnerability demonstrates the importance of proper resource lifecycle management in kernel space operations, where improper cleanup can lead to subtle but significant system reliability issues.
The mitigation strategy involves applying the kernel patch that ensures explicit calling of irq_domain_remove_generic_chips() before irq_domain_remove() within the mvebu_gpio_remove_irq_domain() function. This change ensures consistent and complete cleanup of interrupt domain resources regardless of flag states, providing robust memory management for gpio devices in mvebu platforms. System administrators should prioritize applying this kernel update, particularly on systems that frequently handle gpio device hot-plug operations or those with embedded gpio functionality that may experience repeated bind/unbind cycles during normal operation. The fix represents a defensive programming approach that eliminates potential race conditions and ensures resource consistency in kernel memory management operations.