1b0c632dbSHeiko Carstens /* 2a53c8fabSHeiko Carstens * hosting zSeries kernel virtual machines 3b0c632dbSHeiko Carstens * 4628eb9b8SChristian Ehrhardt * Copyright IBM Corp. 2008, 2009 5b0c632dbSHeiko Carstens * 6b0c632dbSHeiko Carstens * This program is free software; you can redistribute it and/or modify 7b0c632dbSHeiko Carstens * it under the terms of the GNU General Public License (version 2 only) 8b0c632dbSHeiko Carstens * as published by the Free Software Foundation. 9b0c632dbSHeiko Carstens * 10b0c632dbSHeiko Carstens * Author(s): Carsten Otte <cotte@de.ibm.com> 11b0c632dbSHeiko Carstens * Christian Borntraeger <borntraeger@de.ibm.com> 12b0c632dbSHeiko Carstens * Heiko Carstens <heiko.carstens@de.ibm.com> 13628eb9b8SChristian Ehrhardt * Christian Ehrhardt <ehrhardt@de.ibm.com> 1415f36ebdSJason J. Herne * Jason J. Herne <jjherne@us.ibm.com> 15b0c632dbSHeiko Carstens */ 16b0c632dbSHeiko Carstens 17b0c632dbSHeiko Carstens #include <linux/compiler.h> 18b0c632dbSHeiko Carstens #include <linux/err.h> 19b0c632dbSHeiko Carstens #include <linux/fs.h> 20ca872302SChristian Borntraeger #include <linux/hrtimer.h> 21b0c632dbSHeiko Carstens #include <linux/init.h> 22b0c632dbSHeiko Carstens #include <linux/kvm.h> 23b0c632dbSHeiko Carstens #include <linux/kvm_host.h> 24b0c632dbSHeiko Carstens #include <linux/module.h> 25a374e892STony Krowiak #include <linux/random.h> 26b0c632dbSHeiko Carstens #include <linux/slab.h> 27ba5c1e9bSCarsten Otte #include <linux/timer.h> 2841408c28SThomas Huth #include <linux/vmalloc.h> 29cbb870c8SHeiko Carstens #include <asm/asm-offsets.h> 30b0c632dbSHeiko Carstens #include <asm/lowcore.h> 31b0c632dbSHeiko Carstens #include <asm/pgtable.h> 32f5daba1dSHeiko Carstens #include <asm/nmi.h> 33a0616cdeSDavid Howells #include <asm/switch_to.h> 346d3da241SJens Freimann #include <asm/isc.h> 351526bf9cSChristian Borntraeger #include <asm/sclp.h> 368f2abe6aSChristian Borntraeger #include "kvm-s390.h" 37b0c632dbSHeiko Carstens #include "gaccess.h" 38b0c632dbSHeiko Carstens 395786fffaSCornelia Huck #define CREATE_TRACE_POINTS 405786fffaSCornelia Huck #include "trace.h" 41ade38c31SCornelia Huck #include "trace-s390.h" 425786fffaSCornelia Huck 4341408c28SThomas Huth #define MEM_OP_MAX_SIZE 65536 /* Maximum transfer size for KVM_S390_MEM_OP */ 44*816c7667SJens Freimann #define LOCAL_IRQS 32 45*816c7667SJens Freimann #define VCPU_IRQS_MAX_BUF (sizeof(struct kvm_s390_irq) * \ 46*816c7667SJens Freimann (KVM_MAX_VCPUS + LOCAL_IRQS)) 4741408c28SThomas Huth 48b0c632dbSHeiko Carstens #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU 49b0c632dbSHeiko Carstens 50b0c632dbSHeiko Carstens struct kvm_stats_debugfs_item debugfs_entries[] = { 51b0c632dbSHeiko Carstens { "userspace_handled", VCPU_STAT(exit_userspace) }, 520eaeafa1SChristian Borntraeger { "exit_null", VCPU_STAT(exit_null) }, 538f2abe6aSChristian Borntraeger { "exit_validity", VCPU_STAT(exit_validity) }, 548f2abe6aSChristian Borntraeger { "exit_stop_request", VCPU_STAT(exit_stop_request) }, 558f2abe6aSChristian Borntraeger { "exit_external_request", VCPU_STAT(exit_external_request) }, 568f2abe6aSChristian Borntraeger { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) }, 57ba5c1e9bSCarsten Otte { "exit_instruction", VCPU_STAT(exit_instruction) }, 58ba5c1e9bSCarsten Otte { "exit_program_interruption", VCPU_STAT(exit_program_interruption) }, 59ba5c1e9bSCarsten Otte { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) }, 60f7819512SPaolo Bonzini { "halt_successful_poll", VCPU_STAT(halt_successful_poll) }, 61ce2e4f0bSDavid Hildenbrand { "halt_wakeup", VCPU_STAT(halt_wakeup) }, 62f5e10b09SChristian Borntraeger { "instruction_lctlg", VCPU_STAT(instruction_lctlg) }, 63ba5c1e9bSCarsten Otte { "instruction_lctl", VCPU_STAT(instruction_lctl) }, 64aba07508SDavid Hildenbrand { "instruction_stctl", VCPU_STAT(instruction_stctl) }, 65aba07508SDavid Hildenbrand { "instruction_stctg", VCPU_STAT(instruction_stctg) }, 66ba5c1e9bSCarsten Otte { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) }, 677697e71fSChristian Ehrhardt { "deliver_external_call", VCPU_STAT(deliver_external_call) }, 68ba5c1e9bSCarsten Otte { "deliver_service_signal", VCPU_STAT(deliver_service_signal) }, 69ba5c1e9bSCarsten Otte { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) }, 70ba5c1e9bSCarsten Otte { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) }, 71ba5c1e9bSCarsten Otte { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) }, 72ba5c1e9bSCarsten Otte { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) }, 73ba5c1e9bSCarsten Otte { "deliver_program_interruption", VCPU_STAT(deliver_program_int) }, 74ba5c1e9bSCarsten Otte { "exit_wait_state", VCPU_STAT(exit_wait_state) }, 7569d0d3a3SChristian Borntraeger { "instruction_pfmf", VCPU_STAT(instruction_pfmf) }, 76453423dcSChristian Borntraeger { "instruction_stidp", VCPU_STAT(instruction_stidp) }, 77453423dcSChristian Borntraeger { "instruction_spx", VCPU_STAT(instruction_spx) }, 78453423dcSChristian Borntraeger { "instruction_stpx", VCPU_STAT(instruction_stpx) }, 79453423dcSChristian Borntraeger { "instruction_stap", VCPU_STAT(instruction_stap) }, 80453423dcSChristian Borntraeger { "instruction_storage_key", VCPU_STAT(instruction_storage_key) }, 818a242234SHeiko Carstens { "instruction_ipte_interlock", VCPU_STAT(instruction_ipte_interlock) }, 82453423dcSChristian Borntraeger { "instruction_stsch", VCPU_STAT(instruction_stsch) }, 83453423dcSChristian Borntraeger { "instruction_chsc", VCPU_STAT(instruction_chsc) }, 84b31288faSKonstantin Weitz { "instruction_essa", VCPU_STAT(instruction_essa) }, 85453423dcSChristian Borntraeger { "instruction_stsi", VCPU_STAT(instruction_stsi) }, 86453423dcSChristian Borntraeger { "instruction_stfl", VCPU_STAT(instruction_stfl) }, 87bb25b9baSChristian Borntraeger { "instruction_tprot", VCPU_STAT(instruction_tprot) }, 885288fbf0SChristian Borntraeger { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) }, 89bd59d3a4SCornelia Huck { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) }, 907697e71fSChristian Ehrhardt { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) }, 915288fbf0SChristian Borntraeger { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) }, 9242cb0c9fSDavid Hildenbrand { "instruction_sigp_cond_emergency", VCPU_STAT(instruction_sigp_cond_emergency) }, 9342cb0c9fSDavid Hildenbrand { "instruction_sigp_start", VCPU_STAT(instruction_sigp_start) }, 945288fbf0SChristian Borntraeger { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) }, 9542cb0c9fSDavid Hildenbrand { "instruction_sigp_stop_store_status", VCPU_STAT(instruction_sigp_stop_store_status) }, 9642cb0c9fSDavid Hildenbrand { "instruction_sigp_store_status", VCPU_STAT(instruction_sigp_store_status) }, 97cd7b4b61SEric Farman { "instruction_sigp_store_adtl_status", VCPU_STAT(instruction_sigp_store_adtl_status) }, 985288fbf0SChristian Borntraeger { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) }, 995288fbf0SChristian Borntraeger { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) }, 1005288fbf0SChristian Borntraeger { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) }, 10142cb0c9fSDavid Hildenbrand { "instruction_sigp_cpu_reset", VCPU_STAT(instruction_sigp_cpu_reset) }, 10242cb0c9fSDavid Hildenbrand { "instruction_sigp_init_cpu_reset", VCPU_STAT(instruction_sigp_init_cpu_reset) }, 10342cb0c9fSDavid Hildenbrand { "instruction_sigp_unknown", VCPU_STAT(instruction_sigp_unknown) }, 104388186bcSChristian Borntraeger { "diagnose_10", VCPU_STAT(diagnose_10) }, 105e28acfeaSChristian Borntraeger { "diagnose_44", VCPU_STAT(diagnose_44) }, 10641628d33SKonstantin Weitz { "diagnose_9c", VCPU_STAT(diagnose_9c) }, 107b0c632dbSHeiko Carstens { NULL } 108b0c632dbSHeiko Carstens }; 109b0c632dbSHeiko Carstens 1109d8d5786SMichael Mueller /* upper facilities limit for kvm */ 1119d8d5786SMichael Mueller unsigned long kvm_s390_fac_list_mask[] = { 112a3ed8daeSChristian Borntraeger 0xffe6fffbfcfdfc40UL, 113a3ed8daeSChristian Borntraeger 0x205c800000000000UL, 1149d8d5786SMichael Mueller }; 115b0c632dbSHeiko Carstens 1169d8d5786SMichael Mueller unsigned long kvm_s390_fac_list_mask_size(void) 11778c4b59fSMichael Mueller { 1189d8d5786SMichael Mueller BUILD_BUG_ON(ARRAY_SIZE(kvm_s390_fac_list_mask) > S390_ARCH_FAC_MASK_SIZE_U64); 1199d8d5786SMichael Mueller return ARRAY_SIZE(kvm_s390_fac_list_mask); 12078c4b59fSMichael Mueller } 12178c4b59fSMichael Mueller 1229d8d5786SMichael Mueller static struct gmap_notifier gmap_notifier; 1239d8d5786SMichael Mueller 124b0c632dbSHeiko Carstens /* Section: not file related */ 12513a34e06SRadim Krčmář int kvm_arch_hardware_enable(void) 126b0c632dbSHeiko Carstens { 127b0c632dbSHeiko Carstens /* every s390 is virtualization enabled ;-) */ 12810474ae8SAlexander Graf return 0; 129b0c632dbSHeiko Carstens } 130b0c632dbSHeiko Carstens 1312c70fe44SChristian Borntraeger static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address); 1322c70fe44SChristian Borntraeger 133b0c632dbSHeiko Carstens int kvm_arch_hardware_setup(void) 134b0c632dbSHeiko Carstens { 1352c70fe44SChristian Borntraeger gmap_notifier.notifier_call = kvm_gmap_notifier; 1362c70fe44SChristian Borntraeger gmap_register_ipte_notifier(&gmap_notifier); 137b0c632dbSHeiko Carstens return 0; 138b0c632dbSHeiko Carstens } 139b0c632dbSHeiko Carstens 140b0c632dbSHeiko Carstens void kvm_arch_hardware_unsetup(void) 141b0c632dbSHeiko Carstens { 1422c70fe44SChristian Borntraeger gmap_unregister_ipte_notifier(&gmap_notifier); 143b0c632dbSHeiko Carstens } 144b0c632dbSHeiko Carstens 145b0c632dbSHeiko Carstens int kvm_arch_init(void *opaque) 146b0c632dbSHeiko Carstens { 14784877d93SCornelia Huck /* Register floating interrupt controller interface. */ 14884877d93SCornelia Huck return kvm_register_device_ops(&kvm_flic_ops, KVM_DEV_TYPE_FLIC); 149b0c632dbSHeiko Carstens } 150b0c632dbSHeiko Carstens 151b0c632dbSHeiko Carstens /* Section: device related */ 152b0c632dbSHeiko Carstens long kvm_arch_dev_ioctl(struct file *filp, 153b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 154b0c632dbSHeiko Carstens { 155b0c632dbSHeiko Carstens if (ioctl == KVM_S390_ENABLE_SIE) 156b0c632dbSHeiko Carstens return s390_enable_sie(); 157b0c632dbSHeiko Carstens return -EINVAL; 158b0c632dbSHeiko Carstens } 159b0c632dbSHeiko Carstens 160784aa3d7SAlexander Graf int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) 161b0c632dbSHeiko Carstens { 162d7b0b5ebSCarsten Otte int r; 163d7b0b5ebSCarsten Otte 1642bd0ac4eSCarsten Otte switch (ext) { 165d7b0b5ebSCarsten Otte case KVM_CAP_S390_PSW: 166b6cf8788SChristian Borntraeger case KVM_CAP_S390_GMAP: 16752e16b18SChristian Borntraeger case KVM_CAP_SYNC_MMU: 1681efd0f59SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 1691efd0f59SCarsten Otte case KVM_CAP_S390_UCONTROL: 1701efd0f59SCarsten Otte #endif 1713c038e6bSDominik Dingel case KVM_CAP_ASYNC_PF: 17260b413c9SChristian Borntraeger case KVM_CAP_SYNC_REGS: 17314eebd91SCarsten Otte case KVM_CAP_ONE_REG: 174d6712df9SCornelia Huck case KVM_CAP_ENABLE_CAP: 175fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 176ebc32262SCornelia Huck case KVM_CAP_IRQFD: 17710ccaa1eSCornelia Huck case KVM_CAP_IOEVENTFD: 178c05c4186SJens Freimann case KVM_CAP_DEVICE_CTRL: 179d938dc55SCornelia Huck case KVM_CAP_ENABLE_CAP_VM: 18078599d90SCornelia Huck case KVM_CAP_S390_IRQCHIP: 181f2061656SDominik Dingel case KVM_CAP_VM_ATTRIBUTES: 1826352e4d2SDavid Hildenbrand case KVM_CAP_MP_STATE: 18347b43c52SJens Freimann case KVM_CAP_S390_INJECT_IRQ: 1842444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 185e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 18630ee2a98SJason J. Herne case KVM_CAP_S390_SKEYS: 187*816c7667SJens Freimann case KVM_CAP_S390_IRQ_STATE: 188d7b0b5ebSCarsten Otte r = 1; 189d7b0b5ebSCarsten Otte break; 19041408c28SThomas Huth case KVM_CAP_S390_MEM_OP: 19141408c28SThomas Huth r = MEM_OP_MAX_SIZE; 19241408c28SThomas Huth break; 193e726b1bdSChristian Borntraeger case KVM_CAP_NR_VCPUS: 194e726b1bdSChristian Borntraeger case KVM_CAP_MAX_VCPUS: 195e726b1bdSChristian Borntraeger r = KVM_MAX_VCPUS; 196e726b1bdSChristian Borntraeger break; 197e1e2e605SNick Wang case KVM_CAP_NR_MEMSLOTS: 198e1e2e605SNick Wang r = KVM_USER_MEM_SLOTS; 199e1e2e605SNick Wang break; 2001526bf9cSChristian Borntraeger case KVM_CAP_S390_COW: 201abf09bedSMartin Schwidefsky r = MACHINE_HAS_ESOP; 2021526bf9cSChristian Borntraeger break; 20368c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 20468c55750SEric Farman r = MACHINE_HAS_VX; 20568c55750SEric Farman break; 2062bd0ac4eSCarsten Otte default: 207d7b0b5ebSCarsten Otte r = 0; 208b0c632dbSHeiko Carstens } 209d7b0b5ebSCarsten Otte return r; 2102bd0ac4eSCarsten Otte } 211b0c632dbSHeiko Carstens 21215f36ebdSJason J. Herne static void kvm_s390_sync_dirty_log(struct kvm *kvm, 21315f36ebdSJason J. Herne struct kvm_memory_slot *memslot) 21415f36ebdSJason J. Herne { 21515f36ebdSJason J. Herne gfn_t cur_gfn, last_gfn; 21615f36ebdSJason J. Herne unsigned long address; 21715f36ebdSJason J. Herne struct gmap *gmap = kvm->arch.gmap; 21815f36ebdSJason J. Herne 21915f36ebdSJason J. Herne down_read(&gmap->mm->mmap_sem); 22015f36ebdSJason J. Herne /* Loop over all guest pages */ 22115f36ebdSJason J. Herne last_gfn = memslot->base_gfn + memslot->npages; 22215f36ebdSJason J. Herne for (cur_gfn = memslot->base_gfn; cur_gfn <= last_gfn; cur_gfn++) { 22315f36ebdSJason J. Herne address = gfn_to_hva_memslot(memslot, cur_gfn); 22415f36ebdSJason J. Herne 22515f36ebdSJason J. Herne if (gmap_test_and_clear_dirty(address, gmap)) 22615f36ebdSJason J. Herne mark_page_dirty(kvm, cur_gfn); 22715f36ebdSJason J. Herne } 22815f36ebdSJason J. Herne up_read(&gmap->mm->mmap_sem); 22915f36ebdSJason J. Herne } 23015f36ebdSJason J. Herne 231b0c632dbSHeiko Carstens /* Section: vm related */ 232b0c632dbSHeiko Carstens /* 233b0c632dbSHeiko Carstens * Get (and clear) the dirty memory log for a memory slot. 234b0c632dbSHeiko Carstens */ 235b0c632dbSHeiko Carstens int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, 236b0c632dbSHeiko Carstens struct kvm_dirty_log *log) 237b0c632dbSHeiko Carstens { 23815f36ebdSJason J. Herne int r; 23915f36ebdSJason J. Herne unsigned long n; 24015f36ebdSJason J. Herne struct kvm_memory_slot *memslot; 24115f36ebdSJason J. Herne int is_dirty = 0; 24215f36ebdSJason J. Herne 24315f36ebdSJason J. Herne mutex_lock(&kvm->slots_lock); 24415f36ebdSJason J. Herne 24515f36ebdSJason J. Herne r = -EINVAL; 24615f36ebdSJason J. Herne if (log->slot >= KVM_USER_MEM_SLOTS) 24715f36ebdSJason J. Herne goto out; 24815f36ebdSJason J. Herne 24915f36ebdSJason J. Herne memslot = id_to_memslot(kvm->memslots, log->slot); 25015f36ebdSJason J. Herne r = -ENOENT; 25115f36ebdSJason J. Herne if (!memslot->dirty_bitmap) 25215f36ebdSJason J. Herne goto out; 25315f36ebdSJason J. Herne 25415f36ebdSJason J. Herne kvm_s390_sync_dirty_log(kvm, memslot); 25515f36ebdSJason J. Herne r = kvm_get_dirty_log(kvm, log, &is_dirty); 25615f36ebdSJason J. Herne if (r) 25715f36ebdSJason J. Herne goto out; 25815f36ebdSJason J. Herne 25915f36ebdSJason J. Herne /* Clear the dirty log */ 26015f36ebdSJason J. Herne if (is_dirty) { 26115f36ebdSJason J. Herne n = kvm_dirty_bitmap_bytes(memslot); 26215f36ebdSJason J. Herne memset(memslot->dirty_bitmap, 0, n); 26315f36ebdSJason J. Herne } 26415f36ebdSJason J. Herne r = 0; 26515f36ebdSJason J. Herne out: 26615f36ebdSJason J. Herne mutex_unlock(&kvm->slots_lock); 26715f36ebdSJason J. Herne return r; 268b0c632dbSHeiko Carstens } 269b0c632dbSHeiko Carstens 270d938dc55SCornelia Huck static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap) 271d938dc55SCornelia Huck { 272d938dc55SCornelia Huck int r; 273d938dc55SCornelia Huck 274d938dc55SCornelia Huck if (cap->flags) 275d938dc55SCornelia Huck return -EINVAL; 276d938dc55SCornelia Huck 277d938dc55SCornelia Huck switch (cap->cap) { 27884223598SCornelia Huck case KVM_CAP_S390_IRQCHIP: 27984223598SCornelia Huck kvm->arch.use_irqchip = 1; 28084223598SCornelia Huck r = 0; 28184223598SCornelia Huck break; 2822444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 2832444b352SDavid Hildenbrand kvm->arch.user_sigp = 1; 2842444b352SDavid Hildenbrand r = 0; 2852444b352SDavid Hildenbrand break; 28668c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 28718280d8bSMichael Mueller if (MACHINE_HAS_VX) { 28818280d8bSMichael Mueller set_kvm_facility(kvm->arch.model.fac->mask, 129); 28918280d8bSMichael Mueller set_kvm_facility(kvm->arch.model.fac->list, 129); 29018280d8bSMichael Mueller r = 0; 29118280d8bSMichael Mueller } else 29218280d8bSMichael Mueller r = -EINVAL; 29368c55750SEric Farman break; 294e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 295e44fc8c9SEkaterina Tumanova kvm->arch.user_stsi = 1; 296e44fc8c9SEkaterina Tumanova r = 0; 297e44fc8c9SEkaterina Tumanova break; 298d938dc55SCornelia Huck default: 299d938dc55SCornelia Huck r = -EINVAL; 300d938dc55SCornelia Huck break; 301d938dc55SCornelia Huck } 302d938dc55SCornelia Huck return r; 303d938dc55SCornelia Huck } 304d938dc55SCornelia Huck 3058c0a7ce6SDominik Dingel static int kvm_s390_get_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 3068c0a7ce6SDominik Dingel { 3078c0a7ce6SDominik Dingel int ret; 3088c0a7ce6SDominik Dingel 3098c0a7ce6SDominik Dingel switch (attr->attr) { 3108c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 3118c0a7ce6SDominik Dingel ret = 0; 3128c0a7ce6SDominik Dingel if (put_user(kvm->arch.gmap->asce_end, (u64 __user *)attr->addr)) 3138c0a7ce6SDominik Dingel ret = -EFAULT; 3148c0a7ce6SDominik Dingel break; 3158c0a7ce6SDominik Dingel default: 3168c0a7ce6SDominik Dingel ret = -ENXIO; 3178c0a7ce6SDominik Dingel break; 3188c0a7ce6SDominik Dingel } 3198c0a7ce6SDominik Dingel return ret; 3208c0a7ce6SDominik Dingel } 3218c0a7ce6SDominik Dingel 3228c0a7ce6SDominik Dingel static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 3234f718eabSDominik Dingel { 3244f718eabSDominik Dingel int ret; 3254f718eabSDominik Dingel unsigned int idx; 3264f718eabSDominik Dingel switch (attr->attr) { 3274f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 3284f718eabSDominik Dingel ret = -EBUSY; 3294f718eabSDominik Dingel mutex_lock(&kvm->lock); 3304f718eabSDominik Dingel if (atomic_read(&kvm->online_vcpus) == 0) { 3314f718eabSDominik Dingel kvm->arch.use_cmma = 1; 3324f718eabSDominik Dingel ret = 0; 3334f718eabSDominik Dingel } 3344f718eabSDominik Dingel mutex_unlock(&kvm->lock); 3354f718eabSDominik Dingel break; 3364f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 3374f718eabSDominik Dingel mutex_lock(&kvm->lock); 3384f718eabSDominik Dingel idx = srcu_read_lock(&kvm->srcu); 339a13cff31SDominik Dingel s390_reset_cmma(kvm->arch.gmap->mm); 3404f718eabSDominik Dingel srcu_read_unlock(&kvm->srcu, idx); 3414f718eabSDominik Dingel mutex_unlock(&kvm->lock); 3424f718eabSDominik Dingel ret = 0; 3434f718eabSDominik Dingel break; 3448c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: { 3458c0a7ce6SDominik Dingel unsigned long new_limit; 3468c0a7ce6SDominik Dingel 3478c0a7ce6SDominik Dingel if (kvm_is_ucontrol(kvm)) 3488c0a7ce6SDominik Dingel return -EINVAL; 3498c0a7ce6SDominik Dingel 3508c0a7ce6SDominik Dingel if (get_user(new_limit, (u64 __user *)attr->addr)) 3518c0a7ce6SDominik Dingel return -EFAULT; 3528c0a7ce6SDominik Dingel 3538c0a7ce6SDominik Dingel if (new_limit > kvm->arch.gmap->asce_end) 3548c0a7ce6SDominik Dingel return -E2BIG; 3558c0a7ce6SDominik Dingel 3568c0a7ce6SDominik Dingel ret = -EBUSY; 3578c0a7ce6SDominik Dingel mutex_lock(&kvm->lock); 3588c0a7ce6SDominik Dingel if (atomic_read(&kvm->online_vcpus) == 0) { 3598c0a7ce6SDominik Dingel /* gmap_alloc will round the limit up */ 3608c0a7ce6SDominik Dingel struct gmap *new = gmap_alloc(current->mm, new_limit); 3618c0a7ce6SDominik Dingel 3628c0a7ce6SDominik Dingel if (!new) { 3638c0a7ce6SDominik Dingel ret = -ENOMEM; 3648c0a7ce6SDominik Dingel } else { 3658c0a7ce6SDominik Dingel gmap_free(kvm->arch.gmap); 3668c0a7ce6SDominik Dingel new->private = kvm; 3678c0a7ce6SDominik Dingel kvm->arch.gmap = new; 3688c0a7ce6SDominik Dingel ret = 0; 3698c0a7ce6SDominik Dingel } 3708c0a7ce6SDominik Dingel } 3718c0a7ce6SDominik Dingel mutex_unlock(&kvm->lock); 3728c0a7ce6SDominik Dingel break; 3738c0a7ce6SDominik Dingel } 3744f718eabSDominik Dingel default: 3754f718eabSDominik Dingel ret = -ENXIO; 3764f718eabSDominik Dingel break; 3774f718eabSDominik Dingel } 3784f718eabSDominik Dingel return ret; 3794f718eabSDominik Dingel } 3804f718eabSDominik Dingel 381a374e892STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu); 382a374e892STony Krowiak 383a374e892STony Krowiak static int kvm_s390_vm_set_crypto(struct kvm *kvm, struct kvm_device_attr *attr) 384a374e892STony Krowiak { 385a374e892STony Krowiak struct kvm_vcpu *vcpu; 386a374e892STony Krowiak int i; 387a374e892STony Krowiak 3889d8d5786SMichael Mueller if (!test_kvm_facility(kvm, 76)) 389a374e892STony Krowiak return -EINVAL; 390a374e892STony Krowiak 391a374e892STony Krowiak mutex_lock(&kvm->lock); 392a374e892STony Krowiak switch (attr->attr) { 393a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 394a374e892STony Krowiak get_random_bytes( 395a374e892STony Krowiak kvm->arch.crypto.crycb->aes_wrapping_key_mask, 396a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 397a374e892STony Krowiak kvm->arch.crypto.aes_kw = 1; 398a374e892STony Krowiak break; 399a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 400a374e892STony Krowiak get_random_bytes( 401a374e892STony Krowiak kvm->arch.crypto.crycb->dea_wrapping_key_mask, 402a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 403a374e892STony Krowiak kvm->arch.crypto.dea_kw = 1; 404a374e892STony Krowiak break; 405a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 406a374e892STony Krowiak kvm->arch.crypto.aes_kw = 0; 407a374e892STony Krowiak memset(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 0, 408a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 409a374e892STony Krowiak break; 410a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 411a374e892STony Krowiak kvm->arch.crypto.dea_kw = 0; 412a374e892STony Krowiak memset(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 0, 413a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 414a374e892STony Krowiak break; 415a374e892STony Krowiak default: 416a374e892STony Krowiak mutex_unlock(&kvm->lock); 417a374e892STony Krowiak return -ENXIO; 418a374e892STony Krowiak } 419a374e892STony Krowiak 420a374e892STony Krowiak kvm_for_each_vcpu(i, vcpu, kvm) { 421a374e892STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 422a374e892STony Krowiak exit_sie(vcpu); 423a374e892STony Krowiak } 424a374e892STony Krowiak mutex_unlock(&kvm->lock); 425a374e892STony Krowiak return 0; 426a374e892STony Krowiak } 427a374e892STony Krowiak 42872f25020SJason J. Herne static int kvm_s390_set_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 42972f25020SJason J. Herne { 43072f25020SJason J. Herne u8 gtod_high; 43172f25020SJason J. Herne 43272f25020SJason J. Herne if (copy_from_user(>od_high, (void __user *)attr->addr, 43372f25020SJason J. Herne sizeof(gtod_high))) 43472f25020SJason J. Herne return -EFAULT; 43572f25020SJason J. Herne 43672f25020SJason J. Herne if (gtod_high != 0) 43772f25020SJason J. Herne return -EINVAL; 43872f25020SJason J. Herne 43972f25020SJason J. Herne return 0; 44072f25020SJason J. Herne } 44172f25020SJason J. Herne 44272f25020SJason J. Herne static int kvm_s390_set_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 44372f25020SJason J. Herne { 44472f25020SJason J. Herne struct kvm_vcpu *cur_vcpu; 44572f25020SJason J. Herne unsigned int vcpu_idx; 44672f25020SJason J. Herne u64 host_tod, gtod; 44772f25020SJason J. Herne int r; 44872f25020SJason J. Herne 44972f25020SJason J. Herne if (copy_from_user(>od, (void __user *)attr->addr, sizeof(gtod))) 45072f25020SJason J. Herne return -EFAULT; 45172f25020SJason J. Herne 45272f25020SJason J. Herne r = store_tod_clock(&host_tod); 45372f25020SJason J. Herne if (r) 45472f25020SJason J. Herne return r; 45572f25020SJason J. Herne 45672f25020SJason J. Herne mutex_lock(&kvm->lock); 45772f25020SJason J. Herne kvm->arch.epoch = gtod - host_tod; 45872f25020SJason J. Herne kvm_for_each_vcpu(vcpu_idx, cur_vcpu, kvm) { 45972f25020SJason J. Herne cur_vcpu->arch.sie_block->epoch = kvm->arch.epoch; 46072f25020SJason J. Herne exit_sie(cur_vcpu); 46172f25020SJason J. Herne } 46272f25020SJason J. Herne mutex_unlock(&kvm->lock); 46372f25020SJason J. Herne return 0; 46472f25020SJason J. Herne } 46572f25020SJason J. Herne 46672f25020SJason J. Herne static int kvm_s390_set_tod(struct kvm *kvm, struct kvm_device_attr *attr) 46772f25020SJason J. Herne { 46872f25020SJason J. Herne int ret; 46972f25020SJason J. Herne 47072f25020SJason J. Herne if (attr->flags) 47172f25020SJason J. Herne return -EINVAL; 47272f25020SJason J. Herne 47372f25020SJason J. Herne switch (attr->attr) { 47472f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 47572f25020SJason J. Herne ret = kvm_s390_set_tod_high(kvm, attr); 47672f25020SJason J. Herne break; 47772f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 47872f25020SJason J. Herne ret = kvm_s390_set_tod_low(kvm, attr); 47972f25020SJason J. Herne break; 48072f25020SJason J. Herne default: 48172f25020SJason J. Herne ret = -ENXIO; 48272f25020SJason J. Herne break; 48372f25020SJason J. Herne } 48472f25020SJason J. Herne return ret; 48572f25020SJason J. Herne } 48672f25020SJason J. Herne 48772f25020SJason J. Herne static int kvm_s390_get_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 48872f25020SJason J. Herne { 48972f25020SJason J. Herne u8 gtod_high = 0; 49072f25020SJason J. Herne 49172f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od_high, 49272f25020SJason J. Herne sizeof(gtod_high))) 49372f25020SJason J. Herne return -EFAULT; 49472f25020SJason J. Herne 49572f25020SJason J. Herne return 0; 49672f25020SJason J. Herne } 49772f25020SJason J. Herne 49872f25020SJason J. Herne static int kvm_s390_get_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 49972f25020SJason J. Herne { 50072f25020SJason J. Herne u64 host_tod, gtod; 50172f25020SJason J. Herne int r; 50272f25020SJason J. Herne 50372f25020SJason J. Herne r = store_tod_clock(&host_tod); 50472f25020SJason J. Herne if (r) 50572f25020SJason J. Herne return r; 50672f25020SJason J. Herne 50772f25020SJason J. Herne gtod = host_tod + kvm->arch.epoch; 50872f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od, sizeof(gtod))) 50972f25020SJason J. Herne return -EFAULT; 51072f25020SJason J. Herne 51172f25020SJason J. Herne return 0; 51272f25020SJason J. Herne } 51372f25020SJason J. Herne 51472f25020SJason J. Herne static int kvm_s390_get_tod(struct kvm *kvm, struct kvm_device_attr *attr) 51572f25020SJason J. Herne { 51672f25020SJason J. Herne int ret; 51772f25020SJason J. Herne 51872f25020SJason J. Herne if (attr->flags) 51972f25020SJason J. Herne return -EINVAL; 52072f25020SJason J. Herne 52172f25020SJason J. Herne switch (attr->attr) { 52272f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 52372f25020SJason J. Herne ret = kvm_s390_get_tod_high(kvm, attr); 52472f25020SJason J. Herne break; 52572f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 52672f25020SJason J. Herne ret = kvm_s390_get_tod_low(kvm, attr); 52772f25020SJason J. Herne break; 52872f25020SJason J. Herne default: 52972f25020SJason J. Herne ret = -ENXIO; 53072f25020SJason J. Herne break; 53172f25020SJason J. Herne } 53272f25020SJason J. Herne return ret; 53372f25020SJason J. Herne } 53472f25020SJason J. Herne 535658b6edaSMichael Mueller static int kvm_s390_set_processor(struct kvm *kvm, struct kvm_device_attr *attr) 536658b6edaSMichael Mueller { 537658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 538658b6edaSMichael Mueller int ret = 0; 539658b6edaSMichael Mueller 540658b6edaSMichael Mueller mutex_lock(&kvm->lock); 541658b6edaSMichael Mueller if (atomic_read(&kvm->online_vcpus)) { 542658b6edaSMichael Mueller ret = -EBUSY; 543658b6edaSMichael Mueller goto out; 544658b6edaSMichael Mueller } 545658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 546658b6edaSMichael Mueller if (!proc) { 547658b6edaSMichael Mueller ret = -ENOMEM; 548658b6edaSMichael Mueller goto out; 549658b6edaSMichael Mueller } 550658b6edaSMichael Mueller if (!copy_from_user(proc, (void __user *)attr->addr, 551658b6edaSMichael Mueller sizeof(*proc))) { 552658b6edaSMichael Mueller memcpy(&kvm->arch.model.cpu_id, &proc->cpuid, 553658b6edaSMichael Mueller sizeof(struct cpuid)); 554658b6edaSMichael Mueller kvm->arch.model.ibc = proc->ibc; 555981467c9SMichael Mueller memcpy(kvm->arch.model.fac->list, proc->fac_list, 556658b6edaSMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 557658b6edaSMichael Mueller } else 558658b6edaSMichael Mueller ret = -EFAULT; 559658b6edaSMichael Mueller kfree(proc); 560658b6edaSMichael Mueller out: 561658b6edaSMichael Mueller mutex_unlock(&kvm->lock); 562658b6edaSMichael Mueller return ret; 563658b6edaSMichael Mueller } 564658b6edaSMichael Mueller 565658b6edaSMichael Mueller static int kvm_s390_set_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 566658b6edaSMichael Mueller { 567658b6edaSMichael Mueller int ret = -ENXIO; 568658b6edaSMichael Mueller 569658b6edaSMichael Mueller switch (attr->attr) { 570658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 571658b6edaSMichael Mueller ret = kvm_s390_set_processor(kvm, attr); 572658b6edaSMichael Mueller break; 573658b6edaSMichael Mueller } 574658b6edaSMichael Mueller return ret; 575658b6edaSMichael Mueller } 576658b6edaSMichael Mueller 577658b6edaSMichael Mueller static int kvm_s390_get_processor(struct kvm *kvm, struct kvm_device_attr *attr) 578658b6edaSMichael Mueller { 579658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 580658b6edaSMichael Mueller int ret = 0; 581658b6edaSMichael Mueller 582658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 583658b6edaSMichael Mueller if (!proc) { 584658b6edaSMichael Mueller ret = -ENOMEM; 585658b6edaSMichael Mueller goto out; 586658b6edaSMichael Mueller } 587658b6edaSMichael Mueller memcpy(&proc->cpuid, &kvm->arch.model.cpu_id, sizeof(struct cpuid)); 588658b6edaSMichael Mueller proc->ibc = kvm->arch.model.ibc; 589981467c9SMichael Mueller memcpy(&proc->fac_list, kvm->arch.model.fac->list, S390_ARCH_FAC_LIST_SIZE_BYTE); 590658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, proc, sizeof(*proc))) 591658b6edaSMichael Mueller ret = -EFAULT; 592658b6edaSMichael Mueller kfree(proc); 593658b6edaSMichael Mueller out: 594658b6edaSMichael Mueller return ret; 595658b6edaSMichael Mueller } 596658b6edaSMichael Mueller 597658b6edaSMichael Mueller static int kvm_s390_get_machine(struct kvm *kvm, struct kvm_device_attr *attr) 598658b6edaSMichael Mueller { 599658b6edaSMichael Mueller struct kvm_s390_vm_cpu_machine *mach; 600658b6edaSMichael Mueller int ret = 0; 601658b6edaSMichael Mueller 602658b6edaSMichael Mueller mach = kzalloc(sizeof(*mach), GFP_KERNEL); 603658b6edaSMichael Mueller if (!mach) { 604658b6edaSMichael Mueller ret = -ENOMEM; 605658b6edaSMichael Mueller goto out; 606658b6edaSMichael Mueller } 607658b6edaSMichael Mueller get_cpu_id((struct cpuid *) &mach->cpuid); 608658b6edaSMichael Mueller mach->ibc = sclp_get_ibc(); 609981467c9SMichael Mueller memcpy(&mach->fac_mask, kvm->arch.model.fac->mask, 610981467c9SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 611658b6edaSMichael Mueller memcpy((unsigned long *)&mach->fac_list, S390_lowcore.stfle_fac_list, 61294422ee8SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 613658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, mach, sizeof(*mach))) 614658b6edaSMichael Mueller ret = -EFAULT; 615658b6edaSMichael Mueller kfree(mach); 616658b6edaSMichael Mueller out: 617658b6edaSMichael Mueller return ret; 618658b6edaSMichael Mueller } 619658b6edaSMichael Mueller 620658b6edaSMichael Mueller static int kvm_s390_get_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 621658b6edaSMichael Mueller { 622658b6edaSMichael Mueller int ret = -ENXIO; 623658b6edaSMichael Mueller 624658b6edaSMichael Mueller switch (attr->attr) { 625658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 626658b6edaSMichael Mueller ret = kvm_s390_get_processor(kvm, attr); 627658b6edaSMichael Mueller break; 628658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 629658b6edaSMichael Mueller ret = kvm_s390_get_machine(kvm, attr); 630658b6edaSMichael Mueller break; 631658b6edaSMichael Mueller } 632658b6edaSMichael Mueller return ret; 633658b6edaSMichael Mueller } 634658b6edaSMichael Mueller 635f2061656SDominik Dingel static int kvm_s390_vm_set_attr(struct kvm *kvm, struct kvm_device_attr *attr) 636f2061656SDominik Dingel { 637f2061656SDominik Dingel int ret; 638f2061656SDominik Dingel 639f2061656SDominik Dingel switch (attr->group) { 6404f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 6418c0a7ce6SDominik Dingel ret = kvm_s390_set_mem_control(kvm, attr); 6424f718eabSDominik Dingel break; 64372f25020SJason J. Herne case KVM_S390_VM_TOD: 64472f25020SJason J. Herne ret = kvm_s390_set_tod(kvm, attr); 64572f25020SJason J. Herne break; 646658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 647658b6edaSMichael Mueller ret = kvm_s390_set_cpu_model(kvm, attr); 648658b6edaSMichael Mueller break; 649a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 650a374e892STony Krowiak ret = kvm_s390_vm_set_crypto(kvm, attr); 651a374e892STony Krowiak break; 652f2061656SDominik Dingel default: 653f2061656SDominik Dingel ret = -ENXIO; 654f2061656SDominik Dingel break; 655f2061656SDominik Dingel } 656f2061656SDominik Dingel 657f2061656SDominik Dingel return ret; 658f2061656SDominik Dingel } 659f2061656SDominik Dingel 660f2061656SDominik Dingel static int kvm_s390_vm_get_attr(struct kvm *kvm, struct kvm_device_attr *attr) 661f2061656SDominik Dingel { 6628c0a7ce6SDominik Dingel int ret; 6638c0a7ce6SDominik Dingel 6648c0a7ce6SDominik Dingel switch (attr->group) { 6658c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_CTRL: 6668c0a7ce6SDominik Dingel ret = kvm_s390_get_mem_control(kvm, attr); 6678c0a7ce6SDominik Dingel break; 66872f25020SJason J. Herne case KVM_S390_VM_TOD: 66972f25020SJason J. Herne ret = kvm_s390_get_tod(kvm, attr); 67072f25020SJason J. Herne break; 671658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 672658b6edaSMichael Mueller ret = kvm_s390_get_cpu_model(kvm, attr); 673658b6edaSMichael Mueller break; 6748c0a7ce6SDominik Dingel default: 6758c0a7ce6SDominik Dingel ret = -ENXIO; 6768c0a7ce6SDominik Dingel break; 6778c0a7ce6SDominik Dingel } 6788c0a7ce6SDominik Dingel 6798c0a7ce6SDominik Dingel return ret; 680f2061656SDominik Dingel } 681f2061656SDominik Dingel 682f2061656SDominik Dingel static int kvm_s390_vm_has_attr(struct kvm *kvm, struct kvm_device_attr *attr) 683f2061656SDominik Dingel { 684f2061656SDominik Dingel int ret; 685f2061656SDominik Dingel 686f2061656SDominik Dingel switch (attr->group) { 6874f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 6884f718eabSDominik Dingel switch (attr->attr) { 6894f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 6904f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 6918c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 6924f718eabSDominik Dingel ret = 0; 6934f718eabSDominik Dingel break; 6944f718eabSDominik Dingel default: 6954f718eabSDominik Dingel ret = -ENXIO; 6964f718eabSDominik Dingel break; 6974f718eabSDominik Dingel } 6984f718eabSDominik Dingel break; 69972f25020SJason J. Herne case KVM_S390_VM_TOD: 70072f25020SJason J. Herne switch (attr->attr) { 70172f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 70272f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 70372f25020SJason J. Herne ret = 0; 70472f25020SJason J. Herne break; 70572f25020SJason J. Herne default: 70672f25020SJason J. Herne ret = -ENXIO; 70772f25020SJason J. Herne break; 70872f25020SJason J. Herne } 70972f25020SJason J. Herne break; 710658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 711658b6edaSMichael Mueller switch (attr->attr) { 712658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 713658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 714658b6edaSMichael Mueller ret = 0; 715658b6edaSMichael Mueller break; 716658b6edaSMichael Mueller default: 717658b6edaSMichael Mueller ret = -ENXIO; 718658b6edaSMichael Mueller break; 719658b6edaSMichael Mueller } 720658b6edaSMichael Mueller break; 721a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 722a374e892STony Krowiak switch (attr->attr) { 723a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 724a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 725a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 726a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 727a374e892STony Krowiak ret = 0; 728a374e892STony Krowiak break; 729a374e892STony Krowiak default: 730a374e892STony Krowiak ret = -ENXIO; 731a374e892STony Krowiak break; 732a374e892STony Krowiak } 733a374e892STony Krowiak break; 734f2061656SDominik Dingel default: 735f2061656SDominik Dingel ret = -ENXIO; 736f2061656SDominik Dingel break; 737f2061656SDominik Dingel } 738f2061656SDominik Dingel 739f2061656SDominik Dingel return ret; 740f2061656SDominik Dingel } 741f2061656SDominik Dingel 74230ee2a98SJason J. Herne static long kvm_s390_get_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 74330ee2a98SJason J. Herne { 74430ee2a98SJason J. Herne uint8_t *keys; 74530ee2a98SJason J. Herne uint64_t hva; 74630ee2a98SJason J. Herne unsigned long curkey; 74730ee2a98SJason J. Herne int i, r = 0; 74830ee2a98SJason J. Herne 74930ee2a98SJason J. Herne if (args->flags != 0) 75030ee2a98SJason J. Herne return -EINVAL; 75130ee2a98SJason J. Herne 75230ee2a98SJason J. Herne /* Is this guest using storage keys? */ 75330ee2a98SJason J. Herne if (!mm_use_skey(current->mm)) 75430ee2a98SJason J. Herne return KVM_S390_GET_SKEYS_NONE; 75530ee2a98SJason J. Herne 75630ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 75730ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 75830ee2a98SJason J. Herne return -EINVAL; 75930ee2a98SJason J. Herne 76030ee2a98SJason J. Herne keys = kmalloc_array(args->count, sizeof(uint8_t), 76130ee2a98SJason J. Herne GFP_KERNEL | __GFP_NOWARN); 76230ee2a98SJason J. Herne if (!keys) 76330ee2a98SJason J. Herne keys = vmalloc(sizeof(uint8_t) * args->count); 76430ee2a98SJason J. Herne if (!keys) 76530ee2a98SJason J. Herne return -ENOMEM; 76630ee2a98SJason J. Herne 76730ee2a98SJason J. Herne for (i = 0; i < args->count; i++) { 76830ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 76930ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 77030ee2a98SJason J. Herne r = -EFAULT; 77130ee2a98SJason J. Herne goto out; 77230ee2a98SJason J. Herne } 77330ee2a98SJason J. Herne 77430ee2a98SJason J. Herne curkey = get_guest_storage_key(current->mm, hva); 77530ee2a98SJason J. Herne if (IS_ERR_VALUE(curkey)) { 77630ee2a98SJason J. Herne r = curkey; 77730ee2a98SJason J. Herne goto out; 77830ee2a98SJason J. Herne } 77930ee2a98SJason J. Herne keys[i] = curkey; 78030ee2a98SJason J. Herne } 78130ee2a98SJason J. Herne 78230ee2a98SJason J. Herne r = copy_to_user((uint8_t __user *)args->skeydata_addr, keys, 78330ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 78430ee2a98SJason J. Herne if (r) 78530ee2a98SJason J. Herne r = -EFAULT; 78630ee2a98SJason J. Herne out: 78730ee2a98SJason J. Herne kvfree(keys); 78830ee2a98SJason J. Herne return r; 78930ee2a98SJason J. Herne } 79030ee2a98SJason J. Herne 79130ee2a98SJason J. Herne static long kvm_s390_set_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 79230ee2a98SJason J. Herne { 79330ee2a98SJason J. Herne uint8_t *keys; 79430ee2a98SJason J. Herne uint64_t hva; 79530ee2a98SJason J. Herne int i, r = 0; 79630ee2a98SJason J. Herne 79730ee2a98SJason J. Herne if (args->flags != 0) 79830ee2a98SJason J. Herne return -EINVAL; 79930ee2a98SJason J. Herne 80030ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 80130ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 80230ee2a98SJason J. Herne return -EINVAL; 80330ee2a98SJason J. Herne 80430ee2a98SJason J. Herne keys = kmalloc_array(args->count, sizeof(uint8_t), 80530ee2a98SJason J. Herne GFP_KERNEL | __GFP_NOWARN); 80630ee2a98SJason J. Herne if (!keys) 80730ee2a98SJason J. Herne keys = vmalloc(sizeof(uint8_t) * args->count); 80830ee2a98SJason J. Herne if (!keys) 80930ee2a98SJason J. Herne return -ENOMEM; 81030ee2a98SJason J. Herne 81130ee2a98SJason J. Herne r = copy_from_user(keys, (uint8_t __user *)args->skeydata_addr, 81230ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 81330ee2a98SJason J. Herne if (r) { 81430ee2a98SJason J. Herne r = -EFAULT; 81530ee2a98SJason J. Herne goto out; 81630ee2a98SJason J. Herne } 81730ee2a98SJason J. Herne 81830ee2a98SJason J. Herne /* Enable storage key handling for the guest */ 81930ee2a98SJason J. Herne s390_enable_skey(); 82030ee2a98SJason J. Herne 82130ee2a98SJason J. Herne for (i = 0; i < args->count; i++) { 82230ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 82330ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 82430ee2a98SJason J. Herne r = -EFAULT; 82530ee2a98SJason J. Herne goto out; 82630ee2a98SJason J. Herne } 82730ee2a98SJason J. Herne 82830ee2a98SJason J. Herne /* Lowest order bit is reserved */ 82930ee2a98SJason J. Herne if (keys[i] & 0x01) { 83030ee2a98SJason J. Herne r = -EINVAL; 83130ee2a98SJason J. Herne goto out; 83230ee2a98SJason J. Herne } 83330ee2a98SJason J. Herne 83430ee2a98SJason J. Herne r = set_guest_storage_key(current->mm, hva, 83530ee2a98SJason J. Herne (unsigned long)keys[i], 0); 83630ee2a98SJason J. Herne if (r) 83730ee2a98SJason J. Herne goto out; 83830ee2a98SJason J. Herne } 83930ee2a98SJason J. Herne out: 84030ee2a98SJason J. Herne kvfree(keys); 84130ee2a98SJason J. Herne return r; 84230ee2a98SJason J. Herne } 84330ee2a98SJason J. Herne 844b0c632dbSHeiko Carstens long kvm_arch_vm_ioctl(struct file *filp, 845b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 846b0c632dbSHeiko Carstens { 847b0c632dbSHeiko Carstens struct kvm *kvm = filp->private_data; 848b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 849f2061656SDominik Dingel struct kvm_device_attr attr; 850b0c632dbSHeiko Carstens int r; 851b0c632dbSHeiko Carstens 852b0c632dbSHeiko Carstens switch (ioctl) { 853ba5c1e9bSCarsten Otte case KVM_S390_INTERRUPT: { 854ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 855ba5c1e9bSCarsten Otte 856ba5c1e9bSCarsten Otte r = -EFAULT; 857ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 858ba5c1e9bSCarsten Otte break; 859ba5c1e9bSCarsten Otte r = kvm_s390_inject_vm(kvm, &s390int); 860ba5c1e9bSCarsten Otte break; 861ba5c1e9bSCarsten Otte } 862d938dc55SCornelia Huck case KVM_ENABLE_CAP: { 863d938dc55SCornelia Huck struct kvm_enable_cap cap; 864d938dc55SCornelia Huck r = -EFAULT; 865d938dc55SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 866d938dc55SCornelia Huck break; 867d938dc55SCornelia Huck r = kvm_vm_ioctl_enable_cap(kvm, &cap); 868d938dc55SCornelia Huck break; 869d938dc55SCornelia Huck } 87084223598SCornelia Huck case KVM_CREATE_IRQCHIP: { 87184223598SCornelia Huck struct kvm_irq_routing_entry routing; 87284223598SCornelia Huck 87384223598SCornelia Huck r = -EINVAL; 87484223598SCornelia Huck if (kvm->arch.use_irqchip) { 87584223598SCornelia Huck /* Set up dummy routing. */ 87684223598SCornelia Huck memset(&routing, 0, sizeof(routing)); 87784223598SCornelia Huck kvm_set_irq_routing(kvm, &routing, 0, 0); 87884223598SCornelia Huck r = 0; 87984223598SCornelia Huck } 88084223598SCornelia Huck break; 88184223598SCornelia Huck } 882f2061656SDominik Dingel case KVM_SET_DEVICE_ATTR: { 883f2061656SDominik Dingel r = -EFAULT; 884f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 885f2061656SDominik Dingel break; 886f2061656SDominik Dingel r = kvm_s390_vm_set_attr(kvm, &attr); 887f2061656SDominik Dingel break; 888f2061656SDominik Dingel } 889f2061656SDominik Dingel case KVM_GET_DEVICE_ATTR: { 890f2061656SDominik Dingel r = -EFAULT; 891f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 892f2061656SDominik Dingel break; 893f2061656SDominik Dingel r = kvm_s390_vm_get_attr(kvm, &attr); 894f2061656SDominik Dingel break; 895f2061656SDominik Dingel } 896f2061656SDominik Dingel case KVM_HAS_DEVICE_ATTR: { 897f2061656SDominik Dingel r = -EFAULT; 898f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 899f2061656SDominik Dingel break; 900f2061656SDominik Dingel r = kvm_s390_vm_has_attr(kvm, &attr); 901f2061656SDominik Dingel break; 902f2061656SDominik Dingel } 90330ee2a98SJason J. Herne case KVM_S390_GET_SKEYS: { 90430ee2a98SJason J. Herne struct kvm_s390_skeys args; 90530ee2a98SJason J. Herne 90630ee2a98SJason J. Herne r = -EFAULT; 90730ee2a98SJason J. Herne if (copy_from_user(&args, argp, 90830ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 90930ee2a98SJason J. Herne break; 91030ee2a98SJason J. Herne r = kvm_s390_get_skeys(kvm, &args); 91130ee2a98SJason J. Herne break; 91230ee2a98SJason J. Herne } 91330ee2a98SJason J. Herne case KVM_S390_SET_SKEYS: { 91430ee2a98SJason J. Herne struct kvm_s390_skeys args; 91530ee2a98SJason J. Herne 91630ee2a98SJason J. Herne r = -EFAULT; 91730ee2a98SJason J. Herne if (copy_from_user(&args, argp, 91830ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 91930ee2a98SJason J. Herne break; 92030ee2a98SJason J. Herne r = kvm_s390_set_skeys(kvm, &args); 92130ee2a98SJason J. Herne break; 92230ee2a98SJason J. Herne } 923b0c632dbSHeiko Carstens default: 924367e1319SAvi Kivity r = -ENOTTY; 925b0c632dbSHeiko Carstens } 926b0c632dbSHeiko Carstens 927b0c632dbSHeiko Carstens return r; 928b0c632dbSHeiko Carstens } 929b0c632dbSHeiko Carstens 93045c9b47cSTony Krowiak static int kvm_s390_query_ap_config(u8 *config) 93145c9b47cSTony Krowiak { 93245c9b47cSTony Krowiak u32 fcn_code = 0x04000000UL; 93386044c8cSChristian Borntraeger u32 cc = 0; 93445c9b47cSTony Krowiak 93586044c8cSChristian Borntraeger memset(config, 0, 128); 93645c9b47cSTony Krowiak asm volatile( 93745c9b47cSTony Krowiak "lgr 0,%1\n" 93845c9b47cSTony Krowiak "lgr 2,%2\n" 93945c9b47cSTony Krowiak ".long 0xb2af0000\n" /* PQAP(QCI) */ 94086044c8cSChristian Borntraeger "0: ipm %0\n" 94145c9b47cSTony Krowiak "srl %0,28\n" 94286044c8cSChristian Borntraeger "1:\n" 94386044c8cSChristian Borntraeger EX_TABLE(0b, 1b) 94486044c8cSChristian Borntraeger : "+r" (cc) 94545c9b47cSTony Krowiak : "r" (fcn_code), "r" (config) 94645c9b47cSTony Krowiak : "cc", "0", "2", "memory" 94745c9b47cSTony Krowiak ); 94845c9b47cSTony Krowiak 94945c9b47cSTony Krowiak return cc; 95045c9b47cSTony Krowiak } 95145c9b47cSTony Krowiak 95245c9b47cSTony Krowiak static int kvm_s390_apxa_installed(void) 95345c9b47cSTony Krowiak { 95445c9b47cSTony Krowiak u8 config[128]; 95545c9b47cSTony Krowiak int cc; 95645c9b47cSTony Krowiak 95745c9b47cSTony Krowiak if (test_facility(2) && test_facility(12)) { 95845c9b47cSTony Krowiak cc = kvm_s390_query_ap_config(config); 95945c9b47cSTony Krowiak 96045c9b47cSTony Krowiak if (cc) 96145c9b47cSTony Krowiak pr_err("PQAP(QCI) failed with cc=%d", cc); 96245c9b47cSTony Krowiak else 96345c9b47cSTony Krowiak return config[0] & 0x40; 96445c9b47cSTony Krowiak } 96545c9b47cSTony Krowiak 96645c9b47cSTony Krowiak return 0; 96745c9b47cSTony Krowiak } 96845c9b47cSTony Krowiak 96945c9b47cSTony Krowiak static void kvm_s390_set_crycb_format(struct kvm *kvm) 97045c9b47cSTony Krowiak { 97145c9b47cSTony Krowiak kvm->arch.crypto.crycbd = (__u32)(unsigned long) kvm->arch.crypto.crycb; 97245c9b47cSTony Krowiak 97345c9b47cSTony Krowiak if (kvm_s390_apxa_installed()) 97445c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT2; 97545c9b47cSTony Krowiak else 97645c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT1; 97745c9b47cSTony Krowiak } 97845c9b47cSTony Krowiak 9799d8d5786SMichael Mueller static void kvm_s390_get_cpu_id(struct cpuid *cpu_id) 9809d8d5786SMichael Mueller { 9819d8d5786SMichael Mueller get_cpu_id(cpu_id); 9829d8d5786SMichael Mueller cpu_id->version = 0xff; 9839d8d5786SMichael Mueller } 9849d8d5786SMichael Mueller 9855102ee87STony Krowiak static int kvm_s390_crypto_init(struct kvm *kvm) 9865102ee87STony Krowiak { 9879d8d5786SMichael Mueller if (!test_kvm_facility(kvm, 76)) 9885102ee87STony Krowiak return 0; 9895102ee87STony Krowiak 9905102ee87STony Krowiak kvm->arch.crypto.crycb = kzalloc(sizeof(*kvm->arch.crypto.crycb), 9915102ee87STony Krowiak GFP_KERNEL | GFP_DMA); 9925102ee87STony Krowiak if (!kvm->arch.crypto.crycb) 9935102ee87STony Krowiak return -ENOMEM; 9945102ee87STony Krowiak 99545c9b47cSTony Krowiak kvm_s390_set_crycb_format(kvm); 9965102ee87STony Krowiak 997ed6f76b4STony Krowiak /* Enable AES/DEA protected key functions by default */ 998ed6f76b4STony Krowiak kvm->arch.crypto.aes_kw = 1; 999ed6f76b4STony Krowiak kvm->arch.crypto.dea_kw = 1; 1000ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 1001ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 1002ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 1003ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 1004a374e892STony Krowiak 10055102ee87STony Krowiak return 0; 10065102ee87STony Krowiak } 10075102ee87STony Krowiak 1008e08b9637SCarsten Otte int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 1009b0c632dbSHeiko Carstens { 10109d8d5786SMichael Mueller int i, rc; 1011b0c632dbSHeiko Carstens char debug_name[16]; 1012f6c137ffSChristian Borntraeger static unsigned long sca_offset; 1013b0c632dbSHeiko Carstens 1014e08b9637SCarsten Otte rc = -EINVAL; 1015e08b9637SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 1016e08b9637SCarsten Otte if (type & ~KVM_VM_S390_UCONTROL) 1017e08b9637SCarsten Otte goto out_err; 1018e08b9637SCarsten Otte if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN))) 1019e08b9637SCarsten Otte goto out_err; 1020e08b9637SCarsten Otte #else 1021e08b9637SCarsten Otte if (type) 1022e08b9637SCarsten Otte goto out_err; 1023e08b9637SCarsten Otte #endif 1024e08b9637SCarsten Otte 1025b0c632dbSHeiko Carstens rc = s390_enable_sie(); 1026b0c632dbSHeiko Carstens if (rc) 1027d89f5effSJan Kiszka goto out_err; 1028b0c632dbSHeiko Carstens 1029b290411aSCarsten Otte rc = -ENOMEM; 1030b290411aSCarsten Otte 1031b0c632dbSHeiko Carstens kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL); 1032b0c632dbSHeiko Carstens if (!kvm->arch.sca) 1033d89f5effSJan Kiszka goto out_err; 1034f6c137ffSChristian Borntraeger spin_lock(&kvm_lock); 1035f6c137ffSChristian Borntraeger sca_offset = (sca_offset + 16) & 0x7f0; 1036f6c137ffSChristian Borntraeger kvm->arch.sca = (struct sca_block *) ((char *) kvm->arch.sca + sca_offset); 1037f6c137ffSChristian Borntraeger spin_unlock(&kvm_lock); 1038b0c632dbSHeiko Carstens 1039b0c632dbSHeiko Carstens sprintf(debug_name, "kvm-%u", current->pid); 1040b0c632dbSHeiko Carstens 1041b0c632dbSHeiko Carstens kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long)); 1042b0c632dbSHeiko Carstens if (!kvm->arch.dbf) 104340f5b735SDominik Dingel goto out_err; 1044b0c632dbSHeiko Carstens 10459d8d5786SMichael Mueller /* 10469d8d5786SMichael Mueller * The architectural maximum amount of facilities is 16 kbit. To store 10479d8d5786SMichael Mueller * this amount, 2 kbyte of memory is required. Thus we need a full 1048981467c9SMichael Mueller * page to hold the guest facility list (arch.model.fac->list) and the 1049981467c9SMichael Mueller * facility mask (arch.model.fac->mask). Its address size has to be 10509d8d5786SMichael Mueller * 31 bits and word aligned. 10519d8d5786SMichael Mueller */ 10529d8d5786SMichael Mueller kvm->arch.model.fac = 1053981467c9SMichael Mueller (struct kvm_s390_fac *) get_zeroed_page(GFP_KERNEL | GFP_DMA); 10549d8d5786SMichael Mueller if (!kvm->arch.model.fac) 105540f5b735SDominik Dingel goto out_err; 10569d8d5786SMichael Mueller 1057fb5bf93fSMichael Mueller /* Populate the facility mask initially. */ 1058981467c9SMichael Mueller memcpy(kvm->arch.model.fac->mask, S390_lowcore.stfle_fac_list, 105994422ee8SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 10609d8d5786SMichael Mueller for (i = 0; i < S390_ARCH_FAC_LIST_SIZE_U64; i++) { 10619d8d5786SMichael Mueller if (i < kvm_s390_fac_list_mask_size()) 1062981467c9SMichael Mueller kvm->arch.model.fac->mask[i] &= kvm_s390_fac_list_mask[i]; 10639d8d5786SMichael Mueller else 1064981467c9SMichael Mueller kvm->arch.model.fac->mask[i] = 0UL; 10659d8d5786SMichael Mueller } 10669d8d5786SMichael Mueller 1067981467c9SMichael Mueller /* Populate the facility list initially. */ 1068981467c9SMichael Mueller memcpy(kvm->arch.model.fac->list, kvm->arch.model.fac->mask, 1069981467c9SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 1070981467c9SMichael Mueller 10719d8d5786SMichael Mueller kvm_s390_get_cpu_id(&kvm->arch.model.cpu_id); 1072658b6edaSMichael Mueller kvm->arch.model.ibc = sclp_get_ibc() & 0x0fff; 10739d8d5786SMichael Mueller 10745102ee87STony Krowiak if (kvm_s390_crypto_init(kvm) < 0) 107540f5b735SDominik Dingel goto out_err; 10765102ee87STony Krowiak 1077ba5c1e9bSCarsten Otte spin_lock_init(&kvm->arch.float_int.lock); 10786d3da241SJens Freimann for (i = 0; i < FIRQ_LIST_COUNT; i++) 10796d3da241SJens Freimann INIT_LIST_HEAD(&kvm->arch.float_int.lists[i]); 10808a242234SHeiko Carstens init_waitqueue_head(&kvm->arch.ipte_wq); 1081a6b7e459SThomas Huth mutex_init(&kvm->arch.ipte_mutex); 1082ba5c1e9bSCarsten Otte 1083b0c632dbSHeiko Carstens debug_register_view(kvm->arch.dbf, &debug_sprintf_view); 1084b0c632dbSHeiko Carstens VM_EVENT(kvm, 3, "%s", "vm created"); 1085b0c632dbSHeiko Carstens 1086e08b9637SCarsten Otte if (type & KVM_VM_S390_UCONTROL) { 1087e08b9637SCarsten Otte kvm->arch.gmap = NULL; 1088e08b9637SCarsten Otte } else { 10890349985aSChristian Borntraeger kvm->arch.gmap = gmap_alloc(current->mm, (1UL << 44) - 1); 1090598841caSCarsten Otte if (!kvm->arch.gmap) 109140f5b735SDominik Dingel goto out_err; 10922c70fe44SChristian Borntraeger kvm->arch.gmap->private = kvm; 109324eb3a82SDominik Dingel kvm->arch.gmap->pfault_enabled = 0; 1094e08b9637SCarsten Otte } 1095fa6b7fe9SCornelia Huck 1096fa6b7fe9SCornelia Huck kvm->arch.css_support = 0; 109784223598SCornelia Huck kvm->arch.use_irqchip = 0; 109872f25020SJason J. Herne kvm->arch.epoch = 0; 1099fa6b7fe9SCornelia Huck 11008ad35755SDavid Hildenbrand spin_lock_init(&kvm->arch.start_stop_lock); 11018ad35755SDavid Hildenbrand 1102d89f5effSJan Kiszka return 0; 1103d89f5effSJan Kiszka out_err: 110440f5b735SDominik Dingel kfree(kvm->arch.crypto.crycb); 110540f5b735SDominik Dingel free_page((unsigned long)kvm->arch.model.fac); 110640f5b735SDominik Dingel debug_unregister(kvm->arch.dbf); 110740f5b735SDominik Dingel free_page((unsigned long)(kvm->arch.sca)); 1108d89f5effSJan Kiszka return rc; 1109b0c632dbSHeiko Carstens } 1110b0c632dbSHeiko Carstens 1111d329c035SChristian Borntraeger void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 1112d329c035SChristian Borntraeger { 1113d329c035SChristian Borntraeger VCPU_EVENT(vcpu, 3, "%s", "free cpu"); 1114ade38c31SCornelia Huck trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id); 111567335e63SChristian Borntraeger kvm_s390_clear_local_irqs(vcpu); 11163c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 111758f9460bSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 111858f9460bSCarsten Otte clear_bit(63 - vcpu->vcpu_id, 111958f9460bSCarsten Otte (unsigned long *) &vcpu->kvm->arch.sca->mcn); 1120abf4a71eSCarsten Otte if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda == 1121abf4a71eSCarsten Otte (__u64) vcpu->arch.sie_block) 1122abf4a71eSCarsten Otte vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0; 112358f9460bSCarsten Otte } 1124abf4a71eSCarsten Otte smp_mb(); 112527e0393fSCarsten Otte 112627e0393fSCarsten Otte if (kvm_is_ucontrol(vcpu->kvm)) 112727e0393fSCarsten Otte gmap_free(vcpu->arch.gmap); 112827e0393fSCarsten Otte 1129b31605c1SDominik Dingel if (kvm_s390_cmma_enabled(vcpu->kvm)) 1130b31605c1SDominik Dingel kvm_s390_vcpu_unsetup_cmma(vcpu); 1131d329c035SChristian Borntraeger free_page((unsigned long)(vcpu->arch.sie_block)); 1132b31288faSKonstantin Weitz 11336692cef3SChristian Borntraeger kvm_vcpu_uninit(vcpu); 1134b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 1135d329c035SChristian Borntraeger } 1136d329c035SChristian Borntraeger 1137d329c035SChristian Borntraeger static void kvm_free_vcpus(struct kvm *kvm) 1138d329c035SChristian Borntraeger { 1139d329c035SChristian Borntraeger unsigned int i; 1140988a2caeSGleb Natapov struct kvm_vcpu *vcpu; 1141d329c035SChristian Borntraeger 1142988a2caeSGleb Natapov kvm_for_each_vcpu(i, vcpu, kvm) 1143988a2caeSGleb Natapov kvm_arch_vcpu_destroy(vcpu); 1144988a2caeSGleb Natapov 1145988a2caeSGleb Natapov mutex_lock(&kvm->lock); 1146988a2caeSGleb Natapov for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 1147d329c035SChristian Borntraeger kvm->vcpus[i] = NULL; 1148988a2caeSGleb Natapov 1149988a2caeSGleb Natapov atomic_set(&kvm->online_vcpus, 0); 1150988a2caeSGleb Natapov mutex_unlock(&kvm->lock); 1151d329c035SChristian Borntraeger } 1152d329c035SChristian Borntraeger 1153b0c632dbSHeiko Carstens void kvm_arch_destroy_vm(struct kvm *kvm) 1154b0c632dbSHeiko Carstens { 1155d329c035SChristian Borntraeger kvm_free_vcpus(kvm); 11569d8d5786SMichael Mueller free_page((unsigned long)kvm->arch.model.fac); 1157b0c632dbSHeiko Carstens free_page((unsigned long)(kvm->arch.sca)); 1158d329c035SChristian Borntraeger debug_unregister(kvm->arch.dbf); 11595102ee87STony Krowiak kfree(kvm->arch.crypto.crycb); 116027e0393fSCarsten Otte if (!kvm_is_ucontrol(kvm)) 1161598841caSCarsten Otte gmap_free(kvm->arch.gmap); 1162841b91c5SCornelia Huck kvm_s390_destroy_adapters(kvm); 116367335e63SChristian Borntraeger kvm_s390_clear_float_irqs(kvm); 1164b0c632dbSHeiko Carstens } 1165b0c632dbSHeiko Carstens 1166b0c632dbSHeiko Carstens /* Section: vcpu related */ 1167dafd032aSDominik Dingel static int __kvm_ucontrol_vcpu_init(struct kvm_vcpu *vcpu) 1168b0c632dbSHeiko Carstens { 1169c6c956b8SMartin Schwidefsky vcpu->arch.gmap = gmap_alloc(current->mm, -1UL); 117027e0393fSCarsten Otte if (!vcpu->arch.gmap) 117127e0393fSCarsten Otte return -ENOMEM; 11722c70fe44SChristian Borntraeger vcpu->arch.gmap->private = vcpu->kvm; 1173dafd032aSDominik Dingel 117427e0393fSCarsten Otte return 0; 117527e0393fSCarsten Otte } 117627e0393fSCarsten Otte 1177dafd032aSDominik Dingel int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 1178dafd032aSDominik Dingel { 1179dafd032aSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 1180dafd032aSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 118159674c1aSChristian Borntraeger vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX | 118259674c1aSChristian Borntraeger KVM_SYNC_GPRS | 11839eed0735SChristian Borntraeger KVM_SYNC_ACRS | 1184b028ee3eSDavid Hildenbrand KVM_SYNC_CRS | 1185b028ee3eSDavid Hildenbrand KVM_SYNC_ARCH0 | 1186b028ee3eSDavid Hildenbrand KVM_SYNC_PFAULT; 118768c55750SEric Farman if (test_kvm_facility(vcpu->kvm, 129)) 118868c55750SEric Farman vcpu->run->kvm_valid_regs |= KVM_SYNC_VRS; 1189dafd032aSDominik Dingel 1190dafd032aSDominik Dingel if (kvm_is_ucontrol(vcpu->kvm)) 1191dafd032aSDominik Dingel return __kvm_ucontrol_vcpu_init(vcpu); 1192dafd032aSDominik Dingel 1193b0c632dbSHeiko Carstens return 0; 1194b0c632dbSHeiko Carstens } 1195b0c632dbSHeiko Carstens 1196b0c632dbSHeiko Carstens void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 1197b0c632dbSHeiko Carstens { 11984725c860SMartin Schwidefsky save_fp_ctl(&vcpu->arch.host_fpregs.fpc); 119918280d8bSMichael Mueller if (test_kvm_facility(vcpu->kvm, 129)) 120068c55750SEric Farman save_vx_regs((__vector128 *)&vcpu->arch.host_vregs->vrs); 120168c55750SEric Farman else 12024725c860SMartin Schwidefsky save_fp_regs(vcpu->arch.host_fpregs.fprs); 1203b0c632dbSHeiko Carstens save_access_regs(vcpu->arch.host_acrs); 120418280d8bSMichael Mueller if (test_kvm_facility(vcpu->kvm, 129)) { 120568c55750SEric Farman restore_fp_ctl(&vcpu->run->s.regs.fpc); 120668c55750SEric Farman restore_vx_regs((__vector128 *)&vcpu->run->s.regs.vrs); 120768c55750SEric Farman } else { 12084725c860SMartin Schwidefsky restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc); 12094725c860SMartin Schwidefsky restore_fp_regs(vcpu->arch.guest_fpregs.fprs); 121068c55750SEric Farman } 121159674c1aSChristian Borntraeger restore_access_regs(vcpu->run->s.regs.acrs); 1212480e5926SChristian Borntraeger gmap_enable(vcpu->arch.gmap); 12139e6dabefSCornelia Huck atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 1214b0c632dbSHeiko Carstens } 1215b0c632dbSHeiko Carstens 1216b0c632dbSHeiko Carstens void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 1217b0c632dbSHeiko Carstens { 12189e6dabefSCornelia Huck atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 1219480e5926SChristian Borntraeger gmap_disable(vcpu->arch.gmap); 122018280d8bSMichael Mueller if (test_kvm_facility(vcpu->kvm, 129)) { 122168c55750SEric Farman save_fp_ctl(&vcpu->run->s.regs.fpc); 122268c55750SEric Farman save_vx_regs((__vector128 *)&vcpu->run->s.regs.vrs); 122368c55750SEric Farman } else { 12244725c860SMartin Schwidefsky save_fp_ctl(&vcpu->arch.guest_fpregs.fpc); 12254725c860SMartin Schwidefsky save_fp_regs(vcpu->arch.guest_fpregs.fprs); 122668c55750SEric Farman } 122759674c1aSChristian Borntraeger save_access_regs(vcpu->run->s.regs.acrs); 12284725c860SMartin Schwidefsky restore_fp_ctl(&vcpu->arch.host_fpregs.fpc); 122918280d8bSMichael Mueller if (test_kvm_facility(vcpu->kvm, 129)) 123068c55750SEric Farman restore_vx_regs((__vector128 *)&vcpu->arch.host_vregs->vrs); 123168c55750SEric Farman else 12324725c860SMartin Schwidefsky restore_fp_regs(vcpu->arch.host_fpregs.fprs); 1233b0c632dbSHeiko Carstens restore_access_regs(vcpu->arch.host_acrs); 1234b0c632dbSHeiko Carstens } 1235b0c632dbSHeiko Carstens 1236b0c632dbSHeiko Carstens static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu) 1237b0c632dbSHeiko Carstens { 1238b0c632dbSHeiko Carstens /* this equals initial cpu reset in pop, but we don't switch to ESA */ 1239b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.mask = 0UL; 1240b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.addr = 0UL; 12418d26cf7bSChristian Borntraeger kvm_s390_set_prefix(vcpu, 0); 1242b0c632dbSHeiko Carstens vcpu->arch.sie_block->cputm = 0UL; 1243b0c632dbSHeiko Carstens vcpu->arch.sie_block->ckc = 0UL; 1244b0c632dbSHeiko Carstens vcpu->arch.sie_block->todpr = 0; 1245b0c632dbSHeiko Carstens memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64)); 1246b0c632dbSHeiko Carstens vcpu->arch.sie_block->gcr[0] = 0xE0UL; 1247b0c632dbSHeiko Carstens vcpu->arch.sie_block->gcr[14] = 0xC2000000UL; 1248b0c632dbSHeiko Carstens vcpu->arch.guest_fpregs.fpc = 0; 1249b0c632dbSHeiko Carstens asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc)); 1250b0c632dbSHeiko Carstens vcpu->arch.sie_block->gbea = 1; 1251672550fbSChristian Borntraeger vcpu->arch.sie_block->pp = 0; 12523c038e6bSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 12533c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 12546352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) 12556852d7b6SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 12562ed10cc1SJens Freimann kvm_s390_clear_local_irqs(vcpu); 1257b0c632dbSHeiko Carstens } 1258b0c632dbSHeiko Carstens 125931928aa5SDominik Dingel void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu) 126042897d86SMarcelo Tosatti { 126172f25020SJason J. Herne mutex_lock(&vcpu->kvm->lock); 126272f25020SJason J. Herne vcpu->arch.sie_block->epoch = vcpu->kvm->arch.epoch; 126372f25020SJason J. Herne mutex_unlock(&vcpu->kvm->lock); 1264dafd032aSDominik Dingel if (!kvm_is_ucontrol(vcpu->kvm)) 1265dafd032aSDominik Dingel vcpu->arch.gmap = vcpu->kvm->arch.gmap; 126642897d86SMarcelo Tosatti } 126742897d86SMarcelo Tosatti 12685102ee87STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu) 12695102ee87STony Krowiak { 12709d8d5786SMichael Mueller if (!test_kvm_facility(vcpu->kvm, 76)) 12715102ee87STony Krowiak return; 12725102ee87STony Krowiak 1273a374e892STony Krowiak vcpu->arch.sie_block->ecb3 &= ~(ECB3_AES | ECB3_DEA); 1274a374e892STony Krowiak 1275a374e892STony Krowiak if (vcpu->kvm->arch.crypto.aes_kw) 1276a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_AES; 1277a374e892STony Krowiak if (vcpu->kvm->arch.crypto.dea_kw) 1278a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_DEA; 1279a374e892STony Krowiak 12805102ee87STony Krowiak vcpu->arch.sie_block->crycbd = vcpu->kvm->arch.crypto.crycbd; 12815102ee87STony Krowiak } 12825102ee87STony Krowiak 1283b31605c1SDominik Dingel void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu) 1284b31605c1SDominik Dingel { 1285b31605c1SDominik Dingel free_page(vcpu->arch.sie_block->cbrlo); 1286b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = 0; 1287b31605c1SDominik Dingel } 1288b31605c1SDominik Dingel 1289b31605c1SDominik Dingel int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu) 1290b31605c1SDominik Dingel { 1291b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = get_zeroed_page(GFP_KERNEL); 1292b31605c1SDominik Dingel if (!vcpu->arch.sie_block->cbrlo) 1293b31605c1SDominik Dingel return -ENOMEM; 1294b31605c1SDominik Dingel 1295b31605c1SDominik Dingel vcpu->arch.sie_block->ecb2 |= 0x80; 1296b31605c1SDominik Dingel vcpu->arch.sie_block->ecb2 &= ~0x08; 1297b31605c1SDominik Dingel return 0; 1298b31605c1SDominik Dingel } 1299b31605c1SDominik Dingel 130091520f1aSMichael Mueller static void kvm_s390_vcpu_setup_model(struct kvm_vcpu *vcpu) 130191520f1aSMichael Mueller { 130291520f1aSMichael Mueller struct kvm_s390_cpu_model *model = &vcpu->kvm->arch.model; 130391520f1aSMichael Mueller 130491520f1aSMichael Mueller vcpu->arch.cpu_id = model->cpu_id; 130591520f1aSMichael Mueller vcpu->arch.sie_block->ibc = model->ibc; 130691520f1aSMichael Mueller vcpu->arch.sie_block->fac = (int) (long) model->fac->list; 130791520f1aSMichael Mueller } 130891520f1aSMichael Mueller 1309b0c632dbSHeiko Carstens int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) 1310b0c632dbSHeiko Carstens { 1311b31605c1SDominik Dingel int rc = 0; 1312b31288faSKonstantin Weitz 13139e6dabefSCornelia Huck atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH | 13149e6dabefSCornelia Huck CPUSTAT_SM | 131569d0d3a3SChristian Borntraeger CPUSTAT_STOPPED | 131669d0d3a3SChristian Borntraeger CPUSTAT_GED); 131791520f1aSMichael Mueller kvm_s390_vcpu_setup_model(vcpu); 131891520f1aSMichael Mueller 1319fc34531dSChristian Borntraeger vcpu->arch.sie_block->ecb = 6; 13209d8d5786SMichael Mueller if (test_kvm_facility(vcpu->kvm, 50) && test_kvm_facility(vcpu->kvm, 73)) 13217feb6bb8SMichael Mueller vcpu->arch.sie_block->ecb |= 0x10; 13227feb6bb8SMichael Mueller 132369d0d3a3SChristian Borntraeger vcpu->arch.sie_block->ecb2 = 8; 1324ea5f4969SDavid Hildenbrand vcpu->arch.sie_block->eca = 0xC1002000U; 1325217a4406SHeiko Carstens if (sclp_has_siif()) 1326217a4406SHeiko Carstens vcpu->arch.sie_block->eca |= 1; 1327ea5f4969SDavid Hildenbrand if (sclp_has_sigpif()) 1328ea5f4969SDavid Hildenbrand vcpu->arch.sie_block->eca |= 0x10000000U; 132918280d8bSMichael Mueller if (test_kvm_facility(vcpu->kvm, 129)) { 133013211ea7SEric Farman vcpu->arch.sie_block->eca |= 0x00020000; 133113211ea7SEric Farman vcpu->arch.sie_block->ecd |= 0x20000000; 133213211ea7SEric Farman } 1333492d8642SThomas Huth vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE; 13345a5e6536SMatthew Rosato 1335b31605c1SDominik Dingel if (kvm_s390_cmma_enabled(vcpu->kvm)) { 1336b31605c1SDominik Dingel rc = kvm_s390_vcpu_setup_cmma(vcpu); 1337b31605c1SDominik Dingel if (rc) 1338b31605c1SDominik Dingel return rc; 1339b31288faSKonstantin Weitz } 13400ac96cafSDavid Hildenbrand hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 1341ca872302SChristian Borntraeger vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup; 13429d8d5786SMichael Mueller 13435102ee87STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 13445102ee87STony Krowiak 1345b31605c1SDominik Dingel return rc; 1346b0c632dbSHeiko Carstens } 1347b0c632dbSHeiko Carstens 1348b0c632dbSHeiko Carstens struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, 1349b0c632dbSHeiko Carstens unsigned int id) 1350b0c632dbSHeiko Carstens { 13514d47555aSCarsten Otte struct kvm_vcpu *vcpu; 13527feb6bb8SMichael Mueller struct sie_page *sie_page; 13534d47555aSCarsten Otte int rc = -EINVAL; 1354b0c632dbSHeiko Carstens 13554d47555aSCarsten Otte if (id >= KVM_MAX_VCPUS) 13564d47555aSCarsten Otte goto out; 13574d47555aSCarsten Otte 13584d47555aSCarsten Otte rc = -ENOMEM; 13594d47555aSCarsten Otte 1360b110feafSMichael Mueller vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL); 1361b0c632dbSHeiko Carstens if (!vcpu) 13624d47555aSCarsten Otte goto out; 1363b0c632dbSHeiko Carstens 13647feb6bb8SMichael Mueller sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL); 13657feb6bb8SMichael Mueller if (!sie_page) 1366b0c632dbSHeiko Carstens goto out_free_cpu; 1367b0c632dbSHeiko Carstens 13687feb6bb8SMichael Mueller vcpu->arch.sie_block = &sie_page->sie_block; 13697feb6bb8SMichael Mueller vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb; 137068c55750SEric Farman vcpu->arch.host_vregs = &sie_page->vregs; 13717feb6bb8SMichael Mueller 1372b0c632dbSHeiko Carstens vcpu->arch.sie_block->icpua = id; 137358f9460bSCarsten Otte if (!kvm_is_ucontrol(kvm)) { 137458f9460bSCarsten Otte if (!kvm->arch.sca) { 137558f9460bSCarsten Otte WARN_ON_ONCE(1); 137658f9460bSCarsten Otte goto out_free_cpu; 137758f9460bSCarsten Otte } 1378abf4a71eSCarsten Otte if (!kvm->arch.sca->cpu[id].sda) 137958f9460bSCarsten Otte kvm->arch.sca->cpu[id].sda = 138058f9460bSCarsten Otte (__u64) vcpu->arch.sie_block; 138158f9460bSCarsten Otte vcpu->arch.sie_block->scaoh = 138258f9460bSCarsten Otte (__u32)(((__u64)kvm->arch.sca) >> 32); 1383b0c632dbSHeiko Carstens vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca; 1384fc34531dSChristian Borntraeger set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn); 138558f9460bSCarsten Otte } 1386b0c632dbSHeiko Carstens 1387ba5c1e9bSCarsten Otte spin_lock_init(&vcpu->arch.local_int.lock); 1388ba5c1e9bSCarsten Otte vcpu->arch.local_int.float_int = &kvm->arch.float_int; 1389d0321a24SChristian Borntraeger vcpu->arch.local_int.wq = &vcpu->wq; 13905288fbf0SChristian Borntraeger vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags; 1391ba5c1e9bSCarsten Otte 1392b0c632dbSHeiko Carstens rc = kvm_vcpu_init(vcpu, kvm, id); 1393b0c632dbSHeiko Carstens if (rc) 13947b06bf2fSWei Yongjun goto out_free_sie_block; 1395b0c632dbSHeiko Carstens VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu, 1396b0c632dbSHeiko Carstens vcpu->arch.sie_block); 1397ade38c31SCornelia Huck trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block); 1398b0c632dbSHeiko Carstens 1399b0c632dbSHeiko Carstens return vcpu; 14007b06bf2fSWei Yongjun out_free_sie_block: 14017b06bf2fSWei Yongjun free_page((unsigned long)(vcpu->arch.sie_block)); 1402b0c632dbSHeiko Carstens out_free_cpu: 1403b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 14044d47555aSCarsten Otte out: 1405b0c632dbSHeiko Carstens return ERR_PTR(rc); 1406b0c632dbSHeiko Carstens } 1407b0c632dbSHeiko Carstens 1408b0c632dbSHeiko Carstens int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu) 1409b0c632dbSHeiko Carstens { 14109a022067SDavid Hildenbrand return kvm_s390_vcpu_has_irq(vcpu, 0); 1411b0c632dbSHeiko Carstens } 1412b0c632dbSHeiko Carstens 141349b99e1eSChristian Borntraeger void s390_vcpu_block(struct kvm_vcpu *vcpu) 141449b99e1eSChristian Borntraeger { 141549b99e1eSChristian Borntraeger atomic_set_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 141649b99e1eSChristian Borntraeger } 141749b99e1eSChristian Borntraeger 141849b99e1eSChristian Borntraeger void s390_vcpu_unblock(struct kvm_vcpu *vcpu) 141949b99e1eSChristian Borntraeger { 142049b99e1eSChristian Borntraeger atomic_clear_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 142149b99e1eSChristian Borntraeger } 142249b99e1eSChristian Borntraeger 142349b99e1eSChristian Borntraeger /* 142449b99e1eSChristian Borntraeger * Kick a guest cpu out of SIE and wait until SIE is not running. 142549b99e1eSChristian Borntraeger * If the CPU is not running (e.g. waiting as idle) the function will 142649b99e1eSChristian Borntraeger * return immediately. */ 142749b99e1eSChristian Borntraeger void exit_sie(struct kvm_vcpu *vcpu) 142849b99e1eSChristian Borntraeger { 142949b99e1eSChristian Borntraeger atomic_set_mask(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags); 143049b99e1eSChristian Borntraeger while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE) 143149b99e1eSChristian Borntraeger cpu_relax(); 143249b99e1eSChristian Borntraeger } 143349b99e1eSChristian Borntraeger 143449b99e1eSChristian Borntraeger /* Kick a guest cpu out of SIE and prevent SIE-reentry */ 143549b99e1eSChristian Borntraeger void exit_sie_sync(struct kvm_vcpu *vcpu) 143649b99e1eSChristian Borntraeger { 143749b99e1eSChristian Borntraeger s390_vcpu_block(vcpu); 143849b99e1eSChristian Borntraeger exit_sie(vcpu); 143949b99e1eSChristian Borntraeger } 144049b99e1eSChristian Borntraeger 14412c70fe44SChristian Borntraeger static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address) 14422c70fe44SChristian Borntraeger { 14432c70fe44SChristian Borntraeger int i; 14442c70fe44SChristian Borntraeger struct kvm *kvm = gmap->private; 14452c70fe44SChristian Borntraeger struct kvm_vcpu *vcpu; 14462c70fe44SChristian Borntraeger 14472c70fe44SChristian Borntraeger kvm_for_each_vcpu(i, vcpu, kvm) { 14482c70fe44SChristian Borntraeger /* match against both prefix pages */ 1449fda902cbSMichael Mueller if (kvm_s390_get_prefix(vcpu) == (address & ~0x1000UL)) { 14502c70fe44SChristian Borntraeger VCPU_EVENT(vcpu, 2, "gmap notifier for %lx", address); 14512c70fe44SChristian Borntraeger kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu); 14522c70fe44SChristian Borntraeger exit_sie_sync(vcpu); 14532c70fe44SChristian Borntraeger } 14542c70fe44SChristian Borntraeger } 14552c70fe44SChristian Borntraeger } 14562c70fe44SChristian Borntraeger 1457b6d33834SChristoffer Dall int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu) 1458b6d33834SChristoffer Dall { 1459b6d33834SChristoffer Dall /* kvm common code refers to this, but never calls it */ 1460b6d33834SChristoffer Dall BUG(); 1461b6d33834SChristoffer Dall return 0; 1462b6d33834SChristoffer Dall } 1463b6d33834SChristoffer Dall 146414eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, 146514eebd91SCarsten Otte struct kvm_one_reg *reg) 146614eebd91SCarsten Otte { 146714eebd91SCarsten Otte int r = -EINVAL; 146814eebd91SCarsten Otte 146914eebd91SCarsten Otte switch (reg->id) { 147029b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 147129b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->todpr, 147229b7c71bSCarsten Otte (u32 __user *)reg->addr); 147329b7c71bSCarsten Otte break; 147429b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 147529b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->epoch, 147629b7c71bSCarsten Otte (u64 __user *)reg->addr); 147729b7c71bSCarsten Otte break; 147846a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 147946a6dd1cSJason J. herne r = put_user(vcpu->arch.sie_block->cputm, 148046a6dd1cSJason J. herne (u64 __user *)reg->addr); 148146a6dd1cSJason J. herne break; 148246a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 148346a6dd1cSJason J. herne r = put_user(vcpu->arch.sie_block->ckc, 148446a6dd1cSJason J. herne (u64 __user *)reg->addr); 148546a6dd1cSJason J. herne break; 1486536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 1487536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_token, 1488536336c2SDominik Dingel (u64 __user *)reg->addr); 1489536336c2SDominik Dingel break; 1490536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 1491536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_compare, 1492536336c2SDominik Dingel (u64 __user *)reg->addr); 1493536336c2SDominik Dingel break; 1494536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 1495536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_select, 1496536336c2SDominik Dingel (u64 __user *)reg->addr); 1497536336c2SDominik Dingel break; 1498672550fbSChristian Borntraeger case KVM_REG_S390_PP: 1499672550fbSChristian Borntraeger r = put_user(vcpu->arch.sie_block->pp, 1500672550fbSChristian Borntraeger (u64 __user *)reg->addr); 1501672550fbSChristian Borntraeger break; 1502afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 1503afa45ff5SChristian Borntraeger r = put_user(vcpu->arch.sie_block->gbea, 1504afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 1505afa45ff5SChristian Borntraeger break; 150614eebd91SCarsten Otte default: 150714eebd91SCarsten Otte break; 150814eebd91SCarsten Otte } 150914eebd91SCarsten Otte 151014eebd91SCarsten Otte return r; 151114eebd91SCarsten Otte } 151214eebd91SCarsten Otte 151314eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, 151414eebd91SCarsten Otte struct kvm_one_reg *reg) 151514eebd91SCarsten Otte { 151614eebd91SCarsten Otte int r = -EINVAL; 151714eebd91SCarsten Otte 151814eebd91SCarsten Otte switch (reg->id) { 151929b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 152029b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->todpr, 152129b7c71bSCarsten Otte (u32 __user *)reg->addr); 152229b7c71bSCarsten Otte break; 152329b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 152429b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->epoch, 152529b7c71bSCarsten Otte (u64 __user *)reg->addr); 152629b7c71bSCarsten Otte break; 152746a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 152846a6dd1cSJason J. herne r = get_user(vcpu->arch.sie_block->cputm, 152946a6dd1cSJason J. herne (u64 __user *)reg->addr); 153046a6dd1cSJason J. herne break; 153146a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 153246a6dd1cSJason J. herne r = get_user(vcpu->arch.sie_block->ckc, 153346a6dd1cSJason J. herne (u64 __user *)reg->addr); 153446a6dd1cSJason J. herne break; 1535536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 1536536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_token, 1537536336c2SDominik Dingel (u64 __user *)reg->addr); 15389fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 15399fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 1540536336c2SDominik Dingel break; 1541536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 1542536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_compare, 1543536336c2SDominik Dingel (u64 __user *)reg->addr); 1544536336c2SDominik Dingel break; 1545536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 1546536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_select, 1547536336c2SDominik Dingel (u64 __user *)reg->addr); 1548536336c2SDominik Dingel break; 1549672550fbSChristian Borntraeger case KVM_REG_S390_PP: 1550672550fbSChristian Borntraeger r = get_user(vcpu->arch.sie_block->pp, 1551672550fbSChristian Borntraeger (u64 __user *)reg->addr); 1552672550fbSChristian Borntraeger break; 1553afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 1554afa45ff5SChristian Borntraeger r = get_user(vcpu->arch.sie_block->gbea, 1555afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 1556afa45ff5SChristian Borntraeger break; 155714eebd91SCarsten Otte default: 155814eebd91SCarsten Otte break; 155914eebd91SCarsten Otte } 156014eebd91SCarsten Otte 156114eebd91SCarsten Otte return r; 156214eebd91SCarsten Otte } 1563b6d33834SChristoffer Dall 1564b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) 1565b0c632dbSHeiko Carstens { 1566b0c632dbSHeiko Carstens kvm_s390_vcpu_initial_reset(vcpu); 1567b0c632dbSHeiko Carstens return 0; 1568b0c632dbSHeiko Carstens } 1569b0c632dbSHeiko Carstens 1570b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 1571b0c632dbSHeiko Carstens { 15725a32c1afSChristian Borntraeger memcpy(&vcpu->run->s.regs.gprs, ®s->gprs, sizeof(regs->gprs)); 1573b0c632dbSHeiko Carstens return 0; 1574b0c632dbSHeiko Carstens } 1575b0c632dbSHeiko Carstens 1576b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 1577b0c632dbSHeiko Carstens { 15785a32c1afSChristian Borntraeger memcpy(®s->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs)); 1579b0c632dbSHeiko Carstens return 0; 1580b0c632dbSHeiko Carstens } 1581b0c632dbSHeiko Carstens 1582b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, 1583b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 1584b0c632dbSHeiko Carstens { 158559674c1aSChristian Borntraeger memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs)); 1586b0c632dbSHeiko Carstens memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs)); 158759674c1aSChristian Borntraeger restore_access_regs(vcpu->run->s.regs.acrs); 1588b0c632dbSHeiko Carstens return 0; 1589b0c632dbSHeiko Carstens } 1590b0c632dbSHeiko Carstens 1591b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, 1592b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 1593b0c632dbSHeiko Carstens { 159459674c1aSChristian Borntraeger memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs)); 1595b0c632dbSHeiko Carstens memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs)); 1596b0c632dbSHeiko Carstens return 0; 1597b0c632dbSHeiko Carstens } 1598b0c632dbSHeiko Carstens 1599b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 1600b0c632dbSHeiko Carstens { 16014725c860SMartin Schwidefsky if (test_fp_ctl(fpu->fpc)) 16024725c860SMartin Schwidefsky return -EINVAL; 1603b0c632dbSHeiko Carstens memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs)); 16044725c860SMartin Schwidefsky vcpu->arch.guest_fpregs.fpc = fpu->fpc; 16054725c860SMartin Schwidefsky restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc); 16064725c860SMartin Schwidefsky restore_fp_regs(vcpu->arch.guest_fpregs.fprs); 1607b0c632dbSHeiko Carstens return 0; 1608b0c632dbSHeiko Carstens } 1609b0c632dbSHeiko Carstens 1610b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 1611b0c632dbSHeiko Carstens { 1612b0c632dbSHeiko Carstens memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs)); 1613b0c632dbSHeiko Carstens fpu->fpc = vcpu->arch.guest_fpregs.fpc; 1614b0c632dbSHeiko Carstens return 0; 1615b0c632dbSHeiko Carstens } 1616b0c632dbSHeiko Carstens 1617b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw) 1618b0c632dbSHeiko Carstens { 1619b0c632dbSHeiko Carstens int rc = 0; 1620b0c632dbSHeiko Carstens 16217a42fdc2SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 1622b0c632dbSHeiko Carstens rc = -EBUSY; 1623d7b0b5ebSCarsten Otte else { 1624d7b0b5ebSCarsten Otte vcpu->run->psw_mask = psw.mask; 1625d7b0b5ebSCarsten Otte vcpu->run->psw_addr = psw.addr; 1626d7b0b5ebSCarsten Otte } 1627b0c632dbSHeiko Carstens return rc; 1628b0c632dbSHeiko Carstens } 1629b0c632dbSHeiko Carstens 1630b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, 1631b0c632dbSHeiko Carstens struct kvm_translation *tr) 1632b0c632dbSHeiko Carstens { 1633b0c632dbSHeiko Carstens return -EINVAL; /* not implemented yet */ 1634b0c632dbSHeiko Carstens } 1635b0c632dbSHeiko Carstens 163627291e21SDavid Hildenbrand #define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \ 163727291e21SDavid Hildenbrand KVM_GUESTDBG_USE_HW_BP | \ 163827291e21SDavid Hildenbrand KVM_GUESTDBG_ENABLE) 163927291e21SDavid Hildenbrand 1640d0bfb940SJan Kiszka int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 1641d0bfb940SJan Kiszka struct kvm_guest_debug *dbg) 1642b0c632dbSHeiko Carstens { 164327291e21SDavid Hildenbrand int rc = 0; 164427291e21SDavid Hildenbrand 164527291e21SDavid Hildenbrand vcpu->guest_debug = 0; 164627291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 164727291e21SDavid Hildenbrand 16482de3bfc2SDavid Hildenbrand if (dbg->control & ~VALID_GUESTDBG_FLAGS) 164927291e21SDavid Hildenbrand return -EINVAL; 165027291e21SDavid Hildenbrand 165127291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_ENABLE) { 165227291e21SDavid Hildenbrand vcpu->guest_debug = dbg->control; 165327291e21SDavid Hildenbrand /* enforce guest PER */ 165427291e21SDavid Hildenbrand atomic_set_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags); 165527291e21SDavid Hildenbrand 165627291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_USE_HW_BP) 165727291e21SDavid Hildenbrand rc = kvm_s390_import_bp_data(vcpu, dbg); 165827291e21SDavid Hildenbrand } else { 165927291e21SDavid Hildenbrand atomic_clear_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags); 166027291e21SDavid Hildenbrand vcpu->arch.guestdbg.last_bp = 0; 166127291e21SDavid Hildenbrand } 166227291e21SDavid Hildenbrand 166327291e21SDavid Hildenbrand if (rc) { 166427291e21SDavid Hildenbrand vcpu->guest_debug = 0; 166527291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 166627291e21SDavid Hildenbrand atomic_clear_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags); 166727291e21SDavid Hildenbrand } 166827291e21SDavid Hildenbrand 166927291e21SDavid Hildenbrand return rc; 1670b0c632dbSHeiko Carstens } 1671b0c632dbSHeiko Carstens 167262d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 167362d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 167462d9f0dbSMarcelo Tosatti { 16756352e4d2SDavid Hildenbrand /* CHECK_STOP and LOAD are not supported yet */ 16766352e4d2SDavid Hildenbrand return is_vcpu_stopped(vcpu) ? KVM_MP_STATE_STOPPED : 16776352e4d2SDavid Hildenbrand KVM_MP_STATE_OPERATING; 167862d9f0dbSMarcelo Tosatti } 167962d9f0dbSMarcelo Tosatti 168062d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 168162d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 168262d9f0dbSMarcelo Tosatti { 16836352e4d2SDavid Hildenbrand int rc = 0; 16846352e4d2SDavid Hildenbrand 16856352e4d2SDavid Hildenbrand /* user space knows about this interface - let it control the state */ 16866352e4d2SDavid Hildenbrand vcpu->kvm->arch.user_cpu_state_ctrl = 1; 16876352e4d2SDavid Hildenbrand 16886352e4d2SDavid Hildenbrand switch (mp_state->mp_state) { 16896352e4d2SDavid Hildenbrand case KVM_MP_STATE_STOPPED: 16906352e4d2SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 16916352e4d2SDavid Hildenbrand break; 16926352e4d2SDavid Hildenbrand case KVM_MP_STATE_OPERATING: 16936352e4d2SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 16946352e4d2SDavid Hildenbrand break; 16956352e4d2SDavid Hildenbrand case KVM_MP_STATE_LOAD: 16966352e4d2SDavid Hildenbrand case KVM_MP_STATE_CHECK_STOP: 16976352e4d2SDavid Hildenbrand /* fall through - CHECK_STOP and LOAD are not supported yet */ 16986352e4d2SDavid Hildenbrand default: 16996352e4d2SDavid Hildenbrand rc = -ENXIO; 17006352e4d2SDavid Hildenbrand } 17016352e4d2SDavid Hildenbrand 17026352e4d2SDavid Hildenbrand return rc; 170362d9f0dbSMarcelo Tosatti } 170462d9f0dbSMarcelo Tosatti 1705b31605c1SDominik Dingel bool kvm_s390_cmma_enabled(struct kvm *kvm) 1706b31605c1SDominik Dingel { 1707b31605c1SDominik Dingel if (!MACHINE_IS_LPAR) 1708b31605c1SDominik Dingel return false; 1709b31605c1SDominik Dingel /* only enable for z10 and later */ 1710b31605c1SDominik Dingel if (!MACHINE_HAS_EDAT1) 1711b31605c1SDominik Dingel return false; 1712b31605c1SDominik Dingel if (!kvm->arch.use_cmma) 1713b31605c1SDominik Dingel return false; 1714b31605c1SDominik Dingel return true; 1715b31605c1SDominik Dingel } 1716b31605c1SDominik Dingel 17178ad35755SDavid Hildenbrand static bool ibs_enabled(struct kvm_vcpu *vcpu) 17188ad35755SDavid Hildenbrand { 17198ad35755SDavid Hildenbrand return atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_IBS; 17208ad35755SDavid Hildenbrand } 17218ad35755SDavid Hildenbrand 17222c70fe44SChristian Borntraeger static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu) 17232c70fe44SChristian Borntraeger { 17248ad35755SDavid Hildenbrand retry: 17258ad35755SDavid Hildenbrand s390_vcpu_unblock(vcpu); 17262c70fe44SChristian Borntraeger /* 17272c70fe44SChristian Borntraeger * We use MMU_RELOAD just to re-arm the ipte notifier for the 17282c70fe44SChristian Borntraeger * guest prefix page. gmap_ipte_notify will wait on the ptl lock. 17292c70fe44SChristian Borntraeger * This ensures that the ipte instruction for this request has 17302c70fe44SChristian Borntraeger * already finished. We might race against a second unmapper that 17312c70fe44SChristian Borntraeger * wants to set the blocking bit. Lets just retry the request loop. 17322c70fe44SChristian Borntraeger */ 17338ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) { 17342c70fe44SChristian Borntraeger int rc; 17352c70fe44SChristian Borntraeger rc = gmap_ipte_notify(vcpu->arch.gmap, 1736fda902cbSMichael Mueller kvm_s390_get_prefix(vcpu), 17372c70fe44SChristian Borntraeger PAGE_SIZE * 2); 17382c70fe44SChristian Borntraeger if (rc) 17392c70fe44SChristian Borntraeger return rc; 17408ad35755SDavid Hildenbrand goto retry; 17412c70fe44SChristian Borntraeger } 17428ad35755SDavid Hildenbrand 1743d3d692c8SDavid Hildenbrand if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu)) { 1744d3d692c8SDavid Hildenbrand vcpu->arch.sie_block->ihcpu = 0xffff; 1745d3d692c8SDavid Hildenbrand goto retry; 1746d3d692c8SDavid Hildenbrand } 1747d3d692c8SDavid Hildenbrand 17488ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu)) { 17498ad35755SDavid Hildenbrand if (!ibs_enabled(vcpu)) { 17508ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 1); 17518ad35755SDavid Hildenbrand atomic_set_mask(CPUSTAT_IBS, 17528ad35755SDavid Hildenbrand &vcpu->arch.sie_block->cpuflags); 17538ad35755SDavid Hildenbrand } 17548ad35755SDavid Hildenbrand goto retry; 17558ad35755SDavid Hildenbrand } 17568ad35755SDavid Hildenbrand 17578ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu)) { 17588ad35755SDavid Hildenbrand if (ibs_enabled(vcpu)) { 17598ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 0); 17608ad35755SDavid Hildenbrand atomic_clear_mask(CPUSTAT_IBS, 17618ad35755SDavid Hildenbrand &vcpu->arch.sie_block->cpuflags); 17628ad35755SDavid Hildenbrand } 17638ad35755SDavid Hildenbrand goto retry; 17648ad35755SDavid Hildenbrand } 17658ad35755SDavid Hildenbrand 17660759d068SDavid Hildenbrand /* nothing to do, just clear the request */ 17670759d068SDavid Hildenbrand clear_bit(KVM_REQ_UNHALT, &vcpu->requests); 17680759d068SDavid Hildenbrand 17692c70fe44SChristian Borntraeger return 0; 17702c70fe44SChristian Borntraeger } 17712c70fe44SChristian Borntraeger 1772fa576c58SThomas Huth /** 1773fa576c58SThomas Huth * kvm_arch_fault_in_page - fault-in guest page if necessary 1774fa576c58SThomas Huth * @vcpu: The corresponding virtual cpu 1775fa576c58SThomas Huth * @gpa: Guest physical address 1776fa576c58SThomas Huth * @writable: Whether the page should be writable or not 1777fa576c58SThomas Huth * 1778fa576c58SThomas Huth * Make sure that a guest page has been faulted-in on the host. 1779fa576c58SThomas Huth * 1780fa576c58SThomas Huth * Return: Zero on success, negative error code otherwise. 1781fa576c58SThomas Huth */ 1782fa576c58SThomas Huth long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable) 178324eb3a82SDominik Dingel { 1784527e30b4SMartin Schwidefsky return gmap_fault(vcpu->arch.gmap, gpa, 1785527e30b4SMartin Schwidefsky writable ? FAULT_FLAG_WRITE : 0); 178624eb3a82SDominik Dingel } 178724eb3a82SDominik Dingel 17883c038e6bSDominik Dingel static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token, 17893c038e6bSDominik Dingel unsigned long token) 17903c038e6bSDominik Dingel { 17913c038e6bSDominik Dingel struct kvm_s390_interrupt inti; 1792383d0b05SJens Freimann struct kvm_s390_irq irq; 17933c038e6bSDominik Dingel 17943c038e6bSDominik Dingel if (start_token) { 1795383d0b05SJens Freimann irq.u.ext.ext_params2 = token; 1796383d0b05SJens Freimann irq.type = KVM_S390_INT_PFAULT_INIT; 1797383d0b05SJens Freimann WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &irq)); 17983c038e6bSDominik Dingel } else { 17993c038e6bSDominik Dingel inti.type = KVM_S390_INT_PFAULT_DONE; 1800383d0b05SJens Freimann inti.parm64 = token; 18013c038e6bSDominik Dingel WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti)); 18023c038e6bSDominik Dingel } 18033c038e6bSDominik Dingel } 18043c038e6bSDominik Dingel 18053c038e6bSDominik Dingel void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu, 18063c038e6bSDominik Dingel struct kvm_async_pf *work) 18073c038e6bSDominik Dingel { 18083c038e6bSDominik Dingel trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token); 18093c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token); 18103c038e6bSDominik Dingel } 18113c038e6bSDominik Dingel 18123c038e6bSDominik Dingel void kvm_arch_async_page_present(struct kvm_vcpu *vcpu, 18133c038e6bSDominik Dingel struct kvm_async_pf *work) 18143c038e6bSDominik Dingel { 18153c038e6bSDominik Dingel trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token); 18163c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token); 18173c038e6bSDominik Dingel } 18183c038e6bSDominik Dingel 18193c038e6bSDominik Dingel void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu, 18203c038e6bSDominik Dingel struct kvm_async_pf *work) 18213c038e6bSDominik Dingel { 18223c038e6bSDominik Dingel /* s390 will always inject the page directly */ 18233c038e6bSDominik Dingel } 18243c038e6bSDominik Dingel 18253c038e6bSDominik Dingel bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu) 18263c038e6bSDominik Dingel { 18273c038e6bSDominik Dingel /* 18283c038e6bSDominik Dingel * s390 will always inject the page directly, 18293c038e6bSDominik Dingel * but we still want check_async_completion to cleanup 18303c038e6bSDominik Dingel */ 18313c038e6bSDominik Dingel return true; 18323c038e6bSDominik Dingel } 18333c038e6bSDominik Dingel 18343c038e6bSDominik Dingel static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu) 18353c038e6bSDominik Dingel { 18363c038e6bSDominik Dingel hva_t hva; 18373c038e6bSDominik Dingel struct kvm_arch_async_pf arch; 18383c038e6bSDominik Dingel int rc; 18393c038e6bSDominik Dingel 18403c038e6bSDominik Dingel if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 18413c038e6bSDominik Dingel return 0; 18423c038e6bSDominik Dingel if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) != 18433c038e6bSDominik Dingel vcpu->arch.pfault_compare) 18443c038e6bSDominik Dingel return 0; 18453c038e6bSDominik Dingel if (psw_extint_disabled(vcpu)) 18463c038e6bSDominik Dingel return 0; 18479a022067SDavid Hildenbrand if (kvm_s390_vcpu_has_irq(vcpu, 0)) 18483c038e6bSDominik Dingel return 0; 18493c038e6bSDominik Dingel if (!(vcpu->arch.sie_block->gcr[0] & 0x200ul)) 18503c038e6bSDominik Dingel return 0; 18513c038e6bSDominik Dingel if (!vcpu->arch.gmap->pfault_enabled) 18523c038e6bSDominik Dingel return 0; 18533c038e6bSDominik Dingel 185481480cc1SHeiko Carstens hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(current->thread.gmap_addr)); 185581480cc1SHeiko Carstens hva += current->thread.gmap_addr & ~PAGE_MASK; 185681480cc1SHeiko Carstens if (read_guest_real(vcpu, vcpu->arch.pfault_token, &arch.pfault_token, 8)) 18573c038e6bSDominik Dingel return 0; 18583c038e6bSDominik Dingel 18593c038e6bSDominik Dingel rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch); 18603c038e6bSDominik Dingel return rc; 18613c038e6bSDominik Dingel } 18623c038e6bSDominik Dingel 18633fb4c40fSThomas Huth static int vcpu_pre_run(struct kvm_vcpu *vcpu) 1864b0c632dbSHeiko Carstens { 18653fb4c40fSThomas Huth int rc, cpuflags; 1866e168bf8dSCarsten Otte 18673c038e6bSDominik Dingel /* 18683c038e6bSDominik Dingel * On s390 notifications for arriving pages will be delivered directly 18693c038e6bSDominik Dingel * to the guest but the house keeping for completed pfaults is 18703c038e6bSDominik Dingel * handled outside the worker. 18713c038e6bSDominik Dingel */ 18723c038e6bSDominik Dingel kvm_check_async_pf_completion(vcpu); 18733c038e6bSDominik Dingel 18745a32c1afSChristian Borntraeger memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16); 1875b0c632dbSHeiko Carstens 1876b0c632dbSHeiko Carstens if (need_resched()) 1877b0c632dbSHeiko Carstens schedule(); 1878b0c632dbSHeiko Carstens 1879d3a73acbSMartin Schwidefsky if (test_cpu_flag(CIF_MCCK_PENDING)) 188071cde587SChristian Borntraeger s390_handle_mcck(); 188171cde587SChristian Borntraeger 188279395031SJens Freimann if (!kvm_is_ucontrol(vcpu->kvm)) { 188379395031SJens Freimann rc = kvm_s390_deliver_pending_interrupts(vcpu); 188479395031SJens Freimann if (rc) 188579395031SJens Freimann return rc; 188679395031SJens Freimann } 18870ff31867SCarsten Otte 18882c70fe44SChristian Borntraeger rc = kvm_s390_handle_requests(vcpu); 18892c70fe44SChristian Borntraeger if (rc) 18902c70fe44SChristian Borntraeger return rc; 18912c70fe44SChristian Borntraeger 189227291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) { 189327291e21SDavid Hildenbrand kvm_s390_backup_guest_per_regs(vcpu); 189427291e21SDavid Hildenbrand kvm_s390_patch_guest_per_regs(vcpu); 189527291e21SDavid Hildenbrand } 189627291e21SDavid Hildenbrand 1897b0c632dbSHeiko Carstens vcpu->arch.sie_block->icptcode = 0; 18983fb4c40fSThomas Huth cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags); 18993fb4c40fSThomas Huth VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags); 19003fb4c40fSThomas Huth trace_kvm_s390_sie_enter(vcpu, cpuflags); 19012b29a9fdSDominik Dingel 19023fb4c40fSThomas Huth return 0; 19033fb4c40fSThomas Huth } 19043fb4c40fSThomas Huth 1905492d8642SThomas Huth static int vcpu_post_run_fault_in_sie(struct kvm_vcpu *vcpu) 1906492d8642SThomas Huth { 1907492d8642SThomas Huth psw_t *psw = &vcpu->arch.sie_block->gpsw; 1908492d8642SThomas Huth u8 opcode; 1909492d8642SThomas Huth int rc; 1910492d8642SThomas Huth 1911492d8642SThomas Huth VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction"); 1912492d8642SThomas Huth trace_kvm_s390_sie_fault(vcpu); 1913492d8642SThomas Huth 1914492d8642SThomas Huth /* 1915492d8642SThomas Huth * We want to inject an addressing exception, which is defined as a 1916492d8642SThomas Huth * suppressing or terminating exception. However, since we came here 1917492d8642SThomas Huth * by a DAT access exception, the PSW still points to the faulting 1918492d8642SThomas Huth * instruction since DAT exceptions are nullifying. So we've got 1919492d8642SThomas Huth * to look up the current opcode to get the length of the instruction 1920492d8642SThomas Huth * to be able to forward the PSW. 1921492d8642SThomas Huth */ 19228ae04b8fSAlexander Yarygin rc = read_guest(vcpu, psw->addr, 0, &opcode, 1); 1923492d8642SThomas Huth if (rc) 1924492d8642SThomas Huth return kvm_s390_inject_prog_cond(vcpu, rc); 1925492d8642SThomas Huth psw->addr = __rewind_psw(*psw, -insn_length(opcode)); 1926492d8642SThomas Huth 1927492d8642SThomas Huth return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING); 1928492d8642SThomas Huth } 1929492d8642SThomas Huth 19303fb4c40fSThomas Huth static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason) 19313fb4c40fSThomas Huth { 193224eb3a82SDominik Dingel int rc = -1; 19332b29a9fdSDominik Dingel 19342b29a9fdSDominik Dingel VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", 19352b29a9fdSDominik Dingel vcpu->arch.sie_block->icptcode); 19362b29a9fdSDominik Dingel trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode); 19372b29a9fdSDominik Dingel 193827291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) 193927291e21SDavid Hildenbrand kvm_s390_restore_guest_per_regs(vcpu); 194027291e21SDavid Hildenbrand 19413fb4c40fSThomas Huth if (exit_reason >= 0) { 19427c470539SMartin Schwidefsky rc = 0; 1943210b1607SThomas Huth } else if (kvm_is_ucontrol(vcpu->kvm)) { 1944210b1607SThomas Huth vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL; 1945210b1607SThomas Huth vcpu->run->s390_ucontrol.trans_exc_code = 1946210b1607SThomas Huth current->thread.gmap_addr; 1947210b1607SThomas Huth vcpu->run->s390_ucontrol.pgm_code = 0x10; 1948210b1607SThomas Huth rc = -EREMOTE; 194924eb3a82SDominik Dingel 195024eb3a82SDominik Dingel } else if (current->thread.gmap_pfault) { 19513c038e6bSDominik Dingel trace_kvm_s390_major_guest_pfault(vcpu); 195224eb3a82SDominik Dingel current->thread.gmap_pfault = 0; 1953fa576c58SThomas Huth if (kvm_arch_setup_async_pf(vcpu)) { 195424eb3a82SDominik Dingel rc = 0; 1955fa576c58SThomas Huth } else { 1956fa576c58SThomas Huth gpa_t gpa = current->thread.gmap_addr; 1957fa576c58SThomas Huth rc = kvm_arch_fault_in_page(vcpu, gpa, 1); 1958fa576c58SThomas Huth } 195924eb3a82SDominik Dingel } 196024eb3a82SDominik Dingel 1961492d8642SThomas Huth if (rc == -1) 1962492d8642SThomas Huth rc = vcpu_post_run_fault_in_sie(vcpu); 1963b0c632dbSHeiko Carstens 19645a32c1afSChristian Borntraeger memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16); 19653fb4c40fSThomas Huth 1966a76ccff6SThomas Huth if (rc == 0) { 1967a76ccff6SThomas Huth if (kvm_is_ucontrol(vcpu->kvm)) 19682955c83fSChristian Borntraeger /* Don't exit for host interrupts. */ 19692955c83fSChristian Borntraeger rc = vcpu->arch.sie_block->icptcode ? -EOPNOTSUPP : 0; 1970a76ccff6SThomas Huth else 1971a76ccff6SThomas Huth rc = kvm_handle_sie_intercept(vcpu); 1972a76ccff6SThomas Huth } 1973a76ccff6SThomas Huth 19743fb4c40fSThomas Huth return rc; 19753fb4c40fSThomas Huth } 19763fb4c40fSThomas Huth 19773fb4c40fSThomas Huth static int __vcpu_run(struct kvm_vcpu *vcpu) 19783fb4c40fSThomas Huth { 19793fb4c40fSThomas Huth int rc, exit_reason; 19803fb4c40fSThomas Huth 1981800c1065SThomas Huth /* 1982800c1065SThomas Huth * We try to hold kvm->srcu during most of vcpu_run (except when run- 1983800c1065SThomas Huth * ning the guest), so that memslots (and other stuff) are protected 1984800c1065SThomas Huth */ 1985800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 1986800c1065SThomas Huth 1987a76ccff6SThomas Huth do { 19883fb4c40fSThomas Huth rc = vcpu_pre_run(vcpu); 19893fb4c40fSThomas Huth if (rc) 1990a76ccff6SThomas Huth break; 19913fb4c40fSThomas Huth 1992800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 19933fb4c40fSThomas Huth /* 1994a76ccff6SThomas Huth * As PF_VCPU will be used in fault handler, between 1995a76ccff6SThomas Huth * guest_enter and guest_exit should be no uaccess. 19963fb4c40fSThomas Huth */ 19973fb4c40fSThomas Huth preempt_disable(); 19983fb4c40fSThomas Huth kvm_guest_enter(); 19993fb4c40fSThomas Huth preempt_enable(); 2000a76ccff6SThomas Huth exit_reason = sie64a(vcpu->arch.sie_block, 2001a76ccff6SThomas Huth vcpu->run->s.regs.gprs); 20023fb4c40fSThomas Huth kvm_guest_exit(); 2003800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 20043fb4c40fSThomas Huth 20053fb4c40fSThomas Huth rc = vcpu_post_run(vcpu, exit_reason); 200627291e21SDavid Hildenbrand } while (!signal_pending(current) && !guestdbg_exit_pending(vcpu) && !rc); 20073fb4c40fSThomas Huth 2008800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 2009e168bf8dSCarsten Otte return rc; 2010b0c632dbSHeiko Carstens } 2011b0c632dbSHeiko Carstens 2012b028ee3eSDavid Hildenbrand static void sync_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 2013b028ee3eSDavid Hildenbrand { 2014b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask; 2015b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr; 2016b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) 2017b028ee3eSDavid Hildenbrand kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix); 2018b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) { 2019b028ee3eSDavid Hildenbrand memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128); 2020d3d692c8SDavid Hildenbrand /* some control register changes require a tlb flush */ 2021d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 2022b028ee3eSDavid Hildenbrand } 2023b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_ARCH0) { 2024b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->cputm = kvm_run->s.regs.cputm; 2025b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->ckc = kvm_run->s.regs.ckc; 2026b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->todpr = kvm_run->s.regs.todpr; 2027b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->pp = kvm_run->s.regs.pp; 2028b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gbea = kvm_run->s.regs.gbea; 2029b028ee3eSDavid Hildenbrand } 2030b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PFAULT) { 2031b028ee3eSDavid Hildenbrand vcpu->arch.pfault_token = kvm_run->s.regs.pft; 2032b028ee3eSDavid Hildenbrand vcpu->arch.pfault_select = kvm_run->s.regs.pfs; 2033b028ee3eSDavid Hildenbrand vcpu->arch.pfault_compare = kvm_run->s.regs.pfc; 20349fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 20359fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 2036b028ee3eSDavid Hildenbrand } 2037b028ee3eSDavid Hildenbrand kvm_run->kvm_dirty_regs = 0; 2038b028ee3eSDavid Hildenbrand } 2039b028ee3eSDavid Hildenbrand 2040b028ee3eSDavid Hildenbrand static void store_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 2041b028ee3eSDavid Hildenbrand { 2042b028ee3eSDavid Hildenbrand kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask; 2043b028ee3eSDavid Hildenbrand kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr; 2044b028ee3eSDavid Hildenbrand kvm_run->s.regs.prefix = kvm_s390_get_prefix(vcpu); 2045b028ee3eSDavid Hildenbrand memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128); 2046b028ee3eSDavid Hildenbrand kvm_run->s.regs.cputm = vcpu->arch.sie_block->cputm; 2047b028ee3eSDavid Hildenbrand kvm_run->s.regs.ckc = vcpu->arch.sie_block->ckc; 2048b028ee3eSDavid Hildenbrand kvm_run->s.regs.todpr = vcpu->arch.sie_block->todpr; 2049b028ee3eSDavid Hildenbrand kvm_run->s.regs.pp = vcpu->arch.sie_block->pp; 2050b028ee3eSDavid Hildenbrand kvm_run->s.regs.gbea = vcpu->arch.sie_block->gbea; 2051b028ee3eSDavid Hildenbrand kvm_run->s.regs.pft = vcpu->arch.pfault_token; 2052b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfs = vcpu->arch.pfault_select; 2053b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfc = vcpu->arch.pfault_compare; 2054b028ee3eSDavid Hildenbrand } 2055b028ee3eSDavid Hildenbrand 2056b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 2057b0c632dbSHeiko Carstens { 20588f2abe6aSChristian Borntraeger int rc; 2059b0c632dbSHeiko Carstens sigset_t sigsaved; 2060b0c632dbSHeiko Carstens 206127291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu)) { 206227291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 206327291e21SDavid Hildenbrand return 0; 206427291e21SDavid Hildenbrand } 206527291e21SDavid Hildenbrand 2066b0c632dbSHeiko Carstens if (vcpu->sigset_active) 2067b0c632dbSHeiko Carstens sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); 2068b0c632dbSHeiko Carstens 20696352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) { 20706852d7b6SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 20716352e4d2SDavid Hildenbrand } else if (is_vcpu_stopped(vcpu)) { 20726352e4d2SDavid Hildenbrand pr_err_ratelimited("kvm-s390: can't run stopped vcpu %d\n", 20736352e4d2SDavid Hildenbrand vcpu->vcpu_id); 20746352e4d2SDavid Hildenbrand return -EINVAL; 20756352e4d2SDavid Hildenbrand } 2076b0c632dbSHeiko Carstens 2077b028ee3eSDavid Hildenbrand sync_regs(vcpu, kvm_run); 2078d7b0b5ebSCarsten Otte 2079dab4079dSHeiko Carstens might_fault(); 2080e168bf8dSCarsten Otte rc = __vcpu_run(vcpu); 20819ace903dSChristian Ehrhardt 2082b1d16c49SChristian Ehrhardt if (signal_pending(current) && !rc) { 2083b1d16c49SChristian Ehrhardt kvm_run->exit_reason = KVM_EXIT_INTR; 20848f2abe6aSChristian Borntraeger rc = -EINTR; 2085b1d16c49SChristian Ehrhardt } 20868f2abe6aSChristian Borntraeger 208727291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu) && !rc) { 208827291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 208927291e21SDavid Hildenbrand rc = 0; 209027291e21SDavid Hildenbrand } 209127291e21SDavid Hildenbrand 2092b8e660b8SHeiko Carstens if (rc == -EOPNOTSUPP) { 20938f2abe6aSChristian Borntraeger /* intercept cannot be handled in-kernel, prepare kvm-run */ 20948f2abe6aSChristian Borntraeger kvm_run->exit_reason = KVM_EXIT_S390_SIEIC; 20958f2abe6aSChristian Borntraeger kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode; 20968f2abe6aSChristian Borntraeger kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa; 20978f2abe6aSChristian Borntraeger kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb; 20988f2abe6aSChristian Borntraeger rc = 0; 20998f2abe6aSChristian Borntraeger } 21008f2abe6aSChristian Borntraeger 21018f2abe6aSChristian Borntraeger if (rc == -EREMOTE) { 21028f2abe6aSChristian Borntraeger /* intercept was handled, but userspace support is needed 21038f2abe6aSChristian Borntraeger * kvm_run has been prepared by the handler */ 21048f2abe6aSChristian Borntraeger rc = 0; 21058f2abe6aSChristian Borntraeger } 21068f2abe6aSChristian Borntraeger 2107b028ee3eSDavid Hildenbrand store_regs(vcpu, kvm_run); 2108d7b0b5ebSCarsten Otte 2109b0c632dbSHeiko Carstens if (vcpu->sigset_active) 2110b0c632dbSHeiko Carstens sigprocmask(SIG_SETMASK, &sigsaved, NULL); 2111b0c632dbSHeiko Carstens 2112b0c632dbSHeiko Carstens vcpu->stat.exit_userspace++; 21137e8e6ab4SHeiko Carstens return rc; 2114b0c632dbSHeiko Carstens } 2115b0c632dbSHeiko Carstens 2116b0c632dbSHeiko Carstens /* 2117b0c632dbSHeiko Carstens * store status at address 2118b0c632dbSHeiko Carstens * we use have two special cases: 2119b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit 2120b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_PREFIXED: -> prefix 2121b0c632dbSHeiko Carstens */ 2122d0bce605SHeiko Carstens int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long gpa) 2123b0c632dbSHeiko Carstens { 2124092670cdSCarsten Otte unsigned char archmode = 1; 2125fda902cbSMichael Mueller unsigned int px; 2126178bd789SThomas Huth u64 clkcomp; 2127d0bce605SHeiko Carstens int rc; 2128b0c632dbSHeiko Carstens 2129d0bce605SHeiko Carstens if (gpa == KVM_S390_STORE_STATUS_NOADDR) { 2130d0bce605SHeiko Carstens if (write_guest_abs(vcpu, 163, &archmode, 1)) 2131b0c632dbSHeiko Carstens return -EFAULT; 2132d0bce605SHeiko Carstens gpa = SAVE_AREA_BASE; 2133d0bce605SHeiko Carstens } else if (gpa == KVM_S390_STORE_STATUS_PREFIXED) { 2134d0bce605SHeiko Carstens if (write_guest_real(vcpu, 163, &archmode, 1)) 2135b0c632dbSHeiko Carstens return -EFAULT; 2136d0bce605SHeiko Carstens gpa = kvm_s390_real_to_abs(vcpu, SAVE_AREA_BASE); 2137d0bce605SHeiko Carstens } 2138d0bce605SHeiko Carstens rc = write_guest_abs(vcpu, gpa + offsetof(struct save_area, fp_regs), 2139d0bce605SHeiko Carstens vcpu->arch.guest_fpregs.fprs, 128); 2140d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, gp_regs), 2141d0bce605SHeiko Carstens vcpu->run->s.regs.gprs, 128); 2142d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, psw), 2143d0bce605SHeiko Carstens &vcpu->arch.sie_block->gpsw, 16); 2144fda902cbSMichael Mueller px = kvm_s390_get_prefix(vcpu); 2145d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, pref_reg), 2146fda902cbSMichael Mueller &px, 4); 2147d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, 2148d0bce605SHeiko Carstens gpa + offsetof(struct save_area, fp_ctrl_reg), 2149d0bce605SHeiko Carstens &vcpu->arch.guest_fpregs.fpc, 4); 2150d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, tod_reg), 2151d0bce605SHeiko Carstens &vcpu->arch.sie_block->todpr, 4); 2152d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, timer), 2153d0bce605SHeiko Carstens &vcpu->arch.sie_block->cputm, 8); 2154178bd789SThomas Huth clkcomp = vcpu->arch.sie_block->ckc >> 8; 2155d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, clk_cmp), 2156d0bce605SHeiko Carstens &clkcomp, 8); 2157d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, acc_regs), 2158d0bce605SHeiko Carstens &vcpu->run->s.regs.acrs, 64); 2159d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, ctrl_regs), 2160d0bce605SHeiko Carstens &vcpu->arch.sie_block->gcr, 128); 2161d0bce605SHeiko Carstens return rc ? -EFAULT : 0; 2162b0c632dbSHeiko Carstens } 2163b0c632dbSHeiko Carstens 2164e879892cSThomas Huth int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr) 2165e879892cSThomas Huth { 2166e879892cSThomas Huth /* 2167e879892cSThomas Huth * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy 2168e879892cSThomas Huth * copying in vcpu load/put. Lets update our copies before we save 2169e879892cSThomas Huth * it into the save area 2170e879892cSThomas Huth */ 2171e879892cSThomas Huth save_fp_ctl(&vcpu->arch.guest_fpregs.fpc); 2172e879892cSThomas Huth save_fp_regs(vcpu->arch.guest_fpregs.fprs); 2173e879892cSThomas Huth save_access_regs(vcpu->run->s.regs.acrs); 2174e879892cSThomas Huth 2175e879892cSThomas Huth return kvm_s390_store_status_unloaded(vcpu, addr); 2176e879892cSThomas Huth } 2177e879892cSThomas Huth 2178bc17de7cSEric Farman /* 2179bc17de7cSEric Farman * store additional status at address 2180bc17de7cSEric Farman */ 2181bc17de7cSEric Farman int kvm_s390_store_adtl_status_unloaded(struct kvm_vcpu *vcpu, 2182bc17de7cSEric Farman unsigned long gpa) 2183bc17de7cSEric Farman { 2184bc17de7cSEric Farman /* Only bits 0-53 are used for address formation */ 2185bc17de7cSEric Farman if (!(gpa & ~0x3ff)) 2186bc17de7cSEric Farman return 0; 2187bc17de7cSEric Farman 2188bc17de7cSEric Farman return write_guest_abs(vcpu, gpa & ~0x3ff, 2189bc17de7cSEric Farman (void *)&vcpu->run->s.regs.vrs, 512); 2190bc17de7cSEric Farman } 2191bc17de7cSEric Farman 2192bc17de7cSEric Farman int kvm_s390_vcpu_store_adtl_status(struct kvm_vcpu *vcpu, unsigned long addr) 2193bc17de7cSEric Farman { 2194bc17de7cSEric Farman if (!test_kvm_facility(vcpu->kvm, 129)) 2195bc17de7cSEric Farman return 0; 2196bc17de7cSEric Farman 2197bc17de7cSEric Farman /* 2198bc17de7cSEric Farman * The guest VXRS are in the host VXRs due to the lazy 2199bc17de7cSEric Farman * copying in vcpu load/put. Let's update our copies before we save 2200bc17de7cSEric Farman * it into the save area. 2201bc17de7cSEric Farman */ 2202bc17de7cSEric Farman save_vx_regs((__vector128 *)&vcpu->run->s.regs.vrs); 2203bc17de7cSEric Farman 2204bc17de7cSEric Farman return kvm_s390_store_adtl_status_unloaded(vcpu, addr); 2205bc17de7cSEric Farman } 2206bc17de7cSEric Farman 22078ad35755SDavid Hildenbrand static void __disable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 22088ad35755SDavid Hildenbrand { 22098ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu); 22108ad35755SDavid Hildenbrand kvm_make_request(KVM_REQ_DISABLE_IBS, vcpu); 22118ad35755SDavid Hildenbrand exit_sie_sync(vcpu); 22128ad35755SDavid Hildenbrand } 22138ad35755SDavid Hildenbrand 22148ad35755SDavid Hildenbrand static void __disable_ibs_on_all_vcpus(struct kvm *kvm) 22158ad35755SDavid Hildenbrand { 22168ad35755SDavid Hildenbrand unsigned int i; 22178ad35755SDavid Hildenbrand struct kvm_vcpu *vcpu; 22188ad35755SDavid Hildenbrand 22198ad35755SDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 22208ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 22218ad35755SDavid Hildenbrand } 22228ad35755SDavid Hildenbrand } 22238ad35755SDavid Hildenbrand 22248ad35755SDavid Hildenbrand static void __enable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 22258ad35755SDavid Hildenbrand { 22268ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu); 22278ad35755SDavid Hildenbrand kvm_make_request(KVM_REQ_ENABLE_IBS, vcpu); 22288ad35755SDavid Hildenbrand exit_sie_sync(vcpu); 22298ad35755SDavid Hildenbrand } 22308ad35755SDavid Hildenbrand 22316852d7b6SDavid Hildenbrand void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu) 22326852d7b6SDavid Hildenbrand { 22338ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 22348ad35755SDavid Hildenbrand 22358ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 22368ad35755SDavid Hildenbrand return; 22378ad35755SDavid Hildenbrand 22386852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 1); 22398ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 2240433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 22418ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 22428ad35755SDavid Hildenbrand 22438ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 22448ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) 22458ad35755SDavid Hildenbrand started_vcpus++; 22468ad35755SDavid Hildenbrand } 22478ad35755SDavid Hildenbrand 22488ad35755SDavid Hildenbrand if (started_vcpus == 0) { 22498ad35755SDavid Hildenbrand /* we're the only active VCPU -> speed it up */ 22508ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(vcpu); 22518ad35755SDavid Hildenbrand } else if (started_vcpus == 1) { 22528ad35755SDavid Hildenbrand /* 22538ad35755SDavid Hildenbrand * As we are starting a second VCPU, we have to disable 22548ad35755SDavid Hildenbrand * the IBS facility on all VCPUs to remove potentially 22558ad35755SDavid Hildenbrand * oustanding ENABLE requests. 22568ad35755SDavid Hildenbrand */ 22578ad35755SDavid Hildenbrand __disable_ibs_on_all_vcpus(vcpu->kvm); 22588ad35755SDavid Hildenbrand } 22598ad35755SDavid Hildenbrand 22606852d7b6SDavid Hildenbrand atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags); 22618ad35755SDavid Hildenbrand /* 22628ad35755SDavid Hildenbrand * Another VCPU might have used IBS while we were offline. 22638ad35755SDavid Hildenbrand * Let's play safe and flush the VCPU at startup. 22648ad35755SDavid Hildenbrand */ 2265d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 2266433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 22678ad35755SDavid Hildenbrand return; 22686852d7b6SDavid Hildenbrand } 22696852d7b6SDavid Hildenbrand 22706852d7b6SDavid Hildenbrand void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu) 22716852d7b6SDavid Hildenbrand { 22728ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 22738ad35755SDavid Hildenbrand struct kvm_vcpu *started_vcpu = NULL; 22748ad35755SDavid Hildenbrand 22758ad35755SDavid Hildenbrand if (is_vcpu_stopped(vcpu)) 22768ad35755SDavid Hildenbrand return; 22778ad35755SDavid Hildenbrand 22786852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 0); 22798ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 2280433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 22818ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 22828ad35755SDavid Hildenbrand 228332f5ff63SDavid Hildenbrand /* SIGP STOP and SIGP STOP AND STORE STATUS has been fully processed */ 22846cddd432SDavid Hildenbrand kvm_s390_clear_stop_irq(vcpu); 228532f5ff63SDavid Hildenbrand 22866cddd432SDavid Hildenbrand atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags); 22878ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 22888ad35755SDavid Hildenbrand 22898ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 22908ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) { 22918ad35755SDavid Hildenbrand started_vcpus++; 22928ad35755SDavid Hildenbrand started_vcpu = vcpu->kvm->vcpus[i]; 22938ad35755SDavid Hildenbrand } 22948ad35755SDavid Hildenbrand } 22958ad35755SDavid Hildenbrand 22968ad35755SDavid Hildenbrand if (started_vcpus == 1) { 22978ad35755SDavid Hildenbrand /* 22988ad35755SDavid Hildenbrand * As we only have one VCPU left, we want to enable the 22998ad35755SDavid Hildenbrand * IBS facility for that VCPU to speed it up. 23008ad35755SDavid Hildenbrand */ 23018ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(started_vcpu); 23028ad35755SDavid Hildenbrand } 23038ad35755SDavid Hildenbrand 2304433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 23058ad35755SDavid Hildenbrand return; 23066852d7b6SDavid Hildenbrand } 23076852d7b6SDavid Hildenbrand 2308d6712df9SCornelia Huck static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 2309d6712df9SCornelia Huck struct kvm_enable_cap *cap) 2310d6712df9SCornelia Huck { 2311d6712df9SCornelia Huck int r; 2312d6712df9SCornelia Huck 2313d6712df9SCornelia Huck if (cap->flags) 2314d6712df9SCornelia Huck return -EINVAL; 2315d6712df9SCornelia Huck 2316d6712df9SCornelia Huck switch (cap->cap) { 2317fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 2318fa6b7fe9SCornelia Huck if (!vcpu->kvm->arch.css_support) { 2319fa6b7fe9SCornelia Huck vcpu->kvm->arch.css_support = 1; 2320fa6b7fe9SCornelia Huck trace_kvm_s390_enable_css(vcpu->kvm); 2321fa6b7fe9SCornelia Huck } 2322fa6b7fe9SCornelia Huck r = 0; 2323fa6b7fe9SCornelia Huck break; 2324d6712df9SCornelia Huck default: 2325d6712df9SCornelia Huck r = -EINVAL; 2326d6712df9SCornelia Huck break; 2327d6712df9SCornelia Huck } 2328d6712df9SCornelia Huck return r; 2329d6712df9SCornelia Huck } 2330d6712df9SCornelia Huck 233141408c28SThomas Huth static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu, 233241408c28SThomas Huth struct kvm_s390_mem_op *mop) 233341408c28SThomas Huth { 233441408c28SThomas Huth void __user *uaddr = (void __user *)mop->buf; 233541408c28SThomas Huth void *tmpbuf = NULL; 233641408c28SThomas Huth int r, srcu_idx; 233741408c28SThomas Huth const u64 supported_flags = KVM_S390_MEMOP_F_INJECT_EXCEPTION 233841408c28SThomas Huth | KVM_S390_MEMOP_F_CHECK_ONLY; 233941408c28SThomas Huth 234041408c28SThomas Huth if (mop->flags & ~supported_flags) 234141408c28SThomas Huth return -EINVAL; 234241408c28SThomas Huth 234341408c28SThomas Huth if (mop->size > MEM_OP_MAX_SIZE) 234441408c28SThomas Huth return -E2BIG; 234541408c28SThomas Huth 234641408c28SThomas Huth if (!(mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY)) { 234741408c28SThomas Huth tmpbuf = vmalloc(mop->size); 234841408c28SThomas Huth if (!tmpbuf) 234941408c28SThomas Huth return -ENOMEM; 235041408c28SThomas Huth } 235141408c28SThomas Huth 235241408c28SThomas Huth srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 235341408c28SThomas Huth 235441408c28SThomas Huth switch (mop->op) { 235541408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_READ: 235641408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 235741408c28SThomas Huth r = check_gva_range(vcpu, mop->gaddr, mop->ar, mop->size, false); 235841408c28SThomas Huth break; 235941408c28SThomas Huth } 236041408c28SThomas Huth r = read_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 236141408c28SThomas Huth if (r == 0) { 236241408c28SThomas Huth if (copy_to_user(uaddr, tmpbuf, mop->size)) 236341408c28SThomas Huth r = -EFAULT; 236441408c28SThomas Huth } 236541408c28SThomas Huth break; 236641408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_WRITE: 236741408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 236841408c28SThomas Huth r = check_gva_range(vcpu, mop->gaddr, mop->ar, mop->size, true); 236941408c28SThomas Huth break; 237041408c28SThomas Huth } 237141408c28SThomas Huth if (copy_from_user(tmpbuf, uaddr, mop->size)) { 237241408c28SThomas Huth r = -EFAULT; 237341408c28SThomas Huth break; 237441408c28SThomas Huth } 237541408c28SThomas Huth r = write_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 237641408c28SThomas Huth break; 237741408c28SThomas Huth default: 237841408c28SThomas Huth r = -EINVAL; 237941408c28SThomas Huth } 238041408c28SThomas Huth 238141408c28SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, srcu_idx); 238241408c28SThomas Huth 238341408c28SThomas Huth if (r > 0 && (mop->flags & KVM_S390_MEMOP_F_INJECT_EXCEPTION) != 0) 238441408c28SThomas Huth kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm); 238541408c28SThomas Huth 238641408c28SThomas Huth vfree(tmpbuf); 238741408c28SThomas Huth return r; 238841408c28SThomas Huth } 238941408c28SThomas Huth 2390b0c632dbSHeiko Carstens long kvm_arch_vcpu_ioctl(struct file *filp, 2391b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 2392b0c632dbSHeiko Carstens { 2393b0c632dbSHeiko Carstens struct kvm_vcpu *vcpu = filp->private_data; 2394b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 2395800c1065SThomas Huth int idx; 2396bc923cc9SAvi Kivity long r; 2397b0c632dbSHeiko Carstens 239893736624SAvi Kivity switch (ioctl) { 239947b43c52SJens Freimann case KVM_S390_IRQ: { 240047b43c52SJens Freimann struct kvm_s390_irq s390irq; 240147b43c52SJens Freimann 240247b43c52SJens Freimann r = -EFAULT; 240347b43c52SJens Freimann if (copy_from_user(&s390irq, argp, sizeof(s390irq))) 240447b43c52SJens Freimann break; 240547b43c52SJens Freimann r = kvm_s390_inject_vcpu(vcpu, &s390irq); 240647b43c52SJens Freimann break; 240747b43c52SJens Freimann } 240893736624SAvi Kivity case KVM_S390_INTERRUPT: { 2409ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 2410383d0b05SJens Freimann struct kvm_s390_irq s390irq; 2411ba5c1e9bSCarsten Otte 241293736624SAvi Kivity r = -EFAULT; 2413ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 241493736624SAvi Kivity break; 2415383d0b05SJens Freimann if (s390int_to_s390irq(&s390int, &s390irq)) 2416383d0b05SJens Freimann return -EINVAL; 2417383d0b05SJens Freimann r = kvm_s390_inject_vcpu(vcpu, &s390irq); 241893736624SAvi Kivity break; 2419ba5c1e9bSCarsten Otte } 2420b0c632dbSHeiko Carstens case KVM_S390_STORE_STATUS: 2421800c1065SThomas Huth idx = srcu_read_lock(&vcpu->kvm->srcu); 2422bc923cc9SAvi Kivity r = kvm_s390_vcpu_store_status(vcpu, arg); 2423800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, idx); 2424bc923cc9SAvi Kivity break; 2425b0c632dbSHeiko Carstens case KVM_S390_SET_INITIAL_PSW: { 2426b0c632dbSHeiko Carstens psw_t psw; 2427b0c632dbSHeiko Carstens 2428bc923cc9SAvi Kivity r = -EFAULT; 2429b0c632dbSHeiko Carstens if (copy_from_user(&psw, argp, sizeof(psw))) 2430bc923cc9SAvi Kivity break; 2431bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw); 2432bc923cc9SAvi Kivity break; 2433b0c632dbSHeiko Carstens } 2434b0c632dbSHeiko Carstens case KVM_S390_INITIAL_RESET: 2435bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_initial_reset(vcpu); 2436bc923cc9SAvi Kivity break; 243714eebd91SCarsten Otte case KVM_SET_ONE_REG: 243814eebd91SCarsten Otte case KVM_GET_ONE_REG: { 243914eebd91SCarsten Otte struct kvm_one_reg reg; 244014eebd91SCarsten Otte r = -EFAULT; 244114eebd91SCarsten Otte if (copy_from_user(®, argp, sizeof(reg))) 244214eebd91SCarsten Otte break; 244314eebd91SCarsten Otte if (ioctl == KVM_SET_ONE_REG) 244414eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, ®); 244514eebd91SCarsten Otte else 244614eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, ®); 244714eebd91SCarsten Otte break; 244814eebd91SCarsten Otte } 244927e0393fSCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 245027e0393fSCarsten Otte case KVM_S390_UCAS_MAP: { 245127e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 245227e0393fSCarsten Otte 245327e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 245427e0393fSCarsten Otte r = -EFAULT; 245527e0393fSCarsten Otte break; 245627e0393fSCarsten Otte } 245727e0393fSCarsten Otte 245827e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 245927e0393fSCarsten Otte r = -EINVAL; 246027e0393fSCarsten Otte break; 246127e0393fSCarsten Otte } 246227e0393fSCarsten Otte 246327e0393fSCarsten Otte r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr, 246427e0393fSCarsten Otte ucasmap.vcpu_addr, ucasmap.length); 246527e0393fSCarsten Otte break; 246627e0393fSCarsten Otte } 246727e0393fSCarsten Otte case KVM_S390_UCAS_UNMAP: { 246827e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 246927e0393fSCarsten Otte 247027e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 247127e0393fSCarsten Otte r = -EFAULT; 247227e0393fSCarsten Otte break; 247327e0393fSCarsten Otte } 247427e0393fSCarsten Otte 247527e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 247627e0393fSCarsten Otte r = -EINVAL; 247727e0393fSCarsten Otte break; 247827e0393fSCarsten Otte } 247927e0393fSCarsten Otte 248027e0393fSCarsten Otte r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr, 248127e0393fSCarsten Otte ucasmap.length); 248227e0393fSCarsten Otte break; 248327e0393fSCarsten Otte } 248427e0393fSCarsten Otte #endif 2485ccc7910fSCarsten Otte case KVM_S390_VCPU_FAULT: { 2486527e30b4SMartin Schwidefsky r = gmap_fault(vcpu->arch.gmap, arg, 0); 2487ccc7910fSCarsten Otte break; 2488ccc7910fSCarsten Otte } 2489d6712df9SCornelia Huck case KVM_ENABLE_CAP: 2490d6712df9SCornelia Huck { 2491d6712df9SCornelia Huck struct kvm_enable_cap cap; 2492d6712df9SCornelia Huck r = -EFAULT; 2493d6712df9SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 2494d6712df9SCornelia Huck break; 2495d6712df9SCornelia Huck r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 2496d6712df9SCornelia Huck break; 2497d6712df9SCornelia Huck } 249841408c28SThomas Huth case KVM_S390_MEM_OP: { 249941408c28SThomas Huth struct kvm_s390_mem_op mem_op; 250041408c28SThomas Huth 250141408c28SThomas Huth if (copy_from_user(&mem_op, argp, sizeof(mem_op)) == 0) 250241408c28SThomas Huth r = kvm_s390_guest_mem_op(vcpu, &mem_op); 250341408c28SThomas Huth else 250441408c28SThomas Huth r = -EFAULT; 250541408c28SThomas Huth break; 250641408c28SThomas Huth } 2507*816c7667SJens Freimann case KVM_S390_SET_IRQ_STATE: { 2508*816c7667SJens Freimann struct kvm_s390_irq_state irq_state; 2509*816c7667SJens Freimann 2510*816c7667SJens Freimann r = -EFAULT; 2511*816c7667SJens Freimann if (copy_from_user(&irq_state, argp, sizeof(irq_state))) 2512*816c7667SJens Freimann break; 2513*816c7667SJens Freimann if (irq_state.len > VCPU_IRQS_MAX_BUF || 2514*816c7667SJens Freimann irq_state.len == 0 || 2515*816c7667SJens Freimann irq_state.len % sizeof(struct kvm_s390_irq) > 0) { 2516*816c7667SJens Freimann r = -EINVAL; 2517*816c7667SJens Freimann break; 2518*816c7667SJens Freimann } 2519*816c7667SJens Freimann r = kvm_s390_set_irq_state(vcpu, 2520*816c7667SJens Freimann (void __user *) irq_state.buf, 2521*816c7667SJens Freimann irq_state.len); 2522*816c7667SJens Freimann break; 2523*816c7667SJens Freimann } 2524*816c7667SJens Freimann case KVM_S390_GET_IRQ_STATE: { 2525*816c7667SJens Freimann struct kvm_s390_irq_state irq_state; 2526*816c7667SJens Freimann 2527*816c7667SJens Freimann r = -EFAULT; 2528*816c7667SJens Freimann if (copy_from_user(&irq_state, argp, sizeof(irq_state))) 2529*816c7667SJens Freimann break; 2530*816c7667SJens Freimann if (irq_state.len == 0) { 2531*816c7667SJens Freimann r = -EINVAL; 2532*816c7667SJens Freimann break; 2533*816c7667SJens Freimann } 2534*816c7667SJens Freimann r = kvm_s390_get_irq_state(vcpu, 2535*816c7667SJens Freimann (__u8 __user *) irq_state.buf, 2536*816c7667SJens Freimann irq_state.len); 2537*816c7667SJens Freimann break; 2538*816c7667SJens Freimann } 2539b0c632dbSHeiko Carstens default: 25403e6afcf1SCarsten Otte r = -ENOTTY; 2541b0c632dbSHeiko Carstens } 2542bc923cc9SAvi Kivity return r; 2543b0c632dbSHeiko Carstens } 2544b0c632dbSHeiko Carstens 25455b1c1493SCarsten Otte int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) 25465b1c1493SCarsten Otte { 25475b1c1493SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 25485b1c1493SCarsten Otte if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET) 25495b1c1493SCarsten Otte && (kvm_is_ucontrol(vcpu->kvm))) { 25505b1c1493SCarsten Otte vmf->page = virt_to_page(vcpu->arch.sie_block); 25515b1c1493SCarsten Otte get_page(vmf->page); 25525b1c1493SCarsten Otte return 0; 25535b1c1493SCarsten Otte } 25545b1c1493SCarsten Otte #endif 25555b1c1493SCarsten Otte return VM_FAULT_SIGBUS; 25565b1c1493SCarsten Otte } 25575b1c1493SCarsten Otte 25585587027cSAneesh Kumar K.V int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, 25595587027cSAneesh Kumar K.V unsigned long npages) 2560db3fe4ebSTakuya Yoshikawa { 2561db3fe4ebSTakuya Yoshikawa return 0; 2562db3fe4ebSTakuya Yoshikawa } 2563db3fe4ebSTakuya Yoshikawa 2564b0c632dbSHeiko Carstens /* Section: memory related */ 2565f7784b8eSMarcelo Tosatti int kvm_arch_prepare_memory_region(struct kvm *kvm, 2566f7784b8eSMarcelo Tosatti struct kvm_memory_slot *memslot, 25677b6195a9STakuya Yoshikawa struct kvm_userspace_memory_region *mem, 25687b6195a9STakuya Yoshikawa enum kvm_mr_change change) 2569b0c632dbSHeiko Carstens { 2570dd2887e7SNick Wang /* A few sanity checks. We can have memory slots which have to be 2571dd2887e7SNick Wang located/ended at a segment boundary (1MB). The memory in userland is 2572dd2887e7SNick Wang ok to be fragmented into various different vmas. It is okay to mmap() 2573dd2887e7SNick Wang and munmap() stuff in this slot after doing this call at any time */ 2574b0c632dbSHeiko Carstens 2575598841caSCarsten Otte if (mem->userspace_addr & 0xffffful) 2576b0c632dbSHeiko Carstens return -EINVAL; 2577b0c632dbSHeiko Carstens 2578598841caSCarsten Otte if (mem->memory_size & 0xffffful) 2579b0c632dbSHeiko Carstens return -EINVAL; 2580b0c632dbSHeiko Carstens 2581f7784b8eSMarcelo Tosatti return 0; 2582f7784b8eSMarcelo Tosatti } 2583f7784b8eSMarcelo Tosatti 2584f7784b8eSMarcelo Tosatti void kvm_arch_commit_memory_region(struct kvm *kvm, 2585f7784b8eSMarcelo Tosatti struct kvm_userspace_memory_region *mem, 25868482644aSTakuya Yoshikawa const struct kvm_memory_slot *old, 25878482644aSTakuya Yoshikawa enum kvm_mr_change change) 2588f7784b8eSMarcelo Tosatti { 2589f7850c92SCarsten Otte int rc; 2590f7784b8eSMarcelo Tosatti 25912cef4debSChristian Borntraeger /* If the basics of the memslot do not change, we do not want 25922cef4debSChristian Borntraeger * to update the gmap. Every update causes several unnecessary 25932cef4debSChristian Borntraeger * segment translation exceptions. This is usually handled just 25942cef4debSChristian Borntraeger * fine by the normal fault handler + gmap, but it will also 25952cef4debSChristian Borntraeger * cause faults on the prefix page of running guest CPUs. 25962cef4debSChristian Borntraeger */ 25972cef4debSChristian Borntraeger if (old->userspace_addr == mem->userspace_addr && 25982cef4debSChristian Borntraeger old->base_gfn * PAGE_SIZE == mem->guest_phys_addr && 25992cef4debSChristian Borntraeger old->npages * PAGE_SIZE == mem->memory_size) 26002cef4debSChristian Borntraeger return; 2601598841caSCarsten Otte 2602598841caSCarsten Otte rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr, 2603598841caSCarsten Otte mem->guest_phys_addr, mem->memory_size); 2604598841caSCarsten Otte if (rc) 2605f7850c92SCarsten Otte printk(KERN_WARNING "kvm-s390: failed to commit memory region\n"); 2606598841caSCarsten Otte return; 2607b0c632dbSHeiko Carstens } 2608b0c632dbSHeiko Carstens 2609b0c632dbSHeiko Carstens static int __init kvm_s390_init(void) 2610b0c632dbSHeiko Carstens { 26119d8d5786SMichael Mueller return kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); 2612b0c632dbSHeiko Carstens } 2613b0c632dbSHeiko Carstens 2614b0c632dbSHeiko Carstens static void __exit kvm_s390_exit(void) 2615b0c632dbSHeiko Carstens { 2616b0c632dbSHeiko Carstens kvm_exit(); 2617b0c632dbSHeiko Carstens } 2618b0c632dbSHeiko Carstens 2619b0c632dbSHeiko Carstens module_init(kvm_s390_init); 2620b0c632dbSHeiko Carstens module_exit(kvm_s390_exit); 2621566af940SCornelia Huck 2622566af940SCornelia Huck /* 2623566af940SCornelia Huck * Enable autoloading of the kvm module. 2624566af940SCornelia Huck * Note that we add the module alias here instead of virt/kvm/kvm_main.c 2625566af940SCornelia Huck * since x86 takes a different approach. 2626566af940SCornelia Huck */ 2627566af940SCornelia Huck #include <linux/miscdevice.h> 2628566af940SCornelia Huck MODULE_ALIAS_MISCDEV(KVM_MINOR); 2629566af940SCornelia Huck MODULE_ALIAS("devname:kvm"); 2630