mmu_notifier: pass through vma to invalidate_range and invalidate_page v2
Jérôme Glisse [Thu, 16 Jan 2014 21:05:47 +0000 (16:05 -0500)]
New user of the mmu_notifier interface need to lookup vma in order to
perform the invalidation operation. Instead of redoing a vma lookup
inside the callback just pass through the vma from the call site where
it is already available.

This needs small refactoring in memory.c to call invalidate_range on
vma boundary while previously it was call once for larger range. The
overhead might be offseted by the fact that mmu_notifier listener now
work on smaller and exact range.

Changed since v1 :
  - Only passthrough the vma.
  - Commit comment.

Signed-off-by: Jérôme Glisse <jglisse@redhat.com>
(cherry picked from commit eeb9f7693d2a86a7caa368e2c51d3ac09da04a8e)

Conflicts:
drivers/gpu/drm/i915/i915_gem_userptr.c
kernel/events/uprobes.c
mm/huge_memory.c
mm/hugetlb.c
mm/migrate.c
mm/rmap.c
mm/mprotect.c

Bug 200074285

Change-Id: I076973244386b359b1db6c6c2fe0c68d289b19ff
Signed-off-by: Sri Krishna chowdary <schowdary@nvidia.com>
Reviewed-on: http://git-master/r/678276
Reviewed-by: Bharat Nihalani <bnihalani@nvidia.com>

17 files changed:
drivers/iommu/amd_iommu_v2.c
drivers/misc/sgi-gru/grutlbpurge.c
drivers/xen/gntdev.c
include/linux/mmu_notifier.h
kernel/events/uprobes.c
mm/filemap_xip.c
mm/fremap.c
mm/huge_memory.c
mm/hugetlb.c
mm/ksm.c
mm/memory.c
mm/migrate.c
mm/mmu_notifier.c
mm/mprotect.c
mm/mremap.c
mm/rmap.c
virt/kvm/kvm_main.c

