[PATCH v2 13/13] mm/mremap: convert mremap code to use vma_flags_t

[Lorenzo Stoakes <ljs@xxxxxxxxxx>]

Replace use of the legacy vm_flags_t flags with vma_flags_t values
throughout the mremap logic.

Note that, in replacing vm_flags_clear() (which takes the VMA write lock)
with vma_clear_flags() and vma_clear_flags_mask() (which do not)
respectively in unmap_source_vma() and dontunmap_complete(), we do not add
a VMA write lock to account for htis.

This is because, in both cases, move_vma() is their calling function and
this has already acquired the VMA write lock on vrm->vma whose VMA flags
are being cleared.

In the case of vma_set_flags() in unmap_source_vma() we do need to do this
- as prev and next were not necessarily write locked at this point.

Additionally update comments to reflect the changes to be consistent.

No functional change intended.

Reviewed-by: Zi Yan <ziy@xxxxxxxxxx>
Signed-off-by: Lorenzo Stoakes <ljs@xxxxxxxxxx>
---
 mm/mremap.c | 38 ++++++++++++++++++++------------------
 1 file changed, 20 insertions(+), 18 deletions(-)

diff --git a/mm/mremap.c b/mm/mremap.c
index 384ef4cc2195..b64aa1f6e07e 100644
--- a/mm/mremap.c
+++ b/mm/mremap.c
@@ -68,7 +68,7 @@ struct vma_remap_struct {
        bool populate_expand;           /* mlock()'d expanded, must populate. */
        enum mremap_type remap_type;    /* expand, shrink, etc. */
        bool mmap_locked;               /* Is mm currently write-locked? */
-       unsigned long charged;          /* If VM_ACCOUNT, # pages to account. */
+       unsigned long charged;          /* If VMA_ACCOUNT_BIT, # pgs to account 
*/
        bool vmi_needs_invalidate;      /* Is the VMA iterator invalidated? */
 };
 
@@ -963,7 +963,7 @@ static unsigned long vrm_set_new_addr(struct 
vma_remap_struct *vrm)
 
        if (vrm->flags & MREMAP_FIXED)
                map_flags |= MAP_FIXED;
