1d809aa23SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 2b0c632dbSHeiko Carstens /* 3bb64da9aSChristian Borntraeger * hosting IBM Z kernel virtual machines (s390x) 4b0c632dbSHeiko Carstens * 5a37cb07aSChristian Borntraeger * Copyright IBM Corp. 2008, 2018 6b0c632dbSHeiko Carstens * 7b0c632dbSHeiko Carstens * Author(s): Carsten Otte <cotte@de.ibm.com> 8b0c632dbSHeiko Carstens * Christian Borntraeger <borntraeger@de.ibm.com> 9b0c632dbSHeiko Carstens * Heiko Carstens <heiko.carstens@de.ibm.com> 10628eb9b8SChristian Ehrhardt * Christian Ehrhardt <ehrhardt@de.ibm.com> 1115f36ebdSJason J. Herne * Jason J. Herne <jjherne@us.ibm.com> 12b0c632dbSHeiko Carstens */ 13b0c632dbSHeiko Carstens 14b0c632dbSHeiko Carstens #include <linux/compiler.h> 15b0c632dbSHeiko Carstens #include <linux/err.h> 16b0c632dbSHeiko Carstens #include <linux/fs.h> 17ca872302SChristian Borntraeger #include <linux/hrtimer.h> 18b0c632dbSHeiko Carstens #include <linux/init.h> 19b0c632dbSHeiko Carstens #include <linux/kvm.h> 20b0c632dbSHeiko Carstens #include <linux/kvm_host.h> 21b2d73b2aSMartin Schwidefsky #include <linux/mman.h> 22b0c632dbSHeiko Carstens #include <linux/module.h> 23d3217967SPaul Gortmaker #include <linux/moduleparam.h> 24a374e892STony Krowiak #include <linux/random.h> 25b0c632dbSHeiko Carstens #include <linux/slab.h> 26ba5c1e9bSCarsten Otte #include <linux/timer.h> 2741408c28SThomas Huth #include <linux/vmalloc.h> 2815c9705fSDavid Hildenbrand #include <linux/bitmap.h> 29174cd4b1SIngo Molnar #include <linux/sched/signal.h> 30190df4a2SClaudio Imbrenda #include <linux/string.h> 31174cd4b1SIngo Molnar 32cbb870c8SHeiko Carstens #include <asm/asm-offsets.h> 33b0c632dbSHeiko Carstens #include <asm/lowcore.h> 34fd5ada04SMartin Schwidefsky #include <asm/stp.h> 35b0c632dbSHeiko Carstens #include <asm/pgtable.h> 361e133ab2SMartin Schwidefsky #include <asm/gmap.h> 37f5daba1dSHeiko Carstens #include <asm/nmi.h> 38a0616cdeSDavid Howells #include <asm/switch_to.h> 396d3da241SJens Freimann #include <asm/isc.h> 401526bf9cSChristian Borntraeger #include <asm/sclp.h> 410a763c78SDavid Hildenbrand #include <asm/cpacf.h> 42221bb8a4SLinus Torvalds #include <asm/timex.h> 438f2abe6aSChristian Borntraeger #include "kvm-s390.h" 44b0c632dbSHeiko Carstens #include "gaccess.h" 45b0c632dbSHeiko Carstens 46ea2cdd27SDavid Hildenbrand #define KMSG_COMPONENT "kvm-s390" 47ea2cdd27SDavid Hildenbrand #undef pr_fmt 48ea2cdd27SDavid Hildenbrand #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 49ea2cdd27SDavid Hildenbrand 505786fffaSCornelia Huck #define CREATE_TRACE_POINTS 515786fffaSCornelia Huck #include "trace.h" 52ade38c31SCornelia Huck #include "trace-s390.h" 535786fffaSCornelia Huck 5441408c28SThomas Huth #define MEM_OP_MAX_SIZE 65536 /* Maximum transfer size for KVM_S390_MEM_OP */ 55816c7667SJens Freimann #define LOCAL_IRQS 32 56816c7667SJens Freimann #define VCPU_IRQS_MAX_BUF (sizeof(struct kvm_s390_irq) * \ 57816c7667SJens Freimann (KVM_MAX_VCPUS + LOCAL_IRQS)) 5841408c28SThomas Huth 59b0c632dbSHeiko Carstens #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU 60b0c632dbSHeiko Carstens 61b0c632dbSHeiko Carstens struct kvm_stats_debugfs_item debugfs_entries[] = { 62b0c632dbSHeiko Carstens { "userspace_handled", VCPU_STAT(exit_userspace) }, 630eaeafa1SChristian Borntraeger { "exit_null", VCPU_STAT(exit_null) }, 648f2abe6aSChristian Borntraeger { "exit_validity", VCPU_STAT(exit_validity) }, 658f2abe6aSChristian Borntraeger { "exit_stop_request", VCPU_STAT(exit_stop_request) }, 668f2abe6aSChristian Borntraeger { "exit_external_request", VCPU_STAT(exit_external_request) }, 678f2abe6aSChristian Borntraeger { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) }, 68ba5c1e9bSCarsten Otte { "exit_instruction", VCPU_STAT(exit_instruction) }, 699ec6de19SAlexander Yarygin { "exit_pei", VCPU_STAT(exit_pei) }, 70ba5c1e9bSCarsten Otte { "exit_program_interruption", VCPU_STAT(exit_program_interruption) }, 71ba5c1e9bSCarsten Otte { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) }, 72a011eeb2SJanosch Frank { "exit_operation_exception", VCPU_STAT(exit_operation_exception) }, 73f7819512SPaolo Bonzini { "halt_successful_poll", VCPU_STAT(halt_successful_poll) }, 7462bea5bfSPaolo Bonzini { "halt_attempted_poll", VCPU_STAT(halt_attempted_poll) }, 753491caf2SChristian Borntraeger { "halt_poll_invalid", VCPU_STAT(halt_poll_invalid) }, 76ce2e4f0bSDavid Hildenbrand { "halt_wakeup", VCPU_STAT(halt_wakeup) }, 77f5e10b09SChristian Borntraeger { "instruction_lctlg", VCPU_STAT(instruction_lctlg) }, 78ba5c1e9bSCarsten Otte { "instruction_lctl", VCPU_STAT(instruction_lctl) }, 79aba07508SDavid Hildenbrand { "instruction_stctl", VCPU_STAT(instruction_stctl) }, 80aba07508SDavid Hildenbrand { "instruction_stctg", VCPU_STAT(instruction_stctg) }, 81ba5c1e9bSCarsten Otte { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) }, 827697e71fSChristian Ehrhardt { "deliver_external_call", VCPU_STAT(deliver_external_call) }, 83ba5c1e9bSCarsten Otte { "deliver_service_signal", VCPU_STAT(deliver_service_signal) }, 84ba5c1e9bSCarsten Otte { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) }, 85ba5c1e9bSCarsten Otte { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) }, 86ba5c1e9bSCarsten Otte { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) }, 87ba5c1e9bSCarsten Otte { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) }, 88ba5c1e9bSCarsten Otte { "deliver_program_interruption", VCPU_STAT(deliver_program_int) }, 89ba5c1e9bSCarsten Otte { "exit_wait_state", VCPU_STAT(exit_wait_state) }, 90a37cb07aSChristian Borntraeger { "instruction_epsw", VCPU_STAT(instruction_epsw) }, 91a37cb07aSChristian Borntraeger { "instruction_gs", VCPU_STAT(instruction_gs) }, 92a37cb07aSChristian Borntraeger { "instruction_io_other", VCPU_STAT(instruction_io_other) }, 93a37cb07aSChristian Borntraeger { "instruction_lpsw", VCPU_STAT(instruction_lpsw) }, 94a37cb07aSChristian Borntraeger { "instruction_lpswe", VCPU_STAT(instruction_lpswe) }, 9569d0d3a3SChristian Borntraeger { "instruction_pfmf", VCPU_STAT(instruction_pfmf) }, 96a37cb07aSChristian Borntraeger { "instruction_ptff", VCPU_STAT(instruction_ptff) }, 97453423dcSChristian Borntraeger { "instruction_stidp", VCPU_STAT(instruction_stidp) }, 98a37cb07aSChristian Borntraeger { "instruction_sck", VCPU_STAT(instruction_sck) }, 99a37cb07aSChristian Borntraeger { "instruction_sckpf", VCPU_STAT(instruction_sckpf) }, 100453423dcSChristian Borntraeger { "instruction_spx", VCPU_STAT(instruction_spx) }, 101453423dcSChristian Borntraeger { "instruction_stpx", VCPU_STAT(instruction_stpx) }, 102453423dcSChristian Borntraeger { "instruction_stap", VCPU_STAT(instruction_stap) }, 103a37cb07aSChristian Borntraeger { "instruction_iske", VCPU_STAT(instruction_iske) }, 104a37cb07aSChristian Borntraeger { "instruction_ri", VCPU_STAT(instruction_ri) }, 105a37cb07aSChristian Borntraeger { "instruction_rrbe", VCPU_STAT(instruction_rrbe) }, 106a37cb07aSChristian Borntraeger { "instruction_sske", VCPU_STAT(instruction_sske) }, 1078a242234SHeiko Carstens { "instruction_ipte_interlock", VCPU_STAT(instruction_ipte_interlock) }, 108b31288faSKonstantin Weitz { "instruction_essa", VCPU_STAT(instruction_essa) }, 109453423dcSChristian Borntraeger { "instruction_stsi", VCPU_STAT(instruction_stsi) }, 110453423dcSChristian Borntraeger { "instruction_stfl", VCPU_STAT(instruction_stfl) }, 111a37cb07aSChristian Borntraeger { "instruction_tb", VCPU_STAT(instruction_tb) }, 112a37cb07aSChristian Borntraeger { "instruction_tpi", VCPU_STAT(instruction_tpi) }, 113bb25b9baSChristian Borntraeger { "instruction_tprot", VCPU_STAT(instruction_tprot) }, 114a37cb07aSChristian Borntraeger { "instruction_tsch", VCPU_STAT(instruction_tsch) }, 11595ca2cb5SJanosch Frank { "instruction_sthyi", VCPU_STAT(instruction_sthyi) }, 116a3508fbeSDavid Hildenbrand { "instruction_sie", VCPU_STAT(instruction_sie) }, 1175288fbf0SChristian Borntraeger { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) }, 118bd59d3a4SCornelia Huck { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) }, 1197697e71fSChristian Ehrhardt { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) }, 1205288fbf0SChristian Borntraeger { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) }, 12142cb0c9fSDavid Hildenbrand { "instruction_sigp_cond_emergency", VCPU_STAT(instruction_sigp_cond_emergency) }, 12242cb0c9fSDavid Hildenbrand { "instruction_sigp_start", VCPU_STAT(instruction_sigp_start) }, 1235288fbf0SChristian Borntraeger { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) }, 12442cb0c9fSDavid Hildenbrand { "instruction_sigp_stop_store_status", VCPU_STAT(instruction_sigp_stop_store_status) }, 12542cb0c9fSDavid Hildenbrand { "instruction_sigp_store_status", VCPU_STAT(instruction_sigp_store_status) }, 126cd7b4b61SEric Farman { "instruction_sigp_store_adtl_status", VCPU_STAT(instruction_sigp_store_adtl_status) }, 1275288fbf0SChristian Borntraeger { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) }, 1285288fbf0SChristian Borntraeger { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) }, 1295288fbf0SChristian Borntraeger { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) }, 13042cb0c9fSDavid Hildenbrand { "instruction_sigp_cpu_reset", VCPU_STAT(instruction_sigp_cpu_reset) }, 13142cb0c9fSDavid Hildenbrand { "instruction_sigp_init_cpu_reset", VCPU_STAT(instruction_sigp_init_cpu_reset) }, 13242cb0c9fSDavid Hildenbrand { "instruction_sigp_unknown", VCPU_STAT(instruction_sigp_unknown) }, 133866c138cSChristian Borntraeger { "instruction_diag_10", VCPU_STAT(diagnose_10) }, 134866c138cSChristian Borntraeger { "instruction_diag_44", VCPU_STAT(diagnose_44) }, 135866c138cSChristian Borntraeger { "instruction_diag_9c", VCPU_STAT(diagnose_9c) }, 136866c138cSChristian Borntraeger { "instruction_diag_258", VCPU_STAT(diagnose_258) }, 137866c138cSChristian Borntraeger { "instruction_diag_308", VCPU_STAT(diagnose_308) }, 138866c138cSChristian Borntraeger { "instruction_diag_500", VCPU_STAT(diagnose_500) }, 139a37cb07aSChristian Borntraeger { "instruction_diag_other", VCPU_STAT(diagnose_other) }, 140b0c632dbSHeiko Carstens { NULL } 141b0c632dbSHeiko Carstens }; 142b0c632dbSHeiko Carstens 1438fa1696eSCollin L. Walling struct kvm_s390_tod_clock_ext { 1448fa1696eSCollin L. Walling __u8 epoch_idx; 1458fa1696eSCollin L. Walling __u64 tod; 1468fa1696eSCollin L. Walling __u8 reserved[7]; 1478fa1696eSCollin L. Walling } __packed; 1488fa1696eSCollin L. Walling 149a411edf1SDavid Hildenbrand /* allow nested virtualization in KVM (if enabled by user space) */ 150a411edf1SDavid Hildenbrand static int nested; 151a411edf1SDavid Hildenbrand module_param(nested, int, S_IRUGO); 152a411edf1SDavid Hildenbrand MODULE_PARM_DESC(nested, "Nested virtualization support"); 153a411edf1SDavid Hildenbrand 1549d8d5786SMichael Mueller /* upper facilities limit for kvm */ 155f6c1d359SHeiko Carstens unsigned long kvm_s390_fac_list_mask[16] = { FACILITIES_KVM }; 156b0c632dbSHeiko Carstens 1579d8d5786SMichael Mueller unsigned long kvm_s390_fac_list_mask_size(void) 15878c4b59fSMichael Mueller { 1599d8d5786SMichael Mueller BUILD_BUG_ON(ARRAY_SIZE(kvm_s390_fac_list_mask) > S390_ARCH_FAC_MASK_SIZE_U64); 1609d8d5786SMichael Mueller return ARRAY_SIZE(kvm_s390_fac_list_mask); 16178c4b59fSMichael Mueller } 16278c4b59fSMichael Mueller 16315c9705fSDavid Hildenbrand /* available cpu features supported by kvm */ 16415c9705fSDavid Hildenbrand static DECLARE_BITMAP(kvm_s390_available_cpu_feat, KVM_S390_VM_CPU_FEAT_NR_BITS); 1650a763c78SDavid Hildenbrand /* available subfunctions indicated via query / "test bit" */ 1660a763c78SDavid Hildenbrand static struct kvm_s390_vm_cpu_subfunc kvm_s390_available_subfunc; 16715c9705fSDavid Hildenbrand 1689d8d5786SMichael Mueller static struct gmap_notifier gmap_notifier; 169a3508fbeSDavid Hildenbrand static struct gmap_notifier vsie_gmap_notifier; 17078f26131SChristian Borntraeger debug_info_t *kvm_s390_dbf; 1719d8d5786SMichael Mueller 172b0c632dbSHeiko Carstens /* Section: not file related */ 17313a34e06SRadim Krčmář int kvm_arch_hardware_enable(void) 174b0c632dbSHeiko Carstens { 175b0c632dbSHeiko Carstens /* every s390 is virtualization enabled ;-) */ 17610474ae8SAlexander Graf return 0; 177b0c632dbSHeiko Carstens } 178b0c632dbSHeiko Carstens 179414d3b07SMartin Schwidefsky static void kvm_gmap_notifier(struct gmap *gmap, unsigned long start, 180414d3b07SMartin Schwidefsky unsigned long end); 1812c70fe44SChristian Borntraeger 182fdf03650SFan Zhang /* 183fdf03650SFan Zhang * This callback is executed during stop_machine(). All CPUs are therefore 184fdf03650SFan Zhang * temporarily stopped. In order not to change guest behavior, we have to 185fdf03650SFan Zhang * disable preemption whenever we touch the epoch of kvm and the VCPUs, 186fdf03650SFan Zhang * so a CPU won't be stopped while calculating with the epoch. 187fdf03650SFan Zhang */ 188fdf03650SFan Zhang static int kvm_clock_sync(struct notifier_block *notifier, unsigned long val, 189fdf03650SFan Zhang void *v) 190fdf03650SFan Zhang { 191fdf03650SFan Zhang struct kvm *kvm; 192fdf03650SFan Zhang struct kvm_vcpu *vcpu; 193fdf03650SFan Zhang int i; 194fdf03650SFan Zhang unsigned long long *delta = v; 195fdf03650SFan Zhang 196fdf03650SFan Zhang list_for_each_entry(kvm, &vm_list, vm_list) { 197fdf03650SFan Zhang kvm->arch.epoch -= *delta; 198fdf03650SFan Zhang kvm_for_each_vcpu(i, vcpu, kvm) { 199fdf03650SFan Zhang vcpu->arch.sie_block->epoch -= *delta; 200db0758b2SDavid Hildenbrand if (vcpu->arch.cputm_enabled) 201db0758b2SDavid Hildenbrand vcpu->arch.cputm_start += *delta; 20291473b48SDavid Hildenbrand if (vcpu->arch.vsie_block) 20391473b48SDavid Hildenbrand vcpu->arch.vsie_block->epoch -= *delta; 204fdf03650SFan Zhang } 205fdf03650SFan Zhang } 206fdf03650SFan Zhang return NOTIFY_OK; 207fdf03650SFan Zhang } 208fdf03650SFan Zhang 209fdf03650SFan Zhang static struct notifier_block kvm_clock_notifier = { 210fdf03650SFan Zhang .notifier_call = kvm_clock_sync, 211fdf03650SFan Zhang }; 212fdf03650SFan Zhang 213b0c632dbSHeiko Carstens int kvm_arch_hardware_setup(void) 214b0c632dbSHeiko Carstens { 2152c70fe44SChristian Borntraeger gmap_notifier.notifier_call = kvm_gmap_notifier; 216b2d73b2aSMartin Schwidefsky gmap_register_pte_notifier(&gmap_notifier); 217a3508fbeSDavid Hildenbrand vsie_gmap_notifier.notifier_call = kvm_s390_vsie_gmap_notifier; 218a3508fbeSDavid Hildenbrand gmap_register_pte_notifier(&vsie_gmap_notifier); 219fdf03650SFan Zhang atomic_notifier_chain_register(&s390_epoch_delta_notifier, 220fdf03650SFan Zhang &kvm_clock_notifier); 221b0c632dbSHeiko Carstens return 0; 222b0c632dbSHeiko Carstens } 223b0c632dbSHeiko Carstens 224b0c632dbSHeiko Carstens void kvm_arch_hardware_unsetup(void) 225b0c632dbSHeiko Carstens { 226b2d73b2aSMartin Schwidefsky gmap_unregister_pte_notifier(&gmap_notifier); 227a3508fbeSDavid Hildenbrand gmap_unregister_pte_notifier(&vsie_gmap_notifier); 228fdf03650SFan Zhang atomic_notifier_chain_unregister(&s390_epoch_delta_notifier, 229fdf03650SFan Zhang &kvm_clock_notifier); 230b0c632dbSHeiko Carstens } 231b0c632dbSHeiko Carstens 23222be5a13SDavid Hildenbrand static void allow_cpu_feat(unsigned long nr) 23322be5a13SDavid Hildenbrand { 23422be5a13SDavid Hildenbrand set_bit_inv(nr, kvm_s390_available_cpu_feat); 23522be5a13SDavid Hildenbrand } 23622be5a13SDavid Hildenbrand 2370a763c78SDavid Hildenbrand static inline int plo_test_bit(unsigned char nr) 2380a763c78SDavid Hildenbrand { 2390a763c78SDavid Hildenbrand register unsigned long r0 asm("0") = (unsigned long) nr | 0x100; 240d051ae53SHeiko Carstens int cc; 2410a763c78SDavid Hildenbrand 2420a763c78SDavid Hildenbrand asm volatile( 2430a763c78SDavid Hildenbrand /* Parameter registers are ignored for "test bit" */ 2440a763c78SDavid Hildenbrand " plo 0,0,0,0(0)\n" 2450a763c78SDavid Hildenbrand " ipm %0\n" 2460a763c78SDavid Hildenbrand " srl %0,28\n" 2470a763c78SDavid Hildenbrand : "=d" (cc) 2480a763c78SDavid Hildenbrand : "d" (r0) 2490a763c78SDavid Hildenbrand : "cc"); 2500a763c78SDavid Hildenbrand return cc == 0; 2510a763c78SDavid Hildenbrand } 2520a763c78SDavid Hildenbrand 25322be5a13SDavid Hildenbrand static void kvm_s390_cpu_feat_init(void) 25422be5a13SDavid Hildenbrand { 2550a763c78SDavid Hildenbrand int i; 2560a763c78SDavid Hildenbrand 2570a763c78SDavid Hildenbrand for (i = 0; i < 256; ++i) { 2580a763c78SDavid Hildenbrand if (plo_test_bit(i)) 2590a763c78SDavid Hildenbrand kvm_s390_available_subfunc.plo[i >> 3] |= 0x80 >> (i & 7); 2600a763c78SDavid Hildenbrand } 2610a763c78SDavid Hildenbrand 2620a763c78SDavid Hildenbrand if (test_facility(28)) /* TOD-clock steering */ 263221bb8a4SLinus Torvalds ptff(kvm_s390_available_subfunc.ptff, 264221bb8a4SLinus Torvalds sizeof(kvm_s390_available_subfunc.ptff), 265221bb8a4SLinus Torvalds PTFF_QAF); 2660a763c78SDavid Hildenbrand 2670a763c78SDavid Hildenbrand if (test_facility(17)) { /* MSA */ 26869c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMAC, (cpacf_mask_t *) 26969c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmac); 27069c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMC, (cpacf_mask_t *) 27169c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmc); 27269c0e360SMartin Schwidefsky __cpacf_query(CPACF_KM, (cpacf_mask_t *) 27369c0e360SMartin Schwidefsky kvm_s390_available_subfunc.km); 27469c0e360SMartin Schwidefsky __cpacf_query(CPACF_KIMD, (cpacf_mask_t *) 27569c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kimd); 27669c0e360SMartin Schwidefsky __cpacf_query(CPACF_KLMD, (cpacf_mask_t *) 27769c0e360SMartin Schwidefsky kvm_s390_available_subfunc.klmd); 2780a763c78SDavid Hildenbrand } 2790a763c78SDavid Hildenbrand if (test_facility(76)) /* MSA3 */ 28069c0e360SMartin Schwidefsky __cpacf_query(CPACF_PCKMO, (cpacf_mask_t *) 28169c0e360SMartin Schwidefsky kvm_s390_available_subfunc.pckmo); 2820a763c78SDavid Hildenbrand if (test_facility(77)) { /* MSA4 */ 28369c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMCTR, (cpacf_mask_t *) 28469c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmctr); 28569c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMF, (cpacf_mask_t *) 28669c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmf); 28769c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMO, (cpacf_mask_t *) 28869c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmo); 28969c0e360SMartin Schwidefsky __cpacf_query(CPACF_PCC, (cpacf_mask_t *) 29069c0e360SMartin Schwidefsky kvm_s390_available_subfunc.pcc); 2910a763c78SDavid Hildenbrand } 2920a763c78SDavid Hildenbrand if (test_facility(57)) /* MSA5 */ 293985a9d20SHarald Freudenberger __cpacf_query(CPACF_PRNO, (cpacf_mask_t *) 29469c0e360SMartin Schwidefsky kvm_s390_available_subfunc.ppno); 2950a763c78SDavid Hildenbrand 296e000b8e0SJason J. Herne if (test_facility(146)) /* MSA8 */ 297e000b8e0SJason J. Herne __cpacf_query(CPACF_KMA, (cpacf_mask_t *) 298e000b8e0SJason J. Herne kvm_s390_available_subfunc.kma); 299e000b8e0SJason J. Herne 30022be5a13SDavid Hildenbrand if (MACHINE_HAS_ESOP) 30122be5a13SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_ESOP); 302a3508fbeSDavid Hildenbrand /* 303a3508fbeSDavid Hildenbrand * We need SIE support, ESOP (PROT_READ protection for gmap_shadow), 304a3508fbeSDavid Hildenbrand * 64bit SCAO (SCA passthrough) and IDTE (for gmap_shadow unshadowing). 305a3508fbeSDavid Hildenbrand */ 306a3508fbeSDavid Hildenbrand if (!sclp.has_sief2 || !MACHINE_HAS_ESOP || !sclp.has_64bscao || 307a411edf1SDavid Hildenbrand !test_facility(3) || !nested) 308a3508fbeSDavid Hildenbrand return; 309a3508fbeSDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_SIEF2); 31019c439b5SDavid Hildenbrand if (sclp.has_64bscao) 31119c439b5SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_64BSCAO); 3120615a326SDavid Hildenbrand if (sclp.has_siif) 3130615a326SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_SIIF); 31477d18f6dSDavid Hildenbrand if (sclp.has_gpere) 31577d18f6dSDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_GPERE); 316a1b7b9b2SDavid Hildenbrand if (sclp.has_gsls) 317a1b7b9b2SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_GSLS); 3185630a8e8SDavid Hildenbrand if (sclp.has_ib) 3195630a8e8SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_IB); 32013ee3f67SDavid Hildenbrand if (sclp.has_cei) 32113ee3f67SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_CEI); 3227fd7f39dSDavid Hildenbrand if (sclp.has_ibs) 3237fd7f39dSDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_IBS); 324730cd632SFarhan Ali if (sclp.has_kss) 325730cd632SFarhan Ali allow_cpu_feat(KVM_S390_VM_CPU_FEAT_KSS); 3265d3876a8SDavid Hildenbrand /* 3275d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_SKEY: Wrong shadow of PTE.I bits will make 3285d3876a8SDavid Hildenbrand * all skey handling functions read/set the skey from the PGSTE 3295d3876a8SDavid Hildenbrand * instead of the real storage key. 3305d3876a8SDavid Hildenbrand * 3315d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_CMMA: Wrong shadow of PTE.I bits will make 3325d3876a8SDavid Hildenbrand * pages being detected as preserved although they are resident. 3335d3876a8SDavid Hildenbrand * 3345d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_PFMFI: Wrong shadow of PTE.I bits will 3355d3876a8SDavid Hildenbrand * have the same effect as for KVM_S390_VM_CPU_FEAT_SKEY. 3365d3876a8SDavid Hildenbrand * 3375d3876a8SDavid Hildenbrand * For KVM_S390_VM_CPU_FEAT_SKEY, KVM_S390_VM_CPU_FEAT_CMMA and 3385d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_PFMFI, all PTE.I and PGSTE bits have to be 3395d3876a8SDavid Hildenbrand * correctly shadowed. We can do that for the PGSTE but not for PTE.I. 3405d3876a8SDavid Hildenbrand * 3415d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_SIGPIF: Wrong SCB addresses in the SCA. We 3425d3876a8SDavid Hildenbrand * cannot easily shadow the SCA because of the ipte lock. 3435d3876a8SDavid Hildenbrand */ 34422be5a13SDavid Hildenbrand } 34522be5a13SDavid Hildenbrand 346b0c632dbSHeiko Carstens int kvm_arch_init(void *opaque) 347b0c632dbSHeiko Carstens { 34878f26131SChristian Borntraeger kvm_s390_dbf = debug_register("kvm-trace", 32, 1, 7 * sizeof(long)); 34978f26131SChristian Borntraeger if (!kvm_s390_dbf) 35078f26131SChristian Borntraeger return -ENOMEM; 35178f26131SChristian Borntraeger 35278f26131SChristian Borntraeger if (debug_register_view(kvm_s390_dbf, &debug_sprintf_view)) { 35378f26131SChristian Borntraeger debug_unregister(kvm_s390_dbf); 35478f26131SChristian Borntraeger return -ENOMEM; 35578f26131SChristian Borntraeger } 35678f26131SChristian Borntraeger 35722be5a13SDavid Hildenbrand kvm_s390_cpu_feat_init(); 35822be5a13SDavid Hildenbrand 35984877d93SCornelia Huck /* Register floating interrupt controller interface. */ 36084877d93SCornelia Huck return kvm_register_device_ops(&kvm_flic_ops, KVM_DEV_TYPE_FLIC); 361b0c632dbSHeiko Carstens } 362b0c632dbSHeiko Carstens 36378f26131SChristian Borntraeger void kvm_arch_exit(void) 36478f26131SChristian Borntraeger { 36578f26131SChristian Borntraeger debug_unregister(kvm_s390_dbf); 36678f26131SChristian Borntraeger } 36778f26131SChristian Borntraeger 368b0c632dbSHeiko Carstens /* Section: device related */ 369b0c632dbSHeiko Carstens long kvm_arch_dev_ioctl(struct file *filp, 370b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 371b0c632dbSHeiko Carstens { 372b0c632dbSHeiko Carstens if (ioctl == KVM_S390_ENABLE_SIE) 373b0c632dbSHeiko Carstens return s390_enable_sie(); 374b0c632dbSHeiko Carstens return -EINVAL; 375b0c632dbSHeiko Carstens } 376b0c632dbSHeiko Carstens 377784aa3d7SAlexander Graf int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) 378b0c632dbSHeiko Carstens { 379d7b0b5ebSCarsten Otte int r; 380d7b0b5ebSCarsten Otte 3812bd0ac4eSCarsten Otte switch (ext) { 382d7b0b5ebSCarsten Otte case KVM_CAP_S390_PSW: 383b6cf8788SChristian Borntraeger case KVM_CAP_S390_GMAP: 38452e16b18SChristian Borntraeger case KVM_CAP_SYNC_MMU: 3851efd0f59SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 3861efd0f59SCarsten Otte case KVM_CAP_S390_UCONTROL: 3871efd0f59SCarsten Otte #endif 3883c038e6bSDominik Dingel case KVM_CAP_ASYNC_PF: 38960b413c9SChristian Borntraeger case KVM_CAP_SYNC_REGS: 39014eebd91SCarsten Otte case KVM_CAP_ONE_REG: 391d6712df9SCornelia Huck case KVM_CAP_ENABLE_CAP: 392fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 39310ccaa1eSCornelia Huck case KVM_CAP_IOEVENTFD: 394c05c4186SJens Freimann case KVM_CAP_DEVICE_CTRL: 395d938dc55SCornelia Huck case KVM_CAP_ENABLE_CAP_VM: 39678599d90SCornelia Huck case KVM_CAP_S390_IRQCHIP: 397f2061656SDominik Dingel case KVM_CAP_VM_ATTRIBUTES: 3986352e4d2SDavid Hildenbrand case KVM_CAP_MP_STATE: 399460df4c1SPaolo Bonzini case KVM_CAP_IMMEDIATE_EXIT: 40047b43c52SJens Freimann case KVM_CAP_S390_INJECT_IRQ: 4012444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 402e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 40330ee2a98SJason J. Herne case KVM_CAP_S390_SKEYS: 404816c7667SJens Freimann case KVM_CAP_S390_IRQ_STATE: 4056502a34cSDavid Hildenbrand case KVM_CAP_S390_USER_INSTR0: 4064036e387SClaudio Imbrenda case KVM_CAP_S390_CMMA_MIGRATION: 40747a4693eSYi Min Zhao case KVM_CAP_S390_AIS: 408da9a1446SChristian Borntraeger case KVM_CAP_S390_AIS_MIGRATION: 409d7b0b5ebSCarsten Otte r = 1; 410d7b0b5ebSCarsten Otte break; 41141408c28SThomas Huth case KVM_CAP_S390_MEM_OP: 41241408c28SThomas Huth r = MEM_OP_MAX_SIZE; 41341408c28SThomas Huth break; 414e726b1bdSChristian Borntraeger case KVM_CAP_NR_VCPUS: 415e726b1bdSChristian Borntraeger case KVM_CAP_MAX_VCPUS: 41676a6dd72SDavid Hildenbrand r = KVM_S390_BSCA_CPU_SLOTS; 417a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) 418a6940674SDavid Hildenbrand r = KVM_MAX_VCPUS; 419a6940674SDavid Hildenbrand else if (sclp.has_esca && sclp.has_64bscao) 42076a6dd72SDavid Hildenbrand r = KVM_S390_ESCA_CPU_SLOTS; 421e726b1bdSChristian Borntraeger break; 422e1e2e605SNick Wang case KVM_CAP_NR_MEMSLOTS: 423e1e2e605SNick Wang r = KVM_USER_MEM_SLOTS; 424e1e2e605SNick Wang break; 4251526bf9cSChristian Borntraeger case KVM_CAP_S390_COW: 426abf09bedSMartin Schwidefsky r = MACHINE_HAS_ESOP; 4271526bf9cSChristian Borntraeger break; 42868c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 42968c55750SEric Farman r = MACHINE_HAS_VX; 43068c55750SEric Farman break; 431c6e5f166SFan Zhang case KVM_CAP_S390_RI: 432c6e5f166SFan Zhang r = test_facility(64); 433c6e5f166SFan Zhang break; 4344e0b1ab7SFan Zhang case KVM_CAP_S390_GS: 4354e0b1ab7SFan Zhang r = test_facility(133); 4364e0b1ab7SFan Zhang break; 43735b3fde6SChristian Borntraeger case KVM_CAP_S390_BPB: 43835b3fde6SChristian Borntraeger r = test_facility(82); 43935b3fde6SChristian Borntraeger break; 4402bd0ac4eSCarsten Otte default: 441d7b0b5ebSCarsten Otte r = 0; 442b0c632dbSHeiko Carstens } 443d7b0b5ebSCarsten Otte return r; 4442bd0ac4eSCarsten Otte } 445b0c632dbSHeiko Carstens 44615f36ebdSJason J. Herne static void kvm_s390_sync_dirty_log(struct kvm *kvm, 44715f36ebdSJason J. Herne struct kvm_memory_slot *memslot) 44815f36ebdSJason J. Herne { 44915f36ebdSJason J. Herne gfn_t cur_gfn, last_gfn; 45015f36ebdSJason J. Herne unsigned long address; 45115f36ebdSJason J. Herne struct gmap *gmap = kvm->arch.gmap; 45215f36ebdSJason J. Herne 45315f36ebdSJason J. Herne /* Loop over all guest pages */ 45415f36ebdSJason J. Herne last_gfn = memslot->base_gfn + memslot->npages; 45515f36ebdSJason J. Herne for (cur_gfn = memslot->base_gfn; cur_gfn <= last_gfn; cur_gfn++) { 45615f36ebdSJason J. Herne address = gfn_to_hva_memslot(memslot, cur_gfn); 45715f36ebdSJason J. Herne 4581e133ab2SMartin Schwidefsky if (test_and_clear_guest_dirty(gmap->mm, address)) 45915f36ebdSJason J. Herne mark_page_dirty(kvm, cur_gfn); 4601763f8d0SChristian Borntraeger if (fatal_signal_pending(current)) 4611763f8d0SChristian Borntraeger return; 46270c88a00SChristian Borntraeger cond_resched(); 46315f36ebdSJason J. Herne } 46415f36ebdSJason J. Herne } 46515f36ebdSJason J. Herne 466b0c632dbSHeiko Carstens /* Section: vm related */ 467a6e2f683SEugene (jno) Dvurechenski static void sca_del_vcpu(struct kvm_vcpu *vcpu); 468a6e2f683SEugene (jno) Dvurechenski 469b0c632dbSHeiko Carstens /* 470b0c632dbSHeiko Carstens * Get (and clear) the dirty memory log for a memory slot. 471b0c632dbSHeiko Carstens */ 472b0c632dbSHeiko Carstens int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, 473b0c632dbSHeiko Carstens struct kvm_dirty_log *log) 474b0c632dbSHeiko Carstens { 47515f36ebdSJason J. Herne int r; 47615f36ebdSJason J. Herne unsigned long n; 4779f6b8029SPaolo Bonzini struct kvm_memslots *slots; 47815f36ebdSJason J. Herne struct kvm_memory_slot *memslot; 47915f36ebdSJason J. Herne int is_dirty = 0; 48015f36ebdSJason J. Herne 481e1e8a962SJanosch Frank if (kvm_is_ucontrol(kvm)) 482e1e8a962SJanosch Frank return -EINVAL; 483e1e8a962SJanosch Frank 48415f36ebdSJason J. Herne mutex_lock(&kvm->slots_lock); 48515f36ebdSJason J. Herne 48615f36ebdSJason J. Herne r = -EINVAL; 48715f36ebdSJason J. Herne if (log->slot >= KVM_USER_MEM_SLOTS) 48815f36ebdSJason J. Herne goto out; 48915f36ebdSJason J. Herne 4909f6b8029SPaolo Bonzini slots = kvm_memslots(kvm); 4919f6b8029SPaolo Bonzini memslot = id_to_memslot(slots, log->slot); 49215f36ebdSJason J. Herne r = -ENOENT; 49315f36ebdSJason J. Herne if (!memslot->dirty_bitmap) 49415f36ebdSJason J. Herne goto out; 49515f36ebdSJason J. Herne 49615f36ebdSJason J. Herne kvm_s390_sync_dirty_log(kvm, memslot); 49715f36ebdSJason J. Herne r = kvm_get_dirty_log(kvm, log, &is_dirty); 49815f36ebdSJason J. Herne if (r) 49915f36ebdSJason J. Herne goto out; 50015f36ebdSJason J. Herne 50115f36ebdSJason J. Herne /* Clear the dirty log */ 50215f36ebdSJason J. Herne if (is_dirty) { 50315f36ebdSJason J. Herne n = kvm_dirty_bitmap_bytes(memslot); 50415f36ebdSJason J. Herne memset(memslot->dirty_bitmap, 0, n); 50515f36ebdSJason J. Herne } 50615f36ebdSJason J. Herne r = 0; 50715f36ebdSJason J. Herne out: 50815f36ebdSJason J. Herne mutex_unlock(&kvm->slots_lock); 50915f36ebdSJason J. Herne return r; 510b0c632dbSHeiko Carstens } 511b0c632dbSHeiko Carstens 5126502a34cSDavid Hildenbrand static void icpt_operexc_on_all_vcpus(struct kvm *kvm) 5136502a34cSDavid Hildenbrand { 5146502a34cSDavid Hildenbrand unsigned int i; 5156502a34cSDavid Hildenbrand struct kvm_vcpu *vcpu; 5166502a34cSDavid Hildenbrand 5176502a34cSDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 5186502a34cSDavid Hildenbrand kvm_s390_sync_request(KVM_REQ_ICPT_OPEREXC, vcpu); 5196502a34cSDavid Hildenbrand } 5206502a34cSDavid Hildenbrand } 5216502a34cSDavid Hildenbrand 522d938dc55SCornelia Huck static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap) 523d938dc55SCornelia Huck { 524d938dc55SCornelia Huck int r; 525d938dc55SCornelia Huck 526d938dc55SCornelia Huck if (cap->flags) 527d938dc55SCornelia Huck return -EINVAL; 528d938dc55SCornelia Huck 529d938dc55SCornelia Huck switch (cap->cap) { 53084223598SCornelia Huck case KVM_CAP_S390_IRQCHIP: 531c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_IRQCHIP"); 53284223598SCornelia Huck kvm->arch.use_irqchip = 1; 53384223598SCornelia Huck r = 0; 53484223598SCornelia Huck break; 5352444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 536c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_SIGP"); 5372444b352SDavid Hildenbrand kvm->arch.user_sigp = 1; 5382444b352SDavid Hildenbrand r = 0; 5392444b352SDavid Hildenbrand break; 54068c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 5415967c17bSDavid Hildenbrand mutex_lock(&kvm->lock); 542a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 5435967c17bSDavid Hildenbrand r = -EBUSY; 5445967c17bSDavid Hildenbrand } else if (MACHINE_HAS_VX) { 545c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 129); 546c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 129); 5472f87d942SGuenther Hutzl if (test_facility(134)) { 5482f87d942SGuenther Hutzl set_kvm_facility(kvm->arch.model.fac_mask, 134); 5492f87d942SGuenther Hutzl set_kvm_facility(kvm->arch.model.fac_list, 134); 5502f87d942SGuenther Hutzl } 55153743aa7SMaxim Samoylov if (test_facility(135)) { 55253743aa7SMaxim Samoylov set_kvm_facility(kvm->arch.model.fac_mask, 135); 55353743aa7SMaxim Samoylov set_kvm_facility(kvm->arch.model.fac_list, 135); 55453743aa7SMaxim Samoylov } 55518280d8bSMichael Mueller r = 0; 55618280d8bSMichael Mueller } else 55718280d8bSMichael Mueller r = -EINVAL; 5585967c17bSDavid Hildenbrand mutex_unlock(&kvm->lock); 559c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "ENABLE: CAP_S390_VECTOR_REGISTERS %s", 560c92ea7b9SChristian Borntraeger r ? "(not available)" : "(success)"); 56168c55750SEric Farman break; 562c6e5f166SFan Zhang case KVM_CAP_S390_RI: 563c6e5f166SFan Zhang r = -EINVAL; 564c6e5f166SFan Zhang mutex_lock(&kvm->lock); 565a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 566c6e5f166SFan Zhang r = -EBUSY; 567c6e5f166SFan Zhang } else if (test_facility(64)) { 568c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 64); 569c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 64); 570c6e5f166SFan Zhang r = 0; 571c6e5f166SFan Zhang } 572c6e5f166SFan Zhang mutex_unlock(&kvm->lock); 573c6e5f166SFan Zhang VM_EVENT(kvm, 3, "ENABLE: CAP_S390_RI %s", 574c6e5f166SFan Zhang r ? "(not available)" : "(success)"); 575c6e5f166SFan Zhang break; 57647a4693eSYi Min Zhao case KVM_CAP_S390_AIS: 57747a4693eSYi Min Zhao mutex_lock(&kvm->lock); 57847a4693eSYi Min Zhao if (kvm->created_vcpus) { 57947a4693eSYi Min Zhao r = -EBUSY; 58047a4693eSYi Min Zhao } else { 58147a4693eSYi Min Zhao set_kvm_facility(kvm->arch.model.fac_mask, 72); 58247a4693eSYi Min Zhao set_kvm_facility(kvm->arch.model.fac_list, 72); 58347a4693eSYi Min Zhao r = 0; 58447a4693eSYi Min Zhao } 58547a4693eSYi Min Zhao mutex_unlock(&kvm->lock); 58647a4693eSYi Min Zhao VM_EVENT(kvm, 3, "ENABLE: AIS %s", 58747a4693eSYi Min Zhao r ? "(not available)" : "(success)"); 58847a4693eSYi Min Zhao break; 5894e0b1ab7SFan Zhang case KVM_CAP_S390_GS: 5904e0b1ab7SFan Zhang r = -EINVAL; 5914e0b1ab7SFan Zhang mutex_lock(&kvm->lock); 592241e3ec0SChristian Borntraeger if (kvm->created_vcpus) { 5934e0b1ab7SFan Zhang r = -EBUSY; 5944e0b1ab7SFan Zhang } else if (test_facility(133)) { 5954e0b1ab7SFan Zhang set_kvm_facility(kvm->arch.model.fac_mask, 133); 5964e0b1ab7SFan Zhang set_kvm_facility(kvm->arch.model.fac_list, 133); 5974e0b1ab7SFan Zhang r = 0; 5984e0b1ab7SFan Zhang } 5994e0b1ab7SFan Zhang mutex_unlock(&kvm->lock); 6004e0b1ab7SFan Zhang VM_EVENT(kvm, 3, "ENABLE: CAP_S390_GS %s", 6014e0b1ab7SFan Zhang r ? "(not available)" : "(success)"); 6024e0b1ab7SFan Zhang break; 603e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 604c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_STSI"); 605e44fc8c9SEkaterina Tumanova kvm->arch.user_stsi = 1; 606e44fc8c9SEkaterina Tumanova r = 0; 607e44fc8c9SEkaterina Tumanova break; 6086502a34cSDavid Hildenbrand case KVM_CAP_S390_USER_INSTR0: 6096502a34cSDavid Hildenbrand VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_INSTR0"); 6106502a34cSDavid Hildenbrand kvm->arch.user_instr0 = 1; 6116502a34cSDavid Hildenbrand icpt_operexc_on_all_vcpus(kvm); 6126502a34cSDavid Hildenbrand r = 0; 6136502a34cSDavid Hildenbrand break; 614d938dc55SCornelia Huck default: 615d938dc55SCornelia Huck r = -EINVAL; 616d938dc55SCornelia Huck break; 617d938dc55SCornelia Huck } 618d938dc55SCornelia Huck return r; 619d938dc55SCornelia Huck } 620d938dc55SCornelia Huck 6218c0a7ce6SDominik Dingel static int kvm_s390_get_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 6228c0a7ce6SDominik Dingel { 6238c0a7ce6SDominik Dingel int ret; 6248c0a7ce6SDominik Dingel 6258c0a7ce6SDominik Dingel switch (attr->attr) { 6268c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 6278c0a7ce6SDominik Dingel ret = 0; 628c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: max guest memory: %lu bytes", 629a3a92c31SDominik Dingel kvm->arch.mem_limit); 630a3a92c31SDominik Dingel if (put_user(kvm->arch.mem_limit, (u64 __user *)attr->addr)) 6318c0a7ce6SDominik Dingel ret = -EFAULT; 6328c0a7ce6SDominik Dingel break; 6338c0a7ce6SDominik Dingel default: 6348c0a7ce6SDominik Dingel ret = -ENXIO; 6358c0a7ce6SDominik Dingel break; 6368c0a7ce6SDominik Dingel } 6378c0a7ce6SDominik Dingel return ret; 6388c0a7ce6SDominik Dingel } 6398c0a7ce6SDominik Dingel 6408c0a7ce6SDominik Dingel static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 6414f718eabSDominik Dingel { 6424f718eabSDominik Dingel int ret; 6434f718eabSDominik Dingel unsigned int idx; 6444f718eabSDominik Dingel switch (attr->attr) { 6454f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 646f9cbd9b0SDavid Hildenbrand ret = -ENXIO; 647c24cc9c8SDavid Hildenbrand if (!sclp.has_cmma) 648e6db1d61SDominik Dingel break; 649e6db1d61SDominik Dingel 6504f718eabSDominik Dingel ret = -EBUSY; 651c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CMMA support"); 6524f718eabSDominik Dingel mutex_lock(&kvm->lock); 653a03825bbSPaolo Bonzini if (!kvm->created_vcpus) { 6544f718eabSDominik Dingel kvm->arch.use_cmma = 1; 6554f718eabSDominik Dingel ret = 0; 6564f718eabSDominik Dingel } 6574f718eabSDominik Dingel mutex_unlock(&kvm->lock); 6584f718eabSDominik Dingel break; 6594f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 660f9cbd9b0SDavid Hildenbrand ret = -ENXIO; 661f9cbd9b0SDavid Hildenbrand if (!sclp.has_cmma) 662f9cbd9b0SDavid Hildenbrand break; 663c3489155SDominik Dingel ret = -EINVAL; 664c3489155SDominik Dingel if (!kvm->arch.use_cmma) 665c3489155SDominik Dingel break; 666c3489155SDominik Dingel 667c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "RESET: CMMA states"); 6684f718eabSDominik Dingel mutex_lock(&kvm->lock); 6694f718eabSDominik Dingel idx = srcu_read_lock(&kvm->srcu); 670a13cff31SDominik Dingel s390_reset_cmma(kvm->arch.gmap->mm); 6714f718eabSDominik Dingel srcu_read_unlock(&kvm->srcu, idx); 6724f718eabSDominik Dingel mutex_unlock(&kvm->lock); 6734f718eabSDominik Dingel ret = 0; 6744f718eabSDominik Dingel break; 6758c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: { 6768c0a7ce6SDominik Dingel unsigned long new_limit; 6778c0a7ce6SDominik Dingel 6788c0a7ce6SDominik Dingel if (kvm_is_ucontrol(kvm)) 6798c0a7ce6SDominik Dingel return -EINVAL; 6808c0a7ce6SDominik Dingel 6818c0a7ce6SDominik Dingel if (get_user(new_limit, (u64 __user *)attr->addr)) 6828c0a7ce6SDominik Dingel return -EFAULT; 6838c0a7ce6SDominik Dingel 684a3a92c31SDominik Dingel if (kvm->arch.mem_limit != KVM_S390_NO_MEM_LIMIT && 685a3a92c31SDominik Dingel new_limit > kvm->arch.mem_limit) 6868c0a7ce6SDominik Dingel return -E2BIG; 6878c0a7ce6SDominik Dingel 688a3a92c31SDominik Dingel if (!new_limit) 689a3a92c31SDominik Dingel return -EINVAL; 690a3a92c31SDominik Dingel 6916ea427bbSMartin Schwidefsky /* gmap_create takes last usable address */ 692a3a92c31SDominik Dingel if (new_limit != KVM_S390_NO_MEM_LIMIT) 693a3a92c31SDominik Dingel new_limit -= 1; 694a3a92c31SDominik Dingel 6958c0a7ce6SDominik Dingel ret = -EBUSY; 6968c0a7ce6SDominik Dingel mutex_lock(&kvm->lock); 697a03825bbSPaolo Bonzini if (!kvm->created_vcpus) { 6986ea427bbSMartin Schwidefsky /* gmap_create will round the limit up */ 6996ea427bbSMartin Schwidefsky struct gmap *new = gmap_create(current->mm, new_limit); 7008c0a7ce6SDominik Dingel 7018c0a7ce6SDominik Dingel if (!new) { 7028c0a7ce6SDominik Dingel ret = -ENOMEM; 7038c0a7ce6SDominik Dingel } else { 7046ea427bbSMartin Schwidefsky gmap_remove(kvm->arch.gmap); 7058c0a7ce6SDominik Dingel new->private = kvm; 7068c0a7ce6SDominik Dingel kvm->arch.gmap = new; 7078c0a7ce6SDominik Dingel ret = 0; 7088c0a7ce6SDominik Dingel } 7098c0a7ce6SDominik Dingel } 7108c0a7ce6SDominik Dingel mutex_unlock(&kvm->lock); 711a3a92c31SDominik Dingel VM_EVENT(kvm, 3, "SET: max guest address: %lu", new_limit); 712a3a92c31SDominik Dingel VM_EVENT(kvm, 3, "New guest asce: 0x%pK", 713a3a92c31SDominik Dingel (void *) kvm->arch.gmap->asce); 7148c0a7ce6SDominik Dingel break; 7158c0a7ce6SDominik Dingel } 7164f718eabSDominik Dingel default: 7174f718eabSDominik Dingel ret = -ENXIO; 7184f718eabSDominik Dingel break; 7194f718eabSDominik Dingel } 7204f718eabSDominik Dingel return ret; 7214f718eabSDominik Dingel } 7224f718eabSDominik Dingel 723a374e892STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu); 724a374e892STony Krowiak 725a374e892STony Krowiak static int kvm_s390_vm_set_crypto(struct kvm *kvm, struct kvm_device_attr *attr) 726a374e892STony Krowiak { 727a374e892STony Krowiak struct kvm_vcpu *vcpu; 728a374e892STony Krowiak int i; 729a374e892STony Krowiak 7309d8d5786SMichael Mueller if (!test_kvm_facility(kvm, 76)) 731a374e892STony Krowiak return -EINVAL; 732a374e892STony Krowiak 733a374e892STony Krowiak mutex_lock(&kvm->lock); 734a374e892STony Krowiak switch (attr->attr) { 735a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 736a374e892STony Krowiak get_random_bytes( 737a374e892STony Krowiak kvm->arch.crypto.crycb->aes_wrapping_key_mask, 738a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 739a374e892STony Krowiak kvm->arch.crypto.aes_kw = 1; 740c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: AES keywrapping support"); 741a374e892STony Krowiak break; 742a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 743a374e892STony Krowiak get_random_bytes( 744a374e892STony Krowiak kvm->arch.crypto.crycb->dea_wrapping_key_mask, 745a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 746a374e892STony Krowiak kvm->arch.crypto.dea_kw = 1; 747c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: DEA keywrapping support"); 748a374e892STony Krowiak break; 749a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 750a374e892STony Krowiak kvm->arch.crypto.aes_kw = 0; 751a374e892STony Krowiak memset(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 0, 752a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 753c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "DISABLE: AES keywrapping support"); 754a374e892STony Krowiak break; 755a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 756a374e892STony Krowiak kvm->arch.crypto.dea_kw = 0; 757a374e892STony Krowiak memset(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 0, 758a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 759c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "DISABLE: DEA keywrapping support"); 760a374e892STony Krowiak break; 761a374e892STony Krowiak default: 762a374e892STony Krowiak mutex_unlock(&kvm->lock); 763a374e892STony Krowiak return -ENXIO; 764a374e892STony Krowiak } 765a374e892STony Krowiak 766a374e892STony Krowiak kvm_for_each_vcpu(i, vcpu, kvm) { 767a374e892STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 768a374e892STony Krowiak exit_sie(vcpu); 769a374e892STony Krowiak } 770a374e892STony Krowiak mutex_unlock(&kvm->lock); 771a374e892STony Krowiak return 0; 772a374e892STony Krowiak } 773a374e892STony Krowiak 774190df4a2SClaudio Imbrenda static void kvm_s390_sync_request_broadcast(struct kvm *kvm, int req) 775190df4a2SClaudio Imbrenda { 776190df4a2SClaudio Imbrenda int cx; 777190df4a2SClaudio Imbrenda struct kvm_vcpu *vcpu; 778190df4a2SClaudio Imbrenda 779190df4a2SClaudio Imbrenda kvm_for_each_vcpu(cx, vcpu, kvm) 780190df4a2SClaudio Imbrenda kvm_s390_sync_request(req, vcpu); 781190df4a2SClaudio Imbrenda } 782190df4a2SClaudio Imbrenda 783190df4a2SClaudio Imbrenda /* 784190df4a2SClaudio Imbrenda * Must be called with kvm->srcu held to avoid races on memslots, and with 7851de1ea7eSChristian Borntraeger * kvm->slots_lock to avoid races with ourselves and kvm_s390_vm_stop_migration. 786190df4a2SClaudio Imbrenda */ 787190df4a2SClaudio Imbrenda static int kvm_s390_vm_start_migration(struct kvm *kvm) 788190df4a2SClaudio Imbrenda { 789190df4a2SClaudio Imbrenda struct kvm_s390_migration_state *mgs; 790190df4a2SClaudio Imbrenda struct kvm_memory_slot *ms; 791190df4a2SClaudio Imbrenda /* should be the only one */ 792190df4a2SClaudio Imbrenda struct kvm_memslots *slots; 793190df4a2SClaudio Imbrenda unsigned long ram_pages; 794190df4a2SClaudio Imbrenda int slotnr; 795190df4a2SClaudio Imbrenda 796190df4a2SClaudio Imbrenda /* migration mode already enabled */ 797190df4a2SClaudio Imbrenda if (kvm->arch.migration_state) 798190df4a2SClaudio Imbrenda return 0; 799190df4a2SClaudio Imbrenda 800190df4a2SClaudio Imbrenda slots = kvm_memslots(kvm); 801190df4a2SClaudio Imbrenda if (!slots || !slots->used_slots) 802190df4a2SClaudio Imbrenda return -EINVAL; 803190df4a2SClaudio Imbrenda 804190df4a2SClaudio Imbrenda mgs = kzalloc(sizeof(*mgs), GFP_KERNEL); 805190df4a2SClaudio Imbrenda if (!mgs) 806190df4a2SClaudio Imbrenda return -ENOMEM; 807190df4a2SClaudio Imbrenda kvm->arch.migration_state = mgs; 808190df4a2SClaudio Imbrenda 809190df4a2SClaudio Imbrenda if (kvm->arch.use_cmma) { 810190df4a2SClaudio Imbrenda /* 81132aa144fSChristian Borntraeger * Get the first slot. They are reverse sorted by base_gfn, so 81232aa144fSChristian Borntraeger * the first slot is also the one at the end of the address 81332aa144fSChristian Borntraeger * space. We have verified above that at least one slot is 81432aa144fSChristian Borntraeger * present. 815190df4a2SClaudio Imbrenda */ 81632aa144fSChristian Borntraeger ms = slots->memslots; 817190df4a2SClaudio Imbrenda /* round up so we only use full longs */ 818190df4a2SClaudio Imbrenda ram_pages = roundup(ms->base_gfn + ms->npages, BITS_PER_LONG); 819190df4a2SClaudio Imbrenda /* allocate enough bytes to store all the bits */ 820190df4a2SClaudio Imbrenda mgs->pgste_bitmap = vmalloc(ram_pages / 8); 821190df4a2SClaudio Imbrenda if (!mgs->pgste_bitmap) { 822190df4a2SClaudio Imbrenda kfree(mgs); 823190df4a2SClaudio Imbrenda kvm->arch.migration_state = NULL; 824190df4a2SClaudio Imbrenda return -ENOMEM; 825190df4a2SClaudio Imbrenda } 826190df4a2SClaudio Imbrenda 827190df4a2SClaudio Imbrenda mgs->bitmap_size = ram_pages; 828190df4a2SClaudio Imbrenda atomic64_set(&mgs->dirty_pages, ram_pages); 829190df4a2SClaudio Imbrenda /* mark all the pages in active slots as dirty */ 830190df4a2SClaudio Imbrenda for (slotnr = 0; slotnr < slots->used_slots; slotnr++) { 831190df4a2SClaudio Imbrenda ms = slots->memslots + slotnr; 832190df4a2SClaudio Imbrenda bitmap_set(mgs->pgste_bitmap, ms->base_gfn, ms->npages); 833190df4a2SClaudio Imbrenda } 834190df4a2SClaudio Imbrenda 835190df4a2SClaudio Imbrenda kvm_s390_sync_request_broadcast(kvm, KVM_REQ_START_MIGRATION); 836190df4a2SClaudio Imbrenda } 837190df4a2SClaudio Imbrenda return 0; 838190df4a2SClaudio Imbrenda } 839190df4a2SClaudio Imbrenda 840190df4a2SClaudio Imbrenda /* 8411de1ea7eSChristian Borntraeger * Must be called with kvm->slots_lock to avoid races with ourselves and 842190df4a2SClaudio Imbrenda * kvm_s390_vm_start_migration. 843190df4a2SClaudio Imbrenda */ 844190df4a2SClaudio Imbrenda static int kvm_s390_vm_stop_migration(struct kvm *kvm) 845190df4a2SClaudio Imbrenda { 846190df4a2SClaudio Imbrenda struct kvm_s390_migration_state *mgs; 847190df4a2SClaudio Imbrenda 848190df4a2SClaudio Imbrenda /* migration mode already disabled */ 849190df4a2SClaudio Imbrenda if (!kvm->arch.migration_state) 850190df4a2SClaudio Imbrenda return 0; 851190df4a2SClaudio Imbrenda mgs = kvm->arch.migration_state; 852190df4a2SClaudio Imbrenda kvm->arch.migration_state = NULL; 853190df4a2SClaudio Imbrenda 854190df4a2SClaudio Imbrenda if (kvm->arch.use_cmma) { 855190df4a2SClaudio Imbrenda kvm_s390_sync_request_broadcast(kvm, KVM_REQ_STOP_MIGRATION); 8561de1ea7eSChristian Borntraeger /* We have to wait for the essa emulation to finish */ 8571de1ea7eSChristian Borntraeger synchronize_srcu(&kvm->srcu); 858190df4a2SClaudio Imbrenda vfree(mgs->pgste_bitmap); 859190df4a2SClaudio Imbrenda } 860190df4a2SClaudio Imbrenda kfree(mgs); 861190df4a2SClaudio Imbrenda return 0; 862190df4a2SClaudio Imbrenda } 863190df4a2SClaudio Imbrenda 864190df4a2SClaudio Imbrenda static int kvm_s390_vm_set_migration(struct kvm *kvm, 865190df4a2SClaudio Imbrenda struct kvm_device_attr *attr) 866190df4a2SClaudio Imbrenda { 8671de1ea7eSChristian Borntraeger int res = -ENXIO; 868190df4a2SClaudio Imbrenda 8691de1ea7eSChristian Borntraeger mutex_lock(&kvm->slots_lock); 870190df4a2SClaudio Imbrenda switch (attr->attr) { 871190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION_START: 872190df4a2SClaudio Imbrenda res = kvm_s390_vm_start_migration(kvm); 873190df4a2SClaudio Imbrenda break; 874190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION_STOP: 875190df4a2SClaudio Imbrenda res = kvm_s390_vm_stop_migration(kvm); 876190df4a2SClaudio Imbrenda break; 877190df4a2SClaudio Imbrenda default: 878190df4a2SClaudio Imbrenda break; 879190df4a2SClaudio Imbrenda } 8801de1ea7eSChristian Borntraeger mutex_unlock(&kvm->slots_lock); 881190df4a2SClaudio Imbrenda 882190df4a2SClaudio Imbrenda return res; 883190df4a2SClaudio Imbrenda } 884190df4a2SClaudio Imbrenda 885190df4a2SClaudio Imbrenda static int kvm_s390_vm_get_migration(struct kvm *kvm, 886190df4a2SClaudio Imbrenda struct kvm_device_attr *attr) 887190df4a2SClaudio Imbrenda { 888190df4a2SClaudio Imbrenda u64 mig = (kvm->arch.migration_state != NULL); 889190df4a2SClaudio Imbrenda 890190df4a2SClaudio Imbrenda if (attr->attr != KVM_S390_VM_MIGRATION_STATUS) 891190df4a2SClaudio Imbrenda return -ENXIO; 892190df4a2SClaudio Imbrenda 893190df4a2SClaudio Imbrenda if (copy_to_user((void __user *)attr->addr, &mig, sizeof(mig))) 894190df4a2SClaudio Imbrenda return -EFAULT; 895190df4a2SClaudio Imbrenda return 0; 896190df4a2SClaudio Imbrenda } 897190df4a2SClaudio Imbrenda 8988fa1696eSCollin L. Walling static int kvm_s390_set_tod_ext(struct kvm *kvm, struct kvm_device_attr *attr) 8998fa1696eSCollin L. Walling { 9008fa1696eSCollin L. Walling struct kvm_s390_vm_tod_clock gtod; 9018fa1696eSCollin L. Walling 9028fa1696eSCollin L. Walling if (copy_from_user(>od, (void __user *)attr->addr, sizeof(gtod))) 9038fa1696eSCollin L. Walling return -EFAULT; 9048fa1696eSCollin L. Walling 9058fa1696eSCollin L. Walling if (test_kvm_facility(kvm, 139)) 9068fa1696eSCollin L. Walling kvm_s390_set_tod_clock_ext(kvm, >od); 9078fa1696eSCollin L. Walling else if (gtod.epoch_idx == 0) 9088fa1696eSCollin L. Walling kvm_s390_set_tod_clock(kvm, gtod.tod); 9098fa1696eSCollin L. Walling else 9108fa1696eSCollin L. Walling return -EINVAL; 9118fa1696eSCollin L. Walling 9128fa1696eSCollin L. Walling VM_EVENT(kvm, 3, "SET: TOD extension: 0x%x, TOD base: 0x%llx", 9138fa1696eSCollin L. Walling gtod.epoch_idx, gtod.tod); 9148fa1696eSCollin L. Walling 9158fa1696eSCollin L. Walling return 0; 9168fa1696eSCollin L. Walling } 9178fa1696eSCollin L. Walling 91872f25020SJason J. Herne static int kvm_s390_set_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 91972f25020SJason J. Herne { 92072f25020SJason J. Herne u8 gtod_high; 92172f25020SJason J. Herne 92272f25020SJason J. Herne if (copy_from_user(>od_high, (void __user *)attr->addr, 92372f25020SJason J. Herne sizeof(gtod_high))) 92472f25020SJason J. Herne return -EFAULT; 92572f25020SJason J. Herne 92672f25020SJason J. Herne if (gtod_high != 0) 92772f25020SJason J. Herne return -EINVAL; 92858c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "SET: TOD extension: 0x%x", gtod_high); 92972f25020SJason J. Herne 93072f25020SJason J. Herne return 0; 93172f25020SJason J. Herne } 93272f25020SJason J. Herne 93372f25020SJason J. Herne static int kvm_s390_set_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 93472f25020SJason J. Herne { 9355a3d883aSDavid Hildenbrand u64 gtod; 93672f25020SJason J. Herne 93772f25020SJason J. Herne if (copy_from_user(>od, (void __user *)attr->addr, sizeof(gtod))) 93872f25020SJason J. Herne return -EFAULT; 93972f25020SJason J. Herne 94025ed1675SDavid Hildenbrand kvm_s390_set_tod_clock(kvm, gtod); 94158c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "SET: TOD base: 0x%llx", gtod); 94272f25020SJason J. Herne return 0; 94372f25020SJason J. Herne } 94472f25020SJason J. Herne 94572f25020SJason J. Herne static int kvm_s390_set_tod(struct kvm *kvm, struct kvm_device_attr *attr) 94672f25020SJason J. Herne { 94772f25020SJason J. Herne int ret; 94872f25020SJason J. Herne 94972f25020SJason J. Herne if (attr->flags) 95072f25020SJason J. Herne return -EINVAL; 95172f25020SJason J. Herne 95272f25020SJason J. Herne switch (attr->attr) { 9538fa1696eSCollin L. Walling case KVM_S390_VM_TOD_EXT: 9548fa1696eSCollin L. Walling ret = kvm_s390_set_tod_ext(kvm, attr); 9558fa1696eSCollin L. Walling break; 95672f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 95772f25020SJason J. Herne ret = kvm_s390_set_tod_high(kvm, attr); 95872f25020SJason J. Herne break; 95972f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 96072f25020SJason J. Herne ret = kvm_s390_set_tod_low(kvm, attr); 96172f25020SJason J. Herne break; 96272f25020SJason J. Herne default: 96372f25020SJason J. Herne ret = -ENXIO; 96472f25020SJason J. Herne break; 96572f25020SJason J. Herne } 96672f25020SJason J. Herne return ret; 96772f25020SJason J. Herne } 96872f25020SJason J. Herne 9698fa1696eSCollin L. Walling static void kvm_s390_get_tod_clock_ext(struct kvm *kvm, 9708fa1696eSCollin L. Walling struct kvm_s390_vm_tod_clock *gtod) 9718fa1696eSCollin L. Walling { 9728fa1696eSCollin L. Walling struct kvm_s390_tod_clock_ext htod; 9738fa1696eSCollin L. Walling 9748fa1696eSCollin L. Walling preempt_disable(); 9758fa1696eSCollin L. Walling 9768fa1696eSCollin L. Walling get_tod_clock_ext((char *)&htod); 9778fa1696eSCollin L. Walling 9788fa1696eSCollin L. Walling gtod->tod = htod.tod + kvm->arch.epoch; 9798fa1696eSCollin L. Walling gtod->epoch_idx = htod.epoch_idx + kvm->arch.epdx; 9808fa1696eSCollin L. Walling 9818fa1696eSCollin L. Walling if (gtod->tod < htod.tod) 9828fa1696eSCollin L. Walling gtod->epoch_idx += 1; 9838fa1696eSCollin L. Walling 9848fa1696eSCollin L. Walling preempt_enable(); 9858fa1696eSCollin L. Walling } 9868fa1696eSCollin L. Walling 9878fa1696eSCollin L. Walling static int kvm_s390_get_tod_ext(struct kvm *kvm, struct kvm_device_attr *attr) 9888fa1696eSCollin L. Walling { 9898fa1696eSCollin L. Walling struct kvm_s390_vm_tod_clock gtod; 9908fa1696eSCollin L. Walling 9918fa1696eSCollin L. Walling memset(>od, 0, sizeof(gtod)); 9928fa1696eSCollin L. Walling 9938fa1696eSCollin L. Walling if (test_kvm_facility(kvm, 139)) 9948fa1696eSCollin L. Walling kvm_s390_get_tod_clock_ext(kvm, >od); 9958fa1696eSCollin L. Walling else 9968fa1696eSCollin L. Walling gtod.tod = kvm_s390_get_tod_clock_fast(kvm); 9978fa1696eSCollin L. Walling 9988fa1696eSCollin L. Walling if (copy_to_user((void __user *)attr->addr, >od, sizeof(gtod))) 9998fa1696eSCollin L. Walling return -EFAULT; 10008fa1696eSCollin L. Walling 10018fa1696eSCollin L. Walling VM_EVENT(kvm, 3, "QUERY: TOD extension: 0x%x, TOD base: 0x%llx", 10028fa1696eSCollin L. Walling gtod.epoch_idx, gtod.tod); 10038fa1696eSCollin L. Walling return 0; 10048fa1696eSCollin L. Walling } 10058fa1696eSCollin L. Walling 100672f25020SJason J. Herne static int kvm_s390_get_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 100772f25020SJason J. Herne { 100872f25020SJason J. Herne u8 gtod_high = 0; 100972f25020SJason J. Herne 101072f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od_high, 101172f25020SJason J. Herne sizeof(gtod_high))) 101272f25020SJason J. Herne return -EFAULT; 101358c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: TOD extension: 0x%x", gtod_high); 101472f25020SJason J. Herne 101572f25020SJason J. Herne return 0; 101672f25020SJason J. Herne } 101772f25020SJason J. Herne 101872f25020SJason J. Herne static int kvm_s390_get_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 101972f25020SJason J. Herne { 10205a3d883aSDavid Hildenbrand u64 gtod; 102172f25020SJason J. Herne 102260417fccSDavid Hildenbrand gtod = kvm_s390_get_tod_clock_fast(kvm); 102372f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od, sizeof(gtod))) 102472f25020SJason J. Herne return -EFAULT; 102558c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: TOD base: 0x%llx", gtod); 102672f25020SJason J. Herne 102772f25020SJason J. Herne return 0; 102872f25020SJason J. Herne } 102972f25020SJason J. Herne 103072f25020SJason J. Herne static int kvm_s390_get_tod(struct kvm *kvm, struct kvm_device_attr *attr) 103172f25020SJason J. Herne { 103272f25020SJason J. Herne int ret; 103372f25020SJason J. Herne 103472f25020SJason J. Herne if (attr->flags) 103572f25020SJason J. Herne return -EINVAL; 103672f25020SJason J. Herne 103772f25020SJason J. Herne switch (attr->attr) { 10388fa1696eSCollin L. Walling case KVM_S390_VM_TOD_EXT: 10398fa1696eSCollin L. Walling ret = kvm_s390_get_tod_ext(kvm, attr); 10408fa1696eSCollin L. Walling break; 104172f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 104272f25020SJason J. Herne ret = kvm_s390_get_tod_high(kvm, attr); 104372f25020SJason J. Herne break; 104472f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 104572f25020SJason J. Herne ret = kvm_s390_get_tod_low(kvm, attr); 104672f25020SJason J. Herne break; 104772f25020SJason J. Herne default: 104872f25020SJason J. Herne ret = -ENXIO; 104972f25020SJason J. Herne break; 105072f25020SJason J. Herne } 105172f25020SJason J. Herne return ret; 105272f25020SJason J. Herne } 105372f25020SJason J. Herne 1054658b6edaSMichael Mueller static int kvm_s390_set_processor(struct kvm *kvm, struct kvm_device_attr *attr) 1055658b6edaSMichael Mueller { 1056658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 1057053dd230SDavid Hildenbrand u16 lowest_ibc, unblocked_ibc; 1058658b6edaSMichael Mueller int ret = 0; 1059658b6edaSMichael Mueller 1060658b6edaSMichael Mueller mutex_lock(&kvm->lock); 1061a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 1062658b6edaSMichael Mueller ret = -EBUSY; 1063658b6edaSMichael Mueller goto out; 1064658b6edaSMichael Mueller } 1065658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 1066658b6edaSMichael Mueller if (!proc) { 1067658b6edaSMichael Mueller ret = -ENOMEM; 1068658b6edaSMichael Mueller goto out; 1069658b6edaSMichael Mueller } 1070658b6edaSMichael Mueller if (!copy_from_user(proc, (void __user *)attr->addr, 1071658b6edaSMichael Mueller sizeof(*proc))) { 10729bb0ec09SDavid Hildenbrand kvm->arch.model.cpuid = proc->cpuid; 1073053dd230SDavid Hildenbrand lowest_ibc = sclp.ibc >> 16 & 0xfff; 1074053dd230SDavid Hildenbrand unblocked_ibc = sclp.ibc & 0xfff; 10750487c44dSDavid Hildenbrand if (lowest_ibc && proc->ibc) { 1076053dd230SDavid Hildenbrand if (proc->ibc > unblocked_ibc) 1077053dd230SDavid Hildenbrand kvm->arch.model.ibc = unblocked_ibc; 1078053dd230SDavid Hildenbrand else if (proc->ibc < lowest_ibc) 1079053dd230SDavid Hildenbrand kvm->arch.model.ibc = lowest_ibc; 1080053dd230SDavid Hildenbrand else 1081658b6edaSMichael Mueller kvm->arch.model.ibc = proc->ibc; 1082053dd230SDavid Hildenbrand } 1083c54f0d6aSDavid Hildenbrand memcpy(kvm->arch.model.fac_list, proc->fac_list, 1084658b6edaSMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 1085a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest ibc: 0x%4.4x, guest cpuid: 0x%16.16llx", 1086a8c39dd7SChristian Borntraeger kvm->arch.model.ibc, 1087a8c39dd7SChristian Borntraeger kvm->arch.model.cpuid); 1088a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest faclist: 0x%16.16llx.%16.16llx.%16.16llx", 1089a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[0], 1090a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[1], 1091a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[2]); 1092658b6edaSMichael Mueller } else 1093658b6edaSMichael Mueller ret = -EFAULT; 1094658b6edaSMichael Mueller kfree(proc); 1095658b6edaSMichael Mueller out: 1096658b6edaSMichael Mueller mutex_unlock(&kvm->lock); 1097658b6edaSMichael Mueller return ret; 1098658b6edaSMichael Mueller } 1099658b6edaSMichael Mueller 110015c9705fSDavid Hildenbrand static int kvm_s390_set_processor_feat(struct kvm *kvm, 110115c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 110215c9705fSDavid Hildenbrand { 110315c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 110415c9705fSDavid Hildenbrand 110515c9705fSDavid Hildenbrand if (copy_from_user(&data, (void __user *)attr->addr, sizeof(data))) 110615c9705fSDavid Hildenbrand return -EFAULT; 110715c9705fSDavid Hildenbrand if (!bitmap_subset((unsigned long *) data.feat, 110815c9705fSDavid Hildenbrand kvm_s390_available_cpu_feat, 110915c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS)) 111015c9705fSDavid Hildenbrand return -EINVAL; 111115c9705fSDavid Hildenbrand 111215c9705fSDavid Hildenbrand mutex_lock(&kvm->lock); 11132f8311c9SChristian Borntraeger if (kvm->created_vcpus) { 11142f8311c9SChristian Borntraeger mutex_unlock(&kvm->lock); 11152f8311c9SChristian Borntraeger return -EBUSY; 11162f8311c9SChristian Borntraeger } 111715c9705fSDavid Hildenbrand bitmap_copy(kvm->arch.cpu_feat, (unsigned long *) data.feat, 111815c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 111915c9705fSDavid Hildenbrand mutex_unlock(&kvm->lock); 11202f8311c9SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx", 11212f8311c9SChristian Borntraeger data.feat[0], 11222f8311c9SChristian Borntraeger data.feat[1], 11232f8311c9SChristian Borntraeger data.feat[2]); 11242f8311c9SChristian Borntraeger return 0; 112515c9705fSDavid Hildenbrand } 112615c9705fSDavid Hildenbrand 11270a763c78SDavid Hildenbrand static int kvm_s390_set_processor_subfunc(struct kvm *kvm, 11280a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 11290a763c78SDavid Hildenbrand { 11300a763c78SDavid Hildenbrand /* 11310a763c78SDavid Hildenbrand * Once supported by kernel + hw, we have to store the subfunctions 11320a763c78SDavid Hildenbrand * in kvm->arch and remember that user space configured them. 11330a763c78SDavid Hildenbrand */ 11340a763c78SDavid Hildenbrand return -ENXIO; 11350a763c78SDavid Hildenbrand } 11360a763c78SDavid Hildenbrand 1137658b6edaSMichael Mueller static int kvm_s390_set_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 1138658b6edaSMichael Mueller { 1139658b6edaSMichael Mueller int ret = -ENXIO; 1140658b6edaSMichael Mueller 1141658b6edaSMichael Mueller switch (attr->attr) { 1142658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 1143658b6edaSMichael Mueller ret = kvm_s390_set_processor(kvm, attr); 1144658b6edaSMichael Mueller break; 114515c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 114615c9705fSDavid Hildenbrand ret = kvm_s390_set_processor_feat(kvm, attr); 114715c9705fSDavid Hildenbrand break; 11480a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 11490a763c78SDavid Hildenbrand ret = kvm_s390_set_processor_subfunc(kvm, attr); 11500a763c78SDavid Hildenbrand break; 1151658b6edaSMichael Mueller } 1152658b6edaSMichael Mueller return ret; 1153658b6edaSMichael Mueller } 1154658b6edaSMichael Mueller 1155658b6edaSMichael Mueller static int kvm_s390_get_processor(struct kvm *kvm, struct kvm_device_attr *attr) 1156658b6edaSMichael Mueller { 1157658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 1158658b6edaSMichael Mueller int ret = 0; 1159658b6edaSMichael Mueller 1160658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 1161658b6edaSMichael Mueller if (!proc) { 1162658b6edaSMichael Mueller ret = -ENOMEM; 1163658b6edaSMichael Mueller goto out; 1164658b6edaSMichael Mueller } 11659bb0ec09SDavid Hildenbrand proc->cpuid = kvm->arch.model.cpuid; 1166658b6edaSMichael Mueller proc->ibc = kvm->arch.model.ibc; 1167c54f0d6aSDavid Hildenbrand memcpy(&proc->fac_list, kvm->arch.model.fac_list, 1168c54f0d6aSDavid Hildenbrand S390_ARCH_FAC_LIST_SIZE_BYTE); 1169a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest ibc: 0x%4.4x, guest cpuid: 0x%16.16llx", 1170a8c39dd7SChristian Borntraeger kvm->arch.model.ibc, 1171a8c39dd7SChristian Borntraeger kvm->arch.model.cpuid); 1172a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest faclist: 0x%16.16llx.%16.16llx.%16.16llx", 1173a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[0], 1174a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[1], 1175a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[2]); 1176658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, proc, sizeof(*proc))) 1177658b6edaSMichael Mueller ret = -EFAULT; 1178658b6edaSMichael Mueller kfree(proc); 1179658b6edaSMichael Mueller out: 1180658b6edaSMichael Mueller return ret; 1181658b6edaSMichael Mueller } 1182658b6edaSMichael Mueller 1183658b6edaSMichael Mueller static int kvm_s390_get_machine(struct kvm *kvm, struct kvm_device_attr *attr) 1184658b6edaSMichael Mueller { 1185658b6edaSMichael Mueller struct kvm_s390_vm_cpu_machine *mach; 1186658b6edaSMichael Mueller int ret = 0; 1187658b6edaSMichael Mueller 1188658b6edaSMichael Mueller mach = kzalloc(sizeof(*mach), GFP_KERNEL); 1189658b6edaSMichael Mueller if (!mach) { 1190658b6edaSMichael Mueller ret = -ENOMEM; 1191658b6edaSMichael Mueller goto out; 1192658b6edaSMichael Mueller } 1193658b6edaSMichael Mueller get_cpu_id((struct cpuid *) &mach->cpuid); 119437c5f6c8SDavid Hildenbrand mach->ibc = sclp.ibc; 1195c54f0d6aSDavid Hildenbrand memcpy(&mach->fac_mask, kvm->arch.model.fac_mask, 1196981467c9SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 1197658b6edaSMichael Mueller memcpy((unsigned long *)&mach->fac_list, S390_lowcore.stfle_fac_list, 119804478197SChristian Borntraeger sizeof(S390_lowcore.stfle_fac_list)); 1199a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host ibc: 0x%4.4x, host cpuid: 0x%16.16llx", 1200a8c39dd7SChristian Borntraeger kvm->arch.model.ibc, 1201a8c39dd7SChristian Borntraeger kvm->arch.model.cpuid); 1202a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host facmask: 0x%16.16llx.%16.16llx.%16.16llx", 1203a8c39dd7SChristian Borntraeger mach->fac_mask[0], 1204a8c39dd7SChristian Borntraeger mach->fac_mask[1], 1205a8c39dd7SChristian Borntraeger mach->fac_mask[2]); 1206a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host faclist: 0x%16.16llx.%16.16llx.%16.16llx", 1207a8c39dd7SChristian Borntraeger mach->fac_list[0], 1208a8c39dd7SChristian Borntraeger mach->fac_list[1], 1209a8c39dd7SChristian Borntraeger mach->fac_list[2]); 1210658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, mach, sizeof(*mach))) 1211658b6edaSMichael Mueller ret = -EFAULT; 1212658b6edaSMichael Mueller kfree(mach); 1213658b6edaSMichael Mueller out: 1214658b6edaSMichael Mueller return ret; 1215658b6edaSMichael Mueller } 1216658b6edaSMichael Mueller 121715c9705fSDavid Hildenbrand static int kvm_s390_get_processor_feat(struct kvm *kvm, 121815c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 121915c9705fSDavid Hildenbrand { 122015c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 122115c9705fSDavid Hildenbrand 122215c9705fSDavid Hildenbrand bitmap_copy((unsigned long *) data.feat, kvm->arch.cpu_feat, 122315c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 122415c9705fSDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &data, sizeof(data))) 122515c9705fSDavid Hildenbrand return -EFAULT; 12262f8311c9SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx", 12272f8311c9SChristian Borntraeger data.feat[0], 12282f8311c9SChristian Borntraeger data.feat[1], 12292f8311c9SChristian Borntraeger data.feat[2]); 123015c9705fSDavid Hildenbrand return 0; 123115c9705fSDavid Hildenbrand } 123215c9705fSDavid Hildenbrand 123315c9705fSDavid Hildenbrand static int kvm_s390_get_machine_feat(struct kvm *kvm, 123415c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 123515c9705fSDavid Hildenbrand { 123615c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 123715c9705fSDavid Hildenbrand 123815c9705fSDavid Hildenbrand bitmap_copy((unsigned long *) data.feat, 123915c9705fSDavid Hildenbrand kvm_s390_available_cpu_feat, 124015c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 124115c9705fSDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &data, sizeof(data))) 124215c9705fSDavid Hildenbrand return -EFAULT; 12432f8311c9SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx", 12442f8311c9SChristian Borntraeger data.feat[0], 12452f8311c9SChristian Borntraeger data.feat[1], 12462f8311c9SChristian Borntraeger data.feat[2]); 124715c9705fSDavid Hildenbrand return 0; 124815c9705fSDavid Hildenbrand } 124915c9705fSDavid Hildenbrand 12500a763c78SDavid Hildenbrand static int kvm_s390_get_processor_subfunc(struct kvm *kvm, 12510a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 12520a763c78SDavid Hildenbrand { 12530a763c78SDavid Hildenbrand /* 12540a763c78SDavid Hildenbrand * Once we can actually configure subfunctions (kernel + hw support), 12550a763c78SDavid Hildenbrand * we have to check if they were already set by user space, if so copy 12560a763c78SDavid Hildenbrand * them from kvm->arch. 12570a763c78SDavid Hildenbrand */ 12580a763c78SDavid Hildenbrand return -ENXIO; 12590a763c78SDavid Hildenbrand } 12600a763c78SDavid Hildenbrand 12610a763c78SDavid Hildenbrand static int kvm_s390_get_machine_subfunc(struct kvm *kvm, 12620a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 12630a763c78SDavid Hildenbrand { 12640a763c78SDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &kvm_s390_available_subfunc, 12650a763c78SDavid Hildenbrand sizeof(struct kvm_s390_vm_cpu_subfunc))) 12660a763c78SDavid Hildenbrand return -EFAULT; 12670a763c78SDavid Hildenbrand return 0; 12680a763c78SDavid Hildenbrand } 1269658b6edaSMichael Mueller static int kvm_s390_get_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 1270658b6edaSMichael Mueller { 1271658b6edaSMichael Mueller int ret = -ENXIO; 1272658b6edaSMichael Mueller 1273658b6edaSMichael Mueller switch (attr->attr) { 1274658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 1275658b6edaSMichael Mueller ret = kvm_s390_get_processor(kvm, attr); 1276658b6edaSMichael Mueller break; 1277658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 1278658b6edaSMichael Mueller ret = kvm_s390_get_machine(kvm, attr); 1279658b6edaSMichael Mueller break; 128015c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 128115c9705fSDavid Hildenbrand ret = kvm_s390_get_processor_feat(kvm, attr); 128215c9705fSDavid Hildenbrand break; 128315c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_FEAT: 128415c9705fSDavid Hildenbrand ret = kvm_s390_get_machine_feat(kvm, attr); 128515c9705fSDavid Hildenbrand break; 12860a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 12870a763c78SDavid Hildenbrand ret = kvm_s390_get_processor_subfunc(kvm, attr); 12880a763c78SDavid Hildenbrand break; 12890a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_SUBFUNC: 12900a763c78SDavid Hildenbrand ret = kvm_s390_get_machine_subfunc(kvm, attr); 12910a763c78SDavid Hildenbrand break; 1292658b6edaSMichael Mueller } 1293658b6edaSMichael Mueller return ret; 1294658b6edaSMichael Mueller } 1295658b6edaSMichael Mueller 1296f2061656SDominik Dingel static int kvm_s390_vm_set_attr(struct kvm *kvm, struct kvm_device_attr *attr) 1297f2061656SDominik Dingel { 1298f2061656SDominik Dingel int ret; 1299f2061656SDominik Dingel 1300f2061656SDominik Dingel switch (attr->group) { 13014f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 13028c0a7ce6SDominik Dingel ret = kvm_s390_set_mem_control(kvm, attr); 13034f718eabSDominik Dingel break; 130472f25020SJason J. Herne case KVM_S390_VM_TOD: 130572f25020SJason J. Herne ret = kvm_s390_set_tod(kvm, attr); 130672f25020SJason J. Herne break; 1307658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 1308658b6edaSMichael Mueller ret = kvm_s390_set_cpu_model(kvm, attr); 1309658b6edaSMichael Mueller break; 1310a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 1311a374e892STony Krowiak ret = kvm_s390_vm_set_crypto(kvm, attr); 1312a374e892STony Krowiak break; 1313190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION: 1314190df4a2SClaudio Imbrenda ret = kvm_s390_vm_set_migration(kvm, attr); 1315190df4a2SClaudio Imbrenda break; 1316f2061656SDominik Dingel default: 1317f2061656SDominik Dingel ret = -ENXIO; 1318f2061656SDominik Dingel break; 1319f2061656SDominik Dingel } 1320f2061656SDominik Dingel 1321f2061656SDominik Dingel return ret; 1322f2061656SDominik Dingel } 1323f2061656SDominik Dingel 1324f2061656SDominik Dingel static int kvm_s390_vm_get_attr(struct kvm *kvm, struct kvm_device_attr *attr) 1325f2061656SDominik Dingel { 13268c0a7ce6SDominik Dingel int ret; 13278c0a7ce6SDominik Dingel 13288c0a7ce6SDominik Dingel switch (attr->group) { 13298c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_CTRL: 13308c0a7ce6SDominik Dingel ret = kvm_s390_get_mem_control(kvm, attr); 13318c0a7ce6SDominik Dingel break; 133272f25020SJason J. Herne case KVM_S390_VM_TOD: 133372f25020SJason J. Herne ret = kvm_s390_get_tod(kvm, attr); 133472f25020SJason J. Herne break; 1335658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 1336658b6edaSMichael Mueller ret = kvm_s390_get_cpu_model(kvm, attr); 1337658b6edaSMichael Mueller break; 1338190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION: 1339190df4a2SClaudio Imbrenda ret = kvm_s390_vm_get_migration(kvm, attr); 1340190df4a2SClaudio Imbrenda break; 13418c0a7ce6SDominik Dingel default: 13428c0a7ce6SDominik Dingel ret = -ENXIO; 13438c0a7ce6SDominik Dingel break; 13448c0a7ce6SDominik Dingel } 13458c0a7ce6SDominik Dingel 13468c0a7ce6SDominik Dingel return ret; 1347f2061656SDominik Dingel } 1348f2061656SDominik Dingel 1349f2061656SDominik Dingel static int kvm_s390_vm_has_attr(struct kvm *kvm, struct kvm_device_attr *attr) 1350f2061656SDominik Dingel { 1351f2061656SDominik Dingel int ret; 1352f2061656SDominik Dingel 1353f2061656SDominik Dingel switch (attr->group) { 13544f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 13554f718eabSDominik Dingel switch (attr->attr) { 13564f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 13574f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 1358f9cbd9b0SDavid Hildenbrand ret = sclp.has_cmma ? 0 : -ENXIO; 1359f9cbd9b0SDavid Hildenbrand break; 13608c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 13614f718eabSDominik Dingel ret = 0; 13624f718eabSDominik Dingel break; 13634f718eabSDominik Dingel default: 13644f718eabSDominik Dingel ret = -ENXIO; 13654f718eabSDominik Dingel break; 13664f718eabSDominik Dingel } 13674f718eabSDominik Dingel break; 136872f25020SJason J. Herne case KVM_S390_VM_TOD: 136972f25020SJason J. Herne switch (attr->attr) { 137072f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 137172f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 137272f25020SJason J. Herne ret = 0; 137372f25020SJason J. Herne break; 137472f25020SJason J. Herne default: 137572f25020SJason J. Herne ret = -ENXIO; 137672f25020SJason J. Herne break; 137772f25020SJason J. Herne } 137872f25020SJason J. Herne break; 1379658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 1380658b6edaSMichael Mueller switch (attr->attr) { 1381658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 1382658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 138315c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 138415c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_FEAT: 13850a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_SUBFUNC: 1386658b6edaSMichael Mueller ret = 0; 1387658b6edaSMichael Mueller break; 13880a763c78SDavid Hildenbrand /* configuring subfunctions is not supported yet */ 13890a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 1390658b6edaSMichael Mueller default: 1391658b6edaSMichael Mueller ret = -ENXIO; 1392658b6edaSMichael Mueller break; 1393658b6edaSMichael Mueller } 1394658b6edaSMichael Mueller break; 1395a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 1396a374e892STony Krowiak switch (attr->attr) { 1397a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 1398a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 1399a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 1400a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 1401a374e892STony Krowiak ret = 0; 1402a374e892STony Krowiak break; 1403a374e892STony Krowiak default: 1404a374e892STony Krowiak ret = -ENXIO; 1405a374e892STony Krowiak break; 1406a374e892STony Krowiak } 1407a374e892STony Krowiak break; 1408190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION: 1409190df4a2SClaudio Imbrenda ret = 0; 1410190df4a2SClaudio Imbrenda break; 1411f2061656SDominik Dingel default: 1412f2061656SDominik Dingel ret = -ENXIO; 1413f2061656SDominik Dingel break; 1414f2061656SDominik Dingel } 1415f2061656SDominik Dingel 1416f2061656SDominik Dingel return ret; 1417f2061656SDominik Dingel } 1418f2061656SDominik Dingel 141930ee2a98SJason J. Herne static long kvm_s390_get_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 142030ee2a98SJason J. Herne { 142130ee2a98SJason J. Herne uint8_t *keys; 142230ee2a98SJason J. Herne uint64_t hva; 14234f899147SChristian Borntraeger int srcu_idx, i, r = 0; 142430ee2a98SJason J. Herne 142530ee2a98SJason J. Herne if (args->flags != 0) 142630ee2a98SJason J. Herne return -EINVAL; 142730ee2a98SJason J. Herne 142830ee2a98SJason J. Herne /* Is this guest using storage keys? */ 142930ee2a98SJason J. Herne if (!mm_use_skey(current->mm)) 143030ee2a98SJason J. Herne return KVM_S390_GET_SKEYS_NONE; 143130ee2a98SJason J. Herne 143230ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 143330ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 143430ee2a98SJason J. Herne return -EINVAL; 143530ee2a98SJason J. Herne 1436752ade68SMichal Hocko keys = kvmalloc_array(args->count, sizeof(uint8_t), GFP_KERNEL); 143730ee2a98SJason J. Herne if (!keys) 143830ee2a98SJason J. Herne return -ENOMEM; 143930ee2a98SJason J. Herne 1440d3ed1ceeSMartin Schwidefsky down_read(¤t->mm->mmap_sem); 14414f899147SChristian Borntraeger srcu_idx = srcu_read_lock(&kvm->srcu); 144230ee2a98SJason J. Herne for (i = 0; i < args->count; i++) { 144330ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 144430ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 144530ee2a98SJason J. Herne r = -EFAULT; 1446d3ed1ceeSMartin Schwidefsky break; 144730ee2a98SJason J. Herne } 144830ee2a98SJason J. Herne 1449154c8c19SDavid Hildenbrand r = get_guest_storage_key(current->mm, hva, &keys[i]); 1450154c8c19SDavid Hildenbrand if (r) 1451d3ed1ceeSMartin Schwidefsky break; 145230ee2a98SJason J. Herne } 14534f899147SChristian Borntraeger srcu_read_unlock(&kvm->srcu, srcu_idx); 1454d3ed1ceeSMartin Schwidefsky up_read(¤t->mm->mmap_sem); 145530ee2a98SJason J. Herne 1456d3ed1ceeSMartin Schwidefsky if (!r) { 145730ee2a98SJason J. Herne r = copy_to_user((uint8_t __user *)args->skeydata_addr, keys, 145830ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 145930ee2a98SJason J. Herne if (r) 146030ee2a98SJason J. Herne r = -EFAULT; 1461d3ed1ceeSMartin Schwidefsky } 1462d3ed1ceeSMartin Schwidefsky 146330ee2a98SJason J. Herne kvfree(keys); 146430ee2a98SJason J. Herne return r; 146530ee2a98SJason J. Herne } 146630ee2a98SJason J. Herne 146730ee2a98SJason J. Herne static long kvm_s390_set_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 146830ee2a98SJason J. Herne { 146930ee2a98SJason J. Herne uint8_t *keys; 147030ee2a98SJason J. Herne uint64_t hva; 14714f899147SChristian Borntraeger int srcu_idx, i, r = 0; 147230ee2a98SJason J. Herne 147330ee2a98SJason J. Herne if (args->flags != 0) 147430ee2a98SJason J. Herne return -EINVAL; 147530ee2a98SJason J. Herne 147630ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 147730ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 147830ee2a98SJason J. Herne return -EINVAL; 147930ee2a98SJason J. Herne 1480752ade68SMichal Hocko keys = kvmalloc_array(args->count, sizeof(uint8_t), GFP_KERNEL); 148130ee2a98SJason J. Herne if (!keys) 148230ee2a98SJason J. Herne return -ENOMEM; 148330ee2a98SJason J. Herne 148430ee2a98SJason J. Herne r = copy_from_user(keys, (uint8_t __user *)args->skeydata_addr, 148530ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 148630ee2a98SJason J. Herne if (r) { 148730ee2a98SJason J. Herne r = -EFAULT; 148830ee2a98SJason J. Herne goto out; 148930ee2a98SJason J. Herne } 149030ee2a98SJason J. Herne 149130ee2a98SJason J. Herne /* Enable storage key handling for the guest */ 149214d4a425SDominik Dingel r = s390_enable_skey(); 149314d4a425SDominik Dingel if (r) 149414d4a425SDominik Dingel goto out; 149530ee2a98SJason J. Herne 1496d3ed1ceeSMartin Schwidefsky down_read(¤t->mm->mmap_sem); 14974f899147SChristian Borntraeger srcu_idx = srcu_read_lock(&kvm->srcu); 149830ee2a98SJason J. Herne for (i = 0; i < args->count; i++) { 149930ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 150030ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 150130ee2a98SJason J. Herne r = -EFAULT; 1502d3ed1ceeSMartin Schwidefsky break; 150330ee2a98SJason J. Herne } 150430ee2a98SJason J. Herne 150530ee2a98SJason J. Herne /* Lowest order bit is reserved */ 150630ee2a98SJason J. Herne if (keys[i] & 0x01) { 150730ee2a98SJason J. Herne r = -EINVAL; 1508d3ed1ceeSMartin Schwidefsky break; 150930ee2a98SJason J. Herne } 151030ee2a98SJason J. Herne 1511fe69eabfSDavid Hildenbrand r = set_guest_storage_key(current->mm, hva, keys[i], 0); 151230ee2a98SJason J. Herne if (r) 1513d3ed1ceeSMartin Schwidefsky break; 151430ee2a98SJason J. Herne } 15154f899147SChristian Borntraeger srcu_read_unlock(&kvm->srcu, srcu_idx); 1516d3ed1ceeSMartin Schwidefsky up_read(¤t->mm->mmap_sem); 151730ee2a98SJason J. Herne out: 151830ee2a98SJason J. Herne kvfree(keys); 151930ee2a98SJason J. Herne return r; 152030ee2a98SJason J. Herne } 152130ee2a98SJason J. Herne 15224036e387SClaudio Imbrenda /* 15234036e387SClaudio Imbrenda * Base address and length must be sent at the start of each block, therefore 15244036e387SClaudio Imbrenda * it's cheaper to send some clean data, as long as it's less than the size of 15254036e387SClaudio Imbrenda * two longs. 15264036e387SClaudio Imbrenda */ 15274036e387SClaudio Imbrenda #define KVM_S390_MAX_BIT_DISTANCE (2 * sizeof(void *)) 15284036e387SClaudio Imbrenda /* for consistency */ 15294036e387SClaudio Imbrenda #define KVM_S390_CMMA_SIZE_MAX ((u32)KVM_S390_SKEYS_MAX) 15304036e387SClaudio Imbrenda 15314036e387SClaudio Imbrenda /* 15324036e387SClaudio Imbrenda * This function searches for the next page with dirty CMMA attributes, and 15334036e387SClaudio Imbrenda * saves the attributes in the buffer up to either the end of the buffer or 15344036e387SClaudio Imbrenda * until a block of at least KVM_S390_MAX_BIT_DISTANCE clean bits is found; 15354036e387SClaudio Imbrenda * no trailing clean bytes are saved. 15364036e387SClaudio Imbrenda * In case no dirty bits were found, or if CMMA was not enabled or used, the 15374036e387SClaudio Imbrenda * output buffer will indicate 0 as length. 15384036e387SClaudio Imbrenda */ 15394036e387SClaudio Imbrenda static int kvm_s390_get_cmma_bits(struct kvm *kvm, 15404036e387SClaudio Imbrenda struct kvm_s390_cmma_log *args) 15414036e387SClaudio Imbrenda { 15424036e387SClaudio Imbrenda struct kvm_s390_migration_state *s = kvm->arch.migration_state; 15434036e387SClaudio Imbrenda unsigned long bufsize, hva, pgstev, i, next, cur; 15444036e387SClaudio Imbrenda int srcu_idx, peek, r = 0, rr; 15454036e387SClaudio Imbrenda u8 *res; 15464036e387SClaudio Imbrenda 15474036e387SClaudio Imbrenda cur = args->start_gfn; 15484036e387SClaudio Imbrenda i = next = pgstev = 0; 15494036e387SClaudio Imbrenda 15504036e387SClaudio Imbrenda if (unlikely(!kvm->arch.use_cmma)) 15514036e387SClaudio Imbrenda return -ENXIO; 15524036e387SClaudio Imbrenda /* Invalid/unsupported flags were specified */ 15534036e387SClaudio Imbrenda if (args->flags & ~KVM_S390_CMMA_PEEK) 15544036e387SClaudio Imbrenda return -EINVAL; 15554036e387SClaudio Imbrenda /* Migration mode query, and we are not doing a migration */ 15564036e387SClaudio Imbrenda peek = !!(args->flags & KVM_S390_CMMA_PEEK); 15574036e387SClaudio Imbrenda if (!peek && !s) 15584036e387SClaudio Imbrenda return -EINVAL; 15594036e387SClaudio Imbrenda /* CMMA is disabled or was not used, or the buffer has length zero */ 15604036e387SClaudio Imbrenda bufsize = min(args->count, KVM_S390_CMMA_SIZE_MAX); 15614036e387SClaudio Imbrenda if (!bufsize || !kvm->mm->context.use_cmma) { 15624036e387SClaudio Imbrenda memset(args, 0, sizeof(*args)); 15634036e387SClaudio Imbrenda return 0; 15644036e387SClaudio Imbrenda } 15654036e387SClaudio Imbrenda 15664036e387SClaudio Imbrenda if (!peek) { 15674036e387SClaudio Imbrenda /* We are not peeking, and there are no dirty pages */ 15684036e387SClaudio Imbrenda if (!atomic64_read(&s->dirty_pages)) { 15694036e387SClaudio Imbrenda memset(args, 0, sizeof(*args)); 15704036e387SClaudio Imbrenda return 0; 15714036e387SClaudio Imbrenda } 15724036e387SClaudio Imbrenda cur = find_next_bit(s->pgste_bitmap, s->bitmap_size, 15734036e387SClaudio Imbrenda args->start_gfn); 15744036e387SClaudio Imbrenda if (cur >= s->bitmap_size) /* nothing found, loop back */ 15754036e387SClaudio Imbrenda cur = find_next_bit(s->pgste_bitmap, s->bitmap_size, 0); 15764036e387SClaudio Imbrenda if (cur >= s->bitmap_size) { /* again! (very unlikely) */ 15774036e387SClaudio Imbrenda memset(args, 0, sizeof(*args)); 15784036e387SClaudio Imbrenda return 0; 15794036e387SClaudio Imbrenda } 15804036e387SClaudio Imbrenda next = find_next_bit(s->pgste_bitmap, s->bitmap_size, cur + 1); 15814036e387SClaudio Imbrenda } 15824036e387SClaudio Imbrenda 15834036e387SClaudio Imbrenda res = vmalloc(bufsize); 15844036e387SClaudio Imbrenda if (!res) 15854036e387SClaudio Imbrenda return -ENOMEM; 15864036e387SClaudio Imbrenda 15874036e387SClaudio Imbrenda args->start_gfn = cur; 15884036e387SClaudio Imbrenda 15894036e387SClaudio Imbrenda down_read(&kvm->mm->mmap_sem); 15904036e387SClaudio Imbrenda srcu_idx = srcu_read_lock(&kvm->srcu); 15914036e387SClaudio Imbrenda while (i < bufsize) { 15924036e387SClaudio Imbrenda hva = gfn_to_hva(kvm, cur); 15934036e387SClaudio Imbrenda if (kvm_is_error_hva(hva)) { 15944036e387SClaudio Imbrenda r = -EFAULT; 15954036e387SClaudio Imbrenda break; 15964036e387SClaudio Imbrenda } 15974036e387SClaudio Imbrenda /* decrement only if we actually flipped the bit to 0 */ 15984036e387SClaudio Imbrenda if (!peek && test_and_clear_bit(cur, s->pgste_bitmap)) 15994036e387SClaudio Imbrenda atomic64_dec(&s->dirty_pages); 16004036e387SClaudio Imbrenda r = get_pgste(kvm->mm, hva, &pgstev); 16014036e387SClaudio Imbrenda if (r < 0) 16024036e387SClaudio Imbrenda pgstev = 0; 16034036e387SClaudio Imbrenda /* save the value */ 16041bab1c02SClaudio Imbrenda res[i++] = (pgstev >> 24) & 0x43; 16054036e387SClaudio Imbrenda /* 16064036e387SClaudio Imbrenda * if the next bit is too far away, stop. 16074036e387SClaudio Imbrenda * if we reached the previous "next", find the next one 16084036e387SClaudio Imbrenda */ 16094036e387SClaudio Imbrenda if (!peek) { 16104036e387SClaudio Imbrenda if (next > cur + KVM_S390_MAX_BIT_DISTANCE) 16114036e387SClaudio Imbrenda break; 16124036e387SClaudio Imbrenda if (cur == next) 16134036e387SClaudio Imbrenda next = find_next_bit(s->pgste_bitmap, 16144036e387SClaudio Imbrenda s->bitmap_size, cur + 1); 16154036e387SClaudio Imbrenda /* reached the end of the bitmap or of the buffer, stop */ 16164036e387SClaudio Imbrenda if ((next >= s->bitmap_size) || 16174036e387SClaudio Imbrenda (next >= args->start_gfn + bufsize)) 16184036e387SClaudio Imbrenda break; 16194036e387SClaudio Imbrenda } 16204036e387SClaudio Imbrenda cur++; 16214036e387SClaudio Imbrenda } 16224036e387SClaudio Imbrenda srcu_read_unlock(&kvm->srcu, srcu_idx); 16234036e387SClaudio Imbrenda up_read(&kvm->mm->mmap_sem); 16244036e387SClaudio Imbrenda args->count = i; 16254036e387SClaudio Imbrenda args->remaining = s ? atomic64_read(&s->dirty_pages) : 0; 16264036e387SClaudio Imbrenda 16274036e387SClaudio Imbrenda rr = copy_to_user((void __user *)args->values, res, args->count); 16284036e387SClaudio Imbrenda if (rr) 16294036e387SClaudio Imbrenda r = -EFAULT; 16304036e387SClaudio Imbrenda 16314036e387SClaudio Imbrenda vfree(res); 16324036e387SClaudio Imbrenda return r; 16334036e387SClaudio Imbrenda } 16344036e387SClaudio Imbrenda 16354036e387SClaudio Imbrenda /* 16364036e387SClaudio Imbrenda * This function sets the CMMA attributes for the given pages. If the input 16374036e387SClaudio Imbrenda * buffer has zero length, no action is taken, otherwise the attributes are 16384036e387SClaudio Imbrenda * set and the mm->context.use_cmma flag is set. 16394036e387SClaudio Imbrenda */ 16404036e387SClaudio Imbrenda static int kvm_s390_set_cmma_bits(struct kvm *kvm, 16414036e387SClaudio Imbrenda const struct kvm_s390_cmma_log *args) 16424036e387SClaudio Imbrenda { 16434036e387SClaudio Imbrenda unsigned long hva, mask, pgstev, i; 16444036e387SClaudio Imbrenda uint8_t *bits; 16454036e387SClaudio Imbrenda int srcu_idx, r = 0; 16464036e387SClaudio Imbrenda 16474036e387SClaudio Imbrenda mask = args->mask; 16484036e387SClaudio Imbrenda 16494036e387SClaudio Imbrenda if (!kvm->arch.use_cmma) 16504036e387SClaudio Imbrenda return -ENXIO; 16514036e387SClaudio Imbrenda /* invalid/unsupported flags */ 16524036e387SClaudio Imbrenda if (args->flags != 0) 16534036e387SClaudio Imbrenda return -EINVAL; 16544036e387SClaudio Imbrenda /* Enforce sane limit on memory allocation */ 16554036e387SClaudio Imbrenda if (args->count > KVM_S390_CMMA_SIZE_MAX) 16564036e387SClaudio Imbrenda return -EINVAL; 16574036e387SClaudio Imbrenda /* Nothing to do */ 16584036e387SClaudio Imbrenda if (args->count == 0) 16594036e387SClaudio Imbrenda return 0; 16604036e387SClaudio Imbrenda 16614036e387SClaudio Imbrenda bits = vmalloc(sizeof(*bits) * args->count); 16624036e387SClaudio Imbrenda if (!bits) 16634036e387SClaudio Imbrenda return -ENOMEM; 16644036e387SClaudio Imbrenda 16654036e387SClaudio Imbrenda r = copy_from_user(bits, (void __user *)args->values, args->count); 16664036e387SClaudio Imbrenda if (r) { 16674036e387SClaudio Imbrenda r = -EFAULT; 16684036e387SClaudio Imbrenda goto out; 16694036e387SClaudio Imbrenda } 16704036e387SClaudio Imbrenda 16714036e387SClaudio Imbrenda down_read(&kvm->mm->mmap_sem); 16724036e387SClaudio Imbrenda srcu_idx = srcu_read_lock(&kvm->srcu); 16734036e387SClaudio Imbrenda for (i = 0; i < args->count; i++) { 16744036e387SClaudio Imbrenda hva = gfn_to_hva(kvm, args->start_gfn + i); 16754036e387SClaudio Imbrenda if (kvm_is_error_hva(hva)) { 16764036e387SClaudio Imbrenda r = -EFAULT; 16774036e387SClaudio Imbrenda break; 16784036e387SClaudio Imbrenda } 16794036e387SClaudio Imbrenda 16804036e387SClaudio Imbrenda pgstev = bits[i]; 16814036e387SClaudio Imbrenda pgstev = pgstev << 24; 16821bab1c02SClaudio Imbrenda mask &= _PGSTE_GPS_USAGE_MASK | _PGSTE_GPS_NODAT; 16834036e387SClaudio Imbrenda set_pgste_bits(kvm->mm, hva, mask, pgstev); 16844036e387SClaudio Imbrenda } 16854036e387SClaudio Imbrenda srcu_read_unlock(&kvm->srcu, srcu_idx); 16864036e387SClaudio Imbrenda up_read(&kvm->mm->mmap_sem); 16874036e387SClaudio Imbrenda 16884036e387SClaudio Imbrenda if (!kvm->mm->context.use_cmma) { 16894036e387SClaudio Imbrenda down_write(&kvm->mm->mmap_sem); 16904036e387SClaudio Imbrenda kvm->mm->context.use_cmma = 1; 16914036e387SClaudio Imbrenda up_write(&kvm->mm->mmap_sem); 16924036e387SClaudio Imbrenda } 16934036e387SClaudio Imbrenda out: 16944036e387SClaudio Imbrenda vfree(bits); 16954036e387SClaudio Imbrenda return r; 16964036e387SClaudio Imbrenda } 16974036e387SClaudio Imbrenda 1698b0c632dbSHeiko Carstens long kvm_arch_vm_ioctl(struct file *filp, 1699b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 1700b0c632dbSHeiko Carstens { 1701b0c632dbSHeiko Carstens struct kvm *kvm = filp->private_data; 1702b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 1703f2061656SDominik Dingel struct kvm_device_attr attr; 1704b0c632dbSHeiko Carstens int r; 1705b0c632dbSHeiko Carstens 1706b0c632dbSHeiko Carstens switch (ioctl) { 1707ba5c1e9bSCarsten Otte case KVM_S390_INTERRUPT: { 1708ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 1709ba5c1e9bSCarsten Otte 1710ba5c1e9bSCarsten Otte r = -EFAULT; 1711ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 1712ba5c1e9bSCarsten Otte break; 1713ba5c1e9bSCarsten Otte r = kvm_s390_inject_vm(kvm, &s390int); 1714ba5c1e9bSCarsten Otte break; 1715ba5c1e9bSCarsten Otte } 1716d938dc55SCornelia Huck case KVM_ENABLE_CAP: { 1717d938dc55SCornelia Huck struct kvm_enable_cap cap; 1718d938dc55SCornelia Huck r = -EFAULT; 1719d938dc55SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 1720d938dc55SCornelia Huck break; 1721d938dc55SCornelia Huck r = kvm_vm_ioctl_enable_cap(kvm, &cap); 1722d938dc55SCornelia Huck break; 1723d938dc55SCornelia Huck } 172484223598SCornelia Huck case KVM_CREATE_IRQCHIP: { 172584223598SCornelia Huck struct kvm_irq_routing_entry routing; 172684223598SCornelia Huck 172784223598SCornelia Huck r = -EINVAL; 172884223598SCornelia Huck if (kvm->arch.use_irqchip) { 172984223598SCornelia Huck /* Set up dummy routing. */ 173084223598SCornelia Huck memset(&routing, 0, sizeof(routing)); 1731152b2839SNicholas Krause r = kvm_set_irq_routing(kvm, &routing, 0, 0); 173284223598SCornelia Huck } 173384223598SCornelia Huck break; 173484223598SCornelia Huck } 1735f2061656SDominik Dingel case KVM_SET_DEVICE_ATTR: { 1736f2061656SDominik Dingel r = -EFAULT; 1737f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 1738f2061656SDominik Dingel break; 1739f2061656SDominik Dingel r = kvm_s390_vm_set_attr(kvm, &attr); 1740f2061656SDominik Dingel break; 1741f2061656SDominik Dingel } 1742f2061656SDominik Dingel case KVM_GET_DEVICE_ATTR: { 1743f2061656SDominik Dingel r = -EFAULT; 1744f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 1745f2061656SDominik Dingel break; 1746f2061656SDominik Dingel r = kvm_s390_vm_get_attr(kvm, &attr); 1747f2061656SDominik Dingel break; 1748f2061656SDominik Dingel } 1749f2061656SDominik Dingel case KVM_HAS_DEVICE_ATTR: { 1750f2061656SDominik Dingel r = -EFAULT; 1751f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 1752f2061656SDominik Dingel break; 1753f2061656SDominik Dingel r = kvm_s390_vm_has_attr(kvm, &attr); 1754f2061656SDominik Dingel break; 1755f2061656SDominik Dingel } 175630ee2a98SJason J. Herne case KVM_S390_GET_SKEYS: { 175730ee2a98SJason J. Herne struct kvm_s390_skeys args; 175830ee2a98SJason J. Herne 175930ee2a98SJason J. Herne r = -EFAULT; 176030ee2a98SJason J. Herne if (copy_from_user(&args, argp, 176130ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 176230ee2a98SJason J. Herne break; 176330ee2a98SJason J. Herne r = kvm_s390_get_skeys(kvm, &args); 176430ee2a98SJason J. Herne break; 176530ee2a98SJason J. Herne } 176630ee2a98SJason J. Herne case KVM_S390_SET_SKEYS: { 176730ee2a98SJason J. Herne struct kvm_s390_skeys args; 176830ee2a98SJason J. Herne 176930ee2a98SJason J. Herne r = -EFAULT; 177030ee2a98SJason J. Herne if (copy_from_user(&args, argp, 177130ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 177230ee2a98SJason J. Herne break; 177330ee2a98SJason J. Herne r = kvm_s390_set_skeys(kvm, &args); 177430ee2a98SJason J. Herne break; 177530ee2a98SJason J. Herne } 17764036e387SClaudio Imbrenda case KVM_S390_GET_CMMA_BITS: { 17774036e387SClaudio Imbrenda struct kvm_s390_cmma_log args; 17784036e387SClaudio Imbrenda 17794036e387SClaudio Imbrenda r = -EFAULT; 17804036e387SClaudio Imbrenda if (copy_from_user(&args, argp, sizeof(args))) 17814036e387SClaudio Imbrenda break; 17821de1ea7eSChristian Borntraeger mutex_lock(&kvm->slots_lock); 17834036e387SClaudio Imbrenda r = kvm_s390_get_cmma_bits(kvm, &args); 17841de1ea7eSChristian Borntraeger mutex_unlock(&kvm->slots_lock); 17854036e387SClaudio Imbrenda if (!r) { 17864036e387SClaudio Imbrenda r = copy_to_user(argp, &args, sizeof(args)); 17874036e387SClaudio Imbrenda if (r) 17884036e387SClaudio Imbrenda r = -EFAULT; 17894036e387SClaudio Imbrenda } 17904036e387SClaudio Imbrenda break; 17914036e387SClaudio Imbrenda } 17924036e387SClaudio Imbrenda case KVM_S390_SET_CMMA_BITS: { 17934036e387SClaudio Imbrenda struct kvm_s390_cmma_log args; 17944036e387SClaudio Imbrenda 17954036e387SClaudio Imbrenda r = -EFAULT; 17964036e387SClaudio Imbrenda if (copy_from_user(&args, argp, sizeof(args))) 17974036e387SClaudio Imbrenda break; 17981de1ea7eSChristian Borntraeger mutex_lock(&kvm->slots_lock); 17994036e387SClaudio Imbrenda r = kvm_s390_set_cmma_bits(kvm, &args); 18001de1ea7eSChristian Borntraeger mutex_unlock(&kvm->slots_lock); 18014036e387SClaudio Imbrenda break; 18024036e387SClaudio Imbrenda } 1803b0c632dbSHeiko Carstens default: 1804367e1319SAvi Kivity r = -ENOTTY; 1805b0c632dbSHeiko Carstens } 1806b0c632dbSHeiko Carstens 1807b0c632dbSHeiko Carstens return r; 1808b0c632dbSHeiko Carstens } 1809b0c632dbSHeiko Carstens 181045c9b47cSTony Krowiak static int kvm_s390_query_ap_config(u8 *config) 181145c9b47cSTony Krowiak { 181245c9b47cSTony Krowiak u32 fcn_code = 0x04000000UL; 181386044c8cSChristian Borntraeger u32 cc = 0; 181445c9b47cSTony Krowiak 181586044c8cSChristian Borntraeger memset(config, 0, 128); 181645c9b47cSTony Krowiak asm volatile( 181745c9b47cSTony Krowiak "lgr 0,%1\n" 181845c9b47cSTony Krowiak "lgr 2,%2\n" 181945c9b47cSTony Krowiak ".long 0xb2af0000\n" /* PQAP(QCI) */ 182086044c8cSChristian Borntraeger "0: ipm %0\n" 182145c9b47cSTony Krowiak "srl %0,28\n" 182286044c8cSChristian Borntraeger "1:\n" 182386044c8cSChristian Borntraeger EX_TABLE(0b, 1b) 182486044c8cSChristian Borntraeger : "+r" (cc) 182545c9b47cSTony Krowiak : "r" (fcn_code), "r" (config) 182645c9b47cSTony Krowiak : "cc", "0", "2", "memory" 182745c9b47cSTony Krowiak ); 182845c9b47cSTony Krowiak 182945c9b47cSTony Krowiak return cc; 183045c9b47cSTony Krowiak } 183145c9b47cSTony Krowiak 183245c9b47cSTony Krowiak static int kvm_s390_apxa_installed(void) 183345c9b47cSTony Krowiak { 183445c9b47cSTony Krowiak u8 config[128]; 183545c9b47cSTony Krowiak int cc; 183645c9b47cSTony Krowiak 1837a6aacc3fSHeiko Carstens if (test_facility(12)) { 183845c9b47cSTony Krowiak cc = kvm_s390_query_ap_config(config); 183945c9b47cSTony Krowiak 184045c9b47cSTony Krowiak if (cc) 184145c9b47cSTony Krowiak pr_err("PQAP(QCI) failed with cc=%d", cc); 184245c9b47cSTony Krowiak else 184345c9b47cSTony Krowiak return config[0] & 0x40; 184445c9b47cSTony Krowiak } 184545c9b47cSTony Krowiak 184645c9b47cSTony Krowiak return 0; 184745c9b47cSTony Krowiak } 184845c9b47cSTony Krowiak 184945c9b47cSTony Krowiak static void kvm_s390_set_crycb_format(struct kvm *kvm) 185045c9b47cSTony Krowiak { 185145c9b47cSTony Krowiak kvm->arch.crypto.crycbd = (__u32)(unsigned long) kvm->arch.crypto.crycb; 185245c9b47cSTony Krowiak 185345c9b47cSTony Krowiak if (kvm_s390_apxa_installed()) 185445c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT2; 185545c9b47cSTony Krowiak else 185645c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT1; 185745c9b47cSTony Krowiak } 185845c9b47cSTony Krowiak 18599bb0ec09SDavid Hildenbrand static u64 kvm_s390_get_initial_cpuid(void) 18609d8d5786SMichael Mueller { 18619bb0ec09SDavid Hildenbrand struct cpuid cpuid; 18629bb0ec09SDavid Hildenbrand 18639bb0ec09SDavid Hildenbrand get_cpu_id(&cpuid); 18649bb0ec09SDavid Hildenbrand cpuid.version = 0xff; 18659bb0ec09SDavid Hildenbrand return *((u64 *) &cpuid); 18669d8d5786SMichael Mueller } 18679d8d5786SMichael Mueller 1868c54f0d6aSDavid Hildenbrand static void kvm_s390_crypto_init(struct kvm *kvm) 18695102ee87STony Krowiak { 18709d8d5786SMichael Mueller if (!test_kvm_facility(kvm, 76)) 1871c54f0d6aSDavid Hildenbrand return; 18725102ee87STony Krowiak 1873c54f0d6aSDavid Hildenbrand kvm->arch.crypto.crycb = &kvm->arch.sie_page2->crycb; 187445c9b47cSTony Krowiak kvm_s390_set_crycb_format(kvm); 18755102ee87STony Krowiak 1876ed6f76b4STony Krowiak /* Enable AES/DEA protected key functions by default */ 1877ed6f76b4STony Krowiak kvm->arch.crypto.aes_kw = 1; 1878ed6f76b4STony Krowiak kvm->arch.crypto.dea_kw = 1; 1879ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 1880ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 1881ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 1882ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 18835102ee87STony Krowiak } 18845102ee87STony Krowiak 18857d43bafcSEugene (jno) Dvurechenski static void sca_dispose(struct kvm *kvm) 18867d43bafcSEugene (jno) Dvurechenski { 18877d43bafcSEugene (jno) Dvurechenski if (kvm->arch.use_esca) 18885e044315SEugene (jno) Dvurechenski free_pages_exact(kvm->arch.sca, sizeof(struct esca_block)); 18897d43bafcSEugene (jno) Dvurechenski else 18907d43bafcSEugene (jno) Dvurechenski free_page((unsigned long)(kvm->arch.sca)); 18917d43bafcSEugene (jno) Dvurechenski kvm->arch.sca = NULL; 18927d43bafcSEugene (jno) Dvurechenski } 18937d43bafcSEugene (jno) Dvurechenski 1894e08b9637SCarsten Otte int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 1895b0c632dbSHeiko Carstens { 189676a6dd72SDavid Hildenbrand gfp_t alloc_flags = GFP_KERNEL; 18979d8d5786SMichael Mueller int i, rc; 1898b0c632dbSHeiko Carstens char debug_name[16]; 1899f6c137ffSChristian Borntraeger static unsigned long sca_offset; 1900b0c632dbSHeiko Carstens 1901e08b9637SCarsten Otte rc = -EINVAL; 1902e08b9637SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 1903e08b9637SCarsten Otte if (type & ~KVM_VM_S390_UCONTROL) 1904e08b9637SCarsten Otte goto out_err; 1905e08b9637SCarsten Otte if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN))) 1906e08b9637SCarsten Otte goto out_err; 1907e08b9637SCarsten Otte #else 1908e08b9637SCarsten Otte if (type) 1909e08b9637SCarsten Otte goto out_err; 1910e08b9637SCarsten Otte #endif 1911e08b9637SCarsten Otte 1912b0c632dbSHeiko Carstens rc = s390_enable_sie(); 1913b0c632dbSHeiko Carstens if (rc) 1914d89f5effSJan Kiszka goto out_err; 1915b0c632dbSHeiko Carstens 1916b290411aSCarsten Otte rc = -ENOMEM; 1917b290411aSCarsten Otte 19187d43bafcSEugene (jno) Dvurechenski kvm->arch.use_esca = 0; /* start with basic SCA */ 191976a6dd72SDavid Hildenbrand if (!sclp.has_64bscao) 192076a6dd72SDavid Hildenbrand alloc_flags |= GFP_DMA; 19215e044315SEugene (jno) Dvurechenski rwlock_init(&kvm->arch.sca_lock); 192276a6dd72SDavid Hildenbrand kvm->arch.sca = (struct bsca_block *) get_zeroed_page(alloc_flags); 1923b0c632dbSHeiko Carstens if (!kvm->arch.sca) 1924d89f5effSJan Kiszka goto out_err; 1925f6c137ffSChristian Borntraeger spin_lock(&kvm_lock); 1926c5c2c393SDavid Hildenbrand sca_offset += 16; 1927bc784cceSEugene (jno) Dvurechenski if (sca_offset + sizeof(struct bsca_block) > PAGE_SIZE) 1928c5c2c393SDavid Hildenbrand sca_offset = 0; 1929bc784cceSEugene (jno) Dvurechenski kvm->arch.sca = (struct bsca_block *) 1930bc784cceSEugene (jno) Dvurechenski ((char *) kvm->arch.sca + sca_offset); 1931f6c137ffSChristian Borntraeger spin_unlock(&kvm_lock); 1932b0c632dbSHeiko Carstens 1933b0c632dbSHeiko Carstens sprintf(debug_name, "kvm-%u", current->pid); 1934b0c632dbSHeiko Carstens 19351cb9cf72SChristian Borntraeger kvm->arch.dbf = debug_register(debug_name, 32, 1, 7 * sizeof(long)); 1936b0c632dbSHeiko Carstens if (!kvm->arch.dbf) 193740f5b735SDominik Dingel goto out_err; 1938b0c632dbSHeiko Carstens 193919114bebSMichael Mueller BUILD_BUG_ON(sizeof(struct sie_page2) != 4096); 1940c54f0d6aSDavid Hildenbrand kvm->arch.sie_page2 = 1941c54f0d6aSDavid Hildenbrand (struct sie_page2 *) get_zeroed_page(GFP_KERNEL | GFP_DMA); 1942c54f0d6aSDavid Hildenbrand if (!kvm->arch.sie_page2) 194340f5b735SDominik Dingel goto out_err; 19449d8d5786SMichael Mueller 1945fb5bf93fSMichael Mueller /* Populate the facility mask initially. */ 1946c54f0d6aSDavid Hildenbrand memcpy(kvm->arch.model.fac_mask, S390_lowcore.stfle_fac_list, 194704478197SChristian Borntraeger sizeof(S390_lowcore.stfle_fac_list)); 19489d8d5786SMichael Mueller for (i = 0; i < S390_ARCH_FAC_LIST_SIZE_U64; i++) { 19499d8d5786SMichael Mueller if (i < kvm_s390_fac_list_mask_size()) 1950c54f0d6aSDavid Hildenbrand kvm->arch.model.fac_mask[i] &= kvm_s390_fac_list_mask[i]; 19519d8d5786SMichael Mueller else 1952c54f0d6aSDavid Hildenbrand kvm->arch.model.fac_mask[i] = 0UL; 19539d8d5786SMichael Mueller } 19549d8d5786SMichael Mueller 1955981467c9SMichael Mueller /* Populate the facility list initially. */ 1956c54f0d6aSDavid Hildenbrand kvm->arch.model.fac_list = kvm->arch.sie_page2->fac_list; 1957c54f0d6aSDavid Hildenbrand memcpy(kvm->arch.model.fac_list, kvm->arch.model.fac_mask, 1958981467c9SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 1959981467c9SMichael Mueller 19601935222dSDavid Hildenbrand /* we are always in czam mode - even on pre z14 machines */ 19611935222dSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 138); 19621935222dSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 138); 19631935222dSDavid Hildenbrand /* we emulate STHYI in kvm */ 196495ca2cb5SJanosch Frank set_kvm_facility(kvm->arch.model.fac_mask, 74); 196595ca2cb5SJanosch Frank set_kvm_facility(kvm->arch.model.fac_list, 74); 19661bab1c02SClaudio Imbrenda if (MACHINE_HAS_TLB_GUEST) { 19671bab1c02SClaudio Imbrenda set_kvm_facility(kvm->arch.model.fac_mask, 147); 19681bab1c02SClaudio Imbrenda set_kvm_facility(kvm->arch.model.fac_list, 147); 19691bab1c02SClaudio Imbrenda } 197095ca2cb5SJanosch Frank 19719bb0ec09SDavid Hildenbrand kvm->arch.model.cpuid = kvm_s390_get_initial_cpuid(); 197237c5f6c8SDavid Hildenbrand kvm->arch.model.ibc = sclp.ibc & 0x0fff; 19739d8d5786SMichael Mueller 1974c54f0d6aSDavid Hildenbrand kvm_s390_crypto_init(kvm); 19755102ee87STony Krowiak 197651978393SFei Li mutex_init(&kvm->arch.float_int.ais_lock); 197751978393SFei Li kvm->arch.float_int.simm = 0; 197851978393SFei Li kvm->arch.float_int.nimm = 0; 1979ba5c1e9bSCarsten Otte spin_lock_init(&kvm->arch.float_int.lock); 19806d3da241SJens Freimann for (i = 0; i < FIRQ_LIST_COUNT; i++) 19816d3da241SJens Freimann INIT_LIST_HEAD(&kvm->arch.float_int.lists[i]); 19828a242234SHeiko Carstens init_waitqueue_head(&kvm->arch.ipte_wq); 1983a6b7e459SThomas Huth mutex_init(&kvm->arch.ipte_mutex); 1984ba5c1e9bSCarsten Otte 1985b0c632dbSHeiko Carstens debug_register_view(kvm->arch.dbf, &debug_sprintf_view); 198678f26131SChristian Borntraeger VM_EVENT(kvm, 3, "vm created with type %lu", type); 1987b0c632dbSHeiko Carstens 1988e08b9637SCarsten Otte if (type & KVM_VM_S390_UCONTROL) { 1989e08b9637SCarsten Otte kvm->arch.gmap = NULL; 1990a3a92c31SDominik Dingel kvm->arch.mem_limit = KVM_S390_NO_MEM_LIMIT; 1991e08b9637SCarsten Otte } else { 199232e6b236SGuenther Hutzl if (sclp.hamax == U64_MAX) 1993ee71d16dSMartin Schwidefsky kvm->arch.mem_limit = TASK_SIZE_MAX; 199432e6b236SGuenther Hutzl else 1995ee71d16dSMartin Schwidefsky kvm->arch.mem_limit = min_t(unsigned long, TASK_SIZE_MAX, 199632e6b236SGuenther Hutzl sclp.hamax + 1); 19976ea427bbSMartin Schwidefsky kvm->arch.gmap = gmap_create(current->mm, kvm->arch.mem_limit - 1); 1998598841caSCarsten Otte if (!kvm->arch.gmap) 199940f5b735SDominik Dingel goto out_err; 20002c70fe44SChristian Borntraeger kvm->arch.gmap->private = kvm; 200124eb3a82SDominik Dingel kvm->arch.gmap->pfault_enabled = 0; 2002e08b9637SCarsten Otte } 2003fa6b7fe9SCornelia Huck 2004fa6b7fe9SCornelia Huck kvm->arch.css_support = 0; 200584223598SCornelia Huck kvm->arch.use_irqchip = 0; 200672f25020SJason J. Herne kvm->arch.epoch = 0; 2007fa6b7fe9SCornelia Huck 20088ad35755SDavid Hildenbrand spin_lock_init(&kvm->arch.start_stop_lock); 2009a3508fbeSDavid Hildenbrand kvm_s390_vsie_init(kvm); 2010d7c5cb01SMichael Mueller kvm_s390_gisa_init(kvm); 20118335713aSChristian Borntraeger KVM_EVENT(3, "vm 0x%pK created by pid %u", kvm, current->pid); 20128ad35755SDavid Hildenbrand 2013d89f5effSJan Kiszka return 0; 2014d89f5effSJan Kiszka out_err: 2015c54f0d6aSDavid Hildenbrand free_page((unsigned long)kvm->arch.sie_page2); 201640f5b735SDominik Dingel debug_unregister(kvm->arch.dbf); 20177d43bafcSEugene (jno) Dvurechenski sca_dispose(kvm); 201878f26131SChristian Borntraeger KVM_EVENT(3, "creation of vm failed: %d", rc); 2019d89f5effSJan Kiszka return rc; 2020b0c632dbSHeiko Carstens } 2021b0c632dbSHeiko Carstens 2022235539b4SLuiz Capitulino bool kvm_arch_has_vcpu_debugfs(void) 2023235539b4SLuiz Capitulino { 2024235539b4SLuiz Capitulino return false; 2025235539b4SLuiz Capitulino } 2026235539b4SLuiz Capitulino 2027235539b4SLuiz Capitulino int kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu) 2028235539b4SLuiz Capitulino { 2029235539b4SLuiz Capitulino return 0; 2030235539b4SLuiz Capitulino } 2031235539b4SLuiz Capitulino 2032d329c035SChristian Borntraeger void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 2033d329c035SChristian Borntraeger { 2034d329c035SChristian Borntraeger VCPU_EVENT(vcpu, 3, "%s", "free cpu"); 2035ade38c31SCornelia Huck trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id); 203667335e63SChristian Borntraeger kvm_s390_clear_local_irqs(vcpu); 20373c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 2038bc784cceSEugene (jno) Dvurechenski if (!kvm_is_ucontrol(vcpu->kvm)) 2039a6e2f683SEugene (jno) Dvurechenski sca_del_vcpu(vcpu); 204027e0393fSCarsten Otte 204127e0393fSCarsten Otte if (kvm_is_ucontrol(vcpu->kvm)) 20426ea427bbSMartin Schwidefsky gmap_remove(vcpu->arch.gmap); 204327e0393fSCarsten Otte 2044e6db1d61SDominik Dingel if (vcpu->kvm->arch.use_cmma) 2045b31605c1SDominik Dingel kvm_s390_vcpu_unsetup_cmma(vcpu); 2046d329c035SChristian Borntraeger free_page((unsigned long)(vcpu->arch.sie_block)); 2047b31288faSKonstantin Weitz 20486692cef3SChristian Borntraeger kvm_vcpu_uninit(vcpu); 2049b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 2050d329c035SChristian Borntraeger } 2051d329c035SChristian Borntraeger 2052d329c035SChristian Borntraeger static void kvm_free_vcpus(struct kvm *kvm) 2053d329c035SChristian Borntraeger { 2054d329c035SChristian Borntraeger unsigned int i; 2055988a2caeSGleb Natapov struct kvm_vcpu *vcpu; 2056d329c035SChristian Borntraeger 2057988a2caeSGleb Natapov kvm_for_each_vcpu(i, vcpu, kvm) 2058988a2caeSGleb Natapov kvm_arch_vcpu_destroy(vcpu); 2059988a2caeSGleb Natapov 2060988a2caeSGleb Natapov mutex_lock(&kvm->lock); 2061988a2caeSGleb Natapov for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 2062d329c035SChristian Borntraeger kvm->vcpus[i] = NULL; 2063988a2caeSGleb Natapov 2064988a2caeSGleb Natapov atomic_set(&kvm->online_vcpus, 0); 2065988a2caeSGleb Natapov mutex_unlock(&kvm->lock); 2066d329c035SChristian Borntraeger } 2067d329c035SChristian Borntraeger 2068b0c632dbSHeiko Carstens void kvm_arch_destroy_vm(struct kvm *kvm) 2069b0c632dbSHeiko Carstens { 2070d329c035SChristian Borntraeger kvm_free_vcpus(kvm); 20717d43bafcSEugene (jno) Dvurechenski sca_dispose(kvm); 2072d329c035SChristian Borntraeger debug_unregister(kvm->arch.dbf); 2073d7c5cb01SMichael Mueller kvm_s390_gisa_destroy(kvm); 2074c54f0d6aSDavid Hildenbrand free_page((unsigned long)kvm->arch.sie_page2); 207527e0393fSCarsten Otte if (!kvm_is_ucontrol(kvm)) 20766ea427bbSMartin Schwidefsky gmap_remove(kvm->arch.gmap); 2077841b91c5SCornelia Huck kvm_s390_destroy_adapters(kvm); 207867335e63SChristian Borntraeger kvm_s390_clear_float_irqs(kvm); 2079a3508fbeSDavid Hildenbrand kvm_s390_vsie_destroy(kvm); 2080190df4a2SClaudio Imbrenda if (kvm->arch.migration_state) { 2081190df4a2SClaudio Imbrenda vfree(kvm->arch.migration_state->pgste_bitmap); 2082190df4a2SClaudio Imbrenda kfree(kvm->arch.migration_state); 2083190df4a2SClaudio Imbrenda } 20848335713aSChristian Borntraeger KVM_EVENT(3, "vm 0x%pK destroyed", kvm); 2085b0c632dbSHeiko Carstens } 2086b0c632dbSHeiko Carstens 2087b0c632dbSHeiko Carstens /* Section: vcpu related */ 2088dafd032aSDominik Dingel static int __kvm_ucontrol_vcpu_init(struct kvm_vcpu *vcpu) 2089b0c632dbSHeiko Carstens { 20906ea427bbSMartin Schwidefsky vcpu->arch.gmap = gmap_create(current->mm, -1UL); 209127e0393fSCarsten Otte if (!vcpu->arch.gmap) 209227e0393fSCarsten Otte return -ENOMEM; 20932c70fe44SChristian Borntraeger vcpu->arch.gmap->private = vcpu->kvm; 2094dafd032aSDominik Dingel 209527e0393fSCarsten Otte return 0; 209627e0393fSCarsten Otte } 209727e0393fSCarsten Otte 2098a6e2f683SEugene (jno) Dvurechenski static void sca_del_vcpu(struct kvm_vcpu *vcpu) 2099a6e2f683SEugene (jno) Dvurechenski { 2100a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) 2101a6940674SDavid Hildenbrand return; 21025e044315SEugene (jno) Dvurechenski read_lock(&vcpu->kvm->arch.sca_lock); 21037d43bafcSEugene (jno) Dvurechenski if (vcpu->kvm->arch.use_esca) { 21047d43bafcSEugene (jno) Dvurechenski struct esca_block *sca = vcpu->kvm->arch.sca; 21057d43bafcSEugene (jno) Dvurechenski 21067d43bafcSEugene (jno) Dvurechenski clear_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn); 21077d43bafcSEugene (jno) Dvurechenski sca->cpu[vcpu->vcpu_id].sda = 0; 21087d43bafcSEugene (jno) Dvurechenski } else { 2109bc784cceSEugene (jno) Dvurechenski struct bsca_block *sca = vcpu->kvm->arch.sca; 2110a6e2f683SEugene (jno) Dvurechenski 2111a6e2f683SEugene (jno) Dvurechenski clear_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn); 2112a6e2f683SEugene (jno) Dvurechenski sca->cpu[vcpu->vcpu_id].sda = 0; 2113a6e2f683SEugene (jno) Dvurechenski } 21145e044315SEugene (jno) Dvurechenski read_unlock(&vcpu->kvm->arch.sca_lock); 21157d43bafcSEugene (jno) Dvurechenski } 2116a6e2f683SEugene (jno) Dvurechenski 2117eaa78f34SDavid Hildenbrand static void sca_add_vcpu(struct kvm_vcpu *vcpu) 2118a6e2f683SEugene (jno) Dvurechenski { 2119a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) { 2120a6940674SDavid Hildenbrand struct bsca_block *sca = vcpu->kvm->arch.sca; 2121a6940674SDavid Hildenbrand 2122a6940674SDavid Hildenbrand /* we still need the basic sca for the ipte control */ 2123a6940674SDavid Hildenbrand vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 2124a6940674SDavid Hildenbrand vcpu->arch.sie_block->scaol = (__u32)(__u64)sca; 2125a6940674SDavid Hildenbrand } 2126eaa78f34SDavid Hildenbrand read_lock(&vcpu->kvm->arch.sca_lock); 2127eaa78f34SDavid Hildenbrand if (vcpu->kvm->arch.use_esca) { 2128eaa78f34SDavid Hildenbrand struct esca_block *sca = vcpu->kvm->arch.sca; 21297d43bafcSEugene (jno) Dvurechenski 2130eaa78f34SDavid Hildenbrand sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block; 21317d43bafcSEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 21327d43bafcSEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = (__u32)(__u64)sca & ~0x3fU; 21330c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= ECB2_ESCA; 2134eaa78f34SDavid Hildenbrand set_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn); 21357d43bafcSEugene (jno) Dvurechenski } else { 2136eaa78f34SDavid Hildenbrand struct bsca_block *sca = vcpu->kvm->arch.sca; 2137a6e2f683SEugene (jno) Dvurechenski 2138eaa78f34SDavid Hildenbrand sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block; 2139a6e2f683SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 2140a6e2f683SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = (__u32)(__u64)sca; 2141eaa78f34SDavid Hildenbrand set_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn); 2142a6e2f683SEugene (jno) Dvurechenski } 2143eaa78f34SDavid Hildenbrand read_unlock(&vcpu->kvm->arch.sca_lock); 21445e044315SEugene (jno) Dvurechenski } 21455e044315SEugene (jno) Dvurechenski 21465e044315SEugene (jno) Dvurechenski /* Basic SCA to Extended SCA data copy routines */ 21475e044315SEugene (jno) Dvurechenski static inline void sca_copy_entry(struct esca_entry *d, struct bsca_entry *s) 21485e044315SEugene (jno) Dvurechenski { 21495e044315SEugene (jno) Dvurechenski d->sda = s->sda; 21505e044315SEugene (jno) Dvurechenski d->sigp_ctrl.c = s->sigp_ctrl.c; 21515e044315SEugene (jno) Dvurechenski d->sigp_ctrl.scn = s->sigp_ctrl.scn; 21525e044315SEugene (jno) Dvurechenski } 21535e044315SEugene (jno) Dvurechenski 21545e044315SEugene (jno) Dvurechenski static void sca_copy_b_to_e(struct esca_block *d, struct bsca_block *s) 21555e044315SEugene (jno) Dvurechenski { 21565e044315SEugene (jno) Dvurechenski int i; 21575e044315SEugene (jno) Dvurechenski 21585e044315SEugene (jno) Dvurechenski d->ipte_control = s->ipte_control; 21595e044315SEugene (jno) Dvurechenski d->mcn[0] = s->mcn; 21605e044315SEugene (jno) Dvurechenski for (i = 0; i < KVM_S390_BSCA_CPU_SLOTS; i++) 21615e044315SEugene (jno) Dvurechenski sca_copy_entry(&d->cpu[i], &s->cpu[i]); 21625e044315SEugene (jno) Dvurechenski } 21635e044315SEugene (jno) Dvurechenski 21645e044315SEugene (jno) Dvurechenski static int sca_switch_to_extended(struct kvm *kvm) 21655e044315SEugene (jno) Dvurechenski { 21665e044315SEugene (jno) Dvurechenski struct bsca_block *old_sca = kvm->arch.sca; 21675e044315SEugene (jno) Dvurechenski struct esca_block *new_sca; 21685e044315SEugene (jno) Dvurechenski struct kvm_vcpu *vcpu; 21695e044315SEugene (jno) Dvurechenski unsigned int vcpu_idx; 21705e044315SEugene (jno) Dvurechenski u32 scaol, scaoh; 21715e044315SEugene (jno) Dvurechenski 21725e044315SEugene (jno) Dvurechenski new_sca = alloc_pages_exact(sizeof(*new_sca), GFP_KERNEL|__GFP_ZERO); 21735e044315SEugene (jno) Dvurechenski if (!new_sca) 21745e044315SEugene (jno) Dvurechenski return -ENOMEM; 21755e044315SEugene (jno) Dvurechenski 21765e044315SEugene (jno) Dvurechenski scaoh = (u32)((u64)(new_sca) >> 32); 21775e044315SEugene (jno) Dvurechenski scaol = (u32)(u64)(new_sca) & ~0x3fU; 21785e044315SEugene (jno) Dvurechenski 21795e044315SEugene (jno) Dvurechenski kvm_s390_vcpu_block_all(kvm); 21805e044315SEugene (jno) Dvurechenski write_lock(&kvm->arch.sca_lock); 21815e044315SEugene (jno) Dvurechenski 21825e044315SEugene (jno) Dvurechenski sca_copy_b_to_e(new_sca, old_sca); 21835e044315SEugene (jno) Dvurechenski 21845e044315SEugene (jno) Dvurechenski kvm_for_each_vcpu(vcpu_idx, vcpu, kvm) { 21855e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = scaoh; 21865e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = scaol; 21870c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= ECB2_ESCA; 21885e044315SEugene (jno) Dvurechenski } 21895e044315SEugene (jno) Dvurechenski kvm->arch.sca = new_sca; 21905e044315SEugene (jno) Dvurechenski kvm->arch.use_esca = 1; 21915e044315SEugene (jno) Dvurechenski 21925e044315SEugene (jno) Dvurechenski write_unlock(&kvm->arch.sca_lock); 21935e044315SEugene (jno) Dvurechenski kvm_s390_vcpu_unblock_all(kvm); 21945e044315SEugene (jno) Dvurechenski 21955e044315SEugene (jno) Dvurechenski free_page((unsigned long)old_sca); 21965e044315SEugene (jno) Dvurechenski 21978335713aSChristian Borntraeger VM_EVENT(kvm, 2, "Switched to ESCA (0x%pK -> 0x%pK)", 21988335713aSChristian Borntraeger old_sca, kvm->arch.sca); 21995e044315SEugene (jno) Dvurechenski return 0; 22007d43bafcSEugene (jno) Dvurechenski } 2201a6e2f683SEugene (jno) Dvurechenski 2202a6e2f683SEugene (jno) Dvurechenski static int sca_can_add_vcpu(struct kvm *kvm, unsigned int id) 2203a6e2f683SEugene (jno) Dvurechenski { 22045e044315SEugene (jno) Dvurechenski int rc; 22055e044315SEugene (jno) Dvurechenski 2206a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) { 2207a6940674SDavid Hildenbrand if (id < KVM_MAX_VCPUS) 2208a6940674SDavid Hildenbrand return true; 2209a6940674SDavid Hildenbrand return false; 2210a6940674SDavid Hildenbrand } 22115e044315SEugene (jno) Dvurechenski if (id < KVM_S390_BSCA_CPU_SLOTS) 22125e044315SEugene (jno) Dvurechenski return true; 221376a6dd72SDavid Hildenbrand if (!sclp.has_esca || !sclp.has_64bscao) 22145e044315SEugene (jno) Dvurechenski return false; 22155e044315SEugene (jno) Dvurechenski 22165e044315SEugene (jno) Dvurechenski mutex_lock(&kvm->lock); 22175e044315SEugene (jno) Dvurechenski rc = kvm->arch.use_esca ? 0 : sca_switch_to_extended(kvm); 22185e044315SEugene (jno) Dvurechenski mutex_unlock(&kvm->lock); 22195e044315SEugene (jno) Dvurechenski 22205e044315SEugene (jno) Dvurechenski return rc == 0 && id < KVM_S390_ESCA_CPU_SLOTS; 2221a6e2f683SEugene (jno) Dvurechenski } 2222a6e2f683SEugene (jno) Dvurechenski 2223dafd032aSDominik Dingel int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 2224dafd032aSDominik Dingel { 2225dafd032aSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 2226dafd032aSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 222759674c1aSChristian Borntraeger vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX | 222859674c1aSChristian Borntraeger KVM_SYNC_GPRS | 22299eed0735SChristian Borntraeger KVM_SYNC_ACRS | 2230b028ee3eSDavid Hildenbrand KVM_SYNC_CRS | 2231b028ee3eSDavid Hildenbrand KVM_SYNC_ARCH0 | 2232b028ee3eSDavid Hildenbrand KVM_SYNC_PFAULT; 223375a4615cSJulius Niedworok kvm_s390_set_prefix(vcpu, 0); 2234c6e5f166SFan Zhang if (test_kvm_facility(vcpu->kvm, 64)) 2235c6e5f166SFan Zhang vcpu->run->kvm_valid_regs |= KVM_SYNC_RICCB; 223635b3fde6SChristian Borntraeger if (test_kvm_facility(vcpu->kvm, 82)) 223735b3fde6SChristian Borntraeger vcpu->run->kvm_valid_regs |= KVM_SYNC_BPBC; 22384e0b1ab7SFan Zhang if (test_kvm_facility(vcpu->kvm, 133)) 22394e0b1ab7SFan Zhang vcpu->run->kvm_valid_regs |= KVM_SYNC_GSCB; 2240f6aa6dc4SDavid Hildenbrand /* fprs can be synchronized via vrs, even if the guest has no vx. With 2241f6aa6dc4SDavid Hildenbrand * MACHINE_HAS_VX, (load|store)_fpu_regs() will work with vrs format. 2242f6aa6dc4SDavid Hildenbrand */ 2243f6aa6dc4SDavid Hildenbrand if (MACHINE_HAS_VX) 224468c55750SEric Farman vcpu->run->kvm_valid_regs |= KVM_SYNC_VRS; 22456fd8e67dSDavid Hildenbrand else 22466fd8e67dSDavid Hildenbrand vcpu->run->kvm_valid_regs |= KVM_SYNC_FPRS; 2247dafd032aSDominik Dingel 2248dafd032aSDominik Dingel if (kvm_is_ucontrol(vcpu->kvm)) 2249dafd032aSDominik Dingel return __kvm_ucontrol_vcpu_init(vcpu); 2250dafd032aSDominik Dingel 2251b0c632dbSHeiko Carstens return 0; 2252b0c632dbSHeiko Carstens } 2253b0c632dbSHeiko Carstens 2254db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 2255db0758b2SDavid Hildenbrand static void __start_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2256db0758b2SDavid Hildenbrand { 2257db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_start != 0); 22589c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 2259db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = get_tod_clock_fast(); 22609c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 2261db0758b2SDavid Hildenbrand } 2262db0758b2SDavid Hildenbrand 2263db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 2264db0758b2SDavid Hildenbrand static void __stop_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2265db0758b2SDavid Hildenbrand { 2266db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_start == 0); 22679c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 2268db0758b2SDavid Hildenbrand vcpu->arch.sie_block->cputm -= get_tod_clock_fast() - vcpu->arch.cputm_start; 2269db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = 0; 22709c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 2271db0758b2SDavid Hildenbrand } 2272db0758b2SDavid Hildenbrand 2273db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 2274db0758b2SDavid Hildenbrand static void __enable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2275db0758b2SDavid Hildenbrand { 2276db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_enabled); 2277db0758b2SDavid Hildenbrand vcpu->arch.cputm_enabled = true; 2278db0758b2SDavid Hildenbrand __start_cpu_timer_accounting(vcpu); 2279db0758b2SDavid Hildenbrand } 2280db0758b2SDavid Hildenbrand 2281db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 2282db0758b2SDavid Hildenbrand static void __disable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2283db0758b2SDavid Hildenbrand { 2284db0758b2SDavid Hildenbrand WARN_ON_ONCE(!vcpu->arch.cputm_enabled); 2285db0758b2SDavid Hildenbrand __stop_cpu_timer_accounting(vcpu); 2286db0758b2SDavid Hildenbrand vcpu->arch.cputm_enabled = false; 2287db0758b2SDavid Hildenbrand } 2288db0758b2SDavid Hildenbrand 2289db0758b2SDavid Hildenbrand static void enable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2290db0758b2SDavid Hildenbrand { 2291db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 2292db0758b2SDavid Hildenbrand __enable_cpu_timer_accounting(vcpu); 2293db0758b2SDavid Hildenbrand preempt_enable(); 2294db0758b2SDavid Hildenbrand } 2295db0758b2SDavid Hildenbrand 2296db0758b2SDavid Hildenbrand static void disable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2297db0758b2SDavid Hildenbrand { 2298db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 2299db0758b2SDavid Hildenbrand __disable_cpu_timer_accounting(vcpu); 2300db0758b2SDavid Hildenbrand preempt_enable(); 2301db0758b2SDavid Hildenbrand } 2302db0758b2SDavid Hildenbrand 23034287f247SDavid Hildenbrand /* set the cpu timer - may only be called from the VCPU thread itself */ 23044287f247SDavid Hildenbrand void kvm_s390_set_cpu_timer(struct kvm_vcpu *vcpu, __u64 cputm) 23054287f247SDavid Hildenbrand { 2306db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 23079c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 2308db0758b2SDavid Hildenbrand if (vcpu->arch.cputm_enabled) 2309db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = get_tod_clock_fast(); 23104287f247SDavid Hildenbrand vcpu->arch.sie_block->cputm = cputm; 23119c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 2312db0758b2SDavid Hildenbrand preempt_enable(); 23134287f247SDavid Hildenbrand } 23144287f247SDavid Hildenbrand 2315db0758b2SDavid Hildenbrand /* update and get the cpu timer - can also be called from other VCPU threads */ 23164287f247SDavid Hildenbrand __u64 kvm_s390_get_cpu_timer(struct kvm_vcpu *vcpu) 23174287f247SDavid Hildenbrand { 23189c23a131SDavid Hildenbrand unsigned int seq; 2319db0758b2SDavid Hildenbrand __u64 value; 2320db0758b2SDavid Hildenbrand 2321db0758b2SDavid Hildenbrand if (unlikely(!vcpu->arch.cputm_enabled)) 23224287f247SDavid Hildenbrand return vcpu->arch.sie_block->cputm; 2323db0758b2SDavid Hildenbrand 23249c23a131SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 23259c23a131SDavid Hildenbrand do { 23269c23a131SDavid Hildenbrand seq = raw_read_seqcount(&vcpu->arch.cputm_seqcount); 23279c23a131SDavid Hildenbrand /* 23289c23a131SDavid Hildenbrand * If the writer would ever execute a read in the critical 23299c23a131SDavid Hildenbrand * section, e.g. in irq context, we have a deadlock. 23309c23a131SDavid Hildenbrand */ 23319c23a131SDavid Hildenbrand WARN_ON_ONCE((seq & 1) && smp_processor_id() == vcpu->cpu); 2332db0758b2SDavid Hildenbrand value = vcpu->arch.sie_block->cputm; 23339c23a131SDavid Hildenbrand /* if cputm_start is 0, accounting is being started/stopped */ 23349c23a131SDavid Hildenbrand if (likely(vcpu->arch.cputm_start)) 2335db0758b2SDavid Hildenbrand value -= get_tod_clock_fast() - vcpu->arch.cputm_start; 23369c23a131SDavid Hildenbrand } while (read_seqcount_retry(&vcpu->arch.cputm_seqcount, seq & ~1)); 23379c23a131SDavid Hildenbrand preempt_enable(); 2338db0758b2SDavid Hildenbrand return value; 23394287f247SDavid Hildenbrand } 23404287f247SDavid Hildenbrand 2341b0c632dbSHeiko Carstens void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 2342b0c632dbSHeiko Carstens { 23439977e886SHendrik Brueckner 234437d9df98SDavid Hildenbrand gmap_enable(vcpu->arch.enabled_gmap); 2345ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_RUNNING); 23465ebda316SDavid Hildenbrand if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu)) 2347db0758b2SDavid Hildenbrand __start_cpu_timer_accounting(vcpu); 234801a745acSDavid Hildenbrand vcpu->cpu = cpu; 2349b0c632dbSHeiko Carstens } 2350b0c632dbSHeiko Carstens 2351b0c632dbSHeiko Carstens void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 2352b0c632dbSHeiko Carstens { 235301a745acSDavid Hildenbrand vcpu->cpu = -1; 23545ebda316SDavid Hildenbrand if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu)) 2355db0758b2SDavid Hildenbrand __stop_cpu_timer_accounting(vcpu); 23569daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_RUNNING); 235737d9df98SDavid Hildenbrand vcpu->arch.enabled_gmap = gmap_get_enabled(); 235837d9df98SDavid Hildenbrand gmap_disable(vcpu->arch.enabled_gmap); 23599977e886SHendrik Brueckner 2360b0c632dbSHeiko Carstens } 2361b0c632dbSHeiko Carstens 2362b0c632dbSHeiko Carstens static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu) 2363b0c632dbSHeiko Carstens { 2364b0c632dbSHeiko Carstens /* this equals initial cpu reset in pop, but we don't switch to ESA */ 2365b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.mask = 0UL; 2366b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.addr = 0UL; 23678d26cf7bSChristian Borntraeger kvm_s390_set_prefix(vcpu, 0); 23684287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, 0); 2369b0c632dbSHeiko Carstens vcpu->arch.sie_block->ckc = 0UL; 2370b0c632dbSHeiko Carstens vcpu->arch.sie_block->todpr = 0; 2371b0c632dbSHeiko Carstens memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64)); 2372b0c632dbSHeiko Carstens vcpu->arch.sie_block->gcr[0] = 0xE0UL; 2373b0c632dbSHeiko Carstens vcpu->arch.sie_block->gcr[14] = 0xC2000000UL; 23749abc2a08SDavid Hildenbrand /* make sure the new fpc will be lazily loaded */ 23759abc2a08SDavid Hildenbrand save_fpu_regs(); 23769abc2a08SDavid Hildenbrand current->thread.fpu.fpc = 0; 2377b0c632dbSHeiko Carstens vcpu->arch.sie_block->gbea = 1; 2378672550fbSChristian Borntraeger vcpu->arch.sie_block->pp = 0; 237935b3fde6SChristian Borntraeger vcpu->arch.sie_block->fpf &= ~FPF_BPBC; 23803c038e6bSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 23813c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 23826352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) 23836852d7b6SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 23842ed10cc1SJens Freimann kvm_s390_clear_local_irqs(vcpu); 2385b0c632dbSHeiko Carstens } 2386b0c632dbSHeiko Carstens 238731928aa5SDominik Dingel void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu) 238842897d86SMarcelo Tosatti { 238972f25020SJason J. Herne mutex_lock(&vcpu->kvm->lock); 2390fdf03650SFan Zhang preempt_disable(); 239172f25020SJason J. Herne vcpu->arch.sie_block->epoch = vcpu->kvm->arch.epoch; 2392*d16b52cbSDavid Hildenbrand vcpu->arch.sie_block->epdx = vcpu->kvm->arch.epdx; 2393fdf03650SFan Zhang preempt_enable(); 239472f25020SJason J. Herne mutex_unlock(&vcpu->kvm->lock); 239525508824SDavid Hildenbrand if (!kvm_is_ucontrol(vcpu->kvm)) { 2396dafd032aSDominik Dingel vcpu->arch.gmap = vcpu->kvm->arch.gmap; 2397eaa78f34SDavid Hildenbrand sca_add_vcpu(vcpu); 239825508824SDavid Hildenbrand } 23996502a34cSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 74) || vcpu->kvm->arch.user_instr0) 24006502a34cSDavid Hildenbrand vcpu->arch.sie_block->ictl |= ICTL_OPEREXC; 240137d9df98SDavid Hildenbrand /* make vcpu_load load the right gmap on the first trigger */ 240237d9df98SDavid Hildenbrand vcpu->arch.enabled_gmap = vcpu->arch.gmap; 240342897d86SMarcelo Tosatti } 240442897d86SMarcelo Tosatti 24055102ee87STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu) 24065102ee87STony Krowiak { 24079d8d5786SMichael Mueller if (!test_kvm_facility(vcpu->kvm, 76)) 24085102ee87STony Krowiak return; 24095102ee87STony Krowiak 2410a374e892STony Krowiak vcpu->arch.sie_block->ecb3 &= ~(ECB3_AES | ECB3_DEA); 2411a374e892STony Krowiak 2412a374e892STony Krowiak if (vcpu->kvm->arch.crypto.aes_kw) 2413a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_AES; 2414a374e892STony Krowiak if (vcpu->kvm->arch.crypto.dea_kw) 2415a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_DEA; 2416a374e892STony Krowiak 24175102ee87STony Krowiak vcpu->arch.sie_block->crycbd = vcpu->kvm->arch.crypto.crycbd; 24185102ee87STony Krowiak } 24195102ee87STony Krowiak 2420b31605c1SDominik Dingel void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu) 2421b31605c1SDominik Dingel { 2422b31605c1SDominik Dingel free_page(vcpu->arch.sie_block->cbrlo); 2423b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = 0; 2424b31605c1SDominik Dingel } 2425b31605c1SDominik Dingel 2426b31605c1SDominik Dingel int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu) 2427b31605c1SDominik Dingel { 2428b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = get_zeroed_page(GFP_KERNEL); 2429b31605c1SDominik Dingel if (!vcpu->arch.sie_block->cbrlo) 2430b31605c1SDominik Dingel return -ENOMEM; 2431b31605c1SDominik Dingel 24320c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 &= ~ECB2_PFMFI; 2433b31605c1SDominik Dingel return 0; 2434b31605c1SDominik Dingel } 2435b31605c1SDominik Dingel 243691520f1aSMichael Mueller static void kvm_s390_vcpu_setup_model(struct kvm_vcpu *vcpu) 243791520f1aSMichael Mueller { 243891520f1aSMichael Mueller struct kvm_s390_cpu_model *model = &vcpu->kvm->arch.model; 243991520f1aSMichael Mueller 244091520f1aSMichael Mueller vcpu->arch.sie_block->ibc = model->ibc; 244180bc79dcSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 7)) 2442c54f0d6aSDavid Hildenbrand vcpu->arch.sie_block->fac = (u32)(u64) model->fac_list; 244391520f1aSMichael Mueller } 244491520f1aSMichael Mueller 2445b0c632dbSHeiko Carstens int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) 2446b0c632dbSHeiko Carstens { 2447b31605c1SDominik Dingel int rc = 0; 2448b31288faSKonstantin Weitz 24499e6dabefSCornelia Huck atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH | 24509e6dabefSCornelia Huck CPUSTAT_SM | 2451a4a4f191SGuenther Hutzl CPUSTAT_STOPPED); 2452a4a4f191SGuenther Hutzl 245353df84f8SGuenther Hutzl if (test_kvm_facility(vcpu->kvm, 78)) 2454ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_GED2); 245553df84f8SGuenther Hutzl else if (test_kvm_facility(vcpu->kvm, 8)) 2456ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_GED); 2457a4a4f191SGuenther Hutzl 245891520f1aSMichael Mueller kvm_s390_vcpu_setup_model(vcpu); 245991520f1aSMichael Mueller 2460bdab09f3SDavid Hildenbrand /* pgste_set_pte has special handling for !MACHINE_HAS_ESOP */ 2461bdab09f3SDavid Hildenbrand if (MACHINE_HAS_ESOP) 24620c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb |= ECB_HOSTPROTINT; 2463bd50e8ecSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 9)) 24640c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb |= ECB_SRSI; 2465f597d24eSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 73)) 24660c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb |= ECB_TE; 24677feb6bb8SMichael Mueller 2468873b425eSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 8) && sclp.has_pfmfi) 24690c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= ECB2_PFMFI; 2470cd1836f5SJanosch Frank if (test_kvm_facility(vcpu->kvm, 130)) 24710c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= ECB2_IEP; 24720c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca = ECA_MVPGI | ECA_PROTEXCI; 247348ee7d3aSDavid Hildenbrand if (sclp.has_cei) 24740c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_CEI; 247511ad65b7SDavid Hildenbrand if (sclp.has_ib) 24760c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_IB; 247737c5f6c8SDavid Hildenbrand if (sclp.has_siif) 24780c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_SII; 247937c5f6c8SDavid Hildenbrand if (sclp.has_sigpif) 24800c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_SIGPI; 248118280d8bSMichael Mueller if (test_kvm_facility(vcpu->kvm, 129)) { 24820c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_VX; 24830c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecd |= ECD_HOSTREGMGMT; 248413211ea7SEric Farman } 24858fa1696eSCollin L. Walling if (test_kvm_facility(vcpu->kvm, 139)) 24868fa1696eSCollin L. Walling vcpu->arch.sie_block->ecd |= ECD_MEF; 24878fa1696eSCollin L. Walling 2488d7c5cb01SMichael Mueller if (vcpu->arch.sie_block->gd) { 2489d7c5cb01SMichael Mueller vcpu->arch.sie_block->eca |= ECA_AIV; 2490d7c5cb01SMichael Mueller VCPU_EVENT(vcpu, 3, "AIV gisa format-%u enabled for cpu %03u", 2491d7c5cb01SMichael Mueller vcpu->arch.sie_block->gd & 0x3, vcpu->vcpu_id); 2492d7c5cb01SMichael Mueller } 24934e0b1ab7SFan Zhang vcpu->arch.sie_block->sdnxo = ((unsigned long) &vcpu->run->s.regs.sdnx) 24944e0b1ab7SFan Zhang | SDNXC; 2495c6e5f166SFan Zhang vcpu->arch.sie_block->riccbd = (unsigned long) &vcpu->run->s.regs.riccb; 2496730cd632SFarhan Ali 2497730cd632SFarhan Ali if (sclp.has_kss) 2498ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_KSS); 2499730cd632SFarhan Ali else 2500492d8642SThomas Huth vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE; 25015a5e6536SMatthew Rosato 2502e6db1d61SDominik Dingel if (vcpu->kvm->arch.use_cmma) { 2503b31605c1SDominik Dingel rc = kvm_s390_vcpu_setup_cmma(vcpu); 2504b31605c1SDominik Dingel if (rc) 2505b31605c1SDominik Dingel return rc; 2506b31288faSKonstantin Weitz } 25070ac96cafSDavid Hildenbrand hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 2508ca872302SChristian Borntraeger vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup; 25099d8d5786SMichael Mueller 25105102ee87STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 25115102ee87STony Krowiak 2512b31605c1SDominik Dingel return rc; 2513b0c632dbSHeiko Carstens } 2514b0c632dbSHeiko Carstens 2515b0c632dbSHeiko Carstens struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, 2516b0c632dbSHeiko Carstens unsigned int id) 2517b0c632dbSHeiko Carstens { 25184d47555aSCarsten Otte struct kvm_vcpu *vcpu; 25197feb6bb8SMichael Mueller struct sie_page *sie_page; 25204d47555aSCarsten Otte int rc = -EINVAL; 2521b0c632dbSHeiko Carstens 25224215825eSDavid Hildenbrand if (!kvm_is_ucontrol(kvm) && !sca_can_add_vcpu(kvm, id)) 25234d47555aSCarsten Otte goto out; 25244d47555aSCarsten Otte 25254d47555aSCarsten Otte rc = -ENOMEM; 25264d47555aSCarsten Otte 2527b110feafSMichael Mueller vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL); 2528b0c632dbSHeiko Carstens if (!vcpu) 25294d47555aSCarsten Otte goto out; 2530b0c632dbSHeiko Carstens 2531da72ca4dSQingFeng Hao BUILD_BUG_ON(sizeof(struct sie_page) != 4096); 25327feb6bb8SMichael Mueller sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL); 25337feb6bb8SMichael Mueller if (!sie_page) 2534b0c632dbSHeiko Carstens goto out_free_cpu; 2535b0c632dbSHeiko Carstens 25367feb6bb8SMichael Mueller vcpu->arch.sie_block = &sie_page->sie_block; 25377feb6bb8SMichael Mueller vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb; 25387feb6bb8SMichael Mueller 2539efed1104SDavid Hildenbrand /* the real guest size will always be smaller than msl */ 2540efed1104SDavid Hildenbrand vcpu->arch.sie_block->mso = 0; 2541efed1104SDavid Hildenbrand vcpu->arch.sie_block->msl = sclp.hamax; 2542efed1104SDavid Hildenbrand 2543b0c632dbSHeiko Carstens vcpu->arch.sie_block->icpua = id; 2544ba5c1e9bSCarsten Otte spin_lock_init(&vcpu->arch.local_int.lock); 2545d7c5cb01SMichael Mueller vcpu->arch.sie_block->gd = (u32)(u64)kvm->arch.gisa; 25464b9f9525SMichael Mueller if (vcpu->arch.sie_block->gd && sclp.has_gisaf) 25474b9f9525SMichael Mueller vcpu->arch.sie_block->gd |= GISA_FORMAT1; 25489c23a131SDavid Hildenbrand seqcount_init(&vcpu->arch.cputm_seqcount); 2549ba5c1e9bSCarsten Otte 2550b0c632dbSHeiko Carstens rc = kvm_vcpu_init(vcpu, kvm, id); 2551b0c632dbSHeiko Carstens if (rc) 25529abc2a08SDavid Hildenbrand goto out_free_sie_block; 25538335713aSChristian Borntraeger VM_EVENT(kvm, 3, "create cpu %d at 0x%pK, sie block at 0x%pK", id, vcpu, 2554b0c632dbSHeiko Carstens vcpu->arch.sie_block); 2555ade38c31SCornelia Huck trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block); 2556b0c632dbSHeiko Carstens 2557b0c632dbSHeiko Carstens return vcpu; 25587b06bf2fSWei Yongjun out_free_sie_block: 25597b06bf2fSWei Yongjun free_page((unsigned long)(vcpu->arch.sie_block)); 2560b0c632dbSHeiko Carstens out_free_cpu: 2561b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 25624d47555aSCarsten Otte out: 2563b0c632dbSHeiko Carstens return ERR_PTR(rc); 2564b0c632dbSHeiko Carstens } 2565b0c632dbSHeiko Carstens 2566b0c632dbSHeiko Carstens int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu) 2567b0c632dbSHeiko Carstens { 25689a022067SDavid Hildenbrand return kvm_s390_vcpu_has_irq(vcpu, 0); 2569b0c632dbSHeiko Carstens } 2570b0c632dbSHeiko Carstens 2571199b5763SLongpeng(Mike) bool kvm_arch_vcpu_in_kernel(struct kvm_vcpu *vcpu) 2572199b5763SLongpeng(Mike) { 25730546c63dSLongpeng(Mike) return !(vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE); 2574199b5763SLongpeng(Mike) } 2575199b5763SLongpeng(Mike) 257627406cd5SChristian Borntraeger void kvm_s390_vcpu_block(struct kvm_vcpu *vcpu) 257749b99e1eSChristian Borntraeger { 2578805de8f4SPeter Zijlstra atomic_or(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 257961a6df54SDavid Hildenbrand exit_sie(vcpu); 258049b99e1eSChristian Borntraeger } 258149b99e1eSChristian Borntraeger 258227406cd5SChristian Borntraeger void kvm_s390_vcpu_unblock(struct kvm_vcpu *vcpu) 258349b99e1eSChristian Borntraeger { 2584805de8f4SPeter Zijlstra atomic_andnot(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 258549b99e1eSChristian Borntraeger } 258649b99e1eSChristian Borntraeger 25878e236546SChristian Borntraeger static void kvm_s390_vcpu_request(struct kvm_vcpu *vcpu) 25888e236546SChristian Borntraeger { 2589805de8f4SPeter Zijlstra atomic_or(PROG_REQUEST, &vcpu->arch.sie_block->prog20); 259061a6df54SDavid Hildenbrand exit_sie(vcpu); 25918e236546SChristian Borntraeger } 25928e236546SChristian Borntraeger 25938e236546SChristian Borntraeger static void kvm_s390_vcpu_request_handled(struct kvm_vcpu *vcpu) 25948e236546SChristian Borntraeger { 25959bf9fde2SJason J. Herne atomic_andnot(PROG_REQUEST, &vcpu->arch.sie_block->prog20); 25968e236546SChristian Borntraeger } 25978e236546SChristian Borntraeger 259849b99e1eSChristian Borntraeger /* 259949b99e1eSChristian Borntraeger * Kick a guest cpu out of SIE and wait until SIE is not running. 260049b99e1eSChristian Borntraeger * If the CPU is not running (e.g. waiting as idle) the function will 260149b99e1eSChristian Borntraeger * return immediately. */ 260249b99e1eSChristian Borntraeger void exit_sie(struct kvm_vcpu *vcpu) 260349b99e1eSChristian Borntraeger { 2604ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_STOP_INT); 260549b99e1eSChristian Borntraeger while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE) 260649b99e1eSChristian Borntraeger cpu_relax(); 260749b99e1eSChristian Borntraeger } 260849b99e1eSChristian Borntraeger 26098e236546SChristian Borntraeger /* Kick a guest cpu out of SIE to process a request synchronously */ 26108e236546SChristian Borntraeger void kvm_s390_sync_request(int req, struct kvm_vcpu *vcpu) 261149b99e1eSChristian Borntraeger { 26128e236546SChristian Borntraeger kvm_make_request(req, vcpu); 26138e236546SChristian Borntraeger kvm_s390_vcpu_request(vcpu); 261449b99e1eSChristian Borntraeger } 261549b99e1eSChristian Borntraeger 2616414d3b07SMartin Schwidefsky static void kvm_gmap_notifier(struct gmap *gmap, unsigned long start, 2617414d3b07SMartin Schwidefsky unsigned long end) 26182c70fe44SChristian Borntraeger { 26192c70fe44SChristian Borntraeger struct kvm *kvm = gmap->private; 26202c70fe44SChristian Borntraeger struct kvm_vcpu *vcpu; 2621414d3b07SMartin Schwidefsky unsigned long prefix; 2622414d3b07SMartin Schwidefsky int i; 26232c70fe44SChristian Borntraeger 262465d0b0d4SDavid Hildenbrand if (gmap_is_shadow(gmap)) 262565d0b0d4SDavid Hildenbrand return; 2626414d3b07SMartin Schwidefsky if (start >= 1UL << 31) 2627414d3b07SMartin Schwidefsky /* We are only interested in prefix pages */ 2628414d3b07SMartin Schwidefsky return; 26292c70fe44SChristian Borntraeger kvm_for_each_vcpu(i, vcpu, kvm) { 26302c70fe44SChristian Borntraeger /* match against both prefix pages */ 2631414d3b07SMartin Schwidefsky prefix = kvm_s390_get_prefix(vcpu); 2632414d3b07SMartin Schwidefsky if (prefix <= end && start <= prefix + 2*PAGE_SIZE - 1) { 2633414d3b07SMartin Schwidefsky VCPU_EVENT(vcpu, 2, "gmap notifier for %lx-%lx", 2634414d3b07SMartin Schwidefsky start, end); 26358e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_MMU_RELOAD, vcpu); 26362c70fe44SChristian Borntraeger } 26372c70fe44SChristian Borntraeger } 26382c70fe44SChristian Borntraeger } 26392c70fe44SChristian Borntraeger 2640b6d33834SChristoffer Dall int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu) 2641b6d33834SChristoffer Dall { 2642b6d33834SChristoffer Dall /* kvm common code refers to this, but never calls it */ 2643b6d33834SChristoffer Dall BUG(); 2644b6d33834SChristoffer Dall return 0; 2645b6d33834SChristoffer Dall } 2646b6d33834SChristoffer Dall 264714eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, 264814eebd91SCarsten Otte struct kvm_one_reg *reg) 264914eebd91SCarsten Otte { 265014eebd91SCarsten Otte int r = -EINVAL; 265114eebd91SCarsten Otte 265214eebd91SCarsten Otte switch (reg->id) { 265329b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 265429b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->todpr, 265529b7c71bSCarsten Otte (u32 __user *)reg->addr); 265629b7c71bSCarsten Otte break; 265729b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 265829b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->epoch, 265929b7c71bSCarsten Otte (u64 __user *)reg->addr); 266029b7c71bSCarsten Otte break; 266146a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 26624287f247SDavid Hildenbrand r = put_user(kvm_s390_get_cpu_timer(vcpu), 266346a6dd1cSJason J. herne (u64 __user *)reg->addr); 266446a6dd1cSJason J. herne break; 266546a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 266646a6dd1cSJason J. herne r = put_user(vcpu->arch.sie_block->ckc, 266746a6dd1cSJason J. herne (u64 __user *)reg->addr); 266846a6dd1cSJason J. herne break; 2669536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 2670536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_token, 2671536336c2SDominik Dingel (u64 __user *)reg->addr); 2672536336c2SDominik Dingel break; 2673536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 2674536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_compare, 2675536336c2SDominik Dingel (u64 __user *)reg->addr); 2676536336c2SDominik Dingel break; 2677536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 2678536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_select, 2679536336c2SDominik Dingel (u64 __user *)reg->addr); 2680536336c2SDominik Dingel break; 2681672550fbSChristian Borntraeger case KVM_REG_S390_PP: 2682672550fbSChristian Borntraeger r = put_user(vcpu->arch.sie_block->pp, 2683672550fbSChristian Borntraeger (u64 __user *)reg->addr); 2684672550fbSChristian Borntraeger break; 2685afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 2686afa45ff5SChristian Borntraeger r = put_user(vcpu->arch.sie_block->gbea, 2687afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 2688afa45ff5SChristian Borntraeger break; 268914eebd91SCarsten Otte default: 269014eebd91SCarsten Otte break; 269114eebd91SCarsten Otte } 269214eebd91SCarsten Otte 269314eebd91SCarsten Otte return r; 269414eebd91SCarsten Otte } 269514eebd91SCarsten Otte 269614eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, 269714eebd91SCarsten Otte struct kvm_one_reg *reg) 269814eebd91SCarsten Otte { 269914eebd91SCarsten Otte int r = -EINVAL; 27004287f247SDavid Hildenbrand __u64 val; 270114eebd91SCarsten Otte 270214eebd91SCarsten Otte switch (reg->id) { 270329b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 270429b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->todpr, 270529b7c71bSCarsten Otte (u32 __user *)reg->addr); 270629b7c71bSCarsten Otte break; 270729b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 270829b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->epoch, 270929b7c71bSCarsten Otte (u64 __user *)reg->addr); 271029b7c71bSCarsten Otte break; 271146a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 27124287f247SDavid Hildenbrand r = get_user(val, (u64 __user *)reg->addr); 27134287f247SDavid Hildenbrand if (!r) 27144287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, val); 271546a6dd1cSJason J. herne break; 271646a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 271746a6dd1cSJason J. herne r = get_user(vcpu->arch.sie_block->ckc, 271846a6dd1cSJason J. herne (u64 __user *)reg->addr); 271946a6dd1cSJason J. herne break; 2720536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 2721536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_token, 2722536336c2SDominik Dingel (u64 __user *)reg->addr); 27239fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 27249fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 2725536336c2SDominik Dingel break; 2726536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 2727536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_compare, 2728536336c2SDominik Dingel (u64 __user *)reg->addr); 2729536336c2SDominik Dingel break; 2730536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 2731536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_select, 2732536336c2SDominik Dingel (u64 __user *)reg->addr); 2733536336c2SDominik Dingel break; 2734672550fbSChristian Borntraeger case KVM_REG_S390_PP: 2735672550fbSChristian Borntraeger r = get_user(vcpu->arch.sie_block->pp, 2736672550fbSChristian Borntraeger (u64 __user *)reg->addr); 2737672550fbSChristian Borntraeger break; 2738afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 2739afa45ff5SChristian Borntraeger r = get_user(vcpu->arch.sie_block->gbea, 2740afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 2741afa45ff5SChristian Borntraeger break; 274214eebd91SCarsten Otte default: 274314eebd91SCarsten Otte break; 274414eebd91SCarsten Otte } 274514eebd91SCarsten Otte 274614eebd91SCarsten Otte return r; 274714eebd91SCarsten Otte } 2748b6d33834SChristoffer Dall 2749b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) 2750b0c632dbSHeiko Carstens { 2751b0c632dbSHeiko Carstens kvm_s390_vcpu_initial_reset(vcpu); 2752b0c632dbSHeiko Carstens return 0; 2753b0c632dbSHeiko Carstens } 2754b0c632dbSHeiko Carstens 2755b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 2756b0c632dbSHeiko Carstens { 2757875656feSChristoffer Dall vcpu_load(vcpu); 27585a32c1afSChristian Borntraeger memcpy(&vcpu->run->s.regs.gprs, ®s->gprs, sizeof(regs->gprs)); 2759875656feSChristoffer Dall vcpu_put(vcpu); 2760b0c632dbSHeiko Carstens return 0; 2761b0c632dbSHeiko Carstens } 2762b0c632dbSHeiko Carstens 2763b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 2764b0c632dbSHeiko Carstens { 27651fc9b76bSChristoffer Dall vcpu_load(vcpu); 27665a32c1afSChristian Borntraeger memcpy(®s->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs)); 27671fc9b76bSChristoffer Dall vcpu_put(vcpu); 2768b0c632dbSHeiko Carstens return 0; 2769b0c632dbSHeiko Carstens } 2770b0c632dbSHeiko Carstens 2771b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, 2772b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 2773b0c632dbSHeiko Carstens { 2774b4ef9d4eSChristoffer Dall vcpu_load(vcpu); 2775b4ef9d4eSChristoffer Dall 277659674c1aSChristian Borntraeger memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs)); 2777b0c632dbSHeiko Carstens memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs)); 2778b4ef9d4eSChristoffer Dall 2779b4ef9d4eSChristoffer Dall vcpu_put(vcpu); 2780b0c632dbSHeiko Carstens return 0; 2781b0c632dbSHeiko Carstens } 2782b0c632dbSHeiko Carstens 2783b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, 2784b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 2785b0c632dbSHeiko Carstens { 2786bcdec41cSChristoffer Dall vcpu_load(vcpu); 2787bcdec41cSChristoffer Dall 278859674c1aSChristian Borntraeger memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs)); 2789b0c632dbSHeiko Carstens memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs)); 2790bcdec41cSChristoffer Dall 2791bcdec41cSChristoffer Dall vcpu_put(vcpu); 2792b0c632dbSHeiko Carstens return 0; 2793b0c632dbSHeiko Carstens } 2794b0c632dbSHeiko Carstens 2795b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 2796b0c632dbSHeiko Carstens { 27976a96bc7fSChristoffer Dall int ret = 0; 27986a96bc7fSChristoffer Dall 27996a96bc7fSChristoffer Dall vcpu_load(vcpu); 28006a96bc7fSChristoffer Dall 28016a96bc7fSChristoffer Dall if (test_fp_ctl(fpu->fpc)) { 28026a96bc7fSChristoffer Dall ret = -EINVAL; 28036a96bc7fSChristoffer Dall goto out; 28046a96bc7fSChristoffer Dall } 2805e1788bb9SChristian Borntraeger vcpu->run->s.regs.fpc = fpu->fpc; 28069abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) 2807a7d4b8f2SDavid Hildenbrand convert_fp_to_vx((__vector128 *) vcpu->run->s.regs.vrs, 2808a7d4b8f2SDavid Hildenbrand (freg_t *) fpu->fprs); 28099abc2a08SDavid Hildenbrand else 2810a7d4b8f2SDavid Hildenbrand memcpy(vcpu->run->s.regs.fprs, &fpu->fprs, sizeof(fpu->fprs)); 28116a96bc7fSChristoffer Dall 28126a96bc7fSChristoffer Dall out: 28136a96bc7fSChristoffer Dall vcpu_put(vcpu); 28146a96bc7fSChristoffer Dall return ret; 2815b0c632dbSHeiko Carstens } 2816b0c632dbSHeiko Carstens 2817b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 2818b0c632dbSHeiko Carstens { 28191393123eSChristoffer Dall vcpu_load(vcpu); 28201393123eSChristoffer Dall 28219abc2a08SDavid Hildenbrand /* make sure we have the latest values */ 28229abc2a08SDavid Hildenbrand save_fpu_regs(); 28239abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) 2824a7d4b8f2SDavid Hildenbrand convert_vx_to_fp((freg_t *) fpu->fprs, 2825a7d4b8f2SDavid Hildenbrand (__vector128 *) vcpu->run->s.regs.vrs); 28269abc2a08SDavid Hildenbrand else 2827a7d4b8f2SDavid Hildenbrand memcpy(fpu->fprs, vcpu->run->s.regs.fprs, sizeof(fpu->fprs)); 2828e1788bb9SChristian Borntraeger fpu->fpc = vcpu->run->s.regs.fpc; 28291393123eSChristoffer Dall 28301393123eSChristoffer Dall vcpu_put(vcpu); 2831b0c632dbSHeiko Carstens return 0; 2832b0c632dbSHeiko Carstens } 2833b0c632dbSHeiko Carstens 2834b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw) 2835b0c632dbSHeiko Carstens { 2836b0c632dbSHeiko Carstens int rc = 0; 2837b0c632dbSHeiko Carstens 28387a42fdc2SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 2839b0c632dbSHeiko Carstens rc = -EBUSY; 2840d7b0b5ebSCarsten Otte else { 2841d7b0b5ebSCarsten Otte vcpu->run->psw_mask = psw.mask; 2842d7b0b5ebSCarsten Otte vcpu->run->psw_addr = psw.addr; 2843d7b0b5ebSCarsten Otte } 2844b0c632dbSHeiko Carstens return rc; 2845b0c632dbSHeiko Carstens } 2846b0c632dbSHeiko Carstens 2847b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, 2848b0c632dbSHeiko Carstens struct kvm_translation *tr) 2849b0c632dbSHeiko Carstens { 2850b0c632dbSHeiko Carstens return -EINVAL; /* not implemented yet */ 2851b0c632dbSHeiko Carstens } 2852b0c632dbSHeiko Carstens 285327291e21SDavid Hildenbrand #define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \ 285427291e21SDavid Hildenbrand KVM_GUESTDBG_USE_HW_BP | \ 285527291e21SDavid Hildenbrand KVM_GUESTDBG_ENABLE) 285627291e21SDavid Hildenbrand 2857d0bfb940SJan Kiszka int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 2858d0bfb940SJan Kiszka struct kvm_guest_debug *dbg) 2859b0c632dbSHeiko Carstens { 286027291e21SDavid Hildenbrand int rc = 0; 286127291e21SDavid Hildenbrand 286266b56562SChristoffer Dall vcpu_load(vcpu); 286366b56562SChristoffer Dall 286427291e21SDavid Hildenbrand vcpu->guest_debug = 0; 286527291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 286627291e21SDavid Hildenbrand 286766b56562SChristoffer Dall if (dbg->control & ~VALID_GUESTDBG_FLAGS) { 286866b56562SChristoffer Dall rc = -EINVAL; 286966b56562SChristoffer Dall goto out; 287066b56562SChristoffer Dall } 287166b56562SChristoffer Dall if (!sclp.has_gpere) { 287266b56562SChristoffer Dall rc = -EINVAL; 287366b56562SChristoffer Dall goto out; 287466b56562SChristoffer Dall } 287527291e21SDavid Hildenbrand 287627291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_ENABLE) { 287727291e21SDavid Hildenbrand vcpu->guest_debug = dbg->control; 287827291e21SDavid Hildenbrand /* enforce guest PER */ 2879ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_P); 288027291e21SDavid Hildenbrand 288127291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_USE_HW_BP) 288227291e21SDavid Hildenbrand rc = kvm_s390_import_bp_data(vcpu, dbg); 288327291e21SDavid Hildenbrand } else { 28849daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_P); 288527291e21SDavid Hildenbrand vcpu->arch.guestdbg.last_bp = 0; 288627291e21SDavid Hildenbrand } 288727291e21SDavid Hildenbrand 288827291e21SDavid Hildenbrand if (rc) { 288927291e21SDavid Hildenbrand vcpu->guest_debug = 0; 289027291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 28919daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_P); 289227291e21SDavid Hildenbrand } 289327291e21SDavid Hildenbrand 289466b56562SChristoffer Dall out: 289566b56562SChristoffer Dall vcpu_put(vcpu); 289627291e21SDavid Hildenbrand return rc; 2897b0c632dbSHeiko Carstens } 2898b0c632dbSHeiko Carstens 289962d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 290062d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 290162d9f0dbSMarcelo Tosatti { 2902fd232561SChristoffer Dall int ret; 2903fd232561SChristoffer Dall 2904fd232561SChristoffer Dall vcpu_load(vcpu); 2905fd232561SChristoffer Dall 29066352e4d2SDavid Hildenbrand /* CHECK_STOP and LOAD are not supported yet */ 2907fd232561SChristoffer Dall ret = is_vcpu_stopped(vcpu) ? KVM_MP_STATE_STOPPED : 29086352e4d2SDavid Hildenbrand KVM_MP_STATE_OPERATING; 2909fd232561SChristoffer Dall 2910fd232561SChristoffer Dall vcpu_put(vcpu); 2911fd232561SChristoffer Dall return ret; 291262d9f0dbSMarcelo Tosatti } 291362d9f0dbSMarcelo Tosatti 291462d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 291562d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 291662d9f0dbSMarcelo Tosatti { 29176352e4d2SDavid Hildenbrand int rc = 0; 29186352e4d2SDavid Hildenbrand 2919e83dff5eSChristoffer Dall vcpu_load(vcpu); 2920e83dff5eSChristoffer Dall 29216352e4d2SDavid Hildenbrand /* user space knows about this interface - let it control the state */ 29226352e4d2SDavid Hildenbrand vcpu->kvm->arch.user_cpu_state_ctrl = 1; 29236352e4d2SDavid Hildenbrand 29246352e4d2SDavid Hildenbrand switch (mp_state->mp_state) { 29256352e4d2SDavid Hildenbrand case KVM_MP_STATE_STOPPED: 29266352e4d2SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 29276352e4d2SDavid Hildenbrand break; 29286352e4d2SDavid Hildenbrand case KVM_MP_STATE_OPERATING: 29296352e4d2SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 29306352e4d2SDavid Hildenbrand break; 29316352e4d2SDavid Hildenbrand case KVM_MP_STATE_LOAD: 29326352e4d2SDavid Hildenbrand case KVM_MP_STATE_CHECK_STOP: 29336352e4d2SDavid Hildenbrand /* fall through - CHECK_STOP and LOAD are not supported yet */ 29346352e4d2SDavid Hildenbrand default: 29356352e4d2SDavid Hildenbrand rc = -ENXIO; 29366352e4d2SDavid Hildenbrand } 29376352e4d2SDavid Hildenbrand 2938e83dff5eSChristoffer Dall vcpu_put(vcpu); 29396352e4d2SDavid Hildenbrand return rc; 294062d9f0dbSMarcelo Tosatti } 294162d9f0dbSMarcelo Tosatti 29428ad35755SDavid Hildenbrand static bool ibs_enabled(struct kvm_vcpu *vcpu) 29438ad35755SDavid Hildenbrand { 29448d5fb0dcSDavid Hildenbrand return kvm_s390_test_cpuflags(vcpu, CPUSTAT_IBS); 29458ad35755SDavid Hildenbrand } 29468ad35755SDavid Hildenbrand 29472c70fe44SChristian Borntraeger static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu) 29482c70fe44SChristian Borntraeger { 29498ad35755SDavid Hildenbrand retry: 29508e236546SChristian Borntraeger kvm_s390_vcpu_request_handled(vcpu); 29512fa6e1e1SRadim Krčmář if (!kvm_request_pending(vcpu)) 2952586b7ccdSChristian Borntraeger return 0; 29532c70fe44SChristian Borntraeger /* 29542c70fe44SChristian Borntraeger * We use MMU_RELOAD just to re-arm the ipte notifier for the 2955b2d73b2aSMartin Schwidefsky * guest prefix page. gmap_mprotect_notify will wait on the ptl lock. 29562c70fe44SChristian Borntraeger * This ensures that the ipte instruction for this request has 29572c70fe44SChristian Borntraeger * already finished. We might race against a second unmapper that 29582c70fe44SChristian Borntraeger * wants to set the blocking bit. Lets just retry the request loop. 29592c70fe44SChristian Borntraeger */ 29608ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) { 29612c70fe44SChristian Borntraeger int rc; 2962b2d73b2aSMartin Schwidefsky rc = gmap_mprotect_notify(vcpu->arch.gmap, 2963fda902cbSMichael Mueller kvm_s390_get_prefix(vcpu), 2964b2d73b2aSMartin Schwidefsky PAGE_SIZE * 2, PROT_WRITE); 2965aca411a4SJulius Niedworok if (rc) { 2966aca411a4SJulius Niedworok kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu); 29672c70fe44SChristian Borntraeger return rc; 2968aca411a4SJulius Niedworok } 29698ad35755SDavid Hildenbrand goto retry; 29702c70fe44SChristian Borntraeger } 29718ad35755SDavid Hildenbrand 2972d3d692c8SDavid Hildenbrand if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu)) { 2973d3d692c8SDavid Hildenbrand vcpu->arch.sie_block->ihcpu = 0xffff; 2974d3d692c8SDavid Hildenbrand goto retry; 2975d3d692c8SDavid Hildenbrand } 2976d3d692c8SDavid Hildenbrand 29778ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu)) { 29788ad35755SDavid Hildenbrand if (!ibs_enabled(vcpu)) { 29798ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 1); 2980ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_IBS); 29818ad35755SDavid Hildenbrand } 29828ad35755SDavid Hildenbrand goto retry; 29838ad35755SDavid Hildenbrand } 29848ad35755SDavid Hildenbrand 29858ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu)) { 29868ad35755SDavid Hildenbrand if (ibs_enabled(vcpu)) { 29878ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 0); 29889daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_IBS); 29898ad35755SDavid Hildenbrand } 29908ad35755SDavid Hildenbrand goto retry; 29918ad35755SDavid Hildenbrand } 29928ad35755SDavid Hildenbrand 29936502a34cSDavid Hildenbrand if (kvm_check_request(KVM_REQ_ICPT_OPEREXC, vcpu)) { 29946502a34cSDavid Hildenbrand vcpu->arch.sie_block->ictl |= ICTL_OPEREXC; 29956502a34cSDavid Hildenbrand goto retry; 29966502a34cSDavid Hildenbrand } 29976502a34cSDavid Hildenbrand 2998190df4a2SClaudio Imbrenda if (kvm_check_request(KVM_REQ_START_MIGRATION, vcpu)) { 2999190df4a2SClaudio Imbrenda /* 3000190df4a2SClaudio Imbrenda * Disable CMMA virtualization; we will emulate the ESSA 3001190df4a2SClaudio Imbrenda * instruction manually, in order to provide additional 3002190df4a2SClaudio Imbrenda * functionalities needed for live migration. 3003190df4a2SClaudio Imbrenda */ 3004190df4a2SClaudio Imbrenda vcpu->arch.sie_block->ecb2 &= ~ECB2_CMMA; 3005190df4a2SClaudio Imbrenda goto retry; 3006190df4a2SClaudio Imbrenda } 3007190df4a2SClaudio Imbrenda 3008190df4a2SClaudio Imbrenda if (kvm_check_request(KVM_REQ_STOP_MIGRATION, vcpu)) { 3009190df4a2SClaudio Imbrenda /* 3010190df4a2SClaudio Imbrenda * Re-enable CMMA virtualization if CMMA is available and 3011190df4a2SClaudio Imbrenda * was used. 3012190df4a2SClaudio Imbrenda */ 3013190df4a2SClaudio Imbrenda if ((vcpu->kvm->arch.use_cmma) && 3014190df4a2SClaudio Imbrenda (vcpu->kvm->mm->context.use_cmma)) 3015190df4a2SClaudio Imbrenda vcpu->arch.sie_block->ecb2 |= ECB2_CMMA; 3016190df4a2SClaudio Imbrenda goto retry; 3017190df4a2SClaudio Imbrenda } 3018190df4a2SClaudio Imbrenda 30190759d068SDavid Hildenbrand /* nothing to do, just clear the request */ 302072875d8aSRadim Krčmář kvm_clear_request(KVM_REQ_UNHALT, vcpu); 30210759d068SDavid Hildenbrand 30222c70fe44SChristian Borntraeger return 0; 30232c70fe44SChristian Borntraeger } 30242c70fe44SChristian Borntraeger 30258fa1696eSCollin L. Walling void kvm_s390_set_tod_clock_ext(struct kvm *kvm, 30268fa1696eSCollin L. Walling const struct kvm_s390_vm_tod_clock *gtod) 30278fa1696eSCollin L. Walling { 30288fa1696eSCollin L. Walling struct kvm_vcpu *vcpu; 30298fa1696eSCollin L. Walling struct kvm_s390_tod_clock_ext htod; 30308fa1696eSCollin L. Walling int i; 30318fa1696eSCollin L. Walling 30328fa1696eSCollin L. Walling mutex_lock(&kvm->lock); 30338fa1696eSCollin L. Walling preempt_disable(); 30348fa1696eSCollin L. Walling 30358fa1696eSCollin L. Walling get_tod_clock_ext((char *)&htod); 30368fa1696eSCollin L. Walling 30378fa1696eSCollin L. Walling kvm->arch.epoch = gtod->tod - htod.tod; 30388fa1696eSCollin L. Walling kvm->arch.epdx = gtod->epoch_idx - htod.epoch_idx; 30398fa1696eSCollin L. Walling 30408fa1696eSCollin L. Walling if (kvm->arch.epoch > gtod->tod) 30418fa1696eSCollin L. Walling kvm->arch.epdx -= 1; 30428fa1696eSCollin L. Walling 30438fa1696eSCollin L. Walling kvm_s390_vcpu_block_all(kvm); 30448fa1696eSCollin L. Walling kvm_for_each_vcpu(i, vcpu, kvm) { 30458fa1696eSCollin L. Walling vcpu->arch.sie_block->epoch = kvm->arch.epoch; 30468fa1696eSCollin L. Walling vcpu->arch.sie_block->epdx = kvm->arch.epdx; 30478fa1696eSCollin L. Walling } 30488fa1696eSCollin L. Walling 30498fa1696eSCollin L. Walling kvm_s390_vcpu_unblock_all(kvm); 30508fa1696eSCollin L. Walling preempt_enable(); 30518fa1696eSCollin L. Walling mutex_unlock(&kvm->lock); 30528fa1696eSCollin L. Walling } 30538fa1696eSCollin L. Walling 305425ed1675SDavid Hildenbrand void kvm_s390_set_tod_clock(struct kvm *kvm, u64 tod) 305525ed1675SDavid Hildenbrand { 305625ed1675SDavid Hildenbrand struct kvm_vcpu *vcpu; 305725ed1675SDavid Hildenbrand int i; 305825ed1675SDavid Hildenbrand 305925ed1675SDavid Hildenbrand mutex_lock(&kvm->lock); 306025ed1675SDavid Hildenbrand preempt_disable(); 306125ed1675SDavid Hildenbrand kvm->arch.epoch = tod - get_tod_clock(); 306225ed1675SDavid Hildenbrand kvm_s390_vcpu_block_all(kvm); 306325ed1675SDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) 306425ed1675SDavid Hildenbrand vcpu->arch.sie_block->epoch = kvm->arch.epoch; 306525ed1675SDavid Hildenbrand kvm_s390_vcpu_unblock_all(kvm); 306625ed1675SDavid Hildenbrand preempt_enable(); 306725ed1675SDavid Hildenbrand mutex_unlock(&kvm->lock); 306825ed1675SDavid Hildenbrand } 306925ed1675SDavid Hildenbrand 3070fa576c58SThomas Huth /** 3071fa576c58SThomas Huth * kvm_arch_fault_in_page - fault-in guest page if necessary 3072fa576c58SThomas Huth * @vcpu: The corresponding virtual cpu 3073fa576c58SThomas Huth * @gpa: Guest physical address 3074fa576c58SThomas Huth * @writable: Whether the page should be writable or not 3075fa576c58SThomas Huth * 3076fa576c58SThomas Huth * Make sure that a guest page has been faulted-in on the host. 3077fa576c58SThomas Huth * 3078fa576c58SThomas Huth * Return: Zero on success, negative error code otherwise. 3079fa576c58SThomas Huth */ 3080fa576c58SThomas Huth long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable) 308124eb3a82SDominik Dingel { 3082527e30b4SMartin Schwidefsky return gmap_fault(vcpu->arch.gmap, gpa, 3083527e30b4SMartin Schwidefsky writable ? FAULT_FLAG_WRITE : 0); 308424eb3a82SDominik Dingel } 308524eb3a82SDominik Dingel 30863c038e6bSDominik Dingel static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token, 30873c038e6bSDominik Dingel unsigned long token) 30883c038e6bSDominik Dingel { 30893c038e6bSDominik Dingel struct kvm_s390_interrupt inti; 3090383d0b05SJens Freimann struct kvm_s390_irq irq; 30913c038e6bSDominik Dingel 30923c038e6bSDominik Dingel if (start_token) { 3093383d0b05SJens Freimann irq.u.ext.ext_params2 = token; 3094383d0b05SJens Freimann irq.type = KVM_S390_INT_PFAULT_INIT; 3095383d0b05SJens Freimann WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &irq)); 30963c038e6bSDominik Dingel } else { 30973c038e6bSDominik Dingel inti.type = KVM_S390_INT_PFAULT_DONE; 3098383d0b05SJens Freimann inti.parm64 = token; 30993c038e6bSDominik Dingel WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti)); 31003c038e6bSDominik Dingel } 31013c038e6bSDominik Dingel } 31023c038e6bSDominik Dingel 31033c038e6bSDominik Dingel void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu, 31043c038e6bSDominik Dingel struct kvm_async_pf *work) 31053c038e6bSDominik Dingel { 31063c038e6bSDominik Dingel trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token); 31073c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token); 31083c038e6bSDominik Dingel } 31093c038e6bSDominik Dingel 31103c038e6bSDominik Dingel void kvm_arch_async_page_present(struct kvm_vcpu *vcpu, 31113c038e6bSDominik Dingel struct kvm_async_pf *work) 31123c038e6bSDominik Dingel { 31133c038e6bSDominik Dingel trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token); 31143c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token); 31153c038e6bSDominik Dingel } 31163c038e6bSDominik Dingel 31173c038e6bSDominik Dingel void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu, 31183c038e6bSDominik Dingel struct kvm_async_pf *work) 31193c038e6bSDominik Dingel { 31203c038e6bSDominik Dingel /* s390 will always inject the page directly */ 31213c038e6bSDominik Dingel } 31223c038e6bSDominik Dingel 31233c038e6bSDominik Dingel bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu) 31243c038e6bSDominik Dingel { 31253c038e6bSDominik Dingel /* 31263c038e6bSDominik Dingel * s390 will always inject the page directly, 31273c038e6bSDominik Dingel * but we still want check_async_completion to cleanup 31283c038e6bSDominik Dingel */ 31293c038e6bSDominik Dingel return true; 31303c038e6bSDominik Dingel } 31313c038e6bSDominik Dingel 31323c038e6bSDominik Dingel static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu) 31333c038e6bSDominik Dingel { 31343c038e6bSDominik Dingel hva_t hva; 31353c038e6bSDominik Dingel struct kvm_arch_async_pf arch; 31363c038e6bSDominik Dingel int rc; 31373c038e6bSDominik Dingel 31383c038e6bSDominik Dingel if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 31393c038e6bSDominik Dingel return 0; 31403c038e6bSDominik Dingel if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) != 31413c038e6bSDominik Dingel vcpu->arch.pfault_compare) 31423c038e6bSDominik Dingel return 0; 31433c038e6bSDominik Dingel if (psw_extint_disabled(vcpu)) 31443c038e6bSDominik Dingel return 0; 31459a022067SDavid Hildenbrand if (kvm_s390_vcpu_has_irq(vcpu, 0)) 31463c038e6bSDominik Dingel return 0; 31473c038e6bSDominik Dingel if (!(vcpu->arch.sie_block->gcr[0] & 0x200ul)) 31483c038e6bSDominik Dingel return 0; 31493c038e6bSDominik Dingel if (!vcpu->arch.gmap->pfault_enabled) 31503c038e6bSDominik Dingel return 0; 31513c038e6bSDominik Dingel 315281480cc1SHeiko Carstens hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(current->thread.gmap_addr)); 315381480cc1SHeiko Carstens hva += current->thread.gmap_addr & ~PAGE_MASK; 315481480cc1SHeiko Carstens if (read_guest_real(vcpu, vcpu->arch.pfault_token, &arch.pfault_token, 8)) 31553c038e6bSDominik Dingel return 0; 31563c038e6bSDominik Dingel 31573c038e6bSDominik Dingel rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch); 31583c038e6bSDominik Dingel return rc; 31593c038e6bSDominik Dingel } 31603c038e6bSDominik Dingel 31613fb4c40fSThomas Huth static int vcpu_pre_run(struct kvm_vcpu *vcpu) 3162b0c632dbSHeiko Carstens { 31633fb4c40fSThomas Huth int rc, cpuflags; 3164e168bf8dSCarsten Otte 31653c038e6bSDominik Dingel /* 31663c038e6bSDominik Dingel * On s390 notifications for arriving pages will be delivered directly 31673c038e6bSDominik Dingel * to the guest but the house keeping for completed pfaults is 31683c038e6bSDominik Dingel * handled outside the worker. 31693c038e6bSDominik Dingel */ 31703c038e6bSDominik Dingel kvm_check_async_pf_completion(vcpu); 31713c038e6bSDominik Dingel 31727ec7c8c7SChristian Borntraeger vcpu->arch.sie_block->gg14 = vcpu->run->s.regs.gprs[14]; 31737ec7c8c7SChristian Borntraeger vcpu->arch.sie_block->gg15 = vcpu->run->s.regs.gprs[15]; 3174b0c632dbSHeiko Carstens 3175b0c632dbSHeiko Carstens if (need_resched()) 3176b0c632dbSHeiko Carstens schedule(); 3177b0c632dbSHeiko Carstens 3178d3a73acbSMartin Schwidefsky if (test_cpu_flag(CIF_MCCK_PENDING)) 317971cde587SChristian Borntraeger s390_handle_mcck(); 318071cde587SChristian Borntraeger 318179395031SJens Freimann if (!kvm_is_ucontrol(vcpu->kvm)) { 318279395031SJens Freimann rc = kvm_s390_deliver_pending_interrupts(vcpu); 318379395031SJens Freimann if (rc) 318479395031SJens Freimann return rc; 318579395031SJens Freimann } 31860ff31867SCarsten Otte 31872c70fe44SChristian Borntraeger rc = kvm_s390_handle_requests(vcpu); 31882c70fe44SChristian Borntraeger if (rc) 31892c70fe44SChristian Borntraeger return rc; 31902c70fe44SChristian Borntraeger 319127291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) { 319227291e21SDavid Hildenbrand kvm_s390_backup_guest_per_regs(vcpu); 319327291e21SDavid Hildenbrand kvm_s390_patch_guest_per_regs(vcpu); 319427291e21SDavid Hildenbrand } 319527291e21SDavid Hildenbrand 3196b0c632dbSHeiko Carstens vcpu->arch.sie_block->icptcode = 0; 31973fb4c40fSThomas Huth cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags); 31983fb4c40fSThomas Huth VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags); 31993fb4c40fSThomas Huth trace_kvm_s390_sie_enter(vcpu, cpuflags); 32002b29a9fdSDominik Dingel 32013fb4c40fSThomas Huth return 0; 32023fb4c40fSThomas Huth } 32033fb4c40fSThomas Huth 3204492d8642SThomas Huth static int vcpu_post_run_fault_in_sie(struct kvm_vcpu *vcpu) 3205492d8642SThomas Huth { 320656317920SDavid Hildenbrand struct kvm_s390_pgm_info pgm_info = { 320756317920SDavid Hildenbrand .code = PGM_ADDRESSING, 320856317920SDavid Hildenbrand }; 320956317920SDavid Hildenbrand u8 opcode, ilen; 3210492d8642SThomas Huth int rc; 3211492d8642SThomas Huth 3212492d8642SThomas Huth VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction"); 3213492d8642SThomas Huth trace_kvm_s390_sie_fault(vcpu); 3214492d8642SThomas Huth 3215492d8642SThomas Huth /* 3216492d8642SThomas Huth * We want to inject an addressing exception, which is defined as a 3217492d8642SThomas Huth * suppressing or terminating exception. However, since we came here 3218492d8642SThomas Huth * by a DAT access exception, the PSW still points to the faulting 3219492d8642SThomas Huth * instruction since DAT exceptions are nullifying. So we've got 3220492d8642SThomas Huth * to look up the current opcode to get the length of the instruction 3221492d8642SThomas Huth * to be able to forward the PSW. 3222492d8642SThomas Huth */ 32233fa8cad7SDavid Hildenbrand rc = read_guest_instr(vcpu, vcpu->arch.sie_block->gpsw.addr, &opcode, 1); 322456317920SDavid Hildenbrand ilen = insn_length(opcode); 32259b0d721aSDavid Hildenbrand if (rc < 0) { 32269b0d721aSDavid Hildenbrand return rc; 32279b0d721aSDavid Hildenbrand } else if (rc) { 32289b0d721aSDavid Hildenbrand /* Instruction-Fetching Exceptions - we can't detect the ilen. 32299b0d721aSDavid Hildenbrand * Forward by arbitrary ilc, injection will take care of 32309b0d721aSDavid Hildenbrand * nullification if necessary. 32319b0d721aSDavid Hildenbrand */ 32329b0d721aSDavid Hildenbrand pgm_info = vcpu->arch.pgm; 32339b0d721aSDavid Hildenbrand ilen = 4; 32349b0d721aSDavid Hildenbrand } 323556317920SDavid Hildenbrand pgm_info.flags = ilen | KVM_S390_PGM_FLAGS_ILC_VALID; 323656317920SDavid Hildenbrand kvm_s390_forward_psw(vcpu, ilen); 323756317920SDavid Hildenbrand return kvm_s390_inject_prog_irq(vcpu, &pgm_info); 3238492d8642SThomas Huth } 3239492d8642SThomas Huth 32403fb4c40fSThomas Huth static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason) 32413fb4c40fSThomas Huth { 32424d62fcc0SQingFeng Hao struct mcck_volatile_info *mcck_info; 32434d62fcc0SQingFeng Hao struct sie_page *sie_page; 32444d62fcc0SQingFeng Hao 32452b29a9fdSDominik Dingel VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", 32462b29a9fdSDominik Dingel vcpu->arch.sie_block->icptcode); 32472b29a9fdSDominik Dingel trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode); 32482b29a9fdSDominik Dingel 324927291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) 325027291e21SDavid Hildenbrand kvm_s390_restore_guest_per_regs(vcpu); 325127291e21SDavid Hildenbrand 32527ec7c8c7SChristian Borntraeger vcpu->run->s.regs.gprs[14] = vcpu->arch.sie_block->gg14; 32537ec7c8c7SChristian Borntraeger vcpu->run->s.regs.gprs[15] = vcpu->arch.sie_block->gg15; 325471f116bfSDavid Hildenbrand 32554d62fcc0SQingFeng Hao if (exit_reason == -EINTR) { 32564d62fcc0SQingFeng Hao VCPU_EVENT(vcpu, 3, "%s", "machine check"); 32574d62fcc0SQingFeng Hao sie_page = container_of(vcpu->arch.sie_block, 32584d62fcc0SQingFeng Hao struct sie_page, sie_block); 32594d62fcc0SQingFeng Hao mcck_info = &sie_page->mcck_info; 32604d62fcc0SQingFeng Hao kvm_s390_reinject_machine_check(vcpu, mcck_info); 32614d62fcc0SQingFeng Hao return 0; 32624d62fcc0SQingFeng Hao } 32634d62fcc0SQingFeng Hao 326471f116bfSDavid Hildenbrand if (vcpu->arch.sie_block->icptcode > 0) { 326571f116bfSDavid Hildenbrand int rc = kvm_handle_sie_intercept(vcpu); 326671f116bfSDavid Hildenbrand 326771f116bfSDavid Hildenbrand if (rc != -EOPNOTSUPP) 326871f116bfSDavid Hildenbrand return rc; 326971f116bfSDavid Hildenbrand vcpu->run->exit_reason = KVM_EXIT_S390_SIEIC; 327071f116bfSDavid Hildenbrand vcpu->run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode; 327171f116bfSDavid Hildenbrand vcpu->run->s390_sieic.ipa = vcpu->arch.sie_block->ipa; 327271f116bfSDavid Hildenbrand vcpu->run->s390_sieic.ipb = vcpu->arch.sie_block->ipb; 327371f116bfSDavid Hildenbrand return -EREMOTE; 327471f116bfSDavid Hildenbrand } else if (exit_reason != -EFAULT) { 327571f116bfSDavid Hildenbrand vcpu->stat.exit_null++; 327671f116bfSDavid Hildenbrand return 0; 3277210b1607SThomas Huth } else if (kvm_is_ucontrol(vcpu->kvm)) { 3278210b1607SThomas Huth vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL; 3279210b1607SThomas Huth vcpu->run->s390_ucontrol.trans_exc_code = 3280210b1607SThomas Huth current->thread.gmap_addr; 3281210b1607SThomas Huth vcpu->run->s390_ucontrol.pgm_code = 0x10; 328271f116bfSDavid Hildenbrand return -EREMOTE; 328324eb3a82SDominik Dingel } else if (current->thread.gmap_pfault) { 32843c038e6bSDominik Dingel trace_kvm_s390_major_guest_pfault(vcpu); 328524eb3a82SDominik Dingel current->thread.gmap_pfault = 0; 328671f116bfSDavid Hildenbrand if (kvm_arch_setup_async_pf(vcpu)) 328771f116bfSDavid Hildenbrand return 0; 328871f116bfSDavid Hildenbrand return kvm_arch_fault_in_page(vcpu, current->thread.gmap_addr, 1); 3289fa576c58SThomas Huth } 329071f116bfSDavid Hildenbrand return vcpu_post_run_fault_in_sie(vcpu); 32913fb4c40fSThomas Huth } 32923fb4c40fSThomas Huth 32933fb4c40fSThomas Huth static int __vcpu_run(struct kvm_vcpu *vcpu) 32943fb4c40fSThomas Huth { 32953fb4c40fSThomas Huth int rc, exit_reason; 32963fb4c40fSThomas Huth 3297800c1065SThomas Huth /* 3298800c1065SThomas Huth * We try to hold kvm->srcu during most of vcpu_run (except when run- 3299800c1065SThomas Huth * ning the guest), so that memslots (and other stuff) are protected 3300800c1065SThomas Huth */ 3301800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 3302800c1065SThomas Huth 3303a76ccff6SThomas Huth do { 33043fb4c40fSThomas Huth rc = vcpu_pre_run(vcpu); 33053fb4c40fSThomas Huth if (rc) 3306a76ccff6SThomas Huth break; 33073fb4c40fSThomas Huth 3308800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 33093fb4c40fSThomas Huth /* 3310a76ccff6SThomas Huth * As PF_VCPU will be used in fault handler, between 3311a76ccff6SThomas Huth * guest_enter and guest_exit should be no uaccess. 33123fb4c40fSThomas Huth */ 33130097d12eSChristian Borntraeger local_irq_disable(); 33146edaa530SPaolo Bonzini guest_enter_irqoff(); 3315db0758b2SDavid Hildenbrand __disable_cpu_timer_accounting(vcpu); 33160097d12eSChristian Borntraeger local_irq_enable(); 3317a76ccff6SThomas Huth exit_reason = sie64a(vcpu->arch.sie_block, 3318a76ccff6SThomas Huth vcpu->run->s.regs.gprs); 33190097d12eSChristian Borntraeger local_irq_disable(); 3320db0758b2SDavid Hildenbrand __enable_cpu_timer_accounting(vcpu); 33216edaa530SPaolo Bonzini guest_exit_irqoff(); 33220097d12eSChristian Borntraeger local_irq_enable(); 3323800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 33243fb4c40fSThomas Huth 33253fb4c40fSThomas Huth rc = vcpu_post_run(vcpu, exit_reason); 332627291e21SDavid Hildenbrand } while (!signal_pending(current) && !guestdbg_exit_pending(vcpu) && !rc); 33273fb4c40fSThomas Huth 3328800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 3329e168bf8dSCarsten Otte return rc; 3330b0c632dbSHeiko Carstens } 3331b0c632dbSHeiko Carstens 3332b028ee3eSDavid Hildenbrand static void sync_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 3333b028ee3eSDavid Hildenbrand { 33344d5f2c04SChristian Borntraeger struct runtime_instr_cb *riccb; 33354e0b1ab7SFan Zhang struct gs_cb *gscb; 33364d5f2c04SChristian Borntraeger 33374d5f2c04SChristian Borntraeger riccb = (struct runtime_instr_cb *) &kvm_run->s.regs.riccb; 33384e0b1ab7SFan Zhang gscb = (struct gs_cb *) &kvm_run->s.regs.gscb; 3339b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask; 3340b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr; 3341b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) 3342b028ee3eSDavid Hildenbrand kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix); 3343b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) { 3344b028ee3eSDavid Hildenbrand memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128); 3345d3d692c8SDavid Hildenbrand /* some control register changes require a tlb flush */ 3346d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 3347b028ee3eSDavid Hildenbrand } 3348b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_ARCH0) { 33494287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, kvm_run->s.regs.cputm); 3350b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->ckc = kvm_run->s.regs.ckc; 3351b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->todpr = kvm_run->s.regs.todpr; 3352b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->pp = kvm_run->s.regs.pp; 3353b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gbea = kvm_run->s.regs.gbea; 3354b028ee3eSDavid Hildenbrand } 3355b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PFAULT) { 3356b028ee3eSDavid Hildenbrand vcpu->arch.pfault_token = kvm_run->s.regs.pft; 3357b028ee3eSDavid Hildenbrand vcpu->arch.pfault_select = kvm_run->s.regs.pfs; 3358b028ee3eSDavid Hildenbrand vcpu->arch.pfault_compare = kvm_run->s.regs.pfc; 33599fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 33609fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 3361b028ee3eSDavid Hildenbrand } 336280cd8763SFan Zhang /* 336380cd8763SFan Zhang * If userspace sets the riccb (e.g. after migration) to a valid state, 336480cd8763SFan Zhang * we should enable RI here instead of doing the lazy enablement. 336580cd8763SFan Zhang */ 336680cd8763SFan Zhang if ((kvm_run->kvm_dirty_regs & KVM_SYNC_RICCB) && 33674d5f2c04SChristian Borntraeger test_kvm_facility(vcpu->kvm, 64) && 3368bb59c2daSAlice Frosi riccb->v && 33690c9d8683SDavid Hildenbrand !(vcpu->arch.sie_block->ecb3 & ECB3_RI)) { 33704d5f2c04SChristian Borntraeger VCPU_EVENT(vcpu, 3, "%s", "ENABLE: RI (sync_regs)"); 33710c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb3 |= ECB3_RI; 337280cd8763SFan Zhang } 33734e0b1ab7SFan Zhang /* 33744e0b1ab7SFan Zhang * If userspace sets the gscb (e.g. after migration) to non-zero, 33754e0b1ab7SFan Zhang * we should enable GS here instead of doing the lazy enablement. 33764e0b1ab7SFan Zhang */ 33774e0b1ab7SFan Zhang if ((kvm_run->kvm_dirty_regs & KVM_SYNC_GSCB) && 33784e0b1ab7SFan Zhang test_kvm_facility(vcpu->kvm, 133) && 33794e0b1ab7SFan Zhang gscb->gssm && 33804e0b1ab7SFan Zhang !vcpu->arch.gs_enabled) { 33814e0b1ab7SFan Zhang VCPU_EVENT(vcpu, 3, "%s", "ENABLE: GS (sync_regs)"); 33824e0b1ab7SFan Zhang vcpu->arch.sie_block->ecb |= ECB_GS; 33834e0b1ab7SFan Zhang vcpu->arch.sie_block->ecd |= ECD_HOSTREGMGMT; 33844e0b1ab7SFan Zhang vcpu->arch.gs_enabled = 1; 338580cd8763SFan Zhang } 338635b3fde6SChristian Borntraeger if ((kvm_run->kvm_dirty_regs & KVM_SYNC_BPBC) && 338735b3fde6SChristian Borntraeger test_kvm_facility(vcpu->kvm, 82)) { 338835b3fde6SChristian Borntraeger vcpu->arch.sie_block->fpf &= ~FPF_BPBC; 338935b3fde6SChristian Borntraeger vcpu->arch.sie_block->fpf |= kvm_run->s.regs.bpbc ? FPF_BPBC : 0; 339035b3fde6SChristian Borntraeger } 339131d8b8d4SChristian Borntraeger save_access_regs(vcpu->arch.host_acrs); 339231d8b8d4SChristian Borntraeger restore_access_regs(vcpu->run->s.regs.acrs); 3393e1788bb9SChristian Borntraeger /* save host (userspace) fprs/vrs */ 3394e1788bb9SChristian Borntraeger save_fpu_regs(); 3395e1788bb9SChristian Borntraeger vcpu->arch.host_fpregs.fpc = current->thread.fpu.fpc; 3396e1788bb9SChristian Borntraeger vcpu->arch.host_fpregs.regs = current->thread.fpu.regs; 3397e1788bb9SChristian Borntraeger if (MACHINE_HAS_VX) 3398e1788bb9SChristian Borntraeger current->thread.fpu.regs = vcpu->run->s.regs.vrs; 3399e1788bb9SChristian Borntraeger else 3400e1788bb9SChristian Borntraeger current->thread.fpu.regs = vcpu->run->s.regs.fprs; 3401e1788bb9SChristian Borntraeger current->thread.fpu.fpc = vcpu->run->s.regs.fpc; 3402e1788bb9SChristian Borntraeger if (test_fp_ctl(current->thread.fpu.fpc)) 3403e1788bb9SChristian Borntraeger /* User space provided an invalid FPC, let's clear it */ 3404e1788bb9SChristian Borntraeger current->thread.fpu.fpc = 0; 34054e0b1ab7SFan Zhang if (MACHINE_HAS_GS) { 34064e0b1ab7SFan Zhang preempt_disable(); 34074e0b1ab7SFan Zhang __ctl_set_bit(2, 4); 34084e0b1ab7SFan Zhang if (current->thread.gs_cb) { 34094e0b1ab7SFan Zhang vcpu->arch.host_gscb = current->thread.gs_cb; 34104e0b1ab7SFan Zhang save_gs_cb(vcpu->arch.host_gscb); 34114e0b1ab7SFan Zhang } 34124e0b1ab7SFan Zhang if (vcpu->arch.gs_enabled) { 34134e0b1ab7SFan Zhang current->thread.gs_cb = (struct gs_cb *) 34144e0b1ab7SFan Zhang &vcpu->run->s.regs.gscb; 34154e0b1ab7SFan Zhang restore_gs_cb(current->thread.gs_cb); 34164e0b1ab7SFan Zhang } 34174e0b1ab7SFan Zhang preempt_enable(); 34184e0b1ab7SFan Zhang } 341980cd8763SFan Zhang 3420b028ee3eSDavid Hildenbrand kvm_run->kvm_dirty_regs = 0; 3421b028ee3eSDavid Hildenbrand } 3422b028ee3eSDavid Hildenbrand 3423b028ee3eSDavid Hildenbrand static void store_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 3424b028ee3eSDavid Hildenbrand { 3425b028ee3eSDavid Hildenbrand kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask; 3426b028ee3eSDavid Hildenbrand kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr; 3427b028ee3eSDavid Hildenbrand kvm_run->s.regs.prefix = kvm_s390_get_prefix(vcpu); 3428b028ee3eSDavid Hildenbrand memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128); 34294287f247SDavid Hildenbrand kvm_run->s.regs.cputm = kvm_s390_get_cpu_timer(vcpu); 3430b028ee3eSDavid Hildenbrand kvm_run->s.regs.ckc = vcpu->arch.sie_block->ckc; 3431b028ee3eSDavid Hildenbrand kvm_run->s.regs.todpr = vcpu->arch.sie_block->todpr; 3432b028ee3eSDavid Hildenbrand kvm_run->s.regs.pp = vcpu->arch.sie_block->pp; 3433b028ee3eSDavid Hildenbrand kvm_run->s.regs.gbea = vcpu->arch.sie_block->gbea; 3434b028ee3eSDavid Hildenbrand kvm_run->s.regs.pft = vcpu->arch.pfault_token; 3435b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfs = vcpu->arch.pfault_select; 3436b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfc = vcpu->arch.pfault_compare; 343735b3fde6SChristian Borntraeger kvm_run->s.regs.bpbc = (vcpu->arch.sie_block->fpf & FPF_BPBC) == FPF_BPBC; 343831d8b8d4SChristian Borntraeger save_access_regs(vcpu->run->s.regs.acrs); 343931d8b8d4SChristian Borntraeger restore_access_regs(vcpu->arch.host_acrs); 3440e1788bb9SChristian Borntraeger /* Save guest register state */ 3441e1788bb9SChristian Borntraeger save_fpu_regs(); 3442e1788bb9SChristian Borntraeger vcpu->run->s.regs.fpc = current->thread.fpu.fpc; 3443e1788bb9SChristian Borntraeger /* Restore will be done lazily at return */ 3444e1788bb9SChristian Borntraeger current->thread.fpu.fpc = vcpu->arch.host_fpregs.fpc; 3445e1788bb9SChristian Borntraeger current->thread.fpu.regs = vcpu->arch.host_fpregs.regs; 34464e0b1ab7SFan Zhang if (MACHINE_HAS_GS) { 34474e0b1ab7SFan Zhang __ctl_set_bit(2, 4); 34484e0b1ab7SFan Zhang if (vcpu->arch.gs_enabled) 34494e0b1ab7SFan Zhang save_gs_cb(current->thread.gs_cb); 34504e0b1ab7SFan Zhang preempt_disable(); 34514e0b1ab7SFan Zhang current->thread.gs_cb = vcpu->arch.host_gscb; 34524e0b1ab7SFan Zhang restore_gs_cb(vcpu->arch.host_gscb); 34534e0b1ab7SFan Zhang preempt_enable(); 34544e0b1ab7SFan Zhang if (!vcpu->arch.host_gscb) 34554e0b1ab7SFan Zhang __ctl_clear_bit(2, 4); 34564e0b1ab7SFan Zhang vcpu->arch.host_gscb = NULL; 34574e0b1ab7SFan Zhang } 3458e1788bb9SChristian Borntraeger 3459b028ee3eSDavid Hildenbrand } 3460b028ee3eSDavid Hildenbrand 3461b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 3462b0c632dbSHeiko Carstens { 34638f2abe6aSChristian Borntraeger int rc; 3464b0c632dbSHeiko Carstens 3465460df4c1SPaolo Bonzini if (kvm_run->immediate_exit) 3466460df4c1SPaolo Bonzini return -EINTR; 3467460df4c1SPaolo Bonzini 3468accb757dSChristoffer Dall vcpu_load(vcpu); 3469accb757dSChristoffer Dall 347027291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu)) { 347127291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 3472accb757dSChristoffer Dall rc = 0; 3473accb757dSChristoffer Dall goto out; 347427291e21SDavid Hildenbrand } 347527291e21SDavid Hildenbrand 347620b7035cSJan H. Schönherr kvm_sigset_activate(vcpu); 3477b0c632dbSHeiko Carstens 34786352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) { 34796852d7b6SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 34806352e4d2SDavid Hildenbrand } else if (is_vcpu_stopped(vcpu)) { 3481ea2cdd27SDavid Hildenbrand pr_err_ratelimited("can't run stopped vcpu %d\n", 34826352e4d2SDavid Hildenbrand vcpu->vcpu_id); 3483accb757dSChristoffer Dall rc = -EINVAL; 3484accb757dSChristoffer Dall goto out; 34856352e4d2SDavid Hildenbrand } 3486b0c632dbSHeiko Carstens 3487b028ee3eSDavid Hildenbrand sync_regs(vcpu, kvm_run); 3488db0758b2SDavid Hildenbrand enable_cpu_timer_accounting(vcpu); 3489d7b0b5ebSCarsten Otte 3490dab4079dSHeiko Carstens might_fault(); 3491e168bf8dSCarsten Otte rc = __vcpu_run(vcpu); 34929ace903dSChristian Ehrhardt 3493b1d16c49SChristian Ehrhardt if (signal_pending(current) && !rc) { 3494b1d16c49SChristian Ehrhardt kvm_run->exit_reason = KVM_EXIT_INTR; 34958f2abe6aSChristian Borntraeger rc = -EINTR; 3496b1d16c49SChristian Ehrhardt } 34978f2abe6aSChristian Borntraeger 349827291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu) && !rc) { 349927291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 350027291e21SDavid Hildenbrand rc = 0; 350127291e21SDavid Hildenbrand } 350227291e21SDavid Hildenbrand 35038f2abe6aSChristian Borntraeger if (rc == -EREMOTE) { 350471f116bfSDavid Hildenbrand /* userspace support is needed, kvm_run has been prepared */ 35058f2abe6aSChristian Borntraeger rc = 0; 35068f2abe6aSChristian Borntraeger } 35078f2abe6aSChristian Borntraeger 3508db0758b2SDavid Hildenbrand disable_cpu_timer_accounting(vcpu); 3509b028ee3eSDavid Hildenbrand store_regs(vcpu, kvm_run); 3510d7b0b5ebSCarsten Otte 351120b7035cSJan H. Schönherr kvm_sigset_deactivate(vcpu); 3512b0c632dbSHeiko Carstens 3513b0c632dbSHeiko Carstens vcpu->stat.exit_userspace++; 3514accb757dSChristoffer Dall out: 3515accb757dSChristoffer Dall vcpu_put(vcpu); 35167e8e6ab4SHeiko Carstens return rc; 3517b0c632dbSHeiko Carstens } 3518b0c632dbSHeiko Carstens 3519b0c632dbSHeiko Carstens /* 3520b0c632dbSHeiko Carstens * store status at address 3521b0c632dbSHeiko Carstens * we use have two special cases: 3522b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit 3523b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_PREFIXED: -> prefix 3524b0c632dbSHeiko Carstens */ 3525d0bce605SHeiko Carstens int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long gpa) 3526b0c632dbSHeiko Carstens { 3527092670cdSCarsten Otte unsigned char archmode = 1; 35289abc2a08SDavid Hildenbrand freg_t fprs[NUM_FPRS]; 3529fda902cbSMichael Mueller unsigned int px; 35304287f247SDavid Hildenbrand u64 clkcomp, cputm; 3531d0bce605SHeiko Carstens int rc; 3532b0c632dbSHeiko Carstens 3533d9a3a09aSMartin Schwidefsky px = kvm_s390_get_prefix(vcpu); 3534d0bce605SHeiko Carstens if (gpa == KVM_S390_STORE_STATUS_NOADDR) { 3535d0bce605SHeiko Carstens if (write_guest_abs(vcpu, 163, &archmode, 1)) 3536b0c632dbSHeiko Carstens return -EFAULT; 3537d9a3a09aSMartin Schwidefsky gpa = 0; 3538d0bce605SHeiko Carstens } else if (gpa == KVM_S390_STORE_STATUS_PREFIXED) { 3539d0bce605SHeiko Carstens if (write_guest_real(vcpu, 163, &archmode, 1)) 3540b0c632dbSHeiko Carstens return -EFAULT; 3541d9a3a09aSMartin Schwidefsky gpa = px; 3542d9a3a09aSMartin Schwidefsky } else 3543d9a3a09aSMartin Schwidefsky gpa -= __LC_FPREGS_SAVE_AREA; 35449abc2a08SDavid Hildenbrand 35459abc2a08SDavid Hildenbrand /* manually convert vector registers if necessary */ 35469abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) { 35479522b37fSDavid Hildenbrand convert_vx_to_fp(fprs, (__vector128 *) vcpu->run->s.regs.vrs); 3548d9a3a09aSMartin Schwidefsky rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA, 35499abc2a08SDavid Hildenbrand fprs, 128); 35509abc2a08SDavid Hildenbrand } else { 35519abc2a08SDavid Hildenbrand rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA, 35526fd8e67dSDavid Hildenbrand vcpu->run->s.regs.fprs, 128); 35539abc2a08SDavid Hildenbrand } 3554d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_GPREGS_SAVE_AREA, 3555d0bce605SHeiko Carstens vcpu->run->s.regs.gprs, 128); 3556d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_PSW_SAVE_AREA, 3557d0bce605SHeiko Carstens &vcpu->arch.sie_block->gpsw, 16); 3558d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_PREFIX_SAVE_AREA, 3559fda902cbSMichael Mueller &px, 4); 3560d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_FP_CREG_SAVE_AREA, 35619abc2a08SDavid Hildenbrand &vcpu->run->s.regs.fpc, 4); 3562d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_TOD_PROGREG_SAVE_AREA, 3563d0bce605SHeiko Carstens &vcpu->arch.sie_block->todpr, 4); 35644287f247SDavid Hildenbrand cputm = kvm_s390_get_cpu_timer(vcpu); 3565d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CPU_TIMER_SAVE_AREA, 35664287f247SDavid Hildenbrand &cputm, 8); 3567178bd789SThomas Huth clkcomp = vcpu->arch.sie_block->ckc >> 8; 3568d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CLOCK_COMP_SAVE_AREA, 3569d0bce605SHeiko Carstens &clkcomp, 8); 3570d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_AREGS_SAVE_AREA, 3571d0bce605SHeiko Carstens &vcpu->run->s.regs.acrs, 64); 3572d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CREGS_SAVE_AREA, 3573d0bce605SHeiko Carstens &vcpu->arch.sie_block->gcr, 128); 3574d0bce605SHeiko Carstens return rc ? -EFAULT : 0; 3575b0c632dbSHeiko Carstens } 3576b0c632dbSHeiko Carstens 3577e879892cSThomas Huth int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr) 3578e879892cSThomas Huth { 3579e879892cSThomas Huth /* 3580e879892cSThomas Huth * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy 358131d8b8d4SChristian Borntraeger * switch in the run ioctl. Let's update our copies before we save 3582e879892cSThomas Huth * it into the save area 3583e879892cSThomas Huth */ 3584d0164ee2SHendrik Brueckner save_fpu_regs(); 35859abc2a08SDavid Hildenbrand vcpu->run->s.regs.fpc = current->thread.fpu.fpc; 3586e879892cSThomas Huth save_access_regs(vcpu->run->s.regs.acrs); 3587e879892cSThomas Huth 3588e879892cSThomas Huth return kvm_s390_store_status_unloaded(vcpu, addr); 3589e879892cSThomas Huth } 3590e879892cSThomas Huth 35918ad35755SDavid Hildenbrand static void __disable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 35928ad35755SDavid Hildenbrand { 35938ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu); 35948e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_DISABLE_IBS, vcpu); 35958ad35755SDavid Hildenbrand } 35968ad35755SDavid Hildenbrand 35978ad35755SDavid Hildenbrand static void __disable_ibs_on_all_vcpus(struct kvm *kvm) 35988ad35755SDavid Hildenbrand { 35998ad35755SDavid Hildenbrand unsigned int i; 36008ad35755SDavid Hildenbrand struct kvm_vcpu *vcpu; 36018ad35755SDavid Hildenbrand 36028ad35755SDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 36038ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 36048ad35755SDavid Hildenbrand } 36058ad35755SDavid Hildenbrand } 36068ad35755SDavid Hildenbrand 36078ad35755SDavid Hildenbrand static void __enable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 36088ad35755SDavid Hildenbrand { 360909a400e7SDavid Hildenbrand if (!sclp.has_ibs) 361009a400e7SDavid Hildenbrand return; 36118ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu); 36128e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_ENABLE_IBS, vcpu); 36138ad35755SDavid Hildenbrand } 36148ad35755SDavid Hildenbrand 36156852d7b6SDavid Hildenbrand void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu) 36166852d7b6SDavid Hildenbrand { 36178ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 36188ad35755SDavid Hildenbrand 36198ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 36208ad35755SDavid Hildenbrand return; 36218ad35755SDavid Hildenbrand 36226852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 1); 36238ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 3624433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 36258ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 36268ad35755SDavid Hildenbrand 36278ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 36288ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) 36298ad35755SDavid Hildenbrand started_vcpus++; 36308ad35755SDavid Hildenbrand } 36318ad35755SDavid Hildenbrand 36328ad35755SDavid Hildenbrand if (started_vcpus == 0) { 36338ad35755SDavid Hildenbrand /* we're the only active VCPU -> speed it up */ 36348ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(vcpu); 36358ad35755SDavid Hildenbrand } else if (started_vcpus == 1) { 36368ad35755SDavid Hildenbrand /* 36378ad35755SDavid Hildenbrand * As we are starting a second VCPU, we have to disable 36388ad35755SDavid Hildenbrand * the IBS facility on all VCPUs to remove potentially 36398ad35755SDavid Hildenbrand * oustanding ENABLE requests. 36408ad35755SDavid Hildenbrand */ 36418ad35755SDavid Hildenbrand __disable_ibs_on_all_vcpus(vcpu->kvm); 36428ad35755SDavid Hildenbrand } 36438ad35755SDavid Hildenbrand 36449daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_STOPPED); 36458ad35755SDavid Hildenbrand /* 36468ad35755SDavid Hildenbrand * Another VCPU might have used IBS while we were offline. 36478ad35755SDavid Hildenbrand * Let's play safe and flush the VCPU at startup. 36488ad35755SDavid Hildenbrand */ 3649d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 3650433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 36518ad35755SDavid Hildenbrand return; 36526852d7b6SDavid Hildenbrand } 36536852d7b6SDavid Hildenbrand 36546852d7b6SDavid Hildenbrand void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu) 36556852d7b6SDavid Hildenbrand { 36568ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 36578ad35755SDavid Hildenbrand struct kvm_vcpu *started_vcpu = NULL; 36588ad35755SDavid Hildenbrand 36598ad35755SDavid Hildenbrand if (is_vcpu_stopped(vcpu)) 36608ad35755SDavid Hildenbrand return; 36618ad35755SDavid Hildenbrand 36626852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 0); 36638ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 3664433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 36658ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 36668ad35755SDavid Hildenbrand 366732f5ff63SDavid Hildenbrand /* SIGP STOP and SIGP STOP AND STORE STATUS has been fully processed */ 36686cddd432SDavid Hildenbrand kvm_s390_clear_stop_irq(vcpu); 366932f5ff63SDavid Hildenbrand 3670ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_STOPPED); 36718ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 36728ad35755SDavid Hildenbrand 36738ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 36748ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) { 36758ad35755SDavid Hildenbrand started_vcpus++; 36768ad35755SDavid Hildenbrand started_vcpu = vcpu->kvm->vcpus[i]; 36778ad35755SDavid Hildenbrand } 36788ad35755SDavid Hildenbrand } 36798ad35755SDavid Hildenbrand 36808ad35755SDavid Hildenbrand if (started_vcpus == 1) { 36818ad35755SDavid Hildenbrand /* 36828ad35755SDavid Hildenbrand * As we only have one VCPU left, we want to enable the 36838ad35755SDavid Hildenbrand * IBS facility for that VCPU to speed it up. 36848ad35755SDavid Hildenbrand */ 36858ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(started_vcpu); 36868ad35755SDavid Hildenbrand } 36878ad35755SDavid Hildenbrand 3688433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 36898ad35755SDavid Hildenbrand return; 36906852d7b6SDavid Hildenbrand } 36916852d7b6SDavid Hildenbrand 3692d6712df9SCornelia Huck static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 3693d6712df9SCornelia Huck struct kvm_enable_cap *cap) 3694d6712df9SCornelia Huck { 3695d6712df9SCornelia Huck int r; 3696d6712df9SCornelia Huck 3697d6712df9SCornelia Huck if (cap->flags) 3698d6712df9SCornelia Huck return -EINVAL; 3699d6712df9SCornelia Huck 3700d6712df9SCornelia Huck switch (cap->cap) { 3701fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 3702fa6b7fe9SCornelia Huck if (!vcpu->kvm->arch.css_support) { 3703fa6b7fe9SCornelia Huck vcpu->kvm->arch.css_support = 1; 3704c92ea7b9SChristian Borntraeger VM_EVENT(vcpu->kvm, 3, "%s", "ENABLE: CSS support"); 3705fa6b7fe9SCornelia Huck trace_kvm_s390_enable_css(vcpu->kvm); 3706fa6b7fe9SCornelia Huck } 3707fa6b7fe9SCornelia Huck r = 0; 3708fa6b7fe9SCornelia Huck break; 3709d6712df9SCornelia Huck default: 3710d6712df9SCornelia Huck r = -EINVAL; 3711d6712df9SCornelia Huck break; 3712d6712df9SCornelia Huck } 3713d6712df9SCornelia Huck return r; 3714d6712df9SCornelia Huck } 3715d6712df9SCornelia Huck 371641408c28SThomas Huth static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu, 371741408c28SThomas Huth struct kvm_s390_mem_op *mop) 371841408c28SThomas Huth { 371941408c28SThomas Huth void __user *uaddr = (void __user *)mop->buf; 372041408c28SThomas Huth void *tmpbuf = NULL; 372141408c28SThomas Huth int r, srcu_idx; 372241408c28SThomas Huth const u64 supported_flags = KVM_S390_MEMOP_F_INJECT_EXCEPTION 372341408c28SThomas Huth | KVM_S390_MEMOP_F_CHECK_ONLY; 372441408c28SThomas Huth 372541408c28SThomas Huth if (mop->flags & ~supported_flags) 372641408c28SThomas Huth return -EINVAL; 372741408c28SThomas Huth 372841408c28SThomas Huth if (mop->size > MEM_OP_MAX_SIZE) 372941408c28SThomas Huth return -E2BIG; 373041408c28SThomas Huth 373141408c28SThomas Huth if (!(mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY)) { 373241408c28SThomas Huth tmpbuf = vmalloc(mop->size); 373341408c28SThomas Huth if (!tmpbuf) 373441408c28SThomas Huth return -ENOMEM; 373541408c28SThomas Huth } 373641408c28SThomas Huth 373741408c28SThomas Huth srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 373841408c28SThomas Huth 373941408c28SThomas Huth switch (mop->op) { 374041408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_READ: 374141408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 374292c96321SDavid Hildenbrand r = check_gva_range(vcpu, mop->gaddr, mop->ar, 374392c96321SDavid Hildenbrand mop->size, GACC_FETCH); 374441408c28SThomas Huth break; 374541408c28SThomas Huth } 374641408c28SThomas Huth r = read_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 374741408c28SThomas Huth if (r == 0) { 374841408c28SThomas Huth if (copy_to_user(uaddr, tmpbuf, mop->size)) 374941408c28SThomas Huth r = -EFAULT; 375041408c28SThomas Huth } 375141408c28SThomas Huth break; 375241408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_WRITE: 375341408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 375492c96321SDavid Hildenbrand r = check_gva_range(vcpu, mop->gaddr, mop->ar, 375592c96321SDavid Hildenbrand mop->size, GACC_STORE); 375641408c28SThomas Huth break; 375741408c28SThomas Huth } 375841408c28SThomas Huth if (copy_from_user(tmpbuf, uaddr, mop->size)) { 375941408c28SThomas Huth r = -EFAULT; 376041408c28SThomas Huth break; 376141408c28SThomas Huth } 376241408c28SThomas Huth r = write_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 376341408c28SThomas Huth break; 376441408c28SThomas Huth default: 376541408c28SThomas Huth r = -EINVAL; 376641408c28SThomas Huth } 376741408c28SThomas Huth 376841408c28SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, srcu_idx); 376941408c28SThomas Huth 377041408c28SThomas Huth if (r > 0 && (mop->flags & KVM_S390_MEMOP_F_INJECT_EXCEPTION) != 0) 377141408c28SThomas Huth kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm); 377241408c28SThomas Huth 377341408c28SThomas Huth vfree(tmpbuf); 377441408c28SThomas Huth return r; 377541408c28SThomas Huth } 377641408c28SThomas Huth 37775cb0944cSPaolo Bonzini long kvm_arch_vcpu_async_ioctl(struct file *filp, 3778b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 3779b0c632dbSHeiko Carstens { 3780b0c632dbSHeiko Carstens struct kvm_vcpu *vcpu = filp->private_data; 3781b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 3782b0c632dbSHeiko Carstens 378393736624SAvi Kivity switch (ioctl) { 378447b43c52SJens Freimann case KVM_S390_IRQ: { 378547b43c52SJens Freimann struct kvm_s390_irq s390irq; 378647b43c52SJens Freimann 378747b43c52SJens Freimann if (copy_from_user(&s390irq, argp, sizeof(s390irq))) 37889b062471SChristoffer Dall return -EFAULT; 37899b062471SChristoffer Dall return kvm_s390_inject_vcpu(vcpu, &s390irq); 379047b43c52SJens Freimann } 379193736624SAvi Kivity case KVM_S390_INTERRUPT: { 3792ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 3793383d0b05SJens Freimann struct kvm_s390_irq s390irq; 3794ba5c1e9bSCarsten Otte 3795ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 37969b062471SChristoffer Dall return -EFAULT; 3797383d0b05SJens Freimann if (s390int_to_s390irq(&s390int, &s390irq)) 3798383d0b05SJens Freimann return -EINVAL; 37999b062471SChristoffer Dall return kvm_s390_inject_vcpu(vcpu, &s390irq); 3800ba5c1e9bSCarsten Otte } 38019b062471SChristoffer Dall } 38025cb0944cSPaolo Bonzini return -ENOIOCTLCMD; 38035cb0944cSPaolo Bonzini } 38045cb0944cSPaolo Bonzini 38055cb0944cSPaolo Bonzini long kvm_arch_vcpu_ioctl(struct file *filp, 38065cb0944cSPaolo Bonzini unsigned int ioctl, unsigned long arg) 38075cb0944cSPaolo Bonzini { 38085cb0944cSPaolo Bonzini struct kvm_vcpu *vcpu = filp->private_data; 38095cb0944cSPaolo Bonzini void __user *argp = (void __user *)arg; 38105cb0944cSPaolo Bonzini int idx; 38115cb0944cSPaolo Bonzini long r; 38129b062471SChristoffer Dall 38139b062471SChristoffer Dall vcpu_load(vcpu); 38149b062471SChristoffer Dall 38159b062471SChristoffer Dall switch (ioctl) { 3816b0c632dbSHeiko Carstens case KVM_S390_STORE_STATUS: 3817800c1065SThomas Huth idx = srcu_read_lock(&vcpu->kvm->srcu); 3818bc923cc9SAvi Kivity r = kvm_s390_vcpu_store_status(vcpu, arg); 3819800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, idx); 3820bc923cc9SAvi Kivity break; 3821b0c632dbSHeiko Carstens case KVM_S390_SET_INITIAL_PSW: { 3822b0c632dbSHeiko Carstens psw_t psw; 3823b0c632dbSHeiko Carstens 3824bc923cc9SAvi Kivity r = -EFAULT; 3825b0c632dbSHeiko Carstens if (copy_from_user(&psw, argp, sizeof(psw))) 3826bc923cc9SAvi Kivity break; 3827bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw); 3828bc923cc9SAvi Kivity break; 3829b0c632dbSHeiko Carstens } 3830b0c632dbSHeiko Carstens case KVM_S390_INITIAL_RESET: 3831bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_initial_reset(vcpu); 3832bc923cc9SAvi Kivity break; 383314eebd91SCarsten Otte case KVM_SET_ONE_REG: 383414eebd91SCarsten Otte case KVM_GET_ONE_REG: { 383514eebd91SCarsten Otte struct kvm_one_reg reg; 383614eebd91SCarsten Otte r = -EFAULT; 383714eebd91SCarsten Otte if (copy_from_user(®, argp, sizeof(reg))) 383814eebd91SCarsten Otte break; 383914eebd91SCarsten Otte if (ioctl == KVM_SET_ONE_REG) 384014eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, ®); 384114eebd91SCarsten Otte else 384214eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, ®); 384314eebd91SCarsten Otte break; 384414eebd91SCarsten Otte } 384527e0393fSCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 384627e0393fSCarsten Otte case KVM_S390_UCAS_MAP: { 384727e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 384827e0393fSCarsten Otte 384927e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 385027e0393fSCarsten Otte r = -EFAULT; 385127e0393fSCarsten Otte break; 385227e0393fSCarsten Otte } 385327e0393fSCarsten Otte 385427e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 385527e0393fSCarsten Otte r = -EINVAL; 385627e0393fSCarsten Otte break; 385727e0393fSCarsten Otte } 385827e0393fSCarsten Otte 385927e0393fSCarsten Otte r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr, 386027e0393fSCarsten Otte ucasmap.vcpu_addr, ucasmap.length); 386127e0393fSCarsten Otte break; 386227e0393fSCarsten Otte } 386327e0393fSCarsten Otte case KVM_S390_UCAS_UNMAP: { 386427e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 386527e0393fSCarsten Otte 386627e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 386727e0393fSCarsten Otte r = -EFAULT; 386827e0393fSCarsten Otte break; 386927e0393fSCarsten Otte } 387027e0393fSCarsten Otte 387127e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 387227e0393fSCarsten Otte r = -EINVAL; 387327e0393fSCarsten Otte break; 387427e0393fSCarsten Otte } 387527e0393fSCarsten Otte 387627e0393fSCarsten Otte r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr, 387727e0393fSCarsten Otte ucasmap.length); 387827e0393fSCarsten Otte break; 387927e0393fSCarsten Otte } 388027e0393fSCarsten Otte #endif 3881ccc7910fSCarsten Otte case KVM_S390_VCPU_FAULT: { 3882527e30b4SMartin Schwidefsky r = gmap_fault(vcpu->arch.gmap, arg, 0); 3883ccc7910fSCarsten Otte break; 3884ccc7910fSCarsten Otte } 3885d6712df9SCornelia Huck case KVM_ENABLE_CAP: 3886d6712df9SCornelia Huck { 3887d6712df9SCornelia Huck struct kvm_enable_cap cap; 3888d6712df9SCornelia Huck r = -EFAULT; 3889d6712df9SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 3890d6712df9SCornelia Huck break; 3891d6712df9SCornelia Huck r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 3892d6712df9SCornelia Huck break; 3893d6712df9SCornelia Huck } 389441408c28SThomas Huth case KVM_S390_MEM_OP: { 389541408c28SThomas Huth struct kvm_s390_mem_op mem_op; 389641408c28SThomas Huth 389741408c28SThomas Huth if (copy_from_user(&mem_op, argp, sizeof(mem_op)) == 0) 389841408c28SThomas Huth r = kvm_s390_guest_mem_op(vcpu, &mem_op); 389941408c28SThomas Huth else 390041408c28SThomas Huth r = -EFAULT; 390141408c28SThomas Huth break; 390241408c28SThomas Huth } 3903816c7667SJens Freimann case KVM_S390_SET_IRQ_STATE: { 3904816c7667SJens Freimann struct kvm_s390_irq_state irq_state; 3905816c7667SJens Freimann 3906816c7667SJens Freimann r = -EFAULT; 3907816c7667SJens Freimann if (copy_from_user(&irq_state, argp, sizeof(irq_state))) 3908816c7667SJens Freimann break; 3909816c7667SJens Freimann if (irq_state.len > VCPU_IRQS_MAX_BUF || 3910816c7667SJens Freimann irq_state.len == 0 || 3911816c7667SJens Freimann irq_state.len % sizeof(struct kvm_s390_irq) > 0) { 3912816c7667SJens Freimann r = -EINVAL; 3913816c7667SJens Freimann break; 3914816c7667SJens Freimann } 3915bb64da9aSChristian Borntraeger /* do not use irq_state.flags, it will break old QEMUs */ 3916816c7667SJens Freimann r = kvm_s390_set_irq_state(vcpu, 3917816c7667SJens Freimann (void __user *) irq_state.buf, 3918816c7667SJens Freimann irq_state.len); 3919816c7667SJens Freimann break; 3920816c7667SJens Freimann } 3921816c7667SJens Freimann case KVM_S390_GET_IRQ_STATE: { 3922816c7667SJens Freimann struct kvm_s390_irq_state irq_state; 3923816c7667SJens Freimann 3924816c7667SJens Freimann r = -EFAULT; 3925816c7667SJens Freimann if (copy_from_user(&irq_state, argp, sizeof(irq_state))) 3926816c7667SJens Freimann break; 3927816c7667SJens Freimann if (irq_state.len == 0) { 3928816c7667SJens Freimann r = -EINVAL; 3929816c7667SJens Freimann break; 3930816c7667SJens Freimann } 3931bb64da9aSChristian Borntraeger /* do not use irq_state.flags, it will break old QEMUs */ 3932816c7667SJens Freimann r = kvm_s390_get_irq_state(vcpu, 3933816c7667SJens Freimann (__u8 __user *) irq_state.buf, 3934816c7667SJens Freimann irq_state.len); 3935816c7667SJens Freimann break; 3936816c7667SJens Freimann } 3937b0c632dbSHeiko Carstens default: 39383e6afcf1SCarsten Otte r = -ENOTTY; 3939b0c632dbSHeiko Carstens } 39409b062471SChristoffer Dall 39419b062471SChristoffer Dall vcpu_put(vcpu); 3942bc923cc9SAvi Kivity return r; 3943b0c632dbSHeiko Carstens } 3944b0c632dbSHeiko Carstens 39455b1c1493SCarsten Otte int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) 39465b1c1493SCarsten Otte { 39475b1c1493SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 39485b1c1493SCarsten Otte if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET) 39495b1c1493SCarsten Otte && (kvm_is_ucontrol(vcpu->kvm))) { 39505b1c1493SCarsten Otte vmf->page = virt_to_page(vcpu->arch.sie_block); 39515b1c1493SCarsten Otte get_page(vmf->page); 39525b1c1493SCarsten Otte return 0; 39535b1c1493SCarsten Otte } 39545b1c1493SCarsten Otte #endif 39555b1c1493SCarsten Otte return VM_FAULT_SIGBUS; 39565b1c1493SCarsten Otte } 39575b1c1493SCarsten Otte 39585587027cSAneesh Kumar K.V int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, 39595587027cSAneesh Kumar K.V unsigned long npages) 3960db3fe4ebSTakuya Yoshikawa { 3961db3fe4ebSTakuya Yoshikawa return 0; 3962db3fe4ebSTakuya Yoshikawa } 3963db3fe4ebSTakuya Yoshikawa 3964b0c632dbSHeiko Carstens /* Section: memory related */ 3965f7784b8eSMarcelo Tosatti int kvm_arch_prepare_memory_region(struct kvm *kvm, 3966f7784b8eSMarcelo Tosatti struct kvm_memory_slot *memslot, 396709170a49SPaolo Bonzini const struct kvm_userspace_memory_region *mem, 39687b6195a9STakuya Yoshikawa enum kvm_mr_change change) 3969b0c632dbSHeiko Carstens { 3970dd2887e7SNick Wang /* A few sanity checks. We can have memory slots which have to be 3971dd2887e7SNick Wang located/ended at a segment boundary (1MB). The memory in userland is 3972dd2887e7SNick Wang ok to be fragmented into various different vmas. It is okay to mmap() 3973dd2887e7SNick Wang and munmap() stuff in this slot after doing this call at any time */ 3974b0c632dbSHeiko Carstens 3975598841caSCarsten Otte if (mem->userspace_addr & 0xffffful) 3976b0c632dbSHeiko Carstens return -EINVAL; 3977b0c632dbSHeiko Carstens 3978598841caSCarsten Otte if (mem->memory_size & 0xffffful) 3979b0c632dbSHeiko Carstens return -EINVAL; 3980b0c632dbSHeiko Carstens 3981a3a92c31SDominik Dingel if (mem->guest_phys_addr + mem->memory_size > kvm->arch.mem_limit) 3982a3a92c31SDominik Dingel return -EINVAL; 3983a3a92c31SDominik Dingel 3984f7784b8eSMarcelo Tosatti return 0; 3985f7784b8eSMarcelo Tosatti } 3986f7784b8eSMarcelo Tosatti 3987f7784b8eSMarcelo Tosatti void kvm_arch_commit_memory_region(struct kvm *kvm, 398809170a49SPaolo Bonzini const struct kvm_userspace_memory_region *mem, 39898482644aSTakuya Yoshikawa const struct kvm_memory_slot *old, 3990f36f3f28SPaolo Bonzini const struct kvm_memory_slot *new, 39918482644aSTakuya Yoshikawa enum kvm_mr_change change) 3992f7784b8eSMarcelo Tosatti { 3993f7850c92SCarsten Otte int rc; 3994f7784b8eSMarcelo Tosatti 39952cef4debSChristian Borntraeger /* If the basics of the memslot do not change, we do not want 39962cef4debSChristian Borntraeger * to update the gmap. Every update causes several unnecessary 39972cef4debSChristian Borntraeger * segment translation exceptions. This is usually handled just 39982cef4debSChristian Borntraeger * fine by the normal fault handler + gmap, but it will also 39992cef4debSChristian Borntraeger * cause faults on the prefix page of running guest CPUs. 40002cef4debSChristian Borntraeger */ 40012cef4debSChristian Borntraeger if (old->userspace_addr == mem->userspace_addr && 40022cef4debSChristian Borntraeger old->base_gfn * PAGE_SIZE == mem->guest_phys_addr && 40032cef4debSChristian Borntraeger old->npages * PAGE_SIZE == mem->memory_size) 40042cef4debSChristian Borntraeger return; 4005598841caSCarsten Otte 4006598841caSCarsten Otte rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr, 4007598841caSCarsten Otte mem->guest_phys_addr, mem->memory_size); 4008598841caSCarsten Otte if (rc) 4009ea2cdd27SDavid Hildenbrand pr_warn("failed to commit memory region\n"); 4010598841caSCarsten Otte return; 4011b0c632dbSHeiko Carstens } 4012b0c632dbSHeiko Carstens 401360a37709SAlexander Yarygin static inline unsigned long nonhyp_mask(int i) 401460a37709SAlexander Yarygin { 401560a37709SAlexander Yarygin unsigned int nonhyp_fai = (sclp.hmfai << i * 2) >> 30; 401660a37709SAlexander Yarygin 401760a37709SAlexander Yarygin return 0x0000ffffffffffffUL >> (nonhyp_fai << 4); 401860a37709SAlexander Yarygin } 401960a37709SAlexander Yarygin 40203491caf2SChristian Borntraeger void kvm_arch_vcpu_block_finish(struct kvm_vcpu *vcpu) 40213491caf2SChristian Borntraeger { 40223491caf2SChristian Borntraeger vcpu->valid_wakeup = false; 40233491caf2SChristian Borntraeger } 40243491caf2SChristian Borntraeger 4025b0c632dbSHeiko Carstens static int __init kvm_s390_init(void) 4026b0c632dbSHeiko Carstens { 402760a37709SAlexander Yarygin int i; 402860a37709SAlexander Yarygin 402907197fd0SDavid Hildenbrand if (!sclp.has_sief2) { 403007197fd0SDavid Hildenbrand pr_info("SIE not available\n"); 403107197fd0SDavid Hildenbrand return -ENODEV; 403207197fd0SDavid Hildenbrand } 403307197fd0SDavid Hildenbrand 403460a37709SAlexander Yarygin for (i = 0; i < 16; i++) 403560a37709SAlexander Yarygin kvm_s390_fac_list_mask[i] |= 403660a37709SAlexander Yarygin S390_lowcore.stfle_fac_list[i] & nonhyp_mask(i); 403760a37709SAlexander Yarygin 40389d8d5786SMichael Mueller return kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); 4039b0c632dbSHeiko Carstens } 4040b0c632dbSHeiko Carstens 4041b0c632dbSHeiko Carstens static void __exit kvm_s390_exit(void) 4042b0c632dbSHeiko Carstens { 4043b0c632dbSHeiko Carstens kvm_exit(); 4044b0c632dbSHeiko Carstens } 4045b0c632dbSHeiko Carstens 4046b0c632dbSHeiko Carstens module_init(kvm_s390_init); 4047b0c632dbSHeiko Carstens module_exit(kvm_s390_exit); 4048566af940SCornelia Huck 4049566af940SCornelia Huck /* 4050566af940SCornelia Huck * Enable autoloading of the kvm module. 4051566af940SCornelia Huck * Note that we add the module alias here instead of virt/kvm/kvm_main.c 4052566af940SCornelia Huck * since x86 takes a different approach. 4053566af940SCornelia Huck */ 4054566af940SCornelia Huck #include <linux/miscdevice.h> 4055566af940SCornelia Huck MODULE_ALIAS_MISCDEV(KVM_MINOR); 4056566af940SCornelia Huck MODULE_ALIAS("devname:kvm"); 4057