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> 31fdf03650SFan Zhang #include <asm/etr.h> 32b0c632dbSHeiko Carstens #include <asm/pgtable.h> 331e133ab2SMartin Schwidefsky #include <asm/gmap.h> 34f5daba1dSHeiko Carstens #include <asm/nmi.h> 35a0616cdeSDavid Howells #include <asm/switch_to.h> 366d3da241SJens Freimann #include <asm/isc.h> 371526bf9cSChristian Borntraeger #include <asm/sclp.h> 388f2abe6aSChristian Borntraeger #include "kvm-s390.h" 39b0c632dbSHeiko Carstens #include "gaccess.h" 40b0c632dbSHeiko Carstens 41ea2cdd27SDavid Hildenbrand #define KMSG_COMPONENT "kvm-s390" 42ea2cdd27SDavid Hildenbrand #undef pr_fmt 43ea2cdd27SDavid Hildenbrand #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 44ea2cdd27SDavid Hildenbrand 455786fffaSCornelia Huck #define CREATE_TRACE_POINTS 465786fffaSCornelia Huck #include "trace.h" 47ade38c31SCornelia Huck #include "trace-s390.h" 485786fffaSCornelia Huck 4941408c28SThomas Huth #define MEM_OP_MAX_SIZE 65536 /* Maximum transfer size for KVM_S390_MEM_OP */ 50816c7667SJens Freimann #define LOCAL_IRQS 32 51816c7667SJens Freimann #define VCPU_IRQS_MAX_BUF (sizeof(struct kvm_s390_irq) * \ 52816c7667SJens Freimann (KVM_MAX_VCPUS + LOCAL_IRQS)) 5341408c28SThomas Huth 54b0c632dbSHeiko Carstens #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU 55b0c632dbSHeiko Carstens 56b0c632dbSHeiko Carstens struct kvm_stats_debugfs_item debugfs_entries[] = { 57b0c632dbSHeiko Carstens { "userspace_handled", VCPU_STAT(exit_userspace) }, 580eaeafa1SChristian Borntraeger { "exit_null", VCPU_STAT(exit_null) }, 598f2abe6aSChristian Borntraeger { "exit_validity", VCPU_STAT(exit_validity) }, 608f2abe6aSChristian Borntraeger { "exit_stop_request", VCPU_STAT(exit_stop_request) }, 618f2abe6aSChristian Borntraeger { "exit_external_request", VCPU_STAT(exit_external_request) }, 628f2abe6aSChristian Borntraeger { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) }, 63ba5c1e9bSCarsten Otte { "exit_instruction", VCPU_STAT(exit_instruction) }, 64ba5c1e9bSCarsten Otte { "exit_program_interruption", VCPU_STAT(exit_program_interruption) }, 65ba5c1e9bSCarsten Otte { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) }, 66f7819512SPaolo Bonzini { "halt_successful_poll", VCPU_STAT(halt_successful_poll) }, 6762bea5bfSPaolo Bonzini { "halt_attempted_poll", VCPU_STAT(halt_attempted_poll) }, 68ce2e4f0bSDavid Hildenbrand { "halt_wakeup", VCPU_STAT(halt_wakeup) }, 69f5e10b09SChristian Borntraeger { "instruction_lctlg", VCPU_STAT(instruction_lctlg) }, 70ba5c1e9bSCarsten Otte { "instruction_lctl", VCPU_STAT(instruction_lctl) }, 71aba07508SDavid Hildenbrand { "instruction_stctl", VCPU_STAT(instruction_stctl) }, 72aba07508SDavid Hildenbrand { "instruction_stctg", VCPU_STAT(instruction_stctg) }, 73ba5c1e9bSCarsten Otte { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) }, 747697e71fSChristian Ehrhardt { "deliver_external_call", VCPU_STAT(deliver_external_call) }, 75ba5c1e9bSCarsten Otte { "deliver_service_signal", VCPU_STAT(deliver_service_signal) }, 76ba5c1e9bSCarsten Otte { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) }, 77ba5c1e9bSCarsten Otte { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) }, 78ba5c1e9bSCarsten Otte { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) }, 79ba5c1e9bSCarsten Otte { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) }, 80ba5c1e9bSCarsten Otte { "deliver_program_interruption", VCPU_STAT(deliver_program_int) }, 81ba5c1e9bSCarsten Otte { "exit_wait_state", VCPU_STAT(exit_wait_state) }, 8269d0d3a3SChristian Borntraeger { "instruction_pfmf", VCPU_STAT(instruction_pfmf) }, 83453423dcSChristian Borntraeger { "instruction_stidp", VCPU_STAT(instruction_stidp) }, 84453423dcSChristian Borntraeger { "instruction_spx", VCPU_STAT(instruction_spx) }, 85453423dcSChristian Borntraeger { "instruction_stpx", VCPU_STAT(instruction_stpx) }, 86453423dcSChristian Borntraeger { "instruction_stap", VCPU_STAT(instruction_stap) }, 87453423dcSChristian Borntraeger { "instruction_storage_key", VCPU_STAT(instruction_storage_key) }, 888a242234SHeiko Carstens { "instruction_ipte_interlock", VCPU_STAT(instruction_ipte_interlock) }, 89453423dcSChristian Borntraeger { "instruction_stsch", VCPU_STAT(instruction_stsch) }, 90453423dcSChristian Borntraeger { "instruction_chsc", VCPU_STAT(instruction_chsc) }, 91b31288faSKonstantin Weitz { "instruction_essa", VCPU_STAT(instruction_essa) }, 92453423dcSChristian Borntraeger { "instruction_stsi", VCPU_STAT(instruction_stsi) }, 93453423dcSChristian Borntraeger { "instruction_stfl", VCPU_STAT(instruction_stfl) }, 94bb25b9baSChristian Borntraeger { "instruction_tprot", VCPU_STAT(instruction_tprot) }, 955288fbf0SChristian Borntraeger { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) }, 96bd59d3a4SCornelia Huck { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) }, 977697e71fSChristian Ehrhardt { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) }, 985288fbf0SChristian Borntraeger { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) }, 9942cb0c9fSDavid Hildenbrand { "instruction_sigp_cond_emergency", VCPU_STAT(instruction_sigp_cond_emergency) }, 10042cb0c9fSDavid Hildenbrand { "instruction_sigp_start", VCPU_STAT(instruction_sigp_start) }, 1015288fbf0SChristian Borntraeger { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) }, 10242cb0c9fSDavid Hildenbrand { "instruction_sigp_stop_store_status", VCPU_STAT(instruction_sigp_stop_store_status) }, 10342cb0c9fSDavid Hildenbrand { "instruction_sigp_store_status", VCPU_STAT(instruction_sigp_store_status) }, 104cd7b4b61SEric Farman { "instruction_sigp_store_adtl_status", VCPU_STAT(instruction_sigp_store_adtl_status) }, 1055288fbf0SChristian Borntraeger { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) }, 1065288fbf0SChristian Borntraeger { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) }, 1075288fbf0SChristian Borntraeger { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) }, 10842cb0c9fSDavid Hildenbrand { "instruction_sigp_cpu_reset", VCPU_STAT(instruction_sigp_cpu_reset) }, 10942cb0c9fSDavid Hildenbrand { "instruction_sigp_init_cpu_reset", VCPU_STAT(instruction_sigp_init_cpu_reset) }, 11042cb0c9fSDavid Hildenbrand { "instruction_sigp_unknown", VCPU_STAT(instruction_sigp_unknown) }, 111388186bcSChristian Borntraeger { "diagnose_10", VCPU_STAT(diagnose_10) }, 112e28acfeaSChristian Borntraeger { "diagnose_44", VCPU_STAT(diagnose_44) }, 11341628d33SKonstantin Weitz { "diagnose_9c", VCPU_STAT(diagnose_9c) }, 114175a5c9eSChristian Borntraeger { "diagnose_258", VCPU_STAT(diagnose_258) }, 115175a5c9eSChristian Borntraeger { "diagnose_308", VCPU_STAT(diagnose_308) }, 116175a5c9eSChristian Borntraeger { "diagnose_500", VCPU_STAT(diagnose_500) }, 117b0c632dbSHeiko Carstens { NULL } 118b0c632dbSHeiko Carstens }; 119b0c632dbSHeiko Carstens 1209d8d5786SMichael Mueller /* upper facilities limit for kvm */ 1219d8d5786SMichael Mueller unsigned long kvm_s390_fac_list_mask[] = { 122a3ed8daeSChristian Borntraeger 0xffe6fffbfcfdfc40UL, 12353df84f8SGuenther Hutzl 0x005e800000000000UL, 1249d8d5786SMichael Mueller }; 125b0c632dbSHeiko Carstens 1269d8d5786SMichael Mueller unsigned long kvm_s390_fac_list_mask_size(void) 12778c4b59fSMichael Mueller { 1289d8d5786SMichael Mueller BUILD_BUG_ON(ARRAY_SIZE(kvm_s390_fac_list_mask) > S390_ARCH_FAC_MASK_SIZE_U64); 1299d8d5786SMichael Mueller return ARRAY_SIZE(kvm_s390_fac_list_mask); 13078c4b59fSMichael Mueller } 13178c4b59fSMichael Mueller 1329d8d5786SMichael Mueller static struct gmap_notifier gmap_notifier; 13378f26131SChristian Borntraeger debug_info_t *kvm_s390_dbf; 1349d8d5786SMichael Mueller 135b0c632dbSHeiko Carstens /* Section: not file related */ 13613a34e06SRadim Krčmář int kvm_arch_hardware_enable(void) 137b0c632dbSHeiko Carstens { 138b0c632dbSHeiko Carstens /* every s390 is virtualization enabled ;-) */ 13910474ae8SAlexander Graf return 0; 140b0c632dbSHeiko Carstens } 141b0c632dbSHeiko Carstens 1422c70fe44SChristian Borntraeger static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address); 1432c70fe44SChristian Borntraeger 144fdf03650SFan Zhang /* 145fdf03650SFan Zhang * This callback is executed during stop_machine(). All CPUs are therefore 146fdf03650SFan Zhang * temporarily stopped. In order not to change guest behavior, we have to 147fdf03650SFan Zhang * disable preemption whenever we touch the epoch of kvm and the VCPUs, 148fdf03650SFan Zhang * so a CPU won't be stopped while calculating with the epoch. 149fdf03650SFan Zhang */ 150fdf03650SFan Zhang static int kvm_clock_sync(struct notifier_block *notifier, unsigned long val, 151fdf03650SFan Zhang void *v) 152fdf03650SFan Zhang { 153fdf03650SFan Zhang struct kvm *kvm; 154fdf03650SFan Zhang struct kvm_vcpu *vcpu; 155fdf03650SFan Zhang int i; 156fdf03650SFan Zhang unsigned long long *delta = v; 157fdf03650SFan Zhang 158fdf03650SFan Zhang list_for_each_entry(kvm, &vm_list, vm_list) { 159fdf03650SFan Zhang kvm->arch.epoch -= *delta; 160fdf03650SFan Zhang kvm_for_each_vcpu(i, vcpu, kvm) { 161fdf03650SFan Zhang vcpu->arch.sie_block->epoch -= *delta; 162db0758b2SDavid Hildenbrand if (vcpu->arch.cputm_enabled) 163db0758b2SDavid Hildenbrand vcpu->arch.cputm_start += *delta; 164fdf03650SFan Zhang } 165fdf03650SFan Zhang } 166fdf03650SFan Zhang return NOTIFY_OK; 167fdf03650SFan Zhang } 168fdf03650SFan Zhang 169fdf03650SFan Zhang static struct notifier_block kvm_clock_notifier = { 170fdf03650SFan Zhang .notifier_call = kvm_clock_sync, 171fdf03650SFan Zhang }; 172fdf03650SFan Zhang 173b0c632dbSHeiko Carstens int kvm_arch_hardware_setup(void) 174b0c632dbSHeiko Carstens { 1752c70fe44SChristian Borntraeger gmap_notifier.notifier_call = kvm_gmap_notifier; 1762c70fe44SChristian Borntraeger gmap_register_ipte_notifier(&gmap_notifier); 177fdf03650SFan Zhang atomic_notifier_chain_register(&s390_epoch_delta_notifier, 178fdf03650SFan Zhang &kvm_clock_notifier); 179b0c632dbSHeiko Carstens return 0; 180b0c632dbSHeiko Carstens } 181b0c632dbSHeiko Carstens 182b0c632dbSHeiko Carstens void kvm_arch_hardware_unsetup(void) 183b0c632dbSHeiko Carstens { 1842c70fe44SChristian Borntraeger gmap_unregister_ipte_notifier(&gmap_notifier); 185fdf03650SFan Zhang atomic_notifier_chain_unregister(&s390_epoch_delta_notifier, 186fdf03650SFan Zhang &kvm_clock_notifier); 187b0c632dbSHeiko Carstens } 188b0c632dbSHeiko Carstens 189b0c632dbSHeiko Carstens int kvm_arch_init(void *opaque) 190b0c632dbSHeiko Carstens { 19178f26131SChristian Borntraeger kvm_s390_dbf = debug_register("kvm-trace", 32, 1, 7 * sizeof(long)); 19278f26131SChristian Borntraeger if (!kvm_s390_dbf) 19378f26131SChristian Borntraeger return -ENOMEM; 19478f26131SChristian Borntraeger 19578f26131SChristian Borntraeger if (debug_register_view(kvm_s390_dbf, &debug_sprintf_view)) { 19678f26131SChristian Borntraeger debug_unregister(kvm_s390_dbf); 19778f26131SChristian Borntraeger return -ENOMEM; 19878f26131SChristian Borntraeger } 19978f26131SChristian Borntraeger 20084877d93SCornelia Huck /* Register floating interrupt controller interface. */ 20184877d93SCornelia Huck return kvm_register_device_ops(&kvm_flic_ops, KVM_DEV_TYPE_FLIC); 202b0c632dbSHeiko Carstens } 203b0c632dbSHeiko Carstens 20478f26131SChristian Borntraeger void kvm_arch_exit(void) 20578f26131SChristian Borntraeger { 20678f26131SChristian Borntraeger debug_unregister(kvm_s390_dbf); 20778f26131SChristian Borntraeger } 20878f26131SChristian Borntraeger 209b0c632dbSHeiko Carstens /* Section: device related */ 210b0c632dbSHeiko Carstens long kvm_arch_dev_ioctl(struct file *filp, 211b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 212b0c632dbSHeiko Carstens { 213b0c632dbSHeiko Carstens if (ioctl == KVM_S390_ENABLE_SIE) 214b0c632dbSHeiko Carstens return s390_enable_sie(); 215b0c632dbSHeiko Carstens return -EINVAL; 216b0c632dbSHeiko Carstens } 217b0c632dbSHeiko Carstens 218784aa3d7SAlexander Graf int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) 219b0c632dbSHeiko Carstens { 220d7b0b5ebSCarsten Otte int r; 221d7b0b5ebSCarsten Otte 2222bd0ac4eSCarsten Otte switch (ext) { 223d7b0b5ebSCarsten Otte case KVM_CAP_S390_PSW: 224b6cf8788SChristian Borntraeger case KVM_CAP_S390_GMAP: 22552e16b18SChristian Borntraeger case KVM_CAP_SYNC_MMU: 2261efd0f59SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 2271efd0f59SCarsten Otte case KVM_CAP_S390_UCONTROL: 2281efd0f59SCarsten Otte #endif 2293c038e6bSDominik Dingel case KVM_CAP_ASYNC_PF: 23060b413c9SChristian Borntraeger case KVM_CAP_SYNC_REGS: 23114eebd91SCarsten Otte case KVM_CAP_ONE_REG: 232d6712df9SCornelia Huck case KVM_CAP_ENABLE_CAP: 233fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 23410ccaa1eSCornelia Huck case KVM_CAP_IOEVENTFD: 235c05c4186SJens Freimann case KVM_CAP_DEVICE_CTRL: 236d938dc55SCornelia Huck case KVM_CAP_ENABLE_CAP_VM: 23778599d90SCornelia Huck case KVM_CAP_S390_IRQCHIP: 238f2061656SDominik Dingel case KVM_CAP_VM_ATTRIBUTES: 2396352e4d2SDavid Hildenbrand case KVM_CAP_MP_STATE: 24047b43c52SJens Freimann case KVM_CAP_S390_INJECT_IRQ: 2412444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 242e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 24330ee2a98SJason J. Herne case KVM_CAP_S390_SKEYS: 244816c7667SJens Freimann case KVM_CAP_S390_IRQ_STATE: 245d7b0b5ebSCarsten Otte r = 1; 246d7b0b5ebSCarsten Otte break; 24741408c28SThomas Huth case KVM_CAP_S390_MEM_OP: 24841408c28SThomas Huth r = MEM_OP_MAX_SIZE; 24941408c28SThomas Huth break; 250e726b1bdSChristian Borntraeger case KVM_CAP_NR_VCPUS: 251e726b1bdSChristian Borntraeger case KVM_CAP_MAX_VCPUS: 252fe0edcb7SEugene (jno) Dvurechenski r = sclp.has_esca ? KVM_S390_ESCA_CPU_SLOTS 253fe0edcb7SEugene (jno) Dvurechenski : KVM_S390_BSCA_CPU_SLOTS; 254e726b1bdSChristian Borntraeger break; 255e1e2e605SNick Wang case KVM_CAP_NR_MEMSLOTS: 256e1e2e605SNick Wang r = KVM_USER_MEM_SLOTS; 257e1e2e605SNick Wang break; 2581526bf9cSChristian Borntraeger case KVM_CAP_S390_COW: 259abf09bedSMartin Schwidefsky r = MACHINE_HAS_ESOP; 2601526bf9cSChristian Borntraeger break; 26168c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 26268c55750SEric Farman r = MACHINE_HAS_VX; 26368c55750SEric Farman break; 264c6e5f166SFan Zhang case KVM_CAP_S390_RI: 265c6e5f166SFan Zhang r = test_facility(64); 266c6e5f166SFan Zhang break; 2672bd0ac4eSCarsten Otte default: 268d7b0b5ebSCarsten Otte r = 0; 269b0c632dbSHeiko Carstens } 270d7b0b5ebSCarsten Otte return r; 2712bd0ac4eSCarsten Otte } 272b0c632dbSHeiko Carstens 27315f36ebdSJason J. Herne static void kvm_s390_sync_dirty_log(struct kvm *kvm, 27415f36ebdSJason J. Herne struct kvm_memory_slot *memslot) 27515f36ebdSJason J. Herne { 27615f36ebdSJason J. Herne gfn_t cur_gfn, last_gfn; 27715f36ebdSJason J. Herne unsigned long address; 27815f36ebdSJason J. Herne struct gmap *gmap = kvm->arch.gmap; 27915f36ebdSJason J. Herne 28015f36ebdSJason J. Herne /* Loop over all guest pages */ 28115f36ebdSJason J. Herne last_gfn = memslot->base_gfn + memslot->npages; 28215f36ebdSJason J. Herne for (cur_gfn = memslot->base_gfn; cur_gfn <= last_gfn; cur_gfn++) { 28315f36ebdSJason J. Herne address = gfn_to_hva_memslot(memslot, cur_gfn); 28415f36ebdSJason J. Herne 2851e133ab2SMartin Schwidefsky if (test_and_clear_guest_dirty(gmap->mm, address)) 28615f36ebdSJason J. Herne mark_page_dirty(kvm, cur_gfn); 2871763f8d0SChristian Borntraeger if (fatal_signal_pending(current)) 2881763f8d0SChristian Borntraeger return; 28970c88a00SChristian Borntraeger cond_resched(); 29015f36ebdSJason J. Herne } 29115f36ebdSJason J. Herne } 29215f36ebdSJason J. Herne 293b0c632dbSHeiko Carstens /* Section: vm related */ 294a6e2f683SEugene (jno) Dvurechenski static void sca_del_vcpu(struct kvm_vcpu *vcpu); 295a6e2f683SEugene (jno) Dvurechenski 296b0c632dbSHeiko Carstens /* 297b0c632dbSHeiko Carstens * Get (and clear) the dirty memory log for a memory slot. 298b0c632dbSHeiko Carstens */ 299b0c632dbSHeiko Carstens int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, 300b0c632dbSHeiko Carstens struct kvm_dirty_log *log) 301b0c632dbSHeiko Carstens { 30215f36ebdSJason J. Herne int r; 30315f36ebdSJason J. Herne unsigned long n; 3049f6b8029SPaolo Bonzini struct kvm_memslots *slots; 30515f36ebdSJason J. Herne struct kvm_memory_slot *memslot; 30615f36ebdSJason J. Herne int is_dirty = 0; 30715f36ebdSJason J. Herne 30815f36ebdSJason J. Herne mutex_lock(&kvm->slots_lock); 30915f36ebdSJason J. Herne 31015f36ebdSJason J. Herne r = -EINVAL; 31115f36ebdSJason J. Herne if (log->slot >= KVM_USER_MEM_SLOTS) 31215f36ebdSJason J. Herne goto out; 31315f36ebdSJason J. Herne 3149f6b8029SPaolo Bonzini slots = kvm_memslots(kvm); 3159f6b8029SPaolo Bonzini memslot = id_to_memslot(slots, log->slot); 31615f36ebdSJason J. Herne r = -ENOENT; 31715f36ebdSJason J. Herne if (!memslot->dirty_bitmap) 31815f36ebdSJason J. Herne goto out; 31915f36ebdSJason J. Herne 32015f36ebdSJason J. Herne kvm_s390_sync_dirty_log(kvm, memslot); 32115f36ebdSJason J. Herne r = kvm_get_dirty_log(kvm, log, &is_dirty); 32215f36ebdSJason J. Herne if (r) 32315f36ebdSJason J. Herne goto out; 32415f36ebdSJason J. Herne 32515f36ebdSJason J. Herne /* Clear the dirty log */ 32615f36ebdSJason J. Herne if (is_dirty) { 32715f36ebdSJason J. Herne n = kvm_dirty_bitmap_bytes(memslot); 32815f36ebdSJason J. Herne memset(memslot->dirty_bitmap, 0, n); 32915f36ebdSJason J. Herne } 33015f36ebdSJason J. Herne r = 0; 33115f36ebdSJason J. Herne out: 33215f36ebdSJason J. Herne mutex_unlock(&kvm->slots_lock); 33315f36ebdSJason J. Herne return r; 334b0c632dbSHeiko Carstens } 335b0c632dbSHeiko Carstens 336d938dc55SCornelia Huck static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap) 337d938dc55SCornelia Huck { 338d938dc55SCornelia Huck int r; 339d938dc55SCornelia Huck 340d938dc55SCornelia Huck if (cap->flags) 341d938dc55SCornelia Huck return -EINVAL; 342d938dc55SCornelia Huck 343d938dc55SCornelia Huck switch (cap->cap) { 34484223598SCornelia Huck case KVM_CAP_S390_IRQCHIP: 345c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_IRQCHIP"); 34684223598SCornelia Huck kvm->arch.use_irqchip = 1; 34784223598SCornelia Huck r = 0; 34884223598SCornelia Huck break; 3492444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 350c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_SIGP"); 3512444b352SDavid Hildenbrand kvm->arch.user_sigp = 1; 3522444b352SDavid Hildenbrand r = 0; 3532444b352SDavid Hildenbrand break; 35468c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 3555967c17bSDavid Hildenbrand mutex_lock(&kvm->lock); 3565967c17bSDavid Hildenbrand if (atomic_read(&kvm->online_vcpus)) { 3575967c17bSDavid Hildenbrand r = -EBUSY; 3585967c17bSDavid Hildenbrand } else if (MACHINE_HAS_VX) { 359c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 129); 360c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 129); 36118280d8bSMichael Mueller r = 0; 36218280d8bSMichael Mueller } else 36318280d8bSMichael Mueller r = -EINVAL; 3645967c17bSDavid Hildenbrand mutex_unlock(&kvm->lock); 365c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "ENABLE: CAP_S390_VECTOR_REGISTERS %s", 366c92ea7b9SChristian Borntraeger r ? "(not available)" : "(success)"); 36768c55750SEric Farman break; 368c6e5f166SFan Zhang case KVM_CAP_S390_RI: 369c6e5f166SFan Zhang r = -EINVAL; 370c6e5f166SFan Zhang mutex_lock(&kvm->lock); 371c6e5f166SFan Zhang if (atomic_read(&kvm->online_vcpus)) { 372c6e5f166SFan Zhang r = -EBUSY; 373c6e5f166SFan Zhang } else if (test_facility(64)) { 374c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 64); 375c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 64); 376c6e5f166SFan Zhang r = 0; 377c6e5f166SFan Zhang } 378c6e5f166SFan Zhang mutex_unlock(&kvm->lock); 379c6e5f166SFan Zhang VM_EVENT(kvm, 3, "ENABLE: CAP_S390_RI %s", 380c6e5f166SFan Zhang r ? "(not available)" : "(success)"); 381c6e5f166SFan Zhang break; 382e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 383c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_STSI"); 384e44fc8c9SEkaterina Tumanova kvm->arch.user_stsi = 1; 385e44fc8c9SEkaterina Tumanova r = 0; 386e44fc8c9SEkaterina Tumanova break; 387d938dc55SCornelia Huck default: 388d938dc55SCornelia Huck r = -EINVAL; 389d938dc55SCornelia Huck break; 390d938dc55SCornelia Huck } 391d938dc55SCornelia Huck return r; 392d938dc55SCornelia Huck } 393d938dc55SCornelia Huck 3948c0a7ce6SDominik Dingel static int kvm_s390_get_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 3958c0a7ce6SDominik Dingel { 3968c0a7ce6SDominik Dingel int ret; 3978c0a7ce6SDominik Dingel 3988c0a7ce6SDominik Dingel switch (attr->attr) { 3998c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 4008c0a7ce6SDominik Dingel ret = 0; 401c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: max guest memory: %lu bytes", 402a3a92c31SDominik Dingel kvm->arch.mem_limit); 403a3a92c31SDominik Dingel if (put_user(kvm->arch.mem_limit, (u64 __user *)attr->addr)) 4048c0a7ce6SDominik Dingel ret = -EFAULT; 4058c0a7ce6SDominik Dingel break; 4068c0a7ce6SDominik Dingel default: 4078c0a7ce6SDominik Dingel ret = -ENXIO; 4088c0a7ce6SDominik Dingel break; 4098c0a7ce6SDominik Dingel } 4108c0a7ce6SDominik Dingel return ret; 4118c0a7ce6SDominik Dingel } 4128c0a7ce6SDominik Dingel 4138c0a7ce6SDominik Dingel static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 4144f718eabSDominik Dingel { 4154f718eabSDominik Dingel int ret; 4164f718eabSDominik Dingel unsigned int idx; 4174f718eabSDominik Dingel switch (attr->attr) { 4184f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 419e6db1d61SDominik Dingel /* enable CMMA only for z10 and later (EDAT_1) */ 420e6db1d61SDominik Dingel ret = -EINVAL; 421e6db1d61SDominik Dingel if (!MACHINE_IS_LPAR || !MACHINE_HAS_EDAT1) 422e6db1d61SDominik Dingel break; 423e6db1d61SDominik Dingel 4244f718eabSDominik Dingel ret = -EBUSY; 425c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CMMA support"); 4264f718eabSDominik Dingel mutex_lock(&kvm->lock); 4274f718eabSDominik Dingel if (atomic_read(&kvm->online_vcpus) == 0) { 4284f718eabSDominik Dingel kvm->arch.use_cmma = 1; 4294f718eabSDominik Dingel ret = 0; 4304f718eabSDominik Dingel } 4314f718eabSDominik Dingel mutex_unlock(&kvm->lock); 4324f718eabSDominik Dingel break; 4334f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 434c3489155SDominik Dingel ret = -EINVAL; 435c3489155SDominik Dingel if (!kvm->arch.use_cmma) 436c3489155SDominik Dingel break; 437c3489155SDominik Dingel 438c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "RESET: CMMA states"); 4394f718eabSDominik Dingel mutex_lock(&kvm->lock); 4404f718eabSDominik Dingel idx = srcu_read_lock(&kvm->srcu); 441a13cff31SDominik Dingel s390_reset_cmma(kvm->arch.gmap->mm); 4424f718eabSDominik Dingel srcu_read_unlock(&kvm->srcu, idx); 4434f718eabSDominik Dingel mutex_unlock(&kvm->lock); 4444f718eabSDominik Dingel ret = 0; 4454f718eabSDominik Dingel break; 4468c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: { 4478c0a7ce6SDominik Dingel unsigned long new_limit; 4488c0a7ce6SDominik Dingel 4498c0a7ce6SDominik Dingel if (kvm_is_ucontrol(kvm)) 4508c0a7ce6SDominik Dingel return -EINVAL; 4518c0a7ce6SDominik Dingel 4528c0a7ce6SDominik Dingel if (get_user(new_limit, (u64 __user *)attr->addr)) 4538c0a7ce6SDominik Dingel return -EFAULT; 4548c0a7ce6SDominik Dingel 455a3a92c31SDominik Dingel if (kvm->arch.mem_limit != KVM_S390_NO_MEM_LIMIT && 456a3a92c31SDominik Dingel new_limit > kvm->arch.mem_limit) 4578c0a7ce6SDominik Dingel return -E2BIG; 4588c0a7ce6SDominik Dingel 459a3a92c31SDominik Dingel if (!new_limit) 460a3a92c31SDominik Dingel return -EINVAL; 461a3a92c31SDominik Dingel 462a3a92c31SDominik Dingel /* gmap_alloc takes last usable address */ 463a3a92c31SDominik Dingel if (new_limit != KVM_S390_NO_MEM_LIMIT) 464a3a92c31SDominik Dingel new_limit -= 1; 465a3a92c31SDominik Dingel 4668c0a7ce6SDominik Dingel ret = -EBUSY; 4678c0a7ce6SDominik Dingel mutex_lock(&kvm->lock); 4688c0a7ce6SDominik Dingel if (atomic_read(&kvm->online_vcpus) == 0) { 4698c0a7ce6SDominik Dingel /* gmap_alloc will round the limit up */ 4708c0a7ce6SDominik Dingel struct gmap *new = gmap_alloc(current->mm, new_limit); 4718c0a7ce6SDominik Dingel 4728c0a7ce6SDominik Dingel if (!new) { 4738c0a7ce6SDominik Dingel ret = -ENOMEM; 4748c0a7ce6SDominik Dingel } else { 4758c0a7ce6SDominik Dingel gmap_free(kvm->arch.gmap); 4768c0a7ce6SDominik Dingel new->private = kvm; 4778c0a7ce6SDominik Dingel kvm->arch.gmap = new; 4788c0a7ce6SDominik Dingel ret = 0; 4798c0a7ce6SDominik Dingel } 4808c0a7ce6SDominik Dingel } 4818c0a7ce6SDominik Dingel mutex_unlock(&kvm->lock); 482a3a92c31SDominik Dingel VM_EVENT(kvm, 3, "SET: max guest address: %lu", new_limit); 483a3a92c31SDominik Dingel VM_EVENT(kvm, 3, "New guest asce: 0x%pK", 484a3a92c31SDominik Dingel (void *) kvm->arch.gmap->asce); 4858c0a7ce6SDominik Dingel break; 4868c0a7ce6SDominik Dingel } 4874f718eabSDominik Dingel default: 4884f718eabSDominik Dingel ret = -ENXIO; 4894f718eabSDominik Dingel break; 4904f718eabSDominik Dingel } 4914f718eabSDominik Dingel return ret; 4924f718eabSDominik Dingel } 4934f718eabSDominik Dingel 494a374e892STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu); 495a374e892STony Krowiak 496a374e892STony Krowiak static int kvm_s390_vm_set_crypto(struct kvm *kvm, struct kvm_device_attr *attr) 497a374e892STony Krowiak { 498a374e892STony Krowiak struct kvm_vcpu *vcpu; 499a374e892STony Krowiak int i; 500a374e892STony Krowiak 5019d8d5786SMichael Mueller if (!test_kvm_facility(kvm, 76)) 502a374e892STony Krowiak return -EINVAL; 503a374e892STony Krowiak 504a374e892STony Krowiak mutex_lock(&kvm->lock); 505a374e892STony Krowiak switch (attr->attr) { 506a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 507a374e892STony Krowiak get_random_bytes( 508a374e892STony Krowiak kvm->arch.crypto.crycb->aes_wrapping_key_mask, 509a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 510a374e892STony Krowiak kvm->arch.crypto.aes_kw = 1; 511c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: AES keywrapping support"); 512a374e892STony Krowiak break; 513a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 514a374e892STony Krowiak get_random_bytes( 515a374e892STony Krowiak kvm->arch.crypto.crycb->dea_wrapping_key_mask, 516a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 517a374e892STony Krowiak kvm->arch.crypto.dea_kw = 1; 518c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: DEA keywrapping support"); 519a374e892STony Krowiak break; 520a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 521a374e892STony Krowiak kvm->arch.crypto.aes_kw = 0; 522a374e892STony Krowiak memset(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 0, 523a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 524c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "DISABLE: AES keywrapping support"); 525a374e892STony Krowiak break; 526a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 527a374e892STony Krowiak kvm->arch.crypto.dea_kw = 0; 528a374e892STony Krowiak memset(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 0, 529a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 530c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "DISABLE: DEA keywrapping support"); 531a374e892STony Krowiak break; 532a374e892STony Krowiak default: 533a374e892STony Krowiak mutex_unlock(&kvm->lock); 534a374e892STony Krowiak return -ENXIO; 535a374e892STony Krowiak } 536a374e892STony Krowiak 537a374e892STony Krowiak kvm_for_each_vcpu(i, vcpu, kvm) { 538a374e892STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 539a374e892STony Krowiak exit_sie(vcpu); 540a374e892STony Krowiak } 541a374e892STony Krowiak mutex_unlock(&kvm->lock); 542a374e892STony Krowiak return 0; 543a374e892STony Krowiak } 544a374e892STony Krowiak 54572f25020SJason J. Herne static int kvm_s390_set_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 54672f25020SJason J. Herne { 54772f25020SJason J. Herne u8 gtod_high; 54872f25020SJason J. Herne 54972f25020SJason J. Herne if (copy_from_user(>od_high, (void __user *)attr->addr, 55072f25020SJason J. Herne sizeof(gtod_high))) 55172f25020SJason J. Herne return -EFAULT; 55272f25020SJason J. Herne 55372f25020SJason J. Herne if (gtod_high != 0) 55472f25020SJason J. Herne return -EINVAL; 55558c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "SET: TOD extension: 0x%x", gtod_high); 55672f25020SJason J. Herne 55772f25020SJason J. Herne return 0; 55872f25020SJason J. Herne } 55972f25020SJason J. Herne 56072f25020SJason J. Herne static int kvm_s390_set_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 56172f25020SJason J. Herne { 5625a3d883aSDavid Hildenbrand u64 gtod; 56372f25020SJason J. Herne 56472f25020SJason J. Herne if (copy_from_user(>od, (void __user *)attr->addr, sizeof(gtod))) 56572f25020SJason J. Herne return -EFAULT; 56672f25020SJason J. Herne 56725ed1675SDavid Hildenbrand kvm_s390_set_tod_clock(kvm, gtod); 56858c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "SET: TOD base: 0x%llx", gtod); 56972f25020SJason J. Herne return 0; 57072f25020SJason J. Herne } 57172f25020SJason J. Herne 57272f25020SJason J. Herne static int kvm_s390_set_tod(struct kvm *kvm, struct kvm_device_attr *attr) 57372f25020SJason J. Herne { 57472f25020SJason J. Herne int ret; 57572f25020SJason J. Herne 57672f25020SJason J. Herne if (attr->flags) 57772f25020SJason J. Herne return -EINVAL; 57872f25020SJason J. Herne 57972f25020SJason J. Herne switch (attr->attr) { 58072f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 58172f25020SJason J. Herne ret = kvm_s390_set_tod_high(kvm, attr); 58272f25020SJason J. Herne break; 58372f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 58472f25020SJason J. Herne ret = kvm_s390_set_tod_low(kvm, attr); 58572f25020SJason J. Herne break; 58672f25020SJason J. Herne default: 58772f25020SJason J. Herne ret = -ENXIO; 58872f25020SJason J. Herne break; 58972f25020SJason J. Herne } 59072f25020SJason J. Herne return ret; 59172f25020SJason J. Herne } 59272f25020SJason J. Herne 59372f25020SJason J. Herne static int kvm_s390_get_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 59472f25020SJason J. Herne { 59572f25020SJason J. Herne u8 gtod_high = 0; 59672f25020SJason J. Herne 59772f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od_high, 59872f25020SJason J. Herne sizeof(gtod_high))) 59972f25020SJason J. Herne return -EFAULT; 60058c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: TOD extension: 0x%x", gtod_high); 60172f25020SJason J. Herne 60272f25020SJason J. Herne return 0; 60372f25020SJason J. Herne } 60472f25020SJason J. Herne 60572f25020SJason J. Herne static int kvm_s390_get_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 60672f25020SJason J. Herne { 6075a3d883aSDavid Hildenbrand u64 gtod; 60872f25020SJason J. Herne 60960417fccSDavid Hildenbrand gtod = kvm_s390_get_tod_clock_fast(kvm); 61072f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od, sizeof(gtod))) 61172f25020SJason J. Herne return -EFAULT; 61258c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: TOD base: 0x%llx", gtod); 61372f25020SJason J. Herne 61472f25020SJason J. Herne return 0; 61572f25020SJason J. Herne } 61672f25020SJason J. Herne 61772f25020SJason J. Herne static int kvm_s390_get_tod(struct kvm *kvm, struct kvm_device_attr *attr) 61872f25020SJason J. Herne { 61972f25020SJason J. Herne int ret; 62072f25020SJason J. Herne 62172f25020SJason J. Herne if (attr->flags) 62272f25020SJason J. Herne return -EINVAL; 62372f25020SJason J. Herne 62472f25020SJason J. Herne switch (attr->attr) { 62572f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 62672f25020SJason J. Herne ret = kvm_s390_get_tod_high(kvm, attr); 62772f25020SJason J. Herne break; 62872f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 62972f25020SJason J. Herne ret = kvm_s390_get_tod_low(kvm, attr); 63072f25020SJason J. Herne break; 63172f25020SJason J. Herne default: 63272f25020SJason J. Herne ret = -ENXIO; 63372f25020SJason J. Herne break; 63472f25020SJason J. Herne } 63572f25020SJason J. Herne return ret; 63672f25020SJason J. Herne } 63772f25020SJason J. Herne 638658b6edaSMichael Mueller static int kvm_s390_set_processor(struct kvm *kvm, struct kvm_device_attr *attr) 639658b6edaSMichael Mueller { 640658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 641658b6edaSMichael Mueller int ret = 0; 642658b6edaSMichael Mueller 643658b6edaSMichael Mueller mutex_lock(&kvm->lock); 644658b6edaSMichael Mueller if (atomic_read(&kvm->online_vcpus)) { 645658b6edaSMichael Mueller ret = -EBUSY; 646658b6edaSMichael Mueller goto out; 647658b6edaSMichael Mueller } 648658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 649658b6edaSMichael Mueller if (!proc) { 650658b6edaSMichael Mueller ret = -ENOMEM; 651658b6edaSMichael Mueller goto out; 652658b6edaSMichael Mueller } 653658b6edaSMichael Mueller if (!copy_from_user(proc, (void __user *)attr->addr, 654658b6edaSMichael Mueller sizeof(*proc))) { 655658b6edaSMichael Mueller memcpy(&kvm->arch.model.cpu_id, &proc->cpuid, 656658b6edaSMichael Mueller sizeof(struct cpuid)); 657658b6edaSMichael Mueller kvm->arch.model.ibc = proc->ibc; 658c54f0d6aSDavid Hildenbrand memcpy(kvm->arch.model.fac_list, proc->fac_list, 659658b6edaSMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 660658b6edaSMichael Mueller } else 661658b6edaSMichael Mueller ret = -EFAULT; 662658b6edaSMichael Mueller kfree(proc); 663658b6edaSMichael Mueller out: 664658b6edaSMichael Mueller mutex_unlock(&kvm->lock); 665658b6edaSMichael Mueller return ret; 666658b6edaSMichael Mueller } 667658b6edaSMichael Mueller 668658b6edaSMichael Mueller static int kvm_s390_set_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 669658b6edaSMichael Mueller { 670658b6edaSMichael Mueller int ret = -ENXIO; 671658b6edaSMichael Mueller 672658b6edaSMichael Mueller switch (attr->attr) { 673658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 674658b6edaSMichael Mueller ret = kvm_s390_set_processor(kvm, attr); 675658b6edaSMichael Mueller break; 676658b6edaSMichael Mueller } 677658b6edaSMichael Mueller return ret; 678658b6edaSMichael Mueller } 679658b6edaSMichael Mueller 680658b6edaSMichael Mueller static int kvm_s390_get_processor(struct kvm *kvm, struct kvm_device_attr *attr) 681658b6edaSMichael Mueller { 682658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 683658b6edaSMichael Mueller int ret = 0; 684658b6edaSMichael Mueller 685658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 686658b6edaSMichael Mueller if (!proc) { 687658b6edaSMichael Mueller ret = -ENOMEM; 688658b6edaSMichael Mueller goto out; 689658b6edaSMichael Mueller } 690658b6edaSMichael Mueller memcpy(&proc->cpuid, &kvm->arch.model.cpu_id, sizeof(struct cpuid)); 691658b6edaSMichael Mueller proc->ibc = kvm->arch.model.ibc; 692c54f0d6aSDavid Hildenbrand memcpy(&proc->fac_list, kvm->arch.model.fac_list, 693c54f0d6aSDavid Hildenbrand S390_ARCH_FAC_LIST_SIZE_BYTE); 694658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, proc, sizeof(*proc))) 695658b6edaSMichael Mueller ret = -EFAULT; 696658b6edaSMichael Mueller kfree(proc); 697658b6edaSMichael Mueller out: 698658b6edaSMichael Mueller return ret; 699658b6edaSMichael Mueller } 700658b6edaSMichael Mueller 701658b6edaSMichael Mueller static int kvm_s390_get_machine(struct kvm *kvm, struct kvm_device_attr *attr) 702658b6edaSMichael Mueller { 703658b6edaSMichael Mueller struct kvm_s390_vm_cpu_machine *mach; 704658b6edaSMichael Mueller int ret = 0; 705658b6edaSMichael Mueller 706658b6edaSMichael Mueller mach = kzalloc(sizeof(*mach), GFP_KERNEL); 707658b6edaSMichael Mueller if (!mach) { 708658b6edaSMichael Mueller ret = -ENOMEM; 709658b6edaSMichael Mueller goto out; 710658b6edaSMichael Mueller } 711658b6edaSMichael Mueller get_cpu_id((struct cpuid *) &mach->cpuid); 71237c5f6c8SDavid Hildenbrand mach->ibc = sclp.ibc; 713c54f0d6aSDavid Hildenbrand memcpy(&mach->fac_mask, kvm->arch.model.fac_mask, 714981467c9SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 715658b6edaSMichael Mueller memcpy((unsigned long *)&mach->fac_list, S390_lowcore.stfle_fac_list, 71694422ee8SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 717658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, mach, sizeof(*mach))) 718658b6edaSMichael Mueller ret = -EFAULT; 719658b6edaSMichael Mueller kfree(mach); 720658b6edaSMichael Mueller out: 721658b6edaSMichael Mueller return ret; 722658b6edaSMichael Mueller } 723658b6edaSMichael Mueller 724658b6edaSMichael Mueller static int kvm_s390_get_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 725658b6edaSMichael Mueller { 726658b6edaSMichael Mueller int ret = -ENXIO; 727658b6edaSMichael Mueller 728658b6edaSMichael Mueller switch (attr->attr) { 729658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 730658b6edaSMichael Mueller ret = kvm_s390_get_processor(kvm, attr); 731658b6edaSMichael Mueller break; 732658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 733658b6edaSMichael Mueller ret = kvm_s390_get_machine(kvm, attr); 734658b6edaSMichael Mueller break; 735658b6edaSMichael Mueller } 736658b6edaSMichael Mueller return ret; 737658b6edaSMichael Mueller } 738658b6edaSMichael Mueller 739f2061656SDominik Dingel static int kvm_s390_vm_set_attr(struct kvm *kvm, struct kvm_device_attr *attr) 740f2061656SDominik Dingel { 741f2061656SDominik Dingel int ret; 742f2061656SDominik Dingel 743f2061656SDominik Dingel switch (attr->group) { 7444f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 7458c0a7ce6SDominik Dingel ret = kvm_s390_set_mem_control(kvm, attr); 7464f718eabSDominik Dingel break; 74772f25020SJason J. Herne case KVM_S390_VM_TOD: 74872f25020SJason J. Herne ret = kvm_s390_set_tod(kvm, attr); 74972f25020SJason J. Herne break; 750658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 751658b6edaSMichael Mueller ret = kvm_s390_set_cpu_model(kvm, attr); 752658b6edaSMichael Mueller break; 753a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 754a374e892STony Krowiak ret = kvm_s390_vm_set_crypto(kvm, attr); 755a374e892STony Krowiak break; 756f2061656SDominik Dingel default: 757f2061656SDominik Dingel ret = -ENXIO; 758f2061656SDominik Dingel break; 759f2061656SDominik Dingel } 760f2061656SDominik Dingel 761f2061656SDominik Dingel return ret; 762f2061656SDominik Dingel } 763f2061656SDominik Dingel 764f2061656SDominik Dingel static int kvm_s390_vm_get_attr(struct kvm *kvm, struct kvm_device_attr *attr) 765f2061656SDominik Dingel { 7668c0a7ce6SDominik Dingel int ret; 7678c0a7ce6SDominik Dingel 7688c0a7ce6SDominik Dingel switch (attr->group) { 7698c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_CTRL: 7708c0a7ce6SDominik Dingel ret = kvm_s390_get_mem_control(kvm, attr); 7718c0a7ce6SDominik Dingel break; 77272f25020SJason J. Herne case KVM_S390_VM_TOD: 77372f25020SJason J. Herne ret = kvm_s390_get_tod(kvm, attr); 77472f25020SJason J. Herne break; 775658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 776658b6edaSMichael Mueller ret = kvm_s390_get_cpu_model(kvm, attr); 777658b6edaSMichael Mueller break; 7788c0a7ce6SDominik Dingel default: 7798c0a7ce6SDominik Dingel ret = -ENXIO; 7808c0a7ce6SDominik Dingel break; 7818c0a7ce6SDominik Dingel } 7828c0a7ce6SDominik Dingel 7838c0a7ce6SDominik Dingel return ret; 784f2061656SDominik Dingel } 785f2061656SDominik Dingel 786f2061656SDominik Dingel static int kvm_s390_vm_has_attr(struct kvm *kvm, struct kvm_device_attr *attr) 787f2061656SDominik Dingel { 788f2061656SDominik Dingel int ret; 789f2061656SDominik Dingel 790f2061656SDominik Dingel switch (attr->group) { 7914f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 7924f718eabSDominik Dingel switch (attr->attr) { 7934f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 7944f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 7958c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 7964f718eabSDominik Dingel ret = 0; 7974f718eabSDominik Dingel break; 7984f718eabSDominik Dingel default: 7994f718eabSDominik Dingel ret = -ENXIO; 8004f718eabSDominik Dingel break; 8014f718eabSDominik Dingel } 8024f718eabSDominik Dingel break; 80372f25020SJason J. Herne case KVM_S390_VM_TOD: 80472f25020SJason J. Herne switch (attr->attr) { 80572f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 80672f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 80772f25020SJason J. Herne ret = 0; 80872f25020SJason J. Herne break; 80972f25020SJason J. Herne default: 81072f25020SJason J. Herne ret = -ENXIO; 81172f25020SJason J. Herne break; 81272f25020SJason J. Herne } 81372f25020SJason J. Herne break; 814658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 815658b6edaSMichael Mueller switch (attr->attr) { 816658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 817658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 818658b6edaSMichael Mueller ret = 0; 819658b6edaSMichael Mueller break; 820658b6edaSMichael Mueller default: 821658b6edaSMichael Mueller ret = -ENXIO; 822658b6edaSMichael Mueller break; 823658b6edaSMichael Mueller } 824658b6edaSMichael Mueller break; 825a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 826a374e892STony Krowiak switch (attr->attr) { 827a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 828a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 829a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 830a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 831a374e892STony Krowiak ret = 0; 832a374e892STony Krowiak break; 833a374e892STony Krowiak default: 834a374e892STony Krowiak ret = -ENXIO; 835a374e892STony Krowiak break; 836a374e892STony Krowiak } 837a374e892STony Krowiak break; 838f2061656SDominik Dingel default: 839f2061656SDominik Dingel ret = -ENXIO; 840f2061656SDominik Dingel break; 841f2061656SDominik Dingel } 842f2061656SDominik Dingel 843f2061656SDominik Dingel return ret; 844f2061656SDominik Dingel } 845f2061656SDominik Dingel 84630ee2a98SJason J. Herne static long kvm_s390_get_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 84730ee2a98SJason J. Herne { 84830ee2a98SJason J. Herne uint8_t *keys; 84930ee2a98SJason J. Herne uint64_t hva; 85030ee2a98SJason J. Herne unsigned long curkey; 85130ee2a98SJason J. Herne int i, r = 0; 85230ee2a98SJason J. Herne 85330ee2a98SJason J. Herne if (args->flags != 0) 85430ee2a98SJason J. Herne return -EINVAL; 85530ee2a98SJason J. Herne 85630ee2a98SJason J. Herne /* Is this guest using storage keys? */ 85730ee2a98SJason J. Herne if (!mm_use_skey(current->mm)) 85830ee2a98SJason J. Herne return KVM_S390_GET_SKEYS_NONE; 85930ee2a98SJason J. Herne 86030ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 86130ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 86230ee2a98SJason J. Herne return -EINVAL; 86330ee2a98SJason J. Herne 86430ee2a98SJason J. Herne keys = kmalloc_array(args->count, sizeof(uint8_t), 86530ee2a98SJason J. Herne GFP_KERNEL | __GFP_NOWARN); 86630ee2a98SJason J. Herne if (!keys) 86730ee2a98SJason J. Herne keys = vmalloc(sizeof(uint8_t) * args->count); 86830ee2a98SJason J. Herne if (!keys) 86930ee2a98SJason J. Herne return -ENOMEM; 87030ee2a98SJason J. Herne 87130ee2a98SJason J. Herne for (i = 0; i < args->count; i++) { 87230ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 87330ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 87430ee2a98SJason J. Herne r = -EFAULT; 87530ee2a98SJason J. Herne goto out; 87630ee2a98SJason J. Herne } 87730ee2a98SJason J. Herne 87830ee2a98SJason J. Herne curkey = get_guest_storage_key(current->mm, hva); 87930ee2a98SJason J. Herne if (IS_ERR_VALUE(curkey)) { 88030ee2a98SJason J. Herne r = curkey; 88130ee2a98SJason J. Herne goto out; 88230ee2a98SJason J. Herne } 88330ee2a98SJason J. Herne keys[i] = curkey; 88430ee2a98SJason J. Herne } 88530ee2a98SJason J. Herne 88630ee2a98SJason J. Herne r = copy_to_user((uint8_t __user *)args->skeydata_addr, keys, 88730ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 88830ee2a98SJason J. Herne if (r) 88930ee2a98SJason J. Herne r = -EFAULT; 89030ee2a98SJason J. Herne out: 89130ee2a98SJason J. Herne kvfree(keys); 89230ee2a98SJason J. Herne return r; 89330ee2a98SJason J. Herne } 89430ee2a98SJason J. Herne 89530ee2a98SJason J. Herne static long kvm_s390_set_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 89630ee2a98SJason J. Herne { 89730ee2a98SJason J. Herne uint8_t *keys; 89830ee2a98SJason J. Herne uint64_t hva; 89930ee2a98SJason J. Herne int i, r = 0; 90030ee2a98SJason J. Herne 90130ee2a98SJason J. Herne if (args->flags != 0) 90230ee2a98SJason J. Herne return -EINVAL; 90330ee2a98SJason J. Herne 90430ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 90530ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 90630ee2a98SJason J. Herne return -EINVAL; 90730ee2a98SJason J. Herne 90830ee2a98SJason J. Herne keys = kmalloc_array(args->count, sizeof(uint8_t), 90930ee2a98SJason J. Herne GFP_KERNEL | __GFP_NOWARN); 91030ee2a98SJason J. Herne if (!keys) 91130ee2a98SJason J. Herne keys = vmalloc(sizeof(uint8_t) * args->count); 91230ee2a98SJason J. Herne if (!keys) 91330ee2a98SJason J. Herne return -ENOMEM; 91430ee2a98SJason J. Herne 91530ee2a98SJason J. Herne r = copy_from_user(keys, (uint8_t __user *)args->skeydata_addr, 91630ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 91730ee2a98SJason J. Herne if (r) { 91830ee2a98SJason J. Herne r = -EFAULT; 91930ee2a98SJason J. Herne goto out; 92030ee2a98SJason J. Herne } 92130ee2a98SJason J. Herne 92230ee2a98SJason J. Herne /* Enable storage key handling for the guest */ 92314d4a425SDominik Dingel r = s390_enable_skey(); 92414d4a425SDominik Dingel if (r) 92514d4a425SDominik Dingel goto out; 92630ee2a98SJason J. Herne 92730ee2a98SJason J. Herne for (i = 0; i < args->count; i++) { 92830ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 92930ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 93030ee2a98SJason J. Herne r = -EFAULT; 93130ee2a98SJason J. Herne goto out; 93230ee2a98SJason J. Herne } 93330ee2a98SJason J. Herne 93430ee2a98SJason J. Herne /* Lowest order bit is reserved */ 93530ee2a98SJason J. Herne if (keys[i] & 0x01) { 93630ee2a98SJason J. Herne r = -EINVAL; 93730ee2a98SJason J. Herne goto out; 93830ee2a98SJason J. Herne } 93930ee2a98SJason J. Herne 94030ee2a98SJason J. Herne r = set_guest_storage_key(current->mm, hva, 94130ee2a98SJason J. Herne (unsigned long)keys[i], 0); 94230ee2a98SJason J. Herne if (r) 94330ee2a98SJason J. Herne goto out; 94430ee2a98SJason J. Herne } 94530ee2a98SJason J. Herne out: 94630ee2a98SJason J. Herne kvfree(keys); 94730ee2a98SJason J. Herne return r; 94830ee2a98SJason J. Herne } 94930ee2a98SJason J. Herne 950b0c632dbSHeiko Carstens long kvm_arch_vm_ioctl(struct file *filp, 951b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 952b0c632dbSHeiko Carstens { 953b0c632dbSHeiko Carstens struct kvm *kvm = filp->private_data; 954b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 955f2061656SDominik Dingel struct kvm_device_attr attr; 956b0c632dbSHeiko Carstens int r; 957b0c632dbSHeiko Carstens 958b0c632dbSHeiko Carstens switch (ioctl) { 959ba5c1e9bSCarsten Otte case KVM_S390_INTERRUPT: { 960ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 961ba5c1e9bSCarsten Otte 962ba5c1e9bSCarsten Otte r = -EFAULT; 963ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 964ba5c1e9bSCarsten Otte break; 965ba5c1e9bSCarsten Otte r = kvm_s390_inject_vm(kvm, &s390int); 966ba5c1e9bSCarsten Otte break; 967ba5c1e9bSCarsten Otte } 968d938dc55SCornelia Huck case KVM_ENABLE_CAP: { 969d938dc55SCornelia Huck struct kvm_enable_cap cap; 970d938dc55SCornelia Huck r = -EFAULT; 971d938dc55SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 972d938dc55SCornelia Huck break; 973d938dc55SCornelia Huck r = kvm_vm_ioctl_enable_cap(kvm, &cap); 974d938dc55SCornelia Huck break; 975d938dc55SCornelia Huck } 97684223598SCornelia Huck case KVM_CREATE_IRQCHIP: { 97784223598SCornelia Huck struct kvm_irq_routing_entry routing; 97884223598SCornelia Huck 97984223598SCornelia Huck r = -EINVAL; 98084223598SCornelia Huck if (kvm->arch.use_irqchip) { 98184223598SCornelia Huck /* Set up dummy routing. */ 98284223598SCornelia Huck memset(&routing, 0, sizeof(routing)); 983152b2839SNicholas Krause r = kvm_set_irq_routing(kvm, &routing, 0, 0); 98484223598SCornelia Huck } 98584223598SCornelia Huck break; 98684223598SCornelia Huck } 987f2061656SDominik Dingel case KVM_SET_DEVICE_ATTR: { 988f2061656SDominik Dingel r = -EFAULT; 989f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 990f2061656SDominik Dingel break; 991f2061656SDominik Dingel r = kvm_s390_vm_set_attr(kvm, &attr); 992f2061656SDominik Dingel break; 993f2061656SDominik Dingel } 994f2061656SDominik Dingel case KVM_GET_DEVICE_ATTR: { 995f2061656SDominik Dingel r = -EFAULT; 996f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 997f2061656SDominik Dingel break; 998f2061656SDominik Dingel r = kvm_s390_vm_get_attr(kvm, &attr); 999f2061656SDominik Dingel break; 1000f2061656SDominik Dingel } 1001f2061656SDominik Dingel case KVM_HAS_DEVICE_ATTR: { 1002f2061656SDominik Dingel r = -EFAULT; 1003f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 1004f2061656SDominik Dingel break; 1005f2061656SDominik Dingel r = kvm_s390_vm_has_attr(kvm, &attr); 1006f2061656SDominik Dingel break; 1007f2061656SDominik Dingel } 100830ee2a98SJason J. Herne case KVM_S390_GET_SKEYS: { 100930ee2a98SJason J. Herne struct kvm_s390_skeys args; 101030ee2a98SJason J. Herne 101130ee2a98SJason J. Herne r = -EFAULT; 101230ee2a98SJason J. Herne if (copy_from_user(&args, argp, 101330ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 101430ee2a98SJason J. Herne break; 101530ee2a98SJason J. Herne r = kvm_s390_get_skeys(kvm, &args); 101630ee2a98SJason J. Herne break; 101730ee2a98SJason J. Herne } 101830ee2a98SJason J. Herne case KVM_S390_SET_SKEYS: { 101930ee2a98SJason J. Herne struct kvm_s390_skeys args; 102030ee2a98SJason J. Herne 102130ee2a98SJason J. Herne r = -EFAULT; 102230ee2a98SJason J. Herne if (copy_from_user(&args, argp, 102330ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 102430ee2a98SJason J. Herne break; 102530ee2a98SJason J. Herne r = kvm_s390_set_skeys(kvm, &args); 102630ee2a98SJason J. Herne break; 102730ee2a98SJason J. Herne } 1028b0c632dbSHeiko Carstens default: 1029367e1319SAvi Kivity r = -ENOTTY; 1030b0c632dbSHeiko Carstens } 1031b0c632dbSHeiko Carstens 1032b0c632dbSHeiko Carstens return r; 1033b0c632dbSHeiko Carstens } 1034b0c632dbSHeiko Carstens 103545c9b47cSTony Krowiak static int kvm_s390_query_ap_config(u8 *config) 103645c9b47cSTony Krowiak { 103745c9b47cSTony Krowiak u32 fcn_code = 0x04000000UL; 103886044c8cSChristian Borntraeger u32 cc = 0; 103945c9b47cSTony Krowiak 104086044c8cSChristian Borntraeger memset(config, 0, 128); 104145c9b47cSTony Krowiak asm volatile( 104245c9b47cSTony Krowiak "lgr 0,%1\n" 104345c9b47cSTony Krowiak "lgr 2,%2\n" 104445c9b47cSTony Krowiak ".long 0xb2af0000\n" /* PQAP(QCI) */ 104586044c8cSChristian Borntraeger "0: ipm %0\n" 104645c9b47cSTony Krowiak "srl %0,28\n" 104786044c8cSChristian Borntraeger "1:\n" 104886044c8cSChristian Borntraeger EX_TABLE(0b, 1b) 104986044c8cSChristian Borntraeger : "+r" (cc) 105045c9b47cSTony Krowiak : "r" (fcn_code), "r" (config) 105145c9b47cSTony Krowiak : "cc", "0", "2", "memory" 105245c9b47cSTony Krowiak ); 105345c9b47cSTony Krowiak 105445c9b47cSTony Krowiak return cc; 105545c9b47cSTony Krowiak } 105645c9b47cSTony Krowiak 105745c9b47cSTony Krowiak static int kvm_s390_apxa_installed(void) 105845c9b47cSTony Krowiak { 105945c9b47cSTony Krowiak u8 config[128]; 106045c9b47cSTony Krowiak int cc; 106145c9b47cSTony Krowiak 1062a6aacc3fSHeiko Carstens if (test_facility(12)) { 106345c9b47cSTony Krowiak cc = kvm_s390_query_ap_config(config); 106445c9b47cSTony Krowiak 106545c9b47cSTony Krowiak if (cc) 106645c9b47cSTony Krowiak pr_err("PQAP(QCI) failed with cc=%d", cc); 106745c9b47cSTony Krowiak else 106845c9b47cSTony Krowiak return config[0] & 0x40; 106945c9b47cSTony Krowiak } 107045c9b47cSTony Krowiak 107145c9b47cSTony Krowiak return 0; 107245c9b47cSTony Krowiak } 107345c9b47cSTony Krowiak 107445c9b47cSTony Krowiak static void kvm_s390_set_crycb_format(struct kvm *kvm) 107545c9b47cSTony Krowiak { 107645c9b47cSTony Krowiak kvm->arch.crypto.crycbd = (__u32)(unsigned long) kvm->arch.crypto.crycb; 107745c9b47cSTony Krowiak 107845c9b47cSTony Krowiak if (kvm_s390_apxa_installed()) 107945c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT2; 108045c9b47cSTony Krowiak else 108145c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT1; 108245c9b47cSTony Krowiak } 108345c9b47cSTony Krowiak 10849d8d5786SMichael Mueller static void kvm_s390_get_cpu_id(struct cpuid *cpu_id) 10859d8d5786SMichael Mueller { 10869d8d5786SMichael Mueller get_cpu_id(cpu_id); 10879d8d5786SMichael Mueller cpu_id->version = 0xff; 10889d8d5786SMichael Mueller } 10899d8d5786SMichael Mueller 1090c54f0d6aSDavid Hildenbrand static void kvm_s390_crypto_init(struct kvm *kvm) 10915102ee87STony Krowiak { 10929d8d5786SMichael Mueller if (!test_kvm_facility(kvm, 76)) 1093c54f0d6aSDavid Hildenbrand return; 10945102ee87STony Krowiak 1095c54f0d6aSDavid Hildenbrand kvm->arch.crypto.crycb = &kvm->arch.sie_page2->crycb; 109645c9b47cSTony Krowiak kvm_s390_set_crycb_format(kvm); 10975102ee87STony Krowiak 1098ed6f76b4STony Krowiak /* Enable AES/DEA protected key functions by default */ 1099ed6f76b4STony Krowiak kvm->arch.crypto.aes_kw = 1; 1100ed6f76b4STony Krowiak kvm->arch.crypto.dea_kw = 1; 1101ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 1102ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 1103ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 1104ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 11055102ee87STony Krowiak } 11065102ee87STony Krowiak 11077d43bafcSEugene (jno) Dvurechenski static void sca_dispose(struct kvm *kvm) 11087d43bafcSEugene (jno) Dvurechenski { 11097d43bafcSEugene (jno) Dvurechenski if (kvm->arch.use_esca) 11105e044315SEugene (jno) Dvurechenski free_pages_exact(kvm->arch.sca, sizeof(struct esca_block)); 11117d43bafcSEugene (jno) Dvurechenski else 11127d43bafcSEugene (jno) Dvurechenski free_page((unsigned long)(kvm->arch.sca)); 11137d43bafcSEugene (jno) Dvurechenski kvm->arch.sca = NULL; 11147d43bafcSEugene (jno) Dvurechenski } 11157d43bafcSEugene (jno) Dvurechenski 1116e08b9637SCarsten Otte int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 1117b0c632dbSHeiko Carstens { 11189d8d5786SMichael Mueller int i, rc; 1119b0c632dbSHeiko Carstens char debug_name[16]; 1120f6c137ffSChristian Borntraeger static unsigned long sca_offset; 1121b0c632dbSHeiko Carstens 1122e08b9637SCarsten Otte rc = -EINVAL; 1123e08b9637SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 1124e08b9637SCarsten Otte if (type & ~KVM_VM_S390_UCONTROL) 1125e08b9637SCarsten Otte goto out_err; 1126e08b9637SCarsten Otte if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN))) 1127e08b9637SCarsten Otte goto out_err; 1128e08b9637SCarsten Otte #else 1129e08b9637SCarsten Otte if (type) 1130e08b9637SCarsten Otte goto out_err; 1131e08b9637SCarsten Otte #endif 1132e08b9637SCarsten Otte 1133b0c632dbSHeiko Carstens rc = s390_enable_sie(); 1134b0c632dbSHeiko Carstens if (rc) 1135d89f5effSJan Kiszka goto out_err; 1136b0c632dbSHeiko Carstens 1137b290411aSCarsten Otte rc = -ENOMEM; 1138b290411aSCarsten Otte 11397d43bafcSEugene (jno) Dvurechenski kvm->arch.use_esca = 0; /* start with basic SCA */ 11405e044315SEugene (jno) Dvurechenski rwlock_init(&kvm->arch.sca_lock); 1141bc784cceSEugene (jno) Dvurechenski kvm->arch.sca = (struct bsca_block *) get_zeroed_page(GFP_KERNEL); 1142b0c632dbSHeiko Carstens if (!kvm->arch.sca) 1143d89f5effSJan Kiszka goto out_err; 1144f6c137ffSChristian Borntraeger spin_lock(&kvm_lock); 1145c5c2c393SDavid Hildenbrand sca_offset += 16; 1146bc784cceSEugene (jno) Dvurechenski if (sca_offset + sizeof(struct bsca_block) > PAGE_SIZE) 1147c5c2c393SDavid Hildenbrand sca_offset = 0; 1148bc784cceSEugene (jno) Dvurechenski kvm->arch.sca = (struct bsca_block *) 1149bc784cceSEugene (jno) Dvurechenski ((char *) kvm->arch.sca + sca_offset); 1150f6c137ffSChristian Borntraeger spin_unlock(&kvm_lock); 1151b0c632dbSHeiko Carstens 1152b0c632dbSHeiko Carstens sprintf(debug_name, "kvm-%u", current->pid); 1153b0c632dbSHeiko Carstens 11541cb9cf72SChristian Borntraeger kvm->arch.dbf = debug_register(debug_name, 32, 1, 7 * sizeof(long)); 1155b0c632dbSHeiko Carstens if (!kvm->arch.dbf) 115640f5b735SDominik Dingel goto out_err; 1157b0c632dbSHeiko Carstens 1158c54f0d6aSDavid Hildenbrand kvm->arch.sie_page2 = 1159c54f0d6aSDavid Hildenbrand (struct sie_page2 *) get_zeroed_page(GFP_KERNEL | GFP_DMA); 1160c54f0d6aSDavid Hildenbrand if (!kvm->arch.sie_page2) 116140f5b735SDominik Dingel goto out_err; 11629d8d5786SMichael Mueller 1163fb5bf93fSMichael Mueller /* Populate the facility mask initially. */ 1164c54f0d6aSDavid Hildenbrand memcpy(kvm->arch.model.fac_mask, S390_lowcore.stfle_fac_list, 116594422ee8SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 11669d8d5786SMichael Mueller for (i = 0; i < S390_ARCH_FAC_LIST_SIZE_U64; i++) { 11679d8d5786SMichael Mueller if (i < kvm_s390_fac_list_mask_size()) 1168c54f0d6aSDavid Hildenbrand kvm->arch.model.fac_mask[i] &= kvm_s390_fac_list_mask[i]; 11699d8d5786SMichael Mueller else 1170c54f0d6aSDavid Hildenbrand kvm->arch.model.fac_mask[i] = 0UL; 11719d8d5786SMichael Mueller } 11729d8d5786SMichael Mueller 1173981467c9SMichael Mueller /* Populate the facility list initially. */ 1174c54f0d6aSDavid Hildenbrand kvm->arch.model.fac_list = kvm->arch.sie_page2->fac_list; 1175c54f0d6aSDavid Hildenbrand memcpy(kvm->arch.model.fac_list, kvm->arch.model.fac_mask, 1176981467c9SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 1177981467c9SMichael Mueller 11789d8d5786SMichael Mueller kvm_s390_get_cpu_id(&kvm->arch.model.cpu_id); 117937c5f6c8SDavid Hildenbrand kvm->arch.model.ibc = sclp.ibc & 0x0fff; 11809d8d5786SMichael Mueller 1181c54f0d6aSDavid Hildenbrand kvm_s390_crypto_init(kvm); 11825102ee87STony Krowiak 1183ba5c1e9bSCarsten Otte spin_lock_init(&kvm->arch.float_int.lock); 11846d3da241SJens Freimann for (i = 0; i < FIRQ_LIST_COUNT; i++) 11856d3da241SJens Freimann INIT_LIST_HEAD(&kvm->arch.float_int.lists[i]); 11868a242234SHeiko Carstens init_waitqueue_head(&kvm->arch.ipte_wq); 1187a6b7e459SThomas Huth mutex_init(&kvm->arch.ipte_mutex); 1188ba5c1e9bSCarsten Otte 1189b0c632dbSHeiko Carstens debug_register_view(kvm->arch.dbf, &debug_sprintf_view); 119078f26131SChristian Borntraeger VM_EVENT(kvm, 3, "vm created with type %lu", type); 1191b0c632dbSHeiko Carstens 1192e08b9637SCarsten Otte if (type & KVM_VM_S390_UCONTROL) { 1193e08b9637SCarsten Otte kvm->arch.gmap = NULL; 1194a3a92c31SDominik Dingel kvm->arch.mem_limit = KVM_S390_NO_MEM_LIMIT; 1195e08b9637SCarsten Otte } else { 119632e6b236SGuenther Hutzl if (sclp.hamax == U64_MAX) 1197a3a92c31SDominik Dingel kvm->arch.mem_limit = TASK_MAX_SIZE; 119832e6b236SGuenther Hutzl else 119932e6b236SGuenther Hutzl kvm->arch.mem_limit = min_t(unsigned long, TASK_MAX_SIZE, 120032e6b236SGuenther Hutzl sclp.hamax + 1); 1201a3a92c31SDominik Dingel kvm->arch.gmap = gmap_alloc(current->mm, kvm->arch.mem_limit - 1); 1202598841caSCarsten Otte if (!kvm->arch.gmap) 120340f5b735SDominik Dingel goto out_err; 12042c70fe44SChristian Borntraeger kvm->arch.gmap->private = kvm; 120524eb3a82SDominik Dingel kvm->arch.gmap->pfault_enabled = 0; 1206e08b9637SCarsten Otte } 1207fa6b7fe9SCornelia Huck 1208fa6b7fe9SCornelia Huck kvm->arch.css_support = 0; 120984223598SCornelia Huck kvm->arch.use_irqchip = 0; 121072f25020SJason J. Herne kvm->arch.epoch = 0; 1211fa6b7fe9SCornelia Huck 12128ad35755SDavid Hildenbrand spin_lock_init(&kvm->arch.start_stop_lock); 12138335713aSChristian Borntraeger KVM_EVENT(3, "vm 0x%pK created by pid %u", kvm, current->pid); 12148ad35755SDavid Hildenbrand 1215d89f5effSJan Kiszka return 0; 1216d89f5effSJan Kiszka out_err: 1217c54f0d6aSDavid Hildenbrand free_page((unsigned long)kvm->arch.sie_page2); 121840f5b735SDominik Dingel debug_unregister(kvm->arch.dbf); 12197d43bafcSEugene (jno) Dvurechenski sca_dispose(kvm); 122078f26131SChristian Borntraeger KVM_EVENT(3, "creation of vm failed: %d", rc); 1221d89f5effSJan Kiszka return rc; 1222b0c632dbSHeiko Carstens } 1223b0c632dbSHeiko Carstens 1224d329c035SChristian Borntraeger void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 1225d329c035SChristian Borntraeger { 1226d329c035SChristian Borntraeger VCPU_EVENT(vcpu, 3, "%s", "free cpu"); 1227ade38c31SCornelia Huck trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id); 122867335e63SChristian Borntraeger kvm_s390_clear_local_irqs(vcpu); 12293c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 1230bc784cceSEugene (jno) Dvurechenski if (!kvm_is_ucontrol(vcpu->kvm)) 1231a6e2f683SEugene (jno) Dvurechenski sca_del_vcpu(vcpu); 123227e0393fSCarsten Otte 123327e0393fSCarsten Otte if (kvm_is_ucontrol(vcpu->kvm)) 123427e0393fSCarsten Otte gmap_free(vcpu->arch.gmap); 123527e0393fSCarsten Otte 1236e6db1d61SDominik Dingel if (vcpu->kvm->arch.use_cmma) 1237b31605c1SDominik Dingel kvm_s390_vcpu_unsetup_cmma(vcpu); 1238d329c035SChristian Borntraeger free_page((unsigned long)(vcpu->arch.sie_block)); 1239b31288faSKonstantin Weitz 12406692cef3SChristian Borntraeger kvm_vcpu_uninit(vcpu); 1241b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 1242d329c035SChristian Borntraeger } 1243d329c035SChristian Borntraeger 1244d329c035SChristian Borntraeger static void kvm_free_vcpus(struct kvm *kvm) 1245d329c035SChristian Borntraeger { 1246d329c035SChristian Borntraeger unsigned int i; 1247988a2caeSGleb Natapov struct kvm_vcpu *vcpu; 1248d329c035SChristian Borntraeger 1249988a2caeSGleb Natapov kvm_for_each_vcpu(i, vcpu, kvm) 1250988a2caeSGleb Natapov kvm_arch_vcpu_destroy(vcpu); 1251988a2caeSGleb Natapov 1252988a2caeSGleb Natapov mutex_lock(&kvm->lock); 1253988a2caeSGleb Natapov for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 1254d329c035SChristian Borntraeger kvm->vcpus[i] = NULL; 1255988a2caeSGleb Natapov 1256988a2caeSGleb Natapov atomic_set(&kvm->online_vcpus, 0); 1257988a2caeSGleb Natapov mutex_unlock(&kvm->lock); 1258d329c035SChristian Borntraeger } 1259d329c035SChristian Borntraeger 1260b0c632dbSHeiko Carstens void kvm_arch_destroy_vm(struct kvm *kvm) 1261b0c632dbSHeiko Carstens { 1262d329c035SChristian Borntraeger kvm_free_vcpus(kvm); 12637d43bafcSEugene (jno) Dvurechenski sca_dispose(kvm); 1264d329c035SChristian Borntraeger debug_unregister(kvm->arch.dbf); 1265c54f0d6aSDavid Hildenbrand free_page((unsigned long)kvm->arch.sie_page2); 126627e0393fSCarsten Otte if (!kvm_is_ucontrol(kvm)) 1267598841caSCarsten Otte gmap_free(kvm->arch.gmap); 1268841b91c5SCornelia Huck kvm_s390_destroy_adapters(kvm); 126967335e63SChristian Borntraeger kvm_s390_clear_float_irqs(kvm); 12708335713aSChristian Borntraeger KVM_EVENT(3, "vm 0x%pK destroyed", kvm); 1271b0c632dbSHeiko Carstens } 1272b0c632dbSHeiko Carstens 1273b0c632dbSHeiko Carstens /* Section: vcpu related */ 1274dafd032aSDominik Dingel static int __kvm_ucontrol_vcpu_init(struct kvm_vcpu *vcpu) 1275b0c632dbSHeiko Carstens { 1276c6c956b8SMartin Schwidefsky vcpu->arch.gmap = gmap_alloc(current->mm, -1UL); 127727e0393fSCarsten Otte if (!vcpu->arch.gmap) 127827e0393fSCarsten Otte return -ENOMEM; 12792c70fe44SChristian Borntraeger vcpu->arch.gmap->private = vcpu->kvm; 1280dafd032aSDominik Dingel 128127e0393fSCarsten Otte return 0; 128227e0393fSCarsten Otte } 128327e0393fSCarsten Otte 1284a6e2f683SEugene (jno) Dvurechenski static void sca_del_vcpu(struct kvm_vcpu *vcpu) 1285a6e2f683SEugene (jno) Dvurechenski { 12865e044315SEugene (jno) Dvurechenski read_lock(&vcpu->kvm->arch.sca_lock); 12877d43bafcSEugene (jno) Dvurechenski if (vcpu->kvm->arch.use_esca) { 12887d43bafcSEugene (jno) Dvurechenski struct esca_block *sca = vcpu->kvm->arch.sca; 12897d43bafcSEugene (jno) Dvurechenski 12907d43bafcSEugene (jno) Dvurechenski clear_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn); 12917d43bafcSEugene (jno) Dvurechenski sca->cpu[vcpu->vcpu_id].sda = 0; 12927d43bafcSEugene (jno) Dvurechenski } else { 1293bc784cceSEugene (jno) Dvurechenski struct bsca_block *sca = vcpu->kvm->arch.sca; 1294a6e2f683SEugene (jno) Dvurechenski 1295a6e2f683SEugene (jno) Dvurechenski clear_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn); 1296a6e2f683SEugene (jno) Dvurechenski sca->cpu[vcpu->vcpu_id].sda = 0; 1297a6e2f683SEugene (jno) Dvurechenski } 12985e044315SEugene (jno) Dvurechenski read_unlock(&vcpu->kvm->arch.sca_lock); 12997d43bafcSEugene (jno) Dvurechenski } 1300a6e2f683SEugene (jno) Dvurechenski 1301eaa78f34SDavid Hildenbrand static void sca_add_vcpu(struct kvm_vcpu *vcpu) 1302a6e2f683SEugene (jno) Dvurechenski { 1303eaa78f34SDavid Hildenbrand read_lock(&vcpu->kvm->arch.sca_lock); 1304eaa78f34SDavid Hildenbrand if (vcpu->kvm->arch.use_esca) { 1305eaa78f34SDavid Hildenbrand struct esca_block *sca = vcpu->kvm->arch.sca; 13067d43bafcSEugene (jno) Dvurechenski 1307eaa78f34SDavid Hildenbrand sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block; 13087d43bafcSEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 13097d43bafcSEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = (__u32)(__u64)sca & ~0x3fU; 131025508824SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= 0x04U; 1311eaa78f34SDavid Hildenbrand set_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn); 13127d43bafcSEugene (jno) Dvurechenski } else { 1313eaa78f34SDavid Hildenbrand struct bsca_block *sca = vcpu->kvm->arch.sca; 1314a6e2f683SEugene (jno) Dvurechenski 1315eaa78f34SDavid Hildenbrand sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block; 1316a6e2f683SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 1317a6e2f683SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = (__u32)(__u64)sca; 1318eaa78f34SDavid Hildenbrand set_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn); 1319a6e2f683SEugene (jno) Dvurechenski } 1320eaa78f34SDavid Hildenbrand read_unlock(&vcpu->kvm->arch.sca_lock); 13215e044315SEugene (jno) Dvurechenski } 13225e044315SEugene (jno) Dvurechenski 13235e044315SEugene (jno) Dvurechenski /* Basic SCA to Extended SCA data copy routines */ 13245e044315SEugene (jno) Dvurechenski static inline void sca_copy_entry(struct esca_entry *d, struct bsca_entry *s) 13255e044315SEugene (jno) Dvurechenski { 13265e044315SEugene (jno) Dvurechenski d->sda = s->sda; 13275e044315SEugene (jno) Dvurechenski d->sigp_ctrl.c = s->sigp_ctrl.c; 13285e044315SEugene (jno) Dvurechenski d->sigp_ctrl.scn = s->sigp_ctrl.scn; 13295e044315SEugene (jno) Dvurechenski } 13305e044315SEugene (jno) Dvurechenski 13315e044315SEugene (jno) Dvurechenski static void sca_copy_b_to_e(struct esca_block *d, struct bsca_block *s) 13325e044315SEugene (jno) Dvurechenski { 13335e044315SEugene (jno) Dvurechenski int i; 13345e044315SEugene (jno) Dvurechenski 13355e044315SEugene (jno) Dvurechenski d->ipte_control = s->ipte_control; 13365e044315SEugene (jno) Dvurechenski d->mcn[0] = s->mcn; 13375e044315SEugene (jno) Dvurechenski for (i = 0; i < KVM_S390_BSCA_CPU_SLOTS; i++) 13385e044315SEugene (jno) Dvurechenski sca_copy_entry(&d->cpu[i], &s->cpu[i]); 13395e044315SEugene (jno) Dvurechenski } 13405e044315SEugene (jno) Dvurechenski 13415e044315SEugene (jno) Dvurechenski static int sca_switch_to_extended(struct kvm *kvm) 13425e044315SEugene (jno) Dvurechenski { 13435e044315SEugene (jno) Dvurechenski struct bsca_block *old_sca = kvm->arch.sca; 13445e044315SEugene (jno) Dvurechenski struct esca_block *new_sca; 13455e044315SEugene (jno) Dvurechenski struct kvm_vcpu *vcpu; 13465e044315SEugene (jno) Dvurechenski unsigned int vcpu_idx; 13475e044315SEugene (jno) Dvurechenski u32 scaol, scaoh; 13485e044315SEugene (jno) Dvurechenski 13495e044315SEugene (jno) Dvurechenski new_sca = alloc_pages_exact(sizeof(*new_sca), GFP_KERNEL|__GFP_ZERO); 13505e044315SEugene (jno) Dvurechenski if (!new_sca) 13515e044315SEugene (jno) Dvurechenski return -ENOMEM; 13525e044315SEugene (jno) Dvurechenski 13535e044315SEugene (jno) Dvurechenski scaoh = (u32)((u64)(new_sca) >> 32); 13545e044315SEugene (jno) Dvurechenski scaol = (u32)(u64)(new_sca) & ~0x3fU; 13555e044315SEugene (jno) Dvurechenski 13565e044315SEugene (jno) Dvurechenski kvm_s390_vcpu_block_all(kvm); 13575e044315SEugene (jno) Dvurechenski write_lock(&kvm->arch.sca_lock); 13585e044315SEugene (jno) Dvurechenski 13595e044315SEugene (jno) Dvurechenski sca_copy_b_to_e(new_sca, old_sca); 13605e044315SEugene (jno) Dvurechenski 13615e044315SEugene (jno) Dvurechenski kvm_for_each_vcpu(vcpu_idx, vcpu, kvm) { 13625e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = scaoh; 13635e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = scaol; 13645e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->ecb2 |= 0x04U; 13655e044315SEugene (jno) Dvurechenski } 13665e044315SEugene (jno) Dvurechenski kvm->arch.sca = new_sca; 13675e044315SEugene (jno) Dvurechenski kvm->arch.use_esca = 1; 13685e044315SEugene (jno) Dvurechenski 13695e044315SEugene (jno) Dvurechenski write_unlock(&kvm->arch.sca_lock); 13705e044315SEugene (jno) Dvurechenski kvm_s390_vcpu_unblock_all(kvm); 13715e044315SEugene (jno) Dvurechenski 13725e044315SEugene (jno) Dvurechenski free_page((unsigned long)old_sca); 13735e044315SEugene (jno) Dvurechenski 13748335713aSChristian Borntraeger VM_EVENT(kvm, 2, "Switched to ESCA (0x%pK -> 0x%pK)", 13758335713aSChristian Borntraeger old_sca, kvm->arch.sca); 13765e044315SEugene (jno) Dvurechenski return 0; 13777d43bafcSEugene (jno) Dvurechenski } 1378a6e2f683SEugene (jno) Dvurechenski 1379a6e2f683SEugene (jno) Dvurechenski static int sca_can_add_vcpu(struct kvm *kvm, unsigned int id) 1380a6e2f683SEugene (jno) Dvurechenski { 13815e044315SEugene (jno) Dvurechenski int rc; 13825e044315SEugene (jno) Dvurechenski 13835e044315SEugene (jno) Dvurechenski if (id < KVM_S390_BSCA_CPU_SLOTS) 13845e044315SEugene (jno) Dvurechenski return true; 13855e044315SEugene (jno) Dvurechenski if (!sclp.has_esca) 13865e044315SEugene (jno) Dvurechenski return false; 13875e044315SEugene (jno) Dvurechenski 13885e044315SEugene (jno) Dvurechenski mutex_lock(&kvm->lock); 13895e044315SEugene (jno) Dvurechenski rc = kvm->arch.use_esca ? 0 : sca_switch_to_extended(kvm); 13905e044315SEugene (jno) Dvurechenski mutex_unlock(&kvm->lock); 13915e044315SEugene (jno) Dvurechenski 13925e044315SEugene (jno) Dvurechenski return rc == 0 && id < KVM_S390_ESCA_CPU_SLOTS; 1393a6e2f683SEugene (jno) Dvurechenski } 1394a6e2f683SEugene (jno) Dvurechenski 1395dafd032aSDominik Dingel int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 1396dafd032aSDominik Dingel { 1397dafd032aSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 1398dafd032aSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 139959674c1aSChristian Borntraeger vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX | 140059674c1aSChristian Borntraeger KVM_SYNC_GPRS | 14019eed0735SChristian Borntraeger KVM_SYNC_ACRS | 1402b028ee3eSDavid Hildenbrand KVM_SYNC_CRS | 1403b028ee3eSDavid Hildenbrand KVM_SYNC_ARCH0 | 1404b028ee3eSDavid Hildenbrand KVM_SYNC_PFAULT; 1405c6e5f166SFan Zhang if (test_kvm_facility(vcpu->kvm, 64)) 1406c6e5f166SFan Zhang vcpu->run->kvm_valid_regs |= KVM_SYNC_RICCB; 1407f6aa6dc4SDavid Hildenbrand /* fprs can be synchronized via vrs, even if the guest has no vx. With 1408f6aa6dc4SDavid Hildenbrand * MACHINE_HAS_VX, (load|store)_fpu_regs() will work with vrs format. 1409f6aa6dc4SDavid Hildenbrand */ 1410f6aa6dc4SDavid Hildenbrand if (MACHINE_HAS_VX) 141168c55750SEric Farman vcpu->run->kvm_valid_regs |= KVM_SYNC_VRS; 14126fd8e67dSDavid Hildenbrand else 14136fd8e67dSDavid Hildenbrand vcpu->run->kvm_valid_regs |= KVM_SYNC_FPRS; 1414dafd032aSDominik Dingel 1415dafd032aSDominik Dingel if (kvm_is_ucontrol(vcpu->kvm)) 1416dafd032aSDominik Dingel return __kvm_ucontrol_vcpu_init(vcpu); 1417dafd032aSDominik Dingel 1418b0c632dbSHeiko Carstens return 0; 1419b0c632dbSHeiko Carstens } 1420b0c632dbSHeiko Carstens 1421db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 1422db0758b2SDavid Hildenbrand static void __start_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1423db0758b2SDavid Hildenbrand { 1424db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_start != 0); 14259c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 1426db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = get_tod_clock_fast(); 14279c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 1428db0758b2SDavid Hildenbrand } 1429db0758b2SDavid Hildenbrand 1430db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 1431db0758b2SDavid Hildenbrand static void __stop_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1432db0758b2SDavid Hildenbrand { 1433db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_start == 0); 14349c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 1435db0758b2SDavid Hildenbrand vcpu->arch.sie_block->cputm -= get_tod_clock_fast() - vcpu->arch.cputm_start; 1436db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = 0; 14379c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 1438db0758b2SDavid Hildenbrand } 1439db0758b2SDavid Hildenbrand 1440db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 1441db0758b2SDavid Hildenbrand static void __enable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1442db0758b2SDavid Hildenbrand { 1443db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_enabled); 1444db0758b2SDavid Hildenbrand vcpu->arch.cputm_enabled = true; 1445db0758b2SDavid Hildenbrand __start_cpu_timer_accounting(vcpu); 1446db0758b2SDavid Hildenbrand } 1447db0758b2SDavid Hildenbrand 1448db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 1449db0758b2SDavid Hildenbrand static void __disable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1450db0758b2SDavid Hildenbrand { 1451db0758b2SDavid Hildenbrand WARN_ON_ONCE(!vcpu->arch.cputm_enabled); 1452db0758b2SDavid Hildenbrand __stop_cpu_timer_accounting(vcpu); 1453db0758b2SDavid Hildenbrand vcpu->arch.cputm_enabled = false; 1454db0758b2SDavid Hildenbrand } 1455db0758b2SDavid Hildenbrand 1456db0758b2SDavid Hildenbrand static void enable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1457db0758b2SDavid Hildenbrand { 1458db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 1459db0758b2SDavid Hildenbrand __enable_cpu_timer_accounting(vcpu); 1460db0758b2SDavid Hildenbrand preempt_enable(); 1461db0758b2SDavid Hildenbrand } 1462db0758b2SDavid Hildenbrand 1463db0758b2SDavid Hildenbrand static void disable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1464db0758b2SDavid Hildenbrand { 1465db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 1466db0758b2SDavid Hildenbrand __disable_cpu_timer_accounting(vcpu); 1467db0758b2SDavid Hildenbrand preempt_enable(); 1468db0758b2SDavid Hildenbrand } 1469db0758b2SDavid Hildenbrand 14704287f247SDavid Hildenbrand /* set the cpu timer - may only be called from the VCPU thread itself */ 14714287f247SDavid Hildenbrand void kvm_s390_set_cpu_timer(struct kvm_vcpu *vcpu, __u64 cputm) 14724287f247SDavid Hildenbrand { 1473db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 14749c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 1475db0758b2SDavid Hildenbrand if (vcpu->arch.cputm_enabled) 1476db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = get_tod_clock_fast(); 14774287f247SDavid Hildenbrand vcpu->arch.sie_block->cputm = cputm; 14789c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 1479db0758b2SDavid Hildenbrand preempt_enable(); 14804287f247SDavid Hildenbrand } 14814287f247SDavid Hildenbrand 1482db0758b2SDavid Hildenbrand /* update and get the cpu timer - can also be called from other VCPU threads */ 14834287f247SDavid Hildenbrand __u64 kvm_s390_get_cpu_timer(struct kvm_vcpu *vcpu) 14844287f247SDavid Hildenbrand { 14859c23a131SDavid Hildenbrand unsigned int seq; 1486db0758b2SDavid Hildenbrand __u64 value; 1487db0758b2SDavid Hildenbrand 1488db0758b2SDavid Hildenbrand if (unlikely(!vcpu->arch.cputm_enabled)) 14894287f247SDavid Hildenbrand return vcpu->arch.sie_block->cputm; 1490db0758b2SDavid Hildenbrand 14919c23a131SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 14929c23a131SDavid Hildenbrand do { 14939c23a131SDavid Hildenbrand seq = raw_read_seqcount(&vcpu->arch.cputm_seqcount); 14949c23a131SDavid Hildenbrand /* 14959c23a131SDavid Hildenbrand * If the writer would ever execute a read in the critical 14969c23a131SDavid Hildenbrand * section, e.g. in irq context, we have a deadlock. 14979c23a131SDavid Hildenbrand */ 14989c23a131SDavid Hildenbrand WARN_ON_ONCE((seq & 1) && smp_processor_id() == vcpu->cpu); 1499db0758b2SDavid Hildenbrand value = vcpu->arch.sie_block->cputm; 15009c23a131SDavid Hildenbrand /* if cputm_start is 0, accounting is being started/stopped */ 15019c23a131SDavid Hildenbrand if (likely(vcpu->arch.cputm_start)) 1502db0758b2SDavid Hildenbrand value -= get_tod_clock_fast() - vcpu->arch.cputm_start; 15039c23a131SDavid Hildenbrand } while (read_seqcount_retry(&vcpu->arch.cputm_seqcount, seq & ~1)); 15049c23a131SDavid Hildenbrand preempt_enable(); 1505db0758b2SDavid Hildenbrand return value; 15064287f247SDavid Hildenbrand } 15074287f247SDavid Hildenbrand 1508b0c632dbSHeiko Carstens void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 1509b0c632dbSHeiko Carstens { 15109977e886SHendrik Brueckner /* Save host register state */ 1511d0164ee2SHendrik Brueckner save_fpu_regs(); 15129abc2a08SDavid Hildenbrand vcpu->arch.host_fpregs.fpc = current->thread.fpu.fpc; 15139abc2a08SDavid Hildenbrand vcpu->arch.host_fpregs.regs = current->thread.fpu.regs; 151496b2d7a8SHendrik Brueckner 15156fd8e67dSDavid Hildenbrand if (MACHINE_HAS_VX) 15169abc2a08SDavid Hildenbrand current->thread.fpu.regs = vcpu->run->s.regs.vrs; 15176fd8e67dSDavid Hildenbrand else 15186fd8e67dSDavid Hildenbrand current->thread.fpu.regs = vcpu->run->s.regs.fprs; 15199abc2a08SDavid Hildenbrand current->thread.fpu.fpc = vcpu->run->s.regs.fpc; 15209977e886SHendrik Brueckner if (test_fp_ctl(current->thread.fpu.fpc)) 152196b2d7a8SHendrik Brueckner /* User space provided an invalid FPC, let's clear it */ 15229977e886SHendrik Brueckner current->thread.fpu.fpc = 0; 15239977e886SHendrik Brueckner 15249977e886SHendrik Brueckner save_access_regs(vcpu->arch.host_acrs); 152559674c1aSChristian Borntraeger restore_access_regs(vcpu->run->s.regs.acrs); 1526480e5926SChristian Borntraeger gmap_enable(vcpu->arch.gmap); 1527805de8f4SPeter Zijlstra atomic_or(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 15285ebda316SDavid Hildenbrand if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu)) 1529db0758b2SDavid Hildenbrand __start_cpu_timer_accounting(vcpu); 153001a745acSDavid Hildenbrand vcpu->cpu = cpu; 1531b0c632dbSHeiko Carstens } 1532b0c632dbSHeiko Carstens 1533b0c632dbSHeiko Carstens void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 1534b0c632dbSHeiko Carstens { 153501a745acSDavid Hildenbrand vcpu->cpu = -1; 15365ebda316SDavid Hildenbrand if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu)) 1537db0758b2SDavid Hildenbrand __stop_cpu_timer_accounting(vcpu); 1538805de8f4SPeter Zijlstra atomic_andnot(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 1539480e5926SChristian Borntraeger gmap_disable(vcpu->arch.gmap); 15409977e886SHendrik Brueckner 15419abc2a08SDavid Hildenbrand /* Save guest register state */ 1542d0164ee2SHendrik Brueckner save_fpu_regs(); 15439977e886SHendrik Brueckner vcpu->run->s.regs.fpc = current->thread.fpu.fpc; 15449abc2a08SDavid Hildenbrand 15459abc2a08SDavid Hildenbrand /* Restore host register state */ 15469abc2a08SDavid Hildenbrand current->thread.fpu.fpc = vcpu->arch.host_fpregs.fpc; 15479abc2a08SDavid Hildenbrand current->thread.fpu.regs = vcpu->arch.host_fpregs.regs; 15489977e886SHendrik Brueckner 15499977e886SHendrik Brueckner save_access_regs(vcpu->run->s.regs.acrs); 1550b0c632dbSHeiko Carstens restore_access_regs(vcpu->arch.host_acrs); 1551b0c632dbSHeiko Carstens } 1552b0c632dbSHeiko Carstens 1553b0c632dbSHeiko Carstens static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu) 1554b0c632dbSHeiko Carstens { 1555b0c632dbSHeiko Carstens /* this equals initial cpu reset in pop, but we don't switch to ESA */ 1556b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.mask = 0UL; 1557b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.addr = 0UL; 15588d26cf7bSChristian Borntraeger kvm_s390_set_prefix(vcpu, 0); 15594287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, 0); 1560b0c632dbSHeiko Carstens vcpu->arch.sie_block->ckc = 0UL; 1561b0c632dbSHeiko Carstens vcpu->arch.sie_block->todpr = 0; 1562b0c632dbSHeiko Carstens memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64)); 1563b0c632dbSHeiko Carstens vcpu->arch.sie_block->gcr[0] = 0xE0UL; 1564b0c632dbSHeiko Carstens vcpu->arch.sie_block->gcr[14] = 0xC2000000UL; 15659abc2a08SDavid Hildenbrand /* make sure the new fpc will be lazily loaded */ 15669abc2a08SDavid Hildenbrand save_fpu_regs(); 15679abc2a08SDavid Hildenbrand current->thread.fpu.fpc = 0; 1568b0c632dbSHeiko Carstens vcpu->arch.sie_block->gbea = 1; 1569672550fbSChristian Borntraeger vcpu->arch.sie_block->pp = 0; 15703c038e6bSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 15713c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 15726352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) 15736852d7b6SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 15742ed10cc1SJens Freimann kvm_s390_clear_local_irqs(vcpu); 1575b0c632dbSHeiko Carstens } 1576b0c632dbSHeiko Carstens 157731928aa5SDominik Dingel void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu) 157842897d86SMarcelo Tosatti { 157972f25020SJason J. Herne mutex_lock(&vcpu->kvm->lock); 1580fdf03650SFan Zhang preempt_disable(); 158172f25020SJason J. Herne vcpu->arch.sie_block->epoch = vcpu->kvm->arch.epoch; 1582fdf03650SFan Zhang preempt_enable(); 158372f25020SJason J. Herne mutex_unlock(&vcpu->kvm->lock); 158425508824SDavid Hildenbrand if (!kvm_is_ucontrol(vcpu->kvm)) { 1585dafd032aSDominik Dingel vcpu->arch.gmap = vcpu->kvm->arch.gmap; 1586eaa78f34SDavid Hildenbrand sca_add_vcpu(vcpu); 158725508824SDavid Hildenbrand } 158825508824SDavid Hildenbrand 158942897d86SMarcelo Tosatti } 159042897d86SMarcelo Tosatti 15915102ee87STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu) 15925102ee87STony Krowiak { 15939d8d5786SMichael Mueller if (!test_kvm_facility(vcpu->kvm, 76)) 15945102ee87STony Krowiak return; 15955102ee87STony Krowiak 1596a374e892STony Krowiak vcpu->arch.sie_block->ecb3 &= ~(ECB3_AES | ECB3_DEA); 1597a374e892STony Krowiak 1598a374e892STony Krowiak if (vcpu->kvm->arch.crypto.aes_kw) 1599a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_AES; 1600a374e892STony Krowiak if (vcpu->kvm->arch.crypto.dea_kw) 1601a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_DEA; 1602a374e892STony Krowiak 16035102ee87STony Krowiak vcpu->arch.sie_block->crycbd = vcpu->kvm->arch.crypto.crycbd; 16045102ee87STony Krowiak } 16055102ee87STony Krowiak 1606b31605c1SDominik Dingel void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu) 1607b31605c1SDominik Dingel { 1608b31605c1SDominik Dingel free_page(vcpu->arch.sie_block->cbrlo); 1609b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = 0; 1610b31605c1SDominik Dingel } 1611b31605c1SDominik Dingel 1612b31605c1SDominik Dingel int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu) 1613b31605c1SDominik Dingel { 1614b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = get_zeroed_page(GFP_KERNEL); 1615b31605c1SDominik Dingel if (!vcpu->arch.sie_block->cbrlo) 1616b31605c1SDominik Dingel return -ENOMEM; 1617b31605c1SDominik Dingel 1618b31605c1SDominik Dingel vcpu->arch.sie_block->ecb2 |= 0x80; 1619b31605c1SDominik Dingel vcpu->arch.sie_block->ecb2 &= ~0x08; 1620b31605c1SDominik Dingel return 0; 1621b31605c1SDominik Dingel } 1622b31605c1SDominik Dingel 162391520f1aSMichael Mueller static void kvm_s390_vcpu_setup_model(struct kvm_vcpu *vcpu) 162491520f1aSMichael Mueller { 162591520f1aSMichael Mueller struct kvm_s390_cpu_model *model = &vcpu->kvm->arch.model; 162691520f1aSMichael Mueller 162791520f1aSMichael Mueller vcpu->arch.cpu_id = model->cpu_id; 162891520f1aSMichael Mueller vcpu->arch.sie_block->ibc = model->ibc; 162980bc79dcSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 7)) 1630c54f0d6aSDavid Hildenbrand vcpu->arch.sie_block->fac = (u32)(u64) model->fac_list; 163191520f1aSMichael Mueller } 163291520f1aSMichael Mueller 1633b0c632dbSHeiko Carstens int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) 1634b0c632dbSHeiko Carstens { 1635b31605c1SDominik Dingel int rc = 0; 1636b31288faSKonstantin Weitz 16379e6dabefSCornelia Huck atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH | 16389e6dabefSCornelia Huck CPUSTAT_SM | 1639a4a4f191SGuenther Hutzl CPUSTAT_STOPPED); 1640a4a4f191SGuenther Hutzl 164153df84f8SGuenther Hutzl if (test_kvm_facility(vcpu->kvm, 78)) 1642805de8f4SPeter Zijlstra atomic_or(CPUSTAT_GED2, &vcpu->arch.sie_block->cpuflags); 164353df84f8SGuenther Hutzl else if (test_kvm_facility(vcpu->kvm, 8)) 1644805de8f4SPeter Zijlstra atomic_or(CPUSTAT_GED, &vcpu->arch.sie_block->cpuflags); 1645a4a4f191SGuenther Hutzl 164691520f1aSMichael Mueller kvm_s390_vcpu_setup_model(vcpu); 164791520f1aSMichael Mueller 1648fc34531dSChristian Borntraeger vcpu->arch.sie_block->ecb = 6; 16499d8d5786SMichael Mueller if (test_kvm_facility(vcpu->kvm, 50) && test_kvm_facility(vcpu->kvm, 73)) 16507feb6bb8SMichael Mueller vcpu->arch.sie_block->ecb |= 0x10; 16517feb6bb8SMichael Mueller 1652*d6af0b49SDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 8)) 1653*d6af0b49SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= 0x08; 1654ea5f4969SDavid Hildenbrand vcpu->arch.sie_block->eca = 0xC1002000U; 165537c5f6c8SDavid Hildenbrand if (sclp.has_siif) 1656217a4406SHeiko Carstens vcpu->arch.sie_block->eca |= 1; 165737c5f6c8SDavid Hildenbrand if (sclp.has_sigpif) 1658ea5f4969SDavid Hildenbrand vcpu->arch.sie_block->eca |= 0x10000000U; 1659c6e5f166SFan Zhang if (test_kvm_facility(vcpu->kvm, 64)) 1660c6e5f166SFan Zhang vcpu->arch.sie_block->ecb3 |= 0x01; 166118280d8bSMichael Mueller if (test_kvm_facility(vcpu->kvm, 129)) { 166213211ea7SEric Farman vcpu->arch.sie_block->eca |= 0x00020000; 166313211ea7SEric Farman vcpu->arch.sie_block->ecd |= 0x20000000; 166413211ea7SEric Farman } 1665c6e5f166SFan Zhang vcpu->arch.sie_block->riccbd = (unsigned long) &vcpu->run->s.regs.riccb; 1666492d8642SThomas Huth vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE; 16675a5e6536SMatthew Rosato 1668e6db1d61SDominik Dingel if (vcpu->kvm->arch.use_cmma) { 1669b31605c1SDominik Dingel rc = kvm_s390_vcpu_setup_cmma(vcpu); 1670b31605c1SDominik Dingel if (rc) 1671b31605c1SDominik Dingel return rc; 1672b31288faSKonstantin Weitz } 16730ac96cafSDavid Hildenbrand hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 1674ca872302SChristian Borntraeger vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup; 16759d8d5786SMichael Mueller 16765102ee87STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 16775102ee87STony Krowiak 1678b31605c1SDominik Dingel return rc; 1679b0c632dbSHeiko Carstens } 1680b0c632dbSHeiko Carstens 1681b0c632dbSHeiko Carstens struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, 1682b0c632dbSHeiko Carstens unsigned int id) 1683b0c632dbSHeiko Carstens { 16844d47555aSCarsten Otte struct kvm_vcpu *vcpu; 16857feb6bb8SMichael Mueller struct sie_page *sie_page; 16864d47555aSCarsten Otte int rc = -EINVAL; 1687b0c632dbSHeiko Carstens 16884215825eSDavid Hildenbrand if (!kvm_is_ucontrol(kvm) && !sca_can_add_vcpu(kvm, id)) 16894d47555aSCarsten Otte goto out; 16904d47555aSCarsten Otte 16914d47555aSCarsten Otte rc = -ENOMEM; 16924d47555aSCarsten Otte 1693b110feafSMichael Mueller vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL); 1694b0c632dbSHeiko Carstens if (!vcpu) 16954d47555aSCarsten Otte goto out; 1696b0c632dbSHeiko Carstens 16977feb6bb8SMichael Mueller sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL); 16987feb6bb8SMichael Mueller if (!sie_page) 1699b0c632dbSHeiko Carstens goto out_free_cpu; 1700b0c632dbSHeiko Carstens 17017feb6bb8SMichael Mueller vcpu->arch.sie_block = &sie_page->sie_block; 17027feb6bb8SMichael Mueller vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb; 17037feb6bb8SMichael Mueller 1704b0c632dbSHeiko Carstens vcpu->arch.sie_block->icpua = id; 1705ba5c1e9bSCarsten Otte spin_lock_init(&vcpu->arch.local_int.lock); 1706ba5c1e9bSCarsten Otte vcpu->arch.local_int.float_int = &kvm->arch.float_int; 1707d0321a24SChristian Borntraeger vcpu->arch.local_int.wq = &vcpu->wq; 17085288fbf0SChristian Borntraeger vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags; 17099c23a131SDavid Hildenbrand seqcount_init(&vcpu->arch.cputm_seqcount); 1710ba5c1e9bSCarsten Otte 1711b0c632dbSHeiko Carstens rc = kvm_vcpu_init(vcpu, kvm, id); 1712b0c632dbSHeiko Carstens if (rc) 17139abc2a08SDavid Hildenbrand goto out_free_sie_block; 17148335713aSChristian Borntraeger VM_EVENT(kvm, 3, "create cpu %d at 0x%pK, sie block at 0x%pK", id, vcpu, 1715b0c632dbSHeiko Carstens vcpu->arch.sie_block); 1716ade38c31SCornelia Huck trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block); 1717b0c632dbSHeiko Carstens 1718b0c632dbSHeiko Carstens return vcpu; 17197b06bf2fSWei Yongjun out_free_sie_block: 17207b06bf2fSWei Yongjun free_page((unsigned long)(vcpu->arch.sie_block)); 1721b0c632dbSHeiko Carstens out_free_cpu: 1722b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 17234d47555aSCarsten Otte out: 1724b0c632dbSHeiko Carstens return ERR_PTR(rc); 1725b0c632dbSHeiko Carstens } 1726b0c632dbSHeiko Carstens 1727b0c632dbSHeiko Carstens int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu) 1728b0c632dbSHeiko Carstens { 17299a022067SDavid Hildenbrand return kvm_s390_vcpu_has_irq(vcpu, 0); 1730b0c632dbSHeiko Carstens } 1731b0c632dbSHeiko Carstens 173227406cd5SChristian Borntraeger void kvm_s390_vcpu_block(struct kvm_vcpu *vcpu) 173349b99e1eSChristian Borntraeger { 1734805de8f4SPeter Zijlstra atomic_or(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 173561a6df54SDavid Hildenbrand exit_sie(vcpu); 173649b99e1eSChristian Borntraeger } 173749b99e1eSChristian Borntraeger 173827406cd5SChristian Borntraeger void kvm_s390_vcpu_unblock(struct kvm_vcpu *vcpu) 173949b99e1eSChristian Borntraeger { 1740805de8f4SPeter Zijlstra atomic_andnot(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 174149b99e1eSChristian Borntraeger } 174249b99e1eSChristian Borntraeger 17438e236546SChristian Borntraeger static void kvm_s390_vcpu_request(struct kvm_vcpu *vcpu) 17448e236546SChristian Borntraeger { 1745805de8f4SPeter Zijlstra atomic_or(PROG_REQUEST, &vcpu->arch.sie_block->prog20); 174661a6df54SDavid Hildenbrand exit_sie(vcpu); 17478e236546SChristian Borntraeger } 17488e236546SChristian Borntraeger 17498e236546SChristian Borntraeger static void kvm_s390_vcpu_request_handled(struct kvm_vcpu *vcpu) 17508e236546SChristian Borntraeger { 17519bf9fde2SJason J. Herne atomic_andnot(PROG_REQUEST, &vcpu->arch.sie_block->prog20); 17528e236546SChristian Borntraeger } 17538e236546SChristian Borntraeger 175449b99e1eSChristian Borntraeger /* 175549b99e1eSChristian Borntraeger * Kick a guest cpu out of SIE and wait until SIE is not running. 175649b99e1eSChristian Borntraeger * If the CPU is not running (e.g. waiting as idle) the function will 175749b99e1eSChristian Borntraeger * return immediately. */ 175849b99e1eSChristian Borntraeger void exit_sie(struct kvm_vcpu *vcpu) 175949b99e1eSChristian Borntraeger { 1760805de8f4SPeter Zijlstra atomic_or(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags); 176149b99e1eSChristian Borntraeger while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE) 176249b99e1eSChristian Borntraeger cpu_relax(); 176349b99e1eSChristian Borntraeger } 176449b99e1eSChristian Borntraeger 17658e236546SChristian Borntraeger /* Kick a guest cpu out of SIE to process a request synchronously */ 17668e236546SChristian Borntraeger void kvm_s390_sync_request(int req, struct kvm_vcpu *vcpu) 176749b99e1eSChristian Borntraeger { 17688e236546SChristian Borntraeger kvm_make_request(req, vcpu); 17698e236546SChristian Borntraeger kvm_s390_vcpu_request(vcpu); 177049b99e1eSChristian Borntraeger } 177149b99e1eSChristian Borntraeger 17722c70fe44SChristian Borntraeger static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address) 17732c70fe44SChristian Borntraeger { 17742c70fe44SChristian Borntraeger int i; 17752c70fe44SChristian Borntraeger struct kvm *kvm = gmap->private; 17762c70fe44SChristian Borntraeger struct kvm_vcpu *vcpu; 17772c70fe44SChristian Borntraeger 17782c70fe44SChristian Borntraeger kvm_for_each_vcpu(i, vcpu, kvm) { 17792c70fe44SChristian Borntraeger /* match against both prefix pages */ 1780fda902cbSMichael Mueller if (kvm_s390_get_prefix(vcpu) == (address & ~0x1000UL)) { 17812c70fe44SChristian Borntraeger VCPU_EVENT(vcpu, 2, "gmap notifier for %lx", address); 17828e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_MMU_RELOAD, vcpu); 17832c70fe44SChristian Borntraeger } 17842c70fe44SChristian Borntraeger } 17852c70fe44SChristian Borntraeger } 17862c70fe44SChristian Borntraeger 1787b6d33834SChristoffer Dall int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu) 1788b6d33834SChristoffer Dall { 1789b6d33834SChristoffer Dall /* kvm common code refers to this, but never calls it */ 1790b6d33834SChristoffer Dall BUG(); 1791b6d33834SChristoffer Dall return 0; 1792b6d33834SChristoffer Dall } 1793b6d33834SChristoffer Dall 179414eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, 179514eebd91SCarsten Otte struct kvm_one_reg *reg) 179614eebd91SCarsten Otte { 179714eebd91SCarsten Otte int r = -EINVAL; 179814eebd91SCarsten Otte 179914eebd91SCarsten Otte switch (reg->id) { 180029b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 180129b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->todpr, 180229b7c71bSCarsten Otte (u32 __user *)reg->addr); 180329b7c71bSCarsten Otte break; 180429b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 180529b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->epoch, 180629b7c71bSCarsten Otte (u64 __user *)reg->addr); 180729b7c71bSCarsten Otte break; 180846a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 18094287f247SDavid Hildenbrand r = put_user(kvm_s390_get_cpu_timer(vcpu), 181046a6dd1cSJason J. herne (u64 __user *)reg->addr); 181146a6dd1cSJason J. herne break; 181246a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 181346a6dd1cSJason J. herne r = put_user(vcpu->arch.sie_block->ckc, 181446a6dd1cSJason J. herne (u64 __user *)reg->addr); 181546a6dd1cSJason J. herne break; 1816536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 1817536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_token, 1818536336c2SDominik Dingel (u64 __user *)reg->addr); 1819536336c2SDominik Dingel break; 1820536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 1821536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_compare, 1822536336c2SDominik Dingel (u64 __user *)reg->addr); 1823536336c2SDominik Dingel break; 1824536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 1825536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_select, 1826536336c2SDominik Dingel (u64 __user *)reg->addr); 1827536336c2SDominik Dingel break; 1828672550fbSChristian Borntraeger case KVM_REG_S390_PP: 1829672550fbSChristian Borntraeger r = put_user(vcpu->arch.sie_block->pp, 1830672550fbSChristian Borntraeger (u64 __user *)reg->addr); 1831672550fbSChristian Borntraeger break; 1832afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 1833afa45ff5SChristian Borntraeger r = put_user(vcpu->arch.sie_block->gbea, 1834afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 1835afa45ff5SChristian Borntraeger break; 183614eebd91SCarsten Otte default: 183714eebd91SCarsten Otte break; 183814eebd91SCarsten Otte } 183914eebd91SCarsten Otte 184014eebd91SCarsten Otte return r; 184114eebd91SCarsten Otte } 184214eebd91SCarsten Otte 184314eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, 184414eebd91SCarsten Otte struct kvm_one_reg *reg) 184514eebd91SCarsten Otte { 184614eebd91SCarsten Otte int r = -EINVAL; 18474287f247SDavid Hildenbrand __u64 val; 184814eebd91SCarsten Otte 184914eebd91SCarsten Otte switch (reg->id) { 185029b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 185129b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->todpr, 185229b7c71bSCarsten Otte (u32 __user *)reg->addr); 185329b7c71bSCarsten Otte break; 185429b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 185529b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->epoch, 185629b7c71bSCarsten Otte (u64 __user *)reg->addr); 185729b7c71bSCarsten Otte break; 185846a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 18594287f247SDavid Hildenbrand r = get_user(val, (u64 __user *)reg->addr); 18604287f247SDavid Hildenbrand if (!r) 18614287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, val); 186246a6dd1cSJason J. herne break; 186346a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 186446a6dd1cSJason J. herne r = get_user(vcpu->arch.sie_block->ckc, 186546a6dd1cSJason J. herne (u64 __user *)reg->addr); 186646a6dd1cSJason J. herne break; 1867536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 1868536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_token, 1869536336c2SDominik Dingel (u64 __user *)reg->addr); 18709fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 18719fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 1872536336c2SDominik Dingel break; 1873536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 1874536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_compare, 1875536336c2SDominik Dingel (u64 __user *)reg->addr); 1876536336c2SDominik Dingel break; 1877536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 1878536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_select, 1879536336c2SDominik Dingel (u64 __user *)reg->addr); 1880536336c2SDominik Dingel break; 1881672550fbSChristian Borntraeger case KVM_REG_S390_PP: 1882672550fbSChristian Borntraeger r = get_user(vcpu->arch.sie_block->pp, 1883672550fbSChristian Borntraeger (u64 __user *)reg->addr); 1884672550fbSChristian Borntraeger break; 1885afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 1886afa45ff5SChristian Borntraeger r = get_user(vcpu->arch.sie_block->gbea, 1887afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 1888afa45ff5SChristian Borntraeger break; 188914eebd91SCarsten Otte default: 189014eebd91SCarsten Otte break; 189114eebd91SCarsten Otte } 189214eebd91SCarsten Otte 189314eebd91SCarsten Otte return r; 189414eebd91SCarsten Otte } 1895b6d33834SChristoffer Dall 1896b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) 1897b0c632dbSHeiko Carstens { 1898b0c632dbSHeiko Carstens kvm_s390_vcpu_initial_reset(vcpu); 1899b0c632dbSHeiko Carstens return 0; 1900b0c632dbSHeiko Carstens } 1901b0c632dbSHeiko Carstens 1902b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 1903b0c632dbSHeiko Carstens { 19045a32c1afSChristian Borntraeger memcpy(&vcpu->run->s.regs.gprs, ®s->gprs, sizeof(regs->gprs)); 1905b0c632dbSHeiko Carstens return 0; 1906b0c632dbSHeiko Carstens } 1907b0c632dbSHeiko Carstens 1908b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 1909b0c632dbSHeiko Carstens { 19105a32c1afSChristian Borntraeger memcpy(®s->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs)); 1911b0c632dbSHeiko Carstens return 0; 1912b0c632dbSHeiko Carstens } 1913b0c632dbSHeiko Carstens 1914b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, 1915b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 1916b0c632dbSHeiko Carstens { 191759674c1aSChristian Borntraeger memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs)); 1918b0c632dbSHeiko Carstens memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs)); 191959674c1aSChristian Borntraeger restore_access_regs(vcpu->run->s.regs.acrs); 1920b0c632dbSHeiko Carstens return 0; 1921b0c632dbSHeiko Carstens } 1922b0c632dbSHeiko Carstens 1923b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, 1924b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 1925b0c632dbSHeiko Carstens { 192659674c1aSChristian Borntraeger memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs)); 1927b0c632dbSHeiko Carstens memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs)); 1928b0c632dbSHeiko Carstens return 0; 1929b0c632dbSHeiko Carstens } 1930b0c632dbSHeiko Carstens 1931b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 1932b0c632dbSHeiko Carstens { 19339abc2a08SDavid Hildenbrand /* make sure the new values will be lazily loaded */ 19349abc2a08SDavid Hildenbrand save_fpu_regs(); 19354725c860SMartin Schwidefsky if (test_fp_ctl(fpu->fpc)) 19364725c860SMartin Schwidefsky return -EINVAL; 19379abc2a08SDavid Hildenbrand current->thread.fpu.fpc = fpu->fpc; 19389abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) 19399abc2a08SDavid Hildenbrand convert_fp_to_vx(current->thread.fpu.vxrs, (freg_t *)fpu->fprs); 19409abc2a08SDavid Hildenbrand else 19419abc2a08SDavid Hildenbrand memcpy(current->thread.fpu.fprs, &fpu->fprs, sizeof(fpu->fprs)); 1942b0c632dbSHeiko Carstens return 0; 1943b0c632dbSHeiko Carstens } 1944b0c632dbSHeiko Carstens 1945b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 1946b0c632dbSHeiko Carstens { 19479abc2a08SDavid Hildenbrand /* make sure we have the latest values */ 19489abc2a08SDavid Hildenbrand save_fpu_regs(); 19499abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) 19509abc2a08SDavid Hildenbrand convert_vx_to_fp((freg_t *)fpu->fprs, current->thread.fpu.vxrs); 19519abc2a08SDavid Hildenbrand else 19529abc2a08SDavid Hildenbrand memcpy(fpu->fprs, current->thread.fpu.fprs, sizeof(fpu->fprs)); 19539abc2a08SDavid Hildenbrand fpu->fpc = current->thread.fpu.fpc; 1954b0c632dbSHeiko Carstens return 0; 1955b0c632dbSHeiko Carstens } 1956b0c632dbSHeiko Carstens 1957b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw) 1958b0c632dbSHeiko Carstens { 1959b0c632dbSHeiko Carstens int rc = 0; 1960b0c632dbSHeiko Carstens 19617a42fdc2SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 1962b0c632dbSHeiko Carstens rc = -EBUSY; 1963d7b0b5ebSCarsten Otte else { 1964d7b0b5ebSCarsten Otte vcpu->run->psw_mask = psw.mask; 1965d7b0b5ebSCarsten Otte vcpu->run->psw_addr = psw.addr; 1966d7b0b5ebSCarsten Otte } 1967b0c632dbSHeiko Carstens return rc; 1968b0c632dbSHeiko Carstens } 1969b0c632dbSHeiko Carstens 1970b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, 1971b0c632dbSHeiko Carstens struct kvm_translation *tr) 1972b0c632dbSHeiko Carstens { 1973b0c632dbSHeiko Carstens return -EINVAL; /* not implemented yet */ 1974b0c632dbSHeiko Carstens } 1975b0c632dbSHeiko Carstens 197627291e21SDavid Hildenbrand #define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \ 197727291e21SDavid Hildenbrand KVM_GUESTDBG_USE_HW_BP | \ 197827291e21SDavid Hildenbrand KVM_GUESTDBG_ENABLE) 197927291e21SDavid Hildenbrand 1980d0bfb940SJan Kiszka int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 1981d0bfb940SJan Kiszka struct kvm_guest_debug *dbg) 1982b0c632dbSHeiko Carstens { 198327291e21SDavid Hildenbrand int rc = 0; 198427291e21SDavid Hildenbrand 198527291e21SDavid Hildenbrand vcpu->guest_debug = 0; 198627291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 198727291e21SDavid Hildenbrand 19882de3bfc2SDavid Hildenbrand if (dbg->control & ~VALID_GUESTDBG_FLAGS) 198927291e21SDavid Hildenbrand return -EINVAL; 199027291e21SDavid Hildenbrand 199127291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_ENABLE) { 199227291e21SDavid Hildenbrand vcpu->guest_debug = dbg->control; 199327291e21SDavid Hildenbrand /* enforce guest PER */ 1994805de8f4SPeter Zijlstra atomic_or(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags); 199527291e21SDavid Hildenbrand 199627291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_USE_HW_BP) 199727291e21SDavid Hildenbrand rc = kvm_s390_import_bp_data(vcpu, dbg); 199827291e21SDavid Hildenbrand } else { 1999805de8f4SPeter Zijlstra atomic_andnot(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags); 200027291e21SDavid Hildenbrand vcpu->arch.guestdbg.last_bp = 0; 200127291e21SDavid Hildenbrand } 200227291e21SDavid Hildenbrand 200327291e21SDavid Hildenbrand if (rc) { 200427291e21SDavid Hildenbrand vcpu->guest_debug = 0; 200527291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 2006805de8f4SPeter Zijlstra atomic_andnot(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags); 200727291e21SDavid Hildenbrand } 200827291e21SDavid Hildenbrand 200927291e21SDavid Hildenbrand return rc; 2010b0c632dbSHeiko Carstens } 2011b0c632dbSHeiko Carstens 201262d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 201362d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 201462d9f0dbSMarcelo Tosatti { 20156352e4d2SDavid Hildenbrand /* CHECK_STOP and LOAD are not supported yet */ 20166352e4d2SDavid Hildenbrand return is_vcpu_stopped(vcpu) ? KVM_MP_STATE_STOPPED : 20176352e4d2SDavid Hildenbrand KVM_MP_STATE_OPERATING; 201862d9f0dbSMarcelo Tosatti } 201962d9f0dbSMarcelo Tosatti 202062d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 202162d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 202262d9f0dbSMarcelo Tosatti { 20236352e4d2SDavid Hildenbrand int rc = 0; 20246352e4d2SDavid Hildenbrand 20256352e4d2SDavid Hildenbrand /* user space knows about this interface - let it control the state */ 20266352e4d2SDavid Hildenbrand vcpu->kvm->arch.user_cpu_state_ctrl = 1; 20276352e4d2SDavid Hildenbrand 20286352e4d2SDavid Hildenbrand switch (mp_state->mp_state) { 20296352e4d2SDavid Hildenbrand case KVM_MP_STATE_STOPPED: 20306352e4d2SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 20316352e4d2SDavid Hildenbrand break; 20326352e4d2SDavid Hildenbrand case KVM_MP_STATE_OPERATING: 20336352e4d2SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 20346352e4d2SDavid Hildenbrand break; 20356352e4d2SDavid Hildenbrand case KVM_MP_STATE_LOAD: 20366352e4d2SDavid Hildenbrand case KVM_MP_STATE_CHECK_STOP: 20376352e4d2SDavid Hildenbrand /* fall through - CHECK_STOP and LOAD are not supported yet */ 20386352e4d2SDavid Hildenbrand default: 20396352e4d2SDavid Hildenbrand rc = -ENXIO; 20406352e4d2SDavid Hildenbrand } 20416352e4d2SDavid Hildenbrand 20426352e4d2SDavid Hildenbrand return rc; 204362d9f0dbSMarcelo Tosatti } 204462d9f0dbSMarcelo Tosatti 20458ad35755SDavid Hildenbrand static bool ibs_enabled(struct kvm_vcpu *vcpu) 20468ad35755SDavid Hildenbrand { 20478ad35755SDavid Hildenbrand return atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_IBS; 20488ad35755SDavid Hildenbrand } 20498ad35755SDavid Hildenbrand 20502c70fe44SChristian Borntraeger static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu) 20512c70fe44SChristian Borntraeger { 20528ad35755SDavid Hildenbrand retry: 20538e236546SChristian Borntraeger kvm_s390_vcpu_request_handled(vcpu); 2054586b7ccdSChristian Borntraeger if (!vcpu->requests) 2055586b7ccdSChristian Borntraeger return 0; 20562c70fe44SChristian Borntraeger /* 20572c70fe44SChristian Borntraeger * We use MMU_RELOAD just to re-arm the ipte notifier for the 20582c70fe44SChristian Borntraeger * guest prefix page. gmap_ipte_notify will wait on the ptl lock. 20592c70fe44SChristian Borntraeger * This ensures that the ipte instruction for this request has 20602c70fe44SChristian Borntraeger * already finished. We might race against a second unmapper that 20612c70fe44SChristian Borntraeger * wants to set the blocking bit. Lets just retry the request loop. 20622c70fe44SChristian Borntraeger */ 20638ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) { 20642c70fe44SChristian Borntraeger int rc; 20652c70fe44SChristian Borntraeger rc = gmap_ipte_notify(vcpu->arch.gmap, 2066fda902cbSMichael Mueller kvm_s390_get_prefix(vcpu), 20672c70fe44SChristian Borntraeger PAGE_SIZE * 2); 20682c70fe44SChristian Borntraeger if (rc) 20692c70fe44SChristian Borntraeger return rc; 20708ad35755SDavid Hildenbrand goto retry; 20712c70fe44SChristian Borntraeger } 20728ad35755SDavid Hildenbrand 2073d3d692c8SDavid Hildenbrand if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu)) { 2074d3d692c8SDavid Hildenbrand vcpu->arch.sie_block->ihcpu = 0xffff; 2075d3d692c8SDavid Hildenbrand goto retry; 2076d3d692c8SDavid Hildenbrand } 2077d3d692c8SDavid Hildenbrand 20788ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu)) { 20798ad35755SDavid Hildenbrand if (!ibs_enabled(vcpu)) { 20808ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 1); 2081805de8f4SPeter Zijlstra atomic_or(CPUSTAT_IBS, 20828ad35755SDavid Hildenbrand &vcpu->arch.sie_block->cpuflags); 20838ad35755SDavid Hildenbrand } 20848ad35755SDavid Hildenbrand goto retry; 20858ad35755SDavid Hildenbrand } 20868ad35755SDavid Hildenbrand 20878ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu)) { 20888ad35755SDavid Hildenbrand if (ibs_enabled(vcpu)) { 20898ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 0); 2090805de8f4SPeter Zijlstra atomic_andnot(CPUSTAT_IBS, 20918ad35755SDavid Hildenbrand &vcpu->arch.sie_block->cpuflags); 20928ad35755SDavid Hildenbrand } 20938ad35755SDavid Hildenbrand goto retry; 20948ad35755SDavid Hildenbrand } 20958ad35755SDavid Hildenbrand 20960759d068SDavid Hildenbrand /* nothing to do, just clear the request */ 20970759d068SDavid Hildenbrand clear_bit(KVM_REQ_UNHALT, &vcpu->requests); 20980759d068SDavid Hildenbrand 20992c70fe44SChristian Borntraeger return 0; 21002c70fe44SChristian Borntraeger } 21012c70fe44SChristian Borntraeger 210225ed1675SDavid Hildenbrand void kvm_s390_set_tod_clock(struct kvm *kvm, u64 tod) 210325ed1675SDavid Hildenbrand { 210425ed1675SDavid Hildenbrand struct kvm_vcpu *vcpu; 210525ed1675SDavid Hildenbrand int i; 210625ed1675SDavid Hildenbrand 210725ed1675SDavid Hildenbrand mutex_lock(&kvm->lock); 210825ed1675SDavid Hildenbrand preempt_disable(); 210925ed1675SDavid Hildenbrand kvm->arch.epoch = tod - get_tod_clock(); 211025ed1675SDavid Hildenbrand kvm_s390_vcpu_block_all(kvm); 211125ed1675SDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) 211225ed1675SDavid Hildenbrand vcpu->arch.sie_block->epoch = kvm->arch.epoch; 211325ed1675SDavid Hildenbrand kvm_s390_vcpu_unblock_all(kvm); 211425ed1675SDavid Hildenbrand preempt_enable(); 211525ed1675SDavid Hildenbrand mutex_unlock(&kvm->lock); 211625ed1675SDavid Hildenbrand } 211725ed1675SDavid Hildenbrand 2118fa576c58SThomas Huth /** 2119fa576c58SThomas Huth * kvm_arch_fault_in_page - fault-in guest page if necessary 2120fa576c58SThomas Huth * @vcpu: The corresponding virtual cpu 2121fa576c58SThomas Huth * @gpa: Guest physical address 2122fa576c58SThomas Huth * @writable: Whether the page should be writable or not 2123fa576c58SThomas Huth * 2124fa576c58SThomas Huth * Make sure that a guest page has been faulted-in on the host. 2125fa576c58SThomas Huth * 2126fa576c58SThomas Huth * Return: Zero on success, negative error code otherwise. 2127fa576c58SThomas Huth */ 2128fa576c58SThomas Huth long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable) 212924eb3a82SDominik Dingel { 2130527e30b4SMartin Schwidefsky return gmap_fault(vcpu->arch.gmap, gpa, 2131527e30b4SMartin Schwidefsky writable ? FAULT_FLAG_WRITE : 0); 213224eb3a82SDominik Dingel } 213324eb3a82SDominik Dingel 21343c038e6bSDominik Dingel static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token, 21353c038e6bSDominik Dingel unsigned long token) 21363c038e6bSDominik Dingel { 21373c038e6bSDominik Dingel struct kvm_s390_interrupt inti; 2138383d0b05SJens Freimann struct kvm_s390_irq irq; 21393c038e6bSDominik Dingel 21403c038e6bSDominik Dingel if (start_token) { 2141383d0b05SJens Freimann irq.u.ext.ext_params2 = token; 2142383d0b05SJens Freimann irq.type = KVM_S390_INT_PFAULT_INIT; 2143383d0b05SJens Freimann WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &irq)); 21443c038e6bSDominik Dingel } else { 21453c038e6bSDominik Dingel inti.type = KVM_S390_INT_PFAULT_DONE; 2146383d0b05SJens Freimann inti.parm64 = token; 21473c038e6bSDominik Dingel WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti)); 21483c038e6bSDominik Dingel } 21493c038e6bSDominik Dingel } 21503c038e6bSDominik Dingel 21513c038e6bSDominik Dingel void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu, 21523c038e6bSDominik Dingel struct kvm_async_pf *work) 21533c038e6bSDominik Dingel { 21543c038e6bSDominik Dingel trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token); 21553c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token); 21563c038e6bSDominik Dingel } 21573c038e6bSDominik Dingel 21583c038e6bSDominik Dingel void kvm_arch_async_page_present(struct kvm_vcpu *vcpu, 21593c038e6bSDominik Dingel struct kvm_async_pf *work) 21603c038e6bSDominik Dingel { 21613c038e6bSDominik Dingel trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token); 21623c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token); 21633c038e6bSDominik Dingel } 21643c038e6bSDominik Dingel 21653c038e6bSDominik Dingel void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu, 21663c038e6bSDominik Dingel struct kvm_async_pf *work) 21673c038e6bSDominik Dingel { 21683c038e6bSDominik Dingel /* s390 will always inject the page directly */ 21693c038e6bSDominik Dingel } 21703c038e6bSDominik Dingel 21713c038e6bSDominik Dingel bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu) 21723c038e6bSDominik Dingel { 21733c038e6bSDominik Dingel /* 21743c038e6bSDominik Dingel * s390 will always inject the page directly, 21753c038e6bSDominik Dingel * but we still want check_async_completion to cleanup 21763c038e6bSDominik Dingel */ 21773c038e6bSDominik Dingel return true; 21783c038e6bSDominik Dingel } 21793c038e6bSDominik Dingel 21803c038e6bSDominik Dingel static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu) 21813c038e6bSDominik Dingel { 21823c038e6bSDominik Dingel hva_t hva; 21833c038e6bSDominik Dingel struct kvm_arch_async_pf arch; 21843c038e6bSDominik Dingel int rc; 21853c038e6bSDominik Dingel 21863c038e6bSDominik Dingel if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 21873c038e6bSDominik Dingel return 0; 21883c038e6bSDominik Dingel if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) != 21893c038e6bSDominik Dingel vcpu->arch.pfault_compare) 21903c038e6bSDominik Dingel return 0; 21913c038e6bSDominik Dingel if (psw_extint_disabled(vcpu)) 21923c038e6bSDominik Dingel return 0; 21939a022067SDavid Hildenbrand if (kvm_s390_vcpu_has_irq(vcpu, 0)) 21943c038e6bSDominik Dingel return 0; 21953c038e6bSDominik Dingel if (!(vcpu->arch.sie_block->gcr[0] & 0x200ul)) 21963c038e6bSDominik Dingel return 0; 21973c038e6bSDominik Dingel if (!vcpu->arch.gmap->pfault_enabled) 21983c038e6bSDominik Dingel return 0; 21993c038e6bSDominik Dingel 220081480cc1SHeiko Carstens hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(current->thread.gmap_addr)); 220181480cc1SHeiko Carstens hva += current->thread.gmap_addr & ~PAGE_MASK; 220281480cc1SHeiko Carstens if (read_guest_real(vcpu, vcpu->arch.pfault_token, &arch.pfault_token, 8)) 22033c038e6bSDominik Dingel return 0; 22043c038e6bSDominik Dingel 22053c038e6bSDominik Dingel rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch); 22063c038e6bSDominik Dingel return rc; 22073c038e6bSDominik Dingel } 22083c038e6bSDominik Dingel 22093fb4c40fSThomas Huth static int vcpu_pre_run(struct kvm_vcpu *vcpu) 2210b0c632dbSHeiko Carstens { 22113fb4c40fSThomas Huth int rc, cpuflags; 2212e168bf8dSCarsten Otte 22133c038e6bSDominik Dingel /* 22143c038e6bSDominik Dingel * On s390 notifications for arriving pages will be delivered directly 22153c038e6bSDominik Dingel * to the guest but the house keeping for completed pfaults is 22163c038e6bSDominik Dingel * handled outside the worker. 22173c038e6bSDominik Dingel */ 22183c038e6bSDominik Dingel kvm_check_async_pf_completion(vcpu); 22193c038e6bSDominik Dingel 22207ec7c8c7SChristian Borntraeger vcpu->arch.sie_block->gg14 = vcpu->run->s.regs.gprs[14]; 22217ec7c8c7SChristian Borntraeger vcpu->arch.sie_block->gg15 = vcpu->run->s.regs.gprs[15]; 2222b0c632dbSHeiko Carstens 2223b0c632dbSHeiko Carstens if (need_resched()) 2224b0c632dbSHeiko Carstens schedule(); 2225b0c632dbSHeiko Carstens 2226d3a73acbSMartin Schwidefsky if (test_cpu_flag(CIF_MCCK_PENDING)) 222771cde587SChristian Borntraeger s390_handle_mcck(); 222871cde587SChristian Borntraeger 222979395031SJens Freimann if (!kvm_is_ucontrol(vcpu->kvm)) { 223079395031SJens Freimann rc = kvm_s390_deliver_pending_interrupts(vcpu); 223179395031SJens Freimann if (rc) 223279395031SJens Freimann return rc; 223379395031SJens Freimann } 22340ff31867SCarsten Otte 22352c70fe44SChristian Borntraeger rc = kvm_s390_handle_requests(vcpu); 22362c70fe44SChristian Borntraeger if (rc) 22372c70fe44SChristian Borntraeger return rc; 22382c70fe44SChristian Borntraeger 223927291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) { 224027291e21SDavid Hildenbrand kvm_s390_backup_guest_per_regs(vcpu); 224127291e21SDavid Hildenbrand kvm_s390_patch_guest_per_regs(vcpu); 224227291e21SDavid Hildenbrand } 224327291e21SDavid Hildenbrand 2244b0c632dbSHeiko Carstens vcpu->arch.sie_block->icptcode = 0; 22453fb4c40fSThomas Huth cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags); 22463fb4c40fSThomas Huth VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags); 22473fb4c40fSThomas Huth trace_kvm_s390_sie_enter(vcpu, cpuflags); 22482b29a9fdSDominik Dingel 22493fb4c40fSThomas Huth return 0; 22503fb4c40fSThomas Huth } 22513fb4c40fSThomas Huth 2252492d8642SThomas Huth static int vcpu_post_run_fault_in_sie(struct kvm_vcpu *vcpu) 2253492d8642SThomas Huth { 225456317920SDavid Hildenbrand struct kvm_s390_pgm_info pgm_info = { 225556317920SDavid Hildenbrand .code = PGM_ADDRESSING, 225656317920SDavid Hildenbrand }; 225756317920SDavid Hildenbrand u8 opcode, ilen; 2258492d8642SThomas Huth int rc; 2259492d8642SThomas Huth 2260492d8642SThomas Huth VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction"); 2261492d8642SThomas Huth trace_kvm_s390_sie_fault(vcpu); 2262492d8642SThomas Huth 2263492d8642SThomas Huth /* 2264492d8642SThomas Huth * We want to inject an addressing exception, which is defined as a 2265492d8642SThomas Huth * suppressing or terminating exception. However, since we came here 2266492d8642SThomas Huth * by a DAT access exception, the PSW still points to the faulting 2267492d8642SThomas Huth * instruction since DAT exceptions are nullifying. So we've got 2268492d8642SThomas Huth * to look up the current opcode to get the length of the instruction 2269492d8642SThomas Huth * to be able to forward the PSW. 2270492d8642SThomas Huth */ 227165977322SDavid Hildenbrand rc = read_guest_instr(vcpu, &opcode, 1); 227256317920SDavid Hildenbrand ilen = insn_length(opcode); 22739b0d721aSDavid Hildenbrand if (rc < 0) { 22749b0d721aSDavid Hildenbrand return rc; 22759b0d721aSDavid Hildenbrand } else if (rc) { 22769b0d721aSDavid Hildenbrand /* Instruction-Fetching Exceptions - we can't detect the ilen. 22779b0d721aSDavid Hildenbrand * Forward by arbitrary ilc, injection will take care of 22789b0d721aSDavid Hildenbrand * nullification if necessary. 22799b0d721aSDavid Hildenbrand */ 22809b0d721aSDavid Hildenbrand pgm_info = vcpu->arch.pgm; 22819b0d721aSDavid Hildenbrand ilen = 4; 22829b0d721aSDavid Hildenbrand } 228356317920SDavid Hildenbrand pgm_info.flags = ilen | KVM_S390_PGM_FLAGS_ILC_VALID; 228456317920SDavid Hildenbrand kvm_s390_forward_psw(vcpu, ilen); 228556317920SDavid Hildenbrand return kvm_s390_inject_prog_irq(vcpu, &pgm_info); 2286492d8642SThomas Huth } 2287492d8642SThomas Huth 22883fb4c40fSThomas Huth static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason) 22893fb4c40fSThomas Huth { 22902b29a9fdSDominik Dingel VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", 22912b29a9fdSDominik Dingel vcpu->arch.sie_block->icptcode); 22922b29a9fdSDominik Dingel trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode); 22932b29a9fdSDominik Dingel 229427291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) 229527291e21SDavid Hildenbrand kvm_s390_restore_guest_per_regs(vcpu); 229627291e21SDavid Hildenbrand 22977ec7c8c7SChristian Borntraeger vcpu->run->s.regs.gprs[14] = vcpu->arch.sie_block->gg14; 22987ec7c8c7SChristian Borntraeger vcpu->run->s.regs.gprs[15] = vcpu->arch.sie_block->gg15; 229971f116bfSDavid Hildenbrand 230071f116bfSDavid Hildenbrand if (vcpu->arch.sie_block->icptcode > 0) { 230171f116bfSDavid Hildenbrand int rc = kvm_handle_sie_intercept(vcpu); 230271f116bfSDavid Hildenbrand 230371f116bfSDavid Hildenbrand if (rc != -EOPNOTSUPP) 230471f116bfSDavid Hildenbrand return rc; 230571f116bfSDavid Hildenbrand vcpu->run->exit_reason = KVM_EXIT_S390_SIEIC; 230671f116bfSDavid Hildenbrand vcpu->run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode; 230771f116bfSDavid Hildenbrand vcpu->run->s390_sieic.ipa = vcpu->arch.sie_block->ipa; 230871f116bfSDavid Hildenbrand vcpu->run->s390_sieic.ipb = vcpu->arch.sie_block->ipb; 230971f116bfSDavid Hildenbrand return -EREMOTE; 231071f116bfSDavid Hildenbrand } else if (exit_reason != -EFAULT) { 231171f116bfSDavid Hildenbrand vcpu->stat.exit_null++; 231271f116bfSDavid Hildenbrand return 0; 2313210b1607SThomas Huth } else if (kvm_is_ucontrol(vcpu->kvm)) { 2314210b1607SThomas Huth vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL; 2315210b1607SThomas Huth vcpu->run->s390_ucontrol.trans_exc_code = 2316210b1607SThomas Huth current->thread.gmap_addr; 2317210b1607SThomas Huth vcpu->run->s390_ucontrol.pgm_code = 0x10; 231871f116bfSDavid Hildenbrand return -EREMOTE; 231924eb3a82SDominik Dingel } else if (current->thread.gmap_pfault) { 23203c038e6bSDominik Dingel trace_kvm_s390_major_guest_pfault(vcpu); 232124eb3a82SDominik Dingel current->thread.gmap_pfault = 0; 232271f116bfSDavid Hildenbrand if (kvm_arch_setup_async_pf(vcpu)) 232371f116bfSDavid Hildenbrand return 0; 232471f116bfSDavid Hildenbrand return kvm_arch_fault_in_page(vcpu, current->thread.gmap_addr, 1); 2325fa576c58SThomas Huth } 232671f116bfSDavid Hildenbrand return vcpu_post_run_fault_in_sie(vcpu); 23273fb4c40fSThomas Huth } 23283fb4c40fSThomas Huth 23293fb4c40fSThomas Huth static int __vcpu_run(struct kvm_vcpu *vcpu) 23303fb4c40fSThomas Huth { 23313fb4c40fSThomas Huth int rc, exit_reason; 23323fb4c40fSThomas Huth 2333800c1065SThomas Huth /* 2334800c1065SThomas Huth * We try to hold kvm->srcu during most of vcpu_run (except when run- 2335800c1065SThomas Huth * ning the guest), so that memslots (and other stuff) are protected 2336800c1065SThomas Huth */ 2337800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 2338800c1065SThomas Huth 2339a76ccff6SThomas Huth do { 23403fb4c40fSThomas Huth rc = vcpu_pre_run(vcpu); 23413fb4c40fSThomas Huth if (rc) 2342a76ccff6SThomas Huth break; 23433fb4c40fSThomas Huth 2344800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 23453fb4c40fSThomas Huth /* 2346a76ccff6SThomas Huth * As PF_VCPU will be used in fault handler, between 2347a76ccff6SThomas Huth * guest_enter and guest_exit should be no uaccess. 23483fb4c40fSThomas Huth */ 23490097d12eSChristian Borntraeger local_irq_disable(); 23500097d12eSChristian Borntraeger __kvm_guest_enter(); 2351db0758b2SDavid Hildenbrand __disable_cpu_timer_accounting(vcpu); 23520097d12eSChristian Borntraeger local_irq_enable(); 2353a76ccff6SThomas Huth exit_reason = sie64a(vcpu->arch.sie_block, 2354a76ccff6SThomas Huth vcpu->run->s.regs.gprs); 23550097d12eSChristian Borntraeger local_irq_disable(); 2356db0758b2SDavid Hildenbrand __enable_cpu_timer_accounting(vcpu); 23570097d12eSChristian Borntraeger __kvm_guest_exit(); 23580097d12eSChristian Borntraeger local_irq_enable(); 2359800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 23603fb4c40fSThomas Huth 23613fb4c40fSThomas Huth rc = vcpu_post_run(vcpu, exit_reason); 236227291e21SDavid Hildenbrand } while (!signal_pending(current) && !guestdbg_exit_pending(vcpu) && !rc); 23633fb4c40fSThomas Huth 2364800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 2365e168bf8dSCarsten Otte return rc; 2366b0c632dbSHeiko Carstens } 2367b0c632dbSHeiko Carstens 2368b028ee3eSDavid Hildenbrand static void sync_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 2369b028ee3eSDavid Hildenbrand { 2370b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask; 2371b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr; 2372b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) 2373b028ee3eSDavid Hildenbrand kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix); 2374b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) { 2375b028ee3eSDavid Hildenbrand memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128); 2376d3d692c8SDavid Hildenbrand /* some control register changes require a tlb flush */ 2377d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 2378b028ee3eSDavid Hildenbrand } 2379b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_ARCH0) { 23804287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, kvm_run->s.regs.cputm); 2381b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->ckc = kvm_run->s.regs.ckc; 2382b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->todpr = kvm_run->s.regs.todpr; 2383b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->pp = kvm_run->s.regs.pp; 2384b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gbea = kvm_run->s.regs.gbea; 2385b028ee3eSDavid Hildenbrand } 2386b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PFAULT) { 2387b028ee3eSDavid Hildenbrand vcpu->arch.pfault_token = kvm_run->s.regs.pft; 2388b028ee3eSDavid Hildenbrand vcpu->arch.pfault_select = kvm_run->s.regs.pfs; 2389b028ee3eSDavid Hildenbrand vcpu->arch.pfault_compare = kvm_run->s.regs.pfc; 23909fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 23919fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 2392b028ee3eSDavid Hildenbrand } 2393b028ee3eSDavid Hildenbrand kvm_run->kvm_dirty_regs = 0; 2394b028ee3eSDavid Hildenbrand } 2395b028ee3eSDavid Hildenbrand 2396b028ee3eSDavid Hildenbrand static void store_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 2397b028ee3eSDavid Hildenbrand { 2398b028ee3eSDavid Hildenbrand kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask; 2399b028ee3eSDavid Hildenbrand kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr; 2400b028ee3eSDavid Hildenbrand kvm_run->s.regs.prefix = kvm_s390_get_prefix(vcpu); 2401b028ee3eSDavid Hildenbrand memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128); 24024287f247SDavid Hildenbrand kvm_run->s.regs.cputm = kvm_s390_get_cpu_timer(vcpu); 2403b028ee3eSDavid Hildenbrand kvm_run->s.regs.ckc = vcpu->arch.sie_block->ckc; 2404b028ee3eSDavid Hildenbrand kvm_run->s.regs.todpr = vcpu->arch.sie_block->todpr; 2405b028ee3eSDavid Hildenbrand kvm_run->s.regs.pp = vcpu->arch.sie_block->pp; 2406b028ee3eSDavid Hildenbrand kvm_run->s.regs.gbea = vcpu->arch.sie_block->gbea; 2407b028ee3eSDavid Hildenbrand kvm_run->s.regs.pft = vcpu->arch.pfault_token; 2408b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfs = vcpu->arch.pfault_select; 2409b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfc = vcpu->arch.pfault_compare; 2410b028ee3eSDavid Hildenbrand } 2411b028ee3eSDavid Hildenbrand 2412b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 2413b0c632dbSHeiko Carstens { 24148f2abe6aSChristian Borntraeger int rc; 2415b0c632dbSHeiko Carstens sigset_t sigsaved; 2416b0c632dbSHeiko Carstens 241727291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu)) { 241827291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 241927291e21SDavid Hildenbrand return 0; 242027291e21SDavid Hildenbrand } 242127291e21SDavid Hildenbrand 2422b0c632dbSHeiko Carstens if (vcpu->sigset_active) 2423b0c632dbSHeiko Carstens sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); 2424b0c632dbSHeiko Carstens 24256352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) { 24266852d7b6SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 24276352e4d2SDavid Hildenbrand } else if (is_vcpu_stopped(vcpu)) { 2428ea2cdd27SDavid Hildenbrand pr_err_ratelimited("can't run stopped vcpu %d\n", 24296352e4d2SDavid Hildenbrand vcpu->vcpu_id); 24306352e4d2SDavid Hildenbrand return -EINVAL; 24316352e4d2SDavid Hildenbrand } 2432b0c632dbSHeiko Carstens 2433b028ee3eSDavid Hildenbrand sync_regs(vcpu, kvm_run); 2434db0758b2SDavid Hildenbrand enable_cpu_timer_accounting(vcpu); 2435d7b0b5ebSCarsten Otte 2436dab4079dSHeiko Carstens might_fault(); 2437e168bf8dSCarsten Otte rc = __vcpu_run(vcpu); 24389ace903dSChristian Ehrhardt 2439b1d16c49SChristian Ehrhardt if (signal_pending(current) && !rc) { 2440b1d16c49SChristian Ehrhardt kvm_run->exit_reason = KVM_EXIT_INTR; 24418f2abe6aSChristian Borntraeger rc = -EINTR; 2442b1d16c49SChristian Ehrhardt } 24438f2abe6aSChristian Borntraeger 244427291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu) && !rc) { 244527291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 244627291e21SDavid Hildenbrand rc = 0; 244727291e21SDavid Hildenbrand } 244827291e21SDavid Hildenbrand 24498f2abe6aSChristian Borntraeger if (rc == -EREMOTE) { 245071f116bfSDavid Hildenbrand /* userspace support is needed, kvm_run has been prepared */ 24518f2abe6aSChristian Borntraeger rc = 0; 24528f2abe6aSChristian Borntraeger } 24538f2abe6aSChristian Borntraeger 2454db0758b2SDavid Hildenbrand disable_cpu_timer_accounting(vcpu); 2455b028ee3eSDavid Hildenbrand store_regs(vcpu, kvm_run); 2456d7b0b5ebSCarsten Otte 2457b0c632dbSHeiko Carstens if (vcpu->sigset_active) 2458b0c632dbSHeiko Carstens sigprocmask(SIG_SETMASK, &sigsaved, NULL); 2459b0c632dbSHeiko Carstens 2460b0c632dbSHeiko Carstens vcpu->stat.exit_userspace++; 24617e8e6ab4SHeiko Carstens return rc; 2462b0c632dbSHeiko Carstens } 2463b0c632dbSHeiko Carstens 2464b0c632dbSHeiko Carstens /* 2465b0c632dbSHeiko Carstens * store status at address 2466b0c632dbSHeiko Carstens * we use have two special cases: 2467b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit 2468b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_PREFIXED: -> prefix 2469b0c632dbSHeiko Carstens */ 2470d0bce605SHeiko Carstens int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long gpa) 2471b0c632dbSHeiko Carstens { 2472092670cdSCarsten Otte unsigned char archmode = 1; 24739abc2a08SDavid Hildenbrand freg_t fprs[NUM_FPRS]; 2474fda902cbSMichael Mueller unsigned int px; 24754287f247SDavid Hildenbrand u64 clkcomp, cputm; 2476d0bce605SHeiko Carstens int rc; 2477b0c632dbSHeiko Carstens 2478d9a3a09aSMartin Schwidefsky px = kvm_s390_get_prefix(vcpu); 2479d0bce605SHeiko Carstens if (gpa == KVM_S390_STORE_STATUS_NOADDR) { 2480d0bce605SHeiko Carstens if (write_guest_abs(vcpu, 163, &archmode, 1)) 2481b0c632dbSHeiko Carstens return -EFAULT; 2482d9a3a09aSMartin Schwidefsky gpa = 0; 2483d0bce605SHeiko Carstens } else if (gpa == KVM_S390_STORE_STATUS_PREFIXED) { 2484d0bce605SHeiko Carstens if (write_guest_real(vcpu, 163, &archmode, 1)) 2485b0c632dbSHeiko Carstens return -EFAULT; 2486d9a3a09aSMartin Schwidefsky gpa = px; 2487d9a3a09aSMartin Schwidefsky } else 2488d9a3a09aSMartin Schwidefsky gpa -= __LC_FPREGS_SAVE_AREA; 24899abc2a08SDavid Hildenbrand 24909abc2a08SDavid Hildenbrand /* manually convert vector registers if necessary */ 24919abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) { 24929522b37fSDavid Hildenbrand convert_vx_to_fp(fprs, (__vector128 *) vcpu->run->s.regs.vrs); 2493d9a3a09aSMartin Schwidefsky rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA, 24949abc2a08SDavid Hildenbrand fprs, 128); 24959abc2a08SDavid Hildenbrand } else { 24969abc2a08SDavid Hildenbrand rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA, 24976fd8e67dSDavid Hildenbrand vcpu->run->s.regs.fprs, 128); 24989abc2a08SDavid Hildenbrand } 2499d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_GPREGS_SAVE_AREA, 2500d0bce605SHeiko Carstens vcpu->run->s.regs.gprs, 128); 2501d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_PSW_SAVE_AREA, 2502d0bce605SHeiko Carstens &vcpu->arch.sie_block->gpsw, 16); 2503d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_PREFIX_SAVE_AREA, 2504fda902cbSMichael Mueller &px, 4); 2505d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_FP_CREG_SAVE_AREA, 25069abc2a08SDavid Hildenbrand &vcpu->run->s.regs.fpc, 4); 2507d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_TOD_PROGREG_SAVE_AREA, 2508d0bce605SHeiko Carstens &vcpu->arch.sie_block->todpr, 4); 25094287f247SDavid Hildenbrand cputm = kvm_s390_get_cpu_timer(vcpu); 2510d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CPU_TIMER_SAVE_AREA, 25114287f247SDavid Hildenbrand &cputm, 8); 2512178bd789SThomas Huth clkcomp = vcpu->arch.sie_block->ckc >> 8; 2513d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CLOCK_COMP_SAVE_AREA, 2514d0bce605SHeiko Carstens &clkcomp, 8); 2515d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_AREGS_SAVE_AREA, 2516d0bce605SHeiko Carstens &vcpu->run->s.regs.acrs, 64); 2517d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CREGS_SAVE_AREA, 2518d0bce605SHeiko Carstens &vcpu->arch.sie_block->gcr, 128); 2519d0bce605SHeiko Carstens return rc ? -EFAULT : 0; 2520b0c632dbSHeiko Carstens } 2521b0c632dbSHeiko Carstens 2522e879892cSThomas Huth int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr) 2523e879892cSThomas Huth { 2524e879892cSThomas Huth /* 2525e879892cSThomas Huth * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy 2526e879892cSThomas Huth * copying in vcpu load/put. Lets update our copies before we save 2527e879892cSThomas Huth * it into the save area 2528e879892cSThomas Huth */ 2529d0164ee2SHendrik Brueckner save_fpu_regs(); 25309abc2a08SDavid Hildenbrand vcpu->run->s.regs.fpc = current->thread.fpu.fpc; 2531e879892cSThomas Huth save_access_regs(vcpu->run->s.regs.acrs); 2532e879892cSThomas Huth 2533e879892cSThomas Huth return kvm_s390_store_status_unloaded(vcpu, addr); 2534e879892cSThomas Huth } 2535e879892cSThomas Huth 2536bc17de7cSEric Farman /* 2537bc17de7cSEric Farman * store additional status at address 2538bc17de7cSEric Farman */ 2539bc17de7cSEric Farman int kvm_s390_store_adtl_status_unloaded(struct kvm_vcpu *vcpu, 2540bc17de7cSEric Farman unsigned long gpa) 2541bc17de7cSEric Farman { 2542bc17de7cSEric Farman /* Only bits 0-53 are used for address formation */ 2543bc17de7cSEric Farman if (!(gpa & ~0x3ff)) 2544bc17de7cSEric Farman return 0; 2545bc17de7cSEric Farman 2546bc17de7cSEric Farman return write_guest_abs(vcpu, gpa & ~0x3ff, 2547bc17de7cSEric Farman (void *)&vcpu->run->s.regs.vrs, 512); 2548bc17de7cSEric Farman } 2549bc17de7cSEric Farman 2550bc17de7cSEric Farman int kvm_s390_vcpu_store_adtl_status(struct kvm_vcpu *vcpu, unsigned long addr) 2551bc17de7cSEric Farman { 2552bc17de7cSEric Farman if (!test_kvm_facility(vcpu->kvm, 129)) 2553bc17de7cSEric Farman return 0; 2554bc17de7cSEric Farman 2555bc17de7cSEric Farman /* 2556bc17de7cSEric Farman * The guest VXRS are in the host VXRs due to the lazy 25579977e886SHendrik Brueckner * copying in vcpu load/put. We can simply call save_fpu_regs() 25589977e886SHendrik Brueckner * to save the current register state because we are in the 25599977e886SHendrik Brueckner * middle of a load/put cycle. 25609977e886SHendrik Brueckner * 25619977e886SHendrik Brueckner * Let's update our copies before we save it into the save area. 2562bc17de7cSEric Farman */ 2563d0164ee2SHendrik Brueckner save_fpu_regs(); 2564bc17de7cSEric Farman 2565bc17de7cSEric Farman return kvm_s390_store_adtl_status_unloaded(vcpu, addr); 2566bc17de7cSEric Farman } 2567bc17de7cSEric Farman 25688ad35755SDavid Hildenbrand static void __disable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 25698ad35755SDavid Hildenbrand { 25708ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu); 25718e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_DISABLE_IBS, vcpu); 25728ad35755SDavid Hildenbrand } 25738ad35755SDavid Hildenbrand 25748ad35755SDavid Hildenbrand static void __disable_ibs_on_all_vcpus(struct kvm *kvm) 25758ad35755SDavid Hildenbrand { 25768ad35755SDavid Hildenbrand unsigned int i; 25778ad35755SDavid Hildenbrand struct kvm_vcpu *vcpu; 25788ad35755SDavid Hildenbrand 25798ad35755SDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 25808ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 25818ad35755SDavid Hildenbrand } 25828ad35755SDavid Hildenbrand } 25838ad35755SDavid Hildenbrand 25848ad35755SDavid Hildenbrand static void __enable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 25858ad35755SDavid Hildenbrand { 25868ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu); 25878e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_ENABLE_IBS, vcpu); 25888ad35755SDavid Hildenbrand } 25898ad35755SDavid Hildenbrand 25906852d7b6SDavid Hildenbrand void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu) 25916852d7b6SDavid Hildenbrand { 25928ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 25938ad35755SDavid Hildenbrand 25948ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 25958ad35755SDavid Hildenbrand return; 25968ad35755SDavid Hildenbrand 25976852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 1); 25988ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 2599433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 26008ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 26018ad35755SDavid Hildenbrand 26028ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 26038ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) 26048ad35755SDavid Hildenbrand started_vcpus++; 26058ad35755SDavid Hildenbrand } 26068ad35755SDavid Hildenbrand 26078ad35755SDavid Hildenbrand if (started_vcpus == 0) { 26088ad35755SDavid Hildenbrand /* we're the only active VCPU -> speed it up */ 26098ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(vcpu); 26108ad35755SDavid Hildenbrand } else if (started_vcpus == 1) { 26118ad35755SDavid Hildenbrand /* 26128ad35755SDavid Hildenbrand * As we are starting a second VCPU, we have to disable 26138ad35755SDavid Hildenbrand * the IBS facility on all VCPUs to remove potentially 26148ad35755SDavid Hildenbrand * oustanding ENABLE requests. 26158ad35755SDavid Hildenbrand */ 26168ad35755SDavid Hildenbrand __disable_ibs_on_all_vcpus(vcpu->kvm); 26178ad35755SDavid Hildenbrand } 26188ad35755SDavid Hildenbrand 2619805de8f4SPeter Zijlstra atomic_andnot(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags); 26208ad35755SDavid Hildenbrand /* 26218ad35755SDavid Hildenbrand * Another VCPU might have used IBS while we were offline. 26228ad35755SDavid Hildenbrand * Let's play safe and flush the VCPU at startup. 26238ad35755SDavid Hildenbrand */ 2624d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 2625433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 26268ad35755SDavid Hildenbrand return; 26276852d7b6SDavid Hildenbrand } 26286852d7b6SDavid Hildenbrand 26296852d7b6SDavid Hildenbrand void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu) 26306852d7b6SDavid Hildenbrand { 26318ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 26328ad35755SDavid Hildenbrand struct kvm_vcpu *started_vcpu = NULL; 26338ad35755SDavid Hildenbrand 26348ad35755SDavid Hildenbrand if (is_vcpu_stopped(vcpu)) 26358ad35755SDavid Hildenbrand return; 26368ad35755SDavid Hildenbrand 26376852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 0); 26388ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 2639433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 26408ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 26418ad35755SDavid Hildenbrand 264232f5ff63SDavid Hildenbrand /* SIGP STOP and SIGP STOP AND STORE STATUS has been fully processed */ 26436cddd432SDavid Hildenbrand kvm_s390_clear_stop_irq(vcpu); 264432f5ff63SDavid Hildenbrand 2645805de8f4SPeter Zijlstra atomic_or(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags); 26468ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 26478ad35755SDavid Hildenbrand 26488ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 26498ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) { 26508ad35755SDavid Hildenbrand started_vcpus++; 26518ad35755SDavid Hildenbrand started_vcpu = vcpu->kvm->vcpus[i]; 26528ad35755SDavid Hildenbrand } 26538ad35755SDavid Hildenbrand } 26548ad35755SDavid Hildenbrand 26558ad35755SDavid Hildenbrand if (started_vcpus == 1) { 26568ad35755SDavid Hildenbrand /* 26578ad35755SDavid Hildenbrand * As we only have one VCPU left, we want to enable the 26588ad35755SDavid Hildenbrand * IBS facility for that VCPU to speed it up. 26598ad35755SDavid Hildenbrand */ 26608ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(started_vcpu); 26618ad35755SDavid Hildenbrand } 26628ad35755SDavid Hildenbrand 2663433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 26648ad35755SDavid Hildenbrand return; 26656852d7b6SDavid Hildenbrand } 26666852d7b6SDavid Hildenbrand 2667d6712df9SCornelia Huck static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 2668d6712df9SCornelia Huck struct kvm_enable_cap *cap) 2669d6712df9SCornelia Huck { 2670d6712df9SCornelia Huck int r; 2671d6712df9SCornelia Huck 2672d6712df9SCornelia Huck if (cap->flags) 2673d6712df9SCornelia Huck return -EINVAL; 2674d6712df9SCornelia Huck 2675d6712df9SCornelia Huck switch (cap->cap) { 2676fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 2677fa6b7fe9SCornelia Huck if (!vcpu->kvm->arch.css_support) { 2678fa6b7fe9SCornelia Huck vcpu->kvm->arch.css_support = 1; 2679c92ea7b9SChristian Borntraeger VM_EVENT(vcpu->kvm, 3, "%s", "ENABLE: CSS support"); 2680fa6b7fe9SCornelia Huck trace_kvm_s390_enable_css(vcpu->kvm); 2681fa6b7fe9SCornelia Huck } 2682fa6b7fe9SCornelia Huck r = 0; 2683fa6b7fe9SCornelia Huck break; 2684d6712df9SCornelia Huck default: 2685d6712df9SCornelia Huck r = -EINVAL; 2686d6712df9SCornelia Huck break; 2687d6712df9SCornelia Huck } 2688d6712df9SCornelia Huck return r; 2689d6712df9SCornelia Huck } 2690d6712df9SCornelia Huck 269141408c28SThomas Huth static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu, 269241408c28SThomas Huth struct kvm_s390_mem_op *mop) 269341408c28SThomas Huth { 269441408c28SThomas Huth void __user *uaddr = (void __user *)mop->buf; 269541408c28SThomas Huth void *tmpbuf = NULL; 269641408c28SThomas Huth int r, srcu_idx; 269741408c28SThomas Huth const u64 supported_flags = KVM_S390_MEMOP_F_INJECT_EXCEPTION 269841408c28SThomas Huth | KVM_S390_MEMOP_F_CHECK_ONLY; 269941408c28SThomas Huth 270041408c28SThomas Huth if (mop->flags & ~supported_flags) 270141408c28SThomas Huth return -EINVAL; 270241408c28SThomas Huth 270341408c28SThomas Huth if (mop->size > MEM_OP_MAX_SIZE) 270441408c28SThomas Huth return -E2BIG; 270541408c28SThomas Huth 270641408c28SThomas Huth if (!(mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY)) { 270741408c28SThomas Huth tmpbuf = vmalloc(mop->size); 270841408c28SThomas Huth if (!tmpbuf) 270941408c28SThomas Huth return -ENOMEM; 271041408c28SThomas Huth } 271141408c28SThomas Huth 271241408c28SThomas Huth srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 271341408c28SThomas Huth 271441408c28SThomas Huth switch (mop->op) { 271541408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_READ: 271641408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 271792c96321SDavid Hildenbrand r = check_gva_range(vcpu, mop->gaddr, mop->ar, 271892c96321SDavid Hildenbrand mop->size, GACC_FETCH); 271941408c28SThomas Huth break; 272041408c28SThomas Huth } 272141408c28SThomas Huth r = read_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 272241408c28SThomas Huth if (r == 0) { 272341408c28SThomas Huth if (copy_to_user(uaddr, tmpbuf, mop->size)) 272441408c28SThomas Huth r = -EFAULT; 272541408c28SThomas Huth } 272641408c28SThomas Huth break; 272741408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_WRITE: 272841408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 272992c96321SDavid Hildenbrand r = check_gva_range(vcpu, mop->gaddr, mop->ar, 273092c96321SDavid Hildenbrand mop->size, GACC_STORE); 273141408c28SThomas Huth break; 273241408c28SThomas Huth } 273341408c28SThomas Huth if (copy_from_user(tmpbuf, uaddr, mop->size)) { 273441408c28SThomas Huth r = -EFAULT; 273541408c28SThomas Huth break; 273641408c28SThomas Huth } 273741408c28SThomas Huth r = write_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 273841408c28SThomas Huth break; 273941408c28SThomas Huth default: 274041408c28SThomas Huth r = -EINVAL; 274141408c28SThomas Huth } 274241408c28SThomas Huth 274341408c28SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, srcu_idx); 274441408c28SThomas Huth 274541408c28SThomas Huth if (r > 0 && (mop->flags & KVM_S390_MEMOP_F_INJECT_EXCEPTION) != 0) 274641408c28SThomas Huth kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm); 274741408c28SThomas Huth 274841408c28SThomas Huth vfree(tmpbuf); 274941408c28SThomas Huth return r; 275041408c28SThomas Huth } 275141408c28SThomas Huth 2752b0c632dbSHeiko Carstens long kvm_arch_vcpu_ioctl(struct file *filp, 2753b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 2754b0c632dbSHeiko Carstens { 2755b0c632dbSHeiko Carstens struct kvm_vcpu *vcpu = filp->private_data; 2756b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 2757800c1065SThomas Huth int idx; 2758bc923cc9SAvi Kivity long r; 2759b0c632dbSHeiko Carstens 276093736624SAvi Kivity switch (ioctl) { 276147b43c52SJens Freimann case KVM_S390_IRQ: { 276247b43c52SJens Freimann struct kvm_s390_irq s390irq; 276347b43c52SJens Freimann 276447b43c52SJens Freimann r = -EFAULT; 276547b43c52SJens Freimann if (copy_from_user(&s390irq, argp, sizeof(s390irq))) 276647b43c52SJens Freimann break; 276747b43c52SJens Freimann r = kvm_s390_inject_vcpu(vcpu, &s390irq); 276847b43c52SJens Freimann break; 276947b43c52SJens Freimann } 277093736624SAvi Kivity case KVM_S390_INTERRUPT: { 2771ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 2772383d0b05SJens Freimann struct kvm_s390_irq s390irq; 2773ba5c1e9bSCarsten Otte 277493736624SAvi Kivity r = -EFAULT; 2775ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 277693736624SAvi Kivity break; 2777383d0b05SJens Freimann if (s390int_to_s390irq(&s390int, &s390irq)) 2778383d0b05SJens Freimann return -EINVAL; 2779383d0b05SJens Freimann r = kvm_s390_inject_vcpu(vcpu, &s390irq); 278093736624SAvi Kivity break; 2781ba5c1e9bSCarsten Otte } 2782b0c632dbSHeiko Carstens case KVM_S390_STORE_STATUS: 2783800c1065SThomas Huth idx = srcu_read_lock(&vcpu->kvm->srcu); 2784bc923cc9SAvi Kivity r = kvm_s390_vcpu_store_status(vcpu, arg); 2785800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, idx); 2786bc923cc9SAvi Kivity break; 2787b0c632dbSHeiko Carstens case KVM_S390_SET_INITIAL_PSW: { 2788b0c632dbSHeiko Carstens psw_t psw; 2789b0c632dbSHeiko Carstens 2790bc923cc9SAvi Kivity r = -EFAULT; 2791b0c632dbSHeiko Carstens if (copy_from_user(&psw, argp, sizeof(psw))) 2792bc923cc9SAvi Kivity break; 2793bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw); 2794bc923cc9SAvi Kivity break; 2795b0c632dbSHeiko Carstens } 2796b0c632dbSHeiko Carstens case KVM_S390_INITIAL_RESET: 2797bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_initial_reset(vcpu); 2798bc923cc9SAvi Kivity break; 279914eebd91SCarsten Otte case KVM_SET_ONE_REG: 280014eebd91SCarsten Otte case KVM_GET_ONE_REG: { 280114eebd91SCarsten Otte struct kvm_one_reg reg; 280214eebd91SCarsten Otte r = -EFAULT; 280314eebd91SCarsten Otte if (copy_from_user(®, argp, sizeof(reg))) 280414eebd91SCarsten Otte break; 280514eebd91SCarsten Otte if (ioctl == KVM_SET_ONE_REG) 280614eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, ®); 280714eebd91SCarsten Otte else 280814eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, ®); 280914eebd91SCarsten Otte break; 281014eebd91SCarsten Otte } 281127e0393fSCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 281227e0393fSCarsten Otte case KVM_S390_UCAS_MAP: { 281327e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 281427e0393fSCarsten Otte 281527e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 281627e0393fSCarsten Otte r = -EFAULT; 281727e0393fSCarsten Otte break; 281827e0393fSCarsten Otte } 281927e0393fSCarsten Otte 282027e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 282127e0393fSCarsten Otte r = -EINVAL; 282227e0393fSCarsten Otte break; 282327e0393fSCarsten Otte } 282427e0393fSCarsten Otte 282527e0393fSCarsten Otte r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr, 282627e0393fSCarsten Otte ucasmap.vcpu_addr, ucasmap.length); 282727e0393fSCarsten Otte break; 282827e0393fSCarsten Otte } 282927e0393fSCarsten Otte case KVM_S390_UCAS_UNMAP: { 283027e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 283127e0393fSCarsten Otte 283227e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 283327e0393fSCarsten Otte r = -EFAULT; 283427e0393fSCarsten Otte break; 283527e0393fSCarsten Otte } 283627e0393fSCarsten Otte 283727e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 283827e0393fSCarsten Otte r = -EINVAL; 283927e0393fSCarsten Otte break; 284027e0393fSCarsten Otte } 284127e0393fSCarsten Otte 284227e0393fSCarsten Otte r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr, 284327e0393fSCarsten Otte ucasmap.length); 284427e0393fSCarsten Otte break; 284527e0393fSCarsten Otte } 284627e0393fSCarsten Otte #endif 2847ccc7910fSCarsten Otte case KVM_S390_VCPU_FAULT: { 2848527e30b4SMartin Schwidefsky r = gmap_fault(vcpu->arch.gmap, arg, 0); 2849ccc7910fSCarsten Otte break; 2850ccc7910fSCarsten Otte } 2851d6712df9SCornelia Huck case KVM_ENABLE_CAP: 2852d6712df9SCornelia Huck { 2853d6712df9SCornelia Huck struct kvm_enable_cap cap; 2854d6712df9SCornelia Huck r = -EFAULT; 2855d6712df9SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 2856d6712df9SCornelia Huck break; 2857d6712df9SCornelia Huck r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 2858d6712df9SCornelia Huck break; 2859d6712df9SCornelia Huck } 286041408c28SThomas Huth case KVM_S390_MEM_OP: { 286141408c28SThomas Huth struct kvm_s390_mem_op mem_op; 286241408c28SThomas Huth 286341408c28SThomas Huth if (copy_from_user(&mem_op, argp, sizeof(mem_op)) == 0) 286441408c28SThomas Huth r = kvm_s390_guest_mem_op(vcpu, &mem_op); 286541408c28SThomas Huth else 286641408c28SThomas Huth r = -EFAULT; 286741408c28SThomas Huth break; 286841408c28SThomas Huth } 2869816c7667SJens Freimann case KVM_S390_SET_IRQ_STATE: { 2870816c7667SJens Freimann struct kvm_s390_irq_state irq_state; 2871816c7667SJens Freimann 2872816c7667SJens Freimann r = -EFAULT; 2873816c7667SJens Freimann if (copy_from_user(&irq_state, argp, sizeof(irq_state))) 2874816c7667SJens Freimann break; 2875816c7667SJens Freimann if (irq_state.len > VCPU_IRQS_MAX_BUF || 2876816c7667SJens Freimann irq_state.len == 0 || 2877816c7667SJens Freimann irq_state.len % sizeof(struct kvm_s390_irq) > 0) { 2878816c7667SJens Freimann r = -EINVAL; 2879816c7667SJens Freimann break; 2880816c7667SJens Freimann } 2881816c7667SJens Freimann r = kvm_s390_set_irq_state(vcpu, 2882816c7667SJens Freimann (void __user *) irq_state.buf, 2883816c7667SJens Freimann irq_state.len); 2884816c7667SJens Freimann break; 2885816c7667SJens Freimann } 2886816c7667SJens Freimann case KVM_S390_GET_IRQ_STATE: { 2887816c7667SJens Freimann struct kvm_s390_irq_state irq_state; 2888816c7667SJens Freimann 2889816c7667SJens Freimann r = -EFAULT; 2890816c7667SJens Freimann if (copy_from_user(&irq_state, argp, sizeof(irq_state))) 2891816c7667SJens Freimann break; 2892816c7667SJens Freimann if (irq_state.len == 0) { 2893816c7667SJens Freimann r = -EINVAL; 2894816c7667SJens Freimann break; 2895816c7667SJens Freimann } 2896816c7667SJens Freimann r = kvm_s390_get_irq_state(vcpu, 2897816c7667SJens Freimann (__u8 __user *) irq_state.buf, 2898816c7667SJens Freimann irq_state.len); 2899816c7667SJens Freimann break; 2900816c7667SJens Freimann } 2901b0c632dbSHeiko Carstens default: 29023e6afcf1SCarsten Otte r = -ENOTTY; 2903b0c632dbSHeiko Carstens } 2904bc923cc9SAvi Kivity return r; 2905b0c632dbSHeiko Carstens } 2906b0c632dbSHeiko Carstens 29075b1c1493SCarsten Otte int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) 29085b1c1493SCarsten Otte { 29095b1c1493SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 29105b1c1493SCarsten Otte if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET) 29115b1c1493SCarsten Otte && (kvm_is_ucontrol(vcpu->kvm))) { 29125b1c1493SCarsten Otte vmf->page = virt_to_page(vcpu->arch.sie_block); 29135b1c1493SCarsten Otte get_page(vmf->page); 29145b1c1493SCarsten Otte return 0; 29155b1c1493SCarsten Otte } 29165b1c1493SCarsten Otte #endif 29175b1c1493SCarsten Otte return VM_FAULT_SIGBUS; 29185b1c1493SCarsten Otte } 29195b1c1493SCarsten Otte 29205587027cSAneesh Kumar K.V int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, 29215587027cSAneesh Kumar K.V unsigned long npages) 2922db3fe4ebSTakuya Yoshikawa { 2923db3fe4ebSTakuya Yoshikawa return 0; 2924db3fe4ebSTakuya Yoshikawa } 2925db3fe4ebSTakuya Yoshikawa 2926b0c632dbSHeiko Carstens /* Section: memory related */ 2927f7784b8eSMarcelo Tosatti int kvm_arch_prepare_memory_region(struct kvm *kvm, 2928f7784b8eSMarcelo Tosatti struct kvm_memory_slot *memslot, 292909170a49SPaolo Bonzini const struct kvm_userspace_memory_region *mem, 29307b6195a9STakuya Yoshikawa enum kvm_mr_change change) 2931b0c632dbSHeiko Carstens { 2932dd2887e7SNick Wang /* A few sanity checks. We can have memory slots which have to be 2933dd2887e7SNick Wang located/ended at a segment boundary (1MB). The memory in userland is 2934dd2887e7SNick Wang ok to be fragmented into various different vmas. It is okay to mmap() 2935dd2887e7SNick Wang and munmap() stuff in this slot after doing this call at any time */ 2936b0c632dbSHeiko Carstens 2937598841caSCarsten Otte if (mem->userspace_addr & 0xffffful) 2938b0c632dbSHeiko Carstens return -EINVAL; 2939b0c632dbSHeiko Carstens 2940598841caSCarsten Otte if (mem->memory_size & 0xffffful) 2941b0c632dbSHeiko Carstens return -EINVAL; 2942b0c632dbSHeiko Carstens 2943a3a92c31SDominik Dingel if (mem->guest_phys_addr + mem->memory_size > kvm->arch.mem_limit) 2944a3a92c31SDominik Dingel return -EINVAL; 2945a3a92c31SDominik Dingel 2946f7784b8eSMarcelo Tosatti return 0; 2947f7784b8eSMarcelo Tosatti } 2948f7784b8eSMarcelo Tosatti 2949f7784b8eSMarcelo Tosatti void kvm_arch_commit_memory_region(struct kvm *kvm, 295009170a49SPaolo Bonzini const struct kvm_userspace_memory_region *mem, 29518482644aSTakuya Yoshikawa const struct kvm_memory_slot *old, 2952f36f3f28SPaolo Bonzini const struct kvm_memory_slot *new, 29538482644aSTakuya Yoshikawa enum kvm_mr_change change) 2954f7784b8eSMarcelo Tosatti { 2955f7850c92SCarsten Otte int rc; 2956f7784b8eSMarcelo Tosatti 29572cef4debSChristian Borntraeger /* If the basics of the memslot do not change, we do not want 29582cef4debSChristian Borntraeger * to update the gmap. Every update causes several unnecessary 29592cef4debSChristian Borntraeger * segment translation exceptions. This is usually handled just 29602cef4debSChristian Borntraeger * fine by the normal fault handler + gmap, but it will also 29612cef4debSChristian Borntraeger * cause faults on the prefix page of running guest CPUs. 29622cef4debSChristian Borntraeger */ 29632cef4debSChristian Borntraeger if (old->userspace_addr == mem->userspace_addr && 29642cef4debSChristian Borntraeger old->base_gfn * PAGE_SIZE == mem->guest_phys_addr && 29652cef4debSChristian Borntraeger old->npages * PAGE_SIZE == mem->memory_size) 29662cef4debSChristian Borntraeger return; 2967598841caSCarsten Otte 2968598841caSCarsten Otte rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr, 2969598841caSCarsten Otte mem->guest_phys_addr, mem->memory_size); 2970598841caSCarsten Otte if (rc) 2971ea2cdd27SDavid Hildenbrand pr_warn("failed to commit memory region\n"); 2972598841caSCarsten Otte return; 2973b0c632dbSHeiko Carstens } 2974b0c632dbSHeiko Carstens 2975b0c632dbSHeiko Carstens static int __init kvm_s390_init(void) 2976b0c632dbSHeiko Carstens { 297707197fd0SDavid Hildenbrand if (!sclp.has_sief2) { 297807197fd0SDavid Hildenbrand pr_info("SIE not available\n"); 297907197fd0SDavid Hildenbrand return -ENODEV; 298007197fd0SDavid Hildenbrand } 298107197fd0SDavid Hildenbrand 29829d8d5786SMichael Mueller return kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); 2983b0c632dbSHeiko Carstens } 2984b0c632dbSHeiko Carstens 2985b0c632dbSHeiko Carstens static void __exit kvm_s390_exit(void) 2986b0c632dbSHeiko Carstens { 2987b0c632dbSHeiko Carstens kvm_exit(); 2988b0c632dbSHeiko Carstens } 2989b0c632dbSHeiko Carstens 2990b0c632dbSHeiko Carstens module_init(kvm_s390_init); 2991b0c632dbSHeiko Carstens module_exit(kvm_s390_exit); 2992566af940SCornelia Huck 2993566af940SCornelia Huck /* 2994566af940SCornelia Huck * Enable autoloading of the kvm module. 2995566af940SCornelia Huck * Note that we add the module alias here instead of virt/kvm/kvm_main.c 2996566af940SCornelia Huck * since x86 takes a different approach. 2997566af940SCornelia Huck */ 2998566af940SCornelia Huck #include <linux/miscdevice.h> 2999566af940SCornelia Huck MODULE_ALIAS_MISCDEV(KVM_MINOR); 3000566af940SCornelia Huck MODULE_ALIAS("devname:kvm"); 3001