moonjuice/kernel_arpi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

UPSTREAM: mm: refactor vm_area_struct::anon_vma_name usage code

Browse Source 
Avoid mixing strings and their anon_vma_name referenced pointers by
using struct anon_vma_name whenever possible.  This simplifies the code
and allows easier sharing of anon_vma_name structures when they
represent the same name.

[surenb@google.com: fix comment]

Link: https://lkml.kernel.org/r/20220223153613.835563-1-surenb@google.com
Link: https://lkml.kernel.org/r/20220224231834.1481408-1-surenb@google.com
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
Suggested-by: Matthew Wilcox <willy@infradead.org>
Suggested-by: Michal Hocko <mhocko@suse.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Cc: Colin Cross <ccross@google.com>
Cc: Sumit Semwal <sumit.semwal@linaro.org>
Cc: Dave Hansen <dave.hansen@intel.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: "Kirill A. Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: "Eric W. Biederman" <ebiederm@xmission.com>
Cc: Christian Brauner <brauner@kernel.org>
Cc: Alexey Gladkov <legion@kernel.org>
Cc: Sasha Levin <sashal@kernel.org>
Cc: Chris Hyser <chris.hyser@oracle.com>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Peter Collingbourne <pcc@google.com>
Cc: Xiaofeng Cao <caoxiaofeng@yulong.com>
Cc: David Hildenbrand <david@redhat.com>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

(cherry picked from commit 5c26f6ac9416b63d093e29c30e79b3297e425472)

Bug: 218352794
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
Change-Id: I4a6b5602ce7151d1a4b88fac489f86d68089bd4d
This commit is contained in:
Suren Baghdasaryan
2022-03-04 20:28:51 -08:00
parent 7ff2a03673
commit 0fd37220d8
12 changed files with 125 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
fs/proc/task_mmu.c
View File

@@ -309,7 +309,7 @@ show_map_vma(struct seq_file *m, struct vm_area_struct *vma)
name = arch_vma_name(vma); name = arch_vma_name(vma);
if (!name) { if (!name) {
const char *anon_name; struct anon_vma_name *anon_name;
if (!mm) { if (!mm) {
name = "[vdso]"; name = "[vdso]";
@@ -327,10 +327,10 @@ show_map_vma(struct seq_file *m, struct vm_area_struct *vma)
goto done; goto done;
} }
anon_name = vma_anon_name(vma); anon_name = anon_vma_name(vma);
if (anon_name) { if (anon_name) {
seq_pad(m, ' '); seq_pad(m, ' ');
seq_printf(m, "[anon:%s]", anon_name); seq_printf(m, "[anon:%s]", anon_name->name);
} }
} }

6
fs/userfaultfd.c
View File

