mmu_notifier: add event information to address invalidation v3
Jérôme Glisse [Fri, 2 Aug 2013 19:17:24 +0000 (15:17 -0400)]
The event information will be usefull for new user of mmu_notifier API.
The event argument differentiate between a vma disappearing, a page
being write protected or simply a page being unmaped. This allow new
user to take different path for different event for instance on unmap
the resource used to track a vma are still valid and should stay around.
While if the event is saying that a vma is being destroy it means that any
resources used to track this vma can be free.

Changed since v1:
  - renamed action into event (updated commit message too).
  - simplified the event names and clarified their intented usage
    also documenting what exceptation the listener can have in
    respect to each event.

Changed since v2:
  - Avoid crazy name.
  - Do not move code that do not need to move.

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

Conflicts:
drivers/gpu/drm/i915/i915_gem_userptr.c
fs/proc/task_mmu.c
kernel/events/uprobes.c
mm/huge_memory.c
mm/hugetlb.c
mm/ksm.c
mm/migrate.c
mm/rmap.c
include/linux/mmu_notifier.h

Bug 200074285

Change-Id: Ief91a665128bcb4ac5e6fa7dd60215285be54f20
Signed-off-by: Sri Krishna chowdary <schowdary@nvidia.com>
Reviewed-on: http://git-master/r/678260
Reviewed-by: Krishna Reddy <vdumpa@nvidia.com>
Reviewed-by: Hiroshi Doyu <hdoyu@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 5208828..c91d230 100644 (file)
@@ -421,21 +421,25 @@ static int mn_clear_flush_young(struct mmu_notifier *mn,
 static void mn_change_pte(struct mmu_notifier *mn,
                          struct mm_struct *mm,
                          unsigned long address,
-                         pte_t pte)
+                         pte_t pte,
+                         enum mmu_event event)
 {
        __mn_flush_page(mn, address);
 }
 
 static void mn_invalidate_page(struct mmu_notifier *mn,
                               struct mm_struct *mm,
-                              unsigned long address)
+                              unsigned long address,
+                              enum mmu_event event)
 {
        __mn_flush_page(mn, address);
 }
 
 static void mn_invalidate_range_start(struct mmu_notifier *mn,
                                      struct mm_struct *mm,
-                                     unsigned long start, unsigned long end)
+                                     unsigned long start,
+                                     unsigned long end,
+                                     enum mmu_event event)
 {
        struct pasid_state *pasid_state;
        struct device_state *dev_state;
@@ -449,7 +453,9 @@ static void mn_invalidate_range_start(struct mmu_notifier *mn,
 
 static void mn_invalidate_range_end(struct mmu_notifier *mn,
                                    struct mm_struct *mm,
-                                   unsigned long start, unsigned long end)
+                                   unsigned long start,
+                                   unsigned long end,
+                                   enum mmu_event event)
 {
        struct pasid_state *pasid_state;
        struct device_state *dev_state;
index 2129274..e67fed1 100644 (file)
@@ -221,7 +221,8 @@ void gru_flush_all_tlb(struct gru_state *gru)
  */
 static void gru_invalidate_range_start(struct mmu_notifier *mn,
                                       struct mm_struct *mm,
-                                      unsigned long start, unsigned long end)
+                                      unsigned long start, unsigned long end,
+                                      enum mmu_event event)
 {
        struct gru_mm_struct *gms = container_of(mn, struct gru_mm_struct,
                                                 ms_notifier);
@@ -235,7 +236,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,
-                                    unsigned long end)
+                                    unsigned long end,
+                                    enum mmu_event event)
 {
        struct gru_mm_struct *gms = container_of(mn, struct gru_mm_struct,
                                                 ms_notifier);
@@ -248,7 +250,8 @@ static void gru_invalidate_range_end(struct mmu_notifier *mn,
 }
 
 static void gru_invalidate_page(struct mmu_notifier *mn, struct mm_struct *mm,
-                               unsigned long address)
+                               unsigned long address,
+                               enum mmu_event event)
 {
        struct gru_mm_struct *gms = container_of(mn, struct gru_mm_struct,
                                                 ms_notifier);
index 3c8803f..6cb5910 100644 (file)
@@ -433,7 +433,9 @@ static void unmap_if_in_range(struct grant_map *map,
 
 static void mn_invl_range_start(struct mmu_notifier *mn,
                                struct mm_struct *mm,
-                               unsigned long start, unsigned long end)
+                               unsigned long start,
+                               unsigned long end,
+                               enum mmu_event event)
 {
        struct gntdev_priv *priv = container_of(mn, struct gntdev_priv, mn);
        struct grant_map *map;
@@ -450,9 +452,10 @@ static void mn_invl_range_start(struct mmu_notifier *mn,
 
 static void mn_invl_page(struct mmu_notifier *mn,
                         struct mm_struct *mm,
-                        unsigned long address)
+                        unsigned long address,
+                        enum mmu_event event)
 {
-       mn_invl_range_start(mn, mm, address, address + PAGE_SIZE);
+       mn_invl_range_start(mn, mm, address, address + PAGE_SIZE, event);
 }
 
 static void mn_release(struct mmu_notifier *mn,
index d46dbbf..dbd81f5 100644 (file)
@@ -9,6 +9,58 @@
 struct mmu_notifier;
 struct mmu_notifier_ops;
 
+/* MMU Events report fine-grained information to the callback routine, allowing
+ * the event listener to make a more informed decision as to what action to
+ * take. The event types are:
+ *
+ *   - MMU_MIGRATE: memory is migrating from one page to another, thus all write
+ *     access must stop after invalidate_range_start callback returns.
+ *     Furthermore, no read access should be allowed either, as a new page can
+ *     be remapped with write access before the invalidate_range_end callback
+ *     happens and thus any read access to old page might read stale data. There
+ *     are several sources for this event, including:
+ *
+ *         - A page moving to swap (various reasons, including page reclaim),
+ *         - An mremap syscall,
+ *         - migration for NUMA reasons,
+ *         - balancing the memory pool,
+ *         - write fault on COW page,
+ *         - and more that are not listed here.
+ *
+ *   - MMU_MPROT: memory access protection is changing. Refer to the vma to get
+ *     the new access protection. All memory access are still valid until the
+ *     invalidate_range_end callback.
+ *
+ *   - MMU_MUNMAP: the range is being unmapped (outcome of a munmap syscall or
+ *     process destruction). However, access is still allowed, up until the
+ *     invalidate_range_free_pages callback. This also implies that secondary
+ *     page table can be trimmed, because the address range is no longer valid.
+ *
+ *   - MMU_WRITE_BACK: memory is being written back to disk, all write accesses
+ *     must stop after invalidate_range_start callback returns. Read access are
+ *     still allowed.
+ *
+ *   - MMU_WRITE_PROTECT: memory is being writte protected (ie should be mapped
+ *     read only no matter what the vma memory protection allows). All write
+ *     accesses must stop after invalidate_range_start callback returns. Read
+ *     access are still allowed.
+ *
+ *   - MMU_STATUS memory status change, like soft dirty, or huge page
+ *     splitting flag being set on pmd.
+ *
+ * If in doubt when adding a new notifier caller, please use MMU_MIGRATE,
+ * because it will always lead to reasonable behavior, but will not allow the
+ * listener a chance to optimize its events.
+ */
+enum mmu_event {
+       MMU_MIGRATE = 0,
+       MMU_MPROT,
+       MMU_MUNMAP,
+       MMU_STATUS,
+       MMU_WRITE_BACK,
+       MMU_WRITE_PROTECT,
+};
+
 #ifdef CONFIG_MMU_NOTIFIER
 
 /*
@@ -79,7 +131,8 @@ struct mmu_notifier_ops {
        void (*change_pte)(struct mmu_notifier *mn,
                           struct mm_struct *mm,
                           unsigned long address,
-                          pte_t pte);
+                          pte_t pte,
+                          enum mmu_event event);
 
        /*
         * Before this is invoked any secondary MMU is still ok to
@@ -90,7 +143,8 @@ struct mmu_notifier_ops {
         */
        void (*invalidate_page)(struct mmu_notifier *mn,
                                struct mm_struct *mm,
-                               unsigned long address);
+                               unsigned long address,
+                               enum mmu_event event);
 
        /*
         * invalidate_range_start() and invalidate_range_end() must be
@@ -137,10 +191,14 @@ struct mmu_notifier_ops {
         */
        void (*invalidate_range_start)(struct mmu_notifier *mn,
                                       struct mm_struct *mm,
-                                      unsigned long start, unsigned long end);
+                                      unsigned long start,
+                                      unsigned long end,
+                                      enum mmu_event event);
        void (*invalidate_range_end)(struct mmu_notifier *mn,
                                     struct mm_struct *mm,
-                                    unsigned long start, unsigned long end);
+                                    unsigned long start,
+                                    unsigned long end,
+                                    enum mmu_event event);
 
        /*
         * invalidate_range() is either called between
@@ -203,13 +261,20 @@ extern int __mmu_notifier_clear_flush_young(struct mm_struct *mm,
 extern int __mmu_notifier_test_young(struct mm_struct *mm,
                                     unsigned long address);
 extern void __mmu_notifier_change_pte(struct mm_struct *mm,
-                                     unsigned long address, pte_t pte);
+                                     unsigned long address,
+                                     pte_t pte,
+                                     enum mmu_event event);
 extern void __mmu_notifier_invalidate_page(struct mm_struct *mm,
-                                         unsigned long address);
+                                         unsigned long address,
+                                         enum mmu_event event);
 extern void __mmu_notifier_invalidate_range_start(struct mm_struct *mm,
-                                 unsigned long start, unsigned long end);
+                                                 unsigned long start,
+                                                 unsigned long end,
+                                                 enum mmu_event event);
 extern void __mmu_notifier_invalidate_range_end(struct mm_struct *mm,
-                                 unsigned long start, unsigned long end);
+                                               unsigned long start,
+                                               unsigned long end,
+                                               enum mmu_event event);
 extern void __mmu_notifier_invalidate_range(struct mm_struct *mm,
                                  unsigned long start, unsigned long end);
 
@@ -236,31 +301,38 @@ static inline int mmu_notifier_test_young(struct mm_struct *mm,
 }
 
 static inline void mmu_notifier_change_pte(struct mm_struct *mm,
-                                          unsigned long address, pte_t pte)
+                                          unsigned long address,
+                                          pte_t pte,
+                                          enum mmu_event event)
 {
        if (mm_has_notifiers(mm))
-               __mmu_notifier_change_pte(mm, address, pte);
+               __mmu_notifier_change_pte(mm, address, pte, event);
 }
 
 static inline void mmu_notifier_invalidate_page(struct mm_struct *mm,
-                                         unsigned long address)
+                                               unsigned long address,
+                                               enum mmu_event event)
 {
        if (mm_has_notifiers(mm))
-               __mmu_notifier_invalidate_page(mm, address);
+               __mmu_notifier_invalidate_page(mm, address, event);
 }
 
 static inline void mmu_notifier_invalidate_range_start(struct mm_struct *mm,
-                                 unsigned long start, unsigned long end)
+                                                      unsigned long start,
+                                                      unsigned long end,
+                                                      enum mmu_event event)
 {
        if (mm_has_notifiers(mm))
-               __mmu_notifier_invalidate_range_start(mm, start, end);
+               __mmu_notifier_invalidate_range_start(mm, start, end, event);
 }
 
 static inline void mmu_notifier_invalidate_range_end(struct mm_struct *mm,
-                                 unsigned long start, unsigned long end)
+                                                    unsigned long start,
+                                                    unsigned long end,
+                                                    enum mmu_event event)
 {
        if (mm_has_notifiers(mm))
-               __mmu_notifier_invalidate_range_end(mm, start, end);
+               __mmu_notifier_invalidate_range_end(mm, start, end, event);
 }
 
 static inline void mmu_notifier_invalidate_range(struct mm_struct *mm,
@@ -351,13 +423,13 @@ static inline void mmu_notifier_mm_destroy(struct mm_struct *mm)
  * old page would remain mapped readonly in the secondary MMUs after the new
  * page is already writable by some CPU through the primary MMU.
  */
