[PATCH 03/13] mm: convert __get_unmapped_area() to use vma_flags_t

[Lorenzo Stoakes <ljs@xxxxxxxxxx>]

Update __get_unmapped_area() to be parameterised by vma_flags_t rather than
vm_flags_t as part of the effort to move VMA flags from a system word to a
bitmap.

We cascade the changes up to arch_get_unmapped_area_topdown() and
arch_get_unmapped_area(), where, for now, we use vma_flags_to_legacy() in
order to propagate the VMA flags.

No functional change intended.

Signed-off-by: Lorenzo Stoakes <ljs@xxxxxxxxxx>
---
 fs/hugetlbfs/inode.c     |  3 ++-
 include/linux/huge_mm.h  | 10 +++++-----
 include/linux/mm.h       |  6 ++++--
 include/linux/sched/mm.h | 12 ++++++------
 mm/huge_memory.c         | 21 ++++++++++++---------
 mm/mmap.c                | 27 ++++++++++++++-------------
 6 files changed, 43 insertions(+), 36 deletions(-)

diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 894d02e73302..fe7d5a5d60bd 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -184,7 +184,8 @@ hugetlb_get_unmapped_area(struct file *file, unsigned long 
addr,
        if (addr)
                addr0 = ALIGN(addr, huge_page_size(h));
 
-       return mm_get_unmapped_area_vmflags(file, addr0, len, pgoff, flags, 0);
+       return mm_get_unmapped_area_vmaflags(file, addr0, len, pgoff, flags,
+                                            EMPTY_VMA_FLAGS);
 }
 
 /*
diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h
index 653b81d08fe7..ae84a714907f 100644
--- a/include/linux/huge_mm.h
+++ b/include/linux/huge_mm.h
@@ -391,9 +391,9 @@ static inline bool thp_disabled_by_hw(void)
 
 unsigned long thp_get_unmapped_area(struct file *filp, unsigned long addr,
                unsigned long len, unsigned long pgoff, unsigned long flags);
-unsigned long thp_get_unmapped_area_vmflags(struct file *filp, unsigned long 
addr,
+unsigned long thp_get_unmapped_area_vmaflags(struct file *filp, unsigned long 
addr,
                unsigned long len, unsigned long pgoff, unsigned long flags,
-               vm_flags_t vm_flags);
+               vma_flags_t vma_flags);
 
 enum split_type {
        SPLIT_TYPE_UNIFORM,
@@ -615,9 +615,9 @@ static inline unsigned long thp_vma_allowable_orders(struct 
vm_area_struct *vma,
 #define thp_get_unmapped_area  NULL
 
 static inline unsigned long
-thp_get_unmapped_area_vmflags(struct file *filp, unsigned long addr,
-                             unsigned long len, unsigned long pgoff,
-                             unsigned long flags, vm_flags_t vm_flags)
+thp_get_unmapped_area_vmaflags(struct file *filp, unsigned long addr,
+                              unsigned long len, unsigned long pgoff,
+                              unsigned long flags, vma_flags_t vma_flags)
 {
        return 0;
 }
diff --git a/include/linux/mm.h b/include/linux/mm.h
index cc2a87755adb..474b3698f565 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -4160,13 +4160,15 @@ unsigned long randomize_page(unsigned long start, 
unsigned long range);
 
 unsigned long
 __get_unmapped_area(struct file *file, unsigned long addr, unsigned long len,
-                   unsigned long pgoff, unsigned long flags, vm_flags_t 
vm_flags);
+                   unsigned long pgoff, unsigned long flags,
+                   vma_flags_t vma_flags);
 
 static inline unsigned long
 get_unmapped_area(struct file *file, unsigned long addr, unsigned long len,
                  unsigned long pgoff, unsigned long flags)
 {
-       return __get_unmapped_area(file, addr, len, pgoff, flags, 0);
+       return __get_unmapped_area(file, addr, len, pgoff, flags,
+                                  EMPTY_VMA_FLAGS);
 }
 
 unsigned long do_mmap(struct file *file, unsigned long addr,
diff --git a/include/linux/sched/mm.h b/include/linux/sched/mm.h
index 95d0040df584..b301ec90740a 100644
--- a/include/linux/sched/mm.h
+++ b/include/linux/sched/mm.h
@@ -193,12 +193,12 @@ unsigned long mm_get_unmapped_area(struct file *filp, 
unsigned long addr,
                                   unsigned long len, unsigned long pgoff,
                                   unsigned long flags);
 
-unsigned long mm_get_unmapped_area_vmflags(struct file *filp,
-                                          unsigned long addr,
-                                          unsigned long len,
-                                          unsigned long pgoff,
-                                          unsigned long flags,
-                                          vm_flags_t vm_flags);
+unsigned long mm_get_unmapped_area_vmaflags(struct file *filp,
+                                           unsigned long addr,
+                                           unsigned long len,
+                                           unsigned long pgoff,
+                                           unsigned long flags,
+                                           vma_flags_t vma_flags);
 
 unsigned long
 generic_get_unmapped_area(struct file *filp, unsigned long addr,
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index e94f56487225..d6c5f51ee399 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -1196,7 +1196,7 @@ static inline bool is_transparent_hugepage(const struct 
folio *folio)
 static unsigned long __thp_get_unmapped_area(struct file *filp,
                unsigned long addr, unsigned long len,
                loff_t off, unsigned long flags, unsigned long size,
-               vm_flags_t vm_flags)
+               vma_flags_t vma_flags)
 {
        loff_t off_end = off + len;
        loff_t off_align = round_up(off, size);
@@ -1212,8 +1212,9 @@ static unsigned long __thp_get_unmapped_area(struct file 
*filp,
        if (len_pad < len || (off + len_pad) < off)
                return 0;
 
-       ret = mm_get_unmapped_area_vmflags(filp, addr, len_pad,
-                                          off >> PAGE_SHIFT, flags, vm_flags);
+       ret = mm_get_unmapped_area_vmaflags(filp, addr, len_pad,
+                                           off >> PAGE_SHIFT, flags,
+                                           vma_flags);
 
        /*
         * The failure might be due to length padding. The caller will retry
@@ -1238,25 +1239,27 @@ static unsigned long __thp_get_unmapped_area(struct 
file *filp,
        return ret;
 }
 
-unsigned long thp_get_unmapped_area_vmflags(struct file *filp, unsigned long 
addr,
+unsigned long thp_get_unmapped_area_vmaflags(struct file *filp, unsigned long 
addr,
                unsigned long len, unsigned long pgoff, unsigned long flags,
-               vm_flags_t vm_flags)
+               vma_flags_t vma_flags)
 {
        unsigned long ret;
        loff_t off = (loff_t)pgoff << PAGE_SHIFT;
 
-       ret = __thp_get_unmapped_area(filp, addr, len, off, flags, PMD_SIZE, 
vm_flags);
+       ret = __thp_get_unmapped_area(filp, addr, len, off, flags, PMD_SIZE,
+                                     vma_flags);
        if (ret)
                return ret;
 
-       return mm_get_unmapped_area_vmflags(filp, addr, len, pgoff, flags,
-                                           vm_flags);
+       return mm_get_unmapped_area_vmaflags(filp, addr, len, pgoff, flags,
+                                            vma_flags);
 }
 
 unsigned long thp_get_unmapped_area(struct file *filp, unsigned long addr,
                unsigned long len, unsigned long pgoff, unsigned long flags)
 {
-       return thp_get_unmapped_area_vmflags(filp, addr, len, pgoff, flags, 0);
+       return thp_get_unmapped_area_vmaflags(filp, addr, len, pgoff, flags,
+                                             EMPTY_VMA_FLAGS);
 }
 EXPORT_SYMBOL_GPL(thp_get_unmapped_area);
 
diff --git a/mm/mmap.c b/mm/mmap.c
index 547352183214..461ce510e12a 100644
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -411,8 +411,7 @@ unsigned long do_mmap(struct file *file, unsigned long addr,
        /* Obtain the address to map to. we verify (or select) it and ensure
         * that it represents a valid section of the address space.
         */
