linux-kernel.vger.kernel.org archive mirror
 help / color / mirror / Atom feed
From: Liam Howlett <liam.howlett@oracle.com>
To: "maple-tree@lists.infradead.org" <maple-tree@lists.infradead.org>,
	"linux-mm@kvack.org" <linux-mm@kvack.org>,
	"linux-kernel@vger.kernel.org" <linux-kernel@vger.kernel.org>,
	Andrew Morton <akpm@linux-foundation.org>
Cc: Song Liu <songliubraving@fb.com>,
	Davidlohr Bueso <dave@stgolabs.net>,
	"Paul E . McKenney" <paulmck@kernel.org>,
	Matthew Wilcox <willy@infradead.org>,
	Laurent Dufour <ldufour@linux.ibm.com>,
	David Rientjes <rientjes@google.com>,
	Axel Rasmussen <axelrasmussen@google.com>,
	Suren Baghdasaryan <surenb@google.com>,
	Vlastimil Babka <vbabka@suse.cz>, Rik van Riel <riel@surriel.com>,
	Peter Zijlstra <peterz@infradead.org>,
	Michel Lespinasse <walken.cr@gmail.com>,
	Liam Howlett <liam.howlett@oracle.com>
Subject: [PATCH 39/94] mm/mmap: Change do_brk_flags() to expand existing VMA and add do_brk_munmap()
Date: Wed, 28 Apr 2021 15:36:08 +0000	[thread overview]
Message-ID: <20210428153542.2814175-40-Liam.Howlett@Oracle.com> (raw)
In-Reply-To: <20210428153542.2814175-1-Liam.Howlett@Oracle.com>

Avoid allocating a new VMA when it is not necessary.  Expand or contract
the existing VMA instead.  This avoids unnecessary tree manipulations
and allocations.

Once the VMA is known, use it directly when populating to avoid
unnecessary lookup work.

Signed-off-by: Liam R. Howlett <Liam.Howlett@Oracle.com>
---
 mm/mmap.c | 269 +++++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 214 insertions(+), 55 deletions(-)

diff --git a/mm/mmap.c b/mm/mmap.c
index 7747047c4cbe..6671e34b9693 100644
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -190,17 +190,22 @@ static struct vm_area_struct *remove_vma(struct vm_area_struct *vma)
 	return next;
 }
 
-static int do_brk_flags(unsigned long addr, unsigned long request, unsigned long flags,
-		struct list_head *uf);
+static int do_brk_munmap(struct ma_state *mas, struct vm_area_struct *vma,
+			 unsigned long newbrk, unsigned long oldbrk,
+			 struct list_head *uf);
+static int do_brk_flags(struct ma_state *mas, struct vm_area_struct **brkvma,
+			unsigned long addr, unsigned long request,
+			unsigned long flags);
 SYSCALL_DEFINE1(brk, unsigned long, brk)
 {
 	unsigned long newbrk, oldbrk, origbrk;
 	struct mm_struct *mm = current->mm;
-	struct vm_area_struct *next;
+	struct vm_area_struct *brkvma, *next = NULL;
 	unsigned long min_brk;
 	bool populate;
 	bool downgraded = false;
 	LIST_HEAD(uf);
+	MA_STATE(mas, &mm->mm_mt, 0, 0);
 
 	if (mmap_write_lock_killable(mm))
 		return -EINTR;
@@ -240,37 +245,56 @@ SYSCALL_DEFINE1(brk, unsigned long, brk)
 		goto success;
 	}
 