-#define set_pte_at_notify(__mm, __address, __ptep, __pte)              \
+#define set_pte_at_notify(__mm, __address, __ptep, __pte, __event)     \
 ({                                                                     \
        struct mm_struct *___mm = __mm;                                 \
        unsigned long ___address = __address;                           \
        pte_t ___pte = __pte;                                           \
                                                                        \
-       mmu_notifier_change_pte(___mm, ___address, ___pte);             \
+       mmu_notifier_change_pte(___mm, ___address, ___pte, __event);    \
        set_pte_at(___mm, ___address, __ptep, ___pte);                  \
 })
 
@@ -383,22 +455,29 @@ static inline int mmu_notifier_test_young(struct mm_struct *mm,
 }
 
 static inline void mmu_notifier_change_pte(struct mm_struct *mm,
-                                          unsigned long address, pte_t pte)
+                                          unsigned long address,
+                                          pte_t pte,
+                                          enum mmu_event event)
 {
 }
 
 static inline void mmu_notifier_invalidate_page(struct mm_struct *mm,
-                                         unsigned long address)
+                                               unsigned long address,
+                                               enum mmu_event event)
 {
 }
 
 static inline void mmu_notifier_invalidate_range_start(struct mm_struct *mm,
-                                 unsigned long start, unsigned long end)
+                                                      unsigned long start,
+                                                      unsigned long end,
+                                                      enum mmu_event event)
 {
 }
 
 static inline void mmu_notifier_invalidate_range_end(struct mm_struct *mm,
-                                 unsigned long start, unsigned long end)
+                                                    unsigned long start,
+                                                    unsigned long end,
+                                                    enum mmu_event event)
 {
 }
 
