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
17 * Authors: Hollis Blanchard <hollisb@us.ibm.com>
18 * Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com>
21 #include <linux/errno.h>
22 #include <linux/err.h>
23 #include <linux/kvm_host.h>
24 #include <linux/module.h>
25 #include <linux/vmalloc.h>
26 #include <linux/hrtimer.h>
28 #include <linux/slab.h>
29 #include <asm/cputable.h>
30 #include <asm/uaccess.h>
31 #include <asm/kvm_ppc.h>
32 #include <asm/tlbflush.h>
34 #include "../mm/mmu_decl.h"
36 #define CREATE_TRACE_POINTS
39 int kvm_arch_vcpu_runnable(struct kvm_vcpu *v)
41 return !(v->arch.shared->msr & MSR_WE) ||
42 !!(v->arch.pending_exceptions);
45 int kvmppc_kvm_pv(struct kvm_vcpu *vcpu)
47 int nr = kvmppc_get_gpr(vcpu, 11);
49 unsigned long __maybe_unused param1 = kvmppc_get_gpr(vcpu, 3);
50 unsigned long __maybe_unused param2 = kvmppc_get_gpr(vcpu, 4);
51 unsigned long __maybe_unused param3 = kvmppc_get_gpr(vcpu, 5);
52 unsigned long __maybe_unused param4 = kvmppc_get_gpr(vcpu, 6);
55 if (!(vcpu->arch.shared->msr & MSR_SF)) {
64 case HC_VENDOR_KVM | KVM_HC_PPC_MAP_MAGIC_PAGE:
66 vcpu->arch.magic_page_pa = param1;
67 vcpu->arch.magic_page_ea = param2;
69 r2 = KVM_MAGIC_FEAT_SR;
74 case HC_VENDOR_KVM | KVM_HC_FEATURES:
76 #if defined(CONFIG_PPC_BOOK3S) /* XXX Missing magic page on BookE */
77 r2 |= (1 << KVM_FEATURE_MAGIC_PAGE);
80 /* Second return value is in r4 */
83 r = HC_EV_UNIMPLEMENTED;
87 kvmppc_set_gpr(vcpu, 4, r2);
92 int kvmppc_emulate_mmio(struct kvm_run *run, struct kvm_vcpu *vcpu)
94 enum emulation_result er;
97 er = kvmppc_emulate_instruction(run, vcpu);
100 /* Future optimization: only reload non-volatiles if they were
101 * actually modified. */
104 case EMULATE_DO_MMIO:
105 run->exit_reason = KVM_EXIT_MMIO;
106 /* We must reload nonvolatiles because "update" load/store
107 * instructions modify register state. */
108 /* Future optimization: only reload non-volatiles if they were
109 * actually modified. */
113 /* XXX Deliver Program interrupt to guest. */
114 printk(KERN_EMERG "%s: emulation failed (%08x)\n", __func__,
115 kvmppc_get_last_inst(vcpu));
125 int kvm_arch_hardware_enable(void *garbage)
130 void kvm_arch_hardware_disable(void *garbage)
134 int kvm_arch_hardware_setup(void)
139 void kvm_arch_hardware_unsetup(void)
143 void kvm_arch_check_processor_compat(void *rtn)
145 *(int *)rtn = kvmppc_core_check_processor_compat();
148 int kvm_arch_init_vm(struct kvm *kvm)
153 void kvm_arch_destroy_vm(struct kvm *kvm)
156 struct kvm_vcpu *vcpu;
158 kvm_for_each_vcpu(i, vcpu, kvm)
159 kvm_arch_vcpu_free(vcpu);
161 mutex_lock(&kvm->lock);
162 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
163 kvm->vcpus[i] = NULL;
165 atomic_set(&kvm->online_vcpus, 0);
166 mutex_unlock(&kvm->lock);
169 void kvm_arch_sync_events(struct kvm *kvm)
173 int kvm_dev_ioctl_check_extension(long ext)
179 case KVM_CAP_PPC_BOOKE_SREGS:
181 case KVM_CAP_PPC_SEGSTATE:
183 case KVM_CAP_PPC_PAIRED_SINGLES:
184 case KVM_CAP_PPC_UNSET_IRQ:
185 case KVM_CAP_PPC_IRQ_LEVEL:
186 case KVM_CAP_ENABLE_CAP:
187 case KVM_CAP_PPC_OSI:
188 case KVM_CAP_PPC_GET_PVINFO:
191 case KVM_CAP_COALESCED_MMIO:
192 r = KVM_COALESCED_MMIO_PAGE_OFFSET;
202 long kvm_arch_dev_ioctl(struct file *filp,
203 unsigned int ioctl, unsigned long arg)
208 int kvm_arch_prepare_memory_region(struct kvm *kvm,
209 struct kvm_memory_slot *memslot,
210 struct kvm_memory_slot old,
211 struct kvm_userspace_memory_region *mem,
217 void kvm_arch_commit_memory_region(struct kvm *kvm,
218 struct kvm_userspace_memory_region *mem,
219 struct kvm_memory_slot old,
226 void kvm_arch_flush_shadow(struct kvm *kvm)
230 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id)
232 struct kvm_vcpu *vcpu;
233 vcpu = kvmppc_core_vcpu_create(kvm, id);
235 kvmppc_create_vcpu_debugfs(vcpu, id);
239 void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu)
241 /* Make sure we're not using the vcpu anymore */
242 hrtimer_cancel(&vcpu->arch.dec_timer);
243 tasklet_kill(&vcpu->arch.tasklet);
245 kvmppc_remove_vcpu_debugfs(vcpu);
246 kvmppc_core_vcpu_free(vcpu);
249 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
251 kvm_arch_vcpu_free(vcpu);
254 int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
256 return kvmppc_core_pending_dec(vcpu);
259 static void kvmppc_decrementer_func(unsigned long data)
261 struct kvm_vcpu *vcpu = (struct kvm_vcpu *)data;
263 kvmppc_core_queue_dec(vcpu);
265 if (waitqueue_active(&vcpu->wq)) {
266 wake_up_interruptible(&vcpu->wq);
267 vcpu->stat.halt_wakeup++;
272 * low level hrtimer wake routine. Because this runs in hardirq context
273 * we schedule a tasklet to do the real work.
275 enum hrtimer_restart kvmppc_decrementer_wakeup(struct hrtimer *timer)
277 struct kvm_vcpu *vcpu;
279 vcpu = container_of(timer, struct kvm_vcpu, arch.dec_timer);
280 tasklet_schedule(&vcpu->arch.tasklet);
282 return HRTIMER_NORESTART;
285 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
287 hrtimer_init(&vcpu->arch.dec_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
288 tasklet_init(&vcpu->arch.tasklet, kvmppc_decrementer_func, (ulong)vcpu);
289 vcpu->arch.dec_timer.function = kvmppc_decrementer_wakeup;
291 #ifdef CONFIG_KVM_EXIT_TIMING
292 mutex_init(&vcpu->arch.exit_timing_lock);
298 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
300 kvmppc_mmu_destroy(vcpu);
303 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
307 * vrsave (formerly usprg0) isn't used by Linux, but may
308 * be used by the guest.
310 * On non-booke this is associated with Altivec and
311 * is handled by code in book3s.c.
313 mtspr(SPRN_VRSAVE, vcpu->arch.vrsave);
315 kvmppc_core_vcpu_load(vcpu, cpu);
318 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
320 kvmppc_core_vcpu_put(vcpu);
322 vcpu->arch.vrsave = mfspr(SPRN_VRSAVE);
326 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
327 struct kvm_guest_debug *dbg)
332 static void kvmppc_complete_dcr_load(struct kvm_vcpu *vcpu,
335 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, run->dcr.data);
338 static void kvmppc_complete_mmio_load(struct kvm_vcpu *vcpu,
341 u64 uninitialized_var(gpr);
343 if (run->mmio.len > sizeof(gpr)) {
344 printk(KERN_ERR "bad MMIO length: %d\n", run->mmio.len);
348 if (vcpu->arch.mmio_is_bigendian) {
349 switch (run->mmio.len) {
350 case 8: gpr = *(u64 *)run->mmio.data; break;
351 case 4: gpr = *(u32 *)run->mmio.data; break;
352 case 2: gpr = *(u16 *)run->mmio.data; break;
353 case 1: gpr = *(u8 *)run->mmio.data; break;
356 /* Convert BE data from userland back to LE. */
357 switch (run->mmio.len) {
358 case 4: gpr = ld_le32((u32 *)run->mmio.data); break;
359 case 2: gpr = ld_le16((u16 *)run->mmio.data); break;
360 case 1: gpr = *(u8 *)run->mmio.data; break;
364 if (vcpu->arch.mmio_sign_extend) {
365 switch (run->mmio.len) {
380 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr);
382 switch (vcpu->arch.io_gpr & KVM_REG_EXT_MASK) {
384 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr);
387 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr;
389 #ifdef CONFIG_PPC_BOOK3S
391 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr;
394 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr;
395 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr;
403 int kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu,
404 unsigned int rt, unsigned int bytes, int is_bigendian)
406 if (bytes > sizeof(run->mmio.data)) {
407 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
411 run->mmio.phys_addr = vcpu->arch.paddr_accessed;
412 run->mmio.len = bytes;
413 run->mmio.is_write = 0;
415 vcpu->arch.io_gpr = rt;
416 vcpu->arch.mmio_is_bigendian = is_bigendian;
417 vcpu->mmio_needed = 1;
418 vcpu->mmio_is_write = 0;
419 vcpu->arch.mmio_sign_extend = 0;
421 return EMULATE_DO_MMIO;
424 /* Same as above, but sign extends */
425 int kvmppc_handle_loads(struct kvm_run *run, struct kvm_vcpu *vcpu,
426 unsigned int rt, unsigned int bytes, int is_bigendian)
430 r = kvmppc_handle_load(run, vcpu, rt, bytes, is_bigendian);
431 vcpu->arch.mmio_sign_extend = 1;
436 int kvmppc_handle_store(struct kvm_run *run, struct kvm_vcpu *vcpu,
437 u64 val, unsigned int bytes, int is_bigendian)
439 void *data = run->mmio.data;
441 if (bytes > sizeof(run->mmio.data)) {
442 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
446 run->mmio.phys_addr = vcpu->arch.paddr_accessed;
447 run->mmio.len = bytes;
448 run->mmio.is_write = 1;
449 vcpu->mmio_needed = 1;
450 vcpu->mmio_is_write = 1;
452 /* Store the value at the lowest bytes in 'data'. */
455 case 8: *(u64 *)data = val; break;
456 case 4: *(u32 *)data = val; break;
457 case 2: *(u16 *)data = val; break;
458 case 1: *(u8 *)data = val; break;
461 /* Store LE value into 'data'. */
463 case 4: st_le32(data, val); break;
464 case 2: st_le16(data, val); break;
465 case 1: *(u8 *)data = val; break;
469 return EMULATE_DO_MMIO;
472 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
477 if (vcpu->sigset_active)
478 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
480 if (vcpu->mmio_needed) {
481 if (!vcpu->mmio_is_write)
482 kvmppc_complete_mmio_load(vcpu, run);
483 vcpu->mmio_needed = 0;
484 } else if (vcpu->arch.dcr_needed) {
485 if (!vcpu->arch.dcr_is_write)
486 kvmppc_complete_dcr_load(vcpu, run);
487 vcpu->arch.dcr_needed = 0;
488 } else if (vcpu->arch.osi_needed) {
489 u64 *gprs = run->osi.gprs;
492 for (i = 0; i < 32; i++)
493 kvmppc_set_gpr(vcpu, i, gprs[i]);
494 vcpu->arch.osi_needed = 0;
497 kvmppc_core_deliver_interrupts(vcpu);
501 r = __kvmppc_vcpu_run(run, vcpu);
505 if (vcpu->sigset_active)
506 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
511 int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq)
513 if (irq->irq == KVM_INTERRUPT_UNSET)
514 kvmppc_core_dequeue_external(vcpu, irq);
516 kvmppc_core_queue_external(vcpu, irq);
518 if (waitqueue_active(&vcpu->wq)) {
519 wake_up_interruptible(&vcpu->wq);
520 vcpu->stat.halt_wakeup++;
526 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
527 struct kvm_enable_cap *cap)
535 case KVM_CAP_PPC_OSI:
537 vcpu->arch.osi_enabled = true;
547 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
548 struct kvm_mp_state *mp_state)
553 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
554 struct kvm_mp_state *mp_state)
559 long kvm_arch_vcpu_ioctl(struct file *filp,
560 unsigned int ioctl, unsigned long arg)
562 struct kvm_vcpu *vcpu = filp->private_data;
563 void __user *argp = (void __user *)arg;
567 case KVM_INTERRUPT: {
568 struct kvm_interrupt irq;
570 if (copy_from_user(&irq, argp, sizeof(irq)))
572 r = kvm_vcpu_ioctl_interrupt(vcpu, &irq);
578 struct kvm_enable_cap cap;
580 if (copy_from_user(&cap, argp, sizeof(cap)))
582 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
593 static int kvm_vm_ioctl_get_pvinfo(struct kvm_ppc_pvinfo *pvinfo)
595 u32 inst_lis = 0x3c000000;
596 u32 inst_ori = 0x60000000;
597 u32 inst_nop = 0x60000000;
598 u32 inst_sc = 0x44000002;
599 u32 inst_imm_mask = 0xffff;
602 * The hypercall to get into KVM from within guest context is as
605 * lis r0, r0, KVM_SC_MAGIC_R0@h
606 * ori r0, KVM_SC_MAGIC_R0@l
610 pvinfo->hcall[0] = inst_lis | ((KVM_SC_MAGIC_R0 >> 16) & inst_imm_mask);
611 pvinfo->hcall[1] = inst_ori | (KVM_SC_MAGIC_R0 & inst_imm_mask);
612 pvinfo->hcall[2] = inst_sc;
613 pvinfo->hcall[3] = inst_nop;
618 long kvm_arch_vm_ioctl(struct file *filp,
619 unsigned int ioctl, unsigned long arg)
621 void __user *argp = (void __user *)arg;
625 case KVM_PPC_GET_PVINFO: {
626 struct kvm_ppc_pvinfo pvinfo;
627 memset(&pvinfo, 0, sizeof(pvinfo));
628 r = kvm_vm_ioctl_get_pvinfo(&pvinfo);
629 if (copy_to_user(argp, &pvinfo, sizeof(pvinfo))) {
644 int kvm_arch_init(void *opaque)
649 void kvm_arch_exit(void)