1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include "qemu/osdep.h"
21#include "qemu/units.h"
22#include "cpu.h"
23#include "exec/exec-all.h"
24#include "exec/helper-proto.h"
25#include "qemu/error-report.h"
26#include "qemu/qemu-print.h"
27#include "sysemu/hw_accel.h"
28#include "kvm_ppc.h"
29#include "mmu-hash64.h"
30#include "exec/log.h"
31#include "hw/hw.h"
32#include "mmu-book3s-v3.h"
33
34
35
36#ifdef DEBUG_SLB
37# define LOG_SLB(...) qemu_log_mask(CPU_LOG_MMU, __VA_ARGS__)
38#else
39# define LOG_SLB(...) do { } while (0)
40#endif
41
42
43
44
45
46static ppc_slb_t *slb_lookup(PowerPCCPU *cpu, target_ulong eaddr)
47{
48 CPUPPCState *env = &cpu->env;
49 uint64_t esid_256M, esid_1T;
50 int n;
51
52 LOG_SLB("%s: eaddr " TARGET_FMT_lx "\n", __func__, eaddr);
53
54 esid_256M = (eaddr & SEGMENT_MASK_256M) | SLB_ESID_V;
55 esid_1T = (eaddr & SEGMENT_MASK_1T) | SLB_ESID_V;
56
57 for (n = 0; n < cpu->hash64_opts->slb_size; n++) {
58 ppc_slb_t *slb = &env->slb[n];
59
60 LOG_SLB("%s: slot %d %016" PRIx64 " %016"
61 PRIx64 "\n", __func__, n, slb->esid, slb->vsid);
62
63
64
65
66
67 if (((slb->esid == esid_256M) &&
68 ((slb->vsid & SLB_VSID_B) == SLB_VSID_B_256M))
69 || ((slb->esid == esid_1T) &&
70 ((slb->vsid & SLB_VSID_B) == SLB_VSID_B_1T))) {
71 return slb;
72 }
73 }
74
75 return NULL;
76}
77
78void dump_slb(PowerPCCPU *cpu)
79{
80 CPUPPCState *env = &cpu->env;
81 int i;
82 uint64_t slbe, slbv;
83
84 cpu_synchronize_state(CPU(cpu));
85
86 qemu_printf("SLB\tESID\t\t\tVSID\n");
87 for (i = 0; i < cpu->hash64_opts->slb_size; i++) {
88 slbe = env->slb[i].esid;
89 slbv = env->slb[i].vsid;
90 if (slbe == 0 && slbv == 0) {
91 continue;
92 }
93 qemu_printf("%d\t0x%016" PRIx64 "\t0x%016" PRIx64 "\n",
94 i, slbe, slbv);
95 }
96}
97
98void helper_slbia(CPUPPCState *env, uint32_t ih)
99{
100 PowerPCCPU *cpu = env_archcpu(env);
101 int starting_entry;
102 int n;
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125 env->tlb_need_flush |= TLB_NEED_LOCAL_FLUSH;
126
127 starting_entry = 1;
128
129 if (env->mmu_model == POWERPC_MMU_3_00) {
130 switch (ih) {
131 case 0x7:
132
133 return;
134
135 case 0x3:
136 case 0x4:
137
138 starting_entry = 0;
139 break;
140
141 case 0x5:
142
143 qemu_log_mask(LOG_GUEST_ERROR,
144 "slbia undefined IH field %u.\n", ih);
145 break;
146
147 default:
148
149 break;
150 }
151 }
152
153 for (n = starting_entry; n < cpu->hash64_opts->slb_size; n++) {
154 ppc_slb_t *slb = &env->slb[n];
155
156 if (!(slb->esid & SLB_ESID_V)) {
157 continue;
158 }
159 if (env->mmu_model == POWERPC_MMU_3_00) {
160 if (ih == 0x3 && (slb->vsid & SLB_VSID_C) == 0) {
161
162 continue;
163 }
164 }
165
166 slb->esid &= ~SLB_ESID_V;
167 }
168}
169
170static void __helper_slbie(CPUPPCState *env, target_ulong addr,
171 target_ulong global)
172{
173 PowerPCCPU *cpu = env_archcpu(env);
174 ppc_slb_t *slb;
175
176 slb = slb_lookup(cpu, addr);
177 if (!slb) {
178 return;
179 }
180
181 if (slb->esid & SLB_ESID_V) {
182 slb->esid &= ~SLB_ESID_V;
183
184
185
186
187
188
189 env->tlb_need_flush |=
190 (global == false ? TLB_NEED_LOCAL_FLUSH : TLB_NEED_GLOBAL_FLUSH);
191 }
192}
193
194void helper_slbie(CPUPPCState *env, target_ulong addr)
195{
196 __helper_slbie(env, addr, false);
197}
198
199void helper_slbieg(CPUPPCState *env, target_ulong addr)
200{
201 __helper_slbie(env, addr, true);
202}
203
204int ppc_store_slb(PowerPCCPU *cpu, target_ulong slot,
205 target_ulong esid, target_ulong vsid)
206{
207 CPUPPCState *env = &cpu->env;
208 ppc_slb_t *slb = &env->slb[slot];
209 const PPCHash64SegmentPageSizes *sps = NULL;
210 int i;
211
212 if (slot >= cpu->hash64_opts->slb_size) {
213 return -1;
214 }
215 if (esid & ~(SLB_ESID_ESID | SLB_ESID_V)) {
216 return -1;
217 }
218 if (vsid & (SLB_VSID_B & ~SLB_VSID_B_1T)) {
219 return -1;
220 }
221 if ((vsid & SLB_VSID_B) && !(ppc_hash64_has(cpu, PPC_HASH64_1TSEG))) {
222 return -1;
223 }
224
225 for (i = 0; i < PPC_PAGE_SIZES_MAX_SZ; i++) {
226 const PPCHash64SegmentPageSizes *sps1 = &cpu->hash64_opts->sps[i];
227
228 if (!sps1->page_shift) {
229 break;
230 }
231
232 if ((vsid & SLB_VSID_LLP_MASK) == sps1->slb_enc) {
233 sps = sps1;
234 break;
235 }
236 }
237
238 if (!sps) {
239 error_report("Bad page size encoding in SLB store: slot "TARGET_FMT_lu
240 " esid 0x"TARGET_FMT_lx" vsid 0x"TARGET_FMT_lx,
241 slot, esid, vsid);
242 return -1;
243 }
244
245 slb->esid = esid;
246 slb->vsid = vsid;
247 slb->sps = sps;
248
249 LOG_SLB("%s: " TARGET_FMT_lu " " TARGET_FMT_lx " - " TARGET_FMT_lx
250 " => %016" PRIx64 " %016" PRIx64 "\n", __func__, slot, esid, vsid,
251 slb->esid, slb->vsid);
252
253 return 0;
254}
255
256static int ppc_load_slb_esid(PowerPCCPU *cpu, target_ulong rb,
257 target_ulong *rt)
258{
259 CPUPPCState *env = &cpu->env;
260 int slot = rb & 0xfff;
261 ppc_slb_t *slb = &env->slb[slot];
262
263 if (slot >= cpu->hash64_opts->slb_size) {
264 return -1;
265 }
266
267 *rt = slb->esid;
268 return 0;
269}
270
271static int ppc_load_slb_vsid(PowerPCCPU *cpu, target_ulong rb,
272 target_ulong *rt)
273{
274 CPUPPCState *env = &cpu->env;
275 int slot = rb & 0xfff;
276 ppc_slb_t *slb = &env->slb[slot];
277
278 if (slot >= cpu->hash64_opts->slb_size) {
279 return -1;
280 }
281
282 *rt = slb->vsid;
283 return 0;
284}
285
286static int ppc_find_slb_vsid(PowerPCCPU *cpu, target_ulong rb,
287 target_ulong *rt)
288{
289 CPUPPCState *env = &cpu->env;
290 ppc_slb_t *slb;
291
292 if (!msr_is_64bit(env, env->msr)) {
293 rb &= 0xffffffff;
294 }
295 slb = slb_lookup(cpu, rb);
296 if (slb == NULL) {
297 *rt = (target_ulong)-1ul;
298 } else {
299 *rt = slb->vsid;
300 }
301 return 0;
302}
303
304void helper_store_slb(CPUPPCState *env, target_ulong rb, target_ulong rs)
305{
306 PowerPCCPU *cpu = env_archcpu(env);
307
308 if (ppc_store_slb(cpu, rb & 0xfff, rb & ~0xfffULL, rs) < 0) {
309 raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
310 POWERPC_EXCP_INVAL, GETPC());
311 }
312}
313
314target_ulong helper_load_slb_esid(CPUPPCState *env, target_ulong rb)
315{
316 PowerPCCPU *cpu = env_archcpu(env);
317 target_ulong rt = 0;
318
319 if (ppc_load_slb_esid(cpu, rb, &rt) < 0) {
320 raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
321 POWERPC_EXCP_INVAL, GETPC());
322 }
323 return rt;
324}
325
326target_ulong helper_find_slb_vsid(CPUPPCState *env, target_ulong rb)
327{
328 PowerPCCPU *cpu = env_archcpu(env);
329 target_ulong rt = 0;
330
331 if (ppc_find_slb_vsid(cpu, rb, &rt) < 0) {
332 raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
333 POWERPC_EXCP_INVAL, GETPC());
334 }
335 return rt;
336}
337
338target_ulong helper_load_slb_vsid(CPUPPCState *env, target_ulong rb)
339{
340 PowerPCCPU *cpu = env_archcpu(env);
341 target_ulong rt = 0;
342
343 if (ppc_load_slb_vsid(cpu, rb, &rt) < 0) {
344 raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
345 POWERPC_EXCP_INVAL, GETPC());
346 }
347 return rt;
348}
349
350
351static inline int ppc_hash64_pte_noexec_guard(PowerPCCPU *cpu,
352 ppc_hash_pte64_t pte)
353{
354
355 return (pte.pte1 & HPTE64_R_N) || (pte.pte1 & HPTE64_R_G) ?
356 PAGE_READ | PAGE_WRITE : PAGE_READ | PAGE_WRITE | PAGE_EXEC;
357}
358
359
360static int ppc_hash64_pte_prot(PowerPCCPU *cpu,
361 ppc_slb_t *slb, ppc_hash_pte64_t pte)
362{
363 CPUPPCState *env = &cpu->env;
364 unsigned pp, key;
365
366
367
368
369 int prot = 0;
370
371 key = !!(msr_pr ? (slb->vsid & SLB_VSID_KP)
372 : (slb->vsid & SLB_VSID_KS));
373 pp = (pte.pte1 & HPTE64_R_PP) | ((pte.pte1 & HPTE64_R_PP0) >> 61);
374
375 if (key == 0) {
376 switch (pp) {
377 case 0x0:
378 case 0x1:
379 case 0x2:
380 prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
381 break;
382
383 case 0x3:
384 case 0x6:
385 prot = PAGE_READ | PAGE_EXEC;
386 break;
387 }
388 } else {
389 switch (pp) {
390 case 0x0:
391 case 0x6:
392 break;
393
394 case 0x1:
395 case 0x3:
396 prot = PAGE_READ | PAGE_EXEC;
397 break;
398
399 case 0x2:
400 prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
401 break;
402 }
403 }
404
405 return prot;
406}
407
408
409static int ppc_hash64_iamr_prot(PowerPCCPU *cpu, int key)
410{
411 CPUPPCState *env = &cpu->env;
412 int iamr_bits = (env->spr[SPR_IAMR] >> 2 * (31 - key)) & 0x3;
413
414
415
416
417
418
419
420
421 return (iamr_bits & 0x1) ? PAGE_READ | PAGE_WRITE :
422 PAGE_READ | PAGE_WRITE | PAGE_EXEC;
423}
424
425static int ppc_hash64_amr_prot(PowerPCCPU *cpu, ppc_hash_pte64_t pte)
426{
427 CPUPPCState *env = &cpu->env;
428 int key, amrbits;
429 int prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
430
431
432 if (!ppc_hash64_has(cpu, PPC_HASH64_AMR)) {
433 return prot;
434 }
435
436 key = HPTE64_R_KEY(pte.pte1);
437 amrbits = (env->spr[SPR_AMR] >> 2 * (31 - key)) & 0x3;
438
439
440
441
442
443
444
445
446 if (amrbits & 0x2) {
447 prot &= ~PAGE_WRITE;
448 }
449
450
451
452
453 if (amrbits & 0x1) {
454 prot &= ~PAGE_READ;
455 }
456
457 switch (env->mmu_model) {
458
459
460
461
462
463
464 case POWERPC_MMU_2_07:
465 case POWERPC_MMU_3_00:
466 prot &= ppc_hash64_iamr_prot(cpu, key);
467 break;
468 default:
469 break;
470 }
471
472 return prot;
473}
474
475const ppc_hash_pte64_t *ppc_hash64_map_hptes(PowerPCCPU *cpu,
476 hwaddr ptex, int n)
477{
478 hwaddr pte_offset = ptex * HASH_PTE_SIZE_64;
479 hwaddr base;
480 hwaddr plen = n * HASH_PTE_SIZE_64;
481 const ppc_hash_pte64_t *hptes;
482
483 if (cpu->vhyp) {
484 PPCVirtualHypervisorClass *vhc =
485 PPC_VIRTUAL_HYPERVISOR_GET_CLASS(cpu->vhyp);
486 return vhc->map_hptes(cpu->vhyp, ptex, n);
487 }
488 base = ppc_hash64_hpt_base(cpu);
489
490 if (!base) {
491 return NULL;
492 }
493
494 hptes = address_space_map(CPU(cpu)->as, base + pte_offset, &plen, false,
495 MEMTXATTRS_UNSPECIFIED);
496 if (plen < (n * HASH_PTE_SIZE_64)) {
497 hw_error("%s: Unable to map all requested HPTEs\n", __func__);
498 }
499 return hptes;
500}
501
502void ppc_hash64_unmap_hptes(PowerPCCPU *cpu, const ppc_hash_pte64_t *hptes,
503 hwaddr ptex, int n)
504{
505 if (cpu->vhyp) {
506 PPCVirtualHypervisorClass *vhc =
507 PPC_VIRTUAL_HYPERVISOR_GET_CLASS(cpu->vhyp);
508 vhc->unmap_hptes(cpu->vhyp, hptes, ptex, n);
509 return;
510 }
511
512 address_space_unmap(CPU(cpu)->as, (void *)hptes, n * HASH_PTE_SIZE_64,
513 false, n * HASH_PTE_SIZE_64);
514}
515
516static unsigned hpte_page_shift(const PPCHash64SegmentPageSizes *sps,
517 uint64_t pte0, uint64_t pte1)
518{
519 int i;
520
521 if (!(pte0 & HPTE64_V_LARGE)) {
522 if (sps->page_shift != 12) {
523
524 return 0;
525 }
526
527 return 12;
528 }
529
530 for (i = 0; i < PPC_PAGE_SIZES_MAX_SZ; i++) {
531 const PPCHash64PageSize *ps = &sps->enc[i];
532 uint64_t mask;
533
534 if (!ps->page_shift) {
535 break;
536 }
537
538 if (ps->page_shift == 12) {
539
540 continue;
541 }
542
543 mask = ((1ULL << ps->page_shift) - 1) & HPTE64_R_RPN;
544
545 if ((pte1 & mask) == ((uint64_t)ps->pte_enc << HPTE64_R_RPN_SHIFT)) {
546 return ps->page_shift;
547 }
548 }
549
550 return 0;
551}
552
553static void ppc64_v3_new_to_old_hpte(target_ulong *pte0, target_ulong *pte1)
554{
555
556 *pte0 = (*pte0 & HPTE64_V_COMMON_BITS) |
557 ((*pte1 & HPTE64_R_3_0_SSIZE_MASK) <<
558 (HPTE64_V_SSIZE_SHIFT - HPTE64_R_3_0_SSIZE_SHIFT));
559
560
561 *pte1 = *pte1 & ~HPTE64_R_3_0_SSIZE_MASK;
562}
563
564
565static hwaddr ppc_hash64_pteg_search(PowerPCCPU *cpu, hwaddr hash,
566 const PPCHash64SegmentPageSizes *sps,
567 target_ulong ptem,
568 ppc_hash_pte64_t *pte, unsigned *pshift)
569{
570 int i;
571 const ppc_hash_pte64_t *pteg;
572 target_ulong pte0, pte1;
573 target_ulong ptex;
574
575 ptex = (hash & ppc_hash64_hpt_mask(cpu)) * HPTES_PER_GROUP;
576 pteg = ppc_hash64_map_hptes(cpu, ptex, HPTES_PER_GROUP);
577 if (!pteg) {
578 return -1;
579 }
580 for (i = 0; i < HPTES_PER_GROUP; i++) {
581 pte0 = ppc_hash64_hpte0(cpu, pteg, i);
582
583
584
585
586
587 smp_rmb();
588 pte1 = ppc_hash64_hpte1(cpu, pteg, i);
589
590
591 if (cpu->env.mmu_model == POWERPC_MMU_3_00 && !cpu->vhyp) {
592 ppc64_v3_new_to_old_hpte(&pte0, &pte1);
593 }
594
595
596 if (HPTE64_V_COMPARE(pte0, ptem)) {
597 *pshift = hpte_page_shift(sps, pte0, pte1);
598
599
600
601
602
603
604
605 if (*pshift == 0) {
606 continue;
607 }
608
609
610
611
612 pte->pte0 = pte0;
613 pte->pte1 = pte1;
614 ppc_hash64_unmap_hptes(cpu, pteg, ptex, HPTES_PER_GROUP);
615 return ptex + i;
616 }
617 }
618 ppc_hash64_unmap_hptes(cpu, pteg, ptex, HPTES_PER_GROUP);
619
620
621
622 return -1;
623}
624
625static hwaddr ppc_hash64_htab_lookup(PowerPCCPU *cpu,
626 ppc_slb_t *slb, target_ulong eaddr,
627 ppc_hash_pte64_t *pte, unsigned *pshift)
628{
629 CPUPPCState *env = &cpu->env;
630 hwaddr hash, ptex;
631 uint64_t vsid, epnmask, epn, ptem;
632 const PPCHash64SegmentPageSizes *sps = slb->sps;
633
634
635
636
637
638 assert(sps);
639
640
641 if (env->spr[SPR_LPCR] & LPCR_ISL) {
642
643 sps = &cpu->hash64_opts->sps[0];
644 assert(sps->page_shift == 12);
645 }
646
647 epnmask = ~((1ULL << sps->page_shift) - 1);
648
649 if (slb->vsid & SLB_VSID_B) {
650
651 vsid = (slb->vsid & SLB_VSID_VSID) >> SLB_VSID_SHIFT_1T;
652 epn = (eaddr & ~SEGMENT_MASK_1T) & epnmask;
653 hash = vsid ^ (vsid << 25) ^ (epn >> sps->page_shift);
654 } else {
655
656 vsid = (slb->vsid & SLB_VSID_VSID) >> SLB_VSID_SHIFT;
657 epn = (eaddr & ~SEGMENT_MASK_256M) & epnmask;
658 hash = vsid ^ (epn >> sps->page_shift);
659 }
660 ptem = (slb->vsid & SLB_VSID_PTEM) | ((epn >> 16) & HPTE64_V_AVPN);
661 ptem |= HPTE64_V_VALID;
662
663
664 qemu_log_mask(CPU_LOG_MMU,
665 "htab_base " TARGET_FMT_plx " htab_mask " TARGET_FMT_plx
666 " hash " TARGET_FMT_plx "\n",
667 ppc_hash64_hpt_base(cpu), ppc_hash64_hpt_mask(cpu), hash);
668
669
670 qemu_log_mask(CPU_LOG_MMU,
671 "0 htab=" TARGET_FMT_plx "/" TARGET_FMT_plx
672 " vsid=" TARGET_FMT_lx " ptem=" TARGET_FMT_lx
673 " hash=" TARGET_FMT_plx "\n",
674 ppc_hash64_hpt_base(cpu), ppc_hash64_hpt_mask(cpu),
675 vsid, ptem, hash);
676 ptex = ppc_hash64_pteg_search(cpu, hash, sps, ptem, pte, pshift);
677
678 if (ptex == -1) {
679
680 ptem |= HPTE64_V_SECONDARY;
681 qemu_log_mask(CPU_LOG_MMU,
682 "1 htab=" TARGET_FMT_plx "/" TARGET_FMT_plx
683 " vsid=" TARGET_FMT_lx " api=" TARGET_FMT_lx
684 " hash=" TARGET_FMT_plx "\n", ppc_hash64_hpt_base(cpu),
685 ppc_hash64_hpt_mask(cpu), vsid, ptem, ~hash);
686
687 ptex = ppc_hash64_pteg_search(cpu, ~hash, sps, ptem, pte, pshift);
688 }
689
690 return ptex;
691}
692
693unsigned ppc_hash64_hpte_page_shift_noslb(PowerPCCPU *cpu,
694 uint64_t pte0, uint64_t pte1)
695{
696 int i;
697
698 if (!(pte0 & HPTE64_V_LARGE)) {
699 return 12;
700 }
701
702
703
704
705
706 for (i = 0; i < PPC_PAGE_SIZES_MAX_SZ; i++) {
707 const PPCHash64SegmentPageSizes *sps = &cpu->hash64_opts->sps[i];
708 unsigned shift;
709
710 if (!sps->page_shift) {
711 break;
712 }
713
714 shift = hpte_page_shift(sps, pte0, pte1);
715 if (shift) {
716 return shift;
717 }
718 }
719
720 return 0;
721}
722
723static bool ppc_hash64_use_vrma(CPUPPCState *env)
724{
725 switch (env->mmu_model) {
726 case POWERPC_MMU_3_00:
727
728
729
730
731 return true;
732
733 default:
734 return !!(env->spr[SPR_LPCR] & LPCR_VPM0);
735 }
736}
737
738static void ppc_hash64_set_isi(CPUState *cs, uint64_t error_code)
739{
740 CPUPPCState *env = &POWERPC_CPU(cs)->env;
741 bool vpm;
742
743 if (msr_ir) {
744 vpm = !!(env->spr[SPR_LPCR] & LPCR_VPM1);
745 } else {
746 vpm = ppc_hash64_use_vrma(env);
747 }
748 if (vpm && !msr_hv) {
749 cs->exception_index = POWERPC_EXCP_HISI;
750 } else {
751 cs->exception_index = POWERPC_EXCP_ISI;
752 }
753 env->error_code = error_code;
754}
755
756static void ppc_hash64_set_dsi(CPUState *cs, uint64_t dar, uint64_t dsisr)
757{
758 CPUPPCState *env = &POWERPC_CPU(cs)->env;
759 bool vpm;
760
761 if (msr_dr) {
762 vpm = !!(env->spr[SPR_LPCR] & LPCR_VPM1);
763 } else {
764 vpm = ppc_hash64_use_vrma(env);
765 }
766 if (vpm && !msr_hv) {
767 cs->exception_index = POWERPC_EXCP_HDSI;
768 env->spr[SPR_HDAR] = dar;
769 env->spr[SPR_HDSISR] = dsisr;
770 } else {
771 cs->exception_index = POWERPC_EXCP_DSI;
772 env->spr[SPR_DAR] = dar;
773 env->spr[SPR_DSISR] = dsisr;
774 }
775 env->error_code = 0;
776}
777
778
779static void ppc_hash64_set_r(PowerPCCPU *cpu, hwaddr ptex, uint64_t pte1)
780{
781 hwaddr base, offset = ptex * HASH_PTE_SIZE_64 + 16;
782
783 if (cpu->vhyp) {
784 PPCVirtualHypervisorClass *vhc =
785 PPC_VIRTUAL_HYPERVISOR_GET_CLASS(cpu->vhyp);
786 vhc->hpte_set_r(cpu->vhyp, ptex, pte1);
787 return;
788 }
789 base = ppc_hash64_hpt_base(cpu);
790
791
792
793 stb_phys(CPU(cpu)->as, base + offset, ((pte1 >> 8) & 0xff) | 0x01);
794}
795
796static void ppc_hash64_set_c(PowerPCCPU *cpu, hwaddr ptex, uint64_t pte1)
797{
798 hwaddr base, offset = ptex * HASH_PTE_SIZE_64 + 15;
799
800 if (cpu->vhyp) {
801 PPCVirtualHypervisorClass *vhc =
802 PPC_VIRTUAL_HYPERVISOR_GET_CLASS(cpu->vhyp);
803 vhc->hpte_set_c(cpu->vhyp, ptex, pte1);
804 return;
805 }
806 base = ppc_hash64_hpt_base(cpu);
807
808
809 stb_phys(CPU(cpu)->as, base + offset, (pte1 & 0xff) | 0x80);
810}
811
812static target_ulong rmls_limit(PowerPCCPU *cpu)
813{
814 CPUPPCState *env = &cpu->env;
815
816
817
818
819
820
821
822
823
824 static const target_ulong rma_sizes[16] = {
825 [0] = 256 * GiB,
826 [1] = 16 * GiB,
827 [2] = 1 * GiB,
828 [3] = 64 * MiB,
829 [4] = 256 * MiB,
830 [7] = 128 * MiB,
831 [8] = 32 * MiB,
832 };
833 target_ulong rmls = (env->spr[SPR_LPCR] & LPCR_RMLS) >> LPCR_RMLS_SHIFT;
834
835 return rma_sizes[rmls];
836}
837
838static int build_vrma_slbe(PowerPCCPU *cpu, ppc_slb_t *slb)
839{
840 CPUPPCState *env = &cpu->env;
841 target_ulong lpcr = env->spr[SPR_LPCR];
842 uint32_t vrmasd = (lpcr & LPCR_VRMASD) >> LPCR_VRMASD_SHIFT;
843 target_ulong vsid = SLB_VSID_VRMA | ((vrmasd << 4) & SLB_VSID_LLP_MASK);
844 int i;
845
846 for (i = 0; i < PPC_PAGE_SIZES_MAX_SZ; i++) {
847 const PPCHash64SegmentPageSizes *sps = &cpu->hash64_opts->sps[i];
848
849 if (!sps->page_shift) {
850 break;
851 }
852
853 if ((vsid & SLB_VSID_LLP_MASK) == sps->slb_enc) {
854 slb->esid = SLB_ESID_V;
855 slb->vsid = vsid;
856 slb->sps = sps;
857 return 0;
858 }
859 }
860
861 error_report("Bad page size encoding in LPCR[VRMASD]; LPCR=0x"
862 TARGET_FMT_lx"\n", lpcr);
863
864 return -1;
865}
866
867int ppc_hash64_handle_mmu_fault(PowerPCCPU *cpu, vaddr eaddr,
868 int rwx, int mmu_idx)
869{
870 CPUState *cs = CPU(cpu);
871 CPUPPCState *env = &cpu->env;
872 ppc_slb_t vrma_slbe;
873 ppc_slb_t *slb;
874 unsigned apshift;
875 hwaddr ptex;
876 ppc_hash_pte64_t pte;
877 int exec_prot, pp_prot, amr_prot, prot;
878 const int need_prot[] = {PAGE_READ, PAGE_WRITE, PAGE_EXEC};
879 hwaddr raddr;
880
881 assert((rwx == 0) || (rwx == 1) || (rwx == 2));
882
883
884
885
886
887
888
889
890
891
892 if (((rwx == 2) && (msr_ir == 0)) || ((rwx != 2) && (msr_dr == 0))) {
893
894
895
896
897 raddr = eaddr & 0x0FFFFFFFFFFFFFFFULL;
898
899 if (cpu->vhyp) {
900
901
902
903
904 } else if (msr_hv || !env->has_hv_mode) {
905
906 if (!(eaddr >> 63)) {
907 raddr |= env->spr[SPR_HRMOR];
908 }
909 } else if (ppc_hash64_use_vrma(env)) {
910
911 slb = &vrma_slbe;
912 if (build_vrma_slbe(cpu, slb) != 0) {
913
914 cs->exception_index = POWERPC_EXCP_MCHECK;
915 env->error_code = 0;
916 return 1;
917 }
918
919 goto skip_slb_search;
920 } else {
921 target_ulong limit = rmls_limit(cpu);
922
923
924 if (raddr >= limit) {
925 if (rwx == 2) {
926 ppc_hash64_set_isi(cs, SRR1_PROTFAULT);
927 } else {
928 int dsisr = DSISR_PROTFAULT;
929 if (rwx == 1) {
930 dsisr |= DSISR_ISSTORE;
931 }
932 ppc_hash64_set_dsi(cs, eaddr, dsisr);
933 }
934 return 1;
935 }
936
937 raddr |= env->spr[SPR_RMOR];
938 }
939 tlb_set_page(cs, eaddr & TARGET_PAGE_MASK, raddr & TARGET_PAGE_MASK,
940 PAGE_READ | PAGE_WRITE | PAGE_EXEC, mmu_idx,
941 TARGET_PAGE_SIZE);
942 return 0;
943 }
944
945
946 slb = slb_lookup(cpu, eaddr);
947 if (!slb) {
948
949 if (ppc64_use_proc_tbl(cpu)) {
950
951 error_report("Segment Table Support Unimplemented");
952 exit(1);
953 }
954
955 if (rwx == 2) {
956 cs->exception_index = POWERPC_EXCP_ISEG;
957 env->error_code = 0;
958 } else {
959 cs->exception_index = POWERPC_EXCP_DSEG;
960 env->error_code = 0;
961 env->spr[SPR_DAR] = eaddr;
962 }
963 return 1;
964 }
965
966skip_slb_search:
967
968
969 if ((rwx == 2) && (slb->vsid & SLB_VSID_N)) {
970 ppc_hash64_set_isi(cs, SRR1_NOEXEC_GUARD);
971 return 1;
972 }
973
974
975 ptex = ppc_hash64_htab_lookup(cpu, slb, eaddr, &pte, &apshift);
976 if (ptex == -1) {
977 if (rwx == 2) {
978 ppc_hash64_set_isi(cs, SRR1_NOPTE);
979 } else {
980 int dsisr = DSISR_NOPTE;
981 if (rwx == 1) {
982 dsisr |= DSISR_ISSTORE;
983 }
984 ppc_hash64_set_dsi(cs, eaddr, dsisr);
985 }
986 return 1;
987 }
988 qemu_log_mask(CPU_LOG_MMU,
989 "found PTE at index %08" HWADDR_PRIx "\n", ptex);
990
991
992
993 exec_prot = ppc_hash64_pte_noexec_guard(cpu, pte);
994 pp_prot = ppc_hash64_pte_prot(cpu, slb, pte);
995 amr_prot = ppc_hash64_amr_prot(cpu, pte);
996 prot = exec_prot & pp_prot & amr_prot;
997
998 if ((need_prot[rwx] & ~prot) != 0) {
999
1000 qemu_log_mask(CPU_LOG_MMU, "PTE access rejected\n");
1001 if (rwx == 2) {
1002 int srr1 = 0;
1003 if (PAGE_EXEC & ~exec_prot) {
1004 srr1 |= SRR1_NOEXEC_GUARD;
1005 } else if (PAGE_EXEC & ~pp_prot) {
1006 srr1 |= SRR1_PROTFAULT;
1007 }
1008 if (PAGE_EXEC & ~amr_prot) {
1009 srr1 |= SRR1_IAMR;
1010 }
1011 ppc_hash64_set_isi(cs, srr1);
1012 } else {
1013 int dsisr = 0;
1014 if (need_prot[rwx] & ~pp_prot) {
1015 dsisr |= DSISR_PROTFAULT;
1016 }
1017 if (rwx == 1) {
1018 dsisr |= DSISR_ISSTORE;
1019 }
1020 if (need_prot[rwx] & ~amr_prot) {
1021 dsisr |= DSISR_AMR;
1022 }
1023 ppc_hash64_set_dsi(cs, eaddr, dsisr);
1024 }
1025 return 1;
1026 }
1027
1028 qemu_log_mask(CPU_LOG_MMU, "PTE access granted !\n");
1029
1030
1031
1032 if (!(pte.pte1 & HPTE64_R_R)) {
1033 ppc_hash64_set_r(cpu, ptex, pte.pte1);
1034 }
1035 if (!(pte.pte1 & HPTE64_R_C)) {
1036 if (rwx == 1) {
1037 ppc_hash64_set_c(cpu, ptex, pte.pte1);
1038 } else {
1039
1040
1041
1042
1043 prot &= ~PAGE_WRITE;
1044 }
1045 }
1046
1047
1048
1049 raddr = deposit64(pte.pte1 & HPTE64_R_RPN, 0, apshift, eaddr);
1050
1051 tlb_set_page(cs, eaddr & TARGET_PAGE_MASK, raddr & TARGET_PAGE_MASK,
1052 prot, mmu_idx, 1ULL << apshift);
1053
1054 return 0;
1055}
1056
1057hwaddr ppc_hash64_get_phys_page_debug(PowerPCCPU *cpu, target_ulong addr)
1058{
1059 CPUPPCState *env = &cpu->env;
1060 ppc_slb_t vrma_slbe;
1061 ppc_slb_t *slb;
1062 hwaddr ptex, raddr;
1063 ppc_hash_pte64_t pte;
1064 unsigned apshift;
1065
1066
1067 if (msr_dr == 0) {
1068
1069 raddr = addr & 0x0FFFFFFFFFFFFFFFULL;
1070
1071 if (cpu->vhyp) {
1072
1073
1074
1075
1076 return raddr;
1077 } else if ((msr_hv || !env->has_hv_mode) && !(addr >> 63)) {
1078
1079 return raddr | env->spr[SPR_HRMOR];
1080 } else if (ppc_hash64_use_vrma(env)) {
1081
1082 slb = &vrma_slbe;
1083 if (build_vrma_slbe(cpu, slb) != 0) {
1084 return -1;
1085 }
1086 } else {
1087 target_ulong limit = rmls_limit(cpu);
1088
1089
1090 if (raddr >= limit) {
1091 return -1;
1092 }
1093 return raddr | env->spr[SPR_RMOR];
1094 }
1095 } else {
1096 slb = slb_lookup(cpu, addr);
1097 if (!slb) {
1098 return -1;
1099 }
1100 }
1101
1102 ptex = ppc_hash64_htab_lookup(cpu, slb, addr, &pte, &apshift);
1103 if (ptex == -1) {
1104 return -1;
1105 }
1106
1107 return deposit64(pte.pte1 & HPTE64_R_RPN, 0, apshift, addr)
1108 & TARGET_PAGE_MASK;
1109}
1110
1111void ppc_hash64_tlb_flush_hpte(PowerPCCPU *cpu, target_ulong ptex,
1112 target_ulong pte0, target_ulong pte1)
1113{
1114
1115
1116
1117
1118
1119 cpu->env.tlb_need_flush = TLB_NEED_GLOBAL_FLUSH | TLB_NEED_LOCAL_FLUSH;
1120}
1121
1122void ppc_store_lpcr(PowerPCCPU *cpu, target_ulong val)
1123{
1124 PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
1125 CPUPPCState *env = &cpu->env;
1126
1127 env->spr[SPR_LPCR] = val & pcc->lpcr_mask;
1128}
1129
1130void helper_store_lpcr(CPUPPCState *env, target_ulong val)
1131{
1132 PowerPCCPU *cpu = env_archcpu(env);
1133
1134 ppc_store_lpcr(cpu, val);
1135}
1136
1137void ppc_hash64_init(PowerPCCPU *cpu)
1138{
1139 CPUPPCState *env = &cpu->env;
1140 PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
1141
1142 if (!pcc->hash64_opts) {
1143 assert(!(env->mmu_model & POWERPC_MMU_64));
1144 return;
1145 }
1146
1147 cpu->hash64_opts = g_memdup(pcc->hash64_opts, sizeof(*cpu->hash64_opts));
1148}
1149
1150void ppc_hash64_finalize(PowerPCCPU *cpu)
1151{
1152 g_free(cpu->hash64_opts);
1153}
1154
1155const PPCHash64Options ppc_hash64_opts_basic = {
1156 .flags = 0,
1157 .slb_size = 64,
1158 .sps = {
1159 { .page_shift = 12,
1160 .slb_enc = 0,
1161 .enc = { { .page_shift = 12, .pte_enc = 0 } }
1162 },
1163 { .page_shift = 24,
1164 .slb_enc = 0x100,
1165 .enc = { { .page_shift = 24, .pte_enc = 0 } }
1166 },
1167 },
1168};
1169
1170const PPCHash64Options ppc_hash64_opts_POWER7 = {
1171 .flags = PPC_HASH64_1TSEG | PPC_HASH64_AMR | PPC_HASH64_CI_LARGEPAGE,
1172 .slb_size = 32,
1173 .sps = {
1174 {
1175 .page_shift = 12,
1176 .slb_enc = 0,
1177 .enc = { { .page_shift = 12, .pte_enc = 0 },
1178 { .page_shift = 16, .pte_enc = 0x7 },
1179 { .page_shift = 24, .pte_enc = 0x38 }, },
1180 },
1181 {
1182 .page_shift = 16,
1183 .slb_enc = SLB_VSID_64K,
1184 .enc = { { .page_shift = 16, .pte_enc = 0x1 },
1185 { .page_shift = 24, .pte_enc = 0x8 }, },
1186 },
1187 {
1188 .page_shift = 24,
1189 .slb_enc = SLB_VSID_16M,
1190 .enc = { { .page_shift = 24, .pte_enc = 0 }, },
1191 },
1192 {
1193 .page_shift = 34,
1194 .slb_enc = SLB_VSID_16G,
1195 .enc = { { .page_shift = 34, .pte_enc = 0x3 }, },
1196 },
1197 }
1198};
1199
1200void ppc_hash64_filter_pagesizes(PowerPCCPU *cpu,
1201 bool (*cb)(void *, uint32_t, uint32_t),
1202 void *opaque)
1203{
1204 PPCHash64Options *opts = cpu->hash64_opts;
1205 int i;
1206 int n = 0;
1207 bool ci_largepage = false;
1208
1209 assert(opts);
1210
1211 n = 0;
1212 for (i = 0; i < ARRAY_SIZE(opts->sps); i++) {
1213 PPCHash64SegmentPageSizes *sps = &opts->sps[i];
1214 int j;
1215 int m = 0;
1216
1217 assert(n <= i);
1218
1219 if (!sps->page_shift) {
1220 break;
1221 }
1222
1223 for (j = 0; j < ARRAY_SIZE(sps->enc); j++) {
1224 PPCHash64PageSize *ps = &sps->enc[j];
1225
1226 assert(m <= j);
1227 if (!ps->page_shift) {
1228 break;
1229 }
1230
1231 if (cb(opaque, sps->page_shift, ps->page_shift)) {
1232 if (ps->page_shift >= 16) {
1233 ci_largepage = true;
1234 }
1235 sps->enc[m++] = *ps;
1236 }
1237 }
1238
1239
1240 for (j = m; j < ARRAY_SIZE(sps->enc); j++) {
1241 memset(&sps->enc[j], 0, sizeof(sps->enc[j]));
1242 }
1243
1244 if (m) {
1245 n++;
1246 }
1247 }
1248
1249
1250 for (i = n; i < ARRAY_SIZE(opts->sps); i++) {
1251 memset(&opts->sps[i], 0, sizeof(opts->sps[i]));
1252 }
1253
1254 if (!ci_largepage) {
1255 opts->flags &= ~PPC_HASH64_CI_LARGEPAGE;
1256 }
1257}
1258