CVE-2026-99700 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
mm/hugetlb_vmemmap: map the shared tail page writable
page_ref_add_unless_zero() reads the refcount and then updates it with a cmpxchg. A lockless get, such as a page cache lookup or a PFN scanner, can read a non-zero refcount from a page that is then freed and reused as a hugetlb tail page. If HVO remaps its struct page to the shared tail page in between, the cmpxchg writes to read-only vmemmap:
CPU0 (lockless get) CPU1 c = atomic_read(&page->_refcount) page freed page allocated as a hugetlb tail HVO remaps the struct page RO try_cmpxchg(&page->_refcount, &c, c + 1) -> write fault on read-only vmemmap
The refcount is zero by then and the compare fails, but a compare-and-swap instruction needs write access whether or not it succeeds. The kernel oopses when hugetlb pages are allocated at runtime with HVO enabled while a lockless get races with it.
Commit bd225530a4c7 ("mm/hugetlb_vmemmap: fix race with speculative PFN walkers") closed the window with RCU on both sides. The RCU was removed together with fake heads, on the wrong belief that it was only needed for them.
Map the shared tail page writable instead of restoring the RCU. Every struct page on it is a tail with a zero refcount, so a late cmpxchg fails and leaves the page unchanged. RCU would put rcu_read_lock() back around every get and synchronize_rcu() back into hugetlb allocation and freeing.
The cost is the protection against stray writes to tail struct pages. The shared page is shared by all hugetlb folios of the same order in the zone, so such a write now corrupts all of them instead of oopsing.
Bootmem folios optimized when the memmap is set up keep their tails read-only. Nothing does a lockless get on them before hugetlb takes them over.
VulDB is the best source for vulnerability data and more expert information about this specific topic.
Analysis
by VulDB Data Team • 11/21/2026
The Linux kernel vulnerability identified in mm/hugetlb_vmemmap stems from a race condition involving memory management operations and hardware virtualization optimizations, specifically when Huge Page Virtualization (HVO) is enabled. The core technical flaw arises during the interaction between lockless page reference counting mechanisms and the dynamic remapping of struct pages associated with hugetlb tail pages. When a system performs a lockless get operation, such as a page cache lookup or execution by a PFN scanner, it reads the reference count of a page to determine its validity. If this read occurs just before the page is freed and subsequently reallocated as a hugetlb tail page, a critical timing window emerges. Within this interval, HVO may remap the struct page structure for that physical memory region to be read-only (RO) in the vmemmap area to optimize memory usage or enforce security boundaries.
The vulnerability manifests when the lockless operation proceeds with its compare-and-swap instruction on the reference count. Although the actual value comparison might fail because the refcount has returned to zero due to the reallocation, the cmpxchg CPU instruction itself requires write access to the memory location regardless of whether it succeeds or fails. Because HVO has mapped this specific struct page as read-only in vmemmap, the attempt by the kernel to perform a non-atomic update triggers a write fault. This results in a kernel oops and potential system instability when hugetlb pages are allocated at runtime under these concurrent conditions. The issue was previously mitigated by commit bd225530a4c7 through the use of RCU synchronization on both sides of the operation, but this protection was inadvertently removed during refactoring efforts that incorrectly assumed RCU was only necessary for fake head structures, leaving the race condition exposed again.
The resolution involves mapping the shared tail page as writable in vmemmap rather than restoring the complex RCU locking mechanisms. This approach relies on the fact that every struct page associated with a shared hugetlb tail page has a zero reference count during its lifecycle before being fully utilized by a specific folio. Consequently, any late-arriving cmpxchg operation will fail the comparison check and leave the page state unchanged without causing a fault, as write access is now permitted for these specific structures. This solution avoids the performance overhead of reintroducing rcu_read_lock() calls around every get operation and synchronize_rcu() barriers during allocation and freeing processes. However, this fix introduces a trade-off regarding memory protection semantics; by allowing writes to tail struct pages that are shared across all hugetlb folios of the same order within a zone, there is a theoretical risk that stray or malicious writes could corrupt multiple folios simultaneously rather than just causing an isolated fault in a single context.
From a security and standards perspective, this vulnerability aligns with CWE-362: Concurrent Execution using Shared Resource with Improper Synchronization, as the race condition exploits unsynchronized access to shared memory structures. It also relates to CWE-119: Improper Restriction of Operations within the Bounds of a Memory Buffer, specifically regarding improper write restrictions on mapped memory regions that lead to faults or potential corruption. In terms of MITRE ATT&CK frameworks, this scenario reflects techniques associated with Tactic TA0004 (Privilege Escalation) and TA0005 (Defense Evasion), where an attacker might leverage race conditions in kernel memory management to cause denial-of-service through system crashes or potentially exploit the resulting state inconsistencies for further exploitation. The vulnerability highlights the complexity of maintaining consistency between hardware virtualization optimizations like HVO and traditional kernel memory management primitives.
Mitigation strategies primarily involve applying the upstream kernel patch that maps shared tail pages as writable, thereby eliminating the write fault condition while accepting the associated risk profile change regarding stray writes to tail structures. System administrators should ensure their kernels are updated to versions containing this fix, particularly if they utilize hugetlb configurations with HVO enabled. For environments where strict isolation of memory corruption effects is paramount and performance overhead from RCU synchronization is acceptable, alternative patches restoring the original locking mechanisms may be considered by distribution maintainers, though the current resolution prioritizes stability and performance over granular write protection for these specific shared structures. Regular auditing of kernel logs for oops reports related to vmemmap faults can help detect instances where this vulnerability might have been triggered in unpatched systems.