@@ -878,7 +878,7 @@ static int userfaultfd_release(struct inode *inode, struct file *file)
new_flags, vma->anon_vma, new_flags, vma->anon_vma,
vma->vm_file, vma->vm_pgoff, vma->vm_file, vma->vm_pgoff,
vma_policy(vma), vma_policy(vma),
NULL_VM_UFFD_CTX, vma_anon_name(vma)); NULL_VM_UFFD_CTX, anon_vma_name(vma));
if (prev) if (prev)
vma = prev; vma = prev;
else else
@@ -1438,7 +1438,7 @@ static int userfaultfd_register(struct userfaultfd_ctx *ctx,
vma->anon_vma, vma->vm_file, vma->vm_pgoff, vma->anon_vma, vma->vm_file, vma->vm_pgoff,
vma_policy(vma), vma_policy(vma),
((struct vm_userfaultfd_ctx){ ctx }), ((struct vm_userfaultfd_ctx){ ctx }),
vma_anon_name(vma)); anon_vma_name(vma));
if (prev) { if (prev) {
vma = prev; vma = prev;
goto next; goto next;
@@ -1615,7 +1615,7 @@ static int userfaultfd_unregister(struct userfaultfd_ctx *ctx,
prev = vma_merge(mm, prev, start, vma_end, new_flags, prev = vma_merge(mm, prev, start, vma_end, new_flags,
vma->anon_vma, vma->vm_file, vma->vm_pgoff, vma->anon_vma, vma->vm_file, vma->vm_pgoff,
vma_policy(vma), vma_policy(vma),
NULL_VM_UFFD_CTX, vma_anon_name(vma)); NULL_VM_UFFD_CTX, anon_vma_name(vma));
if (prev) { if (prev) {
vma = prev; vma = prev;
goto next; goto next;

7
include/linux/mm.h
View File

@@ -2591,7 +2591,7 @@ static inline int vma_adjust(struct vm_area_struct *vma, unsigned long start,
extern struct vm_area_struct *vma_merge(struct mm_struct *, extern struct vm_area_struct *vma_merge(struct mm_struct *,
struct vm_area_struct *prev, unsigned long addr, unsigned long end, struct vm_area_struct *prev, unsigned long addr, unsigned long end,
unsigned long vm_flags, struct anon_vma *, struct file *, pgoff_t, unsigned long vm_flags, struct anon_vma *, struct file *, pgoff_t,
struct mempolicy *, struct vm_userfaultfd_ctx, const char *); struct mempolicy *, struct vm_userfaultfd_ctx, struct anon_vma_name *);
extern struct anon_vma *find_mergeable_anon_vma(struct vm_area_struct *); extern struct anon_vma *find_mergeable_anon_vma(struct vm_area_struct *);
extern int __split_vma(struct mm_struct *, struct vm_area_struct *, extern int __split_vma(struct mm_struct *, struct vm_area_struct *,
unsigned long addr, int new_below); unsigned long addr, int new_below);
@@ -3338,11 +3338,12 @@ static inline int seal_check_future_write(int seals, struct vm_area_struct *vma)
#ifdef CONFIG_ANON_VMA_NAME #ifdef CONFIG_ANON_VMA_NAME
int madvise_set_anon_name(struct mm_struct *mm, unsigned long start, int madvise_set_anon_name(struct mm_struct *mm, unsigned long start,
unsigned long len_in, const char *name); unsigned long len_in,
struct anon_vma_name *anon_name);
#else #else
static inline int static inline int
madvise_set_anon_name(struct mm_struct *mm, unsigned long start, madvise_set_anon_name(struct mm_struct *mm, unsigned long start,
unsigned long len_in, const char *name) { unsigned long len_in, struct anon_vma_name *anon_name) {
return 0; return 0;
} }
#endif #endif

86
include/linux/mm_inline.h
View File

@@ -108,50 +108,80 @@ static __always_inline void del_page_from_lru_list(struct page *page,
#ifdef CONFIG_ANON_VMA_NAME #ifdef CONFIG_ANON_VMA_NAME
/* /*
* mmap_lock should be read-locked when calling vma_anon_name() and while using * mmap_lock should be read-locked when calling anon_vma_name(). Caller should
* the returned pointer. * either keep holding the lock while using the returned pointer or it should
* raise anon_vma_name refcount before releasing the lock.
*/ */
extern const char *vma_anon_name(struct vm_area_struct *vma); extern struct anon_vma_name *anon_vma_name(struct vm_area_struct *vma);
extern struct anon_vma_name *anon_vma_name_alloc(const char *name);
/* extern void anon_vma_name_free(struct kref *kref);
* mmap_lock should be read-locked for orig_vma->vm_mm.
* mmap_lock should be write-locked for new_vma->vm_mm or new_vma should be
* isolated.
*/
extern void dup_vma_anon_name(struct vm_area_struct *orig_vma,
struct vm_area_struct *new_vma);
/*
* mmap_lock should be write-locked or vma should have been isolated under
* write-locked mmap_lock protection.
*/
extern void free_vma_anon_name(struct vm_area_struct *vma);
/* mmap_lock should be read-locked */ /* mmap_lock should be read-locked */
static inline bool is_same_vma_anon_name(struct vm_area_struct *vma, static inline void anon_vma_name_get(struct anon_vma_name *anon_name)
const char *name)
{ {
const char *vma_name = vma_anon_name(vma); if (anon_name)
kref_get(&anon_name->kref);
}
/* either both NULL, or pointers to same string */ static inline void anon_vma_name_put(struct anon_vma_name *anon_name)
if (vma_name == name) {
if (anon_name)
kref_put(&anon_name->kref, anon_vma_name_free);
}
static inline void dup_anon_vma_name(struct vm_area_struct *orig_vma,
struct vm_area_struct *new_vma)
{
struct anon_vma_name *anon_name = anon_vma_name(orig_vma);
if (anon_name) {
anon_vma_name_get(anon_name);
new_vma->anon_name = anon_name;
}
}
static inline void free_anon_vma_name(struct vm_area_struct *vma)
{
/*
* Not using anon_vma_name because it generates a warning if mmap_lock
* is not held, which might be the case here.
*/
if (!vma->vm_file)
anon_vma_name_put(vma->anon_name);
}
static inline bool anon_vma_name_eq(struct anon_vma_name *anon_name1,
struct anon_vma_name *anon_name2)
{
if (anon_name1 == anon_name2)
return true; return true;
return name && vma_name && !strcmp(name, vma_name); return anon_name1 && anon_name2 &&
!strcmp(anon_name1->name, anon_name2->name);
} }
#else /* CONFIG_ANON_VMA_NAME */ #else /* CONFIG_ANON_VMA_NAME */
static inline const char *vma_anon_name(struct vm_area_struct *vma) static inline struct anon_vma_name *anon_vma_name(struct vm_area_struct *vma)
{ {
return NULL; return NULL;
} }
static inline void dup_vma_anon_name(struct vm_area_struct *orig_vma,
static inline struct anon_vma_name *anon_vma_name_alloc(const char *name)
{
return NULL;
}
static inline void anon_vma_name_get(struct anon_vma_name *anon_name) {}
static inline void anon_vma_name_put(struct anon_vma_name *anon_name) {}
static inline void dup_anon_vma_name(struct vm_area_struct *orig_vma,
struct vm_area_struct *new_vma) {} struct vm_area_struct *new_vma) {}
static inline void free_vma_anon_name(struct vm_area_struct *vma) {} static inline void free_anon_vma_name(struct vm_area_struct *vma) {}
static inline bool is_same_vma_anon_name(struct vm_area_struct *vma,
const char *name) static inline bool anon_vma_name_eq(struct anon_vma_name *anon_name1,
struct anon_vma_name *anon_name2)
{ {
return true; return true;
} }
#endif /* CONFIG_ANON_VMA_NAME */ #endif /* CONFIG_ANON_VMA_NAME */
#endif #endif

5
include/linux/mm_types.h
View File

@@ -378,7 +378,10 @@ struct vm_area_struct {
struct rb_node rb; struct rb_node rb;
unsigned long rb_subtree_last; unsigned long rb_subtree_last;
} shared; } shared;
/* Serialized by mmap_sem. */ /*
* Serialized by mmap_sem. Never use directly because it is
* valid only when vm_file is NULL. Use anon_vma_name instead.
*/
struct anon_vma_name *anon_name; struct anon_vma_name *anon_name;
}; };

4
kernel/fork.c
View File

@@ -376,7 +376,7 @@ struct vm_area_struct *vm_area_dup(struct vm_area_struct *orig)
*new = data_race(*orig); *new = data_race(*orig);
INIT_LIST_HEAD(&new->anon_vma_chain); INIT_LIST_HEAD(&new->anon_vma_chain);
new->vm_next = new->vm_prev = NULL; new->vm_next = new->vm_prev = NULL;
dup_vma_anon_name(orig, new); dup_anon_vma_name(orig, new);
} }
return new; return new;
} }
@@ -399,7 +399,7 @@ static void __vm_area_free(struct rcu_head *head)
void vm_area_free(struct vm_area_struct *vma) void vm_area_free(struct vm_area_struct *vma)
{ {
free_vma_anon_name(vma); free_anon_vma_name(vma);
#ifdef CONFIG_SPECULATIVE_PAGE_FAULT #ifdef CONFIG_SPECULATIVE_PAGE_FAULT
if (atomic_read(&vma->vm_mm->mm_users) > 1) { if (atomic_read(&vma->vm_mm->mm_users) > 1) {
call_rcu(&vma->vm_rcu, __vm_area_free); call_rcu(&vma->vm_rcu, __vm_area_free);

19
kernel/sys.c
View File

@@ -7,6 +7,7 @@
#include <linux/export.h> #include <linux/export.h>
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/mm_inline.h>
#include <linux/utsname.h> #include <linux/utsname.h>
#include <linux/mman.h> #include <linux/mman.h>
#include <linux/reboot.h> #include <linux/reboot.h>
@@ -2288,15 +2289,16 @@ static int prctl_set_vma(unsigned long opt, unsigned long addr,
{ {
struct mm_struct *mm = current->mm; struct mm_struct *mm = current->mm;
const char __user *uname; const char __user *uname;
char *name, *pch; struct anon_vma_name *anon_name = NULL;
int error; int error;
switch (opt) { switch (opt) {
case PR_SET_VMA_ANON_NAME: case PR_SET_VMA_ANON_NAME:
uname = (const char __user *)arg; uname = (const char __user *)arg;
if (uname) { if (uname) {
name = strndup_user(uname, ANON_VMA_NAME_MAX_LEN); char *name, *pch;
name = strndup_user(uname, ANON_VMA_NAME_MAX_LEN);
if (IS_ERR(name)) if (IS_ERR(name))
return PTR_ERR(name); return PTR_ERR(name);
@@ -2306,15 +2308,18 @@ static int prctl_set_vma(unsigned long opt, unsigned long addr,
return -EINVAL; return -EINVAL;
} }
} }
} else { /* anon_vma has its own copy */
/* Reset the name */ anon_name = anon_vma_name_alloc(name);
name = NULL; kfree(name);
if (!anon_name)
return -ENOMEM;
} }
mmap_write_lock(mm); mmap_write_lock(mm);
error = madvise_set_anon_name(mm, addr, size, name); error = madvise_set_anon_name(mm, addr, size, anon_name);
mmap_write_unlock(mm); mmap_write_unlock(mm);
kfree(name); anon_vma_name_put(anon_name);
break; break;
default: default:
error = -EINVAL; error = -EINVAL;

85
mm/madvise.c
View File

@@ -65,7 +65,7 @@ static int madvise_need_mmap_write(int behavior)
} }
#ifdef CONFIG_ANON_VMA_NAME #ifdef CONFIG_ANON_VMA_NAME
static struct anon_vma_name *anon_vma_name_alloc(const char *name) struct anon_vma_name *anon_vma_name_alloc(const char *name)
{ {
struct anon_vma_name *anon_name; struct anon_vma_name *anon_name;
size_t count; size_t count;
@@ -81,78 +81,49 @@ static struct anon_vma_name *anon_vma_name_alloc(const char *name)
return anon_name; return anon_name;
} }
static void vma_anon_name_free(struct kref *kref) void anon_vma_name_free(struct kref *kref)
{ {
struct anon_vma_name *anon_name = struct anon_vma_name *anon_name =
container_of(kref, struct anon_vma_name, kref); container_of(kref, struct anon_vma_name, kref);
kfree(anon_name); kfree(anon_name);
} }
static inline bool has_vma_anon_name(struct vm_area_struct *vma) struct anon_vma_name *anon_vma_name(struct vm_area_struct *vma)
{ {
return !vma->vm_file && vma->anon_name;
}
const char *vma_anon_name(struct vm_area_struct *vma)
{
if (!has_vma_anon_name(vma))
return NULL;
mmap_assert_locked(vma->vm_mm); mmap_assert_locked(vma->vm_mm);
return vma->anon_name->name; if (vma->vm_file)
} return NULL;
void dup_vma_anon_name(struct vm_area_struct *orig_vma, return vma->anon_name;
struct vm_area_struct *new_vma)
{
if (!has_vma_anon_name(orig_vma))
return;
kref_get(&orig_vma->anon_name->kref);
new_vma->anon_name = orig_vma->anon_name;
}
void free_vma_anon_name(struct vm_area_struct *vma)
{
struct anon_vma_name *anon_name;
if (!has_vma_anon_name(vma))
return;
anon_name = vma->anon_name;
vma->anon_name = NULL;
kref_put(&anon_name->kref, vma_anon_name_free);
} }
/* mmap_lock should be write-locked */ /* mmap_lock should be write-locked */
static int replace_vma_anon_name(struct vm_area_struct *vma, const char *name) static int replace_anon_vma_name(struct vm_area_struct *vma,
struct anon_vma_name *anon_name)
{ {
const char *anon_name; struct anon_vma_name *orig_name = anon_vma_name(vma);
if (!name) { if (!anon_name) {
free_vma_anon_name(vma); vma->anon_name = NULL;
anon_vma_name_put(orig_name);
return 0; return 0;
} }
anon_name = vma_anon_name(vma); if (anon_vma_name_eq(orig_name, anon_name))
if (anon_name) {
/* Same name, nothing to do here */
if (!strcmp(name, anon_name))
return 0; return 0;
free_vma_anon_name(vma); anon_vma_name_get(anon_name);
} vma->anon_name = anon_name;
vma->anon_name = anon_vma_name_alloc(name); anon_vma_name_put(orig_name);
if (!vma->anon_name)
return -ENOMEM;
return 0; return 0;
} }
#else /* CONFIG_ANON_VMA_NAME */ #else /* CONFIG_ANON_VMA_NAME */
static int replace_vma_anon_name(struct vm_area_struct *vma, const char *name) static int replace_anon_vma_name(struct vm_area_struct *vma,
struct anon_vma_name *anon_name)
{ {
if (name) if (anon_name)
return -EINVAL; return -EINVAL;
return 0; return 0;
@@ -165,13 +136,13 @@ static int replace_vma_anon_name(struct vm_area_struct *vma, const char *name)
static int madvise_update_vma(struct vm_area_struct *vma, static int madvise_update_vma(struct vm_area_struct *vma,
struct vm_area_struct **prev, unsigned long start, struct vm_area_struct **prev, unsigned long start,
unsigned long end, unsigned long new_flags, unsigned long end, unsigned long new_flags,
const char *name) struct anon_vma_name *anon_name)
{ {
struct mm_struct *mm = vma->vm_mm; struct mm_struct *mm = vma->vm_mm;
int error; int error;
pgoff_t pgoff; pgoff_t pgoff;
if (new_flags == vma->vm_flags && is_same_vma_anon_name(vma, name)) { if (new_flags == vma->vm_flags && anon_vma_name_eq(anon_vma_name(vma), anon_name)) {
*prev = vma; *prev = vma;
return 0; return 0;
} }
@@ -179,7 +150,7 @@ static int madvise_update_vma(struct vm_area_struct *vma,
pgoff = vma->vm_pgoff + ((start - vma->vm_start) >> PAGE_SHIFT); pgoff = vma->vm_pgoff + ((start - vma->vm_start) >> PAGE_SHIFT);
*prev = vma_merge(mm, *prev, start, end, new_flags, vma->anon_vma, *prev = vma_merge(mm, *prev, start, end, new_flags, vma->anon_vma,
vma->vm_file, pgoff, vma_policy(vma), vma->vm_file, pgoff, vma_policy(vma),
vma->vm_userfaultfd_ctx, name); vma->vm_userfaultfd_ctx, anon_name);
if (*prev) { if (*prev) {
vma = *prev; vma = *prev;
goto success; goto success;
@@ -209,7 +180,7 @@ success:
*/ */
vma->vm_flags = new_flags; vma->vm_flags = new_flags;
if (!vma->vm_file) { if (!vma->vm_file) {
error = replace_vma_anon_name(vma, name); error = replace_anon_vma_name(vma, anon_name);
if (error) if (error)
return error; return error;
} }
@@ -1041,7 +1012,7 @@ static int madvise_vma_behavior(struct vm_area_struct *vma,
} }
error = madvise_update_vma(vma, prev, start, end, new_flags, error = madvise_update_vma(vma, prev, start, end, new_flags,
vma_anon_name(vma)); anon_vma_name(vma));
out: out:
/* /*
@@ -1225,7 +1196,7 @@ int madvise_walk_vmas(struct mm_struct *mm, unsigned long start,
static int madvise_vma_anon_name(struct vm_area_struct *vma, static int madvise_vma_anon_name(struct vm_area_struct *vma,
struct vm_area_struct **prev, struct vm_area_struct **prev,
unsigned long start, unsigned long end, unsigned long start, unsigned long end,
unsigned long name) unsigned long anon_name)
{ {
int error; int error;
@@ -1234,7 +1205,7 @@ static int madvise_vma_anon_name(struct vm_area_struct *vma,
return -EBADF; return -EBADF;
error = madvise_update_vma(vma, prev, start, end, vma->vm_flags, error = madvise_update_vma(vma, prev, start, end, vma->vm_flags,
(const char *)name); (struct anon_vma_name *)anon_name);
/* /*
* madvise() returns EAGAIN if kernel resources, such as * madvise() returns EAGAIN if kernel resources, such as
@@ -1246,7 +1217,7 @@ static int madvise_vma_anon_name(struct vm_area_struct *vma,
} }
int madvise_set_anon_name(struct mm_struct *mm, unsigned long start, int madvise_set_anon_name(struct mm_struct *mm, unsigned long start,
unsigned long len_in, const char *name) unsigned long len_in, struct anon_vma_name *anon_name)
{ {
unsigned long end; unsigned long end;
unsigned long len; unsigned long len;
@@ -1266,7 +1237,7 @@ int madvise_set_anon_name(struct mm_struct *mm, unsigned long start,
if (end == start) if (end == start)
return 0; return 0;
return madvise_walk_vmas(mm, start, end, (unsigned long)name, return madvise_walk_vmas(mm, start, end, (unsigned long)anon_name,
madvise_vma_anon_name); madvise_vma_anon_name);
} }
#endif /* CONFIG_ANON_VMA_NAME */ #endif /* CONFIG_ANON_VMA_NAME */

2
mm/mempolicy.c
View File

@@ -811,7 +811,7 @@ static int mbind_range(struct mm_struct *mm, unsigned long start,
prev = vma_merge(mm, prev, vmstart, vmend, vma->vm_flags, prev = vma_merge(mm, prev, vmstart, vmend, vma->vm_flags,
vma->anon_vma, vma->vm_file, pgoff, vma->anon_vma, vma->vm_file, pgoff,
new_pol, vma->vm_userfaultfd_ctx, new_pol, vma->vm_userfaultfd_ctx,
vma_anon_name(vma)); anon_vma_name(vma));
if (prev) { if (prev) {
vma = prev; vma = prev;
next = vma->vm_next; next = vma->vm_next;

2
mm/mlock.c
View File

@@ -511,7 +511,7 @@ static int mlock_fixup(struct vm_area_struct *vma, struct vm_area_struct **prev,
pgoff = vma->vm_pgoff + ((start - vma->vm_start) >> PAGE_SHIFT); pgoff = vma->vm_pgoff + ((start - vma->vm_start) >> PAGE_SHIFT);
*prev = vma_merge(mm, *prev, start, end, newflags, vma->anon_vma, *prev = vma_merge(mm, *prev, start, end, newflags, vma->anon_vma,
vma->vm_file, pgoff, vma_policy(vma), vma->vm_file, pgoff, vma_policy(vma),
vma->vm_userfaultfd_ctx, vma_anon_name(vma)); vma->vm_userfaultfd_ctx, anon_vma_name(vma));
if (*prev) { if (*prev) {
vma = *prev; vma = *prev;
goto success; goto success;

12
mm/mmap.c
View File

@@ -1031,7 +1031,7 @@ again:
static inline int is_mergeable_vma(struct vm_area_struct *vma, static inline int is_mergeable_vma(struct vm_area_struct *vma,
struct file *file, unsigned long vm_flags, struct file *file, unsigned long vm_flags,
struct vm_userfaultfd_ctx vm_userfaultfd_ctx, struct vm_userfaultfd_ctx vm_userfaultfd_ctx,
const char *anon_name) struct anon_vma_name *anon_name)
{ {
/* /*
* VM_SOFTDIRTY should not prevent from VMA merging, if we * VM_SOFTDIRTY should not prevent from VMA merging, if we
@@ -1049,7 +1049,7 @@ static inline int is_mergeable_vma(struct vm_area_struct *vma,
return 0; return 0;
if (!is_mergeable_vm_userfaultfd_ctx(vma, vm_userfaultfd_ctx)) if (!is_mergeable_vm_userfaultfd_ctx(vma, vm_userfaultfd_ctx))
return 0; return 0;
if (!is_same_vma_anon_name(vma, anon_name)) if (!anon_vma_name_eq(anon_vma_name(vma), anon_name))
return 0; return 0;
return 1; return 1;
} }
@@ -1084,7 +1084,7 @@ can_vma_merge_before(struct vm_area_struct *vma, unsigned long vm_flags,
struct anon_vma *anon_vma, struct file *file, struct anon_vma *anon_vma, struct file *file,
pgoff_t vm_pgoff, pgoff_t vm_pgoff,
struct vm_userfaultfd_ctx vm_userfaultfd_ctx, struct vm_userfaultfd_ctx vm_userfaultfd_ctx,
const char *anon_name) struct anon_vma_name *anon_name)
{ {
if (is_mergeable_vma(vma, file, vm_flags, vm_userfaultfd_ctx, anon_name) && if (is_mergeable_vma(vma, file, vm_flags, vm_userfaultfd_ctx, anon_name) &&
is_mergeable_anon_vma(anon_vma, vma->anon_vma, vma)) { is_mergeable_anon_vma(anon_vma, vma->anon_vma, vma)) {
@@ -1106,7 +1106,7 @@ can_vma_merge_after(struct vm_area_struct *vma, unsigned long vm_flags,
struct anon_vma *anon_vma, struct file *file, struct anon_vma *anon_vma, struct file *file,
pgoff_t vm_pgoff, pgoff_t vm_pgoff,
struct vm_userfaultfd_ctx vm_userfaultfd_ctx, struct vm_userfaultfd_ctx vm_userfaultfd_ctx,
const char *anon_name) struct anon_vma_name *anon_name)
{ {
if (is_mergeable_vma(vma, file, vm_flags, vm_userfaultfd_ctx, anon_name) && if (is_mergeable_vma(vma, file, vm_flags, vm_userfaultfd_ctx, anon_name) &&
is_mergeable_anon_vma(anon_vma, vma->anon_vma, vma)) { is_mergeable_anon_vma(anon_vma, vma->anon_vma, vma)) {
@@ -1167,7 +1167,7 @@ struct vm_area_struct *vma_merge(struct mm_struct *mm,
struct anon_vma *anon_vma, struct file *file, struct anon_vma *anon_vma, struct file *file,
pgoff_t pgoff, struct mempolicy *policy, pgoff_t pgoff, struct mempolicy *policy,
struct vm_userfaultfd_ctx vm_userfaultfd_ctx, struct vm_userfaultfd_ctx vm_userfaultfd_ctx,
const char *anon_name) struct anon_vma_name *anon_name)
{ {
pgoff_t pglen = (end - addr) >> PAGE_SHIFT; pgoff_t pglen = (end - addr) >> PAGE_SHIFT;
struct vm_area_struct *area, *next; struct vm_area_struct *area, *next;
@@ -3258,7 +3258,7 @@ struct vm_area_struct *copy_vma(struct vm_area_struct **vmap,
return NULL; /* should never get here */ return NULL; /* should never get here */
new_vma = vma_merge(mm, prev, addr, addr + len, vma->vm_flags, new_vma = vma_merge(mm, prev, addr, addr + len, vma->vm_flags,
vma->anon_vma, vma->vm_file, pgoff, vma_policy(vma), vma->anon_vma, vma->vm_file, pgoff, vma_policy(vma),
vma->vm_userfaultfd_ctx, vma_anon_name(vma)); vma->vm_userfaultfd_ctx, anon_vma_name(vma));
if (new_vma) { if (new_vma) {
/* /*
* Source vma may have been merged into new_vma * Source vma may have been merged into new_vma

2
mm/mprotect.c
View File

@@ -464,7 +464,7 @@ mprotect_fixup(struct vm_area_struct *vma, struct vm_area_struct **pprev,
pgoff = vma->vm_pgoff + ((start - vma->vm_start) >> PAGE_SHIFT); pgoff = vma->vm_pgoff + ((start - vma->vm_start) >> PAGE_SHIFT);
*pprev = vma_merge(mm, *pprev, start, end, newflags, *pprev = vma_merge(mm, *pprev, start, end, newflags,
vma->anon_vma, vma->vm_file, pgoff, vma_policy(vma), vma->anon_vma, vma->vm_file, pgoff, vma_policy(vma),
vma->vm_userfaultfd_ctx, vma_anon_name(vma)); vma->vm_userfaultfd_ctx, anon_vma_name(vma));
if (*pprev) { if (*pprev) {
vma = *pprev; vma = *pprev;
VM_WARN_ON((vma->vm_flags ^ newflags) & ~VM_SOFTDIRTY); VM_WARN_ON((vma->vm_flags ^ newflags) & ~VM_SOFTDIRTY);