1b0c632dbSHeiko Carstens /* 2a53c8fabSHeiko Carstens * hosting zSeries kernel virtual machines 3b0c632dbSHeiko Carstens * 4628eb9b8SChristian Ehrhardt * Copyright IBM Corp. 2008, 2009 5b0c632dbSHeiko Carstens * 6b0c632dbSHeiko Carstens * This program is free software; you can redistribute it and/or modify 7b0c632dbSHeiko Carstens * it under the terms of the GNU General Public License (version 2 only) 8b0c632dbSHeiko Carstens * as published by the Free Software Foundation. 9b0c632dbSHeiko Carstens * 10b0c632dbSHeiko Carstens * Author(s): Carsten Otte <cotte@de.ibm.com> 11b0c632dbSHeiko Carstens * Christian Borntraeger <borntraeger@de.ibm.com> 12b0c632dbSHeiko Carstens * Heiko Carstens <heiko.carstens@de.ibm.com> 13628eb9b8SChristian Ehrhardt * Christian Ehrhardt <ehrhardt@de.ibm.com> 1415f36ebdSJason J. Herne * Jason J. Herne <jjherne@us.ibm.com> 15b0c632dbSHeiko Carstens */ 16b0c632dbSHeiko Carstens 17b0c632dbSHeiko Carstens #include <linux/compiler.h> 18b0c632dbSHeiko Carstens #include <linux/err.h> 19b0c632dbSHeiko Carstens #include <linux/fs.h> 20ca872302SChristian Borntraeger #include <linux/hrtimer.h> 21b0c632dbSHeiko Carstens #include <linux/init.h> 22b0c632dbSHeiko Carstens #include <linux/kvm.h> 23b0c632dbSHeiko Carstens #include <linux/kvm_host.h> 24b2d73b2aSMartin Schwidefsky #include <linux/mman.h> 25b0c632dbSHeiko Carstens #include <linux/module.h> 26a374e892STony Krowiak #include <linux/random.h> 27b0c632dbSHeiko Carstens #include <linux/slab.h> 28ba5c1e9bSCarsten Otte #include <linux/timer.h> 2941408c28SThomas Huth #include <linux/vmalloc.h> 3015c9705fSDavid Hildenbrand #include <linux/bitmap.h> 31cbb870c8SHeiko Carstens #include <asm/asm-offsets.h> 32b0c632dbSHeiko Carstens #include <asm/lowcore.h> 33fd5ada04SMartin Schwidefsky #include <asm/stp.h> 34b0c632dbSHeiko Carstens #include <asm/pgtable.h> 351e133ab2SMartin Schwidefsky #include <asm/gmap.h> 36f5daba1dSHeiko Carstens #include <asm/nmi.h> 37a0616cdeSDavid Howells #include <asm/switch_to.h> 386d3da241SJens Freimann #include <asm/isc.h> 391526bf9cSChristian Borntraeger #include <asm/sclp.h> 400a763c78SDavid Hildenbrand #include <asm/cpacf.h> 41221bb8a4SLinus Torvalds #include <asm/timex.h> 428f2abe6aSChristian Borntraeger #include "kvm-s390.h" 43b0c632dbSHeiko Carstens #include "gaccess.h" 44b0c632dbSHeiko Carstens 45ea2cdd27SDavid Hildenbrand #define KMSG_COMPONENT "kvm-s390" 46ea2cdd27SDavid Hildenbrand #undef pr_fmt 47ea2cdd27SDavid Hildenbrand #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 48ea2cdd27SDavid Hildenbrand 495786fffaSCornelia Huck #define CREATE_TRACE_POINTS 505786fffaSCornelia Huck #include "trace.h" 51ade38c31SCornelia Huck #include "trace-s390.h" 525786fffaSCornelia Huck 5341408c28SThomas Huth #define MEM_OP_MAX_SIZE 65536 /* Maximum transfer size for KVM_S390_MEM_OP */ 54816c7667SJens Freimann #define LOCAL_IRQS 32 55816c7667SJens Freimann #define VCPU_IRQS_MAX_BUF (sizeof(struct kvm_s390_irq) * \ 56816c7667SJens Freimann (KVM_MAX_VCPUS + LOCAL_IRQS)) 5741408c28SThomas Huth 58b0c632dbSHeiko Carstens #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU 59b0c632dbSHeiko Carstens 60b0c632dbSHeiko Carstens struct kvm_stats_debugfs_item debugfs_entries[] = { 61b0c632dbSHeiko Carstens { "userspace_handled", VCPU_STAT(exit_userspace) }, 620eaeafa1SChristian Borntraeger { "exit_null", VCPU_STAT(exit_null) }, 638f2abe6aSChristian Borntraeger { "exit_validity", VCPU_STAT(exit_validity) }, 648f2abe6aSChristian Borntraeger { "exit_stop_request", VCPU_STAT(exit_stop_request) }, 658f2abe6aSChristian Borntraeger { "exit_external_request", VCPU_STAT(exit_external_request) }, 668f2abe6aSChristian Borntraeger { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) }, 67ba5c1e9bSCarsten Otte { "exit_instruction", VCPU_STAT(exit_instruction) }, 689ec6de19SAlexander Yarygin { "exit_pei", VCPU_STAT(exit_pei) }, 69ba5c1e9bSCarsten Otte { "exit_program_interruption", VCPU_STAT(exit_program_interruption) }, 70ba5c1e9bSCarsten Otte { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) }, 71a011eeb2SJanosch Frank { "exit_operation_exception", VCPU_STAT(exit_operation_exception) }, 72f7819512SPaolo Bonzini { "halt_successful_poll", VCPU_STAT(halt_successful_poll) }, 7362bea5bfSPaolo Bonzini { "halt_attempted_poll", VCPU_STAT(halt_attempted_poll) }, 743491caf2SChristian Borntraeger { "halt_poll_invalid", VCPU_STAT(halt_poll_invalid) }, 75ce2e4f0bSDavid Hildenbrand { "halt_wakeup", VCPU_STAT(halt_wakeup) }, 76f5e10b09SChristian Borntraeger { "instruction_lctlg", VCPU_STAT(instruction_lctlg) }, 77ba5c1e9bSCarsten Otte { "instruction_lctl", VCPU_STAT(instruction_lctl) }, 78aba07508SDavid Hildenbrand { "instruction_stctl", VCPU_STAT(instruction_stctl) }, 79aba07508SDavid Hildenbrand { "instruction_stctg", VCPU_STAT(instruction_stctg) }, 80ba5c1e9bSCarsten Otte { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) }, 817697e71fSChristian Ehrhardt { "deliver_external_call", VCPU_STAT(deliver_external_call) }, 82ba5c1e9bSCarsten Otte { "deliver_service_signal", VCPU_STAT(deliver_service_signal) }, 83ba5c1e9bSCarsten Otte { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) }, 84ba5c1e9bSCarsten Otte { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) }, 85ba5c1e9bSCarsten Otte { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) }, 86ba5c1e9bSCarsten Otte { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) }, 87ba5c1e9bSCarsten Otte { "deliver_program_interruption", VCPU_STAT(deliver_program_int) }, 88ba5c1e9bSCarsten Otte { "exit_wait_state", VCPU_STAT(exit_wait_state) }, 8969d0d3a3SChristian Borntraeger { "instruction_pfmf", VCPU_STAT(instruction_pfmf) }, 90453423dcSChristian Borntraeger { "instruction_stidp", VCPU_STAT(instruction_stidp) }, 91453423dcSChristian Borntraeger { "instruction_spx", VCPU_STAT(instruction_spx) }, 92453423dcSChristian Borntraeger { "instruction_stpx", VCPU_STAT(instruction_stpx) }, 93453423dcSChristian Borntraeger { "instruction_stap", VCPU_STAT(instruction_stap) }, 94453423dcSChristian Borntraeger { "instruction_storage_key", VCPU_STAT(instruction_storage_key) }, 958a242234SHeiko Carstens { "instruction_ipte_interlock", VCPU_STAT(instruction_ipte_interlock) }, 96453423dcSChristian Borntraeger { "instruction_stsch", VCPU_STAT(instruction_stsch) }, 97453423dcSChristian Borntraeger { "instruction_chsc", VCPU_STAT(instruction_chsc) }, 98b31288faSKonstantin Weitz { "instruction_essa", VCPU_STAT(instruction_essa) }, 99453423dcSChristian Borntraeger { "instruction_stsi", VCPU_STAT(instruction_stsi) }, 100453423dcSChristian Borntraeger { "instruction_stfl", VCPU_STAT(instruction_stfl) }, 101bb25b9baSChristian Borntraeger { "instruction_tprot", VCPU_STAT(instruction_tprot) }, 10295ca2cb5SJanosch Frank { "instruction_sthyi", VCPU_STAT(instruction_sthyi) }, 103a3508fbeSDavid Hildenbrand { "instruction_sie", VCPU_STAT(instruction_sie) }, 1045288fbf0SChristian Borntraeger { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) }, 105bd59d3a4SCornelia Huck { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) }, 1067697e71fSChristian Ehrhardt { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) }, 1075288fbf0SChristian Borntraeger { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) }, 10842cb0c9fSDavid Hildenbrand { "instruction_sigp_cond_emergency", VCPU_STAT(instruction_sigp_cond_emergency) }, 10942cb0c9fSDavid Hildenbrand { "instruction_sigp_start", VCPU_STAT(instruction_sigp_start) }, 1105288fbf0SChristian Borntraeger { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) }, 11142cb0c9fSDavid Hildenbrand { "instruction_sigp_stop_store_status", VCPU_STAT(instruction_sigp_stop_store_status) }, 11242cb0c9fSDavid Hildenbrand { "instruction_sigp_store_status", VCPU_STAT(instruction_sigp_store_status) }, 113cd7b4b61SEric Farman { "instruction_sigp_store_adtl_status", VCPU_STAT(instruction_sigp_store_adtl_status) }, 1145288fbf0SChristian Borntraeger { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) }, 1155288fbf0SChristian Borntraeger { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) }, 1165288fbf0SChristian Borntraeger { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) }, 11742cb0c9fSDavid Hildenbrand { "instruction_sigp_cpu_reset", VCPU_STAT(instruction_sigp_cpu_reset) }, 11842cb0c9fSDavid Hildenbrand { "instruction_sigp_init_cpu_reset", VCPU_STAT(instruction_sigp_init_cpu_reset) }, 11942cb0c9fSDavid Hildenbrand { "instruction_sigp_unknown", VCPU_STAT(instruction_sigp_unknown) }, 120388186bcSChristian Borntraeger { "diagnose_10", VCPU_STAT(diagnose_10) }, 121e28acfeaSChristian Borntraeger { "diagnose_44", VCPU_STAT(diagnose_44) }, 12241628d33SKonstantin Weitz { "diagnose_9c", VCPU_STAT(diagnose_9c) }, 123175a5c9eSChristian Borntraeger { "diagnose_258", VCPU_STAT(diagnose_258) }, 124175a5c9eSChristian Borntraeger { "diagnose_308", VCPU_STAT(diagnose_308) }, 125175a5c9eSChristian Borntraeger { "diagnose_500", VCPU_STAT(diagnose_500) }, 126b0c632dbSHeiko Carstens { NULL } 127b0c632dbSHeiko Carstens }; 128b0c632dbSHeiko Carstens 129a411edf1SDavid Hildenbrand /* allow nested virtualization in KVM (if enabled by user space) */ 130a411edf1SDavid Hildenbrand static int nested; 131a411edf1SDavid Hildenbrand module_param(nested, int, S_IRUGO); 132a411edf1SDavid Hildenbrand MODULE_PARM_DESC(nested, "Nested virtualization support"); 133a411edf1SDavid Hildenbrand 1349d8d5786SMichael Mueller /* upper facilities limit for kvm */ 135f6c1d359SHeiko Carstens unsigned long kvm_s390_fac_list_mask[16] = { FACILITIES_KVM }; 136b0c632dbSHeiko Carstens 1379d8d5786SMichael Mueller unsigned long kvm_s390_fac_list_mask_size(void) 13878c4b59fSMichael Mueller { 1399d8d5786SMichael Mueller BUILD_BUG_ON(ARRAY_SIZE(kvm_s390_fac_list_mask) > S390_ARCH_FAC_MASK_SIZE_U64); 1409d8d5786SMichael Mueller return ARRAY_SIZE(kvm_s390_fac_list_mask); 14178c4b59fSMichael Mueller } 14278c4b59fSMichael Mueller 14315c9705fSDavid Hildenbrand /* available cpu features supported by kvm */ 14415c9705fSDavid Hildenbrand static DECLARE_BITMAP(kvm_s390_available_cpu_feat, KVM_S390_VM_CPU_FEAT_NR_BITS); 1450a763c78SDavid Hildenbrand /* available subfunctions indicated via query / "test bit" */ 1460a763c78SDavid Hildenbrand static struct kvm_s390_vm_cpu_subfunc kvm_s390_available_subfunc; 14715c9705fSDavid Hildenbrand 1489d8d5786SMichael Mueller static struct gmap_notifier gmap_notifier; 149a3508fbeSDavid Hildenbrand static struct gmap_notifier vsie_gmap_notifier; 15078f26131SChristian Borntraeger debug_info_t *kvm_s390_dbf; 1519d8d5786SMichael Mueller 152b0c632dbSHeiko Carstens /* Section: not file related */ 15313a34e06SRadim Krčmář int kvm_arch_hardware_enable(void) 154b0c632dbSHeiko Carstens { 155b0c632dbSHeiko Carstens /* every s390 is virtualization enabled ;-) */ 15610474ae8SAlexander Graf return 0; 157b0c632dbSHeiko Carstens } 158b0c632dbSHeiko Carstens 159414d3b07SMartin Schwidefsky static void kvm_gmap_notifier(struct gmap *gmap, unsigned long start, 160414d3b07SMartin Schwidefsky unsigned long end); 1612c70fe44SChristian Borntraeger 162fdf03650SFan Zhang /* 163fdf03650SFan Zhang * This callback is executed during stop_machine(). All CPUs are therefore 164fdf03650SFan Zhang * temporarily stopped. In order not to change guest behavior, we have to 165fdf03650SFan Zhang * disable preemption whenever we touch the epoch of kvm and the VCPUs, 166fdf03650SFan Zhang * so a CPU won't be stopped while calculating with the epoch. 167fdf03650SFan Zhang */ 168fdf03650SFan Zhang static int kvm_clock_sync(struct notifier_block *notifier, unsigned long val, 169fdf03650SFan Zhang void *v) 170fdf03650SFan Zhang { 171fdf03650SFan Zhang struct kvm *kvm; 172fdf03650SFan Zhang struct kvm_vcpu *vcpu; 173fdf03650SFan Zhang int i; 174fdf03650SFan Zhang unsigned long long *delta = v; 175fdf03650SFan Zhang 176fdf03650SFan Zhang list_for_each_entry(kvm, &vm_list, vm_list) { 177fdf03650SFan Zhang kvm->arch.epoch -= *delta; 178fdf03650SFan Zhang kvm_for_each_vcpu(i, vcpu, kvm) { 179fdf03650SFan Zhang vcpu->arch.sie_block->epoch -= *delta; 180db0758b2SDavid Hildenbrand if (vcpu->arch.cputm_enabled) 181db0758b2SDavid Hildenbrand vcpu->arch.cputm_start += *delta; 18291473b48SDavid Hildenbrand if (vcpu->arch.vsie_block) 18391473b48SDavid Hildenbrand vcpu->arch.vsie_block->epoch -= *delta; 184fdf03650SFan Zhang } 185fdf03650SFan Zhang } 186fdf03650SFan Zhang return NOTIFY_OK; 187fdf03650SFan Zhang } 188fdf03650SFan Zhang 189fdf03650SFan Zhang static struct notifier_block kvm_clock_notifier = { 190fdf03650SFan Zhang .notifier_call = kvm_clock_sync, 191fdf03650SFan Zhang }; 192fdf03650SFan Zhang 193b0c632dbSHeiko Carstens int kvm_arch_hardware_setup(void) 194b0c632dbSHeiko Carstens { 1952c70fe44SChristian Borntraeger gmap_notifier.notifier_call = kvm_gmap_notifier; 196b2d73b2aSMartin Schwidefsky gmap_register_pte_notifier(&gmap_notifier); 197a3508fbeSDavid Hildenbrand vsie_gmap_notifier.notifier_call = kvm_s390_vsie_gmap_notifier; 198a3508fbeSDavid Hildenbrand gmap_register_pte_notifier(&vsie_gmap_notifier); 199fdf03650SFan Zhang atomic_notifier_chain_register(&s390_epoch_delta_notifier, 200fdf03650SFan Zhang &kvm_clock_notifier); 201b0c632dbSHeiko Carstens return 0; 202b0c632dbSHeiko Carstens } 203b0c632dbSHeiko Carstens 204b0c632dbSHeiko Carstens void kvm_arch_hardware_unsetup(void) 205b0c632dbSHeiko Carstens { 206b2d73b2aSMartin Schwidefsky gmap_unregister_pte_notifier(&gmap_notifier); 207a3508fbeSDavid Hildenbrand gmap_unregister_pte_notifier(&vsie_gmap_notifier); 208fdf03650SFan Zhang atomic_notifier_chain_unregister(&s390_epoch_delta_notifier, 209fdf03650SFan Zhang &kvm_clock_notifier); 210b0c632dbSHeiko Carstens } 211b0c632dbSHeiko Carstens 21222be5a13SDavid Hildenbrand static void allow_cpu_feat(unsigned long nr) 21322be5a13SDavid Hildenbrand { 21422be5a13SDavid Hildenbrand set_bit_inv(nr, kvm_s390_available_cpu_feat); 21522be5a13SDavid Hildenbrand } 21622be5a13SDavid Hildenbrand 2170a763c78SDavid Hildenbrand static inline int plo_test_bit(unsigned char nr) 2180a763c78SDavid Hildenbrand { 2190a763c78SDavid Hildenbrand register unsigned long r0 asm("0") = (unsigned long) nr | 0x100; 220d051ae53SHeiko Carstens int cc; 2210a763c78SDavid Hildenbrand 2220a763c78SDavid Hildenbrand asm volatile( 2230a763c78SDavid Hildenbrand /* Parameter registers are ignored for "test bit" */ 2240a763c78SDavid Hildenbrand " plo 0,0,0,0(0)\n" 2250a763c78SDavid Hildenbrand " ipm %0\n" 2260a763c78SDavid Hildenbrand " srl %0,28\n" 2270a763c78SDavid Hildenbrand : "=d" (cc) 2280a763c78SDavid Hildenbrand : "d" (r0) 2290a763c78SDavid Hildenbrand : "cc"); 2300a763c78SDavid Hildenbrand return cc == 0; 2310a763c78SDavid Hildenbrand } 2320a763c78SDavid Hildenbrand 23322be5a13SDavid Hildenbrand static void kvm_s390_cpu_feat_init(void) 23422be5a13SDavid Hildenbrand { 2350a763c78SDavid Hildenbrand int i; 2360a763c78SDavid Hildenbrand 2370a763c78SDavid Hildenbrand for (i = 0; i < 256; ++i) { 2380a763c78SDavid Hildenbrand if (plo_test_bit(i)) 2390a763c78SDavid Hildenbrand kvm_s390_available_subfunc.plo[i >> 3] |= 0x80 >> (i & 7); 2400a763c78SDavid Hildenbrand } 2410a763c78SDavid Hildenbrand 2420a763c78SDavid Hildenbrand if (test_facility(28)) /* TOD-clock steering */ 243221bb8a4SLinus Torvalds ptff(kvm_s390_available_subfunc.ptff, 244221bb8a4SLinus Torvalds sizeof(kvm_s390_available_subfunc.ptff), 245221bb8a4SLinus Torvalds PTFF_QAF); 2460a763c78SDavid Hildenbrand 2470a763c78SDavid Hildenbrand if (test_facility(17)) { /* MSA */ 24869c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMAC, (cpacf_mask_t *) 24969c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmac); 25069c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMC, (cpacf_mask_t *) 25169c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmc); 25269c0e360SMartin Schwidefsky __cpacf_query(CPACF_KM, (cpacf_mask_t *) 25369c0e360SMartin Schwidefsky kvm_s390_available_subfunc.km); 25469c0e360SMartin Schwidefsky __cpacf_query(CPACF_KIMD, (cpacf_mask_t *) 25569c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kimd); 25669c0e360SMartin Schwidefsky __cpacf_query(CPACF_KLMD, (cpacf_mask_t *) 25769c0e360SMartin Schwidefsky kvm_s390_available_subfunc.klmd); 2580a763c78SDavid Hildenbrand } 2590a763c78SDavid Hildenbrand if (test_facility(76)) /* MSA3 */ 26069c0e360SMartin Schwidefsky __cpacf_query(CPACF_PCKMO, (cpacf_mask_t *) 26169c0e360SMartin Schwidefsky kvm_s390_available_subfunc.pckmo); 2620a763c78SDavid Hildenbrand if (test_facility(77)) { /* MSA4 */ 26369c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMCTR, (cpacf_mask_t *) 26469c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmctr); 26569c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMF, (cpacf_mask_t *) 26669c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmf); 26769c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMO, (cpacf_mask_t *) 26869c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmo); 26969c0e360SMartin Schwidefsky __cpacf_query(CPACF_PCC, (cpacf_mask_t *) 27069c0e360SMartin Schwidefsky kvm_s390_available_subfunc.pcc); 2710a763c78SDavid Hildenbrand } 2720a763c78SDavid Hildenbrand if (test_facility(57)) /* MSA5 */ 27369c0e360SMartin Schwidefsky __cpacf_query(CPACF_PPNO, (cpacf_mask_t *) 27469c0e360SMartin Schwidefsky kvm_s390_available_subfunc.ppno); 2750a763c78SDavid Hildenbrand 27622be5a13SDavid Hildenbrand if (MACHINE_HAS_ESOP) 27722be5a13SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_ESOP); 278a3508fbeSDavid Hildenbrand /* 279a3508fbeSDavid Hildenbrand * We need SIE support, ESOP (PROT_READ protection for gmap_shadow), 280a3508fbeSDavid Hildenbrand * 64bit SCAO (SCA passthrough) and IDTE (for gmap_shadow unshadowing). 281a3508fbeSDavid Hildenbrand */ 282a3508fbeSDavid Hildenbrand if (!sclp.has_sief2 || !MACHINE_HAS_ESOP || !sclp.has_64bscao || 283a411edf1SDavid Hildenbrand !test_facility(3) || !nested) 284a3508fbeSDavid Hildenbrand return; 285a3508fbeSDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_SIEF2); 28619c439b5SDavid Hildenbrand if (sclp.has_64bscao) 28719c439b5SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_64BSCAO); 2880615a326SDavid Hildenbrand if (sclp.has_siif) 2890615a326SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_SIIF); 29077d18f6dSDavid Hildenbrand if (sclp.has_gpere) 29177d18f6dSDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_GPERE); 292a1b7b9b2SDavid Hildenbrand if (sclp.has_gsls) 293a1b7b9b2SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_GSLS); 2945630a8e8SDavid Hildenbrand if (sclp.has_ib) 2955630a8e8SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_IB); 29613ee3f67SDavid Hildenbrand if (sclp.has_cei) 29713ee3f67SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_CEI); 2987fd7f39dSDavid Hildenbrand if (sclp.has_ibs) 2997fd7f39dSDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_IBS); 3005d3876a8SDavid Hildenbrand /* 3015d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_SKEY: Wrong shadow of PTE.I bits will make 3025d3876a8SDavid Hildenbrand * all skey handling functions read/set the skey from the PGSTE 3035d3876a8SDavid Hildenbrand * instead of the real storage key. 3045d3876a8SDavid Hildenbrand * 3055d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_CMMA: Wrong shadow of PTE.I bits will make 3065d3876a8SDavid Hildenbrand * pages being detected as preserved although they are resident. 3075d3876a8SDavid Hildenbrand * 3085d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_PFMFI: Wrong shadow of PTE.I bits will 3095d3876a8SDavid Hildenbrand * have the same effect as for KVM_S390_VM_CPU_FEAT_SKEY. 3105d3876a8SDavid Hildenbrand * 3115d3876a8SDavid Hildenbrand * For KVM_S390_VM_CPU_FEAT_SKEY, KVM_S390_VM_CPU_FEAT_CMMA and 3125d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_PFMFI, all PTE.I and PGSTE bits have to be 3135d3876a8SDavid Hildenbrand * correctly shadowed. We can do that for the PGSTE but not for PTE.I. 3145d3876a8SDavid Hildenbrand * 3155d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_SIGPIF: Wrong SCB addresses in the SCA. We 3165d3876a8SDavid Hildenbrand * cannot easily shadow the SCA because of the ipte lock. 3175d3876a8SDavid Hildenbrand */ 31822be5a13SDavid Hildenbrand } 31922be5a13SDavid Hildenbrand 320b0c632dbSHeiko Carstens int kvm_arch_init(void *opaque) 321b0c632dbSHeiko Carstens { 32278f26131SChristian Borntraeger kvm_s390_dbf = debug_register("kvm-trace", 32, 1, 7 * sizeof(long)); 32378f26131SChristian Borntraeger if (!kvm_s390_dbf) 32478f26131SChristian Borntraeger return -ENOMEM; 32578f26131SChristian Borntraeger 32678f26131SChristian Borntraeger if (debug_register_view(kvm_s390_dbf, &debug_sprintf_view)) { 32778f26131SChristian Borntraeger debug_unregister(kvm_s390_dbf); 32878f26131SChristian Borntraeger return -ENOMEM; 32978f26131SChristian Borntraeger } 33078f26131SChristian Borntraeger 33122be5a13SDavid Hildenbrand kvm_s390_cpu_feat_init(); 33222be5a13SDavid Hildenbrand 33384877d93SCornelia Huck /* Register floating interrupt controller interface. */ 33484877d93SCornelia Huck return kvm_register_device_ops(&kvm_flic_ops, KVM_DEV_TYPE_FLIC); 335b0c632dbSHeiko Carstens } 336b0c632dbSHeiko Carstens 33778f26131SChristian Borntraeger void kvm_arch_exit(void) 33878f26131SChristian Borntraeger { 33978f26131SChristian Borntraeger debug_unregister(kvm_s390_dbf); 34078f26131SChristian Borntraeger } 34178f26131SChristian Borntraeger 342b0c632dbSHeiko Carstens /* Section: device related */ 343b0c632dbSHeiko Carstens long kvm_arch_dev_ioctl(struct file *filp, 344b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 345b0c632dbSHeiko Carstens { 346b0c632dbSHeiko Carstens if (ioctl == KVM_S390_ENABLE_SIE) 347b0c632dbSHeiko Carstens return s390_enable_sie(); 348b0c632dbSHeiko Carstens return -EINVAL; 349b0c632dbSHeiko Carstens } 350b0c632dbSHeiko Carstens 351784aa3d7SAlexander Graf int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) 352b0c632dbSHeiko Carstens { 353d7b0b5ebSCarsten Otte int r; 354d7b0b5ebSCarsten Otte 3552bd0ac4eSCarsten Otte switch (ext) { 356d7b0b5ebSCarsten Otte case KVM_CAP_S390_PSW: 357b6cf8788SChristian Borntraeger case KVM_CAP_S390_GMAP: 35852e16b18SChristian Borntraeger case KVM_CAP_SYNC_MMU: 3591efd0f59SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 3601efd0f59SCarsten Otte case KVM_CAP_S390_UCONTROL: 3611efd0f59SCarsten Otte #endif 3623c038e6bSDominik Dingel case KVM_CAP_ASYNC_PF: 36360b413c9SChristian Borntraeger case KVM_CAP_SYNC_REGS: 36414eebd91SCarsten Otte case KVM_CAP_ONE_REG: 365d6712df9SCornelia Huck case KVM_CAP_ENABLE_CAP: 366fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 36710ccaa1eSCornelia Huck case KVM_CAP_IOEVENTFD: 368c05c4186SJens Freimann case KVM_CAP_DEVICE_CTRL: 369d938dc55SCornelia Huck case KVM_CAP_ENABLE_CAP_VM: 37078599d90SCornelia Huck case KVM_CAP_S390_IRQCHIP: 371f2061656SDominik Dingel case KVM_CAP_VM_ATTRIBUTES: 3726352e4d2SDavid Hildenbrand case KVM_CAP_MP_STATE: 373*460df4c1SPaolo Bonzini case KVM_CAP_IMMEDIATE_EXIT: 37447b43c52SJens Freimann case KVM_CAP_S390_INJECT_IRQ: 3752444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 376e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 37730ee2a98SJason J. Herne case KVM_CAP_S390_SKEYS: 378816c7667SJens Freimann case KVM_CAP_S390_IRQ_STATE: 3796502a34cSDavid Hildenbrand case KVM_CAP_S390_USER_INSTR0: 380d7b0b5ebSCarsten Otte r = 1; 381d7b0b5ebSCarsten Otte break; 38241408c28SThomas Huth case KVM_CAP_S390_MEM_OP: 38341408c28SThomas Huth r = MEM_OP_MAX_SIZE; 38441408c28SThomas Huth break; 385e726b1bdSChristian Borntraeger case KVM_CAP_NR_VCPUS: 386e726b1bdSChristian Borntraeger case KVM_CAP_MAX_VCPUS: 38776a6dd72SDavid Hildenbrand r = KVM_S390_BSCA_CPU_SLOTS; 388a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) 389a6940674SDavid Hildenbrand r = KVM_MAX_VCPUS; 390a6940674SDavid Hildenbrand else if (sclp.has_esca && sclp.has_64bscao) 39176a6dd72SDavid Hildenbrand r = KVM_S390_ESCA_CPU_SLOTS; 392e726b1bdSChristian Borntraeger break; 393e1e2e605SNick Wang case KVM_CAP_NR_MEMSLOTS: 394e1e2e605SNick Wang r = KVM_USER_MEM_SLOTS; 395e1e2e605SNick Wang break; 3961526bf9cSChristian Borntraeger case KVM_CAP_S390_COW: 397abf09bedSMartin Schwidefsky r = MACHINE_HAS_ESOP; 3981526bf9cSChristian Borntraeger break; 39968c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 40068c55750SEric Farman r = MACHINE_HAS_VX; 40168c55750SEric Farman break; 402c6e5f166SFan Zhang case KVM_CAP_S390_RI: 403c6e5f166SFan Zhang r = test_facility(64); 404c6e5f166SFan Zhang break; 4052bd0ac4eSCarsten Otte default: 406d7b0b5ebSCarsten Otte r = 0; 407b0c632dbSHeiko Carstens } 408d7b0b5ebSCarsten Otte return r; 4092bd0ac4eSCarsten Otte } 410b0c632dbSHeiko Carstens 41115f36ebdSJason J. Herne static void kvm_s390_sync_dirty_log(struct kvm *kvm, 41215f36ebdSJason J. Herne struct kvm_memory_slot *memslot) 41315f36ebdSJason J. Herne { 41415f36ebdSJason J. Herne gfn_t cur_gfn, last_gfn; 41515f36ebdSJason J. Herne unsigned long address; 41615f36ebdSJason J. Herne struct gmap *gmap = kvm->arch.gmap; 41715f36ebdSJason J. Herne 41815f36ebdSJason J. Herne /* Loop over all guest pages */ 41915f36ebdSJason J. Herne last_gfn = memslot->base_gfn + memslot->npages; 42015f36ebdSJason J. Herne for (cur_gfn = memslot->base_gfn; cur_gfn <= last_gfn; cur_gfn++) { 42115f36ebdSJason J. Herne address = gfn_to_hva_memslot(memslot, cur_gfn); 42215f36ebdSJason J. Herne 4231e133ab2SMartin Schwidefsky if (test_and_clear_guest_dirty(gmap->mm, address)) 42415f36ebdSJason J. Herne mark_page_dirty(kvm, cur_gfn); 4251763f8d0SChristian Borntraeger if (fatal_signal_pending(current)) 4261763f8d0SChristian Borntraeger return; 42770c88a00SChristian Borntraeger cond_resched(); 42815f36ebdSJason J. Herne } 42915f36ebdSJason J. Herne } 43015f36ebdSJason J. Herne 431b0c632dbSHeiko Carstens /* Section: vm related */ 432a6e2f683SEugene (jno) Dvurechenski static void sca_del_vcpu(struct kvm_vcpu *vcpu); 433a6e2f683SEugene (jno) Dvurechenski 434b0c632dbSHeiko Carstens /* 435b0c632dbSHeiko Carstens * Get (and clear) the dirty memory log for a memory slot. 436b0c632dbSHeiko Carstens */ 437b0c632dbSHeiko Carstens int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, 438b0c632dbSHeiko Carstens struct kvm_dirty_log *log) 439b0c632dbSHeiko Carstens { 44015f36ebdSJason J. Herne int r; 44115f36ebdSJason J. Herne unsigned long n; 4429f6b8029SPaolo Bonzini struct kvm_memslots *slots; 44315f36ebdSJason J. Herne struct kvm_memory_slot *memslot; 44415f36ebdSJason J. Herne int is_dirty = 0; 44515f36ebdSJason J. Herne 446e1e8a962SJanosch Frank if (kvm_is_ucontrol(kvm)) 447e1e8a962SJanosch Frank return -EINVAL; 448e1e8a962SJanosch Frank 44915f36ebdSJason J. Herne mutex_lock(&kvm->slots_lock); 45015f36ebdSJason J. Herne 45115f36ebdSJason J. Herne r = -EINVAL; 45215f36ebdSJason J. Herne if (log->slot >= KVM_USER_MEM_SLOTS) 45315f36ebdSJason J. Herne goto out; 45415f36ebdSJason J. Herne 4559f6b8029SPaolo Bonzini slots = kvm_memslots(kvm); 4569f6b8029SPaolo Bonzini memslot = id_to_memslot(slots, log->slot); 45715f36ebdSJason J. Herne r = -ENOENT; 45815f36ebdSJason J. Herne if (!memslot->dirty_bitmap) 45915f36ebdSJason J. Herne goto out; 46015f36ebdSJason J. Herne 46115f36ebdSJason J. Herne kvm_s390_sync_dirty_log(kvm, memslot); 46215f36ebdSJason J. Herne r = kvm_get_dirty_log(kvm, log, &is_dirty); 46315f36ebdSJason J. Herne if (r) 46415f36ebdSJason J. Herne goto out; 46515f36ebdSJason J. Herne 46615f36ebdSJason J. Herne /* Clear the dirty log */ 46715f36ebdSJason J. Herne if (is_dirty) { 46815f36ebdSJason J. Herne n = kvm_dirty_bitmap_bytes(memslot); 46915f36ebdSJason J. Herne memset(memslot->dirty_bitmap, 0, n); 47015f36ebdSJason J. Herne } 47115f36ebdSJason J. Herne r = 0; 47215f36ebdSJason J. Herne out: 47315f36ebdSJason J. Herne mutex_unlock(&kvm->slots_lock); 47415f36ebdSJason J. Herne return r; 475b0c632dbSHeiko Carstens } 476b0c632dbSHeiko Carstens 4776502a34cSDavid Hildenbrand static void icpt_operexc_on_all_vcpus(struct kvm *kvm) 4786502a34cSDavid Hildenbrand { 4796502a34cSDavid Hildenbrand unsigned int i; 4806502a34cSDavid Hildenbrand struct kvm_vcpu *vcpu; 4816502a34cSDavid Hildenbrand 4826502a34cSDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 4836502a34cSDavid Hildenbrand kvm_s390_sync_request(KVM_REQ_ICPT_OPEREXC, vcpu); 4846502a34cSDavid Hildenbrand } 4856502a34cSDavid Hildenbrand } 4866502a34cSDavid Hildenbrand 487d938dc55SCornelia Huck static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap) 488d938dc55SCornelia Huck { 489d938dc55SCornelia Huck int r; 490d938dc55SCornelia Huck 491d938dc55SCornelia Huck if (cap->flags) 492d938dc55SCornelia Huck return -EINVAL; 493d938dc55SCornelia Huck 494d938dc55SCornelia Huck switch (cap->cap) { 49584223598SCornelia Huck case KVM_CAP_S390_IRQCHIP: 496c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_IRQCHIP"); 49784223598SCornelia Huck kvm->arch.use_irqchip = 1; 49884223598SCornelia Huck r = 0; 49984223598SCornelia Huck break; 5002444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 501c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_SIGP"); 5022444b352SDavid Hildenbrand kvm->arch.user_sigp = 1; 5032444b352SDavid Hildenbrand r = 0; 5042444b352SDavid Hildenbrand break; 50568c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 5065967c17bSDavid Hildenbrand mutex_lock(&kvm->lock); 507a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 5085967c17bSDavid Hildenbrand r = -EBUSY; 5095967c17bSDavid Hildenbrand } else if (MACHINE_HAS_VX) { 510c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 129); 511c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 129); 5122f87d942SGuenther Hutzl if (test_facility(134)) { 5132f87d942SGuenther Hutzl set_kvm_facility(kvm->arch.model.fac_mask, 134); 5142f87d942SGuenther Hutzl set_kvm_facility(kvm->arch.model.fac_list, 134); 5152f87d942SGuenther Hutzl } 51653743aa7SMaxim Samoylov if (test_facility(135)) { 51753743aa7SMaxim Samoylov set_kvm_facility(kvm->arch.model.fac_mask, 135); 51853743aa7SMaxim Samoylov set_kvm_facility(kvm->arch.model.fac_list, 135); 51953743aa7SMaxim Samoylov } 52018280d8bSMichael Mueller r = 0; 52118280d8bSMichael Mueller } else 52218280d8bSMichael Mueller r = -EINVAL; 5235967c17bSDavid Hildenbrand mutex_unlock(&kvm->lock); 524c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "ENABLE: CAP_S390_VECTOR_REGISTERS %s", 525c92ea7b9SChristian Borntraeger r ? "(not available)" : "(success)"); 52668c55750SEric Farman break; 527c6e5f166SFan Zhang case KVM_CAP_S390_RI: 528c6e5f166SFan Zhang r = -EINVAL; 529c6e5f166SFan Zhang mutex_lock(&kvm->lock); 530a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 531c6e5f166SFan Zhang r = -EBUSY; 532c6e5f166SFan Zhang } else if (test_facility(64)) { 533c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 64); 534c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 64); 535c6e5f166SFan Zhang r = 0; 536c6e5f166SFan Zhang } 537c6e5f166SFan Zhang mutex_unlock(&kvm->lock); 538c6e5f166SFan Zhang VM_EVENT(kvm, 3, "ENABLE: CAP_S390_RI %s", 539c6e5f166SFan Zhang r ? "(not available)" : "(success)"); 540c6e5f166SFan Zhang break; 541e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 542c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_STSI"); 543e44fc8c9SEkaterina Tumanova kvm->arch.user_stsi = 1; 544e44fc8c9SEkaterina Tumanova r = 0; 545e44fc8c9SEkaterina Tumanova break; 5466502a34cSDavid Hildenbrand case KVM_CAP_S390_USER_INSTR0: 5476502a34cSDavid Hildenbrand VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_INSTR0"); 5486502a34cSDavid Hildenbrand kvm->arch.user_instr0 = 1; 5496502a34cSDavid Hildenbrand icpt_operexc_on_all_vcpus(kvm); 5506502a34cSDavid Hildenbrand r = 0; 5516502a34cSDavid Hildenbrand break; 552d938dc55SCornelia Huck default: 553d938dc55SCornelia Huck r = -EINVAL; 554d938dc55SCornelia Huck break; 555d938dc55SCornelia Huck } 556d938dc55SCornelia Huck return r; 557d938dc55SCornelia Huck } 558d938dc55SCornelia Huck 5598c0a7ce6SDominik Dingel static int kvm_s390_get_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 5608c0a7ce6SDominik Dingel { 5618c0a7ce6SDominik Dingel int ret; 5628c0a7ce6SDominik Dingel 5638c0a7ce6SDominik Dingel switch (attr->attr) { 5648c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 5658c0a7ce6SDominik Dingel ret = 0; 566c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: max guest memory: %lu bytes", 567a3a92c31SDominik Dingel kvm->arch.mem_limit); 568a3a92c31SDominik Dingel if (put_user(kvm->arch.mem_limit, (u64 __user *)attr->addr)) 5698c0a7ce6SDominik Dingel ret = -EFAULT; 5708c0a7ce6SDominik Dingel break; 5718c0a7ce6SDominik Dingel default: 5728c0a7ce6SDominik Dingel ret = -ENXIO; 5738c0a7ce6SDominik Dingel break; 5748c0a7ce6SDominik Dingel } 5758c0a7ce6SDominik Dingel return ret; 5768c0a7ce6SDominik Dingel } 5778c0a7ce6SDominik Dingel 5788c0a7ce6SDominik Dingel static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 5794f718eabSDominik Dingel { 5804f718eabSDominik Dingel int ret; 5814f718eabSDominik Dingel unsigned int idx; 5824f718eabSDominik Dingel switch (attr->attr) { 5834f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 584f9cbd9b0SDavid Hildenbrand ret = -ENXIO; 585c24cc9c8SDavid Hildenbrand if (!sclp.has_cmma) 586e6db1d61SDominik Dingel break; 587e6db1d61SDominik Dingel 5884f718eabSDominik Dingel ret = -EBUSY; 589c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CMMA support"); 5904f718eabSDominik Dingel mutex_lock(&kvm->lock); 591a03825bbSPaolo Bonzini if (!kvm->created_vcpus) { 5924f718eabSDominik Dingel kvm->arch.use_cmma = 1; 5934f718eabSDominik Dingel ret = 0; 5944f718eabSDominik Dingel } 5954f718eabSDominik Dingel mutex_unlock(&kvm->lock); 5964f718eabSDominik Dingel break; 5974f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 598f9cbd9b0SDavid Hildenbrand ret = -ENXIO; 599f9cbd9b0SDavid Hildenbrand if (!sclp.has_cmma) 600f9cbd9b0SDavid Hildenbrand break; 601c3489155SDominik Dingel ret = -EINVAL; 602c3489155SDominik Dingel if (!kvm->arch.use_cmma) 603c3489155SDominik Dingel break; 604c3489155SDominik Dingel 605c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "RESET: CMMA states"); 6064f718eabSDominik Dingel mutex_lock(&kvm->lock); 6074f718eabSDominik Dingel idx = srcu_read_lock(&kvm->srcu); 608a13cff31SDominik Dingel s390_reset_cmma(kvm->arch.gmap->mm); 6094f718eabSDominik Dingel srcu_read_unlock(&kvm->srcu, idx); 6104f718eabSDominik Dingel mutex_unlock(&kvm->lock); 6114f718eabSDominik Dingel ret = 0; 6124f718eabSDominik Dingel break; 6138c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: { 6148c0a7ce6SDominik Dingel unsigned long new_limit; 6158c0a7ce6SDominik Dingel 6168c0a7ce6SDominik Dingel if (kvm_is_ucontrol(kvm)) 6178c0a7ce6SDominik Dingel return -EINVAL; 6188c0a7ce6SDominik Dingel 6198c0a7ce6SDominik Dingel if (get_user(new_limit, (u64 __user *)attr->addr)) 6208c0a7ce6SDominik Dingel return -EFAULT; 6218c0a7ce6SDominik Dingel 622a3a92c31SDominik Dingel if (kvm->arch.mem_limit != KVM_S390_NO_MEM_LIMIT && 623a3a92c31SDominik Dingel new_limit > kvm->arch.mem_limit) 6248c0a7ce6SDominik Dingel return -E2BIG; 6258c0a7ce6SDominik Dingel 626a3a92c31SDominik Dingel if (!new_limit) 627a3a92c31SDominik Dingel return -EINVAL; 628a3a92c31SDominik Dingel 6296ea427bbSMartin Schwidefsky /* gmap_create takes last usable address */ 630a3a92c31SDominik Dingel if (new_limit != KVM_S390_NO_MEM_LIMIT) 631a3a92c31SDominik Dingel new_limit -= 1; 632a3a92c31SDominik Dingel 6338c0a7ce6SDominik Dingel ret = -EBUSY; 6348c0a7ce6SDominik Dingel mutex_lock(&kvm->lock); 635a03825bbSPaolo Bonzini if (!kvm->created_vcpus) { 6366ea427bbSMartin Schwidefsky /* gmap_create will round the limit up */ 6376ea427bbSMartin Schwidefsky struct gmap *new = gmap_create(current->mm, new_limit); 6388c0a7ce6SDominik Dingel 6398c0a7ce6SDominik Dingel if (!new) { 6408c0a7ce6SDominik Dingel ret = -ENOMEM; 6418c0a7ce6SDominik Dingel } else { 6426ea427bbSMartin Schwidefsky gmap_remove(kvm->arch.gmap); 6438c0a7ce6SDominik Dingel new->private = kvm; 6448c0a7ce6SDominik Dingel kvm->arch.gmap = new; 6458c0a7ce6SDominik Dingel ret = 0; 6468c0a7ce6SDominik Dingel } 6478c0a7ce6SDominik Dingel } 6488c0a7ce6SDominik Dingel mutex_unlock(&kvm->lock); 649a3a92c31SDominik Dingel VM_EVENT(kvm, 3, "SET: max guest address: %lu", new_limit); 650a3a92c31SDominik Dingel VM_EVENT(kvm, 3, "New guest asce: 0x%pK", 651a3a92c31SDominik Dingel (void *) kvm->arch.gmap->asce); 6528c0a7ce6SDominik Dingel break; 6538c0a7ce6SDominik Dingel } 6544f718eabSDominik Dingel default: 6554f718eabSDominik Dingel ret = -ENXIO; 6564f718eabSDominik Dingel break; 6574f718eabSDominik Dingel } 6584f718eabSDominik Dingel return ret; 6594f718eabSDominik Dingel } 6604f718eabSDominik Dingel 661a374e892STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu); 662a374e892STony Krowiak 663a374e892STony Krowiak static int kvm_s390_vm_set_crypto(struct kvm *kvm, struct kvm_device_attr *attr) 664a374e892STony Krowiak { 665a374e892STony Krowiak struct kvm_vcpu *vcpu; 666a374e892STony Krowiak int i; 667a374e892STony Krowiak 6689d8d5786SMichael Mueller if (!test_kvm_facility(kvm, 76)) 669a374e892STony Krowiak return -EINVAL; 670a374e892STony Krowiak 671a374e892STony Krowiak mutex_lock(&kvm->lock); 672a374e892STony Krowiak switch (attr->attr) { 673a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 674a374e892STony Krowiak get_random_bytes( 675a374e892STony Krowiak kvm->arch.crypto.crycb->aes_wrapping_key_mask, 676a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 677a374e892STony Krowiak kvm->arch.crypto.aes_kw = 1; 678c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: AES keywrapping support"); 679a374e892STony Krowiak break; 680a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 681a374e892STony Krowiak get_random_bytes( 682a374e892STony Krowiak kvm->arch.crypto.crycb->dea_wrapping_key_mask, 683a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 684a374e892STony Krowiak kvm->arch.crypto.dea_kw = 1; 685c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: DEA keywrapping support"); 686a374e892STony Krowiak break; 687a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 688a374e892STony Krowiak kvm->arch.crypto.aes_kw = 0; 689a374e892STony Krowiak memset(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 0, 690a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 691c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "DISABLE: AES keywrapping support"); 692a374e892STony Krowiak break; 693a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 694a374e892STony Krowiak kvm->arch.crypto.dea_kw = 0; 695a374e892STony Krowiak memset(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 0, 696a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 697c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "DISABLE: DEA keywrapping support"); 698a374e892STony Krowiak break; 699a374e892STony Krowiak default: 700a374e892STony Krowiak mutex_unlock(&kvm->lock); 701a374e892STony Krowiak return -ENXIO; 702a374e892STony Krowiak } 703a374e892STony Krowiak 704a374e892STony Krowiak kvm_for_each_vcpu(i, vcpu, kvm) { 705a374e892STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 706a374e892STony Krowiak exit_sie(vcpu); 707a374e892STony Krowiak } 708a374e892STony Krowiak mutex_unlock(&kvm->lock); 709a374e892STony Krowiak return 0; 710a374e892STony Krowiak } 711a374e892STony Krowiak 71272f25020SJason J. Herne static int kvm_s390_set_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 71372f25020SJason J. Herne { 71472f25020SJason J. Herne u8 gtod_high; 71572f25020SJason J. Herne 71672f25020SJason J. Herne if (copy_from_user(>od_high, (void __user *)attr->addr, 71772f25020SJason J. Herne sizeof(gtod_high))) 71872f25020SJason J. Herne return -EFAULT; 71972f25020SJason J. Herne 72072f25020SJason J. Herne if (gtod_high != 0) 72172f25020SJason J. Herne return -EINVAL; 72258c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "SET: TOD extension: 0x%x", gtod_high); 72372f25020SJason J. Herne 72472f25020SJason J. Herne return 0; 72572f25020SJason J. Herne } 72672f25020SJason J. Herne 72772f25020SJason J. Herne static int kvm_s390_set_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 72872f25020SJason J. Herne { 7295a3d883aSDavid Hildenbrand u64 gtod; 73072f25020SJason J. Herne 73172f25020SJason J. Herne if (copy_from_user(>od, (void __user *)attr->addr, sizeof(gtod))) 73272f25020SJason J. Herne return -EFAULT; 73372f25020SJason J. Herne 73425ed1675SDavid Hildenbrand kvm_s390_set_tod_clock(kvm, gtod); 73558c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "SET: TOD base: 0x%llx", gtod); 73672f25020SJason J. Herne return 0; 73772f25020SJason J. Herne } 73872f25020SJason J. Herne 73972f25020SJason J. Herne static int kvm_s390_set_tod(struct kvm *kvm, struct kvm_device_attr *attr) 74072f25020SJason J. Herne { 74172f25020SJason J. Herne int ret; 74272f25020SJason J. Herne 74372f25020SJason J. Herne if (attr->flags) 74472f25020SJason J. Herne return -EINVAL; 74572f25020SJason J. Herne 74672f25020SJason J. Herne switch (attr->attr) { 74772f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 74872f25020SJason J. Herne ret = kvm_s390_set_tod_high(kvm, attr); 74972f25020SJason J. Herne break; 75072f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 75172f25020SJason J. Herne ret = kvm_s390_set_tod_low(kvm, attr); 75272f25020SJason J. Herne break; 75372f25020SJason J. Herne default: 75472f25020SJason J. Herne ret = -ENXIO; 75572f25020SJason J. Herne break; 75672f25020SJason J. Herne } 75772f25020SJason J. Herne return ret; 75872f25020SJason J. Herne } 75972f25020SJason J. Herne 76072f25020SJason J. Herne static int kvm_s390_get_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 76172f25020SJason J. Herne { 76272f25020SJason J. Herne u8 gtod_high = 0; 76372f25020SJason J. Herne 76472f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od_high, 76572f25020SJason J. Herne sizeof(gtod_high))) 76672f25020SJason J. Herne return -EFAULT; 76758c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: TOD extension: 0x%x", gtod_high); 76872f25020SJason J. Herne 76972f25020SJason J. Herne return 0; 77072f25020SJason J. Herne } 77172f25020SJason J. Herne 77272f25020SJason J. Herne static int kvm_s390_get_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 77372f25020SJason J. Herne { 7745a3d883aSDavid Hildenbrand u64 gtod; 77572f25020SJason J. Herne 77660417fccSDavid Hildenbrand gtod = kvm_s390_get_tod_clock_fast(kvm); 77772f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od, sizeof(gtod))) 77872f25020SJason J. Herne return -EFAULT; 77958c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: TOD base: 0x%llx", gtod); 78072f25020SJason J. Herne 78172f25020SJason J. Herne return 0; 78272f25020SJason J. Herne } 78372f25020SJason J. Herne 78472f25020SJason J. Herne static int kvm_s390_get_tod(struct kvm *kvm, struct kvm_device_attr *attr) 78572f25020SJason J. Herne { 78672f25020SJason J. Herne int ret; 78772f25020SJason J. Herne 78872f25020SJason J. Herne if (attr->flags) 78972f25020SJason J. Herne return -EINVAL; 79072f25020SJason J. Herne 79172f25020SJason J. Herne switch (attr->attr) { 79272f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 79372f25020SJason J. Herne ret = kvm_s390_get_tod_high(kvm, attr); 79472f25020SJason J. Herne break; 79572f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 79672f25020SJason J. Herne ret = kvm_s390_get_tod_low(kvm, attr); 79772f25020SJason J. Herne break; 79872f25020SJason J. Herne default: 79972f25020SJason J. Herne ret = -ENXIO; 80072f25020SJason J. Herne break; 80172f25020SJason J. Herne } 80272f25020SJason J. Herne return ret; 80372f25020SJason J. Herne } 80472f25020SJason J. Herne 805658b6edaSMichael Mueller static int kvm_s390_set_processor(struct kvm *kvm, struct kvm_device_attr *attr) 806658b6edaSMichael Mueller { 807658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 808053dd230SDavid Hildenbrand u16 lowest_ibc, unblocked_ibc; 809658b6edaSMichael Mueller int ret = 0; 810658b6edaSMichael Mueller 811658b6edaSMichael Mueller mutex_lock(&kvm->lock); 812a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 813658b6edaSMichael Mueller ret = -EBUSY; 814658b6edaSMichael Mueller goto out; 815658b6edaSMichael Mueller } 816658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 817658b6edaSMichael Mueller if (!proc) { 818658b6edaSMichael Mueller ret = -ENOMEM; 819658b6edaSMichael Mueller goto out; 820658b6edaSMichael Mueller } 821658b6edaSMichael Mueller if (!copy_from_user(proc, (void __user *)attr->addr, 822658b6edaSMichael Mueller sizeof(*proc))) { 8239bb0ec09SDavid Hildenbrand kvm->arch.model.cpuid = proc->cpuid; 824053dd230SDavid Hildenbrand lowest_ibc = sclp.ibc >> 16 & 0xfff; 825053dd230SDavid Hildenbrand unblocked_ibc = sclp.ibc & 0xfff; 8260487c44dSDavid Hildenbrand if (lowest_ibc && proc->ibc) { 827053dd230SDavid Hildenbrand if (proc->ibc > unblocked_ibc) 828053dd230SDavid Hildenbrand kvm->arch.model.ibc = unblocked_ibc; 829053dd230SDavid Hildenbrand else if (proc->ibc < lowest_ibc) 830053dd230SDavid Hildenbrand kvm->arch.model.ibc = lowest_ibc; 831053dd230SDavid Hildenbrand else 832658b6edaSMichael Mueller kvm->arch.model.ibc = proc->ibc; 833053dd230SDavid Hildenbrand } 834c54f0d6aSDavid Hildenbrand memcpy(kvm->arch.model.fac_list, proc->fac_list, 835658b6edaSMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 836a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest ibc: 0x%4.4x, guest cpuid: 0x%16.16llx", 837a8c39dd7SChristian Borntraeger kvm->arch.model.ibc, 838a8c39dd7SChristian Borntraeger kvm->arch.model.cpuid); 839a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest faclist: 0x%16.16llx.%16.16llx.%16.16llx", 840a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[0], 841a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[1], 842a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[2]); 843658b6edaSMichael Mueller } else 844658b6edaSMichael Mueller ret = -EFAULT; 845658b6edaSMichael Mueller kfree(proc); 846658b6edaSMichael Mueller out: 847658b6edaSMichael Mueller mutex_unlock(&kvm->lock); 848658b6edaSMichael Mueller return ret; 849658b6edaSMichael Mueller } 850658b6edaSMichael Mueller 85115c9705fSDavid Hildenbrand static int kvm_s390_set_processor_feat(struct kvm *kvm, 85215c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 85315c9705fSDavid Hildenbrand { 85415c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 85515c9705fSDavid Hildenbrand int ret = -EBUSY; 85615c9705fSDavid Hildenbrand 85715c9705fSDavid Hildenbrand if (copy_from_user(&data, (void __user *)attr->addr, sizeof(data))) 85815c9705fSDavid Hildenbrand return -EFAULT; 85915c9705fSDavid Hildenbrand if (!bitmap_subset((unsigned long *) data.feat, 86015c9705fSDavid Hildenbrand kvm_s390_available_cpu_feat, 86115c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS)) 86215c9705fSDavid Hildenbrand return -EINVAL; 86315c9705fSDavid Hildenbrand 86415c9705fSDavid Hildenbrand mutex_lock(&kvm->lock); 86515c9705fSDavid Hildenbrand if (!atomic_read(&kvm->online_vcpus)) { 86615c9705fSDavid Hildenbrand bitmap_copy(kvm->arch.cpu_feat, (unsigned long *) data.feat, 86715c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 86815c9705fSDavid Hildenbrand ret = 0; 86915c9705fSDavid Hildenbrand } 87015c9705fSDavid Hildenbrand mutex_unlock(&kvm->lock); 87115c9705fSDavid Hildenbrand return ret; 87215c9705fSDavid Hildenbrand } 87315c9705fSDavid Hildenbrand 8740a763c78SDavid Hildenbrand static int kvm_s390_set_processor_subfunc(struct kvm *kvm, 8750a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 8760a763c78SDavid Hildenbrand { 8770a763c78SDavid Hildenbrand /* 8780a763c78SDavid Hildenbrand * Once supported by kernel + hw, we have to store the subfunctions 8790a763c78SDavid Hildenbrand * in kvm->arch and remember that user space configured them. 8800a763c78SDavid Hildenbrand */ 8810a763c78SDavid Hildenbrand return -ENXIO; 8820a763c78SDavid Hildenbrand } 8830a763c78SDavid Hildenbrand 884658b6edaSMichael Mueller static int kvm_s390_set_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 885658b6edaSMichael Mueller { 886658b6edaSMichael Mueller int ret = -ENXIO; 887658b6edaSMichael Mueller 888658b6edaSMichael Mueller switch (attr->attr) { 889658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 890658b6edaSMichael Mueller ret = kvm_s390_set_processor(kvm, attr); 891658b6edaSMichael Mueller break; 89215c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 89315c9705fSDavid Hildenbrand ret = kvm_s390_set_processor_feat(kvm, attr); 89415c9705fSDavid Hildenbrand break; 8950a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 8960a763c78SDavid Hildenbrand ret = kvm_s390_set_processor_subfunc(kvm, attr); 8970a763c78SDavid Hildenbrand break; 898658b6edaSMichael Mueller } 899658b6edaSMichael Mueller return ret; 900658b6edaSMichael Mueller } 901658b6edaSMichael Mueller 902658b6edaSMichael Mueller static int kvm_s390_get_processor(struct kvm *kvm, struct kvm_device_attr *attr) 903658b6edaSMichael Mueller { 904658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 905658b6edaSMichael Mueller int ret = 0; 906658b6edaSMichael Mueller 907658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 908658b6edaSMichael Mueller if (!proc) { 909658b6edaSMichael Mueller ret = -ENOMEM; 910658b6edaSMichael Mueller goto out; 911658b6edaSMichael Mueller } 9129bb0ec09SDavid Hildenbrand proc->cpuid = kvm->arch.model.cpuid; 913658b6edaSMichael Mueller proc->ibc = kvm->arch.model.ibc; 914c54f0d6aSDavid Hildenbrand memcpy(&proc->fac_list, kvm->arch.model.fac_list, 915c54f0d6aSDavid Hildenbrand S390_ARCH_FAC_LIST_SIZE_BYTE); 916a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest ibc: 0x%4.4x, guest cpuid: 0x%16.16llx", 917a8c39dd7SChristian Borntraeger kvm->arch.model.ibc, 918a8c39dd7SChristian Borntraeger kvm->arch.model.cpuid); 919a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest faclist: 0x%16.16llx.%16.16llx.%16.16llx", 920a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[0], 921a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[1], 922a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[2]); 923658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, proc, sizeof(*proc))) 924658b6edaSMichael Mueller ret = -EFAULT; 925658b6edaSMichael Mueller kfree(proc); 926658b6edaSMichael Mueller out: 927658b6edaSMichael Mueller return ret; 928658b6edaSMichael Mueller } 929658b6edaSMichael Mueller 930658b6edaSMichael Mueller static int kvm_s390_get_machine(struct kvm *kvm, struct kvm_device_attr *attr) 931658b6edaSMichael Mueller { 932658b6edaSMichael Mueller struct kvm_s390_vm_cpu_machine *mach; 933658b6edaSMichael Mueller int ret = 0; 934658b6edaSMichael Mueller 935658b6edaSMichael Mueller mach = kzalloc(sizeof(*mach), GFP_KERNEL); 936658b6edaSMichael Mueller if (!mach) { 937658b6edaSMichael Mueller ret = -ENOMEM; 938658b6edaSMichael Mueller goto out; 939658b6edaSMichael Mueller } 940658b6edaSMichael Mueller get_cpu_id((struct cpuid *) &mach->cpuid); 94137c5f6c8SDavid Hildenbrand mach->ibc = sclp.ibc; 942c54f0d6aSDavid Hildenbrand memcpy(&mach->fac_mask, kvm->arch.model.fac_mask, 943981467c9SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 944658b6edaSMichael Mueller memcpy((unsigned long *)&mach->fac_list, S390_lowcore.stfle_fac_list, 94504478197SChristian Borntraeger sizeof(S390_lowcore.stfle_fac_list)); 946a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host ibc: 0x%4.4x, host cpuid: 0x%16.16llx", 947a8c39dd7SChristian Borntraeger kvm->arch.model.ibc, 948a8c39dd7SChristian Borntraeger kvm->arch.model.cpuid); 949a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host facmask: 0x%16.16llx.%16.16llx.%16.16llx", 950a8c39dd7SChristian Borntraeger mach->fac_mask[0], 951a8c39dd7SChristian Borntraeger mach->fac_mask[1], 952a8c39dd7SChristian Borntraeger mach->fac_mask[2]); 953a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host faclist: 0x%16.16llx.%16.16llx.%16.16llx", 954a8c39dd7SChristian Borntraeger mach->fac_list[0], 955a8c39dd7SChristian Borntraeger mach->fac_list[1], 956a8c39dd7SChristian Borntraeger mach->fac_list[2]); 957658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, mach, sizeof(*mach))) 958658b6edaSMichael Mueller ret = -EFAULT; 959658b6edaSMichael Mueller kfree(mach); 960658b6edaSMichael Mueller out: 961658b6edaSMichael Mueller return ret; 962658b6edaSMichael Mueller } 963658b6edaSMichael Mueller 96415c9705fSDavid Hildenbrand static int kvm_s390_get_processor_feat(struct kvm *kvm, 96515c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 96615c9705fSDavid Hildenbrand { 96715c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 96815c9705fSDavid Hildenbrand 96915c9705fSDavid Hildenbrand bitmap_copy((unsigned long *) data.feat, kvm->arch.cpu_feat, 97015c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 97115c9705fSDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &data, sizeof(data))) 97215c9705fSDavid Hildenbrand return -EFAULT; 97315c9705fSDavid Hildenbrand return 0; 97415c9705fSDavid Hildenbrand } 97515c9705fSDavid Hildenbrand 97615c9705fSDavid Hildenbrand static int kvm_s390_get_machine_feat(struct kvm *kvm, 97715c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 97815c9705fSDavid Hildenbrand { 97915c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 98015c9705fSDavid Hildenbrand 98115c9705fSDavid Hildenbrand bitmap_copy((unsigned long *) data.feat, 98215c9705fSDavid Hildenbrand kvm_s390_available_cpu_feat, 98315c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 98415c9705fSDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &data, sizeof(data))) 98515c9705fSDavid Hildenbrand return -EFAULT; 98615c9705fSDavid Hildenbrand return 0; 98715c9705fSDavid Hildenbrand } 98815c9705fSDavid Hildenbrand 9890a763c78SDavid Hildenbrand static int kvm_s390_get_processor_subfunc(struct kvm *kvm, 9900a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 9910a763c78SDavid Hildenbrand { 9920a763c78SDavid Hildenbrand /* 9930a763c78SDavid Hildenbrand * Once we can actually configure subfunctions (kernel + hw support), 9940a763c78SDavid Hildenbrand * we have to check if they were already set by user space, if so copy 9950a763c78SDavid Hildenbrand * them from kvm->arch. 9960a763c78SDavid Hildenbrand */ 9970a763c78SDavid Hildenbrand return -ENXIO; 9980a763c78SDavid Hildenbrand } 9990a763c78SDavid Hildenbrand 10000a763c78SDavid Hildenbrand static int kvm_s390_get_machine_subfunc(struct kvm *kvm, 10010a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 10020a763c78SDavid Hildenbrand { 10030a763c78SDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &kvm_s390_available_subfunc, 10040a763c78SDavid Hildenbrand sizeof(struct kvm_s390_vm_cpu_subfunc))) 10050a763c78SDavid Hildenbrand return -EFAULT; 10060a763c78SDavid Hildenbrand return 0; 10070a763c78SDavid Hildenbrand } 1008658b6edaSMichael Mueller static int kvm_s390_get_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 1009658b6edaSMichael Mueller { 1010658b6edaSMichael Mueller int ret = -ENXIO; 1011658b6edaSMichael Mueller 1012658b6edaSMichael Mueller switch (attr->attr) { 1013658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 1014658b6edaSMichael Mueller ret = kvm_s390_get_processor(kvm, attr); 1015658b6edaSMichael Mueller break; 1016658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 1017658b6edaSMichael Mueller ret = kvm_s390_get_machine(kvm, attr); 1018658b6edaSMichael Mueller break; 101915c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 102015c9705fSDavid Hildenbrand ret = kvm_s390_get_processor_feat(kvm, attr); 102115c9705fSDavid Hildenbrand break; 102215c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_FEAT: 102315c9705fSDavid Hildenbrand ret = kvm_s390_get_machine_feat(kvm, attr); 102415c9705fSDavid Hildenbrand break; 10250a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 10260a763c78SDavid Hildenbrand ret = kvm_s390_get_processor_subfunc(kvm, attr); 10270a763c78SDavid Hildenbrand break; 10280a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_SUBFUNC: 10290a763c78SDavid Hildenbrand ret = kvm_s390_get_machine_subfunc(kvm, attr); 10300a763c78SDavid Hildenbrand break; 1031658b6edaSMichael Mueller } 1032658b6edaSMichael Mueller return ret; 1033658b6edaSMichael Mueller } 1034658b6edaSMichael Mueller 1035f2061656SDominik Dingel static int kvm_s390_vm_set_attr(struct kvm *kvm, struct kvm_device_attr *attr) 1036f2061656SDominik Dingel { 1037f2061656SDominik Dingel int ret; 1038f2061656SDominik Dingel 1039f2061656SDominik Dingel switch (attr->group) { 10404f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 10418c0a7ce6SDominik Dingel ret = kvm_s390_set_mem_control(kvm, attr); 10424f718eabSDominik Dingel break; 104372f25020SJason J. Herne case KVM_S390_VM_TOD: 104472f25020SJason J. Herne ret = kvm_s390_set_tod(kvm, attr); 104572f25020SJason J. Herne break; 1046658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 1047658b6edaSMichael Mueller ret = kvm_s390_set_cpu_model(kvm, attr); 1048658b6edaSMichael Mueller break; 1049a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 1050a374e892STony Krowiak ret = kvm_s390_vm_set_crypto(kvm, attr); 1051a374e892STony Krowiak break; 1052f2061656SDominik Dingel default: 1053f2061656SDominik Dingel ret = -ENXIO; 1054f2061656SDominik Dingel break; 1055f2061656SDominik Dingel } 1056f2061656SDominik Dingel 1057f2061656SDominik Dingel return ret; 1058f2061656SDominik Dingel } 1059f2061656SDominik Dingel 1060f2061656SDominik Dingel static int kvm_s390_vm_get_attr(struct kvm *kvm, struct kvm_device_attr *attr) 1061f2061656SDominik Dingel { 10628c0a7ce6SDominik Dingel int ret; 10638c0a7ce6SDominik Dingel 10648c0a7ce6SDominik Dingel switch (attr->group) { 10658c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_CTRL: 10668c0a7ce6SDominik Dingel ret = kvm_s390_get_mem_control(kvm, attr); 10678c0a7ce6SDominik Dingel break; 106872f25020SJason J. Herne case KVM_S390_VM_TOD: 106972f25020SJason J. Herne ret = kvm_s390_get_tod(kvm, attr); 107072f25020SJason J. Herne break; 1071658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 1072658b6edaSMichael Mueller ret = kvm_s390_get_cpu_model(kvm, attr); 1073658b6edaSMichael Mueller break; 10748c0a7ce6SDominik Dingel default: 10758c0a7ce6SDominik Dingel ret = -ENXIO; 10768c0a7ce6SDominik Dingel break; 10778c0a7ce6SDominik Dingel } 10788c0a7ce6SDominik Dingel 10798c0a7ce6SDominik Dingel return ret; 1080f2061656SDominik Dingel } 1081f2061656SDominik Dingel 1082f2061656SDominik Dingel static int kvm_s390_vm_has_attr(struct kvm *kvm, struct kvm_device_attr *attr) 1083f2061656SDominik Dingel { 1084f2061656SDominik Dingel int ret; 1085f2061656SDominik Dingel 1086f2061656SDominik Dingel switch (attr->group) { 10874f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 10884f718eabSDominik Dingel switch (attr->attr) { 10894f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 10904f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 1091f9cbd9b0SDavid Hildenbrand ret = sclp.has_cmma ? 0 : -ENXIO; 1092f9cbd9b0SDavid Hildenbrand break; 10938c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 10944f718eabSDominik Dingel ret = 0; 10954f718eabSDominik Dingel break; 10964f718eabSDominik Dingel default: 10974f718eabSDominik Dingel ret = -ENXIO; 10984f718eabSDominik Dingel break; 10994f718eabSDominik Dingel } 11004f718eabSDominik Dingel break; 110172f25020SJason J. Herne case KVM_S390_VM_TOD: 110272f25020SJason J. Herne switch (attr->attr) { 110372f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 110472f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 110572f25020SJason J. Herne ret = 0; 110672f25020SJason J. Herne break; 110772f25020SJason J. Herne default: 110872f25020SJason J. Herne ret = -ENXIO; 110972f25020SJason J. Herne break; 111072f25020SJason J. Herne } 111172f25020SJason J. Herne break; 1112658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 1113658b6edaSMichael Mueller switch (attr->attr) { 1114658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 1115658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 111615c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 111715c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_FEAT: 11180a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_SUBFUNC: 1119658b6edaSMichael Mueller ret = 0; 1120658b6edaSMichael Mueller break; 11210a763c78SDavid Hildenbrand /* configuring subfunctions is not supported yet */ 11220a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 1123658b6edaSMichael Mueller default: 1124658b6edaSMichael Mueller ret = -ENXIO; 1125658b6edaSMichael Mueller break; 1126658b6edaSMichael Mueller } 1127658b6edaSMichael Mueller break; 1128a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 1129a374e892STony Krowiak switch (attr->attr) { 1130a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 1131a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 1132a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 1133a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 1134a374e892STony Krowiak ret = 0; 1135a374e892STony Krowiak break; 1136a374e892STony Krowiak default: 1137a374e892STony Krowiak ret = -ENXIO; 1138a374e892STony Krowiak break; 1139a374e892STony Krowiak } 1140a374e892STony Krowiak break; 1141f2061656SDominik Dingel default: 1142f2061656SDominik Dingel ret = -ENXIO; 1143f2061656SDominik Dingel break; 1144f2061656SDominik Dingel } 1145f2061656SDominik Dingel 1146f2061656SDominik Dingel return ret; 1147f2061656SDominik Dingel } 1148f2061656SDominik Dingel 114930ee2a98SJason J. Herne static long kvm_s390_get_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 115030ee2a98SJason J. Herne { 115130ee2a98SJason J. Herne uint8_t *keys; 115230ee2a98SJason J. Herne uint64_t hva; 115330ee2a98SJason J. Herne int i, r = 0; 115430ee2a98SJason J. Herne 115530ee2a98SJason J. Herne if (args->flags != 0) 115630ee2a98SJason J. Herne return -EINVAL; 115730ee2a98SJason J. Herne 115830ee2a98SJason J. Herne /* Is this guest using storage keys? */ 115930ee2a98SJason J. Herne if (!mm_use_skey(current->mm)) 116030ee2a98SJason J. Herne return KVM_S390_GET_SKEYS_NONE; 116130ee2a98SJason J. Herne 116230ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 116330ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 116430ee2a98SJason J. Herne return -EINVAL; 116530ee2a98SJason J. Herne 116630ee2a98SJason J. Herne keys = kmalloc_array(args->count, sizeof(uint8_t), 116730ee2a98SJason J. Herne GFP_KERNEL | __GFP_NOWARN); 116830ee2a98SJason J. Herne if (!keys) 116930ee2a98SJason J. Herne keys = vmalloc(sizeof(uint8_t) * args->count); 117030ee2a98SJason J. Herne if (!keys) 117130ee2a98SJason J. Herne return -ENOMEM; 117230ee2a98SJason J. Herne 1173d3ed1ceeSMartin Schwidefsky down_read(¤t->mm->mmap_sem); 117430ee2a98SJason J. Herne for (i = 0; i < args->count; i++) { 117530ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 117630ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 117730ee2a98SJason J. Herne r = -EFAULT; 1178d3ed1ceeSMartin Schwidefsky break; 117930ee2a98SJason J. Herne } 118030ee2a98SJason J. Herne 1181154c8c19SDavid Hildenbrand r = get_guest_storage_key(current->mm, hva, &keys[i]); 1182154c8c19SDavid Hildenbrand if (r) 1183d3ed1ceeSMartin Schwidefsky break; 118430ee2a98SJason J. Herne } 1185d3ed1ceeSMartin Schwidefsky up_read(¤t->mm->mmap_sem); 118630ee2a98SJason J. Herne 1187d3ed1ceeSMartin Schwidefsky if (!r) { 118830ee2a98SJason J. Herne r = copy_to_user((uint8_t __user *)args->skeydata_addr, keys, 118930ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 119030ee2a98SJason J. Herne if (r) 119130ee2a98SJason J. Herne r = -EFAULT; 1192d3ed1ceeSMartin Schwidefsky } 1193d3ed1ceeSMartin Schwidefsky 119430ee2a98SJason J. Herne kvfree(keys); 119530ee2a98SJason J. Herne return r; 119630ee2a98SJason J. Herne } 119730ee2a98SJason J. Herne 119830ee2a98SJason J. Herne static long kvm_s390_set_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 119930ee2a98SJason J. Herne { 120030ee2a98SJason J. Herne uint8_t *keys; 120130ee2a98SJason J. Herne uint64_t hva; 120230ee2a98SJason J. Herne int i, r = 0; 120330ee2a98SJason J. Herne 120430ee2a98SJason J. Herne if (args->flags != 0) 120530ee2a98SJason J. Herne return -EINVAL; 120630ee2a98SJason J. Herne 120730ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 120830ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 120930ee2a98SJason J. Herne return -EINVAL; 121030ee2a98SJason J. Herne 121130ee2a98SJason J. Herne keys = kmalloc_array(args->count, sizeof(uint8_t), 121230ee2a98SJason J. Herne GFP_KERNEL | __GFP_NOWARN); 121330ee2a98SJason J. Herne if (!keys) 121430ee2a98SJason J. Herne keys = vmalloc(sizeof(uint8_t) * args->count); 121530ee2a98SJason J. Herne if (!keys) 121630ee2a98SJason J. Herne return -ENOMEM; 121730ee2a98SJason J. Herne 121830ee2a98SJason J. Herne r = copy_from_user(keys, (uint8_t __user *)args->skeydata_addr, 121930ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 122030ee2a98SJason J. Herne if (r) { 122130ee2a98SJason J. Herne r = -EFAULT; 122230ee2a98SJason J. Herne goto out; 122330ee2a98SJason J. Herne } 122430ee2a98SJason J. Herne 122530ee2a98SJason J. Herne /* Enable storage key handling for the guest */ 122614d4a425SDominik Dingel r = s390_enable_skey(); 122714d4a425SDominik Dingel if (r) 122814d4a425SDominik Dingel goto out; 122930ee2a98SJason J. Herne 1230d3ed1ceeSMartin Schwidefsky down_read(¤t->mm->mmap_sem); 123130ee2a98SJason J. Herne for (i = 0; i < args->count; i++) { 123230ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 123330ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 123430ee2a98SJason J. Herne r = -EFAULT; 1235d3ed1ceeSMartin Schwidefsky break; 123630ee2a98SJason J. Herne } 123730ee2a98SJason J. Herne 123830ee2a98SJason J. Herne /* Lowest order bit is reserved */ 123930ee2a98SJason J. Herne if (keys[i] & 0x01) { 124030ee2a98SJason J. Herne r = -EINVAL; 1241d3ed1ceeSMartin Schwidefsky break; 124230ee2a98SJason J. Herne } 124330ee2a98SJason J. Herne 1244fe69eabfSDavid Hildenbrand r = set_guest_storage_key(current->mm, hva, keys[i], 0); 124530ee2a98SJason J. Herne if (r) 1246d3ed1ceeSMartin Schwidefsky break; 124730ee2a98SJason J. Herne } 1248d3ed1ceeSMartin Schwidefsky up_read(¤t->mm->mmap_sem); 124930ee2a98SJason J. Herne out: 125030ee2a98SJason J. Herne kvfree(keys); 125130ee2a98SJason J. Herne return r; 125230ee2a98SJason J. Herne } 125330ee2a98SJason J. Herne 1254b0c632dbSHeiko Carstens long kvm_arch_vm_ioctl(struct file *filp, 1255b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 1256b0c632dbSHeiko Carstens { 1257b0c632dbSHeiko Carstens struct kvm *kvm = filp->private_data; 1258b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 1259f2061656SDominik Dingel struct kvm_device_attr attr; 1260b0c632dbSHeiko Carstens int r; 1261b0c632dbSHeiko Carstens 1262b0c632dbSHeiko Carstens switch (ioctl) { 1263ba5c1e9bSCarsten Otte case KVM_S390_INTERRUPT: { 1264ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 1265ba5c1e9bSCarsten Otte 1266ba5c1e9bSCarsten Otte r = -EFAULT; 1267ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 1268ba5c1e9bSCarsten Otte break; 1269ba5c1e9bSCarsten Otte r = kvm_s390_inject_vm(kvm, &s390int); 1270ba5c1e9bSCarsten Otte break; 1271ba5c1e9bSCarsten Otte } 1272d938dc55SCornelia Huck case KVM_ENABLE_CAP: { 1273d938dc55SCornelia Huck struct kvm_enable_cap cap; 1274d938dc55SCornelia Huck r = -EFAULT; 1275d938dc55SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 1276d938dc55SCornelia Huck break; 1277d938dc55SCornelia Huck r = kvm_vm_ioctl_enable_cap(kvm, &cap); 1278d938dc55SCornelia Huck break; 1279d938dc55SCornelia Huck } 128084223598SCornelia Huck case KVM_CREATE_IRQCHIP: { 128184223598SCornelia Huck struct kvm_irq_routing_entry routing; 128284223598SCornelia Huck 128384223598SCornelia Huck r = -EINVAL; 128484223598SCornelia Huck if (kvm->arch.use_irqchip) { 128584223598SCornelia Huck /* Set up dummy routing. */ 128684223598SCornelia Huck memset(&routing, 0, sizeof(routing)); 1287152b2839SNicholas Krause r = kvm_set_irq_routing(kvm, &routing, 0, 0); 128884223598SCornelia Huck } 128984223598SCornelia Huck break; 129084223598SCornelia Huck } 1291f2061656SDominik Dingel case KVM_SET_DEVICE_ATTR: { 1292f2061656SDominik Dingel r = -EFAULT; 1293f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 1294f2061656SDominik Dingel break; 1295f2061656SDominik Dingel r = kvm_s390_vm_set_attr(kvm, &attr); 1296f2061656SDominik Dingel break; 1297f2061656SDominik Dingel } 1298f2061656SDominik Dingel case KVM_GET_DEVICE_ATTR: { 1299f2061656SDominik Dingel r = -EFAULT; 1300f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 1301f2061656SDominik Dingel break; 1302f2061656SDominik Dingel r = kvm_s390_vm_get_attr(kvm, &attr); 1303f2061656SDominik Dingel break; 1304f2061656SDominik Dingel } 1305f2061656SDominik Dingel case KVM_HAS_DEVICE_ATTR: { 1306f2061656SDominik Dingel r = -EFAULT; 1307f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 1308f2061656SDominik Dingel break; 1309f2061656SDominik Dingel r = kvm_s390_vm_has_attr(kvm, &attr); 1310f2061656SDominik Dingel break; 1311f2061656SDominik Dingel } 131230ee2a98SJason J. Herne case KVM_S390_GET_SKEYS: { 131330ee2a98SJason J. Herne struct kvm_s390_skeys args; 131430ee2a98SJason J. Herne 131530ee2a98SJason J. Herne r = -EFAULT; 131630ee2a98SJason J. Herne if (copy_from_user(&args, argp, 131730ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 131830ee2a98SJason J. Herne break; 131930ee2a98SJason J. Herne r = kvm_s390_get_skeys(kvm, &args); 132030ee2a98SJason J. Herne break; 132130ee2a98SJason J. Herne } 132230ee2a98SJason J. Herne case KVM_S390_SET_SKEYS: { 132330ee2a98SJason J. Herne struct kvm_s390_skeys args; 132430ee2a98SJason J. Herne 132530ee2a98SJason J. Herne r = -EFAULT; 132630ee2a98SJason J. Herne if (copy_from_user(&args, argp, 132730ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 132830ee2a98SJason J. Herne break; 132930ee2a98SJason J. Herne r = kvm_s390_set_skeys(kvm, &args); 133030ee2a98SJason J. Herne break; 133130ee2a98SJason J. Herne } 1332b0c632dbSHeiko Carstens default: 1333367e1319SAvi Kivity r = -ENOTTY; 1334b0c632dbSHeiko Carstens } 1335b0c632dbSHeiko Carstens 1336b0c632dbSHeiko Carstens return r; 1337b0c632dbSHeiko Carstens } 1338b0c632dbSHeiko Carstens 133945c9b47cSTony Krowiak static int kvm_s390_query_ap_config(u8 *config) 134045c9b47cSTony Krowiak { 134145c9b47cSTony Krowiak u32 fcn_code = 0x04000000UL; 134286044c8cSChristian Borntraeger u32 cc = 0; 134345c9b47cSTony Krowiak 134486044c8cSChristian Borntraeger memset(config, 0, 128); 134545c9b47cSTony Krowiak asm volatile( 134645c9b47cSTony Krowiak "lgr 0,%1\n" 134745c9b47cSTony Krowiak "lgr 2,%2\n" 134845c9b47cSTony Krowiak ".long 0xb2af0000\n" /* PQAP(QCI) */ 134986044c8cSChristian Borntraeger "0: ipm %0\n" 135045c9b47cSTony Krowiak "srl %0,28\n" 135186044c8cSChristian Borntraeger "1:\n" 135286044c8cSChristian Borntraeger EX_TABLE(0b, 1b) 135386044c8cSChristian Borntraeger : "+r" (cc) 135445c9b47cSTony Krowiak : "r" (fcn_code), "r" (config) 135545c9b47cSTony Krowiak : "cc", "0", "2", "memory" 135645c9b47cSTony Krowiak ); 135745c9b47cSTony Krowiak 135845c9b47cSTony Krowiak return cc; 135945c9b47cSTony Krowiak } 136045c9b47cSTony Krowiak 136145c9b47cSTony Krowiak static int kvm_s390_apxa_installed(void) 136245c9b47cSTony Krowiak { 136345c9b47cSTony Krowiak u8 config[128]; 136445c9b47cSTony Krowiak int cc; 136545c9b47cSTony Krowiak 1366a6aacc3fSHeiko Carstens if (test_facility(12)) { 136745c9b47cSTony Krowiak cc = kvm_s390_query_ap_config(config); 136845c9b47cSTony Krowiak 136945c9b47cSTony Krowiak if (cc) 137045c9b47cSTony Krowiak pr_err("PQAP(QCI) failed with cc=%d", cc); 137145c9b47cSTony Krowiak else 137245c9b47cSTony Krowiak return config[0] & 0x40; 137345c9b47cSTony Krowiak } 137445c9b47cSTony Krowiak 137545c9b47cSTony Krowiak return 0; 137645c9b47cSTony Krowiak } 137745c9b47cSTony Krowiak 137845c9b47cSTony Krowiak static void kvm_s390_set_crycb_format(struct kvm *kvm) 137945c9b47cSTony Krowiak { 138045c9b47cSTony Krowiak kvm->arch.crypto.crycbd = (__u32)(unsigned long) kvm->arch.crypto.crycb; 138145c9b47cSTony Krowiak 138245c9b47cSTony Krowiak if (kvm_s390_apxa_installed()) 138345c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT2; 138445c9b47cSTony Krowiak else 138545c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT1; 138645c9b47cSTony Krowiak } 138745c9b47cSTony Krowiak 13889bb0ec09SDavid Hildenbrand static u64 kvm_s390_get_initial_cpuid(void) 13899d8d5786SMichael Mueller { 13909bb0ec09SDavid Hildenbrand struct cpuid cpuid; 13919bb0ec09SDavid Hildenbrand 13929bb0ec09SDavid Hildenbrand get_cpu_id(&cpuid); 13939bb0ec09SDavid Hildenbrand cpuid.version = 0xff; 13949bb0ec09SDavid Hildenbrand return *((u64 *) &cpuid); 13959d8d5786SMichael Mueller } 13969d8d5786SMichael Mueller 1397c54f0d6aSDavid Hildenbrand static void kvm_s390_crypto_init(struct kvm *kvm) 13985102ee87STony Krowiak { 13999d8d5786SMichael Mueller if (!test_kvm_facility(kvm, 76)) 1400c54f0d6aSDavid Hildenbrand return; 14015102ee87STony Krowiak 1402c54f0d6aSDavid Hildenbrand kvm->arch.crypto.crycb = &kvm->arch.sie_page2->crycb; 140345c9b47cSTony Krowiak kvm_s390_set_crycb_format(kvm); 14045102ee87STony Krowiak 1405ed6f76b4STony Krowiak /* Enable AES/DEA protected key functions by default */ 1406ed6f76b4STony Krowiak kvm->arch.crypto.aes_kw = 1; 1407ed6f76b4STony Krowiak kvm->arch.crypto.dea_kw = 1; 1408ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 1409ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 1410ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 1411ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 14125102ee87STony Krowiak } 14135102ee87STony Krowiak 14147d43bafcSEugene (jno) Dvurechenski static void sca_dispose(struct kvm *kvm) 14157d43bafcSEugene (jno) Dvurechenski { 14167d43bafcSEugene (jno) Dvurechenski if (kvm->arch.use_esca) 14175e044315SEugene (jno) Dvurechenski free_pages_exact(kvm->arch.sca, sizeof(struct esca_block)); 14187d43bafcSEugene (jno) Dvurechenski else 14197d43bafcSEugene (jno) Dvurechenski free_page((unsigned long)(kvm->arch.sca)); 14207d43bafcSEugene (jno) Dvurechenski kvm->arch.sca = NULL; 14217d43bafcSEugene (jno) Dvurechenski } 14227d43bafcSEugene (jno) Dvurechenski 1423e08b9637SCarsten Otte int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 1424b0c632dbSHeiko Carstens { 142576a6dd72SDavid Hildenbrand gfp_t alloc_flags = GFP_KERNEL; 14269d8d5786SMichael Mueller int i, rc; 1427b0c632dbSHeiko Carstens char debug_name[16]; 1428f6c137ffSChristian Borntraeger static unsigned long sca_offset; 1429b0c632dbSHeiko Carstens 1430e08b9637SCarsten Otte rc = -EINVAL; 1431e08b9637SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 1432e08b9637SCarsten Otte if (type & ~KVM_VM_S390_UCONTROL) 1433e08b9637SCarsten Otte goto out_err; 1434e08b9637SCarsten Otte if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN))) 1435e08b9637SCarsten Otte goto out_err; 1436e08b9637SCarsten Otte #else 1437e08b9637SCarsten Otte if (type) 1438e08b9637SCarsten Otte goto out_err; 1439e08b9637SCarsten Otte #endif 1440e08b9637SCarsten Otte 1441b0c632dbSHeiko Carstens rc = s390_enable_sie(); 1442b0c632dbSHeiko Carstens if (rc) 1443d89f5effSJan Kiszka goto out_err; 1444b0c632dbSHeiko Carstens 1445b290411aSCarsten Otte rc = -ENOMEM; 1446b290411aSCarsten Otte 14477d0a5e62SJanosch Frank ratelimit_state_init(&kvm->arch.sthyi_limit, 5 * HZ, 500); 14487d0a5e62SJanosch Frank 14497d43bafcSEugene (jno) Dvurechenski kvm->arch.use_esca = 0; /* start with basic SCA */ 145076a6dd72SDavid Hildenbrand if (!sclp.has_64bscao) 145176a6dd72SDavid Hildenbrand alloc_flags |= GFP_DMA; 14525e044315SEugene (jno) Dvurechenski rwlock_init(&kvm->arch.sca_lock); 145376a6dd72SDavid Hildenbrand kvm->arch.sca = (struct bsca_block *) get_zeroed_page(alloc_flags); 1454b0c632dbSHeiko Carstens if (!kvm->arch.sca) 1455d89f5effSJan Kiszka goto out_err; 1456f6c137ffSChristian Borntraeger spin_lock(&kvm_lock); 1457c5c2c393SDavid Hildenbrand sca_offset += 16; 1458bc784cceSEugene (jno) Dvurechenski if (sca_offset + sizeof(struct bsca_block) > PAGE_SIZE) 1459c5c2c393SDavid Hildenbrand sca_offset = 0; 1460bc784cceSEugene (jno) Dvurechenski kvm->arch.sca = (struct bsca_block *) 1461bc784cceSEugene (jno) Dvurechenski ((char *) kvm->arch.sca + sca_offset); 1462f6c137ffSChristian Borntraeger spin_unlock(&kvm_lock); 1463b0c632dbSHeiko Carstens 1464b0c632dbSHeiko Carstens sprintf(debug_name, "kvm-%u", current->pid); 1465b0c632dbSHeiko Carstens 14661cb9cf72SChristian Borntraeger kvm->arch.dbf = debug_register(debug_name, 32, 1, 7 * sizeof(long)); 1467b0c632dbSHeiko Carstens if (!kvm->arch.dbf) 146840f5b735SDominik Dingel goto out_err; 1469b0c632dbSHeiko Carstens 1470c54f0d6aSDavid Hildenbrand kvm->arch.sie_page2 = 1471c54f0d6aSDavid Hildenbrand (struct sie_page2 *) get_zeroed_page(GFP_KERNEL | GFP_DMA); 1472c54f0d6aSDavid Hildenbrand if (!kvm->arch.sie_page2) 147340f5b735SDominik Dingel goto out_err; 14749d8d5786SMichael Mueller 1475fb5bf93fSMichael Mueller /* Populate the facility mask initially. */ 1476c54f0d6aSDavid Hildenbrand memcpy(kvm->arch.model.fac_mask, S390_lowcore.stfle_fac_list, 147704478197SChristian Borntraeger sizeof(S390_lowcore.stfle_fac_list)); 14789d8d5786SMichael Mueller for (i = 0; i < S390_ARCH_FAC_LIST_SIZE_U64; i++) { 14799d8d5786SMichael Mueller if (i < kvm_s390_fac_list_mask_size()) 1480c54f0d6aSDavid Hildenbrand kvm->arch.model.fac_mask[i] &= kvm_s390_fac_list_mask[i]; 14819d8d5786SMichael Mueller else 1482c54f0d6aSDavid Hildenbrand kvm->arch.model.fac_mask[i] = 0UL; 14839d8d5786SMichael Mueller } 14849d8d5786SMichael Mueller 1485981467c9SMichael Mueller /* Populate the facility list initially. */ 1486c54f0d6aSDavid Hildenbrand kvm->arch.model.fac_list = kvm->arch.sie_page2->fac_list; 1487c54f0d6aSDavid Hildenbrand memcpy(kvm->arch.model.fac_list, kvm->arch.model.fac_mask, 1488981467c9SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 1489981467c9SMichael Mueller 149095ca2cb5SJanosch Frank set_kvm_facility(kvm->arch.model.fac_mask, 74); 149195ca2cb5SJanosch Frank set_kvm_facility(kvm->arch.model.fac_list, 74); 149295ca2cb5SJanosch Frank 14939bb0ec09SDavid Hildenbrand kvm->arch.model.cpuid = kvm_s390_get_initial_cpuid(); 149437c5f6c8SDavid Hildenbrand kvm->arch.model.ibc = sclp.ibc & 0x0fff; 14959d8d5786SMichael Mueller 1496c54f0d6aSDavid Hildenbrand kvm_s390_crypto_init(kvm); 14975102ee87STony Krowiak 1498ba5c1e9bSCarsten Otte spin_lock_init(&kvm->arch.float_int.lock); 14996d3da241SJens Freimann for (i = 0; i < FIRQ_LIST_COUNT; i++) 15006d3da241SJens Freimann INIT_LIST_HEAD(&kvm->arch.float_int.lists[i]); 15018a242234SHeiko Carstens init_waitqueue_head(&kvm->arch.ipte_wq); 1502a6b7e459SThomas Huth mutex_init(&kvm->arch.ipte_mutex); 1503ba5c1e9bSCarsten Otte 1504b0c632dbSHeiko Carstens debug_register_view(kvm->arch.dbf, &debug_sprintf_view); 150578f26131SChristian Borntraeger VM_EVENT(kvm, 3, "vm created with type %lu", type); 1506b0c632dbSHeiko Carstens 1507e08b9637SCarsten Otte if (type & KVM_VM_S390_UCONTROL) { 1508e08b9637SCarsten Otte kvm->arch.gmap = NULL; 1509a3a92c31SDominik Dingel kvm->arch.mem_limit = KVM_S390_NO_MEM_LIMIT; 1510e08b9637SCarsten Otte } else { 151132e6b236SGuenther Hutzl if (sclp.hamax == U64_MAX) 1512a3a92c31SDominik Dingel kvm->arch.mem_limit = TASK_MAX_SIZE; 151332e6b236SGuenther Hutzl else 151432e6b236SGuenther Hutzl kvm->arch.mem_limit = min_t(unsigned long, TASK_MAX_SIZE, 151532e6b236SGuenther Hutzl sclp.hamax + 1); 15166ea427bbSMartin Schwidefsky kvm->arch.gmap = gmap_create(current->mm, kvm->arch.mem_limit - 1); 1517598841caSCarsten Otte if (!kvm->arch.gmap) 151840f5b735SDominik Dingel goto out_err; 15192c70fe44SChristian Borntraeger kvm->arch.gmap->private = kvm; 152024eb3a82SDominik Dingel kvm->arch.gmap->pfault_enabled = 0; 1521e08b9637SCarsten Otte } 1522fa6b7fe9SCornelia Huck 1523fa6b7fe9SCornelia Huck kvm->arch.css_support = 0; 152484223598SCornelia Huck kvm->arch.use_irqchip = 0; 152572f25020SJason J. Herne kvm->arch.epoch = 0; 1526fa6b7fe9SCornelia Huck 15278ad35755SDavid Hildenbrand spin_lock_init(&kvm->arch.start_stop_lock); 1528a3508fbeSDavid Hildenbrand kvm_s390_vsie_init(kvm); 15298335713aSChristian Borntraeger KVM_EVENT(3, "vm 0x%pK created by pid %u", kvm, current->pid); 15308ad35755SDavid Hildenbrand 1531d89f5effSJan Kiszka return 0; 1532d89f5effSJan Kiszka out_err: 1533c54f0d6aSDavid Hildenbrand free_page((unsigned long)kvm->arch.sie_page2); 153440f5b735SDominik Dingel debug_unregister(kvm->arch.dbf); 15357d43bafcSEugene (jno) Dvurechenski sca_dispose(kvm); 153678f26131SChristian Borntraeger KVM_EVENT(3, "creation of vm failed: %d", rc); 1537d89f5effSJan Kiszka return rc; 1538b0c632dbSHeiko Carstens } 1539b0c632dbSHeiko Carstens 1540235539b4SLuiz Capitulino bool kvm_arch_has_vcpu_debugfs(void) 1541235539b4SLuiz Capitulino { 1542235539b4SLuiz Capitulino return false; 1543235539b4SLuiz Capitulino } 1544235539b4SLuiz Capitulino 1545235539b4SLuiz Capitulino int kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu) 1546235539b4SLuiz Capitulino { 1547235539b4SLuiz Capitulino return 0; 1548235539b4SLuiz Capitulino } 1549235539b4SLuiz Capitulino 1550d329c035SChristian Borntraeger void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 1551d329c035SChristian Borntraeger { 1552d329c035SChristian Borntraeger VCPU_EVENT(vcpu, 3, "%s", "free cpu"); 1553ade38c31SCornelia Huck trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id); 155467335e63SChristian Borntraeger kvm_s390_clear_local_irqs(vcpu); 15553c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 1556bc784cceSEugene (jno) Dvurechenski if (!kvm_is_ucontrol(vcpu->kvm)) 1557a6e2f683SEugene (jno) Dvurechenski sca_del_vcpu(vcpu); 155827e0393fSCarsten Otte 155927e0393fSCarsten Otte if (kvm_is_ucontrol(vcpu->kvm)) 15606ea427bbSMartin Schwidefsky gmap_remove(vcpu->arch.gmap); 156127e0393fSCarsten Otte 1562e6db1d61SDominik Dingel if (vcpu->kvm->arch.use_cmma) 1563b31605c1SDominik Dingel kvm_s390_vcpu_unsetup_cmma(vcpu); 1564d329c035SChristian Borntraeger free_page((unsigned long)(vcpu->arch.sie_block)); 1565b31288faSKonstantin Weitz 15666692cef3SChristian Borntraeger kvm_vcpu_uninit(vcpu); 1567b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 1568d329c035SChristian Borntraeger } 1569d329c035SChristian Borntraeger 1570d329c035SChristian Borntraeger static void kvm_free_vcpus(struct kvm *kvm) 1571d329c035SChristian Borntraeger { 1572d329c035SChristian Borntraeger unsigned int i; 1573988a2caeSGleb Natapov struct kvm_vcpu *vcpu; 1574d329c035SChristian Borntraeger 1575988a2caeSGleb Natapov kvm_for_each_vcpu(i, vcpu, kvm) 1576988a2caeSGleb Natapov kvm_arch_vcpu_destroy(vcpu); 1577988a2caeSGleb Natapov 1578988a2caeSGleb Natapov mutex_lock(&kvm->lock); 1579988a2caeSGleb Natapov for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 1580d329c035SChristian Borntraeger kvm->vcpus[i] = NULL; 1581988a2caeSGleb Natapov 1582988a2caeSGleb Natapov atomic_set(&kvm->online_vcpus, 0); 1583988a2caeSGleb Natapov mutex_unlock(&kvm->lock); 1584d329c035SChristian Borntraeger } 1585d329c035SChristian Borntraeger 1586b0c632dbSHeiko Carstens void kvm_arch_destroy_vm(struct kvm *kvm) 1587b0c632dbSHeiko Carstens { 1588d329c035SChristian Borntraeger kvm_free_vcpus(kvm); 15897d43bafcSEugene (jno) Dvurechenski sca_dispose(kvm); 1590d329c035SChristian Borntraeger debug_unregister(kvm->arch.dbf); 1591c54f0d6aSDavid Hildenbrand free_page((unsigned long)kvm->arch.sie_page2); 159227e0393fSCarsten Otte if (!kvm_is_ucontrol(kvm)) 15936ea427bbSMartin Schwidefsky gmap_remove(kvm->arch.gmap); 1594841b91c5SCornelia Huck kvm_s390_destroy_adapters(kvm); 159567335e63SChristian Borntraeger kvm_s390_clear_float_irqs(kvm); 1596a3508fbeSDavid Hildenbrand kvm_s390_vsie_destroy(kvm); 15978335713aSChristian Borntraeger KVM_EVENT(3, "vm 0x%pK destroyed", kvm); 1598b0c632dbSHeiko Carstens } 1599b0c632dbSHeiko Carstens 1600b0c632dbSHeiko Carstens /* Section: vcpu related */ 1601dafd032aSDominik Dingel static int __kvm_ucontrol_vcpu_init(struct kvm_vcpu *vcpu) 1602b0c632dbSHeiko Carstens { 16036ea427bbSMartin Schwidefsky vcpu->arch.gmap = gmap_create(current->mm, -1UL); 160427e0393fSCarsten Otte if (!vcpu->arch.gmap) 160527e0393fSCarsten Otte return -ENOMEM; 16062c70fe44SChristian Borntraeger vcpu->arch.gmap->private = vcpu->kvm; 1607dafd032aSDominik Dingel 160827e0393fSCarsten Otte return 0; 160927e0393fSCarsten Otte } 161027e0393fSCarsten Otte 1611a6e2f683SEugene (jno) Dvurechenski static void sca_del_vcpu(struct kvm_vcpu *vcpu) 1612a6e2f683SEugene (jno) Dvurechenski { 1613a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) 1614a6940674SDavid Hildenbrand return; 16155e044315SEugene (jno) Dvurechenski read_lock(&vcpu->kvm->arch.sca_lock); 16167d43bafcSEugene (jno) Dvurechenski if (vcpu->kvm->arch.use_esca) { 16177d43bafcSEugene (jno) Dvurechenski struct esca_block *sca = vcpu->kvm->arch.sca; 16187d43bafcSEugene (jno) Dvurechenski 16197d43bafcSEugene (jno) Dvurechenski clear_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn); 16207d43bafcSEugene (jno) Dvurechenski sca->cpu[vcpu->vcpu_id].sda = 0; 16217d43bafcSEugene (jno) Dvurechenski } else { 1622bc784cceSEugene (jno) Dvurechenski struct bsca_block *sca = vcpu->kvm->arch.sca; 1623a6e2f683SEugene (jno) Dvurechenski 1624a6e2f683SEugene (jno) Dvurechenski clear_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn); 1625a6e2f683SEugene (jno) Dvurechenski sca->cpu[vcpu->vcpu_id].sda = 0; 1626a6e2f683SEugene (jno) Dvurechenski } 16275e044315SEugene (jno) Dvurechenski read_unlock(&vcpu->kvm->arch.sca_lock); 16287d43bafcSEugene (jno) Dvurechenski } 1629a6e2f683SEugene (jno) Dvurechenski 1630eaa78f34SDavid Hildenbrand static void sca_add_vcpu(struct kvm_vcpu *vcpu) 1631a6e2f683SEugene (jno) Dvurechenski { 1632a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) { 1633a6940674SDavid Hildenbrand struct bsca_block *sca = vcpu->kvm->arch.sca; 1634a6940674SDavid Hildenbrand 1635a6940674SDavid Hildenbrand /* we still need the basic sca for the ipte control */ 1636a6940674SDavid Hildenbrand vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 1637a6940674SDavid Hildenbrand vcpu->arch.sie_block->scaol = (__u32)(__u64)sca; 1638a6940674SDavid Hildenbrand } 1639eaa78f34SDavid Hildenbrand read_lock(&vcpu->kvm->arch.sca_lock); 1640eaa78f34SDavid Hildenbrand if (vcpu->kvm->arch.use_esca) { 1641eaa78f34SDavid Hildenbrand struct esca_block *sca = vcpu->kvm->arch.sca; 16427d43bafcSEugene (jno) Dvurechenski 1643eaa78f34SDavid Hildenbrand sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block; 16447d43bafcSEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 16457d43bafcSEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = (__u32)(__u64)sca & ~0x3fU; 164625508824SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= 0x04U; 1647eaa78f34SDavid Hildenbrand set_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn); 16487d43bafcSEugene (jno) Dvurechenski } else { 1649eaa78f34SDavid Hildenbrand struct bsca_block *sca = vcpu->kvm->arch.sca; 1650a6e2f683SEugene (jno) Dvurechenski 1651eaa78f34SDavid Hildenbrand sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block; 1652a6e2f683SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 1653a6e2f683SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = (__u32)(__u64)sca; 1654eaa78f34SDavid Hildenbrand set_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn); 1655a6e2f683SEugene (jno) Dvurechenski } 1656eaa78f34SDavid Hildenbrand read_unlock(&vcpu->kvm->arch.sca_lock); 16575e044315SEugene (jno) Dvurechenski } 16585e044315SEugene (jno) Dvurechenski 16595e044315SEugene (jno) Dvurechenski /* Basic SCA to Extended SCA data copy routines */ 16605e044315SEugene (jno) Dvurechenski static inline void sca_copy_entry(struct esca_entry *d, struct bsca_entry *s) 16615e044315SEugene (jno) Dvurechenski { 16625e044315SEugene (jno) Dvurechenski d->sda = s->sda; 16635e044315SEugene (jno) Dvurechenski d->sigp_ctrl.c = s->sigp_ctrl.c; 16645e044315SEugene (jno) Dvurechenski d->sigp_ctrl.scn = s->sigp_ctrl.scn; 16655e044315SEugene (jno) Dvurechenski } 16665e044315SEugene (jno) Dvurechenski 16675e044315SEugene (jno) Dvurechenski static void sca_copy_b_to_e(struct esca_block *d, struct bsca_block *s) 16685e044315SEugene (jno) Dvurechenski { 16695e044315SEugene (jno) Dvurechenski int i; 16705e044315SEugene (jno) Dvurechenski 16715e044315SEugene (jno) Dvurechenski d->ipte_control = s->ipte_control; 16725e044315SEugene (jno) Dvurechenski d->mcn[0] = s->mcn; 16735e044315SEugene (jno) Dvurechenski for (i = 0; i < KVM_S390_BSCA_CPU_SLOTS; i++) 16745e044315SEugene (jno) Dvurechenski sca_copy_entry(&d->cpu[i], &s->cpu[i]); 16755e044315SEugene (jno) Dvurechenski } 16765e044315SEugene (jno) Dvurechenski 16775e044315SEugene (jno) Dvurechenski static int sca_switch_to_extended(struct kvm *kvm) 16785e044315SEugene (jno) Dvurechenski { 16795e044315SEugene (jno) Dvurechenski struct bsca_block *old_sca = kvm->arch.sca; 16805e044315SEugene (jno) Dvurechenski struct esca_block *new_sca; 16815e044315SEugene (jno) Dvurechenski struct kvm_vcpu *vcpu; 16825e044315SEugene (jno) Dvurechenski unsigned int vcpu_idx; 16835e044315SEugene (jno) Dvurechenski u32 scaol, scaoh; 16845e044315SEugene (jno) Dvurechenski 16855e044315SEugene (jno) Dvurechenski new_sca = alloc_pages_exact(sizeof(*new_sca), GFP_KERNEL|__GFP_ZERO); 16865e044315SEugene (jno) Dvurechenski if (!new_sca) 16875e044315SEugene (jno) Dvurechenski return -ENOMEM; 16885e044315SEugene (jno) Dvurechenski 16895e044315SEugene (jno) Dvurechenski scaoh = (u32)((u64)(new_sca) >> 32); 16905e044315SEugene (jno) Dvurechenski scaol = (u32)(u64)(new_sca) & ~0x3fU; 16915e044315SEugene (jno) Dvurechenski 16925e044315SEugene (jno) Dvurechenski kvm_s390_vcpu_block_all(kvm); 16935e044315SEugene (jno) Dvurechenski write_lock(&kvm->arch.sca_lock); 16945e044315SEugene (jno) Dvurechenski 16955e044315SEugene (jno) Dvurechenski sca_copy_b_to_e(new_sca, old_sca); 16965e044315SEugene (jno) Dvurechenski 16975e044315SEugene (jno) Dvurechenski kvm_for_each_vcpu(vcpu_idx, vcpu, kvm) { 16985e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = scaoh; 16995e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = scaol; 17005e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->ecb2 |= 0x04U; 17015e044315SEugene (jno) Dvurechenski } 17025e044315SEugene (jno) Dvurechenski kvm->arch.sca = new_sca; 17035e044315SEugene (jno) Dvurechenski kvm->arch.use_esca = 1; 17045e044315SEugene (jno) Dvurechenski 17055e044315SEugene (jno) Dvurechenski write_unlock(&kvm->arch.sca_lock); 17065e044315SEugene (jno) Dvurechenski kvm_s390_vcpu_unblock_all(kvm); 17075e044315SEugene (jno) Dvurechenski 17085e044315SEugene (jno) Dvurechenski free_page((unsigned long)old_sca); 17095e044315SEugene (jno) Dvurechenski 17108335713aSChristian Borntraeger VM_EVENT(kvm, 2, "Switched to ESCA (0x%pK -> 0x%pK)", 17118335713aSChristian Borntraeger old_sca, kvm->arch.sca); 17125e044315SEugene (jno) Dvurechenski return 0; 17137d43bafcSEugene (jno) Dvurechenski } 1714a6e2f683SEugene (jno) Dvurechenski 1715a6e2f683SEugene (jno) Dvurechenski static int sca_can_add_vcpu(struct kvm *kvm, unsigned int id) 1716a6e2f683SEugene (jno) Dvurechenski { 17175e044315SEugene (jno) Dvurechenski int rc; 17185e044315SEugene (jno) Dvurechenski 1719a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) { 1720a6940674SDavid Hildenbrand if (id < KVM_MAX_VCPUS) 1721a6940674SDavid Hildenbrand return true; 1722a6940674SDavid Hildenbrand return false; 1723a6940674SDavid Hildenbrand } 17245e044315SEugene (jno) Dvurechenski if (id < KVM_S390_BSCA_CPU_SLOTS) 17255e044315SEugene (jno) Dvurechenski return true; 172676a6dd72SDavid Hildenbrand if (!sclp.has_esca || !sclp.has_64bscao) 17275e044315SEugene (jno) Dvurechenski return false; 17285e044315SEugene (jno) Dvurechenski 17295e044315SEugene (jno) Dvurechenski mutex_lock(&kvm->lock); 17305e044315SEugene (jno) Dvurechenski rc = kvm->arch.use_esca ? 0 : sca_switch_to_extended(kvm); 17315e044315SEugene (jno) Dvurechenski mutex_unlock(&kvm->lock); 17325e044315SEugene (jno) Dvurechenski 17335e044315SEugene (jno) Dvurechenski return rc == 0 && id < KVM_S390_ESCA_CPU_SLOTS; 1734a6e2f683SEugene (jno) Dvurechenski } 1735a6e2f683SEugene (jno) Dvurechenski 1736dafd032aSDominik Dingel int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 1737dafd032aSDominik Dingel { 1738dafd032aSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 1739dafd032aSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 174059674c1aSChristian Borntraeger vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX | 174159674c1aSChristian Borntraeger KVM_SYNC_GPRS | 17429eed0735SChristian Borntraeger KVM_SYNC_ACRS | 1743b028ee3eSDavid Hildenbrand KVM_SYNC_CRS | 1744b028ee3eSDavid Hildenbrand KVM_SYNC_ARCH0 | 1745b028ee3eSDavid Hildenbrand KVM_SYNC_PFAULT; 174675a4615cSJulius Niedworok kvm_s390_set_prefix(vcpu, 0); 1747c6e5f166SFan Zhang if (test_kvm_facility(vcpu->kvm, 64)) 1748c6e5f166SFan Zhang vcpu->run->kvm_valid_regs |= KVM_SYNC_RICCB; 1749f6aa6dc4SDavid Hildenbrand /* fprs can be synchronized via vrs, even if the guest has no vx. With 1750f6aa6dc4SDavid Hildenbrand * MACHINE_HAS_VX, (load|store)_fpu_regs() will work with vrs format. 1751f6aa6dc4SDavid Hildenbrand */ 1752f6aa6dc4SDavid Hildenbrand if (MACHINE_HAS_VX) 175368c55750SEric Farman vcpu->run->kvm_valid_regs |= KVM_SYNC_VRS; 17546fd8e67dSDavid Hildenbrand else 17556fd8e67dSDavid Hildenbrand vcpu->run->kvm_valid_regs |= KVM_SYNC_FPRS; 1756dafd032aSDominik Dingel 1757dafd032aSDominik Dingel if (kvm_is_ucontrol(vcpu->kvm)) 1758dafd032aSDominik Dingel return __kvm_ucontrol_vcpu_init(vcpu); 1759dafd032aSDominik Dingel 1760b0c632dbSHeiko Carstens return 0; 1761b0c632dbSHeiko Carstens } 1762b0c632dbSHeiko Carstens 1763db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 1764db0758b2SDavid Hildenbrand static void __start_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1765db0758b2SDavid Hildenbrand { 1766db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_start != 0); 17679c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 1768db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = get_tod_clock_fast(); 17699c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 1770db0758b2SDavid Hildenbrand } 1771db0758b2SDavid Hildenbrand 1772db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 1773db0758b2SDavid Hildenbrand static void __stop_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1774db0758b2SDavid Hildenbrand { 1775db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_start == 0); 17769c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 1777db0758b2SDavid Hildenbrand vcpu->arch.sie_block->cputm -= get_tod_clock_fast() - vcpu->arch.cputm_start; 1778db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = 0; 17799c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 1780db0758b2SDavid Hildenbrand } 1781db0758b2SDavid Hildenbrand 1782db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 1783db0758b2SDavid Hildenbrand static void __enable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1784db0758b2SDavid Hildenbrand { 1785db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_enabled); 1786db0758b2SDavid Hildenbrand vcpu->arch.cputm_enabled = true; 1787db0758b2SDavid Hildenbrand __start_cpu_timer_accounting(vcpu); 1788db0758b2SDavid Hildenbrand } 1789db0758b2SDavid Hildenbrand 1790db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 1791db0758b2SDavid Hildenbrand static void __disable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1792db0758b2SDavid Hildenbrand { 1793db0758b2SDavid Hildenbrand WARN_ON_ONCE(!vcpu->arch.cputm_enabled); 1794db0758b2SDavid Hildenbrand __stop_cpu_timer_accounting(vcpu); 1795db0758b2SDavid Hildenbrand vcpu->arch.cputm_enabled = false; 1796db0758b2SDavid Hildenbrand } 1797db0758b2SDavid Hildenbrand 1798db0758b2SDavid Hildenbrand static void enable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1799db0758b2SDavid Hildenbrand { 1800db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 1801db0758b2SDavid Hildenbrand __enable_cpu_timer_accounting(vcpu); 1802db0758b2SDavid Hildenbrand preempt_enable(); 1803db0758b2SDavid Hildenbrand } 1804db0758b2SDavid Hildenbrand 1805db0758b2SDavid Hildenbrand static void disable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1806db0758b2SDavid Hildenbrand { 1807db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 1808db0758b2SDavid Hildenbrand __disable_cpu_timer_accounting(vcpu); 1809db0758b2SDavid Hildenbrand preempt_enable(); 1810db0758b2SDavid Hildenbrand } 1811db0758b2SDavid Hildenbrand 18124287f247SDavid Hildenbrand /* set the cpu timer - may only be called from the VCPU thread itself */ 18134287f247SDavid Hildenbrand void kvm_s390_set_cpu_timer(struct kvm_vcpu *vcpu, __u64 cputm) 18144287f247SDavid Hildenbrand { 1815db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 18169c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 1817db0758b2SDavid Hildenbrand if (vcpu->arch.cputm_enabled) 1818db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = get_tod_clock_fast(); 18194287f247SDavid Hildenbrand vcpu->arch.sie_block->cputm = cputm; 18209c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 1821db0758b2SDavid Hildenbrand preempt_enable(); 18224287f247SDavid Hildenbrand } 18234287f247SDavid Hildenbrand 1824db0758b2SDavid Hildenbrand /* update and get the cpu timer - can also be called from other VCPU threads */ 18254287f247SDavid Hildenbrand __u64 kvm_s390_get_cpu_timer(struct kvm_vcpu *vcpu) 18264287f247SDavid Hildenbrand { 18279c23a131SDavid Hildenbrand unsigned int seq; 1828db0758b2SDavid Hildenbrand __u64 value; 1829db0758b2SDavid Hildenbrand 1830db0758b2SDavid Hildenbrand if (unlikely(!vcpu->arch.cputm_enabled)) 18314287f247SDavid Hildenbrand return vcpu->arch.sie_block->cputm; 1832db0758b2SDavid Hildenbrand 18339c23a131SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 18349c23a131SDavid Hildenbrand do { 18359c23a131SDavid Hildenbrand seq = raw_read_seqcount(&vcpu->arch.cputm_seqcount); 18369c23a131SDavid Hildenbrand /* 18379c23a131SDavid Hildenbrand * If the writer would ever execute a read in the critical 18389c23a131SDavid Hildenbrand * section, e.g. in irq context, we have a deadlock. 18399c23a131SDavid Hildenbrand */ 18409c23a131SDavid Hildenbrand WARN_ON_ONCE((seq & 1) && smp_processor_id() == vcpu->cpu); 1841db0758b2SDavid Hildenbrand value = vcpu->arch.sie_block->cputm; 18429c23a131SDavid Hildenbrand /* if cputm_start is 0, accounting is being started/stopped */ 18439c23a131SDavid Hildenbrand if (likely(vcpu->arch.cputm_start)) 1844db0758b2SDavid Hildenbrand value -= get_tod_clock_fast() - vcpu->arch.cputm_start; 18459c23a131SDavid Hildenbrand } while (read_seqcount_retry(&vcpu->arch.cputm_seqcount, seq & ~1)); 18469c23a131SDavid Hildenbrand preempt_enable(); 1847db0758b2SDavid Hildenbrand return value; 18484287f247SDavid Hildenbrand } 18494287f247SDavid Hildenbrand 1850b0c632dbSHeiko Carstens void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 1851b0c632dbSHeiko Carstens { 18529977e886SHendrik Brueckner 185337d9df98SDavid Hildenbrand gmap_enable(vcpu->arch.enabled_gmap); 1854805de8f4SPeter Zijlstra atomic_or(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 18555ebda316SDavid Hildenbrand if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu)) 1856db0758b2SDavid Hildenbrand __start_cpu_timer_accounting(vcpu); 185701a745acSDavid Hildenbrand vcpu->cpu = cpu; 1858b0c632dbSHeiko Carstens } 1859b0c632dbSHeiko Carstens 1860b0c632dbSHeiko Carstens void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 1861b0c632dbSHeiko Carstens { 186201a745acSDavid Hildenbrand vcpu->cpu = -1; 18635ebda316SDavid Hildenbrand if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu)) 1864db0758b2SDavid Hildenbrand __stop_cpu_timer_accounting(vcpu); 1865805de8f4SPeter Zijlstra atomic_andnot(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 186637d9df98SDavid Hildenbrand vcpu->arch.enabled_gmap = gmap_get_enabled(); 186737d9df98SDavid Hildenbrand gmap_disable(vcpu->arch.enabled_gmap); 18689977e886SHendrik Brueckner 1869b0c632dbSHeiko Carstens } 1870b0c632dbSHeiko Carstens 1871b0c632dbSHeiko Carstens static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu) 1872b0c632dbSHeiko Carstens { 1873b0c632dbSHeiko Carstens /* this equals initial cpu reset in pop, but we don't switch to ESA */ 1874b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.mask = 0UL; 1875b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.addr = 0UL; 18768d26cf7bSChristian Borntraeger kvm_s390_set_prefix(vcpu, 0); 18774287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, 0); 1878b0c632dbSHeiko Carstens vcpu->arch.sie_block->ckc = 0UL; 1879b0c632dbSHeiko Carstens vcpu->arch.sie_block->todpr = 0; 1880b0c632dbSHeiko Carstens memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64)); 1881b0c632dbSHeiko Carstens vcpu->arch.sie_block->gcr[0] = 0xE0UL; 1882b0c632dbSHeiko Carstens vcpu->arch.sie_block->gcr[14] = 0xC2000000UL; 18839abc2a08SDavid Hildenbrand /* make sure the new fpc will be lazily loaded */ 18849abc2a08SDavid Hildenbrand save_fpu_regs(); 18859abc2a08SDavid Hildenbrand current->thread.fpu.fpc = 0; 1886b0c632dbSHeiko Carstens vcpu->arch.sie_block->gbea = 1; 1887672550fbSChristian Borntraeger vcpu->arch.sie_block->pp = 0; 18883c038e6bSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 18893c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 18906352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) 18916852d7b6SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 18922ed10cc1SJens Freimann kvm_s390_clear_local_irqs(vcpu); 1893b0c632dbSHeiko Carstens } 1894b0c632dbSHeiko Carstens 189531928aa5SDominik Dingel void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu) 189642897d86SMarcelo Tosatti { 189772f25020SJason J. Herne mutex_lock(&vcpu->kvm->lock); 1898fdf03650SFan Zhang preempt_disable(); 189972f25020SJason J. Herne vcpu->arch.sie_block->epoch = vcpu->kvm->arch.epoch; 1900fdf03650SFan Zhang preempt_enable(); 190172f25020SJason J. Herne mutex_unlock(&vcpu->kvm->lock); 190225508824SDavid Hildenbrand if (!kvm_is_ucontrol(vcpu->kvm)) { 1903dafd032aSDominik Dingel vcpu->arch.gmap = vcpu->kvm->arch.gmap; 1904eaa78f34SDavid Hildenbrand sca_add_vcpu(vcpu); 190525508824SDavid Hildenbrand } 19066502a34cSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 74) || vcpu->kvm->arch.user_instr0) 19076502a34cSDavid Hildenbrand vcpu->arch.sie_block->ictl |= ICTL_OPEREXC; 190837d9df98SDavid Hildenbrand /* make vcpu_load load the right gmap on the first trigger */ 190937d9df98SDavid Hildenbrand vcpu->arch.enabled_gmap = vcpu->arch.gmap; 191042897d86SMarcelo Tosatti } 191142897d86SMarcelo Tosatti 19125102ee87STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu) 19135102ee87STony Krowiak { 19149d8d5786SMichael Mueller if (!test_kvm_facility(vcpu->kvm, 76)) 19155102ee87STony Krowiak return; 19165102ee87STony Krowiak 1917a374e892STony Krowiak vcpu->arch.sie_block->ecb3 &= ~(ECB3_AES | ECB3_DEA); 1918a374e892STony Krowiak 1919a374e892STony Krowiak if (vcpu->kvm->arch.crypto.aes_kw) 1920a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_AES; 1921a374e892STony Krowiak if (vcpu->kvm->arch.crypto.dea_kw) 1922a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_DEA; 1923a374e892STony Krowiak 19245102ee87STony Krowiak vcpu->arch.sie_block->crycbd = vcpu->kvm->arch.crypto.crycbd; 19255102ee87STony Krowiak } 19265102ee87STony Krowiak 1927b31605c1SDominik Dingel void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu) 1928b31605c1SDominik Dingel { 1929b31605c1SDominik Dingel free_page(vcpu->arch.sie_block->cbrlo); 1930b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = 0; 1931b31605c1SDominik Dingel } 1932b31605c1SDominik Dingel 1933b31605c1SDominik Dingel int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu) 1934b31605c1SDominik Dingel { 1935b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = get_zeroed_page(GFP_KERNEL); 1936b31605c1SDominik Dingel if (!vcpu->arch.sie_block->cbrlo) 1937b31605c1SDominik Dingel return -ENOMEM; 1938b31605c1SDominik Dingel 1939b31605c1SDominik Dingel vcpu->arch.sie_block->ecb2 |= 0x80; 1940b31605c1SDominik Dingel vcpu->arch.sie_block->ecb2 &= ~0x08; 1941b31605c1SDominik Dingel return 0; 1942b31605c1SDominik Dingel } 1943b31605c1SDominik Dingel 194491520f1aSMichael Mueller static void kvm_s390_vcpu_setup_model(struct kvm_vcpu *vcpu) 194591520f1aSMichael Mueller { 194691520f1aSMichael Mueller struct kvm_s390_cpu_model *model = &vcpu->kvm->arch.model; 194791520f1aSMichael Mueller 194891520f1aSMichael Mueller vcpu->arch.sie_block->ibc = model->ibc; 194980bc79dcSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 7)) 1950c54f0d6aSDavid Hildenbrand vcpu->arch.sie_block->fac = (u32)(u64) model->fac_list; 195191520f1aSMichael Mueller } 195291520f1aSMichael Mueller 1953b0c632dbSHeiko Carstens int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) 1954b0c632dbSHeiko Carstens { 1955b31605c1SDominik Dingel int rc = 0; 1956b31288faSKonstantin Weitz 19579e6dabefSCornelia Huck atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH | 19589e6dabefSCornelia Huck CPUSTAT_SM | 1959a4a4f191SGuenther Hutzl CPUSTAT_STOPPED); 1960a4a4f191SGuenther Hutzl 196153df84f8SGuenther Hutzl if (test_kvm_facility(vcpu->kvm, 78)) 1962805de8f4SPeter Zijlstra atomic_or(CPUSTAT_GED2, &vcpu->arch.sie_block->cpuflags); 196353df84f8SGuenther Hutzl else if (test_kvm_facility(vcpu->kvm, 8)) 1964805de8f4SPeter Zijlstra atomic_or(CPUSTAT_GED, &vcpu->arch.sie_block->cpuflags); 1965a4a4f191SGuenther Hutzl 196691520f1aSMichael Mueller kvm_s390_vcpu_setup_model(vcpu); 196791520f1aSMichael Mueller 1968bdab09f3SDavid Hildenbrand /* pgste_set_pte has special handling for !MACHINE_HAS_ESOP */ 1969bdab09f3SDavid Hildenbrand if (MACHINE_HAS_ESOP) 1970bdab09f3SDavid Hildenbrand vcpu->arch.sie_block->ecb |= 0x02; 1971bd50e8ecSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 9)) 1972bd50e8ecSDavid Hildenbrand vcpu->arch.sie_block->ecb |= 0x04; 1973f597d24eSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 73)) 19747feb6bb8SMichael Mueller vcpu->arch.sie_block->ecb |= 0x10; 19757feb6bb8SMichael Mueller 1976873b425eSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 8) && sclp.has_pfmfi) 1977d6af0b49SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= 0x08; 1978cd1836f5SJanosch Frank if (test_kvm_facility(vcpu->kvm, 130)) 1979cd1836f5SJanosch Frank vcpu->arch.sie_block->ecb2 |= 0x20; 198048ee7d3aSDavid Hildenbrand vcpu->arch.sie_block->eca = 0x1002000U; 198148ee7d3aSDavid Hildenbrand if (sclp.has_cei) 198248ee7d3aSDavid Hildenbrand vcpu->arch.sie_block->eca |= 0x80000000U; 198311ad65b7SDavid Hildenbrand if (sclp.has_ib) 198411ad65b7SDavid Hildenbrand vcpu->arch.sie_block->eca |= 0x40000000U; 198537c5f6c8SDavid Hildenbrand if (sclp.has_siif) 1986217a4406SHeiko Carstens vcpu->arch.sie_block->eca |= 1; 198737c5f6c8SDavid Hildenbrand if (sclp.has_sigpif) 1988ea5f4969SDavid Hildenbrand vcpu->arch.sie_block->eca |= 0x10000000U; 198918280d8bSMichael Mueller if (test_kvm_facility(vcpu->kvm, 129)) { 199013211ea7SEric Farman vcpu->arch.sie_block->eca |= 0x00020000; 199113211ea7SEric Farman vcpu->arch.sie_block->ecd |= 0x20000000; 199213211ea7SEric Farman } 1993c6e5f166SFan Zhang vcpu->arch.sie_block->riccbd = (unsigned long) &vcpu->run->s.regs.riccb; 1994492d8642SThomas Huth vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE; 19955a5e6536SMatthew Rosato 1996e6db1d61SDominik Dingel if (vcpu->kvm->arch.use_cmma) { 1997b31605c1SDominik Dingel rc = kvm_s390_vcpu_setup_cmma(vcpu); 1998b31605c1SDominik Dingel if (rc) 1999b31605c1SDominik Dingel return rc; 2000b31288faSKonstantin Weitz } 20010ac96cafSDavid Hildenbrand hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 2002ca872302SChristian Borntraeger vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup; 20039d8d5786SMichael Mueller 20045102ee87STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 20055102ee87STony Krowiak 2006b31605c1SDominik Dingel return rc; 2007b0c632dbSHeiko Carstens } 2008b0c632dbSHeiko Carstens 2009b0c632dbSHeiko Carstens struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, 2010b0c632dbSHeiko Carstens unsigned int id) 2011b0c632dbSHeiko Carstens { 20124d47555aSCarsten Otte struct kvm_vcpu *vcpu; 20137feb6bb8SMichael Mueller struct sie_page *sie_page; 20144d47555aSCarsten Otte int rc = -EINVAL; 2015b0c632dbSHeiko Carstens 20164215825eSDavid Hildenbrand if (!kvm_is_ucontrol(kvm) && !sca_can_add_vcpu(kvm, id)) 20174d47555aSCarsten Otte goto out; 20184d47555aSCarsten Otte 20194d47555aSCarsten Otte rc = -ENOMEM; 20204d47555aSCarsten Otte 2021b110feafSMichael Mueller vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL); 2022b0c632dbSHeiko Carstens if (!vcpu) 20234d47555aSCarsten Otte goto out; 2024b0c632dbSHeiko Carstens 20257feb6bb8SMichael Mueller sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL); 20267feb6bb8SMichael Mueller if (!sie_page) 2027b0c632dbSHeiko Carstens goto out_free_cpu; 2028b0c632dbSHeiko Carstens 20297feb6bb8SMichael Mueller vcpu->arch.sie_block = &sie_page->sie_block; 20307feb6bb8SMichael Mueller vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb; 20317feb6bb8SMichael Mueller 2032efed1104SDavid Hildenbrand /* the real guest size will always be smaller than msl */ 2033efed1104SDavid Hildenbrand vcpu->arch.sie_block->mso = 0; 2034efed1104SDavid Hildenbrand vcpu->arch.sie_block->msl = sclp.hamax; 2035efed1104SDavid Hildenbrand 2036b0c632dbSHeiko Carstens vcpu->arch.sie_block->icpua = id; 2037ba5c1e9bSCarsten Otte spin_lock_init(&vcpu->arch.local_int.lock); 2038ba5c1e9bSCarsten Otte vcpu->arch.local_int.float_int = &kvm->arch.float_int; 2039d0321a24SChristian Borntraeger vcpu->arch.local_int.wq = &vcpu->wq; 20405288fbf0SChristian Borntraeger vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags; 20419c23a131SDavid Hildenbrand seqcount_init(&vcpu->arch.cputm_seqcount); 2042ba5c1e9bSCarsten Otte 2043b0c632dbSHeiko Carstens rc = kvm_vcpu_init(vcpu, kvm, id); 2044b0c632dbSHeiko Carstens if (rc) 20459abc2a08SDavid Hildenbrand goto out_free_sie_block; 20468335713aSChristian Borntraeger VM_EVENT(kvm, 3, "create cpu %d at 0x%pK, sie block at 0x%pK", id, vcpu, 2047b0c632dbSHeiko Carstens vcpu->arch.sie_block); 2048ade38c31SCornelia Huck trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block); 2049b0c632dbSHeiko Carstens 2050b0c632dbSHeiko Carstens return vcpu; 20517b06bf2fSWei Yongjun out_free_sie_block: 20527b06bf2fSWei Yongjun free_page((unsigned long)(vcpu->arch.sie_block)); 2053b0c632dbSHeiko Carstens out_free_cpu: 2054b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 20554d47555aSCarsten Otte out: 2056b0c632dbSHeiko Carstens return ERR_PTR(rc); 2057b0c632dbSHeiko Carstens } 2058b0c632dbSHeiko Carstens 2059b0c632dbSHeiko Carstens int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu) 2060b0c632dbSHeiko Carstens { 20619a022067SDavid Hildenbrand return kvm_s390_vcpu_has_irq(vcpu, 0); 2062b0c632dbSHeiko Carstens } 2063b0c632dbSHeiko Carstens 206427406cd5SChristian Borntraeger void kvm_s390_vcpu_block(struct kvm_vcpu *vcpu) 206549b99e1eSChristian Borntraeger { 2066805de8f4SPeter Zijlstra atomic_or(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 206761a6df54SDavid Hildenbrand exit_sie(vcpu); 206849b99e1eSChristian Borntraeger } 206949b99e1eSChristian Borntraeger 207027406cd5SChristian Borntraeger void kvm_s390_vcpu_unblock(struct kvm_vcpu *vcpu) 207149b99e1eSChristian Borntraeger { 2072805de8f4SPeter Zijlstra atomic_andnot(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 207349b99e1eSChristian Borntraeger } 207449b99e1eSChristian Borntraeger 20758e236546SChristian Borntraeger static void kvm_s390_vcpu_request(struct kvm_vcpu *vcpu) 20768e236546SChristian Borntraeger { 2077805de8f4SPeter Zijlstra atomic_or(PROG_REQUEST, &vcpu->arch.sie_block->prog20); 207861a6df54SDavid Hildenbrand exit_sie(vcpu); 20798e236546SChristian Borntraeger } 20808e236546SChristian Borntraeger 20818e236546SChristian Borntraeger static void kvm_s390_vcpu_request_handled(struct kvm_vcpu *vcpu) 20828e236546SChristian Borntraeger { 20839bf9fde2SJason J. Herne atomic_andnot(PROG_REQUEST, &vcpu->arch.sie_block->prog20); 20848e236546SChristian Borntraeger } 20858e236546SChristian Borntraeger 208649b99e1eSChristian Borntraeger /* 208749b99e1eSChristian Borntraeger * Kick a guest cpu out of SIE and wait until SIE is not running. 208849b99e1eSChristian Borntraeger * If the CPU is not running (e.g. waiting as idle) the function will 208949b99e1eSChristian Borntraeger * return immediately. */ 209049b99e1eSChristian Borntraeger void exit_sie(struct kvm_vcpu *vcpu) 209149b99e1eSChristian Borntraeger { 2092805de8f4SPeter Zijlstra atomic_or(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags); 209349b99e1eSChristian Borntraeger while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE) 209449b99e1eSChristian Borntraeger cpu_relax(); 209549b99e1eSChristian Borntraeger } 209649b99e1eSChristian Borntraeger 20978e236546SChristian Borntraeger /* Kick a guest cpu out of SIE to process a request synchronously */ 20988e236546SChristian Borntraeger void kvm_s390_sync_request(int req, struct kvm_vcpu *vcpu) 209949b99e1eSChristian Borntraeger { 21008e236546SChristian Borntraeger kvm_make_request(req, vcpu); 21018e236546SChristian Borntraeger kvm_s390_vcpu_request(vcpu); 210249b99e1eSChristian Borntraeger } 210349b99e1eSChristian Borntraeger 2104414d3b07SMartin Schwidefsky static void kvm_gmap_notifier(struct gmap *gmap, unsigned long start, 2105414d3b07SMartin Schwidefsky unsigned long end) 21062c70fe44SChristian Borntraeger { 21072c70fe44SChristian Borntraeger struct kvm *kvm = gmap->private; 21082c70fe44SChristian Borntraeger struct kvm_vcpu *vcpu; 2109414d3b07SMartin Schwidefsky unsigned long prefix; 2110414d3b07SMartin Schwidefsky int i; 21112c70fe44SChristian Borntraeger 211265d0b0d4SDavid Hildenbrand if (gmap_is_shadow(gmap)) 211365d0b0d4SDavid Hildenbrand return; 2114414d3b07SMartin Schwidefsky if (start >= 1UL << 31) 2115414d3b07SMartin Schwidefsky /* We are only interested in prefix pages */ 2116414d3b07SMartin Schwidefsky return; 21172c70fe44SChristian Borntraeger kvm_for_each_vcpu(i, vcpu, kvm) { 21182c70fe44SChristian Borntraeger /* match against both prefix pages */ 2119414d3b07SMartin Schwidefsky prefix = kvm_s390_get_prefix(vcpu); 2120414d3b07SMartin Schwidefsky if (prefix <= end && start <= prefix + 2*PAGE_SIZE - 1) { 2121414d3b07SMartin Schwidefsky VCPU_EVENT(vcpu, 2, "gmap notifier for %lx-%lx", 2122414d3b07SMartin Schwidefsky start, end); 21238e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_MMU_RELOAD, vcpu); 21242c70fe44SChristian Borntraeger } 21252c70fe44SChristian Borntraeger } 21262c70fe44SChristian Borntraeger } 21272c70fe44SChristian Borntraeger 2128b6d33834SChristoffer Dall int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu) 2129b6d33834SChristoffer Dall { 2130b6d33834SChristoffer Dall /* kvm common code refers to this, but never calls it */ 2131b6d33834SChristoffer Dall BUG(); 2132b6d33834SChristoffer Dall return 0; 2133b6d33834SChristoffer Dall } 2134b6d33834SChristoffer Dall 213514eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, 213614eebd91SCarsten Otte struct kvm_one_reg *reg) 213714eebd91SCarsten Otte { 213814eebd91SCarsten Otte int r = -EINVAL; 213914eebd91SCarsten Otte 214014eebd91SCarsten Otte switch (reg->id) { 214129b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 214229b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->todpr, 214329b7c71bSCarsten Otte (u32 __user *)reg->addr); 214429b7c71bSCarsten Otte break; 214529b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 214629b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->epoch, 214729b7c71bSCarsten Otte (u64 __user *)reg->addr); 214829b7c71bSCarsten Otte break; 214946a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 21504287f247SDavid Hildenbrand r = put_user(kvm_s390_get_cpu_timer(vcpu), 215146a6dd1cSJason J. herne (u64 __user *)reg->addr); 215246a6dd1cSJason J. herne break; 215346a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 215446a6dd1cSJason J. herne r = put_user(vcpu->arch.sie_block->ckc, 215546a6dd1cSJason J. herne (u64 __user *)reg->addr); 215646a6dd1cSJason J. herne break; 2157536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 2158536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_token, 2159536336c2SDominik Dingel (u64 __user *)reg->addr); 2160536336c2SDominik Dingel break; 2161536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 2162536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_compare, 2163536336c2SDominik Dingel (u64 __user *)reg->addr); 2164536336c2SDominik Dingel break; 2165536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 2166536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_select, 2167536336c2SDominik Dingel (u64 __user *)reg->addr); 2168536336c2SDominik Dingel break; 2169672550fbSChristian Borntraeger case KVM_REG_S390_PP: 2170672550fbSChristian Borntraeger r = put_user(vcpu->arch.sie_block->pp, 2171672550fbSChristian Borntraeger (u64 __user *)reg->addr); 2172672550fbSChristian Borntraeger break; 2173afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 2174afa45ff5SChristian Borntraeger r = put_user(vcpu->arch.sie_block->gbea, 2175afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 2176afa45ff5SChristian Borntraeger break; 217714eebd91SCarsten Otte default: 217814eebd91SCarsten Otte break; 217914eebd91SCarsten Otte } 218014eebd91SCarsten Otte 218114eebd91SCarsten Otte return r; 218214eebd91SCarsten Otte } 218314eebd91SCarsten Otte 218414eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, 218514eebd91SCarsten Otte struct kvm_one_reg *reg) 218614eebd91SCarsten Otte { 218714eebd91SCarsten Otte int r = -EINVAL; 21884287f247SDavid Hildenbrand __u64 val; 218914eebd91SCarsten Otte 219014eebd91SCarsten Otte switch (reg->id) { 219129b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 219229b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->todpr, 219329b7c71bSCarsten Otte (u32 __user *)reg->addr); 219429b7c71bSCarsten Otte break; 219529b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 219629b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->epoch, 219729b7c71bSCarsten Otte (u64 __user *)reg->addr); 219829b7c71bSCarsten Otte break; 219946a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 22004287f247SDavid Hildenbrand r = get_user(val, (u64 __user *)reg->addr); 22014287f247SDavid Hildenbrand if (!r) 22024287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, val); 220346a6dd1cSJason J. herne break; 220446a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 220546a6dd1cSJason J. herne r = get_user(vcpu->arch.sie_block->ckc, 220646a6dd1cSJason J. herne (u64 __user *)reg->addr); 220746a6dd1cSJason J. herne break; 2208536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 2209536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_token, 2210536336c2SDominik Dingel (u64 __user *)reg->addr); 22119fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 22129fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 2213536336c2SDominik Dingel break; 2214536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 2215536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_compare, 2216536336c2SDominik Dingel (u64 __user *)reg->addr); 2217536336c2SDominik Dingel break; 2218536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 2219536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_select, 2220536336c2SDominik Dingel (u64 __user *)reg->addr); 2221536336c2SDominik Dingel break; 2222672550fbSChristian Borntraeger case KVM_REG_S390_PP: 2223672550fbSChristian Borntraeger r = get_user(vcpu->arch.sie_block->pp, 2224672550fbSChristian Borntraeger (u64 __user *)reg->addr); 2225672550fbSChristian Borntraeger break; 2226afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 2227afa45ff5SChristian Borntraeger r = get_user(vcpu->arch.sie_block->gbea, 2228afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 2229afa45ff5SChristian Borntraeger break; 223014eebd91SCarsten Otte default: 223114eebd91SCarsten Otte break; 223214eebd91SCarsten Otte } 223314eebd91SCarsten Otte 223414eebd91SCarsten Otte return r; 223514eebd91SCarsten Otte } 2236b6d33834SChristoffer Dall 2237b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) 2238b0c632dbSHeiko Carstens { 2239b0c632dbSHeiko Carstens kvm_s390_vcpu_initial_reset(vcpu); 2240b0c632dbSHeiko Carstens return 0; 2241b0c632dbSHeiko Carstens } 2242b0c632dbSHeiko Carstens 2243b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 2244b0c632dbSHeiko Carstens { 22455a32c1afSChristian Borntraeger memcpy(&vcpu->run->s.regs.gprs, ®s->gprs, sizeof(regs->gprs)); 2246b0c632dbSHeiko Carstens return 0; 2247b0c632dbSHeiko Carstens } 2248b0c632dbSHeiko Carstens 2249b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 2250b0c632dbSHeiko Carstens { 22515a32c1afSChristian Borntraeger memcpy(®s->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs)); 2252b0c632dbSHeiko Carstens return 0; 2253b0c632dbSHeiko Carstens } 2254b0c632dbSHeiko Carstens 2255b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, 2256b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 2257b0c632dbSHeiko Carstens { 225859674c1aSChristian Borntraeger memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs)); 2259b0c632dbSHeiko Carstens memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs)); 2260b0c632dbSHeiko Carstens return 0; 2261b0c632dbSHeiko Carstens } 2262b0c632dbSHeiko Carstens 2263b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, 2264b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 2265b0c632dbSHeiko Carstens { 226659674c1aSChristian Borntraeger memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs)); 2267b0c632dbSHeiko Carstens memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs)); 2268b0c632dbSHeiko Carstens return 0; 2269b0c632dbSHeiko Carstens } 2270b0c632dbSHeiko Carstens 2271b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 2272b0c632dbSHeiko Carstens { 22734725c860SMartin Schwidefsky if (test_fp_ctl(fpu->fpc)) 22744725c860SMartin Schwidefsky return -EINVAL; 2275e1788bb9SChristian Borntraeger vcpu->run->s.regs.fpc = fpu->fpc; 22769abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) 2277a7d4b8f2SDavid Hildenbrand convert_fp_to_vx((__vector128 *) vcpu->run->s.regs.vrs, 2278a7d4b8f2SDavid Hildenbrand (freg_t *) fpu->fprs); 22799abc2a08SDavid Hildenbrand else 2280a7d4b8f2SDavid Hildenbrand memcpy(vcpu->run->s.regs.fprs, &fpu->fprs, sizeof(fpu->fprs)); 2281b0c632dbSHeiko Carstens return 0; 2282b0c632dbSHeiko Carstens } 2283b0c632dbSHeiko Carstens 2284b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 2285b0c632dbSHeiko Carstens { 22869abc2a08SDavid Hildenbrand /* make sure we have the latest values */ 22879abc2a08SDavid Hildenbrand save_fpu_regs(); 22889abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) 2289a7d4b8f2SDavid Hildenbrand convert_vx_to_fp((freg_t *) fpu->fprs, 2290a7d4b8f2SDavid Hildenbrand (__vector128 *) vcpu->run->s.regs.vrs); 22919abc2a08SDavid Hildenbrand else 2292a7d4b8f2SDavid Hildenbrand memcpy(fpu->fprs, vcpu->run->s.regs.fprs, sizeof(fpu->fprs)); 2293e1788bb9SChristian Borntraeger fpu->fpc = vcpu->run->s.regs.fpc; 2294b0c632dbSHeiko Carstens return 0; 2295b0c632dbSHeiko Carstens } 2296b0c632dbSHeiko Carstens 2297b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw) 2298b0c632dbSHeiko Carstens { 2299b0c632dbSHeiko Carstens int rc = 0; 2300b0c632dbSHeiko Carstens 23017a42fdc2SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 2302b0c632dbSHeiko Carstens rc = -EBUSY; 2303d7b0b5ebSCarsten Otte else { 2304d7b0b5ebSCarsten Otte vcpu->run->psw_mask = psw.mask; 2305d7b0b5ebSCarsten Otte vcpu->run->psw_addr = psw.addr; 2306d7b0b5ebSCarsten Otte } 2307b0c632dbSHeiko Carstens return rc; 2308b0c632dbSHeiko Carstens } 2309b0c632dbSHeiko Carstens 2310b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, 2311b0c632dbSHeiko Carstens struct kvm_translation *tr) 2312b0c632dbSHeiko Carstens { 2313b0c632dbSHeiko Carstens return -EINVAL; /* not implemented yet */ 2314b0c632dbSHeiko Carstens } 2315b0c632dbSHeiko Carstens 231627291e21SDavid Hildenbrand #define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \ 231727291e21SDavid Hildenbrand KVM_GUESTDBG_USE_HW_BP | \ 231827291e21SDavid Hildenbrand KVM_GUESTDBG_ENABLE) 231927291e21SDavid Hildenbrand 2320d0bfb940SJan Kiszka int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 2321d0bfb940SJan Kiszka struct kvm_guest_debug *dbg) 2322b0c632dbSHeiko Carstens { 232327291e21SDavid Hildenbrand int rc = 0; 232427291e21SDavid Hildenbrand 232527291e21SDavid Hildenbrand vcpu->guest_debug = 0; 232627291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 232727291e21SDavid Hildenbrand 23282de3bfc2SDavid Hildenbrand if (dbg->control & ~VALID_GUESTDBG_FLAGS) 232927291e21SDavid Hildenbrand return -EINVAL; 233089b5b4deSDavid Hildenbrand if (!sclp.has_gpere) 233189b5b4deSDavid Hildenbrand return -EINVAL; 233227291e21SDavid Hildenbrand 233327291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_ENABLE) { 233427291e21SDavid Hildenbrand vcpu->guest_debug = dbg->control; 233527291e21SDavid Hildenbrand /* enforce guest PER */ 2336805de8f4SPeter Zijlstra atomic_or(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags); 233727291e21SDavid Hildenbrand 233827291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_USE_HW_BP) 233927291e21SDavid Hildenbrand rc = kvm_s390_import_bp_data(vcpu, dbg); 234027291e21SDavid Hildenbrand } else { 2341805de8f4SPeter Zijlstra atomic_andnot(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags); 234227291e21SDavid Hildenbrand vcpu->arch.guestdbg.last_bp = 0; 234327291e21SDavid Hildenbrand } 234427291e21SDavid Hildenbrand 234527291e21SDavid Hildenbrand if (rc) { 234627291e21SDavid Hildenbrand vcpu->guest_debug = 0; 234727291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 2348805de8f4SPeter Zijlstra atomic_andnot(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags); 234927291e21SDavid Hildenbrand } 235027291e21SDavid Hildenbrand 235127291e21SDavid Hildenbrand return rc; 2352b0c632dbSHeiko Carstens } 2353b0c632dbSHeiko Carstens 235462d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 235562d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 235662d9f0dbSMarcelo Tosatti { 23576352e4d2SDavid Hildenbrand /* CHECK_STOP and LOAD are not supported yet */ 23586352e4d2SDavid Hildenbrand return is_vcpu_stopped(vcpu) ? KVM_MP_STATE_STOPPED : 23596352e4d2SDavid Hildenbrand KVM_MP_STATE_OPERATING; 236062d9f0dbSMarcelo Tosatti } 236162d9f0dbSMarcelo Tosatti 236262d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 236362d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 236462d9f0dbSMarcelo Tosatti { 23656352e4d2SDavid Hildenbrand int rc = 0; 23666352e4d2SDavid Hildenbrand 23676352e4d2SDavid Hildenbrand /* user space knows about this interface - let it control the state */ 23686352e4d2SDavid Hildenbrand vcpu->kvm->arch.user_cpu_state_ctrl = 1; 23696352e4d2SDavid Hildenbrand 23706352e4d2SDavid Hildenbrand switch (mp_state->mp_state) { 23716352e4d2SDavid Hildenbrand case KVM_MP_STATE_STOPPED: 23726352e4d2SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 23736352e4d2SDavid Hildenbrand break; 23746352e4d2SDavid Hildenbrand case KVM_MP_STATE_OPERATING: 23756352e4d2SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 23766352e4d2SDavid Hildenbrand break; 23776352e4d2SDavid Hildenbrand case KVM_MP_STATE_LOAD: 23786352e4d2SDavid Hildenbrand case KVM_MP_STATE_CHECK_STOP: 23796352e4d2SDavid Hildenbrand /* fall through - CHECK_STOP and LOAD are not supported yet */ 23806352e4d2SDavid Hildenbrand default: 23816352e4d2SDavid Hildenbrand rc = -ENXIO; 23826352e4d2SDavid Hildenbrand } 23836352e4d2SDavid Hildenbrand 23846352e4d2SDavid Hildenbrand return rc; 238562d9f0dbSMarcelo Tosatti } 238662d9f0dbSMarcelo Tosatti 23878ad35755SDavid Hildenbrand static bool ibs_enabled(struct kvm_vcpu *vcpu) 23888ad35755SDavid Hildenbrand { 23898ad35755SDavid Hildenbrand return atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_IBS; 23908ad35755SDavid Hildenbrand } 23918ad35755SDavid Hildenbrand 23922c70fe44SChristian Borntraeger static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu) 23932c70fe44SChristian Borntraeger { 23948ad35755SDavid Hildenbrand retry: 23958e236546SChristian Borntraeger kvm_s390_vcpu_request_handled(vcpu); 2396586b7ccdSChristian Borntraeger if (!vcpu->requests) 2397586b7ccdSChristian Borntraeger return 0; 23982c70fe44SChristian Borntraeger /* 23992c70fe44SChristian Borntraeger * We use MMU_RELOAD just to re-arm the ipte notifier for the 2400b2d73b2aSMartin Schwidefsky * guest prefix page. gmap_mprotect_notify will wait on the ptl lock. 24012c70fe44SChristian Borntraeger * This ensures that the ipte instruction for this request has 24022c70fe44SChristian Borntraeger * already finished. We might race against a second unmapper that 24032c70fe44SChristian Borntraeger * wants to set the blocking bit. Lets just retry the request loop. 24042c70fe44SChristian Borntraeger */ 24058ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) { 24062c70fe44SChristian Borntraeger int rc; 2407b2d73b2aSMartin Schwidefsky rc = gmap_mprotect_notify(vcpu->arch.gmap, 2408fda902cbSMichael Mueller kvm_s390_get_prefix(vcpu), 2409b2d73b2aSMartin Schwidefsky PAGE_SIZE * 2, PROT_WRITE); 2410aca411a4SJulius Niedworok if (rc) { 2411aca411a4SJulius Niedworok kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu); 24122c70fe44SChristian Borntraeger return rc; 2413aca411a4SJulius Niedworok } 24148ad35755SDavid Hildenbrand goto retry; 24152c70fe44SChristian Borntraeger } 24168ad35755SDavid Hildenbrand 2417d3d692c8SDavid Hildenbrand if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu)) { 2418d3d692c8SDavid Hildenbrand vcpu->arch.sie_block->ihcpu = 0xffff; 2419d3d692c8SDavid Hildenbrand goto retry; 2420d3d692c8SDavid Hildenbrand } 2421d3d692c8SDavid Hildenbrand 24228ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu)) { 24238ad35755SDavid Hildenbrand if (!ibs_enabled(vcpu)) { 24248ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 1); 2425805de8f4SPeter Zijlstra atomic_or(CPUSTAT_IBS, 24268ad35755SDavid Hildenbrand &vcpu->arch.sie_block->cpuflags); 24278ad35755SDavid Hildenbrand } 24288ad35755SDavid Hildenbrand goto retry; 24298ad35755SDavid Hildenbrand } 24308ad35755SDavid Hildenbrand 24318ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu)) { 24328ad35755SDavid Hildenbrand if (ibs_enabled(vcpu)) { 24338ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 0); 2434805de8f4SPeter Zijlstra atomic_andnot(CPUSTAT_IBS, 24358ad35755SDavid Hildenbrand &vcpu->arch.sie_block->cpuflags); 24368ad35755SDavid Hildenbrand } 24378ad35755SDavid Hildenbrand goto retry; 24388ad35755SDavid Hildenbrand } 24398ad35755SDavid Hildenbrand 24406502a34cSDavid Hildenbrand if (kvm_check_request(KVM_REQ_ICPT_OPEREXC, vcpu)) { 24416502a34cSDavid Hildenbrand vcpu->arch.sie_block->ictl |= ICTL_OPEREXC; 24426502a34cSDavid Hildenbrand goto retry; 24436502a34cSDavid Hildenbrand } 24446502a34cSDavid Hildenbrand 24450759d068SDavid Hildenbrand /* nothing to do, just clear the request */ 24460759d068SDavid Hildenbrand clear_bit(KVM_REQ_UNHALT, &vcpu->requests); 24470759d068SDavid Hildenbrand 24482c70fe44SChristian Borntraeger return 0; 24492c70fe44SChristian Borntraeger } 24502c70fe44SChristian Borntraeger 245125ed1675SDavid Hildenbrand void kvm_s390_set_tod_clock(struct kvm *kvm, u64 tod) 245225ed1675SDavid Hildenbrand { 245325ed1675SDavid Hildenbrand struct kvm_vcpu *vcpu; 245425ed1675SDavid Hildenbrand int i; 245525ed1675SDavid Hildenbrand 245625ed1675SDavid Hildenbrand mutex_lock(&kvm->lock); 245725ed1675SDavid Hildenbrand preempt_disable(); 245825ed1675SDavid Hildenbrand kvm->arch.epoch = tod - get_tod_clock(); 245925ed1675SDavid Hildenbrand kvm_s390_vcpu_block_all(kvm); 246025ed1675SDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) 246125ed1675SDavid Hildenbrand vcpu->arch.sie_block->epoch = kvm->arch.epoch; 246225ed1675SDavid Hildenbrand kvm_s390_vcpu_unblock_all(kvm); 246325ed1675SDavid Hildenbrand preempt_enable(); 246425ed1675SDavid Hildenbrand mutex_unlock(&kvm->lock); 246525ed1675SDavid Hildenbrand } 246625ed1675SDavid Hildenbrand 2467fa576c58SThomas Huth /** 2468fa576c58SThomas Huth * kvm_arch_fault_in_page - fault-in guest page if necessary 2469fa576c58SThomas Huth * @vcpu: The corresponding virtual cpu 2470fa576c58SThomas Huth * @gpa: Guest physical address 2471fa576c58SThomas Huth * @writable: Whether the page should be writable or not 2472fa576c58SThomas Huth * 2473fa576c58SThomas Huth * Make sure that a guest page has been faulted-in on the host. 2474fa576c58SThomas Huth * 2475fa576c58SThomas Huth * Return: Zero on success, negative error code otherwise. 2476fa576c58SThomas Huth */ 2477fa576c58SThomas Huth long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable) 247824eb3a82SDominik Dingel { 2479527e30b4SMartin Schwidefsky return gmap_fault(vcpu->arch.gmap, gpa, 2480527e30b4SMartin Schwidefsky writable ? FAULT_FLAG_WRITE : 0); 248124eb3a82SDominik Dingel } 248224eb3a82SDominik Dingel 24833c038e6bSDominik Dingel static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token, 24843c038e6bSDominik Dingel unsigned long token) 24853c038e6bSDominik Dingel { 24863c038e6bSDominik Dingel struct kvm_s390_interrupt inti; 2487383d0b05SJens Freimann struct kvm_s390_irq irq; 24883c038e6bSDominik Dingel 24893c038e6bSDominik Dingel if (start_token) { 2490383d0b05SJens Freimann irq.u.ext.ext_params2 = token; 2491383d0b05SJens Freimann irq.type = KVM_S390_INT_PFAULT_INIT; 2492383d0b05SJens Freimann WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &irq)); 24933c038e6bSDominik Dingel } else { 24943c038e6bSDominik Dingel inti.type = KVM_S390_INT_PFAULT_DONE; 2495383d0b05SJens Freimann inti.parm64 = token; 24963c038e6bSDominik Dingel WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti)); 24973c038e6bSDominik Dingel } 24983c038e6bSDominik Dingel } 24993c038e6bSDominik Dingel 25003c038e6bSDominik Dingel void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu, 25013c038e6bSDominik Dingel struct kvm_async_pf *work) 25023c038e6bSDominik Dingel { 25033c038e6bSDominik Dingel trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token); 25043c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token); 25053c038e6bSDominik Dingel } 25063c038e6bSDominik Dingel 25073c038e6bSDominik Dingel void kvm_arch_async_page_present(struct kvm_vcpu *vcpu, 25083c038e6bSDominik Dingel struct kvm_async_pf *work) 25093c038e6bSDominik Dingel { 25103c038e6bSDominik Dingel trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token); 25113c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token); 25123c038e6bSDominik Dingel } 25133c038e6bSDominik Dingel 25143c038e6bSDominik Dingel void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu, 25153c038e6bSDominik Dingel struct kvm_async_pf *work) 25163c038e6bSDominik Dingel { 25173c038e6bSDominik Dingel /* s390 will always inject the page directly */ 25183c038e6bSDominik Dingel } 25193c038e6bSDominik Dingel 25203c038e6bSDominik Dingel bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu) 25213c038e6bSDominik Dingel { 25223c038e6bSDominik Dingel /* 25233c038e6bSDominik Dingel * s390 will always inject the page directly, 25243c038e6bSDominik Dingel * but we still want check_async_completion to cleanup 25253c038e6bSDominik Dingel */ 25263c038e6bSDominik Dingel return true; 25273c038e6bSDominik Dingel } 25283c038e6bSDominik Dingel 25293c038e6bSDominik Dingel static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu) 25303c038e6bSDominik Dingel { 25313c038e6bSDominik Dingel hva_t hva; 25323c038e6bSDominik Dingel struct kvm_arch_async_pf arch; 25333c038e6bSDominik Dingel int rc; 25343c038e6bSDominik Dingel 25353c038e6bSDominik Dingel if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 25363c038e6bSDominik Dingel return 0; 25373c038e6bSDominik Dingel if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) != 25383c038e6bSDominik Dingel vcpu->arch.pfault_compare) 25393c038e6bSDominik Dingel return 0; 25403c038e6bSDominik Dingel if (psw_extint_disabled(vcpu)) 25413c038e6bSDominik Dingel return 0; 25429a022067SDavid Hildenbrand if (kvm_s390_vcpu_has_irq(vcpu, 0)) 25433c038e6bSDominik Dingel return 0; 25443c038e6bSDominik Dingel if (!(vcpu->arch.sie_block->gcr[0] & 0x200ul)) 25453c038e6bSDominik Dingel return 0; 25463c038e6bSDominik Dingel if (!vcpu->arch.gmap->pfault_enabled) 25473c038e6bSDominik Dingel return 0; 25483c038e6bSDominik Dingel 254981480cc1SHeiko Carstens hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(current->thread.gmap_addr)); 255081480cc1SHeiko Carstens hva += current->thread.gmap_addr & ~PAGE_MASK; 255181480cc1SHeiko Carstens if (read_guest_real(vcpu, vcpu->arch.pfault_token, &arch.pfault_token, 8)) 25523c038e6bSDominik Dingel return 0; 25533c038e6bSDominik Dingel 25543c038e6bSDominik Dingel rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch); 25553c038e6bSDominik Dingel return rc; 25563c038e6bSDominik Dingel } 25573c038e6bSDominik Dingel 25583fb4c40fSThomas Huth static int vcpu_pre_run(struct kvm_vcpu *vcpu) 2559b0c632dbSHeiko Carstens { 25603fb4c40fSThomas Huth int rc, cpuflags; 2561e168bf8dSCarsten Otte 25623c038e6bSDominik Dingel /* 25633c038e6bSDominik Dingel * On s390 notifications for arriving pages will be delivered directly 25643c038e6bSDominik Dingel * to the guest but the house keeping for completed pfaults is 25653c038e6bSDominik Dingel * handled outside the worker. 25663c038e6bSDominik Dingel */ 25673c038e6bSDominik Dingel kvm_check_async_pf_completion(vcpu); 25683c038e6bSDominik Dingel 25697ec7c8c7SChristian Borntraeger vcpu->arch.sie_block->gg14 = vcpu->run->s.regs.gprs[14]; 25707ec7c8c7SChristian Borntraeger vcpu->arch.sie_block->gg15 = vcpu->run->s.regs.gprs[15]; 2571b0c632dbSHeiko Carstens 2572b0c632dbSHeiko Carstens if (need_resched()) 2573b0c632dbSHeiko Carstens schedule(); 2574b0c632dbSHeiko Carstens 2575d3a73acbSMartin Schwidefsky if (test_cpu_flag(CIF_MCCK_PENDING)) 257671cde587SChristian Borntraeger s390_handle_mcck(); 257771cde587SChristian Borntraeger 257879395031SJens Freimann if (!kvm_is_ucontrol(vcpu->kvm)) { 257979395031SJens Freimann rc = kvm_s390_deliver_pending_interrupts(vcpu); 258079395031SJens Freimann if (rc) 258179395031SJens Freimann return rc; 258279395031SJens Freimann } 25830ff31867SCarsten Otte 25842c70fe44SChristian Borntraeger rc = kvm_s390_handle_requests(vcpu); 25852c70fe44SChristian Borntraeger if (rc) 25862c70fe44SChristian Borntraeger return rc; 25872c70fe44SChristian Borntraeger 258827291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) { 258927291e21SDavid Hildenbrand kvm_s390_backup_guest_per_regs(vcpu); 259027291e21SDavid Hildenbrand kvm_s390_patch_guest_per_regs(vcpu); 259127291e21SDavid Hildenbrand } 259227291e21SDavid Hildenbrand 2593b0c632dbSHeiko Carstens vcpu->arch.sie_block->icptcode = 0; 25943fb4c40fSThomas Huth cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags); 25953fb4c40fSThomas Huth VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags); 25963fb4c40fSThomas Huth trace_kvm_s390_sie_enter(vcpu, cpuflags); 25972b29a9fdSDominik Dingel 25983fb4c40fSThomas Huth return 0; 25993fb4c40fSThomas Huth } 26003fb4c40fSThomas Huth 2601492d8642SThomas Huth static int vcpu_post_run_fault_in_sie(struct kvm_vcpu *vcpu) 2602492d8642SThomas Huth { 260356317920SDavid Hildenbrand struct kvm_s390_pgm_info pgm_info = { 260456317920SDavid Hildenbrand .code = PGM_ADDRESSING, 260556317920SDavid Hildenbrand }; 260656317920SDavid Hildenbrand u8 opcode, ilen; 2607492d8642SThomas Huth int rc; 2608492d8642SThomas Huth 2609492d8642SThomas Huth VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction"); 2610492d8642SThomas Huth trace_kvm_s390_sie_fault(vcpu); 2611492d8642SThomas Huth 2612492d8642SThomas Huth /* 2613492d8642SThomas Huth * We want to inject an addressing exception, which is defined as a 2614492d8642SThomas Huth * suppressing or terminating exception. However, since we came here 2615492d8642SThomas Huth * by a DAT access exception, the PSW still points to the faulting 2616492d8642SThomas Huth * instruction since DAT exceptions are nullifying. So we've got 2617492d8642SThomas Huth * to look up the current opcode to get the length of the instruction 2618492d8642SThomas Huth * to be able to forward the PSW. 2619492d8642SThomas Huth */ 26203fa8cad7SDavid Hildenbrand rc = read_guest_instr(vcpu, vcpu->arch.sie_block->gpsw.addr, &opcode, 1); 262156317920SDavid Hildenbrand ilen = insn_length(opcode); 26229b0d721aSDavid Hildenbrand if (rc < 0) { 26239b0d721aSDavid Hildenbrand return rc; 26249b0d721aSDavid Hildenbrand } else if (rc) { 26259b0d721aSDavid Hildenbrand /* Instruction-Fetching Exceptions - we can't detect the ilen. 26269b0d721aSDavid Hildenbrand * Forward by arbitrary ilc, injection will take care of 26279b0d721aSDavid Hildenbrand * nullification if necessary. 26289b0d721aSDavid Hildenbrand */ 26299b0d721aSDavid Hildenbrand pgm_info = vcpu->arch.pgm; 26309b0d721aSDavid Hildenbrand ilen = 4; 26319b0d721aSDavid Hildenbrand } 263256317920SDavid Hildenbrand pgm_info.flags = ilen | KVM_S390_PGM_FLAGS_ILC_VALID; 263356317920SDavid Hildenbrand kvm_s390_forward_psw(vcpu, ilen); 263456317920SDavid Hildenbrand return kvm_s390_inject_prog_irq(vcpu, &pgm_info); 2635492d8642SThomas Huth } 2636492d8642SThomas Huth 26373fb4c40fSThomas Huth static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason) 26383fb4c40fSThomas Huth { 26392b29a9fdSDominik Dingel VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", 26402b29a9fdSDominik Dingel vcpu->arch.sie_block->icptcode); 26412b29a9fdSDominik Dingel trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode); 26422b29a9fdSDominik Dingel 264327291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) 264427291e21SDavid Hildenbrand kvm_s390_restore_guest_per_regs(vcpu); 264527291e21SDavid Hildenbrand 26467ec7c8c7SChristian Borntraeger vcpu->run->s.regs.gprs[14] = vcpu->arch.sie_block->gg14; 26477ec7c8c7SChristian Borntraeger vcpu->run->s.regs.gprs[15] = vcpu->arch.sie_block->gg15; 264871f116bfSDavid Hildenbrand 264971f116bfSDavid Hildenbrand if (vcpu->arch.sie_block->icptcode > 0) { 265071f116bfSDavid Hildenbrand int rc = kvm_handle_sie_intercept(vcpu); 265171f116bfSDavid Hildenbrand 265271f116bfSDavid Hildenbrand if (rc != -EOPNOTSUPP) 265371f116bfSDavid Hildenbrand return rc; 265471f116bfSDavid Hildenbrand vcpu->run->exit_reason = KVM_EXIT_S390_SIEIC; 265571f116bfSDavid Hildenbrand vcpu->run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode; 265671f116bfSDavid Hildenbrand vcpu->run->s390_sieic.ipa = vcpu->arch.sie_block->ipa; 265771f116bfSDavid Hildenbrand vcpu->run->s390_sieic.ipb = vcpu->arch.sie_block->ipb; 265871f116bfSDavid Hildenbrand return -EREMOTE; 265971f116bfSDavid Hildenbrand } else if (exit_reason != -EFAULT) { 266071f116bfSDavid Hildenbrand vcpu->stat.exit_null++; 266171f116bfSDavid Hildenbrand return 0; 2662210b1607SThomas Huth } else if (kvm_is_ucontrol(vcpu->kvm)) { 2663210b1607SThomas Huth vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL; 2664210b1607SThomas Huth vcpu->run->s390_ucontrol.trans_exc_code = 2665210b1607SThomas Huth current->thread.gmap_addr; 2666210b1607SThomas Huth vcpu->run->s390_ucontrol.pgm_code = 0x10; 266771f116bfSDavid Hildenbrand return -EREMOTE; 266824eb3a82SDominik Dingel } else if (current->thread.gmap_pfault) { 26693c038e6bSDominik Dingel trace_kvm_s390_major_guest_pfault(vcpu); 267024eb3a82SDominik Dingel current->thread.gmap_pfault = 0; 267171f116bfSDavid Hildenbrand if (kvm_arch_setup_async_pf(vcpu)) 267271f116bfSDavid Hildenbrand return 0; 267371f116bfSDavid Hildenbrand return kvm_arch_fault_in_page(vcpu, current->thread.gmap_addr, 1); 2674fa576c58SThomas Huth } 267571f116bfSDavid Hildenbrand return vcpu_post_run_fault_in_sie(vcpu); 26763fb4c40fSThomas Huth } 26773fb4c40fSThomas Huth 26783fb4c40fSThomas Huth static int __vcpu_run(struct kvm_vcpu *vcpu) 26793fb4c40fSThomas Huth { 26803fb4c40fSThomas Huth int rc, exit_reason; 26813fb4c40fSThomas Huth 2682800c1065SThomas Huth /* 2683800c1065SThomas Huth * We try to hold kvm->srcu during most of vcpu_run (except when run- 2684800c1065SThomas Huth * ning the guest), so that memslots (and other stuff) are protected 2685800c1065SThomas Huth */ 2686800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 2687800c1065SThomas Huth 2688a76ccff6SThomas Huth do { 26893fb4c40fSThomas Huth rc = vcpu_pre_run(vcpu); 26903fb4c40fSThomas Huth if (rc) 2691a76ccff6SThomas Huth break; 26923fb4c40fSThomas Huth 2693800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 26943fb4c40fSThomas Huth /* 2695a76ccff6SThomas Huth * As PF_VCPU will be used in fault handler, between 2696a76ccff6SThomas Huth * guest_enter and guest_exit should be no uaccess. 26973fb4c40fSThomas Huth */ 26980097d12eSChristian Borntraeger local_irq_disable(); 26996edaa530SPaolo Bonzini guest_enter_irqoff(); 2700db0758b2SDavid Hildenbrand __disable_cpu_timer_accounting(vcpu); 27010097d12eSChristian Borntraeger local_irq_enable(); 2702a76ccff6SThomas Huth exit_reason = sie64a(vcpu->arch.sie_block, 2703a76ccff6SThomas Huth vcpu->run->s.regs.gprs); 27040097d12eSChristian Borntraeger local_irq_disable(); 2705db0758b2SDavid Hildenbrand __enable_cpu_timer_accounting(vcpu); 27066edaa530SPaolo Bonzini guest_exit_irqoff(); 27070097d12eSChristian Borntraeger local_irq_enable(); 2708800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 27093fb4c40fSThomas Huth 27103fb4c40fSThomas Huth rc = vcpu_post_run(vcpu, exit_reason); 271127291e21SDavid Hildenbrand } while (!signal_pending(current) && !guestdbg_exit_pending(vcpu) && !rc); 27123fb4c40fSThomas Huth 2713800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 2714e168bf8dSCarsten Otte return rc; 2715b0c632dbSHeiko Carstens } 2716b0c632dbSHeiko Carstens 2717b028ee3eSDavid Hildenbrand static void sync_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 2718b028ee3eSDavid Hildenbrand { 2719b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask; 2720b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr; 2721b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) 2722b028ee3eSDavid Hildenbrand kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix); 2723b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) { 2724b028ee3eSDavid Hildenbrand memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128); 2725d3d692c8SDavid Hildenbrand /* some control register changes require a tlb flush */ 2726d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 2727b028ee3eSDavid Hildenbrand } 2728b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_ARCH0) { 27294287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, kvm_run->s.regs.cputm); 2730b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->ckc = kvm_run->s.regs.ckc; 2731b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->todpr = kvm_run->s.regs.todpr; 2732b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->pp = kvm_run->s.regs.pp; 2733b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gbea = kvm_run->s.regs.gbea; 2734b028ee3eSDavid Hildenbrand } 2735b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PFAULT) { 2736b028ee3eSDavid Hildenbrand vcpu->arch.pfault_token = kvm_run->s.regs.pft; 2737b028ee3eSDavid Hildenbrand vcpu->arch.pfault_select = kvm_run->s.regs.pfs; 2738b028ee3eSDavid Hildenbrand vcpu->arch.pfault_compare = kvm_run->s.regs.pfc; 27399fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 27409fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 2741b028ee3eSDavid Hildenbrand } 274280cd8763SFan Zhang /* 274380cd8763SFan Zhang * If userspace sets the riccb (e.g. after migration) to a valid state, 274480cd8763SFan Zhang * we should enable RI here instead of doing the lazy enablement. 274580cd8763SFan Zhang */ 274680cd8763SFan Zhang if ((kvm_run->kvm_dirty_regs & KVM_SYNC_RICCB) && 274780cd8763SFan Zhang test_kvm_facility(vcpu->kvm, 64)) { 274880cd8763SFan Zhang struct runtime_instr_cb *riccb = 274980cd8763SFan Zhang (struct runtime_instr_cb *) &kvm_run->s.regs.riccb; 275080cd8763SFan Zhang 275180cd8763SFan Zhang if (riccb->valid) 275280cd8763SFan Zhang vcpu->arch.sie_block->ecb3 |= 0x01; 275380cd8763SFan Zhang } 275431d8b8d4SChristian Borntraeger save_access_regs(vcpu->arch.host_acrs); 275531d8b8d4SChristian Borntraeger restore_access_regs(vcpu->run->s.regs.acrs); 2756e1788bb9SChristian Borntraeger /* save host (userspace) fprs/vrs */ 2757e1788bb9SChristian Borntraeger save_fpu_regs(); 2758e1788bb9SChristian Borntraeger vcpu->arch.host_fpregs.fpc = current->thread.fpu.fpc; 2759e1788bb9SChristian Borntraeger vcpu->arch.host_fpregs.regs = current->thread.fpu.regs; 2760e1788bb9SChristian Borntraeger if (MACHINE_HAS_VX) 2761e1788bb9SChristian Borntraeger current->thread.fpu.regs = vcpu->run->s.regs.vrs; 2762e1788bb9SChristian Borntraeger else 2763e1788bb9SChristian Borntraeger current->thread.fpu.regs = vcpu->run->s.regs.fprs; 2764e1788bb9SChristian Borntraeger current->thread.fpu.fpc = vcpu->run->s.regs.fpc; 2765e1788bb9SChristian Borntraeger if (test_fp_ctl(current->thread.fpu.fpc)) 2766e1788bb9SChristian Borntraeger /* User space provided an invalid FPC, let's clear it */ 2767e1788bb9SChristian Borntraeger current->thread.fpu.fpc = 0; 276880cd8763SFan Zhang 2769b028ee3eSDavid Hildenbrand kvm_run->kvm_dirty_regs = 0; 2770b028ee3eSDavid Hildenbrand } 2771b028ee3eSDavid Hildenbrand 2772b028ee3eSDavid Hildenbrand static void store_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 2773b028ee3eSDavid Hildenbrand { 2774b028ee3eSDavid Hildenbrand kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask; 2775b028ee3eSDavid Hildenbrand kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr; 2776b028ee3eSDavid Hildenbrand kvm_run->s.regs.prefix = kvm_s390_get_prefix(vcpu); 2777b028ee3eSDavid Hildenbrand memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128); 27784287f247SDavid Hildenbrand kvm_run->s.regs.cputm = kvm_s390_get_cpu_timer(vcpu); 2779b028ee3eSDavid Hildenbrand kvm_run->s.regs.ckc = vcpu->arch.sie_block->ckc; 2780b028ee3eSDavid Hildenbrand kvm_run->s.regs.todpr = vcpu->arch.sie_block->todpr; 2781b028ee3eSDavid Hildenbrand kvm_run->s.regs.pp = vcpu->arch.sie_block->pp; 2782b028ee3eSDavid Hildenbrand kvm_run->s.regs.gbea = vcpu->arch.sie_block->gbea; 2783b028ee3eSDavid Hildenbrand kvm_run->s.regs.pft = vcpu->arch.pfault_token; 2784b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfs = vcpu->arch.pfault_select; 2785b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfc = vcpu->arch.pfault_compare; 278631d8b8d4SChristian Borntraeger save_access_regs(vcpu->run->s.regs.acrs); 278731d8b8d4SChristian Borntraeger restore_access_regs(vcpu->arch.host_acrs); 2788e1788bb9SChristian Borntraeger /* Save guest register state */ 2789e1788bb9SChristian Borntraeger save_fpu_regs(); 2790e1788bb9SChristian Borntraeger vcpu->run->s.regs.fpc = current->thread.fpu.fpc; 2791e1788bb9SChristian Borntraeger /* Restore will be done lazily at return */ 2792e1788bb9SChristian Borntraeger current->thread.fpu.fpc = vcpu->arch.host_fpregs.fpc; 2793e1788bb9SChristian Borntraeger current->thread.fpu.regs = vcpu->arch.host_fpregs.regs; 2794e1788bb9SChristian Borntraeger 2795b028ee3eSDavid Hildenbrand } 2796b028ee3eSDavid Hildenbrand 2797b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 2798b0c632dbSHeiko Carstens { 27998f2abe6aSChristian Borntraeger int rc; 2800b0c632dbSHeiko Carstens sigset_t sigsaved; 2801b0c632dbSHeiko Carstens 2802*460df4c1SPaolo Bonzini if (kvm_run->immediate_exit) 2803*460df4c1SPaolo Bonzini return -EINTR; 2804*460df4c1SPaolo Bonzini 280527291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu)) { 280627291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 280727291e21SDavid Hildenbrand return 0; 280827291e21SDavid Hildenbrand } 280927291e21SDavid Hildenbrand 2810b0c632dbSHeiko Carstens if (vcpu->sigset_active) 2811b0c632dbSHeiko Carstens sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); 2812b0c632dbSHeiko Carstens 28136352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) { 28146852d7b6SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 28156352e4d2SDavid Hildenbrand } else if (is_vcpu_stopped(vcpu)) { 2816ea2cdd27SDavid Hildenbrand pr_err_ratelimited("can't run stopped vcpu %d\n", 28176352e4d2SDavid Hildenbrand vcpu->vcpu_id); 28186352e4d2SDavid Hildenbrand return -EINVAL; 28196352e4d2SDavid Hildenbrand } 2820b0c632dbSHeiko Carstens 2821b028ee3eSDavid Hildenbrand sync_regs(vcpu, kvm_run); 2822db0758b2SDavid Hildenbrand enable_cpu_timer_accounting(vcpu); 2823d7b0b5ebSCarsten Otte 2824dab4079dSHeiko Carstens might_fault(); 2825e168bf8dSCarsten Otte rc = __vcpu_run(vcpu); 28269ace903dSChristian Ehrhardt 2827b1d16c49SChristian Ehrhardt if (signal_pending(current) && !rc) { 2828b1d16c49SChristian Ehrhardt kvm_run->exit_reason = KVM_EXIT_INTR; 28298f2abe6aSChristian Borntraeger rc = -EINTR; 2830b1d16c49SChristian Ehrhardt } 28318f2abe6aSChristian Borntraeger 283227291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu) && !rc) { 283327291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 283427291e21SDavid Hildenbrand rc = 0; 283527291e21SDavid Hildenbrand } 283627291e21SDavid Hildenbrand 28378f2abe6aSChristian Borntraeger if (rc == -EREMOTE) { 283871f116bfSDavid Hildenbrand /* userspace support is needed, kvm_run has been prepared */ 28398f2abe6aSChristian Borntraeger rc = 0; 28408f2abe6aSChristian Borntraeger } 28418f2abe6aSChristian Borntraeger 2842db0758b2SDavid Hildenbrand disable_cpu_timer_accounting(vcpu); 2843b028ee3eSDavid Hildenbrand store_regs(vcpu, kvm_run); 2844d7b0b5ebSCarsten Otte 2845b0c632dbSHeiko Carstens if (vcpu->sigset_active) 2846b0c632dbSHeiko Carstens sigprocmask(SIG_SETMASK, &sigsaved, NULL); 2847b0c632dbSHeiko Carstens 2848b0c632dbSHeiko Carstens vcpu->stat.exit_userspace++; 28497e8e6ab4SHeiko Carstens return rc; 2850b0c632dbSHeiko Carstens } 2851b0c632dbSHeiko Carstens 2852b0c632dbSHeiko Carstens /* 2853b0c632dbSHeiko Carstens * store status at address 2854b0c632dbSHeiko Carstens * we use have two special cases: 2855b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit 2856b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_PREFIXED: -> prefix 2857b0c632dbSHeiko Carstens */ 2858d0bce605SHeiko Carstens int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long gpa) 2859b0c632dbSHeiko Carstens { 2860092670cdSCarsten Otte unsigned char archmode = 1; 28619abc2a08SDavid Hildenbrand freg_t fprs[NUM_FPRS]; 2862fda902cbSMichael Mueller unsigned int px; 28634287f247SDavid Hildenbrand u64 clkcomp, cputm; 2864d0bce605SHeiko Carstens int rc; 2865b0c632dbSHeiko Carstens 2866d9a3a09aSMartin Schwidefsky px = kvm_s390_get_prefix(vcpu); 2867d0bce605SHeiko Carstens if (gpa == KVM_S390_STORE_STATUS_NOADDR) { 2868d0bce605SHeiko Carstens if (write_guest_abs(vcpu, 163, &archmode, 1)) 2869b0c632dbSHeiko Carstens return -EFAULT; 2870d9a3a09aSMartin Schwidefsky gpa = 0; 2871d0bce605SHeiko Carstens } else if (gpa == KVM_S390_STORE_STATUS_PREFIXED) { 2872d0bce605SHeiko Carstens if (write_guest_real(vcpu, 163, &archmode, 1)) 2873b0c632dbSHeiko Carstens return -EFAULT; 2874d9a3a09aSMartin Schwidefsky gpa = px; 2875d9a3a09aSMartin Schwidefsky } else 2876d9a3a09aSMartin Schwidefsky gpa -= __LC_FPREGS_SAVE_AREA; 28779abc2a08SDavid Hildenbrand 28789abc2a08SDavid Hildenbrand /* manually convert vector registers if necessary */ 28799abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) { 28809522b37fSDavid Hildenbrand convert_vx_to_fp(fprs, (__vector128 *) vcpu->run->s.regs.vrs); 2881d9a3a09aSMartin Schwidefsky rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA, 28829abc2a08SDavid Hildenbrand fprs, 128); 28839abc2a08SDavid Hildenbrand } else { 28849abc2a08SDavid Hildenbrand rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA, 28856fd8e67dSDavid Hildenbrand vcpu->run->s.regs.fprs, 128); 28869abc2a08SDavid Hildenbrand } 2887d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_GPREGS_SAVE_AREA, 2888d0bce605SHeiko Carstens vcpu->run->s.regs.gprs, 128); 2889d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_PSW_SAVE_AREA, 2890d0bce605SHeiko Carstens &vcpu->arch.sie_block->gpsw, 16); 2891d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_PREFIX_SAVE_AREA, 2892fda902cbSMichael Mueller &px, 4); 2893d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_FP_CREG_SAVE_AREA, 28949abc2a08SDavid Hildenbrand &vcpu->run->s.regs.fpc, 4); 2895d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_TOD_PROGREG_SAVE_AREA, 2896d0bce605SHeiko Carstens &vcpu->arch.sie_block->todpr, 4); 28974287f247SDavid Hildenbrand cputm = kvm_s390_get_cpu_timer(vcpu); 2898d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CPU_TIMER_SAVE_AREA, 28994287f247SDavid Hildenbrand &cputm, 8); 2900178bd789SThomas Huth clkcomp = vcpu->arch.sie_block->ckc >> 8; 2901d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CLOCK_COMP_SAVE_AREA, 2902d0bce605SHeiko Carstens &clkcomp, 8); 2903d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_AREGS_SAVE_AREA, 2904d0bce605SHeiko Carstens &vcpu->run->s.regs.acrs, 64); 2905d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CREGS_SAVE_AREA, 2906d0bce605SHeiko Carstens &vcpu->arch.sie_block->gcr, 128); 2907d0bce605SHeiko Carstens return rc ? -EFAULT : 0; 2908b0c632dbSHeiko Carstens } 2909b0c632dbSHeiko Carstens 2910e879892cSThomas Huth int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr) 2911e879892cSThomas Huth { 2912e879892cSThomas Huth /* 2913e879892cSThomas Huth * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy 291431d8b8d4SChristian Borntraeger * switch in the run ioctl. Let's update our copies before we save 2915e879892cSThomas Huth * it into the save area 2916e879892cSThomas Huth */ 2917d0164ee2SHendrik Brueckner save_fpu_regs(); 29189abc2a08SDavid Hildenbrand vcpu->run->s.regs.fpc = current->thread.fpu.fpc; 2919e879892cSThomas Huth save_access_regs(vcpu->run->s.regs.acrs); 2920e879892cSThomas Huth 2921e879892cSThomas Huth return kvm_s390_store_status_unloaded(vcpu, addr); 2922e879892cSThomas Huth } 2923e879892cSThomas Huth 29248ad35755SDavid Hildenbrand static void __disable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 29258ad35755SDavid Hildenbrand { 29268ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu); 29278e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_DISABLE_IBS, vcpu); 29288ad35755SDavid Hildenbrand } 29298ad35755SDavid Hildenbrand 29308ad35755SDavid Hildenbrand static void __disable_ibs_on_all_vcpus(struct kvm *kvm) 29318ad35755SDavid Hildenbrand { 29328ad35755SDavid Hildenbrand unsigned int i; 29338ad35755SDavid Hildenbrand struct kvm_vcpu *vcpu; 29348ad35755SDavid Hildenbrand 29358ad35755SDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 29368ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 29378ad35755SDavid Hildenbrand } 29388ad35755SDavid Hildenbrand } 29398ad35755SDavid Hildenbrand 29408ad35755SDavid Hildenbrand static void __enable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 29418ad35755SDavid Hildenbrand { 294209a400e7SDavid Hildenbrand if (!sclp.has_ibs) 294309a400e7SDavid Hildenbrand return; 29448ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu); 29458e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_ENABLE_IBS, vcpu); 29468ad35755SDavid Hildenbrand } 29478ad35755SDavid Hildenbrand 29486852d7b6SDavid Hildenbrand void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu) 29496852d7b6SDavid Hildenbrand { 29508ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 29518ad35755SDavid Hildenbrand 29528ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 29538ad35755SDavid Hildenbrand return; 29548ad35755SDavid Hildenbrand 29556852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 1); 29568ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 2957433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 29588ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 29598ad35755SDavid Hildenbrand 29608ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 29618ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) 29628ad35755SDavid Hildenbrand started_vcpus++; 29638ad35755SDavid Hildenbrand } 29648ad35755SDavid Hildenbrand 29658ad35755SDavid Hildenbrand if (started_vcpus == 0) { 29668ad35755SDavid Hildenbrand /* we're the only active VCPU -> speed it up */ 29678ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(vcpu); 29688ad35755SDavid Hildenbrand } else if (started_vcpus == 1) { 29698ad35755SDavid Hildenbrand /* 29708ad35755SDavid Hildenbrand * As we are starting a second VCPU, we have to disable 29718ad35755SDavid Hildenbrand * the IBS facility on all VCPUs to remove potentially 29728ad35755SDavid Hildenbrand * oustanding ENABLE requests. 29738ad35755SDavid Hildenbrand */ 29748ad35755SDavid Hildenbrand __disable_ibs_on_all_vcpus(vcpu->kvm); 29758ad35755SDavid Hildenbrand } 29768ad35755SDavid Hildenbrand 2977805de8f4SPeter Zijlstra atomic_andnot(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags); 29788ad35755SDavid Hildenbrand /* 29798ad35755SDavid Hildenbrand * Another VCPU might have used IBS while we were offline. 29808ad35755SDavid Hildenbrand * Let's play safe and flush the VCPU at startup. 29818ad35755SDavid Hildenbrand */ 2982d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 2983433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 29848ad35755SDavid Hildenbrand return; 29856852d7b6SDavid Hildenbrand } 29866852d7b6SDavid Hildenbrand 29876852d7b6SDavid Hildenbrand void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu) 29886852d7b6SDavid Hildenbrand { 29898ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 29908ad35755SDavid Hildenbrand struct kvm_vcpu *started_vcpu = NULL; 29918ad35755SDavid Hildenbrand 29928ad35755SDavid Hildenbrand if (is_vcpu_stopped(vcpu)) 29938ad35755SDavid Hildenbrand return; 29948ad35755SDavid Hildenbrand 29956852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 0); 29968ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 2997433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 29988ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 29998ad35755SDavid Hildenbrand 300032f5ff63SDavid Hildenbrand /* SIGP STOP and SIGP STOP AND STORE STATUS has been fully processed */ 30016cddd432SDavid Hildenbrand kvm_s390_clear_stop_irq(vcpu); 300232f5ff63SDavid Hildenbrand 3003805de8f4SPeter Zijlstra atomic_or(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags); 30048ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 30058ad35755SDavid Hildenbrand 30068ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 30078ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) { 30088ad35755SDavid Hildenbrand started_vcpus++; 30098ad35755SDavid Hildenbrand started_vcpu = vcpu->kvm->vcpus[i]; 30108ad35755SDavid Hildenbrand } 30118ad35755SDavid Hildenbrand } 30128ad35755SDavid Hildenbrand 30138ad35755SDavid Hildenbrand if (started_vcpus == 1) { 30148ad35755SDavid Hildenbrand /* 30158ad35755SDavid Hildenbrand * As we only have one VCPU left, we want to enable the 30168ad35755SDavid Hildenbrand * IBS facility for that VCPU to speed it up. 30178ad35755SDavid Hildenbrand */ 30188ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(started_vcpu); 30198ad35755SDavid Hildenbrand } 30208ad35755SDavid Hildenbrand 3021433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 30228ad35755SDavid Hildenbrand return; 30236852d7b6SDavid Hildenbrand } 30246852d7b6SDavid Hildenbrand 3025d6712df9SCornelia Huck static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 3026d6712df9SCornelia Huck struct kvm_enable_cap *cap) 3027d6712df9SCornelia Huck { 3028d6712df9SCornelia Huck int r; 3029d6712df9SCornelia Huck 3030d6712df9SCornelia Huck if (cap->flags) 3031d6712df9SCornelia Huck return -EINVAL; 3032d6712df9SCornelia Huck 3033d6712df9SCornelia Huck switch (cap->cap) { 3034fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 3035fa6b7fe9SCornelia Huck if (!vcpu->kvm->arch.css_support) { 3036fa6b7fe9SCornelia Huck vcpu->kvm->arch.css_support = 1; 3037c92ea7b9SChristian Borntraeger VM_EVENT(vcpu->kvm, 3, "%s", "ENABLE: CSS support"); 3038fa6b7fe9SCornelia Huck trace_kvm_s390_enable_css(vcpu->kvm); 3039fa6b7fe9SCornelia Huck } 3040fa6b7fe9SCornelia Huck r = 0; 3041fa6b7fe9SCornelia Huck break; 3042d6712df9SCornelia Huck default: 3043d6712df9SCornelia Huck r = -EINVAL; 3044d6712df9SCornelia Huck break; 3045d6712df9SCornelia Huck } 3046d6712df9SCornelia Huck return r; 3047d6712df9SCornelia Huck } 3048d6712df9SCornelia Huck 304941408c28SThomas Huth static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu, 305041408c28SThomas Huth struct kvm_s390_mem_op *mop) 305141408c28SThomas Huth { 305241408c28SThomas Huth void __user *uaddr = (void __user *)mop->buf; 305341408c28SThomas Huth void *tmpbuf = NULL; 305441408c28SThomas Huth int r, srcu_idx; 305541408c28SThomas Huth const u64 supported_flags = KVM_S390_MEMOP_F_INJECT_EXCEPTION 305641408c28SThomas Huth | KVM_S390_MEMOP_F_CHECK_ONLY; 305741408c28SThomas Huth 305841408c28SThomas Huth if (mop->flags & ~supported_flags) 305941408c28SThomas Huth return -EINVAL; 306041408c28SThomas Huth 306141408c28SThomas Huth if (mop->size > MEM_OP_MAX_SIZE) 306241408c28SThomas Huth return -E2BIG; 306341408c28SThomas Huth 306441408c28SThomas Huth if (!(mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY)) { 306541408c28SThomas Huth tmpbuf = vmalloc(mop->size); 306641408c28SThomas Huth if (!tmpbuf) 306741408c28SThomas Huth return -ENOMEM; 306841408c28SThomas Huth } 306941408c28SThomas Huth 307041408c28SThomas Huth srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 307141408c28SThomas Huth 307241408c28SThomas Huth switch (mop->op) { 307341408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_READ: 307441408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 307592c96321SDavid Hildenbrand r = check_gva_range(vcpu, mop->gaddr, mop->ar, 307692c96321SDavid Hildenbrand mop->size, GACC_FETCH); 307741408c28SThomas Huth break; 307841408c28SThomas Huth } 307941408c28SThomas Huth r = read_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 308041408c28SThomas Huth if (r == 0) { 308141408c28SThomas Huth if (copy_to_user(uaddr, tmpbuf, mop->size)) 308241408c28SThomas Huth r = -EFAULT; 308341408c28SThomas Huth } 308441408c28SThomas Huth break; 308541408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_WRITE: 308641408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 308792c96321SDavid Hildenbrand r = check_gva_range(vcpu, mop->gaddr, mop->ar, 308892c96321SDavid Hildenbrand mop->size, GACC_STORE); 308941408c28SThomas Huth break; 309041408c28SThomas Huth } 309141408c28SThomas Huth if (copy_from_user(tmpbuf, uaddr, mop->size)) { 309241408c28SThomas Huth r = -EFAULT; 309341408c28SThomas Huth break; 309441408c28SThomas Huth } 309541408c28SThomas Huth r = write_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 309641408c28SThomas Huth break; 309741408c28SThomas Huth default: 309841408c28SThomas Huth r = -EINVAL; 309941408c28SThomas Huth } 310041408c28SThomas Huth 310141408c28SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, srcu_idx); 310241408c28SThomas Huth 310341408c28SThomas Huth if (r > 0 && (mop->flags & KVM_S390_MEMOP_F_INJECT_EXCEPTION) != 0) 310441408c28SThomas Huth kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm); 310541408c28SThomas Huth 310641408c28SThomas Huth vfree(tmpbuf); 310741408c28SThomas Huth return r; 310841408c28SThomas Huth } 310941408c28SThomas Huth 3110b0c632dbSHeiko Carstens long kvm_arch_vcpu_ioctl(struct file *filp, 3111b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 3112b0c632dbSHeiko Carstens { 3113b0c632dbSHeiko Carstens struct kvm_vcpu *vcpu = filp->private_data; 3114b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 3115800c1065SThomas Huth int idx; 3116bc923cc9SAvi Kivity long r; 3117b0c632dbSHeiko Carstens 311893736624SAvi Kivity switch (ioctl) { 311947b43c52SJens Freimann case KVM_S390_IRQ: { 312047b43c52SJens Freimann struct kvm_s390_irq s390irq; 312147b43c52SJens Freimann 312247b43c52SJens Freimann r = -EFAULT; 312347b43c52SJens Freimann if (copy_from_user(&s390irq, argp, sizeof(s390irq))) 312447b43c52SJens Freimann break; 312547b43c52SJens Freimann r = kvm_s390_inject_vcpu(vcpu, &s390irq); 312647b43c52SJens Freimann break; 312747b43c52SJens Freimann } 312893736624SAvi Kivity case KVM_S390_INTERRUPT: { 3129ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 3130383d0b05SJens Freimann struct kvm_s390_irq s390irq; 3131ba5c1e9bSCarsten Otte 313293736624SAvi Kivity r = -EFAULT; 3133ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 313493736624SAvi Kivity break; 3135383d0b05SJens Freimann if (s390int_to_s390irq(&s390int, &s390irq)) 3136383d0b05SJens Freimann return -EINVAL; 3137383d0b05SJens Freimann r = kvm_s390_inject_vcpu(vcpu, &s390irq); 313893736624SAvi Kivity break; 3139ba5c1e9bSCarsten Otte } 3140b0c632dbSHeiko Carstens case KVM_S390_STORE_STATUS: 3141800c1065SThomas Huth idx = srcu_read_lock(&vcpu->kvm->srcu); 3142bc923cc9SAvi Kivity r = kvm_s390_vcpu_store_status(vcpu, arg); 3143800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, idx); 3144bc923cc9SAvi Kivity break; 3145b0c632dbSHeiko Carstens case KVM_S390_SET_INITIAL_PSW: { 3146b0c632dbSHeiko Carstens psw_t psw; 3147b0c632dbSHeiko Carstens 3148bc923cc9SAvi Kivity r = -EFAULT; 3149b0c632dbSHeiko Carstens if (copy_from_user(&psw, argp, sizeof(psw))) 3150bc923cc9SAvi Kivity break; 3151bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw); 3152bc923cc9SAvi Kivity break; 3153b0c632dbSHeiko Carstens } 3154b0c632dbSHeiko Carstens case KVM_S390_INITIAL_RESET: 3155bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_initial_reset(vcpu); 3156bc923cc9SAvi Kivity break; 315714eebd91SCarsten Otte case KVM_SET_ONE_REG: 315814eebd91SCarsten Otte case KVM_GET_ONE_REG: { 315914eebd91SCarsten Otte struct kvm_one_reg reg; 316014eebd91SCarsten Otte r = -EFAULT; 316114eebd91SCarsten Otte if (copy_from_user(®, argp, sizeof(reg))) 316214eebd91SCarsten Otte break; 316314eebd91SCarsten Otte if (ioctl == KVM_SET_ONE_REG) 316414eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, ®); 316514eebd91SCarsten Otte else 316614eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, ®); 316714eebd91SCarsten Otte break; 316814eebd91SCarsten Otte } 316927e0393fSCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 317027e0393fSCarsten Otte case KVM_S390_UCAS_MAP: { 317127e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 317227e0393fSCarsten Otte 317327e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 317427e0393fSCarsten Otte r = -EFAULT; 317527e0393fSCarsten Otte break; 317627e0393fSCarsten Otte } 317727e0393fSCarsten Otte 317827e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 317927e0393fSCarsten Otte r = -EINVAL; 318027e0393fSCarsten Otte break; 318127e0393fSCarsten Otte } 318227e0393fSCarsten Otte 318327e0393fSCarsten Otte r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr, 318427e0393fSCarsten Otte ucasmap.vcpu_addr, ucasmap.length); 318527e0393fSCarsten Otte break; 318627e0393fSCarsten Otte } 318727e0393fSCarsten Otte case KVM_S390_UCAS_UNMAP: { 318827e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 318927e0393fSCarsten Otte 319027e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 319127e0393fSCarsten Otte r = -EFAULT; 319227e0393fSCarsten Otte break; 319327e0393fSCarsten Otte } 319427e0393fSCarsten Otte 319527e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 319627e0393fSCarsten Otte r = -EINVAL; 319727e0393fSCarsten Otte break; 319827e0393fSCarsten Otte } 319927e0393fSCarsten Otte 320027e0393fSCarsten Otte r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr, 320127e0393fSCarsten Otte ucasmap.length); 320227e0393fSCarsten Otte break; 320327e0393fSCarsten Otte } 320427e0393fSCarsten Otte #endif 3205ccc7910fSCarsten Otte case KVM_S390_VCPU_FAULT: { 3206527e30b4SMartin Schwidefsky r = gmap_fault(vcpu->arch.gmap, arg, 0); 3207ccc7910fSCarsten Otte break; 3208ccc7910fSCarsten Otte } 3209d6712df9SCornelia Huck case KVM_ENABLE_CAP: 3210d6712df9SCornelia Huck { 3211d6712df9SCornelia Huck struct kvm_enable_cap cap; 3212d6712df9SCornelia Huck r = -EFAULT; 3213d6712df9SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 3214d6712df9SCornelia Huck break; 3215d6712df9SCornelia Huck r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 3216d6712df9SCornelia Huck break; 3217d6712df9SCornelia Huck } 321841408c28SThomas Huth case KVM_S390_MEM_OP: { 321941408c28SThomas Huth struct kvm_s390_mem_op mem_op; 322041408c28SThomas Huth 322141408c28SThomas Huth if (copy_from_user(&mem_op, argp, sizeof(mem_op)) == 0) 322241408c28SThomas Huth r = kvm_s390_guest_mem_op(vcpu, &mem_op); 322341408c28SThomas Huth else 322441408c28SThomas Huth r = -EFAULT; 322541408c28SThomas Huth break; 322641408c28SThomas Huth } 3227816c7667SJens Freimann case KVM_S390_SET_IRQ_STATE: { 3228816c7667SJens Freimann struct kvm_s390_irq_state irq_state; 3229816c7667SJens Freimann 3230816c7667SJens Freimann r = -EFAULT; 3231816c7667SJens Freimann if (copy_from_user(&irq_state, argp, sizeof(irq_state))) 3232816c7667SJens Freimann break; 3233816c7667SJens Freimann if (irq_state.len > VCPU_IRQS_MAX_BUF || 3234816c7667SJens Freimann irq_state.len == 0 || 3235816c7667SJens Freimann irq_state.len % sizeof(struct kvm_s390_irq) > 0) { 3236816c7667SJens Freimann r = -EINVAL; 3237816c7667SJens Freimann break; 3238816c7667SJens Freimann } 3239816c7667SJens Freimann r = kvm_s390_set_irq_state(vcpu, 3240816c7667SJens Freimann (void __user *) irq_state.buf, 3241816c7667SJens Freimann irq_state.len); 3242816c7667SJens Freimann break; 3243816c7667SJens Freimann } 3244816c7667SJens Freimann case KVM_S390_GET_IRQ_STATE: { 3245816c7667SJens Freimann struct kvm_s390_irq_state irq_state; 3246816c7667SJens Freimann 3247816c7667SJens Freimann r = -EFAULT; 3248816c7667SJens Freimann if (copy_from_user(&irq_state, argp, sizeof(irq_state))) 3249816c7667SJens Freimann break; 3250816c7667SJens Freimann if (irq_state.len == 0) { 3251816c7667SJens Freimann r = -EINVAL; 3252816c7667SJens Freimann break; 3253816c7667SJens Freimann } 3254816c7667SJens Freimann r = kvm_s390_get_irq_state(vcpu, 3255816c7667SJens Freimann (__u8 __user *) irq_state.buf, 3256816c7667SJens Freimann irq_state.len); 3257816c7667SJens Freimann break; 3258816c7667SJens Freimann } 3259b0c632dbSHeiko Carstens default: 32603e6afcf1SCarsten Otte r = -ENOTTY; 3261b0c632dbSHeiko Carstens } 3262bc923cc9SAvi Kivity return r; 3263b0c632dbSHeiko Carstens } 3264b0c632dbSHeiko Carstens 32655b1c1493SCarsten Otte int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) 32665b1c1493SCarsten Otte { 32675b1c1493SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 32685b1c1493SCarsten Otte if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET) 32695b1c1493SCarsten Otte && (kvm_is_ucontrol(vcpu->kvm))) { 32705b1c1493SCarsten Otte vmf->page = virt_to_page(vcpu->arch.sie_block); 32715b1c1493SCarsten Otte get_page(vmf->page); 32725b1c1493SCarsten Otte return 0; 32735b1c1493SCarsten Otte } 32745b1c1493SCarsten Otte #endif 32755b1c1493SCarsten Otte return VM_FAULT_SIGBUS; 32765b1c1493SCarsten Otte } 32775b1c1493SCarsten Otte 32785587027cSAneesh Kumar K.V int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, 32795587027cSAneesh Kumar K.V unsigned long npages) 3280db3fe4ebSTakuya Yoshikawa { 3281db3fe4ebSTakuya Yoshikawa return 0; 3282db3fe4ebSTakuya Yoshikawa } 3283db3fe4ebSTakuya Yoshikawa 3284b0c632dbSHeiko Carstens /* Section: memory related */ 3285f7784b8eSMarcelo Tosatti int kvm_arch_prepare_memory_region(struct kvm *kvm, 3286f7784b8eSMarcelo Tosatti struct kvm_memory_slot *memslot, 328709170a49SPaolo Bonzini const struct kvm_userspace_memory_region *mem, 32887b6195a9STakuya Yoshikawa enum kvm_mr_change change) 3289b0c632dbSHeiko Carstens { 3290dd2887e7SNick Wang /* A few sanity checks. We can have memory slots which have to be 3291dd2887e7SNick Wang located/ended at a segment boundary (1MB). The memory in userland is 3292dd2887e7SNick Wang ok to be fragmented into various different vmas. It is okay to mmap() 3293dd2887e7SNick Wang and munmap() stuff in this slot after doing this call at any time */ 3294b0c632dbSHeiko Carstens 3295598841caSCarsten Otte if (mem->userspace_addr & 0xffffful) 3296b0c632dbSHeiko Carstens return -EINVAL; 3297b0c632dbSHeiko Carstens 3298598841caSCarsten Otte if (mem->memory_size & 0xffffful) 3299b0c632dbSHeiko Carstens return -EINVAL; 3300b0c632dbSHeiko Carstens 3301a3a92c31SDominik Dingel if (mem->guest_phys_addr + mem->memory_size > kvm->arch.mem_limit) 3302a3a92c31SDominik Dingel return -EINVAL; 3303a3a92c31SDominik Dingel 3304f7784b8eSMarcelo Tosatti return 0; 3305f7784b8eSMarcelo Tosatti } 3306f7784b8eSMarcelo Tosatti 3307f7784b8eSMarcelo Tosatti void kvm_arch_commit_memory_region(struct kvm *kvm, 330809170a49SPaolo Bonzini const struct kvm_userspace_memory_region *mem, 33098482644aSTakuya Yoshikawa const struct kvm_memory_slot *old, 3310f36f3f28SPaolo Bonzini const struct kvm_memory_slot *new, 33118482644aSTakuya Yoshikawa enum kvm_mr_change change) 3312f7784b8eSMarcelo Tosatti { 3313f7850c92SCarsten Otte int rc; 3314f7784b8eSMarcelo Tosatti 33152cef4debSChristian Borntraeger /* If the basics of the memslot do not change, we do not want 33162cef4debSChristian Borntraeger * to update the gmap. Every update causes several unnecessary 33172cef4debSChristian Borntraeger * segment translation exceptions. This is usually handled just 33182cef4debSChristian Borntraeger * fine by the normal fault handler + gmap, but it will also 33192cef4debSChristian Borntraeger * cause faults on the prefix page of running guest CPUs. 33202cef4debSChristian Borntraeger */ 33212cef4debSChristian Borntraeger if (old->userspace_addr == mem->userspace_addr && 33222cef4debSChristian Borntraeger old->base_gfn * PAGE_SIZE == mem->guest_phys_addr && 33232cef4debSChristian Borntraeger old->npages * PAGE_SIZE == mem->memory_size) 33242cef4debSChristian Borntraeger return; 3325598841caSCarsten Otte 3326598841caSCarsten Otte rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr, 3327598841caSCarsten Otte mem->guest_phys_addr, mem->memory_size); 3328598841caSCarsten Otte if (rc) 3329ea2cdd27SDavid Hildenbrand pr_warn("failed to commit memory region\n"); 3330598841caSCarsten Otte return; 3331b0c632dbSHeiko Carstens } 3332b0c632dbSHeiko Carstens 333360a37709SAlexander Yarygin static inline unsigned long nonhyp_mask(int i) 333460a37709SAlexander Yarygin { 333560a37709SAlexander Yarygin unsigned int nonhyp_fai = (sclp.hmfai << i * 2) >> 30; 333660a37709SAlexander Yarygin 333760a37709SAlexander Yarygin return 0x0000ffffffffffffUL >> (nonhyp_fai << 4); 333860a37709SAlexander Yarygin } 333960a37709SAlexander Yarygin 33403491caf2SChristian Borntraeger void kvm_arch_vcpu_block_finish(struct kvm_vcpu *vcpu) 33413491caf2SChristian Borntraeger { 33423491caf2SChristian Borntraeger vcpu->valid_wakeup = false; 33433491caf2SChristian Borntraeger } 33443491caf2SChristian Borntraeger 3345b0c632dbSHeiko Carstens static int __init kvm_s390_init(void) 3346b0c632dbSHeiko Carstens { 334760a37709SAlexander Yarygin int i; 334860a37709SAlexander Yarygin 334907197fd0SDavid Hildenbrand if (!sclp.has_sief2) { 335007197fd0SDavid Hildenbrand pr_info("SIE not available\n"); 335107197fd0SDavid Hildenbrand return -ENODEV; 335207197fd0SDavid Hildenbrand } 335307197fd0SDavid Hildenbrand 335460a37709SAlexander Yarygin for (i = 0; i < 16; i++) 335560a37709SAlexander Yarygin kvm_s390_fac_list_mask[i] |= 335660a37709SAlexander Yarygin S390_lowcore.stfle_fac_list[i] & nonhyp_mask(i); 335760a37709SAlexander Yarygin 33589d8d5786SMichael Mueller return kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); 3359b0c632dbSHeiko Carstens } 3360b0c632dbSHeiko Carstens 3361b0c632dbSHeiko Carstens static void __exit kvm_s390_exit(void) 3362b0c632dbSHeiko Carstens { 3363b0c632dbSHeiko Carstens kvm_exit(); 3364b0c632dbSHeiko Carstens } 3365b0c632dbSHeiko Carstens 3366b0c632dbSHeiko Carstens module_init(kvm_s390_init); 3367b0c632dbSHeiko Carstens module_exit(kvm_s390_exit); 3368566af940SCornelia Huck 3369566af940SCornelia Huck /* 3370566af940SCornelia Huck * Enable autoloading of the kvm module. 3371566af940SCornelia Huck * Note that we add the module alias here instead of virt/kvm/kvm_main.c 3372566af940SCornelia Huck * since x86 takes a different approach. 3373566af940SCornelia Huck */ 3374566af940SCornelia Huck #include <linux/miscdevice.h> 3375566af940SCornelia Huck MODULE_ALIAS_MISCDEV(KVM_MINOR); 3376566af940SCornelia Huck MODULE_ALIAS("devname:kvm"); 3377