mm/khugepaged: fix dirty page handling for MADV_COLLAPSE
Subsystems (3)
v5 cover mm/khugepaged: fix dirty page handling for MADV_COLLAPSE
MADV_COLLAPSE on file-backed mappings fails with -EINVAL when TEXT pages are dirty. This affects scenarios like package/container updates or executing binaries immediately after writing them, etc.
The issue is that collapse_file() triggers async writeback and returns SCAN_FAIL (maps to -EINVAL), expecting khugepaged to revisit later. But MADV_COLLAPSE is synchronous and userspace expects immediate success or a clear retry signal.
Reproduction:
- Compile or copy 2MB-aligned executable to XFS/ext4 FS
- Call MADV_COLLAPSE on .text section
- First call fails with -EINVAL (text pages dirty from copy)
- Second call succeeds (async writeback completed)
Issue Report:
https://lore.kernel.org/all/[email protected]
Hi Andrew,
This V5 series incorporates David's feedback for simplifying the retry logic. To apply on mm-new, please drop:
- [email protected]:
[PATCH V4 0/2] mm/khugepaged: fix dirty page handling for MADV_COLLAPSE
- [email protected]:
[PATCH V2 0/5] mm/khugepaged: cleanups and scan limit fix (merge conflicts with this series; V3 with review fixes posting soon)
Thank you :)
Changelog:
V5:
- In patch 2/2, Simplify dirty writeback retry logic (David)
V4:
- https://lore.kernel.org/all/[email protected]
- Rebase on mm-new
- Fix spurious blank line (Lance)
V3:
- https://lore.kernel.org/all/[email protected]
- Reordered patches: Enum definition comes first as the retry logic depends on it
- Renamed SCAN_PAGE_NOT_CLEAN to SCAN_PAGE_DIRTY_OR_WRITEBACK (Dev, Lance, David)
- Changed writeback logic: Only trigger synchronous writeback and retry if the initial collapse attempt failed specifically due to dirty/writeback pages, rather than blindly flushing all file-backed VMAs (David)
- Added proper file reference counting (get_file/fput) around the unlock window to prevent UAF (Lance)
V2:
- https://lore.kernel.org/all/[email protected]
- Move writeback to madvise_collapse() (better abstraction, proper mmap_lock handling and does VMA revalidation after I/O) (Lorenzo)
- Rename to SCAN_PAGE_DIRTY to SCAN_PAGE_NOT_CLEAN and extend its use for all dirty/writeback folio cases that previously returned incorrect results (Dev)
V1: https://lore.kernel.org/all/[email protected]
Thanks,
Shivank Garg (2):
mm/khugepaged: map dirty/writeback pages failures to EAGAIN mm/khugepaged: retry with sync writeback for MADV_COLLAPSE
include/trace/events/huge_memory.h | 3 ++- mm/khugepaged.c | 23 ++++++++++++++++++++--- 2 files changed, 22 insertions(+), 4 deletions(-)
Signature · 1 line
2.43.0
PATCH v5 1/2 mm/khugepaged: map dirty/writeback pages failures to EAGAIN
When collapse_file encounters dirty or writeback pages in file-backed mappings, it currently returns SCAN_FAIL which maps to -EINVAL. This is misleading as EINVAL suggests invalid arguments, whereas dirty/writeback pages represent transient conditions that may resolve on retry.
Introduce SCAN_PAGE_DIRTY_OR_WRITEBACK to cover both dirty and writeback states, mapping it to -EAGAIN. For MADV_COLLAPSE, this provides userspace with a clear signal that retry may succeed after writeback completes. For khugepaged, this is harmless as it will naturally revisit the range during periodic scans after async writeback completes.
--- include/trace/events/huge_memory.h | 3 ++- mm/khugepaged.c | 8 +++++--- 2 files changed, 7 insertions(+), 4 deletions(-)
include/trace/events/huge_memory.h +2 -1
@@ -37,7 +37,8 @@ EM( SCAN_PAGE_HAS_PRIVATE, "page_has_private") \ EM( SCAN_STORE_FAILED, "store_failed") \ EM( SCAN_COPY_MC, "copy_poisoned_page") \ - EMe(SCAN_PAGE_FILLED, "page_filled") + EM( SCAN_PAGE_FILLED, "page_filled") \ + EMe(SCAN_PAGE_DIRTY_OR_WRITEBACK, "page_dirty_or_writeback")#undef EM#undef EMe
mm/khugepaged.c +5 -3
@@ -58,6 +58,7 @@ enum scan_result {SCAN_STORE_FAILED ,SCAN_COPY_MC ,SCAN_PAGE_FILLED , + SCAN_PAGE_DIRTY_OR_WRITEBACK, };#define CREATE_TRACE_POINTS
@@ -1967,11 +1968,11 @@ static int collapse_file(struct mm_struct *mm, unsigned long addr,*/ xas_unlock_irq (&xas);filemap_flush (mapping); - result =SCAN_FAIL ; + result =SCAN_PAGE_DIRTY_OR_WRITEBACK ; goto xa_unlocked; }else if (folio_test_writeback (folio)) {xas_unlock_irq (&xas); - result =SCAN_FAIL ; + result =SCAN_PAGE_DIRTY_OR_WRITEBACK ; goto xa_unlocked; }else if (folio_trylock (folio)) {folio_get (folio);
@@ -2018,7 +2019,7 @@ static int collapse_file(struct mm_struct *mm, unsigned long addr,* folio is dirty because it hasn't been flushed * since first write. */ - result =SCAN_FAIL ; + result =SCAN_PAGE_DIRTY_OR_WRITEBACK ; goto out_unlock; }
@@ -2747,6 +2748,7 @@ static int madvise_collapse_errno(enum scan_result r)case SCAN_PAGE_LRU :case SCAN_DEL_PAGE_LRU :case SCAN_PAGE_FILLED : +case SCAN_PAGE_DIRTY_OR_WRITEBACK :return -EAGAIN ;/* * Other: Trying again likely not to succeed / error intrinsic to
Signature · 1 line
2.43.0
PATCH v5 2/2 mm/khugepaged: retry with sync writeback for MADV_COLLAPSE
In reply to Shivank GargWhen MADV_COLLAPSE is called on file-backed mappings (e.g., executable text sections), the pages may still be dirty from recent writes. collapse_file() will trigger async writeback and fail with SCAN_PAGE_DIRTY_OR_WRITEBACK (-EAGAIN).
MADV_COLLAPSE is a synchronous operation where userspace expects immediate results. If the collapse fails due to dirty pages, perform synchronous writeback on the specific range and retry once.
This avoids spurious failures for freshly written executables while avoiding unnecessary synchronous I/O for mappings that are already clean.
--- mm/khugepaged.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
mm/khugepaged.c +15 -0
@@ -22,6 +22,7 @@#include <linux/dax.h> #include <linux/ksm.h> #include <linux/pgalloc.h> +#include <linux/backing-dev.h> #include <asm/tlb.h> #include "internal.h"
@@ -2788,7 +2789,9 @@ int madvise_collapse(struct vm_area_struct *vma, unsigned long start,for (addr = hstart; addr < hend; addr +=HPAGE_PMD_SIZE ) {int result =SCAN_FAIL ; +bool triggered_wb = false; +retry:if (!mmap_locked) {cond_resched ();mmap_read_lock (mm);
@@ -2809,8 +2812,20 @@ int madvise_collapse(struct vm_area_struct *vma, unsigned long start,mmap_read_unlock (mm); mmap_locked = false; + *lock_dropped = true; result =hpage_collapse_scan_file (mm, addr, file, pgoff, cc); + +if (result ==SCAN_PAGE_DIRTY_OR_WRITEBACK && !triggered_wb && +mapping_can_writeback (file->f_mapping)) { +loff_t lstart = (loff_t )pgoff <<PAGE_SHIFT ; +loff_t lend = lstart +HPAGE_PMD_SIZE -1 ; + +filemap_write_and_wait_range (file->f_mapping, lstart, lend); + triggered_wb = true; +fput (file); + goto retry; + }fput (file); }else { result = hpage_collapse_scan_pmd(mm, vma, addr,
Signature · 1 line
2.43.0
Re: [PATCH V5 2/2] mm/khugepaged: retry with sync writeback for MADV_COLLAPSE
Quoted 12 lines · Shivank Garg
When
MADV_COLLAPSEis called on file-backed mappings (e.g., executable text sections), the pages may still be dirty from recent writes.collapse_file()will trigger async writeback and fail withSCAN_PAGE_DIRTY_OR_WRITEBACK(-EAGAIN).
MADV_COLLAPSEis a synchronous operation where userspace expects immediate results. If the collapse fails due to dirty pages, perform synchronous writeback on the specific range and retry once.This avoids spurious failures for freshly written executables while avoiding unnecessary synchronous I/O for mappings that are already clean.
Quoted 7 lines
Reported-by Branden Moore <[email protected]>Fixes 34488399fa08 ("mm/madvise: add file and shmem support to MADV_COLLAPSE")Suggested-by David Hildenbrand <[email protected]>Tested-by Lance Yang <[email protected]>Signed-off-by Shivank Garg <[email protected]>---
Looks good to me now, thanks Shivank!
Signature · 3 lines
Cheers David
Re: [PATCH V5 2/2] mm/khugepaged: retry with sync writeback for MADV_COLLAPSE
In reply to Shivank GargQuoted 48 lines · Shivank Garg
When
MADV_COLLAPSEis called on file-backed mappings (e.g., executable text sections), the pages may still be dirty from recent writes.collapse_file()will trigger async writeback and fail withSCAN_PAGE_DIRTY_OR_WRITEBACK(-EAGAIN).
MADV_COLLAPSEis a synchronous operation where userspace expects immediate results. If the collapse fails due to dirty pages, perform synchronous writeback on the specific range and retry once.This avoids spurious failures for freshly written executables while avoiding unnecessary synchronous I/O for mappings that are already clean.
Reported-by Branden Moore <[email protected]>Fixes 34488399fa08 ("mm/madvise: add file and shmem support to MADV_COLLAPSE")Suggested-by David Hildenbrand <[email protected]>Tested-by Lance Yang <[email protected]>Signed-off-by Shivank Garg <[email protected]>--- mm/khugepaged.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)mm/khugepaged.c +3
-0@@ -22,6 +22,7 @@#include <linux/dax.h> #include <linux/ksm.h> #include <linux/pgalloc.h> +#include <linux/backing-dev.h> #include <asm/tlb.h> #include "internal.h" @@ -2788,7 +2789,9 @@ int madvise_collapse(struct vm_area_struct *vma, unsigned long start,for (addr = hstart; addr < hend; addr +=HPAGE_PMD_SIZE ) {int result =SCAN_FAIL ; +bool triggered_wb = false; +retry:if (!mmap_locked) {cond_resched ();mmap_read_lock (mm);@@ -2809,8 +2812,20 @@ int madvise_collapse(struct vm_area_struct *vma, unsigned long start,mmap_read_unlock (mm); mmap_locked = false;
mm/khugepaged.c int madvise_collapse(struct vm_area_struct *vma, unsigned long start, · line 2824
Quoted 10 lines
mm/khugepaged.c +8
-0+ *lock_dropped = true; result =hpage_collapse_scan_file (mm, addr, file, pgoff, cc); + +if (result ==SCAN_PAGE_DIRTY_OR_WRITEBACK && !triggered_wb && +mapping_can_writeback (file->f_mapping)) { +loff_t lstart = (loff_t )pgoff <<PAGE_SHIFT ; +loff_t lend = lstart +HPAGE_PMD_SIZE -1 ; + +filemap_write_and_wait_range (file->f_mapping, lstart, lend);
So we don't care about the return value here because this is best-effort. I really wish we had in our coding-style.rst to typecast such things to (void), so we know explicitly that we are ignoring the return value, and not that the function itself returns void.
Nothing jumps out at me,
Quoted 7 lines
mm/khugepaged.c +4
-0+ triggered_wb = true; +fput (file); + goto retry; + }fput (file); }else { result = hpage_collapse_scan_pmd(mm, vma, addr,
David Hildenbrand (Red Hat)
maintainerRe: [PATCH V5 2/2] mm/khugepaged: retry with sync writeback for MADV_COLLAPSE
Quoted 57 lines · Dev Jain
Quoted 55 lines · Shivank Garg
When
MADV_COLLAPSEis called on file-backed mappings (e.g., executable text sections), the pages may still be dirty from recent writes.collapse_file()will trigger async writeback and fail withSCAN_PAGE_DIRTY_OR_WRITEBACK(-EAGAIN).
MADV_COLLAPSEis a synchronous operation where userspace expects immediate results. If the collapse fails due to dirty pages, perform synchronous writeback on the specific range and retry once.This avoids spurious failures for freshly written executables while avoiding unnecessary synchronous I/O for mappings that are already clean.
Reported-by Branden Moore <[email protected]>Fixes 34488399fa08 ("mm/madvise: add file and shmem support to MADV_COLLAPSE")Suggested-by David Hildenbrand <[email protected]>Tested-by Lance Yang <[email protected]>Signed-off-by Shivank Garg <[email protected]>--- mm/khugepaged.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)mm/khugepaged.c +8
-0@@ -22,6 +22,7 @@#include <linux/dax.h> #include <linux/ksm.h> #include <linux/pgalloc.h> +#include <linux/backing-dev.h> #include <asm/tlb.h> #include "internal.h" @@ -2788,7 +2789,9 @@ int madvise_collapse(struct vm_area_struct *vma, unsigned long start,for (addr = hstart; addr < hend; addr +=HPAGE_PMD_SIZE ) {int result =SCAN_FAIL ; +bool triggered_wb = false; +retry:if (!mmap_locked) {cond_resched ();mmap_read_lock (mm);@@ -2809,8 +2812,20 @@ int madvise_collapse(struct vm_area_struct *vma, unsigned long start,mmap_read_unlock (mm); mmap_locked = false; + *lock_dropped = true; result =hpage_collapse_scan_file (mm, addr, file, pgoff, cc); + +if (result ==SCAN_PAGE_DIRTY_OR_WRITEBACK && !triggered_wb && +mapping_can_writeback (file->f_mapping)) { +loff_t lstart = (loff_t )pgoff <<PAGE_SHIFT ;
Quoted 8 lines
mm/khugepaged.c int madvise_collapse(struct vm_area_struct *vma, unsigned long start, · line 2824
Quoted 3 lines
mm/khugepaged.c +3
-0+loff_t lend = lstart +HPAGE_PMD_SIZE -1 ; + +filemap_write_and_wait_range (file->f_mapping, lstart, lend);So we don't care about the return value here because this is best-effort. I really wish we had in our
coding-style.rstto typecast such things to (void), so we know explicitly that we are ignoring the return value, and not that the function itself returns void.
That makes functions like bitmap_and() hard (and ugly) to use that just return some value for the caller's convenience.
For functions where we really want callers to think about this, we can enforce such checks through __must_check.
Here, it's rather obvious that we don't care about the result as we only retry once to then give up.
Signature · 3 lines
Cheers David
Andrew Morton
maintainerQuoted 9 lines · On Sun, 18 Jan 2026 19:09:38 +0000 Shivank Garg <[email protected]> wrote:
MADV_COLLAPSEon file-backed mappings fails with-EINVALwhen TEXT pages are dirty. This affects scenarios like package/container updates or executing binaries immediately after writing them, etc.The issue is that
collapse_file()triggers async writeback and returnsSCAN_FAIL(maps to-EINVAL), expecting khugepaged to revisit later. ButMADV_COLLAPSEis synchronous and userspace expects immediate success or a clear retry signal.
Quoted 8 lines
Reproduction:
- Compile or copy 2MB-aligned executable to XFS/ext4 FS
- CallMADV_COLLAPSEon .text section
- First call fails with-EINVAL(text pages dirty from copy)
- Second call succeeds (async writeback completed)Issue Report:
https://lore.kernel.org/all/[email protected]
Updated, thanks.
Please tolerate a little whining about the timeliess here. We're at -rc6, v4 was added to mm.git over a month ago, had quite a lot of review, this is very close to being moved into the mm-stable branch and now we get v5. Argh.
Quoted 2 lines
V5:
- In patch 2/2, Simplify dirty writeback retry logic (David)
Are you sure this is the only change? It looks like a lot for a simplification and I'm wondering if we should retain the v4 series and defer a simplification for separate consideration during the next cycle.
Below is how this updated altered mm.git. Could reviewers please check this fairly soon?
mm/khugepaged.c renamed from mm/khugepaged.c~b +12 -37
@@ -2788,11 +2788,11 @@ int madvise_collapse(struct vm_area_stru hend = end &HPAGE_PMD_MASK ;for (addr = hstart; addr < hend; addr +=HPAGE_PMD_SIZE ) { -bool retried = false;int result =SCAN_FAIL ; +bool triggered_wb = false; -if (!mmap_locked) { retry: +if (!mmap_locked) {cond_resched ();mmap_read_lock (mm); mmap_locked = true;
@@ -2812,52 +2812,27 @@ retry:mmap_read_unlock (mm); mmap_locked = false; + *lock_dropped = true; result =hpage_collapse_scan_file (mm, addr, file, pgoff, cc); -fput (file); - }else { - result =hpage_collapse_scan_pmd (mm, vma, addr, - &mmap_locked, cc); - } -if (!mmap_locked) - *lock_dropped = true; - -/* -* If the file-backed VMA has dirty pages, the scan triggers -* async writeback and returns SCAN_PAGE_DIRTY_OR_WRITEBACK. -* Since MADV_COLLAPSE is sync, we force sync writeback and -* retry once. -*/ -if (result ==SCAN_PAGE_DIRTY_OR_WRITEBACK && !retried) { -/* -* File scan drops the lock. We must re-acquire it to -* safely inspect the VMA and hold the file reference. -*/ -if (!mmap_locked) { -cond_resched (); -mmap_read_lock (mm); - mmap_locked = true; - result =hugepage_vma_revalidate (mm, addr, false, &vma, cc); -if (result !=SCAN_SUCCEED ) - goto handle_result; - } -if (!vma_is_anonymous (vma) && vma->vm_file && -mapping_can_writeback (vma->vm_file->f_mapping)) { -struct file *file =get_file (vma->vm_file); -pgoff_t pgoff =linear_page_index (vma, addr); +if (result ==SCAN_PAGE_DIRTY_OR_WRITEBACK && !triggered_wb && +mapping_can_writeback (file->f_mapping)) {loff_t lstart = (loff_t )pgoff <<PAGE_SHIFT ;loff_t lend = lstart +HPAGE_PMD_SIZE -1 ; -mmap_read_unlock (mm); - mmap_locked = false; - *lock_dropped = true;filemap_write_and_wait_range (file->f_mapping, lstart, lend); + triggered_wb = true;fput (file); - retried = true; goto retry; } +fput (file); + }else { + result =hpage_collapse_scan_pmd (mm, vma, addr, + &mmap_locked, cc); } +if (!mmap_locked) + *lock_dropped = true; handle_result:switch (result) {
_
Quoted 5 lines · Andrew Morton
Please tolerate a little whining about the timeliess here. We're at -rc6, v4 was added to mm.git over a month ago, had quite a lot of review, this is very close to being moved into the mm-stable branch and now we get v5. Argh.
I sincerely apologize for this.
I had this doubt on sending an incremental patch or V5:
https://lore.kernel.org/linux-mm/[email protected]
Quoted 6 lines
Quoted 2 lines
V5:
- In patch 2/2, Simplify dirty writeback retry logic (David)Are you sure this is the only change? It looks like a lot for a simplification and I'm wondering if we should retain the v4 series and defer a simplification for separate consideration during the next cycle.
Yes, patch 1/2 is unchanged and patch 2/2 is the only change.
The diff looks larger due to code movement but logic is actually simpler now.
I completely understand if you prefer to keep V4 and defer this refactoring. I'm sorry for creating this late-cycle churn. Please let me know what you'd prefer and I'll follow your guidance.
Thank you for your patience.
Regards,
Shivank
David Hildenbrand (Red Hat)
maintainerQuoted 21 lines · Shivank
Quoted 5 lines · Andrew Morton
Please tolerate a little whining about the timeliess here. We're at -rc6, v4 was added to mm.git over a month ago, had quite a lot of review, this is very close to being moved into the mm-stable branch and now we get v5. Argh.
I sincerely apologize for this.
I had this doubt on sending an incremental patch or V5:
https://lore.kernel.org/linux-mm/[email protected]Quoted 6 lines
Quoted 2 lines
V5:
- In patch 2/2, Simplify dirty writeback retry logic (David)Are you sure this is the only change? It looks like a lot for a simplification and I'm wondering if we should retain the v4 series and defer a simplification for separate consideration during the next cycle.
Quoted 6 lines
Yes, patch 1/2 is unchanged and patch 2/2 is the only change.
The diff looks larger due to code movement but logic is actually simpler now.I completely understand if you prefer to keep V4 and defer this refactoring. I'm sorry for creating this late-cycle churn. Please let me know what you'd prefer and I'll follow your guidance.
There is no reason to rush any of this. :)
Review was not over and due to multiple factors my review on v4 came in later than I wanted.
Andrew, if you prefer, I can start sending as a reply to every patch set that I want to review so you are aware that it is on my review backlog.
Unfortunately we can't have nice things (sub-maintainer acks).
Signature · 3 lines
Cheers David
Quoted 8 lines · David Hildenbrand (Red Hat)
Quoted 7 lines · Shivank
Quoted 4 lines · Andrew Morton
Please tolerate a little whining about the timeliess here. We're at -rc6, v4 was added to mm.git over a month ago, had quite a lot of review, this is very close to being moved into the mm-stable branch and now we get v5. Argh.
As co-maintainer of THP:
Can I explicitly request that you not merge anything in THP without EXPLICIT sub-M sign-off, i.e. either me or David.
Obviously I have publicly and privately request that we do this for all of mm, but in THP especially, we CANNOT accept series landing without this.
THP workload is one of the worst in mm and is completely overwhelming.
Again - David is working whilst being on holiday to handle the load because by default we auto-merge.
And here you are complaining that you can't auto-merge (...!), it's completely unworkable.
People can just _wait_ for things to land sometimes. It's OK. It's part of why the whole rc- approach was added - I think Greg KH explicitly wrote about this elsewhere - people can just wait for the next cycle and not be too disappointed, it realy isn't that long.
Stability trumps speed of merge.
I don't want to have to write a script to auto-NAK anything that doesn't match this requirement, but I'm starting to feel like I have to... Let's try to avoid that.
Quoted 2 lines
Quoted 2 lines
Quoted 1 line
I sincerely apologize for this.
You don't need to apologise Shivank, you just might have to wait a cycle.
Quoted 12 lines
Quoted 12 lines
I had this doubt on sending an incremental patch or V5:
https://lore.kernel.org/linux-mm/[email protected]Quoted 6 lines
Quoted 2 lines
V5:
- In patch 2/2, Simplify dirty writeback retry logic (David)Are you sure this is the only change? It looks like a lot for a simplification and I'm wondering if we should retain the v4 series and defer a simplification for separate consideration during the next cycle.
Quoted 8 lines
Quoted 6 lines
Yes, patch 1/2 is unchanged and patch 2/2 is the only change.
The diff looks larger due to code movement but logic is actually simpler now.I completely understand if you prefer to keep V4 and defer this refactoring. I'm sorry for creating this late-cycle churn. Please let me know what you'd prefer and I'll follow your guidance.
There is no reason to rush any of this. :)
Yes absolutely.
It's patently INSANE and in fact a ongoing security risk to rush things in mm in general, and we really need to stop this.
Quoted 3 lines
Review was not over and due to multiple factors my review on v4 came in later than I wanted.
Also you're on leave from work :)
I have taken a step back from review somewhat due to this insanity, but now feel like I have to step it back up... due to this insanity.
Or maybe write a script...
Quoted 3 lines
Andrew, if you prefer, I can start sending as a reply to every patch set that I want to review so you are aware that it is on my review backlog.
This is ridiculous and shouldn't be necessary.
Quoted 2 lines
Unfortunately we can't have nice things (sub-maintainer acks).
Well we can start having less nice things like a NAK script if this unworkable situation continues.
Quoted 5 lines
--
CheersDavid
Again Andrew - as THP co-maintainer - I politely ask that, while you might not want to implement a sub-M A-b/R-b requirement across mm (though you should), that you implement one for THP explicitly.
If you don't then I don't really see any other option than to start NAK'ing everything in THP that hits mm-stable which either David or I have not explicitly tagged.
Thanks, Lorenzo