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> 25b0c632dbSHeiko Carstens #include <linux/slab.h> 26ba5c1e9bSCarsten Otte #include <linux/timer.h> 27cbb870c8SHeiko Carstens #include <asm/asm-offsets.h> 28b0c632dbSHeiko Carstens #include <asm/lowcore.h> 29b0c632dbSHeiko Carstens #include <asm/pgtable.h> 30f5daba1dSHeiko Carstens #include <asm/nmi.h> 31a0616cdeSDavid Howells #include <asm/switch_to.h> 3278c4b59fSMichael Mueller #include <asm/facility.h> 331526bf9cSChristian Borntraeger #include <asm/sclp.h> 348f2abe6aSChristian Borntraeger #include "kvm-s390.h" 35b0c632dbSHeiko Carstens #include "gaccess.h" 36b0c632dbSHeiko Carstens 375786fffaSCornelia Huck #define CREATE_TRACE_POINTS 385786fffaSCornelia Huck #include "trace.h" 39ade38c31SCornelia Huck #include "trace-s390.h" 405786fffaSCornelia Huck 41b0c632dbSHeiko Carstens #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU 42b0c632dbSHeiko Carstens 43b0c632dbSHeiko Carstens struct kvm_stats_debugfs_item debugfs_entries[] = { 44b0c632dbSHeiko Carstens { "userspace_handled", VCPU_STAT(exit_userspace) }, 450eaeafa1SChristian Borntraeger { "exit_null", VCPU_STAT(exit_null) }, 468f2abe6aSChristian Borntraeger { "exit_validity", VCPU_STAT(exit_validity) }, 478f2abe6aSChristian Borntraeger { "exit_stop_request", VCPU_STAT(exit_stop_request) }, 488f2abe6aSChristian Borntraeger { "exit_external_request", VCPU_STAT(exit_external_request) }, 498f2abe6aSChristian Borntraeger { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) }, 50ba5c1e9bSCarsten Otte { "exit_instruction", VCPU_STAT(exit_instruction) }, 51ba5c1e9bSCarsten Otte { "exit_program_interruption", VCPU_STAT(exit_program_interruption) }, 52ba5c1e9bSCarsten Otte { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) }, 53f5e10b09SChristian Borntraeger { "instruction_lctlg", VCPU_STAT(instruction_lctlg) }, 54ba5c1e9bSCarsten Otte { "instruction_lctl", VCPU_STAT(instruction_lctl) }, 55ba5c1e9bSCarsten Otte { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) }, 567697e71fSChristian Ehrhardt { "deliver_external_call", VCPU_STAT(deliver_external_call) }, 57ba5c1e9bSCarsten Otte { "deliver_service_signal", VCPU_STAT(deliver_service_signal) }, 58ba5c1e9bSCarsten Otte { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) }, 59ba5c1e9bSCarsten Otte { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) }, 60ba5c1e9bSCarsten Otte { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) }, 61ba5c1e9bSCarsten Otte { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) }, 62ba5c1e9bSCarsten Otte { "deliver_program_interruption", VCPU_STAT(deliver_program_int) }, 63ba5c1e9bSCarsten Otte { "exit_wait_state", VCPU_STAT(exit_wait_state) }, 6469d0d3a3SChristian Borntraeger { "instruction_pfmf", VCPU_STAT(instruction_pfmf) }, 65453423dcSChristian Borntraeger { "instruction_stidp", VCPU_STAT(instruction_stidp) }, 66453423dcSChristian Borntraeger { "instruction_spx", VCPU_STAT(instruction_spx) }, 67453423dcSChristian Borntraeger { "instruction_stpx", VCPU_STAT(instruction_stpx) }, 68453423dcSChristian Borntraeger { "instruction_stap", VCPU_STAT(instruction_stap) }, 69453423dcSChristian Borntraeger { "instruction_storage_key", VCPU_STAT(instruction_storage_key) }, 70453423dcSChristian Borntraeger { "instruction_stsch", VCPU_STAT(instruction_stsch) }, 71453423dcSChristian Borntraeger { "instruction_chsc", VCPU_STAT(instruction_chsc) }, 72b31288faSKonstantin Weitz { "instruction_essa", VCPU_STAT(instruction_essa) }, 73453423dcSChristian Borntraeger { "instruction_stsi", VCPU_STAT(instruction_stsi) }, 74453423dcSChristian Borntraeger { "instruction_stfl", VCPU_STAT(instruction_stfl) }, 75bb25b9baSChristian Borntraeger { "instruction_tprot", VCPU_STAT(instruction_tprot) }, 765288fbf0SChristian Borntraeger { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) }, 77bd59d3a4SCornelia Huck { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) }, 787697e71fSChristian Ehrhardt { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) }, 795288fbf0SChristian Borntraeger { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) }, 805288fbf0SChristian Borntraeger { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) }, 815288fbf0SChristian Borntraeger { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) }, 825288fbf0SChristian Borntraeger { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) }, 835288fbf0SChristian Borntraeger { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) }, 84388186bcSChristian Borntraeger { "diagnose_10", VCPU_STAT(diagnose_10) }, 85e28acfeaSChristian Borntraeger { "diagnose_44", VCPU_STAT(diagnose_44) }, 8641628d33SKonstantin Weitz { "diagnose_9c", VCPU_STAT(diagnose_9c) }, 87b0c632dbSHeiko Carstens { NULL } 88b0c632dbSHeiko Carstens }; 89b0c632dbSHeiko Carstens 9078c4b59fSMichael Mueller unsigned long *vfacilities; 912c70fe44SChristian Borntraeger static struct gmap_notifier gmap_notifier; 92b0c632dbSHeiko Carstens 9378c4b59fSMichael Mueller /* test availability of vfacility */ 94280ef0f1SHeiko Carstens int test_vfacility(unsigned long nr) 9578c4b59fSMichael Mueller { 9678c4b59fSMichael Mueller return __test_facility(nr, (void *) vfacilities); 9778c4b59fSMichael Mueller } 9878c4b59fSMichael Mueller 99b0c632dbSHeiko Carstens /* Section: not file related */ 10010474ae8SAlexander Graf int kvm_arch_hardware_enable(void *garbage) 101b0c632dbSHeiko Carstens { 102b0c632dbSHeiko Carstens /* every s390 is virtualization enabled ;-) */ 10310474ae8SAlexander Graf return 0; 104b0c632dbSHeiko Carstens } 105b0c632dbSHeiko Carstens 106b0c632dbSHeiko Carstens void kvm_arch_hardware_disable(void *garbage) 107b0c632dbSHeiko Carstens { 108b0c632dbSHeiko Carstens } 109b0c632dbSHeiko Carstens 1102c70fe44SChristian Borntraeger static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address); 1112c70fe44SChristian Borntraeger 112b0c632dbSHeiko Carstens int kvm_arch_hardware_setup(void) 113b0c632dbSHeiko Carstens { 1142c70fe44SChristian Borntraeger gmap_notifier.notifier_call = kvm_gmap_notifier; 1152c70fe44SChristian Borntraeger gmap_register_ipte_notifier(&gmap_notifier); 116b0c632dbSHeiko Carstens return 0; 117b0c632dbSHeiko Carstens } 118b0c632dbSHeiko Carstens 119b0c632dbSHeiko Carstens void kvm_arch_hardware_unsetup(void) 120b0c632dbSHeiko Carstens { 1212c70fe44SChristian Borntraeger gmap_unregister_ipte_notifier(&gmap_notifier); 122b0c632dbSHeiko Carstens } 123b0c632dbSHeiko Carstens 124b0c632dbSHeiko Carstens void kvm_arch_check_processor_compat(void *rtn) 125b0c632dbSHeiko Carstens { 126b0c632dbSHeiko Carstens } 127b0c632dbSHeiko Carstens 128b0c632dbSHeiko Carstens int kvm_arch_init(void *opaque) 129b0c632dbSHeiko Carstens { 130b0c632dbSHeiko Carstens return 0; 131b0c632dbSHeiko Carstens } 132b0c632dbSHeiko Carstens 133b0c632dbSHeiko Carstens void kvm_arch_exit(void) 134b0c632dbSHeiko Carstens { 135b0c632dbSHeiko Carstens } 136b0c632dbSHeiko Carstens 137b0c632dbSHeiko Carstens /* Section: device related */ 138b0c632dbSHeiko Carstens long kvm_arch_dev_ioctl(struct file *filp, 139b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 140b0c632dbSHeiko Carstens { 141b0c632dbSHeiko Carstens if (ioctl == KVM_S390_ENABLE_SIE) 142b0c632dbSHeiko Carstens return s390_enable_sie(); 143b0c632dbSHeiko Carstens return -EINVAL; 144b0c632dbSHeiko Carstens } 145b0c632dbSHeiko Carstens 146b0c632dbSHeiko Carstens int kvm_dev_ioctl_check_extension(long ext) 147b0c632dbSHeiko Carstens { 148d7b0b5ebSCarsten Otte int r; 149d7b0b5ebSCarsten Otte 1502bd0ac4eSCarsten Otte switch (ext) { 151d7b0b5ebSCarsten Otte case KVM_CAP_S390_PSW: 152b6cf8788SChristian Borntraeger case KVM_CAP_S390_GMAP: 15352e16b18SChristian Borntraeger case KVM_CAP_SYNC_MMU: 1541efd0f59SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 1551efd0f59SCarsten Otte case KVM_CAP_S390_UCONTROL: 1561efd0f59SCarsten Otte #endif 1573c038e6bSDominik Dingel case KVM_CAP_ASYNC_PF: 15860b413c9SChristian Borntraeger case KVM_CAP_SYNC_REGS: 15914eebd91SCarsten Otte case KVM_CAP_ONE_REG: 160d6712df9SCornelia Huck case KVM_CAP_ENABLE_CAP: 161fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 16210ccaa1eSCornelia Huck case KVM_CAP_IOEVENTFD: 163c05c4186SJens Freimann case KVM_CAP_DEVICE_CTRL: 164d938dc55SCornelia Huck case KVM_CAP_ENABLE_CAP_VM: 165f2061656SDominik Dingel case KVM_CAP_VM_ATTRIBUTES: 166d7b0b5ebSCarsten Otte r = 1; 167d7b0b5ebSCarsten Otte break; 168e726b1bdSChristian Borntraeger case KVM_CAP_NR_VCPUS: 169e726b1bdSChristian Borntraeger case KVM_CAP_MAX_VCPUS: 170e726b1bdSChristian Borntraeger r = KVM_MAX_VCPUS; 171e726b1bdSChristian Borntraeger break; 172e1e2e605SNick Wang case KVM_CAP_NR_MEMSLOTS: 173e1e2e605SNick Wang r = KVM_USER_MEM_SLOTS; 174e1e2e605SNick Wang break; 1751526bf9cSChristian Borntraeger case KVM_CAP_S390_COW: 176abf09bedSMartin Schwidefsky r = MACHINE_HAS_ESOP; 1771526bf9cSChristian Borntraeger break; 1782bd0ac4eSCarsten Otte default: 179d7b0b5ebSCarsten Otte r = 0; 180b0c632dbSHeiko Carstens } 181d7b0b5ebSCarsten Otte return r; 1822bd0ac4eSCarsten Otte } 183b0c632dbSHeiko Carstens 18415f36ebdSJason J. Herne static void kvm_s390_sync_dirty_log(struct kvm *kvm, 18515f36ebdSJason J. Herne struct kvm_memory_slot *memslot) 18615f36ebdSJason J. Herne { 18715f36ebdSJason J. Herne gfn_t cur_gfn, last_gfn; 18815f36ebdSJason J. Herne unsigned long address; 18915f36ebdSJason J. Herne struct gmap *gmap = kvm->arch.gmap; 19015f36ebdSJason J. Herne 19115f36ebdSJason J. Herne down_read(&gmap->mm->mmap_sem); 19215f36ebdSJason J. Herne /* Loop over all guest pages */ 19315f36ebdSJason J. Herne last_gfn = memslot->base_gfn + memslot->npages; 19415f36ebdSJason J. Herne for (cur_gfn = memslot->base_gfn; cur_gfn <= last_gfn; cur_gfn++) { 19515f36ebdSJason J. Herne address = gfn_to_hva_memslot(memslot, cur_gfn); 19615f36ebdSJason J. Herne 19715f36ebdSJason J. Herne if (gmap_test_and_clear_dirty(address, gmap)) 19815f36ebdSJason J. Herne mark_page_dirty(kvm, cur_gfn); 19915f36ebdSJason J. Herne } 20015f36ebdSJason J. Herne up_read(&gmap->mm->mmap_sem); 20115f36ebdSJason J. Herne } 20215f36ebdSJason J. Herne 203b0c632dbSHeiko Carstens /* Section: vm related */ 204b0c632dbSHeiko Carstens /* 205b0c632dbSHeiko Carstens * Get (and clear) the dirty memory log for a memory slot. 206b0c632dbSHeiko Carstens */ 207b0c632dbSHeiko Carstens int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, 208b0c632dbSHeiko Carstens struct kvm_dirty_log *log) 209b0c632dbSHeiko Carstens { 21015f36ebdSJason J. Herne int r; 21115f36ebdSJason J. Herne unsigned long n; 21215f36ebdSJason J. Herne struct kvm_memory_slot *memslot; 21315f36ebdSJason J. Herne int is_dirty = 0; 21415f36ebdSJason J. Herne 21515f36ebdSJason J. Herne mutex_lock(&kvm->slots_lock); 21615f36ebdSJason J. Herne 21715f36ebdSJason J. Herne r = -EINVAL; 21815f36ebdSJason J. Herne if (log->slot >= KVM_USER_MEM_SLOTS) 21915f36ebdSJason J. Herne goto out; 22015f36ebdSJason J. Herne 22115f36ebdSJason J. Herne memslot = id_to_memslot(kvm->memslots, log->slot); 22215f36ebdSJason J. Herne r = -ENOENT; 22315f36ebdSJason J. Herne if (!memslot->dirty_bitmap) 22415f36ebdSJason J. Herne goto out; 22515f36ebdSJason J. Herne 22615f36ebdSJason J. Herne kvm_s390_sync_dirty_log(kvm, memslot); 22715f36ebdSJason J. Herne r = kvm_get_dirty_log(kvm, log, &is_dirty); 22815f36ebdSJason J. Herne if (r) 22915f36ebdSJason J. Herne goto out; 23015f36ebdSJason J. Herne 23115f36ebdSJason J. Herne /* Clear the dirty log */ 23215f36ebdSJason J. Herne if (is_dirty) { 23315f36ebdSJason J. Herne n = kvm_dirty_bitmap_bytes(memslot); 23415f36ebdSJason J. Herne memset(memslot->dirty_bitmap, 0, n); 23515f36ebdSJason J. Herne } 23615f36ebdSJason J. Herne r = 0; 23715f36ebdSJason J. Herne out: 23815f36ebdSJason J. Herne mutex_unlock(&kvm->slots_lock); 23915f36ebdSJason J. Herne return r; 240b0c632dbSHeiko Carstens } 241b0c632dbSHeiko Carstens 242d938dc55SCornelia Huck static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap) 243d938dc55SCornelia Huck { 244d938dc55SCornelia Huck int r; 245d938dc55SCornelia Huck 246d938dc55SCornelia Huck if (cap->flags) 247d938dc55SCornelia Huck return -EINVAL; 248d938dc55SCornelia Huck 249d938dc55SCornelia Huck switch (cap->cap) { 25084223598SCornelia Huck case KVM_CAP_S390_IRQCHIP: 25184223598SCornelia Huck kvm->arch.use_irqchip = 1; 25284223598SCornelia Huck r = 0; 25384223598SCornelia Huck break; 254d938dc55SCornelia Huck default: 255d938dc55SCornelia Huck r = -EINVAL; 256d938dc55SCornelia Huck break; 257d938dc55SCornelia Huck } 258d938dc55SCornelia Huck return r; 259d938dc55SCornelia Huck } 260d938dc55SCornelia Huck 2614f718eabSDominik Dingel static int kvm_s390_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 2624f718eabSDominik Dingel { 2634f718eabSDominik Dingel int ret; 2644f718eabSDominik Dingel unsigned int idx; 2654f718eabSDominik Dingel switch (attr->attr) { 2664f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 2674f718eabSDominik Dingel ret = -EBUSY; 2684f718eabSDominik Dingel mutex_lock(&kvm->lock); 2694f718eabSDominik Dingel if (atomic_read(&kvm->online_vcpus) == 0) { 2704f718eabSDominik Dingel kvm->arch.use_cmma = 1; 2714f718eabSDominik Dingel ret = 0; 2724f718eabSDominik Dingel } 2734f718eabSDominik Dingel mutex_unlock(&kvm->lock); 2744f718eabSDominik Dingel break; 2754f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 2764f718eabSDominik Dingel mutex_lock(&kvm->lock); 2774f718eabSDominik Dingel idx = srcu_read_lock(&kvm->srcu); 2784f718eabSDominik Dingel page_table_reset_pgste(kvm->arch.gmap->mm, 0, TASK_SIZE, false); 2794f718eabSDominik Dingel srcu_read_unlock(&kvm->srcu, idx); 2804f718eabSDominik Dingel mutex_unlock(&kvm->lock); 2814f718eabSDominik Dingel ret = 0; 2824f718eabSDominik Dingel break; 2834f718eabSDominik Dingel default: 2844f718eabSDominik Dingel ret = -ENXIO; 2854f718eabSDominik Dingel break; 2864f718eabSDominik Dingel } 2874f718eabSDominik Dingel return ret; 2884f718eabSDominik Dingel } 2894f718eabSDominik Dingel 290f2061656SDominik Dingel static int kvm_s390_vm_set_attr(struct kvm *kvm, struct kvm_device_attr *attr) 291f2061656SDominik Dingel { 292f2061656SDominik Dingel int ret; 293f2061656SDominik Dingel 294f2061656SDominik Dingel switch (attr->group) { 2954f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 2964f718eabSDominik Dingel ret = kvm_s390_mem_control(kvm, attr); 2974f718eabSDominik Dingel break; 298f2061656SDominik Dingel default: 299f2061656SDominik Dingel ret = -ENXIO; 300f2061656SDominik Dingel break; 301f2061656SDominik Dingel } 302f2061656SDominik Dingel 303f2061656SDominik Dingel return ret; 304f2061656SDominik Dingel } 305f2061656SDominik Dingel 306f2061656SDominik Dingel static int kvm_s390_vm_get_attr(struct kvm *kvm, struct kvm_device_attr *attr) 307f2061656SDominik Dingel { 308f2061656SDominik Dingel return -ENXIO; 309f2061656SDominik Dingel } 310f2061656SDominik Dingel 311f2061656SDominik Dingel static int kvm_s390_vm_has_attr(struct kvm *kvm, struct kvm_device_attr *attr) 312f2061656SDominik Dingel { 313f2061656SDominik Dingel int ret; 314f2061656SDominik Dingel 315f2061656SDominik Dingel switch (attr->group) { 3164f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 3174f718eabSDominik Dingel switch (attr->attr) { 3184f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 3194f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 3204f718eabSDominik Dingel ret = 0; 3214f718eabSDominik Dingel break; 3224f718eabSDominik Dingel default: 3234f718eabSDominik Dingel ret = -ENXIO; 3244f718eabSDominik Dingel break; 3254f718eabSDominik Dingel } 3264f718eabSDominik Dingel break; 327f2061656SDominik Dingel default: 328f2061656SDominik Dingel ret = -ENXIO; 329f2061656SDominik Dingel break; 330f2061656SDominik Dingel } 331f2061656SDominik Dingel 332f2061656SDominik Dingel return ret; 333f2061656SDominik Dingel } 334f2061656SDominik Dingel 335b0c632dbSHeiko Carstens long kvm_arch_vm_ioctl(struct file *filp, 336b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 337b0c632dbSHeiko Carstens { 338b0c632dbSHeiko Carstens struct kvm *kvm = filp->private_data; 339b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 340f2061656SDominik Dingel struct kvm_device_attr attr; 341b0c632dbSHeiko Carstens int r; 342b0c632dbSHeiko Carstens 343b0c632dbSHeiko Carstens switch (ioctl) { 344ba5c1e9bSCarsten Otte case KVM_S390_INTERRUPT: { 345ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 346ba5c1e9bSCarsten Otte 347ba5c1e9bSCarsten Otte r = -EFAULT; 348ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 349ba5c1e9bSCarsten Otte break; 350ba5c1e9bSCarsten Otte r = kvm_s390_inject_vm(kvm, &s390int); 351ba5c1e9bSCarsten Otte break; 352ba5c1e9bSCarsten Otte } 353d938dc55SCornelia Huck case KVM_ENABLE_CAP: { 354d938dc55SCornelia Huck struct kvm_enable_cap cap; 355d938dc55SCornelia Huck r = -EFAULT; 356d938dc55SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 357d938dc55SCornelia Huck break; 358d938dc55SCornelia Huck r = kvm_vm_ioctl_enable_cap(kvm, &cap); 359d938dc55SCornelia Huck break; 360d938dc55SCornelia Huck } 36184223598SCornelia Huck case KVM_CREATE_IRQCHIP: { 36284223598SCornelia Huck struct kvm_irq_routing_entry routing; 36384223598SCornelia Huck 36484223598SCornelia Huck r = -EINVAL; 36584223598SCornelia Huck if (kvm->arch.use_irqchip) { 36684223598SCornelia Huck /* Set up dummy routing. */ 36784223598SCornelia Huck memset(&routing, 0, sizeof(routing)); 36884223598SCornelia Huck kvm_set_irq_routing(kvm, &routing, 0, 0); 36984223598SCornelia Huck r = 0; 37084223598SCornelia Huck } 37184223598SCornelia Huck break; 37284223598SCornelia Huck } 373f2061656SDominik Dingel case KVM_SET_DEVICE_ATTR: { 374f2061656SDominik Dingel r = -EFAULT; 375f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 376f2061656SDominik Dingel break; 377f2061656SDominik Dingel r = kvm_s390_vm_set_attr(kvm, &attr); 378f2061656SDominik Dingel break; 379f2061656SDominik Dingel } 380f2061656SDominik Dingel case KVM_GET_DEVICE_ATTR: { 381f2061656SDominik Dingel r = -EFAULT; 382f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 383f2061656SDominik Dingel break; 384f2061656SDominik Dingel r = kvm_s390_vm_get_attr(kvm, &attr); 385f2061656SDominik Dingel break; 386f2061656SDominik Dingel } 387f2061656SDominik Dingel case KVM_HAS_DEVICE_ATTR: { 388f2061656SDominik Dingel r = -EFAULT; 389f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 390f2061656SDominik Dingel break; 391f2061656SDominik Dingel r = kvm_s390_vm_has_attr(kvm, &attr); 392f2061656SDominik Dingel break; 393f2061656SDominik Dingel } 394b0c632dbSHeiko Carstens default: 395367e1319SAvi Kivity r = -ENOTTY; 396b0c632dbSHeiko Carstens } 397b0c632dbSHeiko Carstens 398b0c632dbSHeiko Carstens return r; 399b0c632dbSHeiko Carstens } 400b0c632dbSHeiko Carstens 401e08b9637SCarsten Otte int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 402b0c632dbSHeiko Carstens { 403b0c632dbSHeiko Carstens int rc; 404b0c632dbSHeiko Carstens char debug_name[16]; 405f6c137ffSChristian Borntraeger static unsigned long sca_offset; 406b0c632dbSHeiko Carstens 407e08b9637SCarsten Otte rc = -EINVAL; 408e08b9637SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 409e08b9637SCarsten Otte if (type & ~KVM_VM_S390_UCONTROL) 410e08b9637SCarsten Otte goto out_err; 411e08b9637SCarsten Otte if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN))) 412e08b9637SCarsten Otte goto out_err; 413e08b9637SCarsten Otte #else 414e08b9637SCarsten Otte if (type) 415e08b9637SCarsten Otte goto out_err; 416e08b9637SCarsten Otte #endif 417e08b9637SCarsten Otte 418b0c632dbSHeiko Carstens rc = s390_enable_sie(); 419b0c632dbSHeiko Carstens if (rc) 420d89f5effSJan Kiszka goto out_err; 421b0c632dbSHeiko Carstens 422b290411aSCarsten Otte rc = -ENOMEM; 423b290411aSCarsten Otte 424b0c632dbSHeiko Carstens kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL); 425b0c632dbSHeiko Carstens if (!kvm->arch.sca) 426d89f5effSJan Kiszka goto out_err; 427f6c137ffSChristian Borntraeger spin_lock(&kvm_lock); 428f6c137ffSChristian Borntraeger sca_offset = (sca_offset + 16) & 0x7f0; 429f6c137ffSChristian Borntraeger kvm->arch.sca = (struct sca_block *) ((char *) kvm->arch.sca + sca_offset); 430f6c137ffSChristian Borntraeger spin_unlock(&kvm_lock); 431b0c632dbSHeiko Carstens 432b0c632dbSHeiko Carstens sprintf(debug_name, "kvm-%u", current->pid); 433b0c632dbSHeiko Carstens 434b0c632dbSHeiko Carstens kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long)); 435b0c632dbSHeiko Carstens if (!kvm->arch.dbf) 436b0c632dbSHeiko Carstens goto out_nodbf; 437b0c632dbSHeiko Carstens 438ba5c1e9bSCarsten Otte spin_lock_init(&kvm->arch.float_int.lock); 439ba5c1e9bSCarsten Otte INIT_LIST_HEAD(&kvm->arch.float_int.list); 440ba5c1e9bSCarsten Otte 441b0c632dbSHeiko Carstens debug_register_view(kvm->arch.dbf, &debug_sprintf_view); 442b0c632dbSHeiko Carstens VM_EVENT(kvm, 3, "%s", "vm created"); 443b0c632dbSHeiko Carstens 444e08b9637SCarsten Otte if (type & KVM_VM_S390_UCONTROL) { 445e08b9637SCarsten Otte kvm->arch.gmap = NULL; 446e08b9637SCarsten Otte } else { 447598841caSCarsten Otte kvm->arch.gmap = gmap_alloc(current->mm); 448598841caSCarsten Otte if (!kvm->arch.gmap) 449598841caSCarsten Otte goto out_nogmap; 4502c70fe44SChristian Borntraeger kvm->arch.gmap->private = kvm; 45124eb3a82SDominik Dingel kvm->arch.gmap->pfault_enabled = 0; 452e08b9637SCarsten Otte } 453fa6b7fe9SCornelia Huck 454fa6b7fe9SCornelia Huck kvm->arch.css_support = 0; 45584223598SCornelia Huck kvm->arch.use_irqchip = 0; 456fa6b7fe9SCornelia Huck 457d89f5effSJan Kiszka return 0; 458598841caSCarsten Otte out_nogmap: 459598841caSCarsten Otte debug_unregister(kvm->arch.dbf); 460b0c632dbSHeiko Carstens out_nodbf: 461b0c632dbSHeiko Carstens free_page((unsigned long)(kvm->arch.sca)); 462d89f5effSJan Kiszka out_err: 463d89f5effSJan Kiszka return rc; 464b0c632dbSHeiko Carstens } 465b0c632dbSHeiko Carstens 466d329c035SChristian Borntraeger void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 467d329c035SChristian Borntraeger { 468d329c035SChristian Borntraeger VCPU_EVENT(vcpu, 3, "%s", "free cpu"); 469ade38c31SCornelia Huck trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id); 4703c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 47158f9460bSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 47258f9460bSCarsten Otte clear_bit(63 - vcpu->vcpu_id, 47358f9460bSCarsten Otte (unsigned long *) &vcpu->kvm->arch.sca->mcn); 474abf4a71eSCarsten Otte if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda == 475abf4a71eSCarsten Otte (__u64) vcpu->arch.sie_block) 476abf4a71eSCarsten Otte vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0; 47758f9460bSCarsten Otte } 478abf4a71eSCarsten Otte smp_mb(); 47927e0393fSCarsten Otte 48027e0393fSCarsten Otte if (kvm_is_ucontrol(vcpu->kvm)) 48127e0393fSCarsten Otte gmap_free(vcpu->arch.gmap); 48227e0393fSCarsten Otte 483b31605c1SDominik Dingel if (kvm_s390_cmma_enabled(vcpu->kvm)) 484b31605c1SDominik Dingel kvm_s390_vcpu_unsetup_cmma(vcpu); 485d329c035SChristian Borntraeger free_page((unsigned long)(vcpu->arch.sie_block)); 486b31288faSKonstantin Weitz 4876692cef3SChristian Borntraeger kvm_vcpu_uninit(vcpu); 488b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 489d329c035SChristian Borntraeger } 490d329c035SChristian Borntraeger 491d329c035SChristian Borntraeger static void kvm_free_vcpus(struct kvm *kvm) 492d329c035SChristian Borntraeger { 493d329c035SChristian Borntraeger unsigned int i; 494988a2caeSGleb Natapov struct kvm_vcpu *vcpu; 495d329c035SChristian Borntraeger 496988a2caeSGleb Natapov kvm_for_each_vcpu(i, vcpu, kvm) 497988a2caeSGleb Natapov kvm_arch_vcpu_destroy(vcpu); 498988a2caeSGleb Natapov 499988a2caeSGleb Natapov mutex_lock(&kvm->lock); 500988a2caeSGleb Natapov for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 501d329c035SChristian Borntraeger kvm->vcpus[i] = NULL; 502988a2caeSGleb Natapov 503988a2caeSGleb Natapov atomic_set(&kvm->online_vcpus, 0); 504988a2caeSGleb Natapov mutex_unlock(&kvm->lock); 505d329c035SChristian Borntraeger } 506d329c035SChristian Borntraeger 507ad8ba2cdSSheng Yang void kvm_arch_sync_events(struct kvm *kvm) 508ad8ba2cdSSheng Yang { 509ad8ba2cdSSheng Yang } 510ad8ba2cdSSheng Yang 511b0c632dbSHeiko Carstens void kvm_arch_destroy_vm(struct kvm *kvm) 512b0c632dbSHeiko Carstens { 513d329c035SChristian Borntraeger kvm_free_vcpus(kvm); 514b0c632dbSHeiko Carstens free_page((unsigned long)(kvm->arch.sca)); 515d329c035SChristian Borntraeger debug_unregister(kvm->arch.dbf); 51627e0393fSCarsten Otte if (!kvm_is_ucontrol(kvm)) 517598841caSCarsten Otte gmap_free(kvm->arch.gmap); 518841b91c5SCornelia Huck kvm_s390_destroy_adapters(kvm); 519b0c632dbSHeiko Carstens } 520b0c632dbSHeiko Carstens 521b0c632dbSHeiko Carstens /* Section: vcpu related */ 522b0c632dbSHeiko Carstens int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 523b0c632dbSHeiko Carstens { 5243c038e6bSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 5253c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 52627e0393fSCarsten Otte if (kvm_is_ucontrol(vcpu->kvm)) { 52727e0393fSCarsten Otte vcpu->arch.gmap = gmap_alloc(current->mm); 52827e0393fSCarsten Otte if (!vcpu->arch.gmap) 52927e0393fSCarsten Otte return -ENOMEM; 5302c70fe44SChristian Borntraeger vcpu->arch.gmap->private = vcpu->kvm; 53127e0393fSCarsten Otte return 0; 53227e0393fSCarsten Otte } 53327e0393fSCarsten Otte 534598841caSCarsten Otte vcpu->arch.gmap = vcpu->kvm->arch.gmap; 53559674c1aSChristian Borntraeger vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX | 53659674c1aSChristian Borntraeger KVM_SYNC_GPRS | 5379eed0735SChristian Borntraeger KVM_SYNC_ACRS | 5389eed0735SChristian Borntraeger KVM_SYNC_CRS; 539b0c632dbSHeiko Carstens return 0; 540b0c632dbSHeiko Carstens } 541b0c632dbSHeiko Carstens 542b0c632dbSHeiko Carstens void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) 543b0c632dbSHeiko Carstens { 5446692cef3SChristian Borntraeger /* Nothing todo */ 545b0c632dbSHeiko Carstens } 546b0c632dbSHeiko Carstens 547b0c632dbSHeiko Carstens void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 548b0c632dbSHeiko Carstens { 5494725c860SMartin Schwidefsky save_fp_ctl(&vcpu->arch.host_fpregs.fpc); 5504725c860SMartin Schwidefsky save_fp_regs(vcpu->arch.host_fpregs.fprs); 551b0c632dbSHeiko Carstens save_access_regs(vcpu->arch.host_acrs); 5524725c860SMartin Schwidefsky restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc); 5534725c860SMartin Schwidefsky restore_fp_regs(vcpu->arch.guest_fpregs.fprs); 55459674c1aSChristian Borntraeger restore_access_regs(vcpu->run->s.regs.acrs); 555480e5926SChristian Borntraeger gmap_enable(vcpu->arch.gmap); 5569e6dabefSCornelia Huck atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 557b0c632dbSHeiko Carstens } 558b0c632dbSHeiko Carstens 559b0c632dbSHeiko Carstens void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 560b0c632dbSHeiko Carstens { 5619e6dabefSCornelia Huck atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 562480e5926SChristian Borntraeger gmap_disable(vcpu->arch.gmap); 5634725c860SMartin Schwidefsky save_fp_ctl(&vcpu->arch.guest_fpregs.fpc); 5644725c860SMartin Schwidefsky save_fp_regs(vcpu->arch.guest_fpregs.fprs); 56559674c1aSChristian Borntraeger save_access_regs(vcpu->run->s.regs.acrs); 5664725c860SMartin Schwidefsky restore_fp_ctl(&vcpu->arch.host_fpregs.fpc); 5674725c860SMartin Schwidefsky restore_fp_regs(vcpu->arch.host_fpregs.fprs); 568b0c632dbSHeiko Carstens restore_access_regs(vcpu->arch.host_acrs); 569b0c632dbSHeiko Carstens } 570b0c632dbSHeiko Carstens 571b0c632dbSHeiko Carstens static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu) 572b0c632dbSHeiko Carstens { 573b0c632dbSHeiko Carstens /* this equals initial cpu reset in pop, but we don't switch to ESA */ 574b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.mask = 0UL; 575b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.addr = 0UL; 5768d26cf7bSChristian Borntraeger kvm_s390_set_prefix(vcpu, 0); 577b0c632dbSHeiko Carstens vcpu->arch.sie_block->cputm = 0UL; 578b0c632dbSHeiko Carstens vcpu->arch.sie_block->ckc = 0UL; 579b0c632dbSHeiko Carstens vcpu->arch.sie_block->todpr = 0; 580b0c632dbSHeiko Carstens memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64)); 581b0c632dbSHeiko Carstens vcpu->arch.sie_block->gcr[0] = 0xE0UL; 582b0c632dbSHeiko Carstens vcpu->arch.sie_block->gcr[14] = 0xC2000000UL; 583b0c632dbSHeiko Carstens vcpu->arch.guest_fpregs.fpc = 0; 584b0c632dbSHeiko Carstens asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc)); 585b0c632dbSHeiko Carstens vcpu->arch.sie_block->gbea = 1; 586672550fbSChristian Borntraeger vcpu->arch.sie_block->pp = 0; 5873c038e6bSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 5883c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 58961bde82cSChristian Borntraeger atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags); 5902ed10cc1SJens Freimann kvm_s390_clear_local_irqs(vcpu); 591b0c632dbSHeiko Carstens } 592b0c632dbSHeiko Carstens 59342897d86SMarcelo Tosatti int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu) 59442897d86SMarcelo Tosatti { 59542897d86SMarcelo Tosatti return 0; 59642897d86SMarcelo Tosatti } 59742897d86SMarcelo Tosatti 598b31605c1SDominik Dingel void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu) 599b31605c1SDominik Dingel { 600b31605c1SDominik Dingel free_page(vcpu->arch.sie_block->cbrlo); 601b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = 0; 602b31605c1SDominik Dingel } 603b31605c1SDominik Dingel 604b31605c1SDominik Dingel int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu) 605b31605c1SDominik Dingel { 606b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = get_zeroed_page(GFP_KERNEL); 607b31605c1SDominik Dingel if (!vcpu->arch.sie_block->cbrlo) 608b31605c1SDominik Dingel return -ENOMEM; 609b31605c1SDominik Dingel 610b31605c1SDominik Dingel vcpu->arch.sie_block->ecb2 |= 0x80; 611b31605c1SDominik Dingel vcpu->arch.sie_block->ecb2 &= ~0x08; 612b31605c1SDominik Dingel return 0; 613b31605c1SDominik Dingel } 614b31605c1SDominik Dingel 615b0c632dbSHeiko Carstens int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) 616b0c632dbSHeiko Carstens { 617b31605c1SDominik Dingel int rc = 0; 618b31288faSKonstantin Weitz 6199e6dabefSCornelia Huck atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH | 6209e6dabefSCornelia Huck CPUSTAT_SM | 62169d0d3a3SChristian Borntraeger CPUSTAT_STOPPED | 62269d0d3a3SChristian Borntraeger CPUSTAT_GED); 623fc34531dSChristian Borntraeger vcpu->arch.sie_block->ecb = 6; 6247feb6bb8SMichael Mueller if (test_vfacility(50) && test_vfacility(73)) 6257feb6bb8SMichael Mueller vcpu->arch.sie_block->ecb |= 0x10; 6267feb6bb8SMichael Mueller 62769d0d3a3SChristian Borntraeger vcpu->arch.sie_block->ecb2 = 8; 628*217a4406SHeiko Carstens vcpu->arch.sie_block->eca = 0xC1002000U; 629*217a4406SHeiko Carstens if (sclp_has_siif()) 630*217a4406SHeiko Carstens vcpu->arch.sie_block->eca |= 1; 63178c4b59fSMichael Mueller vcpu->arch.sie_block->fac = (int) (long) vfacilities; 632693ffc08SDominik Dingel vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE; 633b31605c1SDominik Dingel if (kvm_s390_cmma_enabled(vcpu->kvm)) { 634b31605c1SDominik Dingel rc = kvm_s390_vcpu_setup_cmma(vcpu); 635b31605c1SDominik Dingel if (rc) 636b31605c1SDominik Dingel return rc; 637b31288faSKonstantin Weitz } 638ca872302SChristian Borntraeger hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS); 639ca872302SChristian Borntraeger tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet, 640ba5c1e9bSCarsten Otte (unsigned long) vcpu); 641ca872302SChristian Borntraeger vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup; 642453423dcSChristian Borntraeger get_cpu_id(&vcpu->arch.cpu_id); 64392e6ecf3SChristian Borntraeger vcpu->arch.cpu_id.version = 0xff; 644b31605c1SDominik Dingel return rc; 645b0c632dbSHeiko Carstens } 646b0c632dbSHeiko Carstens 647b0c632dbSHeiko Carstens struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, 648b0c632dbSHeiko Carstens unsigned int id) 649b0c632dbSHeiko Carstens { 6504d47555aSCarsten Otte struct kvm_vcpu *vcpu; 6517feb6bb8SMichael Mueller struct sie_page *sie_page; 6524d47555aSCarsten Otte int rc = -EINVAL; 653b0c632dbSHeiko Carstens 6544d47555aSCarsten Otte if (id >= KVM_MAX_VCPUS) 6554d47555aSCarsten Otte goto out; 6564d47555aSCarsten Otte 6574d47555aSCarsten Otte rc = -ENOMEM; 6584d47555aSCarsten Otte 659b110feafSMichael Mueller vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL); 660b0c632dbSHeiko Carstens if (!vcpu) 6614d47555aSCarsten Otte goto out; 662b0c632dbSHeiko Carstens 6637feb6bb8SMichael Mueller sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL); 6647feb6bb8SMichael Mueller if (!sie_page) 665b0c632dbSHeiko Carstens goto out_free_cpu; 666b0c632dbSHeiko Carstens 6677feb6bb8SMichael Mueller vcpu->arch.sie_block = &sie_page->sie_block; 6687feb6bb8SMichael Mueller vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb; 6697feb6bb8SMichael Mueller 670b0c632dbSHeiko Carstens vcpu->arch.sie_block->icpua = id; 67158f9460bSCarsten Otte if (!kvm_is_ucontrol(kvm)) { 67258f9460bSCarsten Otte if (!kvm->arch.sca) { 67358f9460bSCarsten Otte WARN_ON_ONCE(1); 67458f9460bSCarsten Otte goto out_free_cpu; 67558f9460bSCarsten Otte } 676abf4a71eSCarsten Otte if (!kvm->arch.sca->cpu[id].sda) 67758f9460bSCarsten Otte kvm->arch.sca->cpu[id].sda = 67858f9460bSCarsten Otte (__u64) vcpu->arch.sie_block; 67958f9460bSCarsten Otte vcpu->arch.sie_block->scaoh = 68058f9460bSCarsten Otte (__u32)(((__u64)kvm->arch.sca) >> 32); 681b0c632dbSHeiko Carstens vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca; 682fc34531dSChristian Borntraeger set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn); 68358f9460bSCarsten Otte } 684b0c632dbSHeiko Carstens 685ba5c1e9bSCarsten Otte spin_lock_init(&vcpu->arch.local_int.lock); 686ba5c1e9bSCarsten Otte INIT_LIST_HEAD(&vcpu->arch.local_int.list); 687ba5c1e9bSCarsten Otte vcpu->arch.local_int.float_int = &kvm->arch.float_int; 688d0321a24SChristian Borntraeger vcpu->arch.local_int.wq = &vcpu->wq; 6895288fbf0SChristian Borntraeger vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags; 690ba5c1e9bSCarsten Otte 691b0c632dbSHeiko Carstens rc = kvm_vcpu_init(vcpu, kvm, id); 692b0c632dbSHeiko Carstens if (rc) 6937b06bf2fSWei Yongjun goto out_free_sie_block; 694b0c632dbSHeiko Carstens VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu, 695b0c632dbSHeiko Carstens vcpu->arch.sie_block); 696ade38c31SCornelia Huck trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block); 697b0c632dbSHeiko Carstens 698b0c632dbSHeiko Carstens return vcpu; 6997b06bf2fSWei Yongjun out_free_sie_block: 7007b06bf2fSWei Yongjun free_page((unsigned long)(vcpu->arch.sie_block)); 701b0c632dbSHeiko Carstens out_free_cpu: 702b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 7034d47555aSCarsten Otte out: 704b0c632dbSHeiko Carstens return ERR_PTR(rc); 705b0c632dbSHeiko Carstens } 706b0c632dbSHeiko Carstens 707b0c632dbSHeiko Carstens int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu) 708b0c632dbSHeiko Carstens { 709f87618e8SMichael Mueller return kvm_cpu_has_interrupt(vcpu); 710b0c632dbSHeiko Carstens } 711b0c632dbSHeiko Carstens 71249b99e1eSChristian Borntraeger void s390_vcpu_block(struct kvm_vcpu *vcpu) 71349b99e1eSChristian Borntraeger { 71449b99e1eSChristian Borntraeger atomic_set_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 71549b99e1eSChristian Borntraeger } 71649b99e1eSChristian Borntraeger 71749b99e1eSChristian Borntraeger void s390_vcpu_unblock(struct kvm_vcpu *vcpu) 71849b99e1eSChristian Borntraeger { 71949b99e1eSChristian Borntraeger atomic_clear_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 72049b99e1eSChristian Borntraeger } 72149b99e1eSChristian Borntraeger 72249b99e1eSChristian Borntraeger /* 72349b99e1eSChristian Borntraeger * Kick a guest cpu out of SIE and wait until SIE is not running. 72449b99e1eSChristian Borntraeger * If the CPU is not running (e.g. waiting as idle) the function will 72549b99e1eSChristian Borntraeger * return immediately. */ 72649b99e1eSChristian Borntraeger void exit_sie(struct kvm_vcpu *vcpu) 72749b99e1eSChristian Borntraeger { 72849b99e1eSChristian Borntraeger atomic_set_mask(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags); 72949b99e1eSChristian Borntraeger while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE) 73049b99e1eSChristian Borntraeger cpu_relax(); 73149b99e1eSChristian Borntraeger } 73249b99e1eSChristian Borntraeger 73349b99e1eSChristian Borntraeger /* Kick a guest cpu out of SIE and prevent SIE-reentry */ 73449b99e1eSChristian Borntraeger void exit_sie_sync(struct kvm_vcpu *vcpu) 73549b99e1eSChristian Borntraeger { 73649b99e1eSChristian Borntraeger s390_vcpu_block(vcpu); 73749b99e1eSChristian Borntraeger exit_sie(vcpu); 73849b99e1eSChristian Borntraeger } 73949b99e1eSChristian Borntraeger 7402c70fe44SChristian Borntraeger static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address) 7412c70fe44SChristian Borntraeger { 7422c70fe44SChristian Borntraeger int i; 7432c70fe44SChristian Borntraeger struct kvm *kvm = gmap->private; 7442c70fe44SChristian Borntraeger struct kvm_vcpu *vcpu; 7452c70fe44SChristian Borntraeger 7462c70fe44SChristian Borntraeger kvm_for_each_vcpu(i, vcpu, kvm) { 7472c70fe44SChristian Borntraeger /* match against both prefix pages */ 7482c70fe44SChristian Borntraeger if (vcpu->arch.sie_block->prefix == (address & ~0x1000UL)) { 7492c70fe44SChristian Borntraeger VCPU_EVENT(vcpu, 2, "gmap notifier for %lx", address); 7502c70fe44SChristian Borntraeger kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu); 7512c70fe44SChristian Borntraeger exit_sie_sync(vcpu); 7522c70fe44SChristian Borntraeger } 7532c70fe44SChristian Borntraeger } 7542c70fe44SChristian Borntraeger } 7552c70fe44SChristian Borntraeger 756b6d33834SChristoffer Dall int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu) 757b6d33834SChristoffer Dall { 758b6d33834SChristoffer Dall /* kvm common code refers to this, but never calls it */ 759b6d33834SChristoffer Dall BUG(); 760b6d33834SChristoffer Dall return 0; 761b6d33834SChristoffer Dall } 762b6d33834SChristoffer Dall 76314eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, 76414eebd91SCarsten Otte struct kvm_one_reg *reg) 76514eebd91SCarsten Otte { 76614eebd91SCarsten Otte int r = -EINVAL; 76714eebd91SCarsten Otte 76814eebd91SCarsten Otte switch (reg->id) { 76929b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 77029b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->todpr, 77129b7c71bSCarsten Otte (u32 __user *)reg->addr); 77229b7c71bSCarsten Otte break; 77329b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 77429b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->epoch, 77529b7c71bSCarsten Otte (u64 __user *)reg->addr); 77629b7c71bSCarsten Otte break; 77746a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 77846a6dd1cSJason J. herne r = put_user(vcpu->arch.sie_block->cputm, 77946a6dd1cSJason J. herne (u64 __user *)reg->addr); 78046a6dd1cSJason J. herne break; 78146a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 78246a6dd1cSJason J. herne r = put_user(vcpu->arch.sie_block->ckc, 78346a6dd1cSJason J. herne (u64 __user *)reg->addr); 78446a6dd1cSJason J. herne break; 785536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 786536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_token, 787536336c2SDominik Dingel (u64 __user *)reg->addr); 788536336c2SDominik Dingel break; 789536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 790536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_compare, 791536336c2SDominik Dingel (u64 __user *)reg->addr); 792536336c2SDominik Dingel break; 793536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 794536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_select, 795536336c2SDominik Dingel (u64 __user *)reg->addr); 796536336c2SDominik Dingel break; 797672550fbSChristian Borntraeger case KVM_REG_S390_PP: 798672550fbSChristian Borntraeger r = put_user(vcpu->arch.sie_block->pp, 799672550fbSChristian Borntraeger (u64 __user *)reg->addr); 800672550fbSChristian Borntraeger break; 801afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 802afa45ff5SChristian Borntraeger r = put_user(vcpu->arch.sie_block->gbea, 803afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 804afa45ff5SChristian Borntraeger break; 80514eebd91SCarsten Otte default: 80614eebd91SCarsten Otte break; 80714eebd91SCarsten Otte } 80814eebd91SCarsten Otte 80914eebd91SCarsten Otte return r; 81014eebd91SCarsten Otte } 81114eebd91SCarsten Otte 81214eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, 81314eebd91SCarsten Otte struct kvm_one_reg *reg) 81414eebd91SCarsten Otte { 81514eebd91SCarsten Otte int r = -EINVAL; 81614eebd91SCarsten Otte 81714eebd91SCarsten Otte switch (reg->id) { 81829b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 81929b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->todpr, 82029b7c71bSCarsten Otte (u32 __user *)reg->addr); 82129b7c71bSCarsten Otte break; 82229b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 82329b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->epoch, 82429b7c71bSCarsten Otte (u64 __user *)reg->addr); 82529b7c71bSCarsten Otte break; 82646a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 82746a6dd1cSJason J. herne r = get_user(vcpu->arch.sie_block->cputm, 82846a6dd1cSJason J. herne (u64 __user *)reg->addr); 82946a6dd1cSJason J. herne break; 83046a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 83146a6dd1cSJason J. herne r = get_user(vcpu->arch.sie_block->ckc, 83246a6dd1cSJason J. herne (u64 __user *)reg->addr); 83346a6dd1cSJason J. herne break; 834536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 835536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_token, 836536336c2SDominik Dingel (u64 __user *)reg->addr); 837536336c2SDominik Dingel break; 838536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 839536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_compare, 840536336c2SDominik Dingel (u64 __user *)reg->addr); 841536336c2SDominik Dingel break; 842536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 843536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_select, 844536336c2SDominik Dingel (u64 __user *)reg->addr); 845536336c2SDominik Dingel break; 846672550fbSChristian Borntraeger case KVM_REG_S390_PP: 847672550fbSChristian Borntraeger r = get_user(vcpu->arch.sie_block->pp, 848672550fbSChristian Borntraeger (u64 __user *)reg->addr); 849672550fbSChristian Borntraeger break; 850afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 851afa45ff5SChristian Borntraeger r = get_user(vcpu->arch.sie_block->gbea, 852afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 853afa45ff5SChristian Borntraeger break; 85414eebd91SCarsten Otte default: 85514eebd91SCarsten Otte break; 85614eebd91SCarsten Otte } 85714eebd91SCarsten Otte 85814eebd91SCarsten Otte return r; 85914eebd91SCarsten Otte } 860b6d33834SChristoffer Dall 861b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) 862b0c632dbSHeiko Carstens { 863b0c632dbSHeiko Carstens kvm_s390_vcpu_initial_reset(vcpu); 864b0c632dbSHeiko Carstens return 0; 865b0c632dbSHeiko Carstens } 866b0c632dbSHeiko Carstens 867b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 868b0c632dbSHeiko Carstens { 8695a32c1afSChristian Borntraeger memcpy(&vcpu->run->s.regs.gprs, ®s->gprs, sizeof(regs->gprs)); 870b0c632dbSHeiko Carstens return 0; 871b0c632dbSHeiko Carstens } 872b0c632dbSHeiko Carstens 873b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 874b0c632dbSHeiko Carstens { 8755a32c1afSChristian Borntraeger memcpy(®s->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs)); 876b0c632dbSHeiko Carstens return 0; 877b0c632dbSHeiko Carstens } 878b0c632dbSHeiko Carstens 879b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, 880b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 881b0c632dbSHeiko Carstens { 88259674c1aSChristian Borntraeger memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs)); 883b0c632dbSHeiko Carstens memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs)); 88459674c1aSChristian Borntraeger restore_access_regs(vcpu->run->s.regs.acrs); 885b0c632dbSHeiko Carstens return 0; 886b0c632dbSHeiko Carstens } 887b0c632dbSHeiko Carstens 888b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, 889b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 890b0c632dbSHeiko Carstens { 89159674c1aSChristian Borntraeger memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs)); 892b0c632dbSHeiko Carstens memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs)); 893b0c632dbSHeiko Carstens return 0; 894b0c632dbSHeiko Carstens } 895b0c632dbSHeiko Carstens 896b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 897b0c632dbSHeiko Carstens { 8984725c860SMartin Schwidefsky if (test_fp_ctl(fpu->fpc)) 8994725c860SMartin Schwidefsky return -EINVAL; 900b0c632dbSHeiko Carstens memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs)); 9014725c860SMartin Schwidefsky vcpu->arch.guest_fpregs.fpc = fpu->fpc; 9024725c860SMartin Schwidefsky restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc); 9034725c860SMartin Schwidefsky restore_fp_regs(vcpu->arch.guest_fpregs.fprs); 904b0c632dbSHeiko Carstens return 0; 905b0c632dbSHeiko Carstens } 906b0c632dbSHeiko Carstens 907b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 908b0c632dbSHeiko Carstens { 909b0c632dbSHeiko Carstens memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs)); 910b0c632dbSHeiko Carstens fpu->fpc = vcpu->arch.guest_fpregs.fpc; 911b0c632dbSHeiko Carstens return 0; 912b0c632dbSHeiko Carstens } 913b0c632dbSHeiko Carstens 914b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw) 915b0c632dbSHeiko Carstens { 916b0c632dbSHeiko Carstens int rc = 0; 917b0c632dbSHeiko Carstens 9189e6dabefSCornelia Huck if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED)) 919b0c632dbSHeiko Carstens rc = -EBUSY; 920d7b0b5ebSCarsten Otte else { 921d7b0b5ebSCarsten Otte vcpu->run->psw_mask = psw.mask; 922d7b0b5ebSCarsten Otte vcpu->run->psw_addr = psw.addr; 923d7b0b5ebSCarsten Otte } 924b0c632dbSHeiko Carstens return rc; 925b0c632dbSHeiko Carstens } 926b0c632dbSHeiko Carstens 927b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, 928b0c632dbSHeiko Carstens struct kvm_translation *tr) 929b0c632dbSHeiko Carstens { 930b0c632dbSHeiko Carstens return -EINVAL; /* not implemented yet */ 931b0c632dbSHeiko Carstens } 932b0c632dbSHeiko Carstens 933d0bfb940SJan Kiszka int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 934d0bfb940SJan Kiszka struct kvm_guest_debug *dbg) 935b0c632dbSHeiko Carstens { 936b0c632dbSHeiko Carstens return -EINVAL; /* not implemented yet */ 937b0c632dbSHeiko Carstens } 938b0c632dbSHeiko Carstens 93962d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 94062d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 94162d9f0dbSMarcelo Tosatti { 94262d9f0dbSMarcelo Tosatti return -EINVAL; /* not implemented yet */ 94362d9f0dbSMarcelo Tosatti } 94462d9f0dbSMarcelo Tosatti 94562d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 94662d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 94762d9f0dbSMarcelo Tosatti { 94862d9f0dbSMarcelo Tosatti return -EINVAL; /* not implemented yet */ 94962d9f0dbSMarcelo Tosatti } 95062d9f0dbSMarcelo Tosatti 951b31605c1SDominik Dingel bool kvm_s390_cmma_enabled(struct kvm *kvm) 952b31605c1SDominik Dingel { 953b31605c1SDominik Dingel if (!MACHINE_IS_LPAR) 954b31605c1SDominik Dingel return false; 955b31605c1SDominik Dingel /* only enable for z10 and later */ 956b31605c1SDominik Dingel if (!MACHINE_HAS_EDAT1) 957b31605c1SDominik Dingel return false; 958b31605c1SDominik Dingel if (!kvm->arch.use_cmma) 959b31605c1SDominik Dingel return false; 960b31605c1SDominik Dingel return true; 961b31605c1SDominik Dingel } 962b31605c1SDominik Dingel 9632c70fe44SChristian Borntraeger static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu) 9642c70fe44SChristian Borntraeger { 9652c70fe44SChristian Borntraeger /* 9662c70fe44SChristian Borntraeger * We use MMU_RELOAD just to re-arm the ipte notifier for the 9672c70fe44SChristian Borntraeger * guest prefix page. gmap_ipte_notify will wait on the ptl lock. 9682c70fe44SChristian Borntraeger * This ensures that the ipte instruction for this request has 9692c70fe44SChristian Borntraeger * already finished. We might race against a second unmapper that 9702c70fe44SChristian Borntraeger * wants to set the blocking bit. Lets just retry the request loop. 9712c70fe44SChristian Borntraeger */ 9722c70fe44SChristian Borntraeger while (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) { 9732c70fe44SChristian Borntraeger int rc; 9742c70fe44SChristian Borntraeger rc = gmap_ipte_notify(vcpu->arch.gmap, 9752c70fe44SChristian Borntraeger vcpu->arch.sie_block->prefix, 9762c70fe44SChristian Borntraeger PAGE_SIZE * 2); 9772c70fe44SChristian Borntraeger if (rc) 9782c70fe44SChristian Borntraeger return rc; 9792c70fe44SChristian Borntraeger s390_vcpu_unblock(vcpu); 9802c70fe44SChristian Borntraeger } 9812c70fe44SChristian Borntraeger return 0; 9822c70fe44SChristian Borntraeger } 9832c70fe44SChristian Borntraeger 98424eb3a82SDominik Dingel static long kvm_arch_fault_in_sync(struct kvm_vcpu *vcpu) 98524eb3a82SDominik Dingel { 98624eb3a82SDominik Dingel long rc; 98724eb3a82SDominik Dingel hva_t fault = gmap_fault(current->thread.gmap_addr, vcpu->arch.gmap); 98824eb3a82SDominik Dingel struct mm_struct *mm = current->mm; 98924eb3a82SDominik Dingel down_read(&mm->mmap_sem); 99024eb3a82SDominik Dingel rc = get_user_pages(current, mm, fault, 1, 1, 0, NULL, NULL); 99124eb3a82SDominik Dingel up_read(&mm->mmap_sem); 99224eb3a82SDominik Dingel return rc; 99324eb3a82SDominik Dingel } 99424eb3a82SDominik Dingel 9953c038e6bSDominik Dingel static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token, 9963c038e6bSDominik Dingel unsigned long token) 9973c038e6bSDominik Dingel { 9983c038e6bSDominik Dingel struct kvm_s390_interrupt inti; 9993c038e6bSDominik Dingel inti.parm64 = token; 10003c038e6bSDominik Dingel 10013c038e6bSDominik Dingel if (start_token) { 10023c038e6bSDominik Dingel inti.type = KVM_S390_INT_PFAULT_INIT; 10033c038e6bSDominik Dingel WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &inti)); 10043c038e6bSDominik Dingel } else { 10053c038e6bSDominik Dingel inti.type = KVM_S390_INT_PFAULT_DONE; 10063c038e6bSDominik Dingel WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti)); 10073c038e6bSDominik Dingel } 10083c038e6bSDominik Dingel } 10093c038e6bSDominik Dingel 10103c038e6bSDominik Dingel void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu, 10113c038e6bSDominik Dingel struct kvm_async_pf *work) 10123c038e6bSDominik Dingel { 10133c038e6bSDominik Dingel trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token); 10143c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token); 10153c038e6bSDominik Dingel } 10163c038e6bSDominik Dingel 10173c038e6bSDominik Dingel void kvm_arch_async_page_present(struct kvm_vcpu *vcpu, 10183c038e6bSDominik Dingel struct kvm_async_pf *work) 10193c038e6bSDominik Dingel { 10203c038e6bSDominik Dingel trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token); 10213c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token); 10223c038e6bSDominik Dingel } 10233c038e6bSDominik Dingel 10243c038e6bSDominik Dingel void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu, 10253c038e6bSDominik Dingel struct kvm_async_pf *work) 10263c038e6bSDominik Dingel { 10273c038e6bSDominik Dingel /* s390 will always inject the page directly */ 10283c038e6bSDominik Dingel } 10293c038e6bSDominik Dingel 10303c038e6bSDominik Dingel bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu) 10313c038e6bSDominik Dingel { 10323c038e6bSDominik Dingel /* 10333c038e6bSDominik Dingel * s390 will always inject the page directly, 10343c038e6bSDominik Dingel * but we still want check_async_completion to cleanup 10353c038e6bSDominik Dingel */ 10363c038e6bSDominik Dingel return true; 10373c038e6bSDominik Dingel } 10383c038e6bSDominik Dingel 10393c038e6bSDominik Dingel static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu) 10403c038e6bSDominik Dingel { 10413c038e6bSDominik Dingel hva_t hva; 10423c038e6bSDominik Dingel struct kvm_arch_async_pf arch; 10433c038e6bSDominik Dingel int rc; 10443c038e6bSDominik Dingel 10453c038e6bSDominik Dingel if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 10463c038e6bSDominik Dingel return 0; 10473c038e6bSDominik Dingel if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) != 10483c038e6bSDominik Dingel vcpu->arch.pfault_compare) 10493c038e6bSDominik Dingel return 0; 10503c038e6bSDominik Dingel if (psw_extint_disabled(vcpu)) 10513c038e6bSDominik Dingel return 0; 10523c038e6bSDominik Dingel if (kvm_cpu_has_interrupt(vcpu)) 10533c038e6bSDominik Dingel return 0; 10543c038e6bSDominik Dingel if (!(vcpu->arch.sie_block->gcr[0] & 0x200ul)) 10553c038e6bSDominik Dingel return 0; 10563c038e6bSDominik Dingel if (!vcpu->arch.gmap->pfault_enabled) 10573c038e6bSDominik Dingel return 0; 10583c038e6bSDominik Dingel 10593c038e6bSDominik Dingel hva = gmap_fault(current->thread.gmap_addr, vcpu->arch.gmap); 10603c038e6bSDominik Dingel if (copy_from_guest(vcpu, &arch.pfault_token, vcpu->arch.pfault_token, 8)) 10613c038e6bSDominik Dingel return 0; 10623c038e6bSDominik Dingel 10633c038e6bSDominik Dingel rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch); 10643c038e6bSDominik Dingel return rc; 10653c038e6bSDominik Dingel } 10663c038e6bSDominik Dingel 10673fb4c40fSThomas Huth static int vcpu_pre_run(struct kvm_vcpu *vcpu) 1068b0c632dbSHeiko Carstens { 10693fb4c40fSThomas Huth int rc, cpuflags; 1070e168bf8dSCarsten Otte 10713c038e6bSDominik Dingel /* 10723c038e6bSDominik Dingel * On s390 notifications for arriving pages will be delivered directly 10733c038e6bSDominik Dingel * to the guest but the house keeping for completed pfaults is 10743c038e6bSDominik Dingel * handled outside the worker. 10753c038e6bSDominik Dingel */ 10763c038e6bSDominik Dingel kvm_check_async_pf_completion(vcpu); 10773c038e6bSDominik Dingel 10785a32c1afSChristian Borntraeger memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16); 1079b0c632dbSHeiko Carstens 1080b0c632dbSHeiko Carstens if (need_resched()) 1081b0c632dbSHeiko Carstens schedule(); 1082b0c632dbSHeiko Carstens 108371cde587SChristian Borntraeger if (test_thread_flag(TIF_MCCK_PENDING)) 108471cde587SChristian Borntraeger s390_handle_mcck(); 108571cde587SChristian Borntraeger 1086d6b6d166SCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) 10870ff31867SCarsten Otte kvm_s390_deliver_pending_interrupts(vcpu); 10880ff31867SCarsten Otte 10892c70fe44SChristian Borntraeger rc = kvm_s390_handle_requests(vcpu); 10902c70fe44SChristian Borntraeger if (rc) 10912c70fe44SChristian Borntraeger return rc; 10922c70fe44SChristian Borntraeger 1093b0c632dbSHeiko Carstens vcpu->arch.sie_block->icptcode = 0; 10943fb4c40fSThomas Huth cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags); 10953fb4c40fSThomas Huth VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags); 10963fb4c40fSThomas Huth trace_kvm_s390_sie_enter(vcpu, cpuflags); 10972b29a9fdSDominik Dingel 10983fb4c40fSThomas Huth return 0; 10993fb4c40fSThomas Huth } 11003fb4c40fSThomas Huth 11013fb4c40fSThomas Huth static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason) 11023fb4c40fSThomas Huth { 110324eb3a82SDominik Dingel int rc = -1; 11042b29a9fdSDominik Dingel 11052b29a9fdSDominik Dingel VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", 11062b29a9fdSDominik Dingel vcpu->arch.sie_block->icptcode); 11072b29a9fdSDominik Dingel trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode); 11082b29a9fdSDominik Dingel 11093fb4c40fSThomas Huth if (exit_reason >= 0) { 11107c470539SMartin Schwidefsky rc = 0; 1111210b1607SThomas Huth } else if (kvm_is_ucontrol(vcpu->kvm)) { 1112210b1607SThomas Huth vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL; 1113210b1607SThomas Huth vcpu->run->s390_ucontrol.trans_exc_code = 1114210b1607SThomas Huth current->thread.gmap_addr; 1115210b1607SThomas Huth vcpu->run->s390_ucontrol.pgm_code = 0x10; 1116210b1607SThomas Huth rc = -EREMOTE; 111724eb3a82SDominik Dingel 111824eb3a82SDominik Dingel } else if (current->thread.gmap_pfault) { 11193c038e6bSDominik Dingel trace_kvm_s390_major_guest_pfault(vcpu); 112024eb3a82SDominik Dingel current->thread.gmap_pfault = 0; 11213c038e6bSDominik Dingel if (kvm_arch_setup_async_pf(vcpu) || 11223c038e6bSDominik Dingel (kvm_arch_fault_in_sync(vcpu) >= 0)) 112324eb3a82SDominik Dingel rc = 0; 112424eb3a82SDominik Dingel } 112524eb3a82SDominik Dingel 112624eb3a82SDominik Dingel if (rc == -1) { 1127699bde3bSChristian Borntraeger VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction"); 1128699bde3bSChristian Borntraeger trace_kvm_s390_sie_fault(vcpu); 1129699bde3bSChristian Borntraeger rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING); 11301f0d0f09SCarsten Otte } 1131b0c632dbSHeiko Carstens 11325a32c1afSChristian Borntraeger memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16); 11333fb4c40fSThomas Huth 1134a76ccff6SThomas Huth if (rc == 0) { 1135a76ccff6SThomas Huth if (kvm_is_ucontrol(vcpu->kvm)) 11362955c83fSChristian Borntraeger /* Don't exit for host interrupts. */ 11372955c83fSChristian Borntraeger rc = vcpu->arch.sie_block->icptcode ? -EOPNOTSUPP : 0; 1138a76ccff6SThomas Huth else 1139a76ccff6SThomas Huth rc = kvm_handle_sie_intercept(vcpu); 1140a76ccff6SThomas Huth } 1141a76ccff6SThomas Huth 11423fb4c40fSThomas Huth return rc; 11433fb4c40fSThomas Huth } 11443fb4c40fSThomas Huth 11453fb4c40fSThomas Huth static int __vcpu_run(struct kvm_vcpu *vcpu) 11463fb4c40fSThomas Huth { 11473fb4c40fSThomas Huth int rc, exit_reason; 11483fb4c40fSThomas Huth 1149800c1065SThomas Huth /* 1150800c1065SThomas Huth * We try to hold kvm->srcu during most of vcpu_run (except when run- 1151800c1065SThomas Huth * ning the guest), so that memslots (and other stuff) are protected 1152800c1065SThomas Huth */ 1153800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 1154800c1065SThomas Huth 1155a76ccff6SThomas Huth do { 11563fb4c40fSThomas Huth rc = vcpu_pre_run(vcpu); 11573fb4c40fSThomas Huth if (rc) 1158a76ccff6SThomas Huth break; 11593fb4c40fSThomas Huth 1160800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 11613fb4c40fSThomas Huth /* 1162a76ccff6SThomas Huth * As PF_VCPU will be used in fault handler, between 1163a76ccff6SThomas Huth * guest_enter and guest_exit should be no uaccess. 11643fb4c40fSThomas Huth */ 11653fb4c40fSThomas Huth preempt_disable(); 11663fb4c40fSThomas Huth kvm_guest_enter(); 11673fb4c40fSThomas Huth preempt_enable(); 1168a76ccff6SThomas Huth exit_reason = sie64a(vcpu->arch.sie_block, 1169a76ccff6SThomas Huth vcpu->run->s.regs.gprs); 11703fb4c40fSThomas Huth kvm_guest_exit(); 1171800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 11723fb4c40fSThomas Huth 11733fb4c40fSThomas Huth rc = vcpu_post_run(vcpu, exit_reason); 1174a76ccff6SThomas Huth } while (!signal_pending(current) && !rc); 11753fb4c40fSThomas Huth 1176800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 1177e168bf8dSCarsten Otte return rc; 1178b0c632dbSHeiko Carstens } 1179b0c632dbSHeiko Carstens 1180b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 1181b0c632dbSHeiko Carstens { 11828f2abe6aSChristian Borntraeger int rc; 1183b0c632dbSHeiko Carstens sigset_t sigsaved; 1184b0c632dbSHeiko Carstens 1185b0c632dbSHeiko Carstens if (vcpu->sigset_active) 1186b0c632dbSHeiko Carstens sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); 1187b0c632dbSHeiko Carstens 11889e6dabefSCornelia Huck atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags); 1189b0c632dbSHeiko Carstens 11908f2abe6aSChristian Borntraeger switch (kvm_run->exit_reason) { 11918f2abe6aSChristian Borntraeger case KVM_EXIT_S390_SIEIC: 11928f2abe6aSChristian Borntraeger case KVM_EXIT_UNKNOWN: 11939ace903dSChristian Ehrhardt case KVM_EXIT_INTR: 11948f2abe6aSChristian Borntraeger case KVM_EXIT_S390_RESET: 1195e168bf8dSCarsten Otte case KVM_EXIT_S390_UCONTROL: 1196fa6b7fe9SCornelia Huck case KVM_EXIT_S390_TSCH: 11978f2abe6aSChristian Borntraeger break; 11988f2abe6aSChristian Borntraeger default: 11998f2abe6aSChristian Borntraeger BUG(); 12008f2abe6aSChristian Borntraeger } 12018f2abe6aSChristian Borntraeger 1202d7b0b5ebSCarsten Otte vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask; 1203d7b0b5ebSCarsten Otte vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr; 120460b413c9SChristian Borntraeger if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) { 120560b413c9SChristian Borntraeger kvm_run->kvm_dirty_regs &= ~KVM_SYNC_PREFIX; 120660b413c9SChristian Borntraeger kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix); 120760b413c9SChristian Borntraeger } 12089eed0735SChristian Borntraeger if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) { 12099eed0735SChristian Borntraeger kvm_run->kvm_dirty_regs &= ~KVM_SYNC_CRS; 12109eed0735SChristian Borntraeger memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128); 12119eed0735SChristian Borntraeger kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix); 12129eed0735SChristian Borntraeger } 1213d7b0b5ebSCarsten Otte 1214dab4079dSHeiko Carstens might_fault(); 1215e168bf8dSCarsten Otte rc = __vcpu_run(vcpu); 12169ace903dSChristian Ehrhardt 1217b1d16c49SChristian Ehrhardt if (signal_pending(current) && !rc) { 1218b1d16c49SChristian Ehrhardt kvm_run->exit_reason = KVM_EXIT_INTR; 12198f2abe6aSChristian Borntraeger rc = -EINTR; 1220b1d16c49SChristian Ehrhardt } 12218f2abe6aSChristian Borntraeger 1222b8e660b8SHeiko Carstens if (rc == -EOPNOTSUPP) { 12238f2abe6aSChristian Borntraeger /* intercept cannot be handled in-kernel, prepare kvm-run */ 12248f2abe6aSChristian Borntraeger kvm_run->exit_reason = KVM_EXIT_S390_SIEIC; 12258f2abe6aSChristian Borntraeger kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode; 12268f2abe6aSChristian Borntraeger kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa; 12278f2abe6aSChristian Borntraeger kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb; 12288f2abe6aSChristian Borntraeger rc = 0; 12298f2abe6aSChristian Borntraeger } 12308f2abe6aSChristian Borntraeger 12318f2abe6aSChristian Borntraeger if (rc == -EREMOTE) { 12328f2abe6aSChristian Borntraeger /* intercept was handled, but userspace support is needed 12338f2abe6aSChristian Borntraeger * kvm_run has been prepared by the handler */ 12348f2abe6aSChristian Borntraeger rc = 0; 12358f2abe6aSChristian Borntraeger } 12368f2abe6aSChristian Borntraeger 1237d7b0b5ebSCarsten Otte kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask; 1238d7b0b5ebSCarsten Otte kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr; 123960b413c9SChristian Borntraeger kvm_run->s.regs.prefix = vcpu->arch.sie_block->prefix; 12409eed0735SChristian Borntraeger memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128); 1241d7b0b5ebSCarsten Otte 1242b0c632dbSHeiko Carstens if (vcpu->sigset_active) 1243b0c632dbSHeiko Carstens sigprocmask(SIG_SETMASK, &sigsaved, NULL); 1244b0c632dbSHeiko Carstens 1245b0c632dbSHeiko Carstens vcpu->stat.exit_userspace++; 12467e8e6ab4SHeiko Carstens return rc; 1247b0c632dbSHeiko Carstens } 1248b0c632dbSHeiko Carstens 1249092670cdSCarsten Otte static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from, 1250b0c632dbSHeiko Carstens unsigned long n, int prefix) 1251b0c632dbSHeiko Carstens { 1252b0c632dbSHeiko Carstens if (prefix) 1253b0c632dbSHeiko Carstens return copy_to_guest(vcpu, guestdest, from, n); 1254b0c632dbSHeiko Carstens else 1255b0c632dbSHeiko Carstens return copy_to_guest_absolute(vcpu, guestdest, from, n); 1256b0c632dbSHeiko Carstens } 1257b0c632dbSHeiko Carstens 1258b0c632dbSHeiko Carstens /* 1259b0c632dbSHeiko Carstens * store status at address 1260b0c632dbSHeiko Carstens * we use have two special cases: 1261b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit 1262b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_PREFIXED: -> prefix 1263b0c632dbSHeiko Carstens */ 1264e879892cSThomas Huth int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long addr) 1265b0c632dbSHeiko Carstens { 1266092670cdSCarsten Otte unsigned char archmode = 1; 1267b0c632dbSHeiko Carstens int prefix; 1268178bd789SThomas Huth u64 clkcomp; 1269b0c632dbSHeiko Carstens 1270b0c632dbSHeiko Carstens if (addr == KVM_S390_STORE_STATUS_NOADDR) { 1271b0c632dbSHeiko Carstens if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1)) 1272b0c632dbSHeiko Carstens return -EFAULT; 1273b0c632dbSHeiko Carstens addr = SAVE_AREA_BASE; 1274b0c632dbSHeiko Carstens prefix = 0; 1275b0c632dbSHeiko Carstens } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) { 1276b0c632dbSHeiko Carstens if (copy_to_guest(vcpu, 163ul, &archmode, 1)) 1277b0c632dbSHeiko Carstens return -EFAULT; 1278b0c632dbSHeiko Carstens addr = SAVE_AREA_BASE; 1279b0c632dbSHeiko Carstens prefix = 1; 1280b0c632dbSHeiko Carstens } else 1281b0c632dbSHeiko Carstens prefix = 0; 1282b0c632dbSHeiko Carstens 1283f64ca217SHeiko Carstens if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs), 1284b0c632dbSHeiko Carstens vcpu->arch.guest_fpregs.fprs, 128, prefix)) 1285b0c632dbSHeiko Carstens return -EFAULT; 1286b0c632dbSHeiko Carstens 1287f64ca217SHeiko Carstens if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs), 12885a32c1afSChristian Borntraeger vcpu->run->s.regs.gprs, 128, prefix)) 1289b0c632dbSHeiko Carstens return -EFAULT; 1290b0c632dbSHeiko Carstens 1291f64ca217SHeiko Carstens if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw), 1292b0c632dbSHeiko Carstens &vcpu->arch.sie_block->gpsw, 16, prefix)) 1293b0c632dbSHeiko Carstens return -EFAULT; 1294b0c632dbSHeiko Carstens 1295f64ca217SHeiko Carstens if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg), 1296b0c632dbSHeiko Carstens &vcpu->arch.sie_block->prefix, 4, prefix)) 1297b0c632dbSHeiko Carstens return -EFAULT; 1298b0c632dbSHeiko Carstens 1299b0c632dbSHeiko Carstens if (__guestcopy(vcpu, 1300f64ca217SHeiko Carstens addr + offsetof(struct save_area, fp_ctrl_reg), 1301b0c632dbSHeiko Carstens &vcpu->arch.guest_fpregs.fpc, 4, prefix)) 1302b0c632dbSHeiko Carstens return -EFAULT; 1303b0c632dbSHeiko Carstens 1304f64ca217SHeiko Carstens if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg), 1305b0c632dbSHeiko Carstens &vcpu->arch.sie_block->todpr, 4, prefix)) 1306b0c632dbSHeiko Carstens return -EFAULT; 1307b0c632dbSHeiko Carstens 1308f64ca217SHeiko Carstens if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer), 1309b0c632dbSHeiko Carstens &vcpu->arch.sie_block->cputm, 8, prefix)) 1310b0c632dbSHeiko Carstens return -EFAULT; 1311b0c632dbSHeiko Carstens 1312178bd789SThomas Huth clkcomp = vcpu->arch.sie_block->ckc >> 8; 1313f64ca217SHeiko Carstens if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp), 1314178bd789SThomas Huth &clkcomp, 8, prefix)) 1315b0c632dbSHeiko Carstens return -EFAULT; 1316b0c632dbSHeiko Carstens 1317f64ca217SHeiko Carstens if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs), 131859674c1aSChristian Borntraeger &vcpu->run->s.regs.acrs, 64, prefix)) 1319b0c632dbSHeiko Carstens return -EFAULT; 1320b0c632dbSHeiko Carstens 1321b0c632dbSHeiko Carstens if (__guestcopy(vcpu, 1322f64ca217SHeiko Carstens addr + offsetof(struct save_area, ctrl_regs), 1323b0c632dbSHeiko Carstens &vcpu->arch.sie_block->gcr, 128, prefix)) 1324b0c632dbSHeiko Carstens return -EFAULT; 1325b0c632dbSHeiko Carstens return 0; 1326b0c632dbSHeiko Carstens } 1327b0c632dbSHeiko Carstens 1328e879892cSThomas Huth int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr) 1329e879892cSThomas Huth { 1330e879892cSThomas Huth /* 1331e879892cSThomas Huth * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy 1332e879892cSThomas Huth * copying in vcpu load/put. Lets update our copies before we save 1333e879892cSThomas Huth * it into the save area 1334e879892cSThomas Huth */ 1335e879892cSThomas Huth save_fp_ctl(&vcpu->arch.guest_fpregs.fpc); 1336e879892cSThomas Huth save_fp_regs(vcpu->arch.guest_fpregs.fprs); 1337e879892cSThomas Huth save_access_regs(vcpu->run->s.regs.acrs); 1338e879892cSThomas Huth 1339e879892cSThomas Huth return kvm_s390_store_status_unloaded(vcpu, addr); 1340e879892cSThomas Huth } 1341e879892cSThomas Huth 1342d6712df9SCornelia Huck static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 1343d6712df9SCornelia Huck struct kvm_enable_cap *cap) 1344d6712df9SCornelia Huck { 1345d6712df9SCornelia Huck int r; 1346d6712df9SCornelia Huck 1347d6712df9SCornelia Huck if (cap->flags) 1348d6712df9SCornelia Huck return -EINVAL; 1349d6712df9SCornelia Huck 1350d6712df9SCornelia Huck switch (cap->cap) { 1351fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 1352fa6b7fe9SCornelia Huck if (!vcpu->kvm->arch.css_support) { 1353fa6b7fe9SCornelia Huck vcpu->kvm->arch.css_support = 1; 1354fa6b7fe9SCornelia Huck trace_kvm_s390_enable_css(vcpu->kvm); 1355fa6b7fe9SCornelia Huck } 1356fa6b7fe9SCornelia Huck r = 0; 1357fa6b7fe9SCornelia Huck break; 1358d6712df9SCornelia Huck default: 1359d6712df9SCornelia Huck r = -EINVAL; 1360d6712df9SCornelia Huck break; 1361d6712df9SCornelia Huck } 1362d6712df9SCornelia Huck return r; 1363d6712df9SCornelia Huck } 1364d6712df9SCornelia Huck 1365b0c632dbSHeiko Carstens long kvm_arch_vcpu_ioctl(struct file *filp, 1366b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 1367b0c632dbSHeiko Carstens { 1368b0c632dbSHeiko Carstens struct kvm_vcpu *vcpu = filp->private_data; 1369b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 1370800c1065SThomas Huth int idx; 1371bc923cc9SAvi Kivity long r; 1372b0c632dbSHeiko Carstens 137393736624SAvi Kivity switch (ioctl) { 137493736624SAvi Kivity case KVM_S390_INTERRUPT: { 1375ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 1376ba5c1e9bSCarsten Otte 137793736624SAvi Kivity r = -EFAULT; 1378ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 137993736624SAvi Kivity break; 138093736624SAvi Kivity r = kvm_s390_inject_vcpu(vcpu, &s390int); 138193736624SAvi Kivity break; 1382ba5c1e9bSCarsten Otte } 1383b0c632dbSHeiko Carstens case KVM_S390_STORE_STATUS: 1384800c1065SThomas Huth idx = srcu_read_lock(&vcpu->kvm->srcu); 1385bc923cc9SAvi Kivity r = kvm_s390_vcpu_store_status(vcpu, arg); 1386800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, idx); 1387bc923cc9SAvi Kivity break; 1388b0c632dbSHeiko Carstens case KVM_S390_SET_INITIAL_PSW: { 1389b0c632dbSHeiko Carstens psw_t psw; 1390b0c632dbSHeiko Carstens 1391bc923cc9SAvi Kivity r = -EFAULT; 1392b0c632dbSHeiko Carstens if (copy_from_user(&psw, argp, sizeof(psw))) 1393bc923cc9SAvi Kivity break; 1394bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw); 1395bc923cc9SAvi Kivity break; 1396b0c632dbSHeiko Carstens } 1397b0c632dbSHeiko Carstens case KVM_S390_INITIAL_RESET: 1398bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_initial_reset(vcpu); 1399bc923cc9SAvi Kivity break; 140014eebd91SCarsten Otte case KVM_SET_ONE_REG: 140114eebd91SCarsten Otte case KVM_GET_ONE_REG: { 140214eebd91SCarsten Otte struct kvm_one_reg reg; 140314eebd91SCarsten Otte r = -EFAULT; 140414eebd91SCarsten Otte if (copy_from_user(®, argp, sizeof(reg))) 140514eebd91SCarsten Otte break; 140614eebd91SCarsten Otte if (ioctl == KVM_SET_ONE_REG) 140714eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, ®); 140814eebd91SCarsten Otte else 140914eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, ®); 141014eebd91SCarsten Otte break; 141114eebd91SCarsten Otte } 141227e0393fSCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 141327e0393fSCarsten Otte case KVM_S390_UCAS_MAP: { 141427e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 141527e0393fSCarsten Otte 141627e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 141727e0393fSCarsten Otte r = -EFAULT; 141827e0393fSCarsten Otte break; 141927e0393fSCarsten Otte } 142027e0393fSCarsten Otte 142127e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 142227e0393fSCarsten Otte r = -EINVAL; 142327e0393fSCarsten Otte break; 142427e0393fSCarsten Otte } 142527e0393fSCarsten Otte 142627e0393fSCarsten Otte r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr, 142727e0393fSCarsten Otte ucasmap.vcpu_addr, ucasmap.length); 142827e0393fSCarsten Otte break; 142927e0393fSCarsten Otte } 143027e0393fSCarsten Otte case KVM_S390_UCAS_UNMAP: { 143127e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 143227e0393fSCarsten Otte 143327e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 143427e0393fSCarsten Otte r = -EFAULT; 143527e0393fSCarsten Otte break; 143627e0393fSCarsten Otte } 143727e0393fSCarsten Otte 143827e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 143927e0393fSCarsten Otte r = -EINVAL; 144027e0393fSCarsten Otte break; 144127e0393fSCarsten Otte } 144227e0393fSCarsten Otte 144327e0393fSCarsten Otte r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr, 144427e0393fSCarsten Otte ucasmap.length); 144527e0393fSCarsten Otte break; 144627e0393fSCarsten Otte } 144727e0393fSCarsten Otte #endif 1448ccc7910fSCarsten Otte case KVM_S390_VCPU_FAULT: { 1449ccc7910fSCarsten Otte r = gmap_fault(arg, vcpu->arch.gmap); 1450ccc7910fSCarsten Otte if (!IS_ERR_VALUE(r)) 1451ccc7910fSCarsten Otte r = 0; 1452ccc7910fSCarsten Otte break; 1453ccc7910fSCarsten Otte } 1454d6712df9SCornelia Huck case KVM_ENABLE_CAP: 1455d6712df9SCornelia Huck { 1456d6712df9SCornelia Huck struct kvm_enable_cap cap; 1457d6712df9SCornelia Huck r = -EFAULT; 1458d6712df9SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 1459d6712df9SCornelia Huck break; 1460d6712df9SCornelia Huck r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 1461d6712df9SCornelia Huck break; 1462d6712df9SCornelia Huck } 1463b0c632dbSHeiko Carstens default: 14643e6afcf1SCarsten Otte r = -ENOTTY; 1465b0c632dbSHeiko Carstens } 1466bc923cc9SAvi Kivity return r; 1467b0c632dbSHeiko Carstens } 1468b0c632dbSHeiko Carstens 14695b1c1493SCarsten Otte int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) 14705b1c1493SCarsten Otte { 14715b1c1493SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 14725b1c1493SCarsten Otte if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET) 14735b1c1493SCarsten Otte && (kvm_is_ucontrol(vcpu->kvm))) { 14745b1c1493SCarsten Otte vmf->page = virt_to_page(vcpu->arch.sie_block); 14755b1c1493SCarsten Otte get_page(vmf->page); 14765b1c1493SCarsten Otte return 0; 14775b1c1493SCarsten Otte } 14785b1c1493SCarsten Otte #endif 14795b1c1493SCarsten Otte return VM_FAULT_SIGBUS; 14805b1c1493SCarsten Otte } 14815b1c1493SCarsten Otte 14825587027cSAneesh Kumar K.V void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free, 1483db3fe4ebSTakuya Yoshikawa struct kvm_memory_slot *dont) 1484db3fe4ebSTakuya Yoshikawa { 1485db3fe4ebSTakuya Yoshikawa } 1486db3fe4ebSTakuya Yoshikawa 14875587027cSAneesh Kumar K.V int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, 14885587027cSAneesh Kumar K.V unsigned long npages) 1489db3fe4ebSTakuya Yoshikawa { 1490db3fe4ebSTakuya Yoshikawa return 0; 1491db3fe4ebSTakuya Yoshikawa } 1492db3fe4ebSTakuya Yoshikawa 1493e59dbe09STakuya Yoshikawa void kvm_arch_memslots_updated(struct kvm *kvm) 1494e59dbe09STakuya Yoshikawa { 1495e59dbe09STakuya Yoshikawa } 1496e59dbe09STakuya Yoshikawa 1497b0c632dbSHeiko Carstens /* Section: memory related */ 1498f7784b8eSMarcelo Tosatti int kvm_arch_prepare_memory_region(struct kvm *kvm, 1499f7784b8eSMarcelo Tosatti struct kvm_memory_slot *memslot, 15007b6195a9STakuya Yoshikawa struct kvm_userspace_memory_region *mem, 15017b6195a9STakuya Yoshikawa enum kvm_mr_change change) 1502b0c632dbSHeiko Carstens { 1503dd2887e7SNick Wang /* A few sanity checks. We can have memory slots which have to be 1504dd2887e7SNick Wang located/ended at a segment boundary (1MB). The memory in userland is 1505dd2887e7SNick Wang ok to be fragmented into various different vmas. It is okay to mmap() 1506dd2887e7SNick Wang and munmap() stuff in this slot after doing this call at any time */ 1507b0c632dbSHeiko Carstens 1508598841caSCarsten Otte if (mem->userspace_addr & 0xffffful) 1509b0c632dbSHeiko Carstens return -EINVAL; 1510b0c632dbSHeiko Carstens 1511598841caSCarsten Otte if (mem->memory_size & 0xffffful) 1512b0c632dbSHeiko Carstens return -EINVAL; 1513b0c632dbSHeiko Carstens 1514f7784b8eSMarcelo Tosatti return 0; 1515f7784b8eSMarcelo Tosatti } 1516f7784b8eSMarcelo Tosatti 1517f7784b8eSMarcelo Tosatti void kvm_arch_commit_memory_region(struct kvm *kvm, 1518f7784b8eSMarcelo Tosatti struct kvm_userspace_memory_region *mem, 15198482644aSTakuya Yoshikawa const struct kvm_memory_slot *old, 15208482644aSTakuya Yoshikawa enum kvm_mr_change change) 1521f7784b8eSMarcelo Tosatti { 1522f7850c92SCarsten Otte int rc; 1523f7784b8eSMarcelo Tosatti 15242cef4debSChristian Borntraeger /* If the basics of the memslot do not change, we do not want 15252cef4debSChristian Borntraeger * to update the gmap. Every update causes several unnecessary 15262cef4debSChristian Borntraeger * segment translation exceptions. This is usually handled just 15272cef4debSChristian Borntraeger * fine by the normal fault handler + gmap, but it will also 15282cef4debSChristian Borntraeger * cause faults on the prefix page of running guest CPUs. 15292cef4debSChristian Borntraeger */ 15302cef4debSChristian Borntraeger if (old->userspace_addr == mem->userspace_addr && 15312cef4debSChristian Borntraeger old->base_gfn * PAGE_SIZE == mem->guest_phys_addr && 15322cef4debSChristian Borntraeger old->npages * PAGE_SIZE == mem->memory_size) 15332cef4debSChristian Borntraeger return; 1534598841caSCarsten Otte 1535598841caSCarsten Otte rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr, 1536598841caSCarsten Otte mem->guest_phys_addr, mem->memory_size); 1537598841caSCarsten Otte if (rc) 1538f7850c92SCarsten Otte printk(KERN_WARNING "kvm-s390: failed to commit memory region\n"); 1539598841caSCarsten Otte return; 1540b0c632dbSHeiko Carstens } 1541b0c632dbSHeiko Carstens 15422df72e9bSMarcelo Tosatti void kvm_arch_flush_shadow_all(struct kvm *kvm) 15432df72e9bSMarcelo Tosatti { 15442df72e9bSMarcelo Tosatti } 15452df72e9bSMarcelo Tosatti 15462df72e9bSMarcelo Tosatti void kvm_arch_flush_shadow_memslot(struct kvm *kvm, 15472df72e9bSMarcelo Tosatti struct kvm_memory_slot *slot) 154834d4cb8fSMarcelo Tosatti { 154934d4cb8fSMarcelo Tosatti } 155034d4cb8fSMarcelo Tosatti 1551b0c632dbSHeiko Carstens static int __init kvm_s390_init(void) 1552b0c632dbSHeiko Carstens { 1553ef50f7acSChristian Borntraeger int ret; 15540ee75beaSAvi Kivity ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); 1555ef50f7acSChristian Borntraeger if (ret) 1556ef50f7acSChristian Borntraeger return ret; 1557ef50f7acSChristian Borntraeger 1558ef50f7acSChristian Borntraeger /* 1559ef50f7acSChristian Borntraeger * guests can ask for up to 255+1 double words, we need a full page 156025985edcSLucas De Marchi * to hold the maximum amount of facilities. On the other hand, we 1561ef50f7acSChristian Borntraeger * only set facilities that are known to work in KVM. 1562ef50f7acSChristian Borntraeger */ 156378c4b59fSMichael Mueller vfacilities = (unsigned long *) get_zeroed_page(GFP_KERNEL|GFP_DMA); 156478c4b59fSMichael Mueller if (!vfacilities) { 1565ef50f7acSChristian Borntraeger kvm_exit(); 1566ef50f7acSChristian Borntraeger return -ENOMEM; 1567ef50f7acSChristian Borntraeger } 156878c4b59fSMichael Mueller memcpy(vfacilities, S390_lowcore.stfle_fac_list, 16); 1569d208c79dSThomas Huth vfacilities[0] &= 0xff82fff3f4fc2000UL; 15707feb6bb8SMichael Mueller vfacilities[1] &= 0x005c000000000000UL; 1571ef50f7acSChristian Borntraeger return 0; 1572b0c632dbSHeiko Carstens } 1573b0c632dbSHeiko Carstens 1574b0c632dbSHeiko Carstens static void __exit kvm_s390_exit(void) 1575b0c632dbSHeiko Carstens { 157678c4b59fSMichael Mueller free_page((unsigned long) vfacilities); 1577b0c632dbSHeiko Carstens kvm_exit(); 1578b0c632dbSHeiko Carstens } 1579b0c632dbSHeiko Carstens 1580b0c632dbSHeiko Carstens module_init(kvm_s390_init); 1581b0c632dbSHeiko Carstens module_exit(kvm_s390_exit); 1582566af940SCornelia Huck 1583566af940SCornelia Huck /* 1584566af940SCornelia Huck * Enable autoloading of the kvm module. 1585566af940SCornelia Huck * Note that we add the module alias here instead of virt/kvm/kvm_main.c 1586566af940SCornelia Huck * since x86 takes a different approach. 1587566af940SCornelia Huck */ 1588566af940SCornelia Huck #include <linux/miscdevice.h> 1589566af940SCornelia Huck MODULE_ALIAS_MISCDEV(KVM_MINOR); 1590566af940SCornelia Huck MODULE_ALIAS("devname:kvm"); 1591