-       if (vma->vm_flags & VM_MAYSHARE)
+       if (vma_test(vma, VMA_MAYSHARE_BIT))
                map_flags |= MAP_SHARED;
 
        res = get_unmapped_area(vma->vm_file, new_addr, vrm->new_len, pgoff,
@@ -985,7 +985,7 @@ static bool vrm_calc_charge(struct vma_remap_struct *vrm)
 {
        unsigned long charged;
 
-       if (!(vrm->vma->vm_flags & VM_ACCOUNT))
+       if (!vma_test(vrm->vma, VMA_ACCOUNT_BIT))
                return true;
 
        /*
@@ -1012,7 +1012,7 @@ static bool vrm_calc_charge(struct vma_remap_struct *vrm)
  */
 static void vrm_uncharge(struct vma_remap_struct *vrm)
 {
-       if (!(vrm->vma->vm_flags & VM_ACCOUNT))
+       if (!vma_test(vrm->vma, VMA_ACCOUNT_BIT))
                return;
 
        vm_unacct_memory(vrm->charged);
@@ -1032,7 +1032,7 @@ static void vrm_stat_account(struct vma_remap_struct *vrm,
        struct vm_area_struct *vma = vrm->vma;
 
        vm_stat_account(mm, vma->vm_flags, pages);
-       if (vma->vm_flags & VM_LOCKED)
+       if (vma_test(vma, VMA_LOCKED_BIT))
                mm->locked_vm += pages;
 }
 
@@ -1176,7 +1176,7 @@ static void unmap_source_vma(struct vma_remap_struct *vrm)
         * arose, in which case we _do_ wish to unmap the _new_ VMA, which means
         * we actually _do_ want it be unaccounted.
         */
-       bool accountable_move = (vma->vm_flags & VM_ACCOUNT) &&
+       bool accountable_move = vma_test(vma, VMA_ACCOUNT_BIT) &&
                !(vrm->flags & MREMAP_DONTUNMAP);
 
        /*
@@ -1195,7 +1195,7 @@ static void unmap_source_vma(struct vma_remap_struct *vrm)
         * portions of the original VMA that remain.
         */
        if (accountable_move) {
-               vm_flags_clear(vma, VM_ACCOUNT);
+               vma_clear_flags(vma, VMA_ACCOUNT_BIT);
                /* We are about to split vma, so store the start/end. */
                vm_start = vma->vm_start;
                vm_end = vma->vm_end;
@@ -1220,8 +1220,8 @@ static void unmap_source_vma(struct vma_remap_struct *vrm)
         * |             |
         * |-------------|
         *
-        * Having cleared VM_ACCOUNT from the whole VMA, after we unmap above
-        * we'll end up with:
+        * Having cleared VMA_ACCOUNT_BIT from the whole VMA, after we unmap
+        * above we'll end up with:
         *
         *    addr  end
         *     |     |
@@ -1241,13 +1241,15 @@ static void unmap_source_vma(struct vma_remap_struct 
*vrm)
                if (vm_start < addr) {
                        struct vm_area_struct *prev = vma_prev(&vmi);
 
-                       vm_flags_set(prev, VM_ACCOUNT); /* Acquires VMA lock. */
+                       vma_start_write(prev);
+                       vma_set_flags(prev, VMA_ACCOUNT_BIT);
                }
 
                if (vm_end > end) {
                        struct vm_area_struct *next = vma_next(&vmi);
 
-                       vm_flags_set(next, VM_ACCOUNT); /* Acquires VMA lock. */
+                       vma_start_write(next);
+                       vma_set_flags(next, VMA_ACCOUNT_BIT);
                }
        }
 }
@@ -1330,8 +1332,8 @@ static void dontunmap_complete(struct vma_remap_struct 
*vrm,
        unsigned long old_start = vrm->vma->vm_start;
        unsigned long old_end = vrm->vma->vm_end;
 
-       /* We always clear VM_LOCKED[ONFAULT] on the old VMA. */
-       vm_flags_clear(vrm->vma, VM_LOCKED_MASK);
+       /* We always clear VMA_LOCKED[ONFAULT]_BIT on the old VMA. */
+       vma_clear_flags_mask(vrm->vma, VMA_LOCKED_MASK);
 
        /*
         * anon_vma links of the old vma is no longer needed after its page
@@ -1767,14 +1769,14 @@ static int check_prep_vma(struct vma_remap_struct *vrm)
         * based on the original.  There are no known use cases for this
         * behavior.  As a result, fail such attempts.
         */
-       if (!old_len && !(vma->vm_flags & (VM_SHARED | VM_MAYSHARE))) {
+       if (!old_len && !vma_test_any(vma, VMA_SHARED_BIT, VMA_MAYSHARE_BIT)) {
                pr_warn_once("%s (%d): attempted to duplicate a private mapping 
with mremap.  This is not supported.\n",
                             current->comm, current->pid);
                return -EINVAL;
        }
 
        if ((vrm->flags & MREMAP_DONTUNMAP) &&
-                       (vma->vm_flags & (VM_DONTEXPAND | VM_PFNMAP)))
+           vma_test_any(vma, VMA_DONTEXPAND_BIT, VMA_PFNMAP_BIT))
                return -EINVAL;
 
        /*
@@ -1804,7 +1806,7 @@ static int check_prep_vma(struct vma_remap_struct *vrm)
                return 0;
 
        /* We are expanding and the VMA is mlock()'d so we need to populate. */
-       if (vma->vm_flags & VM_LOCKED)
+       if (vma_test(vma, VMA_LOCKED_BIT))
                vrm->populate_expand = true;
 
        /* Need to be careful about a growing mapping */
@@ -1812,10 +1814,10 @@ static int check_prep_vma(struct vma_remap_struct *vrm)
        if (pgoff + (new_len >> PAGE_SHIFT) < pgoff)
                return -EINVAL;
 
-       if (vma->vm_flags & (VM_DONTEXPAND | VM_PFNMAP))
+       if (vma_test_any(vma, VMA_DONTEXPAND_BIT, VMA_PFNMAP_BIT))
                return -EFAULT;
 
-       if (!mlock_future_ok(mm, vma->vm_flags & VM_LOCKED, vrm->delta))
+       if (!mlock_future_ok(mm, vma_test(vma, VMA_LOCKED_BIT), vrm->delta))
                return -EAGAIN;
 
        if (!may_expand_vm(mm, &vma->flags, vrm->delta >> PAGE_SHIFT))

-- 
2.55.0