-	/*
-	 * Always allow shrinking brk.
-	 * __do_munmap() may downgrade mmap_lock to read.
-	 */
-	if (brk <= mm->brk) {
+	mas_set(&mas, newbrk);
+	brkvma = mas_walk(&mas);
+	if (brkvma) { // munmap necessary, there is something at newbrk.
+		/*
+		 * Always allow shrinking brk.
+		 * do_brk_munmap() may downgrade mmap_lock to read.
+		 */
 		int ret;
 
+		if (brkvma->vm_start >= oldbrk)
+			goto out; // mapping intersects with an existing non-brk vma.
 		/*
-		 * mm->brk must to be protected by write mmap_lock so update it
-		 * before downgrading mmap_lock. When __do_munmap() fails,
-		 * mm->brk will be restored from origbrk.
+		 * mm->brk must to be protected by write mmap_lock.
+		 * do_brk_munmap() may downgrade the lock,  so update it
+		 * before calling do_brk_munmap().
 		 */
 		mm->brk = brk;
-		ret = __do_munmap(mm, newbrk, oldbrk-newbrk, &uf, true);
-		if (ret < 0) {
-			mm->brk = origbrk;
-			goto out;
-		} else if (ret == 1) {
+		mas.last = oldbrk - 1;
+		ret = do_brk_munmap(&mas, brkvma, newbrk, oldbrk, &uf);
+		if (ret == 1)  {
 			downgraded = true;
-		}
-		goto success;
-	}
+			goto success;
+		} else if (!ret)
+			goto success;
 
+		mm->brk = origbrk;
+		goto out;
+	}
+	/* Only check if the next VMA is within the stack_guard_gap of the
+	 * expansion area */
+	next = mas_next(&mas, newbrk + PAGE_SIZE + stack_guard_gap);
 	/* Check against existing mmap mappings. */
-	next = find_vma(mm, oldbrk);
 	if (next && newbrk + PAGE_SIZE > vm_start_gap(next))
 		goto out;
 
+	brkvma = mas_prev(&mas, mm->start_brk);
+	if (brkvma) {
+		if(brkvma->vm_start >= oldbrk)
+			goto out; // Trying to map over another vma.
+
+		if (brkvma->vm_end <= min_brk) {
+			brkvma = NULL;
+			mas_reset(&mas);
+		}
+	}
+
 	/* Ok, looks good - let it rip. */
-	if (do_brk_flags(oldbrk, newbrk-oldbrk, 0, &uf) < 0)
+	if (do_brk_flags(&mas, &brkvma, oldbrk, newbrk - oldbrk, 0) < 0)
 		goto out;
+
 	mm->brk = brk;
 
 success:
@@ -281,7 +305,7 @@ SYSCALL_DEFINE1(brk, unsigned long, brk)
 		mmap_write_unlock(mm);
 	userfaultfd_unmap_complete(mm, &uf);
 	if (populate)
-		mm_populate(oldbrk, newbrk - oldbrk);
+		mm_populate_vma(brkvma, oldbrk, newbrk);
 	return brk;
 
 out:
@@ -372,16 +396,16 @@ static void validate_mm(struct mm_struct *mm)
 	validate_mm_mt(mm);
 
 	while (vma) {
+#ifdef CONFIG_DEBUG_VM_RB
 		struct anon_vma *anon_vma = vma->anon_vma;
 		struct anon_vma_chain *avc;
-
 		if (anon_vma) {
 			anon_vma_lock_read(anon_vma);
 			list_for_each_entry(avc, &vma->anon_vma_chain, same_vma)
 				anon_vma_interval_tree_verify(avc);
 			anon_vma_unlock_read(anon_vma);
 		}
-
+#endif
 		highest_address = vm_end_gap(vma);
 		vma = vma->vm_next;
 		i++;
@@ -2024,13 +2048,16 @@ EXPORT_SYMBOL(get_unmapped_area);
 struct vm_area_struct *find_vma(struct mm_struct *mm, unsigned long addr)
 {
 	struct vm_area_struct *vma;
+	MA_STATE(mas, &mm->mm_mt, addr, addr);
 
 	/* Check the cache first. */
 	vma = vmacache_find(mm, addr);
 	if (likely(vma))
 		return vma;
 
-	vma = mt_find(&mm->mm_mt, &addr, ULONG_MAX);
+	rcu_read_lock();
+	vma = mas_find(&mas, -1);
+	rcu_read_unlock();
 	if (vma)
 		vmacache_update(addr, vma);
 
@@ -2514,7 +2541,6 @@ static inline void unlock_range(struct vm_area_struct *start, unsigned long limi
 			mm->locked_vm -= vma_pages(tmp);
 			munlock_vma_pages_all(tmp);
 		}
-
 		tmp = tmp->vm_next;
 	}
 }
