Pileus Git - ~andy/linux/blob - arch/powerpc/kvm/book3s_64_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  * This program is distributed in the hope that it will be useful,
   7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9  * GNU General Public License for more details.
  10  *
  11  * You should have received a copy of the GNU General Public License
  12  * along with this program; if not, write to the Free Software
  13  * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  14  *
  15  * Copyright SUSE Linux Products GmbH 2009
  16  *
  17  * Authors: Alexander Graf <agraf@suse.de>
  18  */
  19
  20 #include <linux/types.h>
  21 #include <linux/string.h>
  22 #include <linux/kvm.h>
  23 #include <linux/kvm_host.h>
  24 #include <linux/highmem.h>
  25
  26 #include <asm/tlbflush.h>
  27 #include <asm/kvm_ppc.h>
  28 #include <asm/kvm_book3s.h>
  29 #include <asm/mmu-hash64.h>
  30
  31 /* #define DEBUG_MMU */
  32
  33 #ifdef DEBUG_MMU
  34 #define dprintk(X...) printk(KERN_INFO X)
  35 #else
  36 #define dprintk(X...) do { } while(0)
  37 #endif
  38
  39 static void kvmppc_mmu_book3s_64_reset_msr(struct kvm_vcpu *vcpu)
  40 {
  41         kvmppc_set_msr(vcpu, MSR_SF);
  42 }
  43
  44 static struct kvmppc_slb *kvmppc_mmu_book3s_64_find_slbe(
  45                                 struct kvm_vcpu *vcpu,
  46                                 gva_t eaddr)
  47 {
  48         int i;
  49         u64 esid = GET_ESID(eaddr);
  50         u64 esid_1t = GET_ESID_1T(eaddr);
  51
  52         for (i = 0; i < vcpu->arch.slb_nr; i++) {
  53                 u64 cmp_esid = esid;
  54
  55                 if (!vcpu->arch.slb[i].valid)
  56                         continue;
  57
  58                 if (vcpu->arch.slb[i].tb)
  59                         cmp_esid = esid_1t;
  60
  61                 if (vcpu->arch.slb[i].esid == cmp_esid)
  62                         return &vcpu->arch.slb[i];
  63         }
  64
  65         dprintk("KVM: No SLB entry found for 0x%lx [%llx | %llx]\n",
  66                 eaddr, esid, esid_1t);
  67         for (i = 0; i < vcpu->arch.slb_nr; i++) {
  68             if (vcpu->arch.slb[i].vsid)
  69                 dprintk("  %d: %c%c%c %llx %llx\n", i,
  70                         vcpu->arch.slb[i].valid ? 'v' : ' ',
  71                         vcpu->arch.slb[i].large ? 'l' : ' ',
  72                         vcpu->arch.slb[i].tb    ? 't' : ' ',
  73                         vcpu->arch.slb[i].esid,
  74                         vcpu->arch.slb[i].vsid);
  75         }
  76
  77         return NULL;
  78 }
  79
  80 static int kvmppc_slb_sid_shift(struct kvmppc_slb *slbe)
  81 {
  82         return slbe->tb ? SID_SHIFT_1T : SID_SHIFT;
  83 }
  84
  85 static u64 kvmppc_slb_offset_mask(struct kvmppc_slb *slbe)
  86 {
  87         return (1ul << kvmppc_slb_sid_shift(slbe)) - 1;
  88 }
  89
  90 static u64 kvmppc_slb_calc_vpn(struct kvmppc_slb *slb, gva_t eaddr)
  91 {
  92         eaddr &= kvmppc_slb_offset_mask(slb);
  93
  94         return (eaddr >> VPN_SHIFT) |
  95                 ((slb->vsid) << (kvmppc_slb_sid_shift(slb) - VPN_SHIFT));
  96 }
  97
  98 static u64 kvmppc_mmu_book3s_64_ea_to_vp(struct kvm_vcpu *vcpu, gva_t eaddr,
  99                                          bool data)
 100 {
 101         struct kvmppc_slb *slb;
 102
 103         slb = kvmppc_mmu_book3s_64_find_slbe(vcpu, eaddr);
 104         if (!slb)
 105                 return 0;
 106
 107         return kvmppc_slb_calc_vpn(slb, eaddr);
 108 }
 109
 110 static int mmu_pagesize(int mmu_pg)
 111 {
 112         switch (mmu_pg) {
 113         case MMU_PAGE_64K:
 114                 return 16;
 115         case MMU_PAGE_16M:
 116                 return 24;
 117         }
 118         return 12;
 119 }
 120
 121 static int kvmppc_mmu_book3s_64_get_pagesize(struct kvmppc_slb *slbe)
 122 {
 123         return mmu_pagesize(slbe->base_page_size);
 124 }
 125
 126 static u32 kvmppc_mmu_book3s_64_get_page(struct kvmppc_slb *slbe, gva_t eaddr)
 127 {
 128         int p = kvmppc_mmu_book3s_64_get_pagesize(slbe);
 129
 130         return ((eaddr & kvmppc_slb_offset_mask(slbe)) >> p);
 131 }
 132
 133 static hva_t kvmppc_mmu_book3s_64_get_pteg(struct kvm_vcpu *vcpu,
 134                                 struct kvmppc_slb *slbe, gva_t eaddr,
 135                                 bool second)
 136 {
 137         struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu);
 138         u64 hash, pteg, htabsize;
 139         u32 ssize;
 140         hva_t r;
 141         u64 vpn;
 142
 143         htabsize = ((1 << ((vcpu_book3s->sdr1 & 0x1f) + 11)) - 1);
 144
 145         vpn = kvmppc_slb_calc_vpn(slbe, eaddr);
 146         ssize = slbe->tb ? MMU_SEGSIZE_1T : MMU_SEGSIZE_256M;
 147         hash = hpt_hash(vpn, kvmppc_mmu_book3s_64_get_pagesize(slbe), ssize);
 148         if (second)
 149                 hash = ~hash;
 150         hash &= ((1ULL << 39ULL) - 1ULL);
 151         hash &= htabsize;
 152         hash <<= 7ULL;
 153
 154         pteg = vcpu_book3s->sdr1 & 0xfffffffffffc0000ULL;
 155         pteg |= hash;
 156
 157         dprintk("MMU: page=0x%x sdr1=0x%llx pteg=0x%llx vsid=0x%llx\n",
 158                 page, vcpu_book3s->sdr1, pteg, slbe->vsid);
 159
 160         /* When running a PAPR guest, SDR1 contains a HVA address instead
 161            of a GPA */
 162         if (vcpu->arch.papr_enabled)
 163                 r = pteg;
 164         else
 165                 r = gfn_to_hva(vcpu->kvm, pteg >> PAGE_SHIFT);
 166
 167         if (kvm_is_error_hva(r))
 168                 return r;
 169         return r | (pteg & ~PAGE_MASK);
 170 }
 171
 172 static u64 kvmppc_mmu_book3s_64_get_avpn(struct kvmppc_slb *slbe, gva_t eaddr)
 173 {
 174         int p = kvmppc_mmu_book3s_64_get_pagesize(slbe);
 175         u64 avpn;
 176
 177         avpn = kvmppc_mmu_book3s_64_get_page(slbe, eaddr);
 178         avpn |= slbe->vsid << (kvmppc_slb_sid_shift(slbe) - p);
 179
 180         if (p < 16)
 181                 avpn >>= ((80 - p) - 56) - 8;   /* 16 - p */
 182         else
 183                 avpn <<= p - 16;
 184
 185         return avpn;
 186 }
 187
 188 /*
 189  * Return page size encoded in the second word of a HPTE, or
 190  * -1 for an invalid encoding for the base page size indicated by
 191  * the SLB entry.  This doesn't handle mixed pagesize segments yet.
 192  */
 193 static int decode_pagesize(struct kvmppc_slb *slbe, u64 r)
 194 {
 195         switch (slbe->base_page_size) {
 196         case MMU_PAGE_64K:
 197                 if ((r & 0xf000) == 0x1000)
 198                         return MMU_PAGE_64K;
 199                 break;
 200         case MMU_PAGE_16M:
 201                 if ((r & 0xff000) == 0)
 202                         return MMU_PAGE_16M;
 203                 break;
 204         }
 205         return -1;
 206 }
 207
 208 static int kvmppc_mmu_book3s_64_xlate(struct kvm_vcpu *vcpu, gva_t eaddr,
 209                                 struct kvmppc_pte *gpte, bool data)
 210 {
 211         struct kvmppc_slb *slbe;
 212         hva_t ptegp;
 213         u64 pteg[16];
 214         u64 avpn = 0;
 215         u64 v, r;
 216         u64 v_val, v_mask;
 217         u64 eaddr_mask;
 218         int i;
 219         u8 pp, key = 0;
 220         bool found = false;
 221         bool second = false;
 222         int pgsize;
 223         ulong mp_ea = vcpu->arch.magic_page_ea;
 224
 225         /* Magic page override */
 226         if (unlikely(mp_ea) &&
 227             unlikely((eaddr & ~0xfffULL) == (mp_ea & ~0xfffULL)) &&
 228             !(vcpu->arch.shared->msr & MSR_PR)) {
 229                 gpte->eaddr = eaddr;
 230                 gpte->vpage = kvmppc_mmu_book3s_64_ea_to_vp(vcpu, eaddr, data);
 231                 gpte->raddr = vcpu->arch.magic_page_pa | (gpte->raddr & 0xfff);
 232                 gpte->raddr &= KVM_PAM;
 233                 gpte->may_execute = true;
 234                 gpte->may_read = true;
 235                 gpte->may_write = true;
 236                 gpte->page_size = MMU_PAGE_4K;
 237
 238                 return 0;
 239         }
 240
 241         slbe = kvmppc_mmu_book3s_64_find_slbe(vcpu, eaddr);
 242         if (!slbe)
 243                 goto no_seg_found;
 244
 245         avpn = kvmppc_mmu_book3s_64_get_avpn(slbe, eaddr);
 246         v_val = avpn & HPTE_V_AVPN;
 247
 248         if (slbe->tb)
 249                 v_val |= SLB_VSID_B_1T;
 250         if (slbe->large)
 251                 v_val |= HPTE_V_LARGE;
 252         v_val |= HPTE_V_VALID;
 253
 254         v_mask = SLB_VSID_B | HPTE_V_AVPN | HPTE_V_LARGE | HPTE_V_VALID |
 255                 HPTE_V_SECONDARY;
 256
 257         pgsize = slbe->large ? MMU_PAGE_16M : MMU_PAGE_4K;
 258
 259         mutex_lock(&vcpu->kvm->arch.hpt_mutex);
 260
 261 do_second:
 262         ptegp = kvmppc_mmu_book3s_64_get_pteg(vcpu, slbe, eaddr, second);
 263         if (kvm_is_error_hva(ptegp))
 264                 goto no_page_found;
 265
 266         if(copy_from_user(pteg, (void __user *)ptegp, sizeof(pteg))) {
 267                 printk(KERN_ERR "KVM can't copy data from 0x%lx!\n", ptegp);
 268                 goto no_page_found;
 269         }
 270
 271         if ((vcpu->arch.shared->msr & MSR_PR) && slbe->Kp)
 272                 key = 4;
 273         else if (!(vcpu->arch.shared->msr & MSR_PR) && slbe->Ks)
 274                 key = 4;
 275
 276         for (i=0; i<16; i+=2) {
 277                 /* Check all relevant fields of 1st dword */
 278                 if ((pteg[i] & v_mask) == v_val) {
 279                         /* If large page bit is set, check pgsize encoding */
 280                         if (slbe->large &&
 281                             (vcpu->arch.hflags & BOOK3S_HFLAG_MULTI_PGSIZE)) {
 282                                 pgsize = decode_pagesize(slbe, pteg[i+1]);
 283                                 if (pgsize < 0)
 284                                         continue;
 285                         }
 286                         found = true;
 287                         break;
 288                 }
 289         }
 290
 291         if (!found) {
 292                 if (second)
 293                         goto no_page_found;
 294                 v_val |= HPTE_V_SECONDARY;
 295                 second = true;
 296                 goto do_second;
 297         }
 298
 299         v = pteg[i];
 300         r = pteg[i+1];
 301         pp = (r & HPTE_R_PP) | key;
 302         if (r & HPTE_R_PP0)
 303                 pp |= 8;
 304
 305         gpte->eaddr = eaddr;
 306         gpte->vpage = kvmppc_mmu_book3s_64_ea_to_vp(vcpu, eaddr, data);
 307
 308         eaddr_mask = (1ull << mmu_pagesize(pgsize)) - 1;
 309         gpte->raddr = (r & HPTE_R_RPN & ~eaddr_mask) | (eaddr & eaddr_mask);
 310         gpte->page_size = pgsize;
 311         gpte->may_execute = ((r & HPTE_R_N) ? false : true);
 312         gpte->may_read = false;
 313         gpte->may_write = false;
 314
 315         switch (pp) {
 316         case 0:
 317         case 1:
 318         case 2:
 319         case 6:
 320                 gpte->may_write = true;
 321                 /* fall through */
 322         case 3:
 323         case 5:
 324         case 7:
 325         case 10:
 326                 gpte->may_read = true;
 327                 break;
 328         }
 329
 330         dprintk("KVM MMU: Translated 0x%lx [0x%llx] -> 0x%llx "
 331                 "-> 0x%lx\n",
 332                 eaddr, avpn, gpte->vpage, gpte->raddr);
 333
 334         /* Update PTE R and C bits, so the guest's swapper knows we used the
 335          * page */
 336         if (gpte->may_read && !(r & HPTE_R_R)) {
 337                 /*
 338                  * Set the accessed flag.
 339                  * We have to write this back with a single byte write
 340                  * because another vcpu may be accessing this on
 341                  * non-PAPR platforms such as mac99, and this is
 342                  * what real hardware does.
 343                  */
 344                 char __user *addr = (char __user *) &pteg[i+1];
 345                 r |= HPTE_R_R;
 346                 put_user(r >> 8, addr + 6);
 347         }
 348         if (data && gpte->may_write && !(r & HPTE_R_C)) {
 349                 /* Set the dirty flag -- XXX even if not writing */
 350                 /* Use a single byte write */
 351                 char __user *addr = (char __user *) &pteg[i+1];
 352                 r |= HPTE_R_C;
 353                 put_user(r, addr + 7);
 354         }
 355
 356         mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
 357
 358         if (!gpte->may_read)
 359                 return -EPERM;
 360         return 0;
 361
 362 no_page_found:
 363         mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
 364         return -ENOENT;
 365
 366 no_seg_found:
 367         dprintk("KVM MMU: Trigger segment fault\n");
 368         return -EINVAL;
 369 }
 370
 371 static void kvmppc_mmu_book3s_64_slbmte(struct kvm_vcpu *vcpu, u64 rs, u64 rb)
 372 {
 373         struct kvmppc_vcpu_book3s *vcpu_book3s;
 374         u64 esid, esid_1t;
 375         int slb_nr;
 376         struct kvmppc_slb *slbe;
 377
 378         dprintk("KVM MMU: slbmte(0x%llx, 0x%llx)\n", rs, rb);
 379
 380         vcpu_book3s = to_book3s(vcpu);
 381
 382         esid = GET_ESID(rb);
 383         esid_1t = GET_ESID_1T(rb);
 384         slb_nr = rb & 0xfff;
 385
 386         if (slb_nr > vcpu->arch.slb_nr)
 387                 return;
 388
 389         slbe = &vcpu->arch.slb[slb_nr];
 390
 391         slbe->large = (rs & SLB_VSID_L) ? 1 : 0;
 392         slbe->tb    = (rs & SLB_VSID_B_1T) ? 1 : 0;
 393         slbe->esid  = slbe->tb ? esid_1t : esid;
 394         slbe->vsid  = (rs & ~SLB_VSID_B) >> (kvmppc_slb_sid_shift(slbe) - 16);
 395         slbe->valid = (rb & SLB_ESID_V) ? 1 : 0;
 396         slbe->Ks    = (rs & SLB_VSID_KS) ? 1 : 0;
 397         slbe->Kp    = (rs & SLB_VSID_KP) ? 1 : 0;
 398         slbe->nx    = (rs & SLB_VSID_N) ? 1 : 0;
 399         slbe->class = (rs & SLB_VSID_C) ? 1 : 0;
 400
 401         slbe->base_page_size = MMU_PAGE_4K;
 402         if (slbe->large) {
 403                 if (vcpu->arch.hflags & BOOK3S_HFLAG_MULTI_PGSIZE) {
 404                         switch (rs & SLB_VSID_LP) {
 405                         case SLB_VSID_LP_00:
 406                                 slbe->base_page_size = MMU_PAGE_16M;
 407                                 break;
 408                         case SLB_VSID_LP_01:
 409                                 slbe->base_page_size = MMU_PAGE_64K;
 410                                 break;
 411                         }
 412                 } else
 413                         slbe->base_page_size = MMU_PAGE_16M;
 414         }
 415
 416         slbe->orige = rb & (ESID_MASK | SLB_ESID_V);
 417         slbe->origv = rs;
 418
 419         /* Map the new segment */
 420         kvmppc_mmu_map_segment(vcpu, esid << SID_SHIFT);
 421 }
 422
 423 static u64 kvmppc_mmu_book3s_64_slbmfee(struct kvm_vcpu *vcpu, u64 slb_nr)
 424 {
 425         struct kvmppc_slb *slbe;
 426
 427         if (slb_nr > vcpu->arch.slb_nr)
 428                 return 0;
 429
 430         slbe = &vcpu->arch.slb[slb_nr];
 431
 432         return slbe->orige;
 433 }
 434
 435 static u64 kvmppc_mmu_book3s_64_slbmfev(struct kvm_vcpu *vcpu, u64 slb_nr)
 436 {
 437         struct kvmppc_slb *slbe;
 438
 439         if (slb_nr > vcpu->arch.slb_nr)
 440                 return 0;
 441
 442         slbe = &vcpu->arch.slb[slb_nr];
 443
 444         return slbe->origv;
 445 }
 446
 447 static void kvmppc_mmu_book3s_64_slbie(struct kvm_vcpu *vcpu, u64 ea)
 448 {
 449         struct kvmppc_slb *slbe;
 450         u64 seg_size;
 451
 452         dprintk("KVM MMU: slbie(0x%llx)\n", ea);
 453
 454         slbe = kvmppc_mmu_book3s_64_find_slbe(vcpu, ea);
 455
 456         if (!slbe)
 457                 return;
 458
 459         dprintk("KVM MMU: slbie(0x%llx, 0x%llx)\n", ea, slbe->esid);
 460
 461         slbe->valid = false;
 462         slbe->orige = 0;
 463         slbe->origv = 0;
 464
 465         seg_size = 1ull << kvmppc_slb_sid_shift(slbe);
 466         kvmppc_mmu_flush_segment(vcpu, ea & ~(seg_size - 1), seg_size);
 467 }
 468
 469 static void kvmppc_mmu_book3s_64_slbia(struct kvm_vcpu *vcpu)
 470 {
 471         int i;
 472
 473         dprintk("KVM MMU: slbia()\n");
 474
 475         for (i = 1; i < vcpu->arch.slb_nr; i++) {
 476                 vcpu->arch.slb[i].valid = false;
 477                 vcpu->arch.slb[i].orige = 0;
 478                 vcpu->arch.slb[i].origv = 0;
 479         }
 480
 481         if (vcpu->arch.shared->msr & MSR_IR) {
 482                 kvmppc_mmu_flush_segments(vcpu);
 483                 kvmppc_mmu_map_segment(vcpu, kvmppc_get_pc(vcpu));
 484         }
 485 }
 486
 487 static void kvmppc_mmu_book3s_64_mtsrin(struct kvm_vcpu *vcpu, u32 srnum,
 488                                         ulong value)
 489 {
 490         u64 rb = 0, rs = 0;
 491
 492         /*
 493          * According to Book3 2.01 mtsrin is implemented as:
 494          *
 495          * The SLB entry specified by (RB)32:35 is loaded from register
 496          * RS, as follows.
 497          *
 498          * SLBE Bit     Source                  SLB Field
 499          *
 500          * 0:31         0x0000_0000             ESID-0:31
 501          * 32:35        (RB)32:35               ESID-32:35
 502          * 36           0b1                     V
 503          * 37:61        0x00_0000|| 0b0         VSID-0:24
 504          * 62:88        (RS)37:63               VSID-25:51
 505          * 89:91        (RS)33:35               Ks Kp N
 506          * 92           (RS)36                  L ((RS)36 must be 0b0)
 507          * 93           0b0                     C
 508          */
 509
 510         dprintk("KVM MMU: mtsrin(0x%x, 0x%lx)\n", srnum, value);
 511
 512         /* ESID = srnum */
 513         rb |= (srnum & 0xf) << 28;
 514         /* Set the valid bit */
 515         rb |= 1 << 27;
 516         /* Index = ESID */
 517         rb |= srnum;
 518
 519         /* VSID = VSID */
 520         rs |= (value & 0xfffffff) << 12;
 521         /* flags = flags */
 522         rs |= ((value >> 28) & 0x7) << 9;
 523
 524         kvmppc_mmu_book3s_64_slbmte(vcpu, rs, rb);
 525 }
 526
 527 static void kvmppc_mmu_book3s_64_tlbie(struct kvm_vcpu *vcpu, ulong va,
 528                                        bool large)
 529 {
 530         u64 mask = 0xFFFFFFFFFULL;
 531         long i;
 532         struct kvm_vcpu *v;
 533
 534         dprintk("KVM MMU: tlbie(0x%lx)\n", va);
 535
 536         /*
 537          * The tlbie instruction changed behaviour starting with
 538          * POWER6.  POWER6 and later don't have the large page flag
 539          * in the instruction but in the RB value, along with bits
 540          * indicating page and segment sizes.
 541          */
 542         if (vcpu->arch.hflags & BOOK3S_HFLAG_NEW_TLBIE) {
 543                 /* POWER6 or later */
 544                 if (va & 1) {           /* L bit */
 545                         if ((va & 0xf000) == 0x1000)
 546                                 mask = 0xFFFFFFFF0ULL;  /* 64k page */
 547                         else
 548                                 mask = 0xFFFFFF000ULL;  /* 16M page */
 549                 }
 550         } else {
 551                 /* older processors, e.g. PPC970 */
 552                 if (large)
 553                         mask = 0xFFFFFF000ULL;
 554         }
 555         /* flush this VA on all vcpus */
 556         kvm_for_each_vcpu(i, v, vcpu->kvm)
 557                 kvmppc_mmu_pte_vflush(v, va >> 12, mask);
 558 }
 559
 560 #ifdef CONFIG_PPC_64K_PAGES
 561 static int segment_contains_magic_page(struct kvm_vcpu *vcpu, ulong esid)
 562 {
 563         ulong mp_ea = vcpu->arch.magic_page_ea;
 564
 565         return mp_ea && !(vcpu->arch.shared->msr & MSR_PR) &&
 566                 (mp_ea >> SID_SHIFT) == esid;
 567 }
 568 #endif
 569
 570 static int kvmppc_mmu_book3s_64_esid_to_vsid(struct kvm_vcpu *vcpu, ulong esid,
 571                                              u64 *vsid)
 572 {
 573         ulong ea = esid << SID_SHIFT;
 574         struct kvmppc_slb *slb;
 575         u64 gvsid = esid;
 576         ulong mp_ea = vcpu->arch.magic_page_ea;
 577         int pagesize = MMU_PAGE_64K;
 578
 579         if (vcpu->arch.shared->msr & (MSR_DR|MSR_IR)) {
 580                 slb = kvmppc_mmu_book3s_64_find_slbe(vcpu, ea);
 581                 if (slb) {
 582                         gvsid = slb->vsid;
 583                         pagesize = slb->base_page_size;
 584                         if (slb->tb) {
 585                                 gvsid <<= SID_SHIFT_1T - SID_SHIFT;
 586                                 gvsid |= esid & ((1ul << (SID_SHIFT_1T - SID_SHIFT)) - 1);
 587                                 gvsid |= VSID_1T;
 588                         }
 589                 }
 590         }
 591
 592         switch (vcpu->arch.shared->msr & (MSR_DR|MSR_IR)) {
 593         case 0:
 594                 gvsid = VSID_REAL | esid;
 595                 break;
 596         case MSR_IR:
 597                 gvsid |= VSID_REAL_IR;
 598                 break;
 599         case MSR_DR:
 600                 gvsid |= VSID_REAL_DR;
 601                 break;
 602         case MSR_DR|MSR_IR:
 603                 if (!slb)
 604                         goto no_slb;
 605
 606                 break;
 607         default:
 608                 BUG();
 609                 break;
 610         }
 611
 612 #ifdef CONFIG_PPC_64K_PAGES
 613         /*
 614          * Mark this as a 64k segment if the host is using
 615          * 64k pages, the host MMU supports 64k pages and
 616          * the guest segment page size is >= 64k,
 617          * but not if this segment contains the magic page.
 618          */
 619         if (pagesize >= MMU_PAGE_64K &&
 620             mmu_psize_defs[MMU_PAGE_64K].shift &&
 621             !segment_contains_magic_page(vcpu, esid))
 622                 gvsid |= VSID_64K;
 623 #endif
 624
 625         if (vcpu->arch.shared->msr & MSR_PR)
 626                 gvsid |= VSID_PR;
 627
 628         *vsid = gvsid;
 629         return 0;
 630
 631 no_slb:
 632         /* Catch magic page case */
 633         if (unlikely(mp_ea) &&
 634             unlikely(esid == (mp_ea >> SID_SHIFT)) &&
 635             !(vcpu->arch.shared->msr & MSR_PR)) {
 636                 *vsid = VSID_REAL | esid;
 637                 return 0;
 638         }
 639
 640         return -EINVAL;
 641 }
 642
 643 static bool kvmppc_mmu_book3s_64_is_dcbz32(struct kvm_vcpu *vcpu)
 644 {
 645         return (to_book3s(vcpu)->hid[5] & 0x80);
 646 }
 647
 648 void kvmppc_mmu_book3s_64_init(struct kvm_vcpu *vcpu)
 649 {
 650         struct kvmppc_mmu *mmu = &vcpu->arch.mmu;
 651
 652         mmu->mfsrin = NULL;
 653         mmu->mtsrin = kvmppc_mmu_book3s_64_mtsrin;
 654         mmu->slbmte = kvmppc_mmu_book3s_64_slbmte;
 655         mmu->slbmfee = kvmppc_mmu_book3s_64_slbmfee;
 656         mmu->slbmfev = kvmppc_mmu_book3s_64_slbmfev;
 657         mmu->slbie = kvmppc_mmu_book3s_64_slbie;
 658         mmu->slbia = kvmppc_mmu_book3s_64_slbia;
 659         mmu->xlate = kvmppc_mmu_book3s_64_xlate;
 660         mmu->reset_msr = kvmppc_mmu_book3s_64_reset_msr;
 661         mmu->tlbie = kvmppc_mmu_book3s_64_tlbie;
 662         mmu->esid_to_vsid = kvmppc_mmu_book3s_64_esid_to_vsid;
 663         mmu->ea_to_vp = kvmppc_mmu_book3s_64_ea_to_vp;
 664         mmu->is_dcbz32 = kvmppc_mmu_book3s_64_is_dcbz32;
 665
 666         vcpu->arch.hflags |= BOOK3S_HFLAG_SLB;
 667 }