@@ -415,7 +494,14 @@ static inline void mmu_notifier_mm_destroy(struct mm_struct *mm)
 #define        ptep_clear_flush_notify ptep_clear_flush
 #define pmdp_clear_flush_notify pmdp_clear_flush
 #define pmdp_get_and_clear_notify pmdp_get_and_clear
-#define set_pte_at_notify set_pte_at
+#define set_pte_at_notify(__mm, __address, __ptep, __pte, __event)     \
+({                                                                     \
+       struct mm_struct *___mm = __mm;                                 \
+       unsigned long ___address = __address;                           \
+       pte_t ___pte = __pte;                                           \
+                                                                       \
+       set_pte_at(___mm, ___address, __ptep, ___pte);                  \
+})
 
 #endif /* CONFIG_MMU_NOTIFIER */
 
index cb47588..e8383a8 100644 (file)
@@ -137,7 +137,8 @@ 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, mmun_end);
+       mmu_notifier_invalidate_range_start(mm, mmun_start,
+                                           mmun_end, MMU_MIGRATE);
        err = -EAGAIN;
        ptep = page_check_address(page, mm, addr, &ptl, 0);
        if (!ptep)
@@ -153,7 +154,9 @@ static int __replace_page(struct vm_area_struct *vma, unsigned long addr,
 
        flush_cache_page(vma, addr, pte_pfn(*ptep));
        ptep_clear_flush_notify(vma, addr, ptep);
-       set_pte_at_notify(mm, addr, ptep, mk_pte(kpage, vma->vm_page_prot));
+       set_pte_at_notify(mm, addr, ptep,
+                         mk_pte(kpage, vma->vm_page_prot),
+                         MMU_MIGRATE);
 
        page_remove_rmap(page);
        if (!page_mapped(page))
@@ -166,7 +169,8 @@ static int __replace_page(struct vm_area_struct *vma, unsigned long addr,
 
        err = 0;
  unlock:
-       mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end);
+       mmu_notifier_invalidate_range_end(mm, mmun_start,
+                                         mmun_end, MMU_MIGRATE);
        unlock_page(page);
        return err;
 }
