arch/ppc64/mm/hash_native.c

   1 /*
   2  * native hashtable management.
   3  *
   4  * SMP scalability work:
   5  *    Copyright (C) 2001 Anton Blanchard <anton@au.ibm.com>, IBM
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version
  10  * 2 of the License, or (at your option) any later version.
  11  */
  12 #include <linux/spinlock.h>
  13 #include <linux/bitops.h>
  14 #include <linux/threads.h>
  15 #include <linux/smp.h>
  16
  17 #include <asm/abs_addr.h>
  18 #include <asm/machdep.h>
  19 #include <asm/mmu.h>
  20 #include <asm/mmu_context.h>
  21 #include <asm/pgtable.h>
  22 #include <asm/tlbflush.h>
  23 #include <asm/tlb.h>
  24 #include <asm/cputable.h>
  25
  26 #define HPTE_LOCK_BIT 3
  27
  28 static DEFINE_SPINLOCK(native_tlbie_lock);
  29
  30 static inline void native_lock_hpte(hpte_t *hptep)
  31 {
  32         unsigned long *word = &hptep->v;
  33
  34         while (1) {
  35                 if (!test_and_set_bit(HPTE_LOCK_BIT, word))
  36                         break;
  37                 while(test_bit(HPTE_LOCK_BIT, word))
  38                         cpu_relax();
  39         }
  40 }
  41
  42 static inline void native_unlock_hpte(hpte_t *hptep)
  43 {
  44         unsigned long *word = &hptep->v;
  45
  46         asm volatile("lwsync":::"memory");
  47         clear_bit(HPTE_LOCK_BIT, word);
  48 }
  49
  50 long native_hpte_insert(unsigned long hpte_group, unsigned long va,
  51                         unsigned long prpn, unsigned long vflags,
  52                         unsigned long rflags)
  53 {
  54         hpte_t *hptep = htab_address + hpte_group;
  55         unsigned long hpte_v, hpte_r;
  56         int i;
  57
  58         for (i = 0; i < HPTES_PER_GROUP; i++) {
  59                 if (! (hptep->v & HPTE_V_VALID)) {
  60                         /* retry with lock held */
  61                         native_lock_hpte(hptep);
  62                         if (! (hptep->v & HPTE_V_VALID))
  63                                 break;
  64                         native_unlock_hpte(hptep);
  65                 }
  66
  67                 hptep++;
  68         }
  69
  70         if (i == HPTES_PER_GROUP)
  71                 return -1;
  72
  73         hpte_v = (va >> 23) << HPTE_V_AVPN_SHIFT | vflags | HPTE_V_VALID;
  74         if (vflags & HPTE_V_LARGE)
  75                 va &= ~(1UL << HPTE_V_AVPN_SHIFT);
  76         hpte_r = (prpn << HPTE_R_RPN_SHIFT) | rflags;
  77
  78         hptep->r = hpte_r;
  79         /* Guarantee the second dword is visible before the valid bit */
  80         __asm__ __volatile__ ("eieio" : : : "memory");
  81         /*
  82          * Now set the first dword including the valid bit
  83          * NOTE: this also unlocks the hpte
  84          */
  85         hptep->v = hpte_v;
  86
  87         __asm__ __volatile__ ("ptesync" : : : "memory");
  88
  89         return i | (!!(vflags & HPTE_V_SECONDARY) << 3);
  90 }
  91
  92 static long native_hpte_remove(unsigned long hpte_group)
  93 {
  94         hpte_t *hptep;
  95         int i;
  96         int slot_offset;
  97         unsigned long hpte_v;
  98
  99         /* pick a random entry to start at */
 100         slot_offset = mftb() & 0x7;
 101
 102         for (i = 0; i < HPTES_PER_GROUP; i++) {
 103                 hptep = htab_address + hpte_group + slot_offset;
 104                 hpte_v = hptep->v;
 105
 106                 if ((hpte_v & HPTE_V_VALID) && !(hpte_v & HPTE_V_BOLTED)) {
 107                         /* retry with lock held */
 108                         native_lock_hpte(hptep);
 109                         hpte_v = hptep->v;
 110                         if ((hpte_v & HPTE_V_VALID)
 111                             && !(hpte_v & HPTE_V_BOLTED))
 112                                 break;
 113                         native_unlock_hpte(hptep);
 114                 }
 115
 116                 slot_offset++;
 117                 slot_offset &= 0x7;
 118         }
 119
 120         if (i == HPTES_PER_GROUP)
 121                 return -1;
 122
 123         /* Invalidate the hpte. NOTE: this also unlocks it */
 124         hptep->v = 0;
 125
 126         return i;
 127 }
 128
 129 static inline void set_pp_bit(unsigned long pp, hpte_t *addr)
 130 {
 131         unsigned long old;
 132         unsigned long *p = &addr->r;
 133
 134         __asm__ __volatile__(
 135         "1:     ldarx   %0,0,%3\n\
 136                 rldimi  %0,%2,0,61\n\
 137                 stdcx.  %0,0,%3\n\
 138                 bne     1b"
 139         : "=&r" (old), "=m" (*p)
 140         : "r" (pp), "r" (p), "m" (*p)
 141         : "cc");
 142 }
 143
 144 /*
 145  * Only works on small pages. Yes its ugly to have to check each slot in
 146  * the group but we only use this during bootup.
 147  */
 148 static long native_hpte_find(unsigned long vpn)
 149 {
 150         hpte_t *hptep;
 151         unsigned long hash;
 152         unsigned long i, j;
 153         long slot;
 154         unsigned long hpte_v;
 155
 156         hash = hpt_hash(vpn, 0);
 157
 158         for (j = 0; j < 2; j++) {
 159                 slot = (hash & htab_hash_mask) * HPTES_PER_GROUP;
 160                 for (i = 0; i < HPTES_PER_GROUP; i++) {
 161                         hptep = htab_address + slot;
 162                         hpte_v = hptep->v;
 163
 164                         if ((HPTE_V_AVPN_VAL(hpte_v) == (vpn >> 11))
 165                             && (hpte_v & HPTE_V_VALID)
 166                             && ( !!(hpte_v & HPTE_V_SECONDARY) == j)) {
 167                                 /* HPTE matches */
 168                                 if (j)
 169                                         slot = -slot;
 170                                 return slot;
 171                         }
 172                         ++slot;
 173                 }
 174                 hash = ~hash;
 175         }
 176
 177         return -1;
 178 }
 179
 180 static long native_hpte_updatepp(unsigned long slot, unsigned long newpp,
 181                                  unsigned long va, int large, int local)
 182 {
 183         hpte_t *hptep = htab_address + slot;
 184         unsigned long hpte_v;
 185         unsigned long avpn = va >> 23;
 186         int ret = 0;
 187
 188         if (large)
 189                 avpn &= ~1;
 190
 191         native_lock_hpte(hptep);
 192
 193         hpte_v = hptep->v;
 194
 195         /* Even if we miss, we need to invalidate the TLB */
 196         if ((HPTE_V_AVPN_VAL(hpte_v) != avpn)
 197             || !(hpte_v & HPTE_V_VALID)) {
 198                 native_unlock_hpte(hptep);
 199                 ret = -1;
 200         } else {
 201                 set_pp_bit(newpp, hptep);
 202                 native_unlock_hpte(hptep);
 203         }
 204
 205         /* Ensure it is out of the tlb too */
 206         if (cpu_has_feature(CPU_FTR_TLBIEL) && !large && local) {
 207                 tlbiel(va);
 208         } else {
 209                 int lock_tlbie = !cpu_has_feature(CPU_FTR_LOCKLESS_TLBIE);
 210
 211                 if (lock_tlbie)
 212                         spin_lock(&native_tlbie_lock);
 213                 tlbie(va, large);
 214                 if (lock_tlbie)
 215                         spin_unlock(&native_tlbie_lock);
 216         }
 217
 218         return ret;
 219 }
 220
 221 /*
 222  * Update the page protection bits. Intended to be used to create
 223  * guard pages for kernel data structures on pages which are bolted
 224  * in the HPT. Assumes pages being operated on will not be stolen.
 225  * Does not work on large pages.
 226  *
 227  * No need to lock here because we should be the only user.
 228  */
 229 static void native_hpte_updateboltedpp(unsigned long newpp, unsigned long ea)
 230 {
 231         unsigned long vsid, va, vpn, flags = 0;
 232         long slot;
 233         hpte_t *hptep;
 234         int lock_tlbie = !cpu_has_feature(CPU_FTR_LOCKLESS_TLBIE);
 235
 236         vsid = get_kernel_vsid(ea);
 237         va = (vsid << 28) | (ea & 0x0fffffff);
 238         vpn = va >> PAGE_SHIFT;
 239
 240         slot = native_hpte_find(vpn);
 241         if (slot == -1)
 242                 panic("could not find page to bolt\n");
 243         hptep = htab_address + slot;
 244
 245         set_pp_bit(newpp, hptep);
 246
 247         /* Ensure it is out of the tlb too */
 248         if (lock_tlbie)
 249                 spin_lock_irqsave(&native_tlbie_lock, flags);
 250         tlbie(va, 0);
 251         if (lock_tlbie)
 252                 spin_unlock_irqrestore(&native_tlbie_lock, flags);
 253 }
 254
 255 static void native_hpte_invalidate(unsigned long slot, unsigned long va,
 256                                     int large, int local)
 257 {
 258         hpte_t *hptep = htab_address + slot;
 259         unsigned long hpte_v;
 260         unsigned long avpn = va >> 23;
 261         unsigned long flags;
 262         int lock_tlbie = !cpu_has_feature(CPU_FTR_LOCKLESS_TLBIE);
 263
 264         if (large)
 265                 avpn &= ~1;
 266
 267         local_irq_save(flags);
 268         native_lock_hpte(hptep);
 269
 270         hpte_v = hptep->v;
 271
 272         /* Even if we miss, we need to invalidate the TLB */
 273         if ((HPTE_V_AVPN_VAL(hpte_v) != avpn)
 274             || !(hpte_v & HPTE_V_VALID)) {
 275                 native_unlock_hpte(hptep);
 276         } else {
 277                 /* Invalidate the hpte. NOTE: this also unlocks it */
 278                 hptep->v = 0;
 279         }
 280
 281         /* Invalidate the tlb */
 282         if (cpu_has_feature(CPU_FTR_TLBIEL) && !large && local) {
 283                 tlbiel(va);
 284         } else {
 285                 if (lock_tlbie)
 286                         spin_lock(&native_tlbie_lock);
 287                 tlbie(va, large);
 288                 if (lock_tlbie)
 289                         spin_unlock(&native_tlbie_lock);
 290         }
 291         local_irq_restore(flags);
 292 }
 293
 294 /*
 295  * clear all mappings on kexec.  All cpus are in real mode (or they will
 296  * be when they isi), and we are the only one left.  We rely on our kernel
 297  * mapping being 0xC0's and the hardware ignoring those two real bits.
 298  *
 299  * TODO: add batching support when enabled.  remember, no dynamic memory here,
 300  * athough there is the control page available...
 301  */
 302 static void native_hpte_clear(void)
 303 {
 304         unsigned long slot, slots, flags;
 305         hpte_t *hptep = htab_address;
 306         unsigned long hpte_v;
 307         unsigned long pteg_count;
 308
 309         pteg_count = htab_hash_mask + 1;
 310
 311         local_irq_save(flags);
 312
 313         /* we take the tlbie lock and hold it.  Some hardware will
 314          * deadlock if we try to tlbie from two processors at once.
 315          */
 316         spin_lock(&native_tlbie_lock);
 317
 318         slots = pteg_count * HPTES_PER_GROUP;
 319
 320         for (slot = 0; slot < slots; slot++, hptep++) {
 321                 /*
 322                  * we could lock the pte here, but we are the only cpu
 323                  * running,  right?  and for crash dump, we probably
 324                  * don't want to wait for a maybe bad cpu.
 325                  */
 326                 hpte_v = hptep->v;
 327
 328                 if (hpte_v & HPTE_V_VALID) {
 329                         hptep->v = 0;
 330                         tlbie(slot2va(hpte_v, slot), hpte_v & HPTE_V_LARGE);
 331                 }
 332         }
 333
 334         spin_unlock(&native_tlbie_lock);
 335         local_irq_restore(flags);
 336 }
 337
 338 static void native_flush_hash_range(unsigned long context,
 339                                     unsigned long number, int local)
 340 {
 341         unsigned long vsid, vpn, va, hash, secondary, slot, flags, avpn;
 342         int i, j;
 343         hpte_t *hptep;
 344         unsigned long hpte_v;
 345         struct ppc64_tlb_batch *batch = &__get_cpu_var(ppc64_tlb_batch);
 346
 347         /* XXX fix for large ptes */
 348         unsigned long large = 0;
 349
 350         local_irq_save(flags);
 351
 352         j = 0;
 353         for (i = 0; i < number; i++) {
 354                 if (batch->addr[i] < KERNELBASE)
 355                         vsid = get_vsid(context, batch->addr[i]);
 356                 else
 357                         vsid = get_kernel_vsid(batch->addr[i]);
 358
 359                 va = (vsid << 28) | (batch->addr[i] & 0x0fffffff);
 360                 batch->vaddr[j] = va;
 361                 if (large)
 362                         vpn = va >> HPAGE_SHIFT;
 363                 else
 364                         vpn = va >> PAGE_SHIFT;
 365                 hash = hpt_hash(vpn, large);
 366                 secondary = (pte_val(batch->pte[i]) & _PAGE_SECONDARY) >> 15;
 367                 if (secondary)
 368                         hash = ~hash;
 369                 slot = (hash & htab_hash_mask) * HPTES_PER_GROUP;
 370                 slot += (pte_val(batch->pte[i]) & _PAGE_GROUP_IX) >> 12;
 371
 372                 hptep = htab_address + slot;
 373
 374                 avpn = va >> 23;
 375                 if (large)
 376                         avpn &= ~0x1UL;
 377
 378                 native_lock_hpte(hptep);
 379
 380                 hpte_v = hptep->v;
 381
 382                 /* Even if we miss, we need to invalidate the TLB */
 383                 if ((HPTE_V_AVPN_VAL(hpte_v) != avpn)
 384                     || !(hpte_v & HPTE_V_VALID)) {
 385                         native_unlock_hpte(hptep);
 386                 } else {
 387                         /* Invalidate the hpte. NOTE: this also unlocks it */
 388                         hptep->v = 0;
 389                 }
 390
 391                 j++;
 392         }
 393
 394         if (cpu_has_feature(CPU_FTR_TLBIEL) && !large && local) {
 395                 asm volatile("ptesync":::"memory");
 396
 397                 for (i = 0; i < j; i++)
 398                         __tlbiel(batch->vaddr[i]);
 399
 400                 asm volatile("ptesync":::"memory");
 401         } else {
 402                 int lock_tlbie = !cpu_has_feature(CPU_FTR_LOCKLESS_TLBIE);
 403
 404                 if (lock_tlbie)
 405                         spin_lock(&native_tlbie_lock);
 406
 407                 asm volatile("ptesync":::"memory");
 408
 409                 for (i = 0; i < j; i++)
 410                         __tlbie(batch->vaddr[i], 0);
 411
 412                 asm volatile("eieio; tlbsync; ptesync":::"memory");
 413
 414                 if (lock_tlbie)
 415                         spin_unlock(&native_tlbie_lock);
 416         }
 417
 418         local_irq_restore(flags);
 419 }
 420
 421 #ifdef CONFIG_PPC_PSERIES
 422 /* Disable TLB batching on nighthawk */
 423 static inline int tlb_batching_enabled(void)
 424 {
 425         struct device_node *root = of_find_node_by_path("/");
 426         int enabled = 1;
 427
 428         if (root) {
 429                 const char *model = get_property(root, "model", NULL);
 430                 if (model && !strcmp(model, "IBM,9076-N81"))
 431                         enabled = 0;
 432                 of_node_put(root);
 433         }
 434
 435         return enabled;
 436 }
 437 #else
 438 static inline int tlb_batching_enabled(void)
 439 {
 440         return 1;
 441 }
 442 #endif
 443
 444 void hpte_init_native(void)
 445 {
 446         ppc_md.hpte_invalidate  = native_hpte_invalidate;
 447         ppc_md.hpte_updatepp    = native_hpte_updatepp;
 448         ppc_md.hpte_updateboltedpp = native_hpte_updateboltedpp;
 449         ppc_md.hpte_insert      = native_hpte_insert;
 450         ppc_md.hpte_remove      = native_hpte_remove;
 451         ppc_md.hpte_clear_all   = native_hpte_clear;
 452         if (tlb_batching_enabled())
 453                 ppc_md.flush_hash_range = native_flush_hash_range;
 454         htab_finish_init();
 455 }