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 31/94] mm/mmap: Change unmapped_area and unmapped_area_topdown to use maple tree
Date: Wed, 28 Apr 2021 15:36:05 +0000	[thread overview]
Message-ID: <20210428153542.2814175-32-Liam.Howlett@Oracle.com> (raw)
In-Reply-To: <20210428153542.2814175-1-Liam.Howlett@Oracle.com>

Use the new maple tree data structure to find an unmapped area.

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

diff --git a/mm/mmap.c b/mm/mmap.c
index 0fc81b02935f..929c2f9eb3f5 100644
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -2049,260 +2049,61 @@ unsigned long mmap_region(struct file *file, unsigned long addr,
 	return error;
 }
 
+/* unmapped_area() Find an area between the low_limit and the high_limit with
+ * the correct alignment and offset, all from @info. Note: current->mm is used
+ * for the search.
+ *
+ * @info: The unmapped area information including the range (low_limit -
+ * hight_limit), the alignment offset and mask.
+ *
+ * Return: A memory address or -ENOMEM.
+ */
 static unsigned long unmapped_area(struct vm_unmapped_area_info *info)
 {
-	/*
-	 * We implement the search by looking for an rbtree node that
-	 * immediately follows a suitable gap. That is,
-	 * - gap_start = vma->vm_prev->vm_end <= info->high_limit - length;
-	 * - gap_end   = vma->vm_start        >= info->low_limit  + length;
-	 * - gap_end - gap_start >= length
-	 */
+	unsigned long length, gap;
 
-	struct mm_struct *mm = current->mm;
-	struct vm_area_struct *vma;
-	unsigned long length, low_limit, high_limit, gap_start, gap_end;
-	unsigned long gap;
-	MA_STATE(mas, &mm->mm_mt, 0, 0);
+	MA_STATE(mas, &current->mm->mm_mt, 0, 0);
 
 	/* Adjust search length to account for worst case alignment overhead */
 	length = info->length + info->align_mask;
 	if (length < info->length)
 		return -ENOMEM;
 
-	rcu_read_lock();
-	mas_empty_area_rev(&mas, info->low_limit, info->high_limit - 1,
-			   length);
-	rcu_read_unlock();
-	gap = mas.index;
-	gap += (info->align_offset - gap) & info->align_mask;
-
-	/* Adjust search limits by the desired length */
-	if (info->high_limit < length)
-		return -ENOMEM;
-	high_limit = info->high_limit - length;
-
-	if (info->low_limit > high_limit)
+	if (mas_empty_area(&mas, info->low_limit, info->high_limit - 1,
+				  length)) {
 		return -ENOMEM;
-	low_limit = info->low_limit + length;
-
-	/* Check if rbtree root looks promising */
-	if (RB_EMPTY_ROOT(&mm->mm_rb))
-		goto check_highest;
-	vma = rb_entry(mm->mm_rb.rb_node, struct vm_area_struct, vm_rb);
-	if (vma->rb_subtree_gap < length)
-		goto check_highest;
-
-	while (true) {
-		/* Visit left subtree if it looks promising */
-		gap_end = vm_start_gap(vma);
-		if (gap_end >= low_limit && vma->vm_rb.rb_left) {
-			struct vm_area_struct *left =
-				rb_entry(vma->vm_rb.rb_left,
-					 struct vm_area_struct, vm_rb);
-			if (left->rb_subtree_gap >= length) {
-				vma = left;
-				continue;
-			}
-		}
-
-		gap_start = vma->vm_prev ? vm_end_gap(vma->vm_prev) : 0;
-check_current:
-		/* Check if current node has a suitable gap */
-		if (gap_start > high_limit)
-			return -ENOMEM;
-		if (gap_end >= low_limit &&
-		    gap_end > gap_start && gap_end - gap_start >= length)
-			goto found;
-
-		/* Visit right subtree if it looks promising */
-		if (vma->vm_rb.rb_right) {
-			struct vm_area_struct *right =
-				rb_entry(vma->vm_rb.rb_right,
-					 struct vm_area_struct, vm_rb);
-			if (right->rb_subtree_gap >= length) {
-				vma = right;
-				continue;
-			}
-		}
-
-		/* Go back up the rbtree to find next candidate node */
-		while (true) {
-			struct rb_node *prev = &vma->vm_rb;
-			if (!rb_parent(prev))
-				goto check_highest;
-			vma = rb_entry(rb_parent(prev),
-				       struct vm_area_struct, vm_rb);
-			if (prev == vma->vm_rb.rb_left) {
-				gap_start = vm_end_gap(vma->vm_prev);
-				gap_end = vm_start_gap(vma);
-				goto check_current;
-			}
-		}
 	}
-
-check_highest:
-	/* Check highest gap, which does not precede any rbtree node */
-	gap_start = mm->highest_vm_end;
-	gap_end = ULONG_MAX;  /* Only for VM_BUG_ON below */
-	if (gap_start > high_limit)
-		return -ENOMEM;
-
-found:
-	/* We found a suitable gap. Clip it with the original low_limit. */
-	if (gap_start < info->low_limit)
-		gap_start = info->low_limit;
-
-	/* Adjust gap address to the desired alignment */
-	gap_start += (info->align_offset - gap_start) & info->align_mask;
-
-	VM_BUG_ON(gap_start + info->length > info->high_limit);
-	VM_BUG_ON(gap_start + info->length > gap_end);
-
-	VM_BUG_ON(gap != gap_start);
-	return gap_start;
-}
-
-static inline unsigned long top_area_aligned(struct vm_unmapped_area_info *info,
-					     unsigned long end)
-{
-	return (end - info->length - info->align_offset) & (~info->align_mask);
+	gap = mas.index;
+	gap += (info->align_offset - gap) & info->align_mask;
+	return gap;
 }
 
+/* unmapped_area_topdown() Find an area between the low_limit and the
+ * high_limit with * the correct alignment and offset at the highest available
+ * address, all from * @info. Note: current->mm is used for the search.
+ *
+ * @info: The unmapped area information including the range (low_limit -
+ * hight_limit), the alignment offset and mask.
+ *
+ * Return: A memory address or -ENOMEM.
+ */
 static unsigned long unmapped_area_topdown(struct vm_unmapped_area_info *info)
 {
-	struct mm_struct *mm = current->mm;
-	struct vm_area_struct *vma = NULL;
-	unsigned long length, low_limit, high_limit, gap_start, gap_end;
-	unsigned long gap;
-
-	MA_STATE(mas, &mm->mm_mt, 0, 0);
-	validate_mm_mt(mm);
+	unsigned long length, gap;
 
+	MA_STATE(mas, &current->mm->mm_mt, 0, 0);
 	/* Adjust search length to account for worst case alignment overhead */
 	length = info->length + info->align_mask;
 	if (length < info->length)
 		return -ENOMEM;
 
-	rcu_read_lock();
-	mas_empty_area_rev(&mas, info->low_limit, info->high_limit - 1,
-		   length);
-	rcu_read_unlock();
-	gap = (mas.index + info->align_mask) & ~info->align_mask;
-	gap -= info->align_offset & info->align_mask;
-
-	/*
-	 * Adjust search limits by the desired length.
-	 * See implementation comment at top of unmapped_area().
-	 */
-	gap_end = info->high_limit;
-	if (gap_end < length)
+	if (mas_empty_area_rev(&mas, info->low_limit, info->high_limit - 1,
+				length)) {
 		return -ENOMEM;
-	high_limit = gap_end - length;
-
-	if (info->low_limit > high_limit)
-		return -ENOMEM;
-	low_limit = info->low_limit + length;
-
-	/* Check highest gap, which does not precede any rbtree node */
-	gap_start = mm->highest_vm_end;
-	if (gap_start <= high_limit)
-		goto found_highest;
-
-	/* Check if rbtree root looks promising */
-	if (RB_EMPTY_ROOT(&mm->mm_rb))
-		return -ENOMEM;
-	vma = rb_entry(mm->mm_rb.rb_node, struct vm_area_struct, vm_rb);
-	if (vma->rb_subtree_gap < length)
-		return -ENOMEM;
-
-	while (true) {
-		/* Visit right subtree if it looks promising */
-		gap_start = vma->vm_prev ? vm_end_gap(vma->vm_prev) : 0;
-		if (gap_start <= high_limit && vma->vm_rb.rb_right) {
-			struct vm_area_struct *right =
-				rb_entry(vma->vm_rb.rb_right,
-					 struct vm_area_struct, vm_rb);
-			if (right->rb_subtree_gap >= length) {
-				vma = right;
-				continue;
-			}
-		}
-
-check_current:
-		/* Check if current node has a suitable gap */
-		gap_end = vm_start_gap(vma);
-		if (gap_end < low_limit)
-			return -ENOMEM;
-		if (gap_start <= high_limit &&
-		    gap_end > gap_start && gap_end - gap_start >= length)
-			goto found;
-
-		/* Visit left subtree if it looks promising */
-		if (vma->vm_rb.rb_left) {
-			struct vm_area_struct *left =
-				rb_entry(vma->vm_rb.rb_left,
-					 struct vm_area_struct, vm_rb);
-			if (left->rb_subtree_gap >= length) {
-				vma = left;
-				continue;
-			}
-		}
-
-		/* Go back up the rbtree to find next candidate node */
-		while (true) {
-			struct rb_node *prev = &vma->vm_rb;
-			if (!rb_parent(prev))
-				return -ENOMEM;
-			vma = rb_entry(rb_parent(prev),
-				       struct vm_area_struct, vm_rb);
-			if (prev == vma->vm_rb.rb_right) {
-				gap_start = vma->vm_prev ?
-					vm_end_gap(vma->vm_prev) : 0;
-				goto check_current;
-			}
-		}
 	}
-
-found:
-	/* We found a suitable gap. Clip it with the original high_limit. */
-	if (gap_end > info->high_limit)
-		gap_end = info->high_limit;
-
-found_highest:
-	/* Compute highest gap address at the desired alignment */
-	gap_end -= info->length;
-	gap_end -= (gap_end - info->align_offset) & info->align_mask;
-
-	VM_BUG_ON(gap_end < info->low_limit);
-	VM_BUG_ON(gap_end < gap_start);
-
-	if (gap != gap_end) {
-		pr_err("%s: %px Gap was found: mt %lu gap_end %lu\n", __func__,
-		       mm, gap, gap_end);
-		pr_err("window was %lu - %lu size %lu\n", info->high_limit,
-		       info->low_limit, length);
-		pr_err("mas.min %lu max %lu mas.last %lu\n", mas.min, mas.max,
-		       mas.last);
-		pr_err("mas.index %lu align mask %lu offset %lu\n", mas.index,
-		       info->align_mask, info->align_offset);
-		pr_err("rb_find_vma find on %lu => %px (%px)\n", mas.index,
-		       find_vma(mm, mas.index), vma);
-#if defined(CONFIG_DEBUG_MAPLE_TREE)
-		mt_dump(&mm->mm_mt);
-#endif
-		{
-			struct vm_area_struct *dv = mm->mmap;
-
-			while (dv) {
-				printk("vma %px %lu-%lu\n", dv, dv->vm_start, dv->vm_end);
-				dv = dv->vm_next;
-			}
-		}
-		VM_BUG_ON(gap != gap_end);
-	}
-
-	return gap_end;
+	gap = (mas.index + info->align_mask) & ~info->align_mask;
+	gap -= info->align_offset & info->align_mask;
+	return gap;
 }
 
 /*
-- 
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 ` Liam Howlett [this message]
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 ` [PATCH 39/94] mm/mmap: Change do_brk_flags() to expand existing VMA and add do_brk_munmap() Liam Howlett
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-32-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).