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/vmalloc.h> 25 #include <linux/hrtimer.h> 26 #include <linux/fs.h> 27 #include <linux/slab.h> 28 #include <asm/cputable.h> 29 #include <asm/uaccess.h> 30 #include <asm/kvm_ppc.h> 31 #include <asm/tlbflush.h> 32 #include <asm/cputhreads.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 v->requests; 44 } 45 46 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu) 47 { 48 return 1; 49 } 50 51 int kvmppc_kvm_pv(struct kvm_vcpu *vcpu) 52 { 53 int nr = kvmppc_get_gpr(vcpu, 11); 54 int r; 55 unsigned long __maybe_unused param1 = kvmppc_get_gpr(vcpu, 3); 56 unsigned long __maybe_unused param2 = kvmppc_get_gpr(vcpu, 4); 57 unsigned long __maybe_unused param3 = kvmppc_get_gpr(vcpu, 5); 58 unsigned long __maybe_unused param4 = kvmppc_get_gpr(vcpu, 6); 59 unsigned long r2 = 0; 60 61 if (!(vcpu->arch.shared->msr & MSR_SF)) { 62 /* 32 bit mode */ 63 param1 &= 0xffffffff; 64 param2 &= 0xffffffff; 65 param3 &= 0xffffffff; 66 param4 &= 0xffffffff; 67 } 68 69 switch (nr) { 70 case HC_VENDOR_KVM | KVM_HC_PPC_MAP_MAGIC_PAGE: 71 { 72 vcpu->arch.magic_page_pa = param1; 73 vcpu->arch.magic_page_ea = param2; 74 75 r2 = KVM_MAGIC_FEAT_SR | KVM_MAGIC_FEAT_MAS0_TO_SPRG7; 76 77 r = HC_EV_SUCCESS; 78 break; 79 } 80 case HC_VENDOR_KVM | KVM_HC_FEATURES: 81 r = HC_EV_SUCCESS; 82 #if defined(CONFIG_PPC_BOOK3S) || defined(CONFIG_KVM_E500V2) 83 /* XXX Missing magic page on 44x */ 84 r2 |= (1 << KVM_FEATURE_MAGIC_PAGE); 85 #endif 86 87 /* Second return value is in r4 */ 88 break; 89 default: 90 r = HC_EV_UNIMPLEMENTED; 91 break; 92 } 93 94 kvmppc_set_gpr(vcpu, 4, r2); 95 96 return r; 97 } 98 99 int kvmppc_sanity_check(struct kvm_vcpu *vcpu) 100 { 101 int r = false; 102 103 /* We have to know what CPU to virtualize */ 104 if (!vcpu->arch.pvr) 105 goto out; 106 107 /* PAPR only works with book3s_64 */ 108 if ((vcpu->arch.cpu_type != KVM_CPU_3S_64) && vcpu->arch.papr_enabled) 109 goto out; 110 111 #ifdef CONFIG_KVM_BOOK3S_64_HV 112 /* HV KVM can only do PAPR mode for now */ 113 if (!vcpu->arch.papr_enabled) 114 goto out; 115 #endif 116 117 #ifdef CONFIG_KVM_BOOKE_HV 118 if (!cpu_has_feature(CPU_FTR_EMB_HV)) 119 goto out; 120 #endif 121 122 r = true; 123 124 out: 125 vcpu->arch.sane = r; 126 return r ? 0 : -EINVAL; 127 } 128 129 int kvmppc_emulate_mmio(struct kvm_run *run, struct kvm_vcpu *vcpu) 130 { 131 enum emulation_result er; 132 int r; 133 134 er = kvmppc_emulate_instruction(run, vcpu); 135 switch (er) { 136 case EMULATE_DONE: 137 /* Future optimization: only reload non-volatiles if they were 138 * actually modified. */ 139 r = RESUME_GUEST_NV; 140 break; 141 case EMULATE_DO_MMIO: 142 run->exit_reason = KVM_EXIT_MMIO; 143 /* We must reload nonvolatiles because "update" load/store 144 * instructions modify register state. */ 145 /* Future optimization: only reload non-volatiles if they were 146 * actually modified. */ 147 r = RESUME_HOST_NV; 148 break; 149 case EMULATE_FAIL: 150 /* XXX Deliver Program interrupt to guest. */ 151 printk(KERN_EMERG "%s: emulation failed (%08x)\n", __func__, 152 kvmppc_get_last_inst(vcpu)); 153 r = RESUME_HOST; 154 break; 155 default: 156 BUG(); 157 } 158 159 return r; 160 } 161 162 int kvm_arch_hardware_enable(void *garbage) 163 { 164 return 0; 165 } 166 167 void kvm_arch_hardware_disable(void *garbage) 168 { 169 } 170 171 int kvm_arch_hardware_setup(void) 172 { 173 return 0; 174 } 175 176 void kvm_arch_hardware_unsetup(void) 177 { 178 } 179 180 void kvm_arch_check_processor_compat(void *rtn) 181 { 182 *(int *)rtn = kvmppc_core_check_processor_compat(); 183 } 184 185 int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 186 { 187 if (type) 188 return -EINVAL; 189 190 return kvmppc_core_init_vm(kvm); 191 } 192 193 void kvm_arch_destroy_vm(struct kvm *kvm) 194 { 195 unsigned int i; 196 struct kvm_vcpu *vcpu; 197 198 kvm_for_each_vcpu(i, vcpu, kvm) 199 kvm_arch_vcpu_free(vcpu); 200 201 mutex_lock(&kvm->lock); 202 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 203 kvm->vcpus[i] = NULL; 204 205 atomic_set(&kvm->online_vcpus, 0); 206 207 kvmppc_core_destroy_vm(kvm); 208 209 mutex_unlock(&kvm->lock); 210 } 211 212 void kvm_arch_sync_events(struct kvm *kvm) 213 { 214 } 215 216 int kvm_dev_ioctl_check_extension(long ext) 217 { 218 int r; 219 220 switch (ext) { 221 #ifdef CONFIG_BOOKE 222 case KVM_CAP_PPC_BOOKE_SREGS: 223 #else 224 case KVM_CAP_PPC_SEGSTATE: 225 case KVM_CAP_PPC_HIOR: 226 case KVM_CAP_PPC_PAPR: 227 #endif 228 case KVM_CAP_PPC_UNSET_IRQ: 229 case KVM_CAP_PPC_IRQ_LEVEL: 230 case KVM_CAP_ENABLE_CAP: 231 case KVM_CAP_ONE_REG: 232 r = 1; 233 break; 234 #ifndef CONFIG_KVM_BOOK3S_64_HV 235 case KVM_CAP_PPC_PAIRED_SINGLES: 236 case KVM_CAP_PPC_OSI: 237 case KVM_CAP_PPC_GET_PVINFO: 238 #if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC) 239 case KVM_CAP_SW_TLB: 240 #endif 241 r = 1; 242 break; 243 case KVM_CAP_COALESCED_MMIO: 244 r = KVM_COALESCED_MMIO_PAGE_OFFSET; 245 break; 246 #endif 247 #ifdef CONFIG_PPC_BOOK3S_64 248 case KVM_CAP_SPAPR_TCE: 249 r = 1; 250 break; 251 #endif /* CONFIG_PPC_BOOK3S_64 */ 252 #ifdef CONFIG_KVM_BOOK3S_64_HV 253 case KVM_CAP_PPC_SMT: 254 r = threads_per_core; 255 break; 256 case KVM_CAP_PPC_RMA: 257 r = 1; 258 /* PPC970 requires an RMA */ 259 if (cpu_has_feature(CPU_FTR_ARCH_201)) 260 r = 2; 261 break; 262 case KVM_CAP_SYNC_MMU: 263 r = cpu_has_feature(CPU_FTR_ARCH_206) ? 1 : 0; 264 break; 265 #endif 266 case KVM_CAP_NR_VCPUS: 267 /* 268 * Recommending a number of CPUs is somewhat arbitrary; we 269 * return the number of present CPUs for -HV (since a host 270 * will have secondary threads "offline"), and for other KVM 271 * implementations just count online CPUs. 272 */ 273 #ifdef CONFIG_KVM_BOOK3S_64_HV 274 r = num_present_cpus(); 275 #else 276 r = num_online_cpus(); 277 #endif 278 break; 279 case KVM_CAP_MAX_VCPUS: 280 r = KVM_MAX_VCPUS; 281 break; 282 #ifdef CONFIG_PPC_BOOK3S_64 283 case KVM_CAP_PPC_GET_SMMU_INFO: 284 r = 1; 285 break; 286 #endif 287 default: 288 r = 0; 289 break; 290 } 291 return r; 292 293 } 294 295 long kvm_arch_dev_ioctl(struct file *filp, 296 unsigned int ioctl, unsigned long arg) 297 { 298 return -EINVAL; 299 } 300 301 void kvm_arch_free_memslot(struct kvm_memory_slot *free, 302 struct kvm_memory_slot *dont) 303 { 304 } 305 306 int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages) 307 { 308 return 0; 309 } 310 311 int kvm_arch_prepare_memory_region(struct kvm *kvm, 312 struct kvm_memory_slot *memslot, 313 struct kvm_memory_slot old, 314 struct kvm_userspace_memory_region *mem, 315 int user_alloc) 316 { 317 return kvmppc_core_prepare_memory_region(kvm, mem); 318 } 319 320 void kvm_arch_commit_memory_region(struct kvm *kvm, 321 struct kvm_userspace_memory_region *mem, 322 struct kvm_memory_slot old, 323 int user_alloc) 324 { 325 kvmppc_core_commit_memory_region(kvm, mem); 326 } 327 328 329 void kvm_arch_flush_shadow(struct kvm *kvm) 330 { 331 } 332 333 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id) 334 { 335 struct kvm_vcpu *vcpu; 336 vcpu = kvmppc_core_vcpu_create(kvm, id); 337 if (!IS_ERR(vcpu)) { 338 vcpu->arch.wqp = &vcpu->wq; 339 kvmppc_create_vcpu_debugfs(vcpu, id); 340 } 341 return vcpu; 342 } 343 344 void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu) 345 { 346 /* Make sure we're not using the vcpu anymore */ 347 hrtimer_cancel(&vcpu->arch.dec_timer); 348 tasklet_kill(&vcpu->arch.tasklet); 349 350 kvmppc_remove_vcpu_debugfs(vcpu); 351 kvmppc_core_vcpu_free(vcpu); 352 } 353 354 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 355 { 356 kvm_arch_vcpu_free(vcpu); 357 } 358 359 int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu) 360 { 361 return kvmppc_core_pending_dec(vcpu); 362 } 363 364 /* 365 * low level hrtimer wake routine. Because this runs in hardirq context 366 * we schedule a tasklet to do the real work. 367 */ 368 enum hrtimer_restart kvmppc_decrementer_wakeup(struct hrtimer *timer) 369 { 370 struct kvm_vcpu *vcpu; 371 372 vcpu = container_of(timer, struct kvm_vcpu, arch.dec_timer); 373 tasklet_schedule(&vcpu->arch.tasklet); 374 375 return HRTIMER_NORESTART; 376 } 377 378 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 379 { 380 hrtimer_init(&vcpu->arch.dec_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS); 381 tasklet_init(&vcpu->arch.tasklet, kvmppc_decrementer_func, (ulong)vcpu); 382 vcpu->arch.dec_timer.function = kvmppc_decrementer_wakeup; 383 vcpu->arch.dec_expires = ~(u64)0; 384 385 #ifdef CONFIG_KVM_EXIT_TIMING 386 mutex_init(&vcpu->arch.exit_timing_lock); 387 #endif 388 389 return 0; 390 } 391 392 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) 393 { 394 kvmppc_mmu_destroy(vcpu); 395 } 396 397 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 398 { 399 #ifdef CONFIG_BOOKE 400 /* 401 * vrsave (formerly usprg0) isn't used by Linux, but may 402 * be used by the guest. 403 * 404 * On non-booke this is associated with Altivec and 405 * is handled by code in book3s.c. 406 */ 407 mtspr(SPRN_VRSAVE, vcpu->arch.vrsave); 408 #endif 409 kvmppc_core_vcpu_load(vcpu, cpu); 410 vcpu->cpu = smp_processor_id(); 411 } 412 413 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 414 { 415 kvmppc_core_vcpu_put(vcpu); 416 #ifdef CONFIG_BOOKE 417 vcpu->arch.vrsave = mfspr(SPRN_VRSAVE); 418 #endif 419 vcpu->cpu = -1; 420 } 421 422 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 423 struct kvm_guest_debug *dbg) 424 { 425 return -EINVAL; 426 } 427 428 static void kvmppc_complete_dcr_load(struct kvm_vcpu *vcpu, 429 struct kvm_run *run) 430 { 431 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, run->dcr.data); 432 } 433 434 static void kvmppc_complete_mmio_load(struct kvm_vcpu *vcpu, 435 struct kvm_run *run) 436 { 437 u64 uninitialized_var(gpr); 438 439 if (run->mmio.len > sizeof(gpr)) { 440 printk(KERN_ERR "bad MMIO length: %d\n", run->mmio.len); 441 return; 442 } 443 444 if (vcpu->arch.mmio_is_bigendian) { 445 switch (run->mmio.len) { 446 case 8: gpr = *(u64 *)run->mmio.data; break; 447 case 4: gpr = *(u32 *)run->mmio.data; break; 448 case 2: gpr = *(u16 *)run->mmio.data; break; 449 case 1: gpr = *(u8 *)run->mmio.data; break; 450 } 451 } else { 452 /* Convert BE data from userland back to LE. */ 453 switch (run->mmio.len) { 454 case 4: gpr = ld_le32((u32 *)run->mmio.data); break; 455 case 2: gpr = ld_le16((u16 *)run->mmio.data); break; 456 case 1: gpr = *(u8 *)run->mmio.data; break; 457 } 458 } 459 460 if (vcpu->arch.mmio_sign_extend) { 461 switch (run->mmio.len) { 462 #ifdef CONFIG_PPC64 463 case 4: 464 gpr = (s64)(s32)gpr; 465 break; 466 #endif 467 case 2: 468 gpr = (s64)(s16)gpr; 469 break; 470 case 1: 471 gpr = (s64)(s8)gpr; 472 break; 473 } 474 } 475 476 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr); 477 478 switch (vcpu->arch.io_gpr & KVM_MMIO_REG_EXT_MASK) { 479 case KVM_MMIO_REG_GPR: 480 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr); 481 break; 482 case KVM_MMIO_REG_FPR: 483 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr; 484 break; 485 #ifdef CONFIG_PPC_BOOK3S 486 case KVM_MMIO_REG_QPR: 487 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr; 488 break; 489 case KVM_MMIO_REG_FQPR: 490 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr; 491 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr; 492 break; 493 #endif 494 default: 495 BUG(); 496 } 497 } 498 499 int kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu, 500 unsigned int rt, unsigned int bytes, int is_bigendian) 501 { 502 if (bytes > sizeof(run->mmio.data)) { 503 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__, 504 run->mmio.len); 505 } 506 507 run->mmio.phys_addr = vcpu->arch.paddr_accessed; 508 run->mmio.len = bytes; 509 run->mmio.is_write = 0; 510 511 vcpu->arch.io_gpr = rt; 512 vcpu->arch.mmio_is_bigendian = is_bigendian; 513 vcpu->mmio_needed = 1; 514 vcpu->mmio_is_write = 0; 515 vcpu->arch.mmio_sign_extend = 0; 516 517 return EMULATE_DO_MMIO; 518 } 519 520 /* Same as above, but sign extends */ 521 int kvmppc_handle_loads(struct kvm_run *run, struct kvm_vcpu *vcpu, 522 unsigned int rt, unsigned int bytes, int is_bigendian) 523 { 524 int r; 525 526 r = kvmppc_handle_load(run, vcpu, rt, bytes, is_bigendian); 527 vcpu->arch.mmio_sign_extend = 1; 528 529 return r; 530 } 531 532 int kvmppc_handle_store(struct kvm_run *run, struct kvm_vcpu *vcpu, 533 u64 val, unsigned int bytes, int is_bigendian) 534 { 535 void *data = run->mmio.data; 536 537 if (bytes > sizeof(run->mmio.data)) { 538 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__, 539 run->mmio.len); 540 } 541 542 run->mmio.phys_addr = vcpu->arch.paddr_accessed; 543 run->mmio.len = bytes; 544 run->mmio.is_write = 1; 545 vcpu->mmio_needed = 1; 546 vcpu->mmio_is_write = 1; 547 548 /* Store the value at the lowest bytes in 'data'. */ 549 if (is_bigendian) { 550 switch (bytes) { 551 case 8: *(u64 *)data = val; break; 552 case 4: *(u32 *)data = val; break; 553 case 2: *(u16 *)data = val; break; 554 case 1: *(u8 *)data = val; break; 555 } 556 } else { 557 /* Store LE value into 'data'. */ 558 switch (bytes) { 559 case 4: st_le32(data, val); break; 560 case 2: st_le16(data, val); break; 561 case 1: *(u8 *)data = val; break; 562 } 563 } 564 565 return EMULATE_DO_MMIO; 566 } 567 568 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run) 569 { 570 int r; 571 sigset_t sigsaved; 572 573 if (vcpu->sigset_active) 574 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); 575 576 if (vcpu->mmio_needed) { 577 if (!vcpu->mmio_is_write) 578 kvmppc_complete_mmio_load(vcpu, run); 579 vcpu->mmio_needed = 0; 580 } else if (vcpu->arch.dcr_needed) { 581 if (!vcpu->arch.dcr_is_write) 582 kvmppc_complete_dcr_load(vcpu, run); 583 vcpu->arch.dcr_needed = 0; 584 } else if (vcpu->arch.osi_needed) { 585 u64 *gprs = run->osi.gprs; 586 int i; 587 588 for (i = 0; i < 32; i++) 589 kvmppc_set_gpr(vcpu, i, gprs[i]); 590 vcpu->arch.osi_needed = 0; 591 } else if (vcpu->arch.hcall_needed) { 592 int i; 593 594 kvmppc_set_gpr(vcpu, 3, run->papr_hcall.ret); 595 for (i = 0; i < 9; ++i) 596 kvmppc_set_gpr(vcpu, 4 + i, run->papr_hcall.args[i]); 597 vcpu->arch.hcall_needed = 0; 598 } 599 600 r = kvmppc_vcpu_run(run, vcpu); 601 602 if (vcpu->sigset_active) 603 sigprocmask(SIG_SETMASK, &sigsaved, NULL); 604 605 return r; 606 } 607 608 int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq) 609 { 610 if (irq->irq == KVM_INTERRUPT_UNSET) { 611 kvmppc_core_dequeue_external(vcpu, irq); 612 return 0; 613 } 614 615 kvmppc_core_queue_external(vcpu, irq); 616 617 kvm_vcpu_kick(vcpu); 618 619 return 0; 620 } 621 622 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 623 struct kvm_enable_cap *cap) 624 { 625 int r; 626 627 if (cap->flags) 628 return -EINVAL; 629 630 switch (cap->cap) { 631 case KVM_CAP_PPC_OSI: 632 r = 0; 633 vcpu->arch.osi_enabled = true; 634 break; 635 case KVM_CAP_PPC_PAPR: 636 r = 0; 637 vcpu->arch.papr_enabled = true; 638 break; 639 #if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC) 640 case KVM_CAP_SW_TLB: { 641 struct kvm_config_tlb cfg; 642 void __user *user_ptr = (void __user *)(uintptr_t)cap->args[0]; 643 644 r = -EFAULT; 645 if (copy_from_user(&cfg, user_ptr, sizeof(cfg))) 646 break; 647 648 r = kvm_vcpu_ioctl_config_tlb(vcpu, &cfg); 649 break; 650 } 651 #endif 652 default: 653 r = -EINVAL; 654 break; 655 } 656 657 if (!r) 658 r = kvmppc_sanity_check(vcpu); 659 660 return r; 661 } 662 663 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 664 struct kvm_mp_state *mp_state) 665 { 666 return -EINVAL; 667 } 668 669 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 670 struct kvm_mp_state *mp_state) 671 { 672 return -EINVAL; 673 } 674 675 long kvm_arch_vcpu_ioctl(struct file *filp, 676 unsigned int ioctl, unsigned long arg) 677 { 678 struct kvm_vcpu *vcpu = filp->private_data; 679 void __user *argp = (void __user *)arg; 680 long r; 681 682 switch (ioctl) { 683 case KVM_INTERRUPT: { 684 struct kvm_interrupt irq; 685 r = -EFAULT; 686 if (copy_from_user(&irq, argp, sizeof(irq))) 687 goto out; 688 r = kvm_vcpu_ioctl_interrupt(vcpu, &irq); 689 goto out; 690 } 691 692 case KVM_ENABLE_CAP: 693 { 694 struct kvm_enable_cap cap; 695 r = -EFAULT; 696 if (copy_from_user(&cap, argp, sizeof(cap))) 697 goto out; 698 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 699 break; 700 } 701 702 case KVM_SET_ONE_REG: 703 case KVM_GET_ONE_REG: 704 { 705 struct kvm_one_reg reg; 706 r = -EFAULT; 707 if (copy_from_user(®, argp, sizeof(reg))) 708 goto out; 709 if (ioctl == KVM_SET_ONE_REG) 710 r = kvm_vcpu_ioctl_set_one_reg(vcpu, ®); 711 else 712 r = kvm_vcpu_ioctl_get_one_reg(vcpu, ®); 713 break; 714 } 715 716 #if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC) 717 case KVM_DIRTY_TLB: { 718 struct kvm_dirty_tlb dirty; 719 r = -EFAULT; 720 if (copy_from_user(&dirty, argp, sizeof(dirty))) 721 goto out; 722 r = kvm_vcpu_ioctl_dirty_tlb(vcpu, &dirty); 723 break; 724 } 725 #endif 726 default: 727 r = -EINVAL; 728 } 729 730 out: 731 return r; 732 } 733 734 int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) 735 { 736 return VM_FAULT_SIGBUS; 737 } 738 739 static int kvm_vm_ioctl_get_pvinfo(struct kvm_ppc_pvinfo *pvinfo) 740 { 741 u32 inst_lis = 0x3c000000; 742 u32 inst_ori = 0x60000000; 743 u32 inst_nop = 0x60000000; 744 u32 inst_sc = 0x44000002; 745 u32 inst_imm_mask = 0xffff; 746 747 /* 748 * The hypercall to get into KVM from within guest context is as 749 * follows: 750 * 751 * lis r0, r0, KVM_SC_MAGIC_R0@h 752 * ori r0, KVM_SC_MAGIC_R0@l 753 * sc 754 * nop 755 */ 756 pvinfo->hcall[0] = inst_lis | ((KVM_SC_MAGIC_R0 >> 16) & inst_imm_mask); 757 pvinfo->hcall[1] = inst_ori | (KVM_SC_MAGIC_R0 & inst_imm_mask); 758 pvinfo->hcall[2] = inst_sc; 759 pvinfo->hcall[3] = inst_nop; 760 761 return 0; 762 } 763 764 long kvm_arch_vm_ioctl(struct file *filp, 765 unsigned int ioctl, unsigned long arg) 766 { 767 void __user *argp = (void __user *)arg; 768 long r; 769 770 switch (ioctl) { 771 case KVM_PPC_GET_PVINFO: { 772 struct kvm_ppc_pvinfo pvinfo; 773 memset(&pvinfo, 0, sizeof(pvinfo)); 774 r = kvm_vm_ioctl_get_pvinfo(&pvinfo); 775 if (copy_to_user(argp, &pvinfo, sizeof(pvinfo))) { 776 r = -EFAULT; 777 goto out; 778 } 779 780 break; 781 } 782 #ifdef CONFIG_PPC_BOOK3S_64 783 case KVM_CREATE_SPAPR_TCE: { 784 struct kvm_create_spapr_tce create_tce; 785 struct kvm *kvm = filp->private_data; 786 787 r = -EFAULT; 788 if (copy_from_user(&create_tce, argp, sizeof(create_tce))) 789 goto out; 790 r = kvm_vm_ioctl_create_spapr_tce(kvm, &create_tce); 791 goto out; 792 } 793 #endif /* CONFIG_PPC_BOOK3S_64 */ 794 795 #ifdef CONFIG_KVM_BOOK3S_64_HV 796 case KVM_ALLOCATE_RMA: { 797 struct kvm *kvm = filp->private_data; 798 struct kvm_allocate_rma rma; 799 800 r = kvm_vm_ioctl_allocate_rma(kvm, &rma); 801 if (r >= 0 && copy_to_user(argp, &rma, sizeof(rma))) 802 r = -EFAULT; 803 break; 804 } 805 #endif /* CONFIG_KVM_BOOK3S_64_HV */ 806 807 #ifdef CONFIG_PPC_BOOK3S_64 808 case KVM_PPC_GET_SMMU_INFO: { 809 struct kvm *kvm = filp->private_data; 810 struct kvm_ppc_smmu_info info; 811 812 memset(&info, 0, sizeof(info)); 813 r = kvm_vm_ioctl_get_smmu_info(kvm, &info); 814 if (r >= 0 && copy_to_user(argp, &info, sizeof(info))) 815 r = -EFAULT; 816 break; 817 } 818 #endif /* CONFIG_PPC_BOOK3S_64 */ 819 default: 820 r = -ENOTTY; 821 } 822 823 out: 824 return r; 825 } 826 827 static unsigned long lpid_inuse[BITS_TO_LONGS(KVMPPC_NR_LPIDS)]; 828 static unsigned long nr_lpids; 829 830 long kvmppc_alloc_lpid(void) 831 { 832 long lpid; 833 834 do { 835 lpid = find_first_zero_bit(lpid_inuse, KVMPPC_NR_LPIDS); 836 if (lpid >= nr_lpids) { 837 pr_err("%s: No LPIDs free\n", __func__); 838 return -ENOMEM; 839 } 840 } while (test_and_set_bit(lpid, lpid_inuse)); 841 842 return lpid; 843 } 844 845 void kvmppc_claim_lpid(long lpid) 846 { 847 set_bit(lpid, lpid_inuse); 848 } 849 850 void kvmppc_free_lpid(long lpid) 851 { 852 clear_bit(lpid, lpid_inuse); 853 } 854 855 void kvmppc_init_lpid(unsigned long nr_lpids_param) 856 { 857 nr_lpids = min_t(unsigned long, KVMPPC_NR_LPIDS, nr_lpids_param); 858 memset(lpid_inuse, 0, sizeof(lpid_inuse)); 859 } 860 861 int kvm_arch_init(void *opaque) 862 { 863 return 0; 864 } 865 866 void kvm_arch_exit(void) 867 { 868 } 869