mm/madvise: don't perform madvise VMA walk for MADV_POPULATE_(READ|WRITE)

We changed faultin_page_range() to no longer consume a VMA, because
faultin_page_range() might internally release the mm lock to lookup
the VMA again -- required to cleanly handle VM_FAULT_RETRY. But
independent of that, __get_user_pages() will always lookup the VMA
itself.

Now that we let __get_user_pages() just handle VMA checks in a way that
is suitable for MADV_POPULATE_(READ|WRITE), the VMA walk in madvise()
is just overhead. So let's just call madvise_populate()
on the full range instead.

There is one change in behavior: madvise_walk_vmas() would skip any VMA
holes, and if everything succeeded, it would return -ENOMEM after
processing all VMAs.

However, for MADV_POPULATE_(READ|WRITE) it's unlikely for the caller to
notice any difference: -ENOMEM might either indicate that there were VMA
holes or that populating page tables failed because there was not enough
memory. So it's unlikely that user space will notice the difference, and
that special handling likely only makes sense for some other madvise()
actions.

Further, we'd already fail with -ENOMEM early in the past if looking up the
VMA after dropping the MM lock failed because of concurrent VMA
modifications. So let's just keep it simple and avoid the madvise VMA
walk, and consistently fail early if we find a VMA hole.

Link: https://lkml.kernel.org/r/20240314161300.382526-3-david@redhat.com
Signed-off-by: David Hildenbrand <david@redhat.com>
Cc: Darrick J. Wong <djwong@kernel.org>
Cc: Hugh Dickins <hughd@google.com>
Cc: Jason Gunthorpe <jgg@nvidia.com>
Cc: John Hubbard <jhubbard@nvidia.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/mm/madvise.c b/mm/madvise.c
index 1a073fcc4c0c021496667619a20f6ee1afaef7c0..a2dd70c4a2e6b15fa9815f8c0b582367b61e1da0 100644 (file)
--- a/mm/madvise.c
+++ b/mm/madvise.c
@@ -901,26 +901,19 @@ static long madvise_dontneed_free(struct vm_area_struct *vma,
                return -EINVAL;
 }
 
-static long madvise_populate(struct vm_area_struct *vma,
-                            struct vm_area_struct **prev,
-                            unsigned long start, unsigned long end,
-                            int behavior)
+static long madvise_populate(struct mm_struct *mm, unsigned long start,
+               unsigned long end, int behavior)
 {
        const bool write = behavior == MADV_POPULATE_WRITE;
-       struct mm_struct *mm = vma->vm_mm;
        int locked = 1;
        long pages;
 
-       *prev = vma;
-
        while (start < end) {
                /* Populate (prefault) page tables readable/writable. */
                pages = faultin_page_range(mm, start, end, write, &locked);
                if (!locked) {
                        mmap_read_lock(mm);
                        locked = 1;
-                       *prev = NULL;
-                       vma = NULL;
                }
                if (pages < 0) {
                        switch (pages) {
@@ -1021,9 +1014,6 @@ static int madvise_vma_behavior(struct vm_area_struct *vma,
        case MADV_DONTNEED:
        case MADV_DONTNEED_LOCKED:
                return madvise_dontneed_free(vma, prev, start, end, behavior);
-       case MADV_POPULATE_READ:
-       case MADV_POPULATE_WRITE:
-               return madvise_populate(vma, prev, start, end, behavior);
        case MADV_NORMAL:
                new_flags = new_flags & ~VM_RAND_READ & ~VM_SEQ_READ;
                break;
@@ -1425,8 +1415,16 @@ int do_madvise(struct mm_struct *mm, unsigned long start, size_t len_in, int beh
        end = start + len;
 
        blk_start_plug(&plug);
-       error = madvise_walk_vmas(mm, start, end, behavior,
-                       madvise_vma_behavior);
+       switch (behavior) {
+       case MADV_POPULATE_READ:
+       case MADV_POPULATE_WRITE:
+               error = madvise_populate(mm, start, end, behavior);
+               break;
+       default:
+               error = madvise_walk_vmas(mm, start, end, behavior,
+                                         madvise_vma_behavior);
+               break;
+       }
        blk_finish_plug(&plug);
        if (write)
                mmap_write_unlock(mm);