CVE-2026-64062

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

netfs: Fix potential deadlock in write-through mode

Fix netfs_advance_writethrough() to always unlock the supplied folio and to mark it dirty if it isnt yet written to the end. Unfortunately, it cant be marked for writeback until the folio is done with as that may cause a deadlock against mmapped reads and writes.

Even though it has been marked dirty, premature writeback cant occur as the caller is holding both inode->i_rwsem (which will prevent concurrent truncation, fallocation, DIO and other writes) and ictx->wb_lock (which will cause flushing to wait and writeback to skip or wait).

Note that this may be easier to deal with once the queuing of folios is split from the generation of subrequests.

Weakness

The product does not properly acquire or release a lock on a resource, leading to unexpected resource state changes and behaviors.

Affected Software

Extended Description

Locking is a type of synchronization behavior that ensures that multiple independently-operating processes or threads do not interfere with each other when accessing the same resource. All processes/threads are expected to follow the same steps for locking. If these steps are not followed precisely - or if no locking is done at all - then another process/thread could modify the shared resource in a way that is not visible or predictable to the original process. This can lead to data or memory corruption, denial of service, etc.

Potential Mitigations

Related Attack Patterns

• https://cwe.mitre.org/data/definitions/25.html
• https://cwe.mitre.org/data/definitions/26.html
• https://cwe.mitre.org/data/definitions/27.html

References

• https://git.kernel.org/stable/c/003aa0dd26c964025acd6d1213bcdbd674db2ca9
• https://git.kernel.org/stable/c/1468f39243ccb155b6d97f9a9932f610d1205d75
• https://git.kernel.org/stable/c/b6a4ae1634b3ad2aaa05222e53d36da532852faf
• https://git.kernel.org/stable/c/e40e9cbf3ee4d30ee9a97bd128c85500b6ad0da1