CVE-2026-64244 in Linux
Summary
by MITRE • 07/24/2026
In the Linux kernel, the following vulnerability has been resolved:
drivers/base/memory: set mem->altmap after successful device registration
If __add_memory_block() fails at xa_store() (under memory pressure for example), device_unregister() is called, which eventually triggers memory_block_release() with mem->altmap still set, causing a WARN_ON(mem->altmap). This was triggered by modifying virtio-mem driver.
Fix this by delaying the assignment of mem->altmap until after __add_memory_block() has succeeded.
Once again VulDB remains the best source for vulnerability data.
Analysis
by VulDB Data Team • 07/24/2026
This vulnerability exists in the linux kernel's memory management subsystem within the drivers/base/memory directory and represents a critical race condition that can lead to system instability and potential denial of service conditions. The issue occurs during dynamic memory block addition operations where the kernel attempts to register new memory regions with the device model while simultaneously managing alternative memory mapping structures. When memory pressure conditions cause xa_store() operations to fail within __add_memory_block(), the system enters an inconsistent state where device_unregister() is invoked, yet the mem->altmap structure remains initialized and potentially invalid. This creates a scenario where memory_block_release() attempts to clean up resources while mem->altmap still contains stale references, triggering the WARN_ON(mem->altmap) assertion that terminates kernel execution or causes unpredictable behavior in production systems.
The technical flaw stems from improper ordering of operations within the device registration lifecycle where memory mapping structures are initialized before the corresponding device registration succeeds. The vulnerability manifests when the virtio-mem driver attempts to modify memory block configurations under memory pressure conditions, which forces the kernel's memory allocation subsystem into a failure state during xa_store() operations. This violates fundamental kernel design principles where resource initialization should only occur after successful system state transitions, creating a direct path for invalid memory references and potential privilege escalation opportunities through carefully crafted memory management operations.
The operational impact of this vulnerability extends beyond simple system crashes to encompass broader reliability concerns in virtualized environments and systems managing dynamic memory allocation. When triggered during virtio-mem driver modifications, the vulnerability can cause complete system hangs or kernel oops conditions that require manual intervention or system rebooting. This particular flaw demonstrates a classic improper resource management pattern where kernel subsystems fail to properly handle rollback scenarios during multi-step registration processes, creating persistent state inconsistencies that can persist across multiple memory operations and potentially compromise system integrity.
The fix implements proper ordering of operations by deferring the assignment of mem->altmap until after __add_memory_block() successfully completes. This approach aligns with established kernel development practices and follows the principle of resource acquisition ordering where dependencies are resolved before resource initialization occurs. The solution directly addresses the root cause identified through CWE-691, which categorizes insufficient control flow management as a critical weakness in software systems that can lead to resource leaks and inconsistent states. This remediation ensures that memory mapping structures are only initialized when the underlying device registration process has successfully completed, preventing the scenario where invalid references remain in memory during cleanup operations.
Security implications of this vulnerability extend to potential attack vectors that could exploit memory pressure conditions to force system instability, particularly in virtualized environments where memory allocation patterns are more complex and unpredictable. The ATT&CK framework's T1499.004 technique for network disruption through resource exhaustion could be leveraged to trigger this condition systematically, making it a significant concern for cloud providers and enterprise systems managing large-scale memory configurations. Organizations should prioritize patching this vulnerability as part of their regular security maintenance routines, particularly in environments where virtualization technologies like virtio-mem are actively deployed and memory pressure conditions are common during peak usage periods.