-       addr = __get_unmapped_area(file, addr, len, pgoff, flags,
-                                  vma_flags_to_legacy(vma_flags));
+       addr = __get_unmapped_area(file, addr, len, pgoff, flags, vma_flags);
        if (IS_ERR_VALUE(addr))
                return addr;
 
@@ -812,19 +811,20 @@ arch_get_unmapped_area_topdown(struct file *filp, 
unsigned long addr,
 }
 #endif
 
-unsigned long mm_get_unmapped_area_vmflags(struct file *filp, unsigned long 
addr,
-                                          unsigned long len, unsigned long 
pgoff,
-                                          unsigned long flags, vm_flags_t 
vm_flags)
+unsigned long mm_get_unmapped_area_vmaflags(struct file *filp, unsigned long 
addr,
+                                           unsigned long len, unsigned long 
pgoff,
+                                           unsigned long flags, vma_flags_t 
vma_flags)
 {
        if (mm_flags_test(MMF_TOPDOWN, current->mm))
                return arch_get_unmapped_area_topdown(filp, addr, len, pgoff,
-                                                     flags, vm_flags);
-       return arch_get_unmapped_area(filp, addr, len, pgoff, flags, vm_flags);
+                               flags, vma_flags_to_legacy(vma_flags));
+       return arch_get_unmapped_area(filp, addr, len, pgoff, flags,
+                       vma_flags_to_legacy(vma_flags));
 }
 
 unsigned long
 __get_unmapped_area(struct file *file, unsigned long addr, unsigned long len,
-               unsigned long pgoff, unsigned long flags, vm_flags_t vm_flags)
+               unsigned long pgoff, unsigned long flags, vma_flags_t vma_flags)
 {
        unsigned long (*get_area)(struct file *, unsigned long,
                                  unsigned long, unsigned long, unsigned long)
@@ -859,11 +859,11 @@ __get_unmapped_area(struct file *file, unsigned long 
addr, unsigned long len,
                   && !addr /* no hint */
                   && IS_ALIGNED(len, PMD_SIZE)) {
                /* Ensures that larger anonymous mappings are THP aligned. */
-               addr = thp_get_unmapped_area_vmflags(file, addr, len,
-                                                    pgoff, flags, vm_flags);
+               addr = thp_get_unmapped_area_vmaflags(file, addr, len,
+                                                     pgoff, flags, vma_flags);
        } else {
-               addr = mm_get_unmapped_area_vmflags(file, addr, len,
-                                                   pgoff, flags, vm_flags);
+               addr = mm_get_unmapped_area_vmaflags(file, addr, len,
+                                                    pgoff, flags, vma_flags);
        }
        if (IS_ERR_VALUE(addr))
                return addr;
@@ -881,7 +881,8 @@ unsigned long
 mm_get_unmapped_area(struct file *file, unsigned long addr, unsigned long len,
                     unsigned long pgoff, unsigned long flags)
 {
-       return mm_get_unmapped_area_vmflags(file, addr, len, pgoff, flags, 0);
+       return mm_get_unmapped_area_vmaflags(file, addr, len, pgoff, flags,
+                                            EMPTY_VMA_FLAGS);
 }
 EXPORT_SYMBOL(mm_get_unmapped_area);
 
-- 
2.54.0