index 28fe26b..09fc50f 100644 (file)
@@ -198,7 +198,7 @@ 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_notifier_invalidate_page(mm, address, MMU_MIGRATE);
                        page_cache_release(page);
                }
        }
index 8d04ba4..53ddce6 100644 (file)
@@ -236,9 +236,11 @@ get_write_lock:
                vma->vm_flags = vm_flags;
        }
 
-       mmu_notifier_invalidate_range_start(mm, start, start + size);
+       /* XXX: using MMU_MIGRATE as it is OK. Need to optimize this */
+       mmu_notifier_invalidate_range_start(mm, 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_notifier_invalidate_range_end(mm, start, start + size, MMU_MIGRATE);
 
        /*
         * We can't clear VM_NONLINEAR because we'd have to do
index 6c85c63..664feb8 100644 (file)
@@ -1075,7 +1075,8 @@ 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(mm, mmun_start, mmun_end,
+                                           MMU_MIGRATE);
 
        spin_lock(&mm->page_table_lock);
        if (unlikely(!pmd_same(*pmd, orig_pmd)))
@@ -1105,7 +1106,8 @@ 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, mmun_end);
+       mmu_notifier_invalidate_range_end(mm, mmun_start,
+                                         mmun_end, MMU_MIGRATE);
 
        ret |= VM_FAULT_WRITE;
        put_page(page);
@@ -1115,7 +1117,8 @@ out:
 
 out_free_pages:
        spin_unlock(&mm->page_table_lock);
-       mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end);
+       mmu_notifier_invalidate_range_end(mm, mmun_start,
+                                         mmun_end, MMU_MIGRATE);
        mem_cgroup_uncharge_start();
        for (i = 0; i < HPAGE_PMD_NR; i++) {
                mem_cgroup_uncharge_page(pages[i]);
@@ -1198,7 +1201,8 @@ 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(mm, mmun_start, mmun_end,
+                                           MMU_MIGRATE);
 
        spin_lock(&mm->page_table_lock);
        if (page)
@@ -1227,7 +1231,8 @@ alloc:
        }
        spin_unlock(&mm->page_table_lock);
 out_mn:
-       mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end);
+       mmu_notifier_invalidate_range_end(mm, mmun_start,
+                                         mmun_end, MMU_MIGRATE);
 out:
        return ret;
 out_unlock:
@@ -1577,7 +1582,8 @@ 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, mmun_end);
+       mmu_notifier_invalidate_range_start(mm, mmun_start,
+                                           mmun_end, MMU_STATUS);
        spin_lock(&mm->page_table_lock);
        pmd = page_check_address_pmd(page, mm, address,
                                     PAGE_CHECK_ADDRESS_PMD_NOTSPLITTING_FLAG);
@@ -1594,7 +1600,8 @@ 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, mmun_end);
+       mmu_notifier_invalidate_range_end(mm, mmun_start,
+                                         mmun_end, MMU_STATUS);
 
        return ret;
 }
@@ -2351,7 +2358,8 @@ 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, mmun_end);
+       mmu_notifier_invalidate_range_start(mm, mmun_start,
+                                           mmun_end, MMU_MIGRATE);
        spin_lock(&mm->page_table_lock); /* probably unnecessary */
        /*
         * After this gup_fast can't run anymore. This also removes
@@ -2361,7 +2369,8 @@ 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, mmun_end);
+       mmu_notifier_invalidate_range_end(mm, mmun_start,
+                                         mmun_end, MMU_MIGRATE);
 
        spin_lock(ptl);
        isolated = __collapse_huge_page_isolate(vma, address, pte);
@@ -2744,24 +2753,28 @@ 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, mmun_end);
+       mmu_notifier_invalidate_range_start(mm, 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, mmun_end);
+               mmu_notifier_invalidate_range_end(mm, 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, mmun_end);
+               mmu_notifier_invalidate_range_end(mm, mmun_start,
+                                                 mmun_end, MMU_MIGRATE);
                return;
        }
        page = pmd_page(*pmd);
        VM_BUG_ON(!page_count(page));
        get_page(page);
        spin_unlock(&mm->page_table_lock);
-       mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end);
+       mmu_notifier_invalidate_range_end(mm, mmun_start,
+                                         mmun_end, MMU_MIGRATE);
 
        split_huge_page(page);
 
index 49eee80..38ea62c 100644 (file)
@@ -2372,7 +2372,8 @@ 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, mmun_end);
+               mmu_notifier_invalidate_range_start(src, mmun_start,
+                                                   mmun_end, MMU_MIGRATE);
 
        for (addr = vma->vm_start; addr < vma->vm_end; addr += sz) {
                src_pte = huge_pte_offset(src, addr);
@@ -2424,7 +2425,8 @@ int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src,
        }
 
        if (cow)
-               mmu_notifier_invalidate_range_end(src, mmun_start, mmun_end);
+               mmu_notifier_invalidate_range_end(src, mmun_start,
+                                                 mmun_end, MMU_MIGRATE);
 
        return ret;
 }
@@ -2449,7 +2451,8 @@ 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, mmun_end);
+       mmu_notifier_invalidate_range_start(mm, mmun_start,
+                                           mmun_end, MMU_MIGRATE);
 again:
        spin_lock(&mm->page_table_lock);
        for (address = start; address < end; address += sz) {
@@ -2515,7 +2518,8 @@ again:
                if (address < end && !ref_page)
                        goto again;
        }
-       mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end);
+       mmu_notifier_invalidate_range_end(mm, mmun_start,
+                                         mmun_end, MMU_MIGRATE);
        tlb_end_vma(tlb, vma);
 }
 
@@ -2705,7 +2709,8 @@ 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(mm, mmun_start, mmun_end,
+                                           MMU_MIGRATE);
        /*
         * Retake the page_table_lock to check for racing updates
         * before the page tables are altered
@@ -2724,7 +2729,8 @@ 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(mm, mmun_start, mmun_end,
+                                         MMU_MIGRATE);
        /* Caller expects lock to be held */
        spin_lock(&mm->page_table_lock);
        page_cache_release(new_page);
@@ -3121,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_notifier_invalidate_range_start(mm, 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)) {
@@ -3150,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_notifier_invalidate_range_end(mm, start, end, MMU_MPROT);
 
        return pages << h->order;
 }
