CVE-2026-99741 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
tmpfs: keep the quota soft limits of an unused id
When the last reference to a dquot goes away, shmem_release_dquot() stores its limits in the rb tree of the mount, unless shmem_is_empty_dquot() says that there is nothing worth storing. That function looks at the usage and at the two hard limits only.
So if the administrator sets nothing but soft limits for an id that owns no file yet, the entry is thrown away as soon as the dquot that Q_SETQUOTA used is released, and the id never gets to see a limit.
To fix it, compare the soft limits as well: an entry can be empty only if both soft limits are zero as well, which is exactly what shmem_acquire_dquot() sets for a new entry.
Fix generated by an LLM and sent by Josef Bacik in private.
[ david: slightly adjusted description ]
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 vulnerability resides within the tmpfs implementation of the Linux kernel, specifically affecting how disk quota limits are managed for user or group identifiers that have not yet allocated any files. The core issue stems from a logical flaw in the shmem_release_dquot function, which is responsible for persisting quota information when the last reference to a dquot structure is released. Under normal operation, this function attempts to store limit data into an rb tree associated with the mount point to ensure that quotas remain enforced even after temporary references are dropped. However, the decision to discard or retain these limits relies on the shmem_is_empty_dquot helper function, which currently evaluates only the usage statistics and the two hard limits for a given identifier.
This narrow evaluation criteria creates a specific edge case where an administrator configures soft disk quota limits but does not set any corresponding hard limits for an identifier that has no active file allocations. Because the shmem_is_empty_dquot function ignores soft limits during its emptiness check, it incorrectly determines that there is nothing worth storing in this scenario. Consequently, as soon as the dquot object associated with the initial Q_SETQUOTA operation is released by the kernel's reference counting mechanism, the configured soft limit information is discarded from memory rather than being persisted to the mount’s quota tree. This results in a state where the identifier effectively loses its enforced constraints immediately after configuration, despite the administrator having explicitly set them.
The operational impact of this flaw is significant for systems relying on tmpfs and strict disk quotas for resource management or security isolation. When soft limits are silently dropped, processes running under the affected user or group ID can exceed their intended usage thresholds without triggering the expected warnings or throttling mechanisms associated with soft limit enforcement. This undermines administrative policies designed to prevent resource exhaustion within shared memory filesystems. In environments where tmpfs is used for sensitive operations or multi-tenant workloads, this lack of quota enforcement could lead to unexpected consumption of system resources, potentially affecting other services sharing the same mount point and violating security boundaries established by storage quotas.
To resolve this issue, the kernel logic was updated to include soft limits in the emptiness assessment performed by shmem_is_empty_dquot. The fix ensures that an entry is considered empty only if both hard limits and soft limits are zero, aligning with how new entries are initialized via shmem_acquire_dquot. By retaining quota structures even when they contain only soft limit configurations, the kernel preserves administrative intent across reference count transitions. This change mitigates CWE-20 Improper Input Validation by ensuring that all relevant configuration parameters are correctly processed and persisted rather than being erroneously filtered out based on incomplete criteria. From a defense-in-depth perspective, this aligns with ATT&CK technique T1496 Resource Hijacking prevention strategies by maintaining controls against unauthorized or excessive resource consumption within the filesystem layer.