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.
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.
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.
15 * Copyright IBM Corp. 2007
16 * Copyright 2010-2011 Freescale Semiconductor, Inc.
18 * Authors: Hollis Blanchard <hollisb@us.ibm.com>
19 * Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com>
20 * Scott Wood <scottwood@freescale.com>
21 * Varun Sethi <varun.sethi@freescale.com>
24 #include <linux/errno.h>
25 #include <linux/err.h>
26 #include <linux/kvm_host.h>
27 #include <linux/gfp.h>
28 #include <linux/module.h>
29 #include <linux/vmalloc.h>
32 #include <asm/cputable.h>
33 #include <asm/uaccess.h>
34 #include <asm/kvm_ppc.h>
35 #include <asm/cacheflush.h>
36 #include <asm/dbell.h>
37 #include <asm/hw_irq.h>
45 unsigned long kvmppc_booke_handlers
;
47 #define VM_STAT(x) offsetof(struct kvm, stat.x), KVM_STAT_VM
48 #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
50 struct kvm_stats_debugfs_item debugfs_entries
[] = {
51 { "mmio", VCPU_STAT(mmio_exits
) },
52 { "dcr", VCPU_STAT(dcr_exits
) },
53 { "sig", VCPU_STAT(signal_exits
) },
54 { "itlb_r", VCPU_STAT(itlb_real_miss_exits
) },
55 { "itlb_v", VCPU_STAT(itlb_virt_miss_exits
) },
56 { "dtlb_r", VCPU_STAT(dtlb_real_miss_exits
) },
57 { "dtlb_v", VCPU_STAT(dtlb_virt_miss_exits
) },
58 { "sysc", VCPU_STAT(syscall_exits
) },
59 { "isi", VCPU_STAT(isi_exits
) },
60 { "dsi", VCPU_STAT(dsi_exits
) },
61 { "inst_emu", VCPU_STAT(emulated_inst_exits
) },
62 { "dec", VCPU_STAT(dec_exits
) },
63 { "ext_intr", VCPU_STAT(ext_intr_exits
) },
64 { "halt_wakeup", VCPU_STAT(halt_wakeup
) },
65 { "doorbell", VCPU_STAT(dbell_exits
) },
66 { "guest doorbell", VCPU_STAT(gdbell_exits
) },
67 { "remote_tlb_flush", VM_STAT(remote_tlb_flush
) },
71 /* TODO: use vcpu_printf() */
72 void kvmppc_dump_vcpu(struct kvm_vcpu
*vcpu
)
76 printk("pc: %08lx msr: %08llx\n", vcpu
->arch
.pc
, vcpu
->arch
.shared
->msr
);
77 printk("lr: %08lx ctr: %08lx\n", vcpu
->arch
.lr
, vcpu
->arch
.ctr
);
78 printk("srr0: %08llx srr1: %08llx\n", vcpu
->arch
.shared
->srr0
,
79 vcpu
->arch
.shared
->srr1
);
81 printk("exceptions: %08lx\n", vcpu
->arch
.pending_exceptions
);
83 for (i
= 0; i
< 32; i
+= 4) {
84 printk("gpr%02d: %08lx %08lx %08lx %08lx\n", i
,
85 kvmppc_get_gpr(vcpu
, i
),
86 kvmppc_get_gpr(vcpu
, i
+1),
87 kvmppc_get_gpr(vcpu
, i
+2),
88 kvmppc_get_gpr(vcpu
, i
+3));
93 void kvmppc_vcpu_disable_spe(struct kvm_vcpu
*vcpu
)
97 kvmppc_save_guest_spe(vcpu
);
98 vcpu
->arch
.shadow_msr
&= ~MSR_SPE
;
102 static void kvmppc_vcpu_enable_spe(struct kvm_vcpu
*vcpu
)
106 kvmppc_load_guest_spe(vcpu
);
107 vcpu
->arch
.shadow_msr
|= MSR_SPE
;
111 static void kvmppc_vcpu_sync_spe(struct kvm_vcpu
*vcpu
)
113 if (vcpu
->arch
.shared
->msr
& MSR_SPE
) {
114 if (!(vcpu
->arch
.shadow_msr
& MSR_SPE
))
115 kvmppc_vcpu_enable_spe(vcpu
);
116 } else if (vcpu
->arch
.shadow_msr
& MSR_SPE
) {
117 kvmppc_vcpu_disable_spe(vcpu
);
121 static void kvmppc_vcpu_sync_spe(struct kvm_vcpu
*vcpu
)
126 static void kvmppc_vcpu_sync_fpu(struct kvm_vcpu
*vcpu
)
128 #if defined(CONFIG_PPC_FPU) && !defined(CONFIG_KVM_BOOKE_HV)
129 /* We always treat the FP bit as enabled from the host
130 perspective, so only need to adjust the shadow MSR */
131 vcpu
->arch
.shadow_msr
&= ~MSR_FP
;
132 vcpu
->arch
.shadow_msr
|= vcpu
->arch
.shared
->msr
& MSR_FP
;
137 * Helper function for "full" MSR writes. No need to call this if only
138 * EE/CE/ME/DE/RI are changing.
140 void kvmppc_set_msr(struct kvm_vcpu
*vcpu
, u32 new_msr
)
142 u32 old_msr
= vcpu
->arch
.shared
->msr
;
144 #ifdef CONFIG_KVM_BOOKE_HV
148 vcpu
->arch
.shared
->msr
= new_msr
;
150 kvmppc_mmu_msr_notify(vcpu
, old_msr
);
151 kvmppc_vcpu_sync_spe(vcpu
);
152 kvmppc_vcpu_sync_fpu(vcpu
);
155 static void kvmppc_booke_queue_irqprio(struct kvm_vcpu
*vcpu
,
156 unsigned int priority
)
158 trace_kvm_booke_queue_irqprio(vcpu
, priority
);
159 set_bit(priority
, &vcpu
->arch
.pending_exceptions
);
162 static void kvmppc_core_queue_dtlb_miss(struct kvm_vcpu
*vcpu
,
163 ulong dear_flags
, ulong esr_flags
)
165 vcpu
->arch
.queued_dear
= dear_flags
;
166 vcpu
->arch
.queued_esr
= esr_flags
;
167 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_DTLB_MISS
);
170 static void kvmppc_core_queue_data_storage(struct kvm_vcpu
*vcpu
,
171 ulong dear_flags
, ulong esr_flags
)
173 vcpu
->arch
.queued_dear
= dear_flags
;
174 vcpu
->arch
.queued_esr
= esr_flags
;
175 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_DATA_STORAGE
);
178 static void kvmppc_core_queue_inst_storage(struct kvm_vcpu
*vcpu
,
181 vcpu
->arch
.queued_esr
= esr_flags
;
182 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_INST_STORAGE
);
185 static void kvmppc_core_queue_alignment(struct kvm_vcpu
*vcpu
, ulong dear_flags
,
188 vcpu
->arch
.queued_dear
= dear_flags
;
189 vcpu
->arch
.queued_esr
= esr_flags
;
190 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_ALIGNMENT
);
193 void kvmppc_core_queue_program(struct kvm_vcpu
*vcpu
, ulong esr_flags
)
195 vcpu
->arch
.queued_esr
= esr_flags
;
196 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_PROGRAM
);
199 void kvmppc_core_queue_dec(struct kvm_vcpu
*vcpu
)
201 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_DECREMENTER
);
204 int kvmppc_core_pending_dec(struct kvm_vcpu
*vcpu
)
206 return test_bit(BOOKE_IRQPRIO_DECREMENTER
, &vcpu
->arch
.pending_exceptions
);
209 void kvmppc_core_dequeue_dec(struct kvm_vcpu
*vcpu
)
211 clear_bit(BOOKE_IRQPRIO_DECREMENTER
, &vcpu
->arch
.pending_exceptions
);
214 void kvmppc_core_queue_external(struct kvm_vcpu
*vcpu
,
215 struct kvm_interrupt
*irq
)
217 unsigned int prio
= BOOKE_IRQPRIO_EXTERNAL
;
219 if (irq
->irq
== KVM_INTERRUPT_SET_LEVEL
)
220 prio
= BOOKE_IRQPRIO_EXTERNAL_LEVEL
;
222 kvmppc_booke_queue_irqprio(vcpu
, prio
);
225 void kvmppc_core_dequeue_external(struct kvm_vcpu
*vcpu
)
227 clear_bit(BOOKE_IRQPRIO_EXTERNAL
, &vcpu
->arch
.pending_exceptions
);
228 clear_bit(BOOKE_IRQPRIO_EXTERNAL_LEVEL
, &vcpu
->arch
.pending_exceptions
);
231 static void kvmppc_core_queue_watchdog(struct kvm_vcpu
*vcpu
)
233 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_WATCHDOG
);
236 static void kvmppc_core_dequeue_watchdog(struct kvm_vcpu
*vcpu
)
238 clear_bit(BOOKE_IRQPRIO_WATCHDOG
, &vcpu
->arch
.pending_exceptions
);
241 static void set_guest_srr(struct kvm_vcpu
*vcpu
, unsigned long srr0
, u32 srr1
)
243 #ifdef CONFIG_KVM_BOOKE_HV
244 mtspr(SPRN_GSRR0
, srr0
);
245 mtspr(SPRN_GSRR1
, srr1
);
247 vcpu
->arch
.shared
->srr0
= srr0
;
248 vcpu
->arch
.shared
->srr1
= srr1
;
252 static void set_guest_csrr(struct kvm_vcpu
*vcpu
, unsigned long srr0
, u32 srr1
)
254 vcpu
->arch
.csrr0
= srr0
;
255 vcpu
->arch
.csrr1
= srr1
;
258 static void set_guest_dsrr(struct kvm_vcpu
*vcpu
, unsigned long srr0
, u32 srr1
)
260 if (cpu_has_feature(CPU_FTR_DEBUG_LVL_EXC
)) {
261 vcpu
->arch
.dsrr0
= srr0
;
262 vcpu
->arch
.dsrr1
= srr1
;
264 set_guest_csrr(vcpu
, srr0
, srr1
);
268 static void set_guest_mcsrr(struct kvm_vcpu
*vcpu
, unsigned long srr0
, u32 srr1
)
270 vcpu
->arch
.mcsrr0
= srr0
;
271 vcpu
->arch
.mcsrr1
= srr1
;
274 static unsigned long get_guest_dear(struct kvm_vcpu
*vcpu
)
276 #ifdef CONFIG_KVM_BOOKE_HV
277 return mfspr(SPRN_GDEAR
);
279 return vcpu
->arch
.shared
->dar
;
283 static void set_guest_dear(struct kvm_vcpu
*vcpu
, unsigned long dear
)
285 #ifdef CONFIG_KVM_BOOKE_HV
286 mtspr(SPRN_GDEAR
, dear
);
288 vcpu
->arch
.shared
->dar
= dear
;
292 static unsigned long get_guest_esr(struct kvm_vcpu
*vcpu
)
294 #ifdef CONFIG_KVM_BOOKE_HV
295 return mfspr(SPRN_GESR
);
297 return vcpu
->arch
.shared
->esr
;
301 static void set_guest_esr(struct kvm_vcpu
*vcpu
, u32 esr
)
303 #ifdef CONFIG_KVM_BOOKE_HV
304 mtspr(SPRN_GESR
, esr
);
306 vcpu
->arch
.shared
->esr
= esr
;
310 static unsigned long get_guest_epr(struct kvm_vcpu
*vcpu
)
312 #ifdef CONFIG_KVM_BOOKE_HV
313 return mfspr(SPRN_GEPR
);
315 return vcpu
->arch
.epr
;
319 /* Deliver the interrupt of the corresponding priority, if possible. */
320 static int kvmppc_booke_irqprio_deliver(struct kvm_vcpu
*vcpu
,
321 unsigned int priority
)
325 bool update_esr
= false, update_dear
= false, update_epr
= false;
326 ulong crit_raw
= vcpu
->arch
.shared
->critical
;
327 ulong crit_r1
= kvmppc_get_gpr(vcpu
, 1);
329 bool keep_irq
= false;
330 enum int_class int_class
;
331 ulong new_msr
= vcpu
->arch
.shared
->msr
;
333 /* Truncate crit indicators in 32 bit mode */
334 if (!(vcpu
->arch
.shared
->msr
& MSR_SF
)) {
335 crit_raw
&= 0xffffffff;
336 crit_r1
&= 0xffffffff;
339 /* Critical section when crit == r1 */
340 crit
= (crit_raw
== crit_r1
);
341 /* ... and we're in supervisor mode */
342 crit
= crit
&& !(vcpu
->arch
.shared
->msr
& MSR_PR
);
344 if (priority
== BOOKE_IRQPRIO_EXTERNAL_LEVEL
) {
345 priority
= BOOKE_IRQPRIO_EXTERNAL
;
349 if ((priority
== BOOKE_IRQPRIO_EXTERNAL
) && vcpu
->arch
.epr_flags
)
353 case BOOKE_IRQPRIO_DTLB_MISS
:
354 case BOOKE_IRQPRIO_DATA_STORAGE
:
355 case BOOKE_IRQPRIO_ALIGNMENT
:
358 case BOOKE_IRQPRIO_INST_STORAGE
:
359 case BOOKE_IRQPRIO_PROGRAM
:
362 case BOOKE_IRQPRIO_ITLB_MISS
:
363 case BOOKE_IRQPRIO_SYSCALL
:
364 case BOOKE_IRQPRIO_FP_UNAVAIL
:
365 case BOOKE_IRQPRIO_SPE_UNAVAIL
:
366 case BOOKE_IRQPRIO_SPE_FP_DATA
:
367 case BOOKE_IRQPRIO_SPE_FP_ROUND
:
368 case BOOKE_IRQPRIO_AP_UNAVAIL
:
370 msr_mask
= MSR_CE
| MSR_ME
| MSR_DE
;
371 int_class
= INT_CLASS_NONCRIT
;
373 case BOOKE_IRQPRIO_WATCHDOG
:
374 case BOOKE_IRQPRIO_CRITICAL
:
375 case BOOKE_IRQPRIO_DBELL_CRIT
:
376 allowed
= vcpu
->arch
.shared
->msr
& MSR_CE
;
377 allowed
= allowed
&& !crit
;
379 int_class
= INT_CLASS_CRIT
;
381 case BOOKE_IRQPRIO_MACHINE_CHECK
:
382 allowed
= vcpu
->arch
.shared
->msr
& MSR_ME
;
383 allowed
= allowed
&& !crit
;
384 int_class
= INT_CLASS_MC
;
386 case BOOKE_IRQPRIO_DECREMENTER
:
387 case BOOKE_IRQPRIO_FIT
:
390 case BOOKE_IRQPRIO_EXTERNAL
:
391 case BOOKE_IRQPRIO_DBELL
:
392 allowed
= vcpu
->arch
.shared
->msr
& MSR_EE
;
393 allowed
= allowed
&& !crit
;
394 msr_mask
= MSR_CE
| MSR_ME
| MSR_DE
;
395 int_class
= INT_CLASS_NONCRIT
;
397 case BOOKE_IRQPRIO_DEBUG
:
398 allowed
= vcpu
->arch
.shared
->msr
& MSR_DE
;
399 allowed
= allowed
&& !crit
;
401 int_class
= INT_CLASS_CRIT
;
407 case INT_CLASS_NONCRIT
:
408 set_guest_srr(vcpu
, vcpu
->arch
.pc
,
409 vcpu
->arch
.shared
->msr
);
412 set_guest_csrr(vcpu
, vcpu
->arch
.pc
,
413 vcpu
->arch
.shared
->msr
);
416 set_guest_dsrr(vcpu
, vcpu
->arch
.pc
,
417 vcpu
->arch
.shared
->msr
);
420 set_guest_mcsrr(vcpu
, vcpu
->arch
.pc
,
421 vcpu
->arch
.shared
->msr
);
425 vcpu
->arch
.pc
= vcpu
->arch
.ivpr
| vcpu
->arch
.ivor
[priority
];
426 if (update_esr
== true)
427 set_guest_esr(vcpu
, vcpu
->arch
.queued_esr
);
428 if (update_dear
== true)
429 set_guest_dear(vcpu
, vcpu
->arch
.queued_dear
);
430 if (update_epr
== true) {
431 if (vcpu
->arch
.epr_flags
& KVMPPC_EPR_USER
)
432 kvm_make_request(KVM_REQ_EPR_EXIT
, vcpu
);
433 else if (vcpu
->arch
.epr_flags
& KVMPPC_EPR_KERNEL
) {
434 BUG_ON(vcpu
->arch
.irq_type
!= KVMPPC_IRQ_MPIC
);
435 kvmppc_mpic_set_epr(vcpu
);
440 #if defined(CONFIG_64BIT)
441 if (vcpu
->arch
.epcr
& SPRN_EPCR_ICM
)
444 kvmppc_set_msr(vcpu
, new_msr
);
447 clear_bit(priority
, &vcpu
->arch
.pending_exceptions
);
450 #ifdef CONFIG_KVM_BOOKE_HV
452 * If an interrupt is pending but masked, raise a guest doorbell
453 * so that we are notified when the guest enables the relevant
456 if (vcpu
->arch
.pending_exceptions
& BOOKE_IRQMASK_EE
)
457 kvmppc_set_pending_interrupt(vcpu
, INT_CLASS_NONCRIT
);
458 if (vcpu
->arch
.pending_exceptions
& BOOKE_IRQMASK_CE
)
459 kvmppc_set_pending_interrupt(vcpu
, INT_CLASS_CRIT
);
460 if (vcpu
->arch
.pending_exceptions
& BOOKE_IRQPRIO_MACHINE_CHECK
)
461 kvmppc_set_pending_interrupt(vcpu
, INT_CLASS_MC
);
468 * Return the number of jiffies until the next timeout. If the timeout is
469 * longer than the NEXT_TIMER_MAX_DELTA, then return NEXT_TIMER_MAX_DELTA
470 * because the larger value can break the timer APIs.
472 static unsigned long watchdog_next_timeout(struct kvm_vcpu
*vcpu
)
474 u64 tb
, wdt_tb
, wdt_ticks
= 0;
476 u32 period
= TCR_GET_WP(vcpu
->arch
.tcr
);
478 wdt_tb
= 1ULL << (63 - period
);
481 * The watchdog timeout will hapeen when TB bit corresponding
482 * to watchdog will toggle from 0 to 1.
487 wdt_ticks
+= wdt_tb
- (tb
& (wdt_tb
- 1));
489 /* Convert timebase ticks to jiffies */
490 nr_jiffies
= wdt_ticks
;
492 if (do_div(nr_jiffies
, tb_ticks_per_jiffy
))
495 return min_t(unsigned long long, nr_jiffies
, NEXT_TIMER_MAX_DELTA
);
498 static void arm_next_watchdog(struct kvm_vcpu
*vcpu
)
500 unsigned long nr_jiffies
;
504 * If TSR_ENW and TSR_WIS are not set then no need to exit to
505 * userspace, so clear the KVM_REQ_WATCHDOG request.
507 if ((vcpu
->arch
.tsr
& (TSR_ENW
| TSR_WIS
)) != (TSR_ENW
| TSR_WIS
))
508 clear_bit(KVM_REQ_WATCHDOG
, &vcpu
->requests
);
510 spin_lock_irqsave(&vcpu
->arch
.wdt_lock
, flags
);
511 nr_jiffies
= watchdog_next_timeout(vcpu
);
513 * If the number of jiffies of watchdog timer >= NEXT_TIMER_MAX_DELTA
514 * then do not run the watchdog timer as this can break timer APIs.
516 if (nr_jiffies
< NEXT_TIMER_MAX_DELTA
)
517 mod_timer(&vcpu
->arch
.wdt_timer
, jiffies
+ nr_jiffies
);
519 del_timer(&vcpu
->arch
.wdt_timer
);
520 spin_unlock_irqrestore(&vcpu
->arch
.wdt_lock
, flags
);
523 void kvmppc_watchdog_func(unsigned long data
)
525 struct kvm_vcpu
*vcpu
= (struct kvm_vcpu
*)data
;
530 new_tsr
= tsr
= vcpu
->arch
.tsr
;
538 new_tsr
= tsr
| TSR_WIS
;
540 new_tsr
= tsr
| TSR_ENW
;
542 } while (cmpxchg(&vcpu
->arch
.tsr
, tsr
, new_tsr
) != tsr
);
544 if (new_tsr
& TSR_WIS
) {
546 kvm_make_request(KVM_REQ_PENDING_TIMER
, vcpu
);
551 * If this is final watchdog expiry and some action is required
552 * then exit to userspace.
554 if (final
&& (vcpu
->arch
.tcr
& TCR_WRC_MASK
) &&
555 vcpu
->arch
.watchdog_enabled
) {
557 kvm_make_request(KVM_REQ_WATCHDOG
, vcpu
);
562 * Stop running the watchdog timer after final expiration to
563 * prevent the host from being flooded with timers if the
564 * guest sets a short period.
565 * Timers will resume when TSR/TCR is updated next time.
568 arm_next_watchdog(vcpu
);
571 static void update_timer_ints(struct kvm_vcpu
*vcpu
)
573 if ((vcpu
->arch
.tcr
& TCR_DIE
) && (vcpu
->arch
.tsr
& TSR_DIS
))
574 kvmppc_core_queue_dec(vcpu
);
576 kvmppc_core_dequeue_dec(vcpu
);
578 if ((vcpu
->arch
.tcr
& TCR_WIE
) && (vcpu
->arch
.tsr
& TSR_WIS
))
579 kvmppc_core_queue_watchdog(vcpu
);
581 kvmppc_core_dequeue_watchdog(vcpu
);
584 static void kvmppc_core_check_exceptions(struct kvm_vcpu
*vcpu
)
586 unsigned long *pending
= &vcpu
->arch
.pending_exceptions
;
587 unsigned int priority
;
589 priority
= __ffs(*pending
);
590 while (priority
< BOOKE_IRQPRIO_MAX
) {
591 if (kvmppc_booke_irqprio_deliver(vcpu
, priority
))
594 priority
= find_next_bit(pending
,
595 BITS_PER_BYTE
* sizeof(*pending
),
599 /* Tell the guest about our interrupt status */
600 vcpu
->arch
.shared
->int_pending
= !!*pending
;
603 /* Check pending exceptions and deliver one, if possible. */
604 int kvmppc_core_prepare_to_enter(struct kvm_vcpu
*vcpu
)
607 WARN_ON_ONCE(!irqs_disabled());
609 kvmppc_core_check_exceptions(vcpu
);
611 if (vcpu
->requests
) {
612 /* Exception delivery raised request; start over */
616 if (vcpu
->arch
.shared
->msr
& MSR_WE
) {
618 kvm_vcpu_block(vcpu
);
619 clear_bit(KVM_REQ_UNHALT
, &vcpu
->requests
);
622 kvmppc_set_exit_type(vcpu
, EMULATED_MTMSRWE_EXITS
);
629 int kvmppc_core_check_requests(struct kvm_vcpu
*vcpu
)
631 int r
= 1; /* Indicate we want to get back into the guest */
633 if (kvm_check_request(KVM_REQ_PENDING_TIMER
, vcpu
))
634 update_timer_ints(vcpu
);
635 #if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC)
636 if (kvm_check_request(KVM_REQ_TLB_FLUSH
, vcpu
))
637 kvmppc_core_flush_tlb(vcpu
);
640 if (kvm_check_request(KVM_REQ_WATCHDOG
, vcpu
)) {
641 vcpu
->run
->exit_reason
= KVM_EXIT_WATCHDOG
;
645 if (kvm_check_request(KVM_REQ_EPR_EXIT
, vcpu
)) {
646 vcpu
->run
->epr
.epr
= 0;
647 vcpu
->arch
.epr_needed
= true;
648 vcpu
->run
->exit_reason
= KVM_EXIT_EPR
;
655 int kvmppc_vcpu_run(struct kvm_run
*kvm_run
, struct kvm_vcpu
*vcpu
)
658 #ifdef CONFIG_PPC_FPU
664 if (!vcpu
->arch
.sane
) {
665 kvm_run
->exit_reason
= KVM_EXIT_INTERNAL_ERROR
;
670 s
= kvmppc_prepare_to_enter(vcpu
);
679 #ifdef CONFIG_PPC_FPU
680 /* Save userspace FPU state in stack */
682 memcpy(fpr
, current
->thread
.fpr
, sizeof(current
->thread
.fpr
));
683 fpscr
= current
->thread
.fpscr
.val
;
684 fpexc_mode
= current
->thread
.fpexc_mode
;
686 /* Restore guest FPU state to thread */
687 memcpy(current
->thread
.fpr
, vcpu
->arch
.fpr
, sizeof(vcpu
->arch
.fpr
));
688 current
->thread
.fpscr
.val
= vcpu
->arch
.fpscr
;
691 * Since we can't trap on MSR_FP in GS-mode, we consider the guest
692 * as always using the FPU. Kernel usage of FP (via
693 * enable_kernel_fp()) in this thread must not occur while
694 * vcpu->fpu_active is set.
696 vcpu
->fpu_active
= 1;
698 kvmppc_load_guest_fp(vcpu
);
701 kvmppc_lazy_ee_enable();
703 ret
= __kvmppc_vcpu_run(kvm_run
, vcpu
);
705 /* No need for kvm_guest_exit. It's done in handle_exit.
706 We also get here with interrupts enabled. */
708 #ifdef CONFIG_PPC_FPU
709 kvmppc_save_guest_fp(vcpu
);
711 vcpu
->fpu_active
= 0;
713 /* Save guest FPU state from thread */
714 memcpy(vcpu
->arch
.fpr
, current
->thread
.fpr
, sizeof(vcpu
->arch
.fpr
));
715 vcpu
->arch
.fpscr
= current
->thread
.fpscr
.val
;
717 /* Restore userspace FPU state from stack */
718 memcpy(current
->thread
.fpr
, fpr
, sizeof(current
->thread
.fpr
));
719 current
->thread
.fpscr
.val
= fpscr
;
720 current
->thread
.fpexc_mode
= fpexc_mode
;
724 vcpu
->mode
= OUTSIDE_GUEST_MODE
;
728 static int emulation_exit(struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
730 enum emulation_result er
;
732 er
= kvmppc_emulate_instruction(run
, vcpu
);
735 /* don't overwrite subtypes, just account kvm_stats */
736 kvmppc_account_exit_stat(vcpu
, EMULATED_INST_EXITS
);
737 /* Future optimization: only reload non-volatiles if
738 * they were actually modified by emulation. */
739 return RESUME_GUEST_NV
;
742 run
->exit_reason
= KVM_EXIT_DCR
;
746 printk(KERN_CRIT
"%s: emulation at %lx failed (%08x)\n",
747 __func__
, vcpu
->arch
.pc
, vcpu
->arch
.last_inst
);
748 /* For debugging, encode the failing instruction and
749 * report it to userspace. */
750 run
->hw
.hardware_exit_reason
= ~0ULL << 32;
751 run
->hw
.hardware_exit_reason
|= vcpu
->arch
.last_inst
;
752 kvmppc_core_queue_program(vcpu
, ESR_PIL
);
755 case EMULATE_EXIT_USER
:
763 static void kvmppc_fill_pt_regs(struct pt_regs
*regs
)
765 ulong r1
, ip
, msr
, lr
;
767 asm("mr %0, 1" : "=r"(r1
));
768 asm("mflr %0" : "=r"(lr
));
769 asm("mfmsr %0" : "=r"(msr
));
770 asm("bl 1f; 1: mflr %0" : "=r"(ip
));
772 memset(regs
, 0, sizeof(*regs
));
780 * For interrupts needed to be handled by host interrupt handlers,
781 * corresponding host handler are called from here in similar way
782 * (but not exact) as they are called from low level handler
783 * (such as from arch/powerpc/kernel/head_fsl_booke.S).
785 static void kvmppc_restart_interrupt(struct kvm_vcpu
*vcpu
,
786 unsigned int exit_nr
)
791 case BOOKE_INTERRUPT_EXTERNAL
:
792 kvmppc_fill_pt_regs(®s
);
795 case BOOKE_INTERRUPT_DECREMENTER
:
796 kvmppc_fill_pt_regs(®s
);
797 timer_interrupt(®s
);
799 #if defined(CONFIG_PPC_FSL_BOOK3E) || defined(CONFIG_PPC_BOOK3E_64)
800 case BOOKE_INTERRUPT_DOORBELL
:
801 kvmppc_fill_pt_regs(®s
);
802 doorbell_exception(®s
);
805 case BOOKE_INTERRUPT_MACHINE_CHECK
:
808 case BOOKE_INTERRUPT_PERFORMANCE_MONITOR
:
809 kvmppc_fill_pt_regs(®s
);
810 performance_monitor_exception(®s
);
812 case BOOKE_INTERRUPT_WATCHDOG
:
813 kvmppc_fill_pt_regs(®s
);
814 #ifdef CONFIG_BOOKE_WDT
815 WatchdogException(®s
);
817 unknown_exception(®s
);
820 case BOOKE_INTERRUPT_CRITICAL
:
821 unknown_exception(®s
);
829 * Return value is in the form (errcode<<2 | RESUME_FLAG_HOST | RESUME_FLAG_NV)
831 int kvmppc_handle_exit(struct kvm_run
*run
, struct kvm_vcpu
*vcpu
,
832 unsigned int exit_nr
)
839 WARN_ON(local_paca
->irq_happened
!= 0);
843 * We enter with interrupts disabled in hardware, but
844 * we need to call hard_irq_disable anyway to ensure that
845 * the software state is kept in sync.
849 /* update before a new last_exit_type is rewritten */
850 kvmppc_update_timing_stats(vcpu
);
852 /* restart interrupts if they were meant for the host */
853 kvmppc_restart_interrupt(vcpu
, exit_nr
);
857 trace_kvm_exit(exit_nr
, vcpu
);
860 run
->exit_reason
= KVM_EXIT_UNKNOWN
;
861 run
->ready_for_interrupt_injection
= 1;
864 case BOOKE_INTERRUPT_MACHINE_CHECK
:
865 printk("MACHINE CHECK: %lx\n", mfspr(SPRN_MCSR
));
866 kvmppc_dump_vcpu(vcpu
);
867 /* For debugging, send invalid exit reason to user space */
868 run
->hw
.hardware_exit_reason
= ~1ULL << 32;
869 run
->hw
.hardware_exit_reason
|= mfspr(SPRN_MCSR
);
873 case BOOKE_INTERRUPT_EXTERNAL
:
874 kvmppc_account_exit(vcpu
, EXT_INTR_EXITS
);
878 case BOOKE_INTERRUPT_DECREMENTER
:
879 kvmppc_account_exit(vcpu
, DEC_EXITS
);
883 case BOOKE_INTERRUPT_WATCHDOG
:
887 case BOOKE_INTERRUPT_DOORBELL
:
888 kvmppc_account_exit(vcpu
, DBELL_EXITS
);
892 case BOOKE_INTERRUPT_GUEST_DBELL_CRIT
:
893 kvmppc_account_exit(vcpu
, GDBELL_EXITS
);
896 * We are here because there is a pending guest interrupt
897 * which could not be delivered as MSR_CE or MSR_ME was not
898 * set. Once we break from here we will retry delivery.
903 case BOOKE_INTERRUPT_GUEST_DBELL
:
904 kvmppc_account_exit(vcpu
, GDBELL_EXITS
);
907 * We are here because there is a pending guest interrupt
908 * which could not be delivered as MSR_EE was not set. Once
909 * we break from here we will retry delivery.
914 case BOOKE_INTERRUPT_PERFORMANCE_MONITOR
:
918 case BOOKE_INTERRUPT_HV_PRIV
:
919 r
= emulation_exit(run
, vcpu
);
922 case BOOKE_INTERRUPT_PROGRAM
:
923 if (vcpu
->arch
.shared
->msr
& (MSR_PR
| MSR_GS
)) {
925 * Program traps generated by user-level software must
926 * be handled by the guest kernel.
928 * In GS mode, hypervisor privileged instructions trap
929 * on BOOKE_INTERRUPT_HV_PRIV, not here, so these are
930 * actual program interrupts, handled by the guest.
932 kvmppc_core_queue_program(vcpu
, vcpu
->arch
.fault_esr
);
934 kvmppc_account_exit(vcpu
, USR_PR_INST
);
938 r
= emulation_exit(run
, vcpu
);
941 case BOOKE_INTERRUPT_FP_UNAVAIL
:
942 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_FP_UNAVAIL
);
943 kvmppc_account_exit(vcpu
, FP_UNAVAIL
);
948 case BOOKE_INTERRUPT_SPE_UNAVAIL
: {
949 if (vcpu
->arch
.shared
->msr
& MSR_SPE
)
950 kvmppc_vcpu_enable_spe(vcpu
);
952 kvmppc_booke_queue_irqprio(vcpu
,
953 BOOKE_IRQPRIO_SPE_UNAVAIL
);
958 case BOOKE_INTERRUPT_SPE_FP_DATA
:
959 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_SPE_FP_DATA
);
963 case BOOKE_INTERRUPT_SPE_FP_ROUND
:
964 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_SPE_FP_ROUND
);
968 case BOOKE_INTERRUPT_SPE_UNAVAIL
:
970 * Guest wants SPE, but host kernel doesn't support it. Send
971 * an "unimplemented operation" program check to the guest.
973 kvmppc_core_queue_program(vcpu
, ESR_PUO
| ESR_SPV
);
978 * These really should never happen without CONFIG_SPE,
979 * as we should never enable the real MSR[SPE] in the guest.
981 case BOOKE_INTERRUPT_SPE_FP_DATA
:
982 case BOOKE_INTERRUPT_SPE_FP_ROUND
:
983 printk(KERN_CRIT
"%s: unexpected SPE interrupt %u at %08lx\n",
984 __func__
, exit_nr
, vcpu
->arch
.pc
);
985 run
->hw
.hardware_exit_reason
= exit_nr
;
990 case BOOKE_INTERRUPT_DATA_STORAGE
:
991 kvmppc_core_queue_data_storage(vcpu
, vcpu
->arch
.fault_dear
,
992 vcpu
->arch
.fault_esr
);
993 kvmppc_account_exit(vcpu
, DSI_EXITS
);
997 case BOOKE_INTERRUPT_INST_STORAGE
:
998 kvmppc_core_queue_inst_storage(vcpu
, vcpu
->arch
.fault_esr
);
999 kvmppc_account_exit(vcpu
, ISI_EXITS
);
1003 case BOOKE_INTERRUPT_ALIGNMENT
:
1004 kvmppc_core_queue_alignment(vcpu
, vcpu
->arch
.fault_dear
,
1005 vcpu
->arch
.fault_esr
);
1009 #ifdef CONFIG_KVM_BOOKE_HV
1010 case BOOKE_INTERRUPT_HV_SYSCALL
:
1011 if (!(vcpu
->arch
.shared
->msr
& MSR_PR
)) {
1012 kvmppc_set_gpr(vcpu
, 3, kvmppc_kvm_pv(vcpu
));
1015 * hcall from guest userspace -- send privileged
1016 * instruction program check.
1018 kvmppc_core_queue_program(vcpu
, ESR_PPR
);
1024 case BOOKE_INTERRUPT_SYSCALL
:
1025 if (!(vcpu
->arch
.shared
->msr
& MSR_PR
) &&
1026 (((u32
)kvmppc_get_gpr(vcpu
, 0)) == KVM_SC_MAGIC_R0
)) {
1027 /* KVM PV hypercalls */
1028 kvmppc_set_gpr(vcpu
, 3, kvmppc_kvm_pv(vcpu
));
1031 /* Guest syscalls */
1032 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_SYSCALL
);
1034 kvmppc_account_exit(vcpu
, SYSCALL_EXITS
);
1039 case BOOKE_INTERRUPT_DTLB_MISS
: {
1040 unsigned long eaddr
= vcpu
->arch
.fault_dear
;
1045 #ifdef CONFIG_KVM_E500V2
1046 if (!(vcpu
->arch
.shared
->msr
& MSR_PR
) &&
1047 (eaddr
& PAGE_MASK
) == vcpu
->arch
.magic_page_ea
) {
1048 kvmppc_map_magic(vcpu
);
1049 kvmppc_account_exit(vcpu
, DTLB_VIRT_MISS_EXITS
);
1056 /* Check the guest TLB. */
1057 gtlb_index
= kvmppc_mmu_dtlb_index(vcpu
, eaddr
);
1058 if (gtlb_index
< 0) {
1059 /* The guest didn't have a mapping for it. */
1060 kvmppc_core_queue_dtlb_miss(vcpu
,
1061 vcpu
->arch
.fault_dear
,
1062 vcpu
->arch
.fault_esr
);
1063 kvmppc_mmu_dtlb_miss(vcpu
);
1064 kvmppc_account_exit(vcpu
, DTLB_REAL_MISS_EXITS
);
1069 idx
= srcu_read_lock(&vcpu
->kvm
->srcu
);
1071 gpaddr
= kvmppc_mmu_xlate(vcpu
, gtlb_index
, eaddr
);
1072 gfn
= gpaddr
>> PAGE_SHIFT
;
1074 if (kvm_is_visible_gfn(vcpu
->kvm
, gfn
)) {
1075 /* The guest TLB had a mapping, but the shadow TLB
1076 * didn't, and it is RAM. This could be because:
1077 * a) the entry is mapping the host kernel, or
1078 * b) the guest used a large mapping which we're faking
1079 * Either way, we need to satisfy the fault without
1080 * invoking the guest. */
1081 kvmppc_mmu_map(vcpu
, eaddr
, gpaddr
, gtlb_index
);
1082 kvmppc_account_exit(vcpu
, DTLB_VIRT_MISS_EXITS
);
1085 /* Guest has mapped and accessed a page which is not
1087 vcpu
->arch
.paddr_accessed
= gpaddr
;
1088 vcpu
->arch
.vaddr_accessed
= eaddr
;
1089 r
= kvmppc_emulate_mmio(run
, vcpu
);
1090 kvmppc_account_exit(vcpu
, MMIO_EXITS
);
1093 srcu_read_unlock(&vcpu
->kvm
->srcu
, idx
);
1097 case BOOKE_INTERRUPT_ITLB_MISS
: {
1098 unsigned long eaddr
= vcpu
->arch
.pc
;
1105 /* Check the guest TLB. */
1106 gtlb_index
= kvmppc_mmu_itlb_index(vcpu
, eaddr
);
1107 if (gtlb_index
< 0) {
1108 /* The guest didn't have a mapping for it. */
1109 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_ITLB_MISS
);
1110 kvmppc_mmu_itlb_miss(vcpu
);
1111 kvmppc_account_exit(vcpu
, ITLB_REAL_MISS_EXITS
);
1115 kvmppc_account_exit(vcpu
, ITLB_VIRT_MISS_EXITS
);
1117 idx
= srcu_read_lock(&vcpu
->kvm
->srcu
);
1119 gpaddr
= kvmppc_mmu_xlate(vcpu
, gtlb_index
, eaddr
);
1120 gfn
= gpaddr
>> PAGE_SHIFT
;
1122 if (kvm_is_visible_gfn(vcpu
->kvm
, gfn
)) {
1123 /* The guest TLB had a mapping, but the shadow TLB
1124 * didn't. This could be because:
1125 * a) the entry is mapping the host kernel, or
1126 * b) the guest used a large mapping which we're faking
1127 * Either way, we need to satisfy the fault without
1128 * invoking the guest. */
1129 kvmppc_mmu_map(vcpu
, eaddr
, gpaddr
, gtlb_index
);
1131 /* Guest mapped and leaped at non-RAM! */
1132 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_MACHINE_CHECK
);
1135 srcu_read_unlock(&vcpu
->kvm
->srcu
, idx
);
1139 case BOOKE_INTERRUPT_DEBUG
: {
1142 vcpu
->arch
.pc
= mfspr(SPRN_CSRR0
);
1144 /* clear IAC events in DBSR register */
1145 dbsr
= mfspr(SPRN_DBSR
);
1146 dbsr
&= DBSR_IAC1
| DBSR_IAC2
| DBSR_IAC3
| DBSR_IAC4
;
1147 mtspr(SPRN_DBSR
, dbsr
);
1149 run
->exit_reason
= KVM_EXIT_DEBUG
;
1150 kvmppc_account_exit(vcpu
, DEBUG_EXITS
);
1156 printk(KERN_EMERG
"exit_nr %d\n", exit_nr
);
1161 * To avoid clobbering exit_reason, only check for signals if we
1162 * aren't already exiting to userspace for some other reason.
1164 if (!(r
& RESUME_HOST
)) {
1165 local_irq_disable();
1166 s
= kvmppc_prepare_to_enter(vcpu
);
1169 r
= (s
<< 2) | RESUME_HOST
| (r
& RESUME_FLAG_NV
);
1171 kvmppc_lazy_ee_enable();
1178 static void kvmppc_set_tsr(struct kvm_vcpu
*vcpu
, u32 new_tsr
)
1180 u32 old_tsr
= vcpu
->arch
.tsr
;
1182 vcpu
->arch
.tsr
= new_tsr
;
1184 if ((old_tsr
^ vcpu
->arch
.tsr
) & (TSR_ENW
| TSR_WIS
))
1185 arm_next_watchdog(vcpu
);
1187 update_timer_ints(vcpu
);
1190 /* Initial guest state: 16MB mapping 0 -> 0, PC = 0, MSR = 0, R1 = 16MB */
1191 int kvm_arch_vcpu_setup(struct kvm_vcpu
*vcpu
)
1197 vcpu
->arch
.shared
->pir
= vcpu
->vcpu_id
;
1198 kvmppc_set_gpr(vcpu
, 1, (16<<20) - 8); /* -8 for the callee-save LR slot */
1199 kvmppc_set_msr(vcpu
, 0);
1201 #ifndef CONFIG_KVM_BOOKE_HV
1202 vcpu
->arch
.shadow_msr
= MSR_USER
| MSR_DE
| MSR_IS
| MSR_DS
;
1203 vcpu
->arch
.shadow_pid
= 1;
1204 vcpu
->arch
.shared
->msr
= 0;
1207 /* Eye-catching numbers so we know if the guest takes an interrupt
1208 * before it's programmed its own IVPR/IVORs. */
1209 vcpu
->arch
.ivpr
= 0x55550000;
1210 for (i
= 0; i
< BOOKE_IRQPRIO_MAX
; i
++)
1211 vcpu
->arch
.ivor
[i
] = 0x7700 | i
* 4;
1213 kvmppc_init_timing_stats(vcpu
);
1215 r
= kvmppc_core_vcpu_setup(vcpu
);
1216 kvmppc_sanity_check(vcpu
);
1220 int kvmppc_subarch_vcpu_init(struct kvm_vcpu
*vcpu
)
1222 /* setup watchdog timer once */
1223 spin_lock_init(&vcpu
->arch
.wdt_lock
);
1224 setup_timer(&vcpu
->arch
.wdt_timer
, kvmppc_watchdog_func
,
1225 (unsigned long)vcpu
);
1230 void kvmppc_subarch_vcpu_uninit(struct kvm_vcpu
*vcpu
)
1232 del_timer_sync(&vcpu
->arch
.wdt_timer
);
1235 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu
*vcpu
, struct kvm_regs
*regs
)
1239 regs
->pc
= vcpu
->arch
.pc
;
1240 regs
->cr
= kvmppc_get_cr(vcpu
);
1241 regs
->ctr
= vcpu
->arch
.ctr
;
1242 regs
->lr
= vcpu
->arch
.lr
;
1243 regs
->xer
= kvmppc_get_xer(vcpu
);
1244 regs
->msr
= vcpu
->arch
.shared
->msr
;
1245 regs
->srr0
= vcpu
->arch
.shared
->srr0
;
1246 regs
->srr1
= vcpu
->arch
.shared
->srr1
;
1247 regs
->pid
= vcpu
->arch
.pid
;
1248 regs
->sprg0
= vcpu
->arch
.shared
->sprg0
;
1249 regs
->sprg1
= vcpu
->arch
.shared
->sprg1
;
1250 regs
->sprg2
= vcpu
->arch
.shared
->sprg2
;
1251 regs
->sprg3
= vcpu
->arch
.shared
->sprg3
;
1252 regs
->sprg4
= vcpu
->arch
.shared
->sprg4
;
1253 regs
->sprg5
= vcpu
->arch
.shared
->sprg5
;
1254 regs
->sprg6
= vcpu
->arch
.shared
->sprg6
;
1255 regs
->sprg7
= vcpu
->arch
.shared
->sprg7
;
1257 for (i
= 0; i
< ARRAY_SIZE(regs
->gpr
); i
++)
1258 regs
->gpr
[i
] = kvmppc_get_gpr(vcpu
, i
);
1263 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu
*vcpu
, struct kvm_regs
*regs
)
1267 vcpu
->arch
.pc
= regs
->pc
;
1268 kvmppc_set_cr(vcpu
, regs
->cr
);
1269 vcpu
->arch
.ctr
= regs
->ctr
;
1270 vcpu
->arch
.lr
= regs
->lr
;
1271 kvmppc_set_xer(vcpu
, regs
->xer
);
1272 kvmppc_set_msr(vcpu
, regs
->msr
);
1273 vcpu
->arch
.shared
->srr0
= regs
->srr0
;
1274 vcpu
->arch
.shared
->srr1
= regs
->srr1
;
1275 kvmppc_set_pid(vcpu
, regs
->pid
);
1276 vcpu
->arch
.shared
->sprg0
= regs
->sprg0
;
1277 vcpu
->arch
.shared
->sprg1
= regs
->sprg1
;
1278 vcpu
->arch
.shared
->sprg2
= regs
->sprg2
;
1279 vcpu
->arch
.shared
->sprg3
= regs
->sprg3
;
1280 vcpu
->arch
.shared
->sprg4
= regs
->sprg4
;
1281 vcpu
->arch
.shared
->sprg5
= regs
->sprg5
;
1282 vcpu
->arch
.shared
->sprg6
= regs
->sprg6
;
1283 vcpu
->arch
.shared
->sprg7
= regs
->sprg7
;
1285 for (i
= 0; i
< ARRAY_SIZE(regs
->gpr
); i
++)
1286 kvmppc_set_gpr(vcpu
, i
, regs
->gpr
[i
]);
1291 static void get_sregs_base(struct kvm_vcpu
*vcpu
,
1292 struct kvm_sregs
*sregs
)
1296 sregs
->u
.e
.features
|= KVM_SREGS_E_BASE
;
1298 sregs
->u
.e
.csrr0
= vcpu
->arch
.csrr0
;
1299 sregs
->u
.e
.csrr1
= vcpu
->arch
.csrr1
;
1300 sregs
->u
.e
.mcsr
= vcpu
->arch
.mcsr
;
1301 sregs
->u
.e
.esr
= get_guest_esr(vcpu
);
1302 sregs
->u
.e
.dear
= get_guest_dear(vcpu
);
1303 sregs
->u
.e
.tsr
= vcpu
->arch
.tsr
;
1304 sregs
->u
.e
.tcr
= vcpu
->arch
.tcr
;
1305 sregs
->u
.e
.dec
= kvmppc_get_dec(vcpu
, tb
);
1307 sregs
->u
.e
.vrsave
= vcpu
->arch
.vrsave
;
1310 static int set_sregs_base(struct kvm_vcpu
*vcpu
,
1311 struct kvm_sregs
*sregs
)
1313 if (!(sregs
->u
.e
.features
& KVM_SREGS_E_BASE
))
1316 vcpu
->arch
.csrr0
= sregs
->u
.e
.csrr0
;
1317 vcpu
->arch
.csrr1
= sregs
->u
.e
.csrr1
;
1318 vcpu
->arch
.mcsr
= sregs
->u
.e
.mcsr
;
1319 set_guest_esr(vcpu
, sregs
->u
.e
.esr
);
1320 set_guest_dear(vcpu
, sregs
->u
.e
.dear
);
1321 vcpu
->arch
.vrsave
= sregs
->u
.e
.vrsave
;
1322 kvmppc_set_tcr(vcpu
, sregs
->u
.e
.tcr
);
1324 if (sregs
->u
.e
.update_special
& KVM_SREGS_E_UPDATE_DEC
) {
1325 vcpu
->arch
.dec
= sregs
->u
.e
.dec
;
1326 kvmppc_emulate_dec(vcpu
);
1329 if (sregs
->u
.e
.update_special
& KVM_SREGS_E_UPDATE_TSR
)
1330 kvmppc_set_tsr(vcpu
, sregs
->u
.e
.tsr
);
1335 static void get_sregs_arch206(struct kvm_vcpu
*vcpu
,
1336 struct kvm_sregs
*sregs
)
1338 sregs
->u
.e
.features
|= KVM_SREGS_E_ARCH206
;
1340 sregs
->u
.e
.pir
= vcpu
->vcpu_id
;
1341 sregs
->u
.e
.mcsrr0
= vcpu
->arch
.mcsrr0
;
1342 sregs
->u
.e
.mcsrr1
= vcpu
->arch
.mcsrr1
;
1343 sregs
->u
.e
.decar
= vcpu
->arch
.decar
;
1344 sregs
->u
.e
.ivpr
= vcpu
->arch
.ivpr
;
1347 static int set_sregs_arch206(struct kvm_vcpu
*vcpu
,
1348 struct kvm_sregs
*sregs
)
1350 if (!(sregs
->u
.e
.features
& KVM_SREGS_E_ARCH206
))
1353 if (sregs
->u
.e
.pir
!= vcpu
->vcpu_id
)
1356 vcpu
->arch
.mcsrr0
= sregs
->u
.e
.mcsrr0
;
1357 vcpu
->arch
.mcsrr1
= sregs
->u
.e
.mcsrr1
;
1358 vcpu
->arch
.decar
= sregs
->u
.e
.decar
;
1359 vcpu
->arch
.ivpr
= sregs
->u
.e
.ivpr
;
1364 void kvmppc_get_sregs_ivor(struct kvm_vcpu
*vcpu
, struct kvm_sregs
*sregs
)
1366 sregs
->u
.e
.features
|= KVM_SREGS_E_IVOR
;
1368 sregs
->u
.e
.ivor_low
[0] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_CRITICAL
];
1369 sregs
->u
.e
.ivor_low
[1] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_MACHINE_CHECK
];
1370 sregs
->u
.e
.ivor_low
[2] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_DATA_STORAGE
];
1371 sregs
->u
.e
.ivor_low
[3] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_INST_STORAGE
];
1372 sregs
->u
.e
.ivor_low
[4] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_EXTERNAL
];
1373 sregs
->u
.e
.ivor_low
[5] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_ALIGNMENT
];
1374 sregs
->u
.e
.ivor_low
[6] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_PROGRAM
];
1375 sregs
->u
.e
.ivor_low
[7] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_FP_UNAVAIL
];
1376 sregs
->u
.e
.ivor_low
[8] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_SYSCALL
];
1377 sregs
->u
.e
.ivor_low
[9] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_AP_UNAVAIL
];
1378 sregs
->u
.e
.ivor_low
[10] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_DECREMENTER
];
1379 sregs
->u
.e
.ivor_low
[11] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_FIT
];
1380 sregs
->u
.e
.ivor_low
[12] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_WATCHDOG
];
1381 sregs
->u
.e
.ivor_low
[13] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_DTLB_MISS
];
1382 sregs
->u
.e
.ivor_low
[14] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_ITLB_MISS
];
1383 sregs
->u
.e
.ivor_low
[15] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_DEBUG
];
1386 int kvmppc_set_sregs_ivor(struct kvm_vcpu
*vcpu
, struct kvm_sregs
*sregs
)
1388 if (!(sregs
->u
.e
.features
& KVM_SREGS_E_IVOR
))
1391 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_CRITICAL
] = sregs
->u
.e
.ivor_low
[0];
1392 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_MACHINE_CHECK
] = sregs
->u
.e
.ivor_low
[1];
1393 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_DATA_STORAGE
] = sregs
->u
.e
.ivor_low
[2];
1394 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_INST_STORAGE
] = sregs
->u
.e
.ivor_low
[3];
1395 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_EXTERNAL
] = sregs
->u
.e
.ivor_low
[4];
1396 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_ALIGNMENT
] = sregs
->u
.e
.ivor_low
[5];
1397 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_PROGRAM
] = sregs
->u
.e
.ivor_low
[6];
1398 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_FP_UNAVAIL
] = sregs
->u
.e
.ivor_low
[7];
1399 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_SYSCALL
] = sregs
->u
.e
.ivor_low
[8];
1400 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_AP_UNAVAIL
] = sregs
->u
.e
.ivor_low
[9];
1401 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_DECREMENTER
] = sregs
->u
.e
.ivor_low
[10];
1402 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_FIT
] = sregs
->u
.e
.ivor_low
[11];
1403 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_WATCHDOG
] = sregs
->u
.e
.ivor_low
[12];
1404 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_DTLB_MISS
] = sregs
->u
.e
.ivor_low
[13];
1405 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_ITLB_MISS
] = sregs
->u
.e
.ivor_low
[14];
1406 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_DEBUG
] = sregs
->u
.e
.ivor_low
[15];
1411 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu
*vcpu
,
1412 struct kvm_sregs
*sregs
)
1414 sregs
->pvr
= vcpu
->arch
.pvr
;
1416 get_sregs_base(vcpu
, sregs
);
1417 get_sregs_arch206(vcpu
, sregs
);
1418 kvmppc_core_get_sregs(vcpu
, sregs
);
1422 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu
*vcpu
,
1423 struct kvm_sregs
*sregs
)
1427 if (vcpu
->arch
.pvr
!= sregs
->pvr
)
1430 ret
= set_sregs_base(vcpu
, sregs
);
1434 ret
= set_sregs_arch206(vcpu
, sregs
);
1438 return kvmppc_core_set_sregs(vcpu
, sregs
);
1441 int kvm_vcpu_ioctl_get_one_reg(struct kvm_vcpu
*vcpu
, struct kvm_one_reg
*reg
)
1444 union kvmppc_one_reg val
;
1448 size
= one_reg_size(reg
->id
);
1449 if (size
> sizeof(val
))
1453 case KVM_REG_PPC_IAC1
:
1454 case KVM_REG_PPC_IAC2
:
1455 case KVM_REG_PPC_IAC3
:
1456 case KVM_REG_PPC_IAC4
:
1457 i
= reg
->id
- KVM_REG_PPC_IAC1
;
1458 val
= get_reg_val(reg
->id
, vcpu
->arch
.dbg_reg
.iac
[i
]);
1460 case KVM_REG_PPC_DAC1
:
1461 case KVM_REG_PPC_DAC2
:
1462 i
= reg
->id
- KVM_REG_PPC_DAC1
;
1463 val
= get_reg_val(reg
->id
, vcpu
->arch
.dbg_reg
.dac
[i
]);
1465 case KVM_REG_PPC_EPR
: {
1466 u32 epr
= get_guest_epr(vcpu
);
1467 val
= get_reg_val(reg
->id
, epr
);
1470 #if defined(CONFIG_64BIT)
1471 case KVM_REG_PPC_EPCR
:
1472 val
= get_reg_val(reg
->id
, vcpu
->arch
.epcr
);
1475 case KVM_REG_PPC_TCR
:
1476 val
= get_reg_val(reg
->id
, vcpu
->arch
.tcr
);
1478 case KVM_REG_PPC_TSR
:
1479 val
= get_reg_val(reg
->id
, vcpu
->arch
.tsr
);
1481 case KVM_REG_PPC_DEBUG_INST
:
1482 val
= get_reg_val(reg
->id
, KVMPPC_INST_EHPRIV
);
1485 r
= kvmppc_get_one_reg(vcpu
, reg
->id
, &val
);
1492 if (copy_to_user((char __user
*)(unsigned long)reg
->addr
, &val
, size
))
1498 int kvm_vcpu_ioctl_set_one_reg(struct kvm_vcpu
*vcpu
, struct kvm_one_reg
*reg
)
1501 union kvmppc_one_reg val
;
1505 size
= one_reg_size(reg
->id
);
1506 if (size
> sizeof(val
))
1509 if (copy_from_user(&val
, (char __user
*)(unsigned long)reg
->addr
, size
))
1513 case KVM_REG_PPC_IAC1
:
1514 case KVM_REG_PPC_IAC2
:
1515 case KVM_REG_PPC_IAC3
:
1516 case KVM_REG_PPC_IAC4
:
1517 i
= reg
->id
- KVM_REG_PPC_IAC1
;
1518 vcpu
->arch
.dbg_reg
.iac
[i
] = set_reg_val(reg
->id
, val
);
1520 case KVM_REG_PPC_DAC1
:
1521 case KVM_REG_PPC_DAC2
:
1522 i
= reg
->id
- KVM_REG_PPC_DAC1
;
1523 vcpu
->arch
.dbg_reg
.dac
[i
] = set_reg_val(reg
->id
, val
);
1525 case KVM_REG_PPC_EPR
: {
1526 u32 new_epr
= set_reg_val(reg
->id
, val
);
1527 kvmppc_set_epr(vcpu
, new_epr
);
1530 #if defined(CONFIG_64BIT)
1531 case KVM_REG_PPC_EPCR
: {
1532 u32 new_epcr
= set_reg_val(reg
->id
, val
);
1533 kvmppc_set_epcr(vcpu
, new_epcr
);
1537 case KVM_REG_PPC_OR_TSR
: {
1538 u32 tsr_bits
= set_reg_val(reg
->id
, val
);
1539 kvmppc_set_tsr_bits(vcpu
, tsr_bits
);
1542 case KVM_REG_PPC_CLEAR_TSR
: {
1543 u32 tsr_bits
= set_reg_val(reg
->id
, val
);
1544 kvmppc_clr_tsr_bits(vcpu
, tsr_bits
);
1547 case KVM_REG_PPC_TSR
: {
1548 u32 tsr
= set_reg_val(reg
->id
, val
);
1549 kvmppc_set_tsr(vcpu
, tsr
);
1552 case KVM_REG_PPC_TCR
: {
1553 u32 tcr
= set_reg_val(reg
->id
, val
);
1554 kvmppc_set_tcr(vcpu
, tcr
);
1558 r
= kvmppc_set_one_reg(vcpu
, reg
->id
, &val
);
1565 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu
*vcpu
,
1566 struct kvm_guest_debug
*dbg
)
1571 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu
*vcpu
, struct kvm_fpu
*fpu
)
1576 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu
*vcpu
, struct kvm_fpu
*fpu
)
1581 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu
*vcpu
,
1582 struct kvm_translation
*tr
)
1586 r
= kvmppc_core_vcpu_translate(vcpu
, tr
);
1590 int kvm_vm_ioctl_get_dirty_log(struct kvm
*kvm
, struct kvm_dirty_log
*log
)
1595 void kvmppc_core_free_memslot(struct kvm_memory_slot
*free
,
1596 struct kvm_memory_slot
*dont
)
1600 int kvmppc_core_create_memslot(struct kvm_memory_slot
*slot
,
1601 unsigned long npages
)
1606 int kvmppc_core_prepare_memory_region(struct kvm
*kvm
,
1607 struct kvm_memory_slot
*memslot
,
1608 struct kvm_userspace_memory_region
*mem
)
1613 void kvmppc_core_commit_memory_region(struct kvm
*kvm
,
1614 struct kvm_userspace_memory_region
*mem
,
1615 const struct kvm_memory_slot
*old
)
1619 void kvmppc_core_flush_memslot(struct kvm
*kvm
, struct kvm_memory_slot
*memslot
)
1623 void kvmppc_set_epcr(struct kvm_vcpu
*vcpu
, u32 new_epcr
)
1625 #if defined(CONFIG_64BIT)
1626 vcpu
->arch
.epcr
= new_epcr
;
1627 #ifdef CONFIG_KVM_BOOKE_HV
1628 vcpu
->arch
.shadow_epcr
&= ~SPRN_EPCR_GICM
;
1629 if (vcpu
->arch
.epcr
& SPRN_EPCR_ICM
)
1630 vcpu
->arch
.shadow_epcr
|= SPRN_EPCR_GICM
;
1635 void kvmppc_set_tcr(struct kvm_vcpu
*vcpu
, u32 new_tcr
)
1637 vcpu
->arch
.tcr
= new_tcr
;
1638 arm_next_watchdog(vcpu
);
1639 update_timer_ints(vcpu
);
1642 void kvmppc_set_tsr_bits(struct kvm_vcpu
*vcpu
, u32 tsr_bits
)
1644 set_bits(tsr_bits
, &vcpu
->arch
.tsr
);
1646 kvm_make_request(KVM_REQ_PENDING_TIMER
, vcpu
);
1647 kvm_vcpu_kick(vcpu
);
1650 void kvmppc_clr_tsr_bits(struct kvm_vcpu
*vcpu
, u32 tsr_bits
)
1652 clear_bits(tsr_bits
, &vcpu
->arch
.tsr
);
1655 * We may have stopped the watchdog due to
1656 * being stuck on final expiration.
1658 if (tsr_bits
& (TSR_ENW
| TSR_WIS
))
1659 arm_next_watchdog(vcpu
);
1661 update_timer_ints(vcpu
);
1664 void kvmppc_decrementer_func(unsigned long data
)
1666 struct kvm_vcpu
*vcpu
= (struct kvm_vcpu
*)data
;
1668 if (vcpu
->arch
.tcr
& TCR_ARE
) {
1669 vcpu
->arch
.dec
= vcpu
->arch
.decar
;
1670 kvmppc_emulate_dec(vcpu
);
1673 kvmppc_set_tsr_bits(vcpu
, TSR_DIS
);
1676 void kvmppc_booke_vcpu_load(struct kvm_vcpu
*vcpu
, int cpu
)
1678 vcpu
->cpu
= smp_processor_id();
1679 current
->thread
.kvm_vcpu
= vcpu
;
1682 void kvmppc_booke_vcpu_put(struct kvm_vcpu
*vcpu
)
1684 current
->thread
.kvm_vcpu
= NULL
;
1688 int __init
kvmppc_booke_init(void)
1690 #ifndef CONFIG_KVM_BOOKE_HV
1691 unsigned long ivor
[16];
1692 unsigned long *handler
= kvmppc_booke_handler_addr
;
1693 unsigned long max_ivor
= 0;
1694 unsigned long handler_len
;
1697 /* We install our own exception handlers by hijacking IVPR. IVPR must
1698 * be 16-bit aligned, so we need a 64KB allocation. */
1699 kvmppc_booke_handlers
= __get_free_pages(GFP_KERNEL
| __GFP_ZERO
,
1701 if (!kvmppc_booke_handlers
)
1704 /* XXX make sure our handlers are smaller than Linux's */
1706 /* Copy our interrupt handlers to match host IVORs. That way we don't
1707 * have to swap the IVORs on every guest/host transition. */
1708 ivor
[0] = mfspr(SPRN_IVOR0
);
1709 ivor
[1] = mfspr(SPRN_IVOR1
);
1710 ivor
[2] = mfspr(SPRN_IVOR2
);
1711 ivor
[3] = mfspr(SPRN_IVOR3
);
1712 ivor
[4] = mfspr(SPRN_IVOR4
);
1713 ivor
[5] = mfspr(SPRN_IVOR5
);
1714 ivor
[6] = mfspr(SPRN_IVOR6
);
1715 ivor
[7] = mfspr(SPRN_IVOR7
);
1716 ivor
[8] = mfspr(SPRN_IVOR8
);
1717 ivor
[9] = mfspr(SPRN_IVOR9
);
1718 ivor
[10] = mfspr(SPRN_IVOR10
);
1719 ivor
[11] = mfspr(SPRN_IVOR11
);
1720 ivor
[12] = mfspr(SPRN_IVOR12
);
1721 ivor
[13] = mfspr(SPRN_IVOR13
);
1722 ivor
[14] = mfspr(SPRN_IVOR14
);
1723 ivor
[15] = mfspr(SPRN_IVOR15
);
1725 for (i
= 0; i
< 16; i
++) {
1726 if (ivor
[i
] > max_ivor
)
1729 handler_len
= handler
[i
+ 1] - handler
[i
];
1730 memcpy((void *)kvmppc_booke_handlers
+ ivor
[i
],
1731 (void *)handler
[i
], handler_len
);
1734 handler_len
= handler
[max_ivor
+ 1] - handler
[max_ivor
];
1735 flush_icache_range(kvmppc_booke_handlers
, kvmppc_booke_handlers
+
1736 ivor
[max_ivor
] + handler_len
);
1737 #endif /* !BOOKE_HV */
1741 void __exit
kvmppc_booke_exit(void)
1743 free_pages(kvmppc_booke_handlers
, VCPU_SIZE_ORDER
);