CVE-2026-99728 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
mm/huge_memory: fix list corruption when deferred_split_scan() races with deferred_split_folio()
Since the deferred split queue became a list_lru, the isolate callback moves the folios it took a reference on to an on-stack list, linked through folio->_deferred_list, and deferred_split_scan() takes them off that list with list_del_init() without holding the list_lru lock.
deferred_split_folio() does not know about the on-stack list. It only holds the list_lru lock when it looks at the same list_head, and it can run for such a folio: a THP is queued when it is mapped, as a candidate for the underused check, and is queued "again" when a part of it gets unmapped:
CPU0 deferred_split_scan() CPU1 deferred_split_folio() list_del_init(&folio->_deferred_list) next->prev = prev prev->next = next entry->next = entry list_lru_lock_irqsave() folio_set_partially_mapped() __list_lru_add() list_empty(item) -> true list_add_tail(item, &l->list) item->next = &l->list item->prev = tail entry->prev = entry
The folio now sits on the list_lru with ->prev pointing to itself. The next removal leaves the neighbours pointing to it, and they still do so after the folio has been freed. With CONFIG_DEBUG_LIST:
list_del corruption. prev->next should be ffd4000000270090, but was ffd4000000278090. (prev=ffd4000000270090)
Fix it by grabbing the lock around list_del_init() so deferred_split_folio() cannot race with it.
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 11/20/2026
The Linux kernel memory management subsystem contains a critical concurrency flaw within the huge page handling logic, specifically involving the interaction between deferred split scanning and folio queuing mechanisms. This vulnerability arises from a race condition in mm/huge_memory where list operations are performed without proper synchronization primitives. The core issue stems from the transition of the deferred split queue to a list_lru structure, which introduced an isolate callback that moves referenced folios onto an on-stack list linked via the folio->_deferred_list field. While this design aims to optimize memory reclamation by identifying underused transparent huge pages for splitting into smaller units, it inadvertently creates a window where concurrent access can corrupt kernel data structures if locks are not held consistently across all code paths that manipulate these lists.
The technical flaw manifests when deferred_split_scan() attempts to remove folios from the on-stack list using list_del_init() without acquiring the associated list_lru lock. Simultaneously, another CPU executing deferred_split_folio() may be manipulating the same underlying data structures while holding only the list_lru lock for specific operations such as checking if a folio is partially mapped or adding it to the global queue. This lack of mutual exclusion allows two distinct execution contexts to modify linked list pointers concurrently. Specifically, one thread might unlink a node from the on-stack list while another thread adds that same node back into the main deferred split queue based on its mapping status changes. The resulting race condition leads to inconsistent pointer updates where forward and backward links are not updated atomically relative to each other or to the global state.
The operational impact of this vulnerability is severe, primarily characterized by kernel memory corruption leading to system instability. When the linked list pointers become desynchronized due to the race, nodes end up pointing to themselves or maintaining stale references after being freed. This results in a corrupted doubly-linked list structure within the kernel heap. Under normal operation, this can cause unpredictable behavior during memory reclamation processes, potentially leading to crashes when the kernel attempts to traverse these malformed lists. With CONFIG_DEBUG_LIST enabled, the corruption is immediately detectable through explicit validation checks that verify prev->next and next->prev consistency, triggering a list_del corruption error message in the kernel log. In production environments without debug flags, this could lead to silent data structure corruption, eventual use-after-free scenarios when freed memory containing stale pointers is accessed again, or general system panics due to invalid memory accesses during page splitting operations.
This vulnerability aligns with CWE-362, which describes concurrent execution using shared resources with improper synchronization. The root cause is a classic lock ordering and coverage issue where one code path acquires the necessary lock while another does not when accessing the same critical section of data structures. From an ATT&CK perspective, this represents a technique often exploited in exploit chains to gain arbitrary write primitives or escalate privileges by corrupting kernel memory structures like linked lists used for process scheduling or memory management. Attackers with local access could potentially leverage such race conditions to trigger denial-of-service attacks against the system stability or, if combined with other vulnerabilities, achieve privilege escalation by manipulating control flow through corrupted pointers.
To mitigate this vulnerability, it is essential to ensure that all accesses to shared data structures involved in deferred split operations are protected by consistent locking mechanisms. The primary fix involves modifying deferred_split_scan() to acquire the list_lru lock before performing list_del_init() on folios removed from the on-stack list. This ensures mutual exclusion with deferred_split_folio(), which already holds this lock during its critical sections involving queue manipulation. System administrators should apply kernel updates that include this patch immediately, particularly for systems heavily reliant on transparent huge pages and memory reclamation efficiency. Regularly updating to patched versions of the Linux kernel is crucial as unpatched kernels remain susceptible to these race conditions under high load or specific memory pressure scenarios where THP mapping states change rapidly.