@@ -2749,16 +2775,105 @@ SYSCALL_DEFINE5(remap_file_pages, unsigned long, start, unsigned long, size,
 }
 
 /*
- *  this is really a simplified "do_mmap".  it only handles
- *  anonymous maps.  eventually we may be able to do some
- *  brk-specific accounting here.
+ * bkr_munmap() - Unmap a parital vma.
+ * @mas: The maple tree state.
+ * @vma: The vma to be modified
+ * @newbrk: the start of the address to unmap
+ * @oldbrk: The end of the address to unmap
+ * @uf: The userfaultfd list_head
+ *
+ * Returns: 0 on success.
+ * unmaps a partial VMA mapping.  Does not handle alignment, downgrades lock if
+ * possible.
+ */
+static int do_brk_munmap(struct ma_state *mas, struct vm_area_struct *vma,
+			 unsigned long newbrk, unsigned long oldbrk,
+			 struct list_head *uf)
+{
+	struct mm_struct *mm = vma->vm_mm;
+	struct vm_area_struct unmap;
+	unsigned long unmap_pages;
+	int ret = 1;
+
+	arch_unmap(mm, newbrk, oldbrk);
+
+	if (likely(vma->vm_start >= newbrk)) { // remove entire mapping(s)
+		mas_set(mas, newbrk);
+		if (vma->vm_start != newbrk)
+			mas_reset(mas); // cause a re-walk for the first overlap.
+		ret = __do_munmap(mm, newbrk, oldbrk - newbrk, uf, true);
+		goto munmap_full_vma;
+	}
+
+	vma_init(&unmap, mm);
+	unmap.vm_start = newbrk;
+	unmap.vm_end = oldbrk;
+	ret = userfaultfd_unmap_prep(&unmap, newbrk, oldbrk, uf);
+	if (ret)
+		return ret;
+	ret = 1;
+
+	// Change the oldbrk of vma to the newbrk of the munmap area
+	vma_adjust_trans_huge(vma, vma->vm_start, newbrk, 0);
+	if (vma->anon_vma) {
+		anon_vma_lock_write(vma->anon_vma);
+		anon_vma_interval_tree_pre_update_vma(vma);
+	}
+
+	vma->vm_end = newbrk;
+	if (vma_mas_remove(&unmap, mas))
+		goto mas_store_fail;
+
+	vmacache_invalidate(vma->vm_mm);
+	if (vma->anon_vma) {
+		anon_vma_interval_tree_post_update_vma(vma);
+		anon_vma_unlock_write(vma->anon_vma);
+	}
+
+	unmap_pages = vma_pages(&unmap);
+	if (unmap.vm_flags & VM_LOCKED) {
+		mm->locked_vm -= unmap_pages;
+		munlock_vma_pages_range(&unmap, newbrk, oldbrk);
+	}
+
+	mmap_write_downgrade(mm);
+	unmap_region(mm, &unmap, vma, newbrk, oldbrk);
+	/* Statistics */
+	vm_stat_account(mm, unmap.vm_flags, -unmap_pages);
+	if (unmap.vm_flags & VM_ACCOUNT)
+		vm_unacct_memory(unmap_pages);
+
+munmap_full_vma:
+	validate_mm_mt(mm);
+	return ret;
+
+mas_store_fail:
+	vma->vm_end = oldbrk;
+	if (vma->anon_vma) {
+		anon_vma_interval_tree_post_update_vma(vma);
+		anon_vma_unlock_write(vma->anon_vma);
+	}
+	return -ENOMEM;
+}
+
+/*
+ * do_brk_flags() - Increase the brk vma if the flags match.
+ * @mas: The maple tree state.
+ * @addr: The start address
+ * @len: The length of the increase
+ * @vma: The vma,
+ * @flags: The VMA Flags
+ *
+ * Extend the brk VMA from addr to addr + len.  If the VMA is NULL or the flags
+ * do not match then create a new anonymous VMA.  Eventually we may be able to
+ * do some brk-specific accounting here.
  */
