1bbf45ba5SHollis Blanchard /* 2bbf45ba5SHollis Blanchard * This program is free software; you can redistribute it and/or modify 3bbf45ba5SHollis Blanchard * it under the terms of the GNU General Public License, version 2, as 4bbf45ba5SHollis Blanchard * published by the Free Software Foundation. 5bbf45ba5SHollis Blanchard * 6bbf45ba5SHollis Blanchard * This program is distributed in the hope that it will be useful, 7bbf45ba5SHollis Blanchard * but WITHOUT ANY WARRANTY; without even the implied warranty of 8bbf45ba5SHollis Blanchard * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 9bbf45ba5SHollis Blanchard * GNU General Public License for more details. 10bbf45ba5SHollis Blanchard * 11bbf45ba5SHollis Blanchard * You should have received a copy of the GNU General Public License 12bbf45ba5SHollis Blanchard * along with this program; if not, write to the Free Software 13bbf45ba5SHollis Blanchard * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 14bbf45ba5SHollis Blanchard * 15bbf45ba5SHollis Blanchard * Copyright IBM Corp. 2007 16bbf45ba5SHollis Blanchard * 17bbf45ba5SHollis Blanchard * Authors: Hollis Blanchard <hollisb@us.ibm.com> 18bbf45ba5SHollis Blanchard * Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com> 19bbf45ba5SHollis Blanchard */ 20bbf45ba5SHollis Blanchard 21bbf45ba5SHollis Blanchard #include <linux/errno.h> 22bbf45ba5SHollis Blanchard #include <linux/err.h> 23bbf45ba5SHollis Blanchard #include <linux/kvm_host.h> 24bbf45ba5SHollis Blanchard #include <linux/vmalloc.h> 25544c6761SAlexander Graf #include <linux/hrtimer.h> 26bbf45ba5SHollis Blanchard #include <linux/fs.h> 275a0e3ad6STejun Heo #include <linux/slab.h> 28bbf45ba5SHollis Blanchard #include <asm/cputable.h> 29bbf45ba5SHollis Blanchard #include <asm/uaccess.h> 30bbf45ba5SHollis Blanchard #include <asm/kvm_ppc.h> 3183aae4a8SHollis Blanchard #include <asm/tlbflush.h> 32371fefd6SPaul Mackerras #include <asm/cputhreads.h> 3373e75b41SHollis Blanchard #include "timing.h" 34fad7b9b5SPaul Mackerras #include "../mm/mmu_decl.h" 35bbf45ba5SHollis Blanchard 3646f43c6eSMarcelo Tosatti #define CREATE_TRACE_POINTS 3746f43c6eSMarcelo Tosatti #include "trace.h" 3846f43c6eSMarcelo Tosatti 39bbf45ba5SHollis Blanchard int kvm_arch_vcpu_runnable(struct kvm_vcpu *v) 40bbf45ba5SHollis Blanchard { 41666e7252SAlexander Graf return !(v->arch.shared->msr & MSR_WE) || 42666e7252SAlexander Graf !!(v->arch.pending_exceptions); 43bbf45ba5SHollis Blanchard } 44bbf45ba5SHollis Blanchard 452a342ed5SAlexander Graf int kvmppc_kvm_pv(struct kvm_vcpu *vcpu) 462a342ed5SAlexander Graf { 472a342ed5SAlexander Graf int nr = kvmppc_get_gpr(vcpu, 11); 482a342ed5SAlexander Graf int r; 492a342ed5SAlexander Graf unsigned long __maybe_unused param1 = kvmppc_get_gpr(vcpu, 3); 502a342ed5SAlexander Graf unsigned long __maybe_unused param2 = kvmppc_get_gpr(vcpu, 4); 512a342ed5SAlexander Graf unsigned long __maybe_unused param3 = kvmppc_get_gpr(vcpu, 5); 522a342ed5SAlexander Graf unsigned long __maybe_unused param4 = kvmppc_get_gpr(vcpu, 6); 532a342ed5SAlexander Graf unsigned long r2 = 0; 542a342ed5SAlexander Graf 552a342ed5SAlexander Graf if (!(vcpu->arch.shared->msr & MSR_SF)) { 562a342ed5SAlexander Graf /* 32 bit mode */ 572a342ed5SAlexander Graf param1 &= 0xffffffff; 582a342ed5SAlexander Graf param2 &= 0xffffffff; 592a342ed5SAlexander Graf param3 &= 0xffffffff; 602a342ed5SAlexander Graf param4 &= 0xffffffff; 612a342ed5SAlexander Graf } 622a342ed5SAlexander Graf 632a342ed5SAlexander Graf switch (nr) { 645fc87407SAlexander Graf case HC_VENDOR_KVM | KVM_HC_PPC_MAP_MAGIC_PAGE: 655fc87407SAlexander Graf { 665fc87407SAlexander Graf vcpu->arch.magic_page_pa = param1; 675fc87407SAlexander Graf vcpu->arch.magic_page_ea = param2; 685fc87407SAlexander Graf 69df1bfa25SAlexander Graf r2 = KVM_MAGIC_FEAT_SR; 707508e16cSAlexander Graf 715fc87407SAlexander Graf r = HC_EV_SUCCESS; 725fc87407SAlexander Graf break; 735fc87407SAlexander Graf } 742a342ed5SAlexander Graf case HC_VENDOR_KVM | KVM_HC_FEATURES: 752a342ed5SAlexander Graf r = HC_EV_SUCCESS; 76a4cd8b23SScott Wood #if defined(CONFIG_PPC_BOOK3S) || defined(CONFIG_KVM_E500) 77a4cd8b23SScott Wood /* XXX Missing magic page on 44x */ 785fc87407SAlexander Graf r2 |= (1 << KVM_FEATURE_MAGIC_PAGE); 795fc87407SAlexander Graf #endif 802a342ed5SAlexander Graf 812a342ed5SAlexander Graf /* Second return value is in r4 */ 822a342ed5SAlexander Graf break; 832a342ed5SAlexander Graf default: 842a342ed5SAlexander Graf r = HC_EV_UNIMPLEMENTED; 852a342ed5SAlexander Graf break; 862a342ed5SAlexander Graf } 872a342ed5SAlexander Graf 887508e16cSAlexander Graf kvmppc_set_gpr(vcpu, 4, r2); 897508e16cSAlexander Graf 902a342ed5SAlexander Graf return r; 912a342ed5SAlexander Graf } 92bbf45ba5SHollis Blanchard 93af8f38b3SAlexander Graf int kvmppc_sanity_check(struct kvm_vcpu *vcpu) 94af8f38b3SAlexander Graf { 95af8f38b3SAlexander Graf int r = false; 96af8f38b3SAlexander Graf 97af8f38b3SAlexander Graf /* We have to know what CPU to virtualize */ 98af8f38b3SAlexander Graf if (!vcpu->arch.pvr) 99af8f38b3SAlexander Graf goto out; 100af8f38b3SAlexander Graf 101af8f38b3SAlexander Graf /* PAPR only works with book3s_64 */ 102af8f38b3SAlexander Graf if ((vcpu->arch.cpu_type != KVM_CPU_3S_64) && vcpu->arch.papr_enabled) 103af8f38b3SAlexander Graf goto out; 104af8f38b3SAlexander Graf 105af8f38b3SAlexander Graf #ifdef CONFIG_KVM_BOOK3S_64_HV 106af8f38b3SAlexander Graf /* HV KVM can only do PAPR mode for now */ 107af8f38b3SAlexander Graf if (!vcpu->arch.papr_enabled) 108af8f38b3SAlexander Graf goto out; 109af8f38b3SAlexander Graf #endif 110af8f38b3SAlexander Graf 111af8f38b3SAlexander Graf r = true; 112af8f38b3SAlexander Graf 113af8f38b3SAlexander Graf out: 114af8f38b3SAlexander Graf vcpu->arch.sane = r; 115af8f38b3SAlexander Graf return r ? 0 : -EINVAL; 116af8f38b3SAlexander Graf } 117af8f38b3SAlexander Graf 118bbf45ba5SHollis Blanchard int kvmppc_emulate_mmio(struct kvm_run *run, struct kvm_vcpu *vcpu) 119bbf45ba5SHollis Blanchard { 120bbf45ba5SHollis Blanchard enum emulation_result er; 121bbf45ba5SHollis Blanchard int r; 122bbf45ba5SHollis Blanchard 123bbf45ba5SHollis Blanchard er = kvmppc_emulate_instruction(run, vcpu); 124bbf45ba5SHollis Blanchard switch (er) { 125bbf45ba5SHollis Blanchard case EMULATE_DONE: 126bbf45ba5SHollis Blanchard /* Future optimization: only reload non-volatiles if they were 127bbf45ba5SHollis Blanchard * actually modified. */ 128bbf45ba5SHollis Blanchard r = RESUME_GUEST_NV; 129bbf45ba5SHollis Blanchard break; 130bbf45ba5SHollis Blanchard case EMULATE_DO_MMIO: 131bbf45ba5SHollis Blanchard run->exit_reason = KVM_EXIT_MMIO; 132bbf45ba5SHollis Blanchard /* We must reload nonvolatiles because "update" load/store 133bbf45ba5SHollis Blanchard * instructions modify register state. */ 134bbf45ba5SHollis Blanchard /* Future optimization: only reload non-volatiles if they were 135bbf45ba5SHollis Blanchard * actually modified. */ 136bbf45ba5SHollis Blanchard r = RESUME_HOST_NV; 137bbf45ba5SHollis Blanchard break; 138bbf45ba5SHollis Blanchard case EMULATE_FAIL: 139bbf45ba5SHollis Blanchard /* XXX Deliver Program interrupt to guest. */ 140bbf45ba5SHollis Blanchard printk(KERN_EMERG "%s: emulation failed (%08x)\n", __func__, 141c7f38f46SAlexander Graf kvmppc_get_last_inst(vcpu)); 142bbf45ba5SHollis Blanchard r = RESUME_HOST; 143bbf45ba5SHollis Blanchard break; 144bbf45ba5SHollis Blanchard default: 145bbf45ba5SHollis Blanchard BUG(); 146bbf45ba5SHollis Blanchard } 147bbf45ba5SHollis Blanchard 148bbf45ba5SHollis Blanchard return r; 149bbf45ba5SHollis Blanchard } 150bbf45ba5SHollis Blanchard 15110474ae8SAlexander Graf int kvm_arch_hardware_enable(void *garbage) 152bbf45ba5SHollis Blanchard { 15310474ae8SAlexander Graf return 0; 154bbf45ba5SHollis Blanchard } 155bbf45ba5SHollis Blanchard 156bbf45ba5SHollis Blanchard void kvm_arch_hardware_disable(void *garbage) 157bbf45ba5SHollis Blanchard { 158bbf45ba5SHollis Blanchard } 159bbf45ba5SHollis Blanchard 160bbf45ba5SHollis Blanchard int kvm_arch_hardware_setup(void) 161bbf45ba5SHollis Blanchard { 162bbf45ba5SHollis Blanchard return 0; 163bbf45ba5SHollis Blanchard } 164bbf45ba5SHollis Blanchard 165bbf45ba5SHollis Blanchard void kvm_arch_hardware_unsetup(void) 166bbf45ba5SHollis Blanchard { 167bbf45ba5SHollis Blanchard } 168bbf45ba5SHollis Blanchard 169bbf45ba5SHollis Blanchard void kvm_arch_check_processor_compat(void *rtn) 170bbf45ba5SHollis Blanchard { 1719dd921cfSHollis Blanchard *(int *)rtn = kvmppc_core_check_processor_compat(); 172bbf45ba5SHollis Blanchard } 173bbf45ba5SHollis Blanchard 174e08b9637SCarsten Otte int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 175bbf45ba5SHollis Blanchard { 176e08b9637SCarsten Otte if (type) 177e08b9637SCarsten Otte return -EINVAL; 178e08b9637SCarsten Otte 179f9e0554dSPaul Mackerras return kvmppc_core_init_vm(kvm); 180bbf45ba5SHollis Blanchard } 181bbf45ba5SHollis Blanchard 182d89f5effSJan Kiszka void kvm_arch_destroy_vm(struct kvm *kvm) 183bbf45ba5SHollis Blanchard { 184bbf45ba5SHollis Blanchard unsigned int i; 185988a2caeSGleb Natapov struct kvm_vcpu *vcpu; 186bbf45ba5SHollis Blanchard 187988a2caeSGleb Natapov kvm_for_each_vcpu(i, vcpu, kvm) 188988a2caeSGleb Natapov kvm_arch_vcpu_free(vcpu); 189988a2caeSGleb Natapov 190988a2caeSGleb Natapov mutex_lock(&kvm->lock); 191988a2caeSGleb Natapov for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 192bbf45ba5SHollis Blanchard kvm->vcpus[i] = NULL; 193988a2caeSGleb Natapov 194988a2caeSGleb Natapov atomic_set(&kvm->online_vcpus, 0); 195f9e0554dSPaul Mackerras 196f9e0554dSPaul Mackerras kvmppc_core_destroy_vm(kvm); 197f9e0554dSPaul Mackerras 198988a2caeSGleb Natapov mutex_unlock(&kvm->lock); 199bbf45ba5SHollis Blanchard } 200bbf45ba5SHollis Blanchard 201ad8ba2cdSSheng Yang void kvm_arch_sync_events(struct kvm *kvm) 202ad8ba2cdSSheng Yang { 203ad8ba2cdSSheng Yang } 204ad8ba2cdSSheng Yang 205bbf45ba5SHollis Blanchard int kvm_dev_ioctl_check_extension(long ext) 206bbf45ba5SHollis Blanchard { 207bbf45ba5SHollis Blanchard int r; 208bbf45ba5SHollis Blanchard 209bbf45ba5SHollis Blanchard switch (ext) { 2105ce941eeSScott Wood #ifdef CONFIG_BOOKE 2115ce941eeSScott Wood case KVM_CAP_PPC_BOOKE_SREGS: 2125ce941eeSScott Wood #else 213e15a1137SAlexander Graf case KVM_CAP_PPC_SEGSTATE: 214930b412aSAlexander Graf case KVM_CAP_PPC_PAPR: 2155ce941eeSScott Wood #endif 21618978768SAlexander Graf case KVM_CAP_PPC_UNSET_IRQ: 2177b4203e8SAlexander Graf case KVM_CAP_PPC_IRQ_LEVEL: 21871fbfd5fSAlexander Graf case KVM_CAP_ENABLE_CAP: 219de56a948SPaul Mackerras r = 1; 220de56a948SPaul Mackerras break; 221de56a948SPaul Mackerras #ifndef CONFIG_KVM_BOOK3S_64_HV 222de56a948SPaul Mackerras case KVM_CAP_PPC_PAIRED_SINGLES: 223ad0a048bSAlexander Graf case KVM_CAP_PPC_OSI: 22415711e9cSAlexander Graf case KVM_CAP_PPC_GET_PVINFO: 225e15a1137SAlexander Graf r = 1; 226e15a1137SAlexander Graf break; 227588968b6SLaurent Vivier case KVM_CAP_COALESCED_MMIO: 228588968b6SLaurent Vivier r = KVM_COALESCED_MMIO_PAGE_OFFSET; 229588968b6SLaurent Vivier break; 230de56a948SPaul Mackerras #endif 23154738c09SDavid Gibson #ifdef CONFIG_KVM_BOOK3S_64_HV 23254738c09SDavid Gibson case KVM_CAP_SPAPR_TCE: 23354738c09SDavid Gibson r = 1; 23454738c09SDavid Gibson break; 235371fefd6SPaul Mackerras case KVM_CAP_PPC_SMT: 236371fefd6SPaul Mackerras r = threads_per_core; 237371fefd6SPaul Mackerras break; 238aa04b4ccSPaul Mackerras case KVM_CAP_PPC_RMA: 239aa04b4ccSPaul Mackerras r = 1; 2409e368f29SPaul Mackerras /* PPC970 requires an RMA */ 2419e368f29SPaul Mackerras if (cpu_has_feature(CPU_FTR_ARCH_201)) 2429e368f29SPaul Mackerras r = 2; 243aa04b4ccSPaul Mackerras break; 24454738c09SDavid Gibson #endif 245bbf45ba5SHollis Blanchard default: 246bbf45ba5SHollis Blanchard r = 0; 247bbf45ba5SHollis Blanchard break; 248bbf45ba5SHollis Blanchard } 249bbf45ba5SHollis Blanchard return r; 250bbf45ba5SHollis Blanchard 251bbf45ba5SHollis Blanchard } 252bbf45ba5SHollis Blanchard 253bbf45ba5SHollis Blanchard long kvm_arch_dev_ioctl(struct file *filp, 254bbf45ba5SHollis Blanchard unsigned int ioctl, unsigned long arg) 255bbf45ba5SHollis Blanchard { 256bbf45ba5SHollis Blanchard return -EINVAL; 257bbf45ba5SHollis Blanchard } 258bbf45ba5SHollis Blanchard 259f7784b8eSMarcelo Tosatti int kvm_arch_prepare_memory_region(struct kvm *kvm, 260f7784b8eSMarcelo Tosatti struct kvm_memory_slot *memslot, 261bbf45ba5SHollis Blanchard struct kvm_memory_slot old, 262f7784b8eSMarcelo Tosatti struct kvm_userspace_memory_region *mem, 263bbf45ba5SHollis Blanchard int user_alloc) 264bbf45ba5SHollis Blanchard { 265f9e0554dSPaul Mackerras return kvmppc_core_prepare_memory_region(kvm, mem); 266bbf45ba5SHollis Blanchard } 267bbf45ba5SHollis Blanchard 268f7784b8eSMarcelo Tosatti void kvm_arch_commit_memory_region(struct kvm *kvm, 269f7784b8eSMarcelo Tosatti struct kvm_userspace_memory_region *mem, 270f7784b8eSMarcelo Tosatti struct kvm_memory_slot old, 271f7784b8eSMarcelo Tosatti int user_alloc) 272f7784b8eSMarcelo Tosatti { 273f9e0554dSPaul Mackerras kvmppc_core_commit_memory_region(kvm, mem); 274f7784b8eSMarcelo Tosatti } 275f7784b8eSMarcelo Tosatti 276f7784b8eSMarcelo Tosatti 27734d4cb8fSMarcelo Tosatti void kvm_arch_flush_shadow(struct kvm *kvm) 27834d4cb8fSMarcelo Tosatti { 27934d4cb8fSMarcelo Tosatti } 28034d4cb8fSMarcelo Tosatti 281bbf45ba5SHollis Blanchard struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id) 282bbf45ba5SHollis Blanchard { 28373e75b41SHollis Blanchard struct kvm_vcpu *vcpu; 28473e75b41SHollis Blanchard vcpu = kvmppc_core_vcpu_create(kvm, id); 28519ccb76aSPaul Mackerras vcpu->arch.wqp = &vcpu->wq; 28606056bfbSWei Yongjun if (!IS_ERR(vcpu)) 28773e75b41SHollis Blanchard kvmppc_create_vcpu_debugfs(vcpu, id); 28873e75b41SHollis Blanchard return vcpu; 289bbf45ba5SHollis Blanchard } 290bbf45ba5SHollis Blanchard 291bbf45ba5SHollis Blanchard void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu) 292bbf45ba5SHollis Blanchard { 293a595405dSAlexander Graf /* Make sure we're not using the vcpu anymore */ 294a595405dSAlexander Graf hrtimer_cancel(&vcpu->arch.dec_timer); 295a595405dSAlexander Graf tasklet_kill(&vcpu->arch.tasklet); 296a595405dSAlexander Graf 29773e75b41SHollis Blanchard kvmppc_remove_vcpu_debugfs(vcpu); 298db93f574SHollis Blanchard kvmppc_core_vcpu_free(vcpu); 299bbf45ba5SHollis Blanchard } 300bbf45ba5SHollis Blanchard 301bbf45ba5SHollis Blanchard void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 302bbf45ba5SHollis Blanchard { 303bbf45ba5SHollis Blanchard kvm_arch_vcpu_free(vcpu); 304bbf45ba5SHollis Blanchard } 305bbf45ba5SHollis Blanchard 306bbf45ba5SHollis Blanchard int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu) 307bbf45ba5SHollis Blanchard { 3089dd921cfSHollis Blanchard return kvmppc_core_pending_dec(vcpu); 309bbf45ba5SHollis Blanchard } 310bbf45ba5SHollis Blanchard 311bbf45ba5SHollis Blanchard static void kvmppc_decrementer_func(unsigned long data) 312bbf45ba5SHollis Blanchard { 313bbf45ba5SHollis Blanchard struct kvm_vcpu *vcpu = (struct kvm_vcpu *)data; 314bbf45ba5SHollis Blanchard 3159dd921cfSHollis Blanchard kvmppc_core_queue_dec(vcpu); 31645c5eb67SHollis Blanchard 31719ccb76aSPaul Mackerras if (waitqueue_active(vcpu->arch.wqp)) { 31819ccb76aSPaul Mackerras wake_up_interruptible(vcpu->arch.wqp); 31945c5eb67SHollis Blanchard vcpu->stat.halt_wakeup++; 32045c5eb67SHollis Blanchard } 321bbf45ba5SHollis Blanchard } 322bbf45ba5SHollis Blanchard 323544c6761SAlexander Graf /* 324544c6761SAlexander Graf * low level hrtimer wake routine. Because this runs in hardirq context 325544c6761SAlexander Graf * we schedule a tasklet to do the real work. 326544c6761SAlexander Graf */ 327544c6761SAlexander Graf enum hrtimer_restart kvmppc_decrementer_wakeup(struct hrtimer *timer) 328544c6761SAlexander Graf { 329544c6761SAlexander Graf struct kvm_vcpu *vcpu; 330544c6761SAlexander Graf 331544c6761SAlexander Graf vcpu = container_of(timer, struct kvm_vcpu, arch.dec_timer); 332544c6761SAlexander Graf tasklet_schedule(&vcpu->arch.tasklet); 333544c6761SAlexander Graf 334544c6761SAlexander Graf return HRTIMER_NORESTART; 335544c6761SAlexander Graf } 336544c6761SAlexander Graf 337bbf45ba5SHollis Blanchard int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 338bbf45ba5SHollis Blanchard { 339544c6761SAlexander Graf hrtimer_init(&vcpu->arch.dec_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS); 340544c6761SAlexander Graf tasklet_init(&vcpu->arch.tasklet, kvmppc_decrementer_func, (ulong)vcpu); 341544c6761SAlexander Graf vcpu->arch.dec_timer.function = kvmppc_decrementer_wakeup; 342de56a948SPaul Mackerras vcpu->arch.dec_expires = ~(u64)0; 343bbf45ba5SHollis Blanchard 34409000adbSBharat Bhushan #ifdef CONFIG_KVM_EXIT_TIMING 34509000adbSBharat Bhushan mutex_init(&vcpu->arch.exit_timing_lock); 34609000adbSBharat Bhushan #endif 34709000adbSBharat Bhushan 348bbf45ba5SHollis Blanchard return 0; 349bbf45ba5SHollis Blanchard } 350bbf45ba5SHollis Blanchard 351bbf45ba5SHollis Blanchard void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) 352bbf45ba5SHollis Blanchard { 353ecc0981fSHollis Blanchard kvmppc_mmu_destroy(vcpu); 354bbf45ba5SHollis Blanchard } 355bbf45ba5SHollis Blanchard 356bbf45ba5SHollis Blanchard void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 357bbf45ba5SHollis Blanchard { 358eab17672SScott Wood #ifdef CONFIG_BOOKE 359eab17672SScott Wood /* 360eab17672SScott Wood * vrsave (formerly usprg0) isn't used by Linux, but may 361eab17672SScott Wood * be used by the guest. 362eab17672SScott Wood * 363eab17672SScott Wood * On non-booke this is associated with Altivec and 364eab17672SScott Wood * is handled by code in book3s.c. 365eab17672SScott Wood */ 366eab17672SScott Wood mtspr(SPRN_VRSAVE, vcpu->arch.vrsave); 367eab17672SScott Wood #endif 3689dd921cfSHollis Blanchard kvmppc_core_vcpu_load(vcpu, cpu); 369de56a948SPaul Mackerras vcpu->cpu = smp_processor_id(); 370bbf45ba5SHollis Blanchard } 371bbf45ba5SHollis Blanchard 372bbf45ba5SHollis Blanchard void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 373bbf45ba5SHollis Blanchard { 3749dd921cfSHollis Blanchard kvmppc_core_vcpu_put(vcpu); 375eab17672SScott Wood #ifdef CONFIG_BOOKE 376eab17672SScott Wood vcpu->arch.vrsave = mfspr(SPRN_VRSAVE); 377eab17672SScott Wood #endif 378de56a948SPaul Mackerras vcpu->cpu = -1; 379bbf45ba5SHollis Blanchard } 380bbf45ba5SHollis Blanchard 381d0bfb940SJan Kiszka int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 382d0bfb940SJan Kiszka struct kvm_guest_debug *dbg) 383bbf45ba5SHollis Blanchard { 384f5d0906bSHollis Blanchard return -EINVAL; 385bbf45ba5SHollis Blanchard } 386bbf45ba5SHollis Blanchard 387bbf45ba5SHollis Blanchard static void kvmppc_complete_dcr_load(struct kvm_vcpu *vcpu, 388bbf45ba5SHollis Blanchard struct kvm_run *run) 389bbf45ba5SHollis Blanchard { 3908e5b26b5SAlexander Graf kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, run->dcr.data); 391bbf45ba5SHollis Blanchard } 392bbf45ba5SHollis Blanchard 393bbf45ba5SHollis Blanchard static void kvmppc_complete_mmio_load(struct kvm_vcpu *vcpu, 394bbf45ba5SHollis Blanchard struct kvm_run *run) 395bbf45ba5SHollis Blanchard { 39669b61833SDenis Kirjanov u64 uninitialized_var(gpr); 397bbf45ba5SHollis Blanchard 3988e5b26b5SAlexander Graf if (run->mmio.len > sizeof(gpr)) { 399bbf45ba5SHollis Blanchard printk(KERN_ERR "bad MMIO length: %d\n", run->mmio.len); 400bbf45ba5SHollis Blanchard return; 401bbf45ba5SHollis Blanchard } 402bbf45ba5SHollis Blanchard 403bbf45ba5SHollis Blanchard if (vcpu->arch.mmio_is_bigendian) { 404bbf45ba5SHollis Blanchard switch (run->mmio.len) { 405b104d066SAlexander Graf case 8: gpr = *(u64 *)run->mmio.data; break; 4068e5b26b5SAlexander Graf case 4: gpr = *(u32 *)run->mmio.data; break; 4078e5b26b5SAlexander Graf case 2: gpr = *(u16 *)run->mmio.data; break; 4088e5b26b5SAlexander Graf case 1: gpr = *(u8 *)run->mmio.data; break; 409bbf45ba5SHollis Blanchard } 410bbf45ba5SHollis Blanchard } else { 411bbf45ba5SHollis Blanchard /* Convert BE data from userland back to LE. */ 412bbf45ba5SHollis Blanchard switch (run->mmio.len) { 4138e5b26b5SAlexander Graf case 4: gpr = ld_le32((u32 *)run->mmio.data); break; 4148e5b26b5SAlexander Graf case 2: gpr = ld_le16((u16 *)run->mmio.data); break; 4158e5b26b5SAlexander Graf case 1: gpr = *(u8 *)run->mmio.data; break; 416bbf45ba5SHollis Blanchard } 417bbf45ba5SHollis Blanchard } 4188e5b26b5SAlexander Graf 4193587d534SAlexander Graf if (vcpu->arch.mmio_sign_extend) { 4203587d534SAlexander Graf switch (run->mmio.len) { 4213587d534SAlexander Graf #ifdef CONFIG_PPC64 4223587d534SAlexander Graf case 4: 4233587d534SAlexander Graf gpr = (s64)(s32)gpr; 4243587d534SAlexander Graf break; 4253587d534SAlexander Graf #endif 4263587d534SAlexander Graf case 2: 4273587d534SAlexander Graf gpr = (s64)(s16)gpr; 4283587d534SAlexander Graf break; 4293587d534SAlexander Graf case 1: 4303587d534SAlexander Graf gpr = (s64)(s8)gpr; 4313587d534SAlexander Graf break; 4323587d534SAlexander Graf } 4333587d534SAlexander Graf } 4343587d534SAlexander Graf 4358e5b26b5SAlexander Graf kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr); 436b104d066SAlexander Graf 437b104d066SAlexander Graf switch (vcpu->arch.io_gpr & KVM_REG_EXT_MASK) { 438b104d066SAlexander Graf case KVM_REG_GPR: 439b104d066SAlexander Graf kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr); 440b104d066SAlexander Graf break; 441b104d066SAlexander Graf case KVM_REG_FPR: 442b104d066SAlexander Graf vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr; 443b104d066SAlexander Graf break; 444287d5611SAlexander Graf #ifdef CONFIG_PPC_BOOK3S 445b104d066SAlexander Graf case KVM_REG_QPR: 446b104d066SAlexander Graf vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr; 447b104d066SAlexander Graf break; 448b104d066SAlexander Graf case KVM_REG_FQPR: 449b104d066SAlexander Graf vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr; 450b104d066SAlexander Graf vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr; 451b104d066SAlexander Graf break; 452287d5611SAlexander Graf #endif 453b104d066SAlexander Graf default: 454b104d066SAlexander Graf BUG(); 455b104d066SAlexander Graf } 456bbf45ba5SHollis Blanchard } 457bbf45ba5SHollis Blanchard 458bbf45ba5SHollis Blanchard int kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu, 459bbf45ba5SHollis Blanchard unsigned int rt, unsigned int bytes, int is_bigendian) 460bbf45ba5SHollis Blanchard { 461bbf45ba5SHollis Blanchard if (bytes > sizeof(run->mmio.data)) { 462bbf45ba5SHollis Blanchard printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__, 463bbf45ba5SHollis Blanchard run->mmio.len); 464bbf45ba5SHollis Blanchard } 465bbf45ba5SHollis Blanchard 466bbf45ba5SHollis Blanchard run->mmio.phys_addr = vcpu->arch.paddr_accessed; 467bbf45ba5SHollis Blanchard run->mmio.len = bytes; 468bbf45ba5SHollis Blanchard run->mmio.is_write = 0; 469bbf45ba5SHollis Blanchard 470bbf45ba5SHollis Blanchard vcpu->arch.io_gpr = rt; 471bbf45ba5SHollis Blanchard vcpu->arch.mmio_is_bigendian = is_bigendian; 472bbf45ba5SHollis Blanchard vcpu->mmio_needed = 1; 473bbf45ba5SHollis Blanchard vcpu->mmio_is_write = 0; 4743587d534SAlexander Graf vcpu->arch.mmio_sign_extend = 0; 475bbf45ba5SHollis Blanchard 476bbf45ba5SHollis Blanchard return EMULATE_DO_MMIO; 477bbf45ba5SHollis Blanchard } 478bbf45ba5SHollis Blanchard 4793587d534SAlexander Graf /* Same as above, but sign extends */ 4803587d534SAlexander Graf int kvmppc_handle_loads(struct kvm_run *run, struct kvm_vcpu *vcpu, 4813587d534SAlexander Graf unsigned int rt, unsigned int bytes, int is_bigendian) 4823587d534SAlexander Graf { 4833587d534SAlexander Graf int r; 4843587d534SAlexander Graf 4853587d534SAlexander Graf r = kvmppc_handle_load(run, vcpu, rt, bytes, is_bigendian); 4863587d534SAlexander Graf vcpu->arch.mmio_sign_extend = 1; 4873587d534SAlexander Graf 4883587d534SAlexander Graf return r; 4893587d534SAlexander Graf } 4903587d534SAlexander Graf 491bbf45ba5SHollis Blanchard int kvmppc_handle_store(struct kvm_run *run, struct kvm_vcpu *vcpu, 492b104d066SAlexander Graf u64 val, unsigned int bytes, int is_bigendian) 493bbf45ba5SHollis Blanchard { 494bbf45ba5SHollis Blanchard void *data = run->mmio.data; 495bbf45ba5SHollis Blanchard 496bbf45ba5SHollis Blanchard if (bytes > sizeof(run->mmio.data)) { 497bbf45ba5SHollis Blanchard printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__, 498bbf45ba5SHollis Blanchard run->mmio.len); 499bbf45ba5SHollis Blanchard } 500bbf45ba5SHollis Blanchard 501bbf45ba5SHollis Blanchard run->mmio.phys_addr = vcpu->arch.paddr_accessed; 502bbf45ba5SHollis Blanchard run->mmio.len = bytes; 503bbf45ba5SHollis Blanchard run->mmio.is_write = 1; 504bbf45ba5SHollis Blanchard vcpu->mmio_needed = 1; 505bbf45ba5SHollis Blanchard vcpu->mmio_is_write = 1; 506bbf45ba5SHollis Blanchard 507bbf45ba5SHollis Blanchard /* Store the value at the lowest bytes in 'data'. */ 508bbf45ba5SHollis Blanchard if (is_bigendian) { 509bbf45ba5SHollis Blanchard switch (bytes) { 510b104d066SAlexander Graf case 8: *(u64 *)data = val; break; 511bbf45ba5SHollis Blanchard case 4: *(u32 *)data = val; break; 512bbf45ba5SHollis Blanchard case 2: *(u16 *)data = val; break; 513bbf45ba5SHollis Blanchard case 1: *(u8 *)data = val; break; 514bbf45ba5SHollis Blanchard } 515bbf45ba5SHollis Blanchard } else { 516bbf45ba5SHollis Blanchard /* Store LE value into 'data'. */ 517bbf45ba5SHollis Blanchard switch (bytes) { 518bbf45ba5SHollis Blanchard case 4: st_le32(data, val); break; 519bbf45ba5SHollis Blanchard case 2: st_le16(data, val); break; 520bbf45ba5SHollis Blanchard case 1: *(u8 *)data = val; break; 521bbf45ba5SHollis Blanchard } 522bbf45ba5SHollis Blanchard } 523bbf45ba5SHollis Blanchard 524bbf45ba5SHollis Blanchard return EMULATE_DO_MMIO; 525bbf45ba5SHollis Blanchard } 526bbf45ba5SHollis Blanchard 527bbf45ba5SHollis Blanchard int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run) 528bbf45ba5SHollis Blanchard { 529bbf45ba5SHollis Blanchard int r; 530bbf45ba5SHollis Blanchard sigset_t sigsaved; 531bbf45ba5SHollis Blanchard 532bbf45ba5SHollis Blanchard if (vcpu->sigset_active) 533bbf45ba5SHollis Blanchard sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); 534bbf45ba5SHollis Blanchard 535bbf45ba5SHollis Blanchard if (vcpu->mmio_needed) { 536bbf45ba5SHollis Blanchard if (!vcpu->mmio_is_write) 537bbf45ba5SHollis Blanchard kvmppc_complete_mmio_load(vcpu, run); 538bbf45ba5SHollis Blanchard vcpu->mmio_needed = 0; 539bbf45ba5SHollis Blanchard } else if (vcpu->arch.dcr_needed) { 540bbf45ba5SHollis Blanchard if (!vcpu->arch.dcr_is_write) 541bbf45ba5SHollis Blanchard kvmppc_complete_dcr_load(vcpu, run); 542bbf45ba5SHollis Blanchard vcpu->arch.dcr_needed = 0; 543ad0a048bSAlexander Graf } else if (vcpu->arch.osi_needed) { 544ad0a048bSAlexander Graf u64 *gprs = run->osi.gprs; 545ad0a048bSAlexander Graf int i; 546ad0a048bSAlexander Graf 547ad0a048bSAlexander Graf for (i = 0; i < 32; i++) 548ad0a048bSAlexander Graf kvmppc_set_gpr(vcpu, i, gprs[i]); 549ad0a048bSAlexander Graf vcpu->arch.osi_needed = 0; 550de56a948SPaul Mackerras } else if (vcpu->arch.hcall_needed) { 551de56a948SPaul Mackerras int i; 552de56a948SPaul Mackerras 553de56a948SPaul Mackerras kvmppc_set_gpr(vcpu, 3, run->papr_hcall.ret); 554de56a948SPaul Mackerras for (i = 0; i < 9; ++i) 555de56a948SPaul Mackerras kvmppc_set_gpr(vcpu, 4 + i, run->papr_hcall.args[i]); 556de56a948SPaul Mackerras vcpu->arch.hcall_needed = 0; 557bbf45ba5SHollis Blanchard } 558bbf45ba5SHollis Blanchard 5599dd921cfSHollis Blanchard kvmppc_core_deliver_interrupts(vcpu); 560bbf45ba5SHollis Blanchard 561df6909e5SPaul Mackerras r = kvmppc_vcpu_run(run, vcpu); 562bbf45ba5SHollis Blanchard 563bbf45ba5SHollis Blanchard if (vcpu->sigset_active) 564bbf45ba5SHollis Blanchard sigprocmask(SIG_SETMASK, &sigsaved, NULL); 565bbf45ba5SHollis Blanchard 566bbf45ba5SHollis Blanchard return r; 567bbf45ba5SHollis Blanchard } 568bbf45ba5SHollis Blanchard 569bbf45ba5SHollis Blanchard int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq) 570bbf45ba5SHollis Blanchard { 57119ccb76aSPaul Mackerras if (irq->irq == KVM_INTERRUPT_UNSET) { 57218978768SAlexander Graf kvmppc_core_dequeue_external(vcpu, irq); 57319ccb76aSPaul Mackerras return 0; 57419ccb76aSPaul Mackerras } 57519ccb76aSPaul Mackerras 5769dd921cfSHollis Blanchard kvmppc_core_queue_external(vcpu, irq); 57745c5eb67SHollis Blanchard 57819ccb76aSPaul Mackerras if (waitqueue_active(vcpu->arch.wqp)) { 57919ccb76aSPaul Mackerras wake_up_interruptible(vcpu->arch.wqp); 58045c5eb67SHollis Blanchard vcpu->stat.halt_wakeup++; 581de56a948SPaul Mackerras } else if (vcpu->cpu != -1) { 582de56a948SPaul Mackerras smp_send_reschedule(vcpu->cpu); 58345c5eb67SHollis Blanchard } 58445c5eb67SHollis Blanchard 585bbf45ba5SHollis Blanchard return 0; 586bbf45ba5SHollis Blanchard } 587bbf45ba5SHollis Blanchard 58871fbfd5fSAlexander Graf static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 58971fbfd5fSAlexander Graf struct kvm_enable_cap *cap) 59071fbfd5fSAlexander Graf { 59171fbfd5fSAlexander Graf int r; 59271fbfd5fSAlexander Graf 59371fbfd5fSAlexander Graf if (cap->flags) 59471fbfd5fSAlexander Graf return -EINVAL; 59571fbfd5fSAlexander Graf 59671fbfd5fSAlexander Graf switch (cap->cap) { 597ad0a048bSAlexander Graf case KVM_CAP_PPC_OSI: 598ad0a048bSAlexander Graf r = 0; 599ad0a048bSAlexander Graf vcpu->arch.osi_enabled = true; 600ad0a048bSAlexander Graf break; 601930b412aSAlexander Graf case KVM_CAP_PPC_PAPR: 602930b412aSAlexander Graf r = 0; 603930b412aSAlexander Graf vcpu->arch.papr_enabled = true; 604930b412aSAlexander Graf break; 60571fbfd5fSAlexander Graf default: 60671fbfd5fSAlexander Graf r = -EINVAL; 60771fbfd5fSAlexander Graf break; 60871fbfd5fSAlexander Graf } 60971fbfd5fSAlexander Graf 610af8f38b3SAlexander Graf if (!r) 611af8f38b3SAlexander Graf r = kvmppc_sanity_check(vcpu); 612af8f38b3SAlexander Graf 61371fbfd5fSAlexander Graf return r; 61471fbfd5fSAlexander Graf } 61571fbfd5fSAlexander Graf 616bbf45ba5SHollis Blanchard int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 617bbf45ba5SHollis Blanchard struct kvm_mp_state *mp_state) 618bbf45ba5SHollis Blanchard { 619bbf45ba5SHollis Blanchard return -EINVAL; 620bbf45ba5SHollis Blanchard } 621bbf45ba5SHollis Blanchard 622bbf45ba5SHollis Blanchard int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 623bbf45ba5SHollis Blanchard struct kvm_mp_state *mp_state) 624bbf45ba5SHollis Blanchard { 625bbf45ba5SHollis Blanchard return -EINVAL; 626bbf45ba5SHollis Blanchard } 627bbf45ba5SHollis Blanchard 628bbf45ba5SHollis Blanchard long kvm_arch_vcpu_ioctl(struct file *filp, 629bbf45ba5SHollis Blanchard unsigned int ioctl, unsigned long arg) 630bbf45ba5SHollis Blanchard { 631bbf45ba5SHollis Blanchard struct kvm_vcpu *vcpu = filp->private_data; 632bbf45ba5SHollis Blanchard void __user *argp = (void __user *)arg; 633bbf45ba5SHollis Blanchard long r; 634bbf45ba5SHollis Blanchard 63593736624SAvi Kivity switch (ioctl) { 63693736624SAvi Kivity case KVM_INTERRUPT: { 637bbf45ba5SHollis Blanchard struct kvm_interrupt irq; 638bbf45ba5SHollis Blanchard r = -EFAULT; 639bbf45ba5SHollis Blanchard if (copy_from_user(&irq, argp, sizeof(irq))) 64093736624SAvi Kivity goto out; 641bbf45ba5SHollis Blanchard r = kvm_vcpu_ioctl_interrupt(vcpu, &irq); 64293736624SAvi Kivity goto out; 643bbf45ba5SHollis Blanchard } 64419483d14SAvi Kivity 64571fbfd5fSAlexander Graf case KVM_ENABLE_CAP: 64671fbfd5fSAlexander Graf { 64771fbfd5fSAlexander Graf struct kvm_enable_cap cap; 64871fbfd5fSAlexander Graf r = -EFAULT; 64971fbfd5fSAlexander Graf if (copy_from_user(&cap, argp, sizeof(cap))) 65071fbfd5fSAlexander Graf goto out; 65171fbfd5fSAlexander Graf r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 65271fbfd5fSAlexander Graf break; 65371fbfd5fSAlexander Graf } 654bbf45ba5SHollis Blanchard default: 655bbf45ba5SHollis Blanchard r = -EINVAL; 656bbf45ba5SHollis Blanchard } 657bbf45ba5SHollis Blanchard 658bbf45ba5SHollis Blanchard out: 659bbf45ba5SHollis Blanchard return r; 660bbf45ba5SHollis Blanchard } 661bbf45ba5SHollis Blanchard 662*5b1c1493SCarsten Otte int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) 663*5b1c1493SCarsten Otte { 664*5b1c1493SCarsten Otte return VM_FAULT_SIGBUS; 665*5b1c1493SCarsten Otte } 666*5b1c1493SCarsten Otte 66715711e9cSAlexander Graf static int kvm_vm_ioctl_get_pvinfo(struct kvm_ppc_pvinfo *pvinfo) 66815711e9cSAlexander Graf { 66915711e9cSAlexander Graf u32 inst_lis = 0x3c000000; 67015711e9cSAlexander Graf u32 inst_ori = 0x60000000; 67115711e9cSAlexander Graf u32 inst_nop = 0x60000000; 67215711e9cSAlexander Graf u32 inst_sc = 0x44000002; 67315711e9cSAlexander Graf u32 inst_imm_mask = 0xffff; 67415711e9cSAlexander Graf 67515711e9cSAlexander Graf /* 67615711e9cSAlexander Graf * The hypercall to get into KVM from within guest context is as 67715711e9cSAlexander Graf * follows: 67815711e9cSAlexander Graf * 67915711e9cSAlexander Graf * lis r0, r0, KVM_SC_MAGIC_R0@h 68015711e9cSAlexander Graf * ori r0, KVM_SC_MAGIC_R0@l 68115711e9cSAlexander Graf * sc 68215711e9cSAlexander Graf * nop 68315711e9cSAlexander Graf */ 68415711e9cSAlexander Graf pvinfo->hcall[0] = inst_lis | ((KVM_SC_MAGIC_R0 >> 16) & inst_imm_mask); 68515711e9cSAlexander Graf pvinfo->hcall[1] = inst_ori | (KVM_SC_MAGIC_R0 & inst_imm_mask); 68615711e9cSAlexander Graf pvinfo->hcall[2] = inst_sc; 68715711e9cSAlexander Graf pvinfo->hcall[3] = inst_nop; 68815711e9cSAlexander Graf 68915711e9cSAlexander Graf return 0; 69015711e9cSAlexander Graf } 69115711e9cSAlexander Graf 692bbf45ba5SHollis Blanchard long kvm_arch_vm_ioctl(struct file *filp, 693bbf45ba5SHollis Blanchard unsigned int ioctl, unsigned long arg) 694bbf45ba5SHollis Blanchard { 69515711e9cSAlexander Graf void __user *argp = (void __user *)arg; 696bbf45ba5SHollis Blanchard long r; 697bbf45ba5SHollis Blanchard 698bbf45ba5SHollis Blanchard switch (ioctl) { 69915711e9cSAlexander Graf case KVM_PPC_GET_PVINFO: { 70015711e9cSAlexander Graf struct kvm_ppc_pvinfo pvinfo; 701d8cdddcdSVasiliy Kulikov memset(&pvinfo, 0, sizeof(pvinfo)); 70215711e9cSAlexander Graf r = kvm_vm_ioctl_get_pvinfo(&pvinfo); 70315711e9cSAlexander Graf if (copy_to_user(argp, &pvinfo, sizeof(pvinfo))) { 70415711e9cSAlexander Graf r = -EFAULT; 70515711e9cSAlexander Graf goto out; 70615711e9cSAlexander Graf } 70715711e9cSAlexander Graf 70815711e9cSAlexander Graf break; 70915711e9cSAlexander Graf } 71054738c09SDavid Gibson #ifdef CONFIG_KVM_BOOK3S_64_HV 71154738c09SDavid Gibson case KVM_CREATE_SPAPR_TCE: { 71254738c09SDavid Gibson struct kvm_create_spapr_tce create_tce; 71354738c09SDavid Gibson struct kvm *kvm = filp->private_data; 71454738c09SDavid Gibson 71554738c09SDavid Gibson r = -EFAULT; 71654738c09SDavid Gibson if (copy_from_user(&create_tce, argp, sizeof(create_tce))) 71754738c09SDavid Gibson goto out; 71854738c09SDavid Gibson r = kvm_vm_ioctl_create_spapr_tce(kvm, &create_tce); 71954738c09SDavid Gibson goto out; 72054738c09SDavid Gibson } 721aa04b4ccSPaul Mackerras 722aa04b4ccSPaul Mackerras case KVM_ALLOCATE_RMA: { 723aa04b4ccSPaul Mackerras struct kvm *kvm = filp->private_data; 724aa04b4ccSPaul Mackerras struct kvm_allocate_rma rma; 725aa04b4ccSPaul Mackerras 726aa04b4ccSPaul Mackerras r = kvm_vm_ioctl_allocate_rma(kvm, &rma); 727aa04b4ccSPaul Mackerras if (r >= 0 && copy_to_user(argp, &rma, sizeof(rma))) 728aa04b4ccSPaul Mackerras r = -EFAULT; 729aa04b4ccSPaul Mackerras break; 730aa04b4ccSPaul Mackerras } 73154738c09SDavid Gibson #endif /* CONFIG_KVM_BOOK3S_64_HV */ 73254738c09SDavid Gibson 733bbf45ba5SHollis Blanchard default: 734367e1319SAvi Kivity r = -ENOTTY; 735bbf45ba5SHollis Blanchard } 736bbf45ba5SHollis Blanchard 73715711e9cSAlexander Graf out: 738bbf45ba5SHollis Blanchard return r; 739bbf45ba5SHollis Blanchard } 740bbf45ba5SHollis Blanchard 741bbf45ba5SHollis Blanchard int kvm_arch_init(void *opaque) 742bbf45ba5SHollis Blanchard { 743bbf45ba5SHollis Blanchard return 0; 744bbf45ba5SHollis Blanchard } 745bbf45ba5SHollis Blanchard 746bbf45ba5SHollis Blanchard void kvm_arch_exit(void) 747bbf45ba5SHollis Blanchard { 748bbf45ba5SHollis Blanchard } 749