arch/powerpc/mm/tlb-radix.c

   1 /*
   2  * TLB flush routines for radix kernels.
   3  *
   4  * Copyright 2015-2016, Aneesh Kumar K.V, IBM Corporation.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11
  12 #include <linux/mm.h>
  13 #include <linux/hugetlb.h>
  14 #include <linux/memblock.h>
  15
  16 #include <asm/ppc-opcode.h>
  17 #include <asm/tlb.h>
  18 #include <asm/tlbflush.h>
  19 #include <asm/trace.h>
  20 #include <asm/cputhreads.h>
  21
  22 #define RIC_FLUSH_TLB 0
  23 #define RIC_FLUSH_PWC 1
  24 #define RIC_FLUSH_ALL 2
  25
  26 static inline void __tlbiel_pid(unsigned long pid, int set,
  27                                 unsigned long ric)
  28 {
  29         unsigned long rb,rs,prs,r;
  30
  31         rb = PPC_BIT(53); /* IS = 1 */
  32         rb |= set << PPC_BITLSHIFT(51);
  33         rs = ((unsigned long)pid) << PPC_BITLSHIFT(31);
  34         prs = 1; /* process scoped */
  35         r = 1;   /* raidx format */
  36
  37         asm volatile(PPC_TLBIEL(%0, %4, %3, %2, %1)
  38                      : : "r"(rb), "i"(r), "i"(prs), "i"(ric), "r"(rs) : "memory");
  39         trace_tlbie(0, 1, rb, rs, ric, prs, r);
  40 }
  41
  42 /*
  43  * We use 128 set in radix mode and 256 set in hpt mode.
  44  */
  45 static inline void _tlbiel_pid(unsigned long pid, unsigned long ric)
  46 {
  47         int set;
  48
  49         asm volatile("ptesync": : :"memory");
  50
  51         /*
  52          * Flush the first set of the TLB, and if we're doing a RIC_FLUSH_ALL,
  53          * also flush the entire Page Walk Cache.
  54          */
  55         __tlbiel_pid(pid, 0, ric);
  56
  57         /* For PWC, only one flush is needed */
  58         if (ric == RIC_FLUSH_PWC) {
  59                 asm volatile("ptesync": : :"memory");
  60                 return;
  61         }
  62
  63         /* For the remaining sets, just flush the TLB */
  64         for (set = 1; set < POWER9_TLB_SETS_RADIX ; set++)
  65                 __tlbiel_pid(pid, set, RIC_FLUSH_TLB);
  66
  67         asm volatile("ptesync": : :"memory");
  68         asm volatile(PPC_INVALIDATE_ERAT "; isync" : : :"memory");
  69 }
  70
  71 static inline void _tlbie_pid(unsigned long pid, unsigned long ric)
  72 {
  73         unsigned long rb,rs,prs,r;
  74
  75         rb = PPC_BIT(53); /* IS = 1 */
  76         rs = pid << PPC_BITLSHIFT(31);
  77         prs = 1; /* process scoped */
  78         r = 1;   /* raidx format */
  79
  80         asm volatile("ptesync": : :"memory");
  81         asm volatile(PPC_TLBIE_5(%0, %4, %3, %2, %1)
  82                      : : "r"(rb), "i"(r), "i"(prs), "i"(ric), "r"(rs) : "memory");
  83         asm volatile("eieio; tlbsync; ptesync": : :"memory");
  84         trace_tlbie(0, 0, rb, rs, ric, prs, r);
  85 }
  86
  87 static inline void _tlbiel_va(unsigned long va, unsigned long pid,
  88                               unsigned long ap, unsigned long ric)
  89 {
  90         unsigned long rb,rs,prs,r;
  91
  92         rb = va & ~(PPC_BITMASK(52, 63));
  93         rb |= ap << PPC_BITLSHIFT(58);
  94         rs = pid << PPC_BITLSHIFT(31);
  95         prs = 1; /* process scoped */
  96         r = 1;   /* raidx format */
  97
  98         asm volatile("ptesync": : :"memory");
  99         asm volatile(PPC_TLBIEL(%0, %4, %3, %2, %1)
 100                      : : "r"(rb), "i"(r), "i"(prs), "i"(ric), "r"(rs) : "memory");
 101         asm volatile("ptesync": : :"memory");
 102         trace_tlbie(0, 1, rb, rs, ric, prs, r);
 103 }
 104
 105 static inline void _tlbie_va(unsigned long va, unsigned long pid,
 106                              unsigned long ap, unsigned long ric)
 107 {
 108         unsigned long rb,rs,prs,r;
 109
 110         rb = va & ~(PPC_BITMASK(52, 63));
 111         rb |= ap << PPC_BITLSHIFT(58);
 112         rs = pid << PPC_BITLSHIFT(31);
 113         prs = 1; /* process scoped */
 114         r = 1;   /* raidx format */
 115
 116         asm volatile("ptesync": : :"memory");
 117         asm volatile(PPC_TLBIE_5(%0, %4, %3, %2, %1)
 118                      : : "r"(rb), "i"(r), "i"(prs), "i"(ric), "r"(rs) : "memory");
 119         asm volatile("eieio; tlbsync; ptesync": : :"memory");
 120         trace_tlbie(0, 0, rb, rs, ric, prs, r);
 121 }
 122
 123 /*
 124  * Base TLB flushing operations:
 125  *
 126  *  - flush_tlb_mm(mm) flushes the specified mm context TLB's
 127  *  - flush_tlb_page(vma, vmaddr) flushes one page
 128  *  - flush_tlb_range(vma, start, end) flushes a range of pages
 129  *  - flush_tlb_kernel_range(start, end) flushes kernel pages
 130  *
 131  *  - local_* variants of page and mm only apply to the current
 132  *    processor
 133  */
 134 void radix__local_flush_tlb_mm(struct mm_struct *mm)
 135 {
 136         unsigned long pid;
 137
 138         preempt_disable();
 139         pid = mm->context.id;
 140         if (pid != MMU_NO_CONTEXT)
 141                 _tlbiel_pid(pid, RIC_FLUSH_TLB);
 142         preempt_enable();
 143 }
 144 EXPORT_SYMBOL(radix__local_flush_tlb_mm);
 145
 146 #ifndef CONFIG_SMP
 147 static void radix__local_flush_all_mm(struct mm_struct *mm)
 148 {
 149         unsigned long pid;
 150
 151         preempt_disable();
 152         pid = mm->context.id;
 153         if (pid != MMU_NO_CONTEXT)
 154                 _tlbiel_pid(pid, RIC_FLUSH_ALL);
 155         preempt_enable();
 156 }
 157 #endif /* CONFIG_SMP */
 158
 159 void radix__local_flush_tlb_page_psize(struct mm_struct *mm, unsigned long vmaddr,
 160                                        int psize)
 161 {
 162         unsigned long pid;
 163         unsigned long ap = mmu_get_ap(psize);
 164
 165         preempt_disable();
 166         pid = mm ? mm->context.id : 0;
 167         if (pid != MMU_NO_CONTEXT)
 168                 _tlbiel_va(vmaddr, pid, ap, RIC_FLUSH_TLB);
 169         preempt_enable();
 170 }
 171
 172 void radix__local_flush_tlb_page(struct vm_area_struct *vma, unsigned long vmaddr)
 173 {
 174 #ifdef CONFIG_HUGETLB_PAGE
 175         /* need the return fix for nohash.c */
 176         if (vma && is_vm_hugetlb_page(vma))
 177                 return __local_flush_hugetlb_page(vma, vmaddr);
 178 #endif
 179         radix__local_flush_tlb_page_psize(vma ? vma->vm_mm : NULL, vmaddr,
 180                                           mmu_virtual_psize);
 181 }
 182 EXPORT_SYMBOL(radix__local_flush_tlb_page);
 183
 184 #ifdef CONFIG_SMP
 185 void radix__flush_tlb_mm(struct mm_struct *mm)
 186 {
 187         unsigned long pid;
 188
 189         preempt_disable();
 190         pid = mm->context.id;
 191         if (unlikely(pid == MMU_NO_CONTEXT))
 192                 goto no_context;
 193
 194         if (!mm_is_thread_local(mm))
 195                 _tlbie_pid(pid, RIC_FLUSH_TLB);
 196         else
 197                 _tlbiel_pid(pid, RIC_FLUSH_TLB);
 198 no_context:
 199         preempt_enable();
 200 }
 201 EXPORT_SYMBOL(radix__flush_tlb_mm);
 202
 203 static void radix__flush_all_mm(struct mm_struct *mm)
 204 {
 205         unsigned long pid;
 206
 207         preempt_disable();
 208         pid = mm->context.id;
 209         if (unlikely(pid == MMU_NO_CONTEXT))
 210                 goto no_context;
 211
 212         if (!mm_is_thread_local(mm))
 213                 _tlbie_pid(pid, RIC_FLUSH_ALL);
 214         else
 215                 _tlbiel_pid(pid, RIC_FLUSH_ALL);
 216 no_context:
 217         preempt_enable();
 218 }
 219
 220 void radix__flush_tlb_pwc(struct mmu_gather *tlb, unsigned long addr)
 221 {
 222         tlb->need_flush_all = 1;
 223 }
 224 EXPORT_SYMBOL(radix__flush_tlb_pwc);
 225
 226 void radix__flush_tlb_page_psize(struct mm_struct *mm, unsigned long vmaddr,
 227                                  int psize)
 228 {
 229         unsigned long pid;
 230         unsigned long ap = mmu_get_ap(psize);
 231
 232         preempt_disable();
 233         pid = mm ? mm->context.id : 0;
 234         if (unlikely(pid == MMU_NO_CONTEXT))
 235                 goto bail;
 236         if (!mm_is_thread_local(mm))
 237                 _tlbie_va(vmaddr, pid, ap, RIC_FLUSH_TLB);
 238         else
 239                 _tlbiel_va(vmaddr, pid, ap, RIC_FLUSH_TLB);
 240 bail:
 241         preempt_enable();
 242 }
 243
 244 void radix__flush_tlb_page(struct vm_area_struct *vma, unsigned long vmaddr)
 245 {
 246 #ifdef CONFIG_HUGETLB_PAGE
 247         if (vma && is_vm_hugetlb_page(vma))
 248                 return flush_hugetlb_page(vma, vmaddr);
 249 #endif
 250         radix__flush_tlb_page_psize(vma ? vma->vm_mm : NULL, vmaddr,
 251                                     mmu_virtual_psize);
 252 }
 253 EXPORT_SYMBOL(radix__flush_tlb_page);
 254
 255 #else /* CONFIG_SMP */
 256 #define radix__flush_all_mm radix__local_flush_all_mm
 257 #endif /* CONFIG_SMP */
 258
 259 void radix__flush_tlb_kernel_range(unsigned long start, unsigned long end)
 260 {
 261         _tlbie_pid(0, RIC_FLUSH_ALL);
 262 }
 263 EXPORT_SYMBOL(radix__flush_tlb_kernel_range);
 264
 265 /*
 266  * Currently, for range flushing, we just do a full mm flush. Because
 267  * we use this in code path where we don' track the page size.
 268  */
 269 void radix__flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
 270                      unsigned long end)
 271
 272 {
 273         struct mm_struct *mm = vma->vm_mm;
 274
 275         radix__flush_tlb_mm(mm);
 276 }
 277 EXPORT_SYMBOL(radix__flush_tlb_range);
 278
 279 static int radix_get_mmu_psize(int page_size)
 280 {
 281         int psize;
 282
 283         if (page_size == (1UL << mmu_psize_defs[mmu_virtual_psize].shift))
 284                 psize = mmu_virtual_psize;
 285         else if (page_size == (1UL << mmu_psize_defs[MMU_PAGE_2M].shift))
 286                 psize = MMU_PAGE_2M;
 287         else if (page_size == (1UL << mmu_psize_defs[MMU_PAGE_1G].shift))
 288                 psize = MMU_PAGE_1G;
 289         else
 290                 return -1;
 291         return psize;
 292 }
 293
 294 void radix__tlb_flush(struct mmu_gather *tlb)
 295 {
 296         int psize = 0;
 297         struct mm_struct *mm = tlb->mm;
 298         int page_size = tlb->page_size;
 299
 300         psize = radix_get_mmu_psize(page_size);
 301         /*
 302          * if page size is not something we understand, do a full mm flush
 303          */
 304         if (psize != -1 && !tlb->fullmm && !tlb->need_flush_all)
 305                 radix__flush_tlb_range_psize(mm, tlb->start, tlb->end, psize);
 306         else if (tlb->need_flush_all) {
 307                 tlb->need_flush_all = 0;
 308                 radix__flush_all_mm(mm);
 309         } else
 310                 radix__flush_tlb_mm(mm);
 311 }
 312
 313 #define TLB_FLUSH_ALL -1UL
 314 /*
 315  * Number of pages above which we will do a bcast tlbie. Just a
 316  * number at this point copied from x86
 317  */
 318 static unsigned long tlb_single_page_flush_ceiling __read_mostly = 33;
 319
 320 void radix__flush_tlb_range_psize(struct mm_struct *mm, unsigned long start,
 321                                   unsigned long end, int psize)
 322 {
 323         unsigned long pid;
 324         unsigned long addr;
 325         int local = mm_is_thread_local(mm);
 326         unsigned long ap = mmu_get_ap(psize);
 327         unsigned long page_size = 1UL << mmu_psize_defs[psize].shift;
 328
 329
 330         preempt_disable();
 331         pid = mm ? mm->context.id : 0;
 332         if (unlikely(pid == MMU_NO_CONTEXT))
 333                 goto err_out;
 334
 335         if (end == TLB_FLUSH_ALL ||
 336             (end - start) > tlb_single_page_flush_ceiling * page_size) {
 337                 if (local)
 338                         _tlbiel_pid(pid, RIC_FLUSH_TLB);
 339                 else
 340                         _tlbie_pid(pid, RIC_FLUSH_TLB);
 341                 goto err_out;
 342         }
 343         for (addr = start; addr < end; addr += page_size) {
 344
 345                 if (local)
 346                         _tlbiel_va(addr, pid, ap, RIC_FLUSH_TLB);
 347                 else
 348                         _tlbie_va(addr, pid, ap, RIC_FLUSH_TLB);
 349         }
 350 err_out:
 351         preempt_enable();
 352 }
 353
 354 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 355 void radix__flush_tlb_collapsed_pmd(struct mm_struct *mm, unsigned long addr)
 356 {
 357         int local = mm_is_thread_local(mm);
 358         unsigned long ap = mmu_get_ap(mmu_virtual_psize);
 359         unsigned long pid, end;
 360
 361
 362         pid = mm ? mm->context.id : 0;
 363         preempt_disable();
 364         if (unlikely(pid == MMU_NO_CONTEXT))
 365                 goto no_context;
 366
 367         /* 4k page size, just blow the world */
 368         if (PAGE_SIZE == 0x1000) {
 369                 radix__flush_all_mm(mm);
 370                 preempt_enable();
 371                 return;
 372         }
 373
 374         /* Otherwise first do the PWC */
 375         if (local)
 376                 _tlbiel_pid(pid, RIC_FLUSH_PWC);
 377         else
 378                 _tlbie_pid(pid, RIC_FLUSH_PWC);
 379
 380         /* Then iterate the pages */
 381         end = addr + HPAGE_PMD_SIZE;
 382         for (; addr < end; addr += PAGE_SIZE) {
 383                 if (local)
 384                         _tlbiel_va(addr, pid, ap, RIC_FLUSH_TLB);
 385                 else
 386                         _tlbie_va(addr, pid, ap, RIC_FLUSH_TLB);
 387         }
 388 no_context:
 389         preempt_enable();
 390 }
 391 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
 392
 393 void radix__flush_tlb_lpid_va(unsigned long lpid, unsigned long gpa,
 394                               unsigned long page_size)
 395 {
 396         unsigned long rb,rs,prs,r;
 397         unsigned long ap;
 398         unsigned long ric = RIC_FLUSH_TLB;
 399
 400         ap = mmu_get_ap(radix_get_mmu_psize(page_size));
 401         rb = gpa & ~(PPC_BITMASK(52, 63));
 402         rb |= ap << PPC_BITLSHIFT(58);
 403         rs = lpid & ((1UL << 32) - 1);
 404         prs = 0; /* process scoped */
 405         r = 1;   /* raidx format */
 406
 407         asm volatile("ptesync": : :"memory");
 408         asm volatile(PPC_TLBIE_5(%0, %4, %3, %2, %1)
 409                      : : "r"(rb), "i"(r), "i"(prs), "i"(ric), "r"(rs) : "memory");
 410         asm volatile("eieio; tlbsync; ptesync": : :"memory");
 411         trace_tlbie(lpid, 0, rb, rs, ric, prs, r);
 412 }
 413 EXPORT_SYMBOL(radix__flush_tlb_lpid_va);
 414
 415 void radix__flush_tlb_lpid(unsigned long lpid)
 416 {
 417         unsigned long rb,rs,prs,r;
 418         unsigned long ric = RIC_FLUSH_ALL;
 419
 420         rb = 0x2 << PPC_BITLSHIFT(53); /* IS = 2 */
 421         rs = lpid & ((1UL << 32) - 1);
 422         prs = 0; /* partition scoped */
 423         r = 1;   /* raidx format */
 424
 425         asm volatile("ptesync": : :"memory");
 426         asm volatile(PPC_TLBIE_5(%0, %4, %3, %2, %1)
 427                      : : "r"(rb), "i"(r), "i"(prs), "i"(ric), "r"(rs) : "memory");
 428         asm volatile("eieio; tlbsync; ptesync": : :"memory");
 429         trace_tlbie(lpid, 0, rb, rs, ric, prs, r);
 430 }
 431 EXPORT_SYMBOL(radix__flush_tlb_lpid);
 432
 433 void radix__flush_pmd_tlb_range(struct vm_area_struct *vma,
 434                                 unsigned long start, unsigned long end)
 435 {
 436         radix__flush_tlb_range_psize(vma->vm_mm, start, end, MMU_PAGE_2M);
 437 }
 438 EXPORT_SYMBOL(radix__flush_pmd_tlb_range);
 439
 440 void radix__flush_tlb_all(void)
 441 {
 442         unsigned long rb,prs,r,rs;
 443         unsigned long ric = RIC_FLUSH_ALL;
 444
 445         rb = 0x3 << PPC_BITLSHIFT(53); /* IS = 3 */
 446         prs = 0; /* partition scoped */
 447         r = 1;   /* raidx format */
 448         rs = 1 & ((1UL << 32) - 1); /* any LPID value to flush guest mappings */
 449
 450         asm volatile("ptesync": : :"memory");
 451         /*
 452          * now flush guest entries by passing PRS = 1 and LPID != 0
 453          */
 454         asm volatile(PPC_TLBIE_5(%0, %4, %3, %2, %1)
 455                      : : "r"(rb), "i"(r), "i"(1), "i"(ric), "r"(rs) : "memory");
 456         trace_tlbie(0, 0, rb, rs, ric, prs, r);
 457         /*
 458          * now flush host entires by passing PRS = 0 and LPID == 0
 459          */
 460         asm volatile(PPC_TLBIE_5(%0, %4, %3, %2, %1)
 461                      : : "r"(rb), "i"(r), "i"(prs), "i"(ric), "r"(0) : "memory");
 462         asm volatile("eieio; tlbsync; ptesync": : :"memory");
 463         trace_tlbie(0, 0, rb, 0, ric, prs, r);
 464 }
 465
 466 void radix__flush_tlb_pte_p9_dd1(unsigned long old_pte, struct mm_struct *mm,
 467                                  unsigned long address)
 468 {
 469         /*
 470          * We track page size in pte only for DD1, So we can
 471          * call this only on DD1.
 472          */
 473         if (!cpu_has_feature(CPU_FTR_POWER9_DD1)) {
 474                 VM_WARN_ON(1);
 475                 return;
 476         }
 477
 478         if (old_pte & R_PAGE_LARGE)
 479                 radix__flush_tlb_page_psize(mm, address, MMU_PAGE_2M);
 480         else
 481                 radix__flush_tlb_page_psize(mm, address, mmu_virtual_psize);
 482 }
 483
 484 #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE
 485 extern void radix_kvm_prefetch_workaround(struct mm_struct *mm)
 486 {
 487         unsigned int pid = mm->context.id;
 488
 489         if (unlikely(pid == MMU_NO_CONTEXT))
 490                 return;
 491
 492         /*
 493          * If this context hasn't run on that CPU before and KVM is
 494          * around, there's a slim chance that the guest on another
 495          * CPU just brought in obsolete translation into the TLB of
 496          * this CPU due to a bad prefetch using the guest PID on
 497          * the way into the hypervisor.
 498          *
 499          * We work around this here. If KVM is possible, we check if
 500          * any sibling thread is in KVM. If it is, the window may exist
 501          * and thus we flush that PID from the core.
 502          *
 503          * A potential future improvement would be to mark which PIDs
 504          * have never been used on the system and avoid it if the PID
 505          * is new and the process has no other cpumask bit set.
 506          */
 507         if (cpu_has_feature(CPU_FTR_HVMODE) && radix_enabled()) {
 508                 int cpu = smp_processor_id();
 509                 int sib = cpu_first_thread_sibling(cpu);
 510                 bool flush = false;
 511
 512                 for (; sib <= cpu_last_thread_sibling(cpu) && !flush; sib++) {
 513                         if (sib == cpu)
 514                                 continue;
 515                         if (paca[sib].kvm_hstate.kvm_vcpu)
 516                                 flush = true;
 517                 }
 518                 if (flush)
 519                         _tlbiel_pid(pid, RIC_FLUSH_ALL);
 520         }
 521 }
 522 EXPORT_SYMBOL_GPL(radix_kvm_prefetch_workaround);
 523 #endif /* CONFIG_KVM_BOOK3S_HV_POSSIBLE */