FAILED: patch "[PATCH] mm: avoid deadlock when holding rmap on mmap_prepare error" failed to apply to 7.0-stable tree
Subsystems (4)
[email protected]
maintainerThe patch below does not apply to the 7.0-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-7.0.y
git checkout FETCH_HEAD
git cherry-pick -x f96e1d5f15b7c854a6a9ec1225d68a12fe7dcda6
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2026042747-cardinal-pellet-094f@gregkh' --subject-prefix 'PATCH 7.0.y' HEAD^..
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From f96e1d5f15b7c854a6a9ec1225d68a12fe7dcda6 Mon Sep 17 00:00:00 2001
From: "Lorenzo Stoakes (Oracle)" <[email protected]>
Date: Fri, 20 Mar 2026 22:39:30 +0000
Subject: [PATCH] mm: avoid deadlock when holding rmap on mmap_prepare error
Commit ac0a3fc9c07d ("mm: add ability to take further action in vm_area_desc") added the ability for drivers to instruct mm to take actions after the .mmap_prepare callback is complete.
To make life simpler and safer, this is done before the VMA/mmap write lock is dropped but when the VMA is completely established.
So on error, we simply munmap() the VMA.
As part of this implementation, unfortunately a horrible hack had to be implemented to support some questionable behaviour hugetlb relies upon - that is that the file rmap lock is held until the operation is complete.
The implementation, for convenience, did this in mmap_action_finish() so both the VMA and mmap_prepare compatibility layer paths would have this correctly handled.
However, it turns out there is a mistake here - the rmap lock cannot be held on munmap, as free_pgtables() -> unlink_file_vma_batch_add() -> unlink_file_vma_batch_process() takes the file rmap lock.
We therefore currently have a deadlock issue that might arise.
Resolve this by leaving it to callers to handle the unmap.
The compatibility layer does not support this rmap behaviour, so we simply have it unmap on error after calling mmap_action_complete().
In the VMA implementation, we only perform the unmap after the rmap lock is dropped.
This resolves the issue by ensuring the rmap lock is always dropped when the unmap occurs.
mm/util.c +7 -5
@@ -1215,7 +1215,13 @@ int compat_vma_mmap(struct file *file, struct vm_area_struct *vma)return err;set_vma_from_desc (vma, &desc); -return mmap_action_complete (vma, &desc.action); + err =mmap_action_complete (vma, &desc.action); +if (err) { +const size_t len =vma_pages (vma) <<PAGE_SHIFT ; + +do_munmap (current->mm, vma->vm_start, len,NULL ); + } +return err; }EXPORT_SYMBOL (compat_vma_mmap);
@@ -1316,10 +1322,6 @@ static int mmap_action_finish(struct vm_area_struct *vma,* invoked if we do NOT merge, so we only clean up the VMA we created. */ if (err) { -const size_t len =vma_pages (vma) <<PAGE_SHIFT ; - -do_munmap (current->mm, vma->vm_start, len,NULL ); -if (action->error_hook) {/* We may want to filter the error. */ err = action->error_hook (err);
mm/vma.c +10 -3
@@ -2735,9 +2735,9 @@ static int call_action_complete(struct mmap_state *map,struct mmap_action *action, struct vm_area_struct *vma) { - int ret; + int err; - ret =mmap_action_complete (vma, action); + err =mmap_action_complete (vma, action);/* If we held the file rmap we need to release it. */ if (map->hold_file_rmap_lock) {
@@ -2745,7 +2745,14 @@ static int call_action_complete(struct mmap_state *map,i_mmap_unlock_write (file->f_mapping); } -return ret; + +if (err) { +const size_t len =vma_pages (vma) <<PAGE_SHIFT ; + +do_munmap (current->mm, vma->vm_start, len,NULL ); + } + +return err; } static unsigned long __mmap_region(struct file *file, unsigned long addr,
Sasha Levin
maintainerPATCH 1/2 mm: various small mmap_prepare cleanups
From: "Lorenzo Stoakes (Oracle)" <[email protected]>
[ Upstream commit 3e4bb2706817710d9461394da8b75be79981586b ]
Patch series "mm: expand mmap_prepare functionality and usage", v4.
This series expands the mmap_prepare functionality, which is intended to replace the deprecated f_op->mmap hook which has been the source of bugs and security issues for some time.
This series starts with some cleanup of existing mmap_prepare logic, then adds documentation for the mmap_prepare call to make it easier for filesystem and driver writers to understand how it works.
It then importantly adds a vm_ops->mapped hook, a key feature that was missing from mmap_prepare previously - this is invoked when a driver which specifies mmap_prepare has successfully been mapped but not merged with another VMA.
mmap_prepare is invoked prior to a merge being attempted, so you cannot manipulate state such as reference counts as if it were a new mapping.
The vm_ops->mapped hook allows a driver to perform tasks required at this stage, and provides symmetry against subsequent vm_ops->open,close calls.
The series uses this to correct the afs implementation which wrongly manipulated reference count at mmap_prepare time.
It then adds an mmap_prepare equivalent of vm_iomap_memory() - mmap_action_simple_ioremap(), then uses this to update a number of drivers.
It then splits out the mmap_prepare compatibility layer (which allows for invocation of mmap_prepare hooks in an mmap() hook) in such a way as to allow for more incremental implementation of mmap_prepare hooks.
It then uses this to extend mmap_prepare usage in drivers.
Finally it adds an mmap_prepare equivalent of vm_map_pages(), which lays the foundation for future work which will extend mmap_prepare to DMA coherent mappings.
This patch (of 21):
Rather than passing arbitrary fields, pass a vm_area_desc pointer to mmap prepare functions to mmap prepare, and an action and vma pointer to mmap complete in order to put all the action-specific logic in the function actually doing the work.
Additionally, allow mmap prepare functions to return an error so we can error out as soon as possible if there is something logically incorrect in the input.
Update remap_pfn_range_prepare() to properly check the input range for the CoW case.
Also remove io_remap_pfn_range_complete(), as we can simply set up the fields correctly in io_remap_pfn_range_prepare() and use remap_pfn_range_complete() for this.
While we're here, make remap_pfn_range_prepare_vma() a little neater, and pass mmap_action directly to call_action_complete().
Then, update compat_vma_mmap() to perform its logic directly, as __compat_vma_map() is not used by anything so we don't need to export it.
Also update compat_vma_mmap() to use vfs_mmap_prepare() rather than calling the mmap_prepare op directly.
Finally, update the VMA userland tests to reflect the changes.
Stable-dep-of: f96e1d5f15b7 ("mm: avoid deadlock when holding rmap on mmap_prepare error")
--- include/linux/fs.h | 2 - include/linux/mm.h | 7 +- mm/internal.h | 32 ++++---- mm/memory.c | 45 +++++++---- mm/util.c | 121 +++++++++++++----------------- mm/vma.c | 24 +++--- tools/testing/vma/include/dup.h | 7 +- tools/testing/vma/include/stubs.h | 8 +- 8 files changed, 126 insertions(+), 120 deletions(-)
include/linux/fs.h +0 -2
@@ -2058,8 +2058,6 @@ static inline bool can_mmap_file(struct file *file)return true; } -int __compat_vma_mmap (const struct file_operations *f_op, -struct file *file,struct vm_area_struct *vma);int compat_vma_mmap (struct file *file,struct vm_area_struct *vma);static inline int vfs_mmap (struct file *file,struct vm_area_struct *vma)
include/linux/mm.h +3 -4
@@ -4078,10 +4078,9 @@ static inline void mmap_action_ioremap_full(struct vm_area_desc *desc,mmap_action_ioremap (desc, desc->start, start_pfn,vma_desc_size (desc)); } -void mmap_action_prepare (struct mmap_action *action, -struct vm_area_desc *desc); -int mmap_action_complete (struct mmap_action *action, -struct vm_area_struct *vma); +int mmap_action_prepare (struct vm_area_desc *desc); +int mmap_action_complete (struct vm_area_struct *vma, +struct mmap_action *action);/* Look up the first VMA which exactly match the interval vm_start ... vm_end */ static inline struct vm_area_struct *find_exact_vma(struct mm_struct *mm,
mm/internal.h +17 -15
@@ -1747,26 +1747,28 @@ int walk_page_range_debug(struct mm_struct *mm, unsigned long start,void dup_mm_exe_file (struct mm_struct *mm,struct mm_struct *oldmm);int dup_mmap (struct mm_struct *mm,struct mm_struct *oldmm); -void remap_pfn_range_prepare (struct vm_area_desc *desc,unsigned long pfn); -int remap_pfn_range_complete (struct vm_area_struct *vma,unsigned long addr, -unsigned long pfn,unsigned long size,pgprot_t pgprot); +int remap_pfn_range_prepare (struct vm_area_desc *desc); +int remap_pfn_range_complete (struct vm_area_struct *vma, +struct mmap_action *action); -static inline void io_remap_pfn_range_prepare (struct vm_area_desc *desc, -unsigned long orig_pfn,unsigned long size) +static inline int io_remap_pfn_range_prepare (struct vm_area_desc *desc) { +struct mmap_action *action = &desc->action; +const unsigned long orig_pfn = action->remap.start_pfn; +const pgprot_t orig_pgprot = action->remap.pgprot; +const unsigned long size = action->remap.size;const unsigned long pfn =io_remap_pfn_range_pfn (orig_pfn, size); +int err; -return remap_pfn_range_prepare (desc, pfn); -} + action->remap.start_pfn = pfn; + action->remap.pgprot =pgprot_decrypted (orig_pgprot); + err =remap_pfn_range_prepare (desc); +if (err) +return err; -static inline int io_remap_pfn_range_complete (struct vm_area_struct *vma, -unsigned long addr,unsigned long orig_pfn,unsigned long size, -pgprot_t orig_prot) -{ -const unsigned long pfn =io_remap_pfn_range_pfn (orig_pfn, size); -const pgprot_t prot =pgprot_decrypted (orig_prot); - -return remap_pfn_range_complete (vma, addr, pfn, size, prot); +/* Remap does the actual work. */ + action->type =MMAP_REMAP_PFN ; +return 0 ; }#endif /* __MM_INTERNAL_H */
mm/memory.c +29 -16
65 lines not on this page · raw message
mm/util.c +54 -67
192 lines not on this page · raw message
mm/vma.c +14 -10
@@ -2613,15 +2613,18 @@ static void __mmap_complete(struct mmap_state *map, struct vm_area_struct *vma)vma_set_page_prot (vma); } -static void call_action_prepare (struct mmap_state *map, -struct vm_area_desc *desc) +static int call_action_prepare (struct mmap_state *map, +struct vm_area_desc *desc) { -struct mmap_action *action = &desc->action; +int err; -mmap_action_prepare (action, desc); + err =mmap_action_prepare (desc); +if (err) +return err; -if (action->hide_from_rmap_until_complete) +if (desc->action.hide_from_rmap_until_complete) map->hold_file_rmap_lock = true; +return 0 ; }/*
@@ -2645,7 +2648,9 @@ static int call_mmap_prepare(struct mmap_state *map,if (err)return err; -call_action_prepare (map, desc); + err =call_action_prepare (map, desc); +if (err) +return err;/* Update fields permitted to be changed. */ map->pgoff = desc->pgoff;
@@ -2700,13 +2705,12 @@ static bool can_set_ksm_flags_early(struct mmap_state *map) }static int call_action_complete (struct mmap_state *map, -struct vm_area_desc *desc, +struct mmap_action *action,struct vm_area_struct *vma) { -struct mmap_action *action = &desc->action;int ret; - ret =mmap_action_complete (action, vma); + ret =mmap_action_complete (vma, action);/* If we held the file rmap we need to release it. */ if (map->hold_file_rmap_lock) {
@@ -2768,7 +2772,7 @@ static unsigned long __mmap_region(struct file *file, unsigned long addr,__mmap_complete (&map, vma);if (have_mmap_prepare && allocated_new) { - error =call_action_complete (&map, &desc, vma); + error =call_action_complete (&map, &desc.action, vma);if (error)return error;
tools/testing/vma/include/dup.h +5 -2
@@ -1093,9 +1093,12 @@ static inline int __compat_vma_mmap(const struct file_operations *f_op,if (err)return err; -mmap_action_prepare (&desc.action, &desc); + err =mmap_action_prepare (&desc); +if (err) +return err; +set_vma_from_desc (vma, &desc); -return mmap_action_complete (&desc.action, vma); +return mmap_action_complete (vma, &desc.action); } static inline int compat_vma_mmap(struct file *file,
tools/testing/vma/include/stubs.h +4 -4
@@ -81,13 +81,13 @@ static inline void free_anon_vma_name(struct vm_area_struct *vma) { } -static inline void mmap_action_prepare (struct mmap_action *action, -struct vm_area_desc *desc) +static inline int mmap_action_prepare (struct vm_area_desc *desc) { +return 0 ; } -static inline int mmap_action_complete (struct mmap_action *action, -struct vm_area_struct *vma) +static inline int mmap_action_complete (struct vm_area_struct *vma, +struct mmap_action *action) {return 0 ; }
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 2/2 mm: avoid deadlock when holding rmap on mmap_prepare error
From: "Lorenzo Stoakes (Oracle)" <[email protected]>
[ Upstream commit f96e1d5f15b7c854a6a9ec1225d68a12fe7dcda6 ]
Commit ac0a3fc9c07d ("mm: add ability to take further action in vm_area_desc") added the ability for drivers to instruct mm to take actions after the .mmap_prepare callback is complete.
To make life simpler and safer, this is done before the VMA/mmap write lock is dropped but when the VMA is completely established.
So on error, we simply munmap() the VMA.
As part of this implementation, unfortunately a horrible hack had to be implemented to support some questionable behaviour hugetlb relies upon - that is that the file rmap lock is held until the operation is complete.
The implementation, for convenience, did this in mmap_action_finish() so both the VMA and mmap_prepare compatibility layer paths would have this correctly handled.
However, it turns out there is a mistake here - the rmap lock cannot be held on munmap, as free_pgtables() -> unlink_file_vma_batch_add() -> unlink_file_vma_batch_process() takes the file rmap lock.
We therefore currently have a deadlock issue that might arise.
Resolve this by leaving it to callers to handle the unmap.
The compatibility layer does not support this rmap behaviour, so we simply have it unmap on error after calling mmap_action_complete().
In the VMA implementation, we only perform the unmap after the rmap lock is dropped.
This resolves the issue by ensuring the rmap lock is always dropped when the unmap occurs.
--- mm/util.c | 12 +++++++----- mm/vma.c | 13 ++++++++++--- 2 files changed, 17 insertions(+), 8 deletions(-)
mm/util.c +7 -5
@@ -1186,7 +1186,13 @@ int compat_vma_mmap(struct file *file, struct vm_area_struct *vma)return err;set_vma_from_desc (vma, &desc); -return mmap_action_complete (vma, &desc.action); + err =mmap_action_complete (vma, &desc.action); +if (err) { +const size_t len =vma_pages (vma) <<PAGE_SHIFT ; + +do_munmap (current->mm, vma->vm_start, len,NULL ); + } +return err; }EXPORT_SYMBOL (compat_vma_mmap);
@@ -1279,10 +1285,6 @@ static int mmap_action_finish(struct vm_area_struct *vma,* invoked if we do NOT merge, so we only clean up the VMA we created. */ if (err) { -const size_t len =vma_pages (vma) <<PAGE_SHIFT ; - -do_munmap (current->mm, vma->vm_start, len,NULL ); -if (action->error_hook) {/* We may want to filter the error. */ err = action->error_hook (err);
mm/vma.c +10 -3
@@ -2708,9 +2708,9 @@ static int call_action_complete(struct mmap_state *map,struct mmap_action *action, struct vm_area_struct *vma) { - int ret; + int err; - ret =mmap_action_complete (vma, action); + err =mmap_action_complete (vma, action);/* If we held the file rmap we need to release it. */ if (map->hold_file_rmap_lock) {
@@ -2718,7 +2718,14 @@ static int call_action_complete(struct mmap_state *map,i_mmap_unlock_write (file->f_mapping); } -return ret; + +if (err) { +const size_t len =vma_pages (vma) <<PAGE_SHIFT ; + +do_munmap (current->mm, vma->vm_start, len,NULL ); + } + +return err; } static unsigned long __mmap_region(struct file *file, unsigned long addr,
Signature · 1 line
2.53.0