index 05d1cbb..6d735ca 100644 (file)
--- a/mm/ksm.c
+++ b/mm/ksm.c
@@ -872,7 +872,8 @@ 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(mm, mmun_start, mmun_end,
+                                           MMU_WRITE_PROTECT);
 
        ptep = page_check_address(page, mm, addr, &ptl, 0);
        if (!ptep)
@@ -904,7 +905,7 @@ static int write_protect_page(struct vm_area_struct *vma, struct page *page,
                if (pte_dirty(entry))
                        set_page_dirty(page);
                entry = pte_mkclean(pte_wrprotect(entry));
-               set_pte_at_notify(mm, addr, ptep, entry);
+               set_pte_at_notify(mm, addr, ptep, entry, MMU_WRITE_PROTECT);
        }
        *orig_pte = *ptep;
        err = 0;
@@ -912,7 +913,8 @@ 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(mm, mmun_start, mmun_end,
+                                         MMU_WRITE_PROTECT);
 out:
        return err;
 }
@@ -949,7 +951,8 @@ 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(mm, mmun_start, mmun_end,
+                                           MMU_MIGRATE);
 
        ptep = pte_offset_map_lock(mm, pmd, addr, &ptl);
        if (!pte_same(*ptep, orig_pte)) {
@@ -962,7 +965,9 @@ static int replace_page(struct vm_area_struct *vma, struct page *page,
 
        flush_cache_page(vma, addr, pte_pfn(*ptep));
        ptep_clear_flush_notify(vma, addr, ptep);
-       set_pte_at_notify(mm, addr, ptep, mk_pte(kpage, vma->vm_page_prot));
+       set_pte_at_notify(mm, addr, ptep,
+                         mk_pte(kpage, vma->vm_page_prot),
+                         MMU_MIGRATE);
 
        page_remove_rmap(page);
        if (!page_mapped(page))
@@ -972,7 +977,8 @@ 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(mm, mmun_start, mmun_end,
+                                         MMU_MIGRATE);
 out:
        return err;
 }
index c26ddbe..e20d663 100644 (file)
@@ -1070,7 +1070,7 @@ int copy_page_range(struct mm_struct *dst_mm, struct mm_struct *src_mm,
        mmun_end   = end;
        if (is_cow)
                mmu_notifier_invalidate_range_start(src_mm, mmun_start,
-                                                   mmun_end);
+                                                   mmun_end, MMU_MIGRATE);
 
        ret = 0;
        dst_pgd = pgd_offset(dst_mm, addr);
@@ -1087,7 +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_notifier_invalidate_range_end(src_mm, mmun_start, mmun_end,
+                                                 MMU_MIGRATE);
        return ret;
 }
 
