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) || 42dfd4d47eSScott Wood !!(v->arch.pending_exceptions) || 43dfd4d47eSScott Wood v->requests; 44bbf45ba5SHollis Blanchard } 45bbf45ba5SHollis Blanchard 46b6d33834SChristoffer Dall int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu) 47b6d33834SChristoffer Dall { 48b6d33834SChristoffer Dall return 1; 49b6d33834SChristoffer Dall } 50b6d33834SChristoffer Dall 512a342ed5SAlexander Graf int kvmppc_kvm_pv(struct kvm_vcpu *vcpu) 522a342ed5SAlexander Graf { 532a342ed5SAlexander Graf int nr = kvmppc_get_gpr(vcpu, 11); 542a342ed5SAlexander Graf int r; 552a342ed5SAlexander Graf unsigned long __maybe_unused param1 = kvmppc_get_gpr(vcpu, 3); 562a342ed5SAlexander Graf unsigned long __maybe_unused param2 = kvmppc_get_gpr(vcpu, 4); 572a342ed5SAlexander Graf unsigned long __maybe_unused param3 = kvmppc_get_gpr(vcpu, 5); 582a342ed5SAlexander Graf unsigned long __maybe_unused param4 = kvmppc_get_gpr(vcpu, 6); 592a342ed5SAlexander Graf unsigned long r2 = 0; 602a342ed5SAlexander Graf 612a342ed5SAlexander Graf if (!(vcpu->arch.shared->msr & MSR_SF)) { 622a342ed5SAlexander Graf /* 32 bit mode */ 632a342ed5SAlexander Graf param1 &= 0xffffffff; 642a342ed5SAlexander Graf param2 &= 0xffffffff; 652a342ed5SAlexander Graf param3 &= 0xffffffff; 662a342ed5SAlexander Graf param4 &= 0xffffffff; 672a342ed5SAlexander Graf } 682a342ed5SAlexander Graf 692a342ed5SAlexander Graf switch (nr) { 705fc87407SAlexander Graf case HC_VENDOR_KVM | KVM_HC_PPC_MAP_MAGIC_PAGE: 715fc87407SAlexander Graf { 725fc87407SAlexander Graf vcpu->arch.magic_page_pa = param1; 735fc87407SAlexander Graf vcpu->arch.magic_page_ea = param2; 745fc87407SAlexander Graf 75b5904972SScott Wood r2 = KVM_MAGIC_FEAT_SR | KVM_MAGIC_FEAT_MAS0_TO_SPRG7; 767508e16cSAlexander Graf 775fc87407SAlexander Graf r = HC_EV_SUCCESS; 785fc87407SAlexander Graf break; 795fc87407SAlexander Graf } 802a342ed5SAlexander Graf case HC_VENDOR_KVM | KVM_HC_FEATURES: 812a342ed5SAlexander Graf r = HC_EV_SUCCESS; 82bf7ca4bdSAlexander Graf #if defined(CONFIG_PPC_BOOK3S) || defined(CONFIG_KVM_E500V2) 83a4cd8b23SScott Wood /* XXX Missing magic page on 44x */ 845fc87407SAlexander Graf r2 |= (1 << KVM_FEATURE_MAGIC_PAGE); 855fc87407SAlexander Graf #endif 862a342ed5SAlexander Graf 872a342ed5SAlexander Graf /* Second return value is in r4 */ 882a342ed5SAlexander Graf break; 892a342ed5SAlexander Graf default: 902a342ed5SAlexander Graf r = HC_EV_UNIMPLEMENTED; 912a342ed5SAlexander Graf break; 922a342ed5SAlexander Graf } 932a342ed5SAlexander Graf 947508e16cSAlexander Graf kvmppc_set_gpr(vcpu, 4, r2); 957508e16cSAlexander Graf 962a342ed5SAlexander Graf return r; 972a342ed5SAlexander Graf } 98bbf45ba5SHollis Blanchard 99af8f38b3SAlexander Graf int kvmppc_sanity_check(struct kvm_vcpu *vcpu) 100af8f38b3SAlexander Graf { 101af8f38b3SAlexander Graf int r = false; 102af8f38b3SAlexander Graf 103af8f38b3SAlexander Graf /* We have to know what CPU to virtualize */ 104af8f38b3SAlexander Graf if (!vcpu->arch.pvr) 105af8f38b3SAlexander Graf goto out; 106af8f38b3SAlexander Graf 107af8f38b3SAlexander Graf /* PAPR only works with book3s_64 */ 108af8f38b3SAlexander Graf if ((vcpu->arch.cpu_type != KVM_CPU_3S_64) && vcpu->arch.papr_enabled) 109af8f38b3SAlexander Graf goto out; 110af8f38b3SAlexander Graf 111af8f38b3SAlexander Graf #ifdef CONFIG_KVM_BOOK3S_64_HV 112af8f38b3SAlexander Graf /* HV KVM can only do PAPR mode for now */ 113af8f38b3SAlexander Graf if (!vcpu->arch.papr_enabled) 114af8f38b3SAlexander Graf goto out; 115af8f38b3SAlexander Graf #endif 116af8f38b3SAlexander Graf 117d30f6e48SScott Wood #ifdef CONFIG_KVM_BOOKE_HV 118d30f6e48SScott Wood if (!cpu_has_feature(CPU_FTR_EMB_HV)) 119d30f6e48SScott Wood goto out; 120d30f6e48SScott Wood #endif 121d30f6e48SScott Wood 122af8f38b3SAlexander Graf r = true; 123af8f38b3SAlexander Graf 124af8f38b3SAlexander Graf out: 125af8f38b3SAlexander Graf vcpu->arch.sane = r; 126af8f38b3SAlexander Graf return r ? 0 : -EINVAL; 127af8f38b3SAlexander Graf } 128af8f38b3SAlexander Graf 129bbf45ba5SHollis Blanchard int kvmppc_emulate_mmio(struct kvm_run *run, struct kvm_vcpu *vcpu) 130bbf45ba5SHollis Blanchard { 131bbf45ba5SHollis Blanchard enum emulation_result er; 132bbf45ba5SHollis Blanchard int r; 133bbf45ba5SHollis Blanchard 134bbf45ba5SHollis Blanchard er = kvmppc_emulate_instruction(run, vcpu); 135bbf45ba5SHollis Blanchard switch (er) { 136bbf45ba5SHollis Blanchard case EMULATE_DONE: 137bbf45ba5SHollis Blanchard /* Future optimization: only reload non-volatiles if they were 138bbf45ba5SHollis Blanchard * actually modified. */ 139bbf45ba5SHollis Blanchard r = RESUME_GUEST_NV; 140bbf45ba5SHollis Blanchard break; 141bbf45ba5SHollis Blanchard case EMULATE_DO_MMIO: 142bbf45ba5SHollis Blanchard run->exit_reason = KVM_EXIT_MMIO; 143bbf45ba5SHollis Blanchard /* We must reload nonvolatiles because "update" load/store 144bbf45ba5SHollis Blanchard * instructions modify register state. */ 145bbf45ba5SHollis Blanchard /* Future optimization: only reload non-volatiles if they were 146bbf45ba5SHollis Blanchard * actually modified. */ 147bbf45ba5SHollis Blanchard r = RESUME_HOST_NV; 148bbf45ba5SHollis Blanchard break; 149bbf45ba5SHollis Blanchard case EMULATE_FAIL: 150bbf45ba5SHollis Blanchard /* XXX Deliver Program interrupt to guest. */ 151bbf45ba5SHollis Blanchard printk(KERN_EMERG "%s: emulation failed (%08x)\n", __func__, 152c7f38f46SAlexander Graf kvmppc_get_last_inst(vcpu)); 153bbf45ba5SHollis Blanchard r = RESUME_HOST; 154bbf45ba5SHollis Blanchard break; 155bbf45ba5SHollis Blanchard default: 156bbf45ba5SHollis Blanchard BUG(); 157bbf45ba5SHollis Blanchard } 158bbf45ba5SHollis Blanchard 159bbf45ba5SHollis Blanchard return r; 160bbf45ba5SHollis Blanchard } 161bbf45ba5SHollis Blanchard 16210474ae8SAlexander Graf int kvm_arch_hardware_enable(void *garbage) 163bbf45ba5SHollis Blanchard { 16410474ae8SAlexander Graf return 0; 165bbf45ba5SHollis Blanchard } 166bbf45ba5SHollis Blanchard 167bbf45ba5SHollis Blanchard void kvm_arch_hardware_disable(void *garbage) 168bbf45ba5SHollis Blanchard { 169bbf45ba5SHollis Blanchard } 170bbf45ba5SHollis Blanchard 171bbf45ba5SHollis Blanchard int kvm_arch_hardware_setup(void) 172bbf45ba5SHollis Blanchard { 173bbf45ba5SHollis Blanchard return 0; 174bbf45ba5SHollis Blanchard } 175bbf45ba5SHollis Blanchard 176bbf45ba5SHollis Blanchard void kvm_arch_hardware_unsetup(void) 177bbf45ba5SHollis Blanchard { 178bbf45ba5SHollis Blanchard } 179bbf45ba5SHollis Blanchard 180bbf45ba5SHollis Blanchard void kvm_arch_check_processor_compat(void *rtn) 181bbf45ba5SHollis Blanchard { 1829dd921cfSHollis Blanchard *(int *)rtn = kvmppc_core_check_processor_compat(); 183bbf45ba5SHollis Blanchard } 184bbf45ba5SHollis Blanchard 185e08b9637SCarsten Otte int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 186bbf45ba5SHollis Blanchard { 187e08b9637SCarsten Otte if (type) 188e08b9637SCarsten Otte return -EINVAL; 189e08b9637SCarsten Otte 190f9e0554dSPaul Mackerras return kvmppc_core_init_vm(kvm); 191bbf45ba5SHollis Blanchard } 192bbf45ba5SHollis Blanchard 193d89f5effSJan Kiszka void kvm_arch_destroy_vm(struct kvm *kvm) 194bbf45ba5SHollis Blanchard { 195bbf45ba5SHollis Blanchard unsigned int i; 196988a2caeSGleb Natapov struct kvm_vcpu *vcpu; 197bbf45ba5SHollis Blanchard 198988a2caeSGleb Natapov kvm_for_each_vcpu(i, vcpu, kvm) 199988a2caeSGleb Natapov kvm_arch_vcpu_free(vcpu); 200988a2caeSGleb Natapov 201988a2caeSGleb Natapov mutex_lock(&kvm->lock); 202988a2caeSGleb Natapov for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 203bbf45ba5SHollis Blanchard kvm->vcpus[i] = NULL; 204988a2caeSGleb Natapov 205988a2caeSGleb Natapov atomic_set(&kvm->online_vcpus, 0); 206f9e0554dSPaul Mackerras 207f9e0554dSPaul Mackerras kvmppc_core_destroy_vm(kvm); 208f9e0554dSPaul Mackerras 209988a2caeSGleb Natapov mutex_unlock(&kvm->lock); 210bbf45ba5SHollis Blanchard } 211bbf45ba5SHollis Blanchard 212ad8ba2cdSSheng Yang void kvm_arch_sync_events(struct kvm *kvm) 213ad8ba2cdSSheng Yang { 214ad8ba2cdSSheng Yang } 215ad8ba2cdSSheng Yang 216bbf45ba5SHollis Blanchard int kvm_dev_ioctl_check_extension(long ext) 217bbf45ba5SHollis Blanchard { 218bbf45ba5SHollis Blanchard int r; 219bbf45ba5SHollis Blanchard 220bbf45ba5SHollis Blanchard switch (ext) { 2215ce941eeSScott Wood #ifdef CONFIG_BOOKE 2225ce941eeSScott Wood case KVM_CAP_PPC_BOOKE_SREGS: 2235ce941eeSScott Wood #else 224e15a1137SAlexander Graf case KVM_CAP_PPC_SEGSTATE: 2251022fc3dSAlexander Graf case KVM_CAP_PPC_HIOR: 226930b412aSAlexander Graf case KVM_CAP_PPC_PAPR: 2275ce941eeSScott Wood #endif 22818978768SAlexander Graf case KVM_CAP_PPC_UNSET_IRQ: 2297b4203e8SAlexander Graf case KVM_CAP_PPC_IRQ_LEVEL: 23071fbfd5fSAlexander Graf case KVM_CAP_ENABLE_CAP: 231e24ed81fSAlexander Graf case KVM_CAP_ONE_REG: 232de56a948SPaul Mackerras r = 1; 233de56a948SPaul Mackerras break; 234de56a948SPaul Mackerras #ifndef CONFIG_KVM_BOOK3S_64_HV 235de56a948SPaul Mackerras case KVM_CAP_PPC_PAIRED_SINGLES: 236ad0a048bSAlexander Graf case KVM_CAP_PPC_OSI: 23715711e9cSAlexander Graf case KVM_CAP_PPC_GET_PVINFO: 238bf7ca4bdSAlexander Graf #if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC) 239dc83b8bcSScott Wood case KVM_CAP_SW_TLB: 240dc83b8bcSScott Wood #endif 241e15a1137SAlexander Graf r = 1; 242e15a1137SAlexander Graf break; 243588968b6SLaurent Vivier case KVM_CAP_COALESCED_MMIO: 244588968b6SLaurent Vivier r = KVM_COALESCED_MMIO_PAGE_OFFSET; 245588968b6SLaurent Vivier break; 246de56a948SPaul Mackerras #endif 247f31e65e1SBenjamin Herrenschmidt #ifdef CONFIG_PPC_BOOK3S_64 24854738c09SDavid Gibson case KVM_CAP_SPAPR_TCE: 24954738c09SDavid Gibson r = 1; 25054738c09SDavid Gibson break; 251f31e65e1SBenjamin Herrenschmidt #endif /* CONFIG_PPC_BOOK3S_64 */ 252f31e65e1SBenjamin Herrenschmidt #ifdef CONFIG_KVM_BOOK3S_64_HV 253371fefd6SPaul Mackerras case KVM_CAP_PPC_SMT: 254371fefd6SPaul Mackerras r = threads_per_core; 255371fefd6SPaul Mackerras break; 256aa04b4ccSPaul Mackerras case KVM_CAP_PPC_RMA: 257aa04b4ccSPaul Mackerras r = 1; 2589e368f29SPaul Mackerras /* PPC970 requires an RMA */ 2599e368f29SPaul Mackerras if (cpu_has_feature(CPU_FTR_ARCH_201)) 2609e368f29SPaul Mackerras r = 2; 261aa04b4ccSPaul Mackerras break; 262342d3db7SPaul Mackerras case KVM_CAP_SYNC_MMU: 263342d3db7SPaul Mackerras r = cpu_has_feature(CPU_FTR_ARCH_206) ? 1 : 0; 264342d3db7SPaul Mackerras break; 26554738c09SDavid Gibson #endif 266b5434032SMatt Evans case KVM_CAP_NR_VCPUS: 267b5434032SMatt Evans /* 268b5434032SMatt Evans * Recommending a number of CPUs is somewhat arbitrary; we 269b5434032SMatt Evans * return the number of present CPUs for -HV (since a host 270b5434032SMatt Evans * will have secondary threads "offline"), and for other KVM 271b5434032SMatt Evans * implementations just count online CPUs. 272b5434032SMatt Evans */ 273b5434032SMatt Evans #ifdef CONFIG_KVM_BOOK3S_64_HV 274b5434032SMatt Evans r = num_present_cpus(); 275b5434032SMatt Evans #else 276b5434032SMatt Evans r = num_online_cpus(); 277b5434032SMatt Evans #endif 278b5434032SMatt Evans break; 279b5434032SMatt Evans case KVM_CAP_MAX_VCPUS: 280b5434032SMatt Evans r = KVM_MAX_VCPUS; 281b5434032SMatt Evans break; 282*5b74716eSBenjamin Herrenschmidt #ifdef CONFIG_PPC_BOOK3S_64 283*5b74716eSBenjamin Herrenschmidt case KVM_CAP_PPC_GET_SMMU_INFO: 284*5b74716eSBenjamin Herrenschmidt r = 1; 285*5b74716eSBenjamin Herrenschmidt break; 286*5b74716eSBenjamin Herrenschmidt #endif 287bbf45ba5SHollis Blanchard default: 288bbf45ba5SHollis Blanchard r = 0; 289bbf45ba5SHollis Blanchard break; 290bbf45ba5SHollis Blanchard } 291bbf45ba5SHollis Blanchard return r; 292bbf45ba5SHollis Blanchard 293bbf45ba5SHollis Blanchard } 294bbf45ba5SHollis Blanchard 295bbf45ba5SHollis Blanchard long kvm_arch_dev_ioctl(struct file *filp, 296bbf45ba5SHollis Blanchard unsigned int ioctl, unsigned long arg) 297bbf45ba5SHollis Blanchard { 298bbf45ba5SHollis Blanchard return -EINVAL; 299bbf45ba5SHollis Blanchard } 300bbf45ba5SHollis Blanchard 301db3fe4ebSTakuya Yoshikawa void kvm_arch_free_memslot(struct kvm_memory_slot *free, 302db3fe4ebSTakuya Yoshikawa struct kvm_memory_slot *dont) 303db3fe4ebSTakuya Yoshikawa { 304db3fe4ebSTakuya Yoshikawa } 305db3fe4ebSTakuya Yoshikawa 306db3fe4ebSTakuya Yoshikawa int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages) 307db3fe4ebSTakuya Yoshikawa { 308db3fe4ebSTakuya Yoshikawa return 0; 309db3fe4ebSTakuya Yoshikawa } 310db3fe4ebSTakuya Yoshikawa 311f7784b8eSMarcelo Tosatti int kvm_arch_prepare_memory_region(struct kvm *kvm, 312f7784b8eSMarcelo Tosatti struct kvm_memory_slot *memslot, 313bbf45ba5SHollis Blanchard struct kvm_memory_slot old, 314f7784b8eSMarcelo Tosatti struct kvm_userspace_memory_region *mem, 315bbf45ba5SHollis Blanchard int user_alloc) 316bbf45ba5SHollis Blanchard { 317f9e0554dSPaul Mackerras return kvmppc_core_prepare_memory_region(kvm, mem); 318bbf45ba5SHollis Blanchard } 319bbf45ba5SHollis Blanchard 320f7784b8eSMarcelo Tosatti void kvm_arch_commit_memory_region(struct kvm *kvm, 321f7784b8eSMarcelo Tosatti struct kvm_userspace_memory_region *mem, 322f7784b8eSMarcelo Tosatti struct kvm_memory_slot old, 323f7784b8eSMarcelo Tosatti int user_alloc) 324f7784b8eSMarcelo Tosatti { 325f9e0554dSPaul Mackerras kvmppc_core_commit_memory_region(kvm, mem); 326f7784b8eSMarcelo Tosatti } 327f7784b8eSMarcelo Tosatti 328f7784b8eSMarcelo Tosatti 32934d4cb8fSMarcelo Tosatti void kvm_arch_flush_shadow(struct kvm *kvm) 33034d4cb8fSMarcelo Tosatti { 33134d4cb8fSMarcelo Tosatti } 33234d4cb8fSMarcelo Tosatti 333bbf45ba5SHollis Blanchard struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id) 334bbf45ba5SHollis Blanchard { 33573e75b41SHollis Blanchard struct kvm_vcpu *vcpu; 33673e75b41SHollis Blanchard vcpu = kvmppc_core_vcpu_create(kvm, id); 33703cdab53SMatt Evans if (!IS_ERR(vcpu)) { 33819ccb76aSPaul Mackerras vcpu->arch.wqp = &vcpu->wq; 33973e75b41SHollis Blanchard kvmppc_create_vcpu_debugfs(vcpu, id); 34003cdab53SMatt Evans } 34173e75b41SHollis Blanchard return vcpu; 342bbf45ba5SHollis Blanchard } 343bbf45ba5SHollis Blanchard 344bbf45ba5SHollis Blanchard void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu) 345bbf45ba5SHollis Blanchard { 346a595405dSAlexander Graf /* Make sure we're not using the vcpu anymore */ 347a595405dSAlexander Graf hrtimer_cancel(&vcpu->arch.dec_timer); 348a595405dSAlexander Graf tasklet_kill(&vcpu->arch.tasklet); 349a595405dSAlexander Graf 35073e75b41SHollis Blanchard kvmppc_remove_vcpu_debugfs(vcpu); 351db93f574SHollis Blanchard kvmppc_core_vcpu_free(vcpu); 352bbf45ba5SHollis Blanchard } 353bbf45ba5SHollis Blanchard 354bbf45ba5SHollis Blanchard void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 355bbf45ba5SHollis Blanchard { 356bbf45ba5SHollis Blanchard kvm_arch_vcpu_free(vcpu); 357bbf45ba5SHollis Blanchard } 358bbf45ba5SHollis Blanchard 359bbf45ba5SHollis Blanchard int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu) 360bbf45ba5SHollis Blanchard { 3619dd921cfSHollis Blanchard return kvmppc_core_pending_dec(vcpu); 362bbf45ba5SHollis Blanchard } 363bbf45ba5SHollis Blanchard 364544c6761SAlexander Graf /* 365544c6761SAlexander Graf * low level hrtimer wake routine. Because this runs in hardirq context 366544c6761SAlexander Graf * we schedule a tasklet to do the real work. 367544c6761SAlexander Graf */ 368544c6761SAlexander Graf enum hrtimer_restart kvmppc_decrementer_wakeup(struct hrtimer *timer) 369544c6761SAlexander Graf { 370544c6761SAlexander Graf struct kvm_vcpu *vcpu; 371544c6761SAlexander Graf 372544c6761SAlexander Graf vcpu = container_of(timer, struct kvm_vcpu, arch.dec_timer); 373544c6761SAlexander Graf tasklet_schedule(&vcpu->arch.tasklet); 374544c6761SAlexander Graf 375544c6761SAlexander Graf return HRTIMER_NORESTART; 376544c6761SAlexander Graf } 377544c6761SAlexander Graf 378bbf45ba5SHollis Blanchard int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 379bbf45ba5SHollis Blanchard { 380544c6761SAlexander Graf hrtimer_init(&vcpu->arch.dec_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS); 381544c6761SAlexander Graf tasklet_init(&vcpu->arch.tasklet, kvmppc_decrementer_func, (ulong)vcpu); 382544c6761SAlexander Graf vcpu->arch.dec_timer.function = kvmppc_decrementer_wakeup; 383de56a948SPaul Mackerras vcpu->arch.dec_expires = ~(u64)0; 384bbf45ba5SHollis Blanchard 38509000adbSBharat Bhushan #ifdef CONFIG_KVM_EXIT_TIMING 38609000adbSBharat Bhushan mutex_init(&vcpu->arch.exit_timing_lock); 38709000adbSBharat Bhushan #endif 38809000adbSBharat Bhushan 389bbf45ba5SHollis Blanchard return 0; 390bbf45ba5SHollis Blanchard } 391bbf45ba5SHollis Blanchard 392bbf45ba5SHollis Blanchard void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) 393bbf45ba5SHollis Blanchard { 394ecc0981fSHollis Blanchard kvmppc_mmu_destroy(vcpu); 395bbf45ba5SHollis Blanchard } 396bbf45ba5SHollis Blanchard 397bbf45ba5SHollis Blanchard void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 398bbf45ba5SHollis Blanchard { 399eab17672SScott Wood #ifdef CONFIG_BOOKE 400eab17672SScott Wood /* 401eab17672SScott Wood * vrsave (formerly usprg0) isn't used by Linux, but may 402eab17672SScott Wood * be used by the guest. 403eab17672SScott Wood * 404eab17672SScott Wood * On non-booke this is associated with Altivec and 405eab17672SScott Wood * is handled by code in book3s.c. 406eab17672SScott Wood */ 407eab17672SScott Wood mtspr(SPRN_VRSAVE, vcpu->arch.vrsave); 408eab17672SScott Wood #endif 4099dd921cfSHollis Blanchard kvmppc_core_vcpu_load(vcpu, cpu); 410de56a948SPaul Mackerras vcpu->cpu = smp_processor_id(); 411bbf45ba5SHollis Blanchard } 412bbf45ba5SHollis Blanchard 413bbf45ba5SHollis Blanchard void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 414bbf45ba5SHollis Blanchard { 4159dd921cfSHollis Blanchard kvmppc_core_vcpu_put(vcpu); 416eab17672SScott Wood #ifdef CONFIG_BOOKE 417eab17672SScott Wood vcpu->arch.vrsave = mfspr(SPRN_VRSAVE); 418eab17672SScott Wood #endif 419de56a948SPaul Mackerras vcpu->cpu = -1; 420bbf45ba5SHollis Blanchard } 421bbf45ba5SHollis Blanchard 422d0bfb940SJan Kiszka int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 423d0bfb940SJan Kiszka struct kvm_guest_debug *dbg) 424bbf45ba5SHollis Blanchard { 425f5d0906bSHollis Blanchard return -EINVAL; 426bbf45ba5SHollis Blanchard } 427bbf45ba5SHollis Blanchard 428bbf45ba5SHollis Blanchard static void kvmppc_complete_dcr_load(struct kvm_vcpu *vcpu, 429bbf45ba5SHollis Blanchard struct kvm_run *run) 430bbf45ba5SHollis Blanchard { 4318e5b26b5SAlexander Graf kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, run->dcr.data); 432bbf45ba5SHollis Blanchard } 433bbf45ba5SHollis Blanchard 434bbf45ba5SHollis Blanchard static void kvmppc_complete_mmio_load(struct kvm_vcpu *vcpu, 435bbf45ba5SHollis Blanchard struct kvm_run *run) 436bbf45ba5SHollis Blanchard { 43769b61833SDenis Kirjanov u64 uninitialized_var(gpr); 438bbf45ba5SHollis Blanchard 4398e5b26b5SAlexander Graf if (run->mmio.len > sizeof(gpr)) { 440bbf45ba5SHollis Blanchard printk(KERN_ERR "bad MMIO length: %d\n", run->mmio.len); 441bbf45ba5SHollis Blanchard return; 442bbf45ba5SHollis Blanchard } 443bbf45ba5SHollis Blanchard 444bbf45ba5SHollis Blanchard if (vcpu->arch.mmio_is_bigendian) { 445bbf45ba5SHollis Blanchard switch (run->mmio.len) { 446b104d066SAlexander Graf case 8: gpr = *(u64 *)run->mmio.data; break; 4478e5b26b5SAlexander Graf case 4: gpr = *(u32 *)run->mmio.data; break; 4488e5b26b5SAlexander Graf case 2: gpr = *(u16 *)run->mmio.data; break; 4498e5b26b5SAlexander Graf case 1: gpr = *(u8 *)run->mmio.data; break; 450bbf45ba5SHollis Blanchard } 451bbf45ba5SHollis Blanchard } else { 452bbf45ba5SHollis Blanchard /* Convert BE data from userland back to LE. */ 453bbf45ba5SHollis Blanchard switch (run->mmio.len) { 4548e5b26b5SAlexander Graf case 4: gpr = ld_le32((u32 *)run->mmio.data); break; 4558e5b26b5SAlexander Graf case 2: gpr = ld_le16((u16 *)run->mmio.data); break; 4568e5b26b5SAlexander Graf case 1: gpr = *(u8 *)run->mmio.data; break; 457bbf45ba5SHollis Blanchard } 458bbf45ba5SHollis Blanchard } 4598e5b26b5SAlexander Graf 4603587d534SAlexander Graf if (vcpu->arch.mmio_sign_extend) { 4613587d534SAlexander Graf switch (run->mmio.len) { 4623587d534SAlexander Graf #ifdef CONFIG_PPC64 4633587d534SAlexander Graf case 4: 4643587d534SAlexander Graf gpr = (s64)(s32)gpr; 4653587d534SAlexander Graf break; 4663587d534SAlexander Graf #endif 4673587d534SAlexander Graf case 2: 4683587d534SAlexander Graf gpr = (s64)(s16)gpr; 4693587d534SAlexander Graf break; 4703587d534SAlexander Graf case 1: 4713587d534SAlexander Graf gpr = (s64)(s8)gpr; 4723587d534SAlexander Graf break; 4733587d534SAlexander Graf } 4743587d534SAlexander Graf } 4753587d534SAlexander Graf 4768e5b26b5SAlexander Graf kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr); 477b104d066SAlexander Graf 478b3c5d3c2SAlexander Graf switch (vcpu->arch.io_gpr & KVM_MMIO_REG_EXT_MASK) { 479b3c5d3c2SAlexander Graf case KVM_MMIO_REG_GPR: 480b104d066SAlexander Graf kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr); 481b104d066SAlexander Graf break; 482b3c5d3c2SAlexander Graf case KVM_MMIO_REG_FPR: 483b3c5d3c2SAlexander Graf vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr; 484b104d066SAlexander Graf break; 485287d5611SAlexander Graf #ifdef CONFIG_PPC_BOOK3S 486b3c5d3c2SAlexander Graf case KVM_MMIO_REG_QPR: 487b3c5d3c2SAlexander Graf vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr; 488b104d066SAlexander Graf break; 489b3c5d3c2SAlexander Graf case KVM_MMIO_REG_FQPR: 490b3c5d3c2SAlexander Graf vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr; 491b3c5d3c2SAlexander Graf vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr; 492b104d066SAlexander Graf break; 493287d5611SAlexander Graf #endif 494b104d066SAlexander Graf default: 495b104d066SAlexander Graf BUG(); 496b104d066SAlexander Graf } 497bbf45ba5SHollis Blanchard } 498bbf45ba5SHollis Blanchard 499bbf45ba5SHollis Blanchard int kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu, 500bbf45ba5SHollis Blanchard unsigned int rt, unsigned int bytes, int is_bigendian) 501bbf45ba5SHollis Blanchard { 502bbf45ba5SHollis Blanchard if (bytes > sizeof(run->mmio.data)) { 503bbf45ba5SHollis Blanchard printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__, 504bbf45ba5SHollis Blanchard run->mmio.len); 505bbf45ba5SHollis Blanchard } 506bbf45ba5SHollis Blanchard 507bbf45ba5SHollis Blanchard run->mmio.phys_addr = vcpu->arch.paddr_accessed; 508bbf45ba5SHollis Blanchard run->mmio.len = bytes; 509bbf45ba5SHollis Blanchard run->mmio.is_write = 0; 510bbf45ba5SHollis Blanchard 511bbf45ba5SHollis Blanchard vcpu->arch.io_gpr = rt; 512bbf45ba5SHollis Blanchard vcpu->arch.mmio_is_bigendian = is_bigendian; 513bbf45ba5SHollis Blanchard vcpu->mmio_needed = 1; 514bbf45ba5SHollis Blanchard vcpu->mmio_is_write = 0; 5153587d534SAlexander Graf vcpu->arch.mmio_sign_extend = 0; 516bbf45ba5SHollis Blanchard 517bbf45ba5SHollis Blanchard return EMULATE_DO_MMIO; 518bbf45ba5SHollis Blanchard } 519bbf45ba5SHollis Blanchard 5203587d534SAlexander Graf /* Same as above, but sign extends */ 5213587d534SAlexander Graf int kvmppc_handle_loads(struct kvm_run *run, struct kvm_vcpu *vcpu, 5223587d534SAlexander Graf unsigned int rt, unsigned int bytes, int is_bigendian) 5233587d534SAlexander Graf { 5243587d534SAlexander Graf int r; 5253587d534SAlexander Graf 5263587d534SAlexander Graf r = kvmppc_handle_load(run, vcpu, rt, bytes, is_bigendian); 5273587d534SAlexander Graf vcpu->arch.mmio_sign_extend = 1; 5283587d534SAlexander Graf 5293587d534SAlexander Graf return r; 5303587d534SAlexander Graf } 5313587d534SAlexander Graf 532bbf45ba5SHollis Blanchard int kvmppc_handle_store(struct kvm_run *run, struct kvm_vcpu *vcpu, 533b104d066SAlexander Graf u64 val, unsigned int bytes, int is_bigendian) 534bbf45ba5SHollis Blanchard { 535bbf45ba5SHollis Blanchard void *data = run->mmio.data; 536bbf45ba5SHollis Blanchard 537bbf45ba5SHollis Blanchard if (bytes > sizeof(run->mmio.data)) { 538bbf45ba5SHollis Blanchard printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__, 539bbf45ba5SHollis Blanchard run->mmio.len); 540bbf45ba5SHollis Blanchard } 541bbf45ba5SHollis Blanchard 542bbf45ba5SHollis Blanchard run->mmio.phys_addr = vcpu->arch.paddr_accessed; 543bbf45ba5SHollis Blanchard run->mmio.len = bytes; 544bbf45ba5SHollis Blanchard run->mmio.is_write = 1; 545bbf45ba5SHollis Blanchard vcpu->mmio_needed = 1; 546bbf45ba5SHollis Blanchard vcpu->mmio_is_write = 1; 547bbf45ba5SHollis Blanchard 548bbf45ba5SHollis Blanchard /* Store the value at the lowest bytes in 'data'. */ 549bbf45ba5SHollis Blanchard if (is_bigendian) { 550bbf45ba5SHollis Blanchard switch (bytes) { 551b104d066SAlexander Graf case 8: *(u64 *)data = val; break; 552bbf45ba5SHollis Blanchard case 4: *(u32 *)data = val; break; 553bbf45ba5SHollis Blanchard case 2: *(u16 *)data = val; break; 554bbf45ba5SHollis Blanchard case 1: *(u8 *)data = val; break; 555bbf45ba5SHollis Blanchard } 556bbf45ba5SHollis Blanchard } else { 557bbf45ba5SHollis Blanchard /* Store LE value into 'data'. */ 558bbf45ba5SHollis Blanchard switch (bytes) { 559bbf45ba5SHollis Blanchard case 4: st_le32(data, val); break; 560bbf45ba5SHollis Blanchard case 2: st_le16(data, val); break; 561bbf45ba5SHollis Blanchard case 1: *(u8 *)data = val; break; 562bbf45ba5SHollis Blanchard } 563bbf45ba5SHollis Blanchard } 564bbf45ba5SHollis Blanchard 565bbf45ba5SHollis Blanchard return EMULATE_DO_MMIO; 566bbf45ba5SHollis Blanchard } 567bbf45ba5SHollis Blanchard 568bbf45ba5SHollis Blanchard int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run) 569bbf45ba5SHollis Blanchard { 570bbf45ba5SHollis Blanchard int r; 571bbf45ba5SHollis Blanchard sigset_t sigsaved; 572bbf45ba5SHollis Blanchard 573bbf45ba5SHollis Blanchard if (vcpu->sigset_active) 574bbf45ba5SHollis Blanchard sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); 575bbf45ba5SHollis Blanchard 576bbf45ba5SHollis Blanchard if (vcpu->mmio_needed) { 577bbf45ba5SHollis Blanchard if (!vcpu->mmio_is_write) 578bbf45ba5SHollis Blanchard kvmppc_complete_mmio_load(vcpu, run); 579bbf45ba5SHollis Blanchard vcpu->mmio_needed = 0; 580bbf45ba5SHollis Blanchard } else if (vcpu->arch.dcr_needed) { 581bbf45ba5SHollis Blanchard if (!vcpu->arch.dcr_is_write) 582bbf45ba5SHollis Blanchard kvmppc_complete_dcr_load(vcpu, run); 583bbf45ba5SHollis Blanchard vcpu->arch.dcr_needed = 0; 584ad0a048bSAlexander Graf } else if (vcpu->arch.osi_needed) { 585ad0a048bSAlexander Graf u64 *gprs = run->osi.gprs; 586ad0a048bSAlexander Graf int i; 587ad0a048bSAlexander Graf 588ad0a048bSAlexander Graf for (i = 0; i < 32; i++) 589ad0a048bSAlexander Graf kvmppc_set_gpr(vcpu, i, gprs[i]); 590ad0a048bSAlexander Graf vcpu->arch.osi_needed = 0; 591de56a948SPaul Mackerras } else if (vcpu->arch.hcall_needed) { 592de56a948SPaul Mackerras int i; 593de56a948SPaul Mackerras 594de56a948SPaul Mackerras kvmppc_set_gpr(vcpu, 3, run->papr_hcall.ret); 595de56a948SPaul Mackerras for (i = 0; i < 9; ++i) 596de56a948SPaul Mackerras kvmppc_set_gpr(vcpu, 4 + i, run->papr_hcall.args[i]); 597de56a948SPaul Mackerras vcpu->arch.hcall_needed = 0; 598bbf45ba5SHollis Blanchard } 599bbf45ba5SHollis Blanchard 600df6909e5SPaul Mackerras r = kvmppc_vcpu_run(run, vcpu); 601bbf45ba5SHollis Blanchard 602bbf45ba5SHollis Blanchard if (vcpu->sigset_active) 603bbf45ba5SHollis Blanchard sigprocmask(SIG_SETMASK, &sigsaved, NULL); 604bbf45ba5SHollis Blanchard 605bbf45ba5SHollis Blanchard return r; 606bbf45ba5SHollis Blanchard } 607bbf45ba5SHollis Blanchard 608bbf45ba5SHollis Blanchard int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq) 609bbf45ba5SHollis Blanchard { 61019ccb76aSPaul Mackerras if (irq->irq == KVM_INTERRUPT_UNSET) { 61118978768SAlexander Graf kvmppc_core_dequeue_external(vcpu, irq); 61219ccb76aSPaul Mackerras return 0; 61319ccb76aSPaul Mackerras } 61419ccb76aSPaul Mackerras 6159dd921cfSHollis Blanchard kvmppc_core_queue_external(vcpu, irq); 616b6d33834SChristoffer Dall 617dfd4d47eSScott Wood kvm_vcpu_kick(vcpu); 61845c5eb67SHollis Blanchard 619bbf45ba5SHollis Blanchard return 0; 620bbf45ba5SHollis Blanchard } 621bbf45ba5SHollis Blanchard 62271fbfd5fSAlexander Graf static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 62371fbfd5fSAlexander Graf struct kvm_enable_cap *cap) 62471fbfd5fSAlexander Graf { 62571fbfd5fSAlexander Graf int r; 62671fbfd5fSAlexander Graf 62771fbfd5fSAlexander Graf if (cap->flags) 62871fbfd5fSAlexander Graf return -EINVAL; 62971fbfd5fSAlexander Graf 63071fbfd5fSAlexander Graf switch (cap->cap) { 631ad0a048bSAlexander Graf case KVM_CAP_PPC_OSI: 632ad0a048bSAlexander Graf r = 0; 633ad0a048bSAlexander Graf vcpu->arch.osi_enabled = true; 634ad0a048bSAlexander Graf break; 635930b412aSAlexander Graf case KVM_CAP_PPC_PAPR: 636930b412aSAlexander Graf r = 0; 637930b412aSAlexander Graf vcpu->arch.papr_enabled = true; 638930b412aSAlexander Graf break; 639bf7ca4bdSAlexander Graf #if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC) 640dc83b8bcSScott Wood case KVM_CAP_SW_TLB: { 641dc83b8bcSScott Wood struct kvm_config_tlb cfg; 642dc83b8bcSScott Wood void __user *user_ptr = (void __user *)(uintptr_t)cap->args[0]; 643dc83b8bcSScott Wood 644dc83b8bcSScott Wood r = -EFAULT; 645dc83b8bcSScott Wood if (copy_from_user(&cfg, user_ptr, sizeof(cfg))) 646dc83b8bcSScott Wood break; 647dc83b8bcSScott Wood 648dc83b8bcSScott Wood r = kvm_vcpu_ioctl_config_tlb(vcpu, &cfg); 649dc83b8bcSScott Wood break; 650dc83b8bcSScott Wood } 651dc83b8bcSScott Wood #endif 65271fbfd5fSAlexander Graf default: 65371fbfd5fSAlexander Graf r = -EINVAL; 65471fbfd5fSAlexander Graf break; 65571fbfd5fSAlexander Graf } 65671fbfd5fSAlexander Graf 657af8f38b3SAlexander Graf if (!r) 658af8f38b3SAlexander Graf r = kvmppc_sanity_check(vcpu); 659af8f38b3SAlexander Graf 66071fbfd5fSAlexander Graf return r; 66171fbfd5fSAlexander Graf } 66271fbfd5fSAlexander Graf 663bbf45ba5SHollis Blanchard int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 664bbf45ba5SHollis Blanchard struct kvm_mp_state *mp_state) 665bbf45ba5SHollis Blanchard { 666bbf45ba5SHollis Blanchard return -EINVAL; 667bbf45ba5SHollis Blanchard } 668bbf45ba5SHollis Blanchard 669bbf45ba5SHollis Blanchard int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 670bbf45ba5SHollis Blanchard struct kvm_mp_state *mp_state) 671bbf45ba5SHollis Blanchard { 672bbf45ba5SHollis Blanchard return -EINVAL; 673bbf45ba5SHollis Blanchard } 674bbf45ba5SHollis Blanchard 675bbf45ba5SHollis Blanchard long kvm_arch_vcpu_ioctl(struct file *filp, 676bbf45ba5SHollis Blanchard unsigned int ioctl, unsigned long arg) 677bbf45ba5SHollis Blanchard { 678bbf45ba5SHollis Blanchard struct kvm_vcpu *vcpu = filp->private_data; 679bbf45ba5SHollis Blanchard void __user *argp = (void __user *)arg; 680bbf45ba5SHollis Blanchard long r; 681bbf45ba5SHollis Blanchard 68293736624SAvi Kivity switch (ioctl) { 68393736624SAvi Kivity case KVM_INTERRUPT: { 684bbf45ba5SHollis Blanchard struct kvm_interrupt irq; 685bbf45ba5SHollis Blanchard r = -EFAULT; 686bbf45ba5SHollis Blanchard if (copy_from_user(&irq, argp, sizeof(irq))) 68793736624SAvi Kivity goto out; 688bbf45ba5SHollis Blanchard r = kvm_vcpu_ioctl_interrupt(vcpu, &irq); 68993736624SAvi Kivity goto out; 690bbf45ba5SHollis Blanchard } 69119483d14SAvi Kivity 69271fbfd5fSAlexander Graf case KVM_ENABLE_CAP: 69371fbfd5fSAlexander Graf { 69471fbfd5fSAlexander Graf struct kvm_enable_cap cap; 69571fbfd5fSAlexander Graf r = -EFAULT; 69671fbfd5fSAlexander Graf if (copy_from_user(&cap, argp, sizeof(cap))) 69771fbfd5fSAlexander Graf goto out; 69871fbfd5fSAlexander Graf r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 69971fbfd5fSAlexander Graf break; 70071fbfd5fSAlexander Graf } 701dc83b8bcSScott Wood 702e24ed81fSAlexander Graf case KVM_SET_ONE_REG: 703e24ed81fSAlexander Graf case KVM_GET_ONE_REG: 704e24ed81fSAlexander Graf { 705e24ed81fSAlexander Graf struct kvm_one_reg reg; 706e24ed81fSAlexander Graf r = -EFAULT; 707e24ed81fSAlexander Graf if (copy_from_user(®, argp, sizeof(reg))) 708e24ed81fSAlexander Graf goto out; 709e24ed81fSAlexander Graf if (ioctl == KVM_SET_ONE_REG) 710e24ed81fSAlexander Graf r = kvm_vcpu_ioctl_set_one_reg(vcpu, ®); 711e24ed81fSAlexander Graf else 712e24ed81fSAlexander Graf r = kvm_vcpu_ioctl_get_one_reg(vcpu, ®); 713e24ed81fSAlexander Graf break; 714e24ed81fSAlexander Graf } 715e24ed81fSAlexander Graf 716bf7ca4bdSAlexander Graf #if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC) 717dc83b8bcSScott Wood case KVM_DIRTY_TLB: { 718dc83b8bcSScott Wood struct kvm_dirty_tlb dirty; 719dc83b8bcSScott Wood r = -EFAULT; 720dc83b8bcSScott Wood if (copy_from_user(&dirty, argp, sizeof(dirty))) 721dc83b8bcSScott Wood goto out; 722dc83b8bcSScott Wood r = kvm_vcpu_ioctl_dirty_tlb(vcpu, &dirty); 723dc83b8bcSScott Wood break; 724dc83b8bcSScott Wood } 725dc83b8bcSScott Wood #endif 726bbf45ba5SHollis Blanchard default: 727bbf45ba5SHollis Blanchard r = -EINVAL; 728bbf45ba5SHollis Blanchard } 729bbf45ba5SHollis Blanchard 730bbf45ba5SHollis Blanchard out: 731bbf45ba5SHollis Blanchard return r; 732bbf45ba5SHollis Blanchard } 733bbf45ba5SHollis Blanchard 7345b1c1493SCarsten Otte int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) 7355b1c1493SCarsten Otte { 7365b1c1493SCarsten Otte return VM_FAULT_SIGBUS; 7375b1c1493SCarsten Otte } 7385b1c1493SCarsten Otte 73915711e9cSAlexander Graf static int kvm_vm_ioctl_get_pvinfo(struct kvm_ppc_pvinfo *pvinfo) 74015711e9cSAlexander Graf { 74115711e9cSAlexander Graf u32 inst_lis = 0x3c000000; 74215711e9cSAlexander Graf u32 inst_ori = 0x60000000; 74315711e9cSAlexander Graf u32 inst_nop = 0x60000000; 74415711e9cSAlexander Graf u32 inst_sc = 0x44000002; 74515711e9cSAlexander Graf u32 inst_imm_mask = 0xffff; 74615711e9cSAlexander Graf 74715711e9cSAlexander Graf /* 74815711e9cSAlexander Graf * The hypercall to get into KVM from within guest context is as 74915711e9cSAlexander Graf * follows: 75015711e9cSAlexander Graf * 75115711e9cSAlexander Graf * lis r0, r0, KVM_SC_MAGIC_R0@h 75215711e9cSAlexander Graf * ori r0, KVM_SC_MAGIC_R0@l 75315711e9cSAlexander Graf * sc 75415711e9cSAlexander Graf * nop 75515711e9cSAlexander Graf */ 75615711e9cSAlexander Graf pvinfo->hcall[0] = inst_lis | ((KVM_SC_MAGIC_R0 >> 16) & inst_imm_mask); 75715711e9cSAlexander Graf pvinfo->hcall[1] = inst_ori | (KVM_SC_MAGIC_R0 & inst_imm_mask); 75815711e9cSAlexander Graf pvinfo->hcall[2] = inst_sc; 75915711e9cSAlexander Graf pvinfo->hcall[3] = inst_nop; 76015711e9cSAlexander Graf 76115711e9cSAlexander Graf return 0; 76215711e9cSAlexander Graf } 76315711e9cSAlexander Graf 764bbf45ba5SHollis Blanchard long kvm_arch_vm_ioctl(struct file *filp, 765bbf45ba5SHollis Blanchard unsigned int ioctl, unsigned long arg) 766bbf45ba5SHollis Blanchard { 76715711e9cSAlexander Graf void __user *argp = (void __user *)arg; 768bbf45ba5SHollis Blanchard long r; 769bbf45ba5SHollis Blanchard 770bbf45ba5SHollis Blanchard switch (ioctl) { 77115711e9cSAlexander Graf case KVM_PPC_GET_PVINFO: { 77215711e9cSAlexander Graf struct kvm_ppc_pvinfo pvinfo; 773d8cdddcdSVasiliy Kulikov memset(&pvinfo, 0, sizeof(pvinfo)); 77415711e9cSAlexander Graf r = kvm_vm_ioctl_get_pvinfo(&pvinfo); 77515711e9cSAlexander Graf if (copy_to_user(argp, &pvinfo, sizeof(pvinfo))) { 77615711e9cSAlexander Graf r = -EFAULT; 77715711e9cSAlexander Graf goto out; 77815711e9cSAlexander Graf } 77915711e9cSAlexander Graf 78015711e9cSAlexander Graf break; 78115711e9cSAlexander Graf } 782f31e65e1SBenjamin Herrenschmidt #ifdef CONFIG_PPC_BOOK3S_64 78354738c09SDavid Gibson case KVM_CREATE_SPAPR_TCE: { 78454738c09SDavid Gibson struct kvm_create_spapr_tce create_tce; 78554738c09SDavid Gibson struct kvm *kvm = filp->private_data; 78654738c09SDavid Gibson 78754738c09SDavid Gibson r = -EFAULT; 78854738c09SDavid Gibson if (copy_from_user(&create_tce, argp, sizeof(create_tce))) 78954738c09SDavid Gibson goto out; 79054738c09SDavid Gibson r = kvm_vm_ioctl_create_spapr_tce(kvm, &create_tce); 79154738c09SDavid Gibson goto out; 79254738c09SDavid Gibson } 793f31e65e1SBenjamin Herrenschmidt #endif /* CONFIG_PPC_BOOK3S_64 */ 794aa04b4ccSPaul Mackerras 795f31e65e1SBenjamin Herrenschmidt #ifdef CONFIG_KVM_BOOK3S_64_HV 796aa04b4ccSPaul Mackerras case KVM_ALLOCATE_RMA: { 797aa04b4ccSPaul Mackerras struct kvm *kvm = filp->private_data; 798aa04b4ccSPaul Mackerras struct kvm_allocate_rma rma; 799aa04b4ccSPaul Mackerras 800aa04b4ccSPaul Mackerras r = kvm_vm_ioctl_allocate_rma(kvm, &rma); 801aa04b4ccSPaul Mackerras if (r >= 0 && copy_to_user(argp, &rma, sizeof(rma))) 802aa04b4ccSPaul Mackerras r = -EFAULT; 803aa04b4ccSPaul Mackerras break; 804aa04b4ccSPaul Mackerras } 80554738c09SDavid Gibson #endif /* CONFIG_KVM_BOOK3S_64_HV */ 80654738c09SDavid Gibson 807*5b74716eSBenjamin Herrenschmidt #ifdef CONFIG_PPC_BOOK3S_64 808*5b74716eSBenjamin Herrenschmidt case KVM_PPC_GET_SMMU_INFO: { 809*5b74716eSBenjamin Herrenschmidt struct kvm *kvm = filp->private_data; 810*5b74716eSBenjamin Herrenschmidt struct kvm_ppc_smmu_info info; 811*5b74716eSBenjamin Herrenschmidt 812*5b74716eSBenjamin Herrenschmidt memset(&info, 0, sizeof(info)); 813*5b74716eSBenjamin Herrenschmidt r = kvm_vm_ioctl_get_smmu_info(kvm, &info); 814*5b74716eSBenjamin Herrenschmidt if (r >= 0 && copy_to_user(argp, &info, sizeof(info))) 815*5b74716eSBenjamin Herrenschmidt r = -EFAULT; 816*5b74716eSBenjamin Herrenschmidt break; 817*5b74716eSBenjamin Herrenschmidt } 818*5b74716eSBenjamin Herrenschmidt #endif /* CONFIG_PPC_BOOK3S_64 */ 819bbf45ba5SHollis Blanchard default: 820367e1319SAvi Kivity r = -ENOTTY; 821bbf45ba5SHollis Blanchard } 822bbf45ba5SHollis Blanchard 82315711e9cSAlexander Graf out: 824bbf45ba5SHollis Blanchard return r; 825bbf45ba5SHollis Blanchard } 826bbf45ba5SHollis Blanchard 827043cc4d7SScott Wood static unsigned long lpid_inuse[BITS_TO_LONGS(KVMPPC_NR_LPIDS)]; 828043cc4d7SScott Wood static unsigned long nr_lpids; 829043cc4d7SScott Wood 830043cc4d7SScott Wood long kvmppc_alloc_lpid(void) 831043cc4d7SScott Wood { 832043cc4d7SScott Wood long lpid; 833043cc4d7SScott Wood 834043cc4d7SScott Wood do { 835043cc4d7SScott Wood lpid = find_first_zero_bit(lpid_inuse, KVMPPC_NR_LPIDS); 836043cc4d7SScott Wood if (lpid >= nr_lpids) { 837043cc4d7SScott Wood pr_err("%s: No LPIDs free\n", __func__); 838043cc4d7SScott Wood return -ENOMEM; 839043cc4d7SScott Wood } 840043cc4d7SScott Wood } while (test_and_set_bit(lpid, lpid_inuse)); 841043cc4d7SScott Wood 842043cc4d7SScott Wood return lpid; 843043cc4d7SScott Wood } 844043cc4d7SScott Wood 845043cc4d7SScott Wood void kvmppc_claim_lpid(long lpid) 846043cc4d7SScott Wood { 847043cc4d7SScott Wood set_bit(lpid, lpid_inuse); 848043cc4d7SScott Wood } 849043cc4d7SScott Wood 850043cc4d7SScott Wood void kvmppc_free_lpid(long lpid) 851043cc4d7SScott Wood { 852043cc4d7SScott Wood clear_bit(lpid, lpid_inuse); 853043cc4d7SScott Wood } 854043cc4d7SScott Wood 855043cc4d7SScott Wood void kvmppc_init_lpid(unsigned long nr_lpids_param) 856043cc4d7SScott Wood { 857043cc4d7SScott Wood nr_lpids = min_t(unsigned long, KVMPPC_NR_LPIDS, nr_lpids_param); 858043cc4d7SScott Wood memset(lpid_inuse, 0, sizeof(lpid_inuse)); 859043cc4d7SScott Wood } 860043cc4d7SScott Wood 861bbf45ba5SHollis Blanchard int kvm_arch_init(void *opaque) 862bbf45ba5SHollis Blanchard { 863bbf45ba5SHollis Blanchard return 0; 864bbf45ba5SHollis Blanchard } 865bbf45ba5SHollis Blanchard 866bbf45ba5SHollis Blanchard void kvm_arch_exit(void) 867bbf45ba5SHollis Blanchard { 868bbf45ba5SHollis Blanchard } 869