arch/powerpc/kvm/book3s_64_mmu.c

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