CVE-2026-64158 in Linux
Summary
by MITRE • 07/19/2026
In the Linux kernel, the following vulnerability has been resolved:
netfs: Fix write streaming disablement if fd open O_RDWR
In netfs_perform_write(), "write streaming" (the caching of dirty data in dirty but !uptodate folios) is performed to avoid the need to read data that is just going to get immediately overwritten. However, this is/will be disabled in three circumstances: if the fd is open O_RDWR, if fscache is in use (as we need to round out the blocks for DIO) or if content encryption is enabled (again for rounding out purposes).
The idea behind disabling it if the fd is open O_RDWR is that we'd need to flush the write-streaming page before we could read the data, particularly through mmap. But netfs now fills in the gaps if ->read_folio() is called on the page, so that is unnecessary. Further, this doesn't actually work if a separate fd is open for reading.
Fix this by removing the check for O_RDWR, thereby allowing streaming writes even when we might read.
This caused a number of problems with the generic/522 xfstest, but those are now fixed.
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 07/19/2026
The vulnerability addressed in this linux kernel fix relates to improper write streaming behavior in the network filesystem subsystem. The issue specifically impacts the netfs_perform_write() function which implements write streaming optimization to avoid unnecessary data reads when overwriting existing content. This optimization caches dirty data in dirty but not yet up-to-date folios, preventing redundant read operations that would immediately get overwritten. The vulnerability stems from an overly restrictive condition that disabled this optimization when file descriptors were opened with O_RDWR flags, creating unnecessary performance degradation.
The technical flaw involves the kernel's network filesystem implementation incorrectly assuming that write streaming must be disabled when file descriptors are opened in read-write mode. This assumption was based on historical requirements where flushing write-streaming pages before reading data was necessary to maintain consistency. However, modern implementations have evolved to handle these scenarios more efficiently through improved page handling mechanisms. The fix removes the O_RDWR check that was preventing write streaming optimization from functioning properly, allowing the system to utilize this performance enhancement regardless of file descriptor access modes.
The operational impact of this vulnerability manifests primarily as reduced performance in network filesystem operations, particularly affecting workloads that involve frequent read-write operations on files opened with O_RDWR flags. This degradation would be especially noticeable in scenarios involving file updates where data is overwritten without requiring prior reads, resulting in unnecessary I/O overhead and increased latency. The fix resolves issues that were specifically impacting the generic/522 xfstest suite, indicating real-world performance implications for filesystem testing and general network file access patterns.
This vulnerability aligns with CWE-200 (Information Exposure) and CWE-362 (Concurrent Execution using Shared Resources) categories as it affects resource sharing and data handling efficiency in concurrent filesystem operations. The mitigation strategy directly addresses the root cause by removing an unnecessary restriction that was preventing optimal write streaming behavior, thereby restoring expected performance characteristics. The fix follows established kernel development practices for optimizing I/O operations while maintaining consistency with modern filesystem access patterns. The resolution ensures that the network filesystem subsystem can properly utilize caching optimizations regardless of file descriptor access modes, improving overall system efficiency and reducing unnecessary I/O overhead in read-write scenarios.