1d809aa23SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 2b0c632dbSHeiko Carstens /* 3bb64da9aSChristian Borntraeger * hosting IBM Z kernel virtual machines (s390x) 4b0c632dbSHeiko Carstens * 5a37cb07aSChristian Borntraeger * Copyright IBM Corp. 2008, 2018 6b0c632dbSHeiko Carstens * 7b0c632dbSHeiko Carstens * Author(s): Carsten Otte <cotte@de.ibm.com> 8b0c632dbSHeiko Carstens * Christian Borntraeger <borntraeger@de.ibm.com> 9b0c632dbSHeiko Carstens * Heiko Carstens <heiko.carstens@de.ibm.com> 10628eb9b8SChristian Ehrhardt * Christian Ehrhardt <ehrhardt@de.ibm.com> 1115f36ebdSJason J. Herne * Jason J. Herne <jjherne@us.ibm.com> 12b0c632dbSHeiko Carstens */ 13b0c632dbSHeiko Carstens 14b0c632dbSHeiko Carstens #include <linux/compiler.h> 15b0c632dbSHeiko Carstens #include <linux/err.h> 16b0c632dbSHeiko Carstens #include <linux/fs.h> 17ca872302SChristian Borntraeger #include <linux/hrtimer.h> 18b0c632dbSHeiko Carstens #include <linux/init.h> 19b0c632dbSHeiko Carstens #include <linux/kvm.h> 20b0c632dbSHeiko Carstens #include <linux/kvm_host.h> 21b2d73b2aSMartin Schwidefsky #include <linux/mman.h> 22b0c632dbSHeiko Carstens #include <linux/module.h> 23d3217967SPaul Gortmaker #include <linux/moduleparam.h> 24a374e892STony Krowiak #include <linux/random.h> 25b0c632dbSHeiko Carstens #include <linux/slab.h> 26ba5c1e9bSCarsten Otte #include <linux/timer.h> 2741408c28SThomas Huth #include <linux/vmalloc.h> 2815c9705fSDavid Hildenbrand #include <linux/bitmap.h> 29174cd4b1SIngo Molnar #include <linux/sched/signal.h> 30190df4a2SClaudio Imbrenda #include <linux/string.h> 31174cd4b1SIngo Molnar 32cbb870c8SHeiko Carstens #include <asm/asm-offsets.h> 33b0c632dbSHeiko Carstens #include <asm/lowcore.h> 34fd5ada04SMartin Schwidefsky #include <asm/stp.h> 35b0c632dbSHeiko Carstens #include <asm/pgtable.h> 361e133ab2SMartin Schwidefsky #include <asm/gmap.h> 37f5daba1dSHeiko Carstens #include <asm/nmi.h> 38a0616cdeSDavid Howells #include <asm/switch_to.h> 396d3da241SJens Freimann #include <asm/isc.h> 401526bf9cSChristian Borntraeger #include <asm/sclp.h> 410a763c78SDavid Hildenbrand #include <asm/cpacf.h> 42221bb8a4SLinus Torvalds #include <asm/timex.h> 43e585b24aSTony Krowiak #include <asm/ap.h> 448f2abe6aSChristian Borntraeger #include "kvm-s390.h" 45b0c632dbSHeiko Carstens #include "gaccess.h" 46b0c632dbSHeiko Carstens 47ea2cdd27SDavid Hildenbrand #define KMSG_COMPONENT "kvm-s390" 48ea2cdd27SDavid Hildenbrand #undef pr_fmt 49ea2cdd27SDavid Hildenbrand #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 50ea2cdd27SDavid Hildenbrand 515786fffaSCornelia Huck #define CREATE_TRACE_POINTS 525786fffaSCornelia Huck #include "trace.h" 53ade38c31SCornelia Huck #include "trace-s390.h" 545786fffaSCornelia Huck 5541408c28SThomas Huth #define MEM_OP_MAX_SIZE 65536 /* Maximum transfer size for KVM_S390_MEM_OP */ 56816c7667SJens Freimann #define LOCAL_IRQS 32 57816c7667SJens Freimann #define VCPU_IRQS_MAX_BUF (sizeof(struct kvm_s390_irq) * \ 58816c7667SJens Freimann (KVM_MAX_VCPUS + LOCAL_IRQS)) 5941408c28SThomas Huth 60b0c632dbSHeiko Carstens #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU 61ccc40c53SChristian Borntraeger #define VM_STAT(x) offsetof(struct kvm, stat.x), KVM_STAT_VM 62b0c632dbSHeiko Carstens 63b0c632dbSHeiko Carstens struct kvm_stats_debugfs_item debugfs_entries[] = { 64b0c632dbSHeiko Carstens { "userspace_handled", VCPU_STAT(exit_userspace) }, 650eaeafa1SChristian Borntraeger { "exit_null", VCPU_STAT(exit_null) }, 668f2abe6aSChristian Borntraeger { "exit_validity", VCPU_STAT(exit_validity) }, 678f2abe6aSChristian Borntraeger { "exit_stop_request", VCPU_STAT(exit_stop_request) }, 688f2abe6aSChristian Borntraeger { "exit_external_request", VCPU_STAT(exit_external_request) }, 69a5e0aceaSChristian Borntraeger { "exit_io_request", VCPU_STAT(exit_io_request) }, 708f2abe6aSChristian Borntraeger { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) }, 71ba5c1e9bSCarsten Otte { "exit_instruction", VCPU_STAT(exit_instruction) }, 729ec6de19SAlexander Yarygin { "exit_pei", VCPU_STAT(exit_pei) }, 73ba5c1e9bSCarsten Otte { "exit_program_interruption", VCPU_STAT(exit_program_interruption) }, 74ba5c1e9bSCarsten Otte { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) }, 75a011eeb2SJanosch Frank { "exit_operation_exception", VCPU_STAT(exit_operation_exception) }, 76f7819512SPaolo Bonzini { "halt_successful_poll", VCPU_STAT(halt_successful_poll) }, 7762bea5bfSPaolo Bonzini { "halt_attempted_poll", VCPU_STAT(halt_attempted_poll) }, 783491caf2SChristian Borntraeger { "halt_poll_invalid", VCPU_STAT(halt_poll_invalid) }, 79ce2e4f0bSDavid Hildenbrand { "halt_wakeup", VCPU_STAT(halt_wakeup) }, 80f5e10b09SChristian Borntraeger { "instruction_lctlg", VCPU_STAT(instruction_lctlg) }, 81ba5c1e9bSCarsten Otte { "instruction_lctl", VCPU_STAT(instruction_lctl) }, 82aba07508SDavid Hildenbrand { "instruction_stctl", VCPU_STAT(instruction_stctl) }, 83aba07508SDavid Hildenbrand { "instruction_stctg", VCPU_STAT(instruction_stctg) }, 84ccc40c53SChristian Borntraeger { "deliver_ckc", VCPU_STAT(deliver_ckc) }, 85ccc40c53SChristian Borntraeger { "deliver_cputm", VCPU_STAT(deliver_cputm) }, 86ba5c1e9bSCarsten Otte { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) }, 877697e71fSChristian Ehrhardt { "deliver_external_call", VCPU_STAT(deliver_external_call) }, 88ba5c1e9bSCarsten Otte { "deliver_service_signal", VCPU_STAT(deliver_service_signal) }, 89ccc40c53SChristian Borntraeger { "deliver_virtio", VCPU_STAT(deliver_virtio) }, 90ba5c1e9bSCarsten Otte { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) }, 91ba5c1e9bSCarsten Otte { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) }, 92ba5c1e9bSCarsten Otte { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) }, 93ccc40c53SChristian Borntraeger { "deliver_program", VCPU_STAT(deliver_program) }, 94ccc40c53SChristian Borntraeger { "deliver_io", VCPU_STAT(deliver_io) }, 9532de0749SQingFeng Hao { "deliver_machine_check", VCPU_STAT(deliver_machine_check) }, 96ba5c1e9bSCarsten Otte { "exit_wait_state", VCPU_STAT(exit_wait_state) }, 97ccc40c53SChristian Borntraeger { "inject_ckc", VCPU_STAT(inject_ckc) }, 98ccc40c53SChristian Borntraeger { "inject_cputm", VCPU_STAT(inject_cputm) }, 99ccc40c53SChristian Borntraeger { "inject_external_call", VCPU_STAT(inject_external_call) }, 100ccc40c53SChristian Borntraeger { "inject_float_mchk", VM_STAT(inject_float_mchk) }, 101ccc40c53SChristian Borntraeger { "inject_emergency_signal", VCPU_STAT(inject_emergency_signal) }, 102ccc40c53SChristian Borntraeger { "inject_io", VM_STAT(inject_io) }, 103ccc40c53SChristian Borntraeger { "inject_mchk", VCPU_STAT(inject_mchk) }, 104ccc40c53SChristian Borntraeger { "inject_pfault_done", VM_STAT(inject_pfault_done) }, 105ccc40c53SChristian Borntraeger { "inject_program", VCPU_STAT(inject_program) }, 106ccc40c53SChristian Borntraeger { "inject_restart", VCPU_STAT(inject_restart) }, 107ccc40c53SChristian Borntraeger { "inject_service_signal", VM_STAT(inject_service_signal) }, 108ccc40c53SChristian Borntraeger { "inject_set_prefix", VCPU_STAT(inject_set_prefix) }, 109ccc40c53SChristian Borntraeger { "inject_stop_signal", VCPU_STAT(inject_stop_signal) }, 110ccc40c53SChristian Borntraeger { "inject_pfault_init", VCPU_STAT(inject_pfault_init) }, 111ccc40c53SChristian Borntraeger { "inject_virtio", VM_STAT(inject_virtio) }, 112a37cb07aSChristian Borntraeger { "instruction_epsw", VCPU_STAT(instruction_epsw) }, 113a37cb07aSChristian Borntraeger { "instruction_gs", VCPU_STAT(instruction_gs) }, 114a37cb07aSChristian Borntraeger { "instruction_io_other", VCPU_STAT(instruction_io_other) }, 115a37cb07aSChristian Borntraeger { "instruction_lpsw", VCPU_STAT(instruction_lpsw) }, 116a37cb07aSChristian Borntraeger { "instruction_lpswe", VCPU_STAT(instruction_lpswe) }, 11769d0d3a3SChristian Borntraeger { "instruction_pfmf", VCPU_STAT(instruction_pfmf) }, 118a37cb07aSChristian Borntraeger { "instruction_ptff", VCPU_STAT(instruction_ptff) }, 119453423dcSChristian Borntraeger { "instruction_stidp", VCPU_STAT(instruction_stidp) }, 120a37cb07aSChristian Borntraeger { "instruction_sck", VCPU_STAT(instruction_sck) }, 121a37cb07aSChristian Borntraeger { "instruction_sckpf", VCPU_STAT(instruction_sckpf) }, 122453423dcSChristian Borntraeger { "instruction_spx", VCPU_STAT(instruction_spx) }, 123453423dcSChristian Borntraeger { "instruction_stpx", VCPU_STAT(instruction_stpx) }, 124453423dcSChristian Borntraeger { "instruction_stap", VCPU_STAT(instruction_stap) }, 125a37cb07aSChristian Borntraeger { "instruction_iske", VCPU_STAT(instruction_iske) }, 126a37cb07aSChristian Borntraeger { "instruction_ri", VCPU_STAT(instruction_ri) }, 127a37cb07aSChristian Borntraeger { "instruction_rrbe", VCPU_STAT(instruction_rrbe) }, 128a37cb07aSChristian Borntraeger { "instruction_sske", VCPU_STAT(instruction_sske) }, 1298a242234SHeiko Carstens { "instruction_ipte_interlock", VCPU_STAT(instruction_ipte_interlock) }, 130b31288faSKonstantin Weitz { "instruction_essa", VCPU_STAT(instruction_essa) }, 131453423dcSChristian Borntraeger { "instruction_stsi", VCPU_STAT(instruction_stsi) }, 132453423dcSChristian Borntraeger { "instruction_stfl", VCPU_STAT(instruction_stfl) }, 133a37cb07aSChristian Borntraeger { "instruction_tb", VCPU_STAT(instruction_tb) }, 134a37cb07aSChristian Borntraeger { "instruction_tpi", VCPU_STAT(instruction_tpi) }, 135bb25b9baSChristian Borntraeger { "instruction_tprot", VCPU_STAT(instruction_tprot) }, 136a37cb07aSChristian Borntraeger { "instruction_tsch", VCPU_STAT(instruction_tsch) }, 13795ca2cb5SJanosch Frank { "instruction_sthyi", VCPU_STAT(instruction_sthyi) }, 138a3508fbeSDavid Hildenbrand { "instruction_sie", VCPU_STAT(instruction_sie) }, 1395288fbf0SChristian Borntraeger { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) }, 140bd59d3a4SCornelia Huck { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) }, 1417697e71fSChristian Ehrhardt { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) }, 1425288fbf0SChristian Borntraeger { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) }, 14342cb0c9fSDavid Hildenbrand { "instruction_sigp_cond_emergency", VCPU_STAT(instruction_sigp_cond_emergency) }, 14442cb0c9fSDavid Hildenbrand { "instruction_sigp_start", VCPU_STAT(instruction_sigp_start) }, 1455288fbf0SChristian Borntraeger { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) }, 14642cb0c9fSDavid Hildenbrand { "instruction_sigp_stop_store_status", VCPU_STAT(instruction_sigp_stop_store_status) }, 14742cb0c9fSDavid Hildenbrand { "instruction_sigp_store_status", VCPU_STAT(instruction_sigp_store_status) }, 148cd7b4b61SEric Farman { "instruction_sigp_store_adtl_status", VCPU_STAT(instruction_sigp_store_adtl_status) }, 1495288fbf0SChristian Borntraeger { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) }, 1505288fbf0SChristian Borntraeger { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) }, 1515288fbf0SChristian Borntraeger { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) }, 15242cb0c9fSDavid Hildenbrand { "instruction_sigp_cpu_reset", VCPU_STAT(instruction_sigp_cpu_reset) }, 15342cb0c9fSDavid Hildenbrand { "instruction_sigp_init_cpu_reset", VCPU_STAT(instruction_sigp_init_cpu_reset) }, 15442cb0c9fSDavid Hildenbrand { "instruction_sigp_unknown", VCPU_STAT(instruction_sigp_unknown) }, 155866c138cSChristian Borntraeger { "instruction_diag_10", VCPU_STAT(diagnose_10) }, 156866c138cSChristian Borntraeger { "instruction_diag_44", VCPU_STAT(diagnose_44) }, 157866c138cSChristian Borntraeger { "instruction_diag_9c", VCPU_STAT(diagnose_9c) }, 158866c138cSChristian Borntraeger { "instruction_diag_258", VCPU_STAT(diagnose_258) }, 159866c138cSChristian Borntraeger { "instruction_diag_308", VCPU_STAT(diagnose_308) }, 160866c138cSChristian Borntraeger { "instruction_diag_500", VCPU_STAT(diagnose_500) }, 161a37cb07aSChristian Borntraeger { "instruction_diag_other", VCPU_STAT(diagnose_other) }, 162b0c632dbSHeiko Carstens { NULL } 163b0c632dbSHeiko Carstens }; 164b0c632dbSHeiko Carstens 1658fa1696eSCollin L. Walling struct kvm_s390_tod_clock_ext { 1668fa1696eSCollin L. Walling __u8 epoch_idx; 1678fa1696eSCollin L. Walling __u64 tod; 1688fa1696eSCollin L. Walling __u8 reserved[7]; 1698fa1696eSCollin L. Walling } __packed; 1708fa1696eSCollin L. Walling 171a411edf1SDavid Hildenbrand /* allow nested virtualization in KVM (if enabled by user space) */ 172a411edf1SDavid Hildenbrand static int nested; 173a411edf1SDavid Hildenbrand module_param(nested, int, S_IRUGO); 174a411edf1SDavid Hildenbrand MODULE_PARM_DESC(nested, "Nested virtualization support"); 175a411edf1SDavid Hildenbrand 176a4499382SJanosch Frank /* allow 1m huge page guest backing, if !nested */ 177a4499382SJanosch Frank static int hpage; 178a4499382SJanosch Frank module_param(hpage, int, 0444); 179a4499382SJanosch Frank MODULE_PARM_DESC(hpage, "1m huge page backing support"); 180b0c632dbSHeiko Carstens 181c3b9e3e1SChristian Borntraeger /* 182c3b9e3e1SChristian Borntraeger * For now we handle at most 16 double words as this is what the s390 base 183c3b9e3e1SChristian Borntraeger * kernel handles and stores in the prefix page. If we ever need to go beyond 184c3b9e3e1SChristian Borntraeger * this, this requires changes to code, but the external uapi can stay. 185c3b9e3e1SChristian Borntraeger */ 186c3b9e3e1SChristian Borntraeger #define SIZE_INTERNAL 16 187c3b9e3e1SChristian Borntraeger 188c3b9e3e1SChristian Borntraeger /* 189c3b9e3e1SChristian Borntraeger * Base feature mask that defines default mask for facilities. Consists of the 190c3b9e3e1SChristian Borntraeger * defines in FACILITIES_KVM and the non-hypervisor managed bits. 191c3b9e3e1SChristian Borntraeger */ 192c3b9e3e1SChristian Borntraeger static unsigned long kvm_s390_fac_base[SIZE_INTERNAL] = { FACILITIES_KVM }; 193c3b9e3e1SChristian Borntraeger /* 194c3b9e3e1SChristian Borntraeger * Extended feature mask. Consists of the defines in FACILITIES_KVM_CPUMODEL 195c3b9e3e1SChristian Borntraeger * and defines the facilities that can be enabled via a cpu model. 196c3b9e3e1SChristian Borntraeger */ 197c3b9e3e1SChristian Borntraeger static unsigned long kvm_s390_fac_ext[SIZE_INTERNAL] = { FACILITIES_KVM_CPUMODEL }; 198c3b9e3e1SChristian Borntraeger 199c3b9e3e1SChristian Borntraeger static unsigned long kvm_s390_fac_size(void) 20078c4b59fSMichael Mueller { 201c3b9e3e1SChristian Borntraeger BUILD_BUG_ON(SIZE_INTERNAL > S390_ARCH_FAC_MASK_SIZE_U64); 202c3b9e3e1SChristian Borntraeger BUILD_BUG_ON(SIZE_INTERNAL > S390_ARCH_FAC_LIST_SIZE_U64); 203c3b9e3e1SChristian Borntraeger BUILD_BUG_ON(SIZE_INTERNAL * sizeof(unsigned long) > 204c3b9e3e1SChristian Borntraeger sizeof(S390_lowcore.stfle_fac_list)); 205c3b9e3e1SChristian Borntraeger 206c3b9e3e1SChristian Borntraeger return SIZE_INTERNAL; 20778c4b59fSMichael Mueller } 20878c4b59fSMichael Mueller 20915c9705fSDavid Hildenbrand /* available cpu features supported by kvm */ 21015c9705fSDavid Hildenbrand static DECLARE_BITMAP(kvm_s390_available_cpu_feat, KVM_S390_VM_CPU_FEAT_NR_BITS); 2110a763c78SDavid Hildenbrand /* available subfunctions indicated via query / "test bit" */ 2120a763c78SDavid Hildenbrand static struct kvm_s390_vm_cpu_subfunc kvm_s390_available_subfunc; 21315c9705fSDavid Hildenbrand 2149d8d5786SMichael Mueller static struct gmap_notifier gmap_notifier; 215a3508fbeSDavid Hildenbrand static struct gmap_notifier vsie_gmap_notifier; 21678f26131SChristian Borntraeger debug_info_t *kvm_s390_dbf; 2179d8d5786SMichael Mueller 218b0c632dbSHeiko Carstens /* Section: not file related */ 21913a34e06SRadim Krčmář int kvm_arch_hardware_enable(void) 220b0c632dbSHeiko Carstens { 221b0c632dbSHeiko Carstens /* every s390 is virtualization enabled ;-) */ 22210474ae8SAlexander Graf return 0; 223b0c632dbSHeiko Carstens } 224b0c632dbSHeiko Carstens 225414d3b07SMartin Schwidefsky static void kvm_gmap_notifier(struct gmap *gmap, unsigned long start, 226414d3b07SMartin Schwidefsky unsigned long end); 2272c70fe44SChristian Borntraeger 2281575767eSDavid Hildenbrand static void kvm_clock_sync_scb(struct kvm_s390_sie_block *scb, u64 delta) 2291575767eSDavid Hildenbrand { 2301575767eSDavid Hildenbrand u8 delta_idx = 0; 2311575767eSDavid Hildenbrand 2321575767eSDavid Hildenbrand /* 2331575767eSDavid Hildenbrand * The TOD jumps by delta, we have to compensate this by adding 2341575767eSDavid Hildenbrand * -delta to the epoch. 2351575767eSDavid Hildenbrand */ 2361575767eSDavid Hildenbrand delta = -delta; 2371575767eSDavid Hildenbrand 2381575767eSDavid Hildenbrand /* sign-extension - we're adding to signed values below */ 2391575767eSDavid Hildenbrand if ((s64)delta < 0) 2401575767eSDavid Hildenbrand delta_idx = -1; 2411575767eSDavid Hildenbrand 2421575767eSDavid Hildenbrand scb->epoch += delta; 2431575767eSDavid Hildenbrand if (scb->ecd & ECD_MEF) { 2441575767eSDavid Hildenbrand scb->epdx += delta_idx; 2451575767eSDavid Hildenbrand if (scb->epoch < delta) 2461575767eSDavid Hildenbrand scb->epdx += 1; 2471575767eSDavid Hildenbrand } 2481575767eSDavid Hildenbrand } 2491575767eSDavid Hildenbrand 250fdf03650SFan Zhang /* 251fdf03650SFan Zhang * This callback is executed during stop_machine(). All CPUs are therefore 252fdf03650SFan Zhang * temporarily stopped. In order not to change guest behavior, we have to 253fdf03650SFan Zhang * disable preemption whenever we touch the epoch of kvm and the VCPUs, 254fdf03650SFan Zhang * so a CPU won't be stopped while calculating with the epoch. 255fdf03650SFan Zhang */ 256fdf03650SFan Zhang static int kvm_clock_sync(struct notifier_block *notifier, unsigned long val, 257fdf03650SFan Zhang void *v) 258fdf03650SFan Zhang { 259fdf03650SFan Zhang struct kvm *kvm; 260fdf03650SFan Zhang struct kvm_vcpu *vcpu; 261fdf03650SFan Zhang int i; 262fdf03650SFan Zhang unsigned long long *delta = v; 263fdf03650SFan Zhang 264fdf03650SFan Zhang list_for_each_entry(kvm, &vm_list, vm_list) { 265fdf03650SFan Zhang kvm_for_each_vcpu(i, vcpu, kvm) { 2661575767eSDavid Hildenbrand kvm_clock_sync_scb(vcpu->arch.sie_block, *delta); 2671575767eSDavid Hildenbrand if (i == 0) { 2681575767eSDavid Hildenbrand kvm->arch.epoch = vcpu->arch.sie_block->epoch; 2691575767eSDavid Hildenbrand kvm->arch.epdx = vcpu->arch.sie_block->epdx; 2701575767eSDavid Hildenbrand } 271db0758b2SDavid Hildenbrand if (vcpu->arch.cputm_enabled) 272db0758b2SDavid Hildenbrand vcpu->arch.cputm_start += *delta; 27391473b48SDavid Hildenbrand if (vcpu->arch.vsie_block) 2741575767eSDavid Hildenbrand kvm_clock_sync_scb(vcpu->arch.vsie_block, 2751575767eSDavid Hildenbrand *delta); 276fdf03650SFan Zhang } 277fdf03650SFan Zhang } 278fdf03650SFan Zhang return NOTIFY_OK; 279fdf03650SFan Zhang } 280fdf03650SFan Zhang 281fdf03650SFan Zhang static struct notifier_block kvm_clock_notifier = { 282fdf03650SFan Zhang .notifier_call = kvm_clock_sync, 283fdf03650SFan Zhang }; 284fdf03650SFan Zhang 285b0c632dbSHeiko Carstens int kvm_arch_hardware_setup(void) 286b0c632dbSHeiko Carstens { 2872c70fe44SChristian Borntraeger gmap_notifier.notifier_call = kvm_gmap_notifier; 288b2d73b2aSMartin Schwidefsky gmap_register_pte_notifier(&gmap_notifier); 289a3508fbeSDavid Hildenbrand vsie_gmap_notifier.notifier_call = kvm_s390_vsie_gmap_notifier; 290a3508fbeSDavid Hildenbrand gmap_register_pte_notifier(&vsie_gmap_notifier); 291fdf03650SFan Zhang atomic_notifier_chain_register(&s390_epoch_delta_notifier, 292fdf03650SFan Zhang &kvm_clock_notifier); 293b0c632dbSHeiko Carstens return 0; 294b0c632dbSHeiko Carstens } 295b0c632dbSHeiko Carstens 296b0c632dbSHeiko Carstens void kvm_arch_hardware_unsetup(void) 297b0c632dbSHeiko Carstens { 298b2d73b2aSMartin Schwidefsky gmap_unregister_pte_notifier(&gmap_notifier); 299a3508fbeSDavid Hildenbrand gmap_unregister_pte_notifier(&vsie_gmap_notifier); 300fdf03650SFan Zhang atomic_notifier_chain_unregister(&s390_epoch_delta_notifier, 301fdf03650SFan Zhang &kvm_clock_notifier); 302b0c632dbSHeiko Carstens } 303b0c632dbSHeiko Carstens 30422be5a13SDavid Hildenbrand static void allow_cpu_feat(unsigned long nr) 30522be5a13SDavid Hildenbrand { 30622be5a13SDavid Hildenbrand set_bit_inv(nr, kvm_s390_available_cpu_feat); 30722be5a13SDavid Hildenbrand } 30822be5a13SDavid Hildenbrand 3090a763c78SDavid Hildenbrand static inline int plo_test_bit(unsigned char nr) 3100a763c78SDavid Hildenbrand { 3110a763c78SDavid Hildenbrand register unsigned long r0 asm("0") = (unsigned long) nr | 0x100; 312d051ae53SHeiko Carstens int cc; 3130a763c78SDavid Hildenbrand 3140a763c78SDavid Hildenbrand asm volatile( 3150a763c78SDavid Hildenbrand /* Parameter registers are ignored for "test bit" */ 3160a763c78SDavid Hildenbrand " plo 0,0,0,0(0)\n" 3170a763c78SDavid Hildenbrand " ipm %0\n" 3180a763c78SDavid Hildenbrand " srl %0,28\n" 3190a763c78SDavid Hildenbrand : "=d" (cc) 3200a763c78SDavid Hildenbrand : "d" (r0) 3210a763c78SDavid Hildenbrand : "cc"); 3220a763c78SDavid Hildenbrand return cc == 0; 3230a763c78SDavid Hildenbrand } 3240a763c78SDavid Hildenbrand 32522be5a13SDavid Hildenbrand static void kvm_s390_cpu_feat_init(void) 32622be5a13SDavid Hildenbrand { 3270a763c78SDavid Hildenbrand int i; 3280a763c78SDavid Hildenbrand 3290a763c78SDavid Hildenbrand for (i = 0; i < 256; ++i) { 3300a763c78SDavid Hildenbrand if (plo_test_bit(i)) 3310a763c78SDavid Hildenbrand kvm_s390_available_subfunc.plo[i >> 3] |= 0x80 >> (i & 7); 3320a763c78SDavid Hildenbrand } 3330a763c78SDavid Hildenbrand 3340a763c78SDavid Hildenbrand if (test_facility(28)) /* TOD-clock steering */ 335221bb8a4SLinus Torvalds ptff(kvm_s390_available_subfunc.ptff, 336221bb8a4SLinus Torvalds sizeof(kvm_s390_available_subfunc.ptff), 337221bb8a4SLinus Torvalds PTFF_QAF); 3380a763c78SDavid Hildenbrand 3390a763c78SDavid Hildenbrand if (test_facility(17)) { /* MSA */ 34069c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMAC, (cpacf_mask_t *) 34169c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmac); 34269c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMC, (cpacf_mask_t *) 34369c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmc); 34469c0e360SMartin Schwidefsky __cpacf_query(CPACF_KM, (cpacf_mask_t *) 34569c0e360SMartin Schwidefsky kvm_s390_available_subfunc.km); 34669c0e360SMartin Schwidefsky __cpacf_query(CPACF_KIMD, (cpacf_mask_t *) 34769c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kimd); 34869c0e360SMartin Schwidefsky __cpacf_query(CPACF_KLMD, (cpacf_mask_t *) 34969c0e360SMartin Schwidefsky kvm_s390_available_subfunc.klmd); 3500a763c78SDavid Hildenbrand } 3510a763c78SDavid Hildenbrand if (test_facility(76)) /* MSA3 */ 35269c0e360SMartin Schwidefsky __cpacf_query(CPACF_PCKMO, (cpacf_mask_t *) 35369c0e360SMartin Schwidefsky kvm_s390_available_subfunc.pckmo); 3540a763c78SDavid Hildenbrand if (test_facility(77)) { /* MSA4 */ 35569c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMCTR, (cpacf_mask_t *) 35669c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmctr); 35769c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMF, (cpacf_mask_t *) 35869c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmf); 35969c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMO, (cpacf_mask_t *) 36069c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmo); 36169c0e360SMartin Schwidefsky __cpacf_query(CPACF_PCC, (cpacf_mask_t *) 36269c0e360SMartin Schwidefsky kvm_s390_available_subfunc.pcc); 3630a763c78SDavid Hildenbrand } 3640a763c78SDavid Hildenbrand if (test_facility(57)) /* MSA5 */ 365985a9d20SHarald Freudenberger __cpacf_query(CPACF_PRNO, (cpacf_mask_t *) 36669c0e360SMartin Schwidefsky kvm_s390_available_subfunc.ppno); 3670a763c78SDavid Hildenbrand 368e000b8e0SJason J. Herne if (test_facility(146)) /* MSA8 */ 369e000b8e0SJason J. Herne __cpacf_query(CPACF_KMA, (cpacf_mask_t *) 370e000b8e0SJason J. Herne kvm_s390_available_subfunc.kma); 371e000b8e0SJason J. Herne 37222be5a13SDavid Hildenbrand if (MACHINE_HAS_ESOP) 37322be5a13SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_ESOP); 374a3508fbeSDavid Hildenbrand /* 375a3508fbeSDavid Hildenbrand * We need SIE support, ESOP (PROT_READ protection for gmap_shadow), 376a3508fbeSDavid Hildenbrand * 64bit SCAO (SCA passthrough) and IDTE (for gmap_shadow unshadowing). 377a3508fbeSDavid Hildenbrand */ 378a3508fbeSDavid Hildenbrand if (!sclp.has_sief2 || !MACHINE_HAS_ESOP || !sclp.has_64bscao || 379a411edf1SDavid Hildenbrand !test_facility(3) || !nested) 380a3508fbeSDavid Hildenbrand return; 381a3508fbeSDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_SIEF2); 38219c439b5SDavid Hildenbrand if (sclp.has_64bscao) 38319c439b5SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_64BSCAO); 3840615a326SDavid Hildenbrand if (sclp.has_siif) 3850615a326SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_SIIF); 38677d18f6dSDavid Hildenbrand if (sclp.has_gpere) 38777d18f6dSDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_GPERE); 388a1b7b9b2SDavid Hildenbrand if (sclp.has_gsls) 389a1b7b9b2SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_GSLS); 3905630a8e8SDavid Hildenbrand if (sclp.has_ib) 3915630a8e8SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_IB); 39213ee3f67SDavid Hildenbrand if (sclp.has_cei) 39313ee3f67SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_CEI); 3947fd7f39dSDavid Hildenbrand if (sclp.has_ibs) 3957fd7f39dSDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_IBS); 396730cd632SFarhan Ali if (sclp.has_kss) 397730cd632SFarhan Ali allow_cpu_feat(KVM_S390_VM_CPU_FEAT_KSS); 3985d3876a8SDavid Hildenbrand /* 3995d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_SKEY: Wrong shadow of PTE.I bits will make 4005d3876a8SDavid Hildenbrand * all skey handling functions read/set the skey from the PGSTE 4015d3876a8SDavid Hildenbrand * instead of the real storage key. 4025d3876a8SDavid Hildenbrand * 4035d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_CMMA: Wrong shadow of PTE.I bits will make 4045d3876a8SDavid Hildenbrand * pages being detected as preserved although they are resident. 4055d3876a8SDavid Hildenbrand * 4065d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_PFMFI: Wrong shadow of PTE.I bits will 4075d3876a8SDavid Hildenbrand * have the same effect as for KVM_S390_VM_CPU_FEAT_SKEY. 4085d3876a8SDavid Hildenbrand * 4095d3876a8SDavid Hildenbrand * For KVM_S390_VM_CPU_FEAT_SKEY, KVM_S390_VM_CPU_FEAT_CMMA and 4105d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_PFMFI, all PTE.I and PGSTE bits have to be 4115d3876a8SDavid Hildenbrand * correctly shadowed. We can do that for the PGSTE but not for PTE.I. 4125d3876a8SDavid Hildenbrand * 4135d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_SIGPIF: Wrong SCB addresses in the SCA. We 4145d3876a8SDavid Hildenbrand * cannot easily shadow the SCA because of the ipte lock. 4155d3876a8SDavid Hildenbrand */ 41622be5a13SDavid Hildenbrand } 41722be5a13SDavid Hildenbrand 418b0c632dbSHeiko Carstens int kvm_arch_init(void *opaque) 419b0c632dbSHeiko Carstens { 420*308c3e66SMichael Mueller int rc; 421*308c3e66SMichael Mueller 42278f26131SChristian Borntraeger kvm_s390_dbf = debug_register("kvm-trace", 32, 1, 7 * sizeof(long)); 42378f26131SChristian Borntraeger if (!kvm_s390_dbf) 42478f26131SChristian Borntraeger return -ENOMEM; 42578f26131SChristian Borntraeger 42678f26131SChristian Borntraeger if (debug_register_view(kvm_s390_dbf, &debug_sprintf_view)) { 427*308c3e66SMichael Mueller rc = -ENOMEM; 428*308c3e66SMichael Mueller goto out_debug_unreg; 42978f26131SChristian Borntraeger } 43078f26131SChristian Borntraeger 43122be5a13SDavid Hildenbrand kvm_s390_cpu_feat_init(); 43222be5a13SDavid Hildenbrand 43384877d93SCornelia Huck /* Register floating interrupt controller interface. */ 434*308c3e66SMichael Mueller rc = kvm_register_device_ops(&kvm_flic_ops, KVM_DEV_TYPE_FLIC); 435*308c3e66SMichael Mueller if (rc) { 436*308c3e66SMichael Mueller pr_err("Failed to register FLIC rc=%d\n", rc); 437*308c3e66SMichael Mueller goto out_debug_unreg; 438*308c3e66SMichael Mueller } 439*308c3e66SMichael Mueller return 0; 440*308c3e66SMichael Mueller 441*308c3e66SMichael Mueller out_debug_unreg: 442*308c3e66SMichael Mueller debug_unregister(kvm_s390_dbf); 443*308c3e66SMichael Mueller return rc; 444b0c632dbSHeiko Carstens } 445b0c632dbSHeiko Carstens 44678f26131SChristian Borntraeger void kvm_arch_exit(void) 44778f26131SChristian Borntraeger { 44878f26131SChristian Borntraeger debug_unregister(kvm_s390_dbf); 44978f26131SChristian Borntraeger } 45078f26131SChristian Borntraeger 451b0c632dbSHeiko Carstens /* Section: device related */ 452b0c632dbSHeiko Carstens long kvm_arch_dev_ioctl(struct file *filp, 453b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 454b0c632dbSHeiko Carstens { 455b0c632dbSHeiko Carstens if (ioctl == KVM_S390_ENABLE_SIE) 456b0c632dbSHeiko Carstens return s390_enable_sie(); 457b0c632dbSHeiko Carstens return -EINVAL; 458b0c632dbSHeiko Carstens } 459b0c632dbSHeiko Carstens 460784aa3d7SAlexander Graf int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) 461b0c632dbSHeiko Carstens { 462d7b0b5ebSCarsten Otte int r; 463d7b0b5ebSCarsten Otte 4642bd0ac4eSCarsten Otte switch (ext) { 465d7b0b5ebSCarsten Otte case KVM_CAP_S390_PSW: 466b6cf8788SChristian Borntraeger case KVM_CAP_S390_GMAP: 46752e16b18SChristian Borntraeger case KVM_CAP_SYNC_MMU: 4681efd0f59SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 4691efd0f59SCarsten Otte case KVM_CAP_S390_UCONTROL: 4701efd0f59SCarsten Otte #endif 4713c038e6bSDominik Dingel case KVM_CAP_ASYNC_PF: 47260b413c9SChristian Borntraeger case KVM_CAP_SYNC_REGS: 47314eebd91SCarsten Otte case KVM_CAP_ONE_REG: 474d6712df9SCornelia Huck case KVM_CAP_ENABLE_CAP: 475fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 47610ccaa1eSCornelia Huck case KVM_CAP_IOEVENTFD: 477c05c4186SJens Freimann case KVM_CAP_DEVICE_CTRL: 478d938dc55SCornelia Huck case KVM_CAP_ENABLE_CAP_VM: 47978599d90SCornelia Huck case KVM_CAP_S390_IRQCHIP: 480f2061656SDominik Dingel case KVM_CAP_VM_ATTRIBUTES: 4816352e4d2SDavid Hildenbrand case KVM_CAP_MP_STATE: 482460df4c1SPaolo Bonzini case KVM_CAP_IMMEDIATE_EXIT: 48347b43c52SJens Freimann case KVM_CAP_S390_INJECT_IRQ: 4842444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 485e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 48630ee2a98SJason J. Herne case KVM_CAP_S390_SKEYS: 487816c7667SJens Freimann case KVM_CAP_S390_IRQ_STATE: 4886502a34cSDavid Hildenbrand case KVM_CAP_S390_USER_INSTR0: 4894036e387SClaudio Imbrenda case KVM_CAP_S390_CMMA_MIGRATION: 49047a4693eSYi Min Zhao case KVM_CAP_S390_AIS: 491da9a1446SChristian Borntraeger case KVM_CAP_S390_AIS_MIGRATION: 492d7b0b5ebSCarsten Otte r = 1; 493d7b0b5ebSCarsten Otte break; 494a4499382SJanosch Frank case KVM_CAP_S390_HPAGE_1M: 495a4499382SJanosch Frank r = 0; 49640ebdb8eSJanosch Frank if (hpage && !kvm_is_ucontrol(kvm)) 497a4499382SJanosch Frank r = 1; 498a4499382SJanosch Frank break; 49941408c28SThomas Huth case KVM_CAP_S390_MEM_OP: 50041408c28SThomas Huth r = MEM_OP_MAX_SIZE; 50141408c28SThomas Huth break; 502e726b1bdSChristian Borntraeger case KVM_CAP_NR_VCPUS: 503e726b1bdSChristian Borntraeger case KVM_CAP_MAX_VCPUS: 50476a6dd72SDavid Hildenbrand r = KVM_S390_BSCA_CPU_SLOTS; 505a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) 506a6940674SDavid Hildenbrand r = KVM_MAX_VCPUS; 507a6940674SDavid Hildenbrand else if (sclp.has_esca && sclp.has_64bscao) 50876a6dd72SDavid Hildenbrand r = KVM_S390_ESCA_CPU_SLOTS; 509e726b1bdSChristian Borntraeger break; 510e1e2e605SNick Wang case KVM_CAP_NR_MEMSLOTS: 511e1e2e605SNick Wang r = KVM_USER_MEM_SLOTS; 512e1e2e605SNick Wang break; 5131526bf9cSChristian Borntraeger case KVM_CAP_S390_COW: 514abf09bedSMartin Schwidefsky r = MACHINE_HAS_ESOP; 5151526bf9cSChristian Borntraeger break; 51668c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 51768c55750SEric Farman r = MACHINE_HAS_VX; 51868c55750SEric Farman break; 519c6e5f166SFan Zhang case KVM_CAP_S390_RI: 520c6e5f166SFan Zhang r = test_facility(64); 521c6e5f166SFan Zhang break; 5224e0b1ab7SFan Zhang case KVM_CAP_S390_GS: 5234e0b1ab7SFan Zhang r = test_facility(133); 5244e0b1ab7SFan Zhang break; 52535b3fde6SChristian Borntraeger case KVM_CAP_S390_BPB: 52635b3fde6SChristian Borntraeger r = test_facility(82); 52735b3fde6SChristian Borntraeger break; 5282bd0ac4eSCarsten Otte default: 529d7b0b5ebSCarsten Otte r = 0; 530b0c632dbSHeiko Carstens } 531d7b0b5ebSCarsten Otte return r; 5322bd0ac4eSCarsten Otte } 533b0c632dbSHeiko Carstens 53415f36ebdSJason J. Herne static void kvm_s390_sync_dirty_log(struct kvm *kvm, 53515f36ebdSJason J. Herne struct kvm_memory_slot *memslot) 53615f36ebdSJason J. Herne { 5370959e168SJanosch Frank int i; 53815f36ebdSJason J. Herne gfn_t cur_gfn, last_gfn; 5390959e168SJanosch Frank unsigned long gaddr, vmaddr; 54015f36ebdSJason J. Herne struct gmap *gmap = kvm->arch.gmap; 5410959e168SJanosch Frank DECLARE_BITMAP(bitmap, _PAGE_ENTRIES); 54215f36ebdSJason J. Herne 5430959e168SJanosch Frank /* Loop over all guest segments */ 5440959e168SJanosch Frank cur_gfn = memslot->base_gfn; 54515f36ebdSJason J. Herne last_gfn = memslot->base_gfn + memslot->npages; 5460959e168SJanosch Frank for (; cur_gfn <= last_gfn; cur_gfn += _PAGE_ENTRIES) { 5470959e168SJanosch Frank gaddr = gfn_to_gpa(cur_gfn); 5480959e168SJanosch Frank vmaddr = gfn_to_hva_memslot(memslot, cur_gfn); 5490959e168SJanosch Frank if (kvm_is_error_hva(vmaddr)) 5500959e168SJanosch Frank continue; 55115f36ebdSJason J. Herne 5520959e168SJanosch Frank bitmap_zero(bitmap, _PAGE_ENTRIES); 5530959e168SJanosch Frank gmap_sync_dirty_log_pmd(gmap, bitmap, gaddr, vmaddr); 5540959e168SJanosch Frank for (i = 0; i < _PAGE_ENTRIES; i++) { 5550959e168SJanosch Frank if (test_bit(i, bitmap)) 5560959e168SJanosch Frank mark_page_dirty(kvm, cur_gfn + i); 5570959e168SJanosch Frank } 5580959e168SJanosch Frank 5591763f8d0SChristian Borntraeger if (fatal_signal_pending(current)) 5601763f8d0SChristian Borntraeger return; 56170c88a00SChristian Borntraeger cond_resched(); 56215f36ebdSJason J. Herne } 56315f36ebdSJason J. Herne } 56415f36ebdSJason J. Herne 565b0c632dbSHeiko Carstens /* Section: vm related */ 566a6e2f683SEugene (jno) Dvurechenski static void sca_del_vcpu(struct kvm_vcpu *vcpu); 567a6e2f683SEugene (jno) Dvurechenski 568b0c632dbSHeiko Carstens /* 569b0c632dbSHeiko Carstens * Get (and clear) the dirty memory log for a memory slot. 570b0c632dbSHeiko Carstens */ 571b0c632dbSHeiko Carstens int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, 572b0c632dbSHeiko Carstens struct kvm_dirty_log *log) 573b0c632dbSHeiko Carstens { 57415f36ebdSJason J. Herne int r; 57515f36ebdSJason J. Herne unsigned long n; 5769f6b8029SPaolo Bonzini struct kvm_memslots *slots; 57715f36ebdSJason J. Herne struct kvm_memory_slot *memslot; 57815f36ebdSJason J. Herne int is_dirty = 0; 57915f36ebdSJason J. Herne 580e1e8a962SJanosch Frank if (kvm_is_ucontrol(kvm)) 581e1e8a962SJanosch Frank return -EINVAL; 582e1e8a962SJanosch Frank 58315f36ebdSJason J. Herne mutex_lock(&kvm->slots_lock); 58415f36ebdSJason J. Herne 58515f36ebdSJason J. Herne r = -EINVAL; 58615f36ebdSJason J. Herne if (log->slot >= KVM_USER_MEM_SLOTS) 58715f36ebdSJason J. Herne goto out; 58815f36ebdSJason J. Herne 5899f6b8029SPaolo Bonzini slots = kvm_memslots(kvm); 5909f6b8029SPaolo Bonzini memslot = id_to_memslot(slots, log->slot); 59115f36ebdSJason J. Herne r = -ENOENT; 59215f36ebdSJason J. Herne if (!memslot->dirty_bitmap) 59315f36ebdSJason J. Herne goto out; 59415f36ebdSJason J. Herne 59515f36ebdSJason J. Herne kvm_s390_sync_dirty_log(kvm, memslot); 59615f36ebdSJason J. Herne r = kvm_get_dirty_log(kvm, log, &is_dirty); 59715f36ebdSJason J. Herne if (r) 59815f36ebdSJason J. Herne goto out; 59915f36ebdSJason J. Herne 60015f36ebdSJason J. Herne /* Clear the dirty log */ 60115f36ebdSJason J. Herne if (is_dirty) { 60215f36ebdSJason J. Herne n = kvm_dirty_bitmap_bytes(memslot); 60315f36ebdSJason J. Herne memset(memslot->dirty_bitmap, 0, n); 60415f36ebdSJason J. Herne } 60515f36ebdSJason J. Herne r = 0; 60615f36ebdSJason J. Herne out: 60715f36ebdSJason J. Herne mutex_unlock(&kvm->slots_lock); 60815f36ebdSJason J. Herne return r; 609b0c632dbSHeiko Carstens } 610b0c632dbSHeiko Carstens 6116502a34cSDavid Hildenbrand static void icpt_operexc_on_all_vcpus(struct kvm *kvm) 6126502a34cSDavid Hildenbrand { 6136502a34cSDavid Hildenbrand unsigned int i; 6146502a34cSDavid Hildenbrand struct kvm_vcpu *vcpu; 6156502a34cSDavid Hildenbrand 6166502a34cSDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 6176502a34cSDavid Hildenbrand kvm_s390_sync_request(KVM_REQ_ICPT_OPEREXC, vcpu); 6186502a34cSDavid Hildenbrand } 6196502a34cSDavid Hildenbrand } 6206502a34cSDavid Hildenbrand 621d938dc55SCornelia Huck static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap) 622d938dc55SCornelia Huck { 623d938dc55SCornelia Huck int r; 624d938dc55SCornelia Huck 625d938dc55SCornelia Huck if (cap->flags) 626d938dc55SCornelia Huck return -EINVAL; 627d938dc55SCornelia Huck 628d938dc55SCornelia Huck switch (cap->cap) { 62984223598SCornelia Huck case KVM_CAP_S390_IRQCHIP: 630c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_IRQCHIP"); 63184223598SCornelia Huck kvm->arch.use_irqchip = 1; 63284223598SCornelia Huck r = 0; 63384223598SCornelia Huck break; 6342444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 635c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_SIGP"); 6362444b352SDavid Hildenbrand kvm->arch.user_sigp = 1; 6372444b352SDavid Hildenbrand r = 0; 6382444b352SDavid Hildenbrand break; 63968c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 6405967c17bSDavid Hildenbrand mutex_lock(&kvm->lock); 641a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 6425967c17bSDavid Hildenbrand r = -EBUSY; 6435967c17bSDavid Hildenbrand } else if (MACHINE_HAS_VX) { 644c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 129); 645c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 129); 6462f87d942SGuenther Hutzl if (test_facility(134)) { 6472f87d942SGuenther Hutzl set_kvm_facility(kvm->arch.model.fac_mask, 134); 6482f87d942SGuenther Hutzl set_kvm_facility(kvm->arch.model.fac_list, 134); 6492f87d942SGuenther Hutzl } 65053743aa7SMaxim Samoylov if (test_facility(135)) { 65153743aa7SMaxim Samoylov set_kvm_facility(kvm->arch.model.fac_mask, 135); 65253743aa7SMaxim Samoylov set_kvm_facility(kvm->arch.model.fac_list, 135); 65353743aa7SMaxim Samoylov } 65418280d8bSMichael Mueller r = 0; 65518280d8bSMichael Mueller } else 65618280d8bSMichael Mueller r = -EINVAL; 6575967c17bSDavid Hildenbrand mutex_unlock(&kvm->lock); 658c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "ENABLE: CAP_S390_VECTOR_REGISTERS %s", 659c92ea7b9SChristian Borntraeger r ? "(not available)" : "(success)"); 66068c55750SEric Farman break; 661c6e5f166SFan Zhang case KVM_CAP_S390_RI: 662c6e5f166SFan Zhang r = -EINVAL; 663c6e5f166SFan Zhang mutex_lock(&kvm->lock); 664a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 665c6e5f166SFan Zhang r = -EBUSY; 666c6e5f166SFan Zhang } else if (test_facility(64)) { 667c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 64); 668c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 64); 669c6e5f166SFan Zhang r = 0; 670c6e5f166SFan Zhang } 671c6e5f166SFan Zhang mutex_unlock(&kvm->lock); 672c6e5f166SFan Zhang VM_EVENT(kvm, 3, "ENABLE: CAP_S390_RI %s", 673c6e5f166SFan Zhang r ? "(not available)" : "(success)"); 674c6e5f166SFan Zhang break; 67547a4693eSYi Min Zhao case KVM_CAP_S390_AIS: 67647a4693eSYi Min Zhao mutex_lock(&kvm->lock); 67747a4693eSYi Min Zhao if (kvm->created_vcpus) { 67847a4693eSYi Min Zhao r = -EBUSY; 67947a4693eSYi Min Zhao } else { 68047a4693eSYi Min Zhao set_kvm_facility(kvm->arch.model.fac_mask, 72); 68147a4693eSYi Min Zhao set_kvm_facility(kvm->arch.model.fac_list, 72); 68247a4693eSYi Min Zhao r = 0; 68347a4693eSYi Min Zhao } 68447a4693eSYi Min Zhao mutex_unlock(&kvm->lock); 68547a4693eSYi Min Zhao VM_EVENT(kvm, 3, "ENABLE: AIS %s", 68647a4693eSYi Min Zhao r ? "(not available)" : "(success)"); 68747a4693eSYi Min Zhao break; 6884e0b1ab7SFan Zhang case KVM_CAP_S390_GS: 6894e0b1ab7SFan Zhang r = -EINVAL; 6904e0b1ab7SFan Zhang mutex_lock(&kvm->lock); 691241e3ec0SChristian Borntraeger if (kvm->created_vcpus) { 6924e0b1ab7SFan Zhang r = -EBUSY; 6934e0b1ab7SFan Zhang } else if (test_facility(133)) { 6944e0b1ab7SFan Zhang set_kvm_facility(kvm->arch.model.fac_mask, 133); 6954e0b1ab7SFan Zhang set_kvm_facility(kvm->arch.model.fac_list, 133); 6964e0b1ab7SFan Zhang r = 0; 6974e0b1ab7SFan Zhang } 6984e0b1ab7SFan Zhang mutex_unlock(&kvm->lock); 6994e0b1ab7SFan Zhang VM_EVENT(kvm, 3, "ENABLE: CAP_S390_GS %s", 7004e0b1ab7SFan Zhang r ? "(not available)" : "(success)"); 7014e0b1ab7SFan Zhang break; 702a4499382SJanosch Frank case KVM_CAP_S390_HPAGE_1M: 703a4499382SJanosch Frank mutex_lock(&kvm->lock); 704a4499382SJanosch Frank if (kvm->created_vcpus) 705a4499382SJanosch Frank r = -EBUSY; 70640ebdb8eSJanosch Frank else if (!hpage || kvm->arch.use_cmma || kvm_is_ucontrol(kvm)) 707a4499382SJanosch Frank r = -EINVAL; 708a4499382SJanosch Frank else { 709a4499382SJanosch Frank r = 0; 710df88f318SJanosch Frank down_write(&kvm->mm->mmap_sem); 711a4499382SJanosch Frank kvm->mm->context.allow_gmap_hpage_1m = 1; 712df88f318SJanosch Frank up_write(&kvm->mm->mmap_sem); 713a4499382SJanosch Frank /* 714a4499382SJanosch Frank * We might have to create fake 4k page 715a4499382SJanosch Frank * tables. To avoid that the hardware works on 716a4499382SJanosch Frank * stale PGSTEs, we emulate these instructions. 717a4499382SJanosch Frank */ 718a4499382SJanosch Frank kvm->arch.use_skf = 0; 719a4499382SJanosch Frank kvm->arch.use_pfmfi = 0; 720a4499382SJanosch Frank } 721a4499382SJanosch Frank mutex_unlock(&kvm->lock); 722a4499382SJanosch Frank VM_EVENT(kvm, 3, "ENABLE: CAP_S390_HPAGE %s", 723a4499382SJanosch Frank r ? "(not available)" : "(success)"); 724a4499382SJanosch Frank break; 725e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 726c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_STSI"); 727e44fc8c9SEkaterina Tumanova kvm->arch.user_stsi = 1; 728e44fc8c9SEkaterina Tumanova r = 0; 729e44fc8c9SEkaterina Tumanova break; 7306502a34cSDavid Hildenbrand case KVM_CAP_S390_USER_INSTR0: 7316502a34cSDavid Hildenbrand VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_INSTR0"); 7326502a34cSDavid Hildenbrand kvm->arch.user_instr0 = 1; 7336502a34cSDavid Hildenbrand icpt_operexc_on_all_vcpus(kvm); 7346502a34cSDavid Hildenbrand r = 0; 7356502a34cSDavid Hildenbrand break; 736d938dc55SCornelia Huck default: 737d938dc55SCornelia Huck r = -EINVAL; 738d938dc55SCornelia Huck break; 739d938dc55SCornelia Huck } 740d938dc55SCornelia Huck return r; 741d938dc55SCornelia Huck } 742d938dc55SCornelia Huck 7438c0a7ce6SDominik Dingel static int kvm_s390_get_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 7448c0a7ce6SDominik Dingel { 7458c0a7ce6SDominik Dingel int ret; 7468c0a7ce6SDominik Dingel 7478c0a7ce6SDominik Dingel switch (attr->attr) { 7488c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 7498c0a7ce6SDominik Dingel ret = 0; 750c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: max guest memory: %lu bytes", 751a3a92c31SDominik Dingel kvm->arch.mem_limit); 752a3a92c31SDominik Dingel if (put_user(kvm->arch.mem_limit, (u64 __user *)attr->addr)) 7538c0a7ce6SDominik Dingel ret = -EFAULT; 7548c0a7ce6SDominik Dingel break; 7558c0a7ce6SDominik Dingel default: 7568c0a7ce6SDominik Dingel ret = -ENXIO; 7578c0a7ce6SDominik Dingel break; 7588c0a7ce6SDominik Dingel } 7598c0a7ce6SDominik Dingel return ret; 7608c0a7ce6SDominik Dingel } 7618c0a7ce6SDominik Dingel 7628c0a7ce6SDominik Dingel static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 7634f718eabSDominik Dingel { 7644f718eabSDominik Dingel int ret; 7654f718eabSDominik Dingel unsigned int idx; 7664f718eabSDominik Dingel switch (attr->attr) { 7674f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 768f9cbd9b0SDavid Hildenbrand ret = -ENXIO; 769c24cc9c8SDavid Hildenbrand if (!sclp.has_cmma) 770e6db1d61SDominik Dingel break; 771e6db1d61SDominik Dingel 772c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CMMA support"); 7734f718eabSDominik Dingel mutex_lock(&kvm->lock); 774a4499382SJanosch Frank if (kvm->created_vcpus) 775a4499382SJanosch Frank ret = -EBUSY; 776a4499382SJanosch Frank else if (kvm->mm->context.allow_gmap_hpage_1m) 777a4499382SJanosch Frank ret = -EINVAL; 778a4499382SJanosch Frank else { 7794f718eabSDominik Dingel kvm->arch.use_cmma = 1; 780c9f0a2b8SJanosch Frank /* Not compatible with cmma. */ 781c9f0a2b8SJanosch Frank kvm->arch.use_pfmfi = 0; 7824f718eabSDominik Dingel ret = 0; 7834f718eabSDominik Dingel } 7844f718eabSDominik Dingel mutex_unlock(&kvm->lock); 7854f718eabSDominik Dingel break; 7864f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 787f9cbd9b0SDavid Hildenbrand ret = -ENXIO; 788f9cbd9b0SDavid Hildenbrand if (!sclp.has_cmma) 789f9cbd9b0SDavid Hildenbrand break; 790c3489155SDominik Dingel ret = -EINVAL; 791c3489155SDominik Dingel if (!kvm->arch.use_cmma) 792c3489155SDominik Dingel break; 793c3489155SDominik Dingel 794c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "RESET: CMMA states"); 7954f718eabSDominik Dingel mutex_lock(&kvm->lock); 7964f718eabSDominik Dingel idx = srcu_read_lock(&kvm->srcu); 797a13cff31SDominik Dingel s390_reset_cmma(kvm->arch.gmap->mm); 7984f718eabSDominik Dingel srcu_read_unlock(&kvm->srcu, idx); 7994f718eabSDominik Dingel mutex_unlock(&kvm->lock); 8004f718eabSDominik Dingel ret = 0; 8014f718eabSDominik Dingel break; 8028c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: { 8038c0a7ce6SDominik Dingel unsigned long new_limit; 8048c0a7ce6SDominik Dingel 8058c0a7ce6SDominik Dingel if (kvm_is_ucontrol(kvm)) 8068c0a7ce6SDominik Dingel return -EINVAL; 8078c0a7ce6SDominik Dingel 8088c0a7ce6SDominik Dingel if (get_user(new_limit, (u64 __user *)attr->addr)) 8098c0a7ce6SDominik Dingel return -EFAULT; 8108c0a7ce6SDominik Dingel 811a3a92c31SDominik Dingel if (kvm->arch.mem_limit != KVM_S390_NO_MEM_LIMIT && 812a3a92c31SDominik Dingel new_limit > kvm->arch.mem_limit) 8138c0a7ce6SDominik Dingel return -E2BIG; 8148c0a7ce6SDominik Dingel 815a3a92c31SDominik Dingel if (!new_limit) 816a3a92c31SDominik Dingel return -EINVAL; 817a3a92c31SDominik Dingel 8186ea427bbSMartin Schwidefsky /* gmap_create takes last usable address */ 819a3a92c31SDominik Dingel if (new_limit != KVM_S390_NO_MEM_LIMIT) 820a3a92c31SDominik Dingel new_limit -= 1; 821a3a92c31SDominik Dingel 8228c0a7ce6SDominik Dingel ret = -EBUSY; 8238c0a7ce6SDominik Dingel mutex_lock(&kvm->lock); 824a03825bbSPaolo Bonzini if (!kvm->created_vcpus) { 8256ea427bbSMartin Schwidefsky /* gmap_create will round the limit up */ 8266ea427bbSMartin Schwidefsky struct gmap *new = gmap_create(current->mm, new_limit); 8278c0a7ce6SDominik Dingel 8288c0a7ce6SDominik Dingel if (!new) { 8298c0a7ce6SDominik Dingel ret = -ENOMEM; 8308c0a7ce6SDominik Dingel } else { 8316ea427bbSMartin Schwidefsky gmap_remove(kvm->arch.gmap); 8328c0a7ce6SDominik Dingel new->private = kvm; 8338c0a7ce6SDominik Dingel kvm->arch.gmap = new; 8348c0a7ce6SDominik Dingel ret = 0; 8358c0a7ce6SDominik Dingel } 8368c0a7ce6SDominik Dingel } 8378c0a7ce6SDominik Dingel mutex_unlock(&kvm->lock); 838a3a92c31SDominik Dingel VM_EVENT(kvm, 3, "SET: max guest address: %lu", new_limit); 839a3a92c31SDominik Dingel VM_EVENT(kvm, 3, "New guest asce: 0x%pK", 840a3a92c31SDominik Dingel (void *) kvm->arch.gmap->asce); 8418c0a7ce6SDominik Dingel break; 8428c0a7ce6SDominik Dingel } 8434f718eabSDominik Dingel default: 8444f718eabSDominik Dingel ret = -ENXIO; 8454f718eabSDominik Dingel break; 8464f718eabSDominik Dingel } 8474f718eabSDominik Dingel return ret; 8484f718eabSDominik Dingel } 8494f718eabSDominik Dingel 850a374e892STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu); 851a374e892STony Krowiak 85220c922f0STony Krowiak void kvm_s390_vcpu_crypto_reset_all(struct kvm *kvm) 853a374e892STony Krowiak { 854a374e892STony Krowiak struct kvm_vcpu *vcpu; 855a374e892STony Krowiak int i; 856a374e892STony Krowiak 85720c922f0STony Krowiak kvm_s390_vcpu_block_all(kvm); 85820c922f0STony Krowiak 8593194cdb7SDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 86020c922f0STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 8613194cdb7SDavid Hildenbrand /* recreate the shadow crycb by leaving the VSIE handler */ 8623194cdb7SDavid Hildenbrand kvm_s390_sync_request(KVM_REQ_VSIE_RESTART, vcpu); 8633194cdb7SDavid Hildenbrand } 86420c922f0STony Krowiak 86520c922f0STony Krowiak kvm_s390_vcpu_unblock_all(kvm); 86620c922f0STony Krowiak } 86720c922f0STony Krowiak 86820c922f0STony Krowiak static int kvm_s390_vm_set_crypto(struct kvm *kvm, struct kvm_device_attr *attr) 86920c922f0STony Krowiak { 870a374e892STony Krowiak mutex_lock(&kvm->lock); 871a374e892STony Krowiak switch (attr->attr) { 872a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 8738e41bd54SChristian Borntraeger if (!test_kvm_facility(kvm, 76)) { 8748e41bd54SChristian Borntraeger mutex_unlock(&kvm->lock); 87537940fb0STony Krowiak return -EINVAL; 8768e41bd54SChristian Borntraeger } 877a374e892STony Krowiak get_random_bytes( 878a374e892STony Krowiak kvm->arch.crypto.crycb->aes_wrapping_key_mask, 879a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 880a374e892STony Krowiak kvm->arch.crypto.aes_kw = 1; 881c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: AES keywrapping support"); 882a374e892STony Krowiak break; 883a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 8848e41bd54SChristian Borntraeger if (!test_kvm_facility(kvm, 76)) { 8858e41bd54SChristian Borntraeger mutex_unlock(&kvm->lock); 88637940fb0STony Krowiak return -EINVAL; 8878e41bd54SChristian Borntraeger } 888a374e892STony Krowiak get_random_bytes( 889a374e892STony Krowiak kvm->arch.crypto.crycb->dea_wrapping_key_mask, 890a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 891a374e892STony Krowiak kvm->arch.crypto.dea_kw = 1; 892c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: DEA keywrapping support"); 893a374e892STony Krowiak break; 894a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 8958e41bd54SChristian Borntraeger if (!test_kvm_facility(kvm, 76)) { 8968e41bd54SChristian Borntraeger mutex_unlock(&kvm->lock); 89737940fb0STony Krowiak return -EINVAL; 8988e41bd54SChristian Borntraeger } 899a374e892STony Krowiak kvm->arch.crypto.aes_kw = 0; 900a374e892STony Krowiak memset(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 0, 901a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 902c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "DISABLE: AES keywrapping support"); 903a374e892STony Krowiak break; 904a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 9058e41bd54SChristian Borntraeger if (!test_kvm_facility(kvm, 76)) { 9068e41bd54SChristian Borntraeger mutex_unlock(&kvm->lock); 90737940fb0STony Krowiak return -EINVAL; 9088e41bd54SChristian Borntraeger } 909a374e892STony Krowiak kvm->arch.crypto.dea_kw = 0; 910a374e892STony Krowiak memset(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 0, 911a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 912c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "DISABLE: DEA keywrapping support"); 913a374e892STony Krowiak break; 91437940fb0STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_APIE: 91537940fb0STony Krowiak if (!ap_instructions_available()) { 91637940fb0STony Krowiak mutex_unlock(&kvm->lock); 91737940fb0STony Krowiak return -EOPNOTSUPP; 91837940fb0STony Krowiak } 91937940fb0STony Krowiak kvm->arch.crypto.apie = 1; 92037940fb0STony Krowiak break; 92137940fb0STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_APIE: 92237940fb0STony Krowiak if (!ap_instructions_available()) { 92337940fb0STony Krowiak mutex_unlock(&kvm->lock); 92437940fb0STony Krowiak return -EOPNOTSUPP; 92537940fb0STony Krowiak } 92637940fb0STony Krowiak kvm->arch.crypto.apie = 0; 92737940fb0STony Krowiak break; 928a374e892STony Krowiak default: 929a374e892STony Krowiak mutex_unlock(&kvm->lock); 930a374e892STony Krowiak return -ENXIO; 931a374e892STony Krowiak } 932a374e892STony Krowiak 93320c922f0STony Krowiak kvm_s390_vcpu_crypto_reset_all(kvm); 934a374e892STony Krowiak mutex_unlock(&kvm->lock); 935a374e892STony Krowiak return 0; 936a374e892STony Krowiak } 937a374e892STony Krowiak 938190df4a2SClaudio Imbrenda static void kvm_s390_sync_request_broadcast(struct kvm *kvm, int req) 939190df4a2SClaudio Imbrenda { 940190df4a2SClaudio Imbrenda int cx; 941190df4a2SClaudio Imbrenda struct kvm_vcpu *vcpu; 942190df4a2SClaudio Imbrenda 943190df4a2SClaudio Imbrenda kvm_for_each_vcpu(cx, vcpu, kvm) 944190df4a2SClaudio Imbrenda kvm_s390_sync_request(req, vcpu); 945190df4a2SClaudio Imbrenda } 946190df4a2SClaudio Imbrenda 947190df4a2SClaudio Imbrenda /* 948190df4a2SClaudio Imbrenda * Must be called with kvm->srcu held to avoid races on memslots, and with 9491de1ea7eSChristian Borntraeger * kvm->slots_lock to avoid races with ourselves and kvm_s390_vm_stop_migration. 950190df4a2SClaudio Imbrenda */ 951190df4a2SClaudio Imbrenda static int kvm_s390_vm_start_migration(struct kvm *kvm) 952190df4a2SClaudio Imbrenda { 953190df4a2SClaudio Imbrenda struct kvm_memory_slot *ms; 954190df4a2SClaudio Imbrenda struct kvm_memslots *slots; 955afdad616SClaudio Imbrenda unsigned long ram_pages = 0; 956190df4a2SClaudio Imbrenda int slotnr; 957190df4a2SClaudio Imbrenda 958190df4a2SClaudio Imbrenda /* migration mode already enabled */ 959afdad616SClaudio Imbrenda if (kvm->arch.migration_mode) 960190df4a2SClaudio Imbrenda return 0; 961190df4a2SClaudio Imbrenda slots = kvm_memslots(kvm); 962190df4a2SClaudio Imbrenda if (!slots || !slots->used_slots) 963190df4a2SClaudio Imbrenda return -EINVAL; 964190df4a2SClaudio Imbrenda 965afdad616SClaudio Imbrenda if (!kvm->arch.use_cmma) { 966afdad616SClaudio Imbrenda kvm->arch.migration_mode = 1; 967afdad616SClaudio Imbrenda return 0; 968190df4a2SClaudio Imbrenda } 969190df4a2SClaudio Imbrenda /* mark all the pages in active slots as dirty */ 970190df4a2SClaudio Imbrenda for (slotnr = 0; slotnr < slots->used_slots; slotnr++) { 971190df4a2SClaudio Imbrenda ms = slots->memslots + slotnr; 972afdad616SClaudio Imbrenda /* 973afdad616SClaudio Imbrenda * The second half of the bitmap is only used on x86, 974afdad616SClaudio Imbrenda * and would be wasted otherwise, so we put it to good 975afdad616SClaudio Imbrenda * use here to keep track of the state of the storage 976afdad616SClaudio Imbrenda * attributes. 977afdad616SClaudio Imbrenda */ 978afdad616SClaudio Imbrenda memset(kvm_second_dirty_bitmap(ms), 0xff, kvm_dirty_bitmap_bytes(ms)); 979afdad616SClaudio Imbrenda ram_pages += ms->npages; 980190df4a2SClaudio Imbrenda } 981afdad616SClaudio Imbrenda atomic64_set(&kvm->arch.cmma_dirty_pages, ram_pages); 982afdad616SClaudio Imbrenda kvm->arch.migration_mode = 1; 983190df4a2SClaudio Imbrenda kvm_s390_sync_request_broadcast(kvm, KVM_REQ_START_MIGRATION); 984190df4a2SClaudio Imbrenda return 0; 985190df4a2SClaudio Imbrenda } 986190df4a2SClaudio Imbrenda 987190df4a2SClaudio Imbrenda /* 9881de1ea7eSChristian Borntraeger * Must be called with kvm->slots_lock to avoid races with ourselves and 989190df4a2SClaudio Imbrenda * kvm_s390_vm_start_migration. 990190df4a2SClaudio Imbrenda */ 991190df4a2SClaudio Imbrenda static int kvm_s390_vm_stop_migration(struct kvm *kvm) 992190df4a2SClaudio Imbrenda { 993190df4a2SClaudio Imbrenda /* migration mode already disabled */ 994afdad616SClaudio Imbrenda if (!kvm->arch.migration_mode) 995190df4a2SClaudio Imbrenda return 0; 996afdad616SClaudio Imbrenda kvm->arch.migration_mode = 0; 997afdad616SClaudio Imbrenda if (kvm->arch.use_cmma) 998190df4a2SClaudio Imbrenda kvm_s390_sync_request_broadcast(kvm, KVM_REQ_STOP_MIGRATION); 999190df4a2SClaudio Imbrenda return 0; 1000190df4a2SClaudio Imbrenda } 1001190df4a2SClaudio Imbrenda 1002190df4a2SClaudio Imbrenda static int kvm_s390_vm_set_migration(struct kvm *kvm, 1003190df4a2SClaudio Imbrenda struct kvm_device_attr *attr) 1004190df4a2SClaudio Imbrenda { 10051de1ea7eSChristian Borntraeger int res = -ENXIO; 1006190df4a2SClaudio Imbrenda 10071de1ea7eSChristian Borntraeger mutex_lock(&kvm->slots_lock); 1008190df4a2SClaudio Imbrenda switch (attr->attr) { 1009190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION_START: 1010190df4a2SClaudio Imbrenda res = kvm_s390_vm_start_migration(kvm); 1011190df4a2SClaudio Imbrenda break; 1012190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION_STOP: 1013190df4a2SClaudio Imbrenda res = kvm_s390_vm_stop_migration(kvm); 1014190df4a2SClaudio Imbrenda break; 1015190df4a2SClaudio Imbrenda default: 1016190df4a2SClaudio Imbrenda break; 1017190df4a2SClaudio Imbrenda } 10181de1ea7eSChristian Borntraeger mutex_unlock(&kvm->slots_lock); 1019190df4a2SClaudio Imbrenda 1020190df4a2SClaudio Imbrenda return res; 1021190df4a2SClaudio Imbrenda } 1022190df4a2SClaudio Imbrenda 1023190df4a2SClaudio Imbrenda static int kvm_s390_vm_get_migration(struct kvm *kvm, 1024190df4a2SClaudio Imbrenda struct kvm_device_attr *attr) 1025190df4a2SClaudio Imbrenda { 1026afdad616SClaudio Imbrenda u64 mig = kvm->arch.migration_mode; 1027190df4a2SClaudio Imbrenda 1028190df4a2SClaudio Imbrenda if (attr->attr != KVM_S390_VM_MIGRATION_STATUS) 1029190df4a2SClaudio Imbrenda return -ENXIO; 1030190df4a2SClaudio Imbrenda 1031190df4a2SClaudio Imbrenda if (copy_to_user((void __user *)attr->addr, &mig, sizeof(mig))) 1032190df4a2SClaudio Imbrenda return -EFAULT; 1033190df4a2SClaudio Imbrenda return 0; 1034190df4a2SClaudio Imbrenda } 1035190df4a2SClaudio Imbrenda 10368fa1696eSCollin L. Walling static int kvm_s390_set_tod_ext(struct kvm *kvm, struct kvm_device_attr *attr) 10378fa1696eSCollin L. Walling { 10388fa1696eSCollin L. Walling struct kvm_s390_vm_tod_clock gtod; 10398fa1696eSCollin L. Walling 10408fa1696eSCollin L. Walling if (copy_from_user(>od, (void __user *)attr->addr, sizeof(gtod))) 10418fa1696eSCollin L. Walling return -EFAULT; 10428fa1696eSCollin L. Walling 10430e7def5fSDavid Hildenbrand if (!test_kvm_facility(kvm, 139) && gtod.epoch_idx) 10448fa1696eSCollin L. Walling return -EINVAL; 10450e7def5fSDavid Hildenbrand kvm_s390_set_tod_clock(kvm, >od); 10468fa1696eSCollin L. Walling 10478fa1696eSCollin L. Walling VM_EVENT(kvm, 3, "SET: TOD extension: 0x%x, TOD base: 0x%llx", 10488fa1696eSCollin L. Walling gtod.epoch_idx, gtod.tod); 10498fa1696eSCollin L. Walling 10508fa1696eSCollin L. Walling return 0; 10518fa1696eSCollin L. Walling } 10528fa1696eSCollin L. Walling 105372f25020SJason J. Herne static int kvm_s390_set_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 105472f25020SJason J. Herne { 105572f25020SJason J. Herne u8 gtod_high; 105672f25020SJason J. Herne 105772f25020SJason J. Herne if (copy_from_user(>od_high, (void __user *)attr->addr, 105872f25020SJason J. Herne sizeof(gtod_high))) 105972f25020SJason J. Herne return -EFAULT; 106072f25020SJason J. Herne 106172f25020SJason J. Herne if (gtod_high != 0) 106272f25020SJason J. Herne return -EINVAL; 106358c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "SET: TOD extension: 0x%x", gtod_high); 106472f25020SJason J. Herne 106572f25020SJason J. Herne return 0; 106672f25020SJason J. Herne } 106772f25020SJason J. Herne 106872f25020SJason J. Herne static int kvm_s390_set_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 106972f25020SJason J. Herne { 10700e7def5fSDavid Hildenbrand struct kvm_s390_vm_tod_clock gtod = { 0 }; 107172f25020SJason J. Herne 10720e7def5fSDavid Hildenbrand if (copy_from_user(>od.tod, (void __user *)attr->addr, 10730e7def5fSDavid Hildenbrand sizeof(gtod.tod))) 107472f25020SJason J. Herne return -EFAULT; 107572f25020SJason J. Herne 10760e7def5fSDavid Hildenbrand kvm_s390_set_tod_clock(kvm, >od); 10770e7def5fSDavid Hildenbrand VM_EVENT(kvm, 3, "SET: TOD base: 0x%llx", gtod.tod); 107872f25020SJason J. Herne return 0; 107972f25020SJason J. Herne } 108072f25020SJason J. Herne 108172f25020SJason J. Herne static int kvm_s390_set_tod(struct kvm *kvm, struct kvm_device_attr *attr) 108272f25020SJason J. Herne { 108372f25020SJason J. Herne int ret; 108472f25020SJason J. Herne 108572f25020SJason J. Herne if (attr->flags) 108672f25020SJason J. Herne return -EINVAL; 108772f25020SJason J. Herne 108872f25020SJason J. Herne switch (attr->attr) { 10898fa1696eSCollin L. Walling case KVM_S390_VM_TOD_EXT: 10908fa1696eSCollin L. Walling ret = kvm_s390_set_tod_ext(kvm, attr); 10918fa1696eSCollin L. Walling break; 109272f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 109372f25020SJason J. Herne ret = kvm_s390_set_tod_high(kvm, attr); 109472f25020SJason J. Herne break; 109572f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 109672f25020SJason J. Herne ret = kvm_s390_set_tod_low(kvm, attr); 109772f25020SJason J. Herne break; 109872f25020SJason J. Herne default: 109972f25020SJason J. Herne ret = -ENXIO; 110072f25020SJason J. Herne break; 110172f25020SJason J. Herne } 110272f25020SJason J. Herne return ret; 110372f25020SJason J. Herne } 110472f25020SJason J. Herne 110533d1b272SDavid Hildenbrand static void kvm_s390_get_tod_clock(struct kvm *kvm, 11068fa1696eSCollin L. Walling struct kvm_s390_vm_tod_clock *gtod) 11078fa1696eSCollin L. Walling { 11088fa1696eSCollin L. Walling struct kvm_s390_tod_clock_ext htod; 11098fa1696eSCollin L. Walling 11108fa1696eSCollin L. Walling preempt_disable(); 11118fa1696eSCollin L. Walling 11128fa1696eSCollin L. Walling get_tod_clock_ext((char *)&htod); 11138fa1696eSCollin L. Walling 11148fa1696eSCollin L. Walling gtod->tod = htod.tod + kvm->arch.epoch; 111533d1b272SDavid Hildenbrand gtod->epoch_idx = 0; 111633d1b272SDavid Hildenbrand if (test_kvm_facility(kvm, 139)) { 11178fa1696eSCollin L. Walling gtod->epoch_idx = htod.epoch_idx + kvm->arch.epdx; 11188fa1696eSCollin L. Walling if (gtod->tod < htod.tod) 11198fa1696eSCollin L. Walling gtod->epoch_idx += 1; 112033d1b272SDavid Hildenbrand } 11218fa1696eSCollin L. Walling 11228fa1696eSCollin L. Walling preempt_enable(); 11238fa1696eSCollin L. Walling } 11248fa1696eSCollin L. Walling 11258fa1696eSCollin L. Walling static int kvm_s390_get_tod_ext(struct kvm *kvm, struct kvm_device_attr *attr) 11268fa1696eSCollin L. Walling { 11278fa1696eSCollin L. Walling struct kvm_s390_vm_tod_clock gtod; 11288fa1696eSCollin L. Walling 11298fa1696eSCollin L. Walling memset(>od, 0, sizeof(gtod)); 113033d1b272SDavid Hildenbrand kvm_s390_get_tod_clock(kvm, >od); 11318fa1696eSCollin L. Walling if (copy_to_user((void __user *)attr->addr, >od, sizeof(gtod))) 11328fa1696eSCollin L. Walling return -EFAULT; 11338fa1696eSCollin L. Walling 11348fa1696eSCollin L. Walling VM_EVENT(kvm, 3, "QUERY: TOD extension: 0x%x, TOD base: 0x%llx", 11358fa1696eSCollin L. Walling gtod.epoch_idx, gtod.tod); 11368fa1696eSCollin L. Walling return 0; 11378fa1696eSCollin L. Walling } 11388fa1696eSCollin L. Walling 113972f25020SJason J. Herne static int kvm_s390_get_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 114072f25020SJason J. Herne { 114172f25020SJason J. Herne u8 gtod_high = 0; 114272f25020SJason J. Herne 114372f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od_high, 114472f25020SJason J. Herne sizeof(gtod_high))) 114572f25020SJason J. Herne return -EFAULT; 114658c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: TOD extension: 0x%x", gtod_high); 114772f25020SJason J. Herne 114872f25020SJason J. Herne return 0; 114972f25020SJason J. Herne } 115072f25020SJason J. Herne 115172f25020SJason J. Herne static int kvm_s390_get_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 115272f25020SJason J. Herne { 11535a3d883aSDavid Hildenbrand u64 gtod; 115472f25020SJason J. Herne 115560417fccSDavid Hildenbrand gtod = kvm_s390_get_tod_clock_fast(kvm); 115672f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od, sizeof(gtod))) 115772f25020SJason J. Herne return -EFAULT; 115858c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: TOD base: 0x%llx", gtod); 115972f25020SJason J. Herne 116072f25020SJason J. Herne return 0; 116172f25020SJason J. Herne } 116272f25020SJason J. Herne 116372f25020SJason J. Herne static int kvm_s390_get_tod(struct kvm *kvm, struct kvm_device_attr *attr) 116472f25020SJason J. Herne { 116572f25020SJason J. Herne int ret; 116672f25020SJason J. Herne 116772f25020SJason J. Herne if (attr->flags) 116872f25020SJason J. Herne return -EINVAL; 116972f25020SJason J. Herne 117072f25020SJason J. Herne switch (attr->attr) { 11718fa1696eSCollin L. Walling case KVM_S390_VM_TOD_EXT: 11728fa1696eSCollin L. Walling ret = kvm_s390_get_tod_ext(kvm, attr); 11738fa1696eSCollin L. Walling break; 117472f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 117572f25020SJason J. Herne ret = kvm_s390_get_tod_high(kvm, attr); 117672f25020SJason J. Herne break; 117772f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 117872f25020SJason J. Herne ret = kvm_s390_get_tod_low(kvm, attr); 117972f25020SJason J. Herne break; 118072f25020SJason J. Herne default: 118172f25020SJason J. Herne ret = -ENXIO; 118272f25020SJason J. Herne break; 118372f25020SJason J. Herne } 118472f25020SJason J. Herne return ret; 118572f25020SJason J. Herne } 118672f25020SJason J. Herne 1187658b6edaSMichael Mueller static int kvm_s390_set_processor(struct kvm *kvm, struct kvm_device_attr *attr) 1188658b6edaSMichael Mueller { 1189658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 1190053dd230SDavid Hildenbrand u16 lowest_ibc, unblocked_ibc; 1191658b6edaSMichael Mueller int ret = 0; 1192658b6edaSMichael Mueller 1193658b6edaSMichael Mueller mutex_lock(&kvm->lock); 1194a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 1195658b6edaSMichael Mueller ret = -EBUSY; 1196658b6edaSMichael Mueller goto out; 1197658b6edaSMichael Mueller } 1198658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 1199658b6edaSMichael Mueller if (!proc) { 1200658b6edaSMichael Mueller ret = -ENOMEM; 1201658b6edaSMichael Mueller goto out; 1202658b6edaSMichael Mueller } 1203658b6edaSMichael Mueller if (!copy_from_user(proc, (void __user *)attr->addr, 1204658b6edaSMichael Mueller sizeof(*proc))) { 12059bb0ec09SDavid Hildenbrand kvm->arch.model.cpuid = proc->cpuid; 1206053dd230SDavid Hildenbrand lowest_ibc = sclp.ibc >> 16 & 0xfff; 1207053dd230SDavid Hildenbrand unblocked_ibc = sclp.ibc & 0xfff; 12080487c44dSDavid Hildenbrand if (lowest_ibc && proc->ibc) { 1209053dd230SDavid Hildenbrand if (proc->ibc > unblocked_ibc) 1210053dd230SDavid Hildenbrand kvm->arch.model.ibc = unblocked_ibc; 1211053dd230SDavid Hildenbrand else if (proc->ibc < lowest_ibc) 1212053dd230SDavid Hildenbrand kvm->arch.model.ibc = lowest_ibc; 1213053dd230SDavid Hildenbrand else 1214658b6edaSMichael Mueller kvm->arch.model.ibc = proc->ibc; 1215053dd230SDavid Hildenbrand } 1216c54f0d6aSDavid Hildenbrand memcpy(kvm->arch.model.fac_list, proc->fac_list, 1217658b6edaSMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 1218a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest ibc: 0x%4.4x, guest cpuid: 0x%16.16llx", 1219a8c39dd7SChristian Borntraeger kvm->arch.model.ibc, 1220a8c39dd7SChristian Borntraeger kvm->arch.model.cpuid); 1221a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest faclist: 0x%16.16llx.%16.16llx.%16.16llx", 1222a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[0], 1223a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[1], 1224a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[2]); 1225658b6edaSMichael Mueller } else 1226658b6edaSMichael Mueller ret = -EFAULT; 1227658b6edaSMichael Mueller kfree(proc); 1228658b6edaSMichael Mueller out: 1229658b6edaSMichael Mueller mutex_unlock(&kvm->lock); 1230658b6edaSMichael Mueller return ret; 1231658b6edaSMichael Mueller } 1232658b6edaSMichael Mueller 123315c9705fSDavid Hildenbrand static int kvm_s390_set_processor_feat(struct kvm *kvm, 123415c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 123515c9705fSDavid Hildenbrand { 123615c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 123715c9705fSDavid Hildenbrand 123815c9705fSDavid Hildenbrand if (copy_from_user(&data, (void __user *)attr->addr, sizeof(data))) 123915c9705fSDavid Hildenbrand return -EFAULT; 124015c9705fSDavid Hildenbrand if (!bitmap_subset((unsigned long *) data.feat, 124115c9705fSDavid Hildenbrand kvm_s390_available_cpu_feat, 124215c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS)) 124315c9705fSDavid Hildenbrand return -EINVAL; 124415c9705fSDavid Hildenbrand 124515c9705fSDavid Hildenbrand mutex_lock(&kvm->lock); 12462f8311c9SChristian Borntraeger if (kvm->created_vcpus) { 12472f8311c9SChristian Borntraeger mutex_unlock(&kvm->lock); 12482f8311c9SChristian Borntraeger return -EBUSY; 12492f8311c9SChristian Borntraeger } 125015c9705fSDavid Hildenbrand bitmap_copy(kvm->arch.cpu_feat, (unsigned long *) data.feat, 125115c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 125215c9705fSDavid Hildenbrand mutex_unlock(&kvm->lock); 12532f8311c9SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx", 12542f8311c9SChristian Borntraeger data.feat[0], 12552f8311c9SChristian Borntraeger data.feat[1], 12562f8311c9SChristian Borntraeger data.feat[2]); 12572f8311c9SChristian Borntraeger return 0; 125815c9705fSDavid Hildenbrand } 125915c9705fSDavid Hildenbrand 12600a763c78SDavid Hildenbrand static int kvm_s390_set_processor_subfunc(struct kvm *kvm, 12610a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 12620a763c78SDavid Hildenbrand { 12630a763c78SDavid Hildenbrand /* 12640a763c78SDavid Hildenbrand * Once supported by kernel + hw, we have to store the subfunctions 12650a763c78SDavid Hildenbrand * in kvm->arch and remember that user space configured them. 12660a763c78SDavid Hildenbrand */ 12670a763c78SDavid Hildenbrand return -ENXIO; 12680a763c78SDavid Hildenbrand } 12690a763c78SDavid Hildenbrand 1270658b6edaSMichael Mueller static int kvm_s390_set_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 1271658b6edaSMichael Mueller { 1272658b6edaSMichael Mueller int ret = -ENXIO; 1273658b6edaSMichael Mueller 1274658b6edaSMichael Mueller switch (attr->attr) { 1275658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 1276658b6edaSMichael Mueller ret = kvm_s390_set_processor(kvm, attr); 1277658b6edaSMichael Mueller break; 127815c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 127915c9705fSDavid Hildenbrand ret = kvm_s390_set_processor_feat(kvm, attr); 128015c9705fSDavid Hildenbrand break; 12810a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 12820a763c78SDavid Hildenbrand ret = kvm_s390_set_processor_subfunc(kvm, attr); 12830a763c78SDavid Hildenbrand break; 1284658b6edaSMichael Mueller } 1285658b6edaSMichael Mueller return ret; 1286658b6edaSMichael Mueller } 1287658b6edaSMichael Mueller 1288658b6edaSMichael Mueller static int kvm_s390_get_processor(struct kvm *kvm, struct kvm_device_attr *attr) 1289658b6edaSMichael Mueller { 1290658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 1291658b6edaSMichael Mueller int ret = 0; 1292658b6edaSMichael Mueller 1293658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 1294658b6edaSMichael Mueller if (!proc) { 1295658b6edaSMichael Mueller ret = -ENOMEM; 1296658b6edaSMichael Mueller goto out; 1297658b6edaSMichael Mueller } 12989bb0ec09SDavid Hildenbrand proc->cpuid = kvm->arch.model.cpuid; 1299658b6edaSMichael Mueller proc->ibc = kvm->arch.model.ibc; 1300c54f0d6aSDavid Hildenbrand memcpy(&proc->fac_list, kvm->arch.model.fac_list, 1301c54f0d6aSDavid Hildenbrand S390_ARCH_FAC_LIST_SIZE_BYTE); 1302a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest ibc: 0x%4.4x, guest cpuid: 0x%16.16llx", 1303a8c39dd7SChristian Borntraeger kvm->arch.model.ibc, 1304a8c39dd7SChristian Borntraeger kvm->arch.model.cpuid); 1305a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest faclist: 0x%16.16llx.%16.16llx.%16.16llx", 1306a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[0], 1307a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[1], 1308a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[2]); 1309658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, proc, sizeof(*proc))) 1310658b6edaSMichael Mueller ret = -EFAULT; 1311658b6edaSMichael Mueller kfree(proc); 1312658b6edaSMichael Mueller out: 1313658b6edaSMichael Mueller return ret; 1314658b6edaSMichael Mueller } 1315658b6edaSMichael Mueller 1316658b6edaSMichael Mueller static int kvm_s390_get_machine(struct kvm *kvm, struct kvm_device_attr *attr) 1317658b6edaSMichael Mueller { 1318658b6edaSMichael Mueller struct kvm_s390_vm_cpu_machine *mach; 1319658b6edaSMichael Mueller int ret = 0; 1320658b6edaSMichael Mueller 1321658b6edaSMichael Mueller mach = kzalloc(sizeof(*mach), GFP_KERNEL); 1322658b6edaSMichael Mueller if (!mach) { 1323658b6edaSMichael Mueller ret = -ENOMEM; 1324658b6edaSMichael Mueller goto out; 1325658b6edaSMichael Mueller } 1326658b6edaSMichael Mueller get_cpu_id((struct cpuid *) &mach->cpuid); 132737c5f6c8SDavid Hildenbrand mach->ibc = sclp.ibc; 1328c54f0d6aSDavid Hildenbrand memcpy(&mach->fac_mask, kvm->arch.model.fac_mask, 1329981467c9SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 1330658b6edaSMichael Mueller memcpy((unsigned long *)&mach->fac_list, S390_lowcore.stfle_fac_list, 133104478197SChristian Borntraeger sizeof(S390_lowcore.stfle_fac_list)); 1332a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host ibc: 0x%4.4x, host cpuid: 0x%16.16llx", 1333a8c39dd7SChristian Borntraeger kvm->arch.model.ibc, 1334a8c39dd7SChristian Borntraeger kvm->arch.model.cpuid); 1335a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host facmask: 0x%16.16llx.%16.16llx.%16.16llx", 1336a8c39dd7SChristian Borntraeger mach->fac_mask[0], 1337a8c39dd7SChristian Borntraeger mach->fac_mask[1], 1338a8c39dd7SChristian Borntraeger mach->fac_mask[2]); 1339a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host faclist: 0x%16.16llx.%16.16llx.%16.16llx", 1340a8c39dd7SChristian Borntraeger mach->fac_list[0], 1341a8c39dd7SChristian Borntraeger mach->fac_list[1], 1342a8c39dd7SChristian Borntraeger mach->fac_list[2]); 1343658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, mach, sizeof(*mach))) 1344658b6edaSMichael Mueller ret = -EFAULT; 1345658b6edaSMichael Mueller kfree(mach); 1346658b6edaSMichael Mueller out: 1347658b6edaSMichael Mueller return ret; 1348658b6edaSMichael Mueller } 1349658b6edaSMichael Mueller 135015c9705fSDavid Hildenbrand static int kvm_s390_get_processor_feat(struct kvm *kvm, 135115c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 135215c9705fSDavid Hildenbrand { 135315c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 135415c9705fSDavid Hildenbrand 135515c9705fSDavid Hildenbrand bitmap_copy((unsigned long *) data.feat, kvm->arch.cpu_feat, 135615c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 135715c9705fSDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &data, sizeof(data))) 135815c9705fSDavid Hildenbrand return -EFAULT; 13592f8311c9SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx", 13602f8311c9SChristian Borntraeger data.feat[0], 13612f8311c9SChristian Borntraeger data.feat[1], 13622f8311c9SChristian Borntraeger data.feat[2]); 136315c9705fSDavid Hildenbrand return 0; 136415c9705fSDavid Hildenbrand } 136515c9705fSDavid Hildenbrand 136615c9705fSDavid Hildenbrand static int kvm_s390_get_machine_feat(struct kvm *kvm, 136715c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 136815c9705fSDavid Hildenbrand { 136915c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 137015c9705fSDavid Hildenbrand 137115c9705fSDavid Hildenbrand bitmap_copy((unsigned long *) data.feat, 137215c9705fSDavid Hildenbrand kvm_s390_available_cpu_feat, 137315c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 137415c9705fSDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &data, sizeof(data))) 137515c9705fSDavid Hildenbrand return -EFAULT; 13762f8311c9SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx", 13772f8311c9SChristian Borntraeger data.feat[0], 13782f8311c9SChristian Borntraeger data.feat[1], 13792f8311c9SChristian Borntraeger data.feat[2]); 138015c9705fSDavid Hildenbrand return 0; 138115c9705fSDavid Hildenbrand } 138215c9705fSDavid Hildenbrand 13830a763c78SDavid Hildenbrand static int kvm_s390_get_processor_subfunc(struct kvm *kvm, 13840a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 13850a763c78SDavid Hildenbrand { 13860a763c78SDavid Hildenbrand /* 13870a763c78SDavid Hildenbrand * Once we can actually configure subfunctions (kernel + hw support), 13880a763c78SDavid Hildenbrand * we have to check if they were already set by user space, if so copy 13890a763c78SDavid Hildenbrand * them from kvm->arch. 13900a763c78SDavid Hildenbrand */ 13910a763c78SDavid Hildenbrand return -ENXIO; 13920a763c78SDavid Hildenbrand } 13930a763c78SDavid Hildenbrand 13940a763c78SDavid Hildenbrand static int kvm_s390_get_machine_subfunc(struct kvm *kvm, 13950a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 13960a763c78SDavid Hildenbrand { 13970a763c78SDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &kvm_s390_available_subfunc, 13980a763c78SDavid Hildenbrand sizeof(struct kvm_s390_vm_cpu_subfunc))) 13990a763c78SDavid Hildenbrand return -EFAULT; 14000a763c78SDavid Hildenbrand return 0; 14010a763c78SDavid Hildenbrand } 1402658b6edaSMichael Mueller static int kvm_s390_get_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 1403658b6edaSMichael Mueller { 1404658b6edaSMichael Mueller int ret = -ENXIO; 1405658b6edaSMichael Mueller 1406658b6edaSMichael Mueller switch (attr->attr) { 1407658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 1408658b6edaSMichael Mueller ret = kvm_s390_get_processor(kvm, attr); 1409658b6edaSMichael Mueller break; 1410658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 1411658b6edaSMichael Mueller ret = kvm_s390_get_machine(kvm, attr); 1412658b6edaSMichael Mueller break; 141315c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 141415c9705fSDavid Hildenbrand ret = kvm_s390_get_processor_feat(kvm, attr); 141515c9705fSDavid Hildenbrand break; 141615c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_FEAT: 141715c9705fSDavid Hildenbrand ret = kvm_s390_get_machine_feat(kvm, attr); 141815c9705fSDavid Hildenbrand break; 14190a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 14200a763c78SDavid Hildenbrand ret = kvm_s390_get_processor_subfunc(kvm, attr); 14210a763c78SDavid Hildenbrand break; 14220a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_SUBFUNC: 14230a763c78SDavid Hildenbrand ret = kvm_s390_get_machine_subfunc(kvm, attr); 14240a763c78SDavid Hildenbrand break; 1425658b6edaSMichael Mueller } 1426658b6edaSMichael Mueller return ret; 1427658b6edaSMichael Mueller } 1428658b6edaSMichael Mueller 1429f2061656SDominik Dingel static int kvm_s390_vm_set_attr(struct kvm *kvm, struct kvm_device_attr *attr) 1430f2061656SDominik Dingel { 1431f2061656SDominik Dingel int ret; 1432f2061656SDominik Dingel 1433f2061656SDominik Dingel switch (attr->group) { 14344f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 14358c0a7ce6SDominik Dingel ret = kvm_s390_set_mem_control(kvm, attr); 14364f718eabSDominik Dingel break; 143772f25020SJason J. Herne case KVM_S390_VM_TOD: 143872f25020SJason J. Herne ret = kvm_s390_set_tod(kvm, attr); 143972f25020SJason J. Herne break; 1440658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 1441658b6edaSMichael Mueller ret = kvm_s390_set_cpu_model(kvm, attr); 1442658b6edaSMichael Mueller break; 1443a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 1444a374e892STony Krowiak ret = kvm_s390_vm_set_crypto(kvm, attr); 1445a374e892STony Krowiak break; 1446190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION: 1447190df4a2SClaudio Imbrenda ret = kvm_s390_vm_set_migration(kvm, attr); 1448190df4a2SClaudio Imbrenda break; 1449f2061656SDominik Dingel default: 1450f2061656SDominik Dingel ret = -ENXIO; 1451f2061656SDominik Dingel break; 1452f2061656SDominik Dingel } 1453f2061656SDominik Dingel 1454f2061656SDominik Dingel return ret; 1455f2061656SDominik Dingel } 1456f2061656SDominik Dingel 1457f2061656SDominik Dingel static int kvm_s390_vm_get_attr(struct kvm *kvm, struct kvm_device_attr *attr) 1458f2061656SDominik Dingel { 14598c0a7ce6SDominik Dingel int ret; 14608c0a7ce6SDominik Dingel 14618c0a7ce6SDominik Dingel switch (attr->group) { 14628c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_CTRL: 14638c0a7ce6SDominik Dingel ret = kvm_s390_get_mem_control(kvm, attr); 14648c0a7ce6SDominik Dingel break; 146572f25020SJason J. Herne case KVM_S390_VM_TOD: 146672f25020SJason J. Herne ret = kvm_s390_get_tod(kvm, attr); 146772f25020SJason J. Herne break; 1468658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 1469658b6edaSMichael Mueller ret = kvm_s390_get_cpu_model(kvm, attr); 1470658b6edaSMichael Mueller break; 1471190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION: 1472190df4a2SClaudio Imbrenda ret = kvm_s390_vm_get_migration(kvm, attr); 1473190df4a2SClaudio Imbrenda break; 14748c0a7ce6SDominik Dingel default: 14758c0a7ce6SDominik Dingel ret = -ENXIO; 14768c0a7ce6SDominik Dingel break; 14778c0a7ce6SDominik Dingel } 14788c0a7ce6SDominik Dingel 14798c0a7ce6SDominik Dingel return ret; 1480f2061656SDominik Dingel } 1481f2061656SDominik Dingel 1482f2061656SDominik Dingel static int kvm_s390_vm_has_attr(struct kvm *kvm, struct kvm_device_attr *attr) 1483f2061656SDominik Dingel { 1484f2061656SDominik Dingel int ret; 1485f2061656SDominik Dingel 1486f2061656SDominik Dingel switch (attr->group) { 14874f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 14884f718eabSDominik Dingel switch (attr->attr) { 14894f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 14904f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 1491f9cbd9b0SDavid Hildenbrand ret = sclp.has_cmma ? 0 : -ENXIO; 1492f9cbd9b0SDavid Hildenbrand break; 14938c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 14944f718eabSDominik Dingel ret = 0; 14954f718eabSDominik Dingel break; 14964f718eabSDominik Dingel default: 14974f718eabSDominik Dingel ret = -ENXIO; 14984f718eabSDominik Dingel break; 14994f718eabSDominik Dingel } 15004f718eabSDominik Dingel break; 150172f25020SJason J. Herne case KVM_S390_VM_TOD: 150272f25020SJason J. Herne switch (attr->attr) { 150372f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 150472f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 150572f25020SJason J. Herne ret = 0; 150672f25020SJason J. Herne break; 150772f25020SJason J. Herne default: 150872f25020SJason J. Herne ret = -ENXIO; 150972f25020SJason J. Herne break; 151072f25020SJason J. Herne } 151172f25020SJason J. Herne break; 1512658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 1513658b6edaSMichael Mueller switch (attr->attr) { 1514658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 1515658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 151615c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 151715c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_FEAT: 15180a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_SUBFUNC: 1519658b6edaSMichael Mueller ret = 0; 1520658b6edaSMichael Mueller break; 15210a763c78SDavid Hildenbrand /* configuring subfunctions is not supported yet */ 15220a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 1523658b6edaSMichael Mueller default: 1524658b6edaSMichael Mueller ret = -ENXIO; 1525658b6edaSMichael Mueller break; 1526658b6edaSMichael Mueller } 1527658b6edaSMichael Mueller break; 1528a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 1529a374e892STony Krowiak switch (attr->attr) { 1530a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 1531a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 1532a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 1533a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 1534a374e892STony Krowiak ret = 0; 1535a374e892STony Krowiak break; 153637940fb0STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_APIE: 153737940fb0STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_APIE: 153837940fb0STony Krowiak ret = ap_instructions_available() ? 0 : -ENXIO; 153937940fb0STony Krowiak break; 1540a374e892STony Krowiak default: 1541a374e892STony Krowiak ret = -ENXIO; 1542a374e892STony Krowiak break; 1543a374e892STony Krowiak } 1544a374e892STony Krowiak break; 1545190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION: 1546190df4a2SClaudio Imbrenda ret = 0; 1547190df4a2SClaudio Imbrenda break; 1548f2061656SDominik Dingel default: 1549f2061656SDominik Dingel ret = -ENXIO; 1550f2061656SDominik Dingel break; 1551f2061656SDominik Dingel } 1552f2061656SDominik Dingel 1553f2061656SDominik Dingel return ret; 1554f2061656SDominik Dingel } 1555f2061656SDominik Dingel 155630ee2a98SJason J. Herne static long kvm_s390_get_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 155730ee2a98SJason J. Herne { 155830ee2a98SJason J. Herne uint8_t *keys; 155930ee2a98SJason J. Herne uint64_t hva; 15604f899147SChristian Borntraeger int srcu_idx, i, r = 0; 156130ee2a98SJason J. Herne 156230ee2a98SJason J. Herne if (args->flags != 0) 156330ee2a98SJason J. Herne return -EINVAL; 156430ee2a98SJason J. Herne 156530ee2a98SJason J. Herne /* Is this guest using storage keys? */ 156655531b74SJanosch Frank if (!mm_uses_skeys(current->mm)) 156730ee2a98SJason J. Herne return KVM_S390_GET_SKEYS_NONE; 156830ee2a98SJason J. Herne 156930ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 157030ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 157130ee2a98SJason J. Herne return -EINVAL; 157230ee2a98SJason J. Herne 1573752ade68SMichal Hocko keys = kvmalloc_array(args->count, sizeof(uint8_t), GFP_KERNEL); 157430ee2a98SJason J. Herne if (!keys) 157530ee2a98SJason J. Herne return -ENOMEM; 157630ee2a98SJason J. Herne 1577d3ed1ceeSMartin Schwidefsky down_read(¤t->mm->mmap_sem); 15784f899147SChristian Borntraeger srcu_idx = srcu_read_lock(&kvm->srcu); 157930ee2a98SJason J. Herne for (i = 0; i < args->count; i++) { 158030ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 158130ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 158230ee2a98SJason J. Herne r = -EFAULT; 1583d3ed1ceeSMartin Schwidefsky break; 158430ee2a98SJason J. Herne } 158530ee2a98SJason J. Herne 1586154c8c19SDavid Hildenbrand r = get_guest_storage_key(current->mm, hva, &keys[i]); 1587154c8c19SDavid Hildenbrand if (r) 1588d3ed1ceeSMartin Schwidefsky break; 158930ee2a98SJason J. Herne } 15904f899147SChristian Borntraeger srcu_read_unlock(&kvm->srcu, srcu_idx); 1591d3ed1ceeSMartin Schwidefsky up_read(¤t->mm->mmap_sem); 159230ee2a98SJason J. Herne 1593d3ed1ceeSMartin Schwidefsky if (!r) { 159430ee2a98SJason J. Herne r = copy_to_user((uint8_t __user *)args->skeydata_addr, keys, 159530ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 159630ee2a98SJason J. Herne if (r) 159730ee2a98SJason J. Herne r = -EFAULT; 1598d3ed1ceeSMartin Schwidefsky } 1599d3ed1ceeSMartin Schwidefsky 160030ee2a98SJason J. Herne kvfree(keys); 160130ee2a98SJason J. Herne return r; 160230ee2a98SJason J. Herne } 160330ee2a98SJason J. Herne 160430ee2a98SJason J. Herne static long kvm_s390_set_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 160530ee2a98SJason J. Herne { 160630ee2a98SJason J. Herne uint8_t *keys; 160730ee2a98SJason J. Herne uint64_t hva; 16084f899147SChristian Borntraeger int srcu_idx, i, r = 0; 1609bd096f64SJanosch Frank bool unlocked; 161030ee2a98SJason J. Herne 161130ee2a98SJason J. Herne if (args->flags != 0) 161230ee2a98SJason J. Herne return -EINVAL; 161330ee2a98SJason J. Herne 161430ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 161530ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 161630ee2a98SJason J. Herne return -EINVAL; 161730ee2a98SJason J. Herne 1618752ade68SMichal Hocko keys = kvmalloc_array(args->count, sizeof(uint8_t), GFP_KERNEL); 161930ee2a98SJason J. Herne if (!keys) 162030ee2a98SJason J. Herne return -ENOMEM; 162130ee2a98SJason J. Herne 162230ee2a98SJason J. Herne r = copy_from_user(keys, (uint8_t __user *)args->skeydata_addr, 162330ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 162430ee2a98SJason J. Herne if (r) { 162530ee2a98SJason J. Herne r = -EFAULT; 162630ee2a98SJason J. Herne goto out; 162730ee2a98SJason J. Herne } 162830ee2a98SJason J. Herne 162930ee2a98SJason J. Herne /* Enable storage key handling for the guest */ 163014d4a425SDominik Dingel r = s390_enable_skey(); 163114d4a425SDominik Dingel if (r) 163214d4a425SDominik Dingel goto out; 163330ee2a98SJason J. Herne 1634bd096f64SJanosch Frank i = 0; 1635d3ed1ceeSMartin Schwidefsky down_read(¤t->mm->mmap_sem); 16364f899147SChristian Borntraeger srcu_idx = srcu_read_lock(&kvm->srcu); 1637bd096f64SJanosch Frank while (i < args->count) { 1638bd096f64SJanosch Frank unlocked = false; 163930ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 164030ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 164130ee2a98SJason J. Herne r = -EFAULT; 1642d3ed1ceeSMartin Schwidefsky break; 164330ee2a98SJason J. Herne } 164430ee2a98SJason J. Herne 164530ee2a98SJason J. Herne /* Lowest order bit is reserved */ 164630ee2a98SJason J. Herne if (keys[i] & 0x01) { 164730ee2a98SJason J. Herne r = -EINVAL; 1648d3ed1ceeSMartin Schwidefsky break; 164930ee2a98SJason J. Herne } 165030ee2a98SJason J. Herne 1651fe69eabfSDavid Hildenbrand r = set_guest_storage_key(current->mm, hva, keys[i], 0); 1652bd096f64SJanosch Frank if (r) { 1653bd096f64SJanosch Frank r = fixup_user_fault(current, current->mm, hva, 1654bd096f64SJanosch Frank FAULT_FLAG_WRITE, &unlocked); 165530ee2a98SJason J. Herne if (r) 1656d3ed1ceeSMartin Schwidefsky break; 165730ee2a98SJason J. Herne } 1658bd096f64SJanosch Frank if (!r) 1659bd096f64SJanosch Frank i++; 1660bd096f64SJanosch Frank } 16614f899147SChristian Borntraeger srcu_read_unlock(&kvm->srcu, srcu_idx); 1662d3ed1ceeSMartin Schwidefsky up_read(¤t->mm->mmap_sem); 166330ee2a98SJason J. Herne out: 166430ee2a98SJason J. Herne kvfree(keys); 166530ee2a98SJason J. Herne return r; 166630ee2a98SJason J. Herne } 166730ee2a98SJason J. Herne 16684036e387SClaudio Imbrenda /* 16694036e387SClaudio Imbrenda * Base address and length must be sent at the start of each block, therefore 16704036e387SClaudio Imbrenda * it's cheaper to send some clean data, as long as it's less than the size of 16714036e387SClaudio Imbrenda * two longs. 16724036e387SClaudio Imbrenda */ 16734036e387SClaudio Imbrenda #define KVM_S390_MAX_BIT_DISTANCE (2 * sizeof(void *)) 16744036e387SClaudio Imbrenda /* for consistency */ 16754036e387SClaudio Imbrenda #define KVM_S390_CMMA_SIZE_MAX ((u32)KVM_S390_SKEYS_MAX) 16764036e387SClaudio Imbrenda 16774036e387SClaudio Imbrenda /* 1678afdad616SClaudio Imbrenda * Similar to gfn_to_memslot, but returns the index of a memslot also when the 1679afdad616SClaudio Imbrenda * address falls in a hole. In that case the index of one of the memslots 1680afdad616SClaudio Imbrenda * bordering the hole is returned. 1681afdad616SClaudio Imbrenda */ 1682afdad616SClaudio Imbrenda static int gfn_to_memslot_approx(struct kvm_memslots *slots, gfn_t gfn) 1683afdad616SClaudio Imbrenda { 1684afdad616SClaudio Imbrenda int start = 0, end = slots->used_slots; 1685afdad616SClaudio Imbrenda int slot = atomic_read(&slots->lru_slot); 1686afdad616SClaudio Imbrenda struct kvm_memory_slot *memslots = slots->memslots; 1687afdad616SClaudio Imbrenda 1688afdad616SClaudio Imbrenda if (gfn >= memslots[slot].base_gfn && 1689afdad616SClaudio Imbrenda gfn < memslots[slot].base_gfn + memslots[slot].npages) 1690afdad616SClaudio Imbrenda return slot; 1691afdad616SClaudio Imbrenda 1692afdad616SClaudio Imbrenda while (start < end) { 1693afdad616SClaudio Imbrenda slot = start + (end - start) / 2; 1694afdad616SClaudio Imbrenda 1695afdad616SClaudio Imbrenda if (gfn >= memslots[slot].base_gfn) 1696afdad616SClaudio Imbrenda end = slot; 1697afdad616SClaudio Imbrenda else 1698afdad616SClaudio Imbrenda start = slot + 1; 1699afdad616SClaudio Imbrenda } 1700afdad616SClaudio Imbrenda 1701afdad616SClaudio Imbrenda if (gfn >= memslots[start].base_gfn && 1702afdad616SClaudio Imbrenda gfn < memslots[start].base_gfn + memslots[start].npages) { 1703afdad616SClaudio Imbrenda atomic_set(&slots->lru_slot, start); 1704afdad616SClaudio Imbrenda } 1705afdad616SClaudio Imbrenda 1706afdad616SClaudio Imbrenda return start; 1707afdad616SClaudio Imbrenda } 1708afdad616SClaudio Imbrenda 1709afdad616SClaudio Imbrenda static int kvm_s390_peek_cmma(struct kvm *kvm, struct kvm_s390_cmma_log *args, 1710afdad616SClaudio Imbrenda u8 *res, unsigned long bufsize) 1711afdad616SClaudio Imbrenda { 1712afdad616SClaudio Imbrenda unsigned long pgstev, hva, cur_gfn = args->start_gfn; 1713afdad616SClaudio Imbrenda 1714afdad616SClaudio Imbrenda args->count = 0; 1715afdad616SClaudio Imbrenda while (args->count < bufsize) { 1716afdad616SClaudio Imbrenda hva = gfn_to_hva(kvm, cur_gfn); 1717afdad616SClaudio Imbrenda /* 1718afdad616SClaudio Imbrenda * We return an error if the first value was invalid, but we 1719afdad616SClaudio Imbrenda * return successfully if at least one value was copied. 1720afdad616SClaudio Imbrenda */ 1721afdad616SClaudio Imbrenda if (kvm_is_error_hva(hva)) 1722afdad616SClaudio Imbrenda return args->count ? 0 : -EFAULT; 1723afdad616SClaudio Imbrenda if (get_pgste(kvm->mm, hva, &pgstev) < 0) 1724afdad616SClaudio Imbrenda pgstev = 0; 1725afdad616SClaudio Imbrenda res[args->count++] = (pgstev >> 24) & 0x43; 1726afdad616SClaudio Imbrenda cur_gfn++; 1727afdad616SClaudio Imbrenda } 1728afdad616SClaudio Imbrenda 1729afdad616SClaudio Imbrenda return 0; 1730afdad616SClaudio Imbrenda } 1731afdad616SClaudio Imbrenda 1732afdad616SClaudio Imbrenda static unsigned long kvm_s390_next_dirty_cmma(struct kvm_memslots *slots, 1733afdad616SClaudio Imbrenda unsigned long cur_gfn) 1734afdad616SClaudio Imbrenda { 1735afdad616SClaudio Imbrenda int slotidx = gfn_to_memslot_approx(slots, cur_gfn); 1736afdad616SClaudio Imbrenda struct kvm_memory_slot *ms = slots->memslots + slotidx; 1737afdad616SClaudio Imbrenda unsigned long ofs = cur_gfn - ms->base_gfn; 1738afdad616SClaudio Imbrenda 1739afdad616SClaudio Imbrenda if (ms->base_gfn + ms->npages <= cur_gfn) { 1740afdad616SClaudio Imbrenda slotidx--; 1741afdad616SClaudio Imbrenda /* If we are above the highest slot, wrap around */ 1742afdad616SClaudio Imbrenda if (slotidx < 0) 1743afdad616SClaudio Imbrenda slotidx = slots->used_slots - 1; 1744afdad616SClaudio Imbrenda 1745afdad616SClaudio Imbrenda ms = slots->memslots + slotidx; 1746afdad616SClaudio Imbrenda ofs = 0; 1747afdad616SClaudio Imbrenda } 1748afdad616SClaudio Imbrenda ofs = find_next_bit(kvm_second_dirty_bitmap(ms), ms->npages, ofs); 1749afdad616SClaudio Imbrenda while ((slotidx > 0) && (ofs >= ms->npages)) { 1750afdad616SClaudio Imbrenda slotidx--; 1751afdad616SClaudio Imbrenda ms = slots->memslots + slotidx; 1752afdad616SClaudio Imbrenda ofs = find_next_bit(kvm_second_dirty_bitmap(ms), ms->npages, 0); 1753afdad616SClaudio Imbrenda } 1754afdad616SClaudio Imbrenda return ms->base_gfn + ofs; 1755afdad616SClaudio Imbrenda } 1756afdad616SClaudio Imbrenda 1757afdad616SClaudio Imbrenda static int kvm_s390_get_cmma(struct kvm *kvm, struct kvm_s390_cmma_log *args, 1758afdad616SClaudio Imbrenda u8 *res, unsigned long bufsize) 1759afdad616SClaudio Imbrenda { 1760afdad616SClaudio Imbrenda unsigned long mem_end, cur_gfn, next_gfn, hva, pgstev; 1761afdad616SClaudio Imbrenda struct kvm_memslots *slots = kvm_memslots(kvm); 1762afdad616SClaudio Imbrenda struct kvm_memory_slot *ms; 1763afdad616SClaudio Imbrenda 1764afdad616SClaudio Imbrenda cur_gfn = kvm_s390_next_dirty_cmma(slots, args->start_gfn); 1765afdad616SClaudio Imbrenda ms = gfn_to_memslot(kvm, cur_gfn); 1766afdad616SClaudio Imbrenda args->count = 0; 1767afdad616SClaudio Imbrenda args->start_gfn = cur_gfn; 1768afdad616SClaudio Imbrenda if (!ms) 1769afdad616SClaudio Imbrenda return 0; 1770afdad616SClaudio Imbrenda next_gfn = kvm_s390_next_dirty_cmma(slots, cur_gfn + 1); 1771afdad616SClaudio Imbrenda mem_end = slots->memslots[0].base_gfn + slots->memslots[0].npages; 1772afdad616SClaudio Imbrenda 1773afdad616SClaudio Imbrenda while (args->count < bufsize) { 1774afdad616SClaudio Imbrenda hva = gfn_to_hva(kvm, cur_gfn); 1775afdad616SClaudio Imbrenda if (kvm_is_error_hva(hva)) 1776afdad616SClaudio Imbrenda return 0; 1777afdad616SClaudio Imbrenda /* Decrement only if we actually flipped the bit to 0 */ 1778afdad616SClaudio Imbrenda if (test_and_clear_bit(cur_gfn - ms->base_gfn, kvm_second_dirty_bitmap(ms))) 1779afdad616SClaudio Imbrenda atomic64_dec(&kvm->arch.cmma_dirty_pages); 1780afdad616SClaudio Imbrenda if (get_pgste(kvm->mm, hva, &pgstev) < 0) 1781afdad616SClaudio Imbrenda pgstev = 0; 1782afdad616SClaudio Imbrenda /* Save the value */ 1783afdad616SClaudio Imbrenda res[args->count++] = (pgstev >> 24) & 0x43; 1784afdad616SClaudio Imbrenda /* If the next bit is too far away, stop. */ 1785afdad616SClaudio Imbrenda if (next_gfn > cur_gfn + KVM_S390_MAX_BIT_DISTANCE) 1786afdad616SClaudio Imbrenda return 0; 1787afdad616SClaudio Imbrenda /* If we reached the previous "next", find the next one */ 1788afdad616SClaudio Imbrenda if (cur_gfn == next_gfn) 1789afdad616SClaudio Imbrenda next_gfn = kvm_s390_next_dirty_cmma(slots, cur_gfn + 1); 1790afdad616SClaudio Imbrenda /* Reached the end of memory or of the buffer, stop */ 1791afdad616SClaudio Imbrenda if ((next_gfn >= mem_end) || 1792afdad616SClaudio Imbrenda (next_gfn - args->start_gfn >= bufsize)) 1793afdad616SClaudio Imbrenda return 0; 1794afdad616SClaudio Imbrenda cur_gfn++; 1795afdad616SClaudio Imbrenda /* Reached the end of the current memslot, take the next one. */ 1796afdad616SClaudio Imbrenda if (cur_gfn - ms->base_gfn >= ms->npages) { 1797afdad616SClaudio Imbrenda ms = gfn_to_memslot(kvm, cur_gfn); 1798afdad616SClaudio Imbrenda if (!ms) 1799afdad616SClaudio Imbrenda return 0; 1800afdad616SClaudio Imbrenda } 1801afdad616SClaudio Imbrenda } 1802afdad616SClaudio Imbrenda return 0; 1803afdad616SClaudio Imbrenda } 1804afdad616SClaudio Imbrenda 1805afdad616SClaudio Imbrenda /* 18064036e387SClaudio Imbrenda * This function searches for the next page with dirty CMMA attributes, and 18074036e387SClaudio Imbrenda * saves the attributes in the buffer up to either the end of the buffer or 18084036e387SClaudio Imbrenda * until a block of at least KVM_S390_MAX_BIT_DISTANCE clean bits is found; 18094036e387SClaudio Imbrenda * no trailing clean bytes are saved. 18104036e387SClaudio Imbrenda * In case no dirty bits were found, or if CMMA was not enabled or used, the 18114036e387SClaudio Imbrenda * output buffer will indicate 0 as length. 18124036e387SClaudio Imbrenda */ 18134036e387SClaudio Imbrenda static int kvm_s390_get_cmma_bits(struct kvm *kvm, 18144036e387SClaudio Imbrenda struct kvm_s390_cmma_log *args) 18154036e387SClaudio Imbrenda { 1816afdad616SClaudio Imbrenda unsigned long bufsize; 1817afdad616SClaudio Imbrenda int srcu_idx, peek, ret; 1818afdad616SClaudio Imbrenda u8 *values; 18194036e387SClaudio Imbrenda 1820afdad616SClaudio Imbrenda if (!kvm->arch.use_cmma) 18214036e387SClaudio Imbrenda return -ENXIO; 18224036e387SClaudio Imbrenda /* Invalid/unsupported flags were specified */ 18234036e387SClaudio Imbrenda if (args->flags & ~KVM_S390_CMMA_PEEK) 18244036e387SClaudio Imbrenda return -EINVAL; 18254036e387SClaudio Imbrenda /* Migration mode query, and we are not doing a migration */ 18264036e387SClaudio Imbrenda peek = !!(args->flags & KVM_S390_CMMA_PEEK); 1827afdad616SClaudio Imbrenda if (!peek && !kvm->arch.migration_mode) 18284036e387SClaudio Imbrenda return -EINVAL; 18294036e387SClaudio Imbrenda /* CMMA is disabled or was not used, or the buffer has length zero */ 18304036e387SClaudio Imbrenda bufsize = min(args->count, KVM_S390_CMMA_SIZE_MAX); 1831c9f0a2b8SJanosch Frank if (!bufsize || !kvm->mm->context.uses_cmm) { 18324036e387SClaudio Imbrenda memset(args, 0, sizeof(*args)); 18334036e387SClaudio Imbrenda return 0; 18344036e387SClaudio Imbrenda } 18354036e387SClaudio Imbrenda /* We are not peeking, and there are no dirty pages */ 1836afdad616SClaudio Imbrenda if (!peek && !atomic64_read(&kvm->arch.cmma_dirty_pages)) { 18374036e387SClaudio Imbrenda memset(args, 0, sizeof(*args)); 18384036e387SClaudio Imbrenda return 0; 18394036e387SClaudio Imbrenda } 18404036e387SClaudio Imbrenda 1841afdad616SClaudio Imbrenda values = vmalloc(bufsize); 1842afdad616SClaudio Imbrenda if (!values) 18434036e387SClaudio Imbrenda return -ENOMEM; 18444036e387SClaudio Imbrenda 18454036e387SClaudio Imbrenda down_read(&kvm->mm->mmap_sem); 18464036e387SClaudio Imbrenda srcu_idx = srcu_read_lock(&kvm->srcu); 1847afdad616SClaudio Imbrenda if (peek) 1848afdad616SClaudio Imbrenda ret = kvm_s390_peek_cmma(kvm, args, values, bufsize); 1849afdad616SClaudio Imbrenda else 1850afdad616SClaudio Imbrenda ret = kvm_s390_get_cmma(kvm, args, values, bufsize); 18514036e387SClaudio Imbrenda srcu_read_unlock(&kvm->srcu, srcu_idx); 18524036e387SClaudio Imbrenda up_read(&kvm->mm->mmap_sem); 18534036e387SClaudio Imbrenda 1854afdad616SClaudio Imbrenda if (kvm->arch.migration_mode) 1855afdad616SClaudio Imbrenda args->remaining = atomic64_read(&kvm->arch.cmma_dirty_pages); 1856afdad616SClaudio Imbrenda else 1857afdad616SClaudio Imbrenda args->remaining = 0; 18584036e387SClaudio Imbrenda 1859afdad616SClaudio Imbrenda if (copy_to_user((void __user *)args->values, values, args->count)) 1860afdad616SClaudio Imbrenda ret = -EFAULT; 1861afdad616SClaudio Imbrenda 1862afdad616SClaudio Imbrenda vfree(values); 1863afdad616SClaudio Imbrenda return ret; 18644036e387SClaudio Imbrenda } 18654036e387SClaudio Imbrenda 18664036e387SClaudio Imbrenda /* 18674036e387SClaudio Imbrenda * This function sets the CMMA attributes for the given pages. If the input 18684036e387SClaudio Imbrenda * buffer has zero length, no action is taken, otherwise the attributes are 1869c9f0a2b8SJanosch Frank * set and the mm->context.uses_cmm flag is set. 18704036e387SClaudio Imbrenda */ 18714036e387SClaudio Imbrenda static int kvm_s390_set_cmma_bits(struct kvm *kvm, 18724036e387SClaudio Imbrenda const struct kvm_s390_cmma_log *args) 18734036e387SClaudio Imbrenda { 18744036e387SClaudio Imbrenda unsigned long hva, mask, pgstev, i; 18754036e387SClaudio Imbrenda uint8_t *bits; 18764036e387SClaudio Imbrenda int srcu_idx, r = 0; 18774036e387SClaudio Imbrenda 18784036e387SClaudio Imbrenda mask = args->mask; 18794036e387SClaudio Imbrenda 18804036e387SClaudio Imbrenda if (!kvm->arch.use_cmma) 18814036e387SClaudio Imbrenda return -ENXIO; 18824036e387SClaudio Imbrenda /* invalid/unsupported flags */ 18834036e387SClaudio Imbrenda if (args->flags != 0) 18844036e387SClaudio Imbrenda return -EINVAL; 18854036e387SClaudio Imbrenda /* Enforce sane limit on memory allocation */ 18864036e387SClaudio Imbrenda if (args->count > KVM_S390_CMMA_SIZE_MAX) 18874036e387SClaudio Imbrenda return -EINVAL; 18884036e387SClaudio Imbrenda /* Nothing to do */ 18894036e387SClaudio Imbrenda if (args->count == 0) 18904036e387SClaudio Imbrenda return 0; 18914036e387SClaudio Imbrenda 189242bc47b3SKees Cook bits = vmalloc(array_size(sizeof(*bits), args->count)); 18934036e387SClaudio Imbrenda if (!bits) 18944036e387SClaudio Imbrenda return -ENOMEM; 18954036e387SClaudio Imbrenda 18964036e387SClaudio Imbrenda r = copy_from_user(bits, (void __user *)args->values, args->count); 18974036e387SClaudio Imbrenda if (r) { 18984036e387SClaudio Imbrenda r = -EFAULT; 18994036e387SClaudio Imbrenda goto out; 19004036e387SClaudio Imbrenda } 19014036e387SClaudio Imbrenda 19024036e387SClaudio Imbrenda down_read(&kvm->mm->mmap_sem); 19034036e387SClaudio Imbrenda srcu_idx = srcu_read_lock(&kvm->srcu); 19044036e387SClaudio Imbrenda for (i = 0; i < args->count; i++) { 19054036e387SClaudio Imbrenda hva = gfn_to_hva(kvm, args->start_gfn + i); 19064036e387SClaudio Imbrenda if (kvm_is_error_hva(hva)) { 19074036e387SClaudio Imbrenda r = -EFAULT; 19084036e387SClaudio Imbrenda break; 19094036e387SClaudio Imbrenda } 19104036e387SClaudio Imbrenda 19114036e387SClaudio Imbrenda pgstev = bits[i]; 19124036e387SClaudio Imbrenda pgstev = pgstev << 24; 19131bab1c02SClaudio Imbrenda mask &= _PGSTE_GPS_USAGE_MASK | _PGSTE_GPS_NODAT; 19144036e387SClaudio Imbrenda set_pgste_bits(kvm->mm, hva, mask, pgstev); 19154036e387SClaudio Imbrenda } 19164036e387SClaudio Imbrenda srcu_read_unlock(&kvm->srcu, srcu_idx); 19174036e387SClaudio Imbrenda up_read(&kvm->mm->mmap_sem); 19184036e387SClaudio Imbrenda 1919c9f0a2b8SJanosch Frank if (!kvm->mm->context.uses_cmm) { 19204036e387SClaudio Imbrenda down_write(&kvm->mm->mmap_sem); 1921c9f0a2b8SJanosch Frank kvm->mm->context.uses_cmm = 1; 19224036e387SClaudio Imbrenda up_write(&kvm->mm->mmap_sem); 19234036e387SClaudio Imbrenda } 19244036e387SClaudio Imbrenda out: 19254036e387SClaudio Imbrenda vfree(bits); 19264036e387SClaudio Imbrenda return r; 19274036e387SClaudio Imbrenda } 19284036e387SClaudio Imbrenda 1929b0c632dbSHeiko Carstens long kvm_arch_vm_ioctl(struct file *filp, 1930b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 1931b0c632dbSHeiko Carstens { 1932b0c632dbSHeiko Carstens struct kvm *kvm = filp->private_data; 1933b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 1934f2061656SDominik Dingel struct kvm_device_attr attr; 1935b0c632dbSHeiko Carstens int r; 1936b0c632dbSHeiko Carstens 1937b0c632dbSHeiko Carstens switch (ioctl) { 1938ba5c1e9bSCarsten Otte case KVM_S390_INTERRUPT: { 1939ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 1940ba5c1e9bSCarsten Otte 1941ba5c1e9bSCarsten Otte r = -EFAULT; 1942ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 1943ba5c1e9bSCarsten Otte break; 1944ba5c1e9bSCarsten Otte r = kvm_s390_inject_vm(kvm, &s390int); 1945ba5c1e9bSCarsten Otte break; 1946ba5c1e9bSCarsten Otte } 1947d938dc55SCornelia Huck case KVM_ENABLE_CAP: { 1948d938dc55SCornelia Huck struct kvm_enable_cap cap; 1949d938dc55SCornelia Huck r = -EFAULT; 1950d938dc55SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 1951d938dc55SCornelia Huck break; 1952d938dc55SCornelia Huck r = kvm_vm_ioctl_enable_cap(kvm, &cap); 1953d938dc55SCornelia Huck break; 1954d938dc55SCornelia Huck } 195584223598SCornelia Huck case KVM_CREATE_IRQCHIP: { 195684223598SCornelia Huck struct kvm_irq_routing_entry routing; 195784223598SCornelia Huck 195884223598SCornelia Huck r = -EINVAL; 195984223598SCornelia Huck if (kvm->arch.use_irqchip) { 196084223598SCornelia Huck /* Set up dummy routing. */ 196184223598SCornelia Huck memset(&routing, 0, sizeof(routing)); 1962152b2839SNicholas Krause r = kvm_set_irq_routing(kvm, &routing, 0, 0); 196384223598SCornelia Huck } 196484223598SCornelia Huck break; 196584223598SCornelia Huck } 1966f2061656SDominik Dingel case KVM_SET_DEVICE_ATTR: { 1967f2061656SDominik Dingel r = -EFAULT; 1968f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 1969f2061656SDominik Dingel break; 1970f2061656SDominik Dingel r = kvm_s390_vm_set_attr(kvm, &attr); 1971f2061656SDominik Dingel break; 1972f2061656SDominik Dingel } 1973f2061656SDominik Dingel case KVM_GET_DEVICE_ATTR: { 1974f2061656SDominik Dingel r = -EFAULT; 1975f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 1976f2061656SDominik Dingel break; 1977f2061656SDominik Dingel r = kvm_s390_vm_get_attr(kvm, &attr); 1978f2061656SDominik Dingel break; 1979f2061656SDominik Dingel } 1980f2061656SDominik Dingel case KVM_HAS_DEVICE_ATTR: { 1981f2061656SDominik Dingel r = -EFAULT; 1982f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 1983f2061656SDominik Dingel break; 1984f2061656SDominik Dingel r = kvm_s390_vm_has_attr(kvm, &attr); 1985f2061656SDominik Dingel break; 1986f2061656SDominik Dingel } 198730ee2a98SJason J. Herne case KVM_S390_GET_SKEYS: { 198830ee2a98SJason J. Herne struct kvm_s390_skeys args; 198930ee2a98SJason J. Herne 199030ee2a98SJason J. Herne r = -EFAULT; 199130ee2a98SJason J. Herne if (copy_from_user(&args, argp, 199230ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 199330ee2a98SJason J. Herne break; 199430ee2a98SJason J. Herne r = kvm_s390_get_skeys(kvm, &args); 199530ee2a98SJason J. Herne break; 199630ee2a98SJason J. Herne } 199730ee2a98SJason J. Herne case KVM_S390_SET_SKEYS: { 199830ee2a98SJason J. Herne struct kvm_s390_skeys args; 199930ee2a98SJason J. Herne 200030ee2a98SJason J. Herne r = -EFAULT; 200130ee2a98SJason J. Herne if (copy_from_user(&args, argp, 200230ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 200330ee2a98SJason J. Herne break; 200430ee2a98SJason J. Herne r = kvm_s390_set_skeys(kvm, &args); 200530ee2a98SJason J. Herne break; 200630ee2a98SJason J. Herne } 20074036e387SClaudio Imbrenda case KVM_S390_GET_CMMA_BITS: { 20084036e387SClaudio Imbrenda struct kvm_s390_cmma_log args; 20094036e387SClaudio Imbrenda 20104036e387SClaudio Imbrenda r = -EFAULT; 20114036e387SClaudio Imbrenda if (copy_from_user(&args, argp, sizeof(args))) 20124036e387SClaudio Imbrenda break; 20131de1ea7eSChristian Borntraeger mutex_lock(&kvm->slots_lock); 20144036e387SClaudio Imbrenda r = kvm_s390_get_cmma_bits(kvm, &args); 20151de1ea7eSChristian Borntraeger mutex_unlock(&kvm->slots_lock); 20164036e387SClaudio Imbrenda if (!r) { 20174036e387SClaudio Imbrenda r = copy_to_user(argp, &args, sizeof(args)); 20184036e387SClaudio Imbrenda if (r) 20194036e387SClaudio Imbrenda r = -EFAULT; 20204036e387SClaudio Imbrenda } 20214036e387SClaudio Imbrenda break; 20224036e387SClaudio Imbrenda } 20234036e387SClaudio Imbrenda case KVM_S390_SET_CMMA_BITS: { 20244036e387SClaudio Imbrenda struct kvm_s390_cmma_log args; 20254036e387SClaudio Imbrenda 20264036e387SClaudio Imbrenda r = -EFAULT; 20274036e387SClaudio Imbrenda if (copy_from_user(&args, argp, sizeof(args))) 20284036e387SClaudio Imbrenda break; 20291de1ea7eSChristian Borntraeger mutex_lock(&kvm->slots_lock); 20304036e387SClaudio Imbrenda r = kvm_s390_set_cmma_bits(kvm, &args); 20311de1ea7eSChristian Borntraeger mutex_unlock(&kvm->slots_lock); 20324036e387SClaudio Imbrenda break; 20334036e387SClaudio Imbrenda } 2034b0c632dbSHeiko Carstens default: 2035367e1319SAvi Kivity r = -ENOTTY; 2036b0c632dbSHeiko Carstens } 2037b0c632dbSHeiko Carstens 2038b0c632dbSHeiko Carstens return r; 2039b0c632dbSHeiko Carstens } 2040b0c632dbSHeiko Carstens 204145c9b47cSTony Krowiak static int kvm_s390_apxa_installed(void) 204245c9b47cSTony Krowiak { 2043e585b24aSTony Krowiak struct ap_config_info info; 204445c9b47cSTony Krowiak 2045e585b24aSTony Krowiak if (ap_instructions_available()) { 2046e585b24aSTony Krowiak if (ap_qci(&info) == 0) 2047e585b24aSTony Krowiak return info.apxa; 204845c9b47cSTony Krowiak } 204945c9b47cSTony Krowiak 205045c9b47cSTony Krowiak return 0; 205145c9b47cSTony Krowiak } 205245c9b47cSTony Krowiak 2053e585b24aSTony Krowiak /* 2054e585b24aSTony Krowiak * The format of the crypto control block (CRYCB) is specified in the 3 low 2055e585b24aSTony Krowiak * order bits of the CRYCB designation (CRYCBD) field as follows: 2056e585b24aSTony Krowiak * Format 0: Neither the message security assist extension 3 (MSAX3) nor the 2057e585b24aSTony Krowiak * AP extended addressing (APXA) facility are installed. 2058e585b24aSTony Krowiak * Format 1: The APXA facility is not installed but the MSAX3 facility is. 2059e585b24aSTony Krowiak * Format 2: Both the APXA and MSAX3 facilities are installed 2060e585b24aSTony Krowiak */ 206145c9b47cSTony Krowiak static void kvm_s390_set_crycb_format(struct kvm *kvm) 206245c9b47cSTony Krowiak { 206345c9b47cSTony Krowiak kvm->arch.crypto.crycbd = (__u32)(unsigned long) kvm->arch.crypto.crycb; 206445c9b47cSTony Krowiak 2065e585b24aSTony Krowiak /* Clear the CRYCB format bits - i.e., set format 0 by default */ 2066e585b24aSTony Krowiak kvm->arch.crypto.crycbd &= ~(CRYCB_FORMAT_MASK); 2067e585b24aSTony Krowiak 2068e585b24aSTony Krowiak /* Check whether MSAX3 is installed */ 2069e585b24aSTony Krowiak if (!test_kvm_facility(kvm, 76)) 2070e585b24aSTony Krowiak return; 2071e585b24aSTony Krowiak 207245c9b47cSTony Krowiak if (kvm_s390_apxa_installed()) 207345c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT2; 207445c9b47cSTony Krowiak else 207545c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT1; 207645c9b47cSTony Krowiak } 207745c9b47cSTony Krowiak 20780e237e44SPierre Morel void kvm_arch_crypto_set_masks(struct kvm *kvm, unsigned long *apm, 20790e237e44SPierre Morel unsigned long *aqm, unsigned long *adm) 20800e237e44SPierre Morel { 20810e237e44SPierre Morel struct kvm_s390_crypto_cb *crycb = kvm->arch.crypto.crycb; 20820e237e44SPierre Morel 20830e237e44SPierre Morel mutex_lock(&kvm->lock); 20840e237e44SPierre Morel kvm_s390_vcpu_block_all(kvm); 20850e237e44SPierre Morel 20860e237e44SPierre Morel switch (kvm->arch.crypto.crycbd & CRYCB_FORMAT_MASK) { 20870e237e44SPierre Morel case CRYCB_FORMAT2: /* APCB1 use 256 bits */ 20880e237e44SPierre Morel memcpy(crycb->apcb1.apm, apm, 32); 20890e237e44SPierre Morel VM_EVENT(kvm, 3, "SET CRYCB: apm %016lx %016lx %016lx %016lx", 20900e237e44SPierre Morel apm[0], apm[1], apm[2], apm[3]); 20910e237e44SPierre Morel memcpy(crycb->apcb1.aqm, aqm, 32); 20920e237e44SPierre Morel VM_EVENT(kvm, 3, "SET CRYCB: aqm %016lx %016lx %016lx %016lx", 20930e237e44SPierre Morel aqm[0], aqm[1], aqm[2], aqm[3]); 20940e237e44SPierre Morel memcpy(crycb->apcb1.adm, adm, 32); 20950e237e44SPierre Morel VM_EVENT(kvm, 3, "SET CRYCB: adm %016lx %016lx %016lx %016lx", 20960e237e44SPierre Morel adm[0], adm[1], adm[2], adm[3]); 20970e237e44SPierre Morel break; 20980e237e44SPierre Morel case CRYCB_FORMAT1: 20990e237e44SPierre Morel case CRYCB_FORMAT0: /* Fall through both use APCB0 */ 21000e237e44SPierre Morel memcpy(crycb->apcb0.apm, apm, 8); 21010e237e44SPierre Morel memcpy(crycb->apcb0.aqm, aqm, 2); 21020e237e44SPierre Morel memcpy(crycb->apcb0.adm, adm, 2); 21030e237e44SPierre Morel VM_EVENT(kvm, 3, "SET CRYCB: apm %016lx aqm %04x adm %04x", 21040e237e44SPierre Morel apm[0], *((unsigned short *)aqm), 21050e237e44SPierre Morel *((unsigned short *)adm)); 21060e237e44SPierre Morel break; 21070e237e44SPierre Morel default: /* Can not happen */ 21080e237e44SPierre Morel break; 21090e237e44SPierre Morel } 21100e237e44SPierre Morel 21110e237e44SPierre Morel /* recreate the shadow crycb for each vcpu */ 21120e237e44SPierre Morel kvm_s390_sync_request_broadcast(kvm, KVM_REQ_VSIE_RESTART); 21130e237e44SPierre Morel kvm_s390_vcpu_unblock_all(kvm); 21140e237e44SPierre Morel mutex_unlock(&kvm->lock); 21150e237e44SPierre Morel } 21160e237e44SPierre Morel EXPORT_SYMBOL_GPL(kvm_arch_crypto_set_masks); 21170e237e44SPierre Morel 211842104598STony Krowiak void kvm_arch_crypto_clear_masks(struct kvm *kvm) 211942104598STony Krowiak { 212042104598STony Krowiak mutex_lock(&kvm->lock); 212142104598STony Krowiak kvm_s390_vcpu_block_all(kvm); 212242104598STony Krowiak 212342104598STony Krowiak memset(&kvm->arch.crypto.crycb->apcb0, 0, 212442104598STony Krowiak sizeof(kvm->arch.crypto.crycb->apcb0)); 212542104598STony Krowiak memset(&kvm->arch.crypto.crycb->apcb1, 0, 212642104598STony Krowiak sizeof(kvm->arch.crypto.crycb->apcb1)); 212742104598STony Krowiak 21280e237e44SPierre Morel VM_EVENT(kvm, 3, "%s", "CLR CRYCB:"); 21296cc571b1SPierre Morel /* recreate the shadow crycb for each vcpu */ 21306cc571b1SPierre Morel kvm_s390_sync_request_broadcast(kvm, KVM_REQ_VSIE_RESTART); 213142104598STony Krowiak kvm_s390_vcpu_unblock_all(kvm); 213242104598STony Krowiak mutex_unlock(&kvm->lock); 213342104598STony Krowiak } 213442104598STony Krowiak EXPORT_SYMBOL_GPL(kvm_arch_crypto_clear_masks); 213542104598STony Krowiak 21369bb0ec09SDavid Hildenbrand static u64 kvm_s390_get_initial_cpuid(void) 21379d8d5786SMichael Mueller { 21389bb0ec09SDavid Hildenbrand struct cpuid cpuid; 21399bb0ec09SDavid Hildenbrand 21409bb0ec09SDavid Hildenbrand get_cpu_id(&cpuid); 21419bb0ec09SDavid Hildenbrand cpuid.version = 0xff; 21429bb0ec09SDavid Hildenbrand return *((u64 *) &cpuid); 21439d8d5786SMichael Mueller } 21449d8d5786SMichael Mueller 2145c54f0d6aSDavid Hildenbrand static void kvm_s390_crypto_init(struct kvm *kvm) 21465102ee87STony Krowiak { 2147c54f0d6aSDavid Hildenbrand kvm->arch.crypto.crycb = &kvm->arch.sie_page2->crycb; 214845c9b47cSTony Krowiak kvm_s390_set_crycb_format(kvm); 21495102ee87STony Krowiak 2150e585b24aSTony Krowiak if (!test_kvm_facility(kvm, 76)) 2151e585b24aSTony Krowiak return; 2152e585b24aSTony Krowiak 2153ed6f76b4STony Krowiak /* Enable AES/DEA protected key functions by default */ 2154ed6f76b4STony Krowiak kvm->arch.crypto.aes_kw = 1; 2155ed6f76b4STony Krowiak kvm->arch.crypto.dea_kw = 1; 2156ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 2157ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 2158ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 2159ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 21605102ee87STony Krowiak } 21615102ee87STony Krowiak 21627d43bafcSEugene (jno) Dvurechenski static void sca_dispose(struct kvm *kvm) 21637d43bafcSEugene (jno) Dvurechenski { 21647d43bafcSEugene (jno) Dvurechenski if (kvm->arch.use_esca) 21655e044315SEugene (jno) Dvurechenski free_pages_exact(kvm->arch.sca, sizeof(struct esca_block)); 21667d43bafcSEugene (jno) Dvurechenski else 21677d43bafcSEugene (jno) Dvurechenski free_page((unsigned long)(kvm->arch.sca)); 21687d43bafcSEugene (jno) Dvurechenski kvm->arch.sca = NULL; 21697d43bafcSEugene (jno) Dvurechenski } 21707d43bafcSEugene (jno) Dvurechenski 2171e08b9637SCarsten Otte int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 2172b0c632dbSHeiko Carstens { 217376a6dd72SDavid Hildenbrand gfp_t alloc_flags = GFP_KERNEL; 21749d8d5786SMichael Mueller int i, rc; 2175b0c632dbSHeiko Carstens char debug_name[16]; 2176f6c137ffSChristian Borntraeger static unsigned long sca_offset; 2177b0c632dbSHeiko Carstens 2178e08b9637SCarsten Otte rc = -EINVAL; 2179e08b9637SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 2180e08b9637SCarsten Otte if (type & ~KVM_VM_S390_UCONTROL) 2181e08b9637SCarsten Otte goto out_err; 2182e08b9637SCarsten Otte if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN))) 2183e08b9637SCarsten Otte goto out_err; 2184e08b9637SCarsten Otte #else 2185e08b9637SCarsten Otte if (type) 2186e08b9637SCarsten Otte goto out_err; 2187e08b9637SCarsten Otte #endif 2188e08b9637SCarsten Otte 2189b0c632dbSHeiko Carstens rc = s390_enable_sie(); 2190b0c632dbSHeiko Carstens if (rc) 2191d89f5effSJan Kiszka goto out_err; 2192b0c632dbSHeiko Carstens 2193b290411aSCarsten Otte rc = -ENOMEM; 2194b290411aSCarsten Otte 219576a6dd72SDavid Hildenbrand if (!sclp.has_64bscao) 219676a6dd72SDavid Hildenbrand alloc_flags |= GFP_DMA; 21975e044315SEugene (jno) Dvurechenski rwlock_init(&kvm->arch.sca_lock); 21989ac96d75SDavid Hildenbrand /* start with basic SCA */ 219976a6dd72SDavid Hildenbrand kvm->arch.sca = (struct bsca_block *) get_zeroed_page(alloc_flags); 2200b0c632dbSHeiko Carstens if (!kvm->arch.sca) 2201d89f5effSJan Kiszka goto out_err; 2202f6c137ffSChristian Borntraeger spin_lock(&kvm_lock); 2203c5c2c393SDavid Hildenbrand sca_offset += 16; 2204bc784cceSEugene (jno) Dvurechenski if (sca_offset + sizeof(struct bsca_block) > PAGE_SIZE) 2205c5c2c393SDavid Hildenbrand sca_offset = 0; 2206bc784cceSEugene (jno) Dvurechenski kvm->arch.sca = (struct bsca_block *) 2207bc784cceSEugene (jno) Dvurechenski ((char *) kvm->arch.sca + sca_offset); 2208f6c137ffSChristian Borntraeger spin_unlock(&kvm_lock); 2209b0c632dbSHeiko Carstens 2210b0c632dbSHeiko Carstens sprintf(debug_name, "kvm-%u", current->pid); 2211b0c632dbSHeiko Carstens 22121cb9cf72SChristian Borntraeger kvm->arch.dbf = debug_register(debug_name, 32, 1, 7 * sizeof(long)); 2213b0c632dbSHeiko Carstens if (!kvm->arch.dbf) 221440f5b735SDominik Dingel goto out_err; 2215b0c632dbSHeiko Carstens 221619114bebSMichael Mueller BUILD_BUG_ON(sizeof(struct sie_page2) != 4096); 2217c54f0d6aSDavid Hildenbrand kvm->arch.sie_page2 = 2218c54f0d6aSDavid Hildenbrand (struct sie_page2 *) get_zeroed_page(GFP_KERNEL | GFP_DMA); 2219c54f0d6aSDavid Hildenbrand if (!kvm->arch.sie_page2) 222040f5b735SDominik Dingel goto out_err; 22219d8d5786SMichael Mueller 2222c54f0d6aSDavid Hildenbrand kvm->arch.model.fac_list = kvm->arch.sie_page2->fac_list; 2223c3b9e3e1SChristian Borntraeger 2224c3b9e3e1SChristian Borntraeger for (i = 0; i < kvm_s390_fac_size(); i++) { 2225c3b9e3e1SChristian Borntraeger kvm->arch.model.fac_mask[i] = S390_lowcore.stfle_fac_list[i] & 2226c3b9e3e1SChristian Borntraeger (kvm_s390_fac_base[i] | 2227c3b9e3e1SChristian Borntraeger kvm_s390_fac_ext[i]); 2228c3b9e3e1SChristian Borntraeger kvm->arch.model.fac_list[i] = S390_lowcore.stfle_fac_list[i] & 2229c3b9e3e1SChristian Borntraeger kvm_s390_fac_base[i]; 2230c3b9e3e1SChristian Borntraeger } 2231981467c9SMichael Mueller 22321935222dSDavid Hildenbrand /* we are always in czam mode - even on pre z14 machines */ 22331935222dSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 138); 22341935222dSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 138); 22351935222dSDavid Hildenbrand /* we emulate STHYI in kvm */ 223695ca2cb5SJanosch Frank set_kvm_facility(kvm->arch.model.fac_mask, 74); 223795ca2cb5SJanosch Frank set_kvm_facility(kvm->arch.model.fac_list, 74); 22381bab1c02SClaudio Imbrenda if (MACHINE_HAS_TLB_GUEST) { 22391bab1c02SClaudio Imbrenda set_kvm_facility(kvm->arch.model.fac_mask, 147); 22401bab1c02SClaudio Imbrenda set_kvm_facility(kvm->arch.model.fac_list, 147); 22411bab1c02SClaudio Imbrenda } 224295ca2cb5SJanosch Frank 22439bb0ec09SDavid Hildenbrand kvm->arch.model.cpuid = kvm_s390_get_initial_cpuid(); 224437c5f6c8SDavid Hildenbrand kvm->arch.model.ibc = sclp.ibc & 0x0fff; 22459d8d5786SMichael Mueller 2246c54f0d6aSDavid Hildenbrand kvm_s390_crypto_init(kvm); 22475102ee87STony Krowiak 224851978393SFei Li mutex_init(&kvm->arch.float_int.ais_lock); 2249ba5c1e9bSCarsten Otte spin_lock_init(&kvm->arch.float_int.lock); 22506d3da241SJens Freimann for (i = 0; i < FIRQ_LIST_COUNT; i++) 22516d3da241SJens Freimann INIT_LIST_HEAD(&kvm->arch.float_int.lists[i]); 22528a242234SHeiko Carstens init_waitqueue_head(&kvm->arch.ipte_wq); 2253a6b7e459SThomas Huth mutex_init(&kvm->arch.ipte_mutex); 2254ba5c1e9bSCarsten Otte 2255b0c632dbSHeiko Carstens debug_register_view(kvm->arch.dbf, &debug_sprintf_view); 225678f26131SChristian Borntraeger VM_EVENT(kvm, 3, "vm created with type %lu", type); 2257b0c632dbSHeiko Carstens 2258e08b9637SCarsten Otte if (type & KVM_VM_S390_UCONTROL) { 2259e08b9637SCarsten Otte kvm->arch.gmap = NULL; 2260a3a92c31SDominik Dingel kvm->arch.mem_limit = KVM_S390_NO_MEM_LIMIT; 2261e08b9637SCarsten Otte } else { 226232e6b236SGuenther Hutzl if (sclp.hamax == U64_MAX) 2263ee71d16dSMartin Schwidefsky kvm->arch.mem_limit = TASK_SIZE_MAX; 226432e6b236SGuenther Hutzl else 2265ee71d16dSMartin Schwidefsky kvm->arch.mem_limit = min_t(unsigned long, TASK_SIZE_MAX, 226632e6b236SGuenther Hutzl sclp.hamax + 1); 22676ea427bbSMartin Schwidefsky kvm->arch.gmap = gmap_create(current->mm, kvm->arch.mem_limit - 1); 2268598841caSCarsten Otte if (!kvm->arch.gmap) 226940f5b735SDominik Dingel goto out_err; 22702c70fe44SChristian Borntraeger kvm->arch.gmap->private = kvm; 227124eb3a82SDominik Dingel kvm->arch.gmap->pfault_enabled = 0; 2272e08b9637SCarsten Otte } 2273fa6b7fe9SCornelia Huck 2274c9f0a2b8SJanosch Frank kvm->arch.use_pfmfi = sclp.has_pfmfi; 227555531b74SJanosch Frank kvm->arch.use_skf = sclp.has_skey; 22768ad35755SDavid Hildenbrand spin_lock_init(&kvm->arch.start_stop_lock); 2277a3508fbeSDavid Hildenbrand kvm_s390_vsie_init(kvm); 2278d7c5cb01SMichael Mueller kvm_s390_gisa_init(kvm); 22798335713aSChristian Borntraeger KVM_EVENT(3, "vm 0x%pK created by pid %u", kvm, current->pid); 22808ad35755SDavid Hildenbrand 2281d89f5effSJan Kiszka return 0; 2282d89f5effSJan Kiszka out_err: 2283c54f0d6aSDavid Hildenbrand free_page((unsigned long)kvm->arch.sie_page2); 228440f5b735SDominik Dingel debug_unregister(kvm->arch.dbf); 22857d43bafcSEugene (jno) Dvurechenski sca_dispose(kvm); 228678f26131SChristian Borntraeger KVM_EVENT(3, "creation of vm failed: %d", rc); 2287d89f5effSJan Kiszka return rc; 2288b0c632dbSHeiko Carstens } 2289b0c632dbSHeiko Carstens 2290235539b4SLuiz Capitulino bool kvm_arch_has_vcpu_debugfs(void) 2291235539b4SLuiz Capitulino { 2292235539b4SLuiz Capitulino return false; 2293235539b4SLuiz Capitulino } 2294235539b4SLuiz Capitulino 2295235539b4SLuiz Capitulino int kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu) 2296235539b4SLuiz Capitulino { 2297235539b4SLuiz Capitulino return 0; 2298235539b4SLuiz Capitulino } 2299235539b4SLuiz Capitulino 2300d329c035SChristian Borntraeger void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 2301d329c035SChristian Borntraeger { 2302d329c035SChristian Borntraeger VCPU_EVENT(vcpu, 3, "%s", "free cpu"); 2303ade38c31SCornelia Huck trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id); 230467335e63SChristian Borntraeger kvm_s390_clear_local_irqs(vcpu); 23053c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 2306bc784cceSEugene (jno) Dvurechenski if (!kvm_is_ucontrol(vcpu->kvm)) 2307a6e2f683SEugene (jno) Dvurechenski sca_del_vcpu(vcpu); 230827e0393fSCarsten Otte 230927e0393fSCarsten Otte if (kvm_is_ucontrol(vcpu->kvm)) 23106ea427bbSMartin Schwidefsky gmap_remove(vcpu->arch.gmap); 231127e0393fSCarsten Otte 2312e6db1d61SDominik Dingel if (vcpu->kvm->arch.use_cmma) 2313b31605c1SDominik Dingel kvm_s390_vcpu_unsetup_cmma(vcpu); 2314d329c035SChristian Borntraeger free_page((unsigned long)(vcpu->arch.sie_block)); 2315b31288faSKonstantin Weitz 23166692cef3SChristian Borntraeger kvm_vcpu_uninit(vcpu); 2317b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 2318d329c035SChristian Borntraeger } 2319d329c035SChristian Borntraeger 2320d329c035SChristian Borntraeger static void kvm_free_vcpus(struct kvm *kvm) 2321d329c035SChristian Borntraeger { 2322d329c035SChristian Borntraeger unsigned int i; 2323988a2caeSGleb Natapov struct kvm_vcpu *vcpu; 2324d329c035SChristian Borntraeger 2325988a2caeSGleb Natapov kvm_for_each_vcpu(i, vcpu, kvm) 2326988a2caeSGleb Natapov kvm_arch_vcpu_destroy(vcpu); 2327988a2caeSGleb Natapov 2328988a2caeSGleb Natapov mutex_lock(&kvm->lock); 2329988a2caeSGleb Natapov for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 2330d329c035SChristian Borntraeger kvm->vcpus[i] = NULL; 2331988a2caeSGleb Natapov 2332988a2caeSGleb Natapov atomic_set(&kvm->online_vcpus, 0); 2333988a2caeSGleb Natapov mutex_unlock(&kvm->lock); 2334d329c035SChristian Borntraeger } 2335d329c035SChristian Borntraeger 2336b0c632dbSHeiko Carstens void kvm_arch_destroy_vm(struct kvm *kvm) 2337b0c632dbSHeiko Carstens { 2338d329c035SChristian Borntraeger kvm_free_vcpus(kvm); 23397d43bafcSEugene (jno) Dvurechenski sca_dispose(kvm); 2340d329c035SChristian Borntraeger debug_unregister(kvm->arch.dbf); 2341d7c5cb01SMichael Mueller kvm_s390_gisa_destroy(kvm); 2342c54f0d6aSDavid Hildenbrand free_page((unsigned long)kvm->arch.sie_page2); 234327e0393fSCarsten Otte if (!kvm_is_ucontrol(kvm)) 23446ea427bbSMartin Schwidefsky gmap_remove(kvm->arch.gmap); 2345841b91c5SCornelia Huck kvm_s390_destroy_adapters(kvm); 234667335e63SChristian Borntraeger kvm_s390_clear_float_irqs(kvm); 2347a3508fbeSDavid Hildenbrand kvm_s390_vsie_destroy(kvm); 23488335713aSChristian Borntraeger KVM_EVENT(3, "vm 0x%pK destroyed", kvm); 2349b0c632dbSHeiko Carstens } 2350b0c632dbSHeiko Carstens 2351b0c632dbSHeiko Carstens /* Section: vcpu related */ 2352dafd032aSDominik Dingel static int __kvm_ucontrol_vcpu_init(struct kvm_vcpu *vcpu) 2353b0c632dbSHeiko Carstens { 23546ea427bbSMartin Schwidefsky vcpu->arch.gmap = gmap_create(current->mm, -1UL); 235527e0393fSCarsten Otte if (!vcpu->arch.gmap) 235627e0393fSCarsten Otte return -ENOMEM; 23572c70fe44SChristian Borntraeger vcpu->arch.gmap->private = vcpu->kvm; 2358dafd032aSDominik Dingel 235927e0393fSCarsten Otte return 0; 236027e0393fSCarsten Otte } 236127e0393fSCarsten Otte 2362a6e2f683SEugene (jno) Dvurechenski static void sca_del_vcpu(struct kvm_vcpu *vcpu) 2363a6e2f683SEugene (jno) Dvurechenski { 2364a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) 2365a6940674SDavid Hildenbrand return; 23665e044315SEugene (jno) Dvurechenski read_lock(&vcpu->kvm->arch.sca_lock); 23677d43bafcSEugene (jno) Dvurechenski if (vcpu->kvm->arch.use_esca) { 23687d43bafcSEugene (jno) Dvurechenski struct esca_block *sca = vcpu->kvm->arch.sca; 23697d43bafcSEugene (jno) Dvurechenski 23707d43bafcSEugene (jno) Dvurechenski clear_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn); 23717d43bafcSEugene (jno) Dvurechenski sca->cpu[vcpu->vcpu_id].sda = 0; 23727d43bafcSEugene (jno) Dvurechenski } else { 2373bc784cceSEugene (jno) Dvurechenski struct bsca_block *sca = vcpu->kvm->arch.sca; 2374a6e2f683SEugene (jno) Dvurechenski 2375a6e2f683SEugene (jno) Dvurechenski clear_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn); 2376a6e2f683SEugene (jno) Dvurechenski sca->cpu[vcpu->vcpu_id].sda = 0; 2377a6e2f683SEugene (jno) Dvurechenski } 23785e044315SEugene (jno) Dvurechenski read_unlock(&vcpu->kvm->arch.sca_lock); 23797d43bafcSEugene (jno) Dvurechenski } 2380a6e2f683SEugene (jno) Dvurechenski 2381eaa78f34SDavid Hildenbrand static void sca_add_vcpu(struct kvm_vcpu *vcpu) 2382a6e2f683SEugene (jno) Dvurechenski { 2383a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) { 2384a6940674SDavid Hildenbrand struct bsca_block *sca = vcpu->kvm->arch.sca; 2385a6940674SDavid Hildenbrand 2386a6940674SDavid Hildenbrand /* we still need the basic sca for the ipte control */ 2387a6940674SDavid Hildenbrand vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 2388a6940674SDavid Hildenbrand vcpu->arch.sie_block->scaol = (__u32)(__u64)sca; 2389f07afa04SDavid Hildenbrand return; 2390a6940674SDavid Hildenbrand } 2391eaa78f34SDavid Hildenbrand read_lock(&vcpu->kvm->arch.sca_lock); 2392eaa78f34SDavid Hildenbrand if (vcpu->kvm->arch.use_esca) { 2393eaa78f34SDavid Hildenbrand struct esca_block *sca = vcpu->kvm->arch.sca; 23947d43bafcSEugene (jno) Dvurechenski 2395eaa78f34SDavid Hildenbrand sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block; 23967d43bafcSEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 23977d43bafcSEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = (__u32)(__u64)sca & ~0x3fU; 23980c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= ECB2_ESCA; 2399eaa78f34SDavid Hildenbrand set_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn); 24007d43bafcSEugene (jno) Dvurechenski } else { 2401eaa78f34SDavid Hildenbrand struct bsca_block *sca = vcpu->kvm->arch.sca; 2402a6e2f683SEugene (jno) Dvurechenski 2403eaa78f34SDavid Hildenbrand sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block; 2404a6e2f683SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 2405a6e2f683SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = (__u32)(__u64)sca; 2406eaa78f34SDavid Hildenbrand set_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn); 2407a6e2f683SEugene (jno) Dvurechenski } 2408eaa78f34SDavid Hildenbrand read_unlock(&vcpu->kvm->arch.sca_lock); 24095e044315SEugene (jno) Dvurechenski } 24105e044315SEugene (jno) Dvurechenski 24115e044315SEugene (jno) Dvurechenski /* Basic SCA to Extended SCA data copy routines */ 24125e044315SEugene (jno) Dvurechenski static inline void sca_copy_entry(struct esca_entry *d, struct bsca_entry *s) 24135e044315SEugene (jno) Dvurechenski { 24145e044315SEugene (jno) Dvurechenski d->sda = s->sda; 24155e044315SEugene (jno) Dvurechenski d->sigp_ctrl.c = s->sigp_ctrl.c; 24165e044315SEugene (jno) Dvurechenski d->sigp_ctrl.scn = s->sigp_ctrl.scn; 24175e044315SEugene (jno) Dvurechenski } 24185e044315SEugene (jno) Dvurechenski 24195e044315SEugene (jno) Dvurechenski static void sca_copy_b_to_e(struct esca_block *d, struct bsca_block *s) 24205e044315SEugene (jno) Dvurechenski { 24215e044315SEugene (jno) Dvurechenski int i; 24225e044315SEugene (jno) Dvurechenski 24235e044315SEugene (jno) Dvurechenski d->ipte_control = s->ipte_control; 24245e044315SEugene (jno) Dvurechenski d->mcn[0] = s->mcn; 24255e044315SEugene (jno) Dvurechenski for (i = 0; i < KVM_S390_BSCA_CPU_SLOTS; i++) 24265e044315SEugene (jno) Dvurechenski sca_copy_entry(&d->cpu[i], &s->cpu[i]); 24275e044315SEugene (jno) Dvurechenski } 24285e044315SEugene (jno) Dvurechenski 24295e044315SEugene (jno) Dvurechenski static int sca_switch_to_extended(struct kvm *kvm) 24305e044315SEugene (jno) Dvurechenski { 24315e044315SEugene (jno) Dvurechenski struct bsca_block *old_sca = kvm->arch.sca; 24325e044315SEugene (jno) Dvurechenski struct esca_block *new_sca; 24335e044315SEugene (jno) Dvurechenski struct kvm_vcpu *vcpu; 24345e044315SEugene (jno) Dvurechenski unsigned int vcpu_idx; 24355e044315SEugene (jno) Dvurechenski u32 scaol, scaoh; 24365e044315SEugene (jno) Dvurechenski 24375e044315SEugene (jno) Dvurechenski new_sca = alloc_pages_exact(sizeof(*new_sca), GFP_KERNEL|__GFP_ZERO); 24385e044315SEugene (jno) Dvurechenski if (!new_sca) 24395e044315SEugene (jno) Dvurechenski return -ENOMEM; 24405e044315SEugene (jno) Dvurechenski 24415e044315SEugene (jno) Dvurechenski scaoh = (u32)((u64)(new_sca) >> 32); 24425e044315SEugene (jno) Dvurechenski scaol = (u32)(u64)(new_sca) & ~0x3fU; 24435e044315SEugene (jno) Dvurechenski 24445e044315SEugene (jno) Dvurechenski kvm_s390_vcpu_block_all(kvm); 24455e044315SEugene (jno) Dvurechenski write_lock(&kvm->arch.sca_lock); 24465e044315SEugene (jno) Dvurechenski 24475e044315SEugene (jno) Dvurechenski sca_copy_b_to_e(new_sca, old_sca); 24485e044315SEugene (jno) Dvurechenski 24495e044315SEugene (jno) Dvurechenski kvm_for_each_vcpu(vcpu_idx, vcpu, kvm) { 24505e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = scaoh; 24515e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = scaol; 24520c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= ECB2_ESCA; 24535e044315SEugene (jno) Dvurechenski } 24545e044315SEugene (jno) Dvurechenski kvm->arch.sca = new_sca; 24555e044315SEugene (jno) Dvurechenski kvm->arch.use_esca = 1; 24565e044315SEugene (jno) Dvurechenski 24575e044315SEugene (jno) Dvurechenski write_unlock(&kvm->arch.sca_lock); 24585e044315SEugene (jno) Dvurechenski kvm_s390_vcpu_unblock_all(kvm); 24595e044315SEugene (jno) Dvurechenski 24605e044315SEugene (jno) Dvurechenski free_page((unsigned long)old_sca); 24615e044315SEugene (jno) Dvurechenski 24628335713aSChristian Borntraeger VM_EVENT(kvm, 2, "Switched to ESCA (0x%pK -> 0x%pK)", 24638335713aSChristian Borntraeger old_sca, kvm->arch.sca); 24645e044315SEugene (jno) Dvurechenski return 0; 24657d43bafcSEugene (jno) Dvurechenski } 2466a6e2f683SEugene (jno) Dvurechenski 2467a6e2f683SEugene (jno) Dvurechenski static int sca_can_add_vcpu(struct kvm *kvm, unsigned int id) 2468a6e2f683SEugene (jno) Dvurechenski { 24695e044315SEugene (jno) Dvurechenski int rc; 24705e044315SEugene (jno) Dvurechenski 2471a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) { 2472a6940674SDavid Hildenbrand if (id < KVM_MAX_VCPUS) 2473a6940674SDavid Hildenbrand return true; 2474a6940674SDavid Hildenbrand return false; 2475a6940674SDavid Hildenbrand } 24765e044315SEugene (jno) Dvurechenski if (id < KVM_S390_BSCA_CPU_SLOTS) 24775e044315SEugene (jno) Dvurechenski return true; 247876a6dd72SDavid Hildenbrand if (!sclp.has_esca || !sclp.has_64bscao) 24795e044315SEugene (jno) Dvurechenski return false; 24805e044315SEugene (jno) Dvurechenski 24815e044315SEugene (jno) Dvurechenski mutex_lock(&kvm->lock); 24825e044315SEugene (jno) Dvurechenski rc = kvm->arch.use_esca ? 0 : sca_switch_to_extended(kvm); 24835e044315SEugene (jno) Dvurechenski mutex_unlock(&kvm->lock); 24845e044315SEugene (jno) Dvurechenski 24855e044315SEugene (jno) Dvurechenski return rc == 0 && id < KVM_S390_ESCA_CPU_SLOTS; 2486a6e2f683SEugene (jno) Dvurechenski } 2487a6e2f683SEugene (jno) Dvurechenski 2488dafd032aSDominik Dingel int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 2489dafd032aSDominik Dingel { 2490dafd032aSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 2491dafd032aSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 249259674c1aSChristian Borntraeger vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX | 249359674c1aSChristian Borntraeger KVM_SYNC_GPRS | 24949eed0735SChristian Borntraeger KVM_SYNC_ACRS | 2495b028ee3eSDavid Hildenbrand KVM_SYNC_CRS | 2496b028ee3eSDavid Hildenbrand KVM_SYNC_ARCH0 | 2497b028ee3eSDavid Hildenbrand KVM_SYNC_PFAULT; 249875a4615cSJulius Niedworok kvm_s390_set_prefix(vcpu, 0); 2499c6e5f166SFan Zhang if (test_kvm_facility(vcpu->kvm, 64)) 2500c6e5f166SFan Zhang vcpu->run->kvm_valid_regs |= KVM_SYNC_RICCB; 250135b3fde6SChristian Borntraeger if (test_kvm_facility(vcpu->kvm, 82)) 250235b3fde6SChristian Borntraeger vcpu->run->kvm_valid_regs |= KVM_SYNC_BPBC; 25034e0b1ab7SFan Zhang if (test_kvm_facility(vcpu->kvm, 133)) 25044e0b1ab7SFan Zhang vcpu->run->kvm_valid_regs |= KVM_SYNC_GSCB; 2505a3da7b4aSChristian Borntraeger if (test_kvm_facility(vcpu->kvm, 156)) 2506a3da7b4aSChristian Borntraeger vcpu->run->kvm_valid_regs |= KVM_SYNC_ETOKEN; 2507f6aa6dc4SDavid Hildenbrand /* fprs can be synchronized via vrs, even if the guest has no vx. With 2508f6aa6dc4SDavid Hildenbrand * MACHINE_HAS_VX, (load|store)_fpu_regs() will work with vrs format. 2509f6aa6dc4SDavid Hildenbrand */ 2510f6aa6dc4SDavid Hildenbrand if (MACHINE_HAS_VX) 251168c55750SEric Farman vcpu->run->kvm_valid_regs |= KVM_SYNC_VRS; 25126fd8e67dSDavid Hildenbrand else 25136fd8e67dSDavid Hildenbrand vcpu->run->kvm_valid_regs |= KVM_SYNC_FPRS; 2514dafd032aSDominik Dingel 2515dafd032aSDominik Dingel if (kvm_is_ucontrol(vcpu->kvm)) 2516dafd032aSDominik Dingel return __kvm_ucontrol_vcpu_init(vcpu); 2517dafd032aSDominik Dingel 2518b0c632dbSHeiko Carstens return 0; 2519b0c632dbSHeiko Carstens } 2520b0c632dbSHeiko Carstens 2521db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 2522db0758b2SDavid Hildenbrand static void __start_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2523db0758b2SDavid Hildenbrand { 2524db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_start != 0); 25259c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 2526db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = get_tod_clock_fast(); 25279c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 2528db0758b2SDavid Hildenbrand } 2529db0758b2SDavid Hildenbrand 2530db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 2531db0758b2SDavid Hildenbrand static void __stop_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2532db0758b2SDavid Hildenbrand { 2533db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_start == 0); 25349c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 2535db0758b2SDavid Hildenbrand vcpu->arch.sie_block->cputm -= get_tod_clock_fast() - vcpu->arch.cputm_start; 2536db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = 0; 25379c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 2538db0758b2SDavid Hildenbrand } 2539db0758b2SDavid Hildenbrand 2540db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 2541db0758b2SDavid Hildenbrand static void __enable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2542db0758b2SDavid Hildenbrand { 2543db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_enabled); 2544db0758b2SDavid Hildenbrand vcpu->arch.cputm_enabled = true; 2545db0758b2SDavid Hildenbrand __start_cpu_timer_accounting(vcpu); 2546db0758b2SDavid Hildenbrand } 2547db0758b2SDavid Hildenbrand 2548db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 2549db0758b2SDavid Hildenbrand static void __disable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2550db0758b2SDavid Hildenbrand { 2551db0758b2SDavid Hildenbrand WARN_ON_ONCE(!vcpu->arch.cputm_enabled); 2552db0758b2SDavid Hildenbrand __stop_cpu_timer_accounting(vcpu); 2553db0758b2SDavid Hildenbrand vcpu->arch.cputm_enabled = false; 2554db0758b2SDavid Hildenbrand } 2555db0758b2SDavid Hildenbrand 2556db0758b2SDavid Hildenbrand static void enable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2557db0758b2SDavid Hildenbrand { 2558db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 2559db0758b2SDavid Hildenbrand __enable_cpu_timer_accounting(vcpu); 2560db0758b2SDavid Hildenbrand preempt_enable(); 2561db0758b2SDavid Hildenbrand } 2562db0758b2SDavid Hildenbrand 2563db0758b2SDavid Hildenbrand static void disable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2564db0758b2SDavid Hildenbrand { 2565db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 2566db0758b2SDavid Hildenbrand __disable_cpu_timer_accounting(vcpu); 2567db0758b2SDavid Hildenbrand preempt_enable(); 2568db0758b2SDavid Hildenbrand } 2569db0758b2SDavid Hildenbrand 25704287f247SDavid Hildenbrand /* set the cpu timer - may only be called from the VCPU thread itself */ 25714287f247SDavid Hildenbrand void kvm_s390_set_cpu_timer(struct kvm_vcpu *vcpu, __u64 cputm) 25724287f247SDavid Hildenbrand { 2573db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 25749c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 2575db0758b2SDavid Hildenbrand if (vcpu->arch.cputm_enabled) 2576db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = get_tod_clock_fast(); 25774287f247SDavid Hildenbrand vcpu->arch.sie_block->cputm = cputm; 25789c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 2579db0758b2SDavid Hildenbrand preempt_enable(); 25804287f247SDavid Hildenbrand } 25814287f247SDavid Hildenbrand 2582db0758b2SDavid Hildenbrand /* update and get the cpu timer - can also be called from other VCPU threads */ 25834287f247SDavid Hildenbrand __u64 kvm_s390_get_cpu_timer(struct kvm_vcpu *vcpu) 25844287f247SDavid Hildenbrand { 25859c23a131SDavid Hildenbrand unsigned int seq; 2586db0758b2SDavid Hildenbrand __u64 value; 2587db0758b2SDavid Hildenbrand 2588db0758b2SDavid Hildenbrand if (unlikely(!vcpu->arch.cputm_enabled)) 25894287f247SDavid Hildenbrand return vcpu->arch.sie_block->cputm; 2590db0758b2SDavid Hildenbrand 25919c23a131SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 25929c23a131SDavid Hildenbrand do { 25939c23a131SDavid Hildenbrand seq = raw_read_seqcount(&vcpu->arch.cputm_seqcount); 25949c23a131SDavid Hildenbrand /* 25959c23a131SDavid Hildenbrand * If the writer would ever execute a read in the critical 25969c23a131SDavid Hildenbrand * section, e.g. in irq context, we have a deadlock. 25979c23a131SDavid Hildenbrand */ 25989c23a131SDavid Hildenbrand WARN_ON_ONCE((seq & 1) && smp_processor_id() == vcpu->cpu); 2599db0758b2SDavid Hildenbrand value = vcpu->arch.sie_block->cputm; 26009c23a131SDavid Hildenbrand /* if cputm_start is 0, accounting is being started/stopped */ 26019c23a131SDavid Hildenbrand if (likely(vcpu->arch.cputm_start)) 2602db0758b2SDavid Hildenbrand value -= get_tod_clock_fast() - vcpu->arch.cputm_start; 26039c23a131SDavid Hildenbrand } while (read_seqcount_retry(&vcpu->arch.cputm_seqcount, seq & ~1)); 26049c23a131SDavid Hildenbrand preempt_enable(); 2605db0758b2SDavid Hildenbrand return value; 26064287f247SDavid Hildenbrand } 26074287f247SDavid Hildenbrand 2608b0c632dbSHeiko Carstens void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 2609b0c632dbSHeiko Carstens { 26109977e886SHendrik Brueckner 261137d9df98SDavid Hildenbrand gmap_enable(vcpu->arch.enabled_gmap); 2612ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_RUNNING); 26135ebda316SDavid Hildenbrand if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu)) 2614db0758b2SDavid Hildenbrand __start_cpu_timer_accounting(vcpu); 261501a745acSDavid Hildenbrand vcpu->cpu = cpu; 2616b0c632dbSHeiko Carstens } 2617b0c632dbSHeiko Carstens 2618b0c632dbSHeiko Carstens void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 2619b0c632dbSHeiko Carstens { 262001a745acSDavid Hildenbrand vcpu->cpu = -1; 26215ebda316SDavid Hildenbrand if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu)) 2622db0758b2SDavid Hildenbrand __stop_cpu_timer_accounting(vcpu); 26239daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_RUNNING); 262437d9df98SDavid Hildenbrand vcpu->arch.enabled_gmap = gmap_get_enabled(); 262537d9df98SDavid Hildenbrand gmap_disable(vcpu->arch.enabled_gmap); 26269977e886SHendrik Brueckner 2627b0c632dbSHeiko Carstens } 2628b0c632dbSHeiko Carstens 2629b0c632dbSHeiko Carstens static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu) 2630b0c632dbSHeiko Carstens { 2631b0c632dbSHeiko Carstens /* this equals initial cpu reset in pop, but we don't switch to ESA */ 2632b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.mask = 0UL; 2633b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.addr = 0UL; 26348d26cf7bSChristian Borntraeger kvm_s390_set_prefix(vcpu, 0); 26354287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, 0); 2636b0c632dbSHeiko Carstens vcpu->arch.sie_block->ckc = 0UL; 2637b0c632dbSHeiko Carstens vcpu->arch.sie_block->todpr = 0; 2638b0c632dbSHeiko Carstens memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64)); 2639b9224cd7SDavid Hildenbrand vcpu->arch.sie_block->gcr[0] = CR0_UNUSED_56 | 2640b9224cd7SDavid Hildenbrand CR0_INTERRUPT_KEY_SUBMASK | 2641b9224cd7SDavid Hildenbrand CR0_MEASUREMENT_ALERT_SUBMASK; 2642b9224cd7SDavid Hildenbrand vcpu->arch.sie_block->gcr[14] = CR14_UNUSED_32 | 2643b9224cd7SDavid Hildenbrand CR14_UNUSED_33 | 2644b9224cd7SDavid Hildenbrand CR14_EXTERNAL_DAMAGE_SUBMASK; 26459abc2a08SDavid Hildenbrand /* make sure the new fpc will be lazily loaded */ 26469abc2a08SDavid Hildenbrand save_fpu_regs(); 26479abc2a08SDavid Hildenbrand current->thread.fpu.fpc = 0; 2648b0c632dbSHeiko Carstens vcpu->arch.sie_block->gbea = 1; 2649672550fbSChristian Borntraeger vcpu->arch.sie_block->pp = 0; 265035b3fde6SChristian Borntraeger vcpu->arch.sie_block->fpf &= ~FPF_BPBC; 26513c038e6bSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 26523c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 26536352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) 26546852d7b6SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 26552ed10cc1SJens Freimann kvm_s390_clear_local_irqs(vcpu); 2656b0c632dbSHeiko Carstens } 2657b0c632dbSHeiko Carstens 265831928aa5SDominik Dingel void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu) 265942897d86SMarcelo Tosatti { 266072f25020SJason J. Herne mutex_lock(&vcpu->kvm->lock); 2661fdf03650SFan Zhang preempt_disable(); 266272f25020SJason J. Herne vcpu->arch.sie_block->epoch = vcpu->kvm->arch.epoch; 2663d16b52cbSDavid Hildenbrand vcpu->arch.sie_block->epdx = vcpu->kvm->arch.epdx; 2664fdf03650SFan Zhang preempt_enable(); 266572f25020SJason J. Herne mutex_unlock(&vcpu->kvm->lock); 266625508824SDavid Hildenbrand if (!kvm_is_ucontrol(vcpu->kvm)) { 2667dafd032aSDominik Dingel vcpu->arch.gmap = vcpu->kvm->arch.gmap; 2668eaa78f34SDavid Hildenbrand sca_add_vcpu(vcpu); 266925508824SDavid Hildenbrand } 26706502a34cSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 74) || vcpu->kvm->arch.user_instr0) 26716502a34cSDavid Hildenbrand vcpu->arch.sie_block->ictl |= ICTL_OPEREXC; 267237d9df98SDavid Hildenbrand /* make vcpu_load load the right gmap on the first trigger */ 267337d9df98SDavid Hildenbrand vcpu->arch.enabled_gmap = vcpu->arch.gmap; 267442897d86SMarcelo Tosatti } 267542897d86SMarcelo Tosatti 26765102ee87STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu) 26775102ee87STony Krowiak { 2678e585b24aSTony Krowiak /* 2679e585b24aSTony Krowiak * If the AP instructions are not being interpreted and the MSAX3 2680e585b24aSTony Krowiak * facility is not configured for the guest, there is nothing to set up. 2681e585b24aSTony Krowiak */ 2682e585b24aSTony Krowiak if (!vcpu->kvm->arch.crypto.apie && !test_kvm_facility(vcpu->kvm, 76)) 26835102ee87STony Krowiak return; 26845102ee87STony Krowiak 2685e585b24aSTony Krowiak vcpu->arch.sie_block->crycbd = vcpu->kvm->arch.crypto.crycbd; 2686a374e892STony Krowiak vcpu->arch.sie_block->ecb3 &= ~(ECB3_AES | ECB3_DEA); 268737940fb0STony Krowiak vcpu->arch.sie_block->eca &= ~ECA_APIE; 2688a374e892STony Krowiak 2689e585b24aSTony Krowiak if (vcpu->kvm->arch.crypto.apie) 2690e585b24aSTony Krowiak vcpu->arch.sie_block->eca |= ECA_APIE; 2691e585b24aSTony Krowiak 2692e585b24aSTony Krowiak /* Set up protected key support */ 2693a374e892STony Krowiak if (vcpu->kvm->arch.crypto.aes_kw) 2694a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_AES; 2695a374e892STony Krowiak if (vcpu->kvm->arch.crypto.dea_kw) 2696a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_DEA; 26975102ee87STony Krowiak } 26985102ee87STony Krowiak 2699b31605c1SDominik Dingel void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu) 2700b31605c1SDominik Dingel { 2701b31605c1SDominik Dingel free_page(vcpu->arch.sie_block->cbrlo); 2702b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = 0; 2703b31605c1SDominik Dingel } 2704b31605c1SDominik Dingel 2705b31605c1SDominik Dingel int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu) 2706b31605c1SDominik Dingel { 2707b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = get_zeroed_page(GFP_KERNEL); 2708b31605c1SDominik Dingel if (!vcpu->arch.sie_block->cbrlo) 2709b31605c1SDominik Dingel return -ENOMEM; 2710b31605c1SDominik Dingel return 0; 2711b31605c1SDominik Dingel } 2712b31605c1SDominik Dingel 271391520f1aSMichael Mueller static void kvm_s390_vcpu_setup_model(struct kvm_vcpu *vcpu) 271491520f1aSMichael Mueller { 271591520f1aSMichael Mueller struct kvm_s390_cpu_model *model = &vcpu->kvm->arch.model; 271691520f1aSMichael Mueller 271791520f1aSMichael Mueller vcpu->arch.sie_block->ibc = model->ibc; 271880bc79dcSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 7)) 2719c54f0d6aSDavid Hildenbrand vcpu->arch.sie_block->fac = (u32)(u64) model->fac_list; 272091520f1aSMichael Mueller } 272191520f1aSMichael Mueller 2722b0c632dbSHeiko Carstens int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) 2723b0c632dbSHeiko Carstens { 2724b31605c1SDominik Dingel int rc = 0; 2725b31288faSKonstantin Weitz 27269e6dabefSCornelia Huck atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH | 27279e6dabefSCornelia Huck CPUSTAT_SM | 2728a4a4f191SGuenther Hutzl CPUSTAT_STOPPED); 2729a4a4f191SGuenther Hutzl 273053df84f8SGuenther Hutzl if (test_kvm_facility(vcpu->kvm, 78)) 2731ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_GED2); 273253df84f8SGuenther Hutzl else if (test_kvm_facility(vcpu->kvm, 8)) 2733ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_GED); 2734a4a4f191SGuenther Hutzl 273591520f1aSMichael Mueller kvm_s390_vcpu_setup_model(vcpu); 273691520f1aSMichael Mueller 2737bdab09f3SDavid Hildenbrand /* pgste_set_pte has special handling for !MACHINE_HAS_ESOP */ 2738bdab09f3SDavid Hildenbrand if (MACHINE_HAS_ESOP) 27390c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb |= ECB_HOSTPROTINT; 2740bd50e8ecSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 9)) 27410c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb |= ECB_SRSI; 2742f597d24eSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 73)) 27430c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb |= ECB_TE; 27447feb6bb8SMichael Mueller 2745c9f0a2b8SJanosch Frank if (test_kvm_facility(vcpu->kvm, 8) && vcpu->kvm->arch.use_pfmfi) 27460c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= ECB2_PFMFI; 2747cd1836f5SJanosch Frank if (test_kvm_facility(vcpu->kvm, 130)) 27480c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= ECB2_IEP; 27490c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca = ECA_MVPGI | ECA_PROTEXCI; 275048ee7d3aSDavid Hildenbrand if (sclp.has_cei) 27510c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_CEI; 275211ad65b7SDavid Hildenbrand if (sclp.has_ib) 27530c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_IB; 275437c5f6c8SDavid Hildenbrand if (sclp.has_siif) 27550c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_SII; 275637c5f6c8SDavid Hildenbrand if (sclp.has_sigpif) 27570c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_SIGPI; 275818280d8bSMichael Mueller if (test_kvm_facility(vcpu->kvm, 129)) { 27590c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_VX; 27600c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecd |= ECD_HOSTREGMGMT; 276113211ea7SEric Farman } 27628fa1696eSCollin L. Walling if (test_kvm_facility(vcpu->kvm, 139)) 27638fa1696eSCollin L. Walling vcpu->arch.sie_block->ecd |= ECD_MEF; 2764a3da7b4aSChristian Borntraeger if (test_kvm_facility(vcpu->kvm, 156)) 2765a3da7b4aSChristian Borntraeger vcpu->arch.sie_block->ecd |= ECD_ETOKENF; 2766d7c5cb01SMichael Mueller if (vcpu->arch.sie_block->gd) { 2767d7c5cb01SMichael Mueller vcpu->arch.sie_block->eca |= ECA_AIV; 2768d7c5cb01SMichael Mueller VCPU_EVENT(vcpu, 3, "AIV gisa format-%u enabled for cpu %03u", 2769d7c5cb01SMichael Mueller vcpu->arch.sie_block->gd & 0x3, vcpu->vcpu_id); 2770d7c5cb01SMichael Mueller } 27714e0b1ab7SFan Zhang vcpu->arch.sie_block->sdnxo = ((unsigned long) &vcpu->run->s.regs.sdnx) 27724e0b1ab7SFan Zhang | SDNXC; 2773c6e5f166SFan Zhang vcpu->arch.sie_block->riccbd = (unsigned long) &vcpu->run->s.regs.riccb; 2774730cd632SFarhan Ali 2775730cd632SFarhan Ali if (sclp.has_kss) 2776ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_KSS); 2777730cd632SFarhan Ali else 2778492d8642SThomas Huth vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE; 27795a5e6536SMatthew Rosato 2780e6db1d61SDominik Dingel if (vcpu->kvm->arch.use_cmma) { 2781b31605c1SDominik Dingel rc = kvm_s390_vcpu_setup_cmma(vcpu); 2782b31605c1SDominik Dingel if (rc) 2783b31605c1SDominik Dingel return rc; 2784b31288faSKonstantin Weitz } 27850ac96cafSDavid Hildenbrand hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 2786ca872302SChristian Borntraeger vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup; 27879d8d5786SMichael Mueller 278867d49d52SCollin Walling vcpu->arch.sie_block->hpid = HPID_KVM; 278967d49d52SCollin Walling 27905102ee87STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 27915102ee87STony Krowiak 2792b31605c1SDominik Dingel return rc; 2793b0c632dbSHeiko Carstens } 2794b0c632dbSHeiko Carstens 2795b0c632dbSHeiko Carstens struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, 2796b0c632dbSHeiko Carstens unsigned int id) 2797b0c632dbSHeiko Carstens { 27984d47555aSCarsten Otte struct kvm_vcpu *vcpu; 27997feb6bb8SMichael Mueller struct sie_page *sie_page; 28004d47555aSCarsten Otte int rc = -EINVAL; 2801b0c632dbSHeiko Carstens 28024215825eSDavid Hildenbrand if (!kvm_is_ucontrol(kvm) && !sca_can_add_vcpu(kvm, id)) 28034d47555aSCarsten Otte goto out; 28044d47555aSCarsten Otte 28054d47555aSCarsten Otte rc = -ENOMEM; 28064d47555aSCarsten Otte 2807b110feafSMichael Mueller vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL); 2808b0c632dbSHeiko Carstens if (!vcpu) 28094d47555aSCarsten Otte goto out; 2810b0c632dbSHeiko Carstens 2811da72ca4dSQingFeng Hao BUILD_BUG_ON(sizeof(struct sie_page) != 4096); 28127feb6bb8SMichael Mueller sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL); 28137feb6bb8SMichael Mueller if (!sie_page) 2814b0c632dbSHeiko Carstens goto out_free_cpu; 2815b0c632dbSHeiko Carstens 28167feb6bb8SMichael Mueller vcpu->arch.sie_block = &sie_page->sie_block; 28177feb6bb8SMichael Mueller vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb; 28187feb6bb8SMichael Mueller 2819efed1104SDavid Hildenbrand /* the real guest size will always be smaller than msl */ 2820efed1104SDavid Hildenbrand vcpu->arch.sie_block->mso = 0; 2821efed1104SDavid Hildenbrand vcpu->arch.sie_block->msl = sclp.hamax; 2822efed1104SDavid Hildenbrand 2823b0c632dbSHeiko Carstens vcpu->arch.sie_block->icpua = id; 2824ba5c1e9bSCarsten Otte spin_lock_init(&vcpu->arch.local_int.lock); 2825d7c5cb01SMichael Mueller vcpu->arch.sie_block->gd = (u32)(u64)kvm->arch.gisa; 28264b9f9525SMichael Mueller if (vcpu->arch.sie_block->gd && sclp.has_gisaf) 28274b9f9525SMichael Mueller vcpu->arch.sie_block->gd |= GISA_FORMAT1; 28289c23a131SDavid Hildenbrand seqcount_init(&vcpu->arch.cputm_seqcount); 2829ba5c1e9bSCarsten Otte 2830b0c632dbSHeiko Carstens rc = kvm_vcpu_init(vcpu, kvm, id); 2831b0c632dbSHeiko Carstens if (rc) 28329abc2a08SDavid Hildenbrand goto out_free_sie_block; 28338335713aSChristian Borntraeger VM_EVENT(kvm, 3, "create cpu %d at 0x%pK, sie block at 0x%pK", id, vcpu, 2834b0c632dbSHeiko Carstens vcpu->arch.sie_block); 2835ade38c31SCornelia Huck trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block); 2836b0c632dbSHeiko Carstens 2837b0c632dbSHeiko Carstens return vcpu; 28387b06bf2fSWei Yongjun out_free_sie_block: 28397b06bf2fSWei Yongjun free_page((unsigned long)(vcpu->arch.sie_block)); 2840b0c632dbSHeiko Carstens out_free_cpu: 2841b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 28424d47555aSCarsten Otte out: 2843b0c632dbSHeiko Carstens return ERR_PTR(rc); 2844b0c632dbSHeiko Carstens } 2845b0c632dbSHeiko Carstens 2846b0c632dbSHeiko Carstens int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu) 2847b0c632dbSHeiko Carstens { 28489a022067SDavid Hildenbrand return kvm_s390_vcpu_has_irq(vcpu, 0); 2849b0c632dbSHeiko Carstens } 2850b0c632dbSHeiko Carstens 2851199b5763SLongpeng(Mike) bool kvm_arch_vcpu_in_kernel(struct kvm_vcpu *vcpu) 2852199b5763SLongpeng(Mike) { 28530546c63dSLongpeng(Mike) return !(vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE); 2854199b5763SLongpeng(Mike) } 2855199b5763SLongpeng(Mike) 285627406cd5SChristian Borntraeger void kvm_s390_vcpu_block(struct kvm_vcpu *vcpu) 285749b99e1eSChristian Borntraeger { 2858805de8f4SPeter Zijlstra atomic_or(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 285961a6df54SDavid Hildenbrand exit_sie(vcpu); 286049b99e1eSChristian Borntraeger } 286149b99e1eSChristian Borntraeger 286227406cd5SChristian Borntraeger void kvm_s390_vcpu_unblock(struct kvm_vcpu *vcpu) 286349b99e1eSChristian Borntraeger { 2864805de8f4SPeter Zijlstra atomic_andnot(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 286549b99e1eSChristian Borntraeger } 286649b99e1eSChristian Borntraeger 28678e236546SChristian Borntraeger static void kvm_s390_vcpu_request(struct kvm_vcpu *vcpu) 28688e236546SChristian Borntraeger { 2869805de8f4SPeter Zijlstra atomic_or(PROG_REQUEST, &vcpu->arch.sie_block->prog20); 287061a6df54SDavid Hildenbrand exit_sie(vcpu); 28718e236546SChristian Borntraeger } 28728e236546SChristian Borntraeger 28739ea59728SDavid Hildenbrand bool kvm_s390_vcpu_sie_inhibited(struct kvm_vcpu *vcpu) 28749ea59728SDavid Hildenbrand { 28759ea59728SDavid Hildenbrand return atomic_read(&vcpu->arch.sie_block->prog20) & 28769ea59728SDavid Hildenbrand (PROG_BLOCK_SIE | PROG_REQUEST); 28779ea59728SDavid Hildenbrand } 28789ea59728SDavid Hildenbrand 28798e236546SChristian Borntraeger static void kvm_s390_vcpu_request_handled(struct kvm_vcpu *vcpu) 28808e236546SChristian Borntraeger { 28819bf9fde2SJason J. Herne atomic_andnot(PROG_REQUEST, &vcpu->arch.sie_block->prog20); 28828e236546SChristian Borntraeger } 28838e236546SChristian Borntraeger 288449b99e1eSChristian Borntraeger /* 28859ea59728SDavid Hildenbrand * Kick a guest cpu out of (v)SIE and wait until (v)SIE is not running. 288649b99e1eSChristian Borntraeger * If the CPU is not running (e.g. waiting as idle) the function will 288749b99e1eSChristian Borntraeger * return immediately. */ 288849b99e1eSChristian Borntraeger void exit_sie(struct kvm_vcpu *vcpu) 288949b99e1eSChristian Borntraeger { 2890ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_STOP_INT); 28919ea59728SDavid Hildenbrand kvm_s390_vsie_kick(vcpu); 289249b99e1eSChristian Borntraeger while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE) 289349b99e1eSChristian Borntraeger cpu_relax(); 289449b99e1eSChristian Borntraeger } 289549b99e1eSChristian Borntraeger 28968e236546SChristian Borntraeger /* Kick a guest cpu out of SIE to process a request synchronously */ 28978e236546SChristian Borntraeger void kvm_s390_sync_request(int req, struct kvm_vcpu *vcpu) 289849b99e1eSChristian Borntraeger { 28998e236546SChristian Borntraeger kvm_make_request(req, vcpu); 29008e236546SChristian Borntraeger kvm_s390_vcpu_request(vcpu); 290149b99e1eSChristian Borntraeger } 290249b99e1eSChristian Borntraeger 2903414d3b07SMartin Schwidefsky static void kvm_gmap_notifier(struct gmap *gmap, unsigned long start, 2904414d3b07SMartin Schwidefsky unsigned long end) 29052c70fe44SChristian Borntraeger { 29062c70fe44SChristian Borntraeger struct kvm *kvm = gmap->private; 29072c70fe44SChristian Borntraeger struct kvm_vcpu *vcpu; 2908414d3b07SMartin Schwidefsky unsigned long prefix; 2909414d3b07SMartin Schwidefsky int i; 29102c70fe44SChristian Borntraeger 291165d0b0d4SDavid Hildenbrand if (gmap_is_shadow(gmap)) 291265d0b0d4SDavid Hildenbrand return; 2913414d3b07SMartin Schwidefsky if (start >= 1UL << 31) 2914414d3b07SMartin Schwidefsky /* We are only interested in prefix pages */ 2915414d3b07SMartin Schwidefsky return; 29162c70fe44SChristian Borntraeger kvm_for_each_vcpu(i, vcpu, kvm) { 29172c70fe44SChristian Borntraeger /* match against both prefix pages */ 2918414d3b07SMartin Schwidefsky prefix = kvm_s390_get_prefix(vcpu); 2919414d3b07SMartin Schwidefsky if (prefix <= end && start <= prefix + 2*PAGE_SIZE - 1) { 2920414d3b07SMartin Schwidefsky VCPU_EVENT(vcpu, 2, "gmap notifier for %lx-%lx", 2921414d3b07SMartin Schwidefsky start, end); 29228e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_MMU_RELOAD, vcpu); 29232c70fe44SChristian Borntraeger } 29242c70fe44SChristian Borntraeger } 29252c70fe44SChristian Borntraeger } 29262c70fe44SChristian Borntraeger 2927b6d33834SChristoffer Dall int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu) 2928b6d33834SChristoffer Dall { 2929b6d33834SChristoffer Dall /* kvm common code refers to this, but never calls it */ 2930b6d33834SChristoffer Dall BUG(); 2931b6d33834SChristoffer Dall return 0; 2932b6d33834SChristoffer Dall } 2933b6d33834SChristoffer Dall 293414eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, 293514eebd91SCarsten Otte struct kvm_one_reg *reg) 293614eebd91SCarsten Otte { 293714eebd91SCarsten Otte int r = -EINVAL; 293814eebd91SCarsten Otte 293914eebd91SCarsten Otte switch (reg->id) { 294029b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 294129b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->todpr, 294229b7c71bSCarsten Otte (u32 __user *)reg->addr); 294329b7c71bSCarsten Otte break; 294429b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 294529b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->epoch, 294629b7c71bSCarsten Otte (u64 __user *)reg->addr); 294729b7c71bSCarsten Otte break; 294846a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 29494287f247SDavid Hildenbrand r = put_user(kvm_s390_get_cpu_timer(vcpu), 295046a6dd1cSJason J. herne (u64 __user *)reg->addr); 295146a6dd1cSJason J. herne break; 295246a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 295346a6dd1cSJason J. herne r = put_user(vcpu->arch.sie_block->ckc, 295446a6dd1cSJason J. herne (u64 __user *)reg->addr); 295546a6dd1cSJason J. herne break; 2956536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 2957536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_token, 2958536336c2SDominik Dingel (u64 __user *)reg->addr); 2959536336c2SDominik Dingel break; 2960536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 2961536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_compare, 2962536336c2SDominik Dingel (u64 __user *)reg->addr); 2963536336c2SDominik Dingel break; 2964536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 2965536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_select, 2966536336c2SDominik Dingel (u64 __user *)reg->addr); 2967536336c2SDominik Dingel break; 2968672550fbSChristian Borntraeger case KVM_REG_S390_PP: 2969672550fbSChristian Borntraeger r = put_user(vcpu->arch.sie_block->pp, 2970672550fbSChristian Borntraeger (u64 __user *)reg->addr); 2971672550fbSChristian Borntraeger break; 2972afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 2973afa45ff5SChristian Borntraeger r = put_user(vcpu->arch.sie_block->gbea, 2974afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 2975afa45ff5SChristian Borntraeger break; 297614eebd91SCarsten Otte default: 297714eebd91SCarsten Otte break; 297814eebd91SCarsten Otte } 297914eebd91SCarsten Otte 298014eebd91SCarsten Otte return r; 298114eebd91SCarsten Otte } 298214eebd91SCarsten Otte 298314eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, 298414eebd91SCarsten Otte struct kvm_one_reg *reg) 298514eebd91SCarsten Otte { 298614eebd91SCarsten Otte int r = -EINVAL; 29874287f247SDavid Hildenbrand __u64 val; 298814eebd91SCarsten Otte 298914eebd91SCarsten Otte switch (reg->id) { 299029b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 299129b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->todpr, 299229b7c71bSCarsten Otte (u32 __user *)reg->addr); 299329b7c71bSCarsten Otte break; 299429b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 299529b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->epoch, 299629b7c71bSCarsten Otte (u64 __user *)reg->addr); 299729b7c71bSCarsten Otte break; 299846a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 29994287f247SDavid Hildenbrand r = get_user(val, (u64 __user *)reg->addr); 30004287f247SDavid Hildenbrand if (!r) 30014287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, val); 300246a6dd1cSJason J. herne break; 300346a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 300446a6dd1cSJason J. herne r = get_user(vcpu->arch.sie_block->ckc, 300546a6dd1cSJason J. herne (u64 __user *)reg->addr); 300646a6dd1cSJason J. herne break; 3007536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 3008536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_token, 3009536336c2SDominik Dingel (u64 __user *)reg->addr); 30109fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 30119fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 3012536336c2SDominik Dingel break; 3013536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 3014536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_compare, 3015536336c2SDominik Dingel (u64 __user *)reg->addr); 3016536336c2SDominik Dingel break; 3017536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 3018536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_select, 3019536336c2SDominik Dingel (u64 __user *)reg->addr); 3020536336c2SDominik Dingel break; 3021672550fbSChristian Borntraeger case KVM_REG_S390_PP: 3022672550fbSChristian Borntraeger r = get_user(vcpu->arch.sie_block->pp, 3023672550fbSChristian Borntraeger (u64 __user *)reg->addr); 3024672550fbSChristian Borntraeger break; 3025afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 3026afa45ff5SChristian Borntraeger r = get_user(vcpu->arch.sie_block->gbea, 3027afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 3028afa45ff5SChristian Borntraeger break; 302914eebd91SCarsten Otte default: 303014eebd91SCarsten Otte break; 303114eebd91SCarsten Otte } 303214eebd91SCarsten Otte 303314eebd91SCarsten Otte return r; 303414eebd91SCarsten Otte } 3035b6d33834SChristoffer Dall 3036b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) 3037b0c632dbSHeiko Carstens { 3038b0c632dbSHeiko Carstens kvm_s390_vcpu_initial_reset(vcpu); 3039b0c632dbSHeiko Carstens return 0; 3040b0c632dbSHeiko Carstens } 3041b0c632dbSHeiko Carstens 3042b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 3043b0c632dbSHeiko Carstens { 3044875656feSChristoffer Dall vcpu_load(vcpu); 30455a32c1afSChristian Borntraeger memcpy(&vcpu->run->s.regs.gprs, ®s->gprs, sizeof(regs->gprs)); 3046875656feSChristoffer Dall vcpu_put(vcpu); 3047b0c632dbSHeiko Carstens return 0; 3048b0c632dbSHeiko Carstens } 3049b0c632dbSHeiko Carstens 3050b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 3051b0c632dbSHeiko Carstens { 30521fc9b76bSChristoffer Dall vcpu_load(vcpu); 30535a32c1afSChristian Borntraeger memcpy(®s->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs)); 30541fc9b76bSChristoffer Dall vcpu_put(vcpu); 3055b0c632dbSHeiko Carstens return 0; 3056b0c632dbSHeiko Carstens } 3057b0c632dbSHeiko Carstens 3058b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, 3059b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 3060b0c632dbSHeiko Carstens { 3061b4ef9d4eSChristoffer Dall vcpu_load(vcpu); 3062b4ef9d4eSChristoffer Dall 306359674c1aSChristian Borntraeger memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs)); 3064b0c632dbSHeiko Carstens memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs)); 3065b4ef9d4eSChristoffer Dall 3066b4ef9d4eSChristoffer Dall vcpu_put(vcpu); 3067b0c632dbSHeiko Carstens return 0; 3068b0c632dbSHeiko Carstens } 3069b0c632dbSHeiko Carstens 3070b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, 3071b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 3072b0c632dbSHeiko Carstens { 3073bcdec41cSChristoffer Dall vcpu_load(vcpu); 3074bcdec41cSChristoffer Dall 307559674c1aSChristian Borntraeger memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs)); 3076b0c632dbSHeiko Carstens memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs)); 3077bcdec41cSChristoffer Dall 3078bcdec41cSChristoffer Dall vcpu_put(vcpu); 3079b0c632dbSHeiko Carstens return 0; 3080b0c632dbSHeiko Carstens } 3081b0c632dbSHeiko Carstens 3082b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 3083b0c632dbSHeiko Carstens { 30846a96bc7fSChristoffer Dall int ret = 0; 30856a96bc7fSChristoffer Dall 30866a96bc7fSChristoffer Dall vcpu_load(vcpu); 30876a96bc7fSChristoffer Dall 30886a96bc7fSChristoffer Dall if (test_fp_ctl(fpu->fpc)) { 30896a96bc7fSChristoffer Dall ret = -EINVAL; 30906a96bc7fSChristoffer Dall goto out; 30916a96bc7fSChristoffer Dall } 3092e1788bb9SChristian Borntraeger vcpu->run->s.regs.fpc = fpu->fpc; 30939abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) 3094a7d4b8f2SDavid Hildenbrand convert_fp_to_vx((__vector128 *) vcpu->run->s.regs.vrs, 3095a7d4b8f2SDavid Hildenbrand (freg_t *) fpu->fprs); 30969abc2a08SDavid Hildenbrand else 3097a7d4b8f2SDavid Hildenbrand memcpy(vcpu->run->s.regs.fprs, &fpu->fprs, sizeof(fpu->fprs)); 30986a96bc7fSChristoffer Dall 30996a96bc7fSChristoffer Dall out: 31006a96bc7fSChristoffer Dall vcpu_put(vcpu); 31016a96bc7fSChristoffer Dall return ret; 3102b0c632dbSHeiko Carstens } 3103b0c632dbSHeiko Carstens 3104b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 3105b0c632dbSHeiko Carstens { 31061393123eSChristoffer Dall vcpu_load(vcpu); 31071393123eSChristoffer Dall 31089abc2a08SDavid Hildenbrand /* make sure we have the latest values */ 31099abc2a08SDavid Hildenbrand save_fpu_regs(); 31109abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) 3111a7d4b8f2SDavid Hildenbrand convert_vx_to_fp((freg_t *) fpu->fprs, 3112a7d4b8f2SDavid Hildenbrand (__vector128 *) vcpu->run->s.regs.vrs); 31139abc2a08SDavid Hildenbrand else 3114a7d4b8f2SDavid Hildenbrand memcpy(fpu->fprs, vcpu->run->s.regs.fprs, sizeof(fpu->fprs)); 3115e1788bb9SChristian Borntraeger fpu->fpc = vcpu->run->s.regs.fpc; 31161393123eSChristoffer Dall 31171393123eSChristoffer Dall vcpu_put(vcpu); 3118b0c632dbSHeiko Carstens return 0; 3119b0c632dbSHeiko Carstens } 3120b0c632dbSHeiko Carstens 3121b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw) 3122b0c632dbSHeiko Carstens { 3123b0c632dbSHeiko Carstens int rc = 0; 3124b0c632dbSHeiko Carstens 31257a42fdc2SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 3126b0c632dbSHeiko Carstens rc = -EBUSY; 3127d7b0b5ebSCarsten Otte else { 3128d7b0b5ebSCarsten Otte vcpu->run->psw_mask = psw.mask; 3129d7b0b5ebSCarsten Otte vcpu->run->psw_addr = psw.addr; 3130d7b0b5ebSCarsten Otte } 3131b0c632dbSHeiko Carstens return rc; 3132b0c632dbSHeiko Carstens } 3133b0c632dbSHeiko Carstens 3134b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, 3135b0c632dbSHeiko Carstens struct kvm_translation *tr) 3136b0c632dbSHeiko Carstens { 3137b0c632dbSHeiko Carstens return -EINVAL; /* not implemented yet */ 3138b0c632dbSHeiko Carstens } 3139b0c632dbSHeiko Carstens 314027291e21SDavid Hildenbrand #define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \ 314127291e21SDavid Hildenbrand KVM_GUESTDBG_USE_HW_BP | \ 314227291e21SDavid Hildenbrand KVM_GUESTDBG_ENABLE) 314327291e21SDavid Hildenbrand 3144d0bfb940SJan Kiszka int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 3145d0bfb940SJan Kiszka struct kvm_guest_debug *dbg) 3146b0c632dbSHeiko Carstens { 314727291e21SDavid Hildenbrand int rc = 0; 314827291e21SDavid Hildenbrand 314966b56562SChristoffer Dall vcpu_load(vcpu); 315066b56562SChristoffer Dall 315127291e21SDavid Hildenbrand vcpu->guest_debug = 0; 315227291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 315327291e21SDavid Hildenbrand 315466b56562SChristoffer Dall if (dbg->control & ~VALID_GUESTDBG_FLAGS) { 315566b56562SChristoffer Dall rc = -EINVAL; 315666b56562SChristoffer Dall goto out; 315766b56562SChristoffer Dall } 315866b56562SChristoffer Dall if (!sclp.has_gpere) { 315966b56562SChristoffer Dall rc = -EINVAL; 316066b56562SChristoffer Dall goto out; 316166b56562SChristoffer Dall } 316227291e21SDavid Hildenbrand 316327291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_ENABLE) { 316427291e21SDavid Hildenbrand vcpu->guest_debug = dbg->control; 316527291e21SDavid Hildenbrand /* enforce guest PER */ 3166ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_P); 316727291e21SDavid Hildenbrand 316827291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_USE_HW_BP) 316927291e21SDavid Hildenbrand rc = kvm_s390_import_bp_data(vcpu, dbg); 317027291e21SDavid Hildenbrand } else { 31719daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_P); 317227291e21SDavid Hildenbrand vcpu->arch.guestdbg.last_bp = 0; 317327291e21SDavid Hildenbrand } 317427291e21SDavid Hildenbrand 317527291e21SDavid Hildenbrand if (rc) { 317627291e21SDavid Hildenbrand vcpu->guest_debug = 0; 317727291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 31789daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_P); 317927291e21SDavid Hildenbrand } 318027291e21SDavid Hildenbrand 318166b56562SChristoffer Dall out: 318266b56562SChristoffer Dall vcpu_put(vcpu); 318327291e21SDavid Hildenbrand return rc; 3184b0c632dbSHeiko Carstens } 3185b0c632dbSHeiko Carstens 318662d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 318762d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 318862d9f0dbSMarcelo Tosatti { 3189fd232561SChristoffer Dall int ret; 3190fd232561SChristoffer Dall 3191fd232561SChristoffer Dall vcpu_load(vcpu); 3192fd232561SChristoffer Dall 31936352e4d2SDavid Hildenbrand /* CHECK_STOP and LOAD are not supported yet */ 3194fd232561SChristoffer Dall ret = is_vcpu_stopped(vcpu) ? KVM_MP_STATE_STOPPED : 31956352e4d2SDavid Hildenbrand KVM_MP_STATE_OPERATING; 3196fd232561SChristoffer Dall 3197fd232561SChristoffer Dall vcpu_put(vcpu); 3198fd232561SChristoffer Dall return ret; 319962d9f0dbSMarcelo Tosatti } 320062d9f0dbSMarcelo Tosatti 320162d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 320262d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 320362d9f0dbSMarcelo Tosatti { 32046352e4d2SDavid Hildenbrand int rc = 0; 32056352e4d2SDavid Hildenbrand 3206e83dff5eSChristoffer Dall vcpu_load(vcpu); 3207e83dff5eSChristoffer Dall 32086352e4d2SDavid Hildenbrand /* user space knows about this interface - let it control the state */ 32096352e4d2SDavid Hildenbrand vcpu->kvm->arch.user_cpu_state_ctrl = 1; 32106352e4d2SDavid Hildenbrand 32116352e4d2SDavid Hildenbrand switch (mp_state->mp_state) { 32126352e4d2SDavid Hildenbrand case KVM_MP_STATE_STOPPED: 32136352e4d2SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 32146352e4d2SDavid Hildenbrand break; 32156352e4d2SDavid Hildenbrand case KVM_MP_STATE_OPERATING: 32166352e4d2SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 32176352e4d2SDavid Hildenbrand break; 32186352e4d2SDavid Hildenbrand case KVM_MP_STATE_LOAD: 32196352e4d2SDavid Hildenbrand case KVM_MP_STATE_CHECK_STOP: 32206352e4d2SDavid Hildenbrand /* fall through - CHECK_STOP and LOAD are not supported yet */ 32216352e4d2SDavid Hildenbrand default: 32226352e4d2SDavid Hildenbrand rc = -ENXIO; 32236352e4d2SDavid Hildenbrand } 32246352e4d2SDavid Hildenbrand 3225e83dff5eSChristoffer Dall vcpu_put(vcpu); 32266352e4d2SDavid Hildenbrand return rc; 322762d9f0dbSMarcelo Tosatti } 322862d9f0dbSMarcelo Tosatti 32298ad35755SDavid Hildenbrand static bool ibs_enabled(struct kvm_vcpu *vcpu) 32308ad35755SDavid Hildenbrand { 32318d5fb0dcSDavid Hildenbrand return kvm_s390_test_cpuflags(vcpu, CPUSTAT_IBS); 32328ad35755SDavid Hildenbrand } 32338ad35755SDavid Hildenbrand 32342c70fe44SChristian Borntraeger static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu) 32352c70fe44SChristian Borntraeger { 32368ad35755SDavid Hildenbrand retry: 32378e236546SChristian Borntraeger kvm_s390_vcpu_request_handled(vcpu); 32382fa6e1e1SRadim Krčmář if (!kvm_request_pending(vcpu)) 3239586b7ccdSChristian Borntraeger return 0; 32402c70fe44SChristian Borntraeger /* 32412c70fe44SChristian Borntraeger * We use MMU_RELOAD just to re-arm the ipte notifier for the 3242b2d73b2aSMartin Schwidefsky * guest prefix page. gmap_mprotect_notify will wait on the ptl lock. 32432c70fe44SChristian Borntraeger * This ensures that the ipte instruction for this request has 32442c70fe44SChristian Borntraeger * already finished. We might race against a second unmapper that 32452c70fe44SChristian Borntraeger * wants to set the blocking bit. Lets just retry the request loop. 32462c70fe44SChristian Borntraeger */ 32478ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) { 32482c70fe44SChristian Borntraeger int rc; 3249b2d73b2aSMartin Schwidefsky rc = gmap_mprotect_notify(vcpu->arch.gmap, 3250fda902cbSMichael Mueller kvm_s390_get_prefix(vcpu), 3251b2d73b2aSMartin Schwidefsky PAGE_SIZE * 2, PROT_WRITE); 3252aca411a4SJulius Niedworok if (rc) { 3253aca411a4SJulius Niedworok kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu); 32542c70fe44SChristian Borntraeger return rc; 3255aca411a4SJulius Niedworok } 32568ad35755SDavid Hildenbrand goto retry; 32572c70fe44SChristian Borntraeger } 32588ad35755SDavid Hildenbrand 3259d3d692c8SDavid Hildenbrand if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu)) { 3260d3d692c8SDavid Hildenbrand vcpu->arch.sie_block->ihcpu = 0xffff; 3261d3d692c8SDavid Hildenbrand goto retry; 3262d3d692c8SDavid Hildenbrand } 3263d3d692c8SDavid Hildenbrand 32648ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu)) { 32658ad35755SDavid Hildenbrand if (!ibs_enabled(vcpu)) { 32668ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 1); 3267ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_IBS); 32688ad35755SDavid Hildenbrand } 32698ad35755SDavid Hildenbrand goto retry; 32708ad35755SDavid Hildenbrand } 32718ad35755SDavid Hildenbrand 32728ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu)) { 32738ad35755SDavid Hildenbrand if (ibs_enabled(vcpu)) { 32748ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 0); 32759daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_IBS); 32768ad35755SDavid Hildenbrand } 32778ad35755SDavid Hildenbrand goto retry; 32788ad35755SDavid Hildenbrand } 32798ad35755SDavid Hildenbrand 32806502a34cSDavid Hildenbrand if (kvm_check_request(KVM_REQ_ICPT_OPEREXC, vcpu)) { 32816502a34cSDavid Hildenbrand vcpu->arch.sie_block->ictl |= ICTL_OPEREXC; 32826502a34cSDavid Hildenbrand goto retry; 32836502a34cSDavid Hildenbrand } 32846502a34cSDavid Hildenbrand 3285190df4a2SClaudio Imbrenda if (kvm_check_request(KVM_REQ_START_MIGRATION, vcpu)) { 3286190df4a2SClaudio Imbrenda /* 3287c9f0a2b8SJanosch Frank * Disable CMM virtualization; we will emulate the ESSA 3288190df4a2SClaudio Imbrenda * instruction manually, in order to provide additional 3289190df4a2SClaudio Imbrenda * functionalities needed for live migration. 3290190df4a2SClaudio Imbrenda */ 3291190df4a2SClaudio Imbrenda vcpu->arch.sie_block->ecb2 &= ~ECB2_CMMA; 3292190df4a2SClaudio Imbrenda goto retry; 3293190df4a2SClaudio Imbrenda } 3294190df4a2SClaudio Imbrenda 3295190df4a2SClaudio Imbrenda if (kvm_check_request(KVM_REQ_STOP_MIGRATION, vcpu)) { 3296190df4a2SClaudio Imbrenda /* 3297c9f0a2b8SJanosch Frank * Re-enable CMM virtualization if CMMA is available and 3298c9f0a2b8SJanosch Frank * CMM has been used. 3299190df4a2SClaudio Imbrenda */ 3300190df4a2SClaudio Imbrenda if ((vcpu->kvm->arch.use_cmma) && 3301c9f0a2b8SJanosch Frank (vcpu->kvm->mm->context.uses_cmm)) 3302190df4a2SClaudio Imbrenda vcpu->arch.sie_block->ecb2 |= ECB2_CMMA; 3303190df4a2SClaudio Imbrenda goto retry; 3304190df4a2SClaudio Imbrenda } 3305190df4a2SClaudio Imbrenda 33060759d068SDavid Hildenbrand /* nothing to do, just clear the request */ 330772875d8aSRadim Krčmář kvm_clear_request(KVM_REQ_UNHALT, vcpu); 33083194cdb7SDavid Hildenbrand /* we left the vsie handler, nothing to do, just clear the request */ 33093194cdb7SDavid Hildenbrand kvm_clear_request(KVM_REQ_VSIE_RESTART, vcpu); 33100759d068SDavid Hildenbrand 33112c70fe44SChristian Borntraeger return 0; 33122c70fe44SChristian Borntraeger } 33132c70fe44SChristian Borntraeger 33140e7def5fSDavid Hildenbrand void kvm_s390_set_tod_clock(struct kvm *kvm, 33158fa1696eSCollin L. Walling const struct kvm_s390_vm_tod_clock *gtod) 33168fa1696eSCollin L. Walling { 33178fa1696eSCollin L. Walling struct kvm_vcpu *vcpu; 33188fa1696eSCollin L. Walling struct kvm_s390_tod_clock_ext htod; 33198fa1696eSCollin L. Walling int i; 33208fa1696eSCollin L. Walling 33218fa1696eSCollin L. Walling mutex_lock(&kvm->lock); 33228fa1696eSCollin L. Walling preempt_disable(); 33238fa1696eSCollin L. Walling 33248fa1696eSCollin L. Walling get_tod_clock_ext((char *)&htod); 33258fa1696eSCollin L. Walling 33268fa1696eSCollin L. Walling kvm->arch.epoch = gtod->tod - htod.tod; 33270e7def5fSDavid Hildenbrand kvm->arch.epdx = 0; 33280e7def5fSDavid Hildenbrand if (test_kvm_facility(kvm, 139)) { 33298fa1696eSCollin L. Walling kvm->arch.epdx = gtod->epoch_idx - htod.epoch_idx; 33308fa1696eSCollin L. Walling if (kvm->arch.epoch > gtod->tod) 33318fa1696eSCollin L. Walling kvm->arch.epdx -= 1; 33320e7def5fSDavid Hildenbrand } 33338fa1696eSCollin L. Walling 33348fa1696eSCollin L. Walling kvm_s390_vcpu_block_all(kvm); 33358fa1696eSCollin L. Walling kvm_for_each_vcpu(i, vcpu, kvm) { 33368fa1696eSCollin L. Walling vcpu->arch.sie_block->epoch = kvm->arch.epoch; 33378fa1696eSCollin L. Walling vcpu->arch.sie_block->epdx = kvm->arch.epdx; 33388fa1696eSCollin L. Walling } 33398fa1696eSCollin L. Walling 33408fa1696eSCollin L. Walling kvm_s390_vcpu_unblock_all(kvm); 33418fa1696eSCollin L. Walling preempt_enable(); 33428fa1696eSCollin L. Walling mutex_unlock(&kvm->lock); 33438fa1696eSCollin L. Walling } 33448fa1696eSCollin L. Walling 3345fa576c58SThomas Huth /** 3346fa576c58SThomas Huth * kvm_arch_fault_in_page - fault-in guest page if necessary 3347fa576c58SThomas Huth * @vcpu: The corresponding virtual cpu 3348fa576c58SThomas Huth * @gpa: Guest physical address 3349fa576c58SThomas Huth * @writable: Whether the page should be writable or not 3350fa576c58SThomas Huth * 3351fa576c58SThomas Huth * Make sure that a guest page has been faulted-in on the host. 3352fa576c58SThomas Huth * 3353fa576c58SThomas Huth * Return: Zero on success, negative error code otherwise. 3354fa576c58SThomas Huth */ 3355fa576c58SThomas Huth long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable) 335624eb3a82SDominik Dingel { 3357527e30b4SMartin Schwidefsky return gmap_fault(vcpu->arch.gmap, gpa, 3358527e30b4SMartin Schwidefsky writable ? FAULT_FLAG_WRITE : 0); 335924eb3a82SDominik Dingel } 336024eb3a82SDominik Dingel 33613c038e6bSDominik Dingel static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token, 33623c038e6bSDominik Dingel unsigned long token) 33633c038e6bSDominik Dingel { 33643c038e6bSDominik Dingel struct kvm_s390_interrupt inti; 3365383d0b05SJens Freimann struct kvm_s390_irq irq; 33663c038e6bSDominik Dingel 33673c038e6bSDominik Dingel if (start_token) { 3368383d0b05SJens Freimann irq.u.ext.ext_params2 = token; 3369383d0b05SJens Freimann irq.type = KVM_S390_INT_PFAULT_INIT; 3370383d0b05SJens Freimann WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &irq)); 33713c038e6bSDominik Dingel } else { 33723c038e6bSDominik Dingel inti.type = KVM_S390_INT_PFAULT_DONE; 3373383d0b05SJens Freimann inti.parm64 = token; 33743c038e6bSDominik Dingel WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti)); 33753c038e6bSDominik Dingel } 33763c038e6bSDominik Dingel } 33773c038e6bSDominik Dingel 33783c038e6bSDominik Dingel void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu, 33793c038e6bSDominik Dingel struct kvm_async_pf *work) 33803c038e6bSDominik Dingel { 33813c038e6bSDominik Dingel trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token); 33823c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token); 33833c038e6bSDominik Dingel } 33843c038e6bSDominik Dingel 33853c038e6bSDominik Dingel void kvm_arch_async_page_present(struct kvm_vcpu *vcpu, 33863c038e6bSDominik Dingel struct kvm_async_pf *work) 33873c038e6bSDominik Dingel { 33883c038e6bSDominik Dingel trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token); 33893c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token); 33903c038e6bSDominik Dingel } 33913c038e6bSDominik Dingel 33923c038e6bSDominik Dingel void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu, 33933c038e6bSDominik Dingel struct kvm_async_pf *work) 33943c038e6bSDominik Dingel { 33953c038e6bSDominik Dingel /* s390 will always inject the page directly */ 33963c038e6bSDominik Dingel } 33973c038e6bSDominik Dingel 33983c038e6bSDominik Dingel bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu) 33993c038e6bSDominik Dingel { 34003c038e6bSDominik Dingel /* 34013c038e6bSDominik Dingel * s390 will always inject the page directly, 34023c038e6bSDominik Dingel * but we still want check_async_completion to cleanup 34033c038e6bSDominik Dingel */ 34043c038e6bSDominik Dingel return true; 34053c038e6bSDominik Dingel } 34063c038e6bSDominik Dingel 34073c038e6bSDominik Dingel static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu) 34083c038e6bSDominik Dingel { 34093c038e6bSDominik Dingel hva_t hva; 34103c038e6bSDominik Dingel struct kvm_arch_async_pf arch; 34113c038e6bSDominik Dingel int rc; 34123c038e6bSDominik Dingel 34133c038e6bSDominik Dingel if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 34143c038e6bSDominik Dingel return 0; 34153c038e6bSDominik Dingel if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) != 34163c038e6bSDominik Dingel vcpu->arch.pfault_compare) 34173c038e6bSDominik Dingel return 0; 34183c038e6bSDominik Dingel if (psw_extint_disabled(vcpu)) 34193c038e6bSDominik Dingel return 0; 34209a022067SDavid Hildenbrand if (kvm_s390_vcpu_has_irq(vcpu, 0)) 34213c038e6bSDominik Dingel return 0; 3422b9224cd7SDavid Hildenbrand if (!(vcpu->arch.sie_block->gcr[0] & CR0_SERVICE_SIGNAL_SUBMASK)) 34233c038e6bSDominik Dingel return 0; 34243c038e6bSDominik Dingel if (!vcpu->arch.gmap->pfault_enabled) 34253c038e6bSDominik Dingel return 0; 34263c038e6bSDominik Dingel 342781480cc1SHeiko Carstens hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(current->thread.gmap_addr)); 342881480cc1SHeiko Carstens hva += current->thread.gmap_addr & ~PAGE_MASK; 342981480cc1SHeiko Carstens if (read_guest_real(vcpu, vcpu->arch.pfault_token, &arch.pfault_token, 8)) 34303c038e6bSDominik Dingel return 0; 34313c038e6bSDominik Dingel 34323c038e6bSDominik Dingel rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch); 34333c038e6bSDominik Dingel return rc; 34343c038e6bSDominik Dingel } 34353c038e6bSDominik Dingel 34363fb4c40fSThomas Huth static int vcpu_pre_run(struct kvm_vcpu *vcpu) 3437b0c632dbSHeiko Carstens { 34383fb4c40fSThomas Huth int rc, cpuflags; 3439e168bf8dSCarsten Otte 34403c038e6bSDominik Dingel /* 34413c038e6bSDominik Dingel * On s390 notifications for arriving pages will be delivered directly 34423c038e6bSDominik Dingel * to the guest but the house keeping for completed pfaults is 34433c038e6bSDominik Dingel * handled outside the worker. 34443c038e6bSDominik Dingel */ 34453c038e6bSDominik Dingel kvm_check_async_pf_completion(vcpu); 34463c038e6bSDominik Dingel 34477ec7c8c7SChristian Borntraeger vcpu->arch.sie_block->gg14 = vcpu->run->s.regs.gprs[14]; 34487ec7c8c7SChristian Borntraeger vcpu->arch.sie_block->gg15 = vcpu->run->s.regs.gprs[15]; 3449b0c632dbSHeiko Carstens 3450b0c632dbSHeiko Carstens if (need_resched()) 3451b0c632dbSHeiko Carstens schedule(); 3452b0c632dbSHeiko Carstens 3453d3a73acbSMartin Schwidefsky if (test_cpu_flag(CIF_MCCK_PENDING)) 345471cde587SChristian Borntraeger s390_handle_mcck(); 345571cde587SChristian Borntraeger 345679395031SJens Freimann if (!kvm_is_ucontrol(vcpu->kvm)) { 345779395031SJens Freimann rc = kvm_s390_deliver_pending_interrupts(vcpu); 345879395031SJens Freimann if (rc) 345979395031SJens Freimann return rc; 346079395031SJens Freimann } 34610ff31867SCarsten Otte 34622c70fe44SChristian Borntraeger rc = kvm_s390_handle_requests(vcpu); 34632c70fe44SChristian Borntraeger if (rc) 34642c70fe44SChristian Borntraeger return rc; 34652c70fe44SChristian Borntraeger 346627291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) { 346727291e21SDavid Hildenbrand kvm_s390_backup_guest_per_regs(vcpu); 346827291e21SDavid Hildenbrand kvm_s390_patch_guest_per_regs(vcpu); 346927291e21SDavid Hildenbrand } 347027291e21SDavid Hildenbrand 3471b0c632dbSHeiko Carstens vcpu->arch.sie_block->icptcode = 0; 34723fb4c40fSThomas Huth cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags); 34733fb4c40fSThomas Huth VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags); 34743fb4c40fSThomas Huth trace_kvm_s390_sie_enter(vcpu, cpuflags); 34752b29a9fdSDominik Dingel 34763fb4c40fSThomas Huth return 0; 34773fb4c40fSThomas Huth } 34783fb4c40fSThomas Huth 3479492d8642SThomas Huth static int vcpu_post_run_fault_in_sie(struct kvm_vcpu *vcpu) 3480492d8642SThomas Huth { 348156317920SDavid Hildenbrand struct kvm_s390_pgm_info pgm_info = { 348256317920SDavid Hildenbrand .code = PGM_ADDRESSING, 348356317920SDavid Hildenbrand }; 348456317920SDavid Hildenbrand u8 opcode, ilen; 3485492d8642SThomas Huth int rc; 3486492d8642SThomas Huth 3487492d8642SThomas Huth VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction"); 3488492d8642SThomas Huth trace_kvm_s390_sie_fault(vcpu); 3489492d8642SThomas Huth 3490492d8642SThomas Huth /* 3491492d8642SThomas Huth * We want to inject an addressing exception, which is defined as a 3492492d8642SThomas Huth * suppressing or terminating exception. However, since we came here 3493492d8642SThomas Huth * by a DAT access exception, the PSW still points to the faulting 3494492d8642SThomas Huth * instruction since DAT exceptions are nullifying. So we've got 3495492d8642SThomas Huth * to look up the current opcode to get the length of the instruction 3496492d8642SThomas Huth * to be able to forward the PSW. 3497492d8642SThomas Huth */ 34983fa8cad7SDavid Hildenbrand rc = read_guest_instr(vcpu, vcpu->arch.sie_block->gpsw.addr, &opcode, 1); 349956317920SDavid Hildenbrand ilen = insn_length(opcode); 35009b0d721aSDavid Hildenbrand if (rc < 0) { 35019b0d721aSDavid Hildenbrand return rc; 35029b0d721aSDavid Hildenbrand } else if (rc) { 35039b0d721aSDavid Hildenbrand /* Instruction-Fetching Exceptions - we can't detect the ilen. 35049b0d721aSDavid Hildenbrand * Forward by arbitrary ilc, injection will take care of 35059b0d721aSDavid Hildenbrand * nullification if necessary. 35069b0d721aSDavid Hildenbrand */ 35079b0d721aSDavid Hildenbrand pgm_info = vcpu->arch.pgm; 35089b0d721aSDavid Hildenbrand ilen = 4; 35099b0d721aSDavid Hildenbrand } 351056317920SDavid Hildenbrand pgm_info.flags = ilen | KVM_S390_PGM_FLAGS_ILC_VALID; 351156317920SDavid Hildenbrand kvm_s390_forward_psw(vcpu, ilen); 351256317920SDavid Hildenbrand return kvm_s390_inject_prog_irq(vcpu, &pgm_info); 3513492d8642SThomas Huth } 3514492d8642SThomas Huth 35153fb4c40fSThomas Huth static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason) 35163fb4c40fSThomas Huth { 35174d62fcc0SQingFeng Hao struct mcck_volatile_info *mcck_info; 35184d62fcc0SQingFeng Hao struct sie_page *sie_page; 35194d62fcc0SQingFeng Hao 35202b29a9fdSDominik Dingel VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", 35212b29a9fdSDominik Dingel vcpu->arch.sie_block->icptcode); 35222b29a9fdSDominik Dingel trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode); 35232b29a9fdSDominik Dingel 352427291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) 352527291e21SDavid Hildenbrand kvm_s390_restore_guest_per_regs(vcpu); 352627291e21SDavid Hildenbrand 35277ec7c8c7SChristian Borntraeger vcpu->run->s.regs.gprs[14] = vcpu->arch.sie_block->gg14; 35287ec7c8c7SChristian Borntraeger vcpu->run->s.regs.gprs[15] = vcpu->arch.sie_block->gg15; 352971f116bfSDavid Hildenbrand 35304d62fcc0SQingFeng Hao if (exit_reason == -EINTR) { 35314d62fcc0SQingFeng Hao VCPU_EVENT(vcpu, 3, "%s", "machine check"); 35324d62fcc0SQingFeng Hao sie_page = container_of(vcpu->arch.sie_block, 35334d62fcc0SQingFeng Hao struct sie_page, sie_block); 35344d62fcc0SQingFeng Hao mcck_info = &sie_page->mcck_info; 35354d62fcc0SQingFeng Hao kvm_s390_reinject_machine_check(vcpu, mcck_info); 35364d62fcc0SQingFeng Hao return 0; 35374d62fcc0SQingFeng Hao } 35384d62fcc0SQingFeng Hao 353971f116bfSDavid Hildenbrand if (vcpu->arch.sie_block->icptcode > 0) { 354071f116bfSDavid Hildenbrand int rc = kvm_handle_sie_intercept(vcpu); 354171f116bfSDavid Hildenbrand 354271f116bfSDavid Hildenbrand if (rc != -EOPNOTSUPP) 354371f116bfSDavid Hildenbrand return rc; 354471f116bfSDavid Hildenbrand vcpu->run->exit_reason = KVM_EXIT_S390_SIEIC; 354571f116bfSDavid Hildenbrand vcpu->run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode; 354671f116bfSDavid Hildenbrand vcpu->run->s390_sieic.ipa = vcpu->arch.sie_block->ipa; 354771f116bfSDavid Hildenbrand vcpu->run->s390_sieic.ipb = vcpu->arch.sie_block->ipb; 354871f116bfSDavid Hildenbrand return -EREMOTE; 354971f116bfSDavid Hildenbrand } else if (exit_reason != -EFAULT) { 355071f116bfSDavid Hildenbrand vcpu->stat.exit_null++; 355171f116bfSDavid Hildenbrand return 0; 3552210b1607SThomas Huth } else if (kvm_is_ucontrol(vcpu->kvm)) { 3553210b1607SThomas Huth vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL; 3554210b1607SThomas Huth vcpu->run->s390_ucontrol.trans_exc_code = 3555210b1607SThomas Huth current->thread.gmap_addr; 3556210b1607SThomas Huth vcpu->run->s390_ucontrol.pgm_code = 0x10; 355771f116bfSDavid Hildenbrand return -EREMOTE; 355824eb3a82SDominik Dingel } else if (current->thread.gmap_pfault) { 35593c038e6bSDominik Dingel trace_kvm_s390_major_guest_pfault(vcpu); 356024eb3a82SDominik Dingel current->thread.gmap_pfault = 0; 356171f116bfSDavid Hildenbrand if (kvm_arch_setup_async_pf(vcpu)) 356271f116bfSDavid Hildenbrand return 0; 356371f116bfSDavid Hildenbrand return kvm_arch_fault_in_page(vcpu, current->thread.gmap_addr, 1); 3564fa576c58SThomas Huth } 356571f116bfSDavid Hildenbrand return vcpu_post_run_fault_in_sie(vcpu); 35663fb4c40fSThomas Huth } 35673fb4c40fSThomas Huth 35683fb4c40fSThomas Huth static int __vcpu_run(struct kvm_vcpu *vcpu) 35693fb4c40fSThomas Huth { 35703fb4c40fSThomas Huth int rc, exit_reason; 35713fb4c40fSThomas Huth 3572800c1065SThomas Huth /* 3573800c1065SThomas Huth * We try to hold kvm->srcu during most of vcpu_run (except when run- 3574800c1065SThomas Huth * ning the guest), so that memslots (and other stuff) are protected 3575800c1065SThomas Huth */ 3576800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 3577800c1065SThomas Huth 3578a76ccff6SThomas Huth do { 35793fb4c40fSThomas Huth rc = vcpu_pre_run(vcpu); 35803fb4c40fSThomas Huth if (rc) 3581a76ccff6SThomas Huth break; 35823fb4c40fSThomas Huth 3583800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 35843fb4c40fSThomas Huth /* 3585a76ccff6SThomas Huth * As PF_VCPU will be used in fault handler, between 3586a76ccff6SThomas Huth * guest_enter and guest_exit should be no uaccess. 35873fb4c40fSThomas Huth */ 35880097d12eSChristian Borntraeger local_irq_disable(); 35896edaa530SPaolo Bonzini guest_enter_irqoff(); 3590db0758b2SDavid Hildenbrand __disable_cpu_timer_accounting(vcpu); 35910097d12eSChristian Borntraeger local_irq_enable(); 3592a76ccff6SThomas Huth exit_reason = sie64a(vcpu->arch.sie_block, 3593a76ccff6SThomas Huth vcpu->run->s.regs.gprs); 35940097d12eSChristian Borntraeger local_irq_disable(); 3595db0758b2SDavid Hildenbrand __enable_cpu_timer_accounting(vcpu); 35966edaa530SPaolo Bonzini guest_exit_irqoff(); 35970097d12eSChristian Borntraeger local_irq_enable(); 3598800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 35993fb4c40fSThomas Huth 36003fb4c40fSThomas Huth rc = vcpu_post_run(vcpu, exit_reason); 360127291e21SDavid Hildenbrand } while (!signal_pending(current) && !guestdbg_exit_pending(vcpu) && !rc); 36023fb4c40fSThomas Huth 3603800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 3604e168bf8dSCarsten Otte return rc; 3605b0c632dbSHeiko Carstens } 3606b0c632dbSHeiko Carstens 3607b028ee3eSDavid Hildenbrand static void sync_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 3608b028ee3eSDavid Hildenbrand { 36094d5f2c04SChristian Borntraeger struct runtime_instr_cb *riccb; 36104e0b1ab7SFan Zhang struct gs_cb *gscb; 36114d5f2c04SChristian Borntraeger 36124d5f2c04SChristian Borntraeger riccb = (struct runtime_instr_cb *) &kvm_run->s.regs.riccb; 36134e0b1ab7SFan Zhang gscb = (struct gs_cb *) &kvm_run->s.regs.gscb; 3614b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask; 3615b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr; 3616b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) 3617b028ee3eSDavid Hildenbrand kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix); 3618b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) { 3619b028ee3eSDavid Hildenbrand memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128); 3620d3d692c8SDavid Hildenbrand /* some control register changes require a tlb flush */ 3621d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 3622b028ee3eSDavid Hildenbrand } 3623b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_ARCH0) { 36244287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, kvm_run->s.regs.cputm); 3625b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->ckc = kvm_run->s.regs.ckc; 3626b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->todpr = kvm_run->s.regs.todpr; 3627b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->pp = kvm_run->s.regs.pp; 3628b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gbea = kvm_run->s.regs.gbea; 3629b028ee3eSDavid Hildenbrand } 3630b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PFAULT) { 3631b028ee3eSDavid Hildenbrand vcpu->arch.pfault_token = kvm_run->s.regs.pft; 3632b028ee3eSDavid Hildenbrand vcpu->arch.pfault_select = kvm_run->s.regs.pfs; 3633b028ee3eSDavid Hildenbrand vcpu->arch.pfault_compare = kvm_run->s.regs.pfc; 36349fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 36359fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 3636b028ee3eSDavid Hildenbrand } 363780cd8763SFan Zhang /* 363880cd8763SFan Zhang * If userspace sets the riccb (e.g. after migration) to a valid state, 363980cd8763SFan Zhang * we should enable RI here instead of doing the lazy enablement. 364080cd8763SFan Zhang */ 364180cd8763SFan Zhang if ((kvm_run->kvm_dirty_regs & KVM_SYNC_RICCB) && 36424d5f2c04SChristian Borntraeger test_kvm_facility(vcpu->kvm, 64) && 3643bb59c2daSAlice Frosi riccb->v && 36440c9d8683SDavid Hildenbrand !(vcpu->arch.sie_block->ecb3 & ECB3_RI)) { 36454d5f2c04SChristian Borntraeger VCPU_EVENT(vcpu, 3, "%s", "ENABLE: RI (sync_regs)"); 36460c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb3 |= ECB3_RI; 364780cd8763SFan Zhang } 36484e0b1ab7SFan Zhang /* 36494e0b1ab7SFan Zhang * If userspace sets the gscb (e.g. after migration) to non-zero, 36504e0b1ab7SFan Zhang * we should enable GS here instead of doing the lazy enablement. 36514e0b1ab7SFan Zhang */ 36524e0b1ab7SFan Zhang if ((kvm_run->kvm_dirty_regs & KVM_SYNC_GSCB) && 36534e0b1ab7SFan Zhang test_kvm_facility(vcpu->kvm, 133) && 36544e0b1ab7SFan Zhang gscb->gssm && 36554e0b1ab7SFan Zhang !vcpu->arch.gs_enabled) { 36564e0b1ab7SFan Zhang VCPU_EVENT(vcpu, 3, "%s", "ENABLE: GS (sync_regs)"); 36574e0b1ab7SFan Zhang vcpu->arch.sie_block->ecb |= ECB_GS; 36584e0b1ab7SFan Zhang vcpu->arch.sie_block->ecd |= ECD_HOSTREGMGMT; 36594e0b1ab7SFan Zhang vcpu->arch.gs_enabled = 1; 366080cd8763SFan Zhang } 366135b3fde6SChristian Borntraeger if ((kvm_run->kvm_dirty_regs & KVM_SYNC_BPBC) && 366235b3fde6SChristian Borntraeger test_kvm_facility(vcpu->kvm, 82)) { 366335b3fde6SChristian Borntraeger vcpu->arch.sie_block->fpf &= ~FPF_BPBC; 366435b3fde6SChristian Borntraeger vcpu->arch.sie_block->fpf |= kvm_run->s.regs.bpbc ? FPF_BPBC : 0; 366535b3fde6SChristian Borntraeger } 366631d8b8d4SChristian Borntraeger save_access_regs(vcpu->arch.host_acrs); 366731d8b8d4SChristian Borntraeger restore_access_regs(vcpu->run->s.regs.acrs); 3668e1788bb9SChristian Borntraeger /* save host (userspace) fprs/vrs */ 3669e1788bb9SChristian Borntraeger save_fpu_regs(); 3670e1788bb9SChristian Borntraeger vcpu->arch.host_fpregs.fpc = current->thread.fpu.fpc; 3671e1788bb9SChristian Borntraeger vcpu->arch.host_fpregs.regs = current->thread.fpu.regs; 3672e1788bb9SChristian Borntraeger if (MACHINE_HAS_VX) 3673e1788bb9SChristian Borntraeger current->thread.fpu.regs = vcpu->run->s.regs.vrs; 3674e1788bb9SChristian Borntraeger else 3675e1788bb9SChristian Borntraeger current->thread.fpu.regs = vcpu->run->s.regs.fprs; 3676e1788bb9SChristian Borntraeger current->thread.fpu.fpc = vcpu->run->s.regs.fpc; 3677e1788bb9SChristian Borntraeger if (test_fp_ctl(current->thread.fpu.fpc)) 3678e1788bb9SChristian Borntraeger /* User space provided an invalid FPC, let's clear it */ 3679e1788bb9SChristian Borntraeger current->thread.fpu.fpc = 0; 36804e0b1ab7SFan Zhang if (MACHINE_HAS_GS) { 36814e0b1ab7SFan Zhang preempt_disable(); 36824e0b1ab7SFan Zhang __ctl_set_bit(2, 4); 36834e0b1ab7SFan Zhang if (current->thread.gs_cb) { 36844e0b1ab7SFan Zhang vcpu->arch.host_gscb = current->thread.gs_cb; 36854e0b1ab7SFan Zhang save_gs_cb(vcpu->arch.host_gscb); 36864e0b1ab7SFan Zhang } 36874e0b1ab7SFan Zhang if (vcpu->arch.gs_enabled) { 36884e0b1ab7SFan Zhang current->thread.gs_cb = (struct gs_cb *) 36894e0b1ab7SFan Zhang &vcpu->run->s.regs.gscb; 36904e0b1ab7SFan Zhang restore_gs_cb(current->thread.gs_cb); 36914e0b1ab7SFan Zhang } 36924e0b1ab7SFan Zhang preempt_enable(); 36934e0b1ab7SFan Zhang } 3694a3da7b4aSChristian Borntraeger /* SIE will load etoken directly from SDNX and therefore kvm_run */ 369580cd8763SFan Zhang 3696b028ee3eSDavid Hildenbrand kvm_run->kvm_dirty_regs = 0; 3697b028ee3eSDavid Hildenbrand } 3698b028ee3eSDavid Hildenbrand 3699b028ee3eSDavid Hildenbrand static void store_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 3700b028ee3eSDavid Hildenbrand { 3701b028ee3eSDavid Hildenbrand kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask; 3702b028ee3eSDavid Hildenbrand kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr; 3703b028ee3eSDavid Hildenbrand kvm_run->s.regs.prefix = kvm_s390_get_prefix(vcpu); 3704b028ee3eSDavid Hildenbrand memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128); 37054287f247SDavid Hildenbrand kvm_run->s.regs.cputm = kvm_s390_get_cpu_timer(vcpu); 3706b028ee3eSDavid Hildenbrand kvm_run->s.regs.ckc = vcpu->arch.sie_block->ckc; 3707b028ee3eSDavid Hildenbrand kvm_run->s.regs.todpr = vcpu->arch.sie_block->todpr; 3708b028ee3eSDavid Hildenbrand kvm_run->s.regs.pp = vcpu->arch.sie_block->pp; 3709b028ee3eSDavid Hildenbrand kvm_run->s.regs.gbea = vcpu->arch.sie_block->gbea; 3710b028ee3eSDavid Hildenbrand kvm_run->s.regs.pft = vcpu->arch.pfault_token; 3711b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfs = vcpu->arch.pfault_select; 3712b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfc = vcpu->arch.pfault_compare; 371335b3fde6SChristian Borntraeger kvm_run->s.regs.bpbc = (vcpu->arch.sie_block->fpf & FPF_BPBC) == FPF_BPBC; 371431d8b8d4SChristian Borntraeger save_access_regs(vcpu->run->s.regs.acrs); 371531d8b8d4SChristian Borntraeger restore_access_regs(vcpu->arch.host_acrs); 3716e1788bb9SChristian Borntraeger /* Save guest register state */ 3717e1788bb9SChristian Borntraeger save_fpu_regs(); 3718e1788bb9SChristian Borntraeger vcpu->run->s.regs.fpc = current->thread.fpu.fpc; 3719e1788bb9SChristian Borntraeger /* Restore will be done lazily at return */ 3720e1788bb9SChristian Borntraeger current->thread.fpu.fpc = vcpu->arch.host_fpregs.fpc; 3721e1788bb9SChristian Borntraeger current->thread.fpu.regs = vcpu->arch.host_fpregs.regs; 37224e0b1ab7SFan Zhang if (MACHINE_HAS_GS) { 37234e0b1ab7SFan Zhang __ctl_set_bit(2, 4); 37244e0b1ab7SFan Zhang if (vcpu->arch.gs_enabled) 37254e0b1ab7SFan Zhang save_gs_cb(current->thread.gs_cb); 37264e0b1ab7SFan Zhang preempt_disable(); 37274e0b1ab7SFan Zhang current->thread.gs_cb = vcpu->arch.host_gscb; 37284e0b1ab7SFan Zhang restore_gs_cb(vcpu->arch.host_gscb); 37294e0b1ab7SFan Zhang preempt_enable(); 37304e0b1ab7SFan Zhang if (!vcpu->arch.host_gscb) 37314e0b1ab7SFan Zhang __ctl_clear_bit(2, 4); 37324e0b1ab7SFan Zhang vcpu->arch.host_gscb = NULL; 37334e0b1ab7SFan Zhang } 3734a3da7b4aSChristian Borntraeger /* SIE will save etoken directly into SDNX and therefore kvm_run */ 3735b028ee3eSDavid Hildenbrand } 3736b028ee3eSDavid Hildenbrand 3737b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 3738b0c632dbSHeiko Carstens { 37398f2abe6aSChristian Borntraeger int rc; 3740b0c632dbSHeiko Carstens 3741460df4c1SPaolo Bonzini if (kvm_run->immediate_exit) 3742460df4c1SPaolo Bonzini return -EINTR; 3743460df4c1SPaolo Bonzini 3744accb757dSChristoffer Dall vcpu_load(vcpu); 3745accb757dSChristoffer Dall 374627291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu)) { 374727291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 3748accb757dSChristoffer Dall rc = 0; 3749accb757dSChristoffer Dall goto out; 375027291e21SDavid Hildenbrand } 375127291e21SDavid Hildenbrand 375220b7035cSJan H. Schönherr kvm_sigset_activate(vcpu); 3753b0c632dbSHeiko Carstens 37546352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) { 37556852d7b6SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 37566352e4d2SDavid Hildenbrand } else if (is_vcpu_stopped(vcpu)) { 3757ea2cdd27SDavid Hildenbrand pr_err_ratelimited("can't run stopped vcpu %d\n", 37586352e4d2SDavid Hildenbrand vcpu->vcpu_id); 3759accb757dSChristoffer Dall rc = -EINVAL; 3760accb757dSChristoffer Dall goto out; 37616352e4d2SDavid Hildenbrand } 3762b0c632dbSHeiko Carstens 3763b028ee3eSDavid Hildenbrand sync_regs(vcpu, kvm_run); 3764db0758b2SDavid Hildenbrand enable_cpu_timer_accounting(vcpu); 3765d7b0b5ebSCarsten Otte 3766dab4079dSHeiko Carstens might_fault(); 3767e168bf8dSCarsten Otte rc = __vcpu_run(vcpu); 37689ace903dSChristian Ehrhardt 3769b1d16c49SChristian Ehrhardt if (signal_pending(current) && !rc) { 3770b1d16c49SChristian Ehrhardt kvm_run->exit_reason = KVM_EXIT_INTR; 37718f2abe6aSChristian Borntraeger rc = -EINTR; 3772b1d16c49SChristian Ehrhardt } 37738f2abe6aSChristian Borntraeger 377427291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu) && !rc) { 377527291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 377627291e21SDavid Hildenbrand rc = 0; 377727291e21SDavid Hildenbrand } 377827291e21SDavid Hildenbrand 37798f2abe6aSChristian Borntraeger if (rc == -EREMOTE) { 378071f116bfSDavid Hildenbrand /* userspace support is needed, kvm_run has been prepared */ 37818f2abe6aSChristian Borntraeger rc = 0; 37828f2abe6aSChristian Borntraeger } 37838f2abe6aSChristian Borntraeger 3784db0758b2SDavid Hildenbrand disable_cpu_timer_accounting(vcpu); 3785b028ee3eSDavid Hildenbrand store_regs(vcpu, kvm_run); 3786d7b0b5ebSCarsten Otte 378720b7035cSJan H. Schönherr kvm_sigset_deactivate(vcpu); 3788b0c632dbSHeiko Carstens 3789b0c632dbSHeiko Carstens vcpu->stat.exit_userspace++; 3790accb757dSChristoffer Dall out: 3791accb757dSChristoffer Dall vcpu_put(vcpu); 37927e8e6ab4SHeiko Carstens return rc; 3793b0c632dbSHeiko Carstens } 3794b0c632dbSHeiko Carstens 3795b0c632dbSHeiko Carstens /* 3796b0c632dbSHeiko Carstens * store status at address 3797b0c632dbSHeiko Carstens * we use have two special cases: 3798b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit 3799b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_PREFIXED: -> prefix 3800b0c632dbSHeiko Carstens */ 3801d0bce605SHeiko Carstens int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long gpa) 3802b0c632dbSHeiko Carstens { 3803092670cdSCarsten Otte unsigned char archmode = 1; 38049abc2a08SDavid Hildenbrand freg_t fprs[NUM_FPRS]; 3805fda902cbSMichael Mueller unsigned int px; 38064287f247SDavid Hildenbrand u64 clkcomp, cputm; 3807d0bce605SHeiko Carstens int rc; 3808b0c632dbSHeiko Carstens 3809d9a3a09aSMartin Schwidefsky px = kvm_s390_get_prefix(vcpu); 3810d0bce605SHeiko Carstens if (gpa == KVM_S390_STORE_STATUS_NOADDR) { 3811d0bce605SHeiko Carstens if (write_guest_abs(vcpu, 163, &archmode, 1)) 3812b0c632dbSHeiko Carstens return -EFAULT; 3813d9a3a09aSMartin Schwidefsky gpa = 0; 3814d0bce605SHeiko Carstens } else if (gpa == KVM_S390_STORE_STATUS_PREFIXED) { 3815d0bce605SHeiko Carstens if (write_guest_real(vcpu, 163, &archmode, 1)) 3816b0c632dbSHeiko Carstens return -EFAULT; 3817d9a3a09aSMartin Schwidefsky gpa = px; 3818d9a3a09aSMartin Schwidefsky } else 3819d9a3a09aSMartin Schwidefsky gpa -= __LC_FPREGS_SAVE_AREA; 38209abc2a08SDavid Hildenbrand 38219abc2a08SDavid Hildenbrand /* manually convert vector registers if necessary */ 38229abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) { 38239522b37fSDavid Hildenbrand convert_vx_to_fp(fprs, (__vector128 *) vcpu->run->s.regs.vrs); 3824d9a3a09aSMartin Schwidefsky rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA, 38259abc2a08SDavid Hildenbrand fprs, 128); 38269abc2a08SDavid Hildenbrand } else { 38279abc2a08SDavid Hildenbrand rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA, 38286fd8e67dSDavid Hildenbrand vcpu->run->s.regs.fprs, 128); 38299abc2a08SDavid Hildenbrand } 3830d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_GPREGS_SAVE_AREA, 3831d0bce605SHeiko Carstens vcpu->run->s.regs.gprs, 128); 3832d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_PSW_SAVE_AREA, 3833d0bce605SHeiko Carstens &vcpu->arch.sie_block->gpsw, 16); 3834d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_PREFIX_SAVE_AREA, 3835fda902cbSMichael Mueller &px, 4); 3836d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_FP_CREG_SAVE_AREA, 38379abc2a08SDavid Hildenbrand &vcpu->run->s.regs.fpc, 4); 3838d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_TOD_PROGREG_SAVE_AREA, 3839d0bce605SHeiko Carstens &vcpu->arch.sie_block->todpr, 4); 38404287f247SDavid Hildenbrand cputm = kvm_s390_get_cpu_timer(vcpu); 3841d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CPU_TIMER_SAVE_AREA, 38424287f247SDavid Hildenbrand &cputm, 8); 3843178bd789SThomas Huth clkcomp = vcpu->arch.sie_block->ckc >> 8; 3844d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CLOCK_COMP_SAVE_AREA, 3845d0bce605SHeiko Carstens &clkcomp, 8); 3846d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_AREGS_SAVE_AREA, 3847d0bce605SHeiko Carstens &vcpu->run->s.regs.acrs, 64); 3848d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CREGS_SAVE_AREA, 3849d0bce605SHeiko Carstens &vcpu->arch.sie_block->gcr, 128); 3850d0bce605SHeiko Carstens return rc ? -EFAULT : 0; 3851b0c632dbSHeiko Carstens } 3852b0c632dbSHeiko Carstens 3853e879892cSThomas Huth int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr) 3854e879892cSThomas Huth { 3855e879892cSThomas Huth /* 3856e879892cSThomas Huth * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy 385731d8b8d4SChristian Borntraeger * switch in the run ioctl. Let's update our copies before we save 3858e879892cSThomas Huth * it into the save area 3859e879892cSThomas Huth */ 3860d0164ee2SHendrik Brueckner save_fpu_regs(); 38619abc2a08SDavid Hildenbrand vcpu->run->s.regs.fpc = current->thread.fpu.fpc; 3862e879892cSThomas Huth save_access_regs(vcpu->run->s.regs.acrs); 3863e879892cSThomas Huth 3864e879892cSThomas Huth return kvm_s390_store_status_unloaded(vcpu, addr); 3865e879892cSThomas Huth } 3866e879892cSThomas Huth 38678ad35755SDavid Hildenbrand static void __disable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 38688ad35755SDavid Hildenbrand { 38698ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu); 38708e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_DISABLE_IBS, vcpu); 38718ad35755SDavid Hildenbrand } 38728ad35755SDavid Hildenbrand 38738ad35755SDavid Hildenbrand static void __disable_ibs_on_all_vcpus(struct kvm *kvm) 38748ad35755SDavid Hildenbrand { 38758ad35755SDavid Hildenbrand unsigned int i; 38768ad35755SDavid Hildenbrand struct kvm_vcpu *vcpu; 38778ad35755SDavid Hildenbrand 38788ad35755SDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 38798ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 38808ad35755SDavid Hildenbrand } 38818ad35755SDavid Hildenbrand } 38828ad35755SDavid Hildenbrand 38838ad35755SDavid Hildenbrand static void __enable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 38848ad35755SDavid Hildenbrand { 388509a400e7SDavid Hildenbrand if (!sclp.has_ibs) 388609a400e7SDavid Hildenbrand return; 38878ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu); 38888e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_ENABLE_IBS, vcpu); 38898ad35755SDavid Hildenbrand } 38908ad35755SDavid Hildenbrand 38916852d7b6SDavid Hildenbrand void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu) 38926852d7b6SDavid Hildenbrand { 38938ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 38948ad35755SDavid Hildenbrand 38958ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 38968ad35755SDavid Hildenbrand return; 38978ad35755SDavid Hildenbrand 38986852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 1); 38998ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 3900433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 39018ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 39028ad35755SDavid Hildenbrand 39038ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 39048ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) 39058ad35755SDavid Hildenbrand started_vcpus++; 39068ad35755SDavid Hildenbrand } 39078ad35755SDavid Hildenbrand 39088ad35755SDavid Hildenbrand if (started_vcpus == 0) { 39098ad35755SDavid Hildenbrand /* we're the only active VCPU -> speed it up */ 39108ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(vcpu); 39118ad35755SDavid Hildenbrand } else if (started_vcpus == 1) { 39128ad35755SDavid Hildenbrand /* 39138ad35755SDavid Hildenbrand * As we are starting a second VCPU, we have to disable 39148ad35755SDavid Hildenbrand * the IBS facility on all VCPUs to remove potentially 39158ad35755SDavid Hildenbrand * oustanding ENABLE requests. 39168ad35755SDavid Hildenbrand */ 39178ad35755SDavid Hildenbrand __disable_ibs_on_all_vcpus(vcpu->kvm); 39188ad35755SDavid Hildenbrand } 39198ad35755SDavid Hildenbrand 39209daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_STOPPED); 39218ad35755SDavid Hildenbrand /* 39228ad35755SDavid Hildenbrand * Another VCPU might have used IBS while we were offline. 39238ad35755SDavid Hildenbrand * Let's play safe and flush the VCPU at startup. 39248ad35755SDavid Hildenbrand */ 3925d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 3926433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 39278ad35755SDavid Hildenbrand return; 39286852d7b6SDavid Hildenbrand } 39296852d7b6SDavid Hildenbrand 39306852d7b6SDavid Hildenbrand void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu) 39316852d7b6SDavid Hildenbrand { 39328ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 39338ad35755SDavid Hildenbrand struct kvm_vcpu *started_vcpu = NULL; 39348ad35755SDavid Hildenbrand 39358ad35755SDavid Hildenbrand if (is_vcpu_stopped(vcpu)) 39368ad35755SDavid Hildenbrand return; 39378ad35755SDavid Hildenbrand 39386852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 0); 39398ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 3940433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 39418ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 39428ad35755SDavid Hildenbrand 394332f5ff63SDavid Hildenbrand /* SIGP STOP and SIGP STOP AND STORE STATUS has been fully processed */ 39446cddd432SDavid Hildenbrand kvm_s390_clear_stop_irq(vcpu); 394532f5ff63SDavid Hildenbrand 3946ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_STOPPED); 39478ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 39488ad35755SDavid Hildenbrand 39498ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 39508ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) { 39518ad35755SDavid Hildenbrand started_vcpus++; 39528ad35755SDavid Hildenbrand started_vcpu = vcpu->kvm->vcpus[i]; 39538ad35755SDavid Hildenbrand } 39548ad35755SDavid Hildenbrand } 39558ad35755SDavid Hildenbrand 39568ad35755SDavid Hildenbrand if (started_vcpus == 1) { 39578ad35755SDavid Hildenbrand /* 39588ad35755SDavid Hildenbrand * As we only have one VCPU left, we want to enable the 39598ad35755SDavid Hildenbrand * IBS facility for that VCPU to speed it up. 39608ad35755SDavid Hildenbrand */ 39618ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(started_vcpu); 39628ad35755SDavid Hildenbrand } 39638ad35755SDavid Hildenbrand 3964433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 39658ad35755SDavid Hildenbrand return; 39666852d7b6SDavid Hildenbrand } 39676852d7b6SDavid Hildenbrand 3968d6712df9SCornelia Huck static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 3969d6712df9SCornelia Huck struct kvm_enable_cap *cap) 3970d6712df9SCornelia Huck { 3971d6712df9SCornelia Huck int r; 3972d6712df9SCornelia Huck 3973d6712df9SCornelia Huck if (cap->flags) 3974d6712df9SCornelia Huck return -EINVAL; 3975d6712df9SCornelia Huck 3976d6712df9SCornelia Huck switch (cap->cap) { 3977fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 3978fa6b7fe9SCornelia Huck if (!vcpu->kvm->arch.css_support) { 3979fa6b7fe9SCornelia Huck vcpu->kvm->arch.css_support = 1; 3980c92ea7b9SChristian Borntraeger VM_EVENT(vcpu->kvm, 3, "%s", "ENABLE: CSS support"); 3981fa6b7fe9SCornelia Huck trace_kvm_s390_enable_css(vcpu->kvm); 3982fa6b7fe9SCornelia Huck } 3983fa6b7fe9SCornelia Huck r = 0; 3984fa6b7fe9SCornelia Huck break; 3985d6712df9SCornelia Huck default: 3986d6712df9SCornelia Huck r = -EINVAL; 3987d6712df9SCornelia Huck break; 3988d6712df9SCornelia Huck } 3989d6712df9SCornelia Huck return r; 3990d6712df9SCornelia Huck } 3991d6712df9SCornelia Huck 399241408c28SThomas Huth static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu, 399341408c28SThomas Huth struct kvm_s390_mem_op *mop) 399441408c28SThomas Huth { 399541408c28SThomas Huth void __user *uaddr = (void __user *)mop->buf; 399641408c28SThomas Huth void *tmpbuf = NULL; 399741408c28SThomas Huth int r, srcu_idx; 399841408c28SThomas Huth const u64 supported_flags = KVM_S390_MEMOP_F_INJECT_EXCEPTION 399941408c28SThomas Huth | KVM_S390_MEMOP_F_CHECK_ONLY; 400041408c28SThomas Huth 400141408c28SThomas Huth if (mop->flags & ~supported_flags) 400241408c28SThomas Huth return -EINVAL; 400341408c28SThomas Huth 400441408c28SThomas Huth if (mop->size > MEM_OP_MAX_SIZE) 400541408c28SThomas Huth return -E2BIG; 400641408c28SThomas Huth 400741408c28SThomas Huth if (!(mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY)) { 400841408c28SThomas Huth tmpbuf = vmalloc(mop->size); 400941408c28SThomas Huth if (!tmpbuf) 401041408c28SThomas Huth return -ENOMEM; 401141408c28SThomas Huth } 401241408c28SThomas Huth 401341408c28SThomas Huth srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 401441408c28SThomas Huth 401541408c28SThomas Huth switch (mop->op) { 401641408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_READ: 401741408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 401892c96321SDavid Hildenbrand r = check_gva_range(vcpu, mop->gaddr, mop->ar, 401992c96321SDavid Hildenbrand mop->size, GACC_FETCH); 402041408c28SThomas Huth break; 402141408c28SThomas Huth } 402241408c28SThomas Huth r = read_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 402341408c28SThomas Huth if (r == 0) { 402441408c28SThomas Huth if (copy_to_user(uaddr, tmpbuf, mop->size)) 402541408c28SThomas Huth r = -EFAULT; 402641408c28SThomas Huth } 402741408c28SThomas Huth break; 402841408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_WRITE: 402941408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 403092c96321SDavid Hildenbrand r = check_gva_range(vcpu, mop->gaddr, mop->ar, 403192c96321SDavid Hildenbrand mop->size, GACC_STORE); 403241408c28SThomas Huth break; 403341408c28SThomas Huth } 403441408c28SThomas Huth if (copy_from_user(tmpbuf, uaddr, mop->size)) { 403541408c28SThomas Huth r = -EFAULT; 403641408c28SThomas Huth break; 403741408c28SThomas Huth } 403841408c28SThomas Huth r = write_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 403941408c28SThomas Huth break; 404041408c28SThomas Huth default: 404141408c28SThomas Huth r = -EINVAL; 404241408c28SThomas Huth } 404341408c28SThomas Huth 404441408c28SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, srcu_idx); 404541408c28SThomas Huth 404641408c28SThomas Huth if (r > 0 && (mop->flags & KVM_S390_MEMOP_F_INJECT_EXCEPTION) != 0) 404741408c28SThomas Huth kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm); 404841408c28SThomas Huth 404941408c28SThomas Huth vfree(tmpbuf); 405041408c28SThomas Huth return r; 405141408c28SThomas Huth } 405241408c28SThomas Huth 40535cb0944cSPaolo Bonzini long kvm_arch_vcpu_async_ioctl(struct file *filp, 4054b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 4055b0c632dbSHeiko Carstens { 4056b0c632dbSHeiko Carstens struct kvm_vcpu *vcpu = filp->private_data; 4057b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 4058b0c632dbSHeiko Carstens 405993736624SAvi Kivity switch (ioctl) { 406047b43c52SJens Freimann case KVM_S390_IRQ: { 406147b43c52SJens Freimann struct kvm_s390_irq s390irq; 406247b43c52SJens Freimann 406347b43c52SJens Freimann if (copy_from_user(&s390irq, argp, sizeof(s390irq))) 40649b062471SChristoffer Dall return -EFAULT; 40659b062471SChristoffer Dall return kvm_s390_inject_vcpu(vcpu, &s390irq); 406647b43c52SJens Freimann } 406793736624SAvi Kivity case KVM_S390_INTERRUPT: { 4068ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 4069383d0b05SJens Freimann struct kvm_s390_irq s390irq; 4070ba5c1e9bSCarsten Otte 4071ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 40729b062471SChristoffer Dall return -EFAULT; 4073383d0b05SJens Freimann if (s390int_to_s390irq(&s390int, &s390irq)) 4074383d0b05SJens Freimann return -EINVAL; 40759b062471SChristoffer Dall return kvm_s390_inject_vcpu(vcpu, &s390irq); 4076ba5c1e9bSCarsten Otte } 40779b062471SChristoffer Dall } 40785cb0944cSPaolo Bonzini return -ENOIOCTLCMD; 40795cb0944cSPaolo Bonzini } 40805cb0944cSPaolo Bonzini 40815cb0944cSPaolo Bonzini long kvm_arch_vcpu_ioctl(struct file *filp, 40825cb0944cSPaolo Bonzini unsigned int ioctl, unsigned long arg) 40835cb0944cSPaolo Bonzini { 40845cb0944cSPaolo Bonzini struct kvm_vcpu *vcpu = filp->private_data; 40855cb0944cSPaolo Bonzini void __user *argp = (void __user *)arg; 40865cb0944cSPaolo Bonzini int idx; 40875cb0944cSPaolo Bonzini long r; 40889b062471SChristoffer Dall 40899b062471SChristoffer Dall vcpu_load(vcpu); 40909b062471SChristoffer Dall 40919b062471SChristoffer Dall switch (ioctl) { 4092b0c632dbSHeiko Carstens case KVM_S390_STORE_STATUS: 4093800c1065SThomas Huth idx = srcu_read_lock(&vcpu->kvm->srcu); 4094bc923cc9SAvi Kivity r = kvm_s390_vcpu_store_status(vcpu, arg); 4095800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, idx); 4096bc923cc9SAvi Kivity break; 4097b0c632dbSHeiko Carstens case KVM_S390_SET_INITIAL_PSW: { 4098b0c632dbSHeiko Carstens psw_t psw; 4099b0c632dbSHeiko Carstens 4100bc923cc9SAvi Kivity r = -EFAULT; 4101b0c632dbSHeiko Carstens if (copy_from_user(&psw, argp, sizeof(psw))) 4102bc923cc9SAvi Kivity break; 4103bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw); 4104bc923cc9SAvi Kivity break; 4105b0c632dbSHeiko Carstens } 4106b0c632dbSHeiko Carstens case KVM_S390_INITIAL_RESET: 4107bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_initial_reset(vcpu); 4108bc923cc9SAvi Kivity break; 410914eebd91SCarsten Otte case KVM_SET_ONE_REG: 411014eebd91SCarsten Otte case KVM_GET_ONE_REG: { 411114eebd91SCarsten Otte struct kvm_one_reg reg; 411214eebd91SCarsten Otte r = -EFAULT; 411314eebd91SCarsten Otte if (copy_from_user(®, argp, sizeof(reg))) 411414eebd91SCarsten Otte break; 411514eebd91SCarsten Otte if (ioctl == KVM_SET_ONE_REG) 411614eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, ®); 411714eebd91SCarsten Otte else 411814eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, ®); 411914eebd91SCarsten Otte break; 412014eebd91SCarsten Otte } 412127e0393fSCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 412227e0393fSCarsten Otte case KVM_S390_UCAS_MAP: { 412327e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 412427e0393fSCarsten Otte 412527e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 412627e0393fSCarsten Otte r = -EFAULT; 412727e0393fSCarsten Otte break; 412827e0393fSCarsten Otte } 412927e0393fSCarsten Otte 413027e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 413127e0393fSCarsten Otte r = -EINVAL; 413227e0393fSCarsten Otte break; 413327e0393fSCarsten Otte } 413427e0393fSCarsten Otte 413527e0393fSCarsten Otte r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr, 413627e0393fSCarsten Otte ucasmap.vcpu_addr, ucasmap.length); 413727e0393fSCarsten Otte break; 413827e0393fSCarsten Otte } 413927e0393fSCarsten Otte case KVM_S390_UCAS_UNMAP: { 414027e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 414127e0393fSCarsten Otte 414227e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 414327e0393fSCarsten Otte r = -EFAULT; 414427e0393fSCarsten Otte break; 414527e0393fSCarsten Otte } 414627e0393fSCarsten Otte 414727e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 414827e0393fSCarsten Otte r = -EINVAL; 414927e0393fSCarsten Otte break; 415027e0393fSCarsten Otte } 415127e0393fSCarsten Otte 415227e0393fSCarsten Otte r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr, 415327e0393fSCarsten Otte ucasmap.length); 415427e0393fSCarsten Otte break; 415527e0393fSCarsten Otte } 415627e0393fSCarsten Otte #endif 4157ccc7910fSCarsten Otte case KVM_S390_VCPU_FAULT: { 4158527e30b4SMartin Schwidefsky r = gmap_fault(vcpu->arch.gmap, arg, 0); 4159ccc7910fSCarsten Otte break; 4160ccc7910fSCarsten Otte } 4161d6712df9SCornelia Huck case KVM_ENABLE_CAP: 4162d6712df9SCornelia Huck { 4163d6712df9SCornelia Huck struct kvm_enable_cap cap; 4164d6712df9SCornelia Huck r = -EFAULT; 4165d6712df9SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 4166d6712df9SCornelia Huck break; 4167d6712df9SCornelia Huck r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 4168d6712df9SCornelia Huck break; 4169d6712df9SCornelia Huck } 417041408c28SThomas Huth case KVM_S390_MEM_OP: { 417141408c28SThomas Huth struct kvm_s390_mem_op mem_op; 417241408c28SThomas Huth 417341408c28SThomas Huth if (copy_from_user(&mem_op, argp, sizeof(mem_op)) == 0) 417441408c28SThomas Huth r = kvm_s390_guest_mem_op(vcpu, &mem_op); 417541408c28SThomas Huth else 417641408c28SThomas Huth r = -EFAULT; 417741408c28SThomas Huth break; 417841408c28SThomas Huth } 4179816c7667SJens Freimann case KVM_S390_SET_IRQ_STATE: { 4180816c7667SJens Freimann struct kvm_s390_irq_state irq_state; 4181816c7667SJens Freimann 4182816c7667SJens Freimann r = -EFAULT; 4183816c7667SJens Freimann if (copy_from_user(&irq_state, argp, sizeof(irq_state))) 4184816c7667SJens Freimann break; 4185816c7667SJens Freimann if (irq_state.len > VCPU_IRQS_MAX_BUF || 4186816c7667SJens Freimann irq_state.len == 0 || 4187816c7667SJens Freimann irq_state.len % sizeof(struct kvm_s390_irq) > 0) { 4188816c7667SJens Freimann r = -EINVAL; 4189816c7667SJens Freimann break; 4190816c7667SJens Freimann } 4191bb64da9aSChristian Borntraeger /* do not use irq_state.flags, it will break old QEMUs */ 4192816c7667SJens Freimann r = kvm_s390_set_irq_state(vcpu, 4193816c7667SJens Freimann (void __user *) irq_state.buf, 4194816c7667SJens Freimann irq_state.len); 4195816c7667SJens Freimann break; 4196816c7667SJens Freimann } 4197816c7667SJens Freimann case KVM_S390_GET_IRQ_STATE: { 4198816c7667SJens Freimann struct kvm_s390_irq_state irq_state; 4199816c7667SJens Freimann 4200816c7667SJens Freimann r = -EFAULT; 4201816c7667SJens Freimann if (copy_from_user(&irq_state, argp, sizeof(irq_state))) 4202816c7667SJens Freimann break; 4203816c7667SJens Freimann if (irq_state.len == 0) { 4204816c7667SJens Freimann r = -EINVAL; 4205816c7667SJens Freimann break; 4206816c7667SJens Freimann } 4207bb64da9aSChristian Borntraeger /* do not use irq_state.flags, it will break old QEMUs */ 4208816c7667SJens Freimann r = kvm_s390_get_irq_state(vcpu, 4209816c7667SJens Freimann (__u8 __user *) irq_state.buf, 4210816c7667SJens Freimann irq_state.len); 4211816c7667SJens Freimann break; 4212816c7667SJens Freimann } 4213b0c632dbSHeiko Carstens default: 42143e6afcf1SCarsten Otte r = -ENOTTY; 4215b0c632dbSHeiko Carstens } 42169b062471SChristoffer Dall 42179b062471SChristoffer Dall vcpu_put(vcpu); 4218bc923cc9SAvi Kivity return r; 4219b0c632dbSHeiko Carstens } 4220b0c632dbSHeiko Carstens 42211499fa80SSouptick Joarder vm_fault_t kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) 42225b1c1493SCarsten Otte { 42235b1c1493SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 42245b1c1493SCarsten Otte if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET) 42255b1c1493SCarsten Otte && (kvm_is_ucontrol(vcpu->kvm))) { 42265b1c1493SCarsten Otte vmf->page = virt_to_page(vcpu->arch.sie_block); 42275b1c1493SCarsten Otte get_page(vmf->page); 42285b1c1493SCarsten Otte return 0; 42295b1c1493SCarsten Otte } 42305b1c1493SCarsten Otte #endif 42315b1c1493SCarsten Otte return VM_FAULT_SIGBUS; 42325b1c1493SCarsten Otte } 42335b1c1493SCarsten Otte 42345587027cSAneesh Kumar K.V int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, 42355587027cSAneesh Kumar K.V unsigned long npages) 4236db3fe4ebSTakuya Yoshikawa { 4237db3fe4ebSTakuya Yoshikawa return 0; 4238db3fe4ebSTakuya Yoshikawa } 4239db3fe4ebSTakuya Yoshikawa 4240b0c632dbSHeiko Carstens /* Section: memory related */ 4241f7784b8eSMarcelo Tosatti int kvm_arch_prepare_memory_region(struct kvm *kvm, 4242f7784b8eSMarcelo Tosatti struct kvm_memory_slot *memslot, 424309170a49SPaolo Bonzini const struct kvm_userspace_memory_region *mem, 42447b6195a9STakuya Yoshikawa enum kvm_mr_change change) 4245b0c632dbSHeiko Carstens { 4246dd2887e7SNick Wang /* A few sanity checks. We can have memory slots which have to be 4247dd2887e7SNick Wang located/ended at a segment boundary (1MB). The memory in userland is 4248dd2887e7SNick Wang ok to be fragmented into various different vmas. It is okay to mmap() 4249dd2887e7SNick Wang and munmap() stuff in this slot after doing this call at any time */ 4250b0c632dbSHeiko Carstens 4251598841caSCarsten Otte if (mem->userspace_addr & 0xffffful) 4252b0c632dbSHeiko Carstens return -EINVAL; 4253b0c632dbSHeiko Carstens 4254598841caSCarsten Otte if (mem->memory_size & 0xffffful) 4255b0c632dbSHeiko Carstens return -EINVAL; 4256b0c632dbSHeiko Carstens 4257a3a92c31SDominik Dingel if (mem->guest_phys_addr + mem->memory_size > kvm->arch.mem_limit) 4258a3a92c31SDominik Dingel return -EINVAL; 4259a3a92c31SDominik Dingel 4260f7784b8eSMarcelo Tosatti return 0; 4261f7784b8eSMarcelo Tosatti } 4262f7784b8eSMarcelo Tosatti 4263f7784b8eSMarcelo Tosatti void kvm_arch_commit_memory_region(struct kvm *kvm, 426409170a49SPaolo Bonzini const struct kvm_userspace_memory_region *mem, 42658482644aSTakuya Yoshikawa const struct kvm_memory_slot *old, 4266f36f3f28SPaolo Bonzini const struct kvm_memory_slot *new, 42678482644aSTakuya Yoshikawa enum kvm_mr_change change) 4268f7784b8eSMarcelo Tosatti { 4269f7850c92SCarsten Otte int rc; 4270f7784b8eSMarcelo Tosatti 42712cef4debSChristian Borntraeger /* If the basics of the memslot do not change, we do not want 42722cef4debSChristian Borntraeger * to update the gmap. Every update causes several unnecessary 42732cef4debSChristian Borntraeger * segment translation exceptions. This is usually handled just 42742cef4debSChristian Borntraeger * fine by the normal fault handler + gmap, but it will also 42752cef4debSChristian Borntraeger * cause faults on the prefix page of running guest CPUs. 42762cef4debSChristian Borntraeger */ 42772cef4debSChristian Borntraeger if (old->userspace_addr == mem->userspace_addr && 42782cef4debSChristian Borntraeger old->base_gfn * PAGE_SIZE == mem->guest_phys_addr && 42792cef4debSChristian Borntraeger old->npages * PAGE_SIZE == mem->memory_size) 42802cef4debSChristian Borntraeger return; 4281598841caSCarsten Otte 4282598841caSCarsten Otte rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr, 4283598841caSCarsten Otte mem->guest_phys_addr, mem->memory_size); 4284598841caSCarsten Otte if (rc) 4285ea2cdd27SDavid Hildenbrand pr_warn("failed to commit memory region\n"); 4286598841caSCarsten Otte return; 4287b0c632dbSHeiko Carstens } 4288b0c632dbSHeiko Carstens 428960a37709SAlexander Yarygin static inline unsigned long nonhyp_mask(int i) 429060a37709SAlexander Yarygin { 429160a37709SAlexander Yarygin unsigned int nonhyp_fai = (sclp.hmfai << i * 2) >> 30; 429260a37709SAlexander Yarygin 429360a37709SAlexander Yarygin return 0x0000ffffffffffffUL >> (nonhyp_fai << 4); 429460a37709SAlexander Yarygin } 429560a37709SAlexander Yarygin 42963491caf2SChristian Borntraeger void kvm_arch_vcpu_block_finish(struct kvm_vcpu *vcpu) 42973491caf2SChristian Borntraeger { 42983491caf2SChristian Borntraeger vcpu->valid_wakeup = false; 42993491caf2SChristian Borntraeger } 43003491caf2SChristian Borntraeger 4301b0c632dbSHeiko Carstens static int __init kvm_s390_init(void) 4302b0c632dbSHeiko Carstens { 430360a37709SAlexander Yarygin int i; 430460a37709SAlexander Yarygin 430507197fd0SDavid Hildenbrand if (!sclp.has_sief2) { 430607197fd0SDavid Hildenbrand pr_info("SIE not available\n"); 430707197fd0SDavid Hildenbrand return -ENODEV; 430807197fd0SDavid Hildenbrand } 430907197fd0SDavid Hildenbrand 4310a4499382SJanosch Frank if (nested && hpage) { 4311a4499382SJanosch Frank pr_info("nested (vSIE) and hpage (huge page backing) can currently not be activated concurrently"); 4312a4499382SJanosch Frank return -EINVAL; 4313a4499382SJanosch Frank } 4314a4499382SJanosch Frank 431560a37709SAlexander Yarygin for (i = 0; i < 16; i++) 4316c3b9e3e1SChristian Borntraeger kvm_s390_fac_base[i] |= 431760a37709SAlexander Yarygin S390_lowcore.stfle_fac_list[i] & nonhyp_mask(i); 431860a37709SAlexander Yarygin 43199d8d5786SMichael Mueller return kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); 4320b0c632dbSHeiko Carstens } 4321b0c632dbSHeiko Carstens 4322b0c632dbSHeiko Carstens static void __exit kvm_s390_exit(void) 4323b0c632dbSHeiko Carstens { 4324b0c632dbSHeiko Carstens kvm_exit(); 4325b0c632dbSHeiko Carstens } 4326b0c632dbSHeiko Carstens 4327b0c632dbSHeiko Carstens module_init(kvm_s390_init); 4328b0c632dbSHeiko Carstens module_exit(kvm_s390_exit); 4329566af940SCornelia Huck 4330566af940SCornelia Huck /* 4331566af940SCornelia Huck * Enable autoloading of the kvm module. 4332566af940SCornelia Huck * Note that we add the module alias here instead of virt/kvm/kvm_main.c 4333566af940SCornelia Huck * since x86 takes a different approach. 4334566af940SCornelia Huck */ 4335566af940SCornelia Huck #include <linux/miscdevice.h> 4336566af940SCornelia Huck MODULE_ALIAS_MISCDEV(KVM_MINOR); 4337566af940SCornelia Huck MODULE_ALIAS("devname:kvm"); 4338