memfd: Fix COW issue on MAP_PRIVATE and F_SEAL_FUTURE_WRITE mappings
Subsystems (3)
PATCH 1/2 memfd: Fix COW issue on MAP_PRIVATE and F_SEAL_FUTURE_WRITE mappings
From: Nicolas Geoffray <[email protected]>
F_SEAL_FUTURE_WRITE has unexpected behavior when used with MAP_PRIVATE:
A private mapping created after the memfd file that gets sealed with F_SEAL_FUTURE_WRITE loses the copy-on-write at fork behavior, meaning children and parent share the same memory, even though the mapping is private.
The reason for this is due to the code below:
static int shmem_mmap(struct file *file, struct vm_area_struct *vma)
{
struct shmem_inode_info *info = SHMEM_I(file_inode(file));
if (info->seals & F_SEAL_FUTURE_WRITE) {
/*
* New PROT_WRITE and MAP_SHARED mmaps are not allowed when
* "future write" seal active.
*/
if ((vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_WRITE))
return -EPERM;
/*
* Since the F_SEAL_FUTURE_WRITE seals allow for a MAP_SHARED
* read-only mapping, take care to not allow mprotect to revert
* protections.
*/
vma->vm_flags &= ~(VM_MAYWRITE);
}
...
}And for the mm to know if a mapping is copy-on-write:
static inline bool is_cow_mapping(vm_flags_t flags)
{
return (flags & (VM_SHARED | VM_MAYWRITE)) == VM_MAYWRITE;
}The patch fixes the issue by making the mprotect revert protection happen only for shared mappings. For private mappings, using mprotect will have no effect on the seal behavior.
---
Google bug: 143833776
mm/shmem.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)
mm/shmem.c +7 -4
@@ -2214,11 +2214,14 @@ static int shmem_mmap(struct file *file, struct vm_area_struct *vma)return -EPERM ;/* -* Since the F_SEAL_FUTURE_WRITE seals allow for a MAP_SHARED -* read-only mapping, take care to not allow mprotect to revert -* protections. +* Since an F_SEAL_FUTURE_WRITE sealed memfd can be mapped as +* MAP_SHARED and read-only, take care to not allow mprotect to +* revert protections on such mappings. Do this only for shared +* mappings. For private mappings, don't need to mask VM_MAYWRITE +* as we still want them to be COW-writable. */ - vma->vm_flags &= ~(VM_MAYWRITE ); +if (vma->vm_flags &VM_SHARED ) + vma->vm_flags &= ~(VM_MAYWRITE ); }file_accessed (file);
Signature · 1 line
2.24.0.rc1.363.gb1bccd3e3d-goog
PATCH 2/2 memfd: Add test for COW on MAP_PRIVATE and F_SEAL_FUTURE_WRITE mappings
In this test, the parent and child both have writable private mappings. The test shows that without the patch in this series, the parent and child shared the same memory which is incorrect. In other words, COW needs to be triggered so any writes to child's copy stays local to the child.
--- tools/testing/selftests/memfd/memfd_test.c | 36 ++++++++++++++++++++++ 1 file changed, 36 insertions(+)
tools/testing/selftests/memfd/memfd_test.c +36 -0
@@ -290,6 +290,40 @@ static void mfd_assert_read_shared(int fd)munmap (p, mfd_def_size); } +static void mfd_assert_fork_private_write (int fd) +{ +int *p; +pid_t pid; + + p =mmap (NULL , + mfd_def_size, +PROT_READ |PROT_WRITE , +MAP_PRIVATE , + fd, +0 ); +if (p ==MAP_FAILED ) { +printf ("mmap() failed: %m\n" ); +abort (); + } + + p[0 ] =22 ; + + pid =fork (); +if (pid ==0 ) { + p[0 ] =33 ; +exit (0 ); + }else { +waitpid (pid,NULL ,0 ); + +if (p[0 ] !=22 ) { +printf ("MAP_PRIVATE copy-on-write failed: %m\n" ); +abort (); + } + } + +munmap (p, mfd_def_size); +} +static void mfd_assert_write (int fd) {ssize_t l;
@@ -760,6 +794,8 @@ static void test_seal_future_write(void)mfd_assert_read_shared (fd2);mfd_fail_write (fd2); +mfd_assert_fork_private_write (fd); +munmap (p, mfd_def_size);close (fd2);close (fd);
Signature · 1 line
2.24.0.rc1.363.gb1bccd3e3d-goog
Andrew Morton
maintainerQuoted 5 lines · On Thu, 7 Nov 2019 14:53:54 -0500 "Joel Fernandes (Google)"…
F_SEAL_FUTURE_WRITEhas unexpected behavior when used withMAP_PRIVATE:
A private mapping created after the memfd file that gets sealed withF_SEAL_FUTURE_WRITEloses the copy-on-write at fork behavior, meaning children and parent share the same memory, even though the mapping is private.
That sounds fairly serious. Should this be backported into -stable kernels?
Quoted 9 lines · Andrew Morton
Quoted 5 lines · On Thu, 7 Nov 2019 14:53:54 -0500 "Joel Fernandes (Google)"…
F_SEAL_FUTURE_WRITEhas unexpected behavior when used withMAP_PRIVATE:
A private mapping created after the memfd file that gets sealed withF_SEAL_FUTURE_WRITEloses the copy-on-write at fork behavior, meaning children and parent share the same memory, even though the mapping is private.That sounds fairly serious. Should this be backported into -stable kernels?
Yes, it should be. The F_SEAL_FUTURE_WRITE feature was introduced in v5.1 so v5.3.x stable kernels would need a backport. I can submit a backport tomorrow unless we are Ok with stable automatically picking it up (I believe the stable folks "auto select" fixes which should detect this is a fix since I have said it is a fix in the subject line).
thanks,
- Joel
Andrew Morton
maintainerQuoted 9 lines · On Thu, 7 Nov 2019 21:06:14 -0500 Joel Fernandes <[email protected]> wrote:
Quoted 8 lines · Andrew Morton
Quoted 5 lines · On Thu, 7 Nov 2019 14:53:54 -0500 "Joel Fernandes (Google)"…
F_SEAL_FUTURE_WRITEhas unexpected behavior when used withMAP_PRIVATE:
A private mapping created after the memfd file that gets sealed withF_SEAL_FUTURE_WRITEloses the copy-on-write at fork behavior, meaning children and parent share the same memory, even though the mapping is private.
Quoted 3 lines
Quoted 1 line
That sounds fairly serious. Should this be backported into -stable kernels?
Yes, it should be.
I added
Quoted 5 lines
The
F_SEAL_FUTURE_WRITEfeature was introduced in v5.1 so
v5.3.x stable kernels would need a backport. I can submit a backport tomorrow unless we are Ok with stable automatically picking it up (I believe the stable folks "auto select" fixes which should detect this is a fix since I have said it is a fix in the subject line).
The Cc:stable tag should trigger the appropriate actions, assisted by the Fixes:. I doubt if "fix" in the Subject has much effect.
Quoted 9 lines · Joel Fernandes
Quoted 8 lines · Andrew Morton
Quoted 5 lines · On Thu, 7 Nov 2019 14:53:54 -0500 "Joel Fernandes (Google)"…
F_SEAL_FUTURE_WRITEhas unexpected behavior when used withMAP_PRIVATE:
A private mapping created after the memfd file that gets sealed withF_SEAL_FUTURE_WRITEloses the copy-on-write at fork behavior, meaning children and parent share the same memory, even though the mapping is private.
Quoted 7 lines
Quoted 1 line
That sounds fairly serious. Should this be backported into -stable kernels?
Yes, it should be. The
F_SEAL_FUTURE_WRITEfeature was introduced in v5.1 so v5.3.x stable kernels would need a backport. I can submit a backport tomorrow unless we are Ok with stable automatically picking it up (I believe the stable folks "auto select" fixes which should detect this is a fix since I have said it is a fix in the subject line).
Never rely on "auto select" to pick up a patch for stable if you already know it should go to stable. Just mark it as such, or tell stable@vger after the fact.
thanks,
greg k-h
Quoted 18 lines · Greg KH
Quoted 9 lines · Joel Fernandes
Quoted 8 lines · Andrew Morton
Quoted 5 lines · On Thu, 7 Nov 2019 14:53:54 -0500 "Joel Fernandes (Google)"…
F_SEAL_FUTURE_WRITEhas unexpected behavior when used withMAP_PRIVATE:
A private mapping created after the memfd file that gets sealed withF_SEAL_FUTURE_WRITEloses the copy-on-write at fork behavior, meaning children and parent share the same memory, even though the mapping is private.Quoted 7 lines
Quoted 1 line
That sounds fairly serious. Should this be backported into -stable kernels?
Yes, it should be. The
F_SEAL_FUTURE_WRITEfeature was introduced in v5.1 so v5.3.x stable kernels would need a backport. I can submit a backport tomorrow unless we are Ok with stable automatically picking it up (I believe the stable folks "auto select" fixes which should detect this is a fix since I have said it is a fix in the subject line).
Quoted 3 lines
Never rely on "auto select" to pick up a patch for stable if you already know it should go to stable. Just mark it as such, or tell stable@vger after the fact.
Sure, agreed.
Thanks Andrew for adding the tags!
thanks,
- Joel
mm/shmem.c static int shmem_mmap(struct file *file, struct vm_area_struct *vma) · line 2220
Quoted 7 lines
mm/shmem.c +4
-3-* Since the F_SEAL_FUTURE_WRITE seals allow for a MAP_SHARED -* read-only mapping, take care to not allow mprotect to revert -* protections. +* Since an F_SEAL_FUTURE_WRITE sealed memfd can be mapped as +* MAP_SHARED and read-only, take care to not allow mprotect to +* revert protections on such mappings. Do this only for shared +* mappings. For private mappings, don't need to mask VM_MAYWRITE
This adds an > 80 char line.
Quoted 9 lines · Christoph Hellwig
mm/shmem.c static int shmem_mmap(struct file *file, struct vm_area_struct *vma) · line 2220
Quoted 7 lines
mm/shmem.c +4
-3-* Since the F_SEAL_FUTURE_WRITE seals allow for a MAP_SHARED -* read-only mapping, take care to not allow mprotect to revert -* protections. +* Since an F_SEAL_FUTURE_WRITE sealed memfd can be mapped as +* MAP_SHARED and read-only, take care to not allow mprotect to +* revert protections on such mappings. Do this only for shared +* mappings. For private mappings, don't need to mask VM_MAYWRITE This adds an > 80 char line.
Oh, true. Sorry. Andrew I hate to ask you but since you took the patch already, could you just the comment for the character limit in the one you applied?
thanks,
- Joel