arm64: mm: More flags for __flush_tlb_range()

Refactor function variants with "_nosync", "_local" and "_nonotify" into
a single __always_inline implementation that takes flags and rely on
constant folding to select the parts that are actually needed at any
given callsite, based on the provided flags.

Flags all live in the tlbf_t (TLB flags) type; TLBF_NONE (0) continues
to provide the strongest semantics (i.e. evict from walk cache,
broadcast, synchronise and notify). Each flag reduces the strength in
some way; TLBF_NONOTIFY, TLBF_NOSYNC and TLBF_NOBROADCAST are added to
complement the existing TLBF_NOWALKCACHE.

There are no users that require TLBF_NOBROADCAST without
TLBF_NOWALKCACHE so implement that as BUILD_BUG() to avoid needing to
introduce dead code for vae1 invalidations.

The result is a clearer, simpler, more powerful API.

Signed-off-by: Ryan Roberts <ryan.roberts@arm.com>
Reviewed-by: Jonathan Cameron <jonathan.cameron@huawei.com>
Signed-off-by: Catalin Marinas <catalin.marinas@arm.com>

diff --git a/arch/arm64/include/asm/tlbflush.h b/arch/arm64/include/asm/tlbflush.h
index d134824ea5daaf09bbb500e14f1e4a1651c92830..5509927e45b93b4a6ace6c2e4e1f86d6919d61be 100644 (file)
--- a/arch/arm64/include/asm/tlbflush.h
+++ b/arch/arm64/include/asm/tlbflush.h
@@ -295,7 +295,10 @@ static inline void __tlbi_sync_s1ish_hyp(void)
  *             no invalidation may take place. In the case where the level
  *             cannot be easily determined, the value TLBI_TTL_UNKNOWN will
  *             perform a non-hinted invalidation. flags may be TLBF_NONE (0) or
