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>
44 #define CREATE_TRACE_POINTS
45 #include "trace_booke.h"
47 unsigned long kvmppc_booke_handlers
;
49 #define VM_STAT(x) offsetof(struct kvm, stat.x), KVM_STAT_VM
50 #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
52 struct kvm_stats_debugfs_item debugfs_entries
[] = {
53 { "mmio", VCPU_STAT(mmio_exits
) },
54 { "dcr", VCPU_STAT(dcr_exits
) },
55 { "sig", VCPU_STAT(signal_exits
) },
56 { "itlb_r", VCPU_STAT(itlb_real_miss_exits
) },
57 { "itlb_v", VCPU_STAT(itlb_virt_miss_exits
) },
58 { "dtlb_r", VCPU_STAT(dtlb_real_miss_exits
) },
59 { "dtlb_v", VCPU_STAT(dtlb_virt_miss_exits
) },
60 { "sysc", VCPU_STAT(syscall_exits
) },
61 { "isi", VCPU_STAT(isi_exits
) },
62 { "dsi", VCPU_STAT(dsi_exits
) },
63 { "inst_emu", VCPU_STAT(emulated_inst_exits
) },
64 { "dec", VCPU_STAT(dec_exits
) },
65 { "ext_intr", VCPU_STAT(ext_intr_exits
) },
66 { "halt_wakeup", VCPU_STAT(halt_wakeup
) },
67 { "doorbell", VCPU_STAT(dbell_exits
) },
68 { "guest doorbell", VCPU_STAT(gdbell_exits
) },
69 { "remote_tlb_flush", VM_STAT(remote_tlb_flush
) },
73 /* TODO: use vcpu_printf() */
74 void kvmppc_dump_vcpu(struct kvm_vcpu
*vcpu
)
78 printk("pc: %08lx msr: %08llx\n", vcpu
->arch
.pc
, vcpu
->arch
.shared
->msr
);
79 printk("lr: %08lx ctr: %08lx\n", vcpu
->arch
.lr
, vcpu
->arch
.ctr
);
80 printk("srr0: %08llx srr1: %08llx\n", vcpu
->arch
.shared
->srr0
,
81 vcpu
->arch
.shared
->srr1
);
83 printk("exceptions: %08lx\n", vcpu
->arch
.pending_exceptions
);
85 for (i
= 0; i
< 32; i
+= 4) {
86 printk("gpr%02d: %08lx %08lx %08lx %08lx\n", i
,
87 kvmppc_get_gpr(vcpu
, i
),
88 kvmppc_get_gpr(vcpu
, i
+1),
89 kvmppc_get_gpr(vcpu
, i
+2),
90 kvmppc_get_gpr(vcpu
, i
+3));
95 void kvmppc_vcpu_disable_spe(struct kvm_vcpu
*vcpu
)
99 kvmppc_save_guest_spe(vcpu
);
100 vcpu
->arch
.shadow_msr
&= ~MSR_SPE
;
104 static void kvmppc_vcpu_enable_spe(struct kvm_vcpu
*vcpu
)
108 kvmppc_load_guest_spe(vcpu
);
109 vcpu
->arch
.shadow_msr
|= MSR_SPE
;
113 static void kvmppc_vcpu_sync_spe(struct kvm_vcpu
*vcpu
)
115 if (vcpu
->arch
.shared
->msr
& MSR_SPE
) {
116 if (!(vcpu
->arch
.shadow_msr
& MSR_SPE
))
117 kvmppc_vcpu_enable_spe(vcpu
);
118 } else if (vcpu
->arch
.shadow_msr
& MSR_SPE
) {
119 kvmppc_vcpu_disable_spe(vcpu
);
123 static void kvmppc_vcpu_sync_spe(struct kvm_vcpu
*vcpu
)
128 static void kvmppc_vcpu_sync_fpu(struct kvm_vcpu
*vcpu
)
130 #if defined(CONFIG_PPC_FPU) && !defined(CONFIG_KVM_BOOKE_HV)
131 /* We always treat the FP bit as enabled from the host
132 perspective, so only need to adjust the shadow MSR */
133 vcpu
->arch
.shadow_msr
&= ~MSR_FP
;
134 vcpu
->arch
.shadow_msr
|= vcpu
->arch
.shared
->msr
& MSR_FP
;
138 static void kvmppc_vcpu_sync_debug(struct kvm_vcpu
*vcpu
)
140 /* Synchronize guest's desire to get debug interrupts into shadow MSR */
141 #ifndef CONFIG_KVM_BOOKE_HV
142 vcpu
->arch
.shadow_msr
&= ~MSR_DE
;
143 vcpu
->arch
.shadow_msr
|= vcpu
->arch
.shared
->msr
& MSR_DE
;
146 /* Force enable debug interrupts when user space wants to debug */
147 if (vcpu
->guest_debug
) {
148 #ifdef CONFIG_KVM_BOOKE_HV
150 * Since there is no shadow MSR, sync MSR_DE into the guest
153 vcpu
->arch
.shared
->msr
|= MSR_DE
;
155 vcpu
->arch
.shadow_msr
|= MSR_DE
;
156 vcpu
->arch
.shared
->msr
&= ~MSR_DE
;
162 * Helper function for "full" MSR writes. No need to call this if only
163 * EE/CE/ME/DE/RI are changing.
165 void kvmppc_set_msr(struct kvm_vcpu
*vcpu
, u32 new_msr
)
167 u32 old_msr
= vcpu
->arch
.shared
->msr
;
169 #ifdef CONFIG_KVM_BOOKE_HV
173 vcpu
->arch
.shared
->msr
= new_msr
;
175 kvmppc_mmu_msr_notify(vcpu
, old_msr
);
176 kvmppc_vcpu_sync_spe(vcpu
);
177 kvmppc_vcpu_sync_fpu(vcpu
);
178 kvmppc_vcpu_sync_debug(vcpu
);
181 static void kvmppc_booke_queue_irqprio(struct kvm_vcpu
*vcpu
,
182 unsigned int priority
)
184 trace_kvm_booke_queue_irqprio(vcpu
, priority
);
185 set_bit(priority
, &vcpu
->arch
.pending_exceptions
);
188 static void kvmppc_core_queue_dtlb_miss(struct kvm_vcpu
*vcpu
,
189 ulong dear_flags
, ulong esr_flags
)
191 vcpu
->arch
.queued_dear
= dear_flags
;
192 vcpu
->arch
.queued_esr
= esr_flags
;
193 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_DTLB_MISS
);
196 static void kvmppc_core_queue_data_storage(struct kvm_vcpu
*vcpu
,
197 ulong dear_flags
, ulong esr_flags
)
199 vcpu
->arch
.queued_dear
= dear_flags
;
200 vcpu
->arch
.queued_esr
= esr_flags
;
201 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_DATA_STORAGE
);
204 static void kvmppc_core_queue_inst_storage(struct kvm_vcpu
*vcpu
,
207 vcpu
->arch
.queued_esr
= esr_flags
;
208 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_INST_STORAGE
);
211 static void kvmppc_core_queue_alignment(struct kvm_vcpu
*vcpu
, ulong dear_flags
,
214 vcpu
->arch
.queued_dear
= dear_flags
;
215 vcpu
->arch
.queued_esr
= esr_flags
;
216 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_ALIGNMENT
);
219 void kvmppc_core_queue_program(struct kvm_vcpu
*vcpu
, ulong esr_flags
)
221 vcpu
->arch
.queued_esr
= esr_flags
;
222 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_PROGRAM
);
225 void kvmppc_core_queue_dec(struct kvm_vcpu
*vcpu
)
227 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_DECREMENTER
);
230 int kvmppc_core_pending_dec(struct kvm_vcpu
*vcpu
)
232 return test_bit(BOOKE_IRQPRIO_DECREMENTER
, &vcpu
->arch
.pending_exceptions
);
235 void kvmppc_core_dequeue_dec(struct kvm_vcpu
*vcpu
)
237 clear_bit(BOOKE_IRQPRIO_DECREMENTER
, &vcpu
->arch
.pending_exceptions
);
240 void kvmppc_core_queue_external(struct kvm_vcpu
*vcpu
,
241 struct kvm_interrupt
*irq
)
243 unsigned int prio
= BOOKE_IRQPRIO_EXTERNAL
;
245 if (irq
->irq
== KVM_INTERRUPT_SET_LEVEL
)
246 prio
= BOOKE_IRQPRIO_EXTERNAL_LEVEL
;
248 kvmppc_booke_queue_irqprio(vcpu
, prio
);
251 void kvmppc_core_dequeue_external(struct kvm_vcpu
*vcpu
)
253 clear_bit(BOOKE_IRQPRIO_EXTERNAL
, &vcpu
->arch
.pending_exceptions
);
254 clear_bit(BOOKE_IRQPRIO_EXTERNAL_LEVEL
, &vcpu
->arch
.pending_exceptions
);
257 static void kvmppc_core_queue_watchdog(struct kvm_vcpu
*vcpu
)
259 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_WATCHDOG
);
262 static void kvmppc_core_dequeue_watchdog(struct kvm_vcpu
*vcpu
)
264 clear_bit(BOOKE_IRQPRIO_WATCHDOG
, &vcpu
->arch
.pending_exceptions
);
267 static void set_guest_srr(struct kvm_vcpu
*vcpu
, unsigned long srr0
, u32 srr1
)
269 #ifdef CONFIG_KVM_BOOKE_HV
270 mtspr(SPRN_GSRR0
, srr0
);
271 mtspr(SPRN_GSRR1
, srr1
);
273 vcpu
->arch
.shared
->srr0
= srr0
;
274 vcpu
->arch
.shared
->srr1
= srr1
;
278 static void set_guest_csrr(struct kvm_vcpu
*vcpu
, unsigned long srr0
, u32 srr1
)
280 vcpu
->arch
.csrr0
= srr0
;
281 vcpu
->arch
.csrr1
= srr1
;
284 static void set_guest_dsrr(struct kvm_vcpu
*vcpu
, unsigned long srr0
, u32 srr1
)
286 if (cpu_has_feature(CPU_FTR_DEBUG_LVL_EXC
)) {
287 vcpu
->arch
.dsrr0
= srr0
;
288 vcpu
->arch
.dsrr1
= srr1
;
290 set_guest_csrr(vcpu
, srr0
, srr1
);
294 static void set_guest_mcsrr(struct kvm_vcpu
*vcpu
, unsigned long srr0
, u32 srr1
)
296 vcpu
->arch
.mcsrr0
= srr0
;
297 vcpu
->arch
.mcsrr1
= srr1
;
300 static unsigned long get_guest_dear(struct kvm_vcpu
*vcpu
)
302 #ifdef CONFIG_KVM_BOOKE_HV
303 return mfspr(SPRN_GDEAR
);
305 return vcpu
->arch
.shared
->dar
;
309 static void set_guest_dear(struct kvm_vcpu
*vcpu
, unsigned long dear
)
311 #ifdef CONFIG_KVM_BOOKE_HV
312 mtspr(SPRN_GDEAR
, dear
);
314 vcpu
->arch
.shared
->dar
= dear
;
318 static unsigned long get_guest_esr(struct kvm_vcpu
*vcpu
)
320 #ifdef CONFIG_KVM_BOOKE_HV
321 return mfspr(SPRN_GESR
);
323 return vcpu
->arch
.shared
->esr
;
327 static void set_guest_esr(struct kvm_vcpu
*vcpu
, u32 esr
)
329 #ifdef CONFIG_KVM_BOOKE_HV
330 mtspr(SPRN_GESR
, esr
);
332 vcpu
->arch
.shared
->esr
= esr
;
336 static unsigned long get_guest_epr(struct kvm_vcpu
*vcpu
)
338 #ifdef CONFIG_KVM_BOOKE_HV
339 return mfspr(SPRN_GEPR
);
341 return vcpu
->arch
.epr
;
345 /* Deliver the interrupt of the corresponding priority, if possible. */
346 static int kvmppc_booke_irqprio_deliver(struct kvm_vcpu
*vcpu
,
347 unsigned int priority
)
351 bool update_esr
= false, update_dear
= false, update_epr
= false;
352 ulong crit_raw
= vcpu
->arch
.shared
->critical
;
353 ulong crit_r1
= kvmppc_get_gpr(vcpu
, 1);
355 bool keep_irq
= false;
356 enum int_class int_class
;
357 ulong new_msr
= vcpu
->arch
.shared
->msr
;
359 /* Truncate crit indicators in 32 bit mode */
360 if (!(vcpu
->arch
.shared
->msr
& MSR_SF
)) {
361 crit_raw
&= 0xffffffff;
362 crit_r1
&= 0xffffffff;
365 /* Critical section when crit == r1 */
366 crit
= (crit_raw
== crit_r1
);
367 /* ... and we're in supervisor mode */
368 crit
= crit
&& !(vcpu
->arch
.shared
->msr
& MSR_PR
);
370 if (priority
== BOOKE_IRQPRIO_EXTERNAL_LEVEL
) {
371 priority
= BOOKE_IRQPRIO_EXTERNAL
;
375 if ((priority
== BOOKE_IRQPRIO_EXTERNAL
) && vcpu
->arch
.epr_flags
)
379 case BOOKE_IRQPRIO_DTLB_MISS
:
380 case BOOKE_IRQPRIO_DATA_STORAGE
:
381 case BOOKE_IRQPRIO_ALIGNMENT
:
384 case BOOKE_IRQPRIO_INST_STORAGE
:
385 case BOOKE_IRQPRIO_PROGRAM
:
388 case BOOKE_IRQPRIO_ITLB_MISS
:
389 case BOOKE_IRQPRIO_SYSCALL
:
390 case BOOKE_IRQPRIO_FP_UNAVAIL
:
391 case BOOKE_IRQPRIO_SPE_UNAVAIL
:
392 case BOOKE_IRQPRIO_SPE_FP_DATA
:
393 case BOOKE_IRQPRIO_SPE_FP_ROUND
:
394 case BOOKE_IRQPRIO_AP_UNAVAIL
:
396 msr_mask
= MSR_CE
| MSR_ME
| MSR_DE
;
397 int_class
= INT_CLASS_NONCRIT
;
399 case BOOKE_IRQPRIO_WATCHDOG
:
400 case BOOKE_IRQPRIO_CRITICAL
:
401 case BOOKE_IRQPRIO_DBELL_CRIT
:
402 allowed
= vcpu
->arch
.shared
->msr
& MSR_CE
;
403 allowed
= allowed
&& !crit
;
405 int_class
= INT_CLASS_CRIT
;
407 case BOOKE_IRQPRIO_MACHINE_CHECK
:
408 allowed
= vcpu
->arch
.shared
->msr
& MSR_ME
;
409 allowed
= allowed
&& !crit
;
410 int_class
= INT_CLASS_MC
;
412 case BOOKE_IRQPRIO_DECREMENTER
:
413 case BOOKE_IRQPRIO_FIT
:
416 case BOOKE_IRQPRIO_EXTERNAL
:
417 case BOOKE_IRQPRIO_DBELL
:
418 allowed
= vcpu
->arch
.shared
->msr
& MSR_EE
;
419 allowed
= allowed
&& !crit
;
420 msr_mask
= MSR_CE
| MSR_ME
| MSR_DE
;
421 int_class
= INT_CLASS_NONCRIT
;
423 case BOOKE_IRQPRIO_DEBUG
:
424 allowed
= vcpu
->arch
.shared
->msr
& MSR_DE
;
425 allowed
= allowed
&& !crit
;
427 int_class
= INT_CLASS_CRIT
;
433 case INT_CLASS_NONCRIT
:
434 set_guest_srr(vcpu
, vcpu
->arch
.pc
,
435 vcpu
->arch
.shared
->msr
);
438 set_guest_csrr(vcpu
, vcpu
->arch
.pc
,
439 vcpu
->arch
.shared
->msr
);
442 set_guest_dsrr(vcpu
, vcpu
->arch
.pc
,
443 vcpu
->arch
.shared
->msr
);
446 set_guest_mcsrr(vcpu
, vcpu
->arch
.pc
,
447 vcpu
->arch
.shared
->msr
);
451 vcpu
->arch
.pc
= vcpu
->arch
.ivpr
| vcpu
->arch
.ivor
[priority
];
452 if (update_esr
== true)
453 set_guest_esr(vcpu
, vcpu
->arch
.queued_esr
);
454 if (update_dear
== true)
455 set_guest_dear(vcpu
, vcpu
->arch
.queued_dear
);
456 if (update_epr
== true) {
457 if (vcpu
->arch
.epr_flags
& KVMPPC_EPR_USER
)
458 kvm_make_request(KVM_REQ_EPR_EXIT
, vcpu
);
459 else if (vcpu
->arch
.epr_flags
& KVMPPC_EPR_KERNEL
) {
460 BUG_ON(vcpu
->arch
.irq_type
!= KVMPPC_IRQ_MPIC
);
461 kvmppc_mpic_set_epr(vcpu
);
466 #if defined(CONFIG_64BIT)
467 if (vcpu
->arch
.epcr
& SPRN_EPCR_ICM
)
470 kvmppc_set_msr(vcpu
, new_msr
);
473 clear_bit(priority
, &vcpu
->arch
.pending_exceptions
);
476 #ifdef CONFIG_KVM_BOOKE_HV
478 * If an interrupt is pending but masked, raise a guest doorbell
479 * so that we are notified when the guest enables the relevant
482 if (vcpu
->arch
.pending_exceptions
& BOOKE_IRQMASK_EE
)
483 kvmppc_set_pending_interrupt(vcpu
, INT_CLASS_NONCRIT
);
484 if (vcpu
->arch
.pending_exceptions
& BOOKE_IRQMASK_CE
)
485 kvmppc_set_pending_interrupt(vcpu
, INT_CLASS_CRIT
);
486 if (vcpu
->arch
.pending_exceptions
& BOOKE_IRQPRIO_MACHINE_CHECK
)
487 kvmppc_set_pending_interrupt(vcpu
, INT_CLASS_MC
);
494 * Return the number of jiffies until the next timeout. If the timeout is
495 * longer than the NEXT_TIMER_MAX_DELTA, then return NEXT_TIMER_MAX_DELTA
496 * because the larger value can break the timer APIs.
498 static unsigned long watchdog_next_timeout(struct kvm_vcpu
*vcpu
)
500 u64 tb
, wdt_tb
, wdt_ticks
= 0;
502 u32 period
= TCR_GET_WP(vcpu
->arch
.tcr
);
504 wdt_tb
= 1ULL << (63 - period
);
507 * The watchdog timeout will hapeen when TB bit corresponding
508 * to watchdog will toggle from 0 to 1.
513 wdt_ticks
+= wdt_tb
- (tb
& (wdt_tb
- 1));
515 /* Convert timebase ticks to jiffies */
516 nr_jiffies
= wdt_ticks
;
518 if (do_div(nr_jiffies
, tb_ticks_per_jiffy
))
521 return min_t(unsigned long long, nr_jiffies
, NEXT_TIMER_MAX_DELTA
);
524 static void arm_next_watchdog(struct kvm_vcpu
*vcpu
)
526 unsigned long nr_jiffies
;
530 * If TSR_ENW and TSR_WIS are not set then no need to exit to
531 * userspace, so clear the KVM_REQ_WATCHDOG request.
533 if ((vcpu
->arch
.tsr
& (TSR_ENW
| TSR_WIS
)) != (TSR_ENW
| TSR_WIS
))
534 clear_bit(KVM_REQ_WATCHDOG
, &vcpu
->requests
);
536 spin_lock_irqsave(&vcpu
->arch
.wdt_lock
, flags
);
537 nr_jiffies
= watchdog_next_timeout(vcpu
);
539 * If the number of jiffies of watchdog timer >= NEXT_TIMER_MAX_DELTA
540 * then do not run the watchdog timer as this can break timer APIs.
542 if (nr_jiffies
< NEXT_TIMER_MAX_DELTA
)
543 mod_timer(&vcpu
->arch
.wdt_timer
, jiffies
+ nr_jiffies
);
545 del_timer(&vcpu
->arch
.wdt_timer
);
546 spin_unlock_irqrestore(&vcpu
->arch
.wdt_lock
, flags
);
549 void kvmppc_watchdog_func(unsigned long data
)
551 struct kvm_vcpu
*vcpu
= (struct kvm_vcpu
*)data
;
556 new_tsr
= tsr
= vcpu
->arch
.tsr
;
564 new_tsr
= tsr
| TSR_WIS
;
566 new_tsr
= tsr
| TSR_ENW
;
568 } while (cmpxchg(&vcpu
->arch
.tsr
, tsr
, new_tsr
) != tsr
);
570 if (new_tsr
& TSR_WIS
) {
572 kvm_make_request(KVM_REQ_PENDING_TIMER
, vcpu
);
577 * If this is final watchdog expiry and some action is required
578 * then exit to userspace.
580 if (final
&& (vcpu
->arch
.tcr
& TCR_WRC_MASK
) &&
581 vcpu
->arch
.watchdog_enabled
) {
583 kvm_make_request(KVM_REQ_WATCHDOG
, vcpu
);
588 * Stop running the watchdog timer after final expiration to
589 * prevent the host from being flooded with timers if the
590 * guest sets a short period.
591 * Timers will resume when TSR/TCR is updated next time.
594 arm_next_watchdog(vcpu
);
597 static void update_timer_ints(struct kvm_vcpu
*vcpu
)
599 if ((vcpu
->arch
.tcr
& TCR_DIE
) && (vcpu
->arch
.tsr
& TSR_DIS
))
600 kvmppc_core_queue_dec(vcpu
);
602 kvmppc_core_dequeue_dec(vcpu
);
604 if ((vcpu
->arch
.tcr
& TCR_WIE
) && (vcpu
->arch
.tsr
& TSR_WIS
))
605 kvmppc_core_queue_watchdog(vcpu
);
607 kvmppc_core_dequeue_watchdog(vcpu
);
610 static void kvmppc_core_check_exceptions(struct kvm_vcpu
*vcpu
)
612 unsigned long *pending
= &vcpu
->arch
.pending_exceptions
;
613 unsigned int priority
;
615 priority
= __ffs(*pending
);
616 while (priority
< BOOKE_IRQPRIO_MAX
) {
617 if (kvmppc_booke_irqprio_deliver(vcpu
, priority
))
620 priority
= find_next_bit(pending
,
621 BITS_PER_BYTE
* sizeof(*pending
),
625 /* Tell the guest about our interrupt status */
626 vcpu
->arch
.shared
->int_pending
= !!*pending
;
629 /* Check pending exceptions and deliver one, if possible. */
630 int kvmppc_core_prepare_to_enter(struct kvm_vcpu
*vcpu
)
633 WARN_ON_ONCE(!irqs_disabled());
635 kvmppc_core_check_exceptions(vcpu
);
637 if (vcpu
->requests
) {
638 /* Exception delivery raised request; start over */
642 if (vcpu
->arch
.shared
->msr
& MSR_WE
) {
644 kvm_vcpu_block(vcpu
);
645 clear_bit(KVM_REQ_UNHALT
, &vcpu
->requests
);
648 kvmppc_set_exit_type(vcpu
, EMULATED_MTMSRWE_EXITS
);
655 int kvmppc_core_check_requests(struct kvm_vcpu
*vcpu
)
657 int r
= 1; /* Indicate we want to get back into the guest */
659 if (kvm_check_request(KVM_REQ_PENDING_TIMER
, vcpu
))
660 update_timer_ints(vcpu
);
661 #if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC)
662 if (kvm_check_request(KVM_REQ_TLB_FLUSH
, vcpu
))
663 kvmppc_core_flush_tlb(vcpu
);
666 if (kvm_check_request(KVM_REQ_WATCHDOG
, vcpu
)) {
667 vcpu
->run
->exit_reason
= KVM_EXIT_WATCHDOG
;
671 if (kvm_check_request(KVM_REQ_EPR_EXIT
, vcpu
)) {
672 vcpu
->run
->epr
.epr
= 0;
673 vcpu
->arch
.epr_needed
= true;
674 vcpu
->run
->exit_reason
= KVM_EXIT_EPR
;
681 int kvmppc_vcpu_run(struct kvm_run
*kvm_run
, struct kvm_vcpu
*vcpu
)
684 struct thread_struct thread
;
685 #ifdef CONFIG_PPC_FPU
686 struct thread_fp_state fp
;
690 if (!vcpu
->arch
.sane
) {
691 kvm_run
->exit_reason
= KVM_EXIT_INTERNAL_ERROR
;
696 s
= kvmppc_prepare_to_enter(vcpu
);
703 #ifdef CONFIG_PPC_FPU
704 /* Save userspace FPU state in stack */
706 fp
= current
->thread
.fp_state
;
707 fpexc_mode
= current
->thread
.fpexc_mode
;
709 /* Restore guest FPU state to thread */
710 memcpy(current
->thread
.fp_state
.fpr
, vcpu
->arch
.fpr
,
711 sizeof(vcpu
->arch
.fpr
));
712 current
->thread
.fp_state
.fpscr
= vcpu
->arch
.fpscr
;
715 * Since we can't trap on MSR_FP in GS-mode, we consider the guest
716 * as always using the FPU. Kernel usage of FP (via
717 * enable_kernel_fp()) in this thread must not occur while
718 * vcpu->fpu_active is set.
720 vcpu
->fpu_active
= 1;
722 kvmppc_load_guest_fp(vcpu
);
725 /* Switch to guest debug context */
726 thread
.debug
= vcpu
->arch
.shadow_dbg_reg
;
727 switch_booke_debug_regs(&thread
);
728 thread
.debug
= current
->thread
.debug
;
729 current
->thread
.debug
= vcpu
->arch
.shadow_dbg_reg
;
731 kvmppc_fix_ee_before_entry();
733 ret
= __kvmppc_vcpu_run(kvm_run
, vcpu
);
735 /* No need for kvm_guest_exit. It's done in handle_exit.
736 We also get here with interrupts enabled. */
738 /* Switch back to user space debug context */
739 switch_booke_debug_regs(&thread
);
740 current
->thread
.debug
= thread
.debug
;
742 #ifdef CONFIG_PPC_FPU
743 kvmppc_save_guest_fp(vcpu
);
745 vcpu
->fpu_active
= 0;
747 /* Save guest FPU state from thread */
748 memcpy(vcpu
->arch
.fpr
, current
->thread
.fp_state
.fpr
,
749 sizeof(vcpu
->arch
.fpr
));
750 vcpu
->arch
.fpscr
= current
->thread
.fp_state
.fpscr
;
752 /* Restore userspace FPU state from stack */
753 current
->thread
.fp_state
= fp
;
754 current
->thread
.fpexc_mode
= fpexc_mode
;
758 vcpu
->mode
= OUTSIDE_GUEST_MODE
;
762 static int emulation_exit(struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
764 enum emulation_result er
;
766 er
= kvmppc_emulate_instruction(run
, vcpu
);
769 /* don't overwrite subtypes, just account kvm_stats */
770 kvmppc_account_exit_stat(vcpu
, EMULATED_INST_EXITS
);
771 /* Future optimization: only reload non-volatiles if
772 * they were actually modified by emulation. */
773 return RESUME_GUEST_NV
;
776 run
->exit_reason
= KVM_EXIT_DCR
;
780 printk(KERN_CRIT
"%s: emulation at %lx failed (%08x)\n",
781 __func__
, vcpu
->arch
.pc
, vcpu
->arch
.last_inst
);
782 /* For debugging, encode the failing instruction and
783 * report it to userspace. */
784 run
->hw
.hardware_exit_reason
= ~0ULL << 32;
785 run
->hw
.hardware_exit_reason
|= vcpu
->arch
.last_inst
;
786 kvmppc_core_queue_program(vcpu
, ESR_PIL
);
789 case EMULATE_EXIT_USER
:
797 static int kvmppc_handle_debug(struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
799 struct debug_reg
*dbg_reg
= &(vcpu
->arch
.shadow_dbg_reg
);
800 u32 dbsr
= vcpu
->arch
.dbsr
;
802 run
->debug
.arch
.status
= 0;
803 run
->debug
.arch
.address
= vcpu
->arch
.pc
;
805 if (dbsr
& (DBSR_IAC1
| DBSR_IAC2
| DBSR_IAC3
| DBSR_IAC4
)) {
806 run
->debug
.arch
.status
|= KVMPPC_DEBUG_BREAKPOINT
;
808 if (dbsr
& (DBSR_DAC1W
| DBSR_DAC2W
))
809 run
->debug
.arch
.status
|= KVMPPC_DEBUG_WATCH_WRITE
;
810 else if (dbsr
& (DBSR_DAC1R
| DBSR_DAC2R
))
811 run
->debug
.arch
.status
|= KVMPPC_DEBUG_WATCH_READ
;
812 if (dbsr
& (DBSR_DAC1R
| DBSR_DAC1W
))
813 run
->debug
.arch
.address
= dbg_reg
->dac1
;
814 else if (dbsr
& (DBSR_DAC2R
| DBSR_DAC2W
))
815 run
->debug
.arch
.address
= dbg_reg
->dac2
;
821 static void kvmppc_fill_pt_regs(struct pt_regs
*regs
)
823 ulong r1
, ip
, msr
, lr
;
825 asm("mr %0, 1" : "=r"(r1
));
826 asm("mflr %0" : "=r"(lr
));
827 asm("mfmsr %0" : "=r"(msr
));
828 asm("bl 1f; 1: mflr %0" : "=r"(ip
));
830 memset(regs
, 0, sizeof(*regs
));
838 * For interrupts needed to be handled by host interrupt handlers,
839 * corresponding host handler are called from here in similar way
840 * (but not exact) as they are called from low level handler
841 * (such as from arch/powerpc/kernel/head_fsl_booke.S).
843 static void kvmppc_restart_interrupt(struct kvm_vcpu
*vcpu
,
844 unsigned int exit_nr
)
849 case BOOKE_INTERRUPT_EXTERNAL
:
850 kvmppc_fill_pt_regs(®s
);
853 case BOOKE_INTERRUPT_DECREMENTER
:
854 kvmppc_fill_pt_regs(®s
);
855 timer_interrupt(®s
);
857 #if defined(CONFIG_PPC_DOORBELL)
858 case BOOKE_INTERRUPT_DOORBELL
:
859 kvmppc_fill_pt_regs(®s
);
860 doorbell_exception(®s
);
863 case BOOKE_INTERRUPT_MACHINE_CHECK
:
866 case BOOKE_INTERRUPT_PERFORMANCE_MONITOR
:
867 kvmppc_fill_pt_regs(®s
);
868 performance_monitor_exception(®s
);
870 case BOOKE_INTERRUPT_WATCHDOG
:
871 kvmppc_fill_pt_regs(®s
);
872 #ifdef CONFIG_BOOKE_WDT
873 WatchdogException(®s
);
875 unknown_exception(®s
);
878 case BOOKE_INTERRUPT_CRITICAL
:
879 unknown_exception(®s
);
881 case BOOKE_INTERRUPT_DEBUG
:
882 /* Save DBSR before preemption is enabled */
883 vcpu
->arch
.dbsr
= mfspr(SPRN_DBSR
);
892 * Return value is in the form (errcode<<2 | RESUME_FLAG_HOST | RESUME_FLAG_NV)
894 int kvmppc_handle_exit(struct kvm_run
*run
, struct kvm_vcpu
*vcpu
,
895 unsigned int exit_nr
)
902 WARN_ON(local_paca
->irq_happened
!= 0);
906 * We enter with interrupts disabled in hardware, but
907 * we need to call hard_irq_disable anyway to ensure that
908 * the software state is kept in sync.
912 /* update before a new last_exit_type is rewritten */
913 kvmppc_update_timing_stats(vcpu
);
915 /* restart interrupts if they were meant for the host */
916 kvmppc_restart_interrupt(vcpu
, exit_nr
);
920 trace_kvm_exit(exit_nr
, vcpu
);
923 run
->exit_reason
= KVM_EXIT_UNKNOWN
;
924 run
->ready_for_interrupt_injection
= 1;
927 case BOOKE_INTERRUPT_MACHINE_CHECK
:
928 printk("MACHINE CHECK: %lx\n", mfspr(SPRN_MCSR
));
929 kvmppc_dump_vcpu(vcpu
);
930 /* For debugging, send invalid exit reason to user space */
931 run
->hw
.hardware_exit_reason
= ~1ULL << 32;
932 run
->hw
.hardware_exit_reason
|= mfspr(SPRN_MCSR
);
936 case BOOKE_INTERRUPT_EXTERNAL
:
937 kvmppc_account_exit(vcpu
, EXT_INTR_EXITS
);
941 case BOOKE_INTERRUPT_DECREMENTER
:
942 kvmppc_account_exit(vcpu
, DEC_EXITS
);
946 case BOOKE_INTERRUPT_WATCHDOG
:
950 case BOOKE_INTERRUPT_DOORBELL
:
951 kvmppc_account_exit(vcpu
, DBELL_EXITS
);
955 case BOOKE_INTERRUPT_GUEST_DBELL_CRIT
:
956 kvmppc_account_exit(vcpu
, GDBELL_EXITS
);
959 * We are here because there is a pending guest interrupt
960 * which could not be delivered as MSR_CE or MSR_ME was not
961 * set. Once we break from here we will retry delivery.
966 case BOOKE_INTERRUPT_GUEST_DBELL
:
967 kvmppc_account_exit(vcpu
, GDBELL_EXITS
);
970 * We are here because there is a pending guest interrupt
971 * which could not be delivered as MSR_EE was not set. Once
972 * we break from here we will retry delivery.
977 case BOOKE_INTERRUPT_PERFORMANCE_MONITOR
:
981 case BOOKE_INTERRUPT_HV_PRIV
:
982 r
= emulation_exit(run
, vcpu
);
985 case BOOKE_INTERRUPT_PROGRAM
:
986 if (vcpu
->arch
.shared
->msr
& (MSR_PR
| MSR_GS
)) {
988 * Program traps generated by user-level software must
989 * be handled by the guest kernel.
991 * In GS mode, hypervisor privileged instructions trap
992 * on BOOKE_INTERRUPT_HV_PRIV, not here, so these are
993 * actual program interrupts, handled by the guest.
995 kvmppc_core_queue_program(vcpu
, vcpu
->arch
.fault_esr
);
997 kvmppc_account_exit(vcpu
, USR_PR_INST
);
1001 r
= emulation_exit(run
, vcpu
);
1004 case BOOKE_INTERRUPT_FP_UNAVAIL
:
1005 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_FP_UNAVAIL
);
1006 kvmppc_account_exit(vcpu
, FP_UNAVAIL
);
1011 case BOOKE_INTERRUPT_SPE_UNAVAIL
: {
1012 if (vcpu
->arch
.shared
->msr
& MSR_SPE
)
1013 kvmppc_vcpu_enable_spe(vcpu
);
1015 kvmppc_booke_queue_irqprio(vcpu
,
1016 BOOKE_IRQPRIO_SPE_UNAVAIL
);
1021 case BOOKE_INTERRUPT_SPE_FP_DATA
:
1022 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_SPE_FP_DATA
);
1026 case BOOKE_INTERRUPT_SPE_FP_ROUND
:
1027 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_SPE_FP_ROUND
);
1031 case BOOKE_INTERRUPT_SPE_UNAVAIL
:
1033 * Guest wants SPE, but host kernel doesn't support it. Send
1034 * an "unimplemented operation" program check to the guest.
1036 kvmppc_core_queue_program(vcpu
, ESR_PUO
| ESR_SPV
);
1041 * These really should never happen without CONFIG_SPE,
1042 * as we should never enable the real MSR[SPE] in the guest.
1044 case BOOKE_INTERRUPT_SPE_FP_DATA
:
1045 case BOOKE_INTERRUPT_SPE_FP_ROUND
:
1046 printk(KERN_CRIT
"%s: unexpected SPE interrupt %u at %08lx\n",
1047 __func__
, exit_nr
, vcpu
->arch
.pc
);
1048 run
->hw
.hardware_exit_reason
= exit_nr
;
1053 case BOOKE_INTERRUPT_DATA_STORAGE
:
1054 kvmppc_core_queue_data_storage(vcpu
, vcpu
->arch
.fault_dear
,
1055 vcpu
->arch
.fault_esr
);
1056 kvmppc_account_exit(vcpu
, DSI_EXITS
);
1060 case BOOKE_INTERRUPT_INST_STORAGE
:
1061 kvmppc_core_queue_inst_storage(vcpu
, vcpu
->arch
.fault_esr
);
1062 kvmppc_account_exit(vcpu
, ISI_EXITS
);
1066 case BOOKE_INTERRUPT_ALIGNMENT
:
1067 kvmppc_core_queue_alignment(vcpu
, vcpu
->arch
.fault_dear
,
1068 vcpu
->arch
.fault_esr
);
1072 #ifdef CONFIG_KVM_BOOKE_HV
1073 case BOOKE_INTERRUPT_HV_SYSCALL
:
1074 if (!(vcpu
->arch
.shared
->msr
& MSR_PR
)) {
1075 kvmppc_set_gpr(vcpu
, 3, kvmppc_kvm_pv(vcpu
));
1078 * hcall from guest userspace -- send privileged
1079 * instruction program check.
1081 kvmppc_core_queue_program(vcpu
, ESR_PPR
);
1087 case BOOKE_INTERRUPT_SYSCALL
:
1088 if (!(vcpu
->arch
.shared
->msr
& MSR_PR
) &&
1089 (((u32
)kvmppc_get_gpr(vcpu
, 0)) == KVM_SC_MAGIC_R0
)) {
1090 /* KVM PV hypercalls */
1091 kvmppc_set_gpr(vcpu
, 3, kvmppc_kvm_pv(vcpu
));
1094 /* Guest syscalls */
1095 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_SYSCALL
);
1097 kvmppc_account_exit(vcpu
, SYSCALL_EXITS
);
1102 case BOOKE_INTERRUPT_DTLB_MISS
: {
1103 unsigned long eaddr
= vcpu
->arch
.fault_dear
;
1108 #ifdef CONFIG_KVM_E500V2
1109 if (!(vcpu
->arch
.shared
->msr
& MSR_PR
) &&
1110 (eaddr
& PAGE_MASK
) == vcpu
->arch
.magic_page_ea
) {
1111 kvmppc_map_magic(vcpu
);
1112 kvmppc_account_exit(vcpu
, DTLB_VIRT_MISS_EXITS
);
1119 /* Check the guest TLB. */
1120 gtlb_index
= kvmppc_mmu_dtlb_index(vcpu
, eaddr
);
1121 if (gtlb_index
< 0) {
1122 /* The guest didn't have a mapping for it. */
1123 kvmppc_core_queue_dtlb_miss(vcpu
,
1124 vcpu
->arch
.fault_dear
,
1125 vcpu
->arch
.fault_esr
);
1126 kvmppc_mmu_dtlb_miss(vcpu
);
1127 kvmppc_account_exit(vcpu
, DTLB_REAL_MISS_EXITS
);
1132 idx
= srcu_read_lock(&vcpu
->kvm
->srcu
);
1134 gpaddr
= kvmppc_mmu_xlate(vcpu
, gtlb_index
, eaddr
);
1135 gfn
= gpaddr
>> PAGE_SHIFT
;
1137 if (kvm_is_visible_gfn(vcpu
->kvm
, gfn
)) {
1138 /* The guest TLB had a mapping, but the shadow TLB
1139 * didn't, and it is RAM. This could be because:
1140 * a) the entry is mapping the host kernel, or
1141 * b) the guest used a large mapping which we're faking
1142 * Either way, we need to satisfy the fault without
1143 * invoking the guest. */
1144 kvmppc_mmu_map(vcpu
, eaddr
, gpaddr
, gtlb_index
);
1145 kvmppc_account_exit(vcpu
, DTLB_VIRT_MISS_EXITS
);
1148 /* Guest has mapped and accessed a page which is not
1150 vcpu
->arch
.paddr_accessed
= gpaddr
;
1151 vcpu
->arch
.vaddr_accessed
= eaddr
;
1152 r
= kvmppc_emulate_mmio(run
, vcpu
);
1153 kvmppc_account_exit(vcpu
, MMIO_EXITS
);
1156 srcu_read_unlock(&vcpu
->kvm
->srcu
, idx
);
1160 case BOOKE_INTERRUPT_ITLB_MISS
: {
1161 unsigned long eaddr
= vcpu
->arch
.pc
;
1168 /* Check the guest TLB. */
1169 gtlb_index
= kvmppc_mmu_itlb_index(vcpu
, eaddr
);
1170 if (gtlb_index
< 0) {
1171 /* The guest didn't have a mapping for it. */
1172 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_ITLB_MISS
);
1173 kvmppc_mmu_itlb_miss(vcpu
);
1174 kvmppc_account_exit(vcpu
, ITLB_REAL_MISS_EXITS
);
1178 kvmppc_account_exit(vcpu
, ITLB_VIRT_MISS_EXITS
);
1180 idx
= srcu_read_lock(&vcpu
->kvm
->srcu
);
1182 gpaddr
= kvmppc_mmu_xlate(vcpu
, gtlb_index
, eaddr
);
1183 gfn
= gpaddr
>> PAGE_SHIFT
;
1185 if (kvm_is_visible_gfn(vcpu
->kvm
, gfn
)) {
1186 /* The guest TLB had a mapping, but the shadow TLB
1187 * didn't. This could be because:
1188 * a) the entry is mapping the host kernel, or
1189 * b) the guest used a large mapping which we're faking
1190 * Either way, we need to satisfy the fault without
1191 * invoking the guest. */
1192 kvmppc_mmu_map(vcpu
, eaddr
, gpaddr
, gtlb_index
);
1194 /* Guest mapped and leaped at non-RAM! */
1195 kvmppc_booke_queue_irqprio(vcpu
, BOOKE_IRQPRIO_MACHINE_CHECK
);
1198 srcu_read_unlock(&vcpu
->kvm
->srcu
, idx
);
1202 case BOOKE_INTERRUPT_DEBUG
: {
1203 r
= kvmppc_handle_debug(run
, vcpu
);
1204 if (r
== RESUME_HOST
)
1205 run
->exit_reason
= KVM_EXIT_DEBUG
;
1206 kvmppc_account_exit(vcpu
, DEBUG_EXITS
);
1211 printk(KERN_EMERG
"exit_nr %d\n", exit_nr
);
1216 * To avoid clobbering exit_reason, only check for signals if we
1217 * aren't already exiting to userspace for some other reason.
1219 if (!(r
& RESUME_HOST
)) {
1220 local_irq_disable();
1221 s
= kvmppc_prepare_to_enter(vcpu
);
1224 r
= (s
<< 2) | RESUME_HOST
| (r
& RESUME_FLAG_NV
);
1226 kvmppc_fix_ee_before_entry();
1233 static void kvmppc_set_tsr(struct kvm_vcpu
*vcpu
, u32 new_tsr
)
1235 u32 old_tsr
= vcpu
->arch
.tsr
;
1237 vcpu
->arch
.tsr
= new_tsr
;
1239 if ((old_tsr
^ vcpu
->arch
.tsr
) & (TSR_ENW
| TSR_WIS
))
1240 arm_next_watchdog(vcpu
);
1242 update_timer_ints(vcpu
);
1245 /* Initial guest state: 16MB mapping 0 -> 0, PC = 0, MSR = 0, R1 = 16MB */
1246 int kvm_arch_vcpu_setup(struct kvm_vcpu
*vcpu
)
1252 vcpu
->arch
.shared
->pir
= vcpu
->vcpu_id
;
1253 kvmppc_set_gpr(vcpu
, 1, (16<<20) - 8); /* -8 for the callee-save LR slot */
1254 kvmppc_set_msr(vcpu
, 0);
1256 #ifndef CONFIG_KVM_BOOKE_HV
1257 vcpu
->arch
.shadow_msr
= MSR_USER
| MSR_IS
| MSR_DS
;
1258 vcpu
->arch
.shadow_pid
= 1;
1259 vcpu
->arch
.shared
->msr
= 0;
1262 /* Eye-catching numbers so we know if the guest takes an interrupt
1263 * before it's programmed its own IVPR/IVORs. */
1264 vcpu
->arch
.ivpr
= 0x55550000;
1265 for (i
= 0; i
< BOOKE_IRQPRIO_MAX
; i
++)
1266 vcpu
->arch
.ivor
[i
] = 0x7700 | i
* 4;
1268 kvmppc_init_timing_stats(vcpu
);
1270 r
= kvmppc_core_vcpu_setup(vcpu
);
1271 kvmppc_sanity_check(vcpu
);
1275 int kvmppc_subarch_vcpu_init(struct kvm_vcpu
*vcpu
)
1277 /* setup watchdog timer once */
1278 spin_lock_init(&vcpu
->arch
.wdt_lock
);
1279 setup_timer(&vcpu
->arch
.wdt_timer
, kvmppc_watchdog_func
,
1280 (unsigned long)vcpu
);
1285 void kvmppc_subarch_vcpu_uninit(struct kvm_vcpu
*vcpu
)
1287 del_timer_sync(&vcpu
->arch
.wdt_timer
);
1290 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu
*vcpu
, struct kvm_regs
*regs
)
1294 regs
->pc
= vcpu
->arch
.pc
;
1295 regs
->cr
= kvmppc_get_cr(vcpu
);
1296 regs
->ctr
= vcpu
->arch
.ctr
;
1297 regs
->lr
= vcpu
->arch
.lr
;
1298 regs
->xer
= kvmppc_get_xer(vcpu
);
1299 regs
->msr
= vcpu
->arch
.shared
->msr
;
1300 regs
->srr0
= vcpu
->arch
.shared
->srr0
;
1301 regs
->srr1
= vcpu
->arch
.shared
->srr1
;
1302 regs
->pid
= vcpu
->arch
.pid
;
1303 regs
->sprg0
= vcpu
->arch
.shared
->sprg0
;
1304 regs
->sprg1
= vcpu
->arch
.shared
->sprg1
;
1305 regs
->sprg2
= vcpu
->arch
.shared
->sprg2
;
1306 regs
->sprg3
= vcpu
->arch
.shared
->sprg3
;
1307 regs
->sprg4
= vcpu
->arch
.shared
->sprg4
;
1308 regs
->sprg5
= vcpu
->arch
.shared
->sprg5
;
1309 regs
->sprg6
= vcpu
->arch
.shared
->sprg6
;
1310 regs
->sprg7
= vcpu
->arch
.shared
->sprg7
;
1312 for (i
= 0; i
< ARRAY_SIZE(regs
->gpr
); i
++)
1313 regs
->gpr
[i
] = kvmppc_get_gpr(vcpu
, i
);
1318 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu
*vcpu
, struct kvm_regs
*regs
)
1322 vcpu
->arch
.pc
= regs
->pc
;
1323 kvmppc_set_cr(vcpu
, regs
->cr
);
1324 vcpu
->arch
.ctr
= regs
->ctr
;
1325 vcpu
->arch
.lr
= regs
->lr
;
1326 kvmppc_set_xer(vcpu
, regs
->xer
);
1327 kvmppc_set_msr(vcpu
, regs
->msr
);
1328 vcpu
->arch
.shared
->srr0
= regs
->srr0
;
1329 vcpu
->arch
.shared
->srr1
= regs
->srr1
;
1330 kvmppc_set_pid(vcpu
, regs
->pid
);
1331 vcpu
->arch
.shared
->sprg0
= regs
->sprg0
;
1332 vcpu
->arch
.shared
->sprg1
= regs
->sprg1
;
1333 vcpu
->arch
.shared
->sprg2
= regs
->sprg2
;
1334 vcpu
->arch
.shared
->sprg3
= regs
->sprg3
;
1335 vcpu
->arch
.shared
->sprg4
= regs
->sprg4
;
1336 vcpu
->arch
.shared
->sprg5
= regs
->sprg5
;
1337 vcpu
->arch
.shared
->sprg6
= regs
->sprg6
;
1338 vcpu
->arch
.shared
->sprg7
= regs
->sprg7
;
1340 for (i
= 0; i
< ARRAY_SIZE(regs
->gpr
); i
++)
1341 kvmppc_set_gpr(vcpu
, i
, regs
->gpr
[i
]);
1346 static void get_sregs_base(struct kvm_vcpu
*vcpu
,
1347 struct kvm_sregs
*sregs
)
1351 sregs
->u
.e
.features
|= KVM_SREGS_E_BASE
;
1353 sregs
->u
.e
.csrr0
= vcpu
->arch
.csrr0
;
1354 sregs
->u
.e
.csrr1
= vcpu
->arch
.csrr1
;
1355 sregs
->u
.e
.mcsr
= vcpu
->arch
.mcsr
;
1356 sregs
->u
.e
.esr
= get_guest_esr(vcpu
);
1357 sregs
->u
.e
.dear
= get_guest_dear(vcpu
);
1358 sregs
->u
.e
.tsr
= vcpu
->arch
.tsr
;
1359 sregs
->u
.e
.tcr
= vcpu
->arch
.tcr
;
1360 sregs
->u
.e
.dec
= kvmppc_get_dec(vcpu
, tb
);
1362 sregs
->u
.e
.vrsave
= vcpu
->arch
.vrsave
;
1365 static int set_sregs_base(struct kvm_vcpu
*vcpu
,
1366 struct kvm_sregs
*sregs
)
1368 if (!(sregs
->u
.e
.features
& KVM_SREGS_E_BASE
))
1371 vcpu
->arch
.csrr0
= sregs
->u
.e
.csrr0
;
1372 vcpu
->arch
.csrr1
= sregs
->u
.e
.csrr1
;
1373 vcpu
->arch
.mcsr
= sregs
->u
.e
.mcsr
;
1374 set_guest_esr(vcpu
, sregs
->u
.e
.esr
);
1375 set_guest_dear(vcpu
, sregs
->u
.e
.dear
);
1376 vcpu
->arch
.vrsave
= sregs
->u
.e
.vrsave
;
1377 kvmppc_set_tcr(vcpu
, sregs
->u
.e
.tcr
);
1379 if (sregs
->u
.e
.update_special
& KVM_SREGS_E_UPDATE_DEC
) {
1380 vcpu
->arch
.dec
= sregs
->u
.e
.dec
;
1381 kvmppc_emulate_dec(vcpu
);
1384 if (sregs
->u
.e
.update_special
& KVM_SREGS_E_UPDATE_TSR
)
1385 kvmppc_set_tsr(vcpu
, sregs
->u
.e
.tsr
);
1390 static void get_sregs_arch206(struct kvm_vcpu
*vcpu
,
1391 struct kvm_sregs
*sregs
)
1393 sregs
->u
.e
.features
|= KVM_SREGS_E_ARCH206
;
1395 sregs
->u
.e
.pir
= vcpu
->vcpu_id
;
1396 sregs
->u
.e
.mcsrr0
= vcpu
->arch
.mcsrr0
;
1397 sregs
->u
.e
.mcsrr1
= vcpu
->arch
.mcsrr1
;
1398 sregs
->u
.e
.decar
= vcpu
->arch
.decar
;
1399 sregs
->u
.e
.ivpr
= vcpu
->arch
.ivpr
;
1402 static int set_sregs_arch206(struct kvm_vcpu
*vcpu
,
1403 struct kvm_sregs
*sregs
)
1405 if (!(sregs
->u
.e
.features
& KVM_SREGS_E_ARCH206
))
1408 if (sregs
->u
.e
.pir
!= vcpu
->vcpu_id
)
1411 vcpu
->arch
.mcsrr0
= sregs
->u
.e
.mcsrr0
;
1412 vcpu
->arch
.mcsrr1
= sregs
->u
.e
.mcsrr1
;
1413 vcpu
->arch
.decar
= sregs
->u
.e
.decar
;
1414 vcpu
->arch
.ivpr
= sregs
->u
.e
.ivpr
;
1419 int kvmppc_get_sregs_ivor(struct kvm_vcpu
*vcpu
, struct kvm_sregs
*sregs
)
1421 sregs
->u
.e
.features
|= KVM_SREGS_E_IVOR
;
1423 sregs
->u
.e
.ivor_low
[0] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_CRITICAL
];
1424 sregs
->u
.e
.ivor_low
[1] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_MACHINE_CHECK
];
1425 sregs
->u
.e
.ivor_low
[2] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_DATA_STORAGE
];
1426 sregs
->u
.e
.ivor_low
[3] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_INST_STORAGE
];
1427 sregs
->u
.e
.ivor_low
[4] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_EXTERNAL
];
1428 sregs
->u
.e
.ivor_low
[5] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_ALIGNMENT
];
1429 sregs
->u
.e
.ivor_low
[6] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_PROGRAM
];
1430 sregs
->u
.e
.ivor_low
[7] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_FP_UNAVAIL
];
1431 sregs
->u
.e
.ivor_low
[8] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_SYSCALL
];
1432 sregs
->u
.e
.ivor_low
[9] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_AP_UNAVAIL
];
1433 sregs
->u
.e
.ivor_low
[10] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_DECREMENTER
];
1434 sregs
->u
.e
.ivor_low
[11] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_FIT
];
1435 sregs
->u
.e
.ivor_low
[12] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_WATCHDOG
];
1436 sregs
->u
.e
.ivor_low
[13] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_DTLB_MISS
];
1437 sregs
->u
.e
.ivor_low
[14] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_ITLB_MISS
];
1438 sregs
->u
.e
.ivor_low
[15] = vcpu
->arch
.ivor
[BOOKE_IRQPRIO_DEBUG
];
1442 int kvmppc_set_sregs_ivor(struct kvm_vcpu
*vcpu
, struct kvm_sregs
*sregs
)
1444 if (!(sregs
->u
.e
.features
& KVM_SREGS_E_IVOR
))
1447 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_CRITICAL
] = sregs
->u
.e
.ivor_low
[0];
1448 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_MACHINE_CHECK
] = sregs
->u
.e
.ivor_low
[1];
1449 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_DATA_STORAGE
] = sregs
->u
.e
.ivor_low
[2];
1450 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_INST_STORAGE
] = sregs
->u
.e
.ivor_low
[3];
1451 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_EXTERNAL
] = sregs
->u
.e
.ivor_low
[4];
1452 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_ALIGNMENT
] = sregs
->u
.e
.ivor_low
[5];
1453 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_PROGRAM
] = sregs
->u
.e
.ivor_low
[6];
1454 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_FP_UNAVAIL
] = sregs
->u
.e
.ivor_low
[7];
1455 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_SYSCALL
] = sregs
->u
.e
.ivor_low
[8];
1456 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_AP_UNAVAIL
] = sregs
->u
.e
.ivor_low
[9];
1457 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_DECREMENTER
] = sregs
->u
.e
.ivor_low
[10];
1458 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_FIT
] = sregs
->u
.e
.ivor_low
[11];
1459 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_WATCHDOG
] = sregs
->u
.e
.ivor_low
[12];
1460 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_DTLB_MISS
] = sregs
->u
.e
.ivor_low
[13];
1461 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_ITLB_MISS
] = sregs
->u
.e
.ivor_low
[14];
1462 vcpu
->arch
.ivor
[BOOKE_IRQPRIO_DEBUG
] = sregs
->u
.e
.ivor_low
[15];
1467 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu
*vcpu
,
1468 struct kvm_sregs
*sregs
)
1470 sregs
->pvr
= vcpu
->arch
.pvr
;
1472 get_sregs_base(vcpu
, sregs
);
1473 get_sregs_arch206(vcpu
, sregs
);
1474 return vcpu
->kvm
->arch
.kvm_ops
->get_sregs(vcpu
, sregs
);
1477 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu
*vcpu
,
1478 struct kvm_sregs
*sregs
)
1482 if (vcpu
->arch
.pvr
!= sregs
->pvr
)
1485 ret
= set_sregs_base(vcpu
, sregs
);
1489 ret
= set_sregs_arch206(vcpu
, sregs
);
1493 return vcpu
->kvm
->arch
.kvm_ops
->set_sregs(vcpu
, sregs
);
1496 int kvm_vcpu_ioctl_get_one_reg(struct kvm_vcpu
*vcpu
, struct kvm_one_reg
*reg
)
1499 union kvmppc_one_reg val
;
1502 size
= one_reg_size(reg
->id
);
1503 if (size
> sizeof(val
))
1507 case KVM_REG_PPC_IAC1
:
1508 val
= get_reg_val(reg
->id
, vcpu
->arch
.dbg_reg
.iac1
);
1510 case KVM_REG_PPC_IAC2
:
1511 val
= get_reg_val(reg
->id
, vcpu
->arch
.dbg_reg
.iac2
);
1513 #if CONFIG_PPC_ADV_DEBUG_IACS > 2
1514 case KVM_REG_PPC_IAC3
:
1515 val
= get_reg_val(reg
->id
, vcpu
->arch
.dbg_reg
.iac3
);
1517 case KVM_REG_PPC_IAC4
:
1518 val
= get_reg_val(reg
->id
, vcpu
->arch
.dbg_reg
.iac4
);
1521 case KVM_REG_PPC_DAC1
:
1522 val
= get_reg_val(reg
->id
, vcpu
->arch
.dbg_reg
.dac1
);
1524 case KVM_REG_PPC_DAC2
:
1525 val
= get_reg_val(reg
->id
, vcpu
->arch
.dbg_reg
.dac2
);
1527 case KVM_REG_PPC_EPR
: {
1528 u32 epr
= get_guest_epr(vcpu
);
1529 val
= get_reg_val(reg
->id
, epr
);
1532 #if defined(CONFIG_64BIT)
1533 case KVM_REG_PPC_EPCR
:
1534 val
= get_reg_val(reg
->id
, vcpu
->arch
.epcr
);
1537 case KVM_REG_PPC_TCR
:
1538 val
= get_reg_val(reg
->id
, vcpu
->arch
.tcr
);
1540 case KVM_REG_PPC_TSR
:
1541 val
= get_reg_val(reg
->id
, vcpu
->arch
.tsr
);
1543 case KVM_REG_PPC_DEBUG_INST
:
1544 val
= get_reg_val(reg
->id
, KVMPPC_INST_EHPRIV_DEBUG
);
1546 case KVM_REG_PPC_VRSAVE
:
1547 val
= get_reg_val(reg
->id
, vcpu
->arch
.vrsave
);
1550 r
= vcpu
->kvm
->arch
.kvm_ops
->get_one_reg(vcpu
, reg
->id
, &val
);
1557 if (copy_to_user((char __user
*)(unsigned long)reg
->addr
, &val
, size
))
1563 int kvm_vcpu_ioctl_set_one_reg(struct kvm_vcpu
*vcpu
, struct kvm_one_reg
*reg
)
1566 union kvmppc_one_reg val
;
1569 size
= one_reg_size(reg
->id
);
1570 if (size
> sizeof(val
))
1573 if (copy_from_user(&val
, (char __user
*)(unsigned long)reg
->addr
, size
))
1577 case KVM_REG_PPC_IAC1
:
1578 vcpu
->arch
.dbg_reg
.iac1
= set_reg_val(reg
->id
, val
);
1580 case KVM_REG_PPC_IAC2
:
1581 vcpu
->arch
.dbg_reg
.iac2
= set_reg_val(reg
->id
, val
);
1583 #if CONFIG_PPC_ADV_DEBUG_IACS > 2
1584 case KVM_REG_PPC_IAC3
:
1585 vcpu
->arch
.dbg_reg
.iac3
= set_reg_val(reg
->id
, val
);
1587 case KVM_REG_PPC_IAC4
:
1588 vcpu
->arch
.dbg_reg
.iac4
= set_reg_val(reg
->id
, val
);
1591 case KVM_REG_PPC_DAC1
:
1592 vcpu
->arch
.dbg_reg
.dac1
= set_reg_val(reg
->id
, val
);
1594 case KVM_REG_PPC_DAC2
:
1595 vcpu
->arch
.dbg_reg
.dac2
= set_reg_val(reg
->id
, val
);
1597 case KVM_REG_PPC_EPR
: {
1598 u32 new_epr
= set_reg_val(reg
->id
, val
);
1599 kvmppc_set_epr(vcpu
, new_epr
);
1602 #if defined(CONFIG_64BIT)
1603 case KVM_REG_PPC_EPCR
: {
1604 u32 new_epcr
= set_reg_val(reg
->id
, val
);
1605 kvmppc_set_epcr(vcpu
, new_epcr
);
1609 case KVM_REG_PPC_OR_TSR
: {
1610 u32 tsr_bits
= set_reg_val(reg
->id
, val
);
1611 kvmppc_set_tsr_bits(vcpu
, tsr_bits
);
1614 case KVM_REG_PPC_CLEAR_TSR
: {
1615 u32 tsr_bits
= set_reg_val(reg
->id
, val
);
1616 kvmppc_clr_tsr_bits(vcpu
, tsr_bits
);
1619 case KVM_REG_PPC_TSR
: {
1620 u32 tsr
= set_reg_val(reg
->id
, val
);
1621 kvmppc_set_tsr(vcpu
, tsr
);
1624 case KVM_REG_PPC_TCR
: {
1625 u32 tcr
= set_reg_val(reg
->id
, val
);
1626 kvmppc_set_tcr(vcpu
, tcr
);
1629 case KVM_REG_PPC_VRSAVE
:
1630 vcpu
->arch
.vrsave
= set_reg_val(reg
->id
, val
);
1633 r
= vcpu
->kvm
->arch
.kvm_ops
->set_one_reg(vcpu
, reg
->id
, &val
);
1640 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu
*vcpu
, struct kvm_fpu
*fpu
)
1645 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu
*vcpu
, struct kvm_fpu
*fpu
)
1650 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu
*vcpu
,
1651 struct kvm_translation
*tr
)
1655 r
= kvmppc_core_vcpu_translate(vcpu
, tr
);
1659 int kvm_vm_ioctl_get_dirty_log(struct kvm
*kvm
, struct kvm_dirty_log
*log
)
1664 void kvmppc_core_free_memslot(struct kvm
*kvm
, struct kvm_memory_slot
*free
,
1665 struct kvm_memory_slot
*dont
)
1669 int kvmppc_core_create_memslot(struct kvm
*kvm
, struct kvm_memory_slot
*slot
,
1670 unsigned long npages
)
1675 int kvmppc_core_prepare_memory_region(struct kvm
*kvm
,
1676 struct kvm_memory_slot
*memslot
,
1677 struct kvm_userspace_memory_region
*mem
)
1682 void kvmppc_core_commit_memory_region(struct kvm
*kvm
,
1683 struct kvm_userspace_memory_region
*mem
,
1684 const struct kvm_memory_slot
*old
)
1688 void kvmppc_core_flush_memslot(struct kvm
*kvm
, struct kvm_memory_slot
*memslot
)
1692 void kvmppc_set_epcr(struct kvm_vcpu
*vcpu
, u32 new_epcr
)
1694 #if defined(CONFIG_64BIT)
1695 vcpu
->arch
.epcr
= new_epcr
;
1696 #ifdef CONFIG_KVM_BOOKE_HV
1697 vcpu
->arch
.shadow_epcr
&= ~SPRN_EPCR_GICM
;
1698 if (vcpu
->arch
.epcr
& SPRN_EPCR_ICM
)
1699 vcpu
->arch
.shadow_epcr
|= SPRN_EPCR_GICM
;
1704 void kvmppc_set_tcr(struct kvm_vcpu
*vcpu
, u32 new_tcr
)
1706 vcpu
->arch
.tcr
= new_tcr
;
1707 arm_next_watchdog(vcpu
);
1708 update_timer_ints(vcpu
);
1711 void kvmppc_set_tsr_bits(struct kvm_vcpu
*vcpu
, u32 tsr_bits
)
1713 set_bits(tsr_bits
, &vcpu
->arch
.tsr
);
1715 kvm_make_request(KVM_REQ_PENDING_TIMER
, vcpu
);
1716 kvm_vcpu_kick(vcpu
);
1719 void kvmppc_clr_tsr_bits(struct kvm_vcpu
*vcpu
, u32 tsr_bits
)
1721 clear_bits(tsr_bits
, &vcpu
->arch
.tsr
);
1724 * We may have stopped the watchdog due to
1725 * being stuck on final expiration.
1727 if (tsr_bits
& (TSR_ENW
| TSR_WIS
))
1728 arm_next_watchdog(vcpu
);
1730 update_timer_ints(vcpu
);
1733 void kvmppc_decrementer_func(unsigned long data
)
1735 struct kvm_vcpu
*vcpu
= (struct kvm_vcpu
*)data
;
1737 if (vcpu
->arch
.tcr
& TCR_ARE
) {
1738 vcpu
->arch
.dec
= vcpu
->arch
.decar
;
1739 kvmppc_emulate_dec(vcpu
);
1742 kvmppc_set_tsr_bits(vcpu
, TSR_DIS
);
1745 static int kvmppc_booke_add_breakpoint(struct debug_reg
*dbg_reg
,
1746 uint64_t addr
, int index
)
1750 dbg_reg
->dbcr0
|= DBCR0_IAC1
;
1751 dbg_reg
->iac1
= addr
;
1754 dbg_reg
->dbcr0
|= DBCR0_IAC2
;
1755 dbg_reg
->iac2
= addr
;
1757 #if CONFIG_PPC_ADV_DEBUG_IACS > 2
1759 dbg_reg
->dbcr0
|= DBCR0_IAC3
;
1760 dbg_reg
->iac3
= addr
;
1763 dbg_reg
->dbcr0
|= DBCR0_IAC4
;
1764 dbg_reg
->iac4
= addr
;
1771 dbg_reg
->dbcr0
|= DBCR0_IDM
;
1775 static int kvmppc_booke_add_watchpoint(struct debug_reg
*dbg_reg
, uint64_t addr
,
1776 int type
, int index
)
1780 if (type
& KVMPPC_DEBUG_WATCH_READ
)
1781 dbg_reg
->dbcr0
|= DBCR0_DAC1R
;
1782 if (type
& KVMPPC_DEBUG_WATCH_WRITE
)
1783 dbg_reg
->dbcr0
|= DBCR0_DAC1W
;
1784 dbg_reg
->dac1
= addr
;
1787 if (type
& KVMPPC_DEBUG_WATCH_READ
)
1788 dbg_reg
->dbcr0
|= DBCR0_DAC2R
;
1789 if (type
& KVMPPC_DEBUG_WATCH_WRITE
)
1790 dbg_reg
->dbcr0
|= DBCR0_DAC2W
;
1791 dbg_reg
->dac2
= addr
;
1797 dbg_reg
->dbcr0
|= DBCR0_IDM
;
1800 void kvm_guest_protect_msr(struct kvm_vcpu
*vcpu
, ulong prot_bitmap
, bool set
)
1802 /* XXX: Add similar MSR protection for BookE-PR */
1803 #ifdef CONFIG_KVM_BOOKE_HV
1804 BUG_ON(prot_bitmap
& ~(MSRP_UCLEP
| MSRP_DEP
| MSRP_PMMP
));
1806 if (prot_bitmap
& MSR_UCLE
)
1807 vcpu
->arch
.shadow_msrp
|= MSRP_UCLEP
;
1808 if (prot_bitmap
& MSR_DE
)
1809 vcpu
->arch
.shadow_msrp
|= MSRP_DEP
;
1810 if (prot_bitmap
& MSR_PMM
)
1811 vcpu
->arch
.shadow_msrp
|= MSRP_PMMP
;
1813 if (prot_bitmap
& MSR_UCLE
)
1814 vcpu
->arch
.shadow_msrp
&= ~MSRP_UCLEP
;
1815 if (prot_bitmap
& MSR_DE
)
1816 vcpu
->arch
.shadow_msrp
&= ~MSRP_DEP
;
1817 if (prot_bitmap
& MSR_PMM
)
1818 vcpu
->arch
.shadow_msrp
&= ~MSRP_PMMP
;
1823 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu
*vcpu
,
1824 struct kvm_guest_debug
*dbg
)
1826 struct debug_reg
*dbg_reg
;
1827 int n
, b
= 0, w
= 0;
1829 if (!(dbg
->control
& KVM_GUESTDBG_ENABLE
)) {
1830 vcpu
->arch
.shadow_dbg_reg
.dbcr0
= 0;
1831 vcpu
->guest_debug
= 0;
1832 kvm_guest_protect_msr(vcpu
, MSR_DE
, false);
1836 kvm_guest_protect_msr(vcpu
, MSR_DE
, true);
1837 vcpu
->guest_debug
= dbg
->control
;
1838 vcpu
->arch
.shadow_dbg_reg
.dbcr0
= 0;
1839 /* Set DBCR0_EDM in guest visible DBCR0 register. */
1840 vcpu
->arch
.dbg_reg
.dbcr0
= DBCR0_EDM
;
1842 if (vcpu
->guest_debug
& KVM_GUESTDBG_SINGLESTEP
)
1843 vcpu
->arch
.shadow_dbg_reg
.dbcr0
|= DBCR0_IDM
| DBCR0_IC
;
1845 /* Code below handles only HW breakpoints */
1846 dbg_reg
= &(vcpu
->arch
.shadow_dbg_reg
);
1848 #ifdef CONFIG_KVM_BOOKE_HV
1850 * On BookE-HV (e500mc) the guest is always executed with MSR.GS=1
1851 * DBCR1 and DBCR2 are set to trigger debug events when MSR.PR is 0
1857 * On BookE-PR (e500v2) the guest is always executed with MSR.PR=1
1858 * We set DBCR1 and DBCR2 to only trigger debug events when MSR.PR
1861 dbg_reg
->dbcr1
= DBCR1_IAC1US
| DBCR1_IAC2US
| DBCR1_IAC3US
|
1863 dbg_reg
->dbcr2
= DBCR2_DAC1US
| DBCR2_DAC2US
;
1866 if (!(vcpu
->guest_debug
& KVM_GUESTDBG_USE_HW_BP
))
1869 for (n
= 0; n
< (KVMPPC_BOOKE_IAC_NUM
+ KVMPPC_BOOKE_DAC_NUM
); n
++) {
1870 uint64_t addr
= dbg
->arch
.bp
[n
].addr
;
1871 uint32_t type
= dbg
->arch
.bp
[n
].type
;
1873 if (type
== KVMPPC_DEBUG_NONE
)
1876 if (type
& !(KVMPPC_DEBUG_WATCH_READ
|
1877 KVMPPC_DEBUG_WATCH_WRITE
|
1878 KVMPPC_DEBUG_BREAKPOINT
))
1881 if (type
& KVMPPC_DEBUG_BREAKPOINT
) {
1882 /* Setting H/W breakpoint */
1883 if (kvmppc_booke_add_breakpoint(dbg_reg
, addr
, b
++))
1886 /* Setting H/W watchpoint */
1887 if (kvmppc_booke_add_watchpoint(dbg_reg
, addr
,
1896 void kvmppc_booke_vcpu_load(struct kvm_vcpu
*vcpu
, int cpu
)
1898 vcpu
->cpu
= smp_processor_id();
1899 current
->thread
.kvm_vcpu
= vcpu
;
1902 void kvmppc_booke_vcpu_put(struct kvm_vcpu
*vcpu
)
1904 current
->thread
.kvm_vcpu
= NULL
;
1907 /* Clear pending debug event in DBSR */
1908 kvmppc_clear_dbsr();
1911 void kvmppc_mmu_destroy(struct kvm_vcpu
*vcpu
)
1913 vcpu
->kvm
->arch
.kvm_ops
->mmu_destroy(vcpu
);
1916 int kvmppc_core_init_vm(struct kvm
*kvm
)
1918 return kvm
->arch
.kvm_ops
->init_vm(kvm
);
1921 struct kvm_vcpu
*kvmppc_core_vcpu_create(struct kvm
*kvm
, unsigned int id
)
1923 return kvm
->arch
.kvm_ops
->vcpu_create(kvm
, id
);
1926 void kvmppc_core_vcpu_free(struct kvm_vcpu
*vcpu
)
1928 vcpu
->kvm
->arch
.kvm_ops
->vcpu_free(vcpu
);
1931 void kvmppc_core_destroy_vm(struct kvm
*kvm
)
1933 kvm
->arch
.kvm_ops
->destroy_vm(kvm
);
1936 void kvmppc_core_vcpu_load(struct kvm_vcpu
*vcpu
, int cpu
)
1938 vcpu
->kvm
->arch
.kvm_ops
->vcpu_load(vcpu
, cpu
);
1941 void kvmppc_core_vcpu_put(struct kvm_vcpu
*vcpu
)
1943 vcpu
->kvm
->arch
.kvm_ops
->vcpu_put(vcpu
);
1946 int __init
kvmppc_booke_init(void)
1948 #ifndef CONFIG_KVM_BOOKE_HV
1949 unsigned long ivor
[16];
1950 unsigned long *handler
= kvmppc_booke_handler_addr
;
1951 unsigned long max_ivor
= 0;
1952 unsigned long handler_len
;
1955 /* We install our own exception handlers by hijacking IVPR. IVPR must
1956 * be 16-bit aligned, so we need a 64KB allocation. */
1957 kvmppc_booke_handlers
= __get_free_pages(GFP_KERNEL
| __GFP_ZERO
,
1959 if (!kvmppc_booke_handlers
)
1962 /* XXX make sure our handlers are smaller than Linux's */
1964 /* Copy our interrupt handlers to match host IVORs. That way we don't
1965 * have to swap the IVORs on every guest/host transition. */
1966 ivor
[0] = mfspr(SPRN_IVOR0
);
1967 ivor
[1] = mfspr(SPRN_IVOR1
);
1968 ivor
[2] = mfspr(SPRN_IVOR2
);
1969 ivor
[3] = mfspr(SPRN_IVOR3
);
1970 ivor
[4] = mfspr(SPRN_IVOR4
);
1971 ivor
[5] = mfspr(SPRN_IVOR5
);
1972 ivor
[6] = mfspr(SPRN_IVOR6
);
1973 ivor
[7] = mfspr(SPRN_IVOR7
);
1974 ivor
[8] = mfspr(SPRN_IVOR8
);
1975 ivor
[9] = mfspr(SPRN_IVOR9
);
1976 ivor
[10] = mfspr(SPRN_IVOR10
);
1977 ivor
[11] = mfspr(SPRN_IVOR11
);
1978 ivor
[12] = mfspr(SPRN_IVOR12
);
1979 ivor
[13] = mfspr(SPRN_IVOR13
);
1980 ivor
[14] = mfspr(SPRN_IVOR14
);
1981 ivor
[15] = mfspr(SPRN_IVOR15
);
1983 for (i
= 0; i
< 16; i
++) {
1984 if (ivor
[i
] > max_ivor
)
1987 handler_len
= handler
[i
+ 1] - handler
[i
];
1988 memcpy((void *)kvmppc_booke_handlers
+ ivor
[i
],
1989 (void *)handler
[i
], handler_len
);
1992 handler_len
= handler
[max_ivor
+ 1] - handler
[max_ivor
];
1993 flush_icache_range(kvmppc_booke_handlers
, kvmppc_booke_handlers
+
1994 ivor
[max_ivor
] + handler_len
);
1995 #endif /* !BOOKE_HV */
1999 void __exit
kvmppc_booke_exit(void)
2001 free_pages(kvmppc_booke_handlers
, VCPU_SIZE_ORDER
);