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 <linux/file.h> 29 #include <asm/cputable.h> 30 #include <asm/uaccess.h> 31 #include <asm/kvm_ppc.h> 32 #include <asm/tlbflush.h> 33 #include <asm/cputhreads.h> 34 #include <asm/irqflags.h> 35 #include "timing.h" 36 #include "irq.h" 37 #include "../mm/mmu_decl.h" 38 39 #define CREATE_TRACE_POINTS 40 #include "trace.h" 41 42 int kvm_arch_vcpu_runnable(struct kvm_vcpu *v) 43 { 44 return !!(v->arch.pending_exceptions) || 45 v->requests; 46 } 47 48 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu) 49 { 50 return 1; 51 } 52 53 #ifndef CONFIG_KVM_BOOK3S_64_HV 54 /* 55 * Common checks before entering the guest world. Call with interrupts 56 * disabled. 57 * 58 * returns: 59 * 60 * == 1 if we're ready to go into guest state 61 * <= 0 if we need to go back to the host with return value 62 */ 63 int kvmppc_prepare_to_enter(struct kvm_vcpu *vcpu) 64 { 65 int r = 1; 66 67 WARN_ON_ONCE(!irqs_disabled()); 68 while (true) { 69 if (need_resched()) { 70 local_irq_enable(); 71 cond_resched(); 72 local_irq_disable(); 73 continue; 74 } 75 76 if (signal_pending(current)) { 77 kvmppc_account_exit(vcpu, SIGNAL_EXITS); 78 vcpu->run->exit_reason = KVM_EXIT_INTR; 79 r = -EINTR; 80 break; 81 } 82 83 vcpu->mode = IN_GUEST_MODE; 84 85 /* 86 * Reading vcpu->requests must happen after setting vcpu->mode, 87 * so we don't miss a request because the requester sees 88 * OUTSIDE_GUEST_MODE and assumes we'll be checking requests 89 * before next entering the guest (and thus doesn't IPI). 90 */ 91 smp_mb(); 92 93 if (vcpu->requests) { 94 /* Make sure we process requests preemptable */ 95 local_irq_enable(); 96 trace_kvm_check_requests(vcpu); 97 r = kvmppc_core_check_requests(vcpu); 98 local_irq_disable(); 99 if (r > 0) 100 continue; 101 break; 102 } 103 104 if (kvmppc_core_prepare_to_enter(vcpu)) { 105 /* interrupts got enabled in between, so we 106 are back at square 1 */ 107 continue; 108 } 109 110 #ifdef CONFIG_PPC64 111 /* lazy EE magic */ 112 hard_irq_disable(); 113 if (lazy_irq_pending()) { 114 /* Got an interrupt in between, try again */ 115 local_irq_enable(); 116 local_irq_disable(); 117 kvm_guest_exit(); 118 continue; 119 } 120 121 trace_hardirqs_on(); 122 #endif 123 124 kvm_guest_enter(); 125 break; 126 } 127 128 return r; 129 } 130 #endif /* CONFIG_KVM_BOOK3S_64_HV */ 131 132 int kvmppc_kvm_pv(struct kvm_vcpu *vcpu) 133 { 134 int nr = kvmppc_get_gpr(vcpu, 11); 135 int r; 136 unsigned long __maybe_unused param1 = kvmppc_get_gpr(vcpu, 3); 137 unsigned long __maybe_unused param2 = kvmppc_get_gpr(vcpu, 4); 138 unsigned long __maybe_unused param3 = kvmppc_get_gpr(vcpu, 5); 139 unsigned long __maybe_unused param4 = kvmppc_get_gpr(vcpu, 6); 140 unsigned long r2 = 0; 141 142 if (!(vcpu->arch.shared->msr & MSR_SF)) { 143 /* 32 bit mode */ 144 param1 &= 0xffffffff; 145 param2 &= 0xffffffff; 146 param3 &= 0xffffffff; 147 param4 &= 0xffffffff; 148 } 149 150 switch (nr) { 151 case KVM_HCALL_TOKEN(KVM_HC_PPC_MAP_MAGIC_PAGE): 152 { 153 vcpu->arch.magic_page_pa = param1; 154 vcpu->arch.magic_page_ea = param2; 155 156 r2 = KVM_MAGIC_FEAT_SR | KVM_MAGIC_FEAT_MAS0_TO_SPRG7; 157 158 r = EV_SUCCESS; 159 break; 160 } 161 case KVM_HCALL_TOKEN(KVM_HC_FEATURES): 162 r = EV_SUCCESS; 163 #if defined(CONFIG_PPC_BOOK3S) || defined(CONFIG_KVM_E500V2) 164 /* XXX Missing magic page on 44x */ 165 r2 |= (1 << KVM_FEATURE_MAGIC_PAGE); 166 #endif 167 168 /* Second return value is in r4 */ 169 break; 170 case EV_HCALL_TOKEN(EV_IDLE): 171 r = EV_SUCCESS; 172 kvm_vcpu_block(vcpu); 173 clear_bit(KVM_REQ_UNHALT, &vcpu->requests); 174 break; 175 default: 176 r = EV_UNIMPLEMENTED; 177 break; 178 } 179 180 kvmppc_set_gpr(vcpu, 4, r2); 181 182 return r; 183 } 184 185 int kvmppc_sanity_check(struct kvm_vcpu *vcpu) 186 { 187 int r = false; 188 189 /* We have to know what CPU to virtualize */ 190 if (!vcpu->arch.pvr) 191 goto out; 192 193 /* PAPR only works with book3s_64 */ 194 if ((vcpu->arch.cpu_type != KVM_CPU_3S_64) && vcpu->arch.papr_enabled) 195 goto out; 196 197 #ifdef CONFIG_KVM_BOOK3S_64_HV 198 /* HV KVM can only do PAPR mode for now */ 199 if (!vcpu->arch.papr_enabled) 200 goto out; 201 #endif 202 203 #ifdef CONFIG_KVM_BOOKE_HV 204 if (!cpu_has_feature(CPU_FTR_EMB_HV)) 205 goto out; 206 #endif 207 208 r = true; 209 210 out: 211 vcpu->arch.sane = r; 212 return r ? 0 : -EINVAL; 213 } 214 215 int kvmppc_emulate_mmio(struct kvm_run *run, struct kvm_vcpu *vcpu) 216 { 217 enum emulation_result er; 218 int r; 219 220 er = kvmppc_emulate_instruction(run, vcpu); 221 switch (er) { 222 case EMULATE_DONE: 223 /* Future optimization: only reload non-volatiles if they were 224 * actually modified. */ 225 r = RESUME_GUEST_NV; 226 break; 227 case EMULATE_DO_MMIO: 228 run->exit_reason = KVM_EXIT_MMIO; 229 /* We must reload nonvolatiles because "update" load/store 230 * instructions modify register state. */ 231 /* Future optimization: only reload non-volatiles if they were 232 * actually modified. */ 233 r = RESUME_HOST_NV; 234 break; 235 case EMULATE_FAIL: 236 /* XXX Deliver Program interrupt to guest. */ 237 printk(KERN_EMERG "%s: emulation failed (%08x)\n", __func__, 238 kvmppc_get_last_inst(vcpu)); 239 r = RESUME_HOST; 240 break; 241 default: 242 WARN_ON(1); 243 r = RESUME_GUEST; 244 } 245 246 return r; 247 } 248 249 int kvm_arch_hardware_enable(void *garbage) 250 { 251 return 0; 252 } 253 254 void kvm_arch_hardware_disable(void *garbage) 255 { 256 } 257 258 int kvm_arch_hardware_setup(void) 259 { 260 return 0; 261 } 262 263 void kvm_arch_hardware_unsetup(void) 264 { 265 } 266 267 void kvm_arch_check_processor_compat(void *rtn) 268 { 269 *(int *)rtn = kvmppc_core_check_processor_compat(); 270 } 271 272 int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 273 { 274 if (type) 275 return -EINVAL; 276 277 return kvmppc_core_init_vm(kvm); 278 } 279 280 void kvm_arch_destroy_vm(struct kvm *kvm) 281 { 282 unsigned int i; 283 struct kvm_vcpu *vcpu; 284 285 kvm_for_each_vcpu(i, vcpu, kvm) 286 kvm_arch_vcpu_free(vcpu); 287 288 mutex_lock(&kvm->lock); 289 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 290 kvm->vcpus[i] = NULL; 291 292 atomic_set(&kvm->online_vcpus, 0); 293 294 kvmppc_core_destroy_vm(kvm); 295 296 mutex_unlock(&kvm->lock); 297 } 298 299 void kvm_arch_sync_events(struct kvm *kvm) 300 { 301 } 302 303 int kvm_dev_ioctl_check_extension(long ext) 304 { 305 int r; 306 307 switch (ext) { 308 #ifdef CONFIG_BOOKE 309 case KVM_CAP_PPC_BOOKE_SREGS: 310 case KVM_CAP_PPC_BOOKE_WATCHDOG: 311 case KVM_CAP_PPC_EPR: 312 #else 313 case KVM_CAP_PPC_SEGSTATE: 314 case KVM_CAP_PPC_HIOR: 315 case KVM_CAP_PPC_PAPR: 316 #endif 317 case KVM_CAP_PPC_UNSET_IRQ: 318 case KVM_CAP_PPC_IRQ_LEVEL: 319 case KVM_CAP_ENABLE_CAP: 320 case KVM_CAP_ONE_REG: 321 case KVM_CAP_IOEVENTFD: 322 case KVM_CAP_DEVICE_CTRL: 323 r = 1; 324 break; 325 #ifndef CONFIG_KVM_BOOK3S_64_HV 326 case KVM_CAP_PPC_PAIRED_SINGLES: 327 case KVM_CAP_PPC_OSI: 328 case KVM_CAP_PPC_GET_PVINFO: 329 #if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC) 330 case KVM_CAP_SW_TLB: 331 #endif 332 #ifdef CONFIG_KVM_MPIC 333 case KVM_CAP_IRQ_MPIC: 334 #endif 335 r = 1; 336 break; 337 case KVM_CAP_COALESCED_MMIO: 338 r = KVM_COALESCED_MMIO_PAGE_OFFSET; 339 break; 340 #endif 341 #ifdef CONFIG_PPC_BOOK3S_64 342 case KVM_CAP_SPAPR_TCE: 343 case KVM_CAP_PPC_ALLOC_HTAB: 344 case KVM_CAP_PPC_RTAS: 345 #ifdef CONFIG_KVM_XICS 346 case KVM_CAP_IRQ_XICS: 347 #endif 348 r = 1; 349 break; 350 #endif /* CONFIG_PPC_BOOK3S_64 */ 351 #ifdef CONFIG_KVM_BOOK3S_64_HV 352 case KVM_CAP_PPC_SMT: 353 r = threads_per_core; 354 break; 355 case KVM_CAP_PPC_RMA: 356 r = 1; 357 /* PPC970 requires an RMA */ 358 if (cpu_has_feature(CPU_FTR_ARCH_201)) 359 r = 2; 360 break; 361 #endif 362 case KVM_CAP_SYNC_MMU: 363 #ifdef CONFIG_KVM_BOOK3S_64_HV 364 r = cpu_has_feature(CPU_FTR_ARCH_206) ? 1 : 0; 365 #elif defined(KVM_ARCH_WANT_MMU_NOTIFIER) 366 r = 1; 367 #else 368 r = 0; 369 break; 370 #endif 371 #ifdef CONFIG_KVM_BOOK3S_64_HV 372 case KVM_CAP_PPC_HTAB_FD: 373 r = 1; 374 break; 375 #endif 376 break; 377 case KVM_CAP_NR_VCPUS: 378 /* 379 * Recommending a number of CPUs is somewhat arbitrary; we 380 * return the number of present CPUs for -HV (since a host 381 * will have secondary threads "offline"), and for other KVM 382 * implementations just count online CPUs. 383 */ 384 #ifdef CONFIG_KVM_BOOK3S_64_HV 385 r = num_present_cpus(); 386 #else 387 r = num_online_cpus(); 388 #endif 389 break; 390 case KVM_CAP_MAX_VCPUS: 391 r = KVM_MAX_VCPUS; 392 break; 393 #ifdef CONFIG_PPC_BOOK3S_64 394 case KVM_CAP_PPC_GET_SMMU_INFO: 395 r = 1; 396 break; 397 #endif 398 default: 399 r = 0; 400 break; 401 } 402 return r; 403 404 } 405 406 long kvm_arch_dev_ioctl(struct file *filp, 407 unsigned int ioctl, unsigned long arg) 408 { 409 return -EINVAL; 410 } 411 412 void kvm_arch_free_memslot(struct kvm_memory_slot *free, 413 struct kvm_memory_slot *dont) 414 { 415 kvmppc_core_free_memslot(free, dont); 416 } 417 418 int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages) 419 { 420 return kvmppc_core_create_memslot(slot, npages); 421 } 422 423 int kvm_arch_prepare_memory_region(struct kvm *kvm, 424 struct kvm_memory_slot *memslot, 425 struct kvm_userspace_memory_region *mem, 426 enum kvm_mr_change change) 427 { 428 return kvmppc_core_prepare_memory_region(kvm, memslot, mem); 429 } 430 431 void kvm_arch_commit_memory_region(struct kvm *kvm, 432 struct kvm_userspace_memory_region *mem, 433 const struct kvm_memory_slot *old, 434 enum kvm_mr_change change) 435 { 436 kvmppc_core_commit_memory_region(kvm, mem, old); 437 } 438 439 void kvm_arch_flush_shadow_all(struct kvm *kvm) 440 { 441 } 442 443 void kvm_arch_flush_shadow_memslot(struct kvm *kvm, 444 struct kvm_memory_slot *slot) 445 { 446 kvmppc_core_flush_memslot(kvm, slot); 447 } 448 449 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id) 450 { 451 struct kvm_vcpu *vcpu; 452 vcpu = kvmppc_core_vcpu_create(kvm, id); 453 if (!IS_ERR(vcpu)) { 454 vcpu->arch.wqp = &vcpu->wq; 455 kvmppc_create_vcpu_debugfs(vcpu, id); 456 } 457 return vcpu; 458 } 459 460 int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu) 461 { 462 return 0; 463 } 464 465 void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu) 466 { 467 /* Make sure we're not using the vcpu anymore */ 468 hrtimer_cancel(&vcpu->arch.dec_timer); 469 tasklet_kill(&vcpu->arch.tasklet); 470 471 kvmppc_remove_vcpu_debugfs(vcpu); 472 473 switch (vcpu->arch.irq_type) { 474 case KVMPPC_IRQ_MPIC: 475 kvmppc_mpic_disconnect_vcpu(vcpu->arch.mpic, vcpu); 476 break; 477 case KVMPPC_IRQ_XICS: 478 kvmppc_xics_free_icp(vcpu); 479 break; 480 } 481 482 kvmppc_core_vcpu_free(vcpu); 483 } 484 485 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 486 { 487 kvm_arch_vcpu_free(vcpu); 488 } 489 490 int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu) 491 { 492 return kvmppc_core_pending_dec(vcpu); 493 } 494 495 /* 496 * low level hrtimer wake routine. Because this runs in hardirq context 497 * we schedule a tasklet to do the real work. 498 */ 499 enum hrtimer_restart kvmppc_decrementer_wakeup(struct hrtimer *timer) 500 { 501 struct kvm_vcpu *vcpu; 502 503 vcpu = container_of(timer, struct kvm_vcpu, arch.dec_timer); 504 tasklet_schedule(&vcpu->arch.tasklet); 505 506 return HRTIMER_NORESTART; 507 } 508 509 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 510 { 511 int ret; 512 513 hrtimer_init(&vcpu->arch.dec_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS); 514 tasklet_init(&vcpu->arch.tasklet, kvmppc_decrementer_func, (ulong)vcpu); 515 vcpu->arch.dec_timer.function = kvmppc_decrementer_wakeup; 516 vcpu->arch.dec_expires = ~(u64)0; 517 518 #ifdef CONFIG_KVM_EXIT_TIMING 519 mutex_init(&vcpu->arch.exit_timing_lock); 520 #endif 521 ret = kvmppc_subarch_vcpu_init(vcpu); 522 return ret; 523 } 524 525 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) 526 { 527 kvmppc_mmu_destroy(vcpu); 528 kvmppc_subarch_vcpu_uninit(vcpu); 529 } 530 531 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 532 { 533 #ifdef CONFIG_BOOKE 534 /* 535 * vrsave (formerly usprg0) isn't used by Linux, but may 536 * be used by the guest. 537 * 538 * On non-booke this is associated with Altivec and 539 * is handled by code in book3s.c. 540 */ 541 mtspr(SPRN_VRSAVE, vcpu->arch.vrsave); 542 #endif 543 kvmppc_core_vcpu_load(vcpu, cpu); 544 } 545 546 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 547 { 548 kvmppc_core_vcpu_put(vcpu); 549 #ifdef CONFIG_BOOKE 550 vcpu->arch.vrsave = mfspr(SPRN_VRSAVE); 551 #endif 552 } 553 554 static void kvmppc_complete_dcr_load(struct kvm_vcpu *vcpu, 555 struct kvm_run *run) 556 { 557 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, run->dcr.data); 558 } 559 560 static void kvmppc_complete_mmio_load(struct kvm_vcpu *vcpu, 561 struct kvm_run *run) 562 { 563 u64 uninitialized_var(gpr); 564 565 if (run->mmio.len > sizeof(gpr)) { 566 printk(KERN_ERR "bad MMIO length: %d\n", run->mmio.len); 567 return; 568 } 569 570 if (vcpu->arch.mmio_is_bigendian) { 571 switch (run->mmio.len) { 572 case 8: gpr = *(u64 *)run->mmio.data; break; 573 case 4: gpr = *(u32 *)run->mmio.data; break; 574 case 2: gpr = *(u16 *)run->mmio.data; break; 575 case 1: gpr = *(u8 *)run->mmio.data; break; 576 } 577 } else { 578 /* Convert BE data from userland back to LE. */ 579 switch (run->mmio.len) { 580 case 4: gpr = ld_le32((u32 *)run->mmio.data); break; 581 case 2: gpr = ld_le16((u16 *)run->mmio.data); break; 582 case 1: gpr = *(u8 *)run->mmio.data; break; 583 } 584 } 585 586 if (vcpu->arch.mmio_sign_extend) { 587 switch (run->mmio.len) { 588 #ifdef CONFIG_PPC64 589 case 4: 590 gpr = (s64)(s32)gpr; 591 break; 592 #endif 593 case 2: 594 gpr = (s64)(s16)gpr; 595 break; 596 case 1: 597 gpr = (s64)(s8)gpr; 598 break; 599 } 600 } 601 602 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr); 603 604 switch (vcpu->arch.io_gpr & KVM_MMIO_REG_EXT_MASK) { 605 case KVM_MMIO_REG_GPR: 606 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr); 607 break; 608 case KVM_MMIO_REG_FPR: 609 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr; 610 break; 611 #ifdef CONFIG_PPC_BOOK3S 612 case KVM_MMIO_REG_QPR: 613 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr; 614 break; 615 case KVM_MMIO_REG_FQPR: 616 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr; 617 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr; 618 break; 619 #endif 620 default: 621 BUG(); 622 } 623 } 624 625 int kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu, 626 unsigned int rt, unsigned int bytes, int is_bigendian) 627 { 628 int idx, ret; 629 630 if (bytes > sizeof(run->mmio.data)) { 631 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__, 632 run->mmio.len); 633 } 634 635 run->mmio.phys_addr = vcpu->arch.paddr_accessed; 636 run->mmio.len = bytes; 637 run->mmio.is_write = 0; 638 639 vcpu->arch.io_gpr = rt; 640 vcpu->arch.mmio_is_bigendian = is_bigendian; 641 vcpu->mmio_needed = 1; 642 vcpu->mmio_is_write = 0; 643 vcpu->arch.mmio_sign_extend = 0; 644 645 idx = srcu_read_lock(&vcpu->kvm->srcu); 646 647 ret = kvm_io_bus_read(vcpu->kvm, KVM_MMIO_BUS, run->mmio.phys_addr, 648 bytes, &run->mmio.data); 649 650 srcu_read_unlock(&vcpu->kvm->srcu, idx); 651 652 if (!ret) { 653 kvmppc_complete_mmio_load(vcpu, run); 654 vcpu->mmio_needed = 0; 655 return EMULATE_DONE; 656 } 657 658 return EMULATE_DO_MMIO; 659 } 660 661 /* Same as above, but sign extends */ 662 int kvmppc_handle_loads(struct kvm_run *run, struct kvm_vcpu *vcpu, 663 unsigned int rt, unsigned int bytes, int is_bigendian) 664 { 665 int r; 666 667 vcpu->arch.mmio_sign_extend = 1; 668 r = kvmppc_handle_load(run, vcpu, rt, bytes, is_bigendian); 669 670 return r; 671 } 672 673 int kvmppc_handle_store(struct kvm_run *run, struct kvm_vcpu *vcpu, 674 u64 val, unsigned int bytes, int is_bigendian) 675 { 676 void *data = run->mmio.data; 677 int idx, ret; 678 679 if (bytes > sizeof(run->mmio.data)) { 680 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__, 681 run->mmio.len); 682 } 683 684 run->mmio.phys_addr = vcpu->arch.paddr_accessed; 685 run->mmio.len = bytes; 686 run->mmio.is_write = 1; 687 vcpu->mmio_needed = 1; 688 vcpu->mmio_is_write = 1; 689 690 /* Store the value at the lowest bytes in 'data'. */ 691 if (is_bigendian) { 692 switch (bytes) { 693 case 8: *(u64 *)data = val; break; 694 case 4: *(u32 *)data = val; break; 695 case 2: *(u16 *)data = val; break; 696 case 1: *(u8 *)data = val; break; 697 } 698 } else { 699 /* Store LE value into 'data'. */ 700 switch (bytes) { 701 case 4: st_le32(data, val); break; 702 case 2: st_le16(data, val); break; 703 case 1: *(u8 *)data = val; break; 704 } 705 } 706 707 idx = srcu_read_lock(&vcpu->kvm->srcu); 708 709 ret = kvm_io_bus_write(vcpu->kvm, KVM_MMIO_BUS, run->mmio.phys_addr, 710 bytes, &run->mmio.data); 711 712 srcu_read_unlock(&vcpu->kvm->srcu, idx); 713 714 if (!ret) { 715 vcpu->mmio_needed = 0; 716 return EMULATE_DONE; 717 } 718 719 return EMULATE_DO_MMIO; 720 } 721 722 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run) 723 { 724 int r; 725 sigset_t sigsaved; 726 727 if (vcpu->sigset_active) 728 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); 729 730 if (vcpu->mmio_needed) { 731 if (!vcpu->mmio_is_write) 732 kvmppc_complete_mmio_load(vcpu, run); 733 vcpu->mmio_needed = 0; 734 } else if (vcpu->arch.dcr_needed) { 735 if (!vcpu->arch.dcr_is_write) 736 kvmppc_complete_dcr_load(vcpu, run); 737 vcpu->arch.dcr_needed = 0; 738 } else if (vcpu->arch.osi_needed) { 739 u64 *gprs = run->osi.gprs; 740 int i; 741 742 for (i = 0; i < 32; i++) 743 kvmppc_set_gpr(vcpu, i, gprs[i]); 744 vcpu->arch.osi_needed = 0; 745 } else if (vcpu->arch.hcall_needed) { 746 int i; 747 748 kvmppc_set_gpr(vcpu, 3, run->papr_hcall.ret); 749 for (i = 0; i < 9; ++i) 750 kvmppc_set_gpr(vcpu, 4 + i, run->papr_hcall.args[i]); 751 vcpu->arch.hcall_needed = 0; 752 #ifdef CONFIG_BOOKE 753 } else if (vcpu->arch.epr_needed) { 754 kvmppc_set_epr(vcpu, run->epr.epr); 755 vcpu->arch.epr_needed = 0; 756 #endif 757 } 758 759 r = kvmppc_vcpu_run(run, vcpu); 760 761 if (vcpu->sigset_active) 762 sigprocmask(SIG_SETMASK, &sigsaved, NULL); 763 764 return r; 765 } 766 767 int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq) 768 { 769 if (irq->irq == KVM_INTERRUPT_UNSET) { 770 kvmppc_core_dequeue_external(vcpu); 771 return 0; 772 } 773 774 kvmppc_core_queue_external(vcpu, irq); 775 776 kvm_vcpu_kick(vcpu); 777 778 return 0; 779 } 780 781 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 782 struct kvm_enable_cap *cap) 783 { 784 int r; 785 786 if (cap->flags) 787 return -EINVAL; 788 789 switch (cap->cap) { 790 case KVM_CAP_PPC_OSI: 791 r = 0; 792 vcpu->arch.osi_enabled = true; 793 break; 794 case KVM_CAP_PPC_PAPR: 795 r = 0; 796 vcpu->arch.papr_enabled = true; 797 break; 798 case KVM_CAP_PPC_EPR: 799 r = 0; 800 if (cap->args[0]) 801 vcpu->arch.epr_flags |= KVMPPC_EPR_USER; 802 else 803 vcpu->arch.epr_flags &= ~KVMPPC_EPR_USER; 804 break; 805 #ifdef CONFIG_BOOKE 806 case KVM_CAP_PPC_BOOKE_WATCHDOG: 807 r = 0; 808 vcpu->arch.watchdog_enabled = true; 809 break; 810 #endif 811 #if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC) 812 case KVM_CAP_SW_TLB: { 813 struct kvm_config_tlb cfg; 814 void __user *user_ptr = (void __user *)(uintptr_t)cap->args[0]; 815 816 r = -EFAULT; 817 if (copy_from_user(&cfg, user_ptr, sizeof(cfg))) 818 break; 819 820 r = kvm_vcpu_ioctl_config_tlb(vcpu, &cfg); 821 break; 822 } 823 #endif 824 #ifdef CONFIG_KVM_MPIC 825 case KVM_CAP_IRQ_MPIC: { 826 struct file *filp; 827 struct kvm_device *dev; 828 829 r = -EBADF; 830 filp = fget(cap->args[0]); 831 if (!filp) 832 break; 833 834 r = -EPERM; 835 dev = kvm_device_from_filp(filp); 836 if (dev) 837 r = kvmppc_mpic_connect_vcpu(dev, vcpu, cap->args[1]); 838 839 fput(filp); 840 break; 841 } 842 #endif 843 #ifdef CONFIG_KVM_XICS 844 case KVM_CAP_IRQ_XICS: { 845 struct file *filp; 846 struct kvm_device *dev; 847 848 r = -EBADF; 849 filp = fget(cap->args[0]); 850 if (!filp) 851 break; 852 853 r = -EPERM; 854 dev = kvm_device_from_filp(filp); 855 if (dev) 856 r = kvmppc_xics_connect_vcpu(dev, vcpu, cap->args[1]); 857 858 fput(filp); 859 break; 860 } 861 #endif /* CONFIG_KVM_XICS */ 862 default: 863 r = -EINVAL; 864 break; 865 } 866 867 if (!r) 868 r = kvmppc_sanity_check(vcpu); 869 870 return r; 871 } 872 873 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 874 struct kvm_mp_state *mp_state) 875 { 876 return -EINVAL; 877 } 878 879 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 880 struct kvm_mp_state *mp_state) 881 { 882 return -EINVAL; 883 } 884 885 long kvm_arch_vcpu_ioctl(struct file *filp, 886 unsigned int ioctl, unsigned long arg) 887 { 888 struct kvm_vcpu *vcpu = filp->private_data; 889 void __user *argp = (void __user *)arg; 890 long r; 891 892 switch (ioctl) { 893 case KVM_INTERRUPT: { 894 struct kvm_interrupt irq; 895 r = -EFAULT; 896 if (copy_from_user(&irq, argp, sizeof(irq))) 897 goto out; 898 r = kvm_vcpu_ioctl_interrupt(vcpu, &irq); 899 goto out; 900 } 901 902 case KVM_ENABLE_CAP: 903 { 904 struct kvm_enable_cap cap; 905 r = -EFAULT; 906 if (copy_from_user(&cap, argp, sizeof(cap))) 907 goto out; 908 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 909 break; 910 } 911 912 case KVM_SET_ONE_REG: 913 case KVM_GET_ONE_REG: 914 { 915 struct kvm_one_reg reg; 916 r = -EFAULT; 917 if (copy_from_user(®, argp, sizeof(reg))) 918 goto out; 919 if (ioctl == KVM_SET_ONE_REG) 920 r = kvm_vcpu_ioctl_set_one_reg(vcpu, ®); 921 else 922 r = kvm_vcpu_ioctl_get_one_reg(vcpu, ®); 923 break; 924 } 925 926 #if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC) 927 case KVM_DIRTY_TLB: { 928 struct kvm_dirty_tlb dirty; 929 r = -EFAULT; 930 if (copy_from_user(&dirty, argp, sizeof(dirty))) 931 goto out; 932 r = kvm_vcpu_ioctl_dirty_tlb(vcpu, &dirty); 933 break; 934 } 935 #endif 936 default: 937 r = -EINVAL; 938 } 939 940 out: 941 return r; 942 } 943 944 int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) 945 { 946 return VM_FAULT_SIGBUS; 947 } 948 949 static int kvm_vm_ioctl_get_pvinfo(struct kvm_ppc_pvinfo *pvinfo) 950 { 951 u32 inst_nop = 0x60000000; 952 #ifdef CONFIG_KVM_BOOKE_HV 953 u32 inst_sc1 = 0x44000022; 954 pvinfo->hcall[0] = inst_sc1; 955 pvinfo->hcall[1] = inst_nop; 956 pvinfo->hcall[2] = inst_nop; 957 pvinfo->hcall[3] = inst_nop; 958 #else 959 u32 inst_lis = 0x3c000000; 960 u32 inst_ori = 0x60000000; 961 u32 inst_sc = 0x44000002; 962 u32 inst_imm_mask = 0xffff; 963 964 /* 965 * The hypercall to get into KVM from within guest context is as 966 * follows: 967 * 968 * lis r0, r0, KVM_SC_MAGIC_R0@h 969 * ori r0, KVM_SC_MAGIC_R0@l 970 * sc 971 * nop 972 */ 973 pvinfo->hcall[0] = inst_lis | ((KVM_SC_MAGIC_R0 >> 16) & inst_imm_mask); 974 pvinfo->hcall[1] = inst_ori | (KVM_SC_MAGIC_R0 & inst_imm_mask); 975 pvinfo->hcall[2] = inst_sc; 976 pvinfo->hcall[3] = inst_nop; 977 #endif 978 979 pvinfo->flags = KVM_PPC_PVINFO_FLAGS_EV_IDLE; 980 981 return 0; 982 } 983 984 int kvm_vm_ioctl_irq_line(struct kvm *kvm, struct kvm_irq_level *irq_event, 985 bool line_status) 986 { 987 if (!irqchip_in_kernel(kvm)) 988 return -ENXIO; 989 990 irq_event->status = kvm_set_irq(kvm, KVM_USERSPACE_IRQ_SOURCE_ID, 991 irq_event->irq, irq_event->level, 992 line_status); 993 return 0; 994 } 995 996 long kvm_arch_vm_ioctl(struct file *filp, 997 unsigned int ioctl, unsigned long arg) 998 { 999 struct kvm *kvm __maybe_unused = filp->private_data; 1000 void __user *argp = (void __user *)arg; 1001 long r; 1002 1003 switch (ioctl) { 1004 case KVM_PPC_GET_PVINFO: { 1005 struct kvm_ppc_pvinfo pvinfo; 1006 memset(&pvinfo, 0, sizeof(pvinfo)); 1007 r = kvm_vm_ioctl_get_pvinfo(&pvinfo); 1008 if (copy_to_user(argp, &pvinfo, sizeof(pvinfo))) { 1009 r = -EFAULT; 1010 goto out; 1011 } 1012 1013 break; 1014 } 1015 #ifdef CONFIG_PPC_BOOK3S_64 1016 case KVM_CREATE_SPAPR_TCE: { 1017 struct kvm_create_spapr_tce create_tce; 1018 1019 r = -EFAULT; 1020 if (copy_from_user(&create_tce, argp, sizeof(create_tce))) 1021 goto out; 1022 r = kvm_vm_ioctl_create_spapr_tce(kvm, &create_tce); 1023 goto out; 1024 } 1025 #endif /* CONFIG_PPC_BOOK3S_64 */ 1026 1027 #ifdef CONFIG_KVM_BOOK3S_64_HV 1028 case KVM_ALLOCATE_RMA: { 1029 struct kvm_allocate_rma rma; 1030 struct kvm *kvm = filp->private_data; 1031 1032 r = kvm_vm_ioctl_allocate_rma(kvm, &rma); 1033 if (r >= 0 && copy_to_user(argp, &rma, sizeof(rma))) 1034 r = -EFAULT; 1035 break; 1036 } 1037 1038 case KVM_PPC_ALLOCATE_HTAB: { 1039 u32 htab_order; 1040 1041 r = -EFAULT; 1042 if (get_user(htab_order, (u32 __user *)argp)) 1043 break; 1044 r = kvmppc_alloc_reset_hpt(kvm, &htab_order); 1045 if (r) 1046 break; 1047 r = -EFAULT; 1048 if (put_user(htab_order, (u32 __user *)argp)) 1049 break; 1050 r = 0; 1051 break; 1052 } 1053 1054 case KVM_PPC_GET_HTAB_FD: { 1055 struct kvm_get_htab_fd ghf; 1056 1057 r = -EFAULT; 1058 if (copy_from_user(&ghf, argp, sizeof(ghf))) 1059 break; 1060 r = kvm_vm_ioctl_get_htab_fd(kvm, &ghf); 1061 break; 1062 } 1063 #endif /* CONFIG_KVM_BOOK3S_64_HV */ 1064 1065 #ifdef CONFIG_PPC_BOOK3S_64 1066 case KVM_PPC_GET_SMMU_INFO: { 1067 struct kvm_ppc_smmu_info info; 1068 1069 memset(&info, 0, sizeof(info)); 1070 r = kvm_vm_ioctl_get_smmu_info(kvm, &info); 1071 if (r >= 0 && copy_to_user(argp, &info, sizeof(info))) 1072 r = -EFAULT; 1073 break; 1074 } 1075 case KVM_PPC_RTAS_DEFINE_TOKEN: { 1076 struct kvm *kvm = filp->private_data; 1077 1078 r = kvm_vm_ioctl_rtas_define_token(kvm, argp); 1079 break; 1080 } 1081 #endif /* CONFIG_PPC_BOOK3S_64 */ 1082 default: 1083 r = -ENOTTY; 1084 } 1085 1086 out: 1087 return r; 1088 } 1089 1090 static unsigned long lpid_inuse[BITS_TO_LONGS(KVMPPC_NR_LPIDS)]; 1091 static unsigned long nr_lpids; 1092 1093 long kvmppc_alloc_lpid(void) 1094 { 1095 long lpid; 1096 1097 do { 1098 lpid = find_first_zero_bit(lpid_inuse, KVMPPC_NR_LPIDS); 1099 if (lpid >= nr_lpids) { 1100 pr_err("%s: No LPIDs free\n", __func__); 1101 return -ENOMEM; 1102 } 1103 } while (test_and_set_bit(lpid, lpid_inuse)); 1104 1105 return lpid; 1106 } 1107 1108 void kvmppc_claim_lpid(long lpid) 1109 { 1110 set_bit(lpid, lpid_inuse); 1111 } 1112 1113 void kvmppc_free_lpid(long lpid) 1114 { 1115 clear_bit(lpid, lpid_inuse); 1116 } 1117 1118 void kvmppc_init_lpid(unsigned long nr_lpids_param) 1119 { 1120 nr_lpids = min_t(unsigned long, KVMPPC_NR_LPIDS, nr_lpids_param); 1121 memset(lpid_inuse, 0, sizeof(lpid_inuse)); 1122 } 1123 1124 int kvm_arch_init(void *opaque) 1125 { 1126 return 0; 1127 } 1128 1129 void kvm_arch_exit(void) 1130 { 1131 } 1132