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 <asm/cputhreads.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 #ifndef CONFIG_KVM_BOOK3S_64_HV 43 return !(v->arch.shared->msr & MSR_WE) || 44 !!(v->arch.pending_exceptions); 45 #else 46 return !(v->arch.ceded) || !!(v->arch.pending_exceptions); 47 #endif 48 } 49 50 int kvmppc_kvm_pv(struct kvm_vcpu *vcpu) 51 { 52 int nr = kvmppc_get_gpr(vcpu, 11); 53 int r; 54 unsigned long __maybe_unused param1 = kvmppc_get_gpr(vcpu, 3); 55 unsigned long __maybe_unused param2 = kvmppc_get_gpr(vcpu, 4); 56 unsigned long __maybe_unused param3 = kvmppc_get_gpr(vcpu, 5); 57 unsigned long __maybe_unused param4 = kvmppc_get_gpr(vcpu, 6); 58 unsigned long r2 = 0; 59 60 if (!(vcpu->arch.shared->msr & MSR_SF)) { 61 /* 32 bit mode */ 62 param1 &= 0xffffffff; 63 param2 &= 0xffffffff; 64 param3 &= 0xffffffff; 65 param4 &= 0xffffffff; 66 } 67 68 switch (nr) { 69 case HC_VENDOR_KVM | KVM_HC_PPC_MAP_MAGIC_PAGE: 70 { 71 vcpu->arch.magic_page_pa = param1; 72 vcpu->arch.magic_page_ea = param2; 73 74 r2 = KVM_MAGIC_FEAT_SR; 75 76 r = HC_EV_SUCCESS; 77 break; 78 } 79 case HC_VENDOR_KVM | KVM_HC_FEATURES: 80 r = HC_EV_SUCCESS; 81 #if defined(CONFIG_PPC_BOOK3S) || defined(CONFIG_KVM_E500) 82 /* XXX Missing magic page on 44x */ 83 r2 |= (1 << KVM_FEATURE_MAGIC_PAGE); 84 #endif 85 86 /* Second return value is in r4 */ 87 break; 88 default: 89 r = HC_EV_UNIMPLEMENTED; 90 break; 91 } 92 93 kvmppc_set_gpr(vcpu, 4, r2); 94 95 return r; 96 } 97 98 int kvmppc_emulate_mmio(struct kvm_run *run, struct kvm_vcpu *vcpu) 99 { 100 enum emulation_result er; 101 int r; 102 103 er = kvmppc_emulate_instruction(run, vcpu); 104 switch (er) { 105 case EMULATE_DONE: 106 /* Future optimization: only reload non-volatiles if they were 107 * actually modified. */ 108 r = RESUME_GUEST_NV; 109 break; 110 case EMULATE_DO_MMIO: 111 run->exit_reason = KVM_EXIT_MMIO; 112 /* We must reload nonvolatiles because "update" load/store 113 * instructions modify register state. */ 114 /* Future optimization: only reload non-volatiles if they were 115 * actually modified. */ 116 r = RESUME_HOST_NV; 117 break; 118 case EMULATE_FAIL: 119 /* XXX Deliver Program interrupt to guest. */ 120 printk(KERN_EMERG "%s: emulation failed (%08x)\n", __func__, 121 kvmppc_get_last_inst(vcpu)); 122 r = RESUME_HOST; 123 break; 124 default: 125 BUG(); 126 } 127 128 return r; 129 } 130 131 int kvm_arch_hardware_enable(void *garbage) 132 { 133 return 0; 134 } 135 136 void kvm_arch_hardware_disable(void *garbage) 137 { 138 } 139 140 int kvm_arch_hardware_setup(void) 141 { 142 return 0; 143 } 144 145 void kvm_arch_hardware_unsetup(void) 146 { 147 } 148 149 void kvm_arch_check_processor_compat(void *rtn) 150 { 151 *(int *)rtn = kvmppc_core_check_processor_compat(); 152 } 153 154 int kvm_arch_init_vm(struct kvm *kvm) 155 { 156 return kvmppc_core_init_vm(kvm); 157 } 158 159 void kvm_arch_destroy_vm(struct kvm *kvm) 160 { 161 unsigned int i; 162 struct kvm_vcpu *vcpu; 163 164 kvm_for_each_vcpu(i, vcpu, kvm) 165 kvm_arch_vcpu_free(vcpu); 166 167 mutex_lock(&kvm->lock); 168 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 169 kvm->vcpus[i] = NULL; 170 171 atomic_set(&kvm->online_vcpus, 0); 172 173 kvmppc_core_destroy_vm(kvm); 174 175 mutex_unlock(&kvm->lock); 176 } 177 178 void kvm_arch_sync_events(struct kvm *kvm) 179 { 180 } 181 182 int kvm_dev_ioctl_check_extension(long ext) 183 { 184 int r; 185 186 switch (ext) { 187 #ifdef CONFIG_BOOKE 188 case KVM_CAP_PPC_BOOKE_SREGS: 189 #else 190 case KVM_CAP_PPC_SEGSTATE: 191 #endif 192 case KVM_CAP_PPC_UNSET_IRQ: 193 case KVM_CAP_PPC_IRQ_LEVEL: 194 case KVM_CAP_ENABLE_CAP: 195 r = 1; 196 break; 197 #ifndef CONFIG_KVM_BOOK3S_64_HV 198 case KVM_CAP_PPC_PAIRED_SINGLES: 199 case KVM_CAP_PPC_OSI: 200 case KVM_CAP_PPC_GET_PVINFO: 201 r = 1; 202 break; 203 case KVM_CAP_COALESCED_MMIO: 204 r = KVM_COALESCED_MMIO_PAGE_OFFSET; 205 break; 206 #endif 207 #ifdef CONFIG_KVM_BOOK3S_64_HV 208 case KVM_CAP_SPAPR_TCE: 209 r = 1; 210 break; 211 case KVM_CAP_PPC_SMT: 212 r = threads_per_core; 213 break; 214 case KVM_CAP_PPC_RMA: 215 r = 1; 216 /* PPC970 requires an RMA */ 217 if (cpu_has_feature(CPU_FTR_ARCH_201)) 218 r = 2; 219 break; 220 #endif 221 default: 222 r = 0; 223 break; 224 } 225 return r; 226 227 } 228 229 long kvm_arch_dev_ioctl(struct file *filp, 230 unsigned int ioctl, unsigned long arg) 231 { 232 return -EINVAL; 233 } 234 235 int kvm_arch_prepare_memory_region(struct kvm *kvm, 236 struct kvm_memory_slot *memslot, 237 struct kvm_memory_slot old, 238 struct kvm_userspace_memory_region *mem, 239 int user_alloc) 240 { 241 return kvmppc_core_prepare_memory_region(kvm, mem); 242 } 243 244 void kvm_arch_commit_memory_region(struct kvm *kvm, 245 struct kvm_userspace_memory_region *mem, 246 struct kvm_memory_slot old, 247 int user_alloc) 248 { 249 kvmppc_core_commit_memory_region(kvm, mem); 250 } 251 252 253 void kvm_arch_flush_shadow(struct kvm *kvm) 254 { 255 } 256 257 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id) 258 { 259 struct kvm_vcpu *vcpu; 260 vcpu = kvmppc_core_vcpu_create(kvm, id); 261 if (!IS_ERR(vcpu)) 262 kvmppc_create_vcpu_debugfs(vcpu, id); 263 return vcpu; 264 } 265 266 void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu) 267 { 268 /* Make sure we're not using the vcpu anymore */ 269 hrtimer_cancel(&vcpu->arch.dec_timer); 270 tasklet_kill(&vcpu->arch.tasklet); 271 272 kvmppc_remove_vcpu_debugfs(vcpu); 273 kvmppc_core_vcpu_free(vcpu); 274 } 275 276 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 277 { 278 kvm_arch_vcpu_free(vcpu); 279 } 280 281 int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu) 282 { 283 return kvmppc_core_pending_dec(vcpu); 284 } 285 286 static void kvmppc_decrementer_func(unsigned long data) 287 { 288 struct kvm_vcpu *vcpu = (struct kvm_vcpu *)data; 289 290 kvmppc_core_queue_dec(vcpu); 291 292 if (waitqueue_active(&vcpu->wq)) { 293 wake_up_interruptible(&vcpu->wq); 294 vcpu->stat.halt_wakeup++; 295 } 296 } 297 298 /* 299 * low level hrtimer wake routine. Because this runs in hardirq context 300 * we schedule a tasklet to do the real work. 301 */ 302 enum hrtimer_restart kvmppc_decrementer_wakeup(struct hrtimer *timer) 303 { 304 struct kvm_vcpu *vcpu; 305 306 vcpu = container_of(timer, struct kvm_vcpu, arch.dec_timer); 307 tasklet_schedule(&vcpu->arch.tasklet); 308 309 return HRTIMER_NORESTART; 310 } 311 312 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 313 { 314 hrtimer_init(&vcpu->arch.dec_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS); 315 tasklet_init(&vcpu->arch.tasklet, kvmppc_decrementer_func, (ulong)vcpu); 316 vcpu->arch.dec_timer.function = kvmppc_decrementer_wakeup; 317 vcpu->arch.dec_expires = ~(u64)0; 318 319 #ifdef CONFIG_KVM_EXIT_TIMING 320 mutex_init(&vcpu->arch.exit_timing_lock); 321 #endif 322 323 return 0; 324 } 325 326 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) 327 { 328 kvmppc_mmu_destroy(vcpu); 329 } 330 331 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 332 { 333 #ifdef CONFIG_BOOKE 334 /* 335 * vrsave (formerly usprg0) isn't used by Linux, but may 336 * be used by the guest. 337 * 338 * On non-booke this is associated with Altivec and 339 * is handled by code in book3s.c. 340 */ 341 mtspr(SPRN_VRSAVE, vcpu->arch.vrsave); 342 #endif 343 kvmppc_core_vcpu_load(vcpu, cpu); 344 vcpu->cpu = smp_processor_id(); 345 } 346 347 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 348 { 349 kvmppc_core_vcpu_put(vcpu); 350 #ifdef CONFIG_BOOKE 351 vcpu->arch.vrsave = mfspr(SPRN_VRSAVE); 352 #endif 353 vcpu->cpu = -1; 354 } 355 356 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 357 struct kvm_guest_debug *dbg) 358 { 359 return -EINVAL; 360 } 361 362 static void kvmppc_complete_dcr_load(struct kvm_vcpu *vcpu, 363 struct kvm_run *run) 364 { 365 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, run->dcr.data); 366 } 367 368 static void kvmppc_complete_mmio_load(struct kvm_vcpu *vcpu, 369 struct kvm_run *run) 370 { 371 u64 uninitialized_var(gpr); 372 373 if (run->mmio.len > sizeof(gpr)) { 374 printk(KERN_ERR "bad MMIO length: %d\n", run->mmio.len); 375 return; 376 } 377 378 if (vcpu->arch.mmio_is_bigendian) { 379 switch (run->mmio.len) { 380 case 8: gpr = *(u64 *)run->mmio.data; break; 381 case 4: gpr = *(u32 *)run->mmio.data; break; 382 case 2: gpr = *(u16 *)run->mmio.data; break; 383 case 1: gpr = *(u8 *)run->mmio.data; break; 384 } 385 } else { 386 /* Convert BE data from userland back to LE. */ 387 switch (run->mmio.len) { 388 case 4: gpr = ld_le32((u32 *)run->mmio.data); break; 389 case 2: gpr = ld_le16((u16 *)run->mmio.data); break; 390 case 1: gpr = *(u8 *)run->mmio.data; break; 391 } 392 } 393 394 if (vcpu->arch.mmio_sign_extend) { 395 switch (run->mmio.len) { 396 #ifdef CONFIG_PPC64 397 case 4: 398 gpr = (s64)(s32)gpr; 399 break; 400 #endif 401 case 2: 402 gpr = (s64)(s16)gpr; 403 break; 404 case 1: 405 gpr = (s64)(s8)gpr; 406 break; 407 } 408 } 409 410 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr); 411 412 switch (vcpu->arch.io_gpr & KVM_REG_EXT_MASK) { 413 case KVM_REG_GPR: 414 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr); 415 break; 416 case KVM_REG_FPR: 417 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr; 418 break; 419 #ifdef CONFIG_PPC_BOOK3S 420 case KVM_REG_QPR: 421 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr; 422 break; 423 case KVM_REG_FQPR: 424 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr; 425 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr; 426 break; 427 #endif 428 default: 429 BUG(); 430 } 431 } 432 433 int kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu, 434 unsigned int rt, unsigned int bytes, int is_bigendian) 435 { 436 if (bytes > sizeof(run->mmio.data)) { 437 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__, 438 run->mmio.len); 439 } 440 441 run->mmio.phys_addr = vcpu->arch.paddr_accessed; 442 run->mmio.len = bytes; 443 run->mmio.is_write = 0; 444 445 vcpu->arch.io_gpr = rt; 446 vcpu->arch.mmio_is_bigendian = is_bigendian; 447 vcpu->mmio_needed = 1; 448 vcpu->mmio_is_write = 0; 449 vcpu->arch.mmio_sign_extend = 0; 450 451 return EMULATE_DO_MMIO; 452 } 453 454 /* Same as above, but sign extends */ 455 int kvmppc_handle_loads(struct kvm_run *run, struct kvm_vcpu *vcpu, 456 unsigned int rt, unsigned int bytes, int is_bigendian) 457 { 458 int r; 459 460 r = kvmppc_handle_load(run, vcpu, rt, bytes, is_bigendian); 461 vcpu->arch.mmio_sign_extend = 1; 462 463 return r; 464 } 465 466 int kvmppc_handle_store(struct kvm_run *run, struct kvm_vcpu *vcpu, 467 u64 val, unsigned int bytes, int is_bigendian) 468 { 469 void *data = run->mmio.data; 470 471 if (bytes > sizeof(run->mmio.data)) { 472 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__, 473 run->mmio.len); 474 } 475 476 run->mmio.phys_addr = vcpu->arch.paddr_accessed; 477 run->mmio.len = bytes; 478 run->mmio.is_write = 1; 479 vcpu->mmio_needed = 1; 480 vcpu->mmio_is_write = 1; 481 482 /* Store the value at the lowest bytes in 'data'. */ 483 if (is_bigendian) { 484 switch (bytes) { 485 case 8: *(u64 *)data = val; break; 486 case 4: *(u32 *)data = val; break; 487 case 2: *(u16 *)data = val; break; 488 case 1: *(u8 *)data = val; break; 489 } 490 } else { 491 /* Store LE value into 'data'. */ 492 switch (bytes) { 493 case 4: st_le32(data, val); break; 494 case 2: st_le16(data, val); break; 495 case 1: *(u8 *)data = val; break; 496 } 497 } 498 499 return EMULATE_DO_MMIO; 500 } 501 502 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run) 503 { 504 int r; 505 sigset_t sigsaved; 506 507 if (vcpu->sigset_active) 508 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); 509 510 if (vcpu->mmio_needed) { 511 if (!vcpu->mmio_is_write) 512 kvmppc_complete_mmio_load(vcpu, run); 513 vcpu->mmio_needed = 0; 514 } else if (vcpu->arch.dcr_needed) { 515 if (!vcpu->arch.dcr_is_write) 516 kvmppc_complete_dcr_load(vcpu, run); 517 vcpu->arch.dcr_needed = 0; 518 } else if (vcpu->arch.osi_needed) { 519 u64 *gprs = run->osi.gprs; 520 int i; 521 522 for (i = 0; i < 32; i++) 523 kvmppc_set_gpr(vcpu, i, gprs[i]); 524 vcpu->arch.osi_needed = 0; 525 } else if (vcpu->arch.hcall_needed) { 526 int i; 527 528 kvmppc_set_gpr(vcpu, 3, run->papr_hcall.ret); 529 for (i = 0; i < 9; ++i) 530 kvmppc_set_gpr(vcpu, 4 + i, run->papr_hcall.args[i]); 531 vcpu->arch.hcall_needed = 0; 532 } 533 534 kvmppc_core_deliver_interrupts(vcpu); 535 536 r = kvmppc_vcpu_run(run, vcpu); 537 538 if (vcpu->sigset_active) 539 sigprocmask(SIG_SETMASK, &sigsaved, NULL); 540 541 return r; 542 } 543 544 int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq) 545 { 546 if (irq->irq == KVM_INTERRUPT_UNSET) 547 kvmppc_core_dequeue_external(vcpu, irq); 548 else 549 kvmppc_core_queue_external(vcpu, irq); 550 551 if (waitqueue_active(&vcpu->wq)) { 552 wake_up_interruptible(&vcpu->wq); 553 vcpu->stat.halt_wakeup++; 554 } else if (vcpu->cpu != -1) { 555 smp_send_reschedule(vcpu->cpu); 556 } 557 558 return 0; 559 } 560 561 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 562 struct kvm_enable_cap *cap) 563 { 564 int r; 565 566 if (cap->flags) 567 return -EINVAL; 568 569 switch (cap->cap) { 570 case KVM_CAP_PPC_OSI: 571 r = 0; 572 vcpu->arch.osi_enabled = true; 573 break; 574 default: 575 r = -EINVAL; 576 break; 577 } 578 579 return r; 580 } 581 582 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 583 struct kvm_mp_state *mp_state) 584 { 585 return -EINVAL; 586 } 587 588 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 589 struct kvm_mp_state *mp_state) 590 { 591 return -EINVAL; 592 } 593 594 long kvm_arch_vcpu_ioctl(struct file *filp, 595 unsigned int ioctl, unsigned long arg) 596 { 597 struct kvm_vcpu *vcpu = filp->private_data; 598 void __user *argp = (void __user *)arg; 599 long r; 600 601 switch (ioctl) { 602 case KVM_INTERRUPT: { 603 struct kvm_interrupt irq; 604 r = -EFAULT; 605 if (copy_from_user(&irq, argp, sizeof(irq))) 606 goto out; 607 r = kvm_vcpu_ioctl_interrupt(vcpu, &irq); 608 goto out; 609 } 610 611 case KVM_ENABLE_CAP: 612 { 613 struct kvm_enable_cap cap; 614 r = -EFAULT; 615 if (copy_from_user(&cap, argp, sizeof(cap))) 616 goto out; 617 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 618 break; 619 } 620 default: 621 r = -EINVAL; 622 } 623 624 out: 625 return r; 626 } 627 628 static int kvm_vm_ioctl_get_pvinfo(struct kvm_ppc_pvinfo *pvinfo) 629 { 630 u32 inst_lis = 0x3c000000; 631 u32 inst_ori = 0x60000000; 632 u32 inst_nop = 0x60000000; 633 u32 inst_sc = 0x44000002; 634 u32 inst_imm_mask = 0xffff; 635 636 /* 637 * The hypercall to get into KVM from within guest context is as 638 * follows: 639 * 640 * lis r0, r0, KVM_SC_MAGIC_R0@h 641 * ori r0, KVM_SC_MAGIC_R0@l 642 * sc 643 * nop 644 */ 645 pvinfo->hcall[0] = inst_lis | ((KVM_SC_MAGIC_R0 >> 16) & inst_imm_mask); 646 pvinfo->hcall[1] = inst_ori | (KVM_SC_MAGIC_R0 & inst_imm_mask); 647 pvinfo->hcall[2] = inst_sc; 648 pvinfo->hcall[3] = inst_nop; 649 650 return 0; 651 } 652 653 long kvm_arch_vm_ioctl(struct file *filp, 654 unsigned int ioctl, unsigned long arg) 655 { 656 void __user *argp = (void __user *)arg; 657 long r; 658 659 switch (ioctl) { 660 case KVM_PPC_GET_PVINFO: { 661 struct kvm_ppc_pvinfo pvinfo; 662 memset(&pvinfo, 0, sizeof(pvinfo)); 663 r = kvm_vm_ioctl_get_pvinfo(&pvinfo); 664 if (copy_to_user(argp, &pvinfo, sizeof(pvinfo))) { 665 r = -EFAULT; 666 goto out; 667 } 668 669 break; 670 } 671 #ifdef CONFIG_KVM_BOOK3S_64_HV 672 case KVM_CREATE_SPAPR_TCE: { 673 struct kvm_create_spapr_tce create_tce; 674 struct kvm *kvm = filp->private_data; 675 676 r = -EFAULT; 677 if (copy_from_user(&create_tce, argp, sizeof(create_tce))) 678 goto out; 679 r = kvm_vm_ioctl_create_spapr_tce(kvm, &create_tce); 680 goto out; 681 } 682 683 case KVM_ALLOCATE_RMA: { 684 struct kvm *kvm = filp->private_data; 685 struct kvm_allocate_rma rma; 686 687 r = kvm_vm_ioctl_allocate_rma(kvm, &rma); 688 if (r >= 0 && copy_to_user(argp, &rma, sizeof(rma))) 689 r = -EFAULT; 690 break; 691 } 692 #endif /* CONFIG_KVM_BOOK3S_64_HV */ 693 694 default: 695 r = -ENOTTY; 696 } 697 698 out: 699 return r; 700 } 701 702 int kvm_arch_init(void *opaque) 703 { 704 return 0; 705 } 706 707 void kvm_arch_exit(void) 708 { 709 } 710