Description

In the Linux kernel, the following vulnerability has been resolved: mm/huge_memory: unlock i_mmap_rwsem before releasing after-split folios __folio_split() keeps dereferencing the mapping after the split: shmem_uncharge(mapping->host) and remap_page() while the folios are still frozen/locked, and i_mmap_unlock_read(mapping) at the very end, after the after-split folios have been unlocked and freed. Nothing holds an inode reference across that. The split relies on @folio -- which the beyond-EOF drop loop never removes, as it starts at folio_next(folio) -- staying locked and in the page cache to hold off eviction. But the unlock loop unlocks @folio before i_mmap_unlock_read() runs. If the caller's @lock_at is a tail beyond EOF, as memory_failure() passes when splitting a poisoned tail of a shmem THP that reaches past i_size during truncation, it too is gone from the page cache; so once @folio is unlocked no locked, in-cache folio pins the inode, and a concurrent final iput() can evict and RCU-free it before i_mmap_unlock_read() touches i_mmap_rwsem: BUG: KASAN: slab-use-after-free in __up_read+0x634/0x790 i_mmap_unlock_read include/linux/fs.h:537 [inline] __folio_split+0x732/0x1640 mm/huge_memory.c:4100 try_to_split_thp_page+0xab/0x390 mm/memory-failure.c:1675 memory_failure+0x1394/0x26e0 mm/memory-failure.c:2470 Freed by task 4601: shmem_free_in_core_inode+0x54/0xb0 mm/shmem.c:5177 evict+0x57f/0xac0 fs/inode.c:870 Do every mapping dereference while @folio still pins the inode: drop i_mmap_rwsem right after remap_page(), before the loop that unlocks and frees the after-split folios, and clear @mapping so the exit path does not unlock it again. shmem_uncharge() and remap_page() already run before that point, so after this nothing past the unlock loop touches the inode or the mapping. This is now a rule the split depends on, alongside keeping @folio frozen until the page cache is updated: no inode or mapping dereference once the after-split folios start being unlocked.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "7.8",
  "pubDate": "2026-08-15T13:17:53.053Z",
  "pubdate": "2026-08-15T13:17:53.053Z",
  "executiveSummary": "A use-after-free vulnerability exists in the Linux kernel's memory management subsystem, specifically within the transparent huge page splitting logic in mm/huge_memory.c.\nThe vulnerability arises due to a race condition where the i_mmap_rwsem read lock is held while the underlying inode and mapping are released prematurely after folios are unlocked.\nAn attacker or system process triggering specific memory failure and page truncation paths on shared memory (shmem) transparent huge pages can induce a slab-use-after-free condition.\nThis flaw can lead to kernel memory corruption, potential privilege escalation, or a denial of service via kernel panic.\nExploitation requires local execution capabilities and specific memory management operations involving poisoned tails of shmem THP reaching past i_size during truncation.",
  "technicalDetails": "The vulnerability resides in the __folio_split() function within mm/huge_memory.c of the Linux kernel.\nDuring the folio splitting process, __folio_split() continues to dereference the mapping and its host via shmem_uncharge(mapping->host) and remap_page() while folios remain frozen and locked.\nThe i_mmap_unlock_read(mapping) call occurs at the very end of the function, executed after the after-split folios have already been unlocked and freed.\nThe lifetime of the inode is dependent on pinned folios remaining locked and in the page cache to prevent eviction.\nWhen a caller's lock_at points to a tail beyond EOF—such as when memory_failure() splits a poisoned tail of a shmem transparent huge page reaching past i_size during truncation—that folio is also removed from the page cache.\nConsequently, once the target @folio is unlocked, no locked, in-cache folio pins the inode in memory.\nThis permits a concurrent final iput() invocation to execute evict() in fs/inode.c, resulting in the eviction and RCU-freeing of the inode structure while i_mmap_unlock_read() still attempts to access i_mmap_rwsem.\nThis sequence triggers a slab-use-after-free bug in __up_read() called via i_mmap_unlock_read() in include/linux/fs.h.\nTo exploit or trigger this condition, local execution context is required to invoke memory failure handling or truncation routines against shared memory transparent huge pages under specific memory pressure or hardware fault injection scenarios."
}