@@ -1384,10 +1385,12 @@ void unmap_vmas(struct mmu_gather *tlb,
 {
        struct mm_struct *mm = vma->vm_mm;
 
-       mmu_notifier_invalidate_range_start(mm, start_addr, end_addr);
+       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_notifier_invalidate_range_end(mm, start_addr,
+                                         end_addr, MMU_MUNMAP);
 }
 
 /**
@@ -1409,10 +1412,10 @@ 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_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_notifier_invalidate_range_end(mm, start, end, MMU_MUNMAP);
        tlb_finish_mmu(&tlb, start, end);
 }
 
@@ -1435,9 +1438,9 @@ 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_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_notifier_invalidate_range_end(mm, address, end, MMU_MUNMAP);
        tlb_finish_mmu(&tlb, address, end);
 }
 
@@ -2839,7 +2842,8 @@ gotten:
 
        mmun_start  = address & PAGE_MASK;
        mmun_end    = mmun_start + PAGE_SIZE;
-       mmu_notifier_invalidate_range_start(mm, mmun_start, mmun_end);
+       mmu_notifier_invalidate_range_start(mm, mmun_start,
+                                           mmun_end, MMU_MIGRATE);
 
        /*
         * Re-check the pte - we dropped the lock
@@ -2869,7 +2873,7 @@ gotten:
                 * mmu page tables (such as kvm shadow page tables), we want the
                 * new page to be mapped directly into the secondary page table.
                 */
-               set_pte_at_notify(mm, address, page_table, entry);
+               set_pte_at_notify(mm, address, page_table, entry, MMU_MIGRATE);
                update_mmu_cache(vma, address, page_table);
                if (old_page) {
                        /*
@@ -2908,7 +2912,8 @@ gotten:
 unlock:
        pte_unmap_unlock(page_table, ptl);
        if (mmun_end > mmun_start)
-               mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end);
+               mmu_notifier_invalidate_range_end(mm, mmun_start,
+                                                 mmun_end, MMU_MIGRATE);
        if (old_page) {
                /*
                 * Don't let another task, with possibly unlocked vma,
index e786fcb..ad1fbb8 100644 (file)
@@ -1765,11 +1765,13 @@ 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, mmun_end);
+       mmu_notifier_invalidate_range_start(mm, 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, mmun_end);
+               mmu_notifier_invalidate_range_end(mm, mmun_start,
+                                                 mmun_end, MMU_MIGRATE);
 
                /* Reverse changes made by migrate_page_copy() */
                if (TestClearPageActive(new_page))
@@ -1816,7 +1818,8 @@ 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, mmun_end);
+       mmu_notifier_invalidate_range_end(mm, mmun_start,
+                                         mmun_end, MMU_MIGRATE);
 
        unlock_page(new_page);
        unlock_page(page);
index 101c5b3..8bf6975 100644 (file)
@@ -133,8 +133,10 @@ int __mmu_notifier_test_young(struct mm_struct *mm,
        return young;
 }
 
-void __mmu_notifier_change_pte(struct mm_struct *mm, unsigned long address,
-                              pte_t pte)
+void __mmu_notifier_change_pte(struct mm_struct *mm,
+                              unsigned long address,
+                              pte_t pte,
+                              enum mmu_event event)
 {
        struct mmu_notifier *mn;
        int id;
@@ -142,13 +144,14 @@ void __mmu_notifier_change_pte(struct mm_struct *mm, unsigned long address,
        id = srcu_read_lock(&srcu);
        hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist) {
                if (mn->ops->change_pte)
-                       mn->ops->change_pte(mn, mm, address, pte);
+                       mn->ops->change_pte(mn, mm, address, pte, event);
        }
        srcu_read_unlock(&srcu, id);
 }
 
 void __mmu_notifier_invalidate_page(struct mm_struct *mm,
-                                         unsigned long address)
+                                   unsigned long address,
+                                   enum mmu_event event)
 {
        struct mmu_notifier *mn;
        int id;
@@ -156,13 +159,16 @@ void __mmu_notifier_invalidate_page(struct mm_struct *mm,
        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);
+                       mn->ops->invalidate_page(mn, mm, address, event);
        }
        srcu_read_unlock(&srcu, id);
 }
 
 void __mmu_notifier_invalidate_range_start(struct mm_struct *mm,
-                                 unsigned long start, unsigned long end)
+                                          unsigned long start,
+                                          unsigned long end,
+                                          enum mmu_event event)
+
 {
        struct mmu_notifier *mn;
        int id;
@@ -170,14 +176,17 @@ void __mmu_notifier_invalidate_range_start(struct mm_struct *mm,
        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, end);
+                       mn->ops->invalidate_range_start(mn, mm, 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,
-                                 unsigned long start, unsigned long end)
+                                        unsigned long start,
+                                        unsigned long end,
+                                        enum mmu_event event)
 {
        struct mmu_notifier *mn;
        int id;
@@ -195,7 +204,8 @@ 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, end);
+                       mn->ops->invalidate_range_end(mn, mm, start,
+                                                     end, event);
        }
        srcu_read_unlock(&srcu, id);
 }
