1 /* 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. 5 * 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. 10 * 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. 14 * 15 * Copyright IBM Corp. 2007 16 * 17 * Authors: Hollis Blanchard <hollisb@us.ibm.com> 18 * Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com> 19 */ 20 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> 27 #include <linux/fs.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> 33 #include "timing.h" 34 #include "../mm/mmu_decl.h" 35 36 #define CREATE_TRACE_POINTS 37 #include "trace.h" 38 39 int kvm_arch_vcpu_runnable(struct kvm_vcpu *v) 40 { 41 return !(v->arch.shared->msr & MSR_WE) || 42 !!(v->arch.pending_exceptions); 43 } 44 45 int kvmppc_kvm_pv(struct kvm_vcpu *vcpu) 46 { 47 int nr = kvmppc_get_gpr(vcpu, 11); 48 int r; 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); 53 unsigned long r2 = 0; 54 55 if (!(vcpu->arch.shared->msr & MSR_SF)) { 56 /* 32 bit mode */ 57 param1 &= 0xffffffff; 58 param2 &= 0xffffffff; 59 param3 &= 0xffffffff; 60 param4 &= 0xffffffff; 61 } 62 63 switch (nr) { 64 case HC_VENDOR_KVM | KVM_HC_PPC_MAP_MAGIC_PAGE: 65 { 66 vcpu->arch.magic_page_pa = param1; 67 vcpu->arch.magic_page_ea = param2; 68 69 r2 = KVM_MAGIC_FEAT_SR; 70 71 r = HC_EV_SUCCESS; 72 break; 73 } 74 case HC_VENDOR_KVM | KVM_HC_FEATURES: 75 r = HC_EV_SUCCESS; 76 #if defined(CONFIG_PPC_BOOK3S) /* XXX Missing magic page on BookE */ 77 r2 |= (1 << KVM_FEATURE_MAGIC_PAGE); 78 #endif 79 80 /* Second return value is in r4 */ 81 break; 82 default: 83 r = HC_EV_UNIMPLEMENTED; 84 break; 85 } 86 87 kvmppc_set_gpr(vcpu, 4, r2); 88 89 return r; 90 } 91 92 int kvmppc_emulate_mmio(struct kvm_run *run, struct kvm_vcpu *vcpu) 93 { 94 enum emulation_result er; 95 int r; 96 97 er = kvmppc_emulate_instruction(run, vcpu); 98 switch (er) { 99 case EMULATE_DONE: 100 /* Future optimization: only reload non-volatiles if they were 101 * actually modified. */ 102 r = RESUME_GUEST_NV; 103 break; 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. */ 110 r = RESUME_HOST_NV; 111 break; 112 case EMULATE_FAIL: 113 /* XXX Deliver Program interrupt to guest. */ 114 printk(KERN_EMERG "%s: emulation failed (%08x)\n", __func__, 115 kvmppc_get_last_inst(vcpu)); 116 r = RESUME_HOST; 117 break; 118 default: 119 BUG(); 120 } 121 122 return r; 123 } 124 125 int kvm_arch_hardware_enable(void *garbage) 126 { 127 return 0; 128 } 129 130 void kvm_arch_hardware_disable(void *garbage) 131 { 132 } 133 134 int kvm_arch_hardware_setup(void) 135 { 136 return 0; 137 } 138 139 void kvm_arch_hardware_unsetup(void) 140 { 141 } 142 143 void kvm_arch_check_processor_compat(void *rtn) 144 { 145 *(int *)rtn = kvmppc_core_check_processor_compat(); 146 } 147 148 int kvm_arch_init_vm(struct kvm *kvm) 149 { 150 return 0; 151 } 152 153 void kvm_arch_destroy_vm(struct kvm *kvm) 154 { 155 unsigned int i; 156 struct kvm_vcpu *vcpu; 157 158 kvm_for_each_vcpu(i, vcpu, kvm) 159 kvm_arch_vcpu_free(vcpu); 160 161 mutex_lock(&kvm->lock); 162 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 163 kvm->vcpus[i] = NULL; 164 165 atomic_set(&kvm->online_vcpus, 0); 166 mutex_unlock(&kvm->lock); 167 } 168 169 void kvm_arch_sync_events(struct kvm *kvm) 170 { 171 } 172 173 int kvm_dev_ioctl_check_extension(long ext) 174 { 175 int r; 176 177 switch (ext) { 178 #ifdef CONFIG_BOOKE 179 case KVM_CAP_PPC_BOOKE_SREGS: 180 #else 181 case KVM_CAP_PPC_SEGSTATE: 182 #endif 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: 189 r = 1; 190 break; 191 case KVM_CAP_COALESCED_MMIO: 192 r = KVM_COALESCED_MMIO_PAGE_OFFSET; 193 break; 194 default: 195 r = 0; 196 break; 197 } 198 return r; 199 200 } 201 202 long kvm_arch_dev_ioctl(struct file *filp, 203 unsigned int ioctl, unsigned long arg) 204 { 205 return -EINVAL; 206 } 207 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, 212 int user_alloc) 213 { 214 return 0; 215 } 216 217 void kvm_arch_commit_memory_region(struct kvm *kvm, 218 struct kvm_userspace_memory_region *mem, 219 struct kvm_memory_slot old, 220 int user_alloc) 221 { 222 return; 223 } 224 225 226 void kvm_arch_flush_shadow(struct kvm *kvm) 227 { 228 } 229 230 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id) 231 { 232 struct kvm_vcpu *vcpu; 233 vcpu = kvmppc_core_vcpu_create(kvm, id); 234 if (!IS_ERR(vcpu)) 235 kvmppc_create_vcpu_debugfs(vcpu, id); 236 return vcpu; 237 } 238 239 void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu) 240 { 241 /* Make sure we're not using the vcpu anymore */ 242 hrtimer_cancel(&vcpu->arch.dec_timer); 243 tasklet_kill(&vcpu->arch.tasklet); 244 245 kvmppc_remove_vcpu_debugfs(vcpu); 246 kvmppc_core_vcpu_free(vcpu); 247 } 248 249 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 250 { 251 kvm_arch_vcpu_free(vcpu); 252 } 253 254 int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu) 255 { 256 return kvmppc_core_pending_dec(vcpu); 257 } 258 259 static void kvmppc_decrementer_func(unsigned long data) 260 { 261 struct kvm_vcpu *vcpu = (struct kvm_vcpu *)data; 262 263 kvmppc_core_queue_dec(vcpu); 264 265 if (waitqueue_active(&vcpu->wq)) { 266 wake_up_interruptible(&vcpu->wq); 267 vcpu->stat.halt_wakeup++; 268 } 269 } 270 271 /* 272 * low level hrtimer wake routine. Because this runs in hardirq context 273 * we schedule a tasklet to do the real work. 274 */ 275 enum hrtimer_restart kvmppc_decrementer_wakeup(struct hrtimer *timer) 276 { 277 struct kvm_vcpu *vcpu; 278 279 vcpu = container_of(timer, struct kvm_vcpu, arch.dec_timer); 280 tasklet_schedule(&vcpu->arch.tasklet); 281 282 return HRTIMER_NORESTART; 283 } 284 285 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 286 { 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; 290 291 #ifdef CONFIG_KVM_EXIT_TIMING 292 mutex_init(&vcpu->arch.exit_timing_lock); 293 #endif 294 295 return 0; 296 } 297 298 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) 299 { 300 kvmppc_mmu_destroy(vcpu); 301 } 302 303 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 304 { 305 #ifdef CONFIG_BOOKE 306 /* 307 * vrsave (formerly usprg0) isn't used by Linux, but may 308 * be used by the guest. 309 * 310 * On non-booke this is associated with Altivec and 311 * is handled by code in book3s.c. 312 */ 313 mtspr(SPRN_VRSAVE, vcpu->arch.vrsave); 314 #endif 315 kvmppc_core_vcpu_load(vcpu, cpu); 316 } 317 318 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 319 { 320 kvmppc_core_vcpu_put(vcpu); 321 #ifdef CONFIG_BOOKE 322 vcpu->arch.vrsave = mfspr(SPRN_VRSAVE); 323 #endif 324 } 325 326 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 327 struct kvm_guest_debug *dbg) 328 { 329 return -EINVAL; 330 } 331 332 static void kvmppc_complete_dcr_load(struct kvm_vcpu *vcpu, 333 struct kvm_run *run) 334 { 335 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, run->dcr.data); 336 } 337 338 static void kvmppc_complete_mmio_load(struct kvm_vcpu *vcpu, 339 struct kvm_run *run) 340 { 341 u64 uninitialized_var(gpr); 342 343 if (run->mmio.len > sizeof(gpr)) { 344 printk(KERN_ERR "bad MMIO length: %d\n", run->mmio.len); 345 return; 346 } 347 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; 354 } 355 } else { 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; 361 } 362 } 363 364 if (vcpu->arch.mmio_sign_extend) { 365 switch (run->mmio.len) { 366 #ifdef CONFIG_PPC64 367 case 4: 368 gpr = (s64)(s32)gpr; 369 break; 370 #endif 371 case 2: 372 gpr = (s64)(s16)gpr; 373 break; 374 case 1: 375 gpr = (s64)(s8)gpr; 376 break; 377 } 378 } 379 380 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr); 381 382 switch (vcpu->arch.io_gpr & KVM_REG_EXT_MASK) { 383 case KVM_REG_GPR: 384 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr); 385 break; 386 case KVM_REG_FPR: 387 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr; 388 break; 389 #ifdef CONFIG_PPC_BOOK3S 390 case KVM_REG_QPR: 391 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr; 392 break; 393 case KVM_REG_FQPR: 394 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr; 395 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr; 396 break; 397 #endif 398 default: 399 BUG(); 400 } 401 } 402 403 int kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu, 404 unsigned int rt, unsigned int bytes, int is_bigendian) 405 { 406 if (bytes > sizeof(run->mmio.data)) { 407 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__, 408 run->mmio.len); 409 } 410 411 run->mmio.phys_addr = vcpu->arch.paddr_accessed; 412 run->mmio.len = bytes; 413 run->mmio.is_write = 0; 414 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; 420 421 return EMULATE_DO_MMIO; 422 } 423 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) 427 { 428 int r; 429 430 r = kvmppc_handle_load(run, vcpu, rt, bytes, is_bigendian); 431 vcpu->arch.mmio_sign_extend = 1; 432 433 return r; 434 } 435 436 int kvmppc_handle_store(struct kvm_run *run, struct kvm_vcpu *vcpu, 437 u64 val, unsigned int bytes, int is_bigendian) 438 { 439 void *data = run->mmio.data; 440 441 if (bytes > sizeof(run->mmio.data)) { 442 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__, 443 run->mmio.len); 444 } 445 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; 451 452 /* Store the value at the lowest bytes in 'data'. */ 453 if (is_bigendian) { 454 switch (bytes) { 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; 459 } 460 } else { 461 /* Store LE value into 'data'. */ 462 switch (bytes) { 463 case 4: st_le32(data, val); break; 464 case 2: st_le16(data, val); break; 465 case 1: *(u8 *)data = val; break; 466 } 467 } 468 469 return EMULATE_DO_MMIO; 470 } 471 472 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run) 473 { 474 int r; 475 sigset_t sigsaved; 476 477 if (vcpu->sigset_active) 478 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); 479 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; 490 int i; 491 492 for (i = 0; i < 32; i++) 493 kvmppc_set_gpr(vcpu, i, gprs[i]); 494 vcpu->arch.osi_needed = 0; 495 } 496 497 kvmppc_core_deliver_interrupts(vcpu); 498 499 local_irq_disable(); 500 kvm_guest_enter(); 501 r = __kvmppc_vcpu_run(run, vcpu); 502 kvm_guest_exit(); 503 local_irq_enable(); 504 505 if (vcpu->sigset_active) 506 sigprocmask(SIG_SETMASK, &sigsaved, NULL); 507 508 return r; 509 } 510 511 int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq) 512 { 513 if (irq->irq == KVM_INTERRUPT_UNSET) 514 kvmppc_core_dequeue_external(vcpu, irq); 515 else 516 kvmppc_core_queue_external(vcpu, irq); 517 518 if (waitqueue_active(&vcpu->wq)) { 519 wake_up_interruptible(&vcpu->wq); 520 vcpu->stat.halt_wakeup++; 521 } 522 523 return 0; 524 } 525 526 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 527 struct kvm_enable_cap *cap) 528 { 529 int r; 530 531 if (cap->flags) 532 return -EINVAL; 533 534 switch (cap->cap) { 535 case KVM_CAP_PPC_OSI: 536 r = 0; 537 vcpu->arch.osi_enabled = true; 538 break; 539 default: 540 r = -EINVAL; 541 break; 542 } 543 544 return r; 545 } 546 547 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 548 struct kvm_mp_state *mp_state) 549 { 550 return -EINVAL; 551 } 552 553 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 554 struct kvm_mp_state *mp_state) 555 { 556 return -EINVAL; 557 } 558 559 long kvm_arch_vcpu_ioctl(struct file *filp, 560 unsigned int ioctl, unsigned long arg) 561 { 562 struct kvm_vcpu *vcpu = filp->private_data; 563 void __user *argp = (void __user *)arg; 564 long r; 565 566 switch (ioctl) { 567 case KVM_INTERRUPT: { 568 struct kvm_interrupt irq; 569 r = -EFAULT; 570 if (copy_from_user(&irq, argp, sizeof(irq))) 571 goto out; 572 r = kvm_vcpu_ioctl_interrupt(vcpu, &irq); 573 goto out; 574 } 575 576 case KVM_ENABLE_CAP: 577 { 578 struct kvm_enable_cap cap; 579 r = -EFAULT; 580 if (copy_from_user(&cap, argp, sizeof(cap))) 581 goto out; 582 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 583 break; 584 } 585 default: 586 r = -EINVAL; 587 } 588 589 out: 590 return r; 591 } 592 593 static int kvm_vm_ioctl_get_pvinfo(struct kvm_ppc_pvinfo *pvinfo) 594 { 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; 600 601 /* 602 * The hypercall to get into KVM from within guest context is as 603 * follows: 604 * 605 * lis r0, r0, KVM_SC_MAGIC_R0@h 606 * ori r0, KVM_SC_MAGIC_R0@l 607 * sc 608 * nop 609 */ 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; 614 615 return 0; 616 } 617 618 long kvm_arch_vm_ioctl(struct file *filp, 619 unsigned int ioctl, unsigned long arg) 620 { 621 void __user *argp = (void __user *)arg; 622 long r; 623 624 switch (ioctl) { 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))) { 630 r = -EFAULT; 631 goto out; 632 } 633 634 break; 635 } 636 default: 637 r = -ENOTTY; 638 } 639 640 out: 641 return r; 642 } 643 644 int kvm_arch_init(void *opaque) 645 { 646 return 0; 647 } 648 649 void kvm_arch_exit(void) 650 { 651 } 652