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> 341526bf9cSChristian Borntraeger #include <asm/sclp.h> 358f2abe6aSChristian Borntraeger #include "kvm-s390.h" 36b0c632dbSHeiko Carstens #include "gaccess.h" 37b0c632dbSHeiko Carstens 385786fffaSCornelia Huck #define CREATE_TRACE_POINTS 395786fffaSCornelia Huck #include "trace.h" 40ade38c31SCornelia Huck #include "trace-s390.h" 415786fffaSCornelia Huck 4241408c28SThomas Huth #define MEM_OP_MAX_SIZE 65536 /* Maximum transfer size for KVM_S390_MEM_OP */ 4341408c28SThomas Huth 44b0c632dbSHeiko Carstens #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU 45b0c632dbSHeiko Carstens 46b0c632dbSHeiko Carstens struct kvm_stats_debugfs_item debugfs_entries[] = { 47b0c632dbSHeiko Carstens { "userspace_handled", VCPU_STAT(exit_userspace) }, 480eaeafa1SChristian Borntraeger { "exit_null", VCPU_STAT(exit_null) }, 498f2abe6aSChristian Borntraeger { "exit_validity", VCPU_STAT(exit_validity) }, 508f2abe6aSChristian Borntraeger { "exit_stop_request", VCPU_STAT(exit_stop_request) }, 518f2abe6aSChristian Borntraeger { "exit_external_request", VCPU_STAT(exit_external_request) }, 528f2abe6aSChristian Borntraeger { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) }, 53ba5c1e9bSCarsten Otte { "exit_instruction", VCPU_STAT(exit_instruction) }, 54ba5c1e9bSCarsten Otte { "exit_program_interruption", VCPU_STAT(exit_program_interruption) }, 55ba5c1e9bSCarsten Otte { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) }, 56f7819512SPaolo Bonzini { "halt_successful_poll", VCPU_STAT(halt_successful_poll) }, 57ce2e4f0bSDavid Hildenbrand { "halt_wakeup", VCPU_STAT(halt_wakeup) }, 58f5e10b09SChristian Borntraeger { "instruction_lctlg", VCPU_STAT(instruction_lctlg) }, 59ba5c1e9bSCarsten Otte { "instruction_lctl", VCPU_STAT(instruction_lctl) }, 60aba07508SDavid Hildenbrand { "instruction_stctl", VCPU_STAT(instruction_stctl) }, 61aba07508SDavid Hildenbrand { "instruction_stctg", VCPU_STAT(instruction_stctg) }, 62ba5c1e9bSCarsten Otte { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) }, 637697e71fSChristian Ehrhardt { "deliver_external_call", VCPU_STAT(deliver_external_call) }, 64ba5c1e9bSCarsten Otte { "deliver_service_signal", VCPU_STAT(deliver_service_signal) }, 65ba5c1e9bSCarsten Otte { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) }, 66ba5c1e9bSCarsten Otte { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) }, 67ba5c1e9bSCarsten Otte { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) }, 68ba5c1e9bSCarsten Otte { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) }, 69ba5c1e9bSCarsten Otte { "deliver_program_interruption", VCPU_STAT(deliver_program_int) }, 70ba5c1e9bSCarsten Otte { "exit_wait_state", VCPU_STAT(exit_wait_state) }, 7169d0d3a3SChristian Borntraeger { "instruction_pfmf", VCPU_STAT(instruction_pfmf) }, 72453423dcSChristian Borntraeger { "instruction_stidp", VCPU_STAT(instruction_stidp) }, 73453423dcSChristian Borntraeger { "instruction_spx", VCPU_STAT(instruction_spx) }, 74453423dcSChristian Borntraeger { "instruction_stpx", VCPU_STAT(instruction_stpx) }, 75453423dcSChristian Borntraeger { "instruction_stap", VCPU_STAT(instruction_stap) }, 76453423dcSChristian Borntraeger { "instruction_storage_key", VCPU_STAT(instruction_storage_key) }, 778a242234SHeiko Carstens { "instruction_ipte_interlock", VCPU_STAT(instruction_ipte_interlock) }, 78453423dcSChristian Borntraeger { "instruction_stsch", VCPU_STAT(instruction_stsch) }, 79453423dcSChristian Borntraeger { "instruction_chsc", VCPU_STAT(instruction_chsc) }, 80b31288faSKonstantin Weitz { "instruction_essa", VCPU_STAT(instruction_essa) }, 81453423dcSChristian Borntraeger { "instruction_stsi", VCPU_STAT(instruction_stsi) }, 82453423dcSChristian Borntraeger { "instruction_stfl", VCPU_STAT(instruction_stfl) }, 83bb25b9baSChristian Borntraeger { "instruction_tprot", VCPU_STAT(instruction_tprot) }, 845288fbf0SChristian Borntraeger { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) }, 85bd59d3a4SCornelia Huck { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) }, 867697e71fSChristian Ehrhardt { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) }, 875288fbf0SChristian Borntraeger { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) }, 8842cb0c9fSDavid Hildenbrand { "instruction_sigp_cond_emergency", VCPU_STAT(instruction_sigp_cond_emergency) }, 8942cb0c9fSDavid Hildenbrand { "instruction_sigp_start", VCPU_STAT(instruction_sigp_start) }, 905288fbf0SChristian Borntraeger { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) }, 9142cb0c9fSDavid Hildenbrand { "instruction_sigp_stop_store_status", VCPU_STAT(instruction_sigp_stop_store_status) }, 9242cb0c9fSDavid Hildenbrand { "instruction_sigp_store_status", VCPU_STAT(instruction_sigp_store_status) }, 93cd7b4b61SEric Farman { "instruction_sigp_store_adtl_status", VCPU_STAT(instruction_sigp_store_adtl_status) }, 945288fbf0SChristian Borntraeger { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) }, 955288fbf0SChristian Borntraeger { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) }, 965288fbf0SChristian Borntraeger { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) }, 9742cb0c9fSDavid Hildenbrand { "instruction_sigp_cpu_reset", VCPU_STAT(instruction_sigp_cpu_reset) }, 9842cb0c9fSDavid Hildenbrand { "instruction_sigp_init_cpu_reset", VCPU_STAT(instruction_sigp_init_cpu_reset) }, 9942cb0c9fSDavid Hildenbrand { "instruction_sigp_unknown", VCPU_STAT(instruction_sigp_unknown) }, 100388186bcSChristian Borntraeger { "diagnose_10", VCPU_STAT(diagnose_10) }, 101e28acfeaSChristian Borntraeger { "diagnose_44", VCPU_STAT(diagnose_44) }, 10241628d33SKonstantin Weitz { "diagnose_9c", VCPU_STAT(diagnose_9c) }, 103b0c632dbSHeiko Carstens { NULL } 104b0c632dbSHeiko Carstens }; 105b0c632dbSHeiko Carstens 1069d8d5786SMichael Mueller /* upper facilities limit for kvm */ 1079d8d5786SMichael Mueller unsigned long kvm_s390_fac_list_mask[] = { 1089d8d5786SMichael Mueller 0xff82fffbf4fc2000UL, 1099d8d5786SMichael Mueller 0x005c000000000000UL, 11013211ea7SEric Farman 0x4000000000000000UL, 1119d8d5786SMichael Mueller }; 112b0c632dbSHeiko Carstens 1139d8d5786SMichael Mueller unsigned long kvm_s390_fac_list_mask_size(void) 11478c4b59fSMichael Mueller { 1159d8d5786SMichael Mueller BUILD_BUG_ON(ARRAY_SIZE(kvm_s390_fac_list_mask) > S390_ARCH_FAC_MASK_SIZE_U64); 1169d8d5786SMichael Mueller return ARRAY_SIZE(kvm_s390_fac_list_mask); 11778c4b59fSMichael Mueller } 11878c4b59fSMichael Mueller 1199d8d5786SMichael Mueller static struct gmap_notifier gmap_notifier; 1209d8d5786SMichael Mueller 121b0c632dbSHeiko Carstens /* Section: not file related */ 12213a34e06SRadim Krčmář int kvm_arch_hardware_enable(void) 123b0c632dbSHeiko Carstens { 124b0c632dbSHeiko Carstens /* every s390 is virtualization enabled ;-) */ 12510474ae8SAlexander Graf return 0; 126b0c632dbSHeiko Carstens } 127b0c632dbSHeiko Carstens 1282c70fe44SChristian Borntraeger static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address); 1292c70fe44SChristian Borntraeger 130b0c632dbSHeiko Carstens int kvm_arch_hardware_setup(void) 131b0c632dbSHeiko Carstens { 1322c70fe44SChristian Borntraeger gmap_notifier.notifier_call = kvm_gmap_notifier; 1332c70fe44SChristian Borntraeger gmap_register_ipte_notifier(&gmap_notifier); 134b0c632dbSHeiko Carstens return 0; 135b0c632dbSHeiko Carstens } 136b0c632dbSHeiko Carstens 137b0c632dbSHeiko Carstens void kvm_arch_hardware_unsetup(void) 138b0c632dbSHeiko Carstens { 1392c70fe44SChristian Borntraeger gmap_unregister_ipte_notifier(&gmap_notifier); 140b0c632dbSHeiko Carstens } 141b0c632dbSHeiko Carstens 142b0c632dbSHeiko Carstens int kvm_arch_init(void *opaque) 143b0c632dbSHeiko Carstens { 14484877d93SCornelia Huck /* Register floating interrupt controller interface. */ 14584877d93SCornelia Huck return kvm_register_device_ops(&kvm_flic_ops, KVM_DEV_TYPE_FLIC); 146b0c632dbSHeiko Carstens } 147b0c632dbSHeiko Carstens 148b0c632dbSHeiko Carstens /* Section: device related */ 149b0c632dbSHeiko Carstens long kvm_arch_dev_ioctl(struct file *filp, 150b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 151b0c632dbSHeiko Carstens { 152b0c632dbSHeiko Carstens if (ioctl == KVM_S390_ENABLE_SIE) 153b0c632dbSHeiko Carstens return s390_enable_sie(); 154b0c632dbSHeiko Carstens return -EINVAL; 155b0c632dbSHeiko Carstens } 156b0c632dbSHeiko Carstens 157784aa3d7SAlexander Graf int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) 158b0c632dbSHeiko Carstens { 159d7b0b5ebSCarsten Otte int r; 160d7b0b5ebSCarsten Otte 1612bd0ac4eSCarsten Otte switch (ext) { 162d7b0b5ebSCarsten Otte case KVM_CAP_S390_PSW: 163b6cf8788SChristian Borntraeger case KVM_CAP_S390_GMAP: 16452e16b18SChristian Borntraeger case KVM_CAP_SYNC_MMU: 1651efd0f59SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 1661efd0f59SCarsten Otte case KVM_CAP_S390_UCONTROL: 1671efd0f59SCarsten Otte #endif 1683c038e6bSDominik Dingel case KVM_CAP_ASYNC_PF: 16960b413c9SChristian Borntraeger case KVM_CAP_SYNC_REGS: 17014eebd91SCarsten Otte case KVM_CAP_ONE_REG: 171d6712df9SCornelia Huck case KVM_CAP_ENABLE_CAP: 172fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 173ebc32262SCornelia Huck case KVM_CAP_IRQFD: 17410ccaa1eSCornelia Huck case KVM_CAP_IOEVENTFD: 175c05c4186SJens Freimann case KVM_CAP_DEVICE_CTRL: 176d938dc55SCornelia Huck case KVM_CAP_ENABLE_CAP_VM: 17778599d90SCornelia Huck case KVM_CAP_S390_IRQCHIP: 178f2061656SDominik Dingel case KVM_CAP_VM_ATTRIBUTES: 1796352e4d2SDavid Hildenbrand case KVM_CAP_MP_STATE: 1802444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 181e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 182*30ee2a98SJason J. Herne case KVM_CAP_S390_SKEYS: 183d7b0b5ebSCarsten Otte r = 1; 184d7b0b5ebSCarsten Otte break; 18541408c28SThomas Huth case KVM_CAP_S390_MEM_OP: 18641408c28SThomas Huth r = MEM_OP_MAX_SIZE; 18741408c28SThomas Huth break; 188e726b1bdSChristian Borntraeger case KVM_CAP_NR_VCPUS: 189e726b1bdSChristian Borntraeger case KVM_CAP_MAX_VCPUS: 190e726b1bdSChristian Borntraeger r = KVM_MAX_VCPUS; 191e726b1bdSChristian Borntraeger break; 192e1e2e605SNick Wang case KVM_CAP_NR_MEMSLOTS: 193e1e2e605SNick Wang r = KVM_USER_MEM_SLOTS; 194e1e2e605SNick Wang break; 1951526bf9cSChristian Borntraeger case KVM_CAP_S390_COW: 196abf09bedSMartin Schwidefsky r = MACHINE_HAS_ESOP; 1971526bf9cSChristian Borntraeger break; 19868c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 19968c55750SEric Farman r = MACHINE_HAS_VX; 20068c55750SEric Farman break; 2012bd0ac4eSCarsten Otte default: 202d7b0b5ebSCarsten Otte r = 0; 203b0c632dbSHeiko Carstens } 204d7b0b5ebSCarsten Otte return r; 2052bd0ac4eSCarsten Otte } 206b0c632dbSHeiko Carstens 20715f36ebdSJason J. Herne static void kvm_s390_sync_dirty_log(struct kvm *kvm, 20815f36ebdSJason J. Herne struct kvm_memory_slot *memslot) 20915f36ebdSJason J. Herne { 21015f36ebdSJason J. Herne gfn_t cur_gfn, last_gfn; 21115f36ebdSJason J. Herne unsigned long address; 21215f36ebdSJason J. Herne struct gmap *gmap = kvm->arch.gmap; 21315f36ebdSJason J. Herne 21415f36ebdSJason J. Herne down_read(&gmap->mm->mmap_sem); 21515f36ebdSJason J. Herne /* Loop over all guest pages */ 21615f36ebdSJason J. Herne last_gfn = memslot->base_gfn + memslot->npages; 21715f36ebdSJason J. Herne for (cur_gfn = memslot->base_gfn; cur_gfn <= last_gfn; cur_gfn++) { 21815f36ebdSJason J. Herne address = gfn_to_hva_memslot(memslot, cur_gfn); 21915f36ebdSJason J. Herne 22015f36ebdSJason J. Herne if (gmap_test_and_clear_dirty(address, gmap)) 22115f36ebdSJason J. Herne mark_page_dirty(kvm, cur_gfn); 22215f36ebdSJason J. Herne } 22315f36ebdSJason J. Herne up_read(&gmap->mm->mmap_sem); 22415f36ebdSJason J. Herne } 22515f36ebdSJason J. Herne 226b0c632dbSHeiko Carstens /* Section: vm related */ 227b0c632dbSHeiko Carstens /* 228b0c632dbSHeiko Carstens * Get (and clear) the dirty memory log for a memory slot. 229b0c632dbSHeiko Carstens */ 230b0c632dbSHeiko Carstens int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, 231b0c632dbSHeiko Carstens struct kvm_dirty_log *log) 232b0c632dbSHeiko Carstens { 23315f36ebdSJason J. Herne int r; 23415f36ebdSJason J. Herne unsigned long n; 23515f36ebdSJason J. Herne struct kvm_memory_slot *memslot; 23615f36ebdSJason J. Herne int is_dirty = 0; 23715f36ebdSJason J. Herne 23815f36ebdSJason J. Herne mutex_lock(&kvm->slots_lock); 23915f36ebdSJason J. Herne 24015f36ebdSJason J. Herne r = -EINVAL; 24115f36ebdSJason J. Herne if (log->slot >= KVM_USER_MEM_SLOTS) 24215f36ebdSJason J. Herne goto out; 24315f36ebdSJason J. Herne 24415f36ebdSJason J. Herne memslot = id_to_memslot(kvm->memslots, log->slot); 24515f36ebdSJason J. Herne r = -ENOENT; 24615f36ebdSJason J. Herne if (!memslot->dirty_bitmap) 24715f36ebdSJason J. Herne goto out; 24815f36ebdSJason J. Herne 24915f36ebdSJason J. Herne kvm_s390_sync_dirty_log(kvm, memslot); 25015f36ebdSJason J. Herne r = kvm_get_dirty_log(kvm, log, &is_dirty); 25115f36ebdSJason J. Herne if (r) 25215f36ebdSJason J. Herne goto out; 25315f36ebdSJason J. Herne 25415f36ebdSJason J. Herne /* Clear the dirty log */ 25515f36ebdSJason J. Herne if (is_dirty) { 25615f36ebdSJason J. Herne n = kvm_dirty_bitmap_bytes(memslot); 25715f36ebdSJason J. Herne memset(memslot->dirty_bitmap, 0, n); 25815f36ebdSJason J. Herne } 25915f36ebdSJason J. Herne r = 0; 26015f36ebdSJason J. Herne out: 26115f36ebdSJason J. Herne mutex_unlock(&kvm->slots_lock); 26215f36ebdSJason J. Herne return r; 263b0c632dbSHeiko Carstens } 264b0c632dbSHeiko Carstens 265d938dc55SCornelia Huck static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap) 266d938dc55SCornelia Huck { 267d938dc55SCornelia Huck int r; 268d938dc55SCornelia Huck 269d938dc55SCornelia Huck if (cap->flags) 270d938dc55SCornelia Huck return -EINVAL; 271d938dc55SCornelia Huck 272d938dc55SCornelia Huck switch (cap->cap) { 27384223598SCornelia Huck case KVM_CAP_S390_IRQCHIP: 27484223598SCornelia Huck kvm->arch.use_irqchip = 1; 27584223598SCornelia Huck r = 0; 27684223598SCornelia Huck break; 2772444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 2782444b352SDavid Hildenbrand kvm->arch.user_sigp = 1; 2792444b352SDavid Hildenbrand r = 0; 2802444b352SDavid Hildenbrand break; 28168c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 28268c55750SEric Farman kvm->arch.use_vectors = MACHINE_HAS_VX; 28368c55750SEric Farman r = MACHINE_HAS_VX ? 0 : -EINVAL; 28468c55750SEric Farman break; 285e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 286e44fc8c9SEkaterina Tumanova kvm->arch.user_stsi = 1; 287e44fc8c9SEkaterina Tumanova r = 0; 288e44fc8c9SEkaterina Tumanova break; 289d938dc55SCornelia Huck default: 290d938dc55SCornelia Huck r = -EINVAL; 291d938dc55SCornelia Huck break; 292d938dc55SCornelia Huck } 293d938dc55SCornelia Huck return r; 294d938dc55SCornelia Huck } 295d938dc55SCornelia Huck 2968c0a7ce6SDominik Dingel static int kvm_s390_get_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 2978c0a7ce6SDominik Dingel { 2988c0a7ce6SDominik Dingel int ret; 2998c0a7ce6SDominik Dingel 3008c0a7ce6SDominik Dingel switch (attr->attr) { 3018c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 3028c0a7ce6SDominik Dingel ret = 0; 3038c0a7ce6SDominik Dingel if (put_user(kvm->arch.gmap->asce_end, (u64 __user *)attr->addr)) 3048c0a7ce6SDominik Dingel ret = -EFAULT; 3058c0a7ce6SDominik Dingel break; 3068c0a7ce6SDominik Dingel default: 3078c0a7ce6SDominik Dingel ret = -ENXIO; 3088c0a7ce6SDominik Dingel break; 3098c0a7ce6SDominik Dingel } 3108c0a7ce6SDominik Dingel return ret; 3118c0a7ce6SDominik Dingel } 3128c0a7ce6SDominik Dingel 3138c0a7ce6SDominik Dingel static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 3144f718eabSDominik Dingel { 3154f718eabSDominik Dingel int ret; 3164f718eabSDominik Dingel unsigned int idx; 3174f718eabSDominik Dingel switch (attr->attr) { 3184f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 3194f718eabSDominik Dingel ret = -EBUSY; 3204f718eabSDominik Dingel mutex_lock(&kvm->lock); 3214f718eabSDominik Dingel if (atomic_read(&kvm->online_vcpus) == 0) { 3224f718eabSDominik Dingel kvm->arch.use_cmma = 1; 3234f718eabSDominik Dingel ret = 0; 3244f718eabSDominik Dingel } 3254f718eabSDominik Dingel mutex_unlock(&kvm->lock); 3264f718eabSDominik Dingel break; 3274f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 3284f718eabSDominik Dingel mutex_lock(&kvm->lock); 3294f718eabSDominik Dingel idx = srcu_read_lock(&kvm->srcu); 330a13cff31SDominik Dingel s390_reset_cmma(kvm->arch.gmap->mm); 3314f718eabSDominik Dingel srcu_read_unlock(&kvm->srcu, idx); 3324f718eabSDominik Dingel mutex_unlock(&kvm->lock); 3334f718eabSDominik Dingel ret = 0; 3344f718eabSDominik Dingel break; 3358c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: { 3368c0a7ce6SDominik Dingel unsigned long new_limit; 3378c0a7ce6SDominik Dingel 3388c0a7ce6SDominik Dingel if (kvm_is_ucontrol(kvm)) 3398c0a7ce6SDominik Dingel return -EINVAL; 3408c0a7ce6SDominik Dingel 3418c0a7ce6SDominik Dingel if (get_user(new_limit, (u64 __user *)attr->addr)) 3428c0a7ce6SDominik Dingel return -EFAULT; 3438c0a7ce6SDominik Dingel 3448c0a7ce6SDominik Dingel if (new_limit > kvm->arch.gmap->asce_end) 3458c0a7ce6SDominik Dingel return -E2BIG; 3468c0a7ce6SDominik Dingel 3478c0a7ce6SDominik Dingel ret = -EBUSY; 3488c0a7ce6SDominik Dingel mutex_lock(&kvm->lock); 3498c0a7ce6SDominik Dingel if (atomic_read(&kvm->online_vcpus) == 0) { 3508c0a7ce6SDominik Dingel /* gmap_alloc will round the limit up */ 3518c0a7ce6SDominik Dingel struct gmap *new = gmap_alloc(current->mm, new_limit); 3528c0a7ce6SDominik Dingel 3538c0a7ce6SDominik Dingel if (!new) { 3548c0a7ce6SDominik Dingel ret = -ENOMEM; 3558c0a7ce6SDominik Dingel } else { 3568c0a7ce6SDominik Dingel gmap_free(kvm->arch.gmap); 3578c0a7ce6SDominik Dingel new->private = kvm; 3588c0a7ce6SDominik Dingel kvm->arch.gmap = new; 3598c0a7ce6SDominik Dingel ret = 0; 3608c0a7ce6SDominik Dingel } 3618c0a7ce6SDominik Dingel } 3628c0a7ce6SDominik Dingel mutex_unlock(&kvm->lock); 3638c0a7ce6SDominik Dingel break; 3648c0a7ce6SDominik Dingel } 3654f718eabSDominik Dingel default: 3664f718eabSDominik Dingel ret = -ENXIO; 3674f718eabSDominik Dingel break; 3684f718eabSDominik Dingel } 3694f718eabSDominik Dingel return ret; 3704f718eabSDominik Dingel } 3714f718eabSDominik Dingel 372a374e892STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu); 373a374e892STony Krowiak 374a374e892STony Krowiak static int kvm_s390_vm_set_crypto(struct kvm *kvm, struct kvm_device_attr *attr) 375a374e892STony Krowiak { 376a374e892STony Krowiak struct kvm_vcpu *vcpu; 377a374e892STony Krowiak int i; 378a374e892STony Krowiak 3799d8d5786SMichael Mueller if (!test_kvm_facility(kvm, 76)) 380a374e892STony Krowiak return -EINVAL; 381a374e892STony Krowiak 382a374e892STony Krowiak mutex_lock(&kvm->lock); 383a374e892STony Krowiak switch (attr->attr) { 384a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 385a374e892STony Krowiak get_random_bytes( 386a374e892STony Krowiak kvm->arch.crypto.crycb->aes_wrapping_key_mask, 387a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 388a374e892STony Krowiak kvm->arch.crypto.aes_kw = 1; 389a374e892STony Krowiak break; 390a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 391a374e892STony Krowiak get_random_bytes( 392a374e892STony Krowiak kvm->arch.crypto.crycb->dea_wrapping_key_mask, 393a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 394a374e892STony Krowiak kvm->arch.crypto.dea_kw = 1; 395a374e892STony Krowiak break; 396a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 397a374e892STony Krowiak kvm->arch.crypto.aes_kw = 0; 398a374e892STony Krowiak memset(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 0, 399a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 400a374e892STony Krowiak break; 401a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 402a374e892STony Krowiak kvm->arch.crypto.dea_kw = 0; 403a374e892STony Krowiak memset(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 0, 404a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 405a374e892STony Krowiak break; 406a374e892STony Krowiak default: 407a374e892STony Krowiak mutex_unlock(&kvm->lock); 408a374e892STony Krowiak return -ENXIO; 409a374e892STony Krowiak } 410a374e892STony Krowiak 411a374e892STony Krowiak kvm_for_each_vcpu(i, vcpu, kvm) { 412a374e892STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 413a374e892STony Krowiak exit_sie(vcpu); 414a374e892STony Krowiak } 415a374e892STony Krowiak mutex_unlock(&kvm->lock); 416a374e892STony Krowiak return 0; 417a374e892STony Krowiak } 418a374e892STony Krowiak 41972f25020SJason J. Herne static int kvm_s390_set_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 42072f25020SJason J. Herne { 42172f25020SJason J. Herne u8 gtod_high; 42272f25020SJason J. Herne 42372f25020SJason J. Herne if (copy_from_user(>od_high, (void __user *)attr->addr, 42472f25020SJason J. Herne sizeof(gtod_high))) 42572f25020SJason J. Herne return -EFAULT; 42672f25020SJason J. Herne 42772f25020SJason J. Herne if (gtod_high != 0) 42872f25020SJason J. Herne return -EINVAL; 42972f25020SJason J. Herne 43072f25020SJason J. Herne return 0; 43172f25020SJason J. Herne } 43272f25020SJason J. Herne 43372f25020SJason J. Herne static int kvm_s390_set_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 43472f25020SJason J. Herne { 43572f25020SJason J. Herne struct kvm_vcpu *cur_vcpu; 43672f25020SJason J. Herne unsigned int vcpu_idx; 43772f25020SJason J. Herne u64 host_tod, gtod; 43872f25020SJason J. Herne int r; 43972f25020SJason J. Herne 44072f25020SJason J. Herne if (copy_from_user(>od, (void __user *)attr->addr, sizeof(gtod))) 44172f25020SJason J. Herne return -EFAULT; 44272f25020SJason J. Herne 44372f25020SJason J. Herne r = store_tod_clock(&host_tod); 44472f25020SJason J. Herne if (r) 44572f25020SJason J. Herne return r; 44672f25020SJason J. Herne 44772f25020SJason J. Herne mutex_lock(&kvm->lock); 44872f25020SJason J. Herne kvm->arch.epoch = gtod - host_tod; 44972f25020SJason J. Herne kvm_for_each_vcpu(vcpu_idx, cur_vcpu, kvm) { 45072f25020SJason J. Herne cur_vcpu->arch.sie_block->epoch = kvm->arch.epoch; 45172f25020SJason J. Herne exit_sie(cur_vcpu); 45272f25020SJason J. Herne } 45372f25020SJason J. Herne mutex_unlock(&kvm->lock); 45472f25020SJason J. Herne return 0; 45572f25020SJason J. Herne } 45672f25020SJason J. Herne 45772f25020SJason J. Herne static int kvm_s390_set_tod(struct kvm *kvm, struct kvm_device_attr *attr) 45872f25020SJason J. Herne { 45972f25020SJason J. Herne int ret; 46072f25020SJason J. Herne 46172f25020SJason J. Herne if (attr->flags) 46272f25020SJason J. Herne return -EINVAL; 46372f25020SJason J. Herne 46472f25020SJason J. Herne switch (attr->attr) { 46572f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 46672f25020SJason J. Herne ret = kvm_s390_set_tod_high(kvm, attr); 46772f25020SJason J. Herne break; 46872f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 46972f25020SJason J. Herne ret = kvm_s390_set_tod_low(kvm, attr); 47072f25020SJason J. Herne break; 47172f25020SJason J. Herne default: 47272f25020SJason J. Herne ret = -ENXIO; 47372f25020SJason J. Herne break; 47472f25020SJason J. Herne } 47572f25020SJason J. Herne return ret; 47672f25020SJason J. Herne } 47772f25020SJason J. Herne 47872f25020SJason J. Herne static int kvm_s390_get_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 47972f25020SJason J. Herne { 48072f25020SJason J. Herne u8 gtod_high = 0; 48172f25020SJason J. Herne 48272f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od_high, 48372f25020SJason J. Herne sizeof(gtod_high))) 48472f25020SJason J. Herne return -EFAULT; 48572f25020SJason J. Herne 48672f25020SJason J. Herne return 0; 48772f25020SJason J. Herne } 48872f25020SJason J. Herne 48972f25020SJason J. Herne static int kvm_s390_get_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 49072f25020SJason J. Herne { 49172f25020SJason J. Herne u64 host_tod, gtod; 49272f25020SJason J. Herne int r; 49372f25020SJason J. Herne 49472f25020SJason J. Herne r = store_tod_clock(&host_tod); 49572f25020SJason J. Herne if (r) 49672f25020SJason J. Herne return r; 49772f25020SJason J. Herne 49872f25020SJason J. Herne gtod = host_tod + kvm->arch.epoch; 49972f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od, sizeof(gtod))) 50072f25020SJason J. Herne return -EFAULT; 50172f25020SJason J. Herne 50272f25020SJason J. Herne return 0; 50372f25020SJason J. Herne } 50472f25020SJason J. Herne 50572f25020SJason J. Herne static int kvm_s390_get_tod(struct kvm *kvm, struct kvm_device_attr *attr) 50672f25020SJason J. Herne { 50772f25020SJason J. Herne int ret; 50872f25020SJason J. Herne 50972f25020SJason J. Herne if (attr->flags) 51072f25020SJason J. Herne return -EINVAL; 51172f25020SJason J. Herne 51272f25020SJason J. Herne switch (attr->attr) { 51372f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 51472f25020SJason J. Herne ret = kvm_s390_get_tod_high(kvm, attr); 51572f25020SJason J. Herne break; 51672f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 51772f25020SJason J. Herne ret = kvm_s390_get_tod_low(kvm, attr); 51872f25020SJason J. Herne break; 51972f25020SJason J. Herne default: 52072f25020SJason J. Herne ret = -ENXIO; 52172f25020SJason J. Herne break; 52272f25020SJason J. Herne } 52372f25020SJason J. Herne return ret; 52472f25020SJason J. Herne } 52572f25020SJason J. Herne 526658b6edaSMichael Mueller static int kvm_s390_set_processor(struct kvm *kvm, struct kvm_device_attr *attr) 527658b6edaSMichael Mueller { 528658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 529658b6edaSMichael Mueller int ret = 0; 530658b6edaSMichael Mueller 531658b6edaSMichael Mueller mutex_lock(&kvm->lock); 532658b6edaSMichael Mueller if (atomic_read(&kvm->online_vcpus)) { 533658b6edaSMichael Mueller ret = -EBUSY; 534658b6edaSMichael Mueller goto out; 535658b6edaSMichael Mueller } 536658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 537658b6edaSMichael Mueller if (!proc) { 538658b6edaSMichael Mueller ret = -ENOMEM; 539658b6edaSMichael Mueller goto out; 540658b6edaSMichael Mueller } 541658b6edaSMichael Mueller if (!copy_from_user(proc, (void __user *)attr->addr, 542658b6edaSMichael Mueller sizeof(*proc))) { 543658b6edaSMichael Mueller memcpy(&kvm->arch.model.cpu_id, &proc->cpuid, 544658b6edaSMichael Mueller sizeof(struct cpuid)); 545658b6edaSMichael Mueller kvm->arch.model.ibc = proc->ibc; 546981467c9SMichael Mueller memcpy(kvm->arch.model.fac->list, proc->fac_list, 547658b6edaSMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 548658b6edaSMichael Mueller } else 549658b6edaSMichael Mueller ret = -EFAULT; 550658b6edaSMichael Mueller kfree(proc); 551658b6edaSMichael Mueller out: 552658b6edaSMichael Mueller mutex_unlock(&kvm->lock); 553658b6edaSMichael Mueller return ret; 554658b6edaSMichael Mueller } 555658b6edaSMichael Mueller 556658b6edaSMichael Mueller static int kvm_s390_set_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 557658b6edaSMichael Mueller { 558658b6edaSMichael Mueller int ret = -ENXIO; 559658b6edaSMichael Mueller 560658b6edaSMichael Mueller switch (attr->attr) { 561658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 562658b6edaSMichael Mueller ret = kvm_s390_set_processor(kvm, attr); 563658b6edaSMichael Mueller break; 564658b6edaSMichael Mueller } 565658b6edaSMichael Mueller return ret; 566658b6edaSMichael Mueller } 567658b6edaSMichael Mueller 568658b6edaSMichael Mueller static int kvm_s390_get_processor(struct kvm *kvm, struct kvm_device_attr *attr) 569658b6edaSMichael Mueller { 570658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 571658b6edaSMichael Mueller int ret = 0; 572658b6edaSMichael Mueller 573658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 574658b6edaSMichael Mueller if (!proc) { 575658b6edaSMichael Mueller ret = -ENOMEM; 576658b6edaSMichael Mueller goto out; 577658b6edaSMichael Mueller } 578658b6edaSMichael Mueller memcpy(&proc->cpuid, &kvm->arch.model.cpu_id, sizeof(struct cpuid)); 579658b6edaSMichael Mueller proc->ibc = kvm->arch.model.ibc; 580981467c9SMichael Mueller memcpy(&proc->fac_list, kvm->arch.model.fac->list, S390_ARCH_FAC_LIST_SIZE_BYTE); 581658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, proc, sizeof(*proc))) 582658b6edaSMichael Mueller ret = -EFAULT; 583658b6edaSMichael Mueller kfree(proc); 584658b6edaSMichael Mueller out: 585658b6edaSMichael Mueller return ret; 586658b6edaSMichael Mueller } 587658b6edaSMichael Mueller 588658b6edaSMichael Mueller static int kvm_s390_get_machine(struct kvm *kvm, struct kvm_device_attr *attr) 589658b6edaSMichael Mueller { 590658b6edaSMichael Mueller struct kvm_s390_vm_cpu_machine *mach; 591658b6edaSMichael Mueller int ret = 0; 592658b6edaSMichael Mueller 593658b6edaSMichael Mueller mach = kzalloc(sizeof(*mach), GFP_KERNEL); 594658b6edaSMichael Mueller if (!mach) { 595658b6edaSMichael Mueller ret = -ENOMEM; 596658b6edaSMichael Mueller goto out; 597658b6edaSMichael Mueller } 598658b6edaSMichael Mueller get_cpu_id((struct cpuid *) &mach->cpuid); 599658b6edaSMichael Mueller mach->ibc = sclp_get_ibc(); 600981467c9SMichael Mueller memcpy(&mach->fac_mask, kvm->arch.model.fac->mask, 601981467c9SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 602658b6edaSMichael Mueller memcpy((unsigned long *)&mach->fac_list, S390_lowcore.stfle_fac_list, 60394422ee8SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 604658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, mach, sizeof(*mach))) 605658b6edaSMichael Mueller ret = -EFAULT; 606658b6edaSMichael Mueller kfree(mach); 607658b6edaSMichael Mueller out: 608658b6edaSMichael Mueller return ret; 609658b6edaSMichael Mueller } 610658b6edaSMichael Mueller 611658b6edaSMichael Mueller static int kvm_s390_get_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 612658b6edaSMichael Mueller { 613658b6edaSMichael Mueller int ret = -ENXIO; 614658b6edaSMichael Mueller 615658b6edaSMichael Mueller switch (attr->attr) { 616658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 617658b6edaSMichael Mueller ret = kvm_s390_get_processor(kvm, attr); 618658b6edaSMichael Mueller break; 619658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 620658b6edaSMichael Mueller ret = kvm_s390_get_machine(kvm, attr); 621658b6edaSMichael Mueller break; 622658b6edaSMichael Mueller } 623658b6edaSMichael Mueller return ret; 624658b6edaSMichael Mueller } 625658b6edaSMichael Mueller 626f2061656SDominik Dingel static int kvm_s390_vm_set_attr(struct kvm *kvm, struct kvm_device_attr *attr) 627f2061656SDominik Dingel { 628f2061656SDominik Dingel int ret; 629f2061656SDominik Dingel 630f2061656SDominik Dingel switch (attr->group) { 6314f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 6328c0a7ce6SDominik Dingel ret = kvm_s390_set_mem_control(kvm, attr); 6334f718eabSDominik Dingel break; 63472f25020SJason J. Herne case KVM_S390_VM_TOD: 63572f25020SJason J. Herne ret = kvm_s390_set_tod(kvm, attr); 63672f25020SJason J. Herne break; 637658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 638658b6edaSMichael Mueller ret = kvm_s390_set_cpu_model(kvm, attr); 639658b6edaSMichael Mueller break; 640a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 641a374e892STony Krowiak ret = kvm_s390_vm_set_crypto(kvm, attr); 642a374e892STony Krowiak break; 643f2061656SDominik Dingel default: 644f2061656SDominik Dingel ret = -ENXIO; 645f2061656SDominik Dingel break; 646f2061656SDominik Dingel } 647f2061656SDominik Dingel 648f2061656SDominik Dingel return ret; 649f2061656SDominik Dingel } 650f2061656SDominik Dingel 651f2061656SDominik Dingel static int kvm_s390_vm_get_attr(struct kvm *kvm, struct kvm_device_attr *attr) 652f2061656SDominik Dingel { 6538c0a7ce6SDominik Dingel int ret; 6548c0a7ce6SDominik Dingel 6558c0a7ce6SDominik Dingel switch (attr->group) { 6568c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_CTRL: 6578c0a7ce6SDominik Dingel ret = kvm_s390_get_mem_control(kvm, attr); 6588c0a7ce6SDominik Dingel break; 65972f25020SJason J. Herne case KVM_S390_VM_TOD: 66072f25020SJason J. Herne ret = kvm_s390_get_tod(kvm, attr); 66172f25020SJason J. Herne break; 662658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 663658b6edaSMichael Mueller ret = kvm_s390_get_cpu_model(kvm, attr); 664658b6edaSMichael Mueller break; 6658c0a7ce6SDominik Dingel default: 6668c0a7ce6SDominik Dingel ret = -ENXIO; 6678c0a7ce6SDominik Dingel break; 6688c0a7ce6SDominik Dingel } 6698c0a7ce6SDominik Dingel 6708c0a7ce6SDominik Dingel return ret; 671f2061656SDominik Dingel } 672f2061656SDominik Dingel 673f2061656SDominik Dingel static int kvm_s390_vm_has_attr(struct kvm *kvm, struct kvm_device_attr *attr) 674f2061656SDominik Dingel { 675f2061656SDominik Dingel int ret; 676f2061656SDominik Dingel 677f2061656SDominik Dingel switch (attr->group) { 6784f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 6794f718eabSDominik Dingel switch (attr->attr) { 6804f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 6814f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 6828c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 6834f718eabSDominik Dingel ret = 0; 6844f718eabSDominik Dingel break; 6854f718eabSDominik Dingel default: 6864f718eabSDominik Dingel ret = -ENXIO; 6874f718eabSDominik Dingel break; 6884f718eabSDominik Dingel } 6894f718eabSDominik Dingel break; 69072f25020SJason J. Herne case KVM_S390_VM_TOD: 69172f25020SJason J. Herne switch (attr->attr) { 69272f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 69372f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 69472f25020SJason J. Herne ret = 0; 69572f25020SJason J. Herne break; 69672f25020SJason J. Herne default: 69772f25020SJason J. Herne ret = -ENXIO; 69872f25020SJason J. Herne break; 69972f25020SJason J. Herne } 70072f25020SJason J. Herne break; 701658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 702658b6edaSMichael Mueller switch (attr->attr) { 703658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 704658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 705658b6edaSMichael Mueller ret = 0; 706658b6edaSMichael Mueller break; 707658b6edaSMichael Mueller default: 708658b6edaSMichael Mueller ret = -ENXIO; 709658b6edaSMichael Mueller break; 710658b6edaSMichael Mueller } 711658b6edaSMichael Mueller break; 712a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 713a374e892STony Krowiak switch (attr->attr) { 714a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 715a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 716a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 717a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 718a374e892STony Krowiak ret = 0; 719a374e892STony Krowiak break; 720a374e892STony Krowiak default: 721a374e892STony Krowiak ret = -ENXIO; 722a374e892STony Krowiak break; 723a374e892STony Krowiak } 724a374e892STony Krowiak break; 725f2061656SDominik Dingel default: 726f2061656SDominik Dingel ret = -ENXIO; 727f2061656SDominik Dingel break; 728f2061656SDominik Dingel } 729f2061656SDominik Dingel 730f2061656SDominik Dingel return ret; 731f2061656SDominik Dingel } 732f2061656SDominik Dingel 733*30ee2a98SJason J. Herne static long kvm_s390_get_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 734*30ee2a98SJason J. Herne { 735*30ee2a98SJason J. Herne uint8_t *keys; 736*30ee2a98SJason J. Herne uint64_t hva; 737*30ee2a98SJason J. Herne unsigned long curkey; 738*30ee2a98SJason J. Herne int i, r = 0; 739*30ee2a98SJason J. Herne 740*30ee2a98SJason J. Herne if (args->flags != 0) 741*30ee2a98SJason J. Herne return -EINVAL; 742*30ee2a98SJason J. Herne 743*30ee2a98SJason J. Herne /* Is this guest using storage keys? */ 744*30ee2a98SJason J. Herne if (!mm_use_skey(current->mm)) 745*30ee2a98SJason J. Herne return KVM_S390_GET_SKEYS_NONE; 746*30ee2a98SJason J. Herne 747*30ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 748*30ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 749*30ee2a98SJason J. Herne return -EINVAL; 750*30ee2a98SJason J. Herne 751*30ee2a98SJason J. Herne keys = kmalloc_array(args->count, sizeof(uint8_t), 752*30ee2a98SJason J. Herne GFP_KERNEL | __GFP_NOWARN); 753*30ee2a98SJason J. Herne if (!keys) 754*30ee2a98SJason J. Herne keys = vmalloc(sizeof(uint8_t) * args->count); 755*30ee2a98SJason J. Herne if (!keys) 756*30ee2a98SJason J. Herne return -ENOMEM; 757*30ee2a98SJason J. Herne 758*30ee2a98SJason J. Herne for (i = 0; i < args->count; i++) { 759*30ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 760*30ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 761*30ee2a98SJason J. Herne r = -EFAULT; 762*30ee2a98SJason J. Herne goto out; 763*30ee2a98SJason J. Herne } 764*30ee2a98SJason J. Herne 765*30ee2a98SJason J. Herne curkey = get_guest_storage_key(current->mm, hva); 766*30ee2a98SJason J. Herne if (IS_ERR_VALUE(curkey)) { 767*30ee2a98SJason J. Herne r = curkey; 768*30ee2a98SJason J. Herne goto out; 769*30ee2a98SJason J. Herne } 770*30ee2a98SJason J. Herne keys[i] = curkey; 771*30ee2a98SJason J. Herne } 772*30ee2a98SJason J. Herne 773*30ee2a98SJason J. Herne r = copy_to_user((uint8_t __user *)args->skeydata_addr, keys, 774*30ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 775*30ee2a98SJason J. Herne if (r) 776*30ee2a98SJason J. Herne r = -EFAULT; 777*30ee2a98SJason J. Herne out: 778*30ee2a98SJason J. Herne kvfree(keys); 779*30ee2a98SJason J. Herne return r; 780*30ee2a98SJason J. Herne } 781*30ee2a98SJason J. Herne 782*30ee2a98SJason J. Herne static long kvm_s390_set_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 783*30ee2a98SJason J. Herne { 784*30ee2a98SJason J. Herne uint8_t *keys; 785*30ee2a98SJason J. Herne uint64_t hva; 786*30ee2a98SJason J. Herne int i, r = 0; 787*30ee2a98SJason J. Herne 788*30ee2a98SJason J. Herne if (args->flags != 0) 789*30ee2a98SJason J. Herne return -EINVAL; 790*30ee2a98SJason J. Herne 791*30ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 792*30ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 793*30ee2a98SJason J. Herne return -EINVAL; 794*30ee2a98SJason J. Herne 795*30ee2a98SJason J. Herne keys = kmalloc_array(args->count, sizeof(uint8_t), 796*30ee2a98SJason J. Herne GFP_KERNEL | __GFP_NOWARN); 797*30ee2a98SJason J. Herne if (!keys) 798*30ee2a98SJason J. Herne keys = vmalloc(sizeof(uint8_t) * args->count); 799*30ee2a98SJason J. Herne if (!keys) 800*30ee2a98SJason J. Herne return -ENOMEM; 801*30ee2a98SJason J. Herne 802*30ee2a98SJason J. Herne r = copy_from_user(keys, (uint8_t __user *)args->skeydata_addr, 803*30ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 804*30ee2a98SJason J. Herne if (r) { 805*30ee2a98SJason J. Herne r = -EFAULT; 806*30ee2a98SJason J. Herne goto out; 807*30ee2a98SJason J. Herne } 808*30ee2a98SJason J. Herne 809*30ee2a98SJason J. Herne /* Enable storage key handling for the guest */ 810*30ee2a98SJason J. Herne s390_enable_skey(); 811*30ee2a98SJason J. Herne 812*30ee2a98SJason J. Herne for (i = 0; i < args->count; i++) { 813*30ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 814*30ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 815*30ee2a98SJason J. Herne r = -EFAULT; 816*30ee2a98SJason J. Herne goto out; 817*30ee2a98SJason J. Herne } 818*30ee2a98SJason J. Herne 819*30ee2a98SJason J. Herne /* Lowest order bit is reserved */ 820*30ee2a98SJason J. Herne if (keys[i] & 0x01) { 821*30ee2a98SJason J. Herne r = -EINVAL; 822*30ee2a98SJason J. Herne goto out; 823*30ee2a98SJason J. Herne } 824*30ee2a98SJason J. Herne 825*30ee2a98SJason J. Herne r = set_guest_storage_key(current->mm, hva, 826*30ee2a98SJason J. Herne (unsigned long)keys[i], 0); 827*30ee2a98SJason J. Herne if (r) 828*30ee2a98SJason J. Herne goto out; 829*30ee2a98SJason J. Herne } 830*30ee2a98SJason J. Herne out: 831*30ee2a98SJason J. Herne kvfree(keys); 832*30ee2a98SJason J. Herne return r; 833*30ee2a98SJason J. Herne } 834*30ee2a98SJason J. Herne 835b0c632dbSHeiko Carstens long kvm_arch_vm_ioctl(struct file *filp, 836b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 837b0c632dbSHeiko Carstens { 838b0c632dbSHeiko Carstens struct kvm *kvm = filp->private_data; 839b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 840f2061656SDominik Dingel struct kvm_device_attr attr; 841b0c632dbSHeiko Carstens int r; 842b0c632dbSHeiko Carstens 843b0c632dbSHeiko Carstens switch (ioctl) { 844ba5c1e9bSCarsten Otte case KVM_S390_INTERRUPT: { 845ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 846ba5c1e9bSCarsten Otte 847ba5c1e9bSCarsten Otte r = -EFAULT; 848ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 849ba5c1e9bSCarsten Otte break; 850ba5c1e9bSCarsten Otte r = kvm_s390_inject_vm(kvm, &s390int); 851ba5c1e9bSCarsten Otte break; 852ba5c1e9bSCarsten Otte } 853d938dc55SCornelia Huck case KVM_ENABLE_CAP: { 854d938dc55SCornelia Huck struct kvm_enable_cap cap; 855d938dc55SCornelia Huck r = -EFAULT; 856d938dc55SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 857d938dc55SCornelia Huck break; 858d938dc55SCornelia Huck r = kvm_vm_ioctl_enable_cap(kvm, &cap); 859d938dc55SCornelia Huck break; 860d938dc55SCornelia Huck } 86184223598SCornelia Huck case KVM_CREATE_IRQCHIP: { 86284223598SCornelia Huck struct kvm_irq_routing_entry routing; 86384223598SCornelia Huck 86484223598SCornelia Huck r = -EINVAL; 86584223598SCornelia Huck if (kvm->arch.use_irqchip) { 86684223598SCornelia Huck /* Set up dummy routing. */ 86784223598SCornelia Huck memset(&routing, 0, sizeof(routing)); 86884223598SCornelia Huck kvm_set_irq_routing(kvm, &routing, 0, 0); 86984223598SCornelia Huck r = 0; 87084223598SCornelia Huck } 87184223598SCornelia Huck break; 87284223598SCornelia Huck } 873f2061656SDominik Dingel case KVM_SET_DEVICE_ATTR: { 874f2061656SDominik Dingel r = -EFAULT; 875f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 876f2061656SDominik Dingel break; 877f2061656SDominik Dingel r = kvm_s390_vm_set_attr(kvm, &attr); 878f2061656SDominik Dingel break; 879f2061656SDominik Dingel } 880f2061656SDominik Dingel case KVM_GET_DEVICE_ATTR: { 881f2061656SDominik Dingel r = -EFAULT; 882f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 883f2061656SDominik Dingel break; 884f2061656SDominik Dingel r = kvm_s390_vm_get_attr(kvm, &attr); 885f2061656SDominik Dingel break; 886f2061656SDominik Dingel } 887f2061656SDominik Dingel case KVM_HAS_DEVICE_ATTR: { 888f2061656SDominik Dingel r = -EFAULT; 889f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 890f2061656SDominik Dingel break; 891f2061656SDominik Dingel r = kvm_s390_vm_has_attr(kvm, &attr); 892f2061656SDominik Dingel break; 893f2061656SDominik Dingel } 894*30ee2a98SJason J. Herne case KVM_S390_GET_SKEYS: { 895*30ee2a98SJason J. Herne struct kvm_s390_skeys args; 896*30ee2a98SJason J. Herne 897*30ee2a98SJason J. Herne r = -EFAULT; 898*30ee2a98SJason J. Herne if (copy_from_user(&args, argp, 899*30ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 900*30ee2a98SJason J. Herne break; 901*30ee2a98SJason J. Herne r = kvm_s390_get_skeys(kvm, &args); 902*30ee2a98SJason J. Herne break; 903*30ee2a98SJason J. Herne } 904*30ee2a98SJason J. Herne case KVM_S390_SET_SKEYS: { 905*30ee2a98SJason J. Herne struct kvm_s390_skeys args; 906*30ee2a98SJason J. Herne 907*30ee2a98SJason J. Herne r = -EFAULT; 908*30ee2a98SJason J. Herne if (copy_from_user(&args, argp, 909*30ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 910*30ee2a98SJason J. Herne break; 911*30ee2a98SJason J. Herne r = kvm_s390_set_skeys(kvm, &args); 912*30ee2a98SJason J. Herne break; 913*30ee2a98SJason J. Herne } 914b0c632dbSHeiko Carstens default: 915367e1319SAvi Kivity r = -ENOTTY; 916b0c632dbSHeiko Carstens } 917b0c632dbSHeiko Carstens 918b0c632dbSHeiko Carstens return r; 919b0c632dbSHeiko Carstens } 920b0c632dbSHeiko Carstens 92145c9b47cSTony Krowiak static int kvm_s390_query_ap_config(u8 *config) 92245c9b47cSTony Krowiak { 92345c9b47cSTony Krowiak u32 fcn_code = 0x04000000UL; 92486044c8cSChristian Borntraeger u32 cc = 0; 92545c9b47cSTony Krowiak 92686044c8cSChristian Borntraeger memset(config, 0, 128); 92745c9b47cSTony Krowiak asm volatile( 92845c9b47cSTony Krowiak "lgr 0,%1\n" 92945c9b47cSTony Krowiak "lgr 2,%2\n" 93045c9b47cSTony Krowiak ".long 0xb2af0000\n" /* PQAP(QCI) */ 93186044c8cSChristian Borntraeger "0: ipm %0\n" 93245c9b47cSTony Krowiak "srl %0,28\n" 93386044c8cSChristian Borntraeger "1:\n" 93486044c8cSChristian Borntraeger EX_TABLE(0b, 1b) 93586044c8cSChristian Borntraeger : "+r" (cc) 93645c9b47cSTony Krowiak : "r" (fcn_code), "r" (config) 93745c9b47cSTony Krowiak : "cc", "0", "2", "memory" 93845c9b47cSTony Krowiak ); 93945c9b47cSTony Krowiak 94045c9b47cSTony Krowiak return cc; 94145c9b47cSTony Krowiak } 94245c9b47cSTony Krowiak 94345c9b47cSTony Krowiak static int kvm_s390_apxa_installed(void) 94445c9b47cSTony Krowiak { 94545c9b47cSTony Krowiak u8 config[128]; 94645c9b47cSTony Krowiak int cc; 94745c9b47cSTony Krowiak 94845c9b47cSTony Krowiak if (test_facility(2) && test_facility(12)) { 94945c9b47cSTony Krowiak cc = kvm_s390_query_ap_config(config); 95045c9b47cSTony Krowiak 95145c9b47cSTony Krowiak if (cc) 95245c9b47cSTony Krowiak pr_err("PQAP(QCI) failed with cc=%d", cc); 95345c9b47cSTony Krowiak else 95445c9b47cSTony Krowiak return config[0] & 0x40; 95545c9b47cSTony Krowiak } 95645c9b47cSTony Krowiak 95745c9b47cSTony Krowiak return 0; 95845c9b47cSTony Krowiak } 95945c9b47cSTony Krowiak 96045c9b47cSTony Krowiak static void kvm_s390_set_crycb_format(struct kvm *kvm) 96145c9b47cSTony Krowiak { 96245c9b47cSTony Krowiak kvm->arch.crypto.crycbd = (__u32)(unsigned long) kvm->arch.crypto.crycb; 96345c9b47cSTony Krowiak 96445c9b47cSTony Krowiak if (kvm_s390_apxa_installed()) 96545c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT2; 96645c9b47cSTony Krowiak else 96745c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT1; 96845c9b47cSTony Krowiak } 96945c9b47cSTony Krowiak 9709d8d5786SMichael Mueller static void kvm_s390_get_cpu_id(struct cpuid *cpu_id) 9719d8d5786SMichael Mueller { 9729d8d5786SMichael Mueller get_cpu_id(cpu_id); 9739d8d5786SMichael Mueller cpu_id->version = 0xff; 9749d8d5786SMichael Mueller } 9759d8d5786SMichael Mueller 9765102ee87STony Krowiak static int kvm_s390_crypto_init(struct kvm *kvm) 9775102ee87STony Krowiak { 9789d8d5786SMichael Mueller if (!test_kvm_facility(kvm, 76)) 9795102ee87STony Krowiak return 0; 9805102ee87STony Krowiak 9815102ee87STony Krowiak kvm->arch.crypto.crycb = kzalloc(sizeof(*kvm->arch.crypto.crycb), 9825102ee87STony Krowiak GFP_KERNEL | GFP_DMA); 9835102ee87STony Krowiak if (!kvm->arch.crypto.crycb) 9845102ee87STony Krowiak return -ENOMEM; 9855102ee87STony Krowiak 98645c9b47cSTony Krowiak kvm_s390_set_crycb_format(kvm); 9875102ee87STony Krowiak 988ed6f76b4STony Krowiak /* Enable AES/DEA protected key functions by default */ 989ed6f76b4STony Krowiak kvm->arch.crypto.aes_kw = 1; 990ed6f76b4STony Krowiak kvm->arch.crypto.dea_kw = 1; 991ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 992ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 993ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 994ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 995a374e892STony Krowiak 9965102ee87STony Krowiak return 0; 9975102ee87STony Krowiak } 9985102ee87STony Krowiak 999e08b9637SCarsten Otte int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 1000b0c632dbSHeiko Carstens { 10019d8d5786SMichael Mueller int i, rc; 1002b0c632dbSHeiko Carstens char debug_name[16]; 1003f6c137ffSChristian Borntraeger static unsigned long sca_offset; 1004b0c632dbSHeiko Carstens 1005e08b9637SCarsten Otte rc = -EINVAL; 1006e08b9637SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 1007e08b9637SCarsten Otte if (type & ~KVM_VM_S390_UCONTROL) 1008e08b9637SCarsten Otte goto out_err; 1009e08b9637SCarsten Otte if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN))) 1010e08b9637SCarsten Otte goto out_err; 1011e08b9637SCarsten Otte #else 1012e08b9637SCarsten Otte if (type) 1013e08b9637SCarsten Otte goto out_err; 1014e08b9637SCarsten Otte #endif 1015e08b9637SCarsten Otte 1016b0c632dbSHeiko Carstens rc = s390_enable_sie(); 1017b0c632dbSHeiko Carstens if (rc) 1018d89f5effSJan Kiszka goto out_err; 1019b0c632dbSHeiko Carstens 1020b290411aSCarsten Otte rc = -ENOMEM; 1021b290411aSCarsten Otte 1022b0c632dbSHeiko Carstens kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL); 1023b0c632dbSHeiko Carstens if (!kvm->arch.sca) 1024d89f5effSJan Kiszka goto out_err; 1025f6c137ffSChristian Borntraeger spin_lock(&kvm_lock); 1026f6c137ffSChristian Borntraeger sca_offset = (sca_offset + 16) & 0x7f0; 1027f6c137ffSChristian Borntraeger kvm->arch.sca = (struct sca_block *) ((char *) kvm->arch.sca + sca_offset); 1028f6c137ffSChristian Borntraeger spin_unlock(&kvm_lock); 1029b0c632dbSHeiko Carstens 1030b0c632dbSHeiko Carstens sprintf(debug_name, "kvm-%u", current->pid); 1031b0c632dbSHeiko Carstens 1032b0c632dbSHeiko Carstens kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long)); 1033b0c632dbSHeiko Carstens if (!kvm->arch.dbf) 103440f5b735SDominik Dingel goto out_err; 1035b0c632dbSHeiko Carstens 10369d8d5786SMichael Mueller /* 10379d8d5786SMichael Mueller * The architectural maximum amount of facilities is 16 kbit. To store 10389d8d5786SMichael Mueller * this amount, 2 kbyte of memory is required. Thus we need a full 1039981467c9SMichael Mueller * page to hold the guest facility list (arch.model.fac->list) and the 1040981467c9SMichael Mueller * facility mask (arch.model.fac->mask). Its address size has to be 10419d8d5786SMichael Mueller * 31 bits and word aligned. 10429d8d5786SMichael Mueller */ 10439d8d5786SMichael Mueller kvm->arch.model.fac = 1044981467c9SMichael Mueller (struct kvm_s390_fac *) get_zeroed_page(GFP_KERNEL | GFP_DMA); 10459d8d5786SMichael Mueller if (!kvm->arch.model.fac) 104640f5b735SDominik Dingel goto out_err; 10479d8d5786SMichael Mueller 1048fb5bf93fSMichael Mueller /* Populate the facility mask initially. */ 1049981467c9SMichael Mueller memcpy(kvm->arch.model.fac->mask, S390_lowcore.stfle_fac_list, 105094422ee8SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 10519d8d5786SMichael Mueller for (i = 0; i < S390_ARCH_FAC_LIST_SIZE_U64; i++) { 10529d8d5786SMichael Mueller if (i < kvm_s390_fac_list_mask_size()) 1053981467c9SMichael Mueller kvm->arch.model.fac->mask[i] &= kvm_s390_fac_list_mask[i]; 10549d8d5786SMichael Mueller else 1055981467c9SMichael Mueller kvm->arch.model.fac->mask[i] = 0UL; 10569d8d5786SMichael Mueller } 10579d8d5786SMichael Mueller 1058981467c9SMichael Mueller /* Populate the facility list initially. */ 1059981467c9SMichael Mueller memcpy(kvm->arch.model.fac->list, kvm->arch.model.fac->mask, 1060981467c9SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 1061981467c9SMichael Mueller 10629d8d5786SMichael Mueller kvm_s390_get_cpu_id(&kvm->arch.model.cpu_id); 1063658b6edaSMichael Mueller kvm->arch.model.ibc = sclp_get_ibc() & 0x0fff; 10649d8d5786SMichael Mueller 10655102ee87STony Krowiak if (kvm_s390_crypto_init(kvm) < 0) 106640f5b735SDominik Dingel goto out_err; 10675102ee87STony Krowiak 1068ba5c1e9bSCarsten Otte spin_lock_init(&kvm->arch.float_int.lock); 1069ba5c1e9bSCarsten Otte INIT_LIST_HEAD(&kvm->arch.float_int.list); 10708a242234SHeiko Carstens init_waitqueue_head(&kvm->arch.ipte_wq); 1071a6b7e459SThomas Huth mutex_init(&kvm->arch.ipte_mutex); 1072ba5c1e9bSCarsten Otte 1073b0c632dbSHeiko Carstens debug_register_view(kvm->arch.dbf, &debug_sprintf_view); 1074b0c632dbSHeiko Carstens VM_EVENT(kvm, 3, "%s", "vm created"); 1075b0c632dbSHeiko Carstens 1076e08b9637SCarsten Otte if (type & KVM_VM_S390_UCONTROL) { 1077e08b9637SCarsten Otte kvm->arch.gmap = NULL; 1078e08b9637SCarsten Otte } else { 10790349985aSChristian Borntraeger kvm->arch.gmap = gmap_alloc(current->mm, (1UL << 44) - 1); 1080598841caSCarsten Otte if (!kvm->arch.gmap) 108140f5b735SDominik Dingel goto out_err; 10822c70fe44SChristian Borntraeger kvm->arch.gmap->private = kvm; 108324eb3a82SDominik Dingel kvm->arch.gmap->pfault_enabled = 0; 1084e08b9637SCarsten Otte } 1085fa6b7fe9SCornelia Huck 1086fa6b7fe9SCornelia Huck kvm->arch.css_support = 0; 108784223598SCornelia Huck kvm->arch.use_irqchip = 0; 108868c55750SEric Farman kvm->arch.use_vectors = 0; 108972f25020SJason J. Herne kvm->arch.epoch = 0; 1090fa6b7fe9SCornelia Huck 10918ad35755SDavid Hildenbrand spin_lock_init(&kvm->arch.start_stop_lock); 10928ad35755SDavid Hildenbrand 1093d89f5effSJan Kiszka return 0; 1094d89f5effSJan Kiszka out_err: 109540f5b735SDominik Dingel kfree(kvm->arch.crypto.crycb); 109640f5b735SDominik Dingel free_page((unsigned long)kvm->arch.model.fac); 109740f5b735SDominik Dingel debug_unregister(kvm->arch.dbf); 109840f5b735SDominik Dingel free_page((unsigned long)(kvm->arch.sca)); 1099d89f5effSJan Kiszka return rc; 1100b0c632dbSHeiko Carstens } 1101b0c632dbSHeiko Carstens 1102d329c035SChristian Borntraeger void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 1103d329c035SChristian Borntraeger { 1104d329c035SChristian Borntraeger VCPU_EVENT(vcpu, 3, "%s", "free cpu"); 1105ade38c31SCornelia Huck trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id); 110667335e63SChristian Borntraeger kvm_s390_clear_local_irqs(vcpu); 11073c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 110858f9460bSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 110958f9460bSCarsten Otte clear_bit(63 - vcpu->vcpu_id, 111058f9460bSCarsten Otte (unsigned long *) &vcpu->kvm->arch.sca->mcn); 1111abf4a71eSCarsten Otte if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda == 1112abf4a71eSCarsten Otte (__u64) vcpu->arch.sie_block) 1113abf4a71eSCarsten Otte vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0; 111458f9460bSCarsten Otte } 1115abf4a71eSCarsten Otte smp_mb(); 111627e0393fSCarsten Otte 111727e0393fSCarsten Otte if (kvm_is_ucontrol(vcpu->kvm)) 111827e0393fSCarsten Otte gmap_free(vcpu->arch.gmap); 111927e0393fSCarsten Otte 1120b31605c1SDominik Dingel if (kvm_s390_cmma_enabled(vcpu->kvm)) 1121b31605c1SDominik Dingel kvm_s390_vcpu_unsetup_cmma(vcpu); 1122d329c035SChristian Borntraeger free_page((unsigned long)(vcpu->arch.sie_block)); 1123b31288faSKonstantin Weitz 11246692cef3SChristian Borntraeger kvm_vcpu_uninit(vcpu); 1125b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 1126d329c035SChristian Borntraeger } 1127d329c035SChristian Borntraeger 1128d329c035SChristian Borntraeger static void kvm_free_vcpus(struct kvm *kvm) 1129d329c035SChristian Borntraeger { 1130d329c035SChristian Borntraeger unsigned int i; 1131988a2caeSGleb Natapov struct kvm_vcpu *vcpu; 1132d329c035SChristian Borntraeger 1133988a2caeSGleb Natapov kvm_for_each_vcpu(i, vcpu, kvm) 1134988a2caeSGleb Natapov kvm_arch_vcpu_destroy(vcpu); 1135988a2caeSGleb Natapov 1136988a2caeSGleb Natapov mutex_lock(&kvm->lock); 1137988a2caeSGleb Natapov for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 1138d329c035SChristian Borntraeger kvm->vcpus[i] = NULL; 1139988a2caeSGleb Natapov 1140988a2caeSGleb Natapov atomic_set(&kvm->online_vcpus, 0); 1141988a2caeSGleb Natapov mutex_unlock(&kvm->lock); 1142d329c035SChristian Borntraeger } 1143d329c035SChristian Borntraeger 1144b0c632dbSHeiko Carstens void kvm_arch_destroy_vm(struct kvm *kvm) 1145b0c632dbSHeiko Carstens { 1146d329c035SChristian Borntraeger kvm_free_vcpus(kvm); 11479d8d5786SMichael Mueller free_page((unsigned long)kvm->arch.model.fac); 1148b0c632dbSHeiko Carstens free_page((unsigned long)(kvm->arch.sca)); 1149d329c035SChristian Borntraeger debug_unregister(kvm->arch.dbf); 11505102ee87STony Krowiak kfree(kvm->arch.crypto.crycb); 115127e0393fSCarsten Otte if (!kvm_is_ucontrol(kvm)) 1152598841caSCarsten Otte gmap_free(kvm->arch.gmap); 1153841b91c5SCornelia Huck kvm_s390_destroy_adapters(kvm); 115467335e63SChristian Borntraeger kvm_s390_clear_float_irqs(kvm); 1155b0c632dbSHeiko Carstens } 1156b0c632dbSHeiko Carstens 1157b0c632dbSHeiko Carstens /* Section: vcpu related */ 1158dafd032aSDominik Dingel static int __kvm_ucontrol_vcpu_init(struct kvm_vcpu *vcpu) 1159b0c632dbSHeiko Carstens { 1160c6c956b8SMartin Schwidefsky vcpu->arch.gmap = gmap_alloc(current->mm, -1UL); 116127e0393fSCarsten Otte if (!vcpu->arch.gmap) 116227e0393fSCarsten Otte return -ENOMEM; 11632c70fe44SChristian Borntraeger vcpu->arch.gmap->private = vcpu->kvm; 1164dafd032aSDominik Dingel 116527e0393fSCarsten Otte return 0; 116627e0393fSCarsten Otte } 116727e0393fSCarsten Otte 1168dafd032aSDominik Dingel int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 1169dafd032aSDominik Dingel { 1170dafd032aSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 1171dafd032aSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 117259674c1aSChristian Borntraeger vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX | 117359674c1aSChristian Borntraeger KVM_SYNC_GPRS | 11749eed0735SChristian Borntraeger KVM_SYNC_ACRS | 1175b028ee3eSDavid Hildenbrand KVM_SYNC_CRS | 1176b028ee3eSDavid Hildenbrand KVM_SYNC_ARCH0 | 1177b028ee3eSDavid Hildenbrand KVM_SYNC_PFAULT; 117868c55750SEric Farman if (test_kvm_facility(vcpu->kvm, 129)) 117968c55750SEric Farman vcpu->run->kvm_valid_regs |= KVM_SYNC_VRS; 1180dafd032aSDominik Dingel 1181dafd032aSDominik Dingel if (kvm_is_ucontrol(vcpu->kvm)) 1182dafd032aSDominik Dingel return __kvm_ucontrol_vcpu_init(vcpu); 1183dafd032aSDominik Dingel 1184b0c632dbSHeiko Carstens return 0; 1185b0c632dbSHeiko Carstens } 1186b0c632dbSHeiko Carstens 1187b0c632dbSHeiko Carstens void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 1188b0c632dbSHeiko Carstens { 11894725c860SMartin Schwidefsky save_fp_ctl(&vcpu->arch.host_fpregs.fpc); 119068c55750SEric Farman if (vcpu->kvm->arch.use_vectors) 119168c55750SEric Farman save_vx_regs((__vector128 *)&vcpu->arch.host_vregs->vrs); 119268c55750SEric Farman else 11934725c860SMartin Schwidefsky save_fp_regs(vcpu->arch.host_fpregs.fprs); 1194b0c632dbSHeiko Carstens save_access_regs(vcpu->arch.host_acrs); 119568c55750SEric Farman if (vcpu->kvm->arch.use_vectors) { 119668c55750SEric Farman restore_fp_ctl(&vcpu->run->s.regs.fpc); 119768c55750SEric Farman restore_vx_regs((__vector128 *)&vcpu->run->s.regs.vrs); 119868c55750SEric Farman } else { 11994725c860SMartin Schwidefsky restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc); 12004725c860SMartin Schwidefsky restore_fp_regs(vcpu->arch.guest_fpregs.fprs); 120168c55750SEric Farman } 120259674c1aSChristian Borntraeger restore_access_regs(vcpu->run->s.regs.acrs); 1203480e5926SChristian Borntraeger gmap_enable(vcpu->arch.gmap); 12049e6dabefSCornelia Huck atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 1205b0c632dbSHeiko Carstens } 1206b0c632dbSHeiko Carstens 1207b0c632dbSHeiko Carstens void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 1208b0c632dbSHeiko Carstens { 12099e6dabefSCornelia Huck atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 1210480e5926SChristian Borntraeger gmap_disable(vcpu->arch.gmap); 121168c55750SEric Farman if (vcpu->kvm->arch.use_vectors) { 121268c55750SEric Farman save_fp_ctl(&vcpu->run->s.regs.fpc); 121368c55750SEric Farman save_vx_regs((__vector128 *)&vcpu->run->s.regs.vrs); 121468c55750SEric Farman } else { 12154725c860SMartin Schwidefsky save_fp_ctl(&vcpu->arch.guest_fpregs.fpc); 12164725c860SMartin Schwidefsky save_fp_regs(vcpu->arch.guest_fpregs.fprs); 121768c55750SEric Farman } 121859674c1aSChristian Borntraeger save_access_regs(vcpu->run->s.regs.acrs); 12194725c860SMartin Schwidefsky restore_fp_ctl(&vcpu->arch.host_fpregs.fpc); 122068c55750SEric Farman if (vcpu->kvm->arch.use_vectors) 122168c55750SEric Farman restore_vx_regs((__vector128 *)&vcpu->arch.host_vregs->vrs); 122268c55750SEric Farman else 12234725c860SMartin Schwidefsky restore_fp_regs(vcpu->arch.host_fpregs.fprs); 1224b0c632dbSHeiko Carstens restore_access_regs(vcpu->arch.host_acrs); 1225b0c632dbSHeiko Carstens } 1226b0c632dbSHeiko Carstens 1227b0c632dbSHeiko Carstens static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu) 1228b0c632dbSHeiko Carstens { 1229b0c632dbSHeiko Carstens /* this equals initial cpu reset in pop, but we don't switch to ESA */ 1230b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.mask = 0UL; 1231b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.addr = 0UL; 12328d26cf7bSChristian Borntraeger kvm_s390_set_prefix(vcpu, 0); 1233b0c632dbSHeiko Carstens vcpu->arch.sie_block->cputm = 0UL; 1234b0c632dbSHeiko Carstens vcpu->arch.sie_block->ckc = 0UL; 1235b0c632dbSHeiko Carstens vcpu->arch.sie_block->todpr = 0; 1236b0c632dbSHeiko Carstens memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64)); 1237b0c632dbSHeiko Carstens vcpu->arch.sie_block->gcr[0] = 0xE0UL; 1238b0c632dbSHeiko Carstens vcpu->arch.sie_block->gcr[14] = 0xC2000000UL; 1239b0c632dbSHeiko Carstens vcpu->arch.guest_fpregs.fpc = 0; 1240b0c632dbSHeiko Carstens asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc)); 1241b0c632dbSHeiko Carstens vcpu->arch.sie_block->gbea = 1; 1242672550fbSChristian Borntraeger vcpu->arch.sie_block->pp = 0; 12433c038e6bSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 12443c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 12456352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) 12466852d7b6SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 12472ed10cc1SJens Freimann kvm_s390_clear_local_irqs(vcpu); 1248b0c632dbSHeiko Carstens } 1249b0c632dbSHeiko Carstens 125031928aa5SDominik Dingel void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu) 125142897d86SMarcelo Tosatti { 125272f25020SJason J. Herne mutex_lock(&vcpu->kvm->lock); 125372f25020SJason J. Herne vcpu->arch.sie_block->epoch = vcpu->kvm->arch.epoch; 125472f25020SJason J. Herne mutex_unlock(&vcpu->kvm->lock); 1255dafd032aSDominik Dingel if (!kvm_is_ucontrol(vcpu->kvm)) 1256dafd032aSDominik Dingel vcpu->arch.gmap = vcpu->kvm->arch.gmap; 125742897d86SMarcelo Tosatti } 125842897d86SMarcelo Tosatti 12595102ee87STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu) 12605102ee87STony Krowiak { 12619d8d5786SMichael Mueller if (!test_kvm_facility(vcpu->kvm, 76)) 12625102ee87STony Krowiak return; 12635102ee87STony Krowiak 1264a374e892STony Krowiak vcpu->arch.sie_block->ecb3 &= ~(ECB3_AES | ECB3_DEA); 1265a374e892STony Krowiak 1266a374e892STony Krowiak if (vcpu->kvm->arch.crypto.aes_kw) 1267a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_AES; 1268a374e892STony Krowiak if (vcpu->kvm->arch.crypto.dea_kw) 1269a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_DEA; 1270a374e892STony Krowiak 12715102ee87STony Krowiak vcpu->arch.sie_block->crycbd = vcpu->kvm->arch.crypto.crycbd; 12725102ee87STony Krowiak } 12735102ee87STony Krowiak 1274b31605c1SDominik Dingel void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu) 1275b31605c1SDominik Dingel { 1276b31605c1SDominik Dingel free_page(vcpu->arch.sie_block->cbrlo); 1277b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = 0; 1278b31605c1SDominik Dingel } 1279b31605c1SDominik Dingel 1280b31605c1SDominik Dingel int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu) 1281b31605c1SDominik Dingel { 1282b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = get_zeroed_page(GFP_KERNEL); 1283b31605c1SDominik Dingel if (!vcpu->arch.sie_block->cbrlo) 1284b31605c1SDominik Dingel return -ENOMEM; 1285b31605c1SDominik Dingel 1286b31605c1SDominik Dingel vcpu->arch.sie_block->ecb2 |= 0x80; 1287b31605c1SDominik Dingel vcpu->arch.sie_block->ecb2 &= ~0x08; 1288b31605c1SDominik Dingel return 0; 1289b31605c1SDominik Dingel } 1290b31605c1SDominik Dingel 129191520f1aSMichael Mueller static void kvm_s390_vcpu_setup_model(struct kvm_vcpu *vcpu) 129291520f1aSMichael Mueller { 129391520f1aSMichael Mueller struct kvm_s390_cpu_model *model = &vcpu->kvm->arch.model; 129491520f1aSMichael Mueller 129591520f1aSMichael Mueller vcpu->arch.cpu_id = model->cpu_id; 129691520f1aSMichael Mueller vcpu->arch.sie_block->ibc = model->ibc; 129791520f1aSMichael Mueller vcpu->arch.sie_block->fac = (int) (long) model->fac->list; 129891520f1aSMichael Mueller } 129991520f1aSMichael Mueller 1300b0c632dbSHeiko Carstens int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) 1301b0c632dbSHeiko Carstens { 1302b31605c1SDominik Dingel int rc = 0; 1303b31288faSKonstantin Weitz 13049e6dabefSCornelia Huck atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH | 13059e6dabefSCornelia Huck CPUSTAT_SM | 130669d0d3a3SChristian Borntraeger CPUSTAT_STOPPED | 130769d0d3a3SChristian Borntraeger CPUSTAT_GED); 130891520f1aSMichael Mueller kvm_s390_vcpu_setup_model(vcpu); 130991520f1aSMichael Mueller 1310fc34531dSChristian Borntraeger vcpu->arch.sie_block->ecb = 6; 13119d8d5786SMichael Mueller if (test_kvm_facility(vcpu->kvm, 50) && test_kvm_facility(vcpu->kvm, 73)) 13127feb6bb8SMichael Mueller vcpu->arch.sie_block->ecb |= 0x10; 13137feb6bb8SMichael Mueller 131469d0d3a3SChristian Borntraeger vcpu->arch.sie_block->ecb2 = 8; 1315ea5f4969SDavid Hildenbrand vcpu->arch.sie_block->eca = 0xC1002000U; 1316217a4406SHeiko Carstens if (sclp_has_siif()) 1317217a4406SHeiko Carstens vcpu->arch.sie_block->eca |= 1; 1318ea5f4969SDavid Hildenbrand if (sclp_has_sigpif()) 1319ea5f4969SDavid Hildenbrand vcpu->arch.sie_block->eca |= 0x10000000U; 132013211ea7SEric Farman if (vcpu->kvm->arch.use_vectors) { 132113211ea7SEric Farman vcpu->arch.sie_block->eca |= 0x00020000; 132213211ea7SEric Farman vcpu->arch.sie_block->ecd |= 0x20000000; 132313211ea7SEric Farman } 1324492d8642SThomas Huth vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE; 13255a5e6536SMatthew Rosato 1326b31605c1SDominik Dingel if (kvm_s390_cmma_enabled(vcpu->kvm)) { 1327b31605c1SDominik Dingel rc = kvm_s390_vcpu_setup_cmma(vcpu); 1328b31605c1SDominik Dingel if (rc) 1329b31605c1SDominik Dingel return rc; 1330b31288faSKonstantin Weitz } 13310ac96cafSDavid Hildenbrand hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 1332ca872302SChristian Borntraeger vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup; 13339d8d5786SMichael Mueller 13345102ee87STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 13355102ee87STony Krowiak 1336b31605c1SDominik Dingel return rc; 1337b0c632dbSHeiko Carstens } 1338b0c632dbSHeiko Carstens 1339b0c632dbSHeiko Carstens struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, 1340b0c632dbSHeiko Carstens unsigned int id) 1341b0c632dbSHeiko Carstens { 13424d47555aSCarsten Otte struct kvm_vcpu *vcpu; 13437feb6bb8SMichael Mueller struct sie_page *sie_page; 13444d47555aSCarsten Otte int rc = -EINVAL; 1345b0c632dbSHeiko Carstens 13464d47555aSCarsten Otte if (id >= KVM_MAX_VCPUS) 13474d47555aSCarsten Otte goto out; 13484d47555aSCarsten Otte 13494d47555aSCarsten Otte rc = -ENOMEM; 13504d47555aSCarsten Otte 1351b110feafSMichael Mueller vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL); 1352b0c632dbSHeiko Carstens if (!vcpu) 13534d47555aSCarsten Otte goto out; 1354b0c632dbSHeiko Carstens 13557feb6bb8SMichael Mueller sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL); 13567feb6bb8SMichael Mueller if (!sie_page) 1357b0c632dbSHeiko Carstens goto out_free_cpu; 1358b0c632dbSHeiko Carstens 13597feb6bb8SMichael Mueller vcpu->arch.sie_block = &sie_page->sie_block; 13607feb6bb8SMichael Mueller vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb; 136168c55750SEric Farman vcpu->arch.host_vregs = &sie_page->vregs; 13627feb6bb8SMichael Mueller 1363b0c632dbSHeiko Carstens vcpu->arch.sie_block->icpua = id; 136458f9460bSCarsten Otte if (!kvm_is_ucontrol(kvm)) { 136558f9460bSCarsten Otte if (!kvm->arch.sca) { 136658f9460bSCarsten Otte WARN_ON_ONCE(1); 136758f9460bSCarsten Otte goto out_free_cpu; 136858f9460bSCarsten Otte } 1369abf4a71eSCarsten Otte if (!kvm->arch.sca->cpu[id].sda) 137058f9460bSCarsten Otte kvm->arch.sca->cpu[id].sda = 137158f9460bSCarsten Otte (__u64) vcpu->arch.sie_block; 137258f9460bSCarsten Otte vcpu->arch.sie_block->scaoh = 137358f9460bSCarsten Otte (__u32)(((__u64)kvm->arch.sca) >> 32); 1374b0c632dbSHeiko Carstens vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca; 1375fc34531dSChristian Borntraeger set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn); 137658f9460bSCarsten Otte } 1377b0c632dbSHeiko Carstens 1378ba5c1e9bSCarsten Otte spin_lock_init(&vcpu->arch.local_int.lock); 1379ba5c1e9bSCarsten Otte vcpu->arch.local_int.float_int = &kvm->arch.float_int; 1380d0321a24SChristian Borntraeger vcpu->arch.local_int.wq = &vcpu->wq; 13815288fbf0SChristian Borntraeger vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags; 1382ba5c1e9bSCarsten Otte 1383b0c632dbSHeiko Carstens rc = kvm_vcpu_init(vcpu, kvm, id); 1384b0c632dbSHeiko Carstens if (rc) 13857b06bf2fSWei Yongjun goto out_free_sie_block; 1386b0c632dbSHeiko Carstens VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu, 1387b0c632dbSHeiko Carstens vcpu->arch.sie_block); 1388ade38c31SCornelia Huck trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block); 1389b0c632dbSHeiko Carstens 1390b0c632dbSHeiko Carstens return vcpu; 13917b06bf2fSWei Yongjun out_free_sie_block: 13927b06bf2fSWei Yongjun free_page((unsigned long)(vcpu->arch.sie_block)); 1393b0c632dbSHeiko Carstens out_free_cpu: 1394b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 13954d47555aSCarsten Otte out: 1396b0c632dbSHeiko Carstens return ERR_PTR(rc); 1397b0c632dbSHeiko Carstens } 1398b0c632dbSHeiko Carstens 1399b0c632dbSHeiko Carstens int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu) 1400b0c632dbSHeiko Carstens { 14019a022067SDavid Hildenbrand return kvm_s390_vcpu_has_irq(vcpu, 0); 1402b0c632dbSHeiko Carstens } 1403b0c632dbSHeiko Carstens 140449b99e1eSChristian Borntraeger void s390_vcpu_block(struct kvm_vcpu *vcpu) 140549b99e1eSChristian Borntraeger { 140649b99e1eSChristian Borntraeger atomic_set_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 140749b99e1eSChristian Borntraeger } 140849b99e1eSChristian Borntraeger 140949b99e1eSChristian Borntraeger void s390_vcpu_unblock(struct kvm_vcpu *vcpu) 141049b99e1eSChristian Borntraeger { 141149b99e1eSChristian Borntraeger atomic_clear_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 141249b99e1eSChristian Borntraeger } 141349b99e1eSChristian Borntraeger 141449b99e1eSChristian Borntraeger /* 141549b99e1eSChristian Borntraeger * Kick a guest cpu out of SIE and wait until SIE is not running. 141649b99e1eSChristian Borntraeger * If the CPU is not running (e.g. waiting as idle) the function will 141749b99e1eSChristian Borntraeger * return immediately. */ 141849b99e1eSChristian Borntraeger void exit_sie(struct kvm_vcpu *vcpu) 141949b99e1eSChristian Borntraeger { 142049b99e1eSChristian Borntraeger atomic_set_mask(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags); 142149b99e1eSChristian Borntraeger while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE) 142249b99e1eSChristian Borntraeger cpu_relax(); 142349b99e1eSChristian Borntraeger } 142449b99e1eSChristian Borntraeger 142549b99e1eSChristian Borntraeger /* Kick a guest cpu out of SIE and prevent SIE-reentry */ 142649b99e1eSChristian Borntraeger void exit_sie_sync(struct kvm_vcpu *vcpu) 142749b99e1eSChristian Borntraeger { 142849b99e1eSChristian Borntraeger s390_vcpu_block(vcpu); 142949b99e1eSChristian Borntraeger exit_sie(vcpu); 143049b99e1eSChristian Borntraeger } 143149b99e1eSChristian Borntraeger 14322c70fe44SChristian Borntraeger static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address) 14332c70fe44SChristian Borntraeger { 14342c70fe44SChristian Borntraeger int i; 14352c70fe44SChristian Borntraeger struct kvm *kvm = gmap->private; 14362c70fe44SChristian Borntraeger struct kvm_vcpu *vcpu; 14372c70fe44SChristian Borntraeger 14382c70fe44SChristian Borntraeger kvm_for_each_vcpu(i, vcpu, kvm) { 14392c70fe44SChristian Borntraeger /* match against both prefix pages */ 1440fda902cbSMichael Mueller if (kvm_s390_get_prefix(vcpu) == (address & ~0x1000UL)) { 14412c70fe44SChristian Borntraeger VCPU_EVENT(vcpu, 2, "gmap notifier for %lx", address); 14422c70fe44SChristian Borntraeger kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu); 14432c70fe44SChristian Borntraeger exit_sie_sync(vcpu); 14442c70fe44SChristian Borntraeger } 14452c70fe44SChristian Borntraeger } 14462c70fe44SChristian Borntraeger } 14472c70fe44SChristian Borntraeger 1448b6d33834SChristoffer Dall int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu) 1449b6d33834SChristoffer Dall { 1450b6d33834SChristoffer Dall /* kvm common code refers to this, but never calls it */ 1451b6d33834SChristoffer Dall BUG(); 1452b6d33834SChristoffer Dall return 0; 1453b6d33834SChristoffer Dall } 1454b6d33834SChristoffer Dall 145514eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, 145614eebd91SCarsten Otte struct kvm_one_reg *reg) 145714eebd91SCarsten Otte { 145814eebd91SCarsten Otte int r = -EINVAL; 145914eebd91SCarsten Otte 146014eebd91SCarsten Otte switch (reg->id) { 146129b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 146229b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->todpr, 146329b7c71bSCarsten Otte (u32 __user *)reg->addr); 146429b7c71bSCarsten Otte break; 146529b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 146629b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->epoch, 146729b7c71bSCarsten Otte (u64 __user *)reg->addr); 146829b7c71bSCarsten Otte break; 146946a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 147046a6dd1cSJason J. herne r = put_user(vcpu->arch.sie_block->cputm, 147146a6dd1cSJason J. herne (u64 __user *)reg->addr); 147246a6dd1cSJason J. herne break; 147346a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 147446a6dd1cSJason J. herne r = put_user(vcpu->arch.sie_block->ckc, 147546a6dd1cSJason J. herne (u64 __user *)reg->addr); 147646a6dd1cSJason J. herne break; 1477536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 1478536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_token, 1479536336c2SDominik Dingel (u64 __user *)reg->addr); 1480536336c2SDominik Dingel break; 1481536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 1482536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_compare, 1483536336c2SDominik Dingel (u64 __user *)reg->addr); 1484536336c2SDominik Dingel break; 1485536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 1486536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_select, 1487536336c2SDominik Dingel (u64 __user *)reg->addr); 1488536336c2SDominik Dingel break; 1489672550fbSChristian Borntraeger case KVM_REG_S390_PP: 1490672550fbSChristian Borntraeger r = put_user(vcpu->arch.sie_block->pp, 1491672550fbSChristian Borntraeger (u64 __user *)reg->addr); 1492672550fbSChristian Borntraeger break; 1493afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 1494afa45ff5SChristian Borntraeger r = put_user(vcpu->arch.sie_block->gbea, 1495afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 1496afa45ff5SChristian Borntraeger break; 149714eebd91SCarsten Otte default: 149814eebd91SCarsten Otte break; 149914eebd91SCarsten Otte } 150014eebd91SCarsten Otte 150114eebd91SCarsten Otte return r; 150214eebd91SCarsten Otte } 150314eebd91SCarsten Otte 150414eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, 150514eebd91SCarsten Otte struct kvm_one_reg *reg) 150614eebd91SCarsten Otte { 150714eebd91SCarsten Otte int r = -EINVAL; 150814eebd91SCarsten Otte 150914eebd91SCarsten Otte switch (reg->id) { 151029b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 151129b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->todpr, 151229b7c71bSCarsten Otte (u32 __user *)reg->addr); 151329b7c71bSCarsten Otte break; 151429b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 151529b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->epoch, 151629b7c71bSCarsten Otte (u64 __user *)reg->addr); 151729b7c71bSCarsten Otte break; 151846a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 151946a6dd1cSJason J. herne r = get_user(vcpu->arch.sie_block->cputm, 152046a6dd1cSJason J. herne (u64 __user *)reg->addr); 152146a6dd1cSJason J. herne break; 152246a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 152346a6dd1cSJason J. herne r = get_user(vcpu->arch.sie_block->ckc, 152446a6dd1cSJason J. herne (u64 __user *)reg->addr); 152546a6dd1cSJason J. herne break; 1526536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 1527536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_token, 1528536336c2SDominik Dingel (u64 __user *)reg->addr); 15299fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 15309fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 1531536336c2SDominik Dingel break; 1532536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 1533536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_compare, 1534536336c2SDominik Dingel (u64 __user *)reg->addr); 1535536336c2SDominik Dingel break; 1536536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 1537536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_select, 1538536336c2SDominik Dingel (u64 __user *)reg->addr); 1539536336c2SDominik Dingel break; 1540672550fbSChristian Borntraeger case KVM_REG_S390_PP: 1541672550fbSChristian Borntraeger r = get_user(vcpu->arch.sie_block->pp, 1542672550fbSChristian Borntraeger (u64 __user *)reg->addr); 1543672550fbSChristian Borntraeger break; 1544afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 1545afa45ff5SChristian Borntraeger r = get_user(vcpu->arch.sie_block->gbea, 1546afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 1547afa45ff5SChristian Borntraeger break; 154814eebd91SCarsten Otte default: 154914eebd91SCarsten Otte break; 155014eebd91SCarsten Otte } 155114eebd91SCarsten Otte 155214eebd91SCarsten Otte return r; 155314eebd91SCarsten Otte } 1554b6d33834SChristoffer Dall 1555b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) 1556b0c632dbSHeiko Carstens { 1557b0c632dbSHeiko Carstens kvm_s390_vcpu_initial_reset(vcpu); 1558b0c632dbSHeiko Carstens return 0; 1559b0c632dbSHeiko Carstens } 1560b0c632dbSHeiko Carstens 1561b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 1562b0c632dbSHeiko Carstens { 15635a32c1afSChristian Borntraeger memcpy(&vcpu->run->s.regs.gprs, ®s->gprs, sizeof(regs->gprs)); 1564b0c632dbSHeiko Carstens return 0; 1565b0c632dbSHeiko Carstens } 1566b0c632dbSHeiko Carstens 1567b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 1568b0c632dbSHeiko Carstens { 15695a32c1afSChristian Borntraeger memcpy(®s->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs)); 1570b0c632dbSHeiko Carstens return 0; 1571b0c632dbSHeiko Carstens } 1572b0c632dbSHeiko Carstens 1573b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, 1574b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 1575b0c632dbSHeiko Carstens { 157659674c1aSChristian Borntraeger memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs)); 1577b0c632dbSHeiko Carstens memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs)); 157859674c1aSChristian Borntraeger restore_access_regs(vcpu->run->s.regs.acrs); 1579b0c632dbSHeiko Carstens return 0; 1580b0c632dbSHeiko Carstens } 1581b0c632dbSHeiko Carstens 1582b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, 1583b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 1584b0c632dbSHeiko Carstens { 158559674c1aSChristian Borntraeger memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs)); 1586b0c632dbSHeiko Carstens memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs)); 1587b0c632dbSHeiko Carstens return 0; 1588b0c632dbSHeiko Carstens } 1589b0c632dbSHeiko Carstens 1590b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 1591b0c632dbSHeiko Carstens { 15924725c860SMartin Schwidefsky if (test_fp_ctl(fpu->fpc)) 15934725c860SMartin Schwidefsky return -EINVAL; 1594b0c632dbSHeiko Carstens memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs)); 15954725c860SMartin Schwidefsky vcpu->arch.guest_fpregs.fpc = fpu->fpc; 15964725c860SMartin Schwidefsky restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc); 15974725c860SMartin Schwidefsky restore_fp_regs(vcpu->arch.guest_fpregs.fprs); 1598b0c632dbSHeiko Carstens return 0; 1599b0c632dbSHeiko Carstens } 1600b0c632dbSHeiko Carstens 1601b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 1602b0c632dbSHeiko Carstens { 1603b0c632dbSHeiko Carstens memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs)); 1604b0c632dbSHeiko Carstens fpu->fpc = vcpu->arch.guest_fpregs.fpc; 1605b0c632dbSHeiko Carstens return 0; 1606b0c632dbSHeiko Carstens } 1607b0c632dbSHeiko Carstens 1608b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw) 1609b0c632dbSHeiko Carstens { 1610b0c632dbSHeiko Carstens int rc = 0; 1611b0c632dbSHeiko Carstens 16127a42fdc2SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 1613b0c632dbSHeiko Carstens rc = -EBUSY; 1614d7b0b5ebSCarsten Otte else { 1615d7b0b5ebSCarsten Otte vcpu->run->psw_mask = psw.mask; 1616d7b0b5ebSCarsten Otte vcpu->run->psw_addr = psw.addr; 1617d7b0b5ebSCarsten Otte } 1618b0c632dbSHeiko Carstens return rc; 1619b0c632dbSHeiko Carstens } 1620b0c632dbSHeiko Carstens 1621b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, 1622b0c632dbSHeiko Carstens struct kvm_translation *tr) 1623b0c632dbSHeiko Carstens { 1624b0c632dbSHeiko Carstens return -EINVAL; /* not implemented yet */ 1625b0c632dbSHeiko Carstens } 1626b0c632dbSHeiko Carstens 162727291e21SDavid Hildenbrand #define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \ 162827291e21SDavid Hildenbrand KVM_GUESTDBG_USE_HW_BP | \ 162927291e21SDavid Hildenbrand KVM_GUESTDBG_ENABLE) 163027291e21SDavid Hildenbrand 1631d0bfb940SJan Kiszka int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 1632d0bfb940SJan Kiszka struct kvm_guest_debug *dbg) 1633b0c632dbSHeiko Carstens { 163427291e21SDavid Hildenbrand int rc = 0; 163527291e21SDavid Hildenbrand 163627291e21SDavid Hildenbrand vcpu->guest_debug = 0; 163727291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 163827291e21SDavid Hildenbrand 16392de3bfc2SDavid Hildenbrand if (dbg->control & ~VALID_GUESTDBG_FLAGS) 164027291e21SDavid Hildenbrand return -EINVAL; 164127291e21SDavid Hildenbrand 164227291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_ENABLE) { 164327291e21SDavid Hildenbrand vcpu->guest_debug = dbg->control; 164427291e21SDavid Hildenbrand /* enforce guest PER */ 164527291e21SDavid Hildenbrand atomic_set_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags); 164627291e21SDavid Hildenbrand 164727291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_USE_HW_BP) 164827291e21SDavid Hildenbrand rc = kvm_s390_import_bp_data(vcpu, dbg); 164927291e21SDavid Hildenbrand } else { 165027291e21SDavid Hildenbrand atomic_clear_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags); 165127291e21SDavid Hildenbrand vcpu->arch.guestdbg.last_bp = 0; 165227291e21SDavid Hildenbrand } 165327291e21SDavid Hildenbrand 165427291e21SDavid Hildenbrand if (rc) { 165527291e21SDavid Hildenbrand vcpu->guest_debug = 0; 165627291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 165727291e21SDavid Hildenbrand atomic_clear_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags); 165827291e21SDavid Hildenbrand } 165927291e21SDavid Hildenbrand 166027291e21SDavid Hildenbrand return rc; 1661b0c632dbSHeiko Carstens } 1662b0c632dbSHeiko Carstens 166362d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 166462d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 166562d9f0dbSMarcelo Tosatti { 16666352e4d2SDavid Hildenbrand /* CHECK_STOP and LOAD are not supported yet */ 16676352e4d2SDavid Hildenbrand return is_vcpu_stopped(vcpu) ? KVM_MP_STATE_STOPPED : 16686352e4d2SDavid Hildenbrand KVM_MP_STATE_OPERATING; 166962d9f0dbSMarcelo Tosatti } 167062d9f0dbSMarcelo Tosatti 167162d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 167262d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 167362d9f0dbSMarcelo Tosatti { 16746352e4d2SDavid Hildenbrand int rc = 0; 16756352e4d2SDavid Hildenbrand 16766352e4d2SDavid Hildenbrand /* user space knows about this interface - let it control the state */ 16776352e4d2SDavid Hildenbrand vcpu->kvm->arch.user_cpu_state_ctrl = 1; 16786352e4d2SDavid Hildenbrand 16796352e4d2SDavid Hildenbrand switch (mp_state->mp_state) { 16806352e4d2SDavid Hildenbrand case KVM_MP_STATE_STOPPED: 16816352e4d2SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 16826352e4d2SDavid Hildenbrand break; 16836352e4d2SDavid Hildenbrand case KVM_MP_STATE_OPERATING: 16846352e4d2SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 16856352e4d2SDavid Hildenbrand break; 16866352e4d2SDavid Hildenbrand case KVM_MP_STATE_LOAD: 16876352e4d2SDavid Hildenbrand case KVM_MP_STATE_CHECK_STOP: 16886352e4d2SDavid Hildenbrand /* fall through - CHECK_STOP and LOAD are not supported yet */ 16896352e4d2SDavid Hildenbrand default: 16906352e4d2SDavid Hildenbrand rc = -ENXIO; 16916352e4d2SDavid Hildenbrand } 16926352e4d2SDavid Hildenbrand 16936352e4d2SDavid Hildenbrand return rc; 169462d9f0dbSMarcelo Tosatti } 169562d9f0dbSMarcelo Tosatti 1696b31605c1SDominik Dingel bool kvm_s390_cmma_enabled(struct kvm *kvm) 1697b31605c1SDominik Dingel { 1698b31605c1SDominik Dingel if (!MACHINE_IS_LPAR) 1699b31605c1SDominik Dingel return false; 1700b31605c1SDominik Dingel /* only enable for z10 and later */ 1701b31605c1SDominik Dingel if (!MACHINE_HAS_EDAT1) 1702b31605c1SDominik Dingel return false; 1703b31605c1SDominik Dingel if (!kvm->arch.use_cmma) 1704b31605c1SDominik Dingel return false; 1705b31605c1SDominik Dingel return true; 1706b31605c1SDominik Dingel } 1707b31605c1SDominik Dingel 17088ad35755SDavid Hildenbrand static bool ibs_enabled(struct kvm_vcpu *vcpu) 17098ad35755SDavid Hildenbrand { 17108ad35755SDavid Hildenbrand return atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_IBS; 17118ad35755SDavid Hildenbrand } 17128ad35755SDavid Hildenbrand 17132c70fe44SChristian Borntraeger static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu) 17142c70fe44SChristian Borntraeger { 17158ad35755SDavid Hildenbrand retry: 17168ad35755SDavid Hildenbrand s390_vcpu_unblock(vcpu); 17172c70fe44SChristian Borntraeger /* 17182c70fe44SChristian Borntraeger * We use MMU_RELOAD just to re-arm the ipte notifier for the 17192c70fe44SChristian Borntraeger * guest prefix page. gmap_ipte_notify will wait on the ptl lock. 17202c70fe44SChristian Borntraeger * This ensures that the ipte instruction for this request has 17212c70fe44SChristian Borntraeger * already finished. We might race against a second unmapper that 17222c70fe44SChristian Borntraeger * wants to set the blocking bit. Lets just retry the request loop. 17232c70fe44SChristian Borntraeger */ 17248ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) { 17252c70fe44SChristian Borntraeger int rc; 17262c70fe44SChristian Borntraeger rc = gmap_ipte_notify(vcpu->arch.gmap, 1727fda902cbSMichael Mueller kvm_s390_get_prefix(vcpu), 17282c70fe44SChristian Borntraeger PAGE_SIZE * 2); 17292c70fe44SChristian Borntraeger if (rc) 17302c70fe44SChristian Borntraeger return rc; 17318ad35755SDavid Hildenbrand goto retry; 17322c70fe44SChristian Borntraeger } 17338ad35755SDavid Hildenbrand 1734d3d692c8SDavid Hildenbrand if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu)) { 1735d3d692c8SDavid Hildenbrand vcpu->arch.sie_block->ihcpu = 0xffff; 1736d3d692c8SDavid Hildenbrand goto retry; 1737d3d692c8SDavid Hildenbrand } 1738d3d692c8SDavid Hildenbrand 17398ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu)) { 17408ad35755SDavid Hildenbrand if (!ibs_enabled(vcpu)) { 17418ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 1); 17428ad35755SDavid Hildenbrand atomic_set_mask(CPUSTAT_IBS, 17438ad35755SDavid Hildenbrand &vcpu->arch.sie_block->cpuflags); 17448ad35755SDavid Hildenbrand } 17458ad35755SDavid Hildenbrand goto retry; 17468ad35755SDavid Hildenbrand } 17478ad35755SDavid Hildenbrand 17488ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu)) { 17498ad35755SDavid Hildenbrand if (ibs_enabled(vcpu)) { 17508ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 0); 17518ad35755SDavid Hildenbrand atomic_clear_mask(CPUSTAT_IBS, 17528ad35755SDavid Hildenbrand &vcpu->arch.sie_block->cpuflags); 17538ad35755SDavid Hildenbrand } 17548ad35755SDavid Hildenbrand goto retry; 17558ad35755SDavid Hildenbrand } 17568ad35755SDavid Hildenbrand 17570759d068SDavid Hildenbrand /* nothing to do, just clear the request */ 17580759d068SDavid Hildenbrand clear_bit(KVM_REQ_UNHALT, &vcpu->requests); 17590759d068SDavid Hildenbrand 17602c70fe44SChristian Borntraeger return 0; 17612c70fe44SChristian Borntraeger } 17622c70fe44SChristian Borntraeger 1763fa576c58SThomas Huth /** 1764fa576c58SThomas Huth * kvm_arch_fault_in_page - fault-in guest page if necessary 1765fa576c58SThomas Huth * @vcpu: The corresponding virtual cpu 1766fa576c58SThomas Huth * @gpa: Guest physical address 1767fa576c58SThomas Huth * @writable: Whether the page should be writable or not 1768fa576c58SThomas Huth * 1769fa576c58SThomas Huth * Make sure that a guest page has been faulted-in on the host. 1770fa576c58SThomas Huth * 1771fa576c58SThomas Huth * Return: Zero on success, negative error code otherwise. 1772fa576c58SThomas Huth */ 1773fa576c58SThomas Huth long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable) 177424eb3a82SDominik Dingel { 1775527e30b4SMartin Schwidefsky return gmap_fault(vcpu->arch.gmap, gpa, 1776527e30b4SMartin Schwidefsky writable ? FAULT_FLAG_WRITE : 0); 177724eb3a82SDominik Dingel } 177824eb3a82SDominik Dingel 17793c038e6bSDominik Dingel static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token, 17803c038e6bSDominik Dingel unsigned long token) 17813c038e6bSDominik Dingel { 17823c038e6bSDominik Dingel struct kvm_s390_interrupt inti; 1783383d0b05SJens Freimann struct kvm_s390_irq irq; 17843c038e6bSDominik Dingel 17853c038e6bSDominik Dingel if (start_token) { 1786383d0b05SJens Freimann irq.u.ext.ext_params2 = token; 1787383d0b05SJens Freimann irq.type = KVM_S390_INT_PFAULT_INIT; 1788383d0b05SJens Freimann WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &irq)); 17893c038e6bSDominik Dingel } else { 17903c038e6bSDominik Dingel inti.type = KVM_S390_INT_PFAULT_DONE; 1791383d0b05SJens Freimann inti.parm64 = token; 17923c038e6bSDominik Dingel WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti)); 17933c038e6bSDominik Dingel } 17943c038e6bSDominik Dingel } 17953c038e6bSDominik Dingel 17963c038e6bSDominik Dingel void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu, 17973c038e6bSDominik Dingel struct kvm_async_pf *work) 17983c038e6bSDominik Dingel { 17993c038e6bSDominik Dingel trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token); 18003c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token); 18013c038e6bSDominik Dingel } 18023c038e6bSDominik Dingel 18033c038e6bSDominik Dingel void kvm_arch_async_page_present(struct kvm_vcpu *vcpu, 18043c038e6bSDominik Dingel struct kvm_async_pf *work) 18053c038e6bSDominik Dingel { 18063c038e6bSDominik Dingel trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token); 18073c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token); 18083c038e6bSDominik Dingel } 18093c038e6bSDominik Dingel 18103c038e6bSDominik Dingel void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu, 18113c038e6bSDominik Dingel struct kvm_async_pf *work) 18123c038e6bSDominik Dingel { 18133c038e6bSDominik Dingel /* s390 will always inject the page directly */ 18143c038e6bSDominik Dingel } 18153c038e6bSDominik Dingel 18163c038e6bSDominik Dingel bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu) 18173c038e6bSDominik Dingel { 18183c038e6bSDominik Dingel /* 18193c038e6bSDominik Dingel * s390 will always inject the page directly, 18203c038e6bSDominik Dingel * but we still want check_async_completion to cleanup 18213c038e6bSDominik Dingel */ 18223c038e6bSDominik Dingel return true; 18233c038e6bSDominik Dingel } 18243c038e6bSDominik Dingel 18253c038e6bSDominik Dingel static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu) 18263c038e6bSDominik Dingel { 18273c038e6bSDominik Dingel hva_t hva; 18283c038e6bSDominik Dingel struct kvm_arch_async_pf arch; 18293c038e6bSDominik Dingel int rc; 18303c038e6bSDominik Dingel 18313c038e6bSDominik Dingel if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 18323c038e6bSDominik Dingel return 0; 18333c038e6bSDominik Dingel if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) != 18343c038e6bSDominik Dingel vcpu->arch.pfault_compare) 18353c038e6bSDominik Dingel return 0; 18363c038e6bSDominik Dingel if (psw_extint_disabled(vcpu)) 18373c038e6bSDominik Dingel return 0; 18389a022067SDavid Hildenbrand if (kvm_s390_vcpu_has_irq(vcpu, 0)) 18393c038e6bSDominik Dingel return 0; 18403c038e6bSDominik Dingel if (!(vcpu->arch.sie_block->gcr[0] & 0x200ul)) 18413c038e6bSDominik Dingel return 0; 18423c038e6bSDominik Dingel if (!vcpu->arch.gmap->pfault_enabled) 18433c038e6bSDominik Dingel return 0; 18443c038e6bSDominik Dingel 184581480cc1SHeiko Carstens hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(current->thread.gmap_addr)); 184681480cc1SHeiko Carstens hva += current->thread.gmap_addr & ~PAGE_MASK; 184781480cc1SHeiko Carstens if (read_guest_real(vcpu, vcpu->arch.pfault_token, &arch.pfault_token, 8)) 18483c038e6bSDominik Dingel return 0; 18493c038e6bSDominik Dingel 18503c038e6bSDominik Dingel rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch); 18513c038e6bSDominik Dingel return rc; 18523c038e6bSDominik Dingel } 18533c038e6bSDominik Dingel 18543fb4c40fSThomas Huth static int vcpu_pre_run(struct kvm_vcpu *vcpu) 1855b0c632dbSHeiko Carstens { 18563fb4c40fSThomas Huth int rc, cpuflags; 1857e168bf8dSCarsten Otte 18583c038e6bSDominik Dingel /* 18593c038e6bSDominik Dingel * On s390 notifications for arriving pages will be delivered directly 18603c038e6bSDominik Dingel * to the guest but the house keeping for completed pfaults is 18613c038e6bSDominik Dingel * handled outside the worker. 18623c038e6bSDominik Dingel */ 18633c038e6bSDominik Dingel kvm_check_async_pf_completion(vcpu); 18643c038e6bSDominik Dingel 18655a32c1afSChristian Borntraeger memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16); 1866b0c632dbSHeiko Carstens 1867b0c632dbSHeiko Carstens if (need_resched()) 1868b0c632dbSHeiko Carstens schedule(); 1869b0c632dbSHeiko Carstens 1870d3a73acbSMartin Schwidefsky if (test_cpu_flag(CIF_MCCK_PENDING)) 187171cde587SChristian Borntraeger s390_handle_mcck(); 187271cde587SChristian Borntraeger 187379395031SJens Freimann if (!kvm_is_ucontrol(vcpu->kvm)) { 187479395031SJens Freimann rc = kvm_s390_deliver_pending_interrupts(vcpu); 187579395031SJens Freimann if (rc) 187679395031SJens Freimann return rc; 187779395031SJens Freimann } 18780ff31867SCarsten Otte 18792c70fe44SChristian Borntraeger rc = kvm_s390_handle_requests(vcpu); 18802c70fe44SChristian Borntraeger if (rc) 18812c70fe44SChristian Borntraeger return rc; 18822c70fe44SChristian Borntraeger 188327291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) { 188427291e21SDavid Hildenbrand kvm_s390_backup_guest_per_regs(vcpu); 188527291e21SDavid Hildenbrand kvm_s390_patch_guest_per_regs(vcpu); 188627291e21SDavid Hildenbrand } 188727291e21SDavid Hildenbrand 1888b0c632dbSHeiko Carstens vcpu->arch.sie_block->icptcode = 0; 18893fb4c40fSThomas Huth cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags); 18903fb4c40fSThomas Huth VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags); 18913fb4c40fSThomas Huth trace_kvm_s390_sie_enter(vcpu, cpuflags); 18922b29a9fdSDominik Dingel 18933fb4c40fSThomas Huth return 0; 18943fb4c40fSThomas Huth } 18953fb4c40fSThomas Huth 1896492d8642SThomas Huth static int vcpu_post_run_fault_in_sie(struct kvm_vcpu *vcpu) 1897492d8642SThomas Huth { 1898492d8642SThomas Huth psw_t *psw = &vcpu->arch.sie_block->gpsw; 1899492d8642SThomas Huth u8 opcode; 1900492d8642SThomas Huth int rc; 1901492d8642SThomas Huth 1902492d8642SThomas Huth VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction"); 1903492d8642SThomas Huth trace_kvm_s390_sie_fault(vcpu); 1904492d8642SThomas Huth 1905492d8642SThomas Huth /* 1906492d8642SThomas Huth * We want to inject an addressing exception, which is defined as a 1907492d8642SThomas Huth * suppressing or terminating exception. However, since we came here 1908492d8642SThomas Huth * by a DAT access exception, the PSW still points to the faulting 1909492d8642SThomas Huth * instruction since DAT exceptions are nullifying. So we've got 1910492d8642SThomas Huth * to look up the current opcode to get the length of the instruction 1911492d8642SThomas Huth * to be able to forward the PSW. 1912492d8642SThomas Huth */ 19138ae04b8fSAlexander Yarygin rc = read_guest(vcpu, psw->addr, 0, &opcode, 1); 1914492d8642SThomas Huth if (rc) 1915492d8642SThomas Huth return kvm_s390_inject_prog_cond(vcpu, rc); 1916492d8642SThomas Huth psw->addr = __rewind_psw(*psw, -insn_length(opcode)); 1917492d8642SThomas Huth 1918492d8642SThomas Huth return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING); 1919492d8642SThomas Huth } 1920492d8642SThomas Huth 19213fb4c40fSThomas Huth static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason) 19223fb4c40fSThomas Huth { 192324eb3a82SDominik Dingel int rc = -1; 19242b29a9fdSDominik Dingel 19252b29a9fdSDominik Dingel VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", 19262b29a9fdSDominik Dingel vcpu->arch.sie_block->icptcode); 19272b29a9fdSDominik Dingel trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode); 19282b29a9fdSDominik Dingel 192927291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) 193027291e21SDavid Hildenbrand kvm_s390_restore_guest_per_regs(vcpu); 193127291e21SDavid Hildenbrand 19323fb4c40fSThomas Huth if (exit_reason >= 0) { 19337c470539SMartin Schwidefsky rc = 0; 1934210b1607SThomas Huth } else if (kvm_is_ucontrol(vcpu->kvm)) { 1935210b1607SThomas Huth vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL; 1936210b1607SThomas Huth vcpu->run->s390_ucontrol.trans_exc_code = 1937210b1607SThomas Huth current->thread.gmap_addr; 1938210b1607SThomas Huth vcpu->run->s390_ucontrol.pgm_code = 0x10; 1939210b1607SThomas Huth rc = -EREMOTE; 194024eb3a82SDominik Dingel 194124eb3a82SDominik Dingel } else if (current->thread.gmap_pfault) { 19423c038e6bSDominik Dingel trace_kvm_s390_major_guest_pfault(vcpu); 194324eb3a82SDominik Dingel current->thread.gmap_pfault = 0; 1944fa576c58SThomas Huth if (kvm_arch_setup_async_pf(vcpu)) { 194524eb3a82SDominik Dingel rc = 0; 1946fa576c58SThomas Huth } else { 1947fa576c58SThomas Huth gpa_t gpa = current->thread.gmap_addr; 1948fa576c58SThomas Huth rc = kvm_arch_fault_in_page(vcpu, gpa, 1); 1949fa576c58SThomas Huth } 195024eb3a82SDominik Dingel } 195124eb3a82SDominik Dingel 1952492d8642SThomas Huth if (rc == -1) 1953492d8642SThomas Huth rc = vcpu_post_run_fault_in_sie(vcpu); 1954b0c632dbSHeiko Carstens 19555a32c1afSChristian Borntraeger memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16); 19563fb4c40fSThomas Huth 1957a76ccff6SThomas Huth if (rc == 0) { 1958a76ccff6SThomas Huth if (kvm_is_ucontrol(vcpu->kvm)) 19592955c83fSChristian Borntraeger /* Don't exit for host interrupts. */ 19602955c83fSChristian Borntraeger rc = vcpu->arch.sie_block->icptcode ? -EOPNOTSUPP : 0; 1961a76ccff6SThomas Huth else 1962a76ccff6SThomas Huth rc = kvm_handle_sie_intercept(vcpu); 1963a76ccff6SThomas Huth } 1964a76ccff6SThomas Huth 19653fb4c40fSThomas Huth return rc; 19663fb4c40fSThomas Huth } 19673fb4c40fSThomas Huth 19683fb4c40fSThomas Huth static int __vcpu_run(struct kvm_vcpu *vcpu) 19693fb4c40fSThomas Huth { 19703fb4c40fSThomas Huth int rc, exit_reason; 19713fb4c40fSThomas Huth 1972800c1065SThomas Huth /* 1973800c1065SThomas Huth * We try to hold kvm->srcu during most of vcpu_run (except when run- 1974800c1065SThomas Huth * ning the guest), so that memslots (and other stuff) are protected 1975800c1065SThomas Huth */ 1976800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 1977800c1065SThomas Huth 1978a76ccff6SThomas Huth do { 19793fb4c40fSThomas Huth rc = vcpu_pre_run(vcpu); 19803fb4c40fSThomas Huth if (rc) 1981a76ccff6SThomas Huth break; 19823fb4c40fSThomas Huth 1983800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 19843fb4c40fSThomas Huth /* 1985a76ccff6SThomas Huth * As PF_VCPU will be used in fault handler, between 1986a76ccff6SThomas Huth * guest_enter and guest_exit should be no uaccess. 19873fb4c40fSThomas Huth */ 19883fb4c40fSThomas Huth preempt_disable(); 19893fb4c40fSThomas Huth kvm_guest_enter(); 19903fb4c40fSThomas Huth preempt_enable(); 1991a76ccff6SThomas Huth exit_reason = sie64a(vcpu->arch.sie_block, 1992a76ccff6SThomas Huth vcpu->run->s.regs.gprs); 19933fb4c40fSThomas Huth kvm_guest_exit(); 1994800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 19953fb4c40fSThomas Huth 19963fb4c40fSThomas Huth rc = vcpu_post_run(vcpu, exit_reason); 199727291e21SDavid Hildenbrand } while (!signal_pending(current) && !guestdbg_exit_pending(vcpu) && !rc); 19983fb4c40fSThomas Huth 1999800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 2000e168bf8dSCarsten Otte return rc; 2001b0c632dbSHeiko Carstens } 2002b0c632dbSHeiko Carstens 2003b028ee3eSDavid Hildenbrand static void sync_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 2004b028ee3eSDavid Hildenbrand { 2005b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask; 2006b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr; 2007b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) 2008b028ee3eSDavid Hildenbrand kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix); 2009b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) { 2010b028ee3eSDavid Hildenbrand memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128); 2011d3d692c8SDavid Hildenbrand /* some control register changes require a tlb flush */ 2012d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 2013b028ee3eSDavid Hildenbrand } 2014b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_ARCH0) { 2015b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->cputm = kvm_run->s.regs.cputm; 2016b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->ckc = kvm_run->s.regs.ckc; 2017b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->todpr = kvm_run->s.regs.todpr; 2018b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->pp = kvm_run->s.regs.pp; 2019b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gbea = kvm_run->s.regs.gbea; 2020b028ee3eSDavid Hildenbrand } 2021b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PFAULT) { 2022b028ee3eSDavid Hildenbrand vcpu->arch.pfault_token = kvm_run->s.regs.pft; 2023b028ee3eSDavid Hildenbrand vcpu->arch.pfault_select = kvm_run->s.regs.pfs; 2024b028ee3eSDavid Hildenbrand vcpu->arch.pfault_compare = kvm_run->s.regs.pfc; 20259fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 20269fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 2027b028ee3eSDavid Hildenbrand } 2028b028ee3eSDavid Hildenbrand kvm_run->kvm_dirty_regs = 0; 2029b028ee3eSDavid Hildenbrand } 2030b028ee3eSDavid Hildenbrand 2031b028ee3eSDavid Hildenbrand static void store_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 2032b028ee3eSDavid Hildenbrand { 2033b028ee3eSDavid Hildenbrand kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask; 2034b028ee3eSDavid Hildenbrand kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr; 2035b028ee3eSDavid Hildenbrand kvm_run->s.regs.prefix = kvm_s390_get_prefix(vcpu); 2036b028ee3eSDavid Hildenbrand memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128); 2037b028ee3eSDavid Hildenbrand kvm_run->s.regs.cputm = vcpu->arch.sie_block->cputm; 2038b028ee3eSDavid Hildenbrand kvm_run->s.regs.ckc = vcpu->arch.sie_block->ckc; 2039b028ee3eSDavid Hildenbrand kvm_run->s.regs.todpr = vcpu->arch.sie_block->todpr; 2040b028ee3eSDavid Hildenbrand kvm_run->s.regs.pp = vcpu->arch.sie_block->pp; 2041b028ee3eSDavid Hildenbrand kvm_run->s.regs.gbea = vcpu->arch.sie_block->gbea; 2042b028ee3eSDavid Hildenbrand kvm_run->s.regs.pft = vcpu->arch.pfault_token; 2043b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfs = vcpu->arch.pfault_select; 2044b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfc = vcpu->arch.pfault_compare; 2045b028ee3eSDavid Hildenbrand } 2046b028ee3eSDavid Hildenbrand 2047b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 2048b0c632dbSHeiko Carstens { 20498f2abe6aSChristian Borntraeger int rc; 2050b0c632dbSHeiko Carstens sigset_t sigsaved; 2051b0c632dbSHeiko Carstens 205227291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu)) { 205327291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 205427291e21SDavid Hildenbrand return 0; 205527291e21SDavid Hildenbrand } 205627291e21SDavid Hildenbrand 2057b0c632dbSHeiko Carstens if (vcpu->sigset_active) 2058b0c632dbSHeiko Carstens sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); 2059b0c632dbSHeiko Carstens 20606352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) { 20616852d7b6SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 20626352e4d2SDavid Hildenbrand } else if (is_vcpu_stopped(vcpu)) { 20636352e4d2SDavid Hildenbrand pr_err_ratelimited("kvm-s390: can't run stopped vcpu %d\n", 20646352e4d2SDavid Hildenbrand vcpu->vcpu_id); 20656352e4d2SDavid Hildenbrand return -EINVAL; 20666352e4d2SDavid Hildenbrand } 2067b0c632dbSHeiko Carstens 2068b028ee3eSDavid Hildenbrand sync_regs(vcpu, kvm_run); 2069d7b0b5ebSCarsten Otte 2070dab4079dSHeiko Carstens might_fault(); 2071e168bf8dSCarsten Otte rc = __vcpu_run(vcpu); 20729ace903dSChristian Ehrhardt 2073b1d16c49SChristian Ehrhardt if (signal_pending(current) && !rc) { 2074b1d16c49SChristian Ehrhardt kvm_run->exit_reason = KVM_EXIT_INTR; 20758f2abe6aSChristian Borntraeger rc = -EINTR; 2076b1d16c49SChristian Ehrhardt } 20778f2abe6aSChristian Borntraeger 207827291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu) && !rc) { 207927291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 208027291e21SDavid Hildenbrand rc = 0; 208127291e21SDavid Hildenbrand } 208227291e21SDavid Hildenbrand 2083b8e660b8SHeiko Carstens if (rc == -EOPNOTSUPP) { 20848f2abe6aSChristian Borntraeger /* intercept cannot be handled in-kernel, prepare kvm-run */ 20858f2abe6aSChristian Borntraeger kvm_run->exit_reason = KVM_EXIT_S390_SIEIC; 20868f2abe6aSChristian Borntraeger kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode; 20878f2abe6aSChristian Borntraeger kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa; 20888f2abe6aSChristian Borntraeger kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb; 20898f2abe6aSChristian Borntraeger rc = 0; 20908f2abe6aSChristian Borntraeger } 20918f2abe6aSChristian Borntraeger 20928f2abe6aSChristian Borntraeger if (rc == -EREMOTE) { 20938f2abe6aSChristian Borntraeger /* intercept was handled, but userspace support is needed 20948f2abe6aSChristian Borntraeger * kvm_run has been prepared by the handler */ 20958f2abe6aSChristian Borntraeger rc = 0; 20968f2abe6aSChristian Borntraeger } 20978f2abe6aSChristian Borntraeger 2098b028ee3eSDavid Hildenbrand store_regs(vcpu, kvm_run); 2099d7b0b5ebSCarsten Otte 2100b0c632dbSHeiko Carstens if (vcpu->sigset_active) 2101b0c632dbSHeiko Carstens sigprocmask(SIG_SETMASK, &sigsaved, NULL); 2102b0c632dbSHeiko Carstens 2103b0c632dbSHeiko Carstens vcpu->stat.exit_userspace++; 21047e8e6ab4SHeiko Carstens return rc; 2105b0c632dbSHeiko Carstens } 2106b0c632dbSHeiko Carstens 2107b0c632dbSHeiko Carstens /* 2108b0c632dbSHeiko Carstens * store status at address 2109b0c632dbSHeiko Carstens * we use have two special cases: 2110b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit 2111b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_PREFIXED: -> prefix 2112b0c632dbSHeiko Carstens */ 2113d0bce605SHeiko Carstens int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long gpa) 2114b0c632dbSHeiko Carstens { 2115092670cdSCarsten Otte unsigned char archmode = 1; 2116fda902cbSMichael Mueller unsigned int px; 2117178bd789SThomas Huth u64 clkcomp; 2118d0bce605SHeiko Carstens int rc; 2119b0c632dbSHeiko Carstens 2120d0bce605SHeiko Carstens if (gpa == KVM_S390_STORE_STATUS_NOADDR) { 2121d0bce605SHeiko Carstens if (write_guest_abs(vcpu, 163, &archmode, 1)) 2122b0c632dbSHeiko Carstens return -EFAULT; 2123d0bce605SHeiko Carstens gpa = SAVE_AREA_BASE; 2124d0bce605SHeiko Carstens } else if (gpa == KVM_S390_STORE_STATUS_PREFIXED) { 2125d0bce605SHeiko Carstens if (write_guest_real(vcpu, 163, &archmode, 1)) 2126b0c632dbSHeiko Carstens return -EFAULT; 2127d0bce605SHeiko Carstens gpa = kvm_s390_real_to_abs(vcpu, SAVE_AREA_BASE); 2128d0bce605SHeiko Carstens } 2129d0bce605SHeiko Carstens rc = write_guest_abs(vcpu, gpa + offsetof(struct save_area, fp_regs), 2130d0bce605SHeiko Carstens vcpu->arch.guest_fpregs.fprs, 128); 2131d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, gp_regs), 2132d0bce605SHeiko Carstens vcpu->run->s.regs.gprs, 128); 2133d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, psw), 2134d0bce605SHeiko Carstens &vcpu->arch.sie_block->gpsw, 16); 2135fda902cbSMichael Mueller px = kvm_s390_get_prefix(vcpu); 2136d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, pref_reg), 2137fda902cbSMichael Mueller &px, 4); 2138d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, 2139d0bce605SHeiko Carstens gpa + offsetof(struct save_area, fp_ctrl_reg), 2140d0bce605SHeiko Carstens &vcpu->arch.guest_fpregs.fpc, 4); 2141d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, tod_reg), 2142d0bce605SHeiko Carstens &vcpu->arch.sie_block->todpr, 4); 2143d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, timer), 2144d0bce605SHeiko Carstens &vcpu->arch.sie_block->cputm, 8); 2145178bd789SThomas Huth clkcomp = vcpu->arch.sie_block->ckc >> 8; 2146d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, clk_cmp), 2147d0bce605SHeiko Carstens &clkcomp, 8); 2148d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, acc_regs), 2149d0bce605SHeiko Carstens &vcpu->run->s.regs.acrs, 64); 2150d0bce605SHeiko Carstens rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, ctrl_regs), 2151d0bce605SHeiko Carstens &vcpu->arch.sie_block->gcr, 128); 2152d0bce605SHeiko Carstens return rc ? -EFAULT : 0; 2153b0c632dbSHeiko Carstens } 2154b0c632dbSHeiko Carstens 2155e879892cSThomas Huth int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr) 2156e879892cSThomas Huth { 2157e879892cSThomas Huth /* 2158e879892cSThomas Huth * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy 2159e879892cSThomas Huth * copying in vcpu load/put. Lets update our copies before we save 2160e879892cSThomas Huth * it into the save area 2161e879892cSThomas Huth */ 2162e879892cSThomas Huth save_fp_ctl(&vcpu->arch.guest_fpregs.fpc); 2163e879892cSThomas Huth save_fp_regs(vcpu->arch.guest_fpregs.fprs); 2164e879892cSThomas Huth save_access_regs(vcpu->run->s.regs.acrs); 2165e879892cSThomas Huth 2166e879892cSThomas Huth return kvm_s390_store_status_unloaded(vcpu, addr); 2167e879892cSThomas Huth } 2168e879892cSThomas Huth 2169bc17de7cSEric Farman /* 2170bc17de7cSEric Farman * store additional status at address 2171bc17de7cSEric Farman */ 2172bc17de7cSEric Farman int kvm_s390_store_adtl_status_unloaded(struct kvm_vcpu *vcpu, 2173bc17de7cSEric Farman unsigned long gpa) 2174bc17de7cSEric Farman { 2175bc17de7cSEric Farman /* Only bits 0-53 are used for address formation */ 2176bc17de7cSEric Farman if (!(gpa & ~0x3ff)) 2177bc17de7cSEric Farman return 0; 2178bc17de7cSEric Farman 2179bc17de7cSEric Farman return write_guest_abs(vcpu, gpa & ~0x3ff, 2180bc17de7cSEric Farman (void *)&vcpu->run->s.regs.vrs, 512); 2181bc17de7cSEric Farman } 2182bc17de7cSEric Farman 2183bc17de7cSEric Farman int kvm_s390_vcpu_store_adtl_status(struct kvm_vcpu *vcpu, unsigned long addr) 2184bc17de7cSEric Farman { 2185bc17de7cSEric Farman if (!test_kvm_facility(vcpu->kvm, 129)) 2186bc17de7cSEric Farman return 0; 2187bc17de7cSEric Farman 2188bc17de7cSEric Farman /* 2189bc17de7cSEric Farman * The guest VXRS are in the host VXRs due to the lazy 2190bc17de7cSEric Farman * copying in vcpu load/put. Let's update our copies before we save 2191bc17de7cSEric Farman * it into the save area. 2192bc17de7cSEric Farman */ 2193bc17de7cSEric Farman save_vx_regs((__vector128 *)&vcpu->run->s.regs.vrs); 2194bc17de7cSEric Farman 2195bc17de7cSEric Farman return kvm_s390_store_adtl_status_unloaded(vcpu, addr); 2196bc17de7cSEric Farman } 2197bc17de7cSEric Farman 21988ad35755SDavid Hildenbrand static void __disable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 21998ad35755SDavid Hildenbrand { 22008ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu); 22018ad35755SDavid Hildenbrand kvm_make_request(KVM_REQ_DISABLE_IBS, vcpu); 22028ad35755SDavid Hildenbrand exit_sie_sync(vcpu); 22038ad35755SDavid Hildenbrand } 22048ad35755SDavid Hildenbrand 22058ad35755SDavid Hildenbrand static void __disable_ibs_on_all_vcpus(struct kvm *kvm) 22068ad35755SDavid Hildenbrand { 22078ad35755SDavid Hildenbrand unsigned int i; 22088ad35755SDavid Hildenbrand struct kvm_vcpu *vcpu; 22098ad35755SDavid Hildenbrand 22108ad35755SDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 22118ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 22128ad35755SDavid Hildenbrand } 22138ad35755SDavid Hildenbrand } 22148ad35755SDavid Hildenbrand 22158ad35755SDavid Hildenbrand static void __enable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 22168ad35755SDavid Hildenbrand { 22178ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu); 22188ad35755SDavid Hildenbrand kvm_make_request(KVM_REQ_ENABLE_IBS, vcpu); 22198ad35755SDavid Hildenbrand exit_sie_sync(vcpu); 22208ad35755SDavid Hildenbrand } 22218ad35755SDavid Hildenbrand 22226852d7b6SDavid Hildenbrand void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu) 22236852d7b6SDavid Hildenbrand { 22248ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 22258ad35755SDavid Hildenbrand 22268ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 22278ad35755SDavid Hildenbrand return; 22288ad35755SDavid Hildenbrand 22296852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 1); 22308ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 2231433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 22328ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 22338ad35755SDavid Hildenbrand 22348ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 22358ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) 22368ad35755SDavid Hildenbrand started_vcpus++; 22378ad35755SDavid Hildenbrand } 22388ad35755SDavid Hildenbrand 22398ad35755SDavid Hildenbrand if (started_vcpus == 0) { 22408ad35755SDavid Hildenbrand /* we're the only active VCPU -> speed it up */ 22418ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(vcpu); 22428ad35755SDavid Hildenbrand } else if (started_vcpus == 1) { 22438ad35755SDavid Hildenbrand /* 22448ad35755SDavid Hildenbrand * As we are starting a second VCPU, we have to disable 22458ad35755SDavid Hildenbrand * the IBS facility on all VCPUs to remove potentially 22468ad35755SDavid Hildenbrand * oustanding ENABLE requests. 22478ad35755SDavid Hildenbrand */ 22488ad35755SDavid Hildenbrand __disable_ibs_on_all_vcpus(vcpu->kvm); 22498ad35755SDavid Hildenbrand } 22508ad35755SDavid Hildenbrand 22516852d7b6SDavid Hildenbrand atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags); 22528ad35755SDavid Hildenbrand /* 22538ad35755SDavid Hildenbrand * Another VCPU might have used IBS while we were offline. 22548ad35755SDavid Hildenbrand * Let's play safe and flush the VCPU at startup. 22558ad35755SDavid Hildenbrand */ 2256d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 2257433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 22588ad35755SDavid Hildenbrand return; 22596852d7b6SDavid Hildenbrand } 22606852d7b6SDavid Hildenbrand 22616852d7b6SDavid Hildenbrand void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu) 22626852d7b6SDavid Hildenbrand { 22638ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 22648ad35755SDavid Hildenbrand struct kvm_vcpu *started_vcpu = NULL; 22658ad35755SDavid Hildenbrand 22668ad35755SDavid Hildenbrand if (is_vcpu_stopped(vcpu)) 22678ad35755SDavid Hildenbrand return; 22688ad35755SDavid Hildenbrand 22696852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 0); 22708ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 2271433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 22728ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 22738ad35755SDavid Hildenbrand 227432f5ff63SDavid Hildenbrand /* SIGP STOP and SIGP STOP AND STORE STATUS has been fully processed */ 22756cddd432SDavid Hildenbrand kvm_s390_clear_stop_irq(vcpu); 227632f5ff63SDavid Hildenbrand 22776cddd432SDavid Hildenbrand atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags); 22788ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 22798ad35755SDavid Hildenbrand 22808ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 22818ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) { 22828ad35755SDavid Hildenbrand started_vcpus++; 22838ad35755SDavid Hildenbrand started_vcpu = vcpu->kvm->vcpus[i]; 22848ad35755SDavid Hildenbrand } 22858ad35755SDavid Hildenbrand } 22868ad35755SDavid Hildenbrand 22878ad35755SDavid Hildenbrand if (started_vcpus == 1) { 22888ad35755SDavid Hildenbrand /* 22898ad35755SDavid Hildenbrand * As we only have one VCPU left, we want to enable the 22908ad35755SDavid Hildenbrand * IBS facility for that VCPU to speed it up. 22918ad35755SDavid Hildenbrand */ 22928ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(started_vcpu); 22938ad35755SDavid Hildenbrand } 22948ad35755SDavid Hildenbrand 2295433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 22968ad35755SDavid Hildenbrand return; 22976852d7b6SDavid Hildenbrand } 22986852d7b6SDavid Hildenbrand 2299d6712df9SCornelia Huck static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 2300d6712df9SCornelia Huck struct kvm_enable_cap *cap) 2301d6712df9SCornelia Huck { 2302d6712df9SCornelia Huck int r; 2303d6712df9SCornelia Huck 2304d6712df9SCornelia Huck if (cap->flags) 2305d6712df9SCornelia Huck return -EINVAL; 2306d6712df9SCornelia Huck 2307d6712df9SCornelia Huck switch (cap->cap) { 2308fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 2309fa6b7fe9SCornelia Huck if (!vcpu->kvm->arch.css_support) { 2310fa6b7fe9SCornelia Huck vcpu->kvm->arch.css_support = 1; 2311fa6b7fe9SCornelia Huck trace_kvm_s390_enable_css(vcpu->kvm); 2312fa6b7fe9SCornelia Huck } 2313fa6b7fe9SCornelia Huck r = 0; 2314fa6b7fe9SCornelia Huck break; 2315d6712df9SCornelia Huck default: 2316d6712df9SCornelia Huck r = -EINVAL; 2317d6712df9SCornelia Huck break; 2318d6712df9SCornelia Huck } 2319d6712df9SCornelia Huck return r; 2320d6712df9SCornelia Huck } 2321d6712df9SCornelia Huck 232241408c28SThomas Huth static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu, 232341408c28SThomas Huth struct kvm_s390_mem_op *mop) 232441408c28SThomas Huth { 232541408c28SThomas Huth void __user *uaddr = (void __user *)mop->buf; 232641408c28SThomas Huth void *tmpbuf = NULL; 232741408c28SThomas Huth int r, srcu_idx; 232841408c28SThomas Huth const u64 supported_flags = KVM_S390_MEMOP_F_INJECT_EXCEPTION 232941408c28SThomas Huth | KVM_S390_MEMOP_F_CHECK_ONLY; 233041408c28SThomas Huth 233141408c28SThomas Huth if (mop->flags & ~supported_flags) 233241408c28SThomas Huth return -EINVAL; 233341408c28SThomas Huth 233441408c28SThomas Huth if (mop->size > MEM_OP_MAX_SIZE) 233541408c28SThomas Huth return -E2BIG; 233641408c28SThomas Huth 233741408c28SThomas Huth if (!(mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY)) { 233841408c28SThomas Huth tmpbuf = vmalloc(mop->size); 233941408c28SThomas Huth if (!tmpbuf) 234041408c28SThomas Huth return -ENOMEM; 234141408c28SThomas Huth } 234241408c28SThomas Huth 234341408c28SThomas Huth srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 234441408c28SThomas Huth 234541408c28SThomas Huth switch (mop->op) { 234641408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_READ: 234741408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 234841408c28SThomas Huth r = check_gva_range(vcpu, mop->gaddr, mop->ar, mop->size, false); 234941408c28SThomas Huth break; 235041408c28SThomas Huth } 235141408c28SThomas Huth r = read_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 235241408c28SThomas Huth if (r == 0) { 235341408c28SThomas Huth if (copy_to_user(uaddr, tmpbuf, mop->size)) 235441408c28SThomas Huth r = -EFAULT; 235541408c28SThomas Huth } 235641408c28SThomas Huth break; 235741408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_WRITE: 235841408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 235941408c28SThomas Huth r = check_gva_range(vcpu, mop->gaddr, mop->ar, mop->size, true); 236041408c28SThomas Huth break; 236141408c28SThomas Huth } 236241408c28SThomas Huth if (copy_from_user(tmpbuf, uaddr, mop->size)) { 236341408c28SThomas Huth r = -EFAULT; 236441408c28SThomas Huth break; 236541408c28SThomas Huth } 236641408c28SThomas Huth r = write_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 236741408c28SThomas Huth break; 236841408c28SThomas Huth default: 236941408c28SThomas Huth r = -EINVAL; 237041408c28SThomas Huth } 237141408c28SThomas Huth 237241408c28SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, srcu_idx); 237341408c28SThomas Huth 237441408c28SThomas Huth if (r > 0 && (mop->flags & KVM_S390_MEMOP_F_INJECT_EXCEPTION) != 0) 237541408c28SThomas Huth kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm); 237641408c28SThomas Huth 237741408c28SThomas Huth vfree(tmpbuf); 237841408c28SThomas Huth return r; 237941408c28SThomas Huth } 238041408c28SThomas Huth 2381b0c632dbSHeiko Carstens long kvm_arch_vcpu_ioctl(struct file *filp, 2382b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 2383b0c632dbSHeiko Carstens { 2384b0c632dbSHeiko Carstens struct kvm_vcpu *vcpu = filp->private_data; 2385b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 2386800c1065SThomas Huth int idx; 2387bc923cc9SAvi Kivity long r; 2388b0c632dbSHeiko Carstens 238993736624SAvi Kivity switch (ioctl) { 239093736624SAvi Kivity case KVM_S390_INTERRUPT: { 2391ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 2392383d0b05SJens Freimann struct kvm_s390_irq s390irq; 2393ba5c1e9bSCarsten Otte 239493736624SAvi Kivity r = -EFAULT; 2395ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 239693736624SAvi Kivity break; 2397383d0b05SJens Freimann if (s390int_to_s390irq(&s390int, &s390irq)) 2398383d0b05SJens Freimann return -EINVAL; 2399383d0b05SJens Freimann r = kvm_s390_inject_vcpu(vcpu, &s390irq); 240093736624SAvi Kivity break; 2401ba5c1e9bSCarsten Otte } 2402b0c632dbSHeiko Carstens case KVM_S390_STORE_STATUS: 2403800c1065SThomas Huth idx = srcu_read_lock(&vcpu->kvm->srcu); 2404bc923cc9SAvi Kivity r = kvm_s390_vcpu_store_status(vcpu, arg); 2405800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, idx); 2406bc923cc9SAvi Kivity break; 2407b0c632dbSHeiko Carstens case KVM_S390_SET_INITIAL_PSW: { 2408b0c632dbSHeiko Carstens psw_t psw; 2409b0c632dbSHeiko Carstens 2410bc923cc9SAvi Kivity r = -EFAULT; 2411b0c632dbSHeiko Carstens if (copy_from_user(&psw, argp, sizeof(psw))) 2412bc923cc9SAvi Kivity break; 2413bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw); 2414bc923cc9SAvi Kivity break; 2415b0c632dbSHeiko Carstens } 2416b0c632dbSHeiko Carstens case KVM_S390_INITIAL_RESET: 2417bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_initial_reset(vcpu); 2418bc923cc9SAvi Kivity break; 241914eebd91SCarsten Otte case KVM_SET_ONE_REG: 242014eebd91SCarsten Otte case KVM_GET_ONE_REG: { 242114eebd91SCarsten Otte struct kvm_one_reg reg; 242214eebd91SCarsten Otte r = -EFAULT; 242314eebd91SCarsten Otte if (copy_from_user(®, argp, sizeof(reg))) 242414eebd91SCarsten Otte break; 242514eebd91SCarsten Otte if (ioctl == KVM_SET_ONE_REG) 242614eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, ®); 242714eebd91SCarsten Otte else 242814eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, ®); 242914eebd91SCarsten Otte break; 243014eebd91SCarsten Otte } 243127e0393fSCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 243227e0393fSCarsten Otte case KVM_S390_UCAS_MAP: { 243327e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 243427e0393fSCarsten Otte 243527e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 243627e0393fSCarsten Otte r = -EFAULT; 243727e0393fSCarsten Otte break; 243827e0393fSCarsten Otte } 243927e0393fSCarsten Otte 244027e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 244127e0393fSCarsten Otte r = -EINVAL; 244227e0393fSCarsten Otte break; 244327e0393fSCarsten Otte } 244427e0393fSCarsten Otte 244527e0393fSCarsten Otte r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr, 244627e0393fSCarsten Otte ucasmap.vcpu_addr, ucasmap.length); 244727e0393fSCarsten Otte break; 244827e0393fSCarsten Otte } 244927e0393fSCarsten Otte case KVM_S390_UCAS_UNMAP: { 245027e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 245127e0393fSCarsten Otte 245227e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 245327e0393fSCarsten Otte r = -EFAULT; 245427e0393fSCarsten Otte break; 245527e0393fSCarsten Otte } 245627e0393fSCarsten Otte 245727e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 245827e0393fSCarsten Otte r = -EINVAL; 245927e0393fSCarsten Otte break; 246027e0393fSCarsten Otte } 246127e0393fSCarsten Otte 246227e0393fSCarsten Otte r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr, 246327e0393fSCarsten Otte ucasmap.length); 246427e0393fSCarsten Otte break; 246527e0393fSCarsten Otte } 246627e0393fSCarsten Otte #endif 2467ccc7910fSCarsten Otte case KVM_S390_VCPU_FAULT: { 2468527e30b4SMartin Schwidefsky r = gmap_fault(vcpu->arch.gmap, arg, 0); 2469ccc7910fSCarsten Otte break; 2470ccc7910fSCarsten Otte } 2471d6712df9SCornelia Huck case KVM_ENABLE_CAP: 2472d6712df9SCornelia Huck { 2473d6712df9SCornelia Huck struct kvm_enable_cap cap; 2474d6712df9SCornelia Huck r = -EFAULT; 2475d6712df9SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 2476d6712df9SCornelia Huck break; 2477d6712df9SCornelia Huck r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 2478d6712df9SCornelia Huck break; 2479d6712df9SCornelia Huck } 248041408c28SThomas Huth case KVM_S390_MEM_OP: { 248141408c28SThomas Huth struct kvm_s390_mem_op mem_op; 248241408c28SThomas Huth 248341408c28SThomas Huth if (copy_from_user(&mem_op, argp, sizeof(mem_op)) == 0) 248441408c28SThomas Huth r = kvm_s390_guest_mem_op(vcpu, &mem_op); 248541408c28SThomas Huth else 248641408c28SThomas Huth r = -EFAULT; 248741408c28SThomas Huth break; 248841408c28SThomas Huth } 2489b0c632dbSHeiko Carstens default: 24903e6afcf1SCarsten Otte r = -ENOTTY; 2491b0c632dbSHeiko Carstens } 2492bc923cc9SAvi Kivity return r; 2493b0c632dbSHeiko Carstens } 2494b0c632dbSHeiko Carstens 24955b1c1493SCarsten Otte int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) 24965b1c1493SCarsten Otte { 24975b1c1493SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 24985b1c1493SCarsten Otte if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET) 24995b1c1493SCarsten Otte && (kvm_is_ucontrol(vcpu->kvm))) { 25005b1c1493SCarsten Otte vmf->page = virt_to_page(vcpu->arch.sie_block); 25015b1c1493SCarsten Otte get_page(vmf->page); 25025b1c1493SCarsten Otte return 0; 25035b1c1493SCarsten Otte } 25045b1c1493SCarsten Otte #endif 25055b1c1493SCarsten Otte return VM_FAULT_SIGBUS; 25065b1c1493SCarsten Otte } 25075b1c1493SCarsten Otte 25085587027cSAneesh Kumar K.V int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, 25095587027cSAneesh Kumar K.V unsigned long npages) 2510db3fe4ebSTakuya Yoshikawa { 2511db3fe4ebSTakuya Yoshikawa return 0; 2512db3fe4ebSTakuya Yoshikawa } 2513db3fe4ebSTakuya Yoshikawa 2514b0c632dbSHeiko Carstens /* Section: memory related */ 2515f7784b8eSMarcelo Tosatti int kvm_arch_prepare_memory_region(struct kvm *kvm, 2516f7784b8eSMarcelo Tosatti struct kvm_memory_slot *memslot, 25177b6195a9STakuya Yoshikawa struct kvm_userspace_memory_region *mem, 25187b6195a9STakuya Yoshikawa enum kvm_mr_change change) 2519b0c632dbSHeiko Carstens { 2520dd2887e7SNick Wang /* A few sanity checks. We can have memory slots which have to be 2521dd2887e7SNick Wang located/ended at a segment boundary (1MB). The memory in userland is 2522dd2887e7SNick Wang ok to be fragmented into various different vmas. It is okay to mmap() 2523dd2887e7SNick Wang and munmap() stuff in this slot after doing this call at any time */ 2524b0c632dbSHeiko Carstens 2525598841caSCarsten Otte if (mem->userspace_addr & 0xffffful) 2526b0c632dbSHeiko Carstens return -EINVAL; 2527b0c632dbSHeiko Carstens 2528598841caSCarsten Otte if (mem->memory_size & 0xffffful) 2529b0c632dbSHeiko Carstens return -EINVAL; 2530b0c632dbSHeiko Carstens 2531f7784b8eSMarcelo Tosatti return 0; 2532f7784b8eSMarcelo Tosatti } 2533f7784b8eSMarcelo Tosatti 2534f7784b8eSMarcelo Tosatti void kvm_arch_commit_memory_region(struct kvm *kvm, 2535f7784b8eSMarcelo Tosatti struct kvm_userspace_memory_region *mem, 25368482644aSTakuya Yoshikawa const struct kvm_memory_slot *old, 25378482644aSTakuya Yoshikawa enum kvm_mr_change change) 2538f7784b8eSMarcelo Tosatti { 2539f7850c92SCarsten Otte int rc; 2540f7784b8eSMarcelo Tosatti 25412cef4debSChristian Borntraeger /* If the basics of the memslot do not change, we do not want 25422cef4debSChristian Borntraeger * to update the gmap. Every update causes several unnecessary 25432cef4debSChristian Borntraeger * segment translation exceptions. This is usually handled just 25442cef4debSChristian Borntraeger * fine by the normal fault handler + gmap, but it will also 25452cef4debSChristian Borntraeger * cause faults on the prefix page of running guest CPUs. 25462cef4debSChristian Borntraeger */ 25472cef4debSChristian Borntraeger if (old->userspace_addr == mem->userspace_addr && 25482cef4debSChristian Borntraeger old->base_gfn * PAGE_SIZE == mem->guest_phys_addr && 25492cef4debSChristian Borntraeger old->npages * PAGE_SIZE == mem->memory_size) 25502cef4debSChristian Borntraeger return; 2551598841caSCarsten Otte 2552598841caSCarsten Otte rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr, 2553598841caSCarsten Otte mem->guest_phys_addr, mem->memory_size); 2554598841caSCarsten Otte if (rc) 2555f7850c92SCarsten Otte printk(KERN_WARNING "kvm-s390: failed to commit memory region\n"); 2556598841caSCarsten Otte return; 2557b0c632dbSHeiko Carstens } 2558b0c632dbSHeiko Carstens 2559b0c632dbSHeiko Carstens static int __init kvm_s390_init(void) 2560b0c632dbSHeiko Carstens { 25619d8d5786SMichael Mueller return kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); 2562b0c632dbSHeiko Carstens } 2563b0c632dbSHeiko Carstens 2564b0c632dbSHeiko Carstens static void __exit kvm_s390_exit(void) 2565b0c632dbSHeiko Carstens { 2566b0c632dbSHeiko Carstens kvm_exit(); 2567b0c632dbSHeiko Carstens } 2568b0c632dbSHeiko Carstens 2569b0c632dbSHeiko Carstens module_init(kvm_s390_init); 2570b0c632dbSHeiko Carstens module_exit(kvm_s390_exit); 2571566af940SCornelia Huck 2572566af940SCornelia Huck /* 2573566af940SCornelia Huck * Enable autoloading of the kvm module. 2574566af940SCornelia Huck * Note that we add the module alias here instead of virt/kvm/kvm_main.c 2575566af940SCornelia Huck * since x86 takes a different approach. 2576566af940SCornelia Huck */ 2577566af940SCornelia Huck #include <linux/miscdevice.h> 2578566af940SCornelia Huck MODULE_ALIAS_MISCDEV(KVM_MINOR); 2579566af940SCornelia Huck MODULE_ALIAS("devname:kvm"); 2580