index b487761..ab2be52 100644 (file)
@@ -150,7 +150,8 @@ 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, end);
+                       mmu_notifier_invalidate_range_start(mm, mni_start,
+                                                           end, MMU_MPROT);
                }
 
                if (pmd_trans_huge(*pmd)) {
@@ -180,7 +181,8 @@ 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(mm, mni_start, end,
+                                                 MMU_MPROT);
 
        if (nr_huge_updates)
                count_vm_numa_events(NUMA_HUGE_PTE_UPDATES, nr_huge_updates);
index 2201d06..9a8d455 100644 (file)
@@ -158,7 +158,8 @@ 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, mmun_end);
+       mmu_notifier_invalidate_range_start(vma->vm_mm, mmun_start,
+                                           mmun_end, MMU_MIGRATE);
 
        for (; old_addr < old_end; old_addr += extent, new_addr += extent) {
                cond_resched();
@@ -209,7 +210,8 @@ 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, mmun_end);
+       mmu_notifier_invalidate_range_end(vma->vm_mm, mmun_start,
+                                         mmun_end, MMU_MIGRATE);
 
        return len + old_addr - old_end;        /* how much done */
 }
index b64ba09..7de7ed2 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_notifier_invalidate_page(mm, address, MMU_WRITE_BACK);
 out:
        return ret;
 }