index c91d230..aaebf5f 100644 (file)
@@ -428,7 +428,7 @@ static void mn_change_pte(struct mmu_notifier *mn,
 }
 
 static void mn_invalidate_page(struct mmu_notifier *mn,
-                              struct mm_struct *mm,
+                              struct vm_area_struct *vma,
                               unsigned long address,
                               enum mmu_event event)
 {
@@ -436,7 +436,7 @@ static void mn_invalidate_page(struct mmu_notifier *mn,
 }
 
 static void mn_invalidate_range_start(struct mmu_notifier *mn,
-                                     struct mm_struct *mm,
+                                     struct vm_area_struct *vma,
                                      unsigned long start,
                                      unsigned long end,
                                      enum mmu_event event)
@@ -452,7 +452,7 @@ static void mn_invalidate_range_start(struct mmu_notifier *mn,
 }
 
 static void mn_invalidate_range_end(struct mmu_notifier *mn,
-                                   struct mm_struct *mm,
+                                   struct vm_area_struct *vma,
                                    unsigned long start,
                                    unsigned long end,
                                    enum mmu_event event)
index e67fed1..ef29b45 100644 (file)
@@ -220,7 +220,7 @@ void gru_flush_all_tlb(struct gru_state *gru)
  * MMUOPS notifier callout functions
  */
 static void gru_invalidate_range_start(struct mmu_notifier *mn,
-                                      struct mm_struct *mm,
+                                      struct vm_area_struct *vma,
                                       unsigned long start, unsigned long end,
                                       enum mmu_event event)
 {
@@ -235,7 +235,8 @@ static void gru_invalidate_range_start(struct mmu_notifier *mn,
 }
 
 static void gru_invalidate_range_end(struct mmu_notifier *mn,
-                                    struct mm_struct *mm, unsigned long start,
+                                    struct vm_area_struct *vma,
+                                    unsigned long start,
                                     unsigned long end,
                                     enum mmu_event event)
 {
@@ -249,7 +250,8 @@ static void gru_invalidate_range_end(struct mmu_notifier *mn,
        gru_dbg(grudev, "gms %p, start 0x%lx, end 0x%lx\n", gms, start, end);
 }
 
-static void gru_invalidate_page(struct mmu_notifier *mn, struct mm_struct *mm,
+static void gru_invalidate_page(struct mmu_notifier *mn,
+                               struct vm_area_struct *vma,
                                unsigned long address,
                                enum mmu_event event)
 {
index 6cb5910..c01221a 100644 (file)
@@ -432,7 +432,7 @@ static void unmap_if_in_range(struct grant_map *map,
 }
 
 static void mn_invl_range_start(struct mmu_notifier *mn,
-                               struct mm_struct *mm,
+                               struct vm_area_struct *vma,
                                unsigned long start,
                                unsigned long end,
                                enum mmu_event event)
@@ -451,11 +451,11 @@ static void mn_invl_range_start(struct mmu_notifier *mn,
 }
 
 static void mn_invl_page(struct mmu_notifier *mn,
-                        struct mm_struct *mm,
+                        struct vm_area_struct *vma,
                         unsigned long address,
                         enum mmu_event event)
 {
-       mn_invl_range_start(mn, mm, address, address + PAGE_SIZE, event);
+       mn_invl_range_start(mn, vma, address, address + PAGE_SIZE, event);
 }
 
 static void mn_release(struct mmu_notifier *mn,
index dbd81f5..066dba1 100644 (file)
@@ -142,7 +142,7 @@ struct mmu_notifier_ops {
         * be called internally to this method.
         */
        void (*invalidate_page)(struct mmu_notifier *mn,
-                               struct mm_struct *mm,
+                               struct vm_area_struct *vma,
                                unsigned long address,
                                enum mmu_event event);
 
@@ -190,12 +190,12 @@ struct mmu_notifier_ops {
         * the last refcount is dropped.
         */
        void (*invalidate_range_start)(struct mmu_notifier *mn,
-                                      struct mm_struct *mm,
+                                      struct vm_area_struct *vma,
                                       unsigned long start,
                                       unsigned long end,
                                       enum mmu_event event);
        void (*invalidate_range_end)(struct mmu_notifier *mn,
-                                    struct mm_struct *mm,
+                                    struct vm_area_struct *vma,
                                     unsigned long start,
                                     unsigned long end,
                                     enum mmu_event event);
@@ -264,14 +264,14 @@ extern void __mmu_notifier_change_pte(struct mm_struct *mm,
                                      unsigned long address,
                                      pte_t pte,
                                      enum mmu_event event);
-extern void __mmu_notifier_invalidate_page(struct mm_struct *mm,
-                                         unsigned long address,
-                                         enum mmu_event event);
-extern void __mmu_notifier_invalidate_range_start(struct mm_struct *mm,
+extern void __mmu_notifier_invalidate_page(struct vm_area_struct *vma,
+                                          unsigned long address,
+                                          enum mmu_event event);
+extern void __mmu_notifier_invalidate_range_start(struct vm_area_struct *vma,
                                                  unsigned long start,
                                                  unsigned long end,
                                                  enum mmu_event event);
-extern void __mmu_notifier_invalidate_range_end(struct mm_struct *mm,
+extern void __mmu_notifier_invalidate_range_end(struct vm_area_struct *vma,
                                                unsigned long start,
                                                unsigned long end,
                                                enum mmu_event event);
@@ -309,30 +309,31 @@ static inline void mmu_notifier_change_pte(struct mm_struct *mm,
                __mmu_notifier_change_pte(mm, address, pte, event);
 }
 
-static inline void mmu_notifier_invalidate_page(struct mm_struct *mm,
+static inline void mmu_notifier_invalidate_page(struct vm_area_struct *vma,
                                                unsigned long address,
                                                enum mmu_event event)
 {
-       if (mm_has_notifiers(mm))
-               __mmu_notifier_invalidate_page(mm, address, event);
+       if (mm_has_notifiers(vma->vm_mm))
+               __mmu_notifier_invalidate_page(vma, address, event);
 }
 
-static inline void mmu_notifier_invalidate_range_start(struct mm_struct *mm,
+static inline void mmu_notifier_invalidate_range_start(struct vm_area_struct *vma,
                                                       unsigned long start,
                                                       unsigned long end,
                                                       enum mmu_event event)
 {
-       if (mm_has_notifiers(mm))
-               __mmu_notifier_invalidate_range_start(mm, start, end, event);
+       if (mm_has_notifiers(vma->vm_mm))
+               __mmu_notifier_invalidate_range_start(vma, start,
+                                                     end, event);
 }
 
-static inline void mmu_notifier_invalidate_range_end(struct mm_struct *mm,
+static inline void mmu_notifier_invalidate_range_end(struct vm_area_struct *vma,
                                                     unsigned long start,
                                                     unsigned long end,
                                                     enum mmu_event event)
 {
-       if (mm_has_notifiers(mm))
-               __mmu_notifier_invalidate_range_end(mm, start, end, event);
+       if (mm_has_notifiers(vma->vm_mm))
+               __mmu_notifier_invalidate_range_end(vma, start, end, event);
 }
 
 static inline void mmu_notifier_invalidate_range(struct mm_struct *mm,
@@ -461,20 +462,20 @@ static inline void mmu_notifier_change_pte(struct mm_struct *mm,
 {
 }
 
-static inline void mmu_notifier_invalidate_page(struct mm_struct *mm,
+static inline void mmu_notifier_invalidate_page(struct vm_area_struct *vma,
                                                unsigned long address,
                                                enum mmu_event event)
 {
 }
 
-static inline void mmu_notifier_invalidate_range_start(struct mm_struct *mm,
+static inline void mmu_notifier_invalidate_range_start(struct vm_area_struct *vma,
                                                       unsigned long start,
                                                       unsigned long end,
                                                       enum mmu_event event)
 {
 }
 
-static inline void mmu_notifier_invalidate_range_end(struct mm_struct *mm,
+static inline void mmu_notifier_invalidate_range_end(struct vm_area_struct *vma,
                                                     unsigned long start,
                                                     unsigned long end,
                                                     enum mmu_event event)
index e8383a8..c89fa9a 100644 (file)
@@ -137,7 +137,7 @@ static int __replace_page(struct vm_area_struct *vma, unsigned long addr,
        /* For try_to_free_swap() and munlock_vma_page() below */
        lock_page(page);
 
-       mmu_notifier_invalidate_range_start(mm, mmun_start,
+       mmu_notifier_invalidate_range_start(vma, mmun_start,
                                            mmun_end, MMU_MIGRATE);
        err = -EAGAIN;
        ptep = page_check_address(page, mm, addr, &ptl, 0);
@@ -169,7 +169,7 @@ static int __replace_page(struct vm_area_struct *vma, unsigned long addr,
 
        err = 0;
  unlock:
-       mmu_notifier_invalidate_range_end(mm, mmun_start,
+       mmu_notifier_invalidate_range_end(vma, mmun_start,
                                          mmun_end, MMU_MIGRATE);
        unlock_page(page);
        return err;
index 09fc50f..61bdf7d 100644 (file)
@@ -198,7 +198,8 @@ retry:
                        BUG_ON(pte_dirty(pteval));
                        pte_unmap_unlock(pte, ptl);
                        /* must invalidate_page _before_ freeing the page */
-                       mmu_notifier_invalidate_page(mm, address, MMU_MIGRATE);
+                       mmu_notifier_invalidate_page(mm, vma, address,
+                                                    MMU_MIGRATE);
                        page_cache_release(page);
                }
        }
index 53ddce6..f92dab8 100644 (file)
@@ -237,10 +237,11 @@ get_write_lock:
        }
 
        /* XXX: using MMU_MIGRATE as it is OK. Need to optimize this */
-       mmu_notifier_invalidate_range_start(mm, start, start + size,
+       mmu_notifier_invalidate_range_start(vma, start, start + size,
                                            MMU_MIGRATE);
        err = vma->vm_ops->remap_pages(vma, start, size, pgoff);
-       mmu_notifier_invalidate_range_end(mm, start, start + size, MMU_MIGRATE);
+       mmu_notifier_invalidate_range_end(vma, start, start + size,
+                                         MMU_MIGRATE);
 
        /*
         * We can't clear VM_NONLINEAR because we'd have to do
index 664feb8..384907a 100644 (file)
@@ -1075,7 +1075,7 @@ static int do_huge_pmd_wp_page_fallback(struct mm_struct *mm,
 
        mmun_start = haddr;
        mmun_end   = haddr + HPAGE_PMD_SIZE;
-       mmu_notifier_invalidate_range_start(mm, mmun_start, mmun_end,
+       mmu_notifier_invalidate_range_start(vma, mmun_start, mmun_end,
                                            MMU_MIGRATE);
 
        spin_lock(&mm->page_table_lock);
@@ -1106,7 +1106,7 @@ static int do_huge_pmd_wp_page_fallback(struct mm_struct *mm,
        page_remove_rmap(page);
        spin_unlock(&mm->page_table_lock);
 
-       mmu_notifier_invalidate_range_end(mm, mmun_start,
+       mmu_notifier_invalidate_range_end(vma, mmun_start,
                                          mmun_end, MMU_MIGRATE);
 
        ret |= VM_FAULT_WRITE;
@@ -1117,7 +1117,7 @@ out:
 
 out_free_pages:
        spin_unlock(&mm->page_table_lock);
-       mmu_notifier_invalidate_range_end(mm, mmun_start,
+       mmu_notifier_invalidate_range_end(vma, mmun_start,
                                          mmun_end, MMU_MIGRATE);
        mem_cgroup_uncharge_start();
        for (i = 0; i < HPAGE_PMD_NR; i++) {
@@ -1201,7 +1201,7 @@ alloc:
 
        mmun_start = haddr;
        mmun_end   = haddr + HPAGE_PMD_SIZE;
-       mmu_notifier_invalidate_range_start(mm, mmun_start, mmun_end,
+       mmu_notifier_invalidate_range_start(vma, mmun_start, mmun_end,
                                            MMU_MIGRATE);
 
        spin_lock(&mm->page_table_lock);
@@ -1231,7 +1231,7 @@ alloc:
        }
        spin_unlock(&mm->page_table_lock);
 out_mn:
-       mmu_notifier_invalidate_range_end(mm, mmun_start,
+       mmu_notifier_invalidate_range_end(vma, mmun_start,
                                          mmun_end, MMU_MIGRATE);
 out:
        return ret;
@@ -1582,7 +1582,7 @@ static int __split_huge_page_splitting(struct page *page,
        const unsigned long mmun_start = address;
        const unsigned long mmun_end   = address + HPAGE_PMD_SIZE;
 
-       mmu_notifier_invalidate_range_start(mm, mmun_start,
+       mmu_notifier_invalidate_range_start(vma, mmun_start,
                                            mmun_end, MMU_STATUS);
        spin_lock(&mm->page_table_lock);
        pmd = page_check_address_pmd(page, mm, address,
@@ -1600,7 +1600,7 @@ static int __split_huge_page_splitting(struct page *page,
                ret = 1;
        }
        spin_unlock(&mm->page_table_lock);
-       mmu_notifier_invalidate_range_end(mm, mmun_start,
+       mmu_notifier_invalidate_range_end(vma, mmun_start,
                                          mmun_end, MMU_STATUS);
 
        return ret;
@@ -2358,7 +2358,7 @@ static void collapse_huge_page(struct mm_struct *mm,
 
        mmun_start = address;
        mmun_end   = address + HPAGE_PMD_SIZE;
-       mmu_notifier_invalidate_range_start(mm, mmun_start,
+       mmu_notifier_invalidate_range_start(vma, mmun_start,
                                            mmun_end, MMU_MIGRATE);
        spin_lock(&mm->page_table_lock); /* probably unnecessary */
        /*
@@ -2369,7 +2369,7 @@ static void collapse_huge_page(struct mm_struct *mm,
         */
        _pmd = pmdp_clear_flush(vma, address, pmd);
        spin_unlock(&mm->page_table_lock);
-       mmu_notifier_invalidate_range_end(mm, mmun_start,
+       mmu_notifier_invalidate_range_end(vma, mmun_start,
                                          mmun_end, MMU_MIGRATE);
 
        spin_lock(ptl);
@@ -2753,19 +2753,19 @@ void __split_huge_page_pmd(struct vm_area_struct *vma, unsigned long address,
        mmun_start = haddr;
        mmun_end   = haddr + HPAGE_PMD_SIZE;
 again:
-       mmu_notifier_invalidate_range_start(mm, mmun_start,
+       mmu_notifier_invalidate_range_start(vma, mmun_start,
                                            mmun_end, MMU_MIGRATE);
        spin_lock(&mm->page_table_lock);
        if (unlikely(!pmd_trans_huge(*pmd))) {
                spin_unlock(&mm->page_table_lock);
-               mmu_notifier_invalidate_range_end(mm, mmun_start,
+               mmu_notifier_invalidate_range_end(vma, mmun_start,
                                                  mmun_end, MMU_MIGRATE);
                return;
        }
        if (is_huge_zero_pmd(*pmd)) {
                __split_huge_zero_page_pmd(vma, haddr, pmd);
                spin_unlock(&mm->page_table_lock);
-               mmu_notifier_invalidate_range_end(mm, mmun_start,
+               mmu_notifier_invalidate_range_end(vma, mmun_start,
                                                  mmun_end, MMU_MIGRATE);
                return;
        }
@@ -2773,7 +2773,7 @@ again:
        VM_BUG_ON(!page_count(page));
        get_page(page);
        spin_unlock(&mm->page_table_lock);
-       mmu_notifier_invalidate_range_end(mm, mmun_start,
+       mmu_notifier_invalidate_range_end(vma, mmun_start,
                                          mmun_end, MMU_MIGRATE);
 
        split_huge_page(page);
index 38ea62c..196c85c 100644 (file)
@@ -2372,7 +2372,7 @@ int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src,
        mmun_start = vma->vm_start;
        mmun_end = vma->vm_end;
        if (cow)
-               mmu_notifier_invalidate_range_start(src, mmun_start,
+               mmu_notifier_invalidate_range_start(vma, mmun_start,
                                                    mmun_end, MMU_MIGRATE);
 
        for (addr = vma->vm_start; addr < vma->vm_end; addr += sz) {
@@ -2425,7 +2425,7 @@ int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src,
        }
 
        if (cow)
-               mmu_notifier_invalidate_range_end(src, mmun_start,
+               mmu_notifier_invalidate_range_end(vma, mmun_start,
                                                  mmun_end, MMU_MIGRATE);
 
        return ret;
@@ -2451,7 +2451,7 @@ void __unmap_hugepage_range(struct mmu_gather *tlb, struct vm_area_struct *vma,
        BUG_ON(end & ~huge_page_mask(h));
 
        tlb_start_vma(tlb, vma);
-       mmu_notifier_invalidate_range_start(mm, mmun_start,
+       mmu_notifier_invalidate_range_start(vma, mmun_start,
                                            mmun_end, MMU_MIGRATE);
 again:
        spin_lock(&mm->page_table_lock);
@@ -2518,7 +2518,7 @@ again:
                if (address < end && !ref_page)
                        goto again;
        }
-       mmu_notifier_invalidate_range_end(mm, mmun_start,
+       mmu_notifier_invalidate_range_end(vma, mmun_start,
                                          mmun_end, MMU_MIGRATE);
        tlb_end_vma(tlb, vma);
 }
@@ -2709,7 +2709,7 @@ retry_avoidcopy:
 
        mmun_start = address & huge_page_mask(h);
        mmun_end = mmun_start + huge_page_size(h);
-       mmu_notifier_invalidate_range_start(mm, mmun_start, mmun_end,
+       mmu_notifier_invalidate_range_start(vma, mmun_start, mmun_end,
                                            MMU_MIGRATE);
        /*
         * Retake the page_table_lock to check for racing updates
@@ -2729,7 +2729,7 @@ retry_avoidcopy:
                new_page = old_page;
        }
        spin_unlock(&mm->page_table_lock);
-       mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end,
+       mmu_notifier_invalidate_range_end(vma, mmun_start, mmun_end,
                                          MMU_MIGRATE);
        /* Caller expects lock to be held */
        spin_lock(&mm->page_table_lock);
@@ -3127,7 +3127,7 @@ unsigned long hugetlb_change_protection(struct vm_area_struct *vma,
        BUG_ON(address >= end);
        flush_cache_range(vma, address, end);
 
-       mmu_notifier_invalidate_range_start(mm, start, end, MMU_MPROT);
+       mmu_notifier_invalidate_range_start(vma, start, end, MMU_MPROT);
        mutex_lock(&vma->vm_file->f_mapping->i_mmap_mutex);
        spin_lock(&mm->page_table_lock);
        for (; address < end; address += huge_page_size(h)) {
@@ -3156,7 +3156,7 @@ unsigned long hugetlb_change_protection(struct vm_area_struct *vma,
        flush_tlb_range(vma, start, end);
        mmu_notifier_invalidate_range(mm, start, end);
        mutex_unlock(&vma->vm_file->f_mapping->i_mmap_mutex);
-       mmu_notifier_invalidate_range_end(mm, start, end, MMU_MPROT);
+       mmu_notifier_invalidate_range_end(vma, start, end, MMU_MPROT);
 
        return pages << h->order;
 }
index 6d735ca..506a44b 100644 (file)
--- a/mm/ksm.c
+++ b/mm/ksm.c
@@ -872,7 +872,7 @@ static int write_protect_page(struct vm_area_struct *vma, struct page *page,
 
        mmun_start = addr;
        mmun_end   = addr + PAGE_SIZE;
-       mmu_notifier_invalidate_range_start(mm, mmun_start, mmun_end,
+       mmu_notifier_invalidate_range_start(vma, mmun_start, mmun_end,
                                            MMU_WRITE_PROTECT);
 
        ptep = page_check_address(page, mm, addr, &ptl, 0);
@@ -913,7 +913,7 @@ static int write_protect_page(struct vm_area_struct *vma, struct page *page,
 out_unlock:
        pte_unmap_unlock(ptep, ptl);
 out_mn:
-       mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end,
+       mmu_notifier_invalidate_range_end(vma, mmun_start, mmun_end,
                                          MMU_WRITE_PROTECT);
 out:
        return err;
@@ -951,7 +951,7 @@ static int replace_page(struct vm_area_struct *vma, struct page *page,
 
        mmun_start = addr;
        mmun_end   = addr + PAGE_SIZE;
-       mmu_notifier_invalidate_range_start(mm, mmun_start, mmun_end,
+       mmu_notifier_invalidate_range_start(vma, mmun_start, mmun_end,
                                            MMU_MIGRATE);
 
        ptep = pte_offset_map_lock(mm, pmd, addr, &ptl);
@@ -977,7 +977,7 @@ static int replace_page(struct vm_area_struct *vma, struct page *page,
        pte_unmap_unlock(ptep, ptl);
        err = 0;
 out_mn:
-       mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end,
+       mmu_notifier_invalidate_range_end(vma, mmun_start, mmun_end,
                                          MMU_MIGRATE);
 out:
        return err;
index e20d663..5276902 100644 (file)
@@ -1069,7 +1069,7 @@ int copy_page_range(struct mm_struct *dst_mm, struct mm_struct *src_mm,
        mmun_start = addr;
        mmun_end   = end;
        if (is_cow)
-               mmu_notifier_invalidate_range_start(src_mm, mmun_start,
+               mmu_notifier_invalidate_range_start(vma, mmun_start,
                                                    mmun_end, MMU_MIGRATE);
 
        ret = 0;
@@ -1087,8 +1087,8 @@ int copy_page_range(struct mm_struct *dst_mm, struct mm_struct *src_mm,
        } while (dst_pgd++, src_pgd++, addr = next, addr != end);
 
        if (is_cow)
-               mmu_notifier_invalidate_range_end(src_mm, mmun_start, mmun_end,
-                                                 MMU_MIGRATE);
+               mmu_notifier_invalidate_range_end(vma, mmun_start,
+                                                 mmun_end, MMU_MIGRATE);
        return ret;
 }
 
@@ -1332,6 +1332,11 @@ static void unmap_single_vma(struct mmu_gather *tlb,
        if (end <= vma->vm_start)
                return;
 
+       mmu_notifier_invalidate_range_start(vma,
+                                           max(start_addr, vma->vm_start),
+                                           min(end_addr, vma->vm_end),
+                                           MMU_MUNMAP);
+
        if (vma->vm_file)
                uprobe_munmap(vma, start, end);
 
@@ -1359,6 +1364,11 @@ static void unmap_single_vma(struct mmu_gather *tlb,
                } else
                        unmap_page_range(tlb, vma, start, end, details);
        }
+
+       mmu_notifier_invalidate_range_end(vma,
+                                         max(start_addr, vma->vm_start),
+                                         min(end_addr, vma->vm_end),
+                                         MMU_MUNMAP);
 }
 
 /**
@@ -1383,14 +1393,8 @@ void unmap_vmas(struct mmu_gather *tlb,
                struct vm_area_struct *vma, unsigned long start_addr,
                unsigned long end_addr)
 {
-       struct mm_struct *mm = vma->vm_mm;
-
-       mmu_notifier_invalidate_range_start(mm, start_addr,
-                                           end_addr, MMU_MUNMAP);
        for ( ; vma && vma->vm_start < end_addr; vma = vma->vm_next)
                unmap_single_vma(tlb, vma, start_addr, end_addr, NULL);
-       mmu_notifier_invalidate_range_end(mm, start_addr,
-                                         end_addr, MMU_MUNMAP);
 }
 
 /**
@@ -1412,10 +1416,8 @@ void zap_page_range(struct vm_area_struct *vma, unsigned long start,
        lru_add_drain();
        tlb_gather_mmu(&tlb, mm, start, end);
        update_hiwater_rss(mm);
-       mmu_notifier_invalidate_range_start(mm, start, end, MMU_MUNMAP);
        for ( ; vma && vma->vm_start < end; vma = vma->vm_next)
                unmap_single_vma(&tlb, vma, start, end, details);
-       mmu_notifier_invalidate_range_end(mm, start, end, MMU_MUNMAP);
        tlb_finish_mmu(&tlb, start, end);
 }
 
@@ -1438,9 +1440,7 @@ static void zap_page_range_single(struct vm_area_struct *vma, unsigned long addr
        lru_add_drain();
        tlb_gather_mmu(&tlb, mm, address, end);
        update_hiwater_rss(mm);
-       mmu_notifier_invalidate_range_start(mm, address, end, MMU_MUNMAP);
        unmap_single_vma(&tlb, vma, address, end, details);
-       mmu_notifier_invalidate_range_end(mm, address, end, MMU_MUNMAP);
        tlb_finish_mmu(&tlb, address, end);
 }
 
@@ -2842,7 +2842,7 @@ gotten:
 
        mmun_start  = address & PAGE_MASK;
        mmun_end    = mmun_start + PAGE_SIZE;
-       mmu_notifier_invalidate_range_start(mm, mmun_start,
+       mmu_notifier_invalidate_range_start(vma, mmun_start,
                                            mmun_end, MMU_MIGRATE);
 
        /*
@@ -2912,7 +2912,7 @@ gotten:
 unlock:
        pte_unmap_unlock(page_table, ptl);
        if (mmun_end > mmun_start)
-               mmu_notifier_invalidate_range_end(mm, mmun_start,
+               mmu_notifier_invalidate_range_end(vma, mmun_start,
                                                  mmun_end, MMU_MIGRATE);
        if (old_page) {
                /*
index ad1fbb8..2fa07cf 100644 (file)
@@ -1765,12 +1765,12 @@ int migrate_misplaced_transhuge_page(struct mm_struct *mm,
        WARN_ON(PageLRU(new_page));
 
        /* Recheck the target PMD */
-       mmu_notifier_invalidate_range_start(mm, mmun_start,
+       mmu_notifier_invalidate_range_start(vma, mmun_start,
                                            mmun_end, MMU_MIGRATE);
        spin_lock(&mm->page_table_lock);
        if (unlikely(!pmd_same(*pmd, entry))) {
                spin_unlock(&mm->page_table_lock);
-               mmu_notifier_invalidate_range_end(mm, mmun_start,
+               mmu_notifier_invalidate_range_end(vma, mmun_start,
                                                  mmun_end, MMU_MIGRATE);
 
                /* Reverse changes made by migrate_page_copy() */
@@ -1818,7 +1818,7 @@ int migrate_misplaced_transhuge_page(struct mm_struct *mm,
         */
        mem_cgroup_end_migration(memcg, page, new_page, true);
        spin_unlock(&mm->page_table_lock);
-       mmu_notifier_invalidate_range_end(mm, mmun_start,
+       mmu_notifier_invalidate_range_end(vma, mmun_start,
                                          mmun_end, MMU_MIGRATE);
 
        unlock_page(new_page);
index 8bf6975..7227493 100644 (file)
@@ -149,45 +149,48 @@ void __mmu_notifier_change_pte(struct mm_struct *mm,
        srcu_read_unlock(&srcu, id);
 }
 
-void __mmu_notifier_invalidate_page(struct mm_struct *mm,
+void __mmu_notifier_invalidate_page(struct vm_area_struct *vma,
                                    unsigned long address,
                                    enum mmu_event event)
 {
+       struct mm_struct *mm = vma->vm_mm;
        struct mmu_notifier *mn;
        int id;
 
        id = srcu_read_lock(&srcu);
        hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist) {
                if (mn->ops->invalidate_page)
-                       mn->ops->invalidate_page(mn, mm, address, event);
+                       mn->ops->invalidate_page(mn, vma, address, event);
        }
        srcu_read_unlock(&srcu, id);
 }
 
-void __mmu_notifier_invalidate_range_start(struct mm_struct *mm,
+void __mmu_notifier_invalidate_range_start(struct vm_area_struct *vma,
                                           unsigned long start,
                                           unsigned long end,
                                           enum mmu_event event)
 
 {
+       struct mm_struct *mm = vma->vm_mm;
        struct mmu_notifier *mn;
        int id;
 
        id = srcu_read_lock(&srcu);
        hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist) {
                if (mn->ops->invalidate_range_start)
-                       mn->ops->invalidate_range_start(mn, mm, start,
+                       mn->ops->invalidate_range_start(mn, vma, start,
                                                        end, event);
        }
        srcu_read_unlock(&srcu, id);
 }
 EXPORT_SYMBOL_GPL(__mmu_notifier_invalidate_range_start);
 
-void __mmu_notifier_invalidate_range_end(struct mm_struct *mm,
+void __mmu_notifier_invalidate_range_end(struct vm_area_struct *vma,
                                         unsigned long start,
                                         unsigned long end,
                                         enum mmu_event event)
 {
+       struct mm_struct *mm = vma->vm_mm;
        struct mmu_notifier *mn;
        int id;
 
@@ -204,7 +207,7 @@ void __mmu_notifier_invalidate_range_end(struct mm_struct *mm,
                if (mn->ops->invalidate_range)
                        mn->ops->invalidate_range(mn, mm, start, end);
                if (mn->ops->invalidate_range_end)
-                       mn->ops->invalidate_range_end(mn, mm, start,
+                       mn->ops->invalidate_range_end(mn, vma, start,
                                                      end, event);
        }
        srcu_read_unlock(&srcu, id);
index ab2be52..ac69dae 100644 (file)
@@ -136,7 +136,6 @@ static inline unsigned long change_pmd_range(struct vm_area_struct *vma,
                pgprot_t newprot, int dirty_accountable, int prot_numa)
 {
        pmd_t *pmd;
-       struct mm_struct *mm = vma->vm_mm;
        unsigned long next;
        unsigned long pages = 0;
        unsigned long nr_huge_updates = 0;
@@ -150,7 +149,7 @@ static inline unsigned long change_pmd_range(struct vm_area_struct *vma,
                /* invoke the mmu notifier if the pmd is populated */
                if (!mni_start) {
                        mni_start = addr;
-                       mmu_notifier_invalidate_range_start(mm, mni_start,
+                       mmu_notifier_invalidate_range_start(vma, mni_start,
                                                            end, MMU_MPROT);
                }
 
@@ -181,7 +180,7 @@ static inline unsigned long change_pmd_range(struct vm_area_struct *vma,
        } while (pmd++, addr = next, addr != end);
 
        if (mni_start)
-               mmu_notifier_invalidate_range_end(mm, mni_start, end,
+               mmu_notifier_invalidate_range_end(vma, mni_start, end,
                                                  MMU_MPROT);
 
        if (nr_huge_updates)
index 9a8d455..2866a13 100644 (file)
@@ -158,7 +158,7 @@ unsigned long move_page_tables(struct vm_area_struct *vma,
 
        mmun_start = old_addr;
        mmun_end   = old_end;
-       mmu_notifier_invalidate_range_start(vma->vm_mm, mmun_start,
+       mmu_notifier_invalidate_range_start(vma, mmun_start,
                                            mmun_end, MMU_MIGRATE);
 
        for (; old_addr < old_end; old_addr += extent, new_addr += extent) {
@@ -210,7 +210,7 @@ unsigned long move_page_tables(struct vm_area_struct *vma,
        if (likely(need_flush))
                flush_tlb_range(vma, old_end-len, old_addr);
 
-       mmu_notifier_invalidate_range_end(vma->vm_mm, mmun_start,
+       mmu_notifier_invalidate_range_end(vma, mmun_start,
                                          mmun_end, MMU_MIGRATE);
 
        return len + old_addr - old_end;        /* how much done */
index 7de7ed2..b957e08 100644 (file)
--- a/mm/rmap.c
+++ b/mm/rmap.c
@@ -913,7 +913,7 @@ static int page_mkclean_one(struct page *page, struct vm_area_struct *vma,
        pte_unmap_unlock(pte, ptl);
 
        if (ret)
-               mmu_notifier_invalidate_page(mm, address, MMU_WRITE_BACK);
+               mmu_notifier_invalidate_page(vma, address, MMU_WRITE_BACK);
 out:
        return ret;
 }
@@ -1290,7 +1290,7 @@ int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 out_unmap:
        pte_unmap_unlock(pte, ptl);
        if (ret != SWAP_FAIL)
-               mmu_notifier_invalidate_page(mm, address, event);
+               mmu_notifier_invalidate_page(vma, address, event);
 out:
        return ret;
 
@@ -1378,7 +1378,8 @@ static int try_to_unmap_cluster(unsigned long cursor, unsigned int *mapcount,
 
        mmun_start = address;
        mmun_end   = end;
-       mmu_notifier_invalidate_range_start(mm, mmun_start, mmun_end, event);
+       mmu_notifier_invalidate_range_start(vma, mmun_start,
+                                           mmun_end, event);
 
        /*
         * If we can acquire the mmap_sem for read, and vma is VM_LOCKED,
@@ -1439,7 +1440,7 @@ static int try_to_unmap_cluster(unsigned long cursor, unsigned int *mapcount,
                (*mapcount)--;
        }
        pte_unmap_unlock(pte - 1, ptl);
-       mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end, event);
+       mmu_notifier_invalidate_range_end(vma, mmun_start, mmun_end, event);
        if (locked_vma)
                up_read(&vma->vm_mm->mmap_sem);
        return ret;
index afe2740..fa81c10 100644 (file)
@@ -274,7 +274,7 @@ static inline struct kvm *mmu_notifier_to_kvm(struct mmu_notifier *mn)
 }
 
 static void kvm_mmu_notifier_invalidate_page(struct mmu_notifier *mn,
-                                            struct mm_struct *mm,
+                                            struct vm_area_struct *vma,
                                             unsigned long address,
                                             enum mmu_event event)
 {
@@ -330,7 +330,7 @@ static void kvm_mmu_notifier_change_pte(struct mmu_notifier *mn,
 }
 
 static void kvm_mmu_notifier_invalidate_range_start(struct mmu_notifier *mn,
-                                                   struct mm_struct *mm,
+                                                   struct vm_area_struct *vma,
                                                    unsigned long start,
                                                    unsigned long end,
                                                    enum mmu_event event)
@@ -357,7 +357,7 @@ static void kvm_mmu_notifier_invalidate_range_start(struct mmu_notifier *mn,
 }
 
 static void kvm_mmu_notifier_invalidate_range_end(struct mmu_notifier *mn,
-                                                 struct mm_struct *mm,
+                                                 struct vm_area_struct *vma,
                                                  unsigned long start,
                                                  unsigned long end,
                                                  enum mmu_event event)