Pileus Git - ~andy/linux/blob - arch/powerpc/kvm/book3s_hv_rm_mmu.c

   1 /*
   2  * This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License, version 2, as
   4  * published by the Free Software Foundation.
   5  *
   6  * Copyright 2010-2011 Paul Mackerras, IBM Corp. <paulus@au1.ibm.com>
   7  */
   8
   9 #include <linux/types.h>
  10 #include <linux/string.h>
  11 #include <linux/kvm.h>
  12 #include <linux/kvm_host.h>
  13 #include <linux/hugetlb.h>
  14 #include <linux/module.h>
  15
  16 #include <asm/tlbflush.h>
  17 #include <asm/kvm_ppc.h>
  18 #include <asm/kvm_book3s.h>
  19 #include <asm/mmu-hash64.h>
  20 #include <asm/hvcall.h>
  21 #include <asm/synch.h>
  22 #include <asm/ppc-opcode.h>
  23
  24 /*
  25  * Since this file is built in even if KVM is a module, we need
  26  * a local copy of this function for the case where kvm_main.c is
  27  * modular.
  28  */
  29 static struct kvm_memory_slot *builtin_gfn_to_memslot(struct kvm *kvm,
  30                                                 gfn_t gfn)
  31 {
  32         struct kvm_memslots *slots;
  33         struct kvm_memory_slot *memslot;
  34
  35         slots = kvm_memslots(kvm);
  36         kvm_for_each_memslot(memslot, slots)
  37                 if (gfn >= memslot->base_gfn &&
  38                       gfn < memslot->base_gfn + memslot->npages)
  39                         return memslot;
  40         return NULL;
  41 }
  42
  43 /* Translate address of a vmalloc'd thing to a linear map address */
  44 static void *real_vmalloc_addr(void *x)
  45 {
  46         unsigned long addr = (unsigned long) x;
  47         pte_t *p;
  48
  49         p = find_linux_pte(swapper_pg_dir, addr);
  50         if (!p || !pte_present(*p))
  51                 return NULL;
  52         /* assume we don't have huge pages in vmalloc space... */
  53         addr = (pte_pfn(*p) << PAGE_SHIFT) | (addr & ~PAGE_MASK);
  54         return __va(addr);
  55 }
  56
  57 /*
  58  * Add this HPTE into the chain for the real page.
  59  * Must be called with the chain locked; it unlocks the chain.
  60  */
  61 void kvmppc_add_revmap_chain(struct kvm *kvm, struct revmap_entry *rev,
  62                              unsigned long *rmap, long pte_index, int realmode)
  63 {
  64         struct revmap_entry *head, *tail;
  65         unsigned long i;
  66
  67         if (*rmap & KVMPPC_RMAP_PRESENT) {
  68                 i = *rmap & KVMPPC_RMAP_INDEX;
  69                 head = &kvm->arch.revmap[i];
  70                 if (realmode)
  71                         head = real_vmalloc_addr(head);
  72                 tail = &kvm->arch.revmap[head->back];
  73                 if (realmode)
  74                         tail = real_vmalloc_addr(tail);
  75                 rev->forw = i;
  76                 rev->back = head->back;
  77                 tail->forw = pte_index;
  78                 head->back = pte_index;
  79         } else {
  80                 rev->forw = rev->back = pte_index;
  81                 i = pte_index;
  82         }
  83         smp_wmb();
  84         *rmap = i | KVMPPC_RMAP_REFERENCED | KVMPPC_RMAP_PRESENT; /* unlock */
  85 }
  86 EXPORT_SYMBOL_GPL(kvmppc_add_revmap_chain);
  87
  88 /* Remove this HPTE from the chain for a real page */
  89 static void remove_revmap_chain(struct kvm *kvm, long pte_index,
  90                                 unsigned long hpte_v)
  91 {
  92         struct revmap_entry *rev, *next, *prev;
  93         unsigned long gfn, ptel, head;
  94         struct kvm_memory_slot *memslot;
  95         unsigned long *rmap;
  96
  97         rev = real_vmalloc_addr(&kvm->arch.revmap[pte_index]);
  98         ptel = rev->guest_rpte;
  99         gfn = hpte_rpn(ptel, hpte_page_size(hpte_v, ptel));
 100         memslot = builtin_gfn_to_memslot(kvm, gfn);
 101         if (!memslot || (memslot->flags & KVM_MEMSLOT_INVALID))
 102                 return;
 103
 104         rmap = real_vmalloc_addr(&memslot->rmap[gfn - memslot->base_gfn]);
 105         lock_rmap(rmap);
 106
 107         head = *rmap & KVMPPC_RMAP_INDEX;
 108         next = real_vmalloc_addr(&kvm->arch.revmap[rev->forw]);
 109         prev = real_vmalloc_addr(&kvm->arch.revmap[rev->back]);
 110         next->back = rev->back;
 111         prev->forw = rev->forw;
 112         if (head == pte_index) {
 113                 head = rev->forw;
 114                 if (head == pte_index)
 115                         *rmap &= ~(KVMPPC_RMAP_PRESENT | KVMPPC_RMAP_INDEX);
 116                 else
 117                         *rmap = (*rmap & ~KVMPPC_RMAP_INDEX) | head;
 118         }
 119         unlock_rmap(rmap);
 120 }
 121
 122 static pte_t lookup_linux_pte(struct kvm_vcpu *vcpu, unsigned long hva,
 123                               int writing, unsigned long *pte_sizep)
 124 {
 125         pte_t *ptep;
 126         unsigned long ps = *pte_sizep;
 127         unsigned int shift;
 128
 129         ptep = find_linux_pte_or_hugepte(vcpu->arch.pgdir, hva, &shift);
 130         if (!ptep)
 131                 return __pte(0);
 132         if (shift)
 133                 *pte_sizep = 1ul << shift;
 134         else
 135                 *pte_sizep = PAGE_SIZE;
 136         if (ps > *pte_sizep)
 137                 return __pte(0);
 138         if (!pte_present(*ptep))
 139                 return __pte(0);
 140         return kvmppc_read_update_linux_pte(ptep, writing);
 141 }
 142
 143 long kvmppc_h_enter(struct kvm_vcpu *vcpu, unsigned long flags,
 144                     long pte_index, unsigned long pteh, unsigned long ptel)
 145 {
 146         struct kvm *kvm = vcpu->kvm;
 147         unsigned long i, pa, gpa, gfn, psize;
 148         unsigned long slot_fn, hva;
 149         unsigned long *hpte;
 150         struct revmap_entry *rev;
 151         unsigned long g_ptel = ptel;
 152         struct kvm_memory_slot *memslot;
 153         unsigned long *physp, pte_size;
 154         unsigned long is_io;
 155         unsigned long *rmap;
 156         pte_t pte;
 157         unsigned int writing;
 158         unsigned long mmu_seq;
 159         bool realmode = vcpu->arch.vcore->vcore_state == VCORE_RUNNING;
 160
 161         psize = hpte_page_size(pteh, ptel);
 162         if (!psize)
 163                 return H_PARAMETER;
 164         writing = hpte_is_writable(ptel);
 165         pteh &= ~(HPTE_V_HVLOCK | HPTE_V_ABSENT | HPTE_V_VALID);
 166
 167         /* used later to detect if we might have been invalidated */
 168         mmu_seq = kvm->mmu_notifier_seq;
 169         smp_rmb();
 170
 171         /* Find the memslot (if any) for this address */
 172         gpa = (ptel & HPTE_R_RPN) & ~(psize - 1);
 173         gfn = gpa >> PAGE_SHIFT;
 174         memslot = builtin_gfn_to_memslot(kvm, gfn);
 175         pa = 0;
 176         is_io = ~0ul;
 177         rmap = NULL;
 178         if (!(memslot && !(memslot->flags & KVM_MEMSLOT_INVALID))) {
 179                 /* PPC970 can't do emulated MMIO */
 180                 if (!cpu_has_feature(CPU_FTR_ARCH_206))
 181                         return H_PARAMETER;
 182                 /* Emulated MMIO - mark this with key=31 */
 183                 pteh |= HPTE_V_ABSENT;
 184                 ptel |= HPTE_R_KEY_HI | HPTE_R_KEY_LO;
 185                 goto do_insert;
 186         }
 187
 188         /* Check if the requested page fits entirely in the memslot. */
 189         if (!slot_is_aligned(memslot, psize))
 190                 return H_PARAMETER;
 191         slot_fn = gfn - memslot->base_gfn;
 192         rmap = &memslot->rmap[slot_fn];
 193
 194         if (!kvm->arch.using_mmu_notifiers) {
 195                 physp = kvm->arch.slot_phys[memslot->id];
 196                 if (!physp)
 197                         return H_PARAMETER;
 198                 physp += slot_fn;
 199                 if (realmode)
 200                         physp = real_vmalloc_addr(physp);
 201                 pa = *physp;
 202                 if (!pa)
 203                         return H_TOO_HARD;
 204                 is_io = pa & (HPTE_R_I | HPTE_R_W);
 205                 pte_size = PAGE_SIZE << (pa & KVMPPC_PAGE_ORDER_MASK);
 206                 pa &= PAGE_MASK;
 207         } else {
 208                 /* Translate to host virtual address */
 209                 hva = gfn_to_hva_memslot(memslot, gfn);
 210
 211                 /* Look up the Linux PTE for the backing page */
 212                 pte_size = psize;
 213                 pte = lookup_linux_pte(vcpu, hva, writing, &pte_size);
 214                 if (pte_present(pte)) {
 215                         if (writing && !pte_write(pte))
 216                                 /* make the actual HPTE be read-only */
 217                                 ptel = hpte_make_readonly(ptel);
 218                         is_io = hpte_cache_bits(pte_val(pte));
 219                         pa = pte_pfn(pte) << PAGE_SHIFT;
 220                 }
 221         }
 222         if (pte_size < psize)
 223                 return H_PARAMETER;
 224         if (pa && pte_size > psize)
 225                 pa |= gpa & (pte_size - 1);
 226
 227         ptel &= ~(HPTE_R_PP0 - psize);
 228         ptel |= pa;
 229
 230         if (pa)
 231                 pteh |= HPTE_V_VALID;
 232         else
 233                 pteh |= HPTE_V_ABSENT;
 234
 235         /* Check WIMG */
 236         if (is_io != ~0ul && !hpte_cache_flags_ok(ptel, is_io)) {
 237                 if (is_io)
 238                         return H_PARAMETER;
 239                 /*
 240                  * Allow guest to map emulated device memory as
 241                  * uncacheable, but actually make it cacheable.
 242                  */
 243                 ptel &= ~(HPTE_R_W|HPTE_R_I|HPTE_R_G);
 244                 ptel |= HPTE_R_M;
 245         }
 246
 247         /* Find and lock the HPTEG slot to use */
 248  do_insert:
 249         if (pte_index >= HPT_NPTE)
 250                 return H_PARAMETER;
 251         if (likely((flags & H_EXACT) == 0)) {
 252                 pte_index &= ~7UL;
 253                 hpte = (unsigned long *)(kvm->arch.hpt_virt + (pte_index << 4));
 254                 for (i = 0; i < 8; ++i) {
 255                         if ((*hpte & HPTE_V_VALID) == 0 &&
 256                             try_lock_hpte(hpte, HPTE_V_HVLOCK | HPTE_V_VALID |
 257                                           HPTE_V_ABSENT))
 258                                 break;
 259                         hpte += 2;
 260                 }
 261                 if (i == 8) {
 262                         /*
 263                          * Since try_lock_hpte doesn't retry (not even stdcx.
 264                          * failures), it could be that there is a free slot
 265                          * but we transiently failed to lock it.  Try again,
 266                          * actually locking each slot and checking it.
 267                          */
 268                         hpte -= 16;
 269                         for (i = 0; i < 8; ++i) {
 270                                 while (!try_lock_hpte(hpte, HPTE_V_HVLOCK))
 271                                         cpu_relax();
 272                                 if (!(*hpte & (HPTE_V_VALID | HPTE_V_ABSENT)))
 273                                         break;
 274                                 *hpte &= ~HPTE_V_HVLOCK;
 275                                 hpte += 2;
 276                         }
 277                         if (i == 8)
 278                                 return H_PTEG_FULL;
 279                 }
 280                 pte_index += i;
 281         } else {
 282                 hpte = (unsigned long *)(kvm->arch.hpt_virt + (pte_index << 4));
 283                 if (!try_lock_hpte(hpte, HPTE_V_HVLOCK | HPTE_V_VALID |
 284                                    HPTE_V_ABSENT)) {
 285                         /* Lock the slot and check again */
 286                         while (!try_lock_hpte(hpte, HPTE_V_HVLOCK))
 287                                 cpu_relax();
 288                         if (*hpte & (HPTE_V_VALID | HPTE_V_ABSENT)) {
 289                                 *hpte &= ~HPTE_V_HVLOCK;
 290                                 return H_PTEG_FULL;
 291                         }
 292                 }
 293         }
 294
 295         /* Save away the guest's idea of the second HPTE dword */
 296         rev = &kvm->arch.revmap[pte_index];
 297         if (realmode)
 298                 rev = real_vmalloc_addr(rev);
 299         if (rev)
 300                 rev->guest_rpte = g_ptel;
 301
 302         /* Link HPTE into reverse-map chain */
 303         if (pteh & HPTE_V_VALID) {
 304                 if (realmode)
 305                         rmap = real_vmalloc_addr(rmap);
 306                 lock_rmap(rmap);
 307                 /* Check for pending invalidations under the rmap chain lock */
 308                 if (kvm->arch.using_mmu_notifiers &&
 309                     mmu_notifier_retry(vcpu, mmu_seq)) {
 310                         /* inval in progress, write a non-present HPTE */
 311                         pteh |= HPTE_V_ABSENT;
 312                         pteh &= ~HPTE_V_VALID;
 313                         unlock_rmap(rmap);
 314                 } else {
 315                         kvmppc_add_revmap_chain(kvm, rev, rmap, pte_index,
 316                                                 realmode);
 317                 }
 318         }
 319
 320         hpte[1] = ptel;
 321
 322         /* Write the first HPTE dword, unlocking the HPTE and making it valid */
 323         eieio();
 324         hpte[0] = pteh;
 325         asm volatile("ptesync" : : : "memory");
 326
 327         vcpu->arch.gpr[4] = pte_index;
 328         return H_SUCCESS;
 329 }
 330 EXPORT_SYMBOL_GPL(kvmppc_h_enter);
 331
 332 #define LOCK_TOKEN      (*(u32 *)(&get_paca()->lock_token))
 333
 334 static inline int try_lock_tlbie(unsigned int *lock)
 335 {
 336         unsigned int tmp, old;
 337         unsigned int token = LOCK_TOKEN;
 338
 339         asm volatile("1:lwarx   %1,0,%2\n"
 340                      "  cmpwi   cr0,%1,0\n"
 341                      "  bne     2f\n"
 342                      "  stwcx.  %3,0,%2\n"
 343                      "  bne-    1b\n"
 344                      "  isync\n"
 345                      "2:"
 346                      : "=&r" (tmp), "=&r" (old)
 347                      : "r" (lock), "r" (token)
 348                      : "cc", "memory");
 349         return old == 0;
 350 }
 351
 352 long kvmppc_h_remove(struct kvm_vcpu *vcpu, unsigned long flags,
 353                      unsigned long pte_index, unsigned long avpn,
 354                      unsigned long va)
 355 {
 356         struct kvm *kvm = vcpu->kvm;
 357         unsigned long *hpte;
 358         unsigned long v, r, rb;
 359
 360         if (pte_index >= HPT_NPTE)
 361                 return H_PARAMETER;
 362         hpte = (unsigned long *)(kvm->arch.hpt_virt + (pte_index << 4));
 363         while (!try_lock_hpte(hpte, HPTE_V_HVLOCK))
 364                 cpu_relax();
 365         if ((hpte[0] & (HPTE_V_ABSENT | HPTE_V_VALID)) == 0 ||
 366             ((flags & H_AVPN) && (hpte[0] & ~0x7fUL) != avpn) ||
 367             ((flags & H_ANDCOND) && (hpte[0] & avpn) != 0)) {
 368                 hpte[0] &= ~HPTE_V_HVLOCK;
 369                 return H_NOT_FOUND;
 370         }
 371         if (atomic_read(&kvm->online_vcpus) == 1)
 372                 flags |= H_LOCAL;
 373         vcpu->arch.gpr[4] = v = hpte[0] & ~HPTE_V_HVLOCK;
 374         vcpu->arch.gpr[5] = r = hpte[1];
 375         rb = compute_tlbie_rb(v, r, pte_index);
 376         if (v & HPTE_V_VALID)
 377                 remove_revmap_chain(kvm, pte_index, v);
 378         smp_wmb();
 379         hpte[0] = 0;
 380         if (!(v & HPTE_V_VALID))
 381                 return H_SUCCESS;
 382         if (!(flags & H_LOCAL)) {
 383                 while (!try_lock_tlbie(&kvm->arch.tlbie_lock))
 384                         cpu_relax();
 385                 asm volatile("ptesync" : : : "memory");
 386                 asm volatile(PPC_TLBIE(%1,%0)"; eieio; tlbsync"
 387                              : : "r" (rb), "r" (kvm->arch.lpid));
 388                 asm volatile("ptesync" : : : "memory");
 389                 kvm->arch.tlbie_lock = 0;
 390         } else {
 391                 asm volatile("ptesync" : : : "memory");
 392                 asm volatile("tlbiel %0" : : "r" (rb));
 393                 asm volatile("ptesync" : : : "memory");
 394         }
 395         return H_SUCCESS;
 396 }
 397
 398 long kvmppc_h_bulk_remove(struct kvm_vcpu *vcpu)
 399 {
 400         struct kvm *kvm = vcpu->kvm;
 401         unsigned long *args = &vcpu->arch.gpr[4];
 402         unsigned long *hp, tlbrb[4];
 403         long int i, found;
 404         long int n_inval = 0;
 405         unsigned long flags, req, pte_index;
 406         long int local = 0;
 407         long int ret = H_SUCCESS;
 408
 409         if (atomic_read(&kvm->online_vcpus) == 1)
 410                 local = 1;
 411         for (i = 0; i < 4; ++i) {
 412                 pte_index = args[i * 2];
 413                 flags = pte_index >> 56;
 414                 pte_index &= ((1ul << 56) - 1);
 415                 req = flags >> 6;
 416                 flags &= 3;
 417                 if (req == 3)
 418                         break;
 419                 if (req != 1 || flags == 3 ||
 420                     pte_index >= HPT_NPTE) {
 421                         /* parameter error */
 422                         args[i * 2] = ((0xa0 | flags) << 56) + pte_index;
 423                         ret = H_PARAMETER;
 424                         break;
 425                 }
 426                 hp = (unsigned long *)(kvm->arch.hpt_virt + (pte_index << 4));
 427                 while (!try_lock_hpte(hp, HPTE_V_HVLOCK))
 428                         cpu_relax();
 429                 found = 0;
 430                 if (hp[0] & (HPTE_V_ABSENT | HPTE_V_VALID)) {
 431                         switch (flags & 3) {
 432                         case 0:         /* absolute */
 433                                 found = 1;
 434                                 break;
 435                         case 1:         /* andcond */
 436                                 if (!(hp[0] & args[i * 2 + 1]))
 437                                         found = 1;
 438                                 break;
 439                         case 2:         /* AVPN */
 440                                 if ((hp[0] & ~0x7fUL) == args[i * 2 + 1])
 441                                         found = 1;
 442                                 break;
 443                         }
 444                 }
 445                 if (!found) {
 446                         hp[0] &= ~HPTE_V_HVLOCK;
 447                         args[i * 2] = ((0x90 | flags) << 56) + pte_index;
 448                         continue;
 449                 }
 450                 /* insert R and C bits from PTE */
 451                 flags |= (hp[1] >> 5) & 0x0c;
 452                 args[i * 2] = ((0x80 | flags) << 56) + pte_index;
 453                 if (hp[0] & HPTE_V_VALID) {
 454                         tlbrb[n_inval++] = compute_tlbie_rb(hp[0], hp[1], pte_index);
 455                         remove_revmap_chain(kvm, pte_index, hp[0]);
 456                 }
 457                 smp_wmb();
 458                 hp[0] = 0;
 459         }
 460         if (n_inval == 0)
 461                 return ret;
 462
 463         if (!local) {
 464                 while(!try_lock_tlbie(&kvm->arch.tlbie_lock))
 465                         cpu_relax();
 466                 asm volatile("ptesync" : : : "memory");
 467                 for (i = 0; i < n_inval; ++i)
 468                         asm volatile(PPC_TLBIE(%1,%0)
 469                                      : : "r" (tlbrb[i]), "r" (kvm->arch.lpid));
 470                 asm volatile("eieio; tlbsync; ptesync" : : : "memory");
 471                 kvm->arch.tlbie_lock = 0;
 472         } else {
 473                 asm volatile("ptesync" : : : "memory");
 474                 for (i = 0; i < n_inval; ++i)
 475                         asm volatile("tlbiel %0" : : "r" (tlbrb[i]));
 476                 asm volatile("ptesync" : : : "memory");
 477         }
 478         return ret;
 479 }
 480
 481 long kvmppc_h_protect(struct kvm_vcpu *vcpu, unsigned long flags,
 482                       unsigned long pte_index, unsigned long avpn,
 483                       unsigned long va)
 484 {
 485         struct kvm *kvm = vcpu->kvm;
 486         unsigned long *hpte;
 487         struct revmap_entry *rev;
 488         unsigned long v, r, rb, mask, bits;
 489
 490         if (pte_index >= HPT_NPTE)
 491                 return H_PARAMETER;
 492
 493         hpte = (unsigned long *)(kvm->arch.hpt_virt + (pte_index << 4));
 494         while (!try_lock_hpte(hpte, HPTE_V_HVLOCK))
 495                 cpu_relax();
 496         if ((hpte[0] & (HPTE_V_ABSENT | HPTE_V_VALID)) == 0 ||
 497             ((flags & H_AVPN) && (hpte[0] & ~0x7fUL) != avpn)) {
 498                 hpte[0] &= ~HPTE_V_HVLOCK;
 499                 return H_NOT_FOUND;
 500         }
 501
 502         if (atomic_read(&kvm->online_vcpus) == 1)
 503                 flags |= H_LOCAL;
 504         v = hpte[0];
 505         bits = (flags << 55) & HPTE_R_PP0;
 506         bits |= (flags << 48) & HPTE_R_KEY_HI;
 507         bits |= flags & (HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_LO);
 508
 509         /* Update guest view of 2nd HPTE dword */
 510         mask = HPTE_R_PP0 | HPTE_R_PP | HPTE_R_N |
 511                 HPTE_R_KEY_HI | HPTE_R_KEY_LO;
 512         rev = real_vmalloc_addr(&kvm->arch.revmap[pte_index]);
 513         if (rev) {
 514                 r = (rev->guest_rpte & ~mask) | bits;
 515                 rev->guest_rpte = r;
 516         }
 517         r = (hpte[1] & ~mask) | bits;
 518
 519         /* Update HPTE */
 520         if (v & HPTE_V_VALID) {
 521                 rb = compute_tlbie_rb(v, r, pte_index);
 522                 hpte[0] = v & ~HPTE_V_VALID;
 523                 if (!(flags & H_LOCAL)) {
 524                         while(!try_lock_tlbie(&kvm->arch.tlbie_lock))
 525                                 cpu_relax();
 526                         asm volatile("ptesync" : : : "memory");
 527                         asm volatile(PPC_TLBIE(%1,%0)"; eieio; tlbsync"
 528                                      : : "r" (rb), "r" (kvm->arch.lpid));
 529                         asm volatile("ptesync" : : : "memory");
 530                         kvm->arch.tlbie_lock = 0;
 531                 } else {
 532                         asm volatile("ptesync" : : : "memory");
 533                         asm volatile("tlbiel %0" : : "r" (rb));
 534                         asm volatile("ptesync" : : : "memory");
 535                 }
 536         }
 537         hpte[1] = r;
 538         eieio();
 539         hpte[0] = v & ~HPTE_V_HVLOCK;
 540         asm volatile("ptesync" : : : "memory");
 541         return H_SUCCESS;
 542 }
 543
 544 long kvmppc_h_read(struct kvm_vcpu *vcpu, unsigned long flags,
 545                    unsigned long pte_index)
 546 {
 547         struct kvm *kvm = vcpu->kvm;
 548         unsigned long *hpte, v, r;
 549         int i, n = 1;
 550         struct revmap_entry *rev = NULL;
 551
 552         if (pte_index >= HPT_NPTE)
 553                 return H_PARAMETER;
 554         if (flags & H_READ_4) {
 555                 pte_index &= ~3;
 556                 n = 4;
 557         }
 558         if (flags & H_R_XLATE)
 559                 rev = real_vmalloc_addr(&kvm->arch.revmap[pte_index]);
 560         for (i = 0; i < n; ++i, ++pte_index) {
 561                 hpte = (unsigned long *)(kvm->arch.hpt_virt + (pte_index << 4));
 562                 v = hpte[0] & ~HPTE_V_HVLOCK;
 563                 r = hpte[1];
 564                 if (v & HPTE_V_ABSENT) {
 565                         v &= ~HPTE_V_ABSENT;
 566                         v |= HPTE_V_VALID;
 567                 }
 568                 if (v & HPTE_V_VALID) {
 569                         if (rev)
 570                                 r = rev[i].guest_rpte;
 571                         else
 572                                 r = hpte[1] | HPTE_R_RPN;
 573                 }
 574                 vcpu->arch.gpr[4 + i * 2] = v;
 575                 vcpu->arch.gpr[5 + i * 2] = r;
 576         }
 577         return H_SUCCESS;
 578 }
 579
 580 void kvmppc_invalidate_hpte(struct kvm *kvm, unsigned long *hptep,
 581                         unsigned long pte_index)
 582 {
 583         unsigned long rb;
 584
 585         hptep[0] &= ~HPTE_V_VALID;
 586         rb = compute_tlbie_rb(hptep[0], hptep[1], pte_index);
 587         while (!try_lock_tlbie(&kvm->arch.tlbie_lock))
 588                 cpu_relax();
 589         asm volatile("ptesync" : : : "memory");
 590         asm volatile(PPC_TLBIE(%1,%0)"; eieio; tlbsync"
 591                      : : "r" (rb), "r" (kvm->arch.lpid));
 592         asm volatile("ptesync" : : : "memory");
 593         kvm->arch.tlbie_lock = 0;
 594 }
 595 EXPORT_SYMBOL_GPL(kvmppc_invalidate_hpte);
 596
 597 static int slb_base_page_shift[4] = {
 598         24,     /* 16M */
 599         16,     /* 64k */
 600         34,     /* 16G */
 601         20,     /* 1M, unsupported */
 602 };
 603
 604 long kvmppc_hv_find_lock_hpte(struct kvm *kvm, gva_t eaddr, unsigned long slb_v,
 605                               unsigned long valid)
 606 {
 607         unsigned int i;
 608         unsigned int pshift;
 609         unsigned long somask;
 610         unsigned long vsid, hash;
 611         unsigned long avpn;
 612         unsigned long *hpte;
 613         unsigned long mask, val;
 614         unsigned long v, r;
 615
 616         /* Get page shift, work out hash and AVPN etc. */
 617         mask = SLB_VSID_B | HPTE_V_AVPN | HPTE_V_SECONDARY;
 618         val = 0;
 619         pshift = 12;
 620         if (slb_v & SLB_VSID_L) {
 621                 mask |= HPTE_V_LARGE;
 622                 val |= HPTE_V_LARGE;
 623                 pshift = slb_base_page_shift[(slb_v & SLB_VSID_LP) >> 4];
 624         }
 625         if (slb_v & SLB_VSID_B_1T) {
 626                 somask = (1UL << 40) - 1;
 627                 vsid = (slb_v & ~SLB_VSID_B) >> SLB_VSID_SHIFT_1T;
 628                 vsid ^= vsid << 25;
 629         } else {
 630                 somask = (1UL << 28) - 1;
 631                 vsid = (slb_v & ~SLB_VSID_B) >> SLB_VSID_SHIFT;
 632         }
 633         hash = (vsid ^ ((eaddr & somask) >> pshift)) & HPT_HASH_MASK;
 634         avpn = slb_v & ~(somask >> 16); /* also includes B */
 635         avpn |= (eaddr & somask) >> 16;
 636
 637         if (pshift >= 24)
 638                 avpn &= ~((1UL << (pshift - 16)) - 1);
 639         else
 640                 avpn &= ~0x7fUL;
 641         val |= avpn;
 642
 643         for (;;) {
 644                 hpte = (unsigned long *)(kvm->arch.hpt_virt + (hash << 7));
 645
 646                 for (i = 0; i < 16; i += 2) {
 647                         /* Read the PTE racily */
 648                         v = hpte[i] & ~HPTE_V_HVLOCK;
 649
 650                         /* Check valid/absent, hash, segment size and AVPN */
 651                         if (!(v & valid) || (v & mask) != val)
 652                                 continue;
 653
 654                         /* Lock the PTE and read it under the lock */
 655                         while (!try_lock_hpte(&hpte[i], HPTE_V_HVLOCK))
 656                                 cpu_relax();
 657                         v = hpte[i] & ~HPTE_V_HVLOCK;
 658                         r = hpte[i+1];
 659
 660                         /*
 661                          * Check the HPTE again, including large page size
 662                          * Since we don't currently allow any MPSS (mixed
 663                          * page-size segment) page sizes, it is sufficient
 664                          * to check against the actual page size.
 665                          */
 666                         if ((v & valid) && (v & mask) == val &&
 667                             hpte_page_size(v, r) == (1ul << pshift))
 668                                 /* Return with the HPTE still locked */
 669                                 return (hash << 3) + (i >> 1);
 670
 671                         /* Unlock and move on */
 672                         hpte[i] = v;
 673                 }
 674
 675                 if (val & HPTE_V_SECONDARY)
 676                         break;
 677                 val |= HPTE_V_SECONDARY;
 678                 hash = hash ^ HPT_HASH_MASK;
 679         }
 680         return -1;
 681 }
 682 EXPORT_SYMBOL(kvmppc_hv_find_lock_hpte);
 683
 684 /*
 685  * Called in real mode to check whether an HPTE not found fault
 686  * is due to accessing a paged-out page or an emulated MMIO page,
 687  * or if a protection fault is due to accessing a page that the
 688  * guest wanted read/write access to but which we made read-only.
 689  * Returns a possibly modified status (DSISR) value if not
 690  * (i.e. pass the interrupt to the guest),
 691  * -1 to pass the fault up to host kernel mode code, -2 to do that
 692  * and also load the instruction word (for MMIO emulation),
 693  * or 0 if we should make the guest retry the access.
 694  */
 695 long kvmppc_hpte_hv_fault(struct kvm_vcpu *vcpu, unsigned long addr,
 696                           unsigned long slb_v, unsigned int status, bool data)
 697 {
 698         struct kvm *kvm = vcpu->kvm;
 699         long int index;
 700         unsigned long v, r, gr;
 701         unsigned long *hpte;
 702         unsigned long valid;
 703         struct revmap_entry *rev;
 704         unsigned long pp, key;
 705
 706         /* For protection fault, expect to find a valid HPTE */
 707         valid = HPTE_V_VALID;
 708         if (status & DSISR_NOHPTE)
 709                 valid |= HPTE_V_ABSENT;
 710
 711         index = kvmppc_hv_find_lock_hpte(kvm, addr, slb_v, valid);
 712         if (index < 0) {
 713                 if (status & DSISR_NOHPTE)
 714                         return status;  /* there really was no HPTE */
 715                 return 0;               /* for prot fault, HPTE disappeared */
 716         }
 717         hpte = (unsigned long *)(kvm->arch.hpt_virt + (index << 4));
 718         v = hpte[0] & ~HPTE_V_HVLOCK;
 719         r = hpte[1];
 720         rev = real_vmalloc_addr(&kvm->arch.revmap[index]);
 721         gr = rev->guest_rpte;
 722
 723         /* Unlock the HPTE */
 724         asm volatile("lwsync" : : : "memory");
 725         hpte[0] = v;
 726
 727         /* For not found, if the HPTE is valid by now, retry the instruction */
 728         if ((status & DSISR_NOHPTE) && (v & HPTE_V_VALID))
 729                 return 0;
 730
 731         /* Check access permissions to the page */
 732         pp = gr & (HPTE_R_PP0 | HPTE_R_PP);
 733         key = (vcpu->arch.shregs.msr & MSR_PR) ? SLB_VSID_KP : SLB_VSID_KS;
 734         status &= ~DSISR_NOHPTE;        /* DSISR_NOHPTE == SRR1_ISI_NOPT */
 735         if (!data) {
 736                 if (gr & (HPTE_R_N | HPTE_R_G))
 737                         return status | SRR1_ISI_N_OR_G;
 738                 if (!hpte_read_permission(pp, slb_v & key))
 739                         return status | SRR1_ISI_PROT;
 740         } else if (status & DSISR_ISSTORE) {
 741                 /* check write permission */
 742                 if (!hpte_write_permission(pp, slb_v & key))
 743                         return status | DSISR_PROTFAULT;
 744         } else {
 745                 if (!hpte_read_permission(pp, slb_v & key))
 746                         return status | DSISR_PROTFAULT;
 747         }
 748
 749         /* Check storage key, if applicable */
 750         if (data && (vcpu->arch.shregs.msr & MSR_DR)) {
 751                 unsigned int perm = hpte_get_skey_perm(gr, vcpu->arch.amr);
 752                 if (status & DSISR_ISSTORE)
 753                         perm >>= 1;
 754                 if (perm & 1)
 755                         return status | DSISR_KEYFAULT;
 756         }
 757
 758         /* Save HPTE info for virtual-mode handler */
 759         vcpu->arch.pgfault_addr = addr;
 760         vcpu->arch.pgfault_index = index;
 761         vcpu->arch.pgfault_hpte[0] = v;
 762         vcpu->arch.pgfault_hpte[1] = r;
 763
 764         /* Check the storage key to see if it is possibly emulated MMIO */
 765         if (data && (vcpu->arch.shregs.msr & MSR_IR) &&
 766             (r & (HPTE_R_KEY_HI | HPTE_R_KEY_LO)) ==
 767             (HPTE_R_KEY_HI | HPTE_R_KEY_LO))
 768                 return -2;      /* MMIO emulation - load instr word */
 769
 770         return -1;              /* send fault up to host kernel mode */
 771 }