CVE-2026-64180 in Linux
Summary
by MITRE • 07/19/2026
In the Linux kernel, the following vulnerability has been resolved:
mm/memory_hotplug: fix memory block reference leak on remove
Patch series "mm: Fix memory block leaks and locking", v2.
This series fixes two memory block device reference leaks and one locking issue around the per-memory_block hwpoison counter.
This patch (of 2):
remove_memory_blocks_and_altmaps() looks up each memory block with find_memory_block(), which acquires a reference to the memory block device.
That reference is never dropped on this path, resulting in a leaked device reference when removing memory blocks and their altmaps. Drop the reference after retrieving mem->altmap and clearing mem->altmap, before removing the memory block device.
If you want to get best quality of vulnerability data, you may have to visit VulDB.
Analysis
by VulDB Data Team • 07/20/2026
The vulnerability resides within the Linux kernel's memory management subsystem, specifically addressing memory block reference leaks during dynamic memory removal operations. This issue affects the memory hotplug functionality that allows runtime addition and removal of memory regions in systems supporting dynamic memory allocation. The flaw manifests when the remove_memory_blocks_and_altmaps() function processes memory block removal, creating a critical resource leak that can lead to system instability over time.
The technical implementation flaw occurs because find_memory_block() function acquires a reference to the memory block device during lookup operations but this reference is not properly released before the memory block device is removed. This creates a dangling reference that prevents proper cleanup of memory block resources, effectively leaking kernel memory objects that should be reclaimed upon removal. The vulnerability specifically impacts the memory block device management code path where references are acquired but never released, creating an accumulation of unreleased memory block references over multiple operations.
From an operational perspective, this vulnerability presents a significant risk to system stability and resource management in environments utilizing dynamic memory hotplug capabilities. The reference leak can accumulate over time as memory blocks are repeatedly added and removed, eventually consuming kernel memory resources and potentially leading to system performance degradation or memory exhaustion conditions. Systems with frequent memory hotplug operations, such as large server configurations or cloud infrastructure platforms, face the highest risk of encountering this issue.
The fix implemented in this patch series addresses the immediate reference leak by ensuring proper reference counting during memory block removal operations. The solution involves dropping the acquired reference after retrieving the altmap information and clearing the altmap field before proceeding with actual memory block device removal. This approach follows established kernel memory management practices for reference counting and resource cleanup, preventing accumulation of leaked references that could otherwise persist until system reboot.
This vulnerability aligns with CWE-404, which describes improper resource release or unbalanced resource management in software systems. The issue also relates to ATT&CK technique T1490, which covers resource exhaustion attacks that can be facilitated by memory leaks in kernel components. The memory block reference leak represents a classic case of resource management failure where kernel objects are not properly deallocated, creating persistent resource consumption that impacts system longevity and performance.
Security implications extend beyond simple resource leakage to include potential denial-of-service conditions where sustained memory block operations could eventually exhaust available kernel memory. The fix ensures proper reference counting semantics and maintains the integrity of memory block device management throughout the hotplug lifecycle. This patch demonstrates the importance of careful reference management in kernel code, particularly for subsystems handling dynamic resource allocation and deallocation operations that are critical to system stability and performance.