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> 33fdf03650SFan Zhang #include <asm/etr.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> 410a763c78SDavid Hildenbrand #include <asm/etr.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) }, 68ba5c1e9bSCarsten Otte { "exit_program_interruption", VCPU_STAT(exit_program_interruption) }, 69ba5c1e9bSCarsten Otte { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) }, 70a011eeb2SJanosch Frank { "exit_operation_exception", VCPU_STAT(exit_operation_exception) }, 71f7819512SPaolo Bonzini { "halt_successful_poll", VCPU_STAT(halt_successful_poll) }, 7262bea5bfSPaolo Bonzini { "halt_attempted_poll", VCPU_STAT(halt_attempted_poll) }, 733491caf2SChristian Borntraeger { "halt_poll_invalid", VCPU_STAT(halt_poll_invalid) }, 74ce2e4f0bSDavid Hildenbrand { "halt_wakeup", VCPU_STAT(halt_wakeup) }, 75f5e10b09SChristian Borntraeger { "instruction_lctlg", VCPU_STAT(instruction_lctlg) }, 76ba5c1e9bSCarsten Otte { "instruction_lctl", VCPU_STAT(instruction_lctl) }, 77aba07508SDavid Hildenbrand { "instruction_stctl", VCPU_STAT(instruction_stctl) }, 78aba07508SDavid Hildenbrand { "instruction_stctg", VCPU_STAT(instruction_stctg) }, 79ba5c1e9bSCarsten Otte { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) }, 807697e71fSChristian Ehrhardt { "deliver_external_call", VCPU_STAT(deliver_external_call) }, 81ba5c1e9bSCarsten Otte { "deliver_service_signal", VCPU_STAT(deliver_service_signal) }, 82ba5c1e9bSCarsten Otte { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) }, 83ba5c1e9bSCarsten Otte { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) }, 84ba5c1e9bSCarsten Otte { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) }, 85ba5c1e9bSCarsten Otte { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) }, 86ba5c1e9bSCarsten Otte { "deliver_program_interruption", VCPU_STAT(deliver_program_int) }, 87ba5c1e9bSCarsten Otte { "exit_wait_state", VCPU_STAT(exit_wait_state) }, 8869d0d3a3SChristian Borntraeger { "instruction_pfmf", VCPU_STAT(instruction_pfmf) }, 89453423dcSChristian Borntraeger { "instruction_stidp", VCPU_STAT(instruction_stidp) }, 90453423dcSChristian Borntraeger { "instruction_spx", VCPU_STAT(instruction_spx) }, 91453423dcSChristian Borntraeger { "instruction_stpx", VCPU_STAT(instruction_stpx) }, 92453423dcSChristian Borntraeger { "instruction_stap", VCPU_STAT(instruction_stap) }, 93453423dcSChristian Borntraeger { "instruction_storage_key", VCPU_STAT(instruction_storage_key) }, 948a242234SHeiko Carstens { "instruction_ipte_interlock", VCPU_STAT(instruction_ipte_interlock) }, 95453423dcSChristian Borntraeger { "instruction_stsch", VCPU_STAT(instruction_stsch) }, 96453423dcSChristian Borntraeger { "instruction_chsc", VCPU_STAT(instruction_chsc) }, 97b31288faSKonstantin Weitz { "instruction_essa", VCPU_STAT(instruction_essa) }, 98453423dcSChristian Borntraeger { "instruction_stsi", VCPU_STAT(instruction_stsi) }, 99453423dcSChristian Borntraeger { "instruction_stfl", VCPU_STAT(instruction_stfl) }, 100bb25b9baSChristian Borntraeger { "instruction_tprot", VCPU_STAT(instruction_tprot) }, 10195ca2cb5SJanosch Frank { "instruction_sthyi", VCPU_STAT(instruction_sthyi) }, 102a3508fbeSDavid Hildenbrand { "instruction_sie", VCPU_STAT(instruction_sie) }, 1035288fbf0SChristian Borntraeger { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) }, 104bd59d3a4SCornelia Huck { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) }, 1057697e71fSChristian Ehrhardt { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) }, 1065288fbf0SChristian Borntraeger { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) }, 10742cb0c9fSDavid Hildenbrand { "instruction_sigp_cond_emergency", VCPU_STAT(instruction_sigp_cond_emergency) }, 10842cb0c9fSDavid Hildenbrand { "instruction_sigp_start", VCPU_STAT(instruction_sigp_start) }, 1095288fbf0SChristian Borntraeger { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) }, 11042cb0c9fSDavid Hildenbrand { "instruction_sigp_stop_store_status", VCPU_STAT(instruction_sigp_stop_store_status) }, 11142cb0c9fSDavid Hildenbrand { "instruction_sigp_store_status", VCPU_STAT(instruction_sigp_store_status) }, 112cd7b4b61SEric Farman { "instruction_sigp_store_adtl_status", VCPU_STAT(instruction_sigp_store_adtl_status) }, 1135288fbf0SChristian Borntraeger { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) }, 1145288fbf0SChristian Borntraeger { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) }, 1155288fbf0SChristian Borntraeger { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) }, 11642cb0c9fSDavid Hildenbrand { "instruction_sigp_cpu_reset", VCPU_STAT(instruction_sigp_cpu_reset) }, 11742cb0c9fSDavid Hildenbrand { "instruction_sigp_init_cpu_reset", VCPU_STAT(instruction_sigp_init_cpu_reset) }, 11842cb0c9fSDavid Hildenbrand { "instruction_sigp_unknown", VCPU_STAT(instruction_sigp_unknown) }, 119388186bcSChristian Borntraeger { "diagnose_10", VCPU_STAT(diagnose_10) }, 120e28acfeaSChristian Borntraeger { "diagnose_44", VCPU_STAT(diagnose_44) }, 12141628d33SKonstantin Weitz { "diagnose_9c", VCPU_STAT(diagnose_9c) }, 122175a5c9eSChristian Borntraeger { "diagnose_258", VCPU_STAT(diagnose_258) }, 123175a5c9eSChristian Borntraeger { "diagnose_308", VCPU_STAT(diagnose_308) }, 124175a5c9eSChristian Borntraeger { "diagnose_500", VCPU_STAT(diagnose_500) }, 125b0c632dbSHeiko Carstens { NULL } 126b0c632dbSHeiko Carstens }; 127b0c632dbSHeiko Carstens 1289d8d5786SMichael Mueller /* upper facilities limit for kvm */ 12960a37709SAlexander Yarygin unsigned long kvm_s390_fac_list_mask[16] = { 13060a37709SAlexander Yarygin 0xffe6000000000000UL, 13160a37709SAlexander Yarygin 0x005e000000000000UL, 1329d8d5786SMichael Mueller }; 133b0c632dbSHeiko Carstens 1349d8d5786SMichael Mueller unsigned long kvm_s390_fac_list_mask_size(void) 13578c4b59fSMichael Mueller { 1369d8d5786SMichael Mueller BUILD_BUG_ON(ARRAY_SIZE(kvm_s390_fac_list_mask) > S390_ARCH_FAC_MASK_SIZE_U64); 1379d8d5786SMichael Mueller return ARRAY_SIZE(kvm_s390_fac_list_mask); 13878c4b59fSMichael Mueller } 13978c4b59fSMichael Mueller 14015c9705fSDavid Hildenbrand /* available cpu features supported by kvm */ 14115c9705fSDavid Hildenbrand static DECLARE_BITMAP(kvm_s390_available_cpu_feat, KVM_S390_VM_CPU_FEAT_NR_BITS); 1420a763c78SDavid Hildenbrand /* available subfunctions indicated via query / "test bit" */ 1430a763c78SDavid Hildenbrand static struct kvm_s390_vm_cpu_subfunc kvm_s390_available_subfunc; 14415c9705fSDavid Hildenbrand 1459d8d5786SMichael Mueller static struct gmap_notifier gmap_notifier; 146a3508fbeSDavid Hildenbrand static struct gmap_notifier vsie_gmap_notifier; 14778f26131SChristian Borntraeger debug_info_t *kvm_s390_dbf; 1489d8d5786SMichael Mueller 149b0c632dbSHeiko Carstens /* Section: not file related */ 15013a34e06SRadim Krčmář int kvm_arch_hardware_enable(void) 151b0c632dbSHeiko Carstens { 152b0c632dbSHeiko Carstens /* every s390 is virtualization enabled ;-) */ 15310474ae8SAlexander Graf return 0; 154b0c632dbSHeiko Carstens } 155b0c632dbSHeiko Carstens 156414d3b07SMartin Schwidefsky static void kvm_gmap_notifier(struct gmap *gmap, unsigned long start, 157414d3b07SMartin Schwidefsky unsigned long end); 1582c70fe44SChristian Borntraeger 159fdf03650SFan Zhang /* 160fdf03650SFan Zhang * This callback is executed during stop_machine(). All CPUs are therefore 161fdf03650SFan Zhang * temporarily stopped. In order not to change guest behavior, we have to 162fdf03650SFan Zhang * disable preemption whenever we touch the epoch of kvm and the VCPUs, 163fdf03650SFan Zhang * so a CPU won't be stopped while calculating with the epoch. 164fdf03650SFan Zhang */ 165fdf03650SFan Zhang static int kvm_clock_sync(struct notifier_block *notifier, unsigned long val, 166fdf03650SFan Zhang void *v) 167fdf03650SFan Zhang { 168fdf03650SFan Zhang struct kvm *kvm; 169fdf03650SFan Zhang struct kvm_vcpu *vcpu; 170fdf03650SFan Zhang int i; 171fdf03650SFan Zhang unsigned long long *delta = v; 172fdf03650SFan Zhang 173fdf03650SFan Zhang list_for_each_entry(kvm, &vm_list, vm_list) { 174fdf03650SFan Zhang kvm->arch.epoch -= *delta; 175fdf03650SFan Zhang kvm_for_each_vcpu(i, vcpu, kvm) { 176fdf03650SFan Zhang vcpu->arch.sie_block->epoch -= *delta; 177db0758b2SDavid Hildenbrand if (vcpu->arch.cputm_enabled) 178db0758b2SDavid Hildenbrand vcpu->arch.cputm_start += *delta; 179fdf03650SFan Zhang } 180fdf03650SFan Zhang } 181fdf03650SFan Zhang return NOTIFY_OK; 182fdf03650SFan Zhang } 183fdf03650SFan Zhang 184fdf03650SFan Zhang static struct notifier_block kvm_clock_notifier = { 185fdf03650SFan Zhang .notifier_call = kvm_clock_sync, 186fdf03650SFan Zhang }; 187fdf03650SFan Zhang 188b0c632dbSHeiko Carstens int kvm_arch_hardware_setup(void) 189b0c632dbSHeiko Carstens { 1902c70fe44SChristian Borntraeger gmap_notifier.notifier_call = kvm_gmap_notifier; 191b2d73b2aSMartin Schwidefsky gmap_register_pte_notifier(&gmap_notifier); 192a3508fbeSDavid Hildenbrand vsie_gmap_notifier.notifier_call = kvm_s390_vsie_gmap_notifier; 193a3508fbeSDavid Hildenbrand gmap_register_pte_notifier(&vsie_gmap_notifier); 194fdf03650SFan Zhang atomic_notifier_chain_register(&s390_epoch_delta_notifier, 195fdf03650SFan Zhang &kvm_clock_notifier); 196b0c632dbSHeiko Carstens return 0; 197b0c632dbSHeiko Carstens } 198b0c632dbSHeiko Carstens 199b0c632dbSHeiko Carstens void kvm_arch_hardware_unsetup(void) 200b0c632dbSHeiko Carstens { 201b2d73b2aSMartin Schwidefsky gmap_unregister_pte_notifier(&gmap_notifier); 202a3508fbeSDavid Hildenbrand gmap_unregister_pte_notifier(&vsie_gmap_notifier); 203fdf03650SFan Zhang atomic_notifier_chain_unregister(&s390_epoch_delta_notifier, 204fdf03650SFan Zhang &kvm_clock_notifier); 205b0c632dbSHeiko Carstens } 206b0c632dbSHeiko Carstens 20722be5a13SDavid Hildenbrand static void allow_cpu_feat(unsigned long nr) 20822be5a13SDavid Hildenbrand { 20922be5a13SDavid Hildenbrand set_bit_inv(nr, kvm_s390_available_cpu_feat); 21022be5a13SDavid Hildenbrand } 21122be5a13SDavid Hildenbrand 2120a763c78SDavid Hildenbrand static inline int plo_test_bit(unsigned char nr) 2130a763c78SDavid Hildenbrand { 2140a763c78SDavid Hildenbrand register unsigned long r0 asm("0") = (unsigned long) nr | 0x100; 2150a763c78SDavid Hildenbrand int cc = 3; /* subfunction not available */ 2160a763c78SDavid Hildenbrand 2170a763c78SDavid Hildenbrand asm volatile( 2180a763c78SDavid Hildenbrand /* Parameter registers are ignored for "test bit" */ 2190a763c78SDavid Hildenbrand " plo 0,0,0,0(0)\n" 2200a763c78SDavid Hildenbrand " ipm %0\n" 2210a763c78SDavid Hildenbrand " srl %0,28\n" 2220a763c78SDavid Hildenbrand : "=d" (cc) 2230a763c78SDavid Hildenbrand : "d" (r0) 2240a763c78SDavid Hildenbrand : "cc"); 2250a763c78SDavid Hildenbrand return cc == 0; 2260a763c78SDavid Hildenbrand } 2270a763c78SDavid Hildenbrand 22822be5a13SDavid Hildenbrand static void kvm_s390_cpu_feat_init(void) 22922be5a13SDavid Hildenbrand { 2300a763c78SDavid Hildenbrand int i; 2310a763c78SDavid Hildenbrand 2320a763c78SDavid Hildenbrand for (i = 0; i < 256; ++i) { 2330a763c78SDavid Hildenbrand if (plo_test_bit(i)) 2340a763c78SDavid Hildenbrand kvm_s390_available_subfunc.plo[i >> 3] |= 0x80 >> (i & 7); 2350a763c78SDavid Hildenbrand } 2360a763c78SDavid Hildenbrand 2370a763c78SDavid Hildenbrand if (test_facility(28)) /* TOD-clock steering */ 2380a763c78SDavid Hildenbrand etr_ptff(kvm_s390_available_subfunc.ptff, ETR_PTFF_QAF); 2390a763c78SDavid Hildenbrand 2400a763c78SDavid Hildenbrand if (test_facility(17)) { /* MSA */ 2410a763c78SDavid Hildenbrand __cpacf_query(CPACF_KMAC, kvm_s390_available_subfunc.kmac); 2420a763c78SDavid Hildenbrand __cpacf_query(CPACF_KMC, kvm_s390_available_subfunc.kmc); 2430a763c78SDavid Hildenbrand __cpacf_query(CPACF_KM, kvm_s390_available_subfunc.km); 2440a763c78SDavid Hildenbrand __cpacf_query(CPACF_KIMD, kvm_s390_available_subfunc.kimd); 2450a763c78SDavid Hildenbrand __cpacf_query(CPACF_KLMD, kvm_s390_available_subfunc.klmd); 2460a763c78SDavid Hildenbrand } 2470a763c78SDavid Hildenbrand if (test_facility(76)) /* MSA3 */ 2480a763c78SDavid Hildenbrand __cpacf_query(CPACF_PCKMO, kvm_s390_available_subfunc.pckmo); 2490a763c78SDavid Hildenbrand if (test_facility(77)) { /* MSA4 */ 2500a763c78SDavid Hildenbrand __cpacf_query(CPACF_KMCTR, kvm_s390_available_subfunc.kmctr); 2510a763c78SDavid Hildenbrand __cpacf_query(CPACF_KMF, kvm_s390_available_subfunc.kmf); 2520a763c78SDavid Hildenbrand __cpacf_query(CPACF_KMO, kvm_s390_available_subfunc.kmo); 2530a763c78SDavid Hildenbrand __cpacf_query(CPACF_PCC, kvm_s390_available_subfunc.pcc); 2540a763c78SDavid Hildenbrand } 2550a763c78SDavid Hildenbrand if (test_facility(57)) /* MSA5 */ 2560a763c78SDavid Hildenbrand __cpacf_query(CPACF_PPNO, kvm_s390_available_subfunc.ppno); 2570a763c78SDavid Hildenbrand 25822be5a13SDavid Hildenbrand if (MACHINE_HAS_ESOP) 25922be5a13SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_ESOP); 260a3508fbeSDavid Hildenbrand /* 261a3508fbeSDavid Hildenbrand * We need SIE support, ESOP (PROT_READ protection for gmap_shadow), 262a3508fbeSDavid Hildenbrand * 64bit SCAO (SCA passthrough) and IDTE (for gmap_shadow unshadowing). 263a3508fbeSDavid Hildenbrand */ 264a3508fbeSDavid Hildenbrand if (!sclp.has_sief2 || !MACHINE_HAS_ESOP || !sclp.has_64bscao || 265a3508fbeSDavid Hildenbrand !test_facility(3)) 266a3508fbeSDavid Hildenbrand return; 267a3508fbeSDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_SIEF2); 26819c439b5SDavid Hildenbrand if (sclp.has_64bscao) 26919c439b5SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_64BSCAO); 2700615a326SDavid Hildenbrand if (sclp.has_siif) 2710615a326SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_SIIF); 272*77d18f6dSDavid Hildenbrand if (sclp.has_gpere) 273*77d18f6dSDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_GPERE); 27422be5a13SDavid Hildenbrand } 27522be5a13SDavid Hildenbrand 276b0c632dbSHeiko Carstens int kvm_arch_init(void *opaque) 277b0c632dbSHeiko Carstens { 27878f26131SChristian Borntraeger kvm_s390_dbf = debug_register("kvm-trace", 32, 1, 7 * sizeof(long)); 27978f26131SChristian Borntraeger if (!kvm_s390_dbf) 28078f26131SChristian Borntraeger return -ENOMEM; 28178f26131SChristian Borntraeger 28278f26131SChristian Borntraeger if (debug_register_view(kvm_s390_dbf, &debug_sprintf_view)) { 28378f26131SChristian Borntraeger debug_unregister(kvm_s390_dbf); 28478f26131SChristian Borntraeger return -ENOMEM; 28578f26131SChristian Borntraeger } 28678f26131SChristian Borntraeger 28722be5a13SDavid Hildenbrand kvm_s390_cpu_feat_init(); 28822be5a13SDavid Hildenbrand 28984877d93SCornelia Huck /* Register floating interrupt controller interface. */ 29084877d93SCornelia Huck return kvm_register_device_ops(&kvm_flic_ops, KVM_DEV_TYPE_FLIC); 291b0c632dbSHeiko Carstens } 292b0c632dbSHeiko Carstens 29378f26131SChristian Borntraeger void kvm_arch_exit(void) 29478f26131SChristian Borntraeger { 29578f26131SChristian Borntraeger debug_unregister(kvm_s390_dbf); 29678f26131SChristian Borntraeger } 29778f26131SChristian Borntraeger 298b0c632dbSHeiko Carstens /* Section: device related */ 299b0c632dbSHeiko Carstens long kvm_arch_dev_ioctl(struct file *filp, 300b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 301b0c632dbSHeiko Carstens { 302b0c632dbSHeiko Carstens if (ioctl == KVM_S390_ENABLE_SIE) 303b0c632dbSHeiko Carstens return s390_enable_sie(); 304b0c632dbSHeiko Carstens return -EINVAL; 305b0c632dbSHeiko Carstens } 306b0c632dbSHeiko Carstens 307784aa3d7SAlexander Graf int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) 308b0c632dbSHeiko Carstens { 309d7b0b5ebSCarsten Otte int r; 310d7b0b5ebSCarsten Otte 3112bd0ac4eSCarsten Otte switch (ext) { 312d7b0b5ebSCarsten Otte case KVM_CAP_S390_PSW: 313b6cf8788SChristian Borntraeger case KVM_CAP_S390_GMAP: 31452e16b18SChristian Borntraeger case KVM_CAP_SYNC_MMU: 3151efd0f59SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 3161efd0f59SCarsten Otte case KVM_CAP_S390_UCONTROL: 3171efd0f59SCarsten Otte #endif 3183c038e6bSDominik Dingel case KVM_CAP_ASYNC_PF: 31960b413c9SChristian Borntraeger case KVM_CAP_SYNC_REGS: 32014eebd91SCarsten Otte case KVM_CAP_ONE_REG: 321d6712df9SCornelia Huck case KVM_CAP_ENABLE_CAP: 322fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 32310ccaa1eSCornelia Huck case KVM_CAP_IOEVENTFD: 324c05c4186SJens Freimann case KVM_CAP_DEVICE_CTRL: 325d938dc55SCornelia Huck case KVM_CAP_ENABLE_CAP_VM: 32678599d90SCornelia Huck case KVM_CAP_S390_IRQCHIP: 327f2061656SDominik Dingel case KVM_CAP_VM_ATTRIBUTES: 3286352e4d2SDavid Hildenbrand case KVM_CAP_MP_STATE: 32947b43c52SJens Freimann case KVM_CAP_S390_INJECT_IRQ: 3302444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 331e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 33230ee2a98SJason J. Herne case KVM_CAP_S390_SKEYS: 333816c7667SJens Freimann case KVM_CAP_S390_IRQ_STATE: 334d7b0b5ebSCarsten Otte r = 1; 335d7b0b5ebSCarsten Otte break; 33641408c28SThomas Huth case KVM_CAP_S390_MEM_OP: 33741408c28SThomas Huth r = MEM_OP_MAX_SIZE; 33841408c28SThomas Huth break; 339e726b1bdSChristian Borntraeger case KVM_CAP_NR_VCPUS: 340e726b1bdSChristian Borntraeger case KVM_CAP_MAX_VCPUS: 34176a6dd72SDavid Hildenbrand r = KVM_S390_BSCA_CPU_SLOTS; 34276a6dd72SDavid Hildenbrand if (sclp.has_esca && sclp.has_64bscao) 34376a6dd72SDavid Hildenbrand r = KVM_S390_ESCA_CPU_SLOTS; 344e726b1bdSChristian Borntraeger break; 345e1e2e605SNick Wang case KVM_CAP_NR_MEMSLOTS: 346e1e2e605SNick Wang r = KVM_USER_MEM_SLOTS; 347e1e2e605SNick Wang break; 3481526bf9cSChristian Borntraeger case KVM_CAP_S390_COW: 349abf09bedSMartin Schwidefsky r = MACHINE_HAS_ESOP; 3501526bf9cSChristian Borntraeger break; 35168c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 35268c55750SEric Farman r = MACHINE_HAS_VX; 35368c55750SEric Farman break; 354c6e5f166SFan Zhang case KVM_CAP_S390_RI: 355c6e5f166SFan Zhang r = test_facility(64); 356c6e5f166SFan Zhang break; 3572bd0ac4eSCarsten Otte default: 358d7b0b5ebSCarsten Otte r = 0; 359b0c632dbSHeiko Carstens } 360d7b0b5ebSCarsten Otte return r; 3612bd0ac4eSCarsten Otte } 362b0c632dbSHeiko Carstens 36315f36ebdSJason J. Herne static void kvm_s390_sync_dirty_log(struct kvm *kvm, 36415f36ebdSJason J. Herne struct kvm_memory_slot *memslot) 36515f36ebdSJason J. Herne { 36615f36ebdSJason J. Herne gfn_t cur_gfn, last_gfn; 36715f36ebdSJason J. Herne unsigned long address; 36815f36ebdSJason J. Herne struct gmap *gmap = kvm->arch.gmap; 36915f36ebdSJason J. Herne 37015f36ebdSJason J. Herne /* Loop over all guest pages */ 37115f36ebdSJason J. Herne last_gfn = memslot->base_gfn + memslot->npages; 37215f36ebdSJason J. Herne for (cur_gfn = memslot->base_gfn; cur_gfn <= last_gfn; cur_gfn++) { 37315f36ebdSJason J. Herne address = gfn_to_hva_memslot(memslot, cur_gfn); 37415f36ebdSJason J. Herne 3751e133ab2SMartin Schwidefsky if (test_and_clear_guest_dirty(gmap->mm, address)) 37615f36ebdSJason J. Herne mark_page_dirty(kvm, cur_gfn); 3771763f8d0SChristian Borntraeger if (fatal_signal_pending(current)) 3781763f8d0SChristian Borntraeger return; 37970c88a00SChristian Borntraeger cond_resched(); 38015f36ebdSJason J. Herne } 38115f36ebdSJason J. Herne } 38215f36ebdSJason J. Herne 383b0c632dbSHeiko Carstens /* Section: vm related */ 384a6e2f683SEugene (jno) Dvurechenski static void sca_del_vcpu(struct kvm_vcpu *vcpu); 385a6e2f683SEugene (jno) Dvurechenski 386b0c632dbSHeiko Carstens /* 387b0c632dbSHeiko Carstens * Get (and clear) the dirty memory log for a memory slot. 388b0c632dbSHeiko Carstens */ 389b0c632dbSHeiko Carstens int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, 390b0c632dbSHeiko Carstens struct kvm_dirty_log *log) 391b0c632dbSHeiko Carstens { 39215f36ebdSJason J. Herne int r; 39315f36ebdSJason J. Herne unsigned long n; 3949f6b8029SPaolo Bonzini struct kvm_memslots *slots; 39515f36ebdSJason J. Herne struct kvm_memory_slot *memslot; 39615f36ebdSJason J. Herne int is_dirty = 0; 39715f36ebdSJason J. Herne 39815f36ebdSJason J. Herne mutex_lock(&kvm->slots_lock); 39915f36ebdSJason J. Herne 40015f36ebdSJason J. Herne r = -EINVAL; 40115f36ebdSJason J. Herne if (log->slot >= KVM_USER_MEM_SLOTS) 40215f36ebdSJason J. Herne goto out; 40315f36ebdSJason J. Herne 4049f6b8029SPaolo Bonzini slots = kvm_memslots(kvm); 4059f6b8029SPaolo Bonzini memslot = id_to_memslot(slots, log->slot); 40615f36ebdSJason J. Herne r = -ENOENT; 40715f36ebdSJason J. Herne if (!memslot->dirty_bitmap) 40815f36ebdSJason J. Herne goto out; 40915f36ebdSJason J. Herne 41015f36ebdSJason J. Herne kvm_s390_sync_dirty_log(kvm, memslot); 41115f36ebdSJason J. Herne r = kvm_get_dirty_log(kvm, log, &is_dirty); 41215f36ebdSJason J. Herne if (r) 41315f36ebdSJason J. Herne goto out; 41415f36ebdSJason J. Herne 41515f36ebdSJason J. Herne /* Clear the dirty log */ 41615f36ebdSJason J. Herne if (is_dirty) { 41715f36ebdSJason J. Herne n = kvm_dirty_bitmap_bytes(memslot); 41815f36ebdSJason J. Herne memset(memslot->dirty_bitmap, 0, n); 41915f36ebdSJason J. Herne } 42015f36ebdSJason J. Herne r = 0; 42115f36ebdSJason J. Herne out: 42215f36ebdSJason J. Herne mutex_unlock(&kvm->slots_lock); 42315f36ebdSJason J. Herne return r; 424b0c632dbSHeiko Carstens } 425b0c632dbSHeiko Carstens 426d938dc55SCornelia Huck static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap) 427d938dc55SCornelia Huck { 428d938dc55SCornelia Huck int r; 429d938dc55SCornelia Huck 430d938dc55SCornelia Huck if (cap->flags) 431d938dc55SCornelia Huck return -EINVAL; 432d938dc55SCornelia Huck 433d938dc55SCornelia Huck switch (cap->cap) { 43484223598SCornelia Huck case KVM_CAP_S390_IRQCHIP: 435c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_IRQCHIP"); 43684223598SCornelia Huck kvm->arch.use_irqchip = 1; 43784223598SCornelia Huck r = 0; 43884223598SCornelia Huck break; 4392444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 440c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_SIGP"); 4412444b352SDavid Hildenbrand kvm->arch.user_sigp = 1; 4422444b352SDavid Hildenbrand r = 0; 4432444b352SDavid Hildenbrand break; 44468c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 4455967c17bSDavid Hildenbrand mutex_lock(&kvm->lock); 446a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 4475967c17bSDavid Hildenbrand r = -EBUSY; 4485967c17bSDavid Hildenbrand } else if (MACHINE_HAS_VX) { 449c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 129); 450c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 129); 45118280d8bSMichael Mueller r = 0; 45218280d8bSMichael Mueller } else 45318280d8bSMichael Mueller r = -EINVAL; 4545967c17bSDavid Hildenbrand mutex_unlock(&kvm->lock); 455c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "ENABLE: CAP_S390_VECTOR_REGISTERS %s", 456c92ea7b9SChristian Borntraeger r ? "(not available)" : "(success)"); 45768c55750SEric Farman break; 458c6e5f166SFan Zhang case KVM_CAP_S390_RI: 459c6e5f166SFan Zhang r = -EINVAL; 460c6e5f166SFan Zhang mutex_lock(&kvm->lock); 461a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 462c6e5f166SFan Zhang r = -EBUSY; 463c6e5f166SFan Zhang } else if (test_facility(64)) { 464c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 64); 465c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 64); 466c6e5f166SFan Zhang r = 0; 467c6e5f166SFan Zhang } 468c6e5f166SFan Zhang mutex_unlock(&kvm->lock); 469c6e5f166SFan Zhang VM_EVENT(kvm, 3, "ENABLE: CAP_S390_RI %s", 470c6e5f166SFan Zhang r ? "(not available)" : "(success)"); 471c6e5f166SFan Zhang break; 472e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 473c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_STSI"); 474e44fc8c9SEkaterina Tumanova kvm->arch.user_stsi = 1; 475e44fc8c9SEkaterina Tumanova r = 0; 476e44fc8c9SEkaterina Tumanova break; 477d938dc55SCornelia Huck default: 478d938dc55SCornelia Huck r = -EINVAL; 479d938dc55SCornelia Huck break; 480d938dc55SCornelia Huck } 481d938dc55SCornelia Huck return r; 482d938dc55SCornelia Huck } 483d938dc55SCornelia Huck 4848c0a7ce6SDominik Dingel static int kvm_s390_get_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 4858c0a7ce6SDominik Dingel { 4868c0a7ce6SDominik Dingel int ret; 4878c0a7ce6SDominik Dingel 4888c0a7ce6SDominik Dingel switch (attr->attr) { 4898c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 4908c0a7ce6SDominik Dingel ret = 0; 491c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: max guest memory: %lu bytes", 492a3a92c31SDominik Dingel kvm->arch.mem_limit); 493a3a92c31SDominik Dingel if (put_user(kvm->arch.mem_limit, (u64 __user *)attr->addr)) 4948c0a7ce6SDominik Dingel ret = -EFAULT; 4958c0a7ce6SDominik Dingel break; 4968c0a7ce6SDominik Dingel default: 4978c0a7ce6SDominik Dingel ret = -ENXIO; 4988c0a7ce6SDominik Dingel break; 4998c0a7ce6SDominik Dingel } 5008c0a7ce6SDominik Dingel return ret; 5018c0a7ce6SDominik Dingel } 5028c0a7ce6SDominik Dingel 5038c0a7ce6SDominik Dingel static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 5044f718eabSDominik Dingel { 5054f718eabSDominik Dingel int ret; 5064f718eabSDominik Dingel unsigned int idx; 5074f718eabSDominik Dingel switch (attr->attr) { 5084f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 509f9cbd9b0SDavid Hildenbrand ret = -ENXIO; 510c24cc9c8SDavid Hildenbrand if (!sclp.has_cmma) 511e6db1d61SDominik Dingel break; 512e6db1d61SDominik Dingel 5134f718eabSDominik Dingel ret = -EBUSY; 514c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CMMA support"); 5154f718eabSDominik Dingel mutex_lock(&kvm->lock); 516a03825bbSPaolo Bonzini if (!kvm->created_vcpus) { 5174f718eabSDominik Dingel kvm->arch.use_cmma = 1; 5184f718eabSDominik Dingel ret = 0; 5194f718eabSDominik Dingel } 5204f718eabSDominik Dingel mutex_unlock(&kvm->lock); 5214f718eabSDominik Dingel break; 5224f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 523f9cbd9b0SDavid Hildenbrand ret = -ENXIO; 524f9cbd9b0SDavid Hildenbrand if (!sclp.has_cmma) 525f9cbd9b0SDavid Hildenbrand break; 526c3489155SDominik Dingel ret = -EINVAL; 527c3489155SDominik Dingel if (!kvm->arch.use_cmma) 528c3489155SDominik Dingel break; 529c3489155SDominik Dingel 530c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "RESET: CMMA states"); 5314f718eabSDominik Dingel mutex_lock(&kvm->lock); 5324f718eabSDominik Dingel idx = srcu_read_lock(&kvm->srcu); 533a13cff31SDominik Dingel s390_reset_cmma(kvm->arch.gmap->mm); 5344f718eabSDominik Dingel srcu_read_unlock(&kvm->srcu, idx); 5354f718eabSDominik Dingel mutex_unlock(&kvm->lock); 5364f718eabSDominik Dingel ret = 0; 5374f718eabSDominik Dingel break; 5388c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: { 5398c0a7ce6SDominik Dingel unsigned long new_limit; 5408c0a7ce6SDominik Dingel 5418c0a7ce6SDominik Dingel if (kvm_is_ucontrol(kvm)) 5428c0a7ce6SDominik Dingel return -EINVAL; 5438c0a7ce6SDominik Dingel 5448c0a7ce6SDominik Dingel if (get_user(new_limit, (u64 __user *)attr->addr)) 5458c0a7ce6SDominik Dingel return -EFAULT; 5468c0a7ce6SDominik Dingel 547a3a92c31SDominik Dingel if (kvm->arch.mem_limit != KVM_S390_NO_MEM_LIMIT && 548a3a92c31SDominik Dingel new_limit > kvm->arch.mem_limit) 5498c0a7ce6SDominik Dingel return -E2BIG; 5508c0a7ce6SDominik Dingel 551a3a92c31SDominik Dingel if (!new_limit) 552a3a92c31SDominik Dingel return -EINVAL; 553a3a92c31SDominik Dingel 5546ea427bbSMartin Schwidefsky /* gmap_create takes last usable address */ 555a3a92c31SDominik Dingel if (new_limit != KVM_S390_NO_MEM_LIMIT) 556a3a92c31SDominik Dingel new_limit -= 1; 557a3a92c31SDominik Dingel 5588c0a7ce6SDominik Dingel ret = -EBUSY; 5598c0a7ce6SDominik Dingel mutex_lock(&kvm->lock); 560a03825bbSPaolo Bonzini if (!kvm->created_vcpus) { 5616ea427bbSMartin Schwidefsky /* gmap_create will round the limit up */ 5626ea427bbSMartin Schwidefsky struct gmap *new = gmap_create(current->mm, new_limit); 5638c0a7ce6SDominik Dingel 5648c0a7ce6SDominik Dingel if (!new) { 5658c0a7ce6SDominik Dingel ret = -ENOMEM; 5668c0a7ce6SDominik Dingel } else { 5676ea427bbSMartin Schwidefsky gmap_remove(kvm->arch.gmap); 5688c0a7ce6SDominik Dingel new->private = kvm; 5698c0a7ce6SDominik Dingel kvm->arch.gmap = new; 5708c0a7ce6SDominik Dingel ret = 0; 5718c0a7ce6SDominik Dingel } 5728c0a7ce6SDominik Dingel } 5738c0a7ce6SDominik Dingel mutex_unlock(&kvm->lock); 574a3a92c31SDominik Dingel VM_EVENT(kvm, 3, "SET: max guest address: %lu", new_limit); 575a3a92c31SDominik Dingel VM_EVENT(kvm, 3, "New guest asce: 0x%pK", 576a3a92c31SDominik Dingel (void *) kvm->arch.gmap->asce); 5778c0a7ce6SDominik Dingel break; 5788c0a7ce6SDominik Dingel } 5794f718eabSDominik Dingel default: 5804f718eabSDominik Dingel ret = -ENXIO; 5814f718eabSDominik Dingel break; 5824f718eabSDominik Dingel } 5834f718eabSDominik Dingel return ret; 5844f718eabSDominik Dingel } 5854f718eabSDominik Dingel 586a374e892STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu); 587a374e892STony Krowiak 588a374e892STony Krowiak static int kvm_s390_vm_set_crypto(struct kvm *kvm, struct kvm_device_attr *attr) 589a374e892STony Krowiak { 590a374e892STony Krowiak struct kvm_vcpu *vcpu; 591a374e892STony Krowiak int i; 592a374e892STony Krowiak 5939d8d5786SMichael Mueller if (!test_kvm_facility(kvm, 76)) 594a374e892STony Krowiak return -EINVAL; 595a374e892STony Krowiak 596a374e892STony Krowiak mutex_lock(&kvm->lock); 597a374e892STony Krowiak switch (attr->attr) { 598a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 599a374e892STony Krowiak get_random_bytes( 600a374e892STony Krowiak kvm->arch.crypto.crycb->aes_wrapping_key_mask, 601a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 602a374e892STony Krowiak kvm->arch.crypto.aes_kw = 1; 603c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: AES keywrapping support"); 604a374e892STony Krowiak break; 605a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 606a374e892STony Krowiak get_random_bytes( 607a374e892STony Krowiak kvm->arch.crypto.crycb->dea_wrapping_key_mask, 608a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 609a374e892STony Krowiak kvm->arch.crypto.dea_kw = 1; 610c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: DEA keywrapping support"); 611a374e892STony Krowiak break; 612a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 613a374e892STony Krowiak kvm->arch.crypto.aes_kw = 0; 614a374e892STony Krowiak memset(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 0, 615a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 616c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "DISABLE: AES keywrapping support"); 617a374e892STony Krowiak break; 618a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 619a374e892STony Krowiak kvm->arch.crypto.dea_kw = 0; 620a374e892STony Krowiak memset(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 0, 621a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 622c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "DISABLE: DEA keywrapping support"); 623a374e892STony Krowiak break; 624a374e892STony Krowiak default: 625a374e892STony Krowiak mutex_unlock(&kvm->lock); 626a374e892STony Krowiak return -ENXIO; 627a374e892STony Krowiak } 628a374e892STony Krowiak 629a374e892STony Krowiak kvm_for_each_vcpu(i, vcpu, kvm) { 630a374e892STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 631a374e892STony Krowiak exit_sie(vcpu); 632a374e892STony Krowiak } 633a374e892STony Krowiak mutex_unlock(&kvm->lock); 634a374e892STony Krowiak return 0; 635a374e892STony Krowiak } 636a374e892STony Krowiak 63772f25020SJason J. Herne static int kvm_s390_set_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 63872f25020SJason J. Herne { 63972f25020SJason J. Herne u8 gtod_high; 64072f25020SJason J. Herne 64172f25020SJason J. Herne if (copy_from_user(>od_high, (void __user *)attr->addr, 64272f25020SJason J. Herne sizeof(gtod_high))) 64372f25020SJason J. Herne return -EFAULT; 64472f25020SJason J. Herne 64572f25020SJason J. Herne if (gtod_high != 0) 64672f25020SJason J. Herne return -EINVAL; 64758c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "SET: TOD extension: 0x%x", gtod_high); 64872f25020SJason J. Herne 64972f25020SJason J. Herne return 0; 65072f25020SJason J. Herne } 65172f25020SJason J. Herne 65272f25020SJason J. Herne static int kvm_s390_set_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 65372f25020SJason J. Herne { 6545a3d883aSDavid Hildenbrand u64 gtod; 65572f25020SJason J. Herne 65672f25020SJason J. Herne if (copy_from_user(>od, (void __user *)attr->addr, sizeof(gtod))) 65772f25020SJason J. Herne return -EFAULT; 65872f25020SJason J. Herne 65925ed1675SDavid Hildenbrand kvm_s390_set_tod_clock(kvm, gtod); 66058c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "SET: TOD base: 0x%llx", gtod); 66172f25020SJason J. Herne return 0; 66272f25020SJason J. Herne } 66372f25020SJason J. Herne 66472f25020SJason J. Herne static int kvm_s390_set_tod(struct kvm *kvm, struct kvm_device_attr *attr) 66572f25020SJason J. Herne { 66672f25020SJason J. Herne int ret; 66772f25020SJason J. Herne 66872f25020SJason J. Herne if (attr->flags) 66972f25020SJason J. Herne return -EINVAL; 67072f25020SJason J. Herne 67172f25020SJason J. Herne switch (attr->attr) { 67272f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 67372f25020SJason J. Herne ret = kvm_s390_set_tod_high(kvm, attr); 67472f25020SJason J. Herne break; 67572f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 67672f25020SJason J. Herne ret = kvm_s390_set_tod_low(kvm, attr); 67772f25020SJason J. Herne break; 67872f25020SJason J. Herne default: 67972f25020SJason J. Herne ret = -ENXIO; 68072f25020SJason J. Herne break; 68172f25020SJason J. Herne } 68272f25020SJason J. Herne return ret; 68372f25020SJason J. Herne } 68472f25020SJason J. Herne 68572f25020SJason J. Herne static int kvm_s390_get_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 68672f25020SJason J. Herne { 68772f25020SJason J. Herne u8 gtod_high = 0; 68872f25020SJason J. Herne 68972f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od_high, 69072f25020SJason J. Herne sizeof(gtod_high))) 69172f25020SJason J. Herne return -EFAULT; 69258c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: TOD extension: 0x%x", gtod_high); 69372f25020SJason J. Herne 69472f25020SJason J. Herne return 0; 69572f25020SJason J. Herne } 69672f25020SJason J. Herne 69772f25020SJason J. Herne static int kvm_s390_get_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 69872f25020SJason J. Herne { 6995a3d883aSDavid Hildenbrand u64 gtod; 70072f25020SJason J. Herne 70160417fccSDavid Hildenbrand gtod = kvm_s390_get_tod_clock_fast(kvm); 70272f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od, sizeof(gtod))) 70372f25020SJason J. Herne return -EFAULT; 70458c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: TOD base: 0x%llx", gtod); 70572f25020SJason J. Herne 70672f25020SJason J. Herne return 0; 70772f25020SJason J. Herne } 70872f25020SJason J. Herne 70972f25020SJason J. Herne static int kvm_s390_get_tod(struct kvm *kvm, struct kvm_device_attr *attr) 71072f25020SJason J. Herne { 71172f25020SJason J. Herne int ret; 71272f25020SJason J. Herne 71372f25020SJason J. Herne if (attr->flags) 71472f25020SJason J. Herne return -EINVAL; 71572f25020SJason J. Herne 71672f25020SJason J. Herne switch (attr->attr) { 71772f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 71872f25020SJason J. Herne ret = kvm_s390_get_tod_high(kvm, attr); 71972f25020SJason J. Herne break; 72072f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 72172f25020SJason J. Herne ret = kvm_s390_get_tod_low(kvm, attr); 72272f25020SJason J. Herne break; 72372f25020SJason J. Herne default: 72472f25020SJason J. Herne ret = -ENXIO; 72572f25020SJason J. Herne break; 72672f25020SJason J. Herne } 72772f25020SJason J. Herne return ret; 72872f25020SJason J. Herne } 72972f25020SJason J. Herne 730658b6edaSMichael Mueller static int kvm_s390_set_processor(struct kvm *kvm, struct kvm_device_attr *attr) 731658b6edaSMichael Mueller { 732658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 733053dd230SDavid Hildenbrand u16 lowest_ibc, unblocked_ibc; 734658b6edaSMichael Mueller int ret = 0; 735658b6edaSMichael Mueller 736658b6edaSMichael Mueller mutex_lock(&kvm->lock); 737a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 738658b6edaSMichael Mueller ret = -EBUSY; 739658b6edaSMichael Mueller goto out; 740658b6edaSMichael Mueller } 741658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 742658b6edaSMichael Mueller if (!proc) { 743658b6edaSMichael Mueller ret = -ENOMEM; 744658b6edaSMichael Mueller goto out; 745658b6edaSMichael Mueller } 746658b6edaSMichael Mueller if (!copy_from_user(proc, (void __user *)attr->addr, 747658b6edaSMichael Mueller sizeof(*proc))) { 7489bb0ec09SDavid Hildenbrand kvm->arch.model.cpuid = proc->cpuid; 749053dd230SDavid Hildenbrand lowest_ibc = sclp.ibc >> 16 & 0xfff; 750053dd230SDavid Hildenbrand unblocked_ibc = sclp.ibc & 0xfff; 751053dd230SDavid Hildenbrand if (lowest_ibc) { 752053dd230SDavid Hildenbrand if (proc->ibc > unblocked_ibc) 753053dd230SDavid Hildenbrand kvm->arch.model.ibc = unblocked_ibc; 754053dd230SDavid Hildenbrand else if (proc->ibc < lowest_ibc) 755053dd230SDavid Hildenbrand kvm->arch.model.ibc = lowest_ibc; 756053dd230SDavid Hildenbrand else 757658b6edaSMichael Mueller kvm->arch.model.ibc = proc->ibc; 758053dd230SDavid Hildenbrand } 759c54f0d6aSDavid Hildenbrand memcpy(kvm->arch.model.fac_list, proc->fac_list, 760658b6edaSMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 761658b6edaSMichael Mueller } else 762658b6edaSMichael Mueller ret = -EFAULT; 763658b6edaSMichael Mueller kfree(proc); 764658b6edaSMichael Mueller out: 765658b6edaSMichael Mueller mutex_unlock(&kvm->lock); 766658b6edaSMichael Mueller return ret; 767658b6edaSMichael Mueller } 768658b6edaSMichael Mueller 76915c9705fSDavid Hildenbrand static int kvm_s390_set_processor_feat(struct kvm *kvm, 77015c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 77115c9705fSDavid Hildenbrand { 77215c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 77315c9705fSDavid Hildenbrand int ret = -EBUSY; 77415c9705fSDavid Hildenbrand 77515c9705fSDavid Hildenbrand if (copy_from_user(&data, (void __user *)attr->addr, sizeof(data))) 77615c9705fSDavid Hildenbrand return -EFAULT; 77715c9705fSDavid Hildenbrand if (!bitmap_subset((unsigned long *) data.feat, 77815c9705fSDavid Hildenbrand kvm_s390_available_cpu_feat, 77915c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS)) 78015c9705fSDavid Hildenbrand return -EINVAL; 78115c9705fSDavid Hildenbrand 78215c9705fSDavid Hildenbrand mutex_lock(&kvm->lock); 78315c9705fSDavid Hildenbrand if (!atomic_read(&kvm->online_vcpus)) { 78415c9705fSDavid Hildenbrand bitmap_copy(kvm->arch.cpu_feat, (unsigned long *) data.feat, 78515c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 78615c9705fSDavid Hildenbrand ret = 0; 78715c9705fSDavid Hildenbrand } 78815c9705fSDavid Hildenbrand mutex_unlock(&kvm->lock); 78915c9705fSDavid Hildenbrand return ret; 79015c9705fSDavid Hildenbrand } 79115c9705fSDavid Hildenbrand 7920a763c78SDavid Hildenbrand static int kvm_s390_set_processor_subfunc(struct kvm *kvm, 7930a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 7940a763c78SDavid Hildenbrand { 7950a763c78SDavid Hildenbrand /* 7960a763c78SDavid Hildenbrand * Once supported by kernel + hw, we have to store the subfunctions 7970a763c78SDavid Hildenbrand * in kvm->arch and remember that user space configured them. 7980a763c78SDavid Hildenbrand */ 7990a763c78SDavid Hildenbrand return -ENXIO; 8000a763c78SDavid Hildenbrand } 8010a763c78SDavid Hildenbrand 802658b6edaSMichael Mueller static int kvm_s390_set_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 803658b6edaSMichael Mueller { 804658b6edaSMichael Mueller int ret = -ENXIO; 805658b6edaSMichael Mueller 806658b6edaSMichael Mueller switch (attr->attr) { 807658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 808658b6edaSMichael Mueller ret = kvm_s390_set_processor(kvm, attr); 809658b6edaSMichael Mueller break; 81015c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 81115c9705fSDavid Hildenbrand ret = kvm_s390_set_processor_feat(kvm, attr); 81215c9705fSDavid Hildenbrand break; 8130a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 8140a763c78SDavid Hildenbrand ret = kvm_s390_set_processor_subfunc(kvm, attr); 8150a763c78SDavid Hildenbrand break; 816658b6edaSMichael Mueller } 817658b6edaSMichael Mueller return ret; 818658b6edaSMichael Mueller } 819658b6edaSMichael Mueller 820658b6edaSMichael Mueller static int kvm_s390_get_processor(struct kvm *kvm, struct kvm_device_attr *attr) 821658b6edaSMichael Mueller { 822658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 823658b6edaSMichael Mueller int ret = 0; 824658b6edaSMichael Mueller 825658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 826658b6edaSMichael Mueller if (!proc) { 827658b6edaSMichael Mueller ret = -ENOMEM; 828658b6edaSMichael Mueller goto out; 829658b6edaSMichael Mueller } 8309bb0ec09SDavid Hildenbrand proc->cpuid = kvm->arch.model.cpuid; 831658b6edaSMichael Mueller proc->ibc = kvm->arch.model.ibc; 832c54f0d6aSDavid Hildenbrand memcpy(&proc->fac_list, kvm->arch.model.fac_list, 833c54f0d6aSDavid Hildenbrand S390_ARCH_FAC_LIST_SIZE_BYTE); 834658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, proc, sizeof(*proc))) 835658b6edaSMichael Mueller ret = -EFAULT; 836658b6edaSMichael Mueller kfree(proc); 837658b6edaSMichael Mueller out: 838658b6edaSMichael Mueller return ret; 839658b6edaSMichael Mueller } 840658b6edaSMichael Mueller 841658b6edaSMichael Mueller static int kvm_s390_get_machine(struct kvm *kvm, struct kvm_device_attr *attr) 842658b6edaSMichael Mueller { 843658b6edaSMichael Mueller struct kvm_s390_vm_cpu_machine *mach; 844658b6edaSMichael Mueller int ret = 0; 845658b6edaSMichael Mueller 846658b6edaSMichael Mueller mach = kzalloc(sizeof(*mach), GFP_KERNEL); 847658b6edaSMichael Mueller if (!mach) { 848658b6edaSMichael Mueller ret = -ENOMEM; 849658b6edaSMichael Mueller goto out; 850658b6edaSMichael Mueller } 851658b6edaSMichael Mueller get_cpu_id((struct cpuid *) &mach->cpuid); 85237c5f6c8SDavid Hildenbrand mach->ibc = sclp.ibc; 853c54f0d6aSDavid Hildenbrand memcpy(&mach->fac_mask, kvm->arch.model.fac_mask, 854981467c9SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 855658b6edaSMichael Mueller memcpy((unsigned long *)&mach->fac_list, S390_lowcore.stfle_fac_list, 85694422ee8SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 857658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, mach, sizeof(*mach))) 858658b6edaSMichael Mueller ret = -EFAULT; 859658b6edaSMichael Mueller kfree(mach); 860658b6edaSMichael Mueller out: 861658b6edaSMichael Mueller return ret; 862658b6edaSMichael Mueller } 863658b6edaSMichael Mueller 86415c9705fSDavid Hildenbrand static int kvm_s390_get_processor_feat(struct kvm *kvm, 86515c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 86615c9705fSDavid Hildenbrand { 86715c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 86815c9705fSDavid Hildenbrand 86915c9705fSDavid Hildenbrand bitmap_copy((unsigned long *) data.feat, kvm->arch.cpu_feat, 87015c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 87115c9705fSDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &data, sizeof(data))) 87215c9705fSDavid Hildenbrand return -EFAULT; 87315c9705fSDavid Hildenbrand return 0; 87415c9705fSDavid Hildenbrand } 87515c9705fSDavid Hildenbrand 87615c9705fSDavid Hildenbrand static int kvm_s390_get_machine_feat(struct kvm *kvm, 87715c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 87815c9705fSDavid Hildenbrand { 87915c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 88015c9705fSDavid Hildenbrand 88115c9705fSDavid Hildenbrand bitmap_copy((unsigned long *) data.feat, 88215c9705fSDavid Hildenbrand kvm_s390_available_cpu_feat, 88315c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 88415c9705fSDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &data, sizeof(data))) 88515c9705fSDavid Hildenbrand return -EFAULT; 88615c9705fSDavid Hildenbrand return 0; 88715c9705fSDavid Hildenbrand } 88815c9705fSDavid Hildenbrand 8890a763c78SDavid Hildenbrand static int kvm_s390_get_processor_subfunc(struct kvm *kvm, 8900a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 8910a763c78SDavid Hildenbrand { 8920a763c78SDavid Hildenbrand /* 8930a763c78SDavid Hildenbrand * Once we can actually configure subfunctions (kernel + hw support), 8940a763c78SDavid Hildenbrand * we have to check if they were already set by user space, if so copy 8950a763c78SDavid Hildenbrand * them from kvm->arch. 8960a763c78SDavid Hildenbrand */ 8970a763c78SDavid Hildenbrand return -ENXIO; 8980a763c78SDavid Hildenbrand } 8990a763c78SDavid Hildenbrand 9000a763c78SDavid Hildenbrand static int kvm_s390_get_machine_subfunc(struct kvm *kvm, 9010a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 9020a763c78SDavid Hildenbrand { 9030a763c78SDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &kvm_s390_available_subfunc, 9040a763c78SDavid Hildenbrand sizeof(struct kvm_s390_vm_cpu_subfunc))) 9050a763c78SDavid Hildenbrand return -EFAULT; 9060a763c78SDavid Hildenbrand return 0; 9070a763c78SDavid Hildenbrand } 908658b6edaSMichael Mueller static int kvm_s390_get_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 909658b6edaSMichael Mueller { 910658b6edaSMichael Mueller int ret = -ENXIO; 911658b6edaSMichael Mueller 912658b6edaSMichael Mueller switch (attr->attr) { 913658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 914658b6edaSMichael Mueller ret = kvm_s390_get_processor(kvm, attr); 915658b6edaSMichael Mueller break; 916658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 917658b6edaSMichael Mueller ret = kvm_s390_get_machine(kvm, attr); 918658b6edaSMichael Mueller break; 91915c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 92015c9705fSDavid Hildenbrand ret = kvm_s390_get_processor_feat(kvm, attr); 92115c9705fSDavid Hildenbrand break; 92215c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_FEAT: 92315c9705fSDavid Hildenbrand ret = kvm_s390_get_machine_feat(kvm, attr); 92415c9705fSDavid Hildenbrand break; 9250a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 9260a763c78SDavid Hildenbrand ret = kvm_s390_get_processor_subfunc(kvm, attr); 9270a763c78SDavid Hildenbrand break; 9280a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_SUBFUNC: 9290a763c78SDavid Hildenbrand ret = kvm_s390_get_machine_subfunc(kvm, attr); 9300a763c78SDavid Hildenbrand break; 931658b6edaSMichael Mueller } 932658b6edaSMichael Mueller return ret; 933658b6edaSMichael Mueller } 934658b6edaSMichael Mueller 935f2061656SDominik Dingel static int kvm_s390_vm_set_attr(struct kvm *kvm, struct kvm_device_attr *attr) 936f2061656SDominik Dingel { 937f2061656SDominik Dingel int ret; 938f2061656SDominik Dingel 939f2061656SDominik Dingel switch (attr->group) { 9404f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 9418c0a7ce6SDominik Dingel ret = kvm_s390_set_mem_control(kvm, attr); 9424f718eabSDominik Dingel break; 94372f25020SJason J. Herne case KVM_S390_VM_TOD: 94472f25020SJason J. Herne ret = kvm_s390_set_tod(kvm, attr); 94572f25020SJason J. Herne break; 946658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 947658b6edaSMichael Mueller ret = kvm_s390_set_cpu_model(kvm, attr); 948658b6edaSMichael Mueller break; 949a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 950a374e892STony Krowiak ret = kvm_s390_vm_set_crypto(kvm, attr); 951a374e892STony Krowiak break; 952f2061656SDominik Dingel default: 953f2061656SDominik Dingel ret = -ENXIO; 954f2061656SDominik Dingel break; 955f2061656SDominik Dingel } 956f2061656SDominik Dingel 957f2061656SDominik Dingel return ret; 958f2061656SDominik Dingel } 959f2061656SDominik Dingel 960f2061656SDominik Dingel static int kvm_s390_vm_get_attr(struct kvm *kvm, struct kvm_device_attr *attr) 961f2061656SDominik Dingel { 9628c0a7ce6SDominik Dingel int ret; 9638c0a7ce6SDominik Dingel 9648c0a7ce6SDominik Dingel switch (attr->group) { 9658c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_CTRL: 9668c0a7ce6SDominik Dingel ret = kvm_s390_get_mem_control(kvm, attr); 9678c0a7ce6SDominik Dingel break; 96872f25020SJason J. Herne case KVM_S390_VM_TOD: 96972f25020SJason J. Herne ret = kvm_s390_get_tod(kvm, attr); 97072f25020SJason J. Herne break; 971658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 972658b6edaSMichael Mueller ret = kvm_s390_get_cpu_model(kvm, attr); 973658b6edaSMichael Mueller break; 9748c0a7ce6SDominik Dingel default: 9758c0a7ce6SDominik Dingel ret = -ENXIO; 9768c0a7ce6SDominik Dingel break; 9778c0a7ce6SDominik Dingel } 9788c0a7ce6SDominik Dingel 9798c0a7ce6SDominik Dingel return ret; 980f2061656SDominik Dingel } 981f2061656SDominik Dingel 982f2061656SDominik Dingel static int kvm_s390_vm_has_attr(struct kvm *kvm, struct kvm_device_attr *attr) 983f2061656SDominik Dingel { 984f2061656SDominik Dingel int ret; 985f2061656SDominik Dingel 986f2061656SDominik Dingel switch (attr->group) { 9874f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 9884f718eabSDominik Dingel switch (attr->attr) { 9894f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 9904f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 991f9cbd9b0SDavid Hildenbrand ret = sclp.has_cmma ? 0 : -ENXIO; 992f9cbd9b0SDavid Hildenbrand break; 9938c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 9944f718eabSDominik Dingel ret = 0; 9954f718eabSDominik Dingel break; 9964f718eabSDominik Dingel default: 9974f718eabSDominik Dingel ret = -ENXIO; 9984f718eabSDominik Dingel break; 9994f718eabSDominik Dingel } 10004f718eabSDominik Dingel break; 100172f25020SJason J. Herne case KVM_S390_VM_TOD: 100272f25020SJason J. Herne switch (attr->attr) { 100372f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 100472f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 100572f25020SJason J. Herne ret = 0; 100672f25020SJason J. Herne break; 100772f25020SJason J. Herne default: 100872f25020SJason J. Herne ret = -ENXIO; 100972f25020SJason J. Herne break; 101072f25020SJason J. Herne } 101172f25020SJason J. Herne break; 1012658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 1013658b6edaSMichael Mueller switch (attr->attr) { 1014658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 1015658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 101615c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 101715c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_FEAT: 10180a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_SUBFUNC: 1019658b6edaSMichael Mueller ret = 0; 1020658b6edaSMichael Mueller break; 10210a763c78SDavid Hildenbrand /* configuring subfunctions is not supported yet */ 10220a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 1023658b6edaSMichael Mueller default: 1024658b6edaSMichael Mueller ret = -ENXIO; 1025658b6edaSMichael Mueller break; 1026658b6edaSMichael Mueller } 1027658b6edaSMichael Mueller break; 1028a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 1029a374e892STony Krowiak switch (attr->attr) { 1030a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 1031a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 1032a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 1033a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 1034a374e892STony Krowiak ret = 0; 1035a374e892STony Krowiak break; 1036a374e892STony Krowiak default: 1037a374e892STony Krowiak ret = -ENXIO; 1038a374e892STony Krowiak break; 1039a374e892STony Krowiak } 1040a374e892STony Krowiak break; 1041f2061656SDominik Dingel default: 1042f2061656SDominik Dingel ret = -ENXIO; 1043f2061656SDominik Dingel break; 1044f2061656SDominik Dingel } 1045f2061656SDominik Dingel 1046f2061656SDominik Dingel return ret; 1047f2061656SDominik Dingel } 1048f2061656SDominik Dingel 104930ee2a98SJason J. Herne static long kvm_s390_get_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 105030ee2a98SJason J. Herne { 105130ee2a98SJason J. Herne uint8_t *keys; 105230ee2a98SJason J. Herne uint64_t hva; 105330ee2a98SJason J. Herne int i, r = 0; 105430ee2a98SJason J. Herne 105530ee2a98SJason J. Herne if (args->flags != 0) 105630ee2a98SJason J. Herne return -EINVAL; 105730ee2a98SJason J. Herne 105830ee2a98SJason J. Herne /* Is this guest using storage keys? */ 105930ee2a98SJason J. Herne if (!mm_use_skey(current->mm)) 106030ee2a98SJason J. Herne return KVM_S390_GET_SKEYS_NONE; 106130ee2a98SJason J. Herne 106230ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 106330ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 106430ee2a98SJason J. Herne return -EINVAL; 106530ee2a98SJason J. Herne 106630ee2a98SJason J. Herne keys = kmalloc_array(args->count, sizeof(uint8_t), 106730ee2a98SJason J. Herne GFP_KERNEL | __GFP_NOWARN); 106830ee2a98SJason J. Herne if (!keys) 106930ee2a98SJason J. Herne keys = vmalloc(sizeof(uint8_t) * args->count); 107030ee2a98SJason J. Herne if (!keys) 107130ee2a98SJason J. Herne return -ENOMEM; 107230ee2a98SJason J. Herne 1073d3ed1ceeSMartin Schwidefsky down_read(¤t->mm->mmap_sem); 107430ee2a98SJason J. Herne for (i = 0; i < args->count; i++) { 107530ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 107630ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 107730ee2a98SJason J. Herne r = -EFAULT; 1078d3ed1ceeSMartin Schwidefsky break; 107930ee2a98SJason J. Herne } 108030ee2a98SJason J. Herne 1081154c8c19SDavid Hildenbrand r = get_guest_storage_key(current->mm, hva, &keys[i]); 1082154c8c19SDavid Hildenbrand if (r) 1083d3ed1ceeSMartin Schwidefsky break; 108430ee2a98SJason J. Herne } 1085d3ed1ceeSMartin Schwidefsky up_read(¤t->mm->mmap_sem); 108630ee2a98SJason J. Herne 1087d3ed1ceeSMartin Schwidefsky if (!r) { 108830ee2a98SJason J. Herne r = copy_to_user((uint8_t __user *)args->skeydata_addr, keys, 108930ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 109030ee2a98SJason J. Herne if (r) 109130ee2a98SJason J. Herne r = -EFAULT; 1092d3ed1ceeSMartin Schwidefsky } 1093d3ed1ceeSMartin Schwidefsky 109430ee2a98SJason J. Herne kvfree(keys); 109530ee2a98SJason J. Herne return r; 109630ee2a98SJason J. Herne } 109730ee2a98SJason J. Herne 109830ee2a98SJason J. Herne static long kvm_s390_set_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 109930ee2a98SJason J. Herne { 110030ee2a98SJason J. Herne uint8_t *keys; 110130ee2a98SJason J. Herne uint64_t hva; 110230ee2a98SJason J. Herne int i, r = 0; 110330ee2a98SJason J. Herne 110430ee2a98SJason J. Herne if (args->flags != 0) 110530ee2a98SJason J. Herne return -EINVAL; 110630ee2a98SJason J. Herne 110730ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 110830ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 110930ee2a98SJason J. Herne return -EINVAL; 111030ee2a98SJason J. Herne 111130ee2a98SJason J. Herne keys = kmalloc_array(args->count, sizeof(uint8_t), 111230ee2a98SJason J. Herne GFP_KERNEL | __GFP_NOWARN); 111330ee2a98SJason J. Herne if (!keys) 111430ee2a98SJason J. Herne keys = vmalloc(sizeof(uint8_t) * args->count); 111530ee2a98SJason J. Herne if (!keys) 111630ee2a98SJason J. Herne return -ENOMEM; 111730ee2a98SJason J. Herne 111830ee2a98SJason J. Herne r = copy_from_user(keys, (uint8_t __user *)args->skeydata_addr, 111930ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 112030ee2a98SJason J. Herne if (r) { 112130ee2a98SJason J. Herne r = -EFAULT; 112230ee2a98SJason J. Herne goto out; 112330ee2a98SJason J. Herne } 112430ee2a98SJason J. Herne 112530ee2a98SJason J. Herne /* Enable storage key handling for the guest */ 112614d4a425SDominik Dingel r = s390_enable_skey(); 112714d4a425SDominik Dingel if (r) 112814d4a425SDominik Dingel goto out; 112930ee2a98SJason J. Herne 1130d3ed1ceeSMartin Schwidefsky down_read(¤t->mm->mmap_sem); 113130ee2a98SJason J. Herne for (i = 0; i < args->count; i++) { 113230ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 113330ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 113430ee2a98SJason J. Herne r = -EFAULT; 1135d3ed1ceeSMartin Schwidefsky break; 113630ee2a98SJason J. Herne } 113730ee2a98SJason J. Herne 113830ee2a98SJason J. Herne /* Lowest order bit is reserved */ 113930ee2a98SJason J. Herne if (keys[i] & 0x01) { 114030ee2a98SJason J. Herne r = -EINVAL; 1141d3ed1ceeSMartin Schwidefsky break; 114230ee2a98SJason J. Herne } 114330ee2a98SJason J. Herne 1144fe69eabfSDavid Hildenbrand r = set_guest_storage_key(current->mm, hva, keys[i], 0); 114530ee2a98SJason J. Herne if (r) 1146d3ed1ceeSMartin Schwidefsky break; 114730ee2a98SJason J. Herne } 1148d3ed1ceeSMartin Schwidefsky up_read(¤t->mm->mmap_sem); 114930ee2a98SJason J. Herne out: 115030ee2a98SJason J. Herne kvfree(keys); 115130ee2a98SJason J. Herne return r; 115230ee2a98SJason J. Herne } 115330ee2a98SJason J. Herne 1154b0c632dbSHeiko Carstens long kvm_arch_vm_ioctl(struct file *filp, 1155b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 1156b0c632dbSHeiko Carstens { 1157b0c632dbSHeiko Carstens struct kvm *kvm = filp->private_data; 1158b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 1159f2061656SDominik Dingel struct kvm_device_attr attr; 1160b0c632dbSHeiko Carstens int r; 1161b0c632dbSHeiko Carstens 1162b0c632dbSHeiko Carstens switch (ioctl) { 1163ba5c1e9bSCarsten Otte case KVM_S390_INTERRUPT: { 1164ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 1165ba5c1e9bSCarsten Otte 1166ba5c1e9bSCarsten Otte r = -EFAULT; 1167ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 1168ba5c1e9bSCarsten Otte break; 1169ba5c1e9bSCarsten Otte r = kvm_s390_inject_vm(kvm, &s390int); 1170ba5c1e9bSCarsten Otte break; 1171ba5c1e9bSCarsten Otte } 1172d938dc55SCornelia Huck case KVM_ENABLE_CAP: { 1173d938dc55SCornelia Huck struct kvm_enable_cap cap; 1174d938dc55SCornelia Huck r = -EFAULT; 1175d938dc55SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 1176d938dc55SCornelia Huck break; 1177d938dc55SCornelia Huck r = kvm_vm_ioctl_enable_cap(kvm, &cap); 1178d938dc55SCornelia Huck break; 1179d938dc55SCornelia Huck } 118084223598SCornelia Huck case KVM_CREATE_IRQCHIP: { 118184223598SCornelia Huck struct kvm_irq_routing_entry routing; 118284223598SCornelia Huck 118384223598SCornelia Huck r = -EINVAL; 118484223598SCornelia Huck if (kvm->arch.use_irqchip) { 118584223598SCornelia Huck /* Set up dummy routing. */ 118684223598SCornelia Huck memset(&routing, 0, sizeof(routing)); 1187152b2839SNicholas Krause r = kvm_set_irq_routing(kvm, &routing, 0, 0); 118884223598SCornelia Huck } 118984223598SCornelia Huck break; 119084223598SCornelia Huck } 1191f2061656SDominik Dingel case KVM_SET_DEVICE_ATTR: { 1192f2061656SDominik Dingel r = -EFAULT; 1193f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 1194f2061656SDominik Dingel break; 1195f2061656SDominik Dingel r = kvm_s390_vm_set_attr(kvm, &attr); 1196f2061656SDominik Dingel break; 1197f2061656SDominik Dingel } 1198f2061656SDominik Dingel case KVM_GET_DEVICE_ATTR: { 1199f2061656SDominik Dingel r = -EFAULT; 1200f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 1201f2061656SDominik Dingel break; 1202f2061656SDominik Dingel r = kvm_s390_vm_get_attr(kvm, &attr); 1203f2061656SDominik Dingel break; 1204f2061656SDominik Dingel } 1205f2061656SDominik Dingel case KVM_HAS_DEVICE_ATTR: { 1206f2061656SDominik Dingel r = -EFAULT; 1207f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 1208f2061656SDominik Dingel break; 1209f2061656SDominik Dingel r = kvm_s390_vm_has_attr(kvm, &attr); 1210f2061656SDominik Dingel break; 1211f2061656SDominik Dingel } 121230ee2a98SJason J. Herne case KVM_S390_GET_SKEYS: { 121330ee2a98SJason J. Herne struct kvm_s390_skeys args; 121430ee2a98SJason J. Herne 121530ee2a98SJason J. Herne r = -EFAULT; 121630ee2a98SJason J. Herne if (copy_from_user(&args, argp, 121730ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 121830ee2a98SJason J. Herne break; 121930ee2a98SJason J. Herne r = kvm_s390_get_skeys(kvm, &args); 122030ee2a98SJason J. Herne break; 122130ee2a98SJason J. Herne } 122230ee2a98SJason J. Herne case KVM_S390_SET_SKEYS: { 122330ee2a98SJason J. Herne struct kvm_s390_skeys args; 122430ee2a98SJason J. Herne 122530ee2a98SJason J. Herne r = -EFAULT; 122630ee2a98SJason J. Herne if (copy_from_user(&args, argp, 122730ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 122830ee2a98SJason J. Herne break; 122930ee2a98SJason J. Herne r = kvm_s390_set_skeys(kvm, &args); 123030ee2a98SJason J. Herne break; 123130ee2a98SJason J. Herne } 1232b0c632dbSHeiko Carstens default: 1233367e1319SAvi Kivity r = -ENOTTY; 1234b0c632dbSHeiko Carstens } 1235b0c632dbSHeiko Carstens 1236b0c632dbSHeiko Carstens return r; 1237b0c632dbSHeiko Carstens } 1238b0c632dbSHeiko Carstens 123945c9b47cSTony Krowiak static int kvm_s390_query_ap_config(u8 *config) 124045c9b47cSTony Krowiak { 124145c9b47cSTony Krowiak u32 fcn_code = 0x04000000UL; 124286044c8cSChristian Borntraeger u32 cc = 0; 124345c9b47cSTony Krowiak 124486044c8cSChristian Borntraeger memset(config, 0, 128); 124545c9b47cSTony Krowiak asm volatile( 124645c9b47cSTony Krowiak "lgr 0,%1\n" 124745c9b47cSTony Krowiak "lgr 2,%2\n" 124845c9b47cSTony Krowiak ".long 0xb2af0000\n" /* PQAP(QCI) */ 124986044c8cSChristian Borntraeger "0: ipm %0\n" 125045c9b47cSTony Krowiak "srl %0,28\n" 125186044c8cSChristian Borntraeger "1:\n" 125286044c8cSChristian Borntraeger EX_TABLE(0b, 1b) 125386044c8cSChristian Borntraeger : "+r" (cc) 125445c9b47cSTony Krowiak : "r" (fcn_code), "r" (config) 125545c9b47cSTony Krowiak : "cc", "0", "2", "memory" 125645c9b47cSTony Krowiak ); 125745c9b47cSTony Krowiak 125845c9b47cSTony Krowiak return cc; 125945c9b47cSTony Krowiak } 126045c9b47cSTony Krowiak 126145c9b47cSTony Krowiak static int kvm_s390_apxa_installed(void) 126245c9b47cSTony Krowiak { 126345c9b47cSTony Krowiak u8 config[128]; 126445c9b47cSTony Krowiak int cc; 126545c9b47cSTony Krowiak 1266a6aacc3fSHeiko Carstens if (test_facility(12)) { 126745c9b47cSTony Krowiak cc = kvm_s390_query_ap_config(config); 126845c9b47cSTony Krowiak 126945c9b47cSTony Krowiak if (cc) 127045c9b47cSTony Krowiak pr_err("PQAP(QCI) failed with cc=%d", cc); 127145c9b47cSTony Krowiak else 127245c9b47cSTony Krowiak return config[0] & 0x40; 127345c9b47cSTony Krowiak } 127445c9b47cSTony Krowiak 127545c9b47cSTony Krowiak return 0; 127645c9b47cSTony Krowiak } 127745c9b47cSTony Krowiak 127845c9b47cSTony Krowiak static void kvm_s390_set_crycb_format(struct kvm *kvm) 127945c9b47cSTony Krowiak { 128045c9b47cSTony Krowiak kvm->arch.crypto.crycbd = (__u32)(unsigned long) kvm->arch.crypto.crycb; 128145c9b47cSTony Krowiak 128245c9b47cSTony Krowiak if (kvm_s390_apxa_installed()) 128345c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT2; 128445c9b47cSTony Krowiak else 128545c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT1; 128645c9b47cSTony Krowiak } 128745c9b47cSTony Krowiak 12889bb0ec09SDavid Hildenbrand static u64 kvm_s390_get_initial_cpuid(void) 12899d8d5786SMichael Mueller { 12909bb0ec09SDavid Hildenbrand struct cpuid cpuid; 12919bb0ec09SDavid Hildenbrand 12929bb0ec09SDavid Hildenbrand get_cpu_id(&cpuid); 12939bb0ec09SDavid Hildenbrand cpuid.version = 0xff; 12949bb0ec09SDavid Hildenbrand return *((u64 *) &cpuid); 12959d8d5786SMichael Mueller } 12969d8d5786SMichael Mueller 1297c54f0d6aSDavid Hildenbrand static void kvm_s390_crypto_init(struct kvm *kvm) 12985102ee87STony Krowiak { 12999d8d5786SMichael Mueller if (!test_kvm_facility(kvm, 76)) 1300c54f0d6aSDavid Hildenbrand return; 13015102ee87STony Krowiak 1302c54f0d6aSDavid Hildenbrand kvm->arch.crypto.crycb = &kvm->arch.sie_page2->crycb; 130345c9b47cSTony Krowiak kvm_s390_set_crycb_format(kvm); 13045102ee87STony Krowiak 1305ed6f76b4STony Krowiak /* Enable AES/DEA protected key functions by default */ 1306ed6f76b4STony Krowiak kvm->arch.crypto.aes_kw = 1; 1307ed6f76b4STony Krowiak kvm->arch.crypto.dea_kw = 1; 1308ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 1309ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 1310ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 1311ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 13125102ee87STony Krowiak } 13135102ee87STony Krowiak 13147d43bafcSEugene (jno) Dvurechenski static void sca_dispose(struct kvm *kvm) 13157d43bafcSEugene (jno) Dvurechenski { 13167d43bafcSEugene (jno) Dvurechenski if (kvm->arch.use_esca) 13175e044315SEugene (jno) Dvurechenski free_pages_exact(kvm->arch.sca, sizeof(struct esca_block)); 13187d43bafcSEugene (jno) Dvurechenski else 13197d43bafcSEugene (jno) Dvurechenski free_page((unsigned long)(kvm->arch.sca)); 13207d43bafcSEugene (jno) Dvurechenski kvm->arch.sca = NULL; 13217d43bafcSEugene (jno) Dvurechenski } 13227d43bafcSEugene (jno) Dvurechenski 1323e08b9637SCarsten Otte int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 1324b0c632dbSHeiko Carstens { 132576a6dd72SDavid Hildenbrand gfp_t alloc_flags = GFP_KERNEL; 13269d8d5786SMichael Mueller int i, rc; 1327b0c632dbSHeiko Carstens char debug_name[16]; 1328f6c137ffSChristian Borntraeger static unsigned long sca_offset; 1329b0c632dbSHeiko Carstens 1330e08b9637SCarsten Otte rc = -EINVAL; 1331e08b9637SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 1332e08b9637SCarsten Otte if (type & ~KVM_VM_S390_UCONTROL) 1333e08b9637SCarsten Otte goto out_err; 1334e08b9637SCarsten Otte if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN))) 1335e08b9637SCarsten Otte goto out_err; 1336e08b9637SCarsten Otte #else 1337e08b9637SCarsten Otte if (type) 1338e08b9637SCarsten Otte goto out_err; 1339e08b9637SCarsten Otte #endif 1340e08b9637SCarsten Otte 1341b0c632dbSHeiko Carstens rc = s390_enable_sie(); 1342b0c632dbSHeiko Carstens if (rc) 1343d89f5effSJan Kiszka goto out_err; 1344b0c632dbSHeiko Carstens 1345b290411aSCarsten Otte rc = -ENOMEM; 1346b290411aSCarsten Otte 13477d0a5e62SJanosch Frank ratelimit_state_init(&kvm->arch.sthyi_limit, 5 * HZ, 500); 13487d0a5e62SJanosch Frank 13497d43bafcSEugene (jno) Dvurechenski kvm->arch.use_esca = 0; /* start with basic SCA */ 135076a6dd72SDavid Hildenbrand if (!sclp.has_64bscao) 135176a6dd72SDavid Hildenbrand alloc_flags |= GFP_DMA; 13525e044315SEugene (jno) Dvurechenski rwlock_init(&kvm->arch.sca_lock); 135376a6dd72SDavid Hildenbrand kvm->arch.sca = (struct bsca_block *) get_zeroed_page(alloc_flags); 1354b0c632dbSHeiko Carstens if (!kvm->arch.sca) 1355d89f5effSJan Kiszka goto out_err; 1356f6c137ffSChristian Borntraeger spin_lock(&kvm_lock); 1357c5c2c393SDavid Hildenbrand sca_offset += 16; 1358bc784cceSEugene (jno) Dvurechenski if (sca_offset + sizeof(struct bsca_block) > PAGE_SIZE) 1359c5c2c393SDavid Hildenbrand sca_offset = 0; 1360bc784cceSEugene (jno) Dvurechenski kvm->arch.sca = (struct bsca_block *) 1361bc784cceSEugene (jno) Dvurechenski ((char *) kvm->arch.sca + sca_offset); 1362f6c137ffSChristian Borntraeger spin_unlock(&kvm_lock); 1363b0c632dbSHeiko Carstens 1364b0c632dbSHeiko Carstens sprintf(debug_name, "kvm-%u", current->pid); 1365b0c632dbSHeiko Carstens 13661cb9cf72SChristian Borntraeger kvm->arch.dbf = debug_register(debug_name, 32, 1, 7 * sizeof(long)); 1367b0c632dbSHeiko Carstens if (!kvm->arch.dbf) 136840f5b735SDominik Dingel goto out_err; 1369b0c632dbSHeiko Carstens 1370c54f0d6aSDavid Hildenbrand kvm->arch.sie_page2 = 1371c54f0d6aSDavid Hildenbrand (struct sie_page2 *) get_zeroed_page(GFP_KERNEL | GFP_DMA); 1372c54f0d6aSDavid Hildenbrand if (!kvm->arch.sie_page2) 137340f5b735SDominik Dingel goto out_err; 13749d8d5786SMichael Mueller 1375fb5bf93fSMichael Mueller /* Populate the facility mask initially. */ 1376c54f0d6aSDavid Hildenbrand memcpy(kvm->arch.model.fac_mask, S390_lowcore.stfle_fac_list, 137794422ee8SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 13789d8d5786SMichael Mueller for (i = 0; i < S390_ARCH_FAC_LIST_SIZE_U64; i++) { 13799d8d5786SMichael Mueller if (i < kvm_s390_fac_list_mask_size()) 1380c54f0d6aSDavid Hildenbrand kvm->arch.model.fac_mask[i] &= kvm_s390_fac_list_mask[i]; 13819d8d5786SMichael Mueller else 1382c54f0d6aSDavid Hildenbrand kvm->arch.model.fac_mask[i] = 0UL; 13839d8d5786SMichael Mueller } 13849d8d5786SMichael Mueller 1385981467c9SMichael Mueller /* Populate the facility list initially. */ 1386c54f0d6aSDavid Hildenbrand kvm->arch.model.fac_list = kvm->arch.sie_page2->fac_list; 1387c54f0d6aSDavid Hildenbrand memcpy(kvm->arch.model.fac_list, kvm->arch.model.fac_mask, 1388981467c9SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 1389981467c9SMichael Mueller 139095ca2cb5SJanosch Frank set_kvm_facility(kvm->arch.model.fac_mask, 74); 139195ca2cb5SJanosch Frank set_kvm_facility(kvm->arch.model.fac_list, 74); 139295ca2cb5SJanosch Frank 13939bb0ec09SDavid Hildenbrand kvm->arch.model.cpuid = kvm_s390_get_initial_cpuid(); 139437c5f6c8SDavid Hildenbrand kvm->arch.model.ibc = sclp.ibc & 0x0fff; 13959d8d5786SMichael Mueller 1396c54f0d6aSDavid Hildenbrand kvm_s390_crypto_init(kvm); 13975102ee87STony Krowiak 1398ba5c1e9bSCarsten Otte spin_lock_init(&kvm->arch.float_int.lock); 13996d3da241SJens Freimann for (i = 0; i < FIRQ_LIST_COUNT; i++) 14006d3da241SJens Freimann INIT_LIST_HEAD(&kvm->arch.float_int.lists[i]); 14018a242234SHeiko Carstens init_waitqueue_head(&kvm->arch.ipte_wq); 1402a6b7e459SThomas Huth mutex_init(&kvm->arch.ipte_mutex); 1403ba5c1e9bSCarsten Otte 1404b0c632dbSHeiko Carstens debug_register_view(kvm->arch.dbf, &debug_sprintf_view); 140578f26131SChristian Borntraeger VM_EVENT(kvm, 3, "vm created with type %lu", type); 1406b0c632dbSHeiko Carstens 1407e08b9637SCarsten Otte if (type & KVM_VM_S390_UCONTROL) { 1408e08b9637SCarsten Otte kvm->arch.gmap = NULL; 1409a3a92c31SDominik Dingel kvm->arch.mem_limit = KVM_S390_NO_MEM_LIMIT; 1410e08b9637SCarsten Otte } else { 141132e6b236SGuenther Hutzl if (sclp.hamax == U64_MAX) 1412a3a92c31SDominik Dingel kvm->arch.mem_limit = TASK_MAX_SIZE; 141332e6b236SGuenther Hutzl else 141432e6b236SGuenther Hutzl kvm->arch.mem_limit = min_t(unsigned long, TASK_MAX_SIZE, 141532e6b236SGuenther Hutzl sclp.hamax + 1); 14166ea427bbSMartin Schwidefsky kvm->arch.gmap = gmap_create(current->mm, kvm->arch.mem_limit - 1); 1417598841caSCarsten Otte if (!kvm->arch.gmap) 141840f5b735SDominik Dingel goto out_err; 14192c70fe44SChristian Borntraeger kvm->arch.gmap->private = kvm; 142024eb3a82SDominik Dingel kvm->arch.gmap->pfault_enabled = 0; 1421e08b9637SCarsten Otte } 1422fa6b7fe9SCornelia Huck 1423fa6b7fe9SCornelia Huck kvm->arch.css_support = 0; 142484223598SCornelia Huck kvm->arch.use_irqchip = 0; 142572f25020SJason J. Herne kvm->arch.epoch = 0; 1426fa6b7fe9SCornelia Huck 14278ad35755SDavid Hildenbrand spin_lock_init(&kvm->arch.start_stop_lock); 1428a3508fbeSDavid Hildenbrand kvm_s390_vsie_init(kvm); 14298335713aSChristian Borntraeger KVM_EVENT(3, "vm 0x%pK created by pid %u", kvm, current->pid); 14308ad35755SDavid Hildenbrand 1431d89f5effSJan Kiszka return 0; 1432d89f5effSJan Kiszka out_err: 1433c54f0d6aSDavid Hildenbrand free_page((unsigned long)kvm->arch.sie_page2); 143440f5b735SDominik Dingel debug_unregister(kvm->arch.dbf); 14357d43bafcSEugene (jno) Dvurechenski sca_dispose(kvm); 143678f26131SChristian Borntraeger KVM_EVENT(3, "creation of vm failed: %d", rc); 1437d89f5effSJan Kiszka return rc; 1438b0c632dbSHeiko Carstens } 1439b0c632dbSHeiko Carstens 1440d329c035SChristian Borntraeger void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 1441d329c035SChristian Borntraeger { 1442d329c035SChristian Borntraeger VCPU_EVENT(vcpu, 3, "%s", "free cpu"); 1443ade38c31SCornelia Huck trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id); 144467335e63SChristian Borntraeger kvm_s390_clear_local_irqs(vcpu); 14453c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 1446bc784cceSEugene (jno) Dvurechenski if (!kvm_is_ucontrol(vcpu->kvm)) 1447a6e2f683SEugene (jno) Dvurechenski sca_del_vcpu(vcpu); 144827e0393fSCarsten Otte 144927e0393fSCarsten Otte if (kvm_is_ucontrol(vcpu->kvm)) 14506ea427bbSMartin Schwidefsky gmap_remove(vcpu->arch.gmap); 145127e0393fSCarsten Otte 1452e6db1d61SDominik Dingel if (vcpu->kvm->arch.use_cmma) 1453b31605c1SDominik Dingel kvm_s390_vcpu_unsetup_cmma(vcpu); 1454d329c035SChristian Borntraeger free_page((unsigned long)(vcpu->arch.sie_block)); 1455b31288faSKonstantin Weitz 14566692cef3SChristian Borntraeger kvm_vcpu_uninit(vcpu); 1457b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 1458d329c035SChristian Borntraeger } 1459d329c035SChristian Borntraeger 1460d329c035SChristian Borntraeger static void kvm_free_vcpus(struct kvm *kvm) 1461d329c035SChristian Borntraeger { 1462d329c035SChristian Borntraeger unsigned int i; 1463988a2caeSGleb Natapov struct kvm_vcpu *vcpu; 1464d329c035SChristian Borntraeger 1465988a2caeSGleb Natapov kvm_for_each_vcpu(i, vcpu, kvm) 1466988a2caeSGleb Natapov kvm_arch_vcpu_destroy(vcpu); 1467988a2caeSGleb Natapov 1468988a2caeSGleb Natapov mutex_lock(&kvm->lock); 1469988a2caeSGleb Natapov for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 1470d329c035SChristian Borntraeger kvm->vcpus[i] = NULL; 1471988a2caeSGleb Natapov 1472988a2caeSGleb Natapov atomic_set(&kvm->online_vcpus, 0); 1473988a2caeSGleb Natapov mutex_unlock(&kvm->lock); 1474d329c035SChristian Borntraeger } 1475d329c035SChristian Borntraeger 1476b0c632dbSHeiko Carstens void kvm_arch_destroy_vm(struct kvm *kvm) 1477b0c632dbSHeiko Carstens { 1478d329c035SChristian Borntraeger kvm_free_vcpus(kvm); 14797d43bafcSEugene (jno) Dvurechenski sca_dispose(kvm); 1480d329c035SChristian Borntraeger debug_unregister(kvm->arch.dbf); 1481c54f0d6aSDavid Hildenbrand free_page((unsigned long)kvm->arch.sie_page2); 148227e0393fSCarsten Otte if (!kvm_is_ucontrol(kvm)) 14836ea427bbSMartin Schwidefsky gmap_remove(kvm->arch.gmap); 1484841b91c5SCornelia Huck kvm_s390_destroy_adapters(kvm); 148567335e63SChristian Borntraeger kvm_s390_clear_float_irqs(kvm); 1486a3508fbeSDavid Hildenbrand kvm_s390_vsie_destroy(kvm); 14878335713aSChristian Borntraeger KVM_EVENT(3, "vm 0x%pK destroyed", kvm); 1488b0c632dbSHeiko Carstens } 1489b0c632dbSHeiko Carstens 1490b0c632dbSHeiko Carstens /* Section: vcpu related */ 1491dafd032aSDominik Dingel static int __kvm_ucontrol_vcpu_init(struct kvm_vcpu *vcpu) 1492b0c632dbSHeiko Carstens { 14936ea427bbSMartin Schwidefsky vcpu->arch.gmap = gmap_create(current->mm, -1UL); 149427e0393fSCarsten Otte if (!vcpu->arch.gmap) 149527e0393fSCarsten Otte return -ENOMEM; 14962c70fe44SChristian Borntraeger vcpu->arch.gmap->private = vcpu->kvm; 1497dafd032aSDominik Dingel 149827e0393fSCarsten Otte return 0; 149927e0393fSCarsten Otte } 150027e0393fSCarsten Otte 1501a6e2f683SEugene (jno) Dvurechenski static void sca_del_vcpu(struct kvm_vcpu *vcpu) 1502a6e2f683SEugene (jno) Dvurechenski { 15035e044315SEugene (jno) Dvurechenski read_lock(&vcpu->kvm->arch.sca_lock); 15047d43bafcSEugene (jno) Dvurechenski if (vcpu->kvm->arch.use_esca) { 15057d43bafcSEugene (jno) Dvurechenski struct esca_block *sca = vcpu->kvm->arch.sca; 15067d43bafcSEugene (jno) Dvurechenski 15077d43bafcSEugene (jno) Dvurechenski clear_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn); 15087d43bafcSEugene (jno) Dvurechenski sca->cpu[vcpu->vcpu_id].sda = 0; 15097d43bafcSEugene (jno) Dvurechenski } else { 1510bc784cceSEugene (jno) Dvurechenski struct bsca_block *sca = vcpu->kvm->arch.sca; 1511a6e2f683SEugene (jno) Dvurechenski 1512a6e2f683SEugene (jno) Dvurechenski clear_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn); 1513a6e2f683SEugene (jno) Dvurechenski sca->cpu[vcpu->vcpu_id].sda = 0; 1514a6e2f683SEugene (jno) Dvurechenski } 15155e044315SEugene (jno) Dvurechenski read_unlock(&vcpu->kvm->arch.sca_lock); 15167d43bafcSEugene (jno) Dvurechenski } 1517a6e2f683SEugene (jno) Dvurechenski 1518eaa78f34SDavid Hildenbrand static void sca_add_vcpu(struct kvm_vcpu *vcpu) 1519a6e2f683SEugene (jno) Dvurechenski { 1520eaa78f34SDavid Hildenbrand read_lock(&vcpu->kvm->arch.sca_lock); 1521eaa78f34SDavid Hildenbrand if (vcpu->kvm->arch.use_esca) { 1522eaa78f34SDavid Hildenbrand struct esca_block *sca = vcpu->kvm->arch.sca; 15237d43bafcSEugene (jno) Dvurechenski 1524eaa78f34SDavid Hildenbrand sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block; 15257d43bafcSEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 15267d43bafcSEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = (__u32)(__u64)sca & ~0x3fU; 152725508824SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= 0x04U; 1528eaa78f34SDavid Hildenbrand set_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn); 15297d43bafcSEugene (jno) Dvurechenski } else { 1530eaa78f34SDavid Hildenbrand struct bsca_block *sca = vcpu->kvm->arch.sca; 1531a6e2f683SEugene (jno) Dvurechenski 1532eaa78f34SDavid Hildenbrand sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block; 1533a6e2f683SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 1534a6e2f683SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = (__u32)(__u64)sca; 1535eaa78f34SDavid Hildenbrand set_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn); 1536a6e2f683SEugene (jno) Dvurechenski } 1537eaa78f34SDavid Hildenbrand read_unlock(&vcpu->kvm->arch.sca_lock); 15385e044315SEugene (jno) Dvurechenski } 15395e044315SEugene (jno) Dvurechenski 15405e044315SEugene (jno) Dvurechenski /* Basic SCA to Extended SCA data copy routines */ 15415e044315SEugene (jno) Dvurechenski static inline void sca_copy_entry(struct esca_entry *d, struct bsca_entry *s) 15425e044315SEugene (jno) Dvurechenski { 15435e044315SEugene (jno) Dvurechenski d->sda = s->sda; 15445e044315SEugene (jno) Dvurechenski d->sigp_ctrl.c = s->sigp_ctrl.c; 15455e044315SEugene (jno) Dvurechenski d->sigp_ctrl.scn = s->sigp_ctrl.scn; 15465e044315SEugene (jno) Dvurechenski } 15475e044315SEugene (jno) Dvurechenski 15485e044315SEugene (jno) Dvurechenski static void sca_copy_b_to_e(struct esca_block *d, struct bsca_block *s) 15495e044315SEugene (jno) Dvurechenski { 15505e044315SEugene (jno) Dvurechenski int i; 15515e044315SEugene (jno) Dvurechenski 15525e044315SEugene (jno) Dvurechenski d->ipte_control = s->ipte_control; 15535e044315SEugene (jno) Dvurechenski d->mcn[0] = s->mcn; 15545e044315SEugene (jno) Dvurechenski for (i = 0; i < KVM_S390_BSCA_CPU_SLOTS; i++) 15555e044315SEugene (jno) Dvurechenski sca_copy_entry(&d->cpu[i], &s->cpu[i]); 15565e044315SEugene (jno) Dvurechenski } 15575e044315SEugene (jno) Dvurechenski 15585e044315SEugene (jno) Dvurechenski static int sca_switch_to_extended(struct kvm *kvm) 15595e044315SEugene (jno) Dvurechenski { 15605e044315SEugene (jno) Dvurechenski struct bsca_block *old_sca = kvm->arch.sca; 15615e044315SEugene (jno) Dvurechenski struct esca_block *new_sca; 15625e044315SEugene (jno) Dvurechenski struct kvm_vcpu *vcpu; 15635e044315SEugene (jno) Dvurechenski unsigned int vcpu_idx; 15645e044315SEugene (jno) Dvurechenski u32 scaol, scaoh; 15655e044315SEugene (jno) Dvurechenski 15665e044315SEugene (jno) Dvurechenski new_sca = alloc_pages_exact(sizeof(*new_sca), GFP_KERNEL|__GFP_ZERO); 15675e044315SEugene (jno) Dvurechenski if (!new_sca) 15685e044315SEugene (jno) Dvurechenski return -ENOMEM; 15695e044315SEugene (jno) Dvurechenski 15705e044315SEugene (jno) Dvurechenski scaoh = (u32)((u64)(new_sca) >> 32); 15715e044315SEugene (jno) Dvurechenski scaol = (u32)(u64)(new_sca) & ~0x3fU; 15725e044315SEugene (jno) Dvurechenski 15735e044315SEugene (jno) Dvurechenski kvm_s390_vcpu_block_all(kvm); 15745e044315SEugene (jno) Dvurechenski write_lock(&kvm->arch.sca_lock); 15755e044315SEugene (jno) Dvurechenski 15765e044315SEugene (jno) Dvurechenski sca_copy_b_to_e(new_sca, old_sca); 15775e044315SEugene (jno) Dvurechenski 15785e044315SEugene (jno) Dvurechenski kvm_for_each_vcpu(vcpu_idx, vcpu, kvm) { 15795e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = scaoh; 15805e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = scaol; 15815e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->ecb2 |= 0x04U; 15825e044315SEugene (jno) Dvurechenski } 15835e044315SEugene (jno) Dvurechenski kvm->arch.sca = new_sca; 15845e044315SEugene (jno) Dvurechenski kvm->arch.use_esca = 1; 15855e044315SEugene (jno) Dvurechenski 15865e044315SEugene (jno) Dvurechenski write_unlock(&kvm->arch.sca_lock); 15875e044315SEugene (jno) Dvurechenski kvm_s390_vcpu_unblock_all(kvm); 15885e044315SEugene (jno) Dvurechenski 15895e044315SEugene (jno) Dvurechenski free_page((unsigned long)old_sca); 15905e044315SEugene (jno) Dvurechenski 15918335713aSChristian Borntraeger VM_EVENT(kvm, 2, "Switched to ESCA (0x%pK -> 0x%pK)", 15928335713aSChristian Borntraeger old_sca, kvm->arch.sca); 15935e044315SEugene (jno) Dvurechenski return 0; 15947d43bafcSEugene (jno) Dvurechenski } 1595a6e2f683SEugene (jno) Dvurechenski 1596a6e2f683SEugene (jno) Dvurechenski static int sca_can_add_vcpu(struct kvm *kvm, unsigned int id) 1597a6e2f683SEugene (jno) Dvurechenski { 15985e044315SEugene (jno) Dvurechenski int rc; 15995e044315SEugene (jno) Dvurechenski 16005e044315SEugene (jno) Dvurechenski if (id < KVM_S390_BSCA_CPU_SLOTS) 16015e044315SEugene (jno) Dvurechenski return true; 160276a6dd72SDavid Hildenbrand if (!sclp.has_esca || !sclp.has_64bscao) 16035e044315SEugene (jno) Dvurechenski return false; 16045e044315SEugene (jno) Dvurechenski 16055e044315SEugene (jno) Dvurechenski mutex_lock(&kvm->lock); 16065e044315SEugene (jno) Dvurechenski rc = kvm->arch.use_esca ? 0 : sca_switch_to_extended(kvm); 16075e044315SEugene (jno) Dvurechenski mutex_unlock(&kvm->lock); 16085e044315SEugene (jno) Dvurechenski 16095e044315SEugene (jno) Dvurechenski return rc == 0 && id < KVM_S390_ESCA_CPU_SLOTS; 1610a6e2f683SEugene (jno) Dvurechenski } 1611a6e2f683SEugene (jno) Dvurechenski 1612dafd032aSDominik Dingel int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 1613dafd032aSDominik Dingel { 1614dafd032aSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 1615dafd032aSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 161659674c1aSChristian Borntraeger vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX | 161759674c1aSChristian Borntraeger KVM_SYNC_GPRS | 16189eed0735SChristian Borntraeger KVM_SYNC_ACRS | 1619b028ee3eSDavid Hildenbrand KVM_SYNC_CRS | 1620b028ee3eSDavid Hildenbrand KVM_SYNC_ARCH0 | 1621b028ee3eSDavid Hildenbrand KVM_SYNC_PFAULT; 1622c6e5f166SFan Zhang if (test_kvm_facility(vcpu->kvm, 64)) 1623c6e5f166SFan Zhang vcpu->run->kvm_valid_regs |= KVM_SYNC_RICCB; 1624f6aa6dc4SDavid Hildenbrand /* fprs can be synchronized via vrs, even if the guest has no vx. With 1625f6aa6dc4SDavid Hildenbrand * MACHINE_HAS_VX, (load|store)_fpu_regs() will work with vrs format. 1626f6aa6dc4SDavid Hildenbrand */ 1627f6aa6dc4SDavid Hildenbrand if (MACHINE_HAS_VX) 162868c55750SEric Farman vcpu->run->kvm_valid_regs |= KVM_SYNC_VRS; 16296fd8e67dSDavid Hildenbrand else 16306fd8e67dSDavid Hildenbrand vcpu->run->kvm_valid_regs |= KVM_SYNC_FPRS; 1631dafd032aSDominik Dingel 1632dafd032aSDominik Dingel if (kvm_is_ucontrol(vcpu->kvm)) 1633dafd032aSDominik Dingel return __kvm_ucontrol_vcpu_init(vcpu); 1634dafd032aSDominik Dingel 1635b0c632dbSHeiko Carstens return 0; 1636b0c632dbSHeiko Carstens } 1637b0c632dbSHeiko Carstens 1638db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 1639db0758b2SDavid Hildenbrand static void __start_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1640db0758b2SDavid Hildenbrand { 1641db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_start != 0); 16429c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 1643db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = get_tod_clock_fast(); 16449c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 1645db0758b2SDavid Hildenbrand } 1646db0758b2SDavid Hildenbrand 1647db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 1648db0758b2SDavid Hildenbrand static void __stop_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1649db0758b2SDavid Hildenbrand { 1650db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_start == 0); 16519c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 1652db0758b2SDavid Hildenbrand vcpu->arch.sie_block->cputm -= get_tod_clock_fast() - vcpu->arch.cputm_start; 1653db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = 0; 16549c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 1655db0758b2SDavid Hildenbrand } 1656db0758b2SDavid Hildenbrand 1657db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 1658db0758b2SDavid Hildenbrand static void __enable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1659db0758b2SDavid Hildenbrand { 1660db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_enabled); 1661db0758b2SDavid Hildenbrand vcpu->arch.cputm_enabled = true; 1662db0758b2SDavid Hildenbrand __start_cpu_timer_accounting(vcpu); 1663db0758b2SDavid Hildenbrand } 1664db0758b2SDavid Hildenbrand 1665db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 1666db0758b2SDavid Hildenbrand static void __disable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1667db0758b2SDavid Hildenbrand { 1668db0758b2SDavid Hildenbrand WARN_ON_ONCE(!vcpu->arch.cputm_enabled); 1669db0758b2SDavid Hildenbrand __stop_cpu_timer_accounting(vcpu); 1670db0758b2SDavid Hildenbrand vcpu->arch.cputm_enabled = false; 1671db0758b2SDavid Hildenbrand } 1672db0758b2SDavid Hildenbrand 1673db0758b2SDavid Hildenbrand static void enable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1674db0758b2SDavid Hildenbrand { 1675db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 1676db0758b2SDavid Hildenbrand __enable_cpu_timer_accounting(vcpu); 1677db0758b2SDavid Hildenbrand preempt_enable(); 1678db0758b2SDavid Hildenbrand } 1679db0758b2SDavid Hildenbrand 1680db0758b2SDavid Hildenbrand static void disable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 1681db0758b2SDavid Hildenbrand { 1682db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 1683db0758b2SDavid Hildenbrand __disable_cpu_timer_accounting(vcpu); 1684db0758b2SDavid Hildenbrand preempt_enable(); 1685db0758b2SDavid Hildenbrand } 1686db0758b2SDavid Hildenbrand 16874287f247SDavid Hildenbrand /* set the cpu timer - may only be called from the VCPU thread itself */ 16884287f247SDavid Hildenbrand void kvm_s390_set_cpu_timer(struct kvm_vcpu *vcpu, __u64 cputm) 16894287f247SDavid Hildenbrand { 1690db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 16919c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 1692db0758b2SDavid Hildenbrand if (vcpu->arch.cputm_enabled) 1693db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = get_tod_clock_fast(); 16944287f247SDavid Hildenbrand vcpu->arch.sie_block->cputm = cputm; 16959c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 1696db0758b2SDavid Hildenbrand preempt_enable(); 16974287f247SDavid Hildenbrand } 16984287f247SDavid Hildenbrand 1699db0758b2SDavid Hildenbrand /* update and get the cpu timer - can also be called from other VCPU threads */ 17004287f247SDavid Hildenbrand __u64 kvm_s390_get_cpu_timer(struct kvm_vcpu *vcpu) 17014287f247SDavid Hildenbrand { 17029c23a131SDavid Hildenbrand unsigned int seq; 1703db0758b2SDavid Hildenbrand __u64 value; 1704db0758b2SDavid Hildenbrand 1705db0758b2SDavid Hildenbrand if (unlikely(!vcpu->arch.cputm_enabled)) 17064287f247SDavid Hildenbrand return vcpu->arch.sie_block->cputm; 1707db0758b2SDavid Hildenbrand 17089c23a131SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 17099c23a131SDavid Hildenbrand do { 17109c23a131SDavid Hildenbrand seq = raw_read_seqcount(&vcpu->arch.cputm_seqcount); 17119c23a131SDavid Hildenbrand /* 17129c23a131SDavid Hildenbrand * If the writer would ever execute a read in the critical 17139c23a131SDavid Hildenbrand * section, e.g. in irq context, we have a deadlock. 17149c23a131SDavid Hildenbrand */ 17159c23a131SDavid Hildenbrand WARN_ON_ONCE((seq & 1) && smp_processor_id() == vcpu->cpu); 1716db0758b2SDavid Hildenbrand value = vcpu->arch.sie_block->cputm; 17179c23a131SDavid Hildenbrand /* if cputm_start is 0, accounting is being started/stopped */ 17189c23a131SDavid Hildenbrand if (likely(vcpu->arch.cputm_start)) 1719db0758b2SDavid Hildenbrand value -= get_tod_clock_fast() - vcpu->arch.cputm_start; 17209c23a131SDavid Hildenbrand } while (read_seqcount_retry(&vcpu->arch.cputm_seqcount, seq & ~1)); 17219c23a131SDavid Hildenbrand preempt_enable(); 1722db0758b2SDavid Hildenbrand return value; 17234287f247SDavid Hildenbrand } 17244287f247SDavid Hildenbrand 1725b0c632dbSHeiko Carstens void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 1726b0c632dbSHeiko Carstens { 17279977e886SHendrik Brueckner /* Save host register state */ 1728d0164ee2SHendrik Brueckner save_fpu_regs(); 17299abc2a08SDavid Hildenbrand vcpu->arch.host_fpregs.fpc = current->thread.fpu.fpc; 17309abc2a08SDavid Hildenbrand vcpu->arch.host_fpregs.regs = current->thread.fpu.regs; 173196b2d7a8SHendrik Brueckner 17326fd8e67dSDavid Hildenbrand if (MACHINE_HAS_VX) 17339abc2a08SDavid Hildenbrand current->thread.fpu.regs = vcpu->run->s.regs.vrs; 17346fd8e67dSDavid Hildenbrand else 17356fd8e67dSDavid Hildenbrand current->thread.fpu.regs = vcpu->run->s.regs.fprs; 17369abc2a08SDavid Hildenbrand current->thread.fpu.fpc = vcpu->run->s.regs.fpc; 17379977e886SHendrik Brueckner if (test_fp_ctl(current->thread.fpu.fpc)) 173896b2d7a8SHendrik Brueckner /* User space provided an invalid FPC, let's clear it */ 17399977e886SHendrik Brueckner current->thread.fpu.fpc = 0; 17409977e886SHendrik Brueckner 17419977e886SHendrik Brueckner save_access_regs(vcpu->arch.host_acrs); 174259674c1aSChristian Borntraeger restore_access_regs(vcpu->run->s.regs.acrs); 174337d9df98SDavid Hildenbrand gmap_enable(vcpu->arch.enabled_gmap); 1744805de8f4SPeter Zijlstra atomic_or(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 17455ebda316SDavid Hildenbrand if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu)) 1746db0758b2SDavid Hildenbrand __start_cpu_timer_accounting(vcpu); 174701a745acSDavid Hildenbrand vcpu->cpu = cpu; 1748b0c632dbSHeiko Carstens } 1749b0c632dbSHeiko Carstens 1750b0c632dbSHeiko Carstens void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 1751b0c632dbSHeiko Carstens { 175201a745acSDavid Hildenbrand vcpu->cpu = -1; 17535ebda316SDavid Hildenbrand if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu)) 1754db0758b2SDavid Hildenbrand __stop_cpu_timer_accounting(vcpu); 1755805de8f4SPeter Zijlstra atomic_andnot(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 175637d9df98SDavid Hildenbrand vcpu->arch.enabled_gmap = gmap_get_enabled(); 175737d9df98SDavid Hildenbrand gmap_disable(vcpu->arch.enabled_gmap); 17589977e886SHendrik Brueckner 17599abc2a08SDavid Hildenbrand /* Save guest register state */ 1760d0164ee2SHendrik Brueckner save_fpu_regs(); 17619977e886SHendrik Brueckner vcpu->run->s.regs.fpc = current->thread.fpu.fpc; 17629abc2a08SDavid Hildenbrand 17639abc2a08SDavid Hildenbrand /* Restore host register state */ 17649abc2a08SDavid Hildenbrand current->thread.fpu.fpc = vcpu->arch.host_fpregs.fpc; 17659abc2a08SDavid Hildenbrand current->thread.fpu.regs = vcpu->arch.host_fpregs.regs; 17669977e886SHendrik Brueckner 17679977e886SHendrik Brueckner save_access_regs(vcpu->run->s.regs.acrs); 1768b0c632dbSHeiko Carstens restore_access_regs(vcpu->arch.host_acrs); 1769b0c632dbSHeiko Carstens } 1770b0c632dbSHeiko Carstens 1771b0c632dbSHeiko Carstens static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu) 1772b0c632dbSHeiko Carstens { 1773b0c632dbSHeiko Carstens /* this equals initial cpu reset in pop, but we don't switch to ESA */ 1774b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.mask = 0UL; 1775b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.addr = 0UL; 17768d26cf7bSChristian Borntraeger kvm_s390_set_prefix(vcpu, 0); 17774287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, 0); 1778b0c632dbSHeiko Carstens vcpu->arch.sie_block->ckc = 0UL; 1779b0c632dbSHeiko Carstens vcpu->arch.sie_block->todpr = 0; 1780b0c632dbSHeiko Carstens memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64)); 1781b0c632dbSHeiko Carstens vcpu->arch.sie_block->gcr[0] = 0xE0UL; 1782b0c632dbSHeiko Carstens vcpu->arch.sie_block->gcr[14] = 0xC2000000UL; 17839abc2a08SDavid Hildenbrand /* make sure the new fpc will be lazily loaded */ 17849abc2a08SDavid Hildenbrand save_fpu_regs(); 17859abc2a08SDavid Hildenbrand current->thread.fpu.fpc = 0; 1786b0c632dbSHeiko Carstens vcpu->arch.sie_block->gbea = 1; 1787672550fbSChristian Borntraeger vcpu->arch.sie_block->pp = 0; 17883c038e6bSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 17893c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 17906352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) 17916852d7b6SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 17922ed10cc1SJens Freimann kvm_s390_clear_local_irqs(vcpu); 1793b0c632dbSHeiko Carstens } 1794b0c632dbSHeiko Carstens 179531928aa5SDominik Dingel void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu) 179642897d86SMarcelo Tosatti { 179772f25020SJason J. Herne mutex_lock(&vcpu->kvm->lock); 1798fdf03650SFan Zhang preempt_disable(); 179972f25020SJason J. Herne vcpu->arch.sie_block->epoch = vcpu->kvm->arch.epoch; 1800fdf03650SFan Zhang preempt_enable(); 180172f25020SJason J. Herne mutex_unlock(&vcpu->kvm->lock); 180225508824SDavid Hildenbrand if (!kvm_is_ucontrol(vcpu->kvm)) { 1803dafd032aSDominik Dingel vcpu->arch.gmap = vcpu->kvm->arch.gmap; 1804eaa78f34SDavid Hildenbrand sca_add_vcpu(vcpu); 180525508824SDavid Hildenbrand } 180637d9df98SDavid Hildenbrand /* make vcpu_load load the right gmap on the first trigger */ 180737d9df98SDavid Hildenbrand vcpu->arch.enabled_gmap = vcpu->arch.gmap; 180842897d86SMarcelo Tosatti } 180942897d86SMarcelo Tosatti 18105102ee87STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu) 18115102ee87STony Krowiak { 18129d8d5786SMichael Mueller if (!test_kvm_facility(vcpu->kvm, 76)) 18135102ee87STony Krowiak return; 18145102ee87STony Krowiak 1815a374e892STony Krowiak vcpu->arch.sie_block->ecb3 &= ~(ECB3_AES | ECB3_DEA); 1816a374e892STony Krowiak 1817a374e892STony Krowiak if (vcpu->kvm->arch.crypto.aes_kw) 1818a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_AES; 1819a374e892STony Krowiak if (vcpu->kvm->arch.crypto.dea_kw) 1820a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_DEA; 1821a374e892STony Krowiak 18225102ee87STony Krowiak vcpu->arch.sie_block->crycbd = vcpu->kvm->arch.crypto.crycbd; 18235102ee87STony Krowiak } 18245102ee87STony Krowiak 1825b31605c1SDominik Dingel void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu) 1826b31605c1SDominik Dingel { 1827b31605c1SDominik Dingel free_page(vcpu->arch.sie_block->cbrlo); 1828b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = 0; 1829b31605c1SDominik Dingel } 1830b31605c1SDominik Dingel 1831b31605c1SDominik Dingel int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu) 1832b31605c1SDominik Dingel { 1833b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = get_zeroed_page(GFP_KERNEL); 1834b31605c1SDominik Dingel if (!vcpu->arch.sie_block->cbrlo) 1835b31605c1SDominik Dingel return -ENOMEM; 1836b31605c1SDominik Dingel 1837b31605c1SDominik Dingel vcpu->arch.sie_block->ecb2 |= 0x80; 1838b31605c1SDominik Dingel vcpu->arch.sie_block->ecb2 &= ~0x08; 1839b31605c1SDominik Dingel return 0; 1840b31605c1SDominik Dingel } 1841b31605c1SDominik Dingel 184291520f1aSMichael Mueller static void kvm_s390_vcpu_setup_model(struct kvm_vcpu *vcpu) 184391520f1aSMichael Mueller { 184491520f1aSMichael Mueller struct kvm_s390_cpu_model *model = &vcpu->kvm->arch.model; 184591520f1aSMichael Mueller 184691520f1aSMichael Mueller vcpu->arch.sie_block->ibc = model->ibc; 184780bc79dcSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 7)) 1848c54f0d6aSDavid Hildenbrand vcpu->arch.sie_block->fac = (u32)(u64) model->fac_list; 184991520f1aSMichael Mueller } 185091520f1aSMichael Mueller 1851b0c632dbSHeiko Carstens int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) 1852b0c632dbSHeiko Carstens { 1853b31605c1SDominik Dingel int rc = 0; 1854b31288faSKonstantin Weitz 18559e6dabefSCornelia Huck atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH | 18569e6dabefSCornelia Huck CPUSTAT_SM | 1857a4a4f191SGuenther Hutzl CPUSTAT_STOPPED); 1858a4a4f191SGuenther Hutzl 185953df84f8SGuenther Hutzl if (test_kvm_facility(vcpu->kvm, 78)) 1860805de8f4SPeter Zijlstra atomic_or(CPUSTAT_GED2, &vcpu->arch.sie_block->cpuflags); 186153df84f8SGuenther Hutzl else if (test_kvm_facility(vcpu->kvm, 8)) 1862805de8f4SPeter Zijlstra atomic_or(CPUSTAT_GED, &vcpu->arch.sie_block->cpuflags); 1863a4a4f191SGuenther Hutzl 186491520f1aSMichael Mueller kvm_s390_vcpu_setup_model(vcpu); 186591520f1aSMichael Mueller 1866bdab09f3SDavid Hildenbrand /* pgste_set_pte has special handling for !MACHINE_HAS_ESOP */ 1867bdab09f3SDavid Hildenbrand if (MACHINE_HAS_ESOP) 1868bdab09f3SDavid Hildenbrand vcpu->arch.sie_block->ecb |= 0x02; 1869bd50e8ecSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 9)) 1870bd50e8ecSDavid Hildenbrand vcpu->arch.sie_block->ecb |= 0x04; 1871f597d24eSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 73)) 18727feb6bb8SMichael Mueller vcpu->arch.sie_block->ecb |= 0x10; 18737feb6bb8SMichael Mueller 1874873b425eSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 8) && sclp.has_pfmfi) 1875d6af0b49SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= 0x08; 187648ee7d3aSDavid Hildenbrand vcpu->arch.sie_block->eca = 0x1002000U; 187748ee7d3aSDavid Hildenbrand if (sclp.has_cei) 187848ee7d3aSDavid Hildenbrand vcpu->arch.sie_block->eca |= 0x80000000U; 187911ad65b7SDavid Hildenbrand if (sclp.has_ib) 188011ad65b7SDavid Hildenbrand vcpu->arch.sie_block->eca |= 0x40000000U; 188137c5f6c8SDavid Hildenbrand if (sclp.has_siif) 1882217a4406SHeiko Carstens vcpu->arch.sie_block->eca |= 1; 188337c5f6c8SDavid Hildenbrand if (sclp.has_sigpif) 1884ea5f4969SDavid Hildenbrand vcpu->arch.sie_block->eca |= 0x10000000U; 1885c6e5f166SFan Zhang if (test_kvm_facility(vcpu->kvm, 64)) 1886c6e5f166SFan Zhang vcpu->arch.sie_block->ecb3 |= 0x01; 188718280d8bSMichael Mueller if (test_kvm_facility(vcpu->kvm, 129)) { 188813211ea7SEric Farman vcpu->arch.sie_block->eca |= 0x00020000; 188913211ea7SEric Farman vcpu->arch.sie_block->ecd |= 0x20000000; 189013211ea7SEric Farman } 1891c6e5f166SFan Zhang vcpu->arch.sie_block->riccbd = (unsigned long) &vcpu->run->s.regs.riccb; 1892492d8642SThomas Huth vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE; 189395ca2cb5SJanosch Frank if (test_kvm_facility(vcpu->kvm, 74)) 189495ca2cb5SJanosch Frank vcpu->arch.sie_block->ictl |= ICTL_OPEREXC; 18955a5e6536SMatthew Rosato 1896e6db1d61SDominik Dingel if (vcpu->kvm->arch.use_cmma) { 1897b31605c1SDominik Dingel rc = kvm_s390_vcpu_setup_cmma(vcpu); 1898b31605c1SDominik Dingel if (rc) 1899b31605c1SDominik Dingel return rc; 1900b31288faSKonstantin Weitz } 19010ac96cafSDavid Hildenbrand hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 1902ca872302SChristian Borntraeger vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup; 19039d8d5786SMichael Mueller 19045102ee87STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 19055102ee87STony Krowiak 1906b31605c1SDominik Dingel return rc; 1907b0c632dbSHeiko Carstens } 1908b0c632dbSHeiko Carstens 1909b0c632dbSHeiko Carstens struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, 1910b0c632dbSHeiko Carstens unsigned int id) 1911b0c632dbSHeiko Carstens { 19124d47555aSCarsten Otte struct kvm_vcpu *vcpu; 19137feb6bb8SMichael Mueller struct sie_page *sie_page; 19144d47555aSCarsten Otte int rc = -EINVAL; 1915b0c632dbSHeiko Carstens 19164215825eSDavid Hildenbrand if (!kvm_is_ucontrol(kvm) && !sca_can_add_vcpu(kvm, id)) 19174d47555aSCarsten Otte goto out; 19184d47555aSCarsten Otte 19194d47555aSCarsten Otte rc = -ENOMEM; 19204d47555aSCarsten Otte 1921b110feafSMichael Mueller vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL); 1922b0c632dbSHeiko Carstens if (!vcpu) 19234d47555aSCarsten Otte goto out; 1924b0c632dbSHeiko Carstens 19257feb6bb8SMichael Mueller sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL); 19267feb6bb8SMichael Mueller if (!sie_page) 1927b0c632dbSHeiko Carstens goto out_free_cpu; 1928b0c632dbSHeiko Carstens 19297feb6bb8SMichael Mueller vcpu->arch.sie_block = &sie_page->sie_block; 19307feb6bb8SMichael Mueller vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb; 19317feb6bb8SMichael Mueller 1932efed1104SDavid Hildenbrand /* the real guest size will always be smaller than msl */ 1933efed1104SDavid Hildenbrand vcpu->arch.sie_block->mso = 0; 1934efed1104SDavid Hildenbrand vcpu->arch.sie_block->msl = sclp.hamax; 1935efed1104SDavid Hildenbrand 1936b0c632dbSHeiko Carstens vcpu->arch.sie_block->icpua = id; 1937ba5c1e9bSCarsten Otte spin_lock_init(&vcpu->arch.local_int.lock); 1938ba5c1e9bSCarsten Otte vcpu->arch.local_int.float_int = &kvm->arch.float_int; 1939d0321a24SChristian Borntraeger vcpu->arch.local_int.wq = &vcpu->wq; 19405288fbf0SChristian Borntraeger vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags; 19419c23a131SDavid Hildenbrand seqcount_init(&vcpu->arch.cputm_seqcount); 1942ba5c1e9bSCarsten Otte 1943b0c632dbSHeiko Carstens rc = kvm_vcpu_init(vcpu, kvm, id); 1944b0c632dbSHeiko Carstens if (rc) 19459abc2a08SDavid Hildenbrand goto out_free_sie_block; 19468335713aSChristian Borntraeger VM_EVENT(kvm, 3, "create cpu %d at 0x%pK, sie block at 0x%pK", id, vcpu, 1947b0c632dbSHeiko Carstens vcpu->arch.sie_block); 1948ade38c31SCornelia Huck trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block); 1949b0c632dbSHeiko Carstens 1950b0c632dbSHeiko Carstens return vcpu; 19517b06bf2fSWei Yongjun out_free_sie_block: 19527b06bf2fSWei Yongjun free_page((unsigned long)(vcpu->arch.sie_block)); 1953b0c632dbSHeiko Carstens out_free_cpu: 1954b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 19554d47555aSCarsten Otte out: 1956b0c632dbSHeiko Carstens return ERR_PTR(rc); 1957b0c632dbSHeiko Carstens } 1958b0c632dbSHeiko Carstens 1959b0c632dbSHeiko Carstens int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu) 1960b0c632dbSHeiko Carstens { 19619a022067SDavid Hildenbrand return kvm_s390_vcpu_has_irq(vcpu, 0); 1962b0c632dbSHeiko Carstens } 1963b0c632dbSHeiko Carstens 196427406cd5SChristian Borntraeger void kvm_s390_vcpu_block(struct kvm_vcpu *vcpu) 196549b99e1eSChristian Borntraeger { 1966805de8f4SPeter Zijlstra atomic_or(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 196761a6df54SDavid Hildenbrand exit_sie(vcpu); 196849b99e1eSChristian Borntraeger } 196949b99e1eSChristian Borntraeger 197027406cd5SChristian Borntraeger void kvm_s390_vcpu_unblock(struct kvm_vcpu *vcpu) 197149b99e1eSChristian Borntraeger { 1972805de8f4SPeter Zijlstra atomic_andnot(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 197349b99e1eSChristian Borntraeger } 197449b99e1eSChristian Borntraeger 19758e236546SChristian Borntraeger static void kvm_s390_vcpu_request(struct kvm_vcpu *vcpu) 19768e236546SChristian Borntraeger { 1977805de8f4SPeter Zijlstra atomic_or(PROG_REQUEST, &vcpu->arch.sie_block->prog20); 197861a6df54SDavid Hildenbrand exit_sie(vcpu); 19798e236546SChristian Borntraeger } 19808e236546SChristian Borntraeger 19818e236546SChristian Borntraeger static void kvm_s390_vcpu_request_handled(struct kvm_vcpu *vcpu) 19828e236546SChristian Borntraeger { 19839bf9fde2SJason J. Herne atomic_andnot(PROG_REQUEST, &vcpu->arch.sie_block->prog20); 19848e236546SChristian Borntraeger } 19858e236546SChristian Borntraeger 198649b99e1eSChristian Borntraeger /* 198749b99e1eSChristian Borntraeger * Kick a guest cpu out of SIE and wait until SIE is not running. 198849b99e1eSChristian Borntraeger * If the CPU is not running (e.g. waiting as idle) the function will 198949b99e1eSChristian Borntraeger * return immediately. */ 199049b99e1eSChristian Borntraeger void exit_sie(struct kvm_vcpu *vcpu) 199149b99e1eSChristian Borntraeger { 1992805de8f4SPeter Zijlstra atomic_or(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags); 199349b99e1eSChristian Borntraeger while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE) 199449b99e1eSChristian Borntraeger cpu_relax(); 199549b99e1eSChristian Borntraeger } 199649b99e1eSChristian Borntraeger 19978e236546SChristian Borntraeger /* Kick a guest cpu out of SIE to process a request synchronously */ 19988e236546SChristian Borntraeger void kvm_s390_sync_request(int req, struct kvm_vcpu *vcpu) 199949b99e1eSChristian Borntraeger { 20008e236546SChristian Borntraeger kvm_make_request(req, vcpu); 20018e236546SChristian Borntraeger kvm_s390_vcpu_request(vcpu); 200249b99e1eSChristian Borntraeger } 200349b99e1eSChristian Borntraeger 2004414d3b07SMartin Schwidefsky static void kvm_gmap_notifier(struct gmap *gmap, unsigned long start, 2005414d3b07SMartin Schwidefsky unsigned long end) 20062c70fe44SChristian Borntraeger { 20072c70fe44SChristian Borntraeger struct kvm *kvm = gmap->private; 20082c70fe44SChristian Borntraeger struct kvm_vcpu *vcpu; 2009414d3b07SMartin Schwidefsky unsigned long prefix; 2010414d3b07SMartin Schwidefsky int i; 20112c70fe44SChristian Borntraeger 201265d0b0d4SDavid Hildenbrand if (gmap_is_shadow(gmap)) 201365d0b0d4SDavid Hildenbrand return; 2014414d3b07SMartin Schwidefsky if (start >= 1UL << 31) 2015414d3b07SMartin Schwidefsky /* We are only interested in prefix pages */ 2016414d3b07SMartin Schwidefsky return; 20172c70fe44SChristian Borntraeger kvm_for_each_vcpu(i, vcpu, kvm) { 20182c70fe44SChristian Borntraeger /* match against both prefix pages */ 2019414d3b07SMartin Schwidefsky prefix = kvm_s390_get_prefix(vcpu); 2020414d3b07SMartin Schwidefsky if (prefix <= end && start <= prefix + 2*PAGE_SIZE - 1) { 2021414d3b07SMartin Schwidefsky VCPU_EVENT(vcpu, 2, "gmap notifier for %lx-%lx", 2022414d3b07SMartin Schwidefsky start, end); 20238e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_MMU_RELOAD, vcpu); 20242c70fe44SChristian Borntraeger } 20252c70fe44SChristian Borntraeger } 20262c70fe44SChristian Borntraeger } 20272c70fe44SChristian Borntraeger 2028b6d33834SChristoffer Dall int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu) 2029b6d33834SChristoffer Dall { 2030b6d33834SChristoffer Dall /* kvm common code refers to this, but never calls it */ 2031b6d33834SChristoffer Dall BUG(); 2032b6d33834SChristoffer Dall return 0; 2033b6d33834SChristoffer Dall } 2034b6d33834SChristoffer Dall 203514eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, 203614eebd91SCarsten Otte struct kvm_one_reg *reg) 203714eebd91SCarsten Otte { 203814eebd91SCarsten Otte int r = -EINVAL; 203914eebd91SCarsten Otte 204014eebd91SCarsten Otte switch (reg->id) { 204129b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 204229b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->todpr, 204329b7c71bSCarsten Otte (u32 __user *)reg->addr); 204429b7c71bSCarsten Otte break; 204529b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 204629b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->epoch, 204729b7c71bSCarsten Otte (u64 __user *)reg->addr); 204829b7c71bSCarsten Otte break; 204946a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 20504287f247SDavid Hildenbrand r = put_user(kvm_s390_get_cpu_timer(vcpu), 205146a6dd1cSJason J. herne (u64 __user *)reg->addr); 205246a6dd1cSJason J. herne break; 205346a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 205446a6dd1cSJason J. herne r = put_user(vcpu->arch.sie_block->ckc, 205546a6dd1cSJason J. herne (u64 __user *)reg->addr); 205646a6dd1cSJason J. herne break; 2057536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 2058536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_token, 2059536336c2SDominik Dingel (u64 __user *)reg->addr); 2060536336c2SDominik Dingel break; 2061536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 2062536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_compare, 2063536336c2SDominik Dingel (u64 __user *)reg->addr); 2064536336c2SDominik Dingel break; 2065536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 2066536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_select, 2067536336c2SDominik Dingel (u64 __user *)reg->addr); 2068536336c2SDominik Dingel break; 2069672550fbSChristian Borntraeger case KVM_REG_S390_PP: 2070672550fbSChristian Borntraeger r = put_user(vcpu->arch.sie_block->pp, 2071672550fbSChristian Borntraeger (u64 __user *)reg->addr); 2072672550fbSChristian Borntraeger break; 2073afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 2074afa45ff5SChristian Borntraeger r = put_user(vcpu->arch.sie_block->gbea, 2075afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 2076afa45ff5SChristian Borntraeger break; 207714eebd91SCarsten Otte default: 207814eebd91SCarsten Otte break; 207914eebd91SCarsten Otte } 208014eebd91SCarsten Otte 208114eebd91SCarsten Otte return r; 208214eebd91SCarsten Otte } 208314eebd91SCarsten Otte 208414eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, 208514eebd91SCarsten Otte struct kvm_one_reg *reg) 208614eebd91SCarsten Otte { 208714eebd91SCarsten Otte int r = -EINVAL; 20884287f247SDavid Hildenbrand __u64 val; 208914eebd91SCarsten Otte 209014eebd91SCarsten Otte switch (reg->id) { 209129b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 209229b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->todpr, 209329b7c71bSCarsten Otte (u32 __user *)reg->addr); 209429b7c71bSCarsten Otte break; 209529b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 209629b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->epoch, 209729b7c71bSCarsten Otte (u64 __user *)reg->addr); 209829b7c71bSCarsten Otte break; 209946a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 21004287f247SDavid Hildenbrand r = get_user(val, (u64 __user *)reg->addr); 21014287f247SDavid Hildenbrand if (!r) 21024287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, val); 210346a6dd1cSJason J. herne break; 210446a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 210546a6dd1cSJason J. herne r = get_user(vcpu->arch.sie_block->ckc, 210646a6dd1cSJason J. herne (u64 __user *)reg->addr); 210746a6dd1cSJason J. herne break; 2108536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 2109536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_token, 2110536336c2SDominik Dingel (u64 __user *)reg->addr); 21119fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 21129fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 2113536336c2SDominik Dingel break; 2114536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 2115536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_compare, 2116536336c2SDominik Dingel (u64 __user *)reg->addr); 2117536336c2SDominik Dingel break; 2118536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 2119536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_select, 2120536336c2SDominik Dingel (u64 __user *)reg->addr); 2121536336c2SDominik Dingel break; 2122672550fbSChristian Borntraeger case KVM_REG_S390_PP: 2123672550fbSChristian Borntraeger r = get_user(vcpu->arch.sie_block->pp, 2124672550fbSChristian Borntraeger (u64 __user *)reg->addr); 2125672550fbSChristian Borntraeger break; 2126afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 2127afa45ff5SChristian Borntraeger r = get_user(vcpu->arch.sie_block->gbea, 2128afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 2129afa45ff5SChristian Borntraeger break; 213014eebd91SCarsten Otte default: 213114eebd91SCarsten Otte break; 213214eebd91SCarsten Otte } 213314eebd91SCarsten Otte 213414eebd91SCarsten Otte return r; 213514eebd91SCarsten Otte } 2136b6d33834SChristoffer Dall 2137b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) 2138b0c632dbSHeiko Carstens { 2139b0c632dbSHeiko Carstens kvm_s390_vcpu_initial_reset(vcpu); 2140b0c632dbSHeiko Carstens return 0; 2141b0c632dbSHeiko Carstens } 2142b0c632dbSHeiko Carstens 2143b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 2144b0c632dbSHeiko Carstens { 21455a32c1afSChristian Borntraeger memcpy(&vcpu->run->s.regs.gprs, ®s->gprs, sizeof(regs->gprs)); 2146b0c632dbSHeiko Carstens return 0; 2147b0c632dbSHeiko Carstens } 2148b0c632dbSHeiko Carstens 2149b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 2150b0c632dbSHeiko Carstens { 21515a32c1afSChristian Borntraeger memcpy(®s->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs)); 2152b0c632dbSHeiko Carstens return 0; 2153b0c632dbSHeiko Carstens } 2154b0c632dbSHeiko Carstens 2155b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, 2156b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 2157b0c632dbSHeiko Carstens { 215859674c1aSChristian Borntraeger memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs)); 2159b0c632dbSHeiko Carstens memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs)); 216059674c1aSChristian Borntraeger restore_access_regs(vcpu->run->s.regs.acrs); 2161b0c632dbSHeiko Carstens return 0; 2162b0c632dbSHeiko Carstens } 2163b0c632dbSHeiko Carstens 2164b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, 2165b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 2166b0c632dbSHeiko Carstens { 216759674c1aSChristian Borntraeger memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs)); 2168b0c632dbSHeiko Carstens memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs)); 2169b0c632dbSHeiko Carstens return 0; 2170b0c632dbSHeiko Carstens } 2171b0c632dbSHeiko Carstens 2172b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 2173b0c632dbSHeiko Carstens { 21749abc2a08SDavid Hildenbrand /* make sure the new values will be lazily loaded */ 21759abc2a08SDavid Hildenbrand save_fpu_regs(); 21764725c860SMartin Schwidefsky if (test_fp_ctl(fpu->fpc)) 21774725c860SMartin Schwidefsky return -EINVAL; 21789abc2a08SDavid Hildenbrand current->thread.fpu.fpc = fpu->fpc; 21799abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) 21809abc2a08SDavid Hildenbrand convert_fp_to_vx(current->thread.fpu.vxrs, (freg_t *)fpu->fprs); 21819abc2a08SDavid Hildenbrand else 21829abc2a08SDavid Hildenbrand memcpy(current->thread.fpu.fprs, &fpu->fprs, sizeof(fpu->fprs)); 2183b0c632dbSHeiko Carstens return 0; 2184b0c632dbSHeiko Carstens } 2185b0c632dbSHeiko Carstens 2186b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 2187b0c632dbSHeiko Carstens { 21889abc2a08SDavid Hildenbrand /* make sure we have the latest values */ 21899abc2a08SDavid Hildenbrand save_fpu_regs(); 21909abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) 21919abc2a08SDavid Hildenbrand convert_vx_to_fp((freg_t *)fpu->fprs, current->thread.fpu.vxrs); 21929abc2a08SDavid Hildenbrand else 21939abc2a08SDavid Hildenbrand memcpy(fpu->fprs, current->thread.fpu.fprs, sizeof(fpu->fprs)); 21949abc2a08SDavid Hildenbrand fpu->fpc = current->thread.fpu.fpc; 2195b0c632dbSHeiko Carstens return 0; 2196b0c632dbSHeiko Carstens } 2197b0c632dbSHeiko Carstens 2198b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw) 2199b0c632dbSHeiko Carstens { 2200b0c632dbSHeiko Carstens int rc = 0; 2201b0c632dbSHeiko Carstens 22027a42fdc2SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 2203b0c632dbSHeiko Carstens rc = -EBUSY; 2204d7b0b5ebSCarsten Otte else { 2205d7b0b5ebSCarsten Otte vcpu->run->psw_mask = psw.mask; 2206d7b0b5ebSCarsten Otte vcpu->run->psw_addr = psw.addr; 2207d7b0b5ebSCarsten Otte } 2208b0c632dbSHeiko Carstens return rc; 2209b0c632dbSHeiko Carstens } 2210b0c632dbSHeiko Carstens 2211b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, 2212b0c632dbSHeiko Carstens struct kvm_translation *tr) 2213b0c632dbSHeiko Carstens { 2214b0c632dbSHeiko Carstens return -EINVAL; /* not implemented yet */ 2215b0c632dbSHeiko Carstens } 2216b0c632dbSHeiko Carstens 221727291e21SDavid Hildenbrand #define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \ 221827291e21SDavid Hildenbrand KVM_GUESTDBG_USE_HW_BP | \ 221927291e21SDavid Hildenbrand KVM_GUESTDBG_ENABLE) 222027291e21SDavid Hildenbrand 2221d0bfb940SJan Kiszka int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 2222d0bfb940SJan Kiszka struct kvm_guest_debug *dbg) 2223b0c632dbSHeiko Carstens { 222427291e21SDavid Hildenbrand int rc = 0; 222527291e21SDavid Hildenbrand 222627291e21SDavid Hildenbrand vcpu->guest_debug = 0; 222727291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 222827291e21SDavid Hildenbrand 22292de3bfc2SDavid Hildenbrand if (dbg->control & ~VALID_GUESTDBG_FLAGS) 223027291e21SDavid Hildenbrand return -EINVAL; 223189b5b4deSDavid Hildenbrand if (!sclp.has_gpere) 223289b5b4deSDavid Hildenbrand return -EINVAL; 223327291e21SDavid Hildenbrand 223427291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_ENABLE) { 223527291e21SDavid Hildenbrand vcpu->guest_debug = dbg->control; 223627291e21SDavid Hildenbrand /* enforce guest PER */ 2237805de8f4SPeter Zijlstra atomic_or(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags); 223827291e21SDavid Hildenbrand 223927291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_USE_HW_BP) 224027291e21SDavid Hildenbrand rc = kvm_s390_import_bp_data(vcpu, dbg); 224127291e21SDavid Hildenbrand } else { 2242805de8f4SPeter Zijlstra atomic_andnot(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags); 224327291e21SDavid Hildenbrand vcpu->arch.guestdbg.last_bp = 0; 224427291e21SDavid Hildenbrand } 224527291e21SDavid Hildenbrand 224627291e21SDavid Hildenbrand if (rc) { 224727291e21SDavid Hildenbrand vcpu->guest_debug = 0; 224827291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 2249805de8f4SPeter Zijlstra atomic_andnot(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags); 225027291e21SDavid Hildenbrand } 225127291e21SDavid Hildenbrand 225227291e21SDavid Hildenbrand return rc; 2253b0c632dbSHeiko Carstens } 2254b0c632dbSHeiko Carstens 225562d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 225662d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 225762d9f0dbSMarcelo Tosatti { 22586352e4d2SDavid Hildenbrand /* CHECK_STOP and LOAD are not supported yet */ 22596352e4d2SDavid Hildenbrand return is_vcpu_stopped(vcpu) ? KVM_MP_STATE_STOPPED : 22606352e4d2SDavid Hildenbrand KVM_MP_STATE_OPERATING; 226162d9f0dbSMarcelo Tosatti } 226262d9f0dbSMarcelo Tosatti 226362d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 226462d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 226562d9f0dbSMarcelo Tosatti { 22666352e4d2SDavid Hildenbrand int rc = 0; 22676352e4d2SDavid Hildenbrand 22686352e4d2SDavid Hildenbrand /* user space knows about this interface - let it control the state */ 22696352e4d2SDavid Hildenbrand vcpu->kvm->arch.user_cpu_state_ctrl = 1; 22706352e4d2SDavid Hildenbrand 22716352e4d2SDavid Hildenbrand switch (mp_state->mp_state) { 22726352e4d2SDavid Hildenbrand case KVM_MP_STATE_STOPPED: 22736352e4d2SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 22746352e4d2SDavid Hildenbrand break; 22756352e4d2SDavid Hildenbrand case KVM_MP_STATE_OPERATING: 22766352e4d2SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 22776352e4d2SDavid Hildenbrand break; 22786352e4d2SDavid Hildenbrand case KVM_MP_STATE_LOAD: 22796352e4d2SDavid Hildenbrand case KVM_MP_STATE_CHECK_STOP: 22806352e4d2SDavid Hildenbrand /* fall through - CHECK_STOP and LOAD are not supported yet */ 22816352e4d2SDavid Hildenbrand default: 22826352e4d2SDavid Hildenbrand rc = -ENXIO; 22836352e4d2SDavid Hildenbrand } 22846352e4d2SDavid Hildenbrand 22856352e4d2SDavid Hildenbrand return rc; 228662d9f0dbSMarcelo Tosatti } 228762d9f0dbSMarcelo Tosatti 22888ad35755SDavid Hildenbrand static bool ibs_enabled(struct kvm_vcpu *vcpu) 22898ad35755SDavid Hildenbrand { 22908ad35755SDavid Hildenbrand return atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_IBS; 22918ad35755SDavid Hildenbrand } 22928ad35755SDavid Hildenbrand 22932c70fe44SChristian Borntraeger static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu) 22942c70fe44SChristian Borntraeger { 22958ad35755SDavid Hildenbrand retry: 22968e236546SChristian Borntraeger kvm_s390_vcpu_request_handled(vcpu); 2297586b7ccdSChristian Borntraeger if (!vcpu->requests) 2298586b7ccdSChristian Borntraeger return 0; 22992c70fe44SChristian Borntraeger /* 23002c70fe44SChristian Borntraeger * We use MMU_RELOAD just to re-arm the ipte notifier for the 2301b2d73b2aSMartin Schwidefsky * guest prefix page. gmap_mprotect_notify will wait on the ptl lock. 23022c70fe44SChristian Borntraeger * This ensures that the ipte instruction for this request has 23032c70fe44SChristian Borntraeger * already finished. We might race against a second unmapper that 23042c70fe44SChristian Borntraeger * wants to set the blocking bit. Lets just retry the request loop. 23052c70fe44SChristian Borntraeger */ 23068ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) { 23072c70fe44SChristian Borntraeger int rc; 2308b2d73b2aSMartin Schwidefsky rc = gmap_mprotect_notify(vcpu->arch.gmap, 2309fda902cbSMichael Mueller kvm_s390_get_prefix(vcpu), 2310b2d73b2aSMartin Schwidefsky PAGE_SIZE * 2, PROT_WRITE); 23112c70fe44SChristian Borntraeger if (rc) 23122c70fe44SChristian Borntraeger return rc; 23138ad35755SDavid Hildenbrand goto retry; 23142c70fe44SChristian Borntraeger } 23158ad35755SDavid Hildenbrand 2316d3d692c8SDavid Hildenbrand if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu)) { 2317d3d692c8SDavid Hildenbrand vcpu->arch.sie_block->ihcpu = 0xffff; 2318d3d692c8SDavid Hildenbrand goto retry; 2319d3d692c8SDavid Hildenbrand } 2320d3d692c8SDavid Hildenbrand 23218ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu)) { 23228ad35755SDavid Hildenbrand if (!ibs_enabled(vcpu)) { 23238ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 1); 2324805de8f4SPeter Zijlstra atomic_or(CPUSTAT_IBS, 23258ad35755SDavid Hildenbrand &vcpu->arch.sie_block->cpuflags); 23268ad35755SDavid Hildenbrand } 23278ad35755SDavid Hildenbrand goto retry; 23288ad35755SDavid Hildenbrand } 23298ad35755SDavid Hildenbrand 23308ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu)) { 23318ad35755SDavid Hildenbrand if (ibs_enabled(vcpu)) { 23328ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 0); 2333805de8f4SPeter Zijlstra atomic_andnot(CPUSTAT_IBS, 23348ad35755SDavid Hildenbrand &vcpu->arch.sie_block->cpuflags); 23358ad35755SDavid Hildenbrand } 23368ad35755SDavid Hildenbrand goto retry; 23378ad35755SDavid Hildenbrand } 23388ad35755SDavid Hildenbrand 23390759d068SDavid Hildenbrand /* nothing to do, just clear the request */ 23400759d068SDavid Hildenbrand clear_bit(KVM_REQ_UNHALT, &vcpu->requests); 23410759d068SDavid Hildenbrand 23422c70fe44SChristian Borntraeger return 0; 23432c70fe44SChristian Borntraeger } 23442c70fe44SChristian Borntraeger 234525ed1675SDavid Hildenbrand void kvm_s390_set_tod_clock(struct kvm *kvm, u64 tod) 234625ed1675SDavid Hildenbrand { 234725ed1675SDavid Hildenbrand struct kvm_vcpu *vcpu; 234825ed1675SDavid Hildenbrand int i; 234925ed1675SDavid Hildenbrand 235025ed1675SDavid Hildenbrand mutex_lock(&kvm->lock); 235125ed1675SDavid Hildenbrand preempt_disable(); 235225ed1675SDavid Hildenbrand kvm->arch.epoch = tod - get_tod_clock(); 235325ed1675SDavid Hildenbrand kvm_s390_vcpu_block_all(kvm); 235425ed1675SDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) 235525ed1675SDavid Hildenbrand vcpu->arch.sie_block->epoch = kvm->arch.epoch; 235625ed1675SDavid Hildenbrand kvm_s390_vcpu_unblock_all(kvm); 235725ed1675SDavid Hildenbrand preempt_enable(); 235825ed1675SDavid Hildenbrand mutex_unlock(&kvm->lock); 235925ed1675SDavid Hildenbrand } 236025ed1675SDavid Hildenbrand 2361fa576c58SThomas Huth /** 2362fa576c58SThomas Huth * kvm_arch_fault_in_page - fault-in guest page if necessary 2363fa576c58SThomas Huth * @vcpu: The corresponding virtual cpu 2364fa576c58SThomas Huth * @gpa: Guest physical address 2365fa576c58SThomas Huth * @writable: Whether the page should be writable or not 2366fa576c58SThomas Huth * 2367fa576c58SThomas Huth * Make sure that a guest page has been faulted-in on the host. 2368fa576c58SThomas Huth * 2369fa576c58SThomas Huth * Return: Zero on success, negative error code otherwise. 2370fa576c58SThomas Huth */ 2371fa576c58SThomas Huth long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable) 237224eb3a82SDominik Dingel { 2373527e30b4SMartin Schwidefsky return gmap_fault(vcpu->arch.gmap, gpa, 2374527e30b4SMartin Schwidefsky writable ? FAULT_FLAG_WRITE : 0); 237524eb3a82SDominik Dingel } 237624eb3a82SDominik Dingel 23773c038e6bSDominik Dingel static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token, 23783c038e6bSDominik Dingel unsigned long token) 23793c038e6bSDominik Dingel { 23803c038e6bSDominik Dingel struct kvm_s390_interrupt inti; 2381383d0b05SJens Freimann struct kvm_s390_irq irq; 23823c038e6bSDominik Dingel 23833c038e6bSDominik Dingel if (start_token) { 2384383d0b05SJens Freimann irq.u.ext.ext_params2 = token; 2385383d0b05SJens Freimann irq.type = KVM_S390_INT_PFAULT_INIT; 2386383d0b05SJens Freimann WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &irq)); 23873c038e6bSDominik Dingel } else { 23883c038e6bSDominik Dingel inti.type = KVM_S390_INT_PFAULT_DONE; 2389383d0b05SJens Freimann inti.parm64 = token; 23903c038e6bSDominik Dingel WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti)); 23913c038e6bSDominik Dingel } 23923c038e6bSDominik Dingel } 23933c038e6bSDominik Dingel 23943c038e6bSDominik Dingel void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu, 23953c038e6bSDominik Dingel struct kvm_async_pf *work) 23963c038e6bSDominik Dingel { 23973c038e6bSDominik Dingel trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token); 23983c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token); 23993c038e6bSDominik Dingel } 24003c038e6bSDominik Dingel 24013c038e6bSDominik Dingel void kvm_arch_async_page_present(struct kvm_vcpu *vcpu, 24023c038e6bSDominik Dingel struct kvm_async_pf *work) 24033c038e6bSDominik Dingel { 24043c038e6bSDominik Dingel trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token); 24053c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token); 24063c038e6bSDominik Dingel } 24073c038e6bSDominik Dingel 24083c038e6bSDominik Dingel void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu, 24093c038e6bSDominik Dingel struct kvm_async_pf *work) 24103c038e6bSDominik Dingel { 24113c038e6bSDominik Dingel /* s390 will always inject the page directly */ 24123c038e6bSDominik Dingel } 24133c038e6bSDominik Dingel 24143c038e6bSDominik Dingel bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu) 24153c038e6bSDominik Dingel { 24163c038e6bSDominik Dingel /* 24173c038e6bSDominik Dingel * s390 will always inject the page directly, 24183c038e6bSDominik Dingel * but we still want check_async_completion to cleanup 24193c038e6bSDominik Dingel */ 24203c038e6bSDominik Dingel return true; 24213c038e6bSDominik Dingel } 24223c038e6bSDominik Dingel 24233c038e6bSDominik Dingel static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu) 24243c038e6bSDominik Dingel { 24253c038e6bSDominik Dingel hva_t hva; 24263c038e6bSDominik Dingel struct kvm_arch_async_pf arch; 24273c038e6bSDominik Dingel int rc; 24283c038e6bSDominik Dingel 24293c038e6bSDominik Dingel if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 24303c038e6bSDominik Dingel return 0; 24313c038e6bSDominik Dingel if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) != 24323c038e6bSDominik Dingel vcpu->arch.pfault_compare) 24333c038e6bSDominik Dingel return 0; 24343c038e6bSDominik Dingel if (psw_extint_disabled(vcpu)) 24353c038e6bSDominik Dingel return 0; 24369a022067SDavid Hildenbrand if (kvm_s390_vcpu_has_irq(vcpu, 0)) 24373c038e6bSDominik Dingel return 0; 24383c038e6bSDominik Dingel if (!(vcpu->arch.sie_block->gcr[0] & 0x200ul)) 24393c038e6bSDominik Dingel return 0; 24403c038e6bSDominik Dingel if (!vcpu->arch.gmap->pfault_enabled) 24413c038e6bSDominik Dingel return 0; 24423c038e6bSDominik Dingel 244381480cc1SHeiko Carstens hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(current->thread.gmap_addr)); 244481480cc1SHeiko Carstens hva += current->thread.gmap_addr & ~PAGE_MASK; 244581480cc1SHeiko Carstens if (read_guest_real(vcpu, vcpu->arch.pfault_token, &arch.pfault_token, 8)) 24463c038e6bSDominik Dingel return 0; 24473c038e6bSDominik Dingel 24483c038e6bSDominik Dingel rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch); 24493c038e6bSDominik Dingel return rc; 24503c038e6bSDominik Dingel } 24513c038e6bSDominik Dingel 24523fb4c40fSThomas Huth static int vcpu_pre_run(struct kvm_vcpu *vcpu) 2453b0c632dbSHeiko Carstens { 24543fb4c40fSThomas Huth int rc, cpuflags; 2455e168bf8dSCarsten Otte 24563c038e6bSDominik Dingel /* 24573c038e6bSDominik Dingel * On s390 notifications for arriving pages will be delivered directly 24583c038e6bSDominik Dingel * to the guest but the house keeping for completed pfaults is 24593c038e6bSDominik Dingel * handled outside the worker. 24603c038e6bSDominik Dingel */ 24613c038e6bSDominik Dingel kvm_check_async_pf_completion(vcpu); 24623c038e6bSDominik Dingel 24637ec7c8c7SChristian Borntraeger vcpu->arch.sie_block->gg14 = vcpu->run->s.regs.gprs[14]; 24647ec7c8c7SChristian Borntraeger vcpu->arch.sie_block->gg15 = vcpu->run->s.regs.gprs[15]; 2465b0c632dbSHeiko Carstens 2466b0c632dbSHeiko Carstens if (need_resched()) 2467b0c632dbSHeiko Carstens schedule(); 2468b0c632dbSHeiko Carstens 2469d3a73acbSMartin Schwidefsky if (test_cpu_flag(CIF_MCCK_PENDING)) 247071cde587SChristian Borntraeger s390_handle_mcck(); 247171cde587SChristian Borntraeger 247279395031SJens Freimann if (!kvm_is_ucontrol(vcpu->kvm)) { 247379395031SJens Freimann rc = kvm_s390_deliver_pending_interrupts(vcpu); 247479395031SJens Freimann if (rc) 247579395031SJens Freimann return rc; 247679395031SJens Freimann } 24770ff31867SCarsten Otte 24782c70fe44SChristian Borntraeger rc = kvm_s390_handle_requests(vcpu); 24792c70fe44SChristian Borntraeger if (rc) 24802c70fe44SChristian Borntraeger return rc; 24812c70fe44SChristian Borntraeger 248227291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) { 248327291e21SDavid Hildenbrand kvm_s390_backup_guest_per_regs(vcpu); 248427291e21SDavid Hildenbrand kvm_s390_patch_guest_per_regs(vcpu); 248527291e21SDavid Hildenbrand } 248627291e21SDavid Hildenbrand 2487b0c632dbSHeiko Carstens vcpu->arch.sie_block->icptcode = 0; 24883fb4c40fSThomas Huth cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags); 24893fb4c40fSThomas Huth VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags); 24903fb4c40fSThomas Huth trace_kvm_s390_sie_enter(vcpu, cpuflags); 24912b29a9fdSDominik Dingel 24923fb4c40fSThomas Huth return 0; 24933fb4c40fSThomas Huth } 24943fb4c40fSThomas Huth 2495492d8642SThomas Huth static int vcpu_post_run_fault_in_sie(struct kvm_vcpu *vcpu) 2496492d8642SThomas Huth { 249756317920SDavid Hildenbrand struct kvm_s390_pgm_info pgm_info = { 249856317920SDavid Hildenbrand .code = PGM_ADDRESSING, 249956317920SDavid Hildenbrand }; 250056317920SDavid Hildenbrand u8 opcode, ilen; 2501492d8642SThomas Huth int rc; 2502492d8642SThomas Huth 2503492d8642SThomas Huth VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction"); 2504492d8642SThomas Huth trace_kvm_s390_sie_fault(vcpu); 2505492d8642SThomas Huth 2506492d8642SThomas Huth /* 2507492d8642SThomas Huth * We want to inject an addressing exception, which is defined as a 2508492d8642SThomas Huth * suppressing or terminating exception. However, since we came here 2509492d8642SThomas Huth * by a DAT access exception, the PSW still points to the faulting 2510492d8642SThomas Huth * instruction since DAT exceptions are nullifying. So we've got 2511492d8642SThomas Huth * to look up the current opcode to get the length of the instruction 2512492d8642SThomas Huth * to be able to forward the PSW. 2513492d8642SThomas Huth */ 251465977322SDavid Hildenbrand rc = read_guest_instr(vcpu, &opcode, 1); 251556317920SDavid Hildenbrand ilen = insn_length(opcode); 25169b0d721aSDavid Hildenbrand if (rc < 0) { 25179b0d721aSDavid Hildenbrand return rc; 25189b0d721aSDavid Hildenbrand } else if (rc) { 25199b0d721aSDavid Hildenbrand /* Instruction-Fetching Exceptions - we can't detect the ilen. 25209b0d721aSDavid Hildenbrand * Forward by arbitrary ilc, injection will take care of 25219b0d721aSDavid Hildenbrand * nullification if necessary. 25229b0d721aSDavid Hildenbrand */ 25239b0d721aSDavid Hildenbrand pgm_info = vcpu->arch.pgm; 25249b0d721aSDavid Hildenbrand ilen = 4; 25259b0d721aSDavid Hildenbrand } 252656317920SDavid Hildenbrand pgm_info.flags = ilen | KVM_S390_PGM_FLAGS_ILC_VALID; 252756317920SDavid Hildenbrand kvm_s390_forward_psw(vcpu, ilen); 252856317920SDavid Hildenbrand return kvm_s390_inject_prog_irq(vcpu, &pgm_info); 2529492d8642SThomas Huth } 2530492d8642SThomas Huth 25313fb4c40fSThomas Huth static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason) 25323fb4c40fSThomas Huth { 25332b29a9fdSDominik Dingel VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", 25342b29a9fdSDominik Dingel vcpu->arch.sie_block->icptcode); 25352b29a9fdSDominik Dingel trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode); 25362b29a9fdSDominik Dingel 253727291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) 253827291e21SDavid Hildenbrand kvm_s390_restore_guest_per_regs(vcpu); 253927291e21SDavid Hildenbrand 25407ec7c8c7SChristian Borntraeger vcpu->run->s.regs.gprs[14] = vcpu->arch.sie_block->gg14; 25417ec7c8c7SChristian Borntraeger vcpu->run->s.regs.gprs[15] = vcpu->arch.sie_block->gg15; 254271f116bfSDavid Hildenbrand 254371f116bfSDavid Hildenbrand if (vcpu->arch.sie_block->icptcode > 0) { 254471f116bfSDavid Hildenbrand int rc = kvm_handle_sie_intercept(vcpu); 254571f116bfSDavid Hildenbrand 254671f116bfSDavid Hildenbrand if (rc != -EOPNOTSUPP) 254771f116bfSDavid Hildenbrand return rc; 254871f116bfSDavid Hildenbrand vcpu->run->exit_reason = KVM_EXIT_S390_SIEIC; 254971f116bfSDavid Hildenbrand vcpu->run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode; 255071f116bfSDavid Hildenbrand vcpu->run->s390_sieic.ipa = vcpu->arch.sie_block->ipa; 255171f116bfSDavid Hildenbrand vcpu->run->s390_sieic.ipb = vcpu->arch.sie_block->ipb; 255271f116bfSDavid Hildenbrand return -EREMOTE; 255371f116bfSDavid Hildenbrand } else if (exit_reason != -EFAULT) { 255471f116bfSDavid Hildenbrand vcpu->stat.exit_null++; 255571f116bfSDavid Hildenbrand return 0; 2556210b1607SThomas Huth } else if (kvm_is_ucontrol(vcpu->kvm)) { 2557210b1607SThomas Huth vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL; 2558210b1607SThomas Huth vcpu->run->s390_ucontrol.trans_exc_code = 2559210b1607SThomas Huth current->thread.gmap_addr; 2560210b1607SThomas Huth vcpu->run->s390_ucontrol.pgm_code = 0x10; 256171f116bfSDavid Hildenbrand return -EREMOTE; 256224eb3a82SDominik Dingel } else if (current->thread.gmap_pfault) { 25633c038e6bSDominik Dingel trace_kvm_s390_major_guest_pfault(vcpu); 256424eb3a82SDominik Dingel current->thread.gmap_pfault = 0; 256571f116bfSDavid Hildenbrand if (kvm_arch_setup_async_pf(vcpu)) 256671f116bfSDavid Hildenbrand return 0; 256771f116bfSDavid Hildenbrand return kvm_arch_fault_in_page(vcpu, current->thread.gmap_addr, 1); 2568fa576c58SThomas Huth } 256971f116bfSDavid Hildenbrand return vcpu_post_run_fault_in_sie(vcpu); 25703fb4c40fSThomas Huth } 25713fb4c40fSThomas Huth 25723fb4c40fSThomas Huth static int __vcpu_run(struct kvm_vcpu *vcpu) 25733fb4c40fSThomas Huth { 25743fb4c40fSThomas Huth int rc, exit_reason; 25753fb4c40fSThomas Huth 2576800c1065SThomas Huth /* 2577800c1065SThomas Huth * We try to hold kvm->srcu during most of vcpu_run (except when run- 2578800c1065SThomas Huth * ning the guest), so that memslots (and other stuff) are protected 2579800c1065SThomas Huth */ 2580800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 2581800c1065SThomas Huth 2582a76ccff6SThomas Huth do { 25833fb4c40fSThomas Huth rc = vcpu_pre_run(vcpu); 25843fb4c40fSThomas Huth if (rc) 2585a76ccff6SThomas Huth break; 25863fb4c40fSThomas Huth 2587800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 25883fb4c40fSThomas Huth /* 2589a76ccff6SThomas Huth * As PF_VCPU will be used in fault handler, between 2590a76ccff6SThomas Huth * guest_enter and guest_exit should be no uaccess. 25913fb4c40fSThomas Huth */ 25920097d12eSChristian Borntraeger local_irq_disable(); 25930097d12eSChristian Borntraeger __kvm_guest_enter(); 2594db0758b2SDavid Hildenbrand __disable_cpu_timer_accounting(vcpu); 25950097d12eSChristian Borntraeger local_irq_enable(); 2596a76ccff6SThomas Huth exit_reason = sie64a(vcpu->arch.sie_block, 2597a76ccff6SThomas Huth vcpu->run->s.regs.gprs); 25980097d12eSChristian Borntraeger local_irq_disable(); 2599db0758b2SDavid Hildenbrand __enable_cpu_timer_accounting(vcpu); 26000097d12eSChristian Borntraeger __kvm_guest_exit(); 26010097d12eSChristian Borntraeger local_irq_enable(); 2602800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 26033fb4c40fSThomas Huth 26043fb4c40fSThomas Huth rc = vcpu_post_run(vcpu, exit_reason); 260527291e21SDavid Hildenbrand } while (!signal_pending(current) && !guestdbg_exit_pending(vcpu) && !rc); 26063fb4c40fSThomas Huth 2607800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 2608e168bf8dSCarsten Otte return rc; 2609b0c632dbSHeiko Carstens } 2610b0c632dbSHeiko Carstens 2611b028ee3eSDavid Hildenbrand static void sync_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 2612b028ee3eSDavid Hildenbrand { 2613b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask; 2614b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr; 2615b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) 2616b028ee3eSDavid Hildenbrand kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix); 2617b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) { 2618b028ee3eSDavid Hildenbrand memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128); 2619d3d692c8SDavid Hildenbrand /* some control register changes require a tlb flush */ 2620d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 2621b028ee3eSDavid Hildenbrand } 2622b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_ARCH0) { 26234287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, kvm_run->s.regs.cputm); 2624b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->ckc = kvm_run->s.regs.ckc; 2625b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->todpr = kvm_run->s.regs.todpr; 2626b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->pp = kvm_run->s.regs.pp; 2627b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gbea = kvm_run->s.regs.gbea; 2628b028ee3eSDavid Hildenbrand } 2629b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PFAULT) { 2630b028ee3eSDavid Hildenbrand vcpu->arch.pfault_token = kvm_run->s.regs.pft; 2631b028ee3eSDavid Hildenbrand vcpu->arch.pfault_select = kvm_run->s.regs.pfs; 2632b028ee3eSDavid Hildenbrand vcpu->arch.pfault_compare = kvm_run->s.regs.pfc; 26339fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 26349fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 2635b028ee3eSDavid Hildenbrand } 2636b028ee3eSDavid Hildenbrand kvm_run->kvm_dirty_regs = 0; 2637b028ee3eSDavid Hildenbrand } 2638b028ee3eSDavid Hildenbrand 2639b028ee3eSDavid Hildenbrand static void store_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 2640b028ee3eSDavid Hildenbrand { 2641b028ee3eSDavid Hildenbrand kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask; 2642b028ee3eSDavid Hildenbrand kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr; 2643b028ee3eSDavid Hildenbrand kvm_run->s.regs.prefix = kvm_s390_get_prefix(vcpu); 2644b028ee3eSDavid Hildenbrand memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128); 26454287f247SDavid Hildenbrand kvm_run->s.regs.cputm = kvm_s390_get_cpu_timer(vcpu); 2646b028ee3eSDavid Hildenbrand kvm_run->s.regs.ckc = vcpu->arch.sie_block->ckc; 2647b028ee3eSDavid Hildenbrand kvm_run->s.regs.todpr = vcpu->arch.sie_block->todpr; 2648b028ee3eSDavid Hildenbrand kvm_run->s.regs.pp = vcpu->arch.sie_block->pp; 2649b028ee3eSDavid Hildenbrand kvm_run->s.regs.gbea = vcpu->arch.sie_block->gbea; 2650b028ee3eSDavid Hildenbrand kvm_run->s.regs.pft = vcpu->arch.pfault_token; 2651b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfs = vcpu->arch.pfault_select; 2652b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfc = vcpu->arch.pfault_compare; 2653b028ee3eSDavid Hildenbrand } 2654b028ee3eSDavid Hildenbrand 2655b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 2656b0c632dbSHeiko Carstens { 26578f2abe6aSChristian Borntraeger int rc; 2658b0c632dbSHeiko Carstens sigset_t sigsaved; 2659b0c632dbSHeiko Carstens 266027291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu)) { 266127291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 266227291e21SDavid Hildenbrand return 0; 266327291e21SDavid Hildenbrand } 266427291e21SDavid Hildenbrand 2665b0c632dbSHeiko Carstens if (vcpu->sigset_active) 2666b0c632dbSHeiko Carstens sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); 2667b0c632dbSHeiko Carstens 26686352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) { 26696852d7b6SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 26706352e4d2SDavid Hildenbrand } else if (is_vcpu_stopped(vcpu)) { 2671ea2cdd27SDavid Hildenbrand pr_err_ratelimited("can't run stopped vcpu %d\n", 26726352e4d2SDavid Hildenbrand vcpu->vcpu_id); 26736352e4d2SDavid Hildenbrand return -EINVAL; 26746352e4d2SDavid Hildenbrand } 2675b0c632dbSHeiko Carstens 2676b028ee3eSDavid Hildenbrand sync_regs(vcpu, kvm_run); 2677db0758b2SDavid Hildenbrand enable_cpu_timer_accounting(vcpu); 2678d7b0b5ebSCarsten Otte 2679dab4079dSHeiko Carstens might_fault(); 2680e168bf8dSCarsten Otte rc = __vcpu_run(vcpu); 26819ace903dSChristian Ehrhardt 2682b1d16c49SChristian Ehrhardt if (signal_pending(current) && !rc) { 2683b1d16c49SChristian Ehrhardt kvm_run->exit_reason = KVM_EXIT_INTR; 26848f2abe6aSChristian Borntraeger rc = -EINTR; 2685b1d16c49SChristian Ehrhardt } 26868f2abe6aSChristian Borntraeger 268727291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu) && !rc) { 268827291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 268927291e21SDavid Hildenbrand rc = 0; 269027291e21SDavid Hildenbrand } 269127291e21SDavid Hildenbrand 26928f2abe6aSChristian Borntraeger if (rc == -EREMOTE) { 269371f116bfSDavid Hildenbrand /* userspace support is needed, kvm_run has been prepared */ 26948f2abe6aSChristian Borntraeger rc = 0; 26958f2abe6aSChristian Borntraeger } 26968f2abe6aSChristian Borntraeger 2697db0758b2SDavid Hildenbrand disable_cpu_timer_accounting(vcpu); 2698b028ee3eSDavid Hildenbrand store_regs(vcpu, kvm_run); 2699d7b0b5ebSCarsten Otte 2700b0c632dbSHeiko Carstens if (vcpu->sigset_active) 2701b0c632dbSHeiko Carstens sigprocmask(SIG_SETMASK, &sigsaved, NULL); 2702b0c632dbSHeiko Carstens 2703b0c632dbSHeiko Carstens vcpu->stat.exit_userspace++; 27047e8e6ab4SHeiko Carstens return rc; 2705b0c632dbSHeiko Carstens } 2706b0c632dbSHeiko Carstens 2707b0c632dbSHeiko Carstens /* 2708b0c632dbSHeiko Carstens * store status at address 2709b0c632dbSHeiko Carstens * we use have two special cases: 2710b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit 2711b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_PREFIXED: -> prefix 2712b0c632dbSHeiko Carstens */ 2713d0bce605SHeiko Carstens int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long gpa) 2714b0c632dbSHeiko Carstens { 2715092670cdSCarsten Otte unsigned char archmode = 1; 27169abc2a08SDavid Hildenbrand freg_t fprs[NUM_FPRS]; 2717fda902cbSMichael Mueller unsigned int px; 27184287f247SDavid Hildenbrand u64 clkcomp, cputm; 2719d0bce605SHeiko Carstens int rc; 2720b0c632dbSHeiko Carstens 2721d9a3a09aSMartin Schwidefsky px = kvm_s390_get_prefix(vcpu); 2722d0bce605SHeiko Carstens if (gpa == KVM_S390_STORE_STATUS_NOADDR) { 2723d0bce605SHeiko Carstens if (write_guest_abs(vcpu, 163, &archmode, 1)) 2724b0c632dbSHeiko Carstens return -EFAULT; 2725d9a3a09aSMartin Schwidefsky gpa = 0; 2726d0bce605SHeiko Carstens } else if (gpa == KVM_S390_STORE_STATUS_PREFIXED) { 2727d0bce605SHeiko Carstens if (write_guest_real(vcpu, 163, &archmode, 1)) 2728b0c632dbSHeiko Carstens return -EFAULT; 2729d9a3a09aSMartin Schwidefsky gpa = px; 2730d9a3a09aSMartin Schwidefsky } else 2731d9a3a09aSMartin Schwidefsky gpa -= __LC_FPREGS_SAVE_AREA; 27329abc2a08SDavid Hildenbrand 27339abc2a08SDavid Hildenbrand /* manually convert vector registers if necessary */ 27349abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) { 27359522b37fSDavid Hildenbrand convert_vx_to_fp(fprs, (__vector128 *) vcpu->run->s.regs.vrs); 2736d9a3a09aSMartin Schwidefsky rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA, 27379abc2a08SDavid Hildenbrand fprs, 128); 27389abc2a08SDavid Hildenbrand } else { 27399abc2a08SDavid Hildenbrand rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA, 27406fd8e67dSDavid Hildenbrand vcpu->run->s.regs.fprs, 128); 27419abc2a08SDavid Hildenbrand } 2742d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_GPREGS_SAVE_AREA, 2743d0bce605SHeiko Carstens vcpu->run->s.regs.gprs, 128); 2744d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_PSW_SAVE_AREA, 2745d0bce605SHeiko Carstens &vcpu->arch.sie_block->gpsw, 16); 2746d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_PREFIX_SAVE_AREA, 2747fda902cbSMichael Mueller &px, 4); 2748d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_FP_CREG_SAVE_AREA, 27499abc2a08SDavid Hildenbrand &vcpu->run->s.regs.fpc, 4); 2750d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_TOD_PROGREG_SAVE_AREA, 2751d0bce605SHeiko Carstens &vcpu->arch.sie_block->todpr, 4); 27524287f247SDavid Hildenbrand cputm = kvm_s390_get_cpu_timer(vcpu); 2753d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CPU_TIMER_SAVE_AREA, 27544287f247SDavid Hildenbrand &cputm, 8); 2755178bd789SThomas Huth clkcomp = vcpu->arch.sie_block->ckc >> 8; 2756d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CLOCK_COMP_SAVE_AREA, 2757d0bce605SHeiko Carstens &clkcomp, 8); 2758d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_AREGS_SAVE_AREA, 2759d0bce605SHeiko Carstens &vcpu->run->s.regs.acrs, 64); 2760d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CREGS_SAVE_AREA, 2761d0bce605SHeiko Carstens &vcpu->arch.sie_block->gcr, 128); 2762d0bce605SHeiko Carstens return rc ? -EFAULT : 0; 2763b0c632dbSHeiko Carstens } 2764b0c632dbSHeiko Carstens 2765e879892cSThomas Huth int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr) 2766e879892cSThomas Huth { 2767e879892cSThomas Huth /* 2768e879892cSThomas Huth * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy 2769e879892cSThomas Huth * copying in vcpu load/put. Lets update our copies before we save 2770e879892cSThomas Huth * it into the save area 2771e879892cSThomas Huth */ 2772d0164ee2SHendrik Brueckner save_fpu_regs(); 27739abc2a08SDavid Hildenbrand vcpu->run->s.regs.fpc = current->thread.fpu.fpc; 2774e879892cSThomas Huth save_access_regs(vcpu->run->s.regs.acrs); 2775e879892cSThomas Huth 2776e879892cSThomas Huth return kvm_s390_store_status_unloaded(vcpu, addr); 2777e879892cSThomas Huth } 2778e879892cSThomas Huth 2779bc17de7cSEric Farman /* 2780bc17de7cSEric Farman * store additional status at address 2781bc17de7cSEric Farman */ 2782bc17de7cSEric Farman int kvm_s390_store_adtl_status_unloaded(struct kvm_vcpu *vcpu, 2783bc17de7cSEric Farman unsigned long gpa) 2784bc17de7cSEric Farman { 2785bc17de7cSEric Farman /* Only bits 0-53 are used for address formation */ 2786bc17de7cSEric Farman if (!(gpa & ~0x3ff)) 2787bc17de7cSEric Farman return 0; 2788bc17de7cSEric Farman 2789bc17de7cSEric Farman return write_guest_abs(vcpu, gpa & ~0x3ff, 2790bc17de7cSEric Farman (void *)&vcpu->run->s.regs.vrs, 512); 2791bc17de7cSEric Farman } 2792bc17de7cSEric Farman 2793bc17de7cSEric Farman int kvm_s390_vcpu_store_adtl_status(struct kvm_vcpu *vcpu, unsigned long addr) 2794bc17de7cSEric Farman { 2795bc17de7cSEric Farman if (!test_kvm_facility(vcpu->kvm, 129)) 2796bc17de7cSEric Farman return 0; 2797bc17de7cSEric Farman 2798bc17de7cSEric Farman /* 2799bc17de7cSEric Farman * The guest VXRS are in the host VXRs due to the lazy 28009977e886SHendrik Brueckner * copying in vcpu load/put. We can simply call save_fpu_regs() 28019977e886SHendrik Brueckner * to save the current register state because we are in the 28029977e886SHendrik Brueckner * middle of a load/put cycle. 28039977e886SHendrik Brueckner * 28049977e886SHendrik Brueckner * Let's update our copies before we save it into the save area. 2805bc17de7cSEric Farman */ 2806d0164ee2SHendrik Brueckner save_fpu_regs(); 2807bc17de7cSEric Farman 2808bc17de7cSEric Farman return kvm_s390_store_adtl_status_unloaded(vcpu, addr); 2809bc17de7cSEric Farman } 2810bc17de7cSEric Farman 28118ad35755SDavid Hildenbrand static void __disable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 28128ad35755SDavid Hildenbrand { 28138ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu); 28148e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_DISABLE_IBS, vcpu); 28158ad35755SDavid Hildenbrand } 28168ad35755SDavid Hildenbrand 28178ad35755SDavid Hildenbrand static void __disable_ibs_on_all_vcpus(struct kvm *kvm) 28188ad35755SDavid Hildenbrand { 28198ad35755SDavid Hildenbrand unsigned int i; 28208ad35755SDavid Hildenbrand struct kvm_vcpu *vcpu; 28218ad35755SDavid Hildenbrand 28228ad35755SDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 28238ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 28248ad35755SDavid Hildenbrand } 28258ad35755SDavid Hildenbrand } 28268ad35755SDavid Hildenbrand 28278ad35755SDavid Hildenbrand static void __enable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 28288ad35755SDavid Hildenbrand { 282909a400e7SDavid Hildenbrand if (!sclp.has_ibs) 283009a400e7SDavid Hildenbrand return; 28318ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu); 28328e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_ENABLE_IBS, vcpu); 28338ad35755SDavid Hildenbrand } 28348ad35755SDavid Hildenbrand 28356852d7b6SDavid Hildenbrand void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu) 28366852d7b6SDavid Hildenbrand { 28378ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 28388ad35755SDavid Hildenbrand 28398ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 28408ad35755SDavid Hildenbrand return; 28418ad35755SDavid Hildenbrand 28426852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 1); 28438ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 2844433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 28458ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 28468ad35755SDavid Hildenbrand 28478ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 28488ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) 28498ad35755SDavid Hildenbrand started_vcpus++; 28508ad35755SDavid Hildenbrand } 28518ad35755SDavid Hildenbrand 28528ad35755SDavid Hildenbrand if (started_vcpus == 0) { 28538ad35755SDavid Hildenbrand /* we're the only active VCPU -> speed it up */ 28548ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(vcpu); 28558ad35755SDavid Hildenbrand } else if (started_vcpus == 1) { 28568ad35755SDavid Hildenbrand /* 28578ad35755SDavid Hildenbrand * As we are starting a second VCPU, we have to disable 28588ad35755SDavid Hildenbrand * the IBS facility on all VCPUs to remove potentially 28598ad35755SDavid Hildenbrand * oustanding ENABLE requests. 28608ad35755SDavid Hildenbrand */ 28618ad35755SDavid Hildenbrand __disable_ibs_on_all_vcpus(vcpu->kvm); 28628ad35755SDavid Hildenbrand } 28638ad35755SDavid Hildenbrand 2864805de8f4SPeter Zijlstra atomic_andnot(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags); 28658ad35755SDavid Hildenbrand /* 28668ad35755SDavid Hildenbrand * Another VCPU might have used IBS while we were offline. 28678ad35755SDavid Hildenbrand * Let's play safe and flush the VCPU at startup. 28688ad35755SDavid Hildenbrand */ 2869d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 2870433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 28718ad35755SDavid Hildenbrand return; 28726852d7b6SDavid Hildenbrand } 28736852d7b6SDavid Hildenbrand 28746852d7b6SDavid Hildenbrand void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu) 28756852d7b6SDavid Hildenbrand { 28768ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 28778ad35755SDavid Hildenbrand struct kvm_vcpu *started_vcpu = NULL; 28788ad35755SDavid Hildenbrand 28798ad35755SDavid Hildenbrand if (is_vcpu_stopped(vcpu)) 28808ad35755SDavid Hildenbrand return; 28818ad35755SDavid Hildenbrand 28826852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 0); 28838ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 2884433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 28858ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 28868ad35755SDavid Hildenbrand 288732f5ff63SDavid Hildenbrand /* SIGP STOP and SIGP STOP AND STORE STATUS has been fully processed */ 28886cddd432SDavid Hildenbrand kvm_s390_clear_stop_irq(vcpu); 288932f5ff63SDavid Hildenbrand 2890805de8f4SPeter Zijlstra atomic_or(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags); 28918ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 28928ad35755SDavid Hildenbrand 28938ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 28948ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) { 28958ad35755SDavid Hildenbrand started_vcpus++; 28968ad35755SDavid Hildenbrand started_vcpu = vcpu->kvm->vcpus[i]; 28978ad35755SDavid Hildenbrand } 28988ad35755SDavid Hildenbrand } 28998ad35755SDavid Hildenbrand 29008ad35755SDavid Hildenbrand if (started_vcpus == 1) { 29018ad35755SDavid Hildenbrand /* 29028ad35755SDavid Hildenbrand * As we only have one VCPU left, we want to enable the 29038ad35755SDavid Hildenbrand * IBS facility for that VCPU to speed it up. 29048ad35755SDavid Hildenbrand */ 29058ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(started_vcpu); 29068ad35755SDavid Hildenbrand } 29078ad35755SDavid Hildenbrand 2908433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 29098ad35755SDavid Hildenbrand return; 29106852d7b6SDavid Hildenbrand } 29116852d7b6SDavid Hildenbrand 2912d6712df9SCornelia Huck static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 2913d6712df9SCornelia Huck struct kvm_enable_cap *cap) 2914d6712df9SCornelia Huck { 2915d6712df9SCornelia Huck int r; 2916d6712df9SCornelia Huck 2917d6712df9SCornelia Huck if (cap->flags) 2918d6712df9SCornelia Huck return -EINVAL; 2919d6712df9SCornelia Huck 2920d6712df9SCornelia Huck switch (cap->cap) { 2921fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 2922fa6b7fe9SCornelia Huck if (!vcpu->kvm->arch.css_support) { 2923fa6b7fe9SCornelia Huck vcpu->kvm->arch.css_support = 1; 2924c92ea7b9SChristian Borntraeger VM_EVENT(vcpu->kvm, 3, "%s", "ENABLE: CSS support"); 2925fa6b7fe9SCornelia Huck trace_kvm_s390_enable_css(vcpu->kvm); 2926fa6b7fe9SCornelia Huck } 2927fa6b7fe9SCornelia Huck r = 0; 2928fa6b7fe9SCornelia Huck break; 2929d6712df9SCornelia Huck default: 2930d6712df9SCornelia Huck r = -EINVAL; 2931d6712df9SCornelia Huck break; 2932d6712df9SCornelia Huck } 2933d6712df9SCornelia Huck return r; 2934d6712df9SCornelia Huck } 2935d6712df9SCornelia Huck 293641408c28SThomas Huth static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu, 293741408c28SThomas Huth struct kvm_s390_mem_op *mop) 293841408c28SThomas Huth { 293941408c28SThomas Huth void __user *uaddr = (void __user *)mop->buf; 294041408c28SThomas Huth void *tmpbuf = NULL; 294141408c28SThomas Huth int r, srcu_idx; 294241408c28SThomas Huth const u64 supported_flags = KVM_S390_MEMOP_F_INJECT_EXCEPTION 294341408c28SThomas Huth | KVM_S390_MEMOP_F_CHECK_ONLY; 294441408c28SThomas Huth 294541408c28SThomas Huth if (mop->flags & ~supported_flags) 294641408c28SThomas Huth return -EINVAL; 294741408c28SThomas Huth 294841408c28SThomas Huth if (mop->size > MEM_OP_MAX_SIZE) 294941408c28SThomas Huth return -E2BIG; 295041408c28SThomas Huth 295141408c28SThomas Huth if (!(mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY)) { 295241408c28SThomas Huth tmpbuf = vmalloc(mop->size); 295341408c28SThomas Huth if (!tmpbuf) 295441408c28SThomas Huth return -ENOMEM; 295541408c28SThomas Huth } 295641408c28SThomas Huth 295741408c28SThomas Huth srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 295841408c28SThomas Huth 295941408c28SThomas Huth switch (mop->op) { 296041408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_READ: 296141408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 296292c96321SDavid Hildenbrand r = check_gva_range(vcpu, mop->gaddr, mop->ar, 296392c96321SDavid Hildenbrand mop->size, GACC_FETCH); 296441408c28SThomas Huth break; 296541408c28SThomas Huth } 296641408c28SThomas Huth r = read_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 296741408c28SThomas Huth if (r == 0) { 296841408c28SThomas Huth if (copy_to_user(uaddr, tmpbuf, mop->size)) 296941408c28SThomas Huth r = -EFAULT; 297041408c28SThomas Huth } 297141408c28SThomas Huth break; 297241408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_WRITE: 297341408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 297492c96321SDavid Hildenbrand r = check_gva_range(vcpu, mop->gaddr, mop->ar, 297592c96321SDavid Hildenbrand mop->size, GACC_STORE); 297641408c28SThomas Huth break; 297741408c28SThomas Huth } 297841408c28SThomas Huth if (copy_from_user(tmpbuf, uaddr, mop->size)) { 297941408c28SThomas Huth r = -EFAULT; 298041408c28SThomas Huth break; 298141408c28SThomas Huth } 298241408c28SThomas Huth r = write_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 298341408c28SThomas Huth break; 298441408c28SThomas Huth default: 298541408c28SThomas Huth r = -EINVAL; 298641408c28SThomas Huth } 298741408c28SThomas Huth 298841408c28SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, srcu_idx); 298941408c28SThomas Huth 299041408c28SThomas Huth if (r > 0 && (mop->flags & KVM_S390_MEMOP_F_INJECT_EXCEPTION) != 0) 299141408c28SThomas Huth kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm); 299241408c28SThomas Huth 299341408c28SThomas Huth vfree(tmpbuf); 299441408c28SThomas Huth return r; 299541408c28SThomas Huth } 299641408c28SThomas Huth 2997b0c632dbSHeiko Carstens long kvm_arch_vcpu_ioctl(struct file *filp, 2998b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 2999b0c632dbSHeiko Carstens { 3000b0c632dbSHeiko Carstens struct kvm_vcpu *vcpu = filp->private_data; 3001b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 3002800c1065SThomas Huth int idx; 3003bc923cc9SAvi Kivity long r; 3004b0c632dbSHeiko Carstens 300593736624SAvi Kivity switch (ioctl) { 300647b43c52SJens Freimann case KVM_S390_IRQ: { 300747b43c52SJens Freimann struct kvm_s390_irq s390irq; 300847b43c52SJens Freimann 300947b43c52SJens Freimann r = -EFAULT; 301047b43c52SJens Freimann if (copy_from_user(&s390irq, argp, sizeof(s390irq))) 301147b43c52SJens Freimann break; 301247b43c52SJens Freimann r = kvm_s390_inject_vcpu(vcpu, &s390irq); 301347b43c52SJens Freimann break; 301447b43c52SJens Freimann } 301593736624SAvi Kivity case KVM_S390_INTERRUPT: { 3016ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 3017383d0b05SJens Freimann struct kvm_s390_irq s390irq; 3018ba5c1e9bSCarsten Otte 301993736624SAvi Kivity r = -EFAULT; 3020ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 302193736624SAvi Kivity break; 3022383d0b05SJens Freimann if (s390int_to_s390irq(&s390int, &s390irq)) 3023383d0b05SJens Freimann return -EINVAL; 3024383d0b05SJens Freimann r = kvm_s390_inject_vcpu(vcpu, &s390irq); 302593736624SAvi Kivity break; 3026ba5c1e9bSCarsten Otte } 3027b0c632dbSHeiko Carstens case KVM_S390_STORE_STATUS: 3028800c1065SThomas Huth idx = srcu_read_lock(&vcpu->kvm->srcu); 3029bc923cc9SAvi Kivity r = kvm_s390_vcpu_store_status(vcpu, arg); 3030800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, idx); 3031bc923cc9SAvi Kivity break; 3032b0c632dbSHeiko Carstens case KVM_S390_SET_INITIAL_PSW: { 3033b0c632dbSHeiko Carstens psw_t psw; 3034b0c632dbSHeiko Carstens 3035bc923cc9SAvi Kivity r = -EFAULT; 3036b0c632dbSHeiko Carstens if (copy_from_user(&psw, argp, sizeof(psw))) 3037bc923cc9SAvi Kivity break; 3038bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw); 3039bc923cc9SAvi Kivity break; 3040b0c632dbSHeiko Carstens } 3041b0c632dbSHeiko Carstens case KVM_S390_INITIAL_RESET: 3042bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_initial_reset(vcpu); 3043bc923cc9SAvi Kivity break; 304414eebd91SCarsten Otte case KVM_SET_ONE_REG: 304514eebd91SCarsten Otte case KVM_GET_ONE_REG: { 304614eebd91SCarsten Otte struct kvm_one_reg reg; 304714eebd91SCarsten Otte r = -EFAULT; 304814eebd91SCarsten Otte if (copy_from_user(®, argp, sizeof(reg))) 304914eebd91SCarsten Otte break; 305014eebd91SCarsten Otte if (ioctl == KVM_SET_ONE_REG) 305114eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, ®); 305214eebd91SCarsten Otte else 305314eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, ®); 305414eebd91SCarsten Otte break; 305514eebd91SCarsten Otte } 305627e0393fSCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 305727e0393fSCarsten Otte case KVM_S390_UCAS_MAP: { 305827e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 305927e0393fSCarsten Otte 306027e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 306127e0393fSCarsten Otte r = -EFAULT; 306227e0393fSCarsten Otte break; 306327e0393fSCarsten Otte } 306427e0393fSCarsten Otte 306527e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 306627e0393fSCarsten Otte r = -EINVAL; 306727e0393fSCarsten Otte break; 306827e0393fSCarsten Otte } 306927e0393fSCarsten Otte 307027e0393fSCarsten Otte r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr, 307127e0393fSCarsten Otte ucasmap.vcpu_addr, ucasmap.length); 307227e0393fSCarsten Otte break; 307327e0393fSCarsten Otte } 307427e0393fSCarsten Otte case KVM_S390_UCAS_UNMAP: { 307527e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 307627e0393fSCarsten Otte 307727e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 307827e0393fSCarsten Otte r = -EFAULT; 307927e0393fSCarsten Otte break; 308027e0393fSCarsten Otte } 308127e0393fSCarsten Otte 308227e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 308327e0393fSCarsten Otte r = -EINVAL; 308427e0393fSCarsten Otte break; 308527e0393fSCarsten Otte } 308627e0393fSCarsten Otte 308727e0393fSCarsten Otte r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr, 308827e0393fSCarsten Otte ucasmap.length); 308927e0393fSCarsten Otte break; 309027e0393fSCarsten Otte } 309127e0393fSCarsten Otte #endif 3092ccc7910fSCarsten Otte case KVM_S390_VCPU_FAULT: { 3093527e30b4SMartin Schwidefsky r = gmap_fault(vcpu->arch.gmap, arg, 0); 3094ccc7910fSCarsten Otte break; 3095ccc7910fSCarsten Otte } 3096d6712df9SCornelia Huck case KVM_ENABLE_CAP: 3097d6712df9SCornelia Huck { 3098d6712df9SCornelia Huck struct kvm_enable_cap cap; 3099d6712df9SCornelia Huck r = -EFAULT; 3100d6712df9SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 3101d6712df9SCornelia Huck break; 3102d6712df9SCornelia Huck r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 3103d6712df9SCornelia Huck break; 3104d6712df9SCornelia Huck } 310541408c28SThomas Huth case KVM_S390_MEM_OP: { 310641408c28SThomas Huth struct kvm_s390_mem_op mem_op; 310741408c28SThomas Huth 310841408c28SThomas Huth if (copy_from_user(&mem_op, argp, sizeof(mem_op)) == 0) 310941408c28SThomas Huth r = kvm_s390_guest_mem_op(vcpu, &mem_op); 311041408c28SThomas Huth else 311141408c28SThomas Huth r = -EFAULT; 311241408c28SThomas Huth break; 311341408c28SThomas Huth } 3114816c7667SJens Freimann case KVM_S390_SET_IRQ_STATE: { 3115816c7667SJens Freimann struct kvm_s390_irq_state irq_state; 3116816c7667SJens Freimann 3117816c7667SJens Freimann r = -EFAULT; 3118816c7667SJens Freimann if (copy_from_user(&irq_state, argp, sizeof(irq_state))) 3119816c7667SJens Freimann break; 3120816c7667SJens Freimann if (irq_state.len > VCPU_IRQS_MAX_BUF || 3121816c7667SJens Freimann irq_state.len == 0 || 3122816c7667SJens Freimann irq_state.len % sizeof(struct kvm_s390_irq) > 0) { 3123816c7667SJens Freimann r = -EINVAL; 3124816c7667SJens Freimann break; 3125816c7667SJens Freimann } 3126816c7667SJens Freimann r = kvm_s390_set_irq_state(vcpu, 3127816c7667SJens Freimann (void __user *) irq_state.buf, 3128816c7667SJens Freimann irq_state.len); 3129816c7667SJens Freimann break; 3130816c7667SJens Freimann } 3131816c7667SJens Freimann case KVM_S390_GET_IRQ_STATE: { 3132816c7667SJens Freimann struct kvm_s390_irq_state irq_state; 3133816c7667SJens Freimann 3134816c7667SJens Freimann r = -EFAULT; 3135816c7667SJens Freimann if (copy_from_user(&irq_state, argp, sizeof(irq_state))) 3136816c7667SJens Freimann break; 3137816c7667SJens Freimann if (irq_state.len == 0) { 3138816c7667SJens Freimann r = -EINVAL; 3139816c7667SJens Freimann break; 3140816c7667SJens Freimann } 3141816c7667SJens Freimann r = kvm_s390_get_irq_state(vcpu, 3142816c7667SJens Freimann (__u8 __user *) irq_state.buf, 3143816c7667SJens Freimann irq_state.len); 3144816c7667SJens Freimann break; 3145816c7667SJens Freimann } 3146b0c632dbSHeiko Carstens default: 31473e6afcf1SCarsten Otte r = -ENOTTY; 3148b0c632dbSHeiko Carstens } 3149bc923cc9SAvi Kivity return r; 3150b0c632dbSHeiko Carstens } 3151b0c632dbSHeiko Carstens 31525b1c1493SCarsten Otte int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) 31535b1c1493SCarsten Otte { 31545b1c1493SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 31555b1c1493SCarsten Otte if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET) 31565b1c1493SCarsten Otte && (kvm_is_ucontrol(vcpu->kvm))) { 31575b1c1493SCarsten Otte vmf->page = virt_to_page(vcpu->arch.sie_block); 31585b1c1493SCarsten Otte get_page(vmf->page); 31595b1c1493SCarsten Otte return 0; 31605b1c1493SCarsten Otte } 31615b1c1493SCarsten Otte #endif 31625b1c1493SCarsten Otte return VM_FAULT_SIGBUS; 31635b1c1493SCarsten Otte } 31645b1c1493SCarsten Otte 31655587027cSAneesh Kumar K.V int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, 31665587027cSAneesh Kumar K.V unsigned long npages) 3167db3fe4ebSTakuya Yoshikawa { 3168db3fe4ebSTakuya Yoshikawa return 0; 3169db3fe4ebSTakuya Yoshikawa } 3170db3fe4ebSTakuya Yoshikawa 3171b0c632dbSHeiko Carstens /* Section: memory related */ 3172f7784b8eSMarcelo Tosatti int kvm_arch_prepare_memory_region(struct kvm *kvm, 3173f7784b8eSMarcelo Tosatti struct kvm_memory_slot *memslot, 317409170a49SPaolo Bonzini const struct kvm_userspace_memory_region *mem, 31757b6195a9STakuya Yoshikawa enum kvm_mr_change change) 3176b0c632dbSHeiko Carstens { 3177dd2887e7SNick Wang /* A few sanity checks. We can have memory slots which have to be 3178dd2887e7SNick Wang located/ended at a segment boundary (1MB). The memory in userland is 3179dd2887e7SNick Wang ok to be fragmented into various different vmas. It is okay to mmap() 3180dd2887e7SNick Wang and munmap() stuff in this slot after doing this call at any time */ 3181b0c632dbSHeiko Carstens 3182598841caSCarsten Otte if (mem->userspace_addr & 0xffffful) 3183b0c632dbSHeiko Carstens return -EINVAL; 3184b0c632dbSHeiko Carstens 3185598841caSCarsten Otte if (mem->memory_size & 0xffffful) 3186b0c632dbSHeiko Carstens return -EINVAL; 3187b0c632dbSHeiko Carstens 3188a3a92c31SDominik Dingel if (mem->guest_phys_addr + mem->memory_size > kvm->arch.mem_limit) 3189a3a92c31SDominik Dingel return -EINVAL; 3190a3a92c31SDominik Dingel 3191f7784b8eSMarcelo Tosatti return 0; 3192f7784b8eSMarcelo Tosatti } 3193f7784b8eSMarcelo Tosatti 3194f7784b8eSMarcelo Tosatti void kvm_arch_commit_memory_region(struct kvm *kvm, 319509170a49SPaolo Bonzini const struct kvm_userspace_memory_region *mem, 31968482644aSTakuya Yoshikawa const struct kvm_memory_slot *old, 3197f36f3f28SPaolo Bonzini const struct kvm_memory_slot *new, 31988482644aSTakuya Yoshikawa enum kvm_mr_change change) 3199f7784b8eSMarcelo Tosatti { 3200f7850c92SCarsten Otte int rc; 3201f7784b8eSMarcelo Tosatti 32022cef4debSChristian Borntraeger /* If the basics of the memslot do not change, we do not want 32032cef4debSChristian Borntraeger * to update the gmap. Every update causes several unnecessary 32042cef4debSChristian Borntraeger * segment translation exceptions. This is usually handled just 32052cef4debSChristian Borntraeger * fine by the normal fault handler + gmap, but it will also 32062cef4debSChristian Borntraeger * cause faults on the prefix page of running guest CPUs. 32072cef4debSChristian Borntraeger */ 32082cef4debSChristian Borntraeger if (old->userspace_addr == mem->userspace_addr && 32092cef4debSChristian Borntraeger old->base_gfn * PAGE_SIZE == mem->guest_phys_addr && 32102cef4debSChristian Borntraeger old->npages * PAGE_SIZE == mem->memory_size) 32112cef4debSChristian Borntraeger return; 3212598841caSCarsten Otte 3213598841caSCarsten Otte rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr, 3214598841caSCarsten Otte mem->guest_phys_addr, mem->memory_size); 3215598841caSCarsten Otte if (rc) 3216ea2cdd27SDavid Hildenbrand pr_warn("failed to commit memory region\n"); 3217598841caSCarsten Otte return; 3218b0c632dbSHeiko Carstens } 3219b0c632dbSHeiko Carstens 322060a37709SAlexander Yarygin static inline unsigned long nonhyp_mask(int i) 322160a37709SAlexander Yarygin { 322260a37709SAlexander Yarygin unsigned int nonhyp_fai = (sclp.hmfai << i * 2) >> 30; 322360a37709SAlexander Yarygin 322460a37709SAlexander Yarygin return 0x0000ffffffffffffUL >> (nonhyp_fai << 4); 322560a37709SAlexander Yarygin } 322660a37709SAlexander Yarygin 32273491caf2SChristian Borntraeger void kvm_arch_vcpu_block_finish(struct kvm_vcpu *vcpu) 32283491caf2SChristian Borntraeger { 32293491caf2SChristian Borntraeger vcpu->valid_wakeup = false; 32303491caf2SChristian Borntraeger } 32313491caf2SChristian Borntraeger 3232b0c632dbSHeiko Carstens static int __init kvm_s390_init(void) 3233b0c632dbSHeiko Carstens { 323460a37709SAlexander Yarygin int i; 323560a37709SAlexander Yarygin 323607197fd0SDavid Hildenbrand if (!sclp.has_sief2) { 323707197fd0SDavid Hildenbrand pr_info("SIE not available\n"); 323807197fd0SDavid Hildenbrand return -ENODEV; 323907197fd0SDavid Hildenbrand } 324007197fd0SDavid Hildenbrand 324160a37709SAlexander Yarygin for (i = 0; i < 16; i++) 324260a37709SAlexander Yarygin kvm_s390_fac_list_mask[i] |= 324360a37709SAlexander Yarygin S390_lowcore.stfle_fac_list[i] & nonhyp_mask(i); 324460a37709SAlexander Yarygin 32459d8d5786SMichael Mueller return kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); 3246b0c632dbSHeiko Carstens } 3247b0c632dbSHeiko Carstens 3248b0c632dbSHeiko Carstens static void __exit kvm_s390_exit(void) 3249b0c632dbSHeiko Carstens { 3250b0c632dbSHeiko Carstens kvm_exit(); 3251b0c632dbSHeiko Carstens } 3252b0c632dbSHeiko Carstens 3253b0c632dbSHeiko Carstens module_init(kvm_s390_init); 3254b0c632dbSHeiko Carstens module_exit(kvm_s390_exit); 3255566af940SCornelia Huck 3256566af940SCornelia Huck /* 3257566af940SCornelia Huck * Enable autoloading of the kvm module. 3258566af940SCornelia Huck * Note that we add the module alias here instead of virt/kvm/kvm_main.c 3259566af940SCornelia Huck * since x86 takes a different approach. 3260566af940SCornelia Huck */ 3261566af940SCornelia Huck #include <linux/miscdevice.h> 3262566af940SCornelia Huck MODULE_ALIAS_MISCDEV(KVM_MINOR); 3263566af940SCornelia Huck MODULE_ALIAS("devname:kvm"); 3264