CVE-2026-99742 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

mm/mempolicy: charge shared policy nodes

Any local user can bypass memory.max with mbind() on a tmpfs file, and allocate unbounded kernel memory.

mbind() sets a NUMA memory policy for a range of a mapping. If the mapping is of a shmem and friends, the kernel also stores the policy on the inode, in a tree with one entry per range of the file.

Each mbind() on a single page of a mapping can add one shared policy node (struct sp_node) and one struct mempolicy to that tree. They outlive the mapping and stay around until the inode is destroyed. The tree is not bounded by the file size, so the file can be empty.

Memory that user space can allocate must be charged to a memory cgroup. A slab cache does that for all of its objects if it is created with SLAB_ACCOUNT. numa_policy_init() creates the slab caches for both structs without SLAB_ACCOUNT, so they are not charged to any cgroup.

Reproduced with mbind() on single pages of an empty tmpfs file, from a cgroup with memory.max=8M: the global OOM killer killed tasks owned by root, and the machine panicked.

Fix this by creating both caches with SLAB_ACCOUNT. This change implies that mbind() can now fail when running into memcg limits. Further, the policy_cache also serves task and VMA policies, so they are similarly accounted now.

Note that per-file limits are not really helpful, as the user could simply use many files; having limits per user is tricky as well.

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

[ david: smaller description tweaks ]

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 contains a critical resource exhaustion vulnerability within the memory policy subsystem, specifically affecting how shared NUMA (Non-Uniform Memory Access) policies are managed for temporary file systems such as tmpfs. This flaw allows any local user to bypass memory cgroup limits defined by memory.max and allocate unbounded amounts of kernel memory. The vulnerability stems from the implementation details of the mbind() system call, which is designed to set NUMA memory policies for specific ranges of a memory mapping. When applied to shmem or tmpfs mappings, the kernel stores these policies on the inode in a tree structure where each entry corresponds to a range within the file. Crucially, this policy data persists beyond the lifetime of the individual mapping and remains attached to the inode until it is destroyed.

The core technical flaw lies in how memory for these policy structures is allocated from slab caches. Each invocation of mbind() on a single page can create one shared policy node struct sp_node and one struct mempolicy object, adding them to the inode's tree. Because the file size does not constrain this tree structure, an attacker can target even empty tmpfs files. The kernel creates the slab caches for these structures using numa_policy_init without setting the SLAB_ACCOUNT flag. Consequently, memory allocated from these caches is not charged against any memory control group (memcg). This omission means that user-space processes operating within a restricted cgroup with a strict memory.max limit can trigger allocations that bypass those limits entirely, consuming global kernel memory resources instead.

The operational impact of this vulnerability is severe and potentially catastrophic for system stability. By repeatedly calling mbind() on single pages of an empty tmpfs file, a local user can exhaust available kernel memory without triggering the expected cgroup-based throttling or killing mechanisms. In tested scenarios, this unbounded allocation led to global Out-Of-Memory (OOM) conditions where the OOM killer terminated critical system tasks owned by root. The resulting resource starvation caused the machine to panic and crash, effectively denying service to all users on the affected system. This represents a significant availability risk, as it allows an unprivileged user to destabilize the entire host through simple API calls that are intended for legitimate memory management purposes.

To mitigate this vulnerability, the kernel developers have updated the slab cache creation logic in numa_policy_init() to include the SLAB_ACCOUNT flag for both struct sp_node and struct mempolicy caches. This change ensures that all memory allocated from these pools is properly accounted against the relevant memory cgroup limits. As a result of this fix, mbind() operations will now fail with an error code if they would exceed the configured memcg limits, thereby enforcing resource boundaries as originally intended. It is important to note that because policy_cache also serves task and VMA policies, these allocations are similarly accounted for under the new implementation. While per-file limits were considered insufficient due to the ease of bypassing them via multiple files, this fix enforces limits at a broader scope, protecting against both user-level and system-wide resource exhaustion attacks.

From a classification perspective, this vulnerability aligns with CWE-789: Memory Allocation with Excessive Size or Quantity, as it involves allocating more memory than intended by the security policy. It also relates to CWE-400: Uncontrolled Resource Consumption, given that an attacker can deplete system resources leading to denial of service. In terms of attack vectors, this falls under ATT&CK technique T1496: Resource Hijacking, where attackers consume significant amounts of computing resources to degrade performance or cause a denial-of-service condition for other users on the same host. The fix ensures that resource consumption is properly tracked and limited according to cgroup configurations, restoring the integrity of kernel memory management policies.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00169

KEV

no

Activities

very low

Sources

Do you know our Splunk app?

Download it now for free!