arch/powerpc/mm/slb.c

   1 /*
   2  * PowerPC64 SLB support.
   3  *
   4  * Copyright (C) 2004 David Gibson <dwg@au.ibm.com>, IBM
   5  * Based on earlier code written by:
   6  * Dave Engebretsen and Mike Corrigan {engebret|mikejc}@us.ibm.com
   7  *    Copyright (c) 2001 Dave Engebretsen
   8  * Copyright (C) 2002 Anton Blanchard <anton@au.ibm.com>, IBM
   9  *
  10  *
  11  *      This program is free software; you can redistribute it and/or
  12  *      modify it under the terms of the GNU General Public License
  13  *      as published by the Free Software Foundation; either version
  14  *      2 of the License, or (at your option) any later version.
  15  */
  16
  17 #include <asm/pgtable.h>
  18 #include <asm/mmu.h>
  19 #include <asm/mmu_context.h>
  20 #include <asm/paca.h>
  21 #include <asm/cputable.h>
  22 #include <asm/cacheflush.h>
  23 #include <asm/smp.h>
  24 #include <linux/compiler.h>
  25 #include <linux/context_tracking.h>
  26 #include <linux/mm_types.h>
  27
  28 #include <asm/udbg.h>
  29 #include <asm/code-patching.h>
  30
  31 enum slb_index {
  32         LINEAR_INDEX    = 0, /* Kernel linear map  (0xc000000000000000) */
  33         VMALLOC_INDEX   = 1, /* Kernel virtual map (0xd000000000000000) */
  34         KSTACK_INDEX    = 2, /* Kernel stack map */
  35 };
  36
  37 extern void slb_allocate(unsigned long ea);
  38
  39 #define slb_esid_mask(ssize)    \
  40         (((ssize) == MMU_SEGSIZE_256M)? ESID_MASK: ESID_MASK_1T)
  41
  42 static inline unsigned long mk_esid_data(unsigned long ea, int ssize,
  43                                          enum slb_index index)
  44 {
  45         return (ea & slb_esid_mask(ssize)) | SLB_ESID_V | index;
  46 }
  47
  48 static inline unsigned long mk_vsid_data(unsigned long ea, int ssize,
  49                                          unsigned long flags)
  50 {
  51         return (get_kernel_vsid(ea, ssize) << slb_vsid_shift(ssize)) | flags |
  52                 ((unsigned long) ssize << SLB_VSID_SSIZE_SHIFT);
  53 }
  54
  55 static inline void slb_shadow_update(unsigned long ea, int ssize,
  56                                      unsigned long flags,
  57                                      enum slb_index index)
  58 {
  59         struct slb_shadow *p = get_slb_shadow();
  60
  61         /*
  62          * Clear the ESID first so the entry is not valid while we are
  63          * updating it.  No write barriers are needed here, provided
  64          * we only update the current CPU's SLB shadow buffer.
  65          */
  66         WRITE_ONCE(p->save_area[index].esid, 0);
  67         WRITE_ONCE(p->save_area[index].vsid, cpu_to_be64(mk_vsid_data(ea, ssize, flags)));
  68         WRITE_ONCE(p->save_area[index].esid, cpu_to_be64(mk_esid_data(ea, ssize, index)));
  69 }
  70
  71 static inline void slb_shadow_clear(enum slb_index index)
  72 {
  73         WRITE_ONCE(get_slb_shadow()->save_area[index].esid, cpu_to_be64(index));
  74 }
  75
  76 static inline void create_shadowed_slbe(unsigned long ea, int ssize,
  77                                         unsigned long flags,
  78                                         enum slb_index index)
  79 {
  80         /*
  81          * Updating the shadow buffer before writing the SLB ensures
  82          * we don't get a stale entry here if we get preempted by PHYP
  83          * between these two statements.
  84          */
  85         slb_shadow_update(ea, ssize, flags, index);
  86
  87         asm volatile("slbmte  %0,%1" :
  88                      : "r" (mk_vsid_data(ea, ssize, flags)),
  89                        "r" (mk_esid_data(ea, ssize, index))
  90                      : "memory" );
  91 }
  92
  93 /*
  94  * Insert bolted entries into SLB (which may not be empty, so don't clear
  95  * slb_cache_ptr).
  96  */
  97 void __slb_restore_bolted_realmode(void)
  98 {
  99         struct slb_shadow *p = get_slb_shadow();
 100         enum slb_index index;
 101
 102          /* No isync needed because realmode. */
 103         for (index = 0; index < SLB_NUM_BOLTED; index++) {
 104                 asm volatile("slbmte  %0,%1" :
 105                      : "r" (be64_to_cpu(p->save_area[index].vsid)),
 106                        "r" (be64_to_cpu(p->save_area[index].esid)));
 107         }
 108 }
 109
 110 /*
 111  * Insert the bolted entries into an empty SLB.
 112  * This is not the same as rebolt because the bolted segments are not
 113  * changed, just loaded from the shadow area.
 114  */
 115 void slb_restore_bolted_realmode(void)
 116 {
 117         __slb_restore_bolted_realmode();
 118         get_paca()->slb_cache_ptr = 0;
 119 }
 120
 121 /*
 122  * This flushes all SLB entries including 0, so it must be realmode.
 123  */
 124 void slb_flush_all_realmode(void)
 125 {
 126         /*
 127          * This flushes all SLB entries including 0, so it must be realmode.
 128          */
 129         asm volatile("slbmte %0,%0; slbia" : : "r" (0));
 130 }
 131
 132 static void __slb_flush_and_rebolt(void)
 133 {
 134         /* If you change this make sure you change SLB_NUM_BOLTED
 135          * and PR KVM appropriately too. */
 136         unsigned long linear_llp, vmalloc_llp, lflags, vflags;
 137         unsigned long ksp_esid_data, ksp_vsid_data;
 138
 139         linear_llp = mmu_psize_defs[mmu_linear_psize].sllp;
 140         vmalloc_llp = mmu_psize_defs[mmu_vmalloc_psize].sllp;
 141         lflags = SLB_VSID_KERNEL | linear_llp;
 142         vflags = SLB_VSID_KERNEL | vmalloc_llp;
 143
 144         ksp_esid_data = mk_esid_data(get_paca()->kstack, mmu_kernel_ssize, KSTACK_INDEX);
 145         if ((ksp_esid_data & ~0xfffffffUL) <= PAGE_OFFSET) {
 146                 ksp_esid_data &= ~SLB_ESID_V;
 147                 ksp_vsid_data = 0;
 148                 slb_shadow_clear(KSTACK_INDEX);
 149         } else {
 150                 /* Update stack entry; others don't change */
 151                 slb_shadow_update(get_paca()->kstack, mmu_kernel_ssize, lflags, KSTACK_INDEX);
 152                 ksp_vsid_data =
 153                         be64_to_cpu(get_slb_shadow()->save_area[KSTACK_INDEX].vsid);
 154         }
 155
 156         /* We need to do this all in asm, so we're sure we don't touch
 157          * the stack between the slbia and rebolting it. */
 158         asm volatile("isync\n"
 159                      "slbia\n"
 160                      /* Slot 1 - first VMALLOC segment */
 161                      "slbmte    %0,%1\n"
 162                      /* Slot 2 - kernel stack */
 163                      "slbmte    %2,%3\n"
 164                      "isync"
 165                      :: "r"(mk_vsid_data(VMALLOC_START, mmu_kernel_ssize, vflags)),
 166                         "r"(mk_esid_data(VMALLOC_START, mmu_kernel_ssize, VMALLOC_INDEX)),
 167                         "r"(ksp_vsid_data),
 168                         "r"(ksp_esid_data)
 169                      : "memory");
 170 }
 171
 172 void slb_flush_and_rebolt(void)
 173 {
 174
 175         WARN_ON(!irqs_disabled());
 176
 177         /*
 178          * We can't take a PMU exception in the following code, so hard
 179          * disable interrupts.
 180          */
 181         hard_irq_disable();
 182
 183         __slb_flush_and_rebolt();
 184         get_paca()->slb_cache_ptr = 0;
 185 }
 186
 187 void slb_vmalloc_update(void)
 188 {
 189         unsigned long vflags;
 190
 191         vflags = SLB_VSID_KERNEL | mmu_psize_defs[mmu_vmalloc_psize].sllp;
 192         slb_shadow_update(VMALLOC_START, mmu_kernel_ssize, vflags, VMALLOC_INDEX);
 193         slb_flush_and_rebolt();
 194 }
 195
 196 /* Helper function to compare esids.  There are four cases to handle.
 197  * 1. The system is not 1T segment size capable.  Use the GET_ESID compare.
 198  * 2. The system is 1T capable, both addresses are < 1T, use the GET_ESID compare.
 199  * 3. The system is 1T capable, only one of the two addresses is > 1T.  This is not a match.
 200  * 4. The system is 1T capable, both addresses are > 1T, use the GET_ESID_1T macro to compare.
 201  */
 202 static inline int esids_match(unsigned long addr1, unsigned long addr2)
 203 {
 204         int esid_1t_count;
 205
 206         /* System is not 1T segment size capable. */
 207         if (!mmu_has_feature(MMU_FTR_1T_SEGMENT))
 208                 return (GET_ESID(addr1) == GET_ESID(addr2));
 209
 210         esid_1t_count = (((addr1 >> SID_SHIFT_1T) != 0) +
 211                                 ((addr2 >> SID_SHIFT_1T) != 0));
 212
 213         /* both addresses are < 1T */
 214         if (esid_1t_count == 0)
 215                 return (GET_ESID(addr1) == GET_ESID(addr2));
 216
 217         /* One address < 1T, the other > 1T.  Not a match */
 218         if (esid_1t_count == 1)
 219                 return 0;
 220
 221         /* Both addresses are > 1T. */
 222         return (GET_ESID_1T(addr1) == GET_ESID_1T(addr2));
 223 }
 224
 225 /* Flush all user entries from the segment table of the current processor. */
 226 void switch_slb(struct task_struct *tsk, struct mm_struct *mm)
 227 {
 228         unsigned long offset;
 229         unsigned long slbie_data = 0;
 230         unsigned long pc = KSTK_EIP(tsk);
 231         unsigned long stack = KSTK_ESP(tsk);
 232         unsigned long exec_base;
 233
 234         /*
 235          * We need interrupts hard-disabled here, not just soft-disabled,
 236          * so that a PMU interrupt can't occur, which might try to access
 237          * user memory (to get a stack trace) and possible cause an SLB miss
 238          * which would update the slb_cache/slb_cache_ptr fields in the PACA.
 239          */
 240         hard_irq_disable();
 241         offset = get_paca()->slb_cache_ptr;
 242         if (!mmu_has_feature(MMU_FTR_NO_SLBIE_B) &&
 243             offset <= SLB_CACHE_ENTRIES) {
 244                 int i;
 245                 asm volatile("isync" : : : "memory");
 246                 for (i = 0; i < offset; i++) {
 247                         slbie_data = (unsigned long)get_paca()->slb_cache[i]
 248                                 << SID_SHIFT; /* EA */
 249                         slbie_data |= user_segment_size(slbie_data)
 250                                 << SLBIE_SSIZE_SHIFT;
 251                         slbie_data |= SLBIE_C; /* C set for user addresses */
 252                         asm volatile("slbie %0" : : "r" (slbie_data));
 253                 }
 254                 asm volatile("isync" : : : "memory");
 255         } else {
 256                 __slb_flush_and_rebolt();
 257         }
 258
 259         /* Workaround POWER5 < DD2.1 issue */
 260         if (offset == 1 || offset > SLB_CACHE_ENTRIES)
 261                 asm volatile("slbie %0" : : "r" (slbie_data));
 262
 263         get_paca()->slb_cache_ptr = 0;
 264         copy_mm_to_paca(mm);
 265
 266         /*
 267          * preload some userspace segments into the SLB.
 268          * Almost all 32 and 64bit PowerPC executables are linked at
 269          * 0x10000000 so it makes sense to preload this segment.
 270          */
 271         exec_base = 0x10000000;
 272
 273         if (is_kernel_addr(pc) || is_kernel_addr(stack) ||
 274             is_kernel_addr(exec_base))
 275                 return;
 276
 277         slb_allocate(pc);
 278
 279         if (!esids_match(pc, stack))
 280                 slb_allocate(stack);
 281
 282         if (!esids_match(pc, exec_base) &&
 283             !esids_match(stack, exec_base))
 284                 slb_allocate(exec_base);
 285 }
 286
 287 static inline void patch_slb_encoding(unsigned int *insn_addr,
 288                                       unsigned int immed)
 289 {
 290
 291         /*
 292          * This function patches either an li or a cmpldi instruction with
 293          * a new immediate value. This relies on the fact that both li
 294          * (which is actually addi) and cmpldi both take a 16-bit immediate
 295          * value, and it is situated in the same location in the instruction,
 296          * ie. bits 16-31 (Big endian bit order) or the lower 16 bits.
 297          * The signedness of the immediate operand differs between the two
 298          * instructions however this code is only ever patching a small value,
 299          * much less than 1 << 15, so we can get away with it.
 300          * To patch the value we read the existing instruction, clear the
 301          * immediate value, and or in our new value, then write the instruction
 302          * back.
 303          */
 304         unsigned int insn = (*insn_addr & 0xffff0000) | immed;
 305         patch_instruction(insn_addr, insn);
 306 }
 307
 308 extern u32 slb_miss_kernel_load_linear[];
 309 extern u32 slb_miss_kernel_load_io[];
 310 extern u32 slb_compare_rr_to_size[];
 311 extern u32 slb_miss_kernel_load_vmemmap[];
 312
 313 void slb_set_size(u16 size)
 314 {
 315         if (mmu_slb_size == size)
 316                 return;
 317
 318         mmu_slb_size = size;
 319         patch_slb_encoding(slb_compare_rr_to_size, mmu_slb_size);
 320 }
 321
 322 void slb_initialize(void)
 323 {
 324         unsigned long linear_llp, vmalloc_llp, io_llp;
 325         unsigned long lflags, vflags;
 326         static int slb_encoding_inited;
 327 #ifdef CONFIG_SPARSEMEM_VMEMMAP
 328         unsigned long vmemmap_llp;
 329 #endif
 330
 331         /* Prepare our SLB miss handler based on our page size */
 332         linear_llp = mmu_psize_defs[mmu_linear_psize].sllp;
 333         io_llp = mmu_psize_defs[mmu_io_psize].sllp;
 334         vmalloc_llp = mmu_psize_defs[mmu_vmalloc_psize].sllp;
 335         get_paca()->vmalloc_sllp = SLB_VSID_KERNEL | vmalloc_llp;
 336 #ifdef CONFIG_SPARSEMEM_VMEMMAP
 337         vmemmap_llp = mmu_psize_defs[mmu_vmemmap_psize].sllp;
 338 #endif
 339         if (!slb_encoding_inited) {
 340                 slb_encoding_inited = 1;
 341                 patch_slb_encoding(slb_miss_kernel_load_linear,
 342                                    SLB_VSID_KERNEL | linear_llp);
 343                 patch_slb_encoding(slb_miss_kernel_load_io,
 344                                    SLB_VSID_KERNEL | io_llp);
 345                 patch_slb_encoding(slb_compare_rr_to_size,
 346                                    mmu_slb_size);
 347
 348                 pr_devel("SLB: linear  LLP = %04lx\n", linear_llp);
 349                 pr_devel("SLB: io      LLP = %04lx\n", io_llp);
 350
 351 #ifdef CONFIG_SPARSEMEM_VMEMMAP
 352                 patch_slb_encoding(slb_miss_kernel_load_vmemmap,
 353                                    SLB_VSID_KERNEL | vmemmap_llp);
 354                 pr_devel("SLB: vmemmap LLP = %04lx\n", vmemmap_llp);
 355 #endif
 356         }
 357
 358         get_paca()->stab_rr = SLB_NUM_BOLTED;
 359
 360         lflags = SLB_VSID_KERNEL | linear_llp;
 361         vflags = SLB_VSID_KERNEL | vmalloc_llp;
 362
 363         /* Invalidate the entire SLB (even entry 0) & all the ERATS */
 364         asm volatile("isync":::"memory");
 365         asm volatile("slbmte  %0,%0"::"r" (0) : "memory");
 366         asm volatile("isync; slbia; isync":::"memory");
 367         create_shadowed_slbe(PAGE_OFFSET, mmu_kernel_ssize, lflags, LINEAR_INDEX);
 368         create_shadowed_slbe(VMALLOC_START, mmu_kernel_ssize, vflags, VMALLOC_INDEX);
 369
 370         /* For the boot cpu, we're running on the stack in init_thread_union,
 371          * which is in the first segment of the linear mapping, and also
 372          * get_paca()->kstack hasn't been initialized yet.
 373          * For secondary cpus, we need to bolt the kernel stack entry now.
 374          */
 375         slb_shadow_clear(KSTACK_INDEX);
 376         if (raw_smp_processor_id() != boot_cpuid &&
 377             (get_paca()->kstack & slb_esid_mask(mmu_kernel_ssize)) > PAGE_OFFSET)
 378                 create_shadowed_slbe(get_paca()->kstack,
 379                                      mmu_kernel_ssize, lflags, KSTACK_INDEX);
 380
 381         asm volatile("isync":::"memory");
 382 }
 383
 384 static void insert_slb_entry(unsigned long vsid, unsigned long ea,
 385                              int bpsize, int ssize)
 386 {
 387         unsigned long flags, vsid_data, esid_data;
 388         enum slb_index index;
 389         int slb_cache_index;
 390
 391         /*
 392          * We are irq disabled, hence should be safe to access PACA.
 393          */
 394         VM_WARN_ON(!irqs_disabled());
 395
 396         /*
 397          * We can't take a PMU exception in the following code, so hard
 398          * disable interrupts.
 399          */
 400         hard_irq_disable();
 401
 402         index = get_paca()->stab_rr;
 403
 404         /*
 405          * simple round-robin replacement of slb starting at SLB_NUM_BOLTED.
 406          */
 407         if (index < (mmu_slb_size - 1))
 408                 index++;
 409         else
 410                 index = SLB_NUM_BOLTED;
 411
 412         get_paca()->stab_rr = index;
 413
 414         flags = SLB_VSID_USER | mmu_psize_defs[bpsize].sllp;
 415         vsid_data = (vsid << slb_vsid_shift(ssize)) | flags |
 416                     ((unsigned long) ssize << SLB_VSID_SSIZE_SHIFT);
 417         esid_data = mk_esid_data(ea, ssize, index);
 418
 419         /*
 420          * No need for an isync before or after this slbmte. The exception
 421          * we enter with and the rfid we exit with are context synchronizing.
 422          * Also we only handle user segments here.
 423          */
 424         asm volatile("slbmte %0, %1" : : "r" (vsid_data), "r" (esid_data)
 425                      : "memory");
 426
 427         /*
 428          * Now update slb cache entries
 429          */
 430         slb_cache_index = get_paca()->slb_cache_ptr;
 431         if (slb_cache_index < SLB_CACHE_ENTRIES) {
 432                 /*
 433                  * We have space in slb cache for optimized switch_slb().
 434                  * Top 36 bits from esid_data as per ISA
 435                  */
 436                 get_paca()->slb_cache[slb_cache_index++] = esid_data >> 28;
 437                 get_paca()->slb_cache_ptr++;
 438         } else {
 439                 /*
 440                  * Our cache is full and the current cache content strictly
 441                  * doesn't indicate the active SLB conents. Bump the ptr
 442                  * so that switch_slb() will ignore the cache.
 443                  */
 444                 get_paca()->slb_cache_ptr = SLB_CACHE_ENTRIES + 1;
 445         }
 446 }
 447
 448 static void handle_multi_context_slb_miss(int context_id, unsigned long ea)
 449 {
 450         struct mm_struct *mm = current->mm;
 451         unsigned long vsid;
 452         int bpsize;
 453
 454         /*
 455          * We are always above 1TB, hence use high user segment size.
 456          */
 457         vsid = get_vsid(context_id, ea, mmu_highuser_ssize);
 458         bpsize = get_slice_psize(mm, ea);
 459         insert_slb_entry(vsid, ea, bpsize, mmu_highuser_ssize);
 460 }
 461
 462 void slb_miss_large_addr(struct pt_regs *regs)
 463 {
 464         enum ctx_state prev_state = exception_enter();
 465         unsigned long ea = regs->dar;
 466         int context;
 467
 468         if (REGION_ID(ea) != USER_REGION_ID)
 469                 goto slb_bad_addr;
 470
 471         /*
 472          * Are we beyound what the page table layout supports ?
 473          */
 474         if ((ea & ~REGION_MASK) >= H_PGTABLE_RANGE)
 475                 goto slb_bad_addr;
 476
 477         /* Lower address should have been handled by asm code */
 478         if (ea < (1UL << MAX_EA_BITS_PER_CONTEXT))
 479                 goto slb_bad_addr;
 480
 481         /*
 482          * consider this as bad access if we take a SLB miss
 483          * on an address above addr limit.
 484          */
 485         if (ea >= current->mm->context.slb_addr_limit)
 486                 goto slb_bad_addr;
 487
 488         context = get_ea_context(&current->mm->context, ea);
 489         if (!context)
 490                 goto slb_bad_addr;
 491
 492         handle_multi_context_slb_miss(context, ea);
 493         exception_exit(prev_state);
 494         return;
 495
 496 slb_bad_addr:
 497         if (user_mode(regs))
 498                 _exception(SIGSEGV, regs, SEGV_BNDERR, ea);
 499         else
 500                 bad_page_fault(regs, ea, SIGSEGV);
 501         exception_exit(prev_state);
 502 }