CVE-2026-99740 in Linuxinfo

Summary

by MITRE • 11/20/2026

In the Linux kernel, the following vulnerability has been resolved:

mm/shmem: stop retrying folios that cannot be split

A fault or collapse can insert a large folio crossing EOF after shmem_undo_range() has handled the boundary folios. If splitting that folio fails, truncate_inode_partial_folio() retains it when it is dirty. The final scan then repeatedly finds it because it restarts from an unchanged start.

Truncation keeps the inode lock and ignores fatal signals while looping. A concurrent unlink() can then block other directory operations while holding the directory lock and waiting for the file's lock.

Advance start past the retained folio, whose truncated part has already been zeroed. Do not move start backwards if the failed split has shrunk the folio.

Fix generated by an LLM and sent by Chris Mason in private.

[ david: split fixes, simplify descriptions, adjust comments ]

If you want to get best quality of vulnerability data, you may have to visit VulDB.

Analysis

by VulDB Data Team • 11/20/2026

The vulnerability identified within the Linux kernel's shared memory subsystem involves a logic error during file truncation operations that can lead to performance degradation and potential denial of service conditions. Specifically, the issue resides in the mm/shmem module where large folios crossing the end-of-file boundary are not handled correctly when they cannot be split after an undo range operation has already processed the boundary folios. When a fault or collapse mechanism inserts such a large folio that extends beyond the file's current size, and subsequent attempts to split this folio fail, the truncate_inode_partial_folio function retains the dirty portion of the folio rather than discarding it appropriately. This retention creates a state where the truncation loop repeatedly encounters the same unchanged starting point because the start index is not advanced past the retained folio whose truncated segment has already been zeroed out.

This logical flaw results in an infinite or near-infinite retry loop during file operations that require truncation, such as unlinking files from directories containing shared memory mappings. The operational impact of this defect includes significant CPU consumption due to the tight looping behavior and severe blocking of concurrent directory operations. Because the truncation process holds the inode lock while ignoring fatal signals, it prevents other processes from accessing or modifying related inodes. Furthermore, a concurrent unlink operation can block other directory activities by holding the directory lock and waiting for the file's lock, creating a deadlock-like scenario that effectively denies service to legitimate users and applications attempting to perform standard filesystem operations on affected directories.

From a classification perspective, this vulnerability aligns with CWE-835 which describes loops involving resource exhaustion or infinite looping due to improper loop control logic. The behavior also reflects aspects of CWE-400 concerning uncontrolled resource consumption where the kernel enters a state that consumes excessive processing time without making progress toward completion. In terms of attack vectors, this could be leveraged by local attackers with sufficient privileges to create shared memory files and trigger truncation operations under specific timing conditions involving concurrent unlinking activities. This maps to MITRE ATT&CK techniques related to resource hijacking or denial of service through kernel-level exploitation, particularly in multi-tenant environments where such blocking can impact system stability and responsiveness for other users on the same host.

The resolution involves modifying the truncation logic to ensure that the start index is advanced past any retained folio after a failed split attempt, preventing the loop from restarting at an unchanged position. Additionally, the fix ensures that if a failed split shrinks the folio, the start pointer does not move backwards, thereby maintaining forward progress in the iteration process. This correction eliminates the possibility of getting stuck on unsplittable dirty folios and restores normal operation for file truncation and unlinking sequences involving shared memory objects.

To mitigate this vulnerability, system administrators should apply the latest kernel updates that include fixes to the mm/shmem subsystem. Organizations relying on Linux kernels with shared memory capabilities must ensure their patch management processes are up to date to prevent potential denial of service scenarios arising from concurrent file operations. Monitoring for high CPU usage associated with filesystem-related tasks or unusual blocking in directory operations can serve as an indicator of exploitation attempts targeting this flaw until patches are deployed across all affected systems.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00168

KEV

no

Activities

very low

Sources

Want to stay up to date on a daily basis?

Enable the mail alert feature now!