- *             TLBF_NOWALKCACHE (elide eviction of walk cache entries).
+ *             any combination of TLBF_NOWALKCACHE (elide eviction of walk
+ *             cache entries), TLBF_NONOTIFY (don't call mmu notifiers),
+ *             TLBF_NOSYNC (don't issue trailing dsb) and TLBF_NOBROADCAST
+ *             (only perform the invalidation for the local cpu).
  *
  *     local_flush_tlb_page(vma, addr)
  *             Local variant of flush_tlb_page().  Stale TLB entries may
@@ -305,12 +308,6 @@ static inline void __tlbi_sync_s1ish_hyp(void)
  *             Same as local_flush_tlb_page() except MMU notifier will not be
  *             called.
  *
- *     local_flush_tlb_contpte(vma, addr)
- *             Invalidate the virtual-address range
- *             '[addr, addr+CONT_PTE_SIZE)' mapped with contpte on local CPU
- *             for the user address space corresponding to 'vma->mm'.  Stale
- *             TLB entries may remain in remote CPUs.
- *
  *     Finally, take a look at asm/tlb.h to see how tlb_flush() is implemented
  *     on top of these routines, since that is our interface to the mmu_gather
  *     API as used by munmap() and friends.
@@ -552,15 +549,23 @@ typedef unsigned __bitwise tlbf_t;
 /* Invalidate tlb entries only, leaving the page table walk cache intact. */
 #define TLBF_NOWALKCACHE       ((__force tlbf_t)BIT(0))
 
-static inline void __flush_tlb_range_nosync(struct mm_struct *mm,
-                                    unsigned long start, unsigned long end,
-                                    unsigned long stride, int tlb_level,
-                                    tlbf_t flags)
+/* Skip the trailing dsb after issuing tlbi. */
+#define TLBF_NOSYNC            ((__force tlbf_t)BIT(1))
+
+/* Suppress tlb notifier callbacks for this flush operation. */
+#define TLBF_NONOTIFY          ((__force tlbf_t)BIT(2))
+
+/* Perform the tlbi locally without broadcasting to other CPUs. */
+#define TLBF_NOBROADCAST       ((__force tlbf_t)BIT(3))
+
+static __always_inline void __do_flush_tlb_range(struct vm_area_struct *vma,
+                                       unsigned long start, unsigned long end,
+                                       unsigned long stride, int tlb_level,
+                                       tlbf_t flags)
 {
+       struct mm_struct *mm = vma->vm_mm;
        unsigned long asid, pages;
 
-       start = round_down(start, stride);
-       end = round_up(end, stride);
        pages = (end - start) >> PAGE_SHIFT;
 
        if (__flush_tlb_range_limit_excess(pages, stride)) {
@@ -568,17 +573,41 @@ static inline void __flush_tlb_range_nosync(struct mm_struct *mm,
                return;
        }
 
-       dsb(ishst);
+       if (!(flags & TLBF_NOBROADCAST))
+               dsb(ishst);
+       else
+               dsb(nshst);
+
        asid = ASID(mm);
 
-       if (flags & TLBF_NOWALKCACHE)
-               __flush_s1_tlb_range_op(vale1is, start, pages, stride,
-                                    asid, tlb_level);
-       else
+       switch (flags & (TLBF_NOWALKCACHE | TLBF_NOBROADCAST)) {
+       case TLBF_NONE:
                __flush_s1_tlb_range_op(vae1is, start, pages, stride,
-                                    asid, tlb_level);
+                                       asid, tlb_level);
+               break;
+       case TLBF_NOWALKCACHE:
+               __flush_s1_tlb_range_op(vale1is, start, pages, stride,
+                                       asid, tlb_level);
+               break;
+       case TLBF_NOBROADCAST:
+               /* Combination unused */
+               BUG();
+               break;
+       case TLBF_NOWALKCACHE | TLBF_NOBROADCAST:
+               __flush_s1_tlb_range_op(vale1, start, pages, stride,
+                                       asid, tlb_level);
+               break;
+       }
+
+       if (!(flags & TLBF_NONOTIFY))
+               mmu_notifier_arch_invalidate_secondary_tlbs(mm, start, end);
 
-       mmu_notifier_arch_invalidate_secondary_tlbs(mm, start, end);
+       if (!(flags & TLBF_NOSYNC)) {
+               if (!(flags & TLBF_NOBROADCAST))
+                       __tlbi_sync_s1ish();
+               else
+                       dsb(nsh);
+       }
 }
 
 static inline void __flush_tlb_range(struct vm_area_struct *vma,
@@ -586,24 +615,9 @@ static inline void __flush_tlb_range(struct vm_area_struct *vma,
                                     unsigned long stride, int tlb_level,
                                     tlbf_t flags)
 {
-       __flush_tlb_range_nosync(vma->vm_mm, start, end, stride,
-                                tlb_level, flags);
-       __tlbi_sync_s1ish();
-}
-
-static inline void local_flush_tlb_contpte(struct vm_area_struct *vma,
-                                          unsigned long addr)
-{
-       unsigned long asid;
-
-       addr = round_down(addr, CONT_PTE_SIZE);
-
-       dsb(nshst);
-       asid = ASID(vma->vm_mm);
-       __flush_s1_tlb_range_op(vale1, addr, CONT_PTES, PAGE_SIZE, asid, 3);
-       mmu_notifier_arch_invalidate_secondary_tlbs(vma->vm_mm, addr,
-                                                   addr + CONT_PTE_SIZE);
-       dsb(nsh);
+       start = round_down(start, stride);
+       end = round_up(end, stride);
+       __do_flush_tlb_range(vma, start, end, stride, tlb_level, flags);
 }
 
 static inline void flush_tlb_range(struct vm_area_struct *vma,
@@ -656,7 +670,10 @@ static inline void __flush_tlb_kernel_pgtable(unsigned long kaddr)
 static inline void arch_tlbbatch_add_pending(struct arch_tlbflush_unmap_batch *batch,
                struct mm_struct *mm, unsigned long start, unsigned long end)
 {
-       __flush_tlb_range_nosync(mm, start, end, PAGE_SIZE, 3, TLBF_NOWALKCACHE);
+       struct vm_area_struct vma = { .vm_mm = mm, .vm_flags = 0 };
+
+       __flush_tlb_range(&vma, start, end, PAGE_SIZE, 3,
+                         TLBF_NOWALKCACHE | TLBF_NOSYNC);
 }
 
 static inline bool __pte_flags_need_flush(ptdesc_t oldval, ptdesc_t newval)

diff --git a/arch/arm64/mm/contpte.c b/arch/arm64/mm/contpte.c
index 5f2a7b43ca329bbeff08482490777fa7224a60e2..3970392c43267c587586ee5158c204b2c4ace45c 100644 (file)
--- a/arch/arm64/mm/contpte.c
+++ b/arch/arm64/mm/contpte.c
@@ -552,8 +552,8 @@ int contpte_clear_flush_young_ptes(struct vm_area_struct *vma,
                 * See comment in __ptep_clear_flush_young(); same rationale for
                 * eliding the trailing DSB applies here.
                 */
-               __flush_tlb_range_nosync(vma->vm_mm, addr, end,
-                                        PAGE_SIZE, 3, TLBF_NOWALKCACHE);
+               __flush_tlb_range(vma, addr, end, PAGE_SIZE, 3,
+                                 TLBF_NOWALKCACHE | TLBF_NOSYNC);
        }
 
        return young;
@@ -686,7 +686,10 @@ int contpte_ptep_set_access_flags(struct vm_area_struct *vma,
                        __ptep_set_access_flags(vma, addr, ptep, entry, 0);
 
                if (dirty)
-                       local_flush_tlb_contpte(vma, start_addr);
+                       __flush_tlb_range(vma, start_addr,
+                                         start_addr + CONT_PTE_SIZE,
+                                         PAGE_SIZE, 3,
+                                         TLBF_NOWALKCACHE | TLBF_NOBROADCAST);
        } else {
                __contpte_try_unfold(vma->vm_mm, addr, ptep, orig_pte);
                __ptep_set_access_flags(vma, addr, ptep, entry, dirty);