@@ -1195,6 +1195,10 @@ int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
        pte_t pteval;
        spinlock_t *ptl;
        int ret = SWAP_AGAIN;
+       enum mmu_event event = MMU_MIGRATE;
+
+       if (flags & TTU_MUNLOCK)
+               event = MMU_STATUS;
 
        pte = page_check_address(page, mm, address, &ptl, 0);
        if (!pte)
@@ -1286,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);
+               mmu_notifier_invalidate_page(mm, address, event);
 out:
        return ret;
 
@@ -1340,7 +1344,9 @@ out_mlock:
 #define CLUSTER_MASK   (~(CLUSTER_SIZE - 1))
 
 static int try_to_unmap_cluster(unsigned long cursor, unsigned int *mapcount,
-               struct vm_area_struct *vma, struct page *check_page)
+                               struct vm_area_struct *vma,
+                               struct page *check_page,
+                               enum ttu_flags flags)
 {
        struct mm_struct *mm = vma->vm_mm;
        pmd_t *pmd;
@@ -1354,6 +1360,10 @@ static int try_to_unmap_cluster(unsigned long cursor, unsigned int *mapcount,
        unsigned long end;
        int ret = SWAP_AGAIN;
        int locked_vma = 0;
+       enum mmu_event event = MMU_MIGRATE;
+
+       if (flags & TTU_MUNLOCK)
+               event = MMU_STATUS;
 
        address = (vma->vm_start + cursor) & CLUSTER_MASK;
        end = address + CLUSTER_SIZE;
@@ -1368,7 +1378,7 @@ 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);
+       mmu_notifier_invalidate_range_start(mm, mmun_start, mmun_end, event);
 
        /*
         * If we can acquire the mmap_sem for read, and vma is VM_LOCKED,
@@ -1429,7 +1439,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);
+       mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end, event);
        if (locked_vma)
                up_read(&vma->vm_mm->mmap_sem);
        return ret;
@@ -1589,7 +1599,8 @@ static int try_to_unmap_file(struct page *page, enum ttu_flags flags)
                        while ( cursor < max_nl_cursor &&
                                cursor < vma->vm_end - vma->vm_start) {
                                if (try_to_unmap_cluster(cursor, &mapcount,
-                                               vma, page) == SWAP_MLOCK)
+                                                        vma, page, flags)
+                                                        == SWAP_MLOCK)
                                        ret = SWAP_MLOCK;
                                cursor += CLUSTER_SIZE;
                                vma->vm_private_data = (void *) cursor;
index a17f190..afe2740 100644 (file)
@@ -275,7 +275,8 @@ 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,
-                                            unsigned long address)
+                                            unsigned long address,
+                                            enum mmu_event event)
 {
        struct kvm *kvm = mmu_notifier_to_kvm(mn);
        int need_tlb_flush, idx;
@@ -314,7 +315,8 @@ static void kvm_mmu_notifier_invalidate_page(struct mmu_notifier *mn,
 static void kvm_mmu_notifier_change_pte(struct mmu_notifier *mn,
                                        struct mm_struct *mm,
                                        unsigned long address,
-                                       pte_t pte)
+                                       pte_t pte,
+                                       enum mmu_event event)
 {
        struct kvm *kvm = mmu_notifier_to_kvm(mn);
        int idx;
@@ -330,7 +332,8 @@ 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,
                                                    unsigned long start,
-                                                   unsigned long end)
+                                                   unsigned long end,
+                                                   enum mmu_event event)
 {
        struct kvm *kvm = mmu_notifier_to_kvm(mn);
        int need_tlb_flush = 0, idx;
@@ -356,7 +359,8 @@ 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,
                                                  unsigned long start,
-                                                 unsigned long end)
+                                                 unsigned long end,
+                                                 enum mmu_event event)
 {
        struct kvm *kvm = mmu_notifier_to_kvm(mn);