80
void kvmppc_core_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
82
#ifdef CONFIG_PPC_BOOK3S_64
83
memcpy(to_svcpu(vcpu)->slb, to_book3s(vcpu)->slb_shadow, sizeof(to_svcpu(vcpu)->slb));
84
memcpy(&get_paca()->shadow_vcpu, to_book3s(vcpu)->shadow_vcpu,
85
sizeof(get_paca()->shadow_vcpu));
86
to_svcpu(vcpu)->slb_max = to_book3s(vcpu)->slb_shadow_max;
89
#ifdef CONFIG_PPC_BOOK3S_32
90
current->thread.kvm_shadow_vcpu = to_book3s(vcpu)->shadow_vcpu;
94
void kvmppc_core_vcpu_put(struct kvm_vcpu *vcpu)
96
#ifdef CONFIG_PPC_BOOK3S_64
97
memcpy(to_book3s(vcpu)->slb_shadow, to_svcpu(vcpu)->slb, sizeof(to_svcpu(vcpu)->slb));
98
memcpy(to_book3s(vcpu)->shadow_vcpu, &get_paca()->shadow_vcpu,
99
sizeof(get_paca()->shadow_vcpu));
100
to_book3s(vcpu)->slb_shadow_max = to_svcpu(vcpu)->slb_max;
103
kvmppc_giveup_ext(vcpu, MSR_FP);
104
kvmppc_giveup_ext(vcpu, MSR_VEC);
105
kvmppc_giveup_ext(vcpu, MSR_VSX);
108
static void kvmppc_recalc_shadow_msr(struct kvm_vcpu *vcpu)
110
ulong smsr = vcpu->arch.shared->msr;
112
/* Guest MSR values */
113
smsr &= MSR_FE0 | MSR_FE1 | MSR_SF | MSR_SE | MSR_BE | MSR_DE;
114
/* Process MSR values */
115
smsr |= MSR_ME | MSR_RI | MSR_IR | MSR_DR | MSR_PR | MSR_EE;
116
/* External providers the guest reserved */
117
smsr |= (vcpu->arch.shared->msr & vcpu->arch.guest_owned_ext);
118
/* 64-bit Process MSR values */
119
#ifdef CONFIG_PPC_BOOK3S_64
120
smsr |= MSR_ISF | MSR_HV;
122
vcpu->arch.shadow_msr = smsr;
125
void kvmppc_set_msr(struct kvm_vcpu *vcpu, u64 msr)
127
ulong old_msr = vcpu->arch.shared->msr;
130
printk(KERN_INFO "KVM: Set MSR to 0x%llx\n", msr);
133
msr &= to_book3s(vcpu)->msr_mask;
134
vcpu->arch.shared->msr = msr;
135
kvmppc_recalc_shadow_msr(vcpu);
138
if (!vcpu->arch.pending_exceptions) {
139
kvm_vcpu_block(vcpu);
140
vcpu->stat.halt_wakeup++;
142
/* Unset POW bit after we woke up */
144
vcpu->arch.shared->msr = msr;
148
if ((vcpu->arch.shared->msr & (MSR_PR|MSR_IR|MSR_DR)) !=
149
(old_msr & (MSR_PR|MSR_IR|MSR_DR))) {
150
kvmppc_mmu_flush_segments(vcpu);
151
kvmppc_mmu_map_segment(vcpu, kvmppc_get_pc(vcpu));
153
/* Preload magic page segment when in kernel mode */
154
if (!(msr & MSR_PR) && vcpu->arch.magic_page_pa) {
155
struct kvm_vcpu_arch *a = &vcpu->arch;
158
kvmppc_mmu_map_segment(vcpu, a->magic_page_ea);
160
kvmppc_mmu_map_segment(vcpu, a->magic_page_pa);
164
/* Preload FPU if it's enabled */
165
if (vcpu->arch.shared->msr & MSR_FP)
166
kvmppc_handle_ext(vcpu, BOOK3S_INTERRUPT_FP_UNAVAIL, MSR_FP);
169
72
void kvmppc_inject_interrupt(struct kvm_vcpu *vcpu, int vec, u64 flags)
171
74
vcpu->arch.shared->srr0 = kvmppc_get_pc(vcpu);
172
75
vcpu->arch.shared->srr1 = vcpu->arch.shared->msr | flags;
173
kvmppc_set_pc(vcpu, to_book3s(vcpu)->hior + vec);
76
kvmppc_set_pc(vcpu, kvmppc_interrupt_offset(vcpu) + vec);
174
77
vcpu->arch.mmu.reset_msr(vcpu);
606
401
return EMULATE_DO_MMIO;
609
static int kvmppc_visible_gfn(struct kvm_vcpu *vcpu, gfn_t gfn)
611
ulong mp_pa = vcpu->arch.magic_page_pa;
613
if (unlikely(mp_pa) &&
614
unlikely((mp_pa & KVM_PAM) >> PAGE_SHIFT == gfn)) {
618
return kvm_is_visible_gfn(vcpu->kvm, gfn);
621
int kvmppc_handle_pagefault(struct kvm_run *run, struct kvm_vcpu *vcpu,
622
ulong eaddr, int vec)
624
bool data = (vec == BOOK3S_INTERRUPT_DATA_STORAGE);
625
int r = RESUME_GUEST;
628
struct kvmppc_pte pte;
629
bool is_mmio = false;
630
bool dr = (vcpu->arch.shared->msr & MSR_DR) ? true : false;
631
bool ir = (vcpu->arch.shared->msr & MSR_IR) ? true : false;
634
relocated = data ? dr : ir;
636
/* Resolve real address if translation turned on */
638
page_found = vcpu->arch.mmu.xlate(vcpu, eaddr, &pte, data);
640
pte.may_execute = true;
642
pte.may_write = true;
643
pte.raddr = eaddr & KVM_PAM;
645
pte.vpage = eaddr >> 12;
648
switch (vcpu->arch.shared->msr & (MSR_DR|MSR_IR)) {
650
pte.vpage |= ((u64)VSID_REAL << (SID_SHIFT - 12));
654
vcpu->arch.mmu.esid_to_vsid(vcpu, eaddr >> SID_SHIFT, &vsid);
656
if ((vcpu->arch.shared->msr & (MSR_DR|MSR_IR)) == MSR_DR)
657
pte.vpage |= ((u64)VSID_REAL_DR << (SID_SHIFT - 12));
659
pte.vpage |= ((u64)VSID_REAL_IR << (SID_SHIFT - 12));
663
page_found = -EINVAL;
667
if (vcpu->arch.mmu.is_dcbz32(vcpu) &&
668
(!(vcpu->arch.hflags & BOOK3S_HFLAG_DCBZ32))) {
670
* If we do the dcbz hack, we have to NX on every execution,
671
* so we can patch the executing code. This renders our guest
674
pte.may_execute = !data;
677
if (page_found == -ENOENT) {
678
/* Page not found in guest PTE entries */
679
vcpu->arch.shared->dar = kvmppc_get_fault_dar(vcpu);
680
vcpu->arch.shared->dsisr = to_svcpu(vcpu)->fault_dsisr;
681
vcpu->arch.shared->msr |=
682
(to_svcpu(vcpu)->shadow_srr1 & 0x00000000f8000000ULL);
683
kvmppc_book3s_queue_irqprio(vcpu, vec);
684
} else if (page_found == -EPERM) {
685
/* Storage protection */
686
vcpu->arch.shared->dar = kvmppc_get_fault_dar(vcpu);
687
vcpu->arch.shared->dsisr =
688
to_svcpu(vcpu)->fault_dsisr & ~DSISR_NOHPTE;
689
vcpu->arch.shared->dsisr |= DSISR_PROTFAULT;
690
vcpu->arch.shared->msr |=
691
(to_svcpu(vcpu)->shadow_srr1 & 0x00000000f8000000ULL);
692
kvmppc_book3s_queue_irqprio(vcpu, vec);
693
} else if (page_found == -EINVAL) {
694
/* Page not found in guest SLB */
695
vcpu->arch.shared->dar = kvmppc_get_fault_dar(vcpu);
696
kvmppc_book3s_queue_irqprio(vcpu, vec + 0x80);
697
} else if (!is_mmio &&
698
kvmppc_visible_gfn(vcpu, pte.raddr >> PAGE_SHIFT)) {
699
/* The guest's PTE is not mapped yet. Map on the host */
700
kvmppc_mmu_map_page(vcpu, &pte);
702
vcpu->stat.sp_storage++;
703
else if (vcpu->arch.mmu.is_dcbz32(vcpu) &&
704
(!(vcpu->arch.hflags & BOOK3S_HFLAG_DCBZ32)))
705
kvmppc_patch_dcbz(vcpu, &pte);
708
vcpu->stat.mmio_exits++;
709
vcpu->arch.paddr_accessed = pte.raddr;
710
r = kvmppc_emulate_mmio(run, vcpu);
711
if ( r == RESUME_HOST_NV )
718
static inline int get_fpr_index(int i)
726
/* Give up external provider (FPU, Altivec, VSX) */
727
void kvmppc_giveup_ext(struct kvm_vcpu *vcpu, ulong msr)
729
struct thread_struct *t = ¤t->thread;
730
u64 *vcpu_fpr = vcpu->arch.fpr;
732
u64 *vcpu_vsx = vcpu->arch.vsr;
734
u64 *thread_fpr = (u64*)t->fpr;
737
if (!(vcpu->arch.guest_owned_ext & msr))
741
printk(KERN_INFO "Giving up ext 0x%lx\n", msr);
747
for (i = 0; i < ARRAY_SIZE(vcpu->arch.fpr); i++)
748
vcpu_fpr[i] = thread_fpr[get_fpr_index(i)];
750
vcpu->arch.fpscr = t->fpscr.val;
753
#ifdef CONFIG_ALTIVEC
754
giveup_altivec(current);
755
memcpy(vcpu->arch.vr, t->vr, sizeof(vcpu->arch.vr));
756
vcpu->arch.vscr = t->vscr;
761
__giveup_vsx(current);
762
for (i = 0; i < ARRAY_SIZE(vcpu->arch.vsr); i++)
763
vcpu_vsx[i] = thread_fpr[get_fpr_index(i) + 1];
770
vcpu->arch.guest_owned_ext &= ~msr;
771
current->thread.regs->msr &= ~msr;
772
kvmppc_recalc_shadow_msr(vcpu);
775
static int kvmppc_read_inst(struct kvm_vcpu *vcpu)
777
ulong srr0 = kvmppc_get_pc(vcpu);
778
u32 last_inst = kvmppc_get_last_inst(vcpu);
781
ret = kvmppc_ld(vcpu, &srr0, sizeof(u32), &last_inst, false);
782
if (ret == -ENOENT) {
783
ulong msr = vcpu->arch.shared->msr;
785
msr = kvmppc_set_field(msr, 33, 33, 1);
786
msr = kvmppc_set_field(msr, 34, 36, 0);
787
vcpu->arch.shared->msr = kvmppc_set_field(msr, 42, 47, 0);
788
kvmppc_book3s_queue_irqprio(vcpu, BOOK3S_INTERRUPT_INST_STORAGE);
789
return EMULATE_AGAIN;
795
static int kvmppc_check_ext(struct kvm_vcpu *vcpu, unsigned int exit_nr)
798
/* Need to do paired single emulation? */
799
if (!(vcpu->arch.hflags & BOOK3S_HFLAG_PAIRED_SINGLE))
802
/* Read out the instruction */
803
if (kvmppc_read_inst(vcpu) == EMULATE_DONE)
804
/* Need to emulate */
807
return EMULATE_AGAIN;
810
/* Handle external providers (FPU, Altivec, VSX) */
811
static int kvmppc_handle_ext(struct kvm_vcpu *vcpu, unsigned int exit_nr,
814
struct thread_struct *t = ¤t->thread;
815
u64 *vcpu_fpr = vcpu->arch.fpr;
817
u64 *vcpu_vsx = vcpu->arch.vsr;
819
u64 *thread_fpr = (u64*)t->fpr;
822
/* When we have paired singles, we emulate in software */
823
if (vcpu->arch.hflags & BOOK3S_HFLAG_PAIRED_SINGLE)
826
if (!(vcpu->arch.shared->msr & msr)) {
827
kvmppc_book3s_queue_irqprio(vcpu, exit_nr);
831
/* We already own the ext */
832
if (vcpu->arch.guest_owned_ext & msr) {
837
printk(KERN_INFO "Loading up ext 0x%lx\n", msr);
840
current->thread.regs->msr |= msr;
844
for (i = 0; i < ARRAY_SIZE(vcpu->arch.fpr); i++)
845
thread_fpr[get_fpr_index(i)] = vcpu_fpr[i];
847
t->fpscr.val = vcpu->arch.fpscr;
849
kvmppc_load_up_fpu();
852
#ifdef CONFIG_ALTIVEC
853
memcpy(t->vr, vcpu->arch.vr, sizeof(vcpu->arch.vr));
854
t->vscr = vcpu->arch.vscr;
856
kvmppc_load_up_altivec();
861
for (i = 0; i < ARRAY_SIZE(vcpu->arch.vsr); i++)
862
thread_fpr[get_fpr_index(i) + 1] = vcpu_vsx[i];
863
kvmppc_load_up_vsx();
870
vcpu->arch.guest_owned_ext |= msr;
872
kvmppc_recalc_shadow_msr(vcpu);
877
int kvmppc_handle_exit(struct kvm_run *run, struct kvm_vcpu *vcpu,
878
unsigned int exit_nr)
882
vcpu->stat.sum_exits++;
884
run->exit_reason = KVM_EXIT_UNKNOWN;
885
run->ready_for_interrupt_injection = 1;
887
trace_kvm_book3s_exit(exit_nr, vcpu);
890
case BOOK3S_INTERRUPT_INST_STORAGE:
891
vcpu->stat.pf_instruc++;
893
#ifdef CONFIG_PPC_BOOK3S_32
894
/* We set segments as unused segments when invalidating them. So
895
* treat the respective fault as segment fault. */
896
if (to_svcpu(vcpu)->sr[kvmppc_get_pc(vcpu) >> SID_SHIFT]
898
kvmppc_mmu_map_segment(vcpu, kvmppc_get_pc(vcpu));
904
/* only care about PTEG not found errors, but leave NX alone */
905
if (to_svcpu(vcpu)->shadow_srr1 & 0x40000000) {
906
r = kvmppc_handle_pagefault(run, vcpu, kvmppc_get_pc(vcpu), exit_nr);
907
vcpu->stat.sp_instruc++;
908
} else if (vcpu->arch.mmu.is_dcbz32(vcpu) &&
909
(!(vcpu->arch.hflags & BOOK3S_HFLAG_DCBZ32))) {
911
* XXX If we do the dcbz hack we use the NX bit to flush&patch the page,
912
* so we can't use the NX bit inside the guest. Let's cross our fingers,
913
* that no guest that needs the dcbz hack does NX.
915
kvmppc_mmu_pte_flush(vcpu, kvmppc_get_pc(vcpu), ~0xFFFUL);
918
vcpu->arch.shared->msr |=
919
to_svcpu(vcpu)->shadow_srr1 & 0x58000000;
920
kvmppc_book3s_queue_irqprio(vcpu, exit_nr);
924
case BOOK3S_INTERRUPT_DATA_STORAGE:
926
ulong dar = kvmppc_get_fault_dar(vcpu);
927
vcpu->stat.pf_storage++;
929
#ifdef CONFIG_PPC_BOOK3S_32
930
/* We set segments as unused segments when invalidating them. So
931
* treat the respective fault as segment fault. */
932
if ((to_svcpu(vcpu)->sr[dar >> SID_SHIFT]) == SR_INVALID) {
933
kvmppc_mmu_map_segment(vcpu, dar);
939
/* The only case we need to handle is missing shadow PTEs */
940
if (to_svcpu(vcpu)->fault_dsisr & DSISR_NOHPTE) {
941
r = kvmppc_handle_pagefault(run, vcpu, dar, exit_nr);
943
vcpu->arch.shared->dar = dar;
944
vcpu->arch.shared->dsisr = to_svcpu(vcpu)->fault_dsisr;
945
kvmppc_book3s_queue_irqprio(vcpu, exit_nr);
950
case BOOK3S_INTERRUPT_DATA_SEGMENT:
951
if (kvmppc_mmu_map_segment(vcpu, kvmppc_get_fault_dar(vcpu)) < 0) {
952
vcpu->arch.shared->dar = kvmppc_get_fault_dar(vcpu);
953
kvmppc_book3s_queue_irqprio(vcpu,
954
BOOK3S_INTERRUPT_DATA_SEGMENT);
958
case BOOK3S_INTERRUPT_INST_SEGMENT:
959
if (kvmppc_mmu_map_segment(vcpu, kvmppc_get_pc(vcpu)) < 0) {
960
kvmppc_book3s_queue_irqprio(vcpu,
961
BOOK3S_INTERRUPT_INST_SEGMENT);
965
/* We're good on these - the host merely wanted to get our attention */
966
case BOOK3S_INTERRUPT_DECREMENTER:
967
vcpu->stat.dec_exits++;
970
case BOOK3S_INTERRUPT_EXTERNAL:
971
vcpu->stat.ext_intr_exits++;
974
case BOOK3S_INTERRUPT_PERFMON:
977
case BOOK3S_INTERRUPT_PROGRAM:
979
enum emulation_result er;
983
flags = to_svcpu(vcpu)->shadow_srr1 & 0x1f0000ull;
985
if (vcpu->arch.shared->msr & MSR_PR) {
987
printk(KERN_INFO "Userspace triggered 0x700 exception at 0x%lx (0x%x)\n", kvmppc_get_pc(vcpu), kvmppc_get_last_inst(vcpu));
989
if ((kvmppc_get_last_inst(vcpu) & 0xff0007ff) !=
990
(INS_DCBZ & 0xfffffff7)) {
991
kvmppc_core_queue_program(vcpu, flags);
997
vcpu->stat.emulated_inst_exits++;
998
er = kvmppc_emulate_instruction(run, vcpu);
1001
r = RESUME_GUEST_NV;
1007
printk(KERN_CRIT "%s: emulation at %lx failed (%08x)\n",
1008
__func__, kvmppc_get_pc(vcpu), kvmppc_get_last_inst(vcpu));
1009
kvmppc_core_queue_program(vcpu, flags);
1012
case EMULATE_DO_MMIO:
1013
run->exit_reason = KVM_EXIT_MMIO;
1021
case BOOK3S_INTERRUPT_SYSCALL:
1022
if (vcpu->arch.osi_enabled &&
1023
(((u32)kvmppc_get_gpr(vcpu, 3)) == OSI_SC_MAGIC_R3) &&
1024
(((u32)kvmppc_get_gpr(vcpu, 4)) == OSI_SC_MAGIC_R4)) {
1025
/* MOL hypercalls */
1026
u64 *gprs = run->osi.gprs;
1029
run->exit_reason = KVM_EXIT_OSI;
1030
for (i = 0; i < 32; i++)
1031
gprs[i] = kvmppc_get_gpr(vcpu, i);
1032
vcpu->arch.osi_needed = 1;
1034
} else if (!(vcpu->arch.shared->msr & MSR_PR) &&
1035
(((u32)kvmppc_get_gpr(vcpu, 0)) == KVM_SC_MAGIC_R0)) {
1036
/* KVM PV hypercalls */
1037
kvmppc_set_gpr(vcpu, 3, kvmppc_kvm_pv(vcpu));
1040
/* Guest syscalls */
1041
vcpu->stat.syscall_exits++;
1042
kvmppc_book3s_queue_irqprio(vcpu, exit_nr);
1046
case BOOK3S_INTERRUPT_FP_UNAVAIL:
1047
case BOOK3S_INTERRUPT_ALTIVEC:
1048
case BOOK3S_INTERRUPT_VSX:
1053
case BOOK3S_INTERRUPT_FP_UNAVAIL: ext_msr = MSR_FP; break;
1054
case BOOK3S_INTERRUPT_ALTIVEC: ext_msr = MSR_VEC; break;
1055
case BOOK3S_INTERRUPT_VSX: ext_msr = MSR_VSX; break;
1058
switch (kvmppc_check_ext(vcpu, exit_nr)) {
1060
/* everything ok - let's enable the ext */
1061
r = kvmppc_handle_ext(vcpu, exit_nr, ext_msr);
1064
/* we need to emulate this instruction */
1065
goto program_interrupt;
1068
/* nothing to worry about - go again */
1073
case BOOK3S_INTERRUPT_ALIGNMENT:
1074
if (kvmppc_read_inst(vcpu) == EMULATE_DONE) {
1075
vcpu->arch.shared->dsisr = kvmppc_alignment_dsisr(vcpu,
1076
kvmppc_get_last_inst(vcpu));
1077
vcpu->arch.shared->dar = kvmppc_alignment_dar(vcpu,
1078
kvmppc_get_last_inst(vcpu));
1079
kvmppc_book3s_queue_irqprio(vcpu, exit_nr);
1083
case BOOK3S_INTERRUPT_MACHINE_CHECK:
1084
case BOOK3S_INTERRUPT_TRACE:
1085
kvmppc_book3s_queue_irqprio(vcpu, exit_nr);
1089
/* Ugh - bork here! What did we get? */
1090
printk(KERN_EMERG "exit_nr=0x%x | pc=0x%lx | msr=0x%lx\n",
1091
exit_nr, kvmppc_get_pc(vcpu), to_svcpu(vcpu)->shadow_srr1);
1098
if (!(r & RESUME_HOST)) {
1099
/* To avoid clobbering exit_reason, only check for signals if
1100
* we aren't already exiting to userspace for some other
1102
if (signal_pending(current)) {
1104
printk(KERN_EMERG "KVM: Going back to host\n");
1106
vcpu->stat.signal_exits++;
1107
run->exit_reason = KVM_EXIT_INTR;
1110
/* In case an interrupt came in that was triggered
1111
* from userspace (like DEC), we need to check what
1113
kvmppc_core_deliver_interrupts(vcpu);
1117
trace_kvm_book3s_reenter(r, vcpu);
1122
404
int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
1296
515
mutex_unlock(&kvm->slots_lock);
1300
int kvmppc_core_check_processor_compat(void)
1305
struct kvm_vcpu *kvmppc_core_vcpu_create(struct kvm *kvm, unsigned int id)
1307
struct kvmppc_vcpu_book3s *vcpu_book3s;
1308
struct kvm_vcpu *vcpu;
1312
vcpu_book3s = vzalloc(sizeof(struct kvmppc_vcpu_book3s));
1316
vcpu_book3s->shadow_vcpu = (struct kvmppc_book3s_shadow_vcpu *)
1317
kzalloc(sizeof(*vcpu_book3s->shadow_vcpu), GFP_KERNEL);
1318
if (!vcpu_book3s->shadow_vcpu)
1321
vcpu = &vcpu_book3s->vcpu;
1322
err = kvm_vcpu_init(vcpu, kvm, id);
1324
goto free_shadow_vcpu;
1326
p = __get_free_page(GFP_KERNEL|__GFP_ZERO);
1327
/* the real shared page fills the last 4k of our page */
1328
vcpu->arch.shared = (void*)(p + PAGE_SIZE - 4096);
1332
vcpu->arch.host_retip = kvm_return_point;
1333
vcpu->arch.host_msr = mfmsr();
1334
#ifdef CONFIG_PPC_BOOK3S_64
1335
/* default to book3s_64 (970fx) */
1336
vcpu->arch.pvr = 0x3C0301;
1338
/* default to book3s_32 (750) */
1339
vcpu->arch.pvr = 0x84202;
1341
kvmppc_set_pvr(vcpu, vcpu->arch.pvr);
1342
vcpu_book3s->slb_nr = 64;
1344
/* remember where some real-mode handlers are */
1345
vcpu->arch.trampoline_lowmem = kvmppc_trampoline_lowmem;
1346
vcpu->arch.trampoline_enter = kvmppc_trampoline_enter;
1347
vcpu->arch.highmem_handler = (ulong)kvmppc_handler_highmem;
1348
#ifdef CONFIG_PPC_BOOK3S_64
1349
vcpu->arch.rmcall = *(ulong*)kvmppc_rmcall;
1351
vcpu->arch.rmcall = (ulong)kvmppc_rmcall;
1354
vcpu->arch.shadow_msr = MSR_USER64;
1356
err = kvmppc_mmu_init(vcpu);
1363
kvm_vcpu_uninit(vcpu);
1365
kfree(vcpu_book3s->shadow_vcpu);
1369
return ERR_PTR(err);
1372
void kvmppc_core_vcpu_free(struct kvm_vcpu *vcpu)
1374
struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu);
1376
free_page((unsigned long)vcpu->arch.shared & PAGE_MASK);
1377
kvm_vcpu_uninit(vcpu);
1378
kfree(vcpu_book3s->shadow_vcpu);
1382
extern int __kvmppc_vcpu_entry(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu);
1383
int __kvmppc_vcpu_run(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
1386
double fpr[32][TS_FPRWIDTH];
1389
#ifdef CONFIG_ALTIVEC
1392
unsigned long uninitialized_var(vrsave);
1400
/* No need to go into the guest when all we do is going out */
1401
if (signal_pending(current)) {
1402
kvm_run->exit_reason = KVM_EXIT_INTR;
1406
/* Save FPU state in stack */
1407
if (current->thread.regs->msr & MSR_FP)
1408
giveup_fpu(current);
1409
memcpy(fpr, current->thread.fpr, sizeof(current->thread.fpr));
1410
fpscr = current->thread.fpscr.val;
1411
fpexc_mode = current->thread.fpexc_mode;
1413
#ifdef CONFIG_ALTIVEC
1414
/* Save Altivec state in stack */
1415
used_vr = current->thread.used_vr;
1417
if (current->thread.regs->msr & MSR_VEC)
1418
giveup_altivec(current);
1419
memcpy(vr, current->thread.vr, sizeof(current->thread.vr));
1420
vscr = current->thread.vscr;
1421
vrsave = current->thread.vrsave;
1426
/* Save VSX state in stack */
1427
used_vsr = current->thread.used_vsr;
1428
if (used_vsr && (current->thread.regs->msr & MSR_VSX))
1429
__giveup_vsx(current);
1432
/* Remember the MSR with disabled extensions */
1433
ext_msr = current->thread.regs->msr;
1435
/* XXX we get called with irq disabled - change that! */
1438
/* Preload FPU if it's enabled */
1439
if (vcpu->arch.shared->msr & MSR_FP)
1440
kvmppc_handle_ext(vcpu, BOOK3S_INTERRUPT_FP_UNAVAIL, MSR_FP);
1442
ret = __kvmppc_vcpu_entry(kvm_run, vcpu);
1444
local_irq_disable();
1446
current->thread.regs->msr = ext_msr;
1448
/* Make sure we save the guest FPU/Altivec/VSX state */
1449
kvmppc_giveup_ext(vcpu, MSR_FP);
1450
kvmppc_giveup_ext(vcpu, MSR_VEC);
1451
kvmppc_giveup_ext(vcpu, MSR_VSX);
1453
/* Restore FPU state from stack */
1454
memcpy(current->thread.fpr, fpr, sizeof(current->thread.fpr));
1455
current->thread.fpscr.val = fpscr;
1456
current->thread.fpexc_mode = fpexc_mode;
1458
#ifdef CONFIG_ALTIVEC
1459
/* Restore Altivec state from stack */
1460
if (used_vr && current->thread.used_vr) {
1461
memcpy(current->thread.vr, vr, sizeof(current->thread.vr));
1462
current->thread.vscr = vscr;
1463
current->thread.vrsave = vrsave;
1465
current->thread.used_vr = used_vr;
1469
current->thread.used_vsr = used_vsr;
1475
static int kvmppc_book3s_init(void)
1479
r = kvm_init(NULL, sizeof(struct kvmppc_vcpu_book3s), 0,
1485
r = kvmppc_mmu_hpte_sysinit();
1490
static void kvmppc_book3s_exit(void)
1492
kvmppc_mmu_hpte_sysexit();
1496
module_init(kvmppc_book3s_init);
1497
module_exit(kvmppc_book3s_exit);