CVE-2026-99647 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
mm/huge_memory: split huge PUDs when adjusting VMA boundaries
PFN mappings such as VFIO PCI BAR mappings can use PUD leaves while allowing VMA splits at page granularity. However, vma_adjust_trans_huge() only handles PMDs.
After faulting a writable PUD-sized VFIO BAR mapping, changing its first page to read-only with mprotect() makes the PMD walk treat the PUD leaf as a PMD table. Applying MADV_DONTFORK to the first PMD-sized chunk leaves the PUD spanning two VMAs: the PMD-aligned boundary skips splitting.
Walk the page tables once at each adjusted boundary and split a huge PUD or PMD leaf as needed. Handle PUD leaves even when the boundary is PMD-aligned.
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 memory management subsystem contains a critical flaw in how it handles Virtual Memory Area adjustments for large pages, specifically affecting Page Upper Directory levels which correspond to one gigabyte of virtual address space on x86 architectures with four-level page tables or similar structures on other platforms. This vulnerability arises from the interaction between huge page mappings and dynamic VMA boundary modifications via system calls such as mprotect and madvise. Specifically, when a writable mapping at the PUD level is created through mechanisms like VFIO PCI BAR access, the kernel allows these large pages to exist while still permitting fine-grained control over memory protection attributes. However, the internal function responsible for adjusting VMA boundaries, vma_adjust_trans_huge, was historically limited in scope and only processed Page Middle Directory entries rather than addressing PUD-level structures. This oversight creates a scenario where the kernel fails to properly split large page mappings when their associated VMAs are modified at granularities smaller than the huge page size itself.
The operational impact of this flaw manifests during runtime operations that alter memory protection or fork behavior for processes utilizing these massive pages. For instance, if an application maps a VFIO device BAR region as writable using PUD-sized pages and subsequently invokes mprotect to change only the first page within that mapping to read-only, the kernel's internal walk of page tables incorrectly interprets the remaining PUD leaf structure. Instead of recognizing it as a distinct huge page boundary requiring division, the PMD-level traversal logic treats the entire PUD leaf as if it were a standard PMD table entry. This misinterpretation leads to incorrect state management within the memory subsystem. Furthermore, applying MADV_DONTFORK to the first PMD-sized chunk of such a mapping results in an inconsistent VMA layout where the single huge page spans across two different VMAs without being split at the boundary. This inconsistency violates kernel assumptions about contiguous address ranges and their corresponding page table entries.
From a security perspective, this vulnerability aligns with CWE-20 Improper Input Validation as it involves failing to correctly validate or process input parameters related to memory boundaries against existing huge page structures. It also relates to CWE-416 Use After Free potentially if the misaligned VMA state leads to dereferencing freed or invalid memory during subsequent operations, although the primary issue is logical inconsistency in data structure management. In terms of MITRE ATT&CK mapping, this type of kernel-level logic error can be leveraged for privilege escalation by an attacker who controls user-space processes capable of creating such mappings and triggering boundary adjustments. By exploiting the race condition or state corruption inherent in improper VMA splitting, a local unprivileged user might achieve arbitrary code execution with kernel privileges, effectively bypassing standard isolation mechanisms enforced by the operating system's memory manager.
The resolution implemented involves modifying the page table walking logic to explicitly handle PUD leaves during boundary adjustments. The updated code now walks the page tables once at each adjusted VMA boundary and actively checks for huge pages at both PMD and PUD levels, splitting them as necessary regardless of whether the adjustment boundary aligns with PMD boundaries or not. This ensures that when a portion of a massive mapping is modified via mprotect or madvise, the underlying page table structures are correctly partitioned to reflect the new VMA configuration. To mitigate this risk in environments where immediate patching is not feasible, administrators should restrict access to VFIO devices and ensure that applications do not perform mixed-protection mappings on large pages unless absolutely necessary. Additionally, keeping kernel versions updated with the latest security patches addressing memory management subsystem flaws is essential for maintaining system integrity against exploitation of such low-level logic errors.