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