CVE-2026-68086
Received Received - Intake

Memory Corruption in Linux Kernel THPs Handling

Vulnerability report for CVE-2026-68086, including description, CVSS score, EPSS score, affected products, exploitability, helpful resources, and attack-flow context.

Publication date: 2026-08-10

Last updated on: 2026-08-10

Assigner: kernel.org

Description

In the Linux kernel, the following vulnerability has been resolved: mm/khugepaged: write all dirty file folios when collapsing [There is no upstream commit, as this code was removed by upstream commit 044925f9b565 ("mm: fs: remove filemap_nr_thps*() functions and their users")] As-is, khugepaged and writable-file opening exclude each other. A file cannot be open writeable and have THPs (because the filesystem is not aware of them). khugepaged will never collapse file pages for files that are opened writeable. On an open(O_RDWR/O_WRONLY), the page cache for that particular file is dropped. This is fine because nothing could've been dirtied. However, there is an edge-case: collapse_file() might not be able to coexist with concurrent writers, but it can coexist with dirty folios (from previous writers). Therefore, the following can happen: open(file, O_RDWR) write(file) close(file) madvise(file_mapping, MADV_COLLAPSE, some non-dirty range) open(file, O_RDWR) nr_thps > 0 truncate_inode_pages() /* THPs are cleared out, but so are the dirty folios */ When this edge-case happens, there is data loss, as the dirty folios are fully discarded. Fix it by fully writing back the page cache (and waiting) when collapsing file THPs. Doing so provides the guarantee that no dirty folio will be observed while there are active THPs. To fully ensure this is safe, the invalidate_lock needs to be held while doing the writeout, so that do_dentry_open()'s page cache truncation excludes this write-and-wait. As a side effect, move the nr_thps counter bumping outside the i_pages lock. This is correct since the counter itself is an atomic_t and the producer <-> consumer correctness is provided by a full memory barrier: smp_mb() in collapse_file()/memory barrier implied by full ordering in get_write_access() -> atomic_inc_unless_negative().

CVSS Scores

EPSS Scores

Probability:
Percentile:

Meta Information

Published
2026-08-10
Last Modified
2026-08-10
Generated
2026-08-10
AI Q&A
2026-08-10
EPSS Evaluated
N/A
NVD
EUVD

Affected Vendors & Products

Currently, no data is known.

Helpful Resources

Exploitability

CWE
CWE Icon
KEV
KEV Icon
CWE ID Description
CWE-UNKNOWN

Attack-Flow Graph

AI Quick Actions

Instant insights powered by AI
Executive Summary

This vulnerability in the Linux kernel involves data loss during file page collapsing. When a file is opened for writing, its page cache is dropped. However, if a process tries to collapse file pages (using madvise with MADV_COLLAPSE) after a write operation but before the dirty pages are fully written back, the dirty pages may be discarded. This happens because truncate_inode_pages() clears both THPs and dirty folios, leading to data loss.

Impact Analysis

If you use applications relying on Linux kernel file operations, this vulnerability could cause unexpected data loss. Specifically, if a file is written to, closed, and then a process attempts to collapse its pages before dirty pages are fully written back, the dirty data may be lost. This affects systems where large files or memory-mapped files are frequently modified.

Mitigation Strategies

Apply the Linux kernel patch that resolves this issue by ensuring dirty file folios are written back before collapsing THPs. Monitor for data loss in applications using madvise with MADV_COLLAPSE on writable files.

Chat Assistant

Ask questions about this CVE
Hi! I’m here to help you understand CVE-2026-68086. Ask me anything about the vulnerability, its impact, or mitigation strategies.
0/70

EPSS Chart