-static int do_brk_flags(unsigned long addr, unsigned long len,
-			unsigned long flags, struct list_head *uf)
+static int do_brk_flags(struct ma_state *mas, struct vm_area_struct **brkvma,
+			unsigned long addr, unsigned long len,
+			unsigned long flags)
 {
 	struct mm_struct *mm = current->mm;
-	struct vm_area_struct *vma, *prev;
-	pgoff_t pgoff = addr >> PAGE_SHIFT;
+	struct vm_area_struct *prev = NULL, *vma;
 	int error;
 	unsigned long mapped_addr;
 	validate_mm_mt(mm);
@@ -2776,11 +2891,7 @@ static int do_brk_flags(unsigned long addr, unsigned long len,
 	if (error)
 		return error;
 
-	/* Clear old maps, set up prev and uf */
-	if (munmap_vma_range(mm, addr, len, &prev, uf))
-		return -ENOMEM;
-
-	/* Check against address space limits *after* clearing old maps... */
+	/* Check against address space limits by the changed size */
 	if (!may_expand_vm(mm, flags, len >> PAGE_SHIFT))
 		return -ENOMEM;
 
@@ -2790,28 +2901,59 @@ static int do_brk_flags(unsigned long addr, unsigned long len,
 	if (security_vm_enough_memory_mm(mm, len >> PAGE_SHIFT))
 		return -ENOMEM;
 
-	/* Can we just expand an old private anonymous mapping? */
-	vma = vma_merge(mm, prev, addr, addr + len, flags,
-			NULL, NULL, pgoff, NULL, NULL_VM_UFFD_CTX);
-	if (vma)
-		goto out;
+	mas->last = addr + len - 1;
+	if (*brkvma) {
+		vma = *brkvma;
+		/* Expand the existing vma if possible; almost never a singular
+		 * list, so this will almost always fail. */
 
-	/*
-	 * create a vma struct for an anonymous mapping
-	 */
-	vma = vm_area_alloc(mm);
-	if (!vma) {
-		vm_unacct_memory(len >> PAGE_SHIFT);
-		return -ENOMEM;
+		if ((!vma->anon_vma ||
+		     list_is_singular(&vma->anon_vma_chain)) &&
+		     ((vma->vm_flags & ~VM_SOFTDIRTY) == flags)){
+			mas->index = vma->vm_start;
+
+			vma_adjust_trans_huge(vma, addr, addr + len, 0);
+			if (vma->anon_vma) {
+				anon_vma_lock_write(vma->anon_vma);
+				anon_vma_interval_tree_pre_update_vma(vma);
+			}
+			vma->vm_end = addr + len;
+			vma->vm_flags |= VM_SOFTDIRTY;
+			if (mas_store_gfp(mas, vma, GFP_KERNEL))
+				goto mas_mod_fail;
+
+			if (vma->anon_vma) {
+				anon_vma_interval_tree_post_update_vma(vma);
+				anon_vma_unlock_write(vma->anon_vma);
+			}
+			khugepaged_enter_vma_merge(vma, flags);
+			goto out;
+		}
+		prev = vma;
 	}
+	mas->index = addr;
+	mas_walk(mas);
+
+	/* create a vma struct for an anonymous mapping */
+	vma = vm_area_alloc(mm);
+	if (!vma)
+		goto vma_alloc_fail;
 
 	vma_set_anonymous(vma);
 	vma->vm_start = addr;
 	vma->vm_end = addr + len;
-	vma->vm_pgoff = pgoff;
+	vma->vm_pgoff = addr >> PAGE_SHIFT;
 	vma->vm_flags = flags;
 	vma->vm_page_prot = vm_get_page_prot(flags);
-	vma_link(mm, vma, prev);
+	if (vma_mas_store(vma, mas))
+		goto mas_store_fail;
+
+	if (!prev)
+		prev = mas_prev(mas, 0);
+
+	__vma_link_list(mm, vma, prev);
+	mm->map_count++;
+	*brkvma = vma;
 out:
 	perf_event_mmap(vma);
 	mm->total_vm += len >> PAGE_SHIFT;
@@ -2821,15 +2963,31 @@ static int do_brk_flags(unsigned long addr, unsigned long len,
 	vma->vm_flags |= VM_SOFTDIRTY;
 	validate_mm_mt(mm);
 	return 0;
+
+mas_store_fail:
+	vm_area_free(vma);
+vma_alloc_fail:
+	vm_unacct_memory(len >> PAGE_SHIFT);
+	return -ENOMEM;
+
+mas_mod_fail:
+	vma->vm_end = addr;
+	if (vma->anon_vma) {
+		anon_vma_interval_tree_post_update_vma(vma);
+		anon_vma_unlock_write(vma->anon_vma);
+	}
+	return -ENOMEM;
+
 }
 
 int vm_brk_flags(unsigned long addr, unsigned long request, unsigned long flags)
 {
 	struct mm_struct *mm = current->mm;
+	struct vm_area_struct *vma = NULL;
 	unsigned long len;
 	int ret;
 	bool populate;
-	LIST_HEAD(uf);
+	MA_STATE(mas, &mm->mm_mt, addr, addr);
 
 	len = PAGE_ALIGN(request);
 	if (len < request)
@@ -2840,10 +2998,11 @@ int vm_brk_flags(unsigned long addr, unsigned long request, unsigned long flags)
 	if (mmap_write_lock_killable(mm))
 		return -EINTR;
 
-	ret = do_brk_flags(addr, len, flags, &uf);
+	// This vma left intentionally blank.
+	mas_walk(&mas);
+	ret = do_brk_flags(&mas, &vma, addr, len, flags);
 	populate = ((mm->def_flags & VM_LOCKED) != 0);
 	mmap_write_unlock(mm);
-	userfaultfd_unmap_complete(mm, &uf);
 	if (populate && !ret)
 		mm_populate(addr, len);
 	return ret;
-- 
2.30.2

  parent reply	other threads:[~2021-04-28 15:42 UTC|newest]

Thread overview: 136+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2021-04-28 15:35 [PATCH 00/94] Introducing the Maple Tree Liam Howlett
2021-04-28 15:35 ` [PATCH 01/94] mm: Add vma_lookup() Liam Howlett
2021-05-01  5:04   ` Michel Lespinasse
2021-05-03 16:08     ` Liam Howlett
2021-04-28 15:35 ` [PATCH 02/94] drm/i915/selftests: Use vma_lookup() in __igt_mmap() Liam Howlett
2021-04-28 15:35 ` [PATCH 03/94] arch/arc/kernel/troubleshoot: use vma_lookup() instead of find_vma_intersection() Liam Howlett
2021-04-28 15:35 ` [PATCH 04/94] arch/arm64/kvm: Use " Liam Howlett
2021-04-28 15:35 ` [PATCH 05/94] arch/powerpc/kvm/book3s_hv_uvmem: " Liam Howlett
2021-04-28 15:35 ` [PATCH 06/94] arch/powerpc/kvm/book3s: Use vma_lookup() in kvmppc_hv_setup_htab_rma() Liam Howlett
2021-04-28 15:35 ` [PATCH 08/94] x86/sgx: Use vma_lookup() in sgx_encl_find() Liam Howlett
2021-04-28 15:35 ` [PATCH 07/94] arch/mips/kernel/traps: Use vma_lookup() instead of find_vma_intersection() Liam Howlett
2021-04-28 15:35 ` [PATCH 09/94] virt/kvm: " Liam Howlett
2021-04-28 15:35 ` [PATCH 10/94] vfio: " Liam Howlett
2021-04-28 15:35 ` [PATCH 12/94] drm/amdgpu: Use vma_lookup() in amdgpu_ttm_tt_get_user_pages() Liam Howlett
2021-04-28 15:35 ` [PATCH 11/94] net/ipv5/tcp: Use vma_lookup() in tcp_zerocopy_receive() Liam Howlett
2021-04-28 15:35 ` [PATCH 15/94] kernel/events/uprobes: Use vma_lookup() in find_active_uprobe() Liam Howlett
2021-04-28 15:35 ` [PATCH 14/94] misc/sgi-gru/grufault: Use vma_lookup() in gru_find_vma() Liam Howlett
2021-04-28 15:35 ` [PATCH 13/94] media: videobuf2: Use vma_lookup() in get_vaddr_frames() Liam Howlett
2021-04-28 15:35 ` [PATCH 16/94] lib/test_hmm: Use vma_lookup() in dmirror_migrate() Liam Howlett
2021-04-28 15:35 ` [PATCH 18/94] mm/migrate: Use vma_lookup() in do_pages_stat_array() Liam Howlett
2021-04-28 15:35 ` [PATCH 17/94] mm/ksm: Use vma_lookup() in find_mergeable_vma() Liam Howlett
2021-04-28 15:35 ` [PATCH 19/94] mm/mremap: Use vma_lookup() in vma_to_resize() Liam Howlett
2021-04-28 15:35 ` [PATCH 20/94] mm/memory.c: Use vma_lookup() instead of find_vma_intersection() Liam Howlett
2021-04-28 15:35 ` [PATCH 21/94] radix tree test suite: Enhancements for Maple Tree Liam Howlett
2021-05-28 17:30   ` Suren Baghdasaryan
2021-05-28 18:54     ` Liam Howlett
2021-04-28 15:35 ` [PATCH 23/94] radix tree test suite: Add support for kmem_cache_free_bulk Liam Howlett
2021-05-28 17:55   ` Suren Baghdasaryan
2021-05-28 19:07     ` Liam Howlett
2021-04-28 15:35 ` [PATCH 22/94] radix tree test suite: Add support for fallthrough attribute Liam Howlett
2021-04-28 15:35 ` [PATCH 24/94] radix tree test suite: Add keme_cache_alloc_bulk() support Liam Howlett
2021-05-28 18:17   ` Suren Baghdasaryan
2021-05-28 19:28     ` Liam Howlett
2021-04-28 15:35 ` [PATCH 25/94] radix tree test suite: Add __must_be_array() support Liam Howlett
2021-04-28 15:36 ` [PATCH 26/94] Maple Tree: Add new data structure Liam Howlett
2021-05-14 10:40   ` Peter Zijlstra
2021-05-14 20:36     ` Liam Howlett
2021-05-14 10:56   ` Peter Zijlstra
2021-05-14 20:45     ` Liam Howlett
2021-05-14 11:13   ` Peter Zijlstra
2021-05-14 11:27     ` Peter Zijlstra
2021-05-14 21:23       ` Liam Howlett
2021-05-14 11:20   ` Peter Zijlstra
2021-05-14 20:46     ` Liam Howlett
2021-05-14 11:54   ` Peter Zijlstra
2021-05-14 21:25     ` Liam Howlett
2021-05-14 12:17   ` Peter Zijlstra
2021-05-14 12:43     ` Matthew Wilcox
2021-05-14 21:29     ` Liam Howlett
2021-05-14 13:42   ` Peter Zijlstra
2021-05-14 21:42     ` Liam Howlett
2021-05-14 15:32   ` Peter Zijlstra
2021-05-14 15:34     ` Peter Zijlstra
2021-05-14 21:57       ` Liam Howlett
2021-05-14 21:43     ` Liam Howlett
2021-05-14 15:40   ` Peter Zijlstra
2021-05-15  0:02     ` Liam Howlett
2021-04-28 15:36 ` [PATCH 28/94] mm/mmap: Introduce unlock_range() for code cleanup Liam Howlett
2021-04-28 15:36 ` [PATCH 27/94] mm: Start tracking VMAs with maple tree Liam Howlett
2021-04-28 15:36 ` [PATCH 30/94] mm/mmap: Change find_vma_prev() to use " Liam Howlett
2021-04-28 15:36 ` [PATCH 29/94] mm/mmap: Change find_vma() to use the " Liam Howlett
2021-04-28 15:36 ` [PATCH 32/94] kernel/fork: Convert dup_mmap to use " Liam Howlett
2021-05-29  0:42   ` Suren Baghdasaryan
2021-05-31 13:39     ` Liam Howlett
2021-04-28 15:36 ` [PATCH 31/94] mm/mmap: Change unmapped_area and unmapped_area_topdown " Liam Howlett
2021-04-28 15:36 ` [PATCH 33/94] mm: Remove rb tree Liam Howlett
2021-05-29  1:26   ` Suren Baghdasaryan
2021-05-31 13:42     ` Liam Howlett
2021-04-28 15:36 ` [PATCH 35/94] xen/privcmd: Optimized privcmd_ioctl_mmap() by using vma_lookup() Liam Howlett
2021-04-28 15:36 ` [PATCH 34/94] arch/m68k/kernel/sys_m68k: Use vma_lookup() in sys_cacheflush() Liam Howlett
2021-04-28 15:36 ` [PATCH 37/94] mm/khugepaged: Optimize collapse_pte_mapped_thp() by using vma_lookup() Liam Howlett
2021-04-28 15:36 ` [PATCH 36/94] mm: Optimize find_exact_vma() to use vma_lookup() Liam Howlett
2021-04-28 15:36 ` [PATCH 38/94] mm/gup: Add mm_populate_vma() for use when the vma is known Liam Howlett
2021-05-01  5:13   ` Michel Lespinasse
2021-05-03 15:53     ` Liam Howlett
2021-05-03 16:00       ` Matthew Wilcox
2021-05-03 23:01         ` Liam Howlett
2021-04-28 15:36 ` Liam Howlett [this message]
2021-04-28 15:36 ` [PATCH 40/94] mm/mmap: Change vm_brk_flags() to use mm_populate_vma() Liam Howlett
2021-04-28 15:36 ` [PATCH 41/94] mm: Change find_vma_intersection() to maple tree and make find_vma() to inline Liam Howlett
2021-04-28 15:36 ` [PATCH 44/94] mm: Remove vmacache Liam Howlett
2021-04-28 15:36 ` [PATCH 43/94] mm/mmap: Drop munmap_vma_range() Liam Howlett
2021-04-28 15:36 ` [PATCH 42/94] mm/mmap: Change mmap_region() to use maple tree state Liam Howlett
2021-04-28 15:36 ` [PATCH 45/94] mm/mmap: Change __do_munmap() to avoid unnecessary lookups Liam Howlett
2021-04-28 15:36 ` [PATCH 46/94] mm/mmap: Move mmap_region() below do_munmap() Liam Howlett
2021-04-28 15:36 ` [PATCH 47/94] mm/mmap: Add do_mas_munmap() and wraper for __do_munmap() Liam Howlett
2021-04-28 15:36 ` [PATCH 48/94] mmap: Use find_vma_intersection in do_mmap() for overlap Liam Howlett
2021-04-28 15:36 ` [PATCH 49/94] mmap: Remove __do_munmap() in favour of do_mas_munmap() Liam Howlett
2021-04-28 15:36 ` [PATCH 50/94] mm/mmap: Change do_brk_munmap() to use do_mas_align_munmap() Liam Howlett
2021-04-28 15:36 ` [PATCH 51/94] mmap: make remove_vma_list() inline Liam Howlett
2021-04-28 15:36 ` [PATCH 52/94] mm: Introduce vma_next() and vma_prev() Liam Howlett
2021-04-28 15:36 ` [PATCH 53/94] arch/arm64: Remove mmap linked list from vdso Liam Howlett
2021-04-28 15:36 ` [PATCH 54/94] arch/parisc: Remove mmap linked list from kernel/cache Liam Howlett
2021-04-28 15:36 ` [PATCH 55/94] arch/powerpc: Remove mmap linked list from mm/book3s32/tlb Liam Howlett
2021-04-28 15:36 ` [PATCH 56/94] arch/powerpc: Remove mmap linked list from mm/book3s64/subpage_prot Liam Howlett
2021-04-28 15:36 ` [PATCH 57/94] arch/s390: Use maple tree iterators instead of linked list Liam Howlett
2021-04-28 15:36 ` [PATCH 58/94] arch/x86: Use maple tree iterators for vdso/vma Liam Howlett
2021-04-28 15:36 ` [PATCH 59/94] arch/xtensa: Use maple tree iterators for unmapped area Liam Howlett
2021-04-28 15:36 ` [PATCH 60/94] drivers/misc/cxl: Use maple tree iterators for cxl_prefault_vma() Liam Howlett
2021-04-28 15:36 ` [PATCH 61/94] drivers/tee/optee: Use maple tree iterators for __check_mem_type() Liam Howlett
2021-04-28 15:36 ` [PATCH 63/94] fs/coredump: Use maple tree iterators in place of linked list Liam Howlett
2021-04-28 15:36 ` [PATCH 62/94] fs/binfmt_elf: Use maple tree iterators for fill_files_note() Liam Howlett
2021-04-28 15:36 ` [PATCH 64/94] fs/exec: Use vma_next() instead of linked list Liam Howlett
2021-04-28 15:36 ` [PATCH 65/94] fs/proc/base: Use maple tree iterators in place " Liam Howlett
2021-04-28 15:36 ` [PATCH 66/94] fs/proc/task_mmu: Stop using linked list and highest_vm_end Liam Howlett
2021-04-28 15:36 ` [PATCH 67/94] fs/userfaultfd: Stop using vma linked list Liam Howlett
2021-04-28 15:36 ` [PATCH 68/94] ipc/shm: Stop using the " Liam Howlett
2021-04-28 15:36 ` [PATCH 69/94] kernel/acct: Use maple tree iterators instead of " Liam Howlett
2021-04-28 15:36 ` [PATCH 70/94] kernel/events/core: " Liam Howlett
2021-04-28 15:36 ` [PATCH 71/94] kernel/events/uprobes: " Liam Howlett
2021-04-28 15:36 ` [PATCH 73/94] kernel/sys: " Liam Howlett
2021-04-28 15:36 ` [PATCH 72/94] kernel/sched/fair: " Liam Howlett
2021-04-28 15:36 ` [PATCH 75/94] mm/huge_memory: Use vma_next() instead of vma " Liam Howlett
2021-04-28 15:36 ` [PATCH 76/94] mm/khugepaged: Use maple tree iterators " Liam Howlett
2021-04-28 15:36 ` [PATCH 74/94] mm/gup: Use maple tree navigation instead of " Liam Howlett
2021-04-28 15:36 ` [PATCH 77/94] mm/ksm: Use maple tree iterators instead of vma " Liam Howlett
2021-04-28 15:36 ` [PATCH 78/94] mm/madvise: Use vma_next " Liam Howlett
2021-04-28 15:36 ` [PATCH 79/94] mm/memcontrol: Stop using mm->highest_vm_end Liam Howlett
2021-04-28 15:36 ` [PATCH 81/94] mm/mlock: Use maple tree iterators instead of vma linked list Liam Howlett
2021-04-28 15:36 ` [PATCH 80/94] mm/mempolicy: " Liam Howlett
2021-04-28 15:36 ` [PATCH 82/94] mm/mprotect: Use maple tree navigation " Liam Howlett
2021-04-28 15:36 ` [PATCH 84/94] mm/msync: Use vma_next() " Liam Howlett
2021-04-28 15:36 ` [PATCH 83/94] mm/mremap: " Liam Howlett
2021-04-28 15:36 ` [PATCH 86/94] mm/pagewalk: " Liam Howlett
2021-04-28 15:36 ` [PATCH 85/94] mm/oom_kill: Use maple tree iterators " Liam Howlett
2021-04-28 15:36 ` [PATCH 87/94] mm/swapfile: Use maple tree iterator " Liam Howlett
2021-04-28 15:36 ` [PATCH 88/94] mm/util: Remove __vma_link_list() and __vma_unlink_list() Liam Howlett
2021-04-28 15:36 ` [PATCH 89/94] arch/um/kernel/tlb: Stop using linked list Liam Howlett
2021-04-28 15:36 ` [PATCH 90/94] bpf: Remove VMA " Liam Howlett
2021-04-28 15:36 ` [PATCH 91/94] mm: Remove vma " Liam Howlett
2021-04-28 15:36 ` [PATCH 92/94] mm: Return a bool from anon_vma_interval_tree_verify() Liam Howlett
2021-04-28 15:36 ` [PATCH 94/94] mm: Move mas locking outside of munmap() path Liam Howlett
2021-05-01  6:13   ` Michel Lespinasse
2021-05-03 16:05     ` Liam Howlett
2021-04-28 15:36 ` [PATCH 93/94] mm/mmap: Add mas_split_vma() and use it for munmap() Liam Howlett
     [not found] ` <20210504042930.10436-1-hdanton@sina.com>
2021-05-04 14:05   ` [PATCH 76/94] mm/khugepaged: Use maple tree iterators instead of vma Liam Howlett

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20210428153542.2814175-40-Liam.Howlett@Oracle.com \
    --to=liam.howlett@oracle.com \
    --cc=akpm@linux-foundation.org \
    --cc=axelrasmussen@google.com \
    --cc=dave@stgolabs.net \
    --cc=ldufour@linux.ibm.com \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-mm@kvack.org \
    --cc=maple-tree@lists.infradead.org \
    --cc=paulmck@kernel.org \
    --cc=peterz@infradead.org \
    --cc=riel@surriel.com \
    --cc=rientjes@google.com \
    --cc=songliubraving@fb.com \
    --cc=surenb@google.com \
    --cc=vbabka@suse.cz \
    --cc=walken.cr@gmail.com \
    --cc=willy@infradead.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).