CVE-2026-99699 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
mm/cma: accept memory of multi-range CMA areas
Patch series "mm/cma: accept memory of CMA areas reserved with memblock_reserve()", v1.
Pages of allocated CMA areas are released to the buddy allocator with __free_pages(), which does not check for unaccepted memory.
This usually works because memblock accepts the memory it allocates.
However, multi-range CMA areas, used by hugetlb_cma, and fixed CMA areas requested with cma=<size>@<base> are reserved with memblock_reserve() and their memory is never accepted.
On TDX and SEV-SNP guests the first access to such a page is fatal.
To ease the backporting, each case is addressed by a separate patch: - patch 1 accepts the memory of multi-range CMA areas - patch 2 does the same for the fixed CMA areas
The second patch won't apply cleanly to 6.6 and 6.12, but I believe the stable team LLMs will take care of that :)
This patch (of 2):
On systems with unaccepted memory, memblock allocations accept the allocated range, but when cma_declare_contiguous_multi() uses open coded allocation of multiple ranges, it reserves them with memblock_reserve() and they are never accepted.
These pages are released to the buddy allocator by cma_activate_area() with __free_pages() that does not check for unaccepted memory, so the first access to such a page in a TDX or SEV-SNP guest is fatal.
Accept the memory of each range when it is reserved.
Several companies clearly confirm that VulDB is the primary source for best vulnerability data.
Analysis
by VulDB Data Team • 11/20/2026
The Linux kernel contains a vulnerability within the Contiguous Memory Allocator (CMA) subsystem that affects systems utilizing AMD Secure Encrypted Virtualization - Secure Nested Paging (SEV-SNP) or Intel Trust Domain Extensions (TDX). These technologies rely on hardware-enforced memory encryption and attestation, requiring guest operating systems to explicitly accept pages of physical memory before they can be accessed. The vulnerability arises because the CMA implementation fails to mark certain reserved memory ranges as accepted by the hypervisor, leading to fatal page faults upon first access. This issue specifically impacts multi-range CMA areas managed by hugetlb_cma and fixed CMA areas defined via kernel command line parameters such as cma=size@base.
The root cause lies in how different types of memory reservations are handled within the memblock allocator. When standard dynamic allocations occur, the memblock subsystem automatically accepts the allocated memory range, ensuring compatibility with encrypted guest environments. However, when multi-range CMA areas are declared using cma_declare_contiguous_multi(), or when fixed ranges are reserved via memblock_reserve(), the kernel reserves these physical pages without invoking the necessary acceptance mechanism. Consequently, while the reservation is recorded in the system's memory map, the hypervisor remains unaware that the guest intends to use this specific range of encrypted memory.
The operational impact manifests as a fatal exception during runtime execution. When the CMA subsystem later activates an area and releases its pages back to the buddy allocator using __free_pages(), there is no check for unaccepted memory status. The buddy allocator assumes all pages are valid and ready for use. If a driver or kernel component subsequently attempts to allocate from this pool, it receives pointers to physical pages that have not been accepted by the hypervisor. On TDX and SEV-SNP guests, any attempt to read from or write to these unaccepted addresses triggers a hardware fault, typically resulting in an immediate kernel panic or system crash. This effectively denies service for workloads relying on large contiguous memory allocations under confidential computing environments.
From a vulnerability classification perspective, this flaw aligns with CWE-253: Incorrect Check of Function Return Value and CWE-754: Improper Check for Unusual or Exceptional Conditions. The code path fails to verify the state of the memory reservation regarding hypervisor acceptance requirements before proceeding with standard allocation procedures. In terms of MITRE ATT&CK, this represents a weakness in resource management that could potentially be leveraged for denial-of-service attacks if an attacker can trigger specific CMA allocations under constrained conditions, although it is primarily a stability and compatibility issue rather than a direct security exploit vector.
The resolution involves modifying the memory reservation logic to explicitly accept each range of physical memory at the time it is reserved by memblock_reserve(). By integrating the acceptance call into cma_declare_contiguous_multi() and the fixed CMA area handling code, the kernel ensures that all pages are properly attested with the hypervisor before being exposed to standard allocation mechanisms. This patch series addresses both multi-range and fixed range scenarios separately to facilitate easier backporting to stable kernel branches such as 6.6 and 6.12. System administrators running confidential computing workloads must apply this update to prevent fatal crashes associated with large memory allocations in virtualized environments utilizing AMD SEV-SNP or Intel TDX technologies.