CVE-2026-72366 in Linux
Summary
by MITRE • 08/15/2026
In the Linux kernel, the following vulnerability has been resolved:
netfs: Fix netfs_create_write_req() to handle async cache object creation
netfs_create_write_req() will skip caching if the fscache cookie is disabled, but this is a problem because async cache object creation might not have got far enough yet that has been enabled - thereby causing the call to fscache_begin_write_operation() to be skipped.
Fix this by removing the checks on the cookie and delegating this to fscache_begin_write_operation().
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 08/15/2026
The vulnerability identified in the Linux kernel's netfs subsystem represents a critical race condition affecting asynchronous cache object creation mechanisms within the file system caching framework. This issue specifically impacts the netfs_create_write_req() function which serves as a core component in managing write operations for network file systems that utilize the fscache infrastructure. The flaw arises from improper handling of cache cookie states during concurrent operations, creating a scenario where the system may prematurely skip essential caching initialization steps.
The technical root cause stems from inadequate synchronization logic within the netfs subsystem where the function performs early checks on fscache cookie status before proceeding with write operation initialization. When cache cookies are disabled or not yet fully initialized, the function incorrectly assumes that no caching should occur and bypasses the critical fscache_begin_write_operation() call. This premature optimization fails to account for asynchronous cache object creation processes that may still be in progress, leading to a state where cache objects remain uninitialized while write operations attempt to proceed.
This vulnerability creates significant operational risks within network file system environments where fscache is actively utilized for performance optimization. The race condition can result in inconsistent cache states, potential data loss during write operations, and degraded system reliability when concurrent access patterns occur. Attackers could potentially exploit this timing issue to manipulate cache consistency or force the system into error states that might be leveraged for denial-of-service attacks against network file services.
The fix implemented addresses this by removing the conditional checks on fscache cookies within netfs_create_write_req() and instead delegating all cache state management to the fscache_begin_write_operation() function. This approach ensures proper synchronization between cache initialization phases and write operation commencement, allowing the system to handle asynchronous cache object creation correctly regardless of initial cookie states. The solution aligns with established security practices for concurrent systems and follows the principle of least privilege by ensuring all cache operations are properly validated through the designated cache management interface.
This vulnerability demonstrates the importance of proper synchronization in distributed file system implementations and highlights potential issues when multiple subsystems interact through shared caching mechanisms. The fix reinforces proper design patterns for asynchronous operations and ensures that critical cache initialization steps cannot be bypassed due to timing issues in concurrent environments. From an industry standards perspective, this addresses concepts related to CWE-362 (Concurrent Execution using Shared Resource with Improper Synchronization) and aligns with ATT&CK techniques involving system modification through race conditions.
The remediation ensures that network file systems utilizing fscache functionality maintain proper cache consistency during write operations while preserving the performance benefits of asynchronous caching mechanisms. This fix particularly impacts enterprise environments relying on network file services where cache coherency is critical for data integrity and system reliability. The solution maintains backward compatibility while strengthening the robustness of the underlying caching infrastructure against race conditions that could otherwise compromise system stability or security properties.