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 { 42078f26131SChristian Borntraeger kvm_s390_dbf = debug_register("kvm-trace", 32, 1, 7 * sizeof(long)); 42178f26131SChristian Borntraeger if (!kvm_s390_dbf) 42278f26131SChristian Borntraeger return -ENOMEM; 42378f26131SChristian Borntraeger 42478f26131SChristian Borntraeger if (debug_register_view(kvm_s390_dbf, &debug_sprintf_view)) { 42578f26131SChristian Borntraeger debug_unregister(kvm_s390_dbf); 42678f26131SChristian Borntraeger return -ENOMEM; 42778f26131SChristian Borntraeger } 42878f26131SChristian Borntraeger 42922be5a13SDavid Hildenbrand kvm_s390_cpu_feat_init(); 43022be5a13SDavid Hildenbrand 43184877d93SCornelia Huck /* Register floating interrupt controller interface. */ 43284877d93SCornelia Huck return kvm_register_device_ops(&kvm_flic_ops, KVM_DEV_TYPE_FLIC); 433b0c632dbSHeiko Carstens } 434b0c632dbSHeiko Carstens 43578f26131SChristian Borntraeger void kvm_arch_exit(void) 43678f26131SChristian Borntraeger { 43778f26131SChristian Borntraeger debug_unregister(kvm_s390_dbf); 43878f26131SChristian Borntraeger } 43978f26131SChristian Borntraeger 440b0c632dbSHeiko Carstens /* Section: device related */ 441b0c632dbSHeiko Carstens long kvm_arch_dev_ioctl(struct file *filp, 442b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 443b0c632dbSHeiko Carstens { 444b0c632dbSHeiko Carstens if (ioctl == KVM_S390_ENABLE_SIE) 445b0c632dbSHeiko Carstens return s390_enable_sie(); 446b0c632dbSHeiko Carstens return -EINVAL; 447b0c632dbSHeiko Carstens } 448b0c632dbSHeiko Carstens 449784aa3d7SAlexander Graf int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) 450b0c632dbSHeiko Carstens { 451d7b0b5ebSCarsten Otte int r; 452d7b0b5ebSCarsten Otte 4532bd0ac4eSCarsten Otte switch (ext) { 454d7b0b5ebSCarsten Otte case KVM_CAP_S390_PSW: 455b6cf8788SChristian Borntraeger case KVM_CAP_S390_GMAP: 45652e16b18SChristian Borntraeger case KVM_CAP_SYNC_MMU: 4571efd0f59SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 4581efd0f59SCarsten Otte case KVM_CAP_S390_UCONTROL: 4591efd0f59SCarsten Otte #endif 4603c038e6bSDominik Dingel case KVM_CAP_ASYNC_PF: 46160b413c9SChristian Borntraeger case KVM_CAP_SYNC_REGS: 46214eebd91SCarsten Otte case KVM_CAP_ONE_REG: 463d6712df9SCornelia Huck case KVM_CAP_ENABLE_CAP: 464fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 46510ccaa1eSCornelia Huck case KVM_CAP_IOEVENTFD: 466c05c4186SJens Freimann case KVM_CAP_DEVICE_CTRL: 467d938dc55SCornelia Huck case KVM_CAP_ENABLE_CAP_VM: 46878599d90SCornelia Huck case KVM_CAP_S390_IRQCHIP: 469f2061656SDominik Dingel case KVM_CAP_VM_ATTRIBUTES: 4706352e4d2SDavid Hildenbrand case KVM_CAP_MP_STATE: 471460df4c1SPaolo Bonzini case KVM_CAP_IMMEDIATE_EXIT: 47247b43c52SJens Freimann case KVM_CAP_S390_INJECT_IRQ: 4732444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 474e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 47530ee2a98SJason J. Herne case KVM_CAP_S390_SKEYS: 476816c7667SJens Freimann case KVM_CAP_S390_IRQ_STATE: 4776502a34cSDavid Hildenbrand case KVM_CAP_S390_USER_INSTR0: 4784036e387SClaudio Imbrenda case KVM_CAP_S390_CMMA_MIGRATION: 47947a4693eSYi Min Zhao case KVM_CAP_S390_AIS: 480da9a1446SChristian Borntraeger case KVM_CAP_S390_AIS_MIGRATION: 481d7b0b5ebSCarsten Otte r = 1; 482d7b0b5ebSCarsten Otte break; 483a4499382SJanosch Frank case KVM_CAP_S390_HPAGE_1M: 484a4499382SJanosch Frank r = 0; 485a4499382SJanosch Frank if (hpage) 486a4499382SJanosch Frank r = 1; 487a4499382SJanosch Frank break; 48841408c28SThomas Huth case KVM_CAP_S390_MEM_OP: 48941408c28SThomas Huth r = MEM_OP_MAX_SIZE; 49041408c28SThomas Huth break; 491e726b1bdSChristian Borntraeger case KVM_CAP_NR_VCPUS: 492e726b1bdSChristian Borntraeger case KVM_CAP_MAX_VCPUS: 49376a6dd72SDavid Hildenbrand r = KVM_S390_BSCA_CPU_SLOTS; 494a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) 495a6940674SDavid Hildenbrand r = KVM_MAX_VCPUS; 496a6940674SDavid Hildenbrand else if (sclp.has_esca && sclp.has_64bscao) 49776a6dd72SDavid Hildenbrand r = KVM_S390_ESCA_CPU_SLOTS; 498e726b1bdSChristian Borntraeger break; 499e1e2e605SNick Wang case KVM_CAP_NR_MEMSLOTS: 500e1e2e605SNick Wang r = KVM_USER_MEM_SLOTS; 501e1e2e605SNick Wang break; 5021526bf9cSChristian Borntraeger case KVM_CAP_S390_COW: 503abf09bedSMartin Schwidefsky r = MACHINE_HAS_ESOP; 5041526bf9cSChristian Borntraeger break; 50568c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 50668c55750SEric Farman r = MACHINE_HAS_VX; 50768c55750SEric Farman break; 508c6e5f166SFan Zhang case KVM_CAP_S390_RI: 509c6e5f166SFan Zhang r = test_facility(64); 510c6e5f166SFan Zhang break; 5114e0b1ab7SFan Zhang case KVM_CAP_S390_GS: 5124e0b1ab7SFan Zhang r = test_facility(133); 5134e0b1ab7SFan Zhang break; 51435b3fde6SChristian Borntraeger case KVM_CAP_S390_BPB: 51535b3fde6SChristian Borntraeger r = test_facility(82); 51635b3fde6SChristian Borntraeger break; 5172bd0ac4eSCarsten Otte default: 518d7b0b5ebSCarsten Otte r = 0; 519b0c632dbSHeiko Carstens } 520d7b0b5ebSCarsten Otte return r; 5212bd0ac4eSCarsten Otte } 522b0c632dbSHeiko Carstens 52315f36ebdSJason J. Herne static void kvm_s390_sync_dirty_log(struct kvm *kvm, 52415f36ebdSJason J. Herne struct kvm_memory_slot *memslot) 52515f36ebdSJason J. Herne { 5260959e168SJanosch Frank int i; 52715f36ebdSJason J. Herne gfn_t cur_gfn, last_gfn; 5280959e168SJanosch Frank unsigned long gaddr, vmaddr; 52915f36ebdSJason J. Herne struct gmap *gmap = kvm->arch.gmap; 5300959e168SJanosch Frank DECLARE_BITMAP(bitmap, _PAGE_ENTRIES); 53115f36ebdSJason J. Herne 5320959e168SJanosch Frank /* Loop over all guest segments */ 5330959e168SJanosch Frank cur_gfn = memslot->base_gfn; 53415f36ebdSJason J. Herne last_gfn = memslot->base_gfn + memslot->npages; 5350959e168SJanosch Frank for (; cur_gfn <= last_gfn; cur_gfn += _PAGE_ENTRIES) { 5360959e168SJanosch Frank gaddr = gfn_to_gpa(cur_gfn); 5370959e168SJanosch Frank vmaddr = gfn_to_hva_memslot(memslot, cur_gfn); 5380959e168SJanosch Frank if (kvm_is_error_hva(vmaddr)) 5390959e168SJanosch Frank continue; 54015f36ebdSJason J. Herne 5410959e168SJanosch Frank bitmap_zero(bitmap, _PAGE_ENTRIES); 5420959e168SJanosch Frank gmap_sync_dirty_log_pmd(gmap, bitmap, gaddr, vmaddr); 5430959e168SJanosch Frank for (i = 0; i < _PAGE_ENTRIES; i++) { 5440959e168SJanosch Frank if (test_bit(i, bitmap)) 5450959e168SJanosch Frank mark_page_dirty(kvm, cur_gfn + i); 5460959e168SJanosch Frank } 5470959e168SJanosch Frank 5481763f8d0SChristian Borntraeger if (fatal_signal_pending(current)) 5491763f8d0SChristian Borntraeger return; 55070c88a00SChristian Borntraeger cond_resched(); 55115f36ebdSJason J. Herne } 55215f36ebdSJason J. Herne } 55315f36ebdSJason J. Herne 554b0c632dbSHeiko Carstens /* Section: vm related */ 555a6e2f683SEugene (jno) Dvurechenski static void sca_del_vcpu(struct kvm_vcpu *vcpu); 556a6e2f683SEugene (jno) Dvurechenski 557b0c632dbSHeiko Carstens /* 558b0c632dbSHeiko Carstens * Get (and clear) the dirty memory log for a memory slot. 559b0c632dbSHeiko Carstens */ 560b0c632dbSHeiko Carstens int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, 561b0c632dbSHeiko Carstens struct kvm_dirty_log *log) 562b0c632dbSHeiko Carstens { 56315f36ebdSJason J. Herne int r; 56415f36ebdSJason J. Herne unsigned long n; 5659f6b8029SPaolo Bonzini struct kvm_memslots *slots; 56615f36ebdSJason J. Herne struct kvm_memory_slot *memslot; 56715f36ebdSJason J. Herne int is_dirty = 0; 56815f36ebdSJason J. Herne 569e1e8a962SJanosch Frank if (kvm_is_ucontrol(kvm)) 570e1e8a962SJanosch Frank return -EINVAL; 571e1e8a962SJanosch Frank 57215f36ebdSJason J. Herne mutex_lock(&kvm->slots_lock); 57315f36ebdSJason J. Herne 57415f36ebdSJason J. Herne r = -EINVAL; 57515f36ebdSJason J. Herne if (log->slot >= KVM_USER_MEM_SLOTS) 57615f36ebdSJason J. Herne goto out; 57715f36ebdSJason J. Herne 5789f6b8029SPaolo Bonzini slots = kvm_memslots(kvm); 5799f6b8029SPaolo Bonzini memslot = id_to_memslot(slots, log->slot); 58015f36ebdSJason J. Herne r = -ENOENT; 58115f36ebdSJason J. Herne if (!memslot->dirty_bitmap) 58215f36ebdSJason J. Herne goto out; 58315f36ebdSJason J. Herne 58415f36ebdSJason J. Herne kvm_s390_sync_dirty_log(kvm, memslot); 58515f36ebdSJason J. Herne r = kvm_get_dirty_log(kvm, log, &is_dirty); 58615f36ebdSJason J. Herne if (r) 58715f36ebdSJason J. Herne goto out; 58815f36ebdSJason J. Herne 58915f36ebdSJason J. Herne /* Clear the dirty log */ 59015f36ebdSJason J. Herne if (is_dirty) { 59115f36ebdSJason J. Herne n = kvm_dirty_bitmap_bytes(memslot); 59215f36ebdSJason J. Herne memset(memslot->dirty_bitmap, 0, n); 59315f36ebdSJason J. Herne } 59415f36ebdSJason J. Herne r = 0; 59515f36ebdSJason J. Herne out: 59615f36ebdSJason J. Herne mutex_unlock(&kvm->slots_lock); 59715f36ebdSJason J. Herne return r; 598b0c632dbSHeiko Carstens } 599b0c632dbSHeiko Carstens 6006502a34cSDavid Hildenbrand static void icpt_operexc_on_all_vcpus(struct kvm *kvm) 6016502a34cSDavid Hildenbrand { 6026502a34cSDavid Hildenbrand unsigned int i; 6036502a34cSDavid Hildenbrand struct kvm_vcpu *vcpu; 6046502a34cSDavid Hildenbrand 6056502a34cSDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 6066502a34cSDavid Hildenbrand kvm_s390_sync_request(KVM_REQ_ICPT_OPEREXC, vcpu); 6076502a34cSDavid Hildenbrand } 6086502a34cSDavid Hildenbrand } 6096502a34cSDavid Hildenbrand 610d938dc55SCornelia Huck static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap) 611d938dc55SCornelia Huck { 612d938dc55SCornelia Huck int r; 613d938dc55SCornelia Huck 614d938dc55SCornelia Huck if (cap->flags) 615d938dc55SCornelia Huck return -EINVAL; 616d938dc55SCornelia Huck 617d938dc55SCornelia Huck switch (cap->cap) { 61884223598SCornelia Huck case KVM_CAP_S390_IRQCHIP: 619c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_IRQCHIP"); 62084223598SCornelia Huck kvm->arch.use_irqchip = 1; 62184223598SCornelia Huck r = 0; 62284223598SCornelia Huck break; 6232444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 624c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_SIGP"); 6252444b352SDavid Hildenbrand kvm->arch.user_sigp = 1; 6262444b352SDavid Hildenbrand r = 0; 6272444b352SDavid Hildenbrand break; 62868c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 6295967c17bSDavid Hildenbrand mutex_lock(&kvm->lock); 630a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 6315967c17bSDavid Hildenbrand r = -EBUSY; 6325967c17bSDavid Hildenbrand } else if (MACHINE_HAS_VX) { 633c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 129); 634c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 129); 6352f87d942SGuenther Hutzl if (test_facility(134)) { 6362f87d942SGuenther Hutzl set_kvm_facility(kvm->arch.model.fac_mask, 134); 6372f87d942SGuenther Hutzl set_kvm_facility(kvm->arch.model.fac_list, 134); 6382f87d942SGuenther Hutzl } 63953743aa7SMaxim Samoylov if (test_facility(135)) { 64053743aa7SMaxim Samoylov set_kvm_facility(kvm->arch.model.fac_mask, 135); 64153743aa7SMaxim Samoylov set_kvm_facility(kvm->arch.model.fac_list, 135); 64253743aa7SMaxim Samoylov } 64318280d8bSMichael Mueller r = 0; 64418280d8bSMichael Mueller } else 64518280d8bSMichael Mueller r = -EINVAL; 6465967c17bSDavid Hildenbrand mutex_unlock(&kvm->lock); 647c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "ENABLE: CAP_S390_VECTOR_REGISTERS %s", 648c92ea7b9SChristian Borntraeger r ? "(not available)" : "(success)"); 64968c55750SEric Farman break; 650c6e5f166SFan Zhang case KVM_CAP_S390_RI: 651c6e5f166SFan Zhang r = -EINVAL; 652c6e5f166SFan Zhang mutex_lock(&kvm->lock); 653a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 654c6e5f166SFan Zhang r = -EBUSY; 655c6e5f166SFan Zhang } else if (test_facility(64)) { 656c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 64); 657c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 64); 658c6e5f166SFan Zhang r = 0; 659c6e5f166SFan Zhang } 660c6e5f166SFan Zhang mutex_unlock(&kvm->lock); 661c6e5f166SFan Zhang VM_EVENT(kvm, 3, "ENABLE: CAP_S390_RI %s", 662c6e5f166SFan Zhang r ? "(not available)" : "(success)"); 663c6e5f166SFan Zhang break; 66447a4693eSYi Min Zhao case KVM_CAP_S390_AIS: 66547a4693eSYi Min Zhao mutex_lock(&kvm->lock); 66647a4693eSYi Min Zhao if (kvm->created_vcpus) { 66747a4693eSYi Min Zhao r = -EBUSY; 66847a4693eSYi Min Zhao } else { 66947a4693eSYi Min Zhao set_kvm_facility(kvm->arch.model.fac_mask, 72); 67047a4693eSYi Min Zhao set_kvm_facility(kvm->arch.model.fac_list, 72); 67147a4693eSYi Min Zhao r = 0; 67247a4693eSYi Min Zhao } 67347a4693eSYi Min Zhao mutex_unlock(&kvm->lock); 67447a4693eSYi Min Zhao VM_EVENT(kvm, 3, "ENABLE: AIS %s", 67547a4693eSYi Min Zhao r ? "(not available)" : "(success)"); 67647a4693eSYi Min Zhao break; 6774e0b1ab7SFan Zhang case KVM_CAP_S390_GS: 6784e0b1ab7SFan Zhang r = -EINVAL; 6794e0b1ab7SFan Zhang mutex_lock(&kvm->lock); 680241e3ec0SChristian Borntraeger if (kvm->created_vcpus) { 6814e0b1ab7SFan Zhang r = -EBUSY; 6824e0b1ab7SFan Zhang } else if (test_facility(133)) { 6834e0b1ab7SFan Zhang set_kvm_facility(kvm->arch.model.fac_mask, 133); 6844e0b1ab7SFan Zhang set_kvm_facility(kvm->arch.model.fac_list, 133); 6854e0b1ab7SFan Zhang r = 0; 6864e0b1ab7SFan Zhang } 6874e0b1ab7SFan Zhang mutex_unlock(&kvm->lock); 6884e0b1ab7SFan Zhang VM_EVENT(kvm, 3, "ENABLE: CAP_S390_GS %s", 6894e0b1ab7SFan Zhang r ? "(not available)" : "(success)"); 6904e0b1ab7SFan Zhang break; 691a4499382SJanosch Frank case KVM_CAP_S390_HPAGE_1M: 692a4499382SJanosch Frank mutex_lock(&kvm->lock); 693a4499382SJanosch Frank if (kvm->created_vcpus) 694a4499382SJanosch Frank r = -EBUSY; 695a4499382SJanosch Frank else if (!hpage || kvm->arch.use_cmma) 696a4499382SJanosch Frank r = -EINVAL; 697a4499382SJanosch Frank else { 698a4499382SJanosch Frank r = 0; 699df88f318SJanosch Frank down_write(&kvm->mm->mmap_sem); 700a4499382SJanosch Frank kvm->mm->context.allow_gmap_hpage_1m = 1; 701df88f318SJanosch Frank up_write(&kvm->mm->mmap_sem); 702a4499382SJanosch Frank /* 703a4499382SJanosch Frank * We might have to create fake 4k page 704a4499382SJanosch Frank * tables. To avoid that the hardware works on 705a4499382SJanosch Frank * stale PGSTEs, we emulate these instructions. 706a4499382SJanosch Frank */ 707a4499382SJanosch Frank kvm->arch.use_skf = 0; 708a4499382SJanosch Frank kvm->arch.use_pfmfi = 0; 709a4499382SJanosch Frank } 710a4499382SJanosch Frank mutex_unlock(&kvm->lock); 711a4499382SJanosch Frank VM_EVENT(kvm, 3, "ENABLE: CAP_S390_HPAGE %s", 712a4499382SJanosch Frank r ? "(not available)" : "(success)"); 713a4499382SJanosch Frank break; 714e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 715c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_STSI"); 716e44fc8c9SEkaterina Tumanova kvm->arch.user_stsi = 1; 717e44fc8c9SEkaterina Tumanova r = 0; 718e44fc8c9SEkaterina Tumanova break; 7196502a34cSDavid Hildenbrand case KVM_CAP_S390_USER_INSTR0: 7206502a34cSDavid Hildenbrand VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_INSTR0"); 7216502a34cSDavid Hildenbrand kvm->arch.user_instr0 = 1; 7226502a34cSDavid Hildenbrand icpt_operexc_on_all_vcpus(kvm); 7236502a34cSDavid Hildenbrand r = 0; 7246502a34cSDavid Hildenbrand break; 725d938dc55SCornelia Huck default: 726d938dc55SCornelia Huck r = -EINVAL; 727d938dc55SCornelia Huck break; 728d938dc55SCornelia Huck } 729d938dc55SCornelia Huck return r; 730d938dc55SCornelia Huck } 731d938dc55SCornelia Huck 7328c0a7ce6SDominik Dingel static int kvm_s390_get_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 7338c0a7ce6SDominik Dingel { 7348c0a7ce6SDominik Dingel int ret; 7358c0a7ce6SDominik Dingel 7368c0a7ce6SDominik Dingel switch (attr->attr) { 7378c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 7388c0a7ce6SDominik Dingel ret = 0; 739c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: max guest memory: %lu bytes", 740a3a92c31SDominik Dingel kvm->arch.mem_limit); 741a3a92c31SDominik Dingel if (put_user(kvm->arch.mem_limit, (u64 __user *)attr->addr)) 7428c0a7ce6SDominik Dingel ret = -EFAULT; 7438c0a7ce6SDominik Dingel break; 7448c0a7ce6SDominik Dingel default: 7458c0a7ce6SDominik Dingel ret = -ENXIO; 7468c0a7ce6SDominik Dingel break; 7478c0a7ce6SDominik Dingel } 7488c0a7ce6SDominik Dingel return ret; 7498c0a7ce6SDominik Dingel } 7508c0a7ce6SDominik Dingel 7518c0a7ce6SDominik Dingel static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 7524f718eabSDominik Dingel { 7534f718eabSDominik Dingel int ret; 7544f718eabSDominik Dingel unsigned int idx; 7554f718eabSDominik Dingel switch (attr->attr) { 7564f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 757f9cbd9b0SDavid Hildenbrand ret = -ENXIO; 758c24cc9c8SDavid Hildenbrand if (!sclp.has_cmma) 759e6db1d61SDominik Dingel break; 760e6db1d61SDominik Dingel 761c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CMMA support"); 7624f718eabSDominik Dingel mutex_lock(&kvm->lock); 763a4499382SJanosch Frank if (kvm->created_vcpus) 764a4499382SJanosch Frank ret = -EBUSY; 765a4499382SJanosch Frank else if (kvm->mm->context.allow_gmap_hpage_1m) 766a4499382SJanosch Frank ret = -EINVAL; 767a4499382SJanosch Frank else { 7684f718eabSDominik Dingel kvm->arch.use_cmma = 1; 769c9f0a2b8SJanosch Frank /* Not compatible with cmma. */ 770c9f0a2b8SJanosch Frank kvm->arch.use_pfmfi = 0; 7714f718eabSDominik Dingel ret = 0; 7724f718eabSDominik Dingel } 7734f718eabSDominik Dingel mutex_unlock(&kvm->lock); 7744f718eabSDominik Dingel break; 7754f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 776f9cbd9b0SDavid Hildenbrand ret = -ENXIO; 777f9cbd9b0SDavid Hildenbrand if (!sclp.has_cmma) 778f9cbd9b0SDavid Hildenbrand break; 779c3489155SDominik Dingel ret = -EINVAL; 780c3489155SDominik Dingel if (!kvm->arch.use_cmma) 781c3489155SDominik Dingel break; 782c3489155SDominik Dingel 783c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "RESET: CMMA states"); 7844f718eabSDominik Dingel mutex_lock(&kvm->lock); 7854f718eabSDominik Dingel idx = srcu_read_lock(&kvm->srcu); 786a13cff31SDominik Dingel s390_reset_cmma(kvm->arch.gmap->mm); 7874f718eabSDominik Dingel srcu_read_unlock(&kvm->srcu, idx); 7884f718eabSDominik Dingel mutex_unlock(&kvm->lock); 7894f718eabSDominik Dingel ret = 0; 7904f718eabSDominik Dingel break; 7918c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: { 7928c0a7ce6SDominik Dingel unsigned long new_limit; 7938c0a7ce6SDominik Dingel 7948c0a7ce6SDominik Dingel if (kvm_is_ucontrol(kvm)) 7958c0a7ce6SDominik Dingel return -EINVAL; 7968c0a7ce6SDominik Dingel 7978c0a7ce6SDominik Dingel if (get_user(new_limit, (u64 __user *)attr->addr)) 7988c0a7ce6SDominik Dingel return -EFAULT; 7998c0a7ce6SDominik Dingel 800a3a92c31SDominik Dingel if (kvm->arch.mem_limit != KVM_S390_NO_MEM_LIMIT && 801a3a92c31SDominik Dingel new_limit > kvm->arch.mem_limit) 8028c0a7ce6SDominik Dingel return -E2BIG; 8038c0a7ce6SDominik Dingel 804a3a92c31SDominik Dingel if (!new_limit) 805a3a92c31SDominik Dingel return -EINVAL; 806a3a92c31SDominik Dingel 8076ea427bbSMartin Schwidefsky /* gmap_create takes last usable address */ 808a3a92c31SDominik Dingel if (new_limit != KVM_S390_NO_MEM_LIMIT) 809a3a92c31SDominik Dingel new_limit -= 1; 810a3a92c31SDominik Dingel 8118c0a7ce6SDominik Dingel ret = -EBUSY; 8128c0a7ce6SDominik Dingel mutex_lock(&kvm->lock); 813a03825bbSPaolo Bonzini if (!kvm->created_vcpus) { 8146ea427bbSMartin Schwidefsky /* gmap_create will round the limit up */ 8156ea427bbSMartin Schwidefsky struct gmap *new = gmap_create(current->mm, new_limit); 8168c0a7ce6SDominik Dingel 8178c0a7ce6SDominik Dingel if (!new) { 8188c0a7ce6SDominik Dingel ret = -ENOMEM; 8198c0a7ce6SDominik Dingel } else { 8206ea427bbSMartin Schwidefsky gmap_remove(kvm->arch.gmap); 8218c0a7ce6SDominik Dingel new->private = kvm; 8228c0a7ce6SDominik Dingel kvm->arch.gmap = new; 8238c0a7ce6SDominik Dingel ret = 0; 8248c0a7ce6SDominik Dingel } 8258c0a7ce6SDominik Dingel } 8268c0a7ce6SDominik Dingel mutex_unlock(&kvm->lock); 827a3a92c31SDominik Dingel VM_EVENT(kvm, 3, "SET: max guest address: %lu", new_limit); 828a3a92c31SDominik Dingel VM_EVENT(kvm, 3, "New guest asce: 0x%pK", 829a3a92c31SDominik Dingel (void *) kvm->arch.gmap->asce); 8308c0a7ce6SDominik Dingel break; 8318c0a7ce6SDominik Dingel } 8324f718eabSDominik Dingel default: 8334f718eabSDominik Dingel ret = -ENXIO; 8344f718eabSDominik Dingel break; 8354f718eabSDominik Dingel } 8364f718eabSDominik Dingel return ret; 8374f718eabSDominik Dingel } 8384f718eabSDominik Dingel 839a374e892STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu); 840a374e892STony Krowiak 84120c922f0STony Krowiak void kvm_s390_vcpu_crypto_reset_all(struct kvm *kvm) 842a374e892STony Krowiak { 843a374e892STony Krowiak struct kvm_vcpu *vcpu; 844a374e892STony Krowiak int i; 845a374e892STony Krowiak 84620c922f0STony Krowiak kvm_s390_vcpu_block_all(kvm); 84720c922f0STony Krowiak 8483194cdb7SDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 84920c922f0STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 8503194cdb7SDavid Hildenbrand /* recreate the shadow crycb by leaving the VSIE handler */ 8513194cdb7SDavid Hildenbrand kvm_s390_sync_request(KVM_REQ_VSIE_RESTART, vcpu); 8523194cdb7SDavid Hildenbrand } 85320c922f0STony Krowiak 85420c922f0STony Krowiak kvm_s390_vcpu_unblock_all(kvm); 85520c922f0STony Krowiak } 85620c922f0STony Krowiak 85720c922f0STony Krowiak static int kvm_s390_vm_set_crypto(struct kvm *kvm, struct kvm_device_attr *attr) 85820c922f0STony Krowiak { 8599d8d5786SMichael Mueller if (!test_kvm_facility(kvm, 76)) 860a374e892STony Krowiak return -EINVAL; 861a374e892STony Krowiak 862a374e892STony Krowiak mutex_lock(&kvm->lock); 863a374e892STony Krowiak switch (attr->attr) { 864a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 865a374e892STony Krowiak get_random_bytes( 866a374e892STony Krowiak kvm->arch.crypto.crycb->aes_wrapping_key_mask, 867a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 868a374e892STony Krowiak kvm->arch.crypto.aes_kw = 1; 869c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: AES keywrapping support"); 870a374e892STony Krowiak break; 871a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 872a374e892STony Krowiak get_random_bytes( 873a374e892STony Krowiak kvm->arch.crypto.crycb->dea_wrapping_key_mask, 874a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 875a374e892STony Krowiak kvm->arch.crypto.dea_kw = 1; 876c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: DEA keywrapping support"); 877a374e892STony Krowiak break; 878a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 879a374e892STony Krowiak kvm->arch.crypto.aes_kw = 0; 880a374e892STony Krowiak memset(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 0, 881a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 882c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "DISABLE: AES keywrapping support"); 883a374e892STony Krowiak break; 884a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 885a374e892STony Krowiak kvm->arch.crypto.dea_kw = 0; 886a374e892STony Krowiak memset(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 0, 887a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 888c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "DISABLE: DEA keywrapping support"); 889a374e892STony Krowiak break; 890a374e892STony Krowiak default: 891a374e892STony Krowiak mutex_unlock(&kvm->lock); 892a374e892STony Krowiak return -ENXIO; 893a374e892STony Krowiak } 894a374e892STony Krowiak 89520c922f0STony Krowiak kvm_s390_vcpu_crypto_reset_all(kvm); 896a374e892STony Krowiak mutex_unlock(&kvm->lock); 897a374e892STony Krowiak return 0; 898a374e892STony Krowiak } 899a374e892STony Krowiak 900190df4a2SClaudio Imbrenda static void kvm_s390_sync_request_broadcast(struct kvm *kvm, int req) 901190df4a2SClaudio Imbrenda { 902190df4a2SClaudio Imbrenda int cx; 903190df4a2SClaudio Imbrenda struct kvm_vcpu *vcpu; 904190df4a2SClaudio Imbrenda 905190df4a2SClaudio Imbrenda kvm_for_each_vcpu(cx, vcpu, kvm) 906190df4a2SClaudio Imbrenda kvm_s390_sync_request(req, vcpu); 907190df4a2SClaudio Imbrenda } 908190df4a2SClaudio Imbrenda 909190df4a2SClaudio Imbrenda /* 910190df4a2SClaudio Imbrenda * Must be called with kvm->srcu held to avoid races on memslots, and with 9111de1ea7eSChristian Borntraeger * kvm->slots_lock to avoid races with ourselves and kvm_s390_vm_stop_migration. 912190df4a2SClaudio Imbrenda */ 913190df4a2SClaudio Imbrenda static int kvm_s390_vm_start_migration(struct kvm *kvm) 914190df4a2SClaudio Imbrenda { 915190df4a2SClaudio Imbrenda struct kvm_memory_slot *ms; 916190df4a2SClaudio Imbrenda struct kvm_memslots *slots; 917afdad616SClaudio Imbrenda unsigned long ram_pages = 0; 918190df4a2SClaudio Imbrenda int slotnr; 919190df4a2SClaudio Imbrenda 920190df4a2SClaudio Imbrenda /* migration mode already enabled */ 921afdad616SClaudio Imbrenda if (kvm->arch.migration_mode) 922190df4a2SClaudio Imbrenda return 0; 923190df4a2SClaudio Imbrenda slots = kvm_memslots(kvm); 924190df4a2SClaudio Imbrenda if (!slots || !slots->used_slots) 925190df4a2SClaudio Imbrenda return -EINVAL; 926190df4a2SClaudio Imbrenda 927afdad616SClaudio Imbrenda if (!kvm->arch.use_cmma) { 928afdad616SClaudio Imbrenda kvm->arch.migration_mode = 1; 929afdad616SClaudio Imbrenda return 0; 930190df4a2SClaudio Imbrenda } 931190df4a2SClaudio Imbrenda /* mark all the pages in active slots as dirty */ 932190df4a2SClaudio Imbrenda for (slotnr = 0; slotnr < slots->used_slots; slotnr++) { 933190df4a2SClaudio Imbrenda ms = slots->memslots + slotnr; 934afdad616SClaudio Imbrenda /* 935afdad616SClaudio Imbrenda * The second half of the bitmap is only used on x86, 936afdad616SClaudio Imbrenda * and would be wasted otherwise, so we put it to good 937afdad616SClaudio Imbrenda * use here to keep track of the state of the storage 938afdad616SClaudio Imbrenda * attributes. 939afdad616SClaudio Imbrenda */ 940afdad616SClaudio Imbrenda memset(kvm_second_dirty_bitmap(ms), 0xff, kvm_dirty_bitmap_bytes(ms)); 941afdad616SClaudio Imbrenda ram_pages += ms->npages; 942190df4a2SClaudio Imbrenda } 943afdad616SClaudio Imbrenda atomic64_set(&kvm->arch.cmma_dirty_pages, ram_pages); 944afdad616SClaudio Imbrenda kvm->arch.migration_mode = 1; 945190df4a2SClaudio Imbrenda kvm_s390_sync_request_broadcast(kvm, KVM_REQ_START_MIGRATION); 946190df4a2SClaudio Imbrenda return 0; 947190df4a2SClaudio Imbrenda } 948190df4a2SClaudio Imbrenda 949190df4a2SClaudio Imbrenda /* 9501de1ea7eSChristian Borntraeger * Must be called with kvm->slots_lock to avoid races with ourselves and 951190df4a2SClaudio Imbrenda * kvm_s390_vm_start_migration. 952190df4a2SClaudio Imbrenda */ 953190df4a2SClaudio Imbrenda static int kvm_s390_vm_stop_migration(struct kvm *kvm) 954190df4a2SClaudio Imbrenda { 955190df4a2SClaudio Imbrenda /* migration mode already disabled */ 956afdad616SClaudio Imbrenda if (!kvm->arch.migration_mode) 957190df4a2SClaudio Imbrenda return 0; 958afdad616SClaudio Imbrenda kvm->arch.migration_mode = 0; 959afdad616SClaudio Imbrenda if (kvm->arch.use_cmma) 960190df4a2SClaudio Imbrenda kvm_s390_sync_request_broadcast(kvm, KVM_REQ_STOP_MIGRATION); 961190df4a2SClaudio Imbrenda return 0; 962190df4a2SClaudio Imbrenda } 963190df4a2SClaudio Imbrenda 964190df4a2SClaudio Imbrenda static int kvm_s390_vm_set_migration(struct kvm *kvm, 965190df4a2SClaudio Imbrenda struct kvm_device_attr *attr) 966190df4a2SClaudio Imbrenda { 9671de1ea7eSChristian Borntraeger int res = -ENXIO; 968190df4a2SClaudio Imbrenda 9691de1ea7eSChristian Borntraeger mutex_lock(&kvm->slots_lock); 970190df4a2SClaudio Imbrenda switch (attr->attr) { 971190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION_START: 972190df4a2SClaudio Imbrenda res = kvm_s390_vm_start_migration(kvm); 973190df4a2SClaudio Imbrenda break; 974190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION_STOP: 975190df4a2SClaudio Imbrenda res = kvm_s390_vm_stop_migration(kvm); 976190df4a2SClaudio Imbrenda break; 977190df4a2SClaudio Imbrenda default: 978190df4a2SClaudio Imbrenda break; 979190df4a2SClaudio Imbrenda } 9801de1ea7eSChristian Borntraeger mutex_unlock(&kvm->slots_lock); 981190df4a2SClaudio Imbrenda 982190df4a2SClaudio Imbrenda return res; 983190df4a2SClaudio Imbrenda } 984190df4a2SClaudio Imbrenda 985190df4a2SClaudio Imbrenda static int kvm_s390_vm_get_migration(struct kvm *kvm, 986190df4a2SClaudio Imbrenda struct kvm_device_attr *attr) 987190df4a2SClaudio Imbrenda { 988afdad616SClaudio Imbrenda u64 mig = kvm->arch.migration_mode; 989190df4a2SClaudio Imbrenda 990190df4a2SClaudio Imbrenda if (attr->attr != KVM_S390_VM_MIGRATION_STATUS) 991190df4a2SClaudio Imbrenda return -ENXIO; 992190df4a2SClaudio Imbrenda 993190df4a2SClaudio Imbrenda if (copy_to_user((void __user *)attr->addr, &mig, sizeof(mig))) 994190df4a2SClaudio Imbrenda return -EFAULT; 995190df4a2SClaudio Imbrenda return 0; 996190df4a2SClaudio Imbrenda } 997190df4a2SClaudio Imbrenda 9988fa1696eSCollin L. Walling static int kvm_s390_set_tod_ext(struct kvm *kvm, struct kvm_device_attr *attr) 9998fa1696eSCollin L. Walling { 10008fa1696eSCollin L. Walling struct kvm_s390_vm_tod_clock gtod; 10018fa1696eSCollin L. Walling 10028fa1696eSCollin L. Walling if (copy_from_user(>od, (void __user *)attr->addr, sizeof(gtod))) 10038fa1696eSCollin L. Walling return -EFAULT; 10048fa1696eSCollin L. Walling 10050e7def5fSDavid Hildenbrand if (!test_kvm_facility(kvm, 139) && gtod.epoch_idx) 10068fa1696eSCollin L. Walling return -EINVAL; 10070e7def5fSDavid Hildenbrand kvm_s390_set_tod_clock(kvm, >od); 10088fa1696eSCollin L. Walling 10098fa1696eSCollin L. Walling VM_EVENT(kvm, 3, "SET: TOD extension: 0x%x, TOD base: 0x%llx", 10108fa1696eSCollin L. Walling gtod.epoch_idx, gtod.tod); 10118fa1696eSCollin L. Walling 10128fa1696eSCollin L. Walling return 0; 10138fa1696eSCollin L. Walling } 10148fa1696eSCollin L. Walling 101572f25020SJason J. Herne static int kvm_s390_set_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 101672f25020SJason J. Herne { 101772f25020SJason J. Herne u8 gtod_high; 101872f25020SJason J. Herne 101972f25020SJason J. Herne if (copy_from_user(>od_high, (void __user *)attr->addr, 102072f25020SJason J. Herne sizeof(gtod_high))) 102172f25020SJason J. Herne return -EFAULT; 102272f25020SJason J. Herne 102372f25020SJason J. Herne if (gtod_high != 0) 102472f25020SJason J. Herne return -EINVAL; 102558c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "SET: TOD extension: 0x%x", gtod_high); 102672f25020SJason J. Herne 102772f25020SJason J. Herne return 0; 102872f25020SJason J. Herne } 102972f25020SJason J. Herne 103072f25020SJason J. Herne static int kvm_s390_set_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 103172f25020SJason J. Herne { 10320e7def5fSDavid Hildenbrand struct kvm_s390_vm_tod_clock gtod = { 0 }; 103372f25020SJason J. Herne 10340e7def5fSDavid Hildenbrand if (copy_from_user(>od.tod, (void __user *)attr->addr, 10350e7def5fSDavid Hildenbrand sizeof(gtod.tod))) 103672f25020SJason J. Herne return -EFAULT; 103772f25020SJason J. Herne 10380e7def5fSDavid Hildenbrand kvm_s390_set_tod_clock(kvm, >od); 10390e7def5fSDavid Hildenbrand VM_EVENT(kvm, 3, "SET: TOD base: 0x%llx", gtod.tod); 104072f25020SJason J. Herne return 0; 104172f25020SJason J. Herne } 104272f25020SJason J. Herne 104372f25020SJason J. Herne static int kvm_s390_set_tod(struct kvm *kvm, struct kvm_device_attr *attr) 104472f25020SJason J. Herne { 104572f25020SJason J. Herne int ret; 104672f25020SJason J. Herne 104772f25020SJason J. Herne if (attr->flags) 104872f25020SJason J. Herne return -EINVAL; 104972f25020SJason J. Herne 105072f25020SJason J. Herne switch (attr->attr) { 10518fa1696eSCollin L. Walling case KVM_S390_VM_TOD_EXT: 10528fa1696eSCollin L. Walling ret = kvm_s390_set_tod_ext(kvm, attr); 10538fa1696eSCollin L. Walling break; 105472f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 105572f25020SJason J. Herne ret = kvm_s390_set_tod_high(kvm, attr); 105672f25020SJason J. Herne break; 105772f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 105872f25020SJason J. Herne ret = kvm_s390_set_tod_low(kvm, attr); 105972f25020SJason J. Herne break; 106072f25020SJason J. Herne default: 106172f25020SJason J. Herne ret = -ENXIO; 106272f25020SJason J. Herne break; 106372f25020SJason J. Herne } 106472f25020SJason J. Herne return ret; 106572f25020SJason J. Herne } 106672f25020SJason J. Herne 106733d1b272SDavid Hildenbrand static void kvm_s390_get_tod_clock(struct kvm *kvm, 10688fa1696eSCollin L. Walling struct kvm_s390_vm_tod_clock *gtod) 10698fa1696eSCollin L. Walling { 10708fa1696eSCollin L. Walling struct kvm_s390_tod_clock_ext htod; 10718fa1696eSCollin L. Walling 10728fa1696eSCollin L. Walling preempt_disable(); 10738fa1696eSCollin L. Walling 10748fa1696eSCollin L. Walling get_tod_clock_ext((char *)&htod); 10758fa1696eSCollin L. Walling 10768fa1696eSCollin L. Walling gtod->tod = htod.tod + kvm->arch.epoch; 107733d1b272SDavid Hildenbrand gtod->epoch_idx = 0; 107833d1b272SDavid Hildenbrand if (test_kvm_facility(kvm, 139)) { 10798fa1696eSCollin L. Walling gtod->epoch_idx = htod.epoch_idx + kvm->arch.epdx; 10808fa1696eSCollin L. Walling if (gtod->tod < htod.tod) 10818fa1696eSCollin L. Walling gtod->epoch_idx += 1; 108233d1b272SDavid Hildenbrand } 10838fa1696eSCollin L. Walling 10848fa1696eSCollin L. Walling preempt_enable(); 10858fa1696eSCollin L. Walling } 10868fa1696eSCollin L. Walling 10878fa1696eSCollin L. Walling static int kvm_s390_get_tod_ext(struct kvm *kvm, struct kvm_device_attr *attr) 10888fa1696eSCollin L. Walling { 10898fa1696eSCollin L. Walling struct kvm_s390_vm_tod_clock gtod; 10908fa1696eSCollin L. Walling 10918fa1696eSCollin L. Walling memset(>od, 0, sizeof(gtod)); 109233d1b272SDavid Hildenbrand kvm_s390_get_tod_clock(kvm, >od); 10938fa1696eSCollin L. Walling if (copy_to_user((void __user *)attr->addr, >od, sizeof(gtod))) 10948fa1696eSCollin L. Walling return -EFAULT; 10958fa1696eSCollin L. Walling 10968fa1696eSCollin L. Walling VM_EVENT(kvm, 3, "QUERY: TOD extension: 0x%x, TOD base: 0x%llx", 10978fa1696eSCollin L. Walling gtod.epoch_idx, gtod.tod); 10988fa1696eSCollin L. Walling return 0; 10998fa1696eSCollin L. Walling } 11008fa1696eSCollin L. Walling 110172f25020SJason J. Herne static int kvm_s390_get_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 110272f25020SJason J. Herne { 110372f25020SJason J. Herne u8 gtod_high = 0; 110472f25020SJason J. Herne 110572f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od_high, 110672f25020SJason J. Herne sizeof(gtod_high))) 110772f25020SJason J. Herne return -EFAULT; 110858c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: TOD extension: 0x%x", gtod_high); 110972f25020SJason J. Herne 111072f25020SJason J. Herne return 0; 111172f25020SJason J. Herne } 111272f25020SJason J. Herne 111372f25020SJason J. Herne static int kvm_s390_get_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 111472f25020SJason J. Herne { 11155a3d883aSDavid Hildenbrand u64 gtod; 111672f25020SJason J. Herne 111760417fccSDavid Hildenbrand gtod = kvm_s390_get_tod_clock_fast(kvm); 111872f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od, sizeof(gtod))) 111972f25020SJason J. Herne return -EFAULT; 112058c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: TOD base: 0x%llx", gtod); 112172f25020SJason J. Herne 112272f25020SJason J. Herne return 0; 112372f25020SJason J. Herne } 112472f25020SJason J. Herne 112572f25020SJason J. Herne static int kvm_s390_get_tod(struct kvm *kvm, struct kvm_device_attr *attr) 112672f25020SJason J. Herne { 112772f25020SJason J. Herne int ret; 112872f25020SJason J. Herne 112972f25020SJason J. Herne if (attr->flags) 113072f25020SJason J. Herne return -EINVAL; 113172f25020SJason J. Herne 113272f25020SJason J. Herne switch (attr->attr) { 11338fa1696eSCollin L. Walling case KVM_S390_VM_TOD_EXT: 11348fa1696eSCollin L. Walling ret = kvm_s390_get_tod_ext(kvm, attr); 11358fa1696eSCollin L. Walling break; 113672f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 113772f25020SJason J. Herne ret = kvm_s390_get_tod_high(kvm, attr); 113872f25020SJason J. Herne break; 113972f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 114072f25020SJason J. Herne ret = kvm_s390_get_tod_low(kvm, attr); 114172f25020SJason J. Herne break; 114272f25020SJason J. Herne default: 114372f25020SJason J. Herne ret = -ENXIO; 114472f25020SJason J. Herne break; 114572f25020SJason J. Herne } 114672f25020SJason J. Herne return ret; 114772f25020SJason J. Herne } 114872f25020SJason J. Herne 1149658b6edaSMichael Mueller static int kvm_s390_set_processor(struct kvm *kvm, struct kvm_device_attr *attr) 1150658b6edaSMichael Mueller { 1151658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 1152053dd230SDavid Hildenbrand u16 lowest_ibc, unblocked_ibc; 1153658b6edaSMichael Mueller int ret = 0; 1154658b6edaSMichael Mueller 1155658b6edaSMichael Mueller mutex_lock(&kvm->lock); 1156a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 1157658b6edaSMichael Mueller ret = -EBUSY; 1158658b6edaSMichael Mueller goto out; 1159658b6edaSMichael Mueller } 1160658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 1161658b6edaSMichael Mueller if (!proc) { 1162658b6edaSMichael Mueller ret = -ENOMEM; 1163658b6edaSMichael Mueller goto out; 1164658b6edaSMichael Mueller } 1165658b6edaSMichael Mueller if (!copy_from_user(proc, (void __user *)attr->addr, 1166658b6edaSMichael Mueller sizeof(*proc))) { 11679bb0ec09SDavid Hildenbrand kvm->arch.model.cpuid = proc->cpuid; 1168053dd230SDavid Hildenbrand lowest_ibc = sclp.ibc >> 16 & 0xfff; 1169053dd230SDavid Hildenbrand unblocked_ibc = sclp.ibc & 0xfff; 11700487c44dSDavid Hildenbrand if (lowest_ibc && proc->ibc) { 1171053dd230SDavid Hildenbrand if (proc->ibc > unblocked_ibc) 1172053dd230SDavid Hildenbrand kvm->arch.model.ibc = unblocked_ibc; 1173053dd230SDavid Hildenbrand else if (proc->ibc < lowest_ibc) 1174053dd230SDavid Hildenbrand kvm->arch.model.ibc = lowest_ibc; 1175053dd230SDavid Hildenbrand else 1176658b6edaSMichael Mueller kvm->arch.model.ibc = proc->ibc; 1177053dd230SDavid Hildenbrand } 1178c54f0d6aSDavid Hildenbrand memcpy(kvm->arch.model.fac_list, proc->fac_list, 1179658b6edaSMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 1180a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest ibc: 0x%4.4x, guest cpuid: 0x%16.16llx", 1181a8c39dd7SChristian Borntraeger kvm->arch.model.ibc, 1182a8c39dd7SChristian Borntraeger kvm->arch.model.cpuid); 1183a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest faclist: 0x%16.16llx.%16.16llx.%16.16llx", 1184a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[0], 1185a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[1], 1186a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[2]); 1187658b6edaSMichael Mueller } else 1188658b6edaSMichael Mueller ret = -EFAULT; 1189658b6edaSMichael Mueller kfree(proc); 1190658b6edaSMichael Mueller out: 1191658b6edaSMichael Mueller mutex_unlock(&kvm->lock); 1192658b6edaSMichael Mueller return ret; 1193658b6edaSMichael Mueller } 1194658b6edaSMichael Mueller 119515c9705fSDavid Hildenbrand static int kvm_s390_set_processor_feat(struct kvm *kvm, 119615c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 119715c9705fSDavid Hildenbrand { 119815c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 119915c9705fSDavid Hildenbrand 120015c9705fSDavid Hildenbrand if (copy_from_user(&data, (void __user *)attr->addr, sizeof(data))) 120115c9705fSDavid Hildenbrand return -EFAULT; 120215c9705fSDavid Hildenbrand if (!bitmap_subset((unsigned long *) data.feat, 120315c9705fSDavid Hildenbrand kvm_s390_available_cpu_feat, 120415c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS)) 120515c9705fSDavid Hildenbrand return -EINVAL; 120615c9705fSDavid Hildenbrand 120715c9705fSDavid Hildenbrand mutex_lock(&kvm->lock); 12082f8311c9SChristian Borntraeger if (kvm->created_vcpus) { 12092f8311c9SChristian Borntraeger mutex_unlock(&kvm->lock); 12102f8311c9SChristian Borntraeger return -EBUSY; 12112f8311c9SChristian Borntraeger } 121215c9705fSDavid Hildenbrand bitmap_copy(kvm->arch.cpu_feat, (unsigned long *) data.feat, 121315c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 121415c9705fSDavid Hildenbrand mutex_unlock(&kvm->lock); 12152f8311c9SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx", 12162f8311c9SChristian Borntraeger data.feat[0], 12172f8311c9SChristian Borntraeger data.feat[1], 12182f8311c9SChristian Borntraeger data.feat[2]); 12192f8311c9SChristian Borntraeger return 0; 122015c9705fSDavid Hildenbrand } 122115c9705fSDavid Hildenbrand 12220a763c78SDavid Hildenbrand static int kvm_s390_set_processor_subfunc(struct kvm *kvm, 12230a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 12240a763c78SDavid Hildenbrand { 12250a763c78SDavid Hildenbrand /* 12260a763c78SDavid Hildenbrand * Once supported by kernel + hw, we have to store the subfunctions 12270a763c78SDavid Hildenbrand * in kvm->arch and remember that user space configured them. 12280a763c78SDavid Hildenbrand */ 12290a763c78SDavid Hildenbrand return -ENXIO; 12300a763c78SDavid Hildenbrand } 12310a763c78SDavid Hildenbrand 1232658b6edaSMichael Mueller static int kvm_s390_set_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 1233658b6edaSMichael Mueller { 1234658b6edaSMichael Mueller int ret = -ENXIO; 1235658b6edaSMichael Mueller 1236658b6edaSMichael Mueller switch (attr->attr) { 1237658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 1238658b6edaSMichael Mueller ret = kvm_s390_set_processor(kvm, attr); 1239658b6edaSMichael Mueller break; 124015c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 124115c9705fSDavid Hildenbrand ret = kvm_s390_set_processor_feat(kvm, attr); 124215c9705fSDavid Hildenbrand break; 12430a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 12440a763c78SDavid Hildenbrand ret = kvm_s390_set_processor_subfunc(kvm, attr); 12450a763c78SDavid Hildenbrand break; 1246658b6edaSMichael Mueller } 1247658b6edaSMichael Mueller return ret; 1248658b6edaSMichael Mueller } 1249658b6edaSMichael Mueller 1250658b6edaSMichael Mueller static int kvm_s390_get_processor(struct kvm *kvm, struct kvm_device_attr *attr) 1251658b6edaSMichael Mueller { 1252658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 1253658b6edaSMichael Mueller int ret = 0; 1254658b6edaSMichael Mueller 1255658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 1256658b6edaSMichael Mueller if (!proc) { 1257658b6edaSMichael Mueller ret = -ENOMEM; 1258658b6edaSMichael Mueller goto out; 1259658b6edaSMichael Mueller } 12609bb0ec09SDavid Hildenbrand proc->cpuid = kvm->arch.model.cpuid; 1261658b6edaSMichael Mueller proc->ibc = kvm->arch.model.ibc; 1262c54f0d6aSDavid Hildenbrand memcpy(&proc->fac_list, kvm->arch.model.fac_list, 1263c54f0d6aSDavid Hildenbrand S390_ARCH_FAC_LIST_SIZE_BYTE); 1264a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest ibc: 0x%4.4x, guest cpuid: 0x%16.16llx", 1265a8c39dd7SChristian Borntraeger kvm->arch.model.ibc, 1266a8c39dd7SChristian Borntraeger kvm->arch.model.cpuid); 1267a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest faclist: 0x%16.16llx.%16.16llx.%16.16llx", 1268a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[0], 1269a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[1], 1270a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[2]); 1271658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, proc, sizeof(*proc))) 1272658b6edaSMichael Mueller ret = -EFAULT; 1273658b6edaSMichael Mueller kfree(proc); 1274658b6edaSMichael Mueller out: 1275658b6edaSMichael Mueller return ret; 1276658b6edaSMichael Mueller } 1277658b6edaSMichael Mueller 1278658b6edaSMichael Mueller static int kvm_s390_get_machine(struct kvm *kvm, struct kvm_device_attr *attr) 1279658b6edaSMichael Mueller { 1280658b6edaSMichael Mueller struct kvm_s390_vm_cpu_machine *mach; 1281658b6edaSMichael Mueller int ret = 0; 1282658b6edaSMichael Mueller 1283658b6edaSMichael Mueller mach = kzalloc(sizeof(*mach), GFP_KERNEL); 1284658b6edaSMichael Mueller if (!mach) { 1285658b6edaSMichael Mueller ret = -ENOMEM; 1286658b6edaSMichael Mueller goto out; 1287658b6edaSMichael Mueller } 1288658b6edaSMichael Mueller get_cpu_id((struct cpuid *) &mach->cpuid); 128937c5f6c8SDavid Hildenbrand mach->ibc = sclp.ibc; 1290c54f0d6aSDavid Hildenbrand memcpy(&mach->fac_mask, kvm->arch.model.fac_mask, 1291981467c9SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 1292658b6edaSMichael Mueller memcpy((unsigned long *)&mach->fac_list, S390_lowcore.stfle_fac_list, 129304478197SChristian Borntraeger sizeof(S390_lowcore.stfle_fac_list)); 1294a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host ibc: 0x%4.4x, host cpuid: 0x%16.16llx", 1295a8c39dd7SChristian Borntraeger kvm->arch.model.ibc, 1296a8c39dd7SChristian Borntraeger kvm->arch.model.cpuid); 1297a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host facmask: 0x%16.16llx.%16.16llx.%16.16llx", 1298a8c39dd7SChristian Borntraeger mach->fac_mask[0], 1299a8c39dd7SChristian Borntraeger mach->fac_mask[1], 1300a8c39dd7SChristian Borntraeger mach->fac_mask[2]); 1301a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host faclist: 0x%16.16llx.%16.16llx.%16.16llx", 1302a8c39dd7SChristian Borntraeger mach->fac_list[0], 1303a8c39dd7SChristian Borntraeger mach->fac_list[1], 1304a8c39dd7SChristian Borntraeger mach->fac_list[2]); 1305658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, mach, sizeof(*mach))) 1306658b6edaSMichael Mueller ret = -EFAULT; 1307658b6edaSMichael Mueller kfree(mach); 1308658b6edaSMichael Mueller out: 1309658b6edaSMichael Mueller return ret; 1310658b6edaSMichael Mueller } 1311658b6edaSMichael Mueller 131215c9705fSDavid Hildenbrand static int kvm_s390_get_processor_feat(struct kvm *kvm, 131315c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 131415c9705fSDavid Hildenbrand { 131515c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 131615c9705fSDavid Hildenbrand 131715c9705fSDavid Hildenbrand bitmap_copy((unsigned long *) data.feat, kvm->arch.cpu_feat, 131815c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 131915c9705fSDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &data, sizeof(data))) 132015c9705fSDavid Hildenbrand return -EFAULT; 13212f8311c9SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx", 13222f8311c9SChristian Borntraeger data.feat[0], 13232f8311c9SChristian Borntraeger data.feat[1], 13242f8311c9SChristian Borntraeger data.feat[2]); 132515c9705fSDavid Hildenbrand return 0; 132615c9705fSDavid Hildenbrand } 132715c9705fSDavid Hildenbrand 132815c9705fSDavid Hildenbrand static int kvm_s390_get_machine_feat(struct kvm *kvm, 132915c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 133015c9705fSDavid Hildenbrand { 133115c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 133215c9705fSDavid Hildenbrand 133315c9705fSDavid Hildenbrand bitmap_copy((unsigned long *) data.feat, 133415c9705fSDavid Hildenbrand kvm_s390_available_cpu_feat, 133515c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 133615c9705fSDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &data, sizeof(data))) 133715c9705fSDavid Hildenbrand return -EFAULT; 13382f8311c9SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx", 13392f8311c9SChristian Borntraeger data.feat[0], 13402f8311c9SChristian Borntraeger data.feat[1], 13412f8311c9SChristian Borntraeger data.feat[2]); 134215c9705fSDavid Hildenbrand return 0; 134315c9705fSDavid Hildenbrand } 134415c9705fSDavid Hildenbrand 13450a763c78SDavid Hildenbrand static int kvm_s390_get_processor_subfunc(struct kvm *kvm, 13460a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 13470a763c78SDavid Hildenbrand { 13480a763c78SDavid Hildenbrand /* 13490a763c78SDavid Hildenbrand * Once we can actually configure subfunctions (kernel + hw support), 13500a763c78SDavid Hildenbrand * we have to check if they were already set by user space, if so copy 13510a763c78SDavid Hildenbrand * them from kvm->arch. 13520a763c78SDavid Hildenbrand */ 13530a763c78SDavid Hildenbrand return -ENXIO; 13540a763c78SDavid Hildenbrand } 13550a763c78SDavid Hildenbrand 13560a763c78SDavid Hildenbrand static int kvm_s390_get_machine_subfunc(struct kvm *kvm, 13570a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 13580a763c78SDavid Hildenbrand { 13590a763c78SDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &kvm_s390_available_subfunc, 13600a763c78SDavid Hildenbrand sizeof(struct kvm_s390_vm_cpu_subfunc))) 13610a763c78SDavid Hildenbrand return -EFAULT; 13620a763c78SDavid Hildenbrand return 0; 13630a763c78SDavid Hildenbrand } 1364658b6edaSMichael Mueller static int kvm_s390_get_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 1365658b6edaSMichael Mueller { 1366658b6edaSMichael Mueller int ret = -ENXIO; 1367658b6edaSMichael Mueller 1368658b6edaSMichael Mueller switch (attr->attr) { 1369658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 1370658b6edaSMichael Mueller ret = kvm_s390_get_processor(kvm, attr); 1371658b6edaSMichael Mueller break; 1372658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 1373658b6edaSMichael Mueller ret = kvm_s390_get_machine(kvm, attr); 1374658b6edaSMichael Mueller break; 137515c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 137615c9705fSDavid Hildenbrand ret = kvm_s390_get_processor_feat(kvm, attr); 137715c9705fSDavid Hildenbrand break; 137815c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_FEAT: 137915c9705fSDavid Hildenbrand ret = kvm_s390_get_machine_feat(kvm, attr); 138015c9705fSDavid Hildenbrand break; 13810a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 13820a763c78SDavid Hildenbrand ret = kvm_s390_get_processor_subfunc(kvm, attr); 13830a763c78SDavid Hildenbrand break; 13840a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_SUBFUNC: 13850a763c78SDavid Hildenbrand ret = kvm_s390_get_machine_subfunc(kvm, attr); 13860a763c78SDavid Hildenbrand break; 1387658b6edaSMichael Mueller } 1388658b6edaSMichael Mueller return ret; 1389658b6edaSMichael Mueller } 1390658b6edaSMichael Mueller 1391f2061656SDominik Dingel static int kvm_s390_vm_set_attr(struct kvm *kvm, struct kvm_device_attr *attr) 1392f2061656SDominik Dingel { 1393f2061656SDominik Dingel int ret; 1394f2061656SDominik Dingel 1395f2061656SDominik Dingel switch (attr->group) { 13964f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 13978c0a7ce6SDominik Dingel ret = kvm_s390_set_mem_control(kvm, attr); 13984f718eabSDominik Dingel break; 139972f25020SJason J. Herne case KVM_S390_VM_TOD: 140072f25020SJason J. Herne ret = kvm_s390_set_tod(kvm, attr); 140172f25020SJason J. Herne break; 1402658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 1403658b6edaSMichael Mueller ret = kvm_s390_set_cpu_model(kvm, attr); 1404658b6edaSMichael Mueller break; 1405a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 1406a374e892STony Krowiak ret = kvm_s390_vm_set_crypto(kvm, attr); 1407a374e892STony Krowiak break; 1408190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION: 1409190df4a2SClaudio Imbrenda ret = kvm_s390_vm_set_migration(kvm, attr); 1410190df4a2SClaudio Imbrenda break; 1411f2061656SDominik Dingel default: 1412f2061656SDominik Dingel ret = -ENXIO; 1413f2061656SDominik Dingel break; 1414f2061656SDominik Dingel } 1415f2061656SDominik Dingel 1416f2061656SDominik Dingel return ret; 1417f2061656SDominik Dingel } 1418f2061656SDominik Dingel 1419f2061656SDominik Dingel static int kvm_s390_vm_get_attr(struct kvm *kvm, struct kvm_device_attr *attr) 1420f2061656SDominik Dingel { 14218c0a7ce6SDominik Dingel int ret; 14228c0a7ce6SDominik Dingel 14238c0a7ce6SDominik Dingel switch (attr->group) { 14248c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_CTRL: 14258c0a7ce6SDominik Dingel ret = kvm_s390_get_mem_control(kvm, attr); 14268c0a7ce6SDominik Dingel break; 142772f25020SJason J. Herne case KVM_S390_VM_TOD: 142872f25020SJason J. Herne ret = kvm_s390_get_tod(kvm, attr); 142972f25020SJason J. Herne break; 1430658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 1431658b6edaSMichael Mueller ret = kvm_s390_get_cpu_model(kvm, attr); 1432658b6edaSMichael Mueller break; 1433190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION: 1434190df4a2SClaudio Imbrenda ret = kvm_s390_vm_get_migration(kvm, attr); 1435190df4a2SClaudio Imbrenda break; 14368c0a7ce6SDominik Dingel default: 14378c0a7ce6SDominik Dingel ret = -ENXIO; 14388c0a7ce6SDominik Dingel break; 14398c0a7ce6SDominik Dingel } 14408c0a7ce6SDominik Dingel 14418c0a7ce6SDominik Dingel return ret; 1442f2061656SDominik Dingel } 1443f2061656SDominik Dingel 1444f2061656SDominik Dingel static int kvm_s390_vm_has_attr(struct kvm *kvm, struct kvm_device_attr *attr) 1445f2061656SDominik Dingel { 1446f2061656SDominik Dingel int ret; 1447f2061656SDominik Dingel 1448f2061656SDominik Dingel switch (attr->group) { 14494f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 14504f718eabSDominik Dingel switch (attr->attr) { 14514f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 14524f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 1453f9cbd9b0SDavid Hildenbrand ret = sclp.has_cmma ? 0 : -ENXIO; 1454f9cbd9b0SDavid Hildenbrand break; 14558c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 14564f718eabSDominik Dingel ret = 0; 14574f718eabSDominik Dingel break; 14584f718eabSDominik Dingel default: 14594f718eabSDominik Dingel ret = -ENXIO; 14604f718eabSDominik Dingel break; 14614f718eabSDominik Dingel } 14624f718eabSDominik Dingel break; 146372f25020SJason J. Herne case KVM_S390_VM_TOD: 146472f25020SJason J. Herne switch (attr->attr) { 146572f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 146672f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 146772f25020SJason J. Herne ret = 0; 146872f25020SJason J. Herne break; 146972f25020SJason J. Herne default: 147072f25020SJason J. Herne ret = -ENXIO; 147172f25020SJason J. Herne break; 147272f25020SJason J. Herne } 147372f25020SJason J. Herne break; 1474658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 1475658b6edaSMichael Mueller switch (attr->attr) { 1476658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 1477658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 147815c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 147915c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_FEAT: 14800a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_SUBFUNC: 1481658b6edaSMichael Mueller ret = 0; 1482658b6edaSMichael Mueller break; 14830a763c78SDavid Hildenbrand /* configuring subfunctions is not supported yet */ 14840a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 1485658b6edaSMichael Mueller default: 1486658b6edaSMichael Mueller ret = -ENXIO; 1487658b6edaSMichael Mueller break; 1488658b6edaSMichael Mueller } 1489658b6edaSMichael Mueller break; 1490a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 1491a374e892STony Krowiak switch (attr->attr) { 1492a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 1493a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 1494a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 1495a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 1496a374e892STony Krowiak ret = 0; 1497a374e892STony Krowiak break; 1498a374e892STony Krowiak default: 1499a374e892STony Krowiak ret = -ENXIO; 1500a374e892STony Krowiak break; 1501a374e892STony Krowiak } 1502a374e892STony Krowiak break; 1503190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION: 1504190df4a2SClaudio Imbrenda ret = 0; 1505190df4a2SClaudio Imbrenda break; 1506f2061656SDominik Dingel default: 1507f2061656SDominik Dingel ret = -ENXIO; 1508f2061656SDominik Dingel break; 1509f2061656SDominik Dingel } 1510f2061656SDominik Dingel 1511f2061656SDominik Dingel return ret; 1512f2061656SDominik Dingel } 1513f2061656SDominik Dingel 151430ee2a98SJason J. Herne static long kvm_s390_get_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 151530ee2a98SJason J. Herne { 151630ee2a98SJason J. Herne uint8_t *keys; 151730ee2a98SJason J. Herne uint64_t hva; 15184f899147SChristian Borntraeger int srcu_idx, i, r = 0; 151930ee2a98SJason J. Herne 152030ee2a98SJason J. Herne if (args->flags != 0) 152130ee2a98SJason J. Herne return -EINVAL; 152230ee2a98SJason J. Herne 152330ee2a98SJason J. Herne /* Is this guest using storage keys? */ 152455531b74SJanosch Frank if (!mm_uses_skeys(current->mm)) 152530ee2a98SJason J. Herne return KVM_S390_GET_SKEYS_NONE; 152630ee2a98SJason J. Herne 152730ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 152830ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 152930ee2a98SJason J. Herne return -EINVAL; 153030ee2a98SJason J. Herne 1531752ade68SMichal Hocko keys = kvmalloc_array(args->count, sizeof(uint8_t), GFP_KERNEL); 153230ee2a98SJason J. Herne if (!keys) 153330ee2a98SJason J. Herne return -ENOMEM; 153430ee2a98SJason J. Herne 1535d3ed1ceeSMartin Schwidefsky down_read(¤t->mm->mmap_sem); 15364f899147SChristian Borntraeger srcu_idx = srcu_read_lock(&kvm->srcu); 153730ee2a98SJason J. Herne for (i = 0; i < args->count; i++) { 153830ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 153930ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 154030ee2a98SJason J. Herne r = -EFAULT; 1541d3ed1ceeSMartin Schwidefsky break; 154230ee2a98SJason J. Herne } 154330ee2a98SJason J. Herne 1544154c8c19SDavid Hildenbrand r = get_guest_storage_key(current->mm, hva, &keys[i]); 1545154c8c19SDavid Hildenbrand if (r) 1546d3ed1ceeSMartin Schwidefsky break; 154730ee2a98SJason J. Herne } 15484f899147SChristian Borntraeger srcu_read_unlock(&kvm->srcu, srcu_idx); 1549d3ed1ceeSMartin Schwidefsky up_read(¤t->mm->mmap_sem); 155030ee2a98SJason J. Herne 1551d3ed1ceeSMartin Schwidefsky if (!r) { 155230ee2a98SJason J. Herne r = copy_to_user((uint8_t __user *)args->skeydata_addr, keys, 155330ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 155430ee2a98SJason J. Herne if (r) 155530ee2a98SJason J. Herne r = -EFAULT; 1556d3ed1ceeSMartin Schwidefsky } 1557d3ed1ceeSMartin Schwidefsky 155830ee2a98SJason J. Herne kvfree(keys); 155930ee2a98SJason J. Herne return r; 156030ee2a98SJason J. Herne } 156130ee2a98SJason J. Herne 156230ee2a98SJason J. Herne static long kvm_s390_set_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 156330ee2a98SJason J. Herne { 156430ee2a98SJason J. Herne uint8_t *keys; 156530ee2a98SJason J. Herne uint64_t hva; 15664f899147SChristian Borntraeger int srcu_idx, i, r = 0; 1567bd096f64SJanosch Frank bool unlocked; 156830ee2a98SJason J. Herne 156930ee2a98SJason J. Herne if (args->flags != 0) 157030ee2a98SJason J. Herne return -EINVAL; 157130ee2a98SJason J. Herne 157230ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 157330ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 157430ee2a98SJason J. Herne return -EINVAL; 157530ee2a98SJason J. Herne 1576752ade68SMichal Hocko keys = kvmalloc_array(args->count, sizeof(uint8_t), GFP_KERNEL); 157730ee2a98SJason J. Herne if (!keys) 157830ee2a98SJason J. Herne return -ENOMEM; 157930ee2a98SJason J. Herne 158030ee2a98SJason J. Herne r = copy_from_user(keys, (uint8_t __user *)args->skeydata_addr, 158130ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 158230ee2a98SJason J. Herne if (r) { 158330ee2a98SJason J. Herne r = -EFAULT; 158430ee2a98SJason J. Herne goto out; 158530ee2a98SJason J. Herne } 158630ee2a98SJason J. Herne 158730ee2a98SJason J. Herne /* Enable storage key handling for the guest */ 158814d4a425SDominik Dingel r = s390_enable_skey(); 158914d4a425SDominik Dingel if (r) 159014d4a425SDominik Dingel goto out; 159130ee2a98SJason J. Herne 1592bd096f64SJanosch Frank i = 0; 1593d3ed1ceeSMartin Schwidefsky down_read(¤t->mm->mmap_sem); 15944f899147SChristian Borntraeger srcu_idx = srcu_read_lock(&kvm->srcu); 1595bd096f64SJanosch Frank while (i < args->count) { 1596bd096f64SJanosch Frank unlocked = false; 159730ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 159830ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 159930ee2a98SJason J. Herne r = -EFAULT; 1600d3ed1ceeSMartin Schwidefsky break; 160130ee2a98SJason J. Herne } 160230ee2a98SJason J. Herne 160330ee2a98SJason J. Herne /* Lowest order bit is reserved */ 160430ee2a98SJason J. Herne if (keys[i] & 0x01) { 160530ee2a98SJason J. Herne r = -EINVAL; 1606d3ed1ceeSMartin Schwidefsky break; 160730ee2a98SJason J. Herne } 160830ee2a98SJason J. Herne 1609fe69eabfSDavid Hildenbrand r = set_guest_storage_key(current->mm, hva, keys[i], 0); 1610bd096f64SJanosch Frank if (r) { 1611bd096f64SJanosch Frank r = fixup_user_fault(current, current->mm, hva, 1612bd096f64SJanosch Frank FAULT_FLAG_WRITE, &unlocked); 161330ee2a98SJason J. Herne if (r) 1614d3ed1ceeSMartin Schwidefsky break; 161530ee2a98SJason J. Herne } 1616bd096f64SJanosch Frank if (!r) 1617bd096f64SJanosch Frank i++; 1618bd096f64SJanosch Frank } 16194f899147SChristian Borntraeger srcu_read_unlock(&kvm->srcu, srcu_idx); 1620d3ed1ceeSMartin Schwidefsky up_read(¤t->mm->mmap_sem); 162130ee2a98SJason J. Herne out: 162230ee2a98SJason J. Herne kvfree(keys); 162330ee2a98SJason J. Herne return r; 162430ee2a98SJason J. Herne } 162530ee2a98SJason J. Herne 16264036e387SClaudio Imbrenda /* 16274036e387SClaudio Imbrenda * Base address and length must be sent at the start of each block, therefore 16284036e387SClaudio Imbrenda * it's cheaper to send some clean data, as long as it's less than the size of 16294036e387SClaudio Imbrenda * two longs. 16304036e387SClaudio Imbrenda */ 16314036e387SClaudio Imbrenda #define KVM_S390_MAX_BIT_DISTANCE (2 * sizeof(void *)) 16324036e387SClaudio Imbrenda /* for consistency */ 16334036e387SClaudio Imbrenda #define KVM_S390_CMMA_SIZE_MAX ((u32)KVM_S390_SKEYS_MAX) 16344036e387SClaudio Imbrenda 16354036e387SClaudio Imbrenda /* 1636afdad616SClaudio Imbrenda * Similar to gfn_to_memslot, but returns the index of a memslot also when the 1637afdad616SClaudio Imbrenda * address falls in a hole. In that case the index of one of the memslots 1638afdad616SClaudio Imbrenda * bordering the hole is returned. 1639afdad616SClaudio Imbrenda */ 1640afdad616SClaudio Imbrenda static int gfn_to_memslot_approx(struct kvm_memslots *slots, gfn_t gfn) 1641afdad616SClaudio Imbrenda { 1642afdad616SClaudio Imbrenda int start = 0, end = slots->used_slots; 1643afdad616SClaudio Imbrenda int slot = atomic_read(&slots->lru_slot); 1644afdad616SClaudio Imbrenda struct kvm_memory_slot *memslots = slots->memslots; 1645afdad616SClaudio Imbrenda 1646afdad616SClaudio Imbrenda if (gfn >= memslots[slot].base_gfn && 1647afdad616SClaudio Imbrenda gfn < memslots[slot].base_gfn + memslots[slot].npages) 1648afdad616SClaudio Imbrenda return slot; 1649afdad616SClaudio Imbrenda 1650afdad616SClaudio Imbrenda while (start < end) { 1651afdad616SClaudio Imbrenda slot = start + (end - start) / 2; 1652afdad616SClaudio Imbrenda 1653afdad616SClaudio Imbrenda if (gfn >= memslots[slot].base_gfn) 1654afdad616SClaudio Imbrenda end = slot; 1655afdad616SClaudio Imbrenda else 1656afdad616SClaudio Imbrenda start = slot + 1; 1657afdad616SClaudio Imbrenda } 1658afdad616SClaudio Imbrenda 1659afdad616SClaudio Imbrenda if (gfn >= memslots[start].base_gfn && 1660afdad616SClaudio Imbrenda gfn < memslots[start].base_gfn + memslots[start].npages) { 1661afdad616SClaudio Imbrenda atomic_set(&slots->lru_slot, start); 1662afdad616SClaudio Imbrenda } 1663afdad616SClaudio Imbrenda 1664afdad616SClaudio Imbrenda return start; 1665afdad616SClaudio Imbrenda } 1666afdad616SClaudio Imbrenda 1667afdad616SClaudio Imbrenda static int kvm_s390_peek_cmma(struct kvm *kvm, struct kvm_s390_cmma_log *args, 1668afdad616SClaudio Imbrenda u8 *res, unsigned long bufsize) 1669afdad616SClaudio Imbrenda { 1670afdad616SClaudio Imbrenda unsigned long pgstev, hva, cur_gfn = args->start_gfn; 1671afdad616SClaudio Imbrenda 1672afdad616SClaudio Imbrenda args->count = 0; 1673afdad616SClaudio Imbrenda while (args->count < bufsize) { 1674afdad616SClaudio Imbrenda hva = gfn_to_hva(kvm, cur_gfn); 1675afdad616SClaudio Imbrenda /* 1676afdad616SClaudio Imbrenda * We return an error if the first value was invalid, but we 1677afdad616SClaudio Imbrenda * return successfully if at least one value was copied. 1678afdad616SClaudio Imbrenda */ 1679afdad616SClaudio Imbrenda if (kvm_is_error_hva(hva)) 1680afdad616SClaudio Imbrenda return args->count ? 0 : -EFAULT; 1681afdad616SClaudio Imbrenda if (get_pgste(kvm->mm, hva, &pgstev) < 0) 1682afdad616SClaudio Imbrenda pgstev = 0; 1683afdad616SClaudio Imbrenda res[args->count++] = (pgstev >> 24) & 0x43; 1684afdad616SClaudio Imbrenda cur_gfn++; 1685afdad616SClaudio Imbrenda } 1686afdad616SClaudio Imbrenda 1687afdad616SClaudio Imbrenda return 0; 1688afdad616SClaudio Imbrenda } 1689afdad616SClaudio Imbrenda 1690afdad616SClaudio Imbrenda static unsigned long kvm_s390_next_dirty_cmma(struct kvm_memslots *slots, 1691afdad616SClaudio Imbrenda unsigned long cur_gfn) 1692afdad616SClaudio Imbrenda { 1693afdad616SClaudio Imbrenda int slotidx = gfn_to_memslot_approx(slots, cur_gfn); 1694afdad616SClaudio Imbrenda struct kvm_memory_slot *ms = slots->memslots + slotidx; 1695afdad616SClaudio Imbrenda unsigned long ofs = cur_gfn - ms->base_gfn; 1696afdad616SClaudio Imbrenda 1697afdad616SClaudio Imbrenda if (ms->base_gfn + ms->npages <= cur_gfn) { 1698afdad616SClaudio Imbrenda slotidx--; 1699afdad616SClaudio Imbrenda /* If we are above the highest slot, wrap around */ 1700afdad616SClaudio Imbrenda if (slotidx < 0) 1701afdad616SClaudio Imbrenda slotidx = slots->used_slots - 1; 1702afdad616SClaudio Imbrenda 1703afdad616SClaudio Imbrenda ms = slots->memslots + slotidx; 1704afdad616SClaudio Imbrenda ofs = 0; 1705afdad616SClaudio Imbrenda } 1706afdad616SClaudio Imbrenda ofs = find_next_bit(kvm_second_dirty_bitmap(ms), ms->npages, ofs); 1707afdad616SClaudio Imbrenda while ((slotidx > 0) && (ofs >= ms->npages)) { 1708afdad616SClaudio Imbrenda slotidx--; 1709afdad616SClaudio Imbrenda ms = slots->memslots + slotidx; 1710afdad616SClaudio Imbrenda ofs = find_next_bit(kvm_second_dirty_bitmap(ms), ms->npages, 0); 1711afdad616SClaudio Imbrenda } 1712afdad616SClaudio Imbrenda return ms->base_gfn + ofs; 1713afdad616SClaudio Imbrenda } 1714afdad616SClaudio Imbrenda 1715afdad616SClaudio Imbrenda static int kvm_s390_get_cmma(struct kvm *kvm, struct kvm_s390_cmma_log *args, 1716afdad616SClaudio Imbrenda u8 *res, unsigned long bufsize) 1717afdad616SClaudio Imbrenda { 1718afdad616SClaudio Imbrenda unsigned long mem_end, cur_gfn, next_gfn, hva, pgstev; 1719afdad616SClaudio Imbrenda struct kvm_memslots *slots = kvm_memslots(kvm); 1720afdad616SClaudio Imbrenda struct kvm_memory_slot *ms; 1721afdad616SClaudio Imbrenda 1722afdad616SClaudio Imbrenda cur_gfn = kvm_s390_next_dirty_cmma(slots, args->start_gfn); 1723afdad616SClaudio Imbrenda ms = gfn_to_memslot(kvm, cur_gfn); 1724afdad616SClaudio Imbrenda args->count = 0; 1725afdad616SClaudio Imbrenda args->start_gfn = cur_gfn; 1726afdad616SClaudio Imbrenda if (!ms) 1727afdad616SClaudio Imbrenda return 0; 1728afdad616SClaudio Imbrenda next_gfn = kvm_s390_next_dirty_cmma(slots, cur_gfn + 1); 1729afdad616SClaudio Imbrenda mem_end = slots->memslots[0].base_gfn + slots->memslots[0].npages; 1730afdad616SClaudio Imbrenda 1731afdad616SClaudio Imbrenda while (args->count < bufsize) { 1732afdad616SClaudio Imbrenda hva = gfn_to_hva(kvm, cur_gfn); 1733afdad616SClaudio Imbrenda if (kvm_is_error_hva(hva)) 1734afdad616SClaudio Imbrenda return 0; 1735afdad616SClaudio Imbrenda /* Decrement only if we actually flipped the bit to 0 */ 1736afdad616SClaudio Imbrenda if (test_and_clear_bit(cur_gfn - ms->base_gfn, kvm_second_dirty_bitmap(ms))) 1737afdad616SClaudio Imbrenda atomic64_dec(&kvm->arch.cmma_dirty_pages); 1738afdad616SClaudio Imbrenda if (get_pgste(kvm->mm, hva, &pgstev) < 0) 1739afdad616SClaudio Imbrenda pgstev = 0; 1740afdad616SClaudio Imbrenda /* Save the value */ 1741afdad616SClaudio Imbrenda res[args->count++] = (pgstev >> 24) & 0x43; 1742afdad616SClaudio Imbrenda /* If the next bit is too far away, stop. */ 1743afdad616SClaudio Imbrenda if (next_gfn > cur_gfn + KVM_S390_MAX_BIT_DISTANCE) 1744afdad616SClaudio Imbrenda return 0; 1745afdad616SClaudio Imbrenda /* If we reached the previous "next", find the next one */ 1746afdad616SClaudio Imbrenda if (cur_gfn == next_gfn) 1747afdad616SClaudio Imbrenda next_gfn = kvm_s390_next_dirty_cmma(slots, cur_gfn + 1); 1748afdad616SClaudio Imbrenda /* Reached the end of memory or of the buffer, stop */ 1749afdad616SClaudio Imbrenda if ((next_gfn >= mem_end) || 1750afdad616SClaudio Imbrenda (next_gfn - args->start_gfn >= bufsize)) 1751afdad616SClaudio Imbrenda return 0; 1752afdad616SClaudio Imbrenda cur_gfn++; 1753afdad616SClaudio Imbrenda /* Reached the end of the current memslot, take the next one. */ 1754afdad616SClaudio Imbrenda if (cur_gfn - ms->base_gfn >= ms->npages) { 1755afdad616SClaudio Imbrenda ms = gfn_to_memslot(kvm, cur_gfn); 1756afdad616SClaudio Imbrenda if (!ms) 1757afdad616SClaudio Imbrenda return 0; 1758afdad616SClaudio Imbrenda } 1759afdad616SClaudio Imbrenda } 1760afdad616SClaudio Imbrenda return 0; 1761afdad616SClaudio Imbrenda } 1762afdad616SClaudio Imbrenda 1763afdad616SClaudio Imbrenda /* 17644036e387SClaudio Imbrenda * This function searches for the next page with dirty CMMA attributes, and 17654036e387SClaudio Imbrenda * saves the attributes in the buffer up to either the end of the buffer or 17664036e387SClaudio Imbrenda * until a block of at least KVM_S390_MAX_BIT_DISTANCE clean bits is found; 17674036e387SClaudio Imbrenda * no trailing clean bytes are saved. 17684036e387SClaudio Imbrenda * In case no dirty bits were found, or if CMMA was not enabled or used, the 17694036e387SClaudio Imbrenda * output buffer will indicate 0 as length. 17704036e387SClaudio Imbrenda */ 17714036e387SClaudio Imbrenda static int kvm_s390_get_cmma_bits(struct kvm *kvm, 17724036e387SClaudio Imbrenda struct kvm_s390_cmma_log *args) 17734036e387SClaudio Imbrenda { 1774afdad616SClaudio Imbrenda unsigned long bufsize; 1775afdad616SClaudio Imbrenda int srcu_idx, peek, ret; 1776afdad616SClaudio Imbrenda u8 *values; 17774036e387SClaudio Imbrenda 1778afdad616SClaudio Imbrenda if (!kvm->arch.use_cmma) 17794036e387SClaudio Imbrenda return -ENXIO; 17804036e387SClaudio Imbrenda /* Invalid/unsupported flags were specified */ 17814036e387SClaudio Imbrenda if (args->flags & ~KVM_S390_CMMA_PEEK) 17824036e387SClaudio Imbrenda return -EINVAL; 17834036e387SClaudio Imbrenda /* Migration mode query, and we are not doing a migration */ 17844036e387SClaudio Imbrenda peek = !!(args->flags & KVM_S390_CMMA_PEEK); 1785afdad616SClaudio Imbrenda if (!peek && !kvm->arch.migration_mode) 17864036e387SClaudio Imbrenda return -EINVAL; 17874036e387SClaudio Imbrenda /* CMMA is disabled or was not used, or the buffer has length zero */ 17884036e387SClaudio Imbrenda bufsize = min(args->count, KVM_S390_CMMA_SIZE_MAX); 1789c9f0a2b8SJanosch Frank if (!bufsize || !kvm->mm->context.uses_cmm) { 17904036e387SClaudio Imbrenda memset(args, 0, sizeof(*args)); 17914036e387SClaudio Imbrenda return 0; 17924036e387SClaudio Imbrenda } 17934036e387SClaudio Imbrenda /* We are not peeking, and there are no dirty pages */ 1794afdad616SClaudio Imbrenda if (!peek && !atomic64_read(&kvm->arch.cmma_dirty_pages)) { 17954036e387SClaudio Imbrenda memset(args, 0, sizeof(*args)); 17964036e387SClaudio Imbrenda return 0; 17974036e387SClaudio Imbrenda } 17984036e387SClaudio Imbrenda 1799afdad616SClaudio Imbrenda values = vmalloc(bufsize); 1800afdad616SClaudio Imbrenda if (!values) 18014036e387SClaudio Imbrenda return -ENOMEM; 18024036e387SClaudio Imbrenda 18034036e387SClaudio Imbrenda down_read(&kvm->mm->mmap_sem); 18044036e387SClaudio Imbrenda srcu_idx = srcu_read_lock(&kvm->srcu); 1805afdad616SClaudio Imbrenda if (peek) 1806afdad616SClaudio Imbrenda ret = kvm_s390_peek_cmma(kvm, args, values, bufsize); 1807afdad616SClaudio Imbrenda else 1808afdad616SClaudio Imbrenda ret = kvm_s390_get_cmma(kvm, args, values, bufsize); 18094036e387SClaudio Imbrenda srcu_read_unlock(&kvm->srcu, srcu_idx); 18104036e387SClaudio Imbrenda up_read(&kvm->mm->mmap_sem); 18114036e387SClaudio Imbrenda 1812afdad616SClaudio Imbrenda if (kvm->arch.migration_mode) 1813afdad616SClaudio Imbrenda args->remaining = atomic64_read(&kvm->arch.cmma_dirty_pages); 1814afdad616SClaudio Imbrenda else 1815afdad616SClaudio Imbrenda args->remaining = 0; 18164036e387SClaudio Imbrenda 1817afdad616SClaudio Imbrenda if (copy_to_user((void __user *)args->values, values, args->count)) 1818afdad616SClaudio Imbrenda ret = -EFAULT; 1819afdad616SClaudio Imbrenda 1820afdad616SClaudio Imbrenda vfree(values); 1821afdad616SClaudio Imbrenda return ret; 18224036e387SClaudio Imbrenda } 18234036e387SClaudio Imbrenda 18244036e387SClaudio Imbrenda /* 18254036e387SClaudio Imbrenda * This function sets the CMMA attributes for the given pages. If the input 18264036e387SClaudio Imbrenda * buffer has zero length, no action is taken, otherwise the attributes are 1827c9f0a2b8SJanosch Frank * set and the mm->context.uses_cmm flag is set. 18284036e387SClaudio Imbrenda */ 18294036e387SClaudio Imbrenda static int kvm_s390_set_cmma_bits(struct kvm *kvm, 18304036e387SClaudio Imbrenda const struct kvm_s390_cmma_log *args) 18314036e387SClaudio Imbrenda { 18324036e387SClaudio Imbrenda unsigned long hva, mask, pgstev, i; 18334036e387SClaudio Imbrenda uint8_t *bits; 18344036e387SClaudio Imbrenda int srcu_idx, r = 0; 18354036e387SClaudio Imbrenda 18364036e387SClaudio Imbrenda mask = args->mask; 18374036e387SClaudio Imbrenda 18384036e387SClaudio Imbrenda if (!kvm->arch.use_cmma) 18394036e387SClaudio Imbrenda return -ENXIO; 18404036e387SClaudio Imbrenda /* invalid/unsupported flags */ 18414036e387SClaudio Imbrenda if (args->flags != 0) 18424036e387SClaudio Imbrenda return -EINVAL; 18434036e387SClaudio Imbrenda /* Enforce sane limit on memory allocation */ 18444036e387SClaudio Imbrenda if (args->count > KVM_S390_CMMA_SIZE_MAX) 18454036e387SClaudio Imbrenda return -EINVAL; 18464036e387SClaudio Imbrenda /* Nothing to do */ 18474036e387SClaudio Imbrenda if (args->count == 0) 18484036e387SClaudio Imbrenda return 0; 18494036e387SClaudio Imbrenda 185042bc47b3SKees Cook bits = vmalloc(array_size(sizeof(*bits), args->count)); 18514036e387SClaudio Imbrenda if (!bits) 18524036e387SClaudio Imbrenda return -ENOMEM; 18534036e387SClaudio Imbrenda 18544036e387SClaudio Imbrenda r = copy_from_user(bits, (void __user *)args->values, args->count); 18554036e387SClaudio Imbrenda if (r) { 18564036e387SClaudio Imbrenda r = -EFAULT; 18574036e387SClaudio Imbrenda goto out; 18584036e387SClaudio Imbrenda } 18594036e387SClaudio Imbrenda 18604036e387SClaudio Imbrenda down_read(&kvm->mm->mmap_sem); 18614036e387SClaudio Imbrenda srcu_idx = srcu_read_lock(&kvm->srcu); 18624036e387SClaudio Imbrenda for (i = 0; i < args->count; i++) { 18634036e387SClaudio Imbrenda hva = gfn_to_hva(kvm, args->start_gfn + i); 18644036e387SClaudio Imbrenda if (kvm_is_error_hva(hva)) { 18654036e387SClaudio Imbrenda r = -EFAULT; 18664036e387SClaudio Imbrenda break; 18674036e387SClaudio Imbrenda } 18684036e387SClaudio Imbrenda 18694036e387SClaudio Imbrenda pgstev = bits[i]; 18704036e387SClaudio Imbrenda pgstev = pgstev << 24; 18711bab1c02SClaudio Imbrenda mask &= _PGSTE_GPS_USAGE_MASK | _PGSTE_GPS_NODAT; 18724036e387SClaudio Imbrenda set_pgste_bits(kvm->mm, hva, mask, pgstev); 18734036e387SClaudio Imbrenda } 18744036e387SClaudio Imbrenda srcu_read_unlock(&kvm->srcu, srcu_idx); 18754036e387SClaudio Imbrenda up_read(&kvm->mm->mmap_sem); 18764036e387SClaudio Imbrenda 1877c9f0a2b8SJanosch Frank if (!kvm->mm->context.uses_cmm) { 18784036e387SClaudio Imbrenda down_write(&kvm->mm->mmap_sem); 1879c9f0a2b8SJanosch Frank kvm->mm->context.uses_cmm = 1; 18804036e387SClaudio Imbrenda up_write(&kvm->mm->mmap_sem); 18814036e387SClaudio Imbrenda } 18824036e387SClaudio Imbrenda out: 18834036e387SClaudio Imbrenda vfree(bits); 18844036e387SClaudio Imbrenda return r; 18854036e387SClaudio Imbrenda } 18864036e387SClaudio Imbrenda 1887b0c632dbSHeiko Carstens long kvm_arch_vm_ioctl(struct file *filp, 1888b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 1889b0c632dbSHeiko Carstens { 1890b0c632dbSHeiko Carstens struct kvm *kvm = filp->private_data; 1891b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 1892f2061656SDominik Dingel struct kvm_device_attr attr; 1893b0c632dbSHeiko Carstens int r; 1894b0c632dbSHeiko Carstens 1895b0c632dbSHeiko Carstens switch (ioctl) { 1896ba5c1e9bSCarsten Otte case KVM_S390_INTERRUPT: { 1897ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 1898ba5c1e9bSCarsten Otte 1899ba5c1e9bSCarsten Otte r = -EFAULT; 1900ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 1901ba5c1e9bSCarsten Otte break; 1902ba5c1e9bSCarsten Otte r = kvm_s390_inject_vm(kvm, &s390int); 1903ba5c1e9bSCarsten Otte break; 1904ba5c1e9bSCarsten Otte } 1905d938dc55SCornelia Huck case KVM_ENABLE_CAP: { 1906d938dc55SCornelia Huck struct kvm_enable_cap cap; 1907d938dc55SCornelia Huck r = -EFAULT; 1908d938dc55SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 1909d938dc55SCornelia Huck break; 1910d938dc55SCornelia Huck r = kvm_vm_ioctl_enable_cap(kvm, &cap); 1911d938dc55SCornelia Huck break; 1912d938dc55SCornelia Huck } 191384223598SCornelia Huck case KVM_CREATE_IRQCHIP: { 191484223598SCornelia Huck struct kvm_irq_routing_entry routing; 191584223598SCornelia Huck 191684223598SCornelia Huck r = -EINVAL; 191784223598SCornelia Huck if (kvm->arch.use_irqchip) { 191884223598SCornelia Huck /* Set up dummy routing. */ 191984223598SCornelia Huck memset(&routing, 0, sizeof(routing)); 1920152b2839SNicholas Krause r = kvm_set_irq_routing(kvm, &routing, 0, 0); 192184223598SCornelia Huck } 192284223598SCornelia Huck break; 192384223598SCornelia Huck } 1924f2061656SDominik Dingel case KVM_SET_DEVICE_ATTR: { 1925f2061656SDominik Dingel r = -EFAULT; 1926f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 1927f2061656SDominik Dingel break; 1928f2061656SDominik Dingel r = kvm_s390_vm_set_attr(kvm, &attr); 1929f2061656SDominik Dingel break; 1930f2061656SDominik Dingel } 1931f2061656SDominik Dingel case KVM_GET_DEVICE_ATTR: { 1932f2061656SDominik Dingel r = -EFAULT; 1933f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 1934f2061656SDominik Dingel break; 1935f2061656SDominik Dingel r = kvm_s390_vm_get_attr(kvm, &attr); 1936f2061656SDominik Dingel break; 1937f2061656SDominik Dingel } 1938f2061656SDominik Dingel case KVM_HAS_DEVICE_ATTR: { 1939f2061656SDominik Dingel r = -EFAULT; 1940f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 1941f2061656SDominik Dingel break; 1942f2061656SDominik Dingel r = kvm_s390_vm_has_attr(kvm, &attr); 1943f2061656SDominik Dingel break; 1944f2061656SDominik Dingel } 194530ee2a98SJason J. Herne case KVM_S390_GET_SKEYS: { 194630ee2a98SJason J. Herne struct kvm_s390_skeys args; 194730ee2a98SJason J. Herne 194830ee2a98SJason J. Herne r = -EFAULT; 194930ee2a98SJason J. Herne if (copy_from_user(&args, argp, 195030ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 195130ee2a98SJason J. Herne break; 195230ee2a98SJason J. Herne r = kvm_s390_get_skeys(kvm, &args); 195330ee2a98SJason J. Herne break; 195430ee2a98SJason J. Herne } 195530ee2a98SJason J. Herne case KVM_S390_SET_SKEYS: { 195630ee2a98SJason J. Herne struct kvm_s390_skeys args; 195730ee2a98SJason J. Herne 195830ee2a98SJason J. Herne r = -EFAULT; 195930ee2a98SJason J. Herne if (copy_from_user(&args, argp, 196030ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 196130ee2a98SJason J. Herne break; 196230ee2a98SJason J. Herne r = kvm_s390_set_skeys(kvm, &args); 196330ee2a98SJason J. Herne break; 196430ee2a98SJason J. Herne } 19654036e387SClaudio Imbrenda case KVM_S390_GET_CMMA_BITS: { 19664036e387SClaudio Imbrenda struct kvm_s390_cmma_log args; 19674036e387SClaudio Imbrenda 19684036e387SClaudio Imbrenda r = -EFAULT; 19694036e387SClaudio Imbrenda if (copy_from_user(&args, argp, sizeof(args))) 19704036e387SClaudio Imbrenda break; 19711de1ea7eSChristian Borntraeger mutex_lock(&kvm->slots_lock); 19724036e387SClaudio Imbrenda r = kvm_s390_get_cmma_bits(kvm, &args); 19731de1ea7eSChristian Borntraeger mutex_unlock(&kvm->slots_lock); 19744036e387SClaudio Imbrenda if (!r) { 19754036e387SClaudio Imbrenda r = copy_to_user(argp, &args, sizeof(args)); 19764036e387SClaudio Imbrenda if (r) 19774036e387SClaudio Imbrenda r = -EFAULT; 19784036e387SClaudio Imbrenda } 19794036e387SClaudio Imbrenda break; 19804036e387SClaudio Imbrenda } 19814036e387SClaudio Imbrenda case KVM_S390_SET_CMMA_BITS: { 19824036e387SClaudio Imbrenda struct kvm_s390_cmma_log args; 19834036e387SClaudio Imbrenda 19844036e387SClaudio Imbrenda r = -EFAULT; 19854036e387SClaudio Imbrenda if (copy_from_user(&args, argp, sizeof(args))) 19864036e387SClaudio Imbrenda break; 19871de1ea7eSChristian Borntraeger mutex_lock(&kvm->slots_lock); 19884036e387SClaudio Imbrenda r = kvm_s390_set_cmma_bits(kvm, &args); 19891de1ea7eSChristian Borntraeger mutex_unlock(&kvm->slots_lock); 19904036e387SClaudio Imbrenda break; 19914036e387SClaudio Imbrenda } 1992b0c632dbSHeiko Carstens default: 1993367e1319SAvi Kivity r = -ENOTTY; 1994b0c632dbSHeiko Carstens } 1995b0c632dbSHeiko Carstens 1996b0c632dbSHeiko Carstens return r; 1997b0c632dbSHeiko Carstens } 1998b0c632dbSHeiko Carstens 199945c9b47cSTony Krowiak static int kvm_s390_apxa_installed(void) 200045c9b47cSTony Krowiak { 2001e585b24aSTony Krowiak struct ap_config_info info; 200245c9b47cSTony Krowiak 2003e585b24aSTony Krowiak if (ap_instructions_available()) { 2004e585b24aSTony Krowiak if (ap_qci(&info) == 0) 2005e585b24aSTony Krowiak return info.apxa; 200645c9b47cSTony Krowiak } 200745c9b47cSTony Krowiak 200845c9b47cSTony Krowiak return 0; 200945c9b47cSTony Krowiak } 201045c9b47cSTony Krowiak 2011e585b24aSTony Krowiak /* 2012e585b24aSTony Krowiak * The format of the crypto control block (CRYCB) is specified in the 3 low 2013e585b24aSTony Krowiak * order bits of the CRYCB designation (CRYCBD) field as follows: 2014e585b24aSTony Krowiak * Format 0: Neither the message security assist extension 3 (MSAX3) nor the 2015e585b24aSTony Krowiak * AP extended addressing (APXA) facility are installed. 2016e585b24aSTony Krowiak * Format 1: The APXA facility is not installed but the MSAX3 facility is. 2017e585b24aSTony Krowiak * Format 2: Both the APXA and MSAX3 facilities are installed 2018e585b24aSTony Krowiak */ 201945c9b47cSTony Krowiak static void kvm_s390_set_crycb_format(struct kvm *kvm) 202045c9b47cSTony Krowiak { 202145c9b47cSTony Krowiak kvm->arch.crypto.crycbd = (__u32)(unsigned long) kvm->arch.crypto.crycb; 202245c9b47cSTony Krowiak 2023e585b24aSTony Krowiak /* Clear the CRYCB format bits - i.e., set format 0 by default */ 2024e585b24aSTony Krowiak kvm->arch.crypto.crycbd &= ~(CRYCB_FORMAT_MASK); 2025e585b24aSTony Krowiak 2026e585b24aSTony Krowiak /* Check whether MSAX3 is installed */ 2027e585b24aSTony Krowiak if (!test_kvm_facility(kvm, 76)) 2028e585b24aSTony Krowiak return; 2029e585b24aSTony Krowiak 203045c9b47cSTony Krowiak if (kvm_s390_apxa_installed()) 203145c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT2; 203245c9b47cSTony Krowiak else 203345c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT1; 203445c9b47cSTony Krowiak } 203545c9b47cSTony Krowiak 203642104598STony Krowiak void kvm_arch_crypto_clear_masks(struct kvm *kvm) 203742104598STony Krowiak { 203842104598STony Krowiak mutex_lock(&kvm->lock); 203942104598STony Krowiak kvm_s390_vcpu_block_all(kvm); 204042104598STony Krowiak 204142104598STony Krowiak memset(&kvm->arch.crypto.crycb->apcb0, 0, 204242104598STony Krowiak sizeof(kvm->arch.crypto.crycb->apcb0)); 204342104598STony Krowiak memset(&kvm->arch.crypto.crycb->apcb1, 0, 204442104598STony Krowiak sizeof(kvm->arch.crypto.crycb->apcb1)); 204542104598STony Krowiak 2046*6cc571b1SPierre Morel /* recreate the shadow crycb for each vcpu */ 2047*6cc571b1SPierre Morel kvm_s390_sync_request_broadcast(kvm, KVM_REQ_VSIE_RESTART); 204842104598STony Krowiak kvm_s390_vcpu_unblock_all(kvm); 204942104598STony Krowiak mutex_unlock(&kvm->lock); 205042104598STony Krowiak } 205142104598STony Krowiak EXPORT_SYMBOL_GPL(kvm_arch_crypto_clear_masks); 205242104598STony Krowiak 20539bb0ec09SDavid Hildenbrand static u64 kvm_s390_get_initial_cpuid(void) 20549d8d5786SMichael Mueller { 20559bb0ec09SDavid Hildenbrand struct cpuid cpuid; 20569bb0ec09SDavid Hildenbrand 20579bb0ec09SDavid Hildenbrand get_cpu_id(&cpuid); 20589bb0ec09SDavid Hildenbrand cpuid.version = 0xff; 20599bb0ec09SDavid Hildenbrand return *((u64 *) &cpuid); 20609d8d5786SMichael Mueller } 20619d8d5786SMichael Mueller 2062c54f0d6aSDavid Hildenbrand static void kvm_s390_crypto_init(struct kvm *kvm) 20635102ee87STony Krowiak { 2064c54f0d6aSDavid Hildenbrand kvm->arch.crypto.crycb = &kvm->arch.sie_page2->crycb; 206545c9b47cSTony Krowiak kvm_s390_set_crycb_format(kvm); 20665102ee87STony Krowiak 2067e585b24aSTony Krowiak if (!test_kvm_facility(kvm, 76)) 2068e585b24aSTony Krowiak return; 2069e585b24aSTony Krowiak 2070ed6f76b4STony Krowiak /* Enable AES/DEA protected key functions by default */ 2071ed6f76b4STony Krowiak kvm->arch.crypto.aes_kw = 1; 2072ed6f76b4STony Krowiak kvm->arch.crypto.dea_kw = 1; 2073ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 2074ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 2075ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 2076ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 20775102ee87STony Krowiak } 20785102ee87STony Krowiak 20797d43bafcSEugene (jno) Dvurechenski static void sca_dispose(struct kvm *kvm) 20807d43bafcSEugene (jno) Dvurechenski { 20817d43bafcSEugene (jno) Dvurechenski if (kvm->arch.use_esca) 20825e044315SEugene (jno) Dvurechenski free_pages_exact(kvm->arch.sca, sizeof(struct esca_block)); 20837d43bafcSEugene (jno) Dvurechenski else 20847d43bafcSEugene (jno) Dvurechenski free_page((unsigned long)(kvm->arch.sca)); 20857d43bafcSEugene (jno) Dvurechenski kvm->arch.sca = NULL; 20867d43bafcSEugene (jno) Dvurechenski } 20877d43bafcSEugene (jno) Dvurechenski 2088e08b9637SCarsten Otte int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 2089b0c632dbSHeiko Carstens { 209076a6dd72SDavid Hildenbrand gfp_t alloc_flags = GFP_KERNEL; 20919d8d5786SMichael Mueller int i, rc; 2092b0c632dbSHeiko Carstens char debug_name[16]; 2093f6c137ffSChristian Borntraeger static unsigned long sca_offset; 2094b0c632dbSHeiko Carstens 2095e08b9637SCarsten Otte rc = -EINVAL; 2096e08b9637SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 2097e08b9637SCarsten Otte if (type & ~KVM_VM_S390_UCONTROL) 2098e08b9637SCarsten Otte goto out_err; 2099e08b9637SCarsten Otte if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN))) 2100e08b9637SCarsten Otte goto out_err; 2101e08b9637SCarsten Otte #else 2102e08b9637SCarsten Otte if (type) 2103e08b9637SCarsten Otte goto out_err; 2104e08b9637SCarsten Otte #endif 2105e08b9637SCarsten Otte 2106b0c632dbSHeiko Carstens rc = s390_enable_sie(); 2107b0c632dbSHeiko Carstens if (rc) 2108d89f5effSJan Kiszka goto out_err; 2109b0c632dbSHeiko Carstens 2110b290411aSCarsten Otte rc = -ENOMEM; 2111b290411aSCarsten Otte 211276a6dd72SDavid Hildenbrand if (!sclp.has_64bscao) 211376a6dd72SDavid Hildenbrand alloc_flags |= GFP_DMA; 21145e044315SEugene (jno) Dvurechenski rwlock_init(&kvm->arch.sca_lock); 21159ac96d75SDavid Hildenbrand /* start with basic SCA */ 211676a6dd72SDavid Hildenbrand kvm->arch.sca = (struct bsca_block *) get_zeroed_page(alloc_flags); 2117b0c632dbSHeiko Carstens if (!kvm->arch.sca) 2118d89f5effSJan Kiszka goto out_err; 2119f6c137ffSChristian Borntraeger spin_lock(&kvm_lock); 2120c5c2c393SDavid Hildenbrand sca_offset += 16; 2121bc784cceSEugene (jno) Dvurechenski if (sca_offset + sizeof(struct bsca_block) > PAGE_SIZE) 2122c5c2c393SDavid Hildenbrand sca_offset = 0; 2123bc784cceSEugene (jno) Dvurechenski kvm->arch.sca = (struct bsca_block *) 2124bc784cceSEugene (jno) Dvurechenski ((char *) kvm->arch.sca + sca_offset); 2125f6c137ffSChristian Borntraeger spin_unlock(&kvm_lock); 2126b0c632dbSHeiko Carstens 2127b0c632dbSHeiko Carstens sprintf(debug_name, "kvm-%u", current->pid); 2128b0c632dbSHeiko Carstens 21291cb9cf72SChristian Borntraeger kvm->arch.dbf = debug_register(debug_name, 32, 1, 7 * sizeof(long)); 2130b0c632dbSHeiko Carstens if (!kvm->arch.dbf) 213140f5b735SDominik Dingel goto out_err; 2132b0c632dbSHeiko Carstens 213319114bebSMichael Mueller BUILD_BUG_ON(sizeof(struct sie_page2) != 4096); 2134c54f0d6aSDavid Hildenbrand kvm->arch.sie_page2 = 2135c54f0d6aSDavid Hildenbrand (struct sie_page2 *) get_zeroed_page(GFP_KERNEL | GFP_DMA); 2136c54f0d6aSDavid Hildenbrand if (!kvm->arch.sie_page2) 213740f5b735SDominik Dingel goto out_err; 21389d8d5786SMichael Mueller 2139c54f0d6aSDavid Hildenbrand kvm->arch.model.fac_list = kvm->arch.sie_page2->fac_list; 2140c3b9e3e1SChristian Borntraeger 2141c3b9e3e1SChristian Borntraeger for (i = 0; i < kvm_s390_fac_size(); i++) { 2142c3b9e3e1SChristian Borntraeger kvm->arch.model.fac_mask[i] = S390_lowcore.stfle_fac_list[i] & 2143c3b9e3e1SChristian Borntraeger (kvm_s390_fac_base[i] | 2144c3b9e3e1SChristian Borntraeger kvm_s390_fac_ext[i]); 2145c3b9e3e1SChristian Borntraeger kvm->arch.model.fac_list[i] = S390_lowcore.stfle_fac_list[i] & 2146c3b9e3e1SChristian Borntraeger kvm_s390_fac_base[i]; 2147c3b9e3e1SChristian Borntraeger } 2148981467c9SMichael Mueller 21491935222dSDavid Hildenbrand /* we are always in czam mode - even on pre z14 machines */ 21501935222dSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 138); 21511935222dSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 138); 21521935222dSDavid Hildenbrand /* we emulate STHYI in kvm */ 215395ca2cb5SJanosch Frank set_kvm_facility(kvm->arch.model.fac_mask, 74); 215495ca2cb5SJanosch Frank set_kvm_facility(kvm->arch.model.fac_list, 74); 21551bab1c02SClaudio Imbrenda if (MACHINE_HAS_TLB_GUEST) { 21561bab1c02SClaudio Imbrenda set_kvm_facility(kvm->arch.model.fac_mask, 147); 21571bab1c02SClaudio Imbrenda set_kvm_facility(kvm->arch.model.fac_list, 147); 21581bab1c02SClaudio Imbrenda } 215995ca2cb5SJanosch Frank 21609bb0ec09SDavid Hildenbrand kvm->arch.model.cpuid = kvm_s390_get_initial_cpuid(); 216137c5f6c8SDavid Hildenbrand kvm->arch.model.ibc = sclp.ibc & 0x0fff; 21629d8d5786SMichael Mueller 2163c54f0d6aSDavid Hildenbrand kvm_s390_crypto_init(kvm); 21645102ee87STony Krowiak 216551978393SFei Li mutex_init(&kvm->arch.float_int.ais_lock); 2166ba5c1e9bSCarsten Otte spin_lock_init(&kvm->arch.float_int.lock); 21676d3da241SJens Freimann for (i = 0; i < FIRQ_LIST_COUNT; i++) 21686d3da241SJens Freimann INIT_LIST_HEAD(&kvm->arch.float_int.lists[i]); 21698a242234SHeiko Carstens init_waitqueue_head(&kvm->arch.ipte_wq); 2170a6b7e459SThomas Huth mutex_init(&kvm->arch.ipte_mutex); 2171ba5c1e9bSCarsten Otte 2172b0c632dbSHeiko Carstens debug_register_view(kvm->arch.dbf, &debug_sprintf_view); 217378f26131SChristian Borntraeger VM_EVENT(kvm, 3, "vm created with type %lu", type); 2174b0c632dbSHeiko Carstens 2175e08b9637SCarsten Otte if (type & KVM_VM_S390_UCONTROL) { 2176e08b9637SCarsten Otte kvm->arch.gmap = NULL; 2177a3a92c31SDominik Dingel kvm->arch.mem_limit = KVM_S390_NO_MEM_LIMIT; 2178e08b9637SCarsten Otte } else { 217932e6b236SGuenther Hutzl if (sclp.hamax == U64_MAX) 2180ee71d16dSMartin Schwidefsky kvm->arch.mem_limit = TASK_SIZE_MAX; 218132e6b236SGuenther Hutzl else 2182ee71d16dSMartin Schwidefsky kvm->arch.mem_limit = min_t(unsigned long, TASK_SIZE_MAX, 218332e6b236SGuenther Hutzl sclp.hamax + 1); 21846ea427bbSMartin Schwidefsky kvm->arch.gmap = gmap_create(current->mm, kvm->arch.mem_limit - 1); 2185598841caSCarsten Otte if (!kvm->arch.gmap) 218640f5b735SDominik Dingel goto out_err; 21872c70fe44SChristian Borntraeger kvm->arch.gmap->private = kvm; 218824eb3a82SDominik Dingel kvm->arch.gmap->pfault_enabled = 0; 2189e08b9637SCarsten Otte } 2190fa6b7fe9SCornelia Huck 2191c9f0a2b8SJanosch Frank kvm->arch.use_pfmfi = sclp.has_pfmfi; 219255531b74SJanosch Frank kvm->arch.use_skf = sclp.has_skey; 21938ad35755SDavid Hildenbrand spin_lock_init(&kvm->arch.start_stop_lock); 2194a3508fbeSDavid Hildenbrand kvm_s390_vsie_init(kvm); 2195d7c5cb01SMichael Mueller kvm_s390_gisa_init(kvm); 21968335713aSChristian Borntraeger KVM_EVENT(3, "vm 0x%pK created by pid %u", kvm, current->pid); 21978ad35755SDavid Hildenbrand 2198d89f5effSJan Kiszka return 0; 2199d89f5effSJan Kiszka out_err: 2200c54f0d6aSDavid Hildenbrand free_page((unsigned long)kvm->arch.sie_page2); 220140f5b735SDominik Dingel debug_unregister(kvm->arch.dbf); 22027d43bafcSEugene (jno) Dvurechenski sca_dispose(kvm); 220378f26131SChristian Borntraeger KVM_EVENT(3, "creation of vm failed: %d", rc); 2204d89f5effSJan Kiszka return rc; 2205b0c632dbSHeiko Carstens } 2206b0c632dbSHeiko Carstens 2207235539b4SLuiz Capitulino bool kvm_arch_has_vcpu_debugfs(void) 2208235539b4SLuiz Capitulino { 2209235539b4SLuiz Capitulino return false; 2210235539b4SLuiz Capitulino } 2211235539b4SLuiz Capitulino 2212235539b4SLuiz Capitulino int kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu) 2213235539b4SLuiz Capitulino { 2214235539b4SLuiz Capitulino return 0; 2215235539b4SLuiz Capitulino } 2216235539b4SLuiz Capitulino 2217d329c035SChristian Borntraeger void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 2218d329c035SChristian Borntraeger { 2219d329c035SChristian Borntraeger VCPU_EVENT(vcpu, 3, "%s", "free cpu"); 2220ade38c31SCornelia Huck trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id); 222167335e63SChristian Borntraeger kvm_s390_clear_local_irqs(vcpu); 22223c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 2223bc784cceSEugene (jno) Dvurechenski if (!kvm_is_ucontrol(vcpu->kvm)) 2224a6e2f683SEugene (jno) Dvurechenski sca_del_vcpu(vcpu); 222527e0393fSCarsten Otte 222627e0393fSCarsten Otte if (kvm_is_ucontrol(vcpu->kvm)) 22276ea427bbSMartin Schwidefsky gmap_remove(vcpu->arch.gmap); 222827e0393fSCarsten Otte 2229e6db1d61SDominik Dingel if (vcpu->kvm->arch.use_cmma) 2230b31605c1SDominik Dingel kvm_s390_vcpu_unsetup_cmma(vcpu); 2231d329c035SChristian Borntraeger free_page((unsigned long)(vcpu->arch.sie_block)); 2232b31288faSKonstantin Weitz 22336692cef3SChristian Borntraeger kvm_vcpu_uninit(vcpu); 2234b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 2235d329c035SChristian Borntraeger } 2236d329c035SChristian Borntraeger 2237d329c035SChristian Borntraeger static void kvm_free_vcpus(struct kvm *kvm) 2238d329c035SChristian Borntraeger { 2239d329c035SChristian Borntraeger unsigned int i; 2240988a2caeSGleb Natapov struct kvm_vcpu *vcpu; 2241d329c035SChristian Borntraeger 2242988a2caeSGleb Natapov kvm_for_each_vcpu(i, vcpu, kvm) 2243988a2caeSGleb Natapov kvm_arch_vcpu_destroy(vcpu); 2244988a2caeSGleb Natapov 2245988a2caeSGleb Natapov mutex_lock(&kvm->lock); 2246988a2caeSGleb Natapov for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 2247d329c035SChristian Borntraeger kvm->vcpus[i] = NULL; 2248988a2caeSGleb Natapov 2249988a2caeSGleb Natapov atomic_set(&kvm->online_vcpus, 0); 2250988a2caeSGleb Natapov mutex_unlock(&kvm->lock); 2251d329c035SChristian Borntraeger } 2252d329c035SChristian Borntraeger 2253b0c632dbSHeiko Carstens void kvm_arch_destroy_vm(struct kvm *kvm) 2254b0c632dbSHeiko Carstens { 2255d329c035SChristian Borntraeger kvm_free_vcpus(kvm); 22567d43bafcSEugene (jno) Dvurechenski sca_dispose(kvm); 2257d329c035SChristian Borntraeger debug_unregister(kvm->arch.dbf); 2258d7c5cb01SMichael Mueller kvm_s390_gisa_destroy(kvm); 2259c54f0d6aSDavid Hildenbrand free_page((unsigned long)kvm->arch.sie_page2); 226027e0393fSCarsten Otte if (!kvm_is_ucontrol(kvm)) 22616ea427bbSMartin Schwidefsky gmap_remove(kvm->arch.gmap); 2262841b91c5SCornelia Huck kvm_s390_destroy_adapters(kvm); 226367335e63SChristian Borntraeger kvm_s390_clear_float_irqs(kvm); 2264a3508fbeSDavid Hildenbrand kvm_s390_vsie_destroy(kvm); 22658335713aSChristian Borntraeger KVM_EVENT(3, "vm 0x%pK destroyed", kvm); 2266b0c632dbSHeiko Carstens } 2267b0c632dbSHeiko Carstens 2268b0c632dbSHeiko Carstens /* Section: vcpu related */ 2269dafd032aSDominik Dingel static int __kvm_ucontrol_vcpu_init(struct kvm_vcpu *vcpu) 2270b0c632dbSHeiko Carstens { 22716ea427bbSMartin Schwidefsky vcpu->arch.gmap = gmap_create(current->mm, -1UL); 227227e0393fSCarsten Otte if (!vcpu->arch.gmap) 227327e0393fSCarsten Otte return -ENOMEM; 22742c70fe44SChristian Borntraeger vcpu->arch.gmap->private = vcpu->kvm; 2275dafd032aSDominik Dingel 227627e0393fSCarsten Otte return 0; 227727e0393fSCarsten Otte } 227827e0393fSCarsten Otte 2279a6e2f683SEugene (jno) Dvurechenski static void sca_del_vcpu(struct kvm_vcpu *vcpu) 2280a6e2f683SEugene (jno) Dvurechenski { 2281a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) 2282a6940674SDavid Hildenbrand return; 22835e044315SEugene (jno) Dvurechenski read_lock(&vcpu->kvm->arch.sca_lock); 22847d43bafcSEugene (jno) Dvurechenski if (vcpu->kvm->arch.use_esca) { 22857d43bafcSEugene (jno) Dvurechenski struct esca_block *sca = vcpu->kvm->arch.sca; 22867d43bafcSEugene (jno) Dvurechenski 22877d43bafcSEugene (jno) Dvurechenski clear_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn); 22887d43bafcSEugene (jno) Dvurechenski sca->cpu[vcpu->vcpu_id].sda = 0; 22897d43bafcSEugene (jno) Dvurechenski } else { 2290bc784cceSEugene (jno) Dvurechenski struct bsca_block *sca = vcpu->kvm->arch.sca; 2291a6e2f683SEugene (jno) Dvurechenski 2292a6e2f683SEugene (jno) Dvurechenski clear_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn); 2293a6e2f683SEugene (jno) Dvurechenski sca->cpu[vcpu->vcpu_id].sda = 0; 2294a6e2f683SEugene (jno) Dvurechenski } 22955e044315SEugene (jno) Dvurechenski read_unlock(&vcpu->kvm->arch.sca_lock); 22967d43bafcSEugene (jno) Dvurechenski } 2297a6e2f683SEugene (jno) Dvurechenski 2298eaa78f34SDavid Hildenbrand static void sca_add_vcpu(struct kvm_vcpu *vcpu) 2299a6e2f683SEugene (jno) Dvurechenski { 2300a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) { 2301a6940674SDavid Hildenbrand struct bsca_block *sca = vcpu->kvm->arch.sca; 2302a6940674SDavid Hildenbrand 2303a6940674SDavid Hildenbrand /* we still need the basic sca for the ipte control */ 2304a6940674SDavid Hildenbrand vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 2305a6940674SDavid Hildenbrand vcpu->arch.sie_block->scaol = (__u32)(__u64)sca; 2306f07afa04SDavid Hildenbrand return; 2307a6940674SDavid Hildenbrand } 2308eaa78f34SDavid Hildenbrand read_lock(&vcpu->kvm->arch.sca_lock); 2309eaa78f34SDavid Hildenbrand if (vcpu->kvm->arch.use_esca) { 2310eaa78f34SDavid Hildenbrand struct esca_block *sca = vcpu->kvm->arch.sca; 23117d43bafcSEugene (jno) Dvurechenski 2312eaa78f34SDavid Hildenbrand sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block; 23137d43bafcSEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 23147d43bafcSEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = (__u32)(__u64)sca & ~0x3fU; 23150c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= ECB2_ESCA; 2316eaa78f34SDavid Hildenbrand set_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn); 23177d43bafcSEugene (jno) Dvurechenski } else { 2318eaa78f34SDavid Hildenbrand struct bsca_block *sca = vcpu->kvm->arch.sca; 2319a6e2f683SEugene (jno) Dvurechenski 2320eaa78f34SDavid Hildenbrand sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block; 2321a6e2f683SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 2322a6e2f683SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = (__u32)(__u64)sca; 2323eaa78f34SDavid Hildenbrand set_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn); 2324a6e2f683SEugene (jno) Dvurechenski } 2325eaa78f34SDavid Hildenbrand read_unlock(&vcpu->kvm->arch.sca_lock); 23265e044315SEugene (jno) Dvurechenski } 23275e044315SEugene (jno) Dvurechenski 23285e044315SEugene (jno) Dvurechenski /* Basic SCA to Extended SCA data copy routines */ 23295e044315SEugene (jno) Dvurechenski static inline void sca_copy_entry(struct esca_entry *d, struct bsca_entry *s) 23305e044315SEugene (jno) Dvurechenski { 23315e044315SEugene (jno) Dvurechenski d->sda = s->sda; 23325e044315SEugene (jno) Dvurechenski d->sigp_ctrl.c = s->sigp_ctrl.c; 23335e044315SEugene (jno) Dvurechenski d->sigp_ctrl.scn = s->sigp_ctrl.scn; 23345e044315SEugene (jno) Dvurechenski } 23355e044315SEugene (jno) Dvurechenski 23365e044315SEugene (jno) Dvurechenski static void sca_copy_b_to_e(struct esca_block *d, struct bsca_block *s) 23375e044315SEugene (jno) Dvurechenski { 23385e044315SEugene (jno) Dvurechenski int i; 23395e044315SEugene (jno) Dvurechenski 23405e044315SEugene (jno) Dvurechenski d->ipte_control = s->ipte_control; 23415e044315SEugene (jno) Dvurechenski d->mcn[0] = s->mcn; 23425e044315SEugene (jno) Dvurechenski for (i = 0; i < KVM_S390_BSCA_CPU_SLOTS; i++) 23435e044315SEugene (jno) Dvurechenski sca_copy_entry(&d->cpu[i], &s->cpu[i]); 23445e044315SEugene (jno) Dvurechenski } 23455e044315SEugene (jno) Dvurechenski 23465e044315SEugene (jno) Dvurechenski static int sca_switch_to_extended(struct kvm *kvm) 23475e044315SEugene (jno) Dvurechenski { 23485e044315SEugene (jno) Dvurechenski struct bsca_block *old_sca = kvm->arch.sca; 23495e044315SEugene (jno) Dvurechenski struct esca_block *new_sca; 23505e044315SEugene (jno) Dvurechenski struct kvm_vcpu *vcpu; 23515e044315SEugene (jno) Dvurechenski unsigned int vcpu_idx; 23525e044315SEugene (jno) Dvurechenski u32 scaol, scaoh; 23535e044315SEugene (jno) Dvurechenski 23545e044315SEugene (jno) Dvurechenski new_sca = alloc_pages_exact(sizeof(*new_sca), GFP_KERNEL|__GFP_ZERO); 23555e044315SEugene (jno) Dvurechenski if (!new_sca) 23565e044315SEugene (jno) Dvurechenski return -ENOMEM; 23575e044315SEugene (jno) Dvurechenski 23585e044315SEugene (jno) Dvurechenski scaoh = (u32)((u64)(new_sca) >> 32); 23595e044315SEugene (jno) Dvurechenski scaol = (u32)(u64)(new_sca) & ~0x3fU; 23605e044315SEugene (jno) Dvurechenski 23615e044315SEugene (jno) Dvurechenski kvm_s390_vcpu_block_all(kvm); 23625e044315SEugene (jno) Dvurechenski write_lock(&kvm->arch.sca_lock); 23635e044315SEugene (jno) Dvurechenski 23645e044315SEugene (jno) Dvurechenski sca_copy_b_to_e(new_sca, old_sca); 23655e044315SEugene (jno) Dvurechenski 23665e044315SEugene (jno) Dvurechenski kvm_for_each_vcpu(vcpu_idx, vcpu, kvm) { 23675e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = scaoh; 23685e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = scaol; 23690c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= ECB2_ESCA; 23705e044315SEugene (jno) Dvurechenski } 23715e044315SEugene (jno) Dvurechenski kvm->arch.sca = new_sca; 23725e044315SEugene (jno) Dvurechenski kvm->arch.use_esca = 1; 23735e044315SEugene (jno) Dvurechenski 23745e044315SEugene (jno) Dvurechenski write_unlock(&kvm->arch.sca_lock); 23755e044315SEugene (jno) Dvurechenski kvm_s390_vcpu_unblock_all(kvm); 23765e044315SEugene (jno) Dvurechenski 23775e044315SEugene (jno) Dvurechenski free_page((unsigned long)old_sca); 23785e044315SEugene (jno) Dvurechenski 23798335713aSChristian Borntraeger VM_EVENT(kvm, 2, "Switched to ESCA (0x%pK -> 0x%pK)", 23808335713aSChristian Borntraeger old_sca, kvm->arch.sca); 23815e044315SEugene (jno) Dvurechenski return 0; 23827d43bafcSEugene (jno) Dvurechenski } 2383a6e2f683SEugene (jno) Dvurechenski 2384a6e2f683SEugene (jno) Dvurechenski static int sca_can_add_vcpu(struct kvm *kvm, unsigned int id) 2385a6e2f683SEugene (jno) Dvurechenski { 23865e044315SEugene (jno) Dvurechenski int rc; 23875e044315SEugene (jno) Dvurechenski 2388a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) { 2389a6940674SDavid Hildenbrand if (id < KVM_MAX_VCPUS) 2390a6940674SDavid Hildenbrand return true; 2391a6940674SDavid Hildenbrand return false; 2392a6940674SDavid Hildenbrand } 23935e044315SEugene (jno) Dvurechenski if (id < KVM_S390_BSCA_CPU_SLOTS) 23945e044315SEugene (jno) Dvurechenski return true; 239576a6dd72SDavid Hildenbrand if (!sclp.has_esca || !sclp.has_64bscao) 23965e044315SEugene (jno) Dvurechenski return false; 23975e044315SEugene (jno) Dvurechenski 23985e044315SEugene (jno) Dvurechenski mutex_lock(&kvm->lock); 23995e044315SEugene (jno) Dvurechenski rc = kvm->arch.use_esca ? 0 : sca_switch_to_extended(kvm); 24005e044315SEugene (jno) Dvurechenski mutex_unlock(&kvm->lock); 24015e044315SEugene (jno) Dvurechenski 24025e044315SEugene (jno) Dvurechenski return rc == 0 && id < KVM_S390_ESCA_CPU_SLOTS; 2403a6e2f683SEugene (jno) Dvurechenski } 2404a6e2f683SEugene (jno) Dvurechenski 2405dafd032aSDominik Dingel int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 2406dafd032aSDominik Dingel { 2407dafd032aSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 2408dafd032aSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 240959674c1aSChristian Borntraeger vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX | 241059674c1aSChristian Borntraeger KVM_SYNC_GPRS | 24119eed0735SChristian Borntraeger KVM_SYNC_ACRS | 2412b028ee3eSDavid Hildenbrand KVM_SYNC_CRS | 2413b028ee3eSDavid Hildenbrand KVM_SYNC_ARCH0 | 2414b028ee3eSDavid Hildenbrand KVM_SYNC_PFAULT; 241575a4615cSJulius Niedworok kvm_s390_set_prefix(vcpu, 0); 2416c6e5f166SFan Zhang if (test_kvm_facility(vcpu->kvm, 64)) 2417c6e5f166SFan Zhang vcpu->run->kvm_valid_regs |= KVM_SYNC_RICCB; 241835b3fde6SChristian Borntraeger if (test_kvm_facility(vcpu->kvm, 82)) 241935b3fde6SChristian Borntraeger vcpu->run->kvm_valid_regs |= KVM_SYNC_BPBC; 24204e0b1ab7SFan Zhang if (test_kvm_facility(vcpu->kvm, 133)) 24214e0b1ab7SFan Zhang vcpu->run->kvm_valid_regs |= KVM_SYNC_GSCB; 2422a3da7b4aSChristian Borntraeger if (test_kvm_facility(vcpu->kvm, 156)) 2423a3da7b4aSChristian Borntraeger vcpu->run->kvm_valid_regs |= KVM_SYNC_ETOKEN; 2424f6aa6dc4SDavid Hildenbrand /* fprs can be synchronized via vrs, even if the guest has no vx. With 2425f6aa6dc4SDavid Hildenbrand * MACHINE_HAS_VX, (load|store)_fpu_regs() will work with vrs format. 2426f6aa6dc4SDavid Hildenbrand */ 2427f6aa6dc4SDavid Hildenbrand if (MACHINE_HAS_VX) 242868c55750SEric Farman vcpu->run->kvm_valid_regs |= KVM_SYNC_VRS; 24296fd8e67dSDavid Hildenbrand else 24306fd8e67dSDavid Hildenbrand vcpu->run->kvm_valid_regs |= KVM_SYNC_FPRS; 2431dafd032aSDominik Dingel 2432dafd032aSDominik Dingel if (kvm_is_ucontrol(vcpu->kvm)) 2433dafd032aSDominik Dingel return __kvm_ucontrol_vcpu_init(vcpu); 2434dafd032aSDominik Dingel 2435b0c632dbSHeiko Carstens return 0; 2436b0c632dbSHeiko Carstens } 2437b0c632dbSHeiko Carstens 2438db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 2439db0758b2SDavid Hildenbrand static void __start_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2440db0758b2SDavid Hildenbrand { 2441db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_start != 0); 24429c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 2443db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = get_tod_clock_fast(); 24449c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 2445db0758b2SDavid Hildenbrand } 2446db0758b2SDavid Hildenbrand 2447db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 2448db0758b2SDavid Hildenbrand static void __stop_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2449db0758b2SDavid Hildenbrand { 2450db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_start == 0); 24519c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 2452db0758b2SDavid Hildenbrand vcpu->arch.sie_block->cputm -= get_tod_clock_fast() - vcpu->arch.cputm_start; 2453db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = 0; 24549c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 2455db0758b2SDavid Hildenbrand } 2456db0758b2SDavid Hildenbrand 2457db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 2458db0758b2SDavid Hildenbrand static void __enable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2459db0758b2SDavid Hildenbrand { 2460db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_enabled); 2461db0758b2SDavid Hildenbrand vcpu->arch.cputm_enabled = true; 2462db0758b2SDavid Hildenbrand __start_cpu_timer_accounting(vcpu); 2463db0758b2SDavid Hildenbrand } 2464db0758b2SDavid Hildenbrand 2465db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 2466db0758b2SDavid Hildenbrand static void __disable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2467db0758b2SDavid Hildenbrand { 2468db0758b2SDavid Hildenbrand WARN_ON_ONCE(!vcpu->arch.cputm_enabled); 2469db0758b2SDavid Hildenbrand __stop_cpu_timer_accounting(vcpu); 2470db0758b2SDavid Hildenbrand vcpu->arch.cputm_enabled = false; 2471db0758b2SDavid Hildenbrand } 2472db0758b2SDavid Hildenbrand 2473db0758b2SDavid Hildenbrand static void enable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2474db0758b2SDavid Hildenbrand { 2475db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 2476db0758b2SDavid Hildenbrand __enable_cpu_timer_accounting(vcpu); 2477db0758b2SDavid Hildenbrand preempt_enable(); 2478db0758b2SDavid Hildenbrand } 2479db0758b2SDavid Hildenbrand 2480db0758b2SDavid Hildenbrand static void disable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2481db0758b2SDavid Hildenbrand { 2482db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 2483db0758b2SDavid Hildenbrand __disable_cpu_timer_accounting(vcpu); 2484db0758b2SDavid Hildenbrand preempt_enable(); 2485db0758b2SDavid Hildenbrand } 2486db0758b2SDavid Hildenbrand 24874287f247SDavid Hildenbrand /* set the cpu timer - may only be called from the VCPU thread itself */ 24884287f247SDavid Hildenbrand void kvm_s390_set_cpu_timer(struct kvm_vcpu *vcpu, __u64 cputm) 24894287f247SDavid Hildenbrand { 2490db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 24919c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 2492db0758b2SDavid Hildenbrand if (vcpu->arch.cputm_enabled) 2493db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = get_tod_clock_fast(); 24944287f247SDavid Hildenbrand vcpu->arch.sie_block->cputm = cputm; 24959c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 2496db0758b2SDavid Hildenbrand preempt_enable(); 24974287f247SDavid Hildenbrand } 24984287f247SDavid Hildenbrand 2499db0758b2SDavid Hildenbrand /* update and get the cpu timer - can also be called from other VCPU threads */ 25004287f247SDavid Hildenbrand __u64 kvm_s390_get_cpu_timer(struct kvm_vcpu *vcpu) 25014287f247SDavid Hildenbrand { 25029c23a131SDavid Hildenbrand unsigned int seq; 2503db0758b2SDavid Hildenbrand __u64 value; 2504db0758b2SDavid Hildenbrand 2505db0758b2SDavid Hildenbrand if (unlikely(!vcpu->arch.cputm_enabled)) 25064287f247SDavid Hildenbrand return vcpu->arch.sie_block->cputm; 2507db0758b2SDavid Hildenbrand 25089c23a131SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 25099c23a131SDavid Hildenbrand do { 25109c23a131SDavid Hildenbrand seq = raw_read_seqcount(&vcpu->arch.cputm_seqcount); 25119c23a131SDavid Hildenbrand /* 25129c23a131SDavid Hildenbrand * If the writer would ever execute a read in the critical 25139c23a131SDavid Hildenbrand * section, e.g. in irq context, we have a deadlock. 25149c23a131SDavid Hildenbrand */ 25159c23a131SDavid Hildenbrand WARN_ON_ONCE((seq & 1) && smp_processor_id() == vcpu->cpu); 2516db0758b2SDavid Hildenbrand value = vcpu->arch.sie_block->cputm; 25179c23a131SDavid Hildenbrand /* if cputm_start is 0, accounting is being started/stopped */ 25189c23a131SDavid Hildenbrand if (likely(vcpu->arch.cputm_start)) 2519db0758b2SDavid Hildenbrand value -= get_tod_clock_fast() - vcpu->arch.cputm_start; 25209c23a131SDavid Hildenbrand } while (read_seqcount_retry(&vcpu->arch.cputm_seqcount, seq & ~1)); 25219c23a131SDavid Hildenbrand preempt_enable(); 2522db0758b2SDavid Hildenbrand return value; 25234287f247SDavid Hildenbrand } 25244287f247SDavid Hildenbrand 2525b0c632dbSHeiko Carstens void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 2526b0c632dbSHeiko Carstens { 25279977e886SHendrik Brueckner 252837d9df98SDavid Hildenbrand gmap_enable(vcpu->arch.enabled_gmap); 2529ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_RUNNING); 25305ebda316SDavid Hildenbrand if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu)) 2531db0758b2SDavid Hildenbrand __start_cpu_timer_accounting(vcpu); 253201a745acSDavid Hildenbrand vcpu->cpu = cpu; 2533b0c632dbSHeiko Carstens } 2534b0c632dbSHeiko Carstens 2535b0c632dbSHeiko Carstens void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 2536b0c632dbSHeiko Carstens { 253701a745acSDavid Hildenbrand vcpu->cpu = -1; 25385ebda316SDavid Hildenbrand if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu)) 2539db0758b2SDavid Hildenbrand __stop_cpu_timer_accounting(vcpu); 25409daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_RUNNING); 254137d9df98SDavid Hildenbrand vcpu->arch.enabled_gmap = gmap_get_enabled(); 254237d9df98SDavid Hildenbrand gmap_disable(vcpu->arch.enabled_gmap); 25439977e886SHendrik Brueckner 2544b0c632dbSHeiko Carstens } 2545b0c632dbSHeiko Carstens 2546b0c632dbSHeiko Carstens static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu) 2547b0c632dbSHeiko Carstens { 2548b0c632dbSHeiko Carstens /* this equals initial cpu reset in pop, but we don't switch to ESA */ 2549b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.mask = 0UL; 2550b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.addr = 0UL; 25518d26cf7bSChristian Borntraeger kvm_s390_set_prefix(vcpu, 0); 25524287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, 0); 2553b0c632dbSHeiko Carstens vcpu->arch.sie_block->ckc = 0UL; 2554b0c632dbSHeiko Carstens vcpu->arch.sie_block->todpr = 0; 2555b0c632dbSHeiko Carstens memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64)); 2556b9224cd7SDavid Hildenbrand vcpu->arch.sie_block->gcr[0] = CR0_UNUSED_56 | 2557b9224cd7SDavid Hildenbrand CR0_INTERRUPT_KEY_SUBMASK | 2558b9224cd7SDavid Hildenbrand CR0_MEASUREMENT_ALERT_SUBMASK; 2559b9224cd7SDavid Hildenbrand vcpu->arch.sie_block->gcr[14] = CR14_UNUSED_32 | 2560b9224cd7SDavid Hildenbrand CR14_UNUSED_33 | 2561b9224cd7SDavid Hildenbrand CR14_EXTERNAL_DAMAGE_SUBMASK; 25629abc2a08SDavid Hildenbrand /* make sure the new fpc will be lazily loaded */ 25639abc2a08SDavid Hildenbrand save_fpu_regs(); 25649abc2a08SDavid Hildenbrand current->thread.fpu.fpc = 0; 2565b0c632dbSHeiko Carstens vcpu->arch.sie_block->gbea = 1; 2566672550fbSChristian Borntraeger vcpu->arch.sie_block->pp = 0; 256735b3fde6SChristian Borntraeger vcpu->arch.sie_block->fpf &= ~FPF_BPBC; 25683c038e6bSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 25693c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 25706352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) 25716852d7b6SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 25722ed10cc1SJens Freimann kvm_s390_clear_local_irqs(vcpu); 2573b0c632dbSHeiko Carstens } 2574b0c632dbSHeiko Carstens 257531928aa5SDominik Dingel void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu) 257642897d86SMarcelo Tosatti { 257772f25020SJason J. Herne mutex_lock(&vcpu->kvm->lock); 2578fdf03650SFan Zhang preempt_disable(); 257972f25020SJason J. Herne vcpu->arch.sie_block->epoch = vcpu->kvm->arch.epoch; 2580d16b52cbSDavid Hildenbrand vcpu->arch.sie_block->epdx = vcpu->kvm->arch.epdx; 2581fdf03650SFan Zhang preempt_enable(); 258272f25020SJason J. Herne mutex_unlock(&vcpu->kvm->lock); 258325508824SDavid Hildenbrand if (!kvm_is_ucontrol(vcpu->kvm)) { 2584dafd032aSDominik Dingel vcpu->arch.gmap = vcpu->kvm->arch.gmap; 2585eaa78f34SDavid Hildenbrand sca_add_vcpu(vcpu); 258625508824SDavid Hildenbrand } 25876502a34cSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 74) || vcpu->kvm->arch.user_instr0) 25886502a34cSDavid Hildenbrand vcpu->arch.sie_block->ictl |= ICTL_OPEREXC; 258937d9df98SDavid Hildenbrand /* make vcpu_load load the right gmap on the first trigger */ 259037d9df98SDavid Hildenbrand vcpu->arch.enabled_gmap = vcpu->arch.gmap; 259142897d86SMarcelo Tosatti } 259242897d86SMarcelo Tosatti 25935102ee87STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu) 25945102ee87STony Krowiak { 2595e585b24aSTony Krowiak /* 2596e585b24aSTony Krowiak * If the AP instructions are not being interpreted and the MSAX3 2597e585b24aSTony Krowiak * facility is not configured for the guest, there is nothing to set up. 2598e585b24aSTony Krowiak */ 2599e585b24aSTony Krowiak if (!vcpu->kvm->arch.crypto.apie && !test_kvm_facility(vcpu->kvm, 76)) 26005102ee87STony Krowiak return; 26015102ee87STony Krowiak 2602e585b24aSTony Krowiak vcpu->arch.sie_block->crycbd = vcpu->kvm->arch.crypto.crycbd; 2603a374e892STony Krowiak vcpu->arch.sie_block->ecb3 &= ~(ECB3_AES | ECB3_DEA); 2604a374e892STony Krowiak 2605e585b24aSTony Krowiak if (vcpu->kvm->arch.crypto.apie) 2606e585b24aSTony Krowiak vcpu->arch.sie_block->eca |= ECA_APIE; 2607e585b24aSTony Krowiak 2608e585b24aSTony Krowiak /* Set up protected key support */ 2609a374e892STony Krowiak if (vcpu->kvm->arch.crypto.aes_kw) 2610a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_AES; 2611a374e892STony Krowiak if (vcpu->kvm->arch.crypto.dea_kw) 2612a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_DEA; 26135102ee87STony Krowiak } 26145102ee87STony Krowiak 2615b31605c1SDominik Dingel void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu) 2616b31605c1SDominik Dingel { 2617b31605c1SDominik Dingel free_page(vcpu->arch.sie_block->cbrlo); 2618b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = 0; 2619b31605c1SDominik Dingel } 2620b31605c1SDominik Dingel 2621b31605c1SDominik Dingel int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu) 2622b31605c1SDominik Dingel { 2623b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = get_zeroed_page(GFP_KERNEL); 2624b31605c1SDominik Dingel if (!vcpu->arch.sie_block->cbrlo) 2625b31605c1SDominik Dingel return -ENOMEM; 2626b31605c1SDominik Dingel return 0; 2627b31605c1SDominik Dingel } 2628b31605c1SDominik Dingel 262991520f1aSMichael Mueller static void kvm_s390_vcpu_setup_model(struct kvm_vcpu *vcpu) 263091520f1aSMichael Mueller { 263191520f1aSMichael Mueller struct kvm_s390_cpu_model *model = &vcpu->kvm->arch.model; 263291520f1aSMichael Mueller 263391520f1aSMichael Mueller vcpu->arch.sie_block->ibc = model->ibc; 263480bc79dcSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 7)) 2635c54f0d6aSDavid Hildenbrand vcpu->arch.sie_block->fac = (u32)(u64) model->fac_list; 263691520f1aSMichael Mueller } 263791520f1aSMichael Mueller 2638b0c632dbSHeiko Carstens int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) 2639b0c632dbSHeiko Carstens { 2640b31605c1SDominik Dingel int rc = 0; 2641b31288faSKonstantin Weitz 26429e6dabefSCornelia Huck atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH | 26439e6dabefSCornelia Huck CPUSTAT_SM | 2644a4a4f191SGuenther Hutzl CPUSTAT_STOPPED); 2645a4a4f191SGuenther Hutzl 264653df84f8SGuenther Hutzl if (test_kvm_facility(vcpu->kvm, 78)) 2647ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_GED2); 264853df84f8SGuenther Hutzl else if (test_kvm_facility(vcpu->kvm, 8)) 2649ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_GED); 2650a4a4f191SGuenther Hutzl 265191520f1aSMichael Mueller kvm_s390_vcpu_setup_model(vcpu); 265291520f1aSMichael Mueller 2653bdab09f3SDavid Hildenbrand /* pgste_set_pte has special handling for !MACHINE_HAS_ESOP */ 2654bdab09f3SDavid Hildenbrand if (MACHINE_HAS_ESOP) 26550c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb |= ECB_HOSTPROTINT; 2656bd50e8ecSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 9)) 26570c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb |= ECB_SRSI; 2658f597d24eSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 73)) 26590c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb |= ECB_TE; 26607feb6bb8SMichael Mueller 2661c9f0a2b8SJanosch Frank if (test_kvm_facility(vcpu->kvm, 8) && vcpu->kvm->arch.use_pfmfi) 26620c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= ECB2_PFMFI; 2663cd1836f5SJanosch Frank if (test_kvm_facility(vcpu->kvm, 130)) 26640c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= ECB2_IEP; 26650c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca = ECA_MVPGI | ECA_PROTEXCI; 266648ee7d3aSDavid Hildenbrand if (sclp.has_cei) 26670c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_CEI; 266811ad65b7SDavid Hildenbrand if (sclp.has_ib) 26690c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_IB; 267037c5f6c8SDavid Hildenbrand if (sclp.has_siif) 26710c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_SII; 267237c5f6c8SDavid Hildenbrand if (sclp.has_sigpif) 26730c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_SIGPI; 267418280d8bSMichael Mueller if (test_kvm_facility(vcpu->kvm, 129)) { 26750c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_VX; 26760c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecd |= ECD_HOSTREGMGMT; 267713211ea7SEric Farman } 26788fa1696eSCollin L. Walling if (test_kvm_facility(vcpu->kvm, 139)) 26798fa1696eSCollin L. Walling vcpu->arch.sie_block->ecd |= ECD_MEF; 2680a3da7b4aSChristian Borntraeger if (test_kvm_facility(vcpu->kvm, 156)) 2681a3da7b4aSChristian Borntraeger vcpu->arch.sie_block->ecd |= ECD_ETOKENF; 2682d7c5cb01SMichael Mueller if (vcpu->arch.sie_block->gd) { 2683d7c5cb01SMichael Mueller vcpu->arch.sie_block->eca |= ECA_AIV; 2684d7c5cb01SMichael Mueller VCPU_EVENT(vcpu, 3, "AIV gisa format-%u enabled for cpu %03u", 2685d7c5cb01SMichael Mueller vcpu->arch.sie_block->gd & 0x3, vcpu->vcpu_id); 2686d7c5cb01SMichael Mueller } 26874e0b1ab7SFan Zhang vcpu->arch.sie_block->sdnxo = ((unsigned long) &vcpu->run->s.regs.sdnx) 26884e0b1ab7SFan Zhang | SDNXC; 2689c6e5f166SFan Zhang vcpu->arch.sie_block->riccbd = (unsigned long) &vcpu->run->s.regs.riccb; 2690730cd632SFarhan Ali 2691730cd632SFarhan Ali if (sclp.has_kss) 2692ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_KSS); 2693730cd632SFarhan Ali else 2694492d8642SThomas Huth vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE; 26955a5e6536SMatthew Rosato 2696e6db1d61SDominik Dingel if (vcpu->kvm->arch.use_cmma) { 2697b31605c1SDominik Dingel rc = kvm_s390_vcpu_setup_cmma(vcpu); 2698b31605c1SDominik Dingel if (rc) 2699b31605c1SDominik Dingel return rc; 2700b31288faSKonstantin Weitz } 27010ac96cafSDavid Hildenbrand hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 2702ca872302SChristian Borntraeger vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup; 27039d8d5786SMichael Mueller 27045102ee87STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 27055102ee87STony Krowiak 2706b31605c1SDominik Dingel return rc; 2707b0c632dbSHeiko Carstens } 2708b0c632dbSHeiko Carstens 2709b0c632dbSHeiko Carstens struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, 2710b0c632dbSHeiko Carstens unsigned int id) 2711b0c632dbSHeiko Carstens { 27124d47555aSCarsten Otte struct kvm_vcpu *vcpu; 27137feb6bb8SMichael Mueller struct sie_page *sie_page; 27144d47555aSCarsten Otte int rc = -EINVAL; 2715b0c632dbSHeiko Carstens 27164215825eSDavid Hildenbrand if (!kvm_is_ucontrol(kvm) && !sca_can_add_vcpu(kvm, id)) 27174d47555aSCarsten Otte goto out; 27184d47555aSCarsten Otte 27194d47555aSCarsten Otte rc = -ENOMEM; 27204d47555aSCarsten Otte 2721b110feafSMichael Mueller vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL); 2722b0c632dbSHeiko Carstens if (!vcpu) 27234d47555aSCarsten Otte goto out; 2724b0c632dbSHeiko Carstens 2725da72ca4dSQingFeng Hao BUILD_BUG_ON(sizeof(struct sie_page) != 4096); 27267feb6bb8SMichael Mueller sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL); 27277feb6bb8SMichael Mueller if (!sie_page) 2728b0c632dbSHeiko Carstens goto out_free_cpu; 2729b0c632dbSHeiko Carstens 27307feb6bb8SMichael Mueller vcpu->arch.sie_block = &sie_page->sie_block; 27317feb6bb8SMichael Mueller vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb; 27327feb6bb8SMichael Mueller 2733efed1104SDavid Hildenbrand /* the real guest size will always be smaller than msl */ 2734efed1104SDavid Hildenbrand vcpu->arch.sie_block->mso = 0; 2735efed1104SDavid Hildenbrand vcpu->arch.sie_block->msl = sclp.hamax; 2736efed1104SDavid Hildenbrand 2737b0c632dbSHeiko Carstens vcpu->arch.sie_block->icpua = id; 2738ba5c1e9bSCarsten Otte spin_lock_init(&vcpu->arch.local_int.lock); 2739d7c5cb01SMichael Mueller vcpu->arch.sie_block->gd = (u32)(u64)kvm->arch.gisa; 27404b9f9525SMichael Mueller if (vcpu->arch.sie_block->gd && sclp.has_gisaf) 27414b9f9525SMichael Mueller vcpu->arch.sie_block->gd |= GISA_FORMAT1; 27429c23a131SDavid Hildenbrand seqcount_init(&vcpu->arch.cputm_seqcount); 2743ba5c1e9bSCarsten Otte 2744b0c632dbSHeiko Carstens rc = kvm_vcpu_init(vcpu, kvm, id); 2745b0c632dbSHeiko Carstens if (rc) 27469abc2a08SDavid Hildenbrand goto out_free_sie_block; 27478335713aSChristian Borntraeger VM_EVENT(kvm, 3, "create cpu %d at 0x%pK, sie block at 0x%pK", id, vcpu, 2748b0c632dbSHeiko Carstens vcpu->arch.sie_block); 2749ade38c31SCornelia Huck trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block); 2750b0c632dbSHeiko Carstens 2751b0c632dbSHeiko Carstens return vcpu; 27527b06bf2fSWei Yongjun out_free_sie_block: 27537b06bf2fSWei Yongjun free_page((unsigned long)(vcpu->arch.sie_block)); 2754b0c632dbSHeiko Carstens out_free_cpu: 2755b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 27564d47555aSCarsten Otte out: 2757b0c632dbSHeiko Carstens return ERR_PTR(rc); 2758b0c632dbSHeiko Carstens } 2759b0c632dbSHeiko Carstens 2760b0c632dbSHeiko Carstens int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu) 2761b0c632dbSHeiko Carstens { 27629a022067SDavid Hildenbrand return kvm_s390_vcpu_has_irq(vcpu, 0); 2763b0c632dbSHeiko Carstens } 2764b0c632dbSHeiko Carstens 2765199b5763SLongpeng(Mike) bool kvm_arch_vcpu_in_kernel(struct kvm_vcpu *vcpu) 2766199b5763SLongpeng(Mike) { 27670546c63dSLongpeng(Mike) return !(vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE); 2768199b5763SLongpeng(Mike) } 2769199b5763SLongpeng(Mike) 277027406cd5SChristian Borntraeger void kvm_s390_vcpu_block(struct kvm_vcpu *vcpu) 277149b99e1eSChristian Borntraeger { 2772805de8f4SPeter Zijlstra atomic_or(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 277361a6df54SDavid Hildenbrand exit_sie(vcpu); 277449b99e1eSChristian Borntraeger } 277549b99e1eSChristian Borntraeger 277627406cd5SChristian Borntraeger void kvm_s390_vcpu_unblock(struct kvm_vcpu *vcpu) 277749b99e1eSChristian Borntraeger { 2778805de8f4SPeter Zijlstra atomic_andnot(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 277949b99e1eSChristian Borntraeger } 278049b99e1eSChristian Borntraeger 27818e236546SChristian Borntraeger static void kvm_s390_vcpu_request(struct kvm_vcpu *vcpu) 27828e236546SChristian Borntraeger { 2783805de8f4SPeter Zijlstra atomic_or(PROG_REQUEST, &vcpu->arch.sie_block->prog20); 278461a6df54SDavid Hildenbrand exit_sie(vcpu); 27858e236546SChristian Borntraeger } 27868e236546SChristian Borntraeger 27879ea59728SDavid Hildenbrand bool kvm_s390_vcpu_sie_inhibited(struct kvm_vcpu *vcpu) 27889ea59728SDavid Hildenbrand { 27899ea59728SDavid Hildenbrand return atomic_read(&vcpu->arch.sie_block->prog20) & 27909ea59728SDavid Hildenbrand (PROG_BLOCK_SIE | PROG_REQUEST); 27919ea59728SDavid Hildenbrand } 27929ea59728SDavid Hildenbrand 27938e236546SChristian Borntraeger static void kvm_s390_vcpu_request_handled(struct kvm_vcpu *vcpu) 27948e236546SChristian Borntraeger { 27959bf9fde2SJason J. Herne atomic_andnot(PROG_REQUEST, &vcpu->arch.sie_block->prog20); 27968e236546SChristian Borntraeger } 27978e236546SChristian Borntraeger 279849b99e1eSChristian Borntraeger /* 27999ea59728SDavid Hildenbrand * Kick a guest cpu out of (v)SIE and wait until (v)SIE is not running. 280049b99e1eSChristian Borntraeger * If the CPU is not running (e.g. waiting as idle) the function will 280149b99e1eSChristian Borntraeger * return immediately. */ 280249b99e1eSChristian Borntraeger void exit_sie(struct kvm_vcpu *vcpu) 280349b99e1eSChristian Borntraeger { 2804ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_STOP_INT); 28059ea59728SDavid Hildenbrand kvm_s390_vsie_kick(vcpu); 280649b99e1eSChristian Borntraeger while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE) 280749b99e1eSChristian Borntraeger cpu_relax(); 280849b99e1eSChristian Borntraeger } 280949b99e1eSChristian Borntraeger 28108e236546SChristian Borntraeger /* Kick a guest cpu out of SIE to process a request synchronously */ 28118e236546SChristian Borntraeger void kvm_s390_sync_request(int req, struct kvm_vcpu *vcpu) 281249b99e1eSChristian Borntraeger { 28138e236546SChristian Borntraeger kvm_make_request(req, vcpu); 28148e236546SChristian Borntraeger kvm_s390_vcpu_request(vcpu); 281549b99e1eSChristian Borntraeger } 281649b99e1eSChristian Borntraeger 2817414d3b07SMartin Schwidefsky static void kvm_gmap_notifier(struct gmap *gmap, unsigned long start, 2818414d3b07SMartin Schwidefsky unsigned long end) 28192c70fe44SChristian Borntraeger { 28202c70fe44SChristian Borntraeger struct kvm *kvm = gmap->private; 28212c70fe44SChristian Borntraeger struct kvm_vcpu *vcpu; 2822414d3b07SMartin Schwidefsky unsigned long prefix; 2823414d3b07SMartin Schwidefsky int i; 28242c70fe44SChristian Borntraeger 282565d0b0d4SDavid Hildenbrand if (gmap_is_shadow(gmap)) 282665d0b0d4SDavid Hildenbrand return; 2827414d3b07SMartin Schwidefsky if (start >= 1UL << 31) 2828414d3b07SMartin Schwidefsky /* We are only interested in prefix pages */ 2829414d3b07SMartin Schwidefsky return; 28302c70fe44SChristian Borntraeger kvm_for_each_vcpu(i, vcpu, kvm) { 28312c70fe44SChristian Borntraeger /* match against both prefix pages */ 2832414d3b07SMartin Schwidefsky prefix = kvm_s390_get_prefix(vcpu); 2833414d3b07SMartin Schwidefsky if (prefix <= end && start <= prefix + 2*PAGE_SIZE - 1) { 2834414d3b07SMartin Schwidefsky VCPU_EVENT(vcpu, 2, "gmap notifier for %lx-%lx", 2835414d3b07SMartin Schwidefsky start, end); 28368e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_MMU_RELOAD, vcpu); 28372c70fe44SChristian Borntraeger } 28382c70fe44SChristian Borntraeger } 28392c70fe44SChristian Borntraeger } 28402c70fe44SChristian Borntraeger 2841b6d33834SChristoffer Dall int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu) 2842b6d33834SChristoffer Dall { 2843b6d33834SChristoffer Dall /* kvm common code refers to this, but never calls it */ 2844b6d33834SChristoffer Dall BUG(); 2845b6d33834SChristoffer Dall return 0; 2846b6d33834SChristoffer Dall } 2847b6d33834SChristoffer Dall 284814eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, 284914eebd91SCarsten Otte struct kvm_one_reg *reg) 285014eebd91SCarsten Otte { 285114eebd91SCarsten Otte int r = -EINVAL; 285214eebd91SCarsten Otte 285314eebd91SCarsten Otte switch (reg->id) { 285429b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 285529b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->todpr, 285629b7c71bSCarsten Otte (u32 __user *)reg->addr); 285729b7c71bSCarsten Otte break; 285829b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 285929b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->epoch, 286029b7c71bSCarsten Otte (u64 __user *)reg->addr); 286129b7c71bSCarsten Otte break; 286246a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 28634287f247SDavid Hildenbrand r = put_user(kvm_s390_get_cpu_timer(vcpu), 286446a6dd1cSJason J. herne (u64 __user *)reg->addr); 286546a6dd1cSJason J. herne break; 286646a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 286746a6dd1cSJason J. herne r = put_user(vcpu->arch.sie_block->ckc, 286846a6dd1cSJason J. herne (u64 __user *)reg->addr); 286946a6dd1cSJason J. herne break; 2870536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 2871536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_token, 2872536336c2SDominik Dingel (u64 __user *)reg->addr); 2873536336c2SDominik Dingel break; 2874536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 2875536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_compare, 2876536336c2SDominik Dingel (u64 __user *)reg->addr); 2877536336c2SDominik Dingel break; 2878536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 2879536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_select, 2880536336c2SDominik Dingel (u64 __user *)reg->addr); 2881536336c2SDominik Dingel break; 2882672550fbSChristian Borntraeger case KVM_REG_S390_PP: 2883672550fbSChristian Borntraeger r = put_user(vcpu->arch.sie_block->pp, 2884672550fbSChristian Borntraeger (u64 __user *)reg->addr); 2885672550fbSChristian Borntraeger break; 2886afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 2887afa45ff5SChristian Borntraeger r = put_user(vcpu->arch.sie_block->gbea, 2888afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 2889afa45ff5SChristian Borntraeger break; 289014eebd91SCarsten Otte default: 289114eebd91SCarsten Otte break; 289214eebd91SCarsten Otte } 289314eebd91SCarsten Otte 289414eebd91SCarsten Otte return r; 289514eebd91SCarsten Otte } 289614eebd91SCarsten Otte 289714eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, 289814eebd91SCarsten Otte struct kvm_one_reg *reg) 289914eebd91SCarsten Otte { 290014eebd91SCarsten Otte int r = -EINVAL; 29014287f247SDavid Hildenbrand __u64 val; 290214eebd91SCarsten Otte 290314eebd91SCarsten Otte switch (reg->id) { 290429b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 290529b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->todpr, 290629b7c71bSCarsten Otte (u32 __user *)reg->addr); 290729b7c71bSCarsten Otte break; 290829b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 290929b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->epoch, 291029b7c71bSCarsten Otte (u64 __user *)reg->addr); 291129b7c71bSCarsten Otte break; 291246a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 29134287f247SDavid Hildenbrand r = get_user(val, (u64 __user *)reg->addr); 29144287f247SDavid Hildenbrand if (!r) 29154287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, val); 291646a6dd1cSJason J. herne break; 291746a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 291846a6dd1cSJason J. herne r = get_user(vcpu->arch.sie_block->ckc, 291946a6dd1cSJason J. herne (u64 __user *)reg->addr); 292046a6dd1cSJason J. herne break; 2921536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 2922536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_token, 2923536336c2SDominik Dingel (u64 __user *)reg->addr); 29249fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 29259fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 2926536336c2SDominik Dingel break; 2927536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 2928536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_compare, 2929536336c2SDominik Dingel (u64 __user *)reg->addr); 2930536336c2SDominik Dingel break; 2931536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 2932536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_select, 2933536336c2SDominik Dingel (u64 __user *)reg->addr); 2934536336c2SDominik Dingel break; 2935672550fbSChristian Borntraeger case KVM_REG_S390_PP: 2936672550fbSChristian Borntraeger r = get_user(vcpu->arch.sie_block->pp, 2937672550fbSChristian Borntraeger (u64 __user *)reg->addr); 2938672550fbSChristian Borntraeger break; 2939afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 2940afa45ff5SChristian Borntraeger r = get_user(vcpu->arch.sie_block->gbea, 2941afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 2942afa45ff5SChristian Borntraeger break; 294314eebd91SCarsten Otte default: 294414eebd91SCarsten Otte break; 294514eebd91SCarsten Otte } 294614eebd91SCarsten Otte 294714eebd91SCarsten Otte return r; 294814eebd91SCarsten Otte } 2949b6d33834SChristoffer Dall 2950b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) 2951b0c632dbSHeiko Carstens { 2952b0c632dbSHeiko Carstens kvm_s390_vcpu_initial_reset(vcpu); 2953b0c632dbSHeiko Carstens return 0; 2954b0c632dbSHeiko Carstens } 2955b0c632dbSHeiko Carstens 2956b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 2957b0c632dbSHeiko Carstens { 2958875656feSChristoffer Dall vcpu_load(vcpu); 29595a32c1afSChristian Borntraeger memcpy(&vcpu->run->s.regs.gprs, ®s->gprs, sizeof(regs->gprs)); 2960875656feSChristoffer Dall vcpu_put(vcpu); 2961b0c632dbSHeiko Carstens return 0; 2962b0c632dbSHeiko Carstens } 2963b0c632dbSHeiko Carstens 2964b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 2965b0c632dbSHeiko Carstens { 29661fc9b76bSChristoffer Dall vcpu_load(vcpu); 29675a32c1afSChristian Borntraeger memcpy(®s->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs)); 29681fc9b76bSChristoffer Dall vcpu_put(vcpu); 2969b0c632dbSHeiko Carstens return 0; 2970b0c632dbSHeiko Carstens } 2971b0c632dbSHeiko Carstens 2972b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, 2973b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 2974b0c632dbSHeiko Carstens { 2975b4ef9d4eSChristoffer Dall vcpu_load(vcpu); 2976b4ef9d4eSChristoffer Dall 297759674c1aSChristian Borntraeger memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs)); 2978b0c632dbSHeiko Carstens memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs)); 2979b4ef9d4eSChristoffer Dall 2980b4ef9d4eSChristoffer Dall vcpu_put(vcpu); 2981b0c632dbSHeiko Carstens return 0; 2982b0c632dbSHeiko Carstens } 2983b0c632dbSHeiko Carstens 2984b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, 2985b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 2986b0c632dbSHeiko Carstens { 2987bcdec41cSChristoffer Dall vcpu_load(vcpu); 2988bcdec41cSChristoffer Dall 298959674c1aSChristian Borntraeger memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs)); 2990b0c632dbSHeiko Carstens memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs)); 2991bcdec41cSChristoffer Dall 2992bcdec41cSChristoffer Dall vcpu_put(vcpu); 2993b0c632dbSHeiko Carstens return 0; 2994b0c632dbSHeiko Carstens } 2995b0c632dbSHeiko Carstens 2996b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 2997b0c632dbSHeiko Carstens { 29986a96bc7fSChristoffer Dall int ret = 0; 29996a96bc7fSChristoffer Dall 30006a96bc7fSChristoffer Dall vcpu_load(vcpu); 30016a96bc7fSChristoffer Dall 30026a96bc7fSChristoffer Dall if (test_fp_ctl(fpu->fpc)) { 30036a96bc7fSChristoffer Dall ret = -EINVAL; 30046a96bc7fSChristoffer Dall goto out; 30056a96bc7fSChristoffer Dall } 3006e1788bb9SChristian Borntraeger vcpu->run->s.regs.fpc = fpu->fpc; 30079abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) 3008a7d4b8f2SDavid Hildenbrand convert_fp_to_vx((__vector128 *) vcpu->run->s.regs.vrs, 3009a7d4b8f2SDavid Hildenbrand (freg_t *) fpu->fprs); 30109abc2a08SDavid Hildenbrand else 3011a7d4b8f2SDavid Hildenbrand memcpy(vcpu->run->s.regs.fprs, &fpu->fprs, sizeof(fpu->fprs)); 30126a96bc7fSChristoffer Dall 30136a96bc7fSChristoffer Dall out: 30146a96bc7fSChristoffer Dall vcpu_put(vcpu); 30156a96bc7fSChristoffer Dall return ret; 3016b0c632dbSHeiko Carstens } 3017b0c632dbSHeiko Carstens 3018b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 3019b0c632dbSHeiko Carstens { 30201393123eSChristoffer Dall vcpu_load(vcpu); 30211393123eSChristoffer Dall 30229abc2a08SDavid Hildenbrand /* make sure we have the latest values */ 30239abc2a08SDavid Hildenbrand save_fpu_regs(); 30249abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) 3025a7d4b8f2SDavid Hildenbrand convert_vx_to_fp((freg_t *) fpu->fprs, 3026a7d4b8f2SDavid Hildenbrand (__vector128 *) vcpu->run->s.regs.vrs); 30279abc2a08SDavid Hildenbrand else 3028a7d4b8f2SDavid Hildenbrand memcpy(fpu->fprs, vcpu->run->s.regs.fprs, sizeof(fpu->fprs)); 3029e1788bb9SChristian Borntraeger fpu->fpc = vcpu->run->s.regs.fpc; 30301393123eSChristoffer Dall 30311393123eSChristoffer Dall vcpu_put(vcpu); 3032b0c632dbSHeiko Carstens return 0; 3033b0c632dbSHeiko Carstens } 3034b0c632dbSHeiko Carstens 3035b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw) 3036b0c632dbSHeiko Carstens { 3037b0c632dbSHeiko Carstens int rc = 0; 3038b0c632dbSHeiko Carstens 30397a42fdc2SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 3040b0c632dbSHeiko Carstens rc = -EBUSY; 3041d7b0b5ebSCarsten Otte else { 3042d7b0b5ebSCarsten Otte vcpu->run->psw_mask = psw.mask; 3043d7b0b5ebSCarsten Otte vcpu->run->psw_addr = psw.addr; 3044d7b0b5ebSCarsten Otte } 3045b0c632dbSHeiko Carstens return rc; 3046b0c632dbSHeiko Carstens } 3047b0c632dbSHeiko Carstens 3048b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, 3049b0c632dbSHeiko Carstens struct kvm_translation *tr) 3050b0c632dbSHeiko Carstens { 3051b0c632dbSHeiko Carstens return -EINVAL; /* not implemented yet */ 3052b0c632dbSHeiko Carstens } 3053b0c632dbSHeiko Carstens 305427291e21SDavid Hildenbrand #define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \ 305527291e21SDavid Hildenbrand KVM_GUESTDBG_USE_HW_BP | \ 305627291e21SDavid Hildenbrand KVM_GUESTDBG_ENABLE) 305727291e21SDavid Hildenbrand 3058d0bfb940SJan Kiszka int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 3059d0bfb940SJan Kiszka struct kvm_guest_debug *dbg) 3060b0c632dbSHeiko Carstens { 306127291e21SDavid Hildenbrand int rc = 0; 306227291e21SDavid Hildenbrand 306366b56562SChristoffer Dall vcpu_load(vcpu); 306466b56562SChristoffer Dall 306527291e21SDavid Hildenbrand vcpu->guest_debug = 0; 306627291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 306727291e21SDavid Hildenbrand 306866b56562SChristoffer Dall if (dbg->control & ~VALID_GUESTDBG_FLAGS) { 306966b56562SChristoffer Dall rc = -EINVAL; 307066b56562SChristoffer Dall goto out; 307166b56562SChristoffer Dall } 307266b56562SChristoffer Dall if (!sclp.has_gpere) { 307366b56562SChristoffer Dall rc = -EINVAL; 307466b56562SChristoffer Dall goto out; 307566b56562SChristoffer Dall } 307627291e21SDavid Hildenbrand 307727291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_ENABLE) { 307827291e21SDavid Hildenbrand vcpu->guest_debug = dbg->control; 307927291e21SDavid Hildenbrand /* enforce guest PER */ 3080ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_P); 308127291e21SDavid Hildenbrand 308227291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_USE_HW_BP) 308327291e21SDavid Hildenbrand rc = kvm_s390_import_bp_data(vcpu, dbg); 308427291e21SDavid Hildenbrand } else { 30859daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_P); 308627291e21SDavid Hildenbrand vcpu->arch.guestdbg.last_bp = 0; 308727291e21SDavid Hildenbrand } 308827291e21SDavid Hildenbrand 308927291e21SDavid Hildenbrand if (rc) { 309027291e21SDavid Hildenbrand vcpu->guest_debug = 0; 309127291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 30929daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_P); 309327291e21SDavid Hildenbrand } 309427291e21SDavid Hildenbrand 309566b56562SChristoffer Dall out: 309666b56562SChristoffer Dall vcpu_put(vcpu); 309727291e21SDavid Hildenbrand return rc; 3098b0c632dbSHeiko Carstens } 3099b0c632dbSHeiko Carstens 310062d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 310162d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 310262d9f0dbSMarcelo Tosatti { 3103fd232561SChristoffer Dall int ret; 3104fd232561SChristoffer Dall 3105fd232561SChristoffer Dall vcpu_load(vcpu); 3106fd232561SChristoffer Dall 31076352e4d2SDavid Hildenbrand /* CHECK_STOP and LOAD are not supported yet */ 3108fd232561SChristoffer Dall ret = is_vcpu_stopped(vcpu) ? KVM_MP_STATE_STOPPED : 31096352e4d2SDavid Hildenbrand KVM_MP_STATE_OPERATING; 3110fd232561SChristoffer Dall 3111fd232561SChristoffer Dall vcpu_put(vcpu); 3112fd232561SChristoffer Dall return ret; 311362d9f0dbSMarcelo Tosatti } 311462d9f0dbSMarcelo Tosatti 311562d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 311662d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 311762d9f0dbSMarcelo Tosatti { 31186352e4d2SDavid Hildenbrand int rc = 0; 31196352e4d2SDavid Hildenbrand 3120e83dff5eSChristoffer Dall vcpu_load(vcpu); 3121e83dff5eSChristoffer Dall 31226352e4d2SDavid Hildenbrand /* user space knows about this interface - let it control the state */ 31236352e4d2SDavid Hildenbrand vcpu->kvm->arch.user_cpu_state_ctrl = 1; 31246352e4d2SDavid Hildenbrand 31256352e4d2SDavid Hildenbrand switch (mp_state->mp_state) { 31266352e4d2SDavid Hildenbrand case KVM_MP_STATE_STOPPED: 31276352e4d2SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 31286352e4d2SDavid Hildenbrand break; 31296352e4d2SDavid Hildenbrand case KVM_MP_STATE_OPERATING: 31306352e4d2SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 31316352e4d2SDavid Hildenbrand break; 31326352e4d2SDavid Hildenbrand case KVM_MP_STATE_LOAD: 31336352e4d2SDavid Hildenbrand case KVM_MP_STATE_CHECK_STOP: 31346352e4d2SDavid Hildenbrand /* fall through - CHECK_STOP and LOAD are not supported yet */ 31356352e4d2SDavid Hildenbrand default: 31366352e4d2SDavid Hildenbrand rc = -ENXIO; 31376352e4d2SDavid Hildenbrand } 31386352e4d2SDavid Hildenbrand 3139e83dff5eSChristoffer Dall vcpu_put(vcpu); 31406352e4d2SDavid Hildenbrand return rc; 314162d9f0dbSMarcelo Tosatti } 314262d9f0dbSMarcelo Tosatti 31438ad35755SDavid Hildenbrand static bool ibs_enabled(struct kvm_vcpu *vcpu) 31448ad35755SDavid Hildenbrand { 31458d5fb0dcSDavid Hildenbrand return kvm_s390_test_cpuflags(vcpu, CPUSTAT_IBS); 31468ad35755SDavid Hildenbrand } 31478ad35755SDavid Hildenbrand 31482c70fe44SChristian Borntraeger static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu) 31492c70fe44SChristian Borntraeger { 31508ad35755SDavid Hildenbrand retry: 31518e236546SChristian Borntraeger kvm_s390_vcpu_request_handled(vcpu); 31522fa6e1e1SRadim Krčmář if (!kvm_request_pending(vcpu)) 3153586b7ccdSChristian Borntraeger return 0; 31542c70fe44SChristian Borntraeger /* 31552c70fe44SChristian Borntraeger * We use MMU_RELOAD just to re-arm the ipte notifier for the 3156b2d73b2aSMartin Schwidefsky * guest prefix page. gmap_mprotect_notify will wait on the ptl lock. 31572c70fe44SChristian Borntraeger * This ensures that the ipte instruction for this request has 31582c70fe44SChristian Borntraeger * already finished. We might race against a second unmapper that 31592c70fe44SChristian Borntraeger * wants to set the blocking bit. Lets just retry the request loop. 31602c70fe44SChristian Borntraeger */ 31618ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) { 31622c70fe44SChristian Borntraeger int rc; 3163b2d73b2aSMartin Schwidefsky rc = gmap_mprotect_notify(vcpu->arch.gmap, 3164fda902cbSMichael Mueller kvm_s390_get_prefix(vcpu), 3165b2d73b2aSMartin Schwidefsky PAGE_SIZE * 2, PROT_WRITE); 3166aca411a4SJulius Niedworok if (rc) { 3167aca411a4SJulius Niedworok kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu); 31682c70fe44SChristian Borntraeger return rc; 3169aca411a4SJulius Niedworok } 31708ad35755SDavid Hildenbrand goto retry; 31712c70fe44SChristian Borntraeger } 31728ad35755SDavid Hildenbrand 3173d3d692c8SDavid Hildenbrand if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu)) { 3174d3d692c8SDavid Hildenbrand vcpu->arch.sie_block->ihcpu = 0xffff; 3175d3d692c8SDavid Hildenbrand goto retry; 3176d3d692c8SDavid Hildenbrand } 3177d3d692c8SDavid Hildenbrand 31788ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu)) { 31798ad35755SDavid Hildenbrand if (!ibs_enabled(vcpu)) { 31808ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 1); 3181ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_IBS); 31828ad35755SDavid Hildenbrand } 31838ad35755SDavid Hildenbrand goto retry; 31848ad35755SDavid Hildenbrand } 31858ad35755SDavid Hildenbrand 31868ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu)) { 31878ad35755SDavid Hildenbrand if (ibs_enabled(vcpu)) { 31888ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 0); 31899daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_IBS); 31908ad35755SDavid Hildenbrand } 31918ad35755SDavid Hildenbrand goto retry; 31928ad35755SDavid Hildenbrand } 31938ad35755SDavid Hildenbrand 31946502a34cSDavid Hildenbrand if (kvm_check_request(KVM_REQ_ICPT_OPEREXC, vcpu)) { 31956502a34cSDavid Hildenbrand vcpu->arch.sie_block->ictl |= ICTL_OPEREXC; 31966502a34cSDavid Hildenbrand goto retry; 31976502a34cSDavid Hildenbrand } 31986502a34cSDavid Hildenbrand 3199190df4a2SClaudio Imbrenda if (kvm_check_request(KVM_REQ_START_MIGRATION, vcpu)) { 3200190df4a2SClaudio Imbrenda /* 3201c9f0a2b8SJanosch Frank * Disable CMM virtualization; we will emulate the ESSA 3202190df4a2SClaudio Imbrenda * instruction manually, in order to provide additional 3203190df4a2SClaudio Imbrenda * functionalities needed for live migration. 3204190df4a2SClaudio Imbrenda */ 3205190df4a2SClaudio Imbrenda vcpu->arch.sie_block->ecb2 &= ~ECB2_CMMA; 3206190df4a2SClaudio Imbrenda goto retry; 3207190df4a2SClaudio Imbrenda } 3208190df4a2SClaudio Imbrenda 3209190df4a2SClaudio Imbrenda if (kvm_check_request(KVM_REQ_STOP_MIGRATION, vcpu)) { 3210190df4a2SClaudio Imbrenda /* 3211c9f0a2b8SJanosch Frank * Re-enable CMM virtualization if CMMA is available and 3212c9f0a2b8SJanosch Frank * CMM has been used. 3213190df4a2SClaudio Imbrenda */ 3214190df4a2SClaudio Imbrenda if ((vcpu->kvm->arch.use_cmma) && 3215c9f0a2b8SJanosch Frank (vcpu->kvm->mm->context.uses_cmm)) 3216190df4a2SClaudio Imbrenda vcpu->arch.sie_block->ecb2 |= ECB2_CMMA; 3217190df4a2SClaudio Imbrenda goto retry; 3218190df4a2SClaudio Imbrenda } 3219190df4a2SClaudio Imbrenda 32200759d068SDavid Hildenbrand /* nothing to do, just clear the request */ 322172875d8aSRadim Krčmář kvm_clear_request(KVM_REQ_UNHALT, vcpu); 32223194cdb7SDavid Hildenbrand /* we left the vsie handler, nothing to do, just clear the request */ 32233194cdb7SDavid Hildenbrand kvm_clear_request(KVM_REQ_VSIE_RESTART, vcpu); 32240759d068SDavid Hildenbrand 32252c70fe44SChristian Borntraeger return 0; 32262c70fe44SChristian Borntraeger } 32272c70fe44SChristian Borntraeger 32280e7def5fSDavid Hildenbrand void kvm_s390_set_tod_clock(struct kvm *kvm, 32298fa1696eSCollin L. Walling const struct kvm_s390_vm_tod_clock *gtod) 32308fa1696eSCollin L. Walling { 32318fa1696eSCollin L. Walling struct kvm_vcpu *vcpu; 32328fa1696eSCollin L. Walling struct kvm_s390_tod_clock_ext htod; 32338fa1696eSCollin L. Walling int i; 32348fa1696eSCollin L. Walling 32358fa1696eSCollin L. Walling mutex_lock(&kvm->lock); 32368fa1696eSCollin L. Walling preempt_disable(); 32378fa1696eSCollin L. Walling 32388fa1696eSCollin L. Walling get_tod_clock_ext((char *)&htod); 32398fa1696eSCollin L. Walling 32408fa1696eSCollin L. Walling kvm->arch.epoch = gtod->tod - htod.tod; 32410e7def5fSDavid Hildenbrand kvm->arch.epdx = 0; 32420e7def5fSDavid Hildenbrand if (test_kvm_facility(kvm, 139)) { 32438fa1696eSCollin L. Walling kvm->arch.epdx = gtod->epoch_idx - htod.epoch_idx; 32448fa1696eSCollin L. Walling if (kvm->arch.epoch > gtod->tod) 32458fa1696eSCollin L. Walling kvm->arch.epdx -= 1; 32460e7def5fSDavid Hildenbrand } 32478fa1696eSCollin L. Walling 32488fa1696eSCollin L. Walling kvm_s390_vcpu_block_all(kvm); 32498fa1696eSCollin L. Walling kvm_for_each_vcpu(i, vcpu, kvm) { 32508fa1696eSCollin L. Walling vcpu->arch.sie_block->epoch = kvm->arch.epoch; 32518fa1696eSCollin L. Walling vcpu->arch.sie_block->epdx = kvm->arch.epdx; 32528fa1696eSCollin L. Walling } 32538fa1696eSCollin L. Walling 32548fa1696eSCollin L. Walling kvm_s390_vcpu_unblock_all(kvm); 32558fa1696eSCollin L. Walling preempt_enable(); 32568fa1696eSCollin L. Walling mutex_unlock(&kvm->lock); 32578fa1696eSCollin L. Walling } 32588fa1696eSCollin L. Walling 3259fa576c58SThomas Huth /** 3260fa576c58SThomas Huth * kvm_arch_fault_in_page - fault-in guest page if necessary 3261fa576c58SThomas Huth * @vcpu: The corresponding virtual cpu 3262fa576c58SThomas Huth * @gpa: Guest physical address 3263fa576c58SThomas Huth * @writable: Whether the page should be writable or not 3264fa576c58SThomas Huth * 3265fa576c58SThomas Huth * Make sure that a guest page has been faulted-in on the host. 3266fa576c58SThomas Huth * 3267fa576c58SThomas Huth * Return: Zero on success, negative error code otherwise. 3268fa576c58SThomas Huth */ 3269fa576c58SThomas Huth long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable) 327024eb3a82SDominik Dingel { 3271527e30b4SMartin Schwidefsky return gmap_fault(vcpu->arch.gmap, gpa, 3272527e30b4SMartin Schwidefsky writable ? FAULT_FLAG_WRITE : 0); 327324eb3a82SDominik Dingel } 327424eb3a82SDominik Dingel 32753c038e6bSDominik Dingel static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token, 32763c038e6bSDominik Dingel unsigned long token) 32773c038e6bSDominik Dingel { 32783c038e6bSDominik Dingel struct kvm_s390_interrupt inti; 3279383d0b05SJens Freimann struct kvm_s390_irq irq; 32803c038e6bSDominik Dingel 32813c038e6bSDominik Dingel if (start_token) { 3282383d0b05SJens Freimann irq.u.ext.ext_params2 = token; 3283383d0b05SJens Freimann irq.type = KVM_S390_INT_PFAULT_INIT; 3284383d0b05SJens Freimann WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &irq)); 32853c038e6bSDominik Dingel } else { 32863c038e6bSDominik Dingel inti.type = KVM_S390_INT_PFAULT_DONE; 3287383d0b05SJens Freimann inti.parm64 = token; 32883c038e6bSDominik Dingel WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti)); 32893c038e6bSDominik Dingel } 32903c038e6bSDominik Dingel } 32913c038e6bSDominik Dingel 32923c038e6bSDominik Dingel void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu, 32933c038e6bSDominik Dingel struct kvm_async_pf *work) 32943c038e6bSDominik Dingel { 32953c038e6bSDominik Dingel trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token); 32963c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token); 32973c038e6bSDominik Dingel } 32983c038e6bSDominik Dingel 32993c038e6bSDominik Dingel void kvm_arch_async_page_present(struct kvm_vcpu *vcpu, 33003c038e6bSDominik Dingel struct kvm_async_pf *work) 33013c038e6bSDominik Dingel { 33023c038e6bSDominik Dingel trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token); 33033c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token); 33043c038e6bSDominik Dingel } 33053c038e6bSDominik Dingel 33063c038e6bSDominik Dingel void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu, 33073c038e6bSDominik Dingel struct kvm_async_pf *work) 33083c038e6bSDominik Dingel { 33093c038e6bSDominik Dingel /* s390 will always inject the page directly */ 33103c038e6bSDominik Dingel } 33113c038e6bSDominik Dingel 33123c038e6bSDominik Dingel bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu) 33133c038e6bSDominik Dingel { 33143c038e6bSDominik Dingel /* 33153c038e6bSDominik Dingel * s390 will always inject the page directly, 33163c038e6bSDominik Dingel * but we still want check_async_completion to cleanup 33173c038e6bSDominik Dingel */ 33183c038e6bSDominik Dingel return true; 33193c038e6bSDominik Dingel } 33203c038e6bSDominik Dingel 33213c038e6bSDominik Dingel static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu) 33223c038e6bSDominik Dingel { 33233c038e6bSDominik Dingel hva_t hva; 33243c038e6bSDominik Dingel struct kvm_arch_async_pf arch; 33253c038e6bSDominik Dingel int rc; 33263c038e6bSDominik Dingel 33273c038e6bSDominik Dingel if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 33283c038e6bSDominik Dingel return 0; 33293c038e6bSDominik Dingel if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) != 33303c038e6bSDominik Dingel vcpu->arch.pfault_compare) 33313c038e6bSDominik Dingel return 0; 33323c038e6bSDominik Dingel if (psw_extint_disabled(vcpu)) 33333c038e6bSDominik Dingel return 0; 33349a022067SDavid Hildenbrand if (kvm_s390_vcpu_has_irq(vcpu, 0)) 33353c038e6bSDominik Dingel return 0; 3336b9224cd7SDavid Hildenbrand if (!(vcpu->arch.sie_block->gcr[0] & CR0_SERVICE_SIGNAL_SUBMASK)) 33373c038e6bSDominik Dingel return 0; 33383c038e6bSDominik Dingel if (!vcpu->arch.gmap->pfault_enabled) 33393c038e6bSDominik Dingel return 0; 33403c038e6bSDominik Dingel 334181480cc1SHeiko Carstens hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(current->thread.gmap_addr)); 334281480cc1SHeiko Carstens hva += current->thread.gmap_addr & ~PAGE_MASK; 334381480cc1SHeiko Carstens if (read_guest_real(vcpu, vcpu->arch.pfault_token, &arch.pfault_token, 8)) 33443c038e6bSDominik Dingel return 0; 33453c038e6bSDominik Dingel 33463c038e6bSDominik Dingel rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch); 33473c038e6bSDominik Dingel return rc; 33483c038e6bSDominik Dingel } 33493c038e6bSDominik Dingel 33503fb4c40fSThomas Huth static int vcpu_pre_run(struct kvm_vcpu *vcpu) 3351b0c632dbSHeiko Carstens { 33523fb4c40fSThomas Huth int rc, cpuflags; 3353e168bf8dSCarsten Otte 33543c038e6bSDominik Dingel /* 33553c038e6bSDominik Dingel * On s390 notifications for arriving pages will be delivered directly 33563c038e6bSDominik Dingel * to the guest but the house keeping for completed pfaults is 33573c038e6bSDominik Dingel * handled outside the worker. 33583c038e6bSDominik Dingel */ 33593c038e6bSDominik Dingel kvm_check_async_pf_completion(vcpu); 33603c038e6bSDominik Dingel 33617ec7c8c7SChristian Borntraeger vcpu->arch.sie_block->gg14 = vcpu->run->s.regs.gprs[14]; 33627ec7c8c7SChristian Borntraeger vcpu->arch.sie_block->gg15 = vcpu->run->s.regs.gprs[15]; 3363b0c632dbSHeiko Carstens 3364b0c632dbSHeiko Carstens if (need_resched()) 3365b0c632dbSHeiko Carstens schedule(); 3366b0c632dbSHeiko Carstens 3367d3a73acbSMartin Schwidefsky if (test_cpu_flag(CIF_MCCK_PENDING)) 336871cde587SChristian Borntraeger s390_handle_mcck(); 336971cde587SChristian Borntraeger 337079395031SJens Freimann if (!kvm_is_ucontrol(vcpu->kvm)) { 337179395031SJens Freimann rc = kvm_s390_deliver_pending_interrupts(vcpu); 337279395031SJens Freimann if (rc) 337379395031SJens Freimann return rc; 337479395031SJens Freimann } 33750ff31867SCarsten Otte 33762c70fe44SChristian Borntraeger rc = kvm_s390_handle_requests(vcpu); 33772c70fe44SChristian Borntraeger if (rc) 33782c70fe44SChristian Borntraeger return rc; 33792c70fe44SChristian Borntraeger 338027291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) { 338127291e21SDavid Hildenbrand kvm_s390_backup_guest_per_regs(vcpu); 338227291e21SDavid Hildenbrand kvm_s390_patch_guest_per_regs(vcpu); 338327291e21SDavid Hildenbrand } 338427291e21SDavid Hildenbrand 3385b0c632dbSHeiko Carstens vcpu->arch.sie_block->icptcode = 0; 33863fb4c40fSThomas Huth cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags); 33873fb4c40fSThomas Huth VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags); 33883fb4c40fSThomas Huth trace_kvm_s390_sie_enter(vcpu, cpuflags); 33892b29a9fdSDominik Dingel 33903fb4c40fSThomas Huth return 0; 33913fb4c40fSThomas Huth } 33923fb4c40fSThomas Huth 3393492d8642SThomas Huth static int vcpu_post_run_fault_in_sie(struct kvm_vcpu *vcpu) 3394492d8642SThomas Huth { 339556317920SDavid Hildenbrand struct kvm_s390_pgm_info pgm_info = { 339656317920SDavid Hildenbrand .code = PGM_ADDRESSING, 339756317920SDavid Hildenbrand }; 339856317920SDavid Hildenbrand u8 opcode, ilen; 3399492d8642SThomas Huth int rc; 3400492d8642SThomas Huth 3401492d8642SThomas Huth VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction"); 3402492d8642SThomas Huth trace_kvm_s390_sie_fault(vcpu); 3403492d8642SThomas Huth 3404492d8642SThomas Huth /* 3405492d8642SThomas Huth * We want to inject an addressing exception, which is defined as a 3406492d8642SThomas Huth * suppressing or terminating exception. However, since we came here 3407492d8642SThomas Huth * by a DAT access exception, the PSW still points to the faulting 3408492d8642SThomas Huth * instruction since DAT exceptions are nullifying. So we've got 3409492d8642SThomas Huth * to look up the current opcode to get the length of the instruction 3410492d8642SThomas Huth * to be able to forward the PSW. 3411492d8642SThomas Huth */ 34123fa8cad7SDavid Hildenbrand rc = read_guest_instr(vcpu, vcpu->arch.sie_block->gpsw.addr, &opcode, 1); 341356317920SDavid Hildenbrand ilen = insn_length(opcode); 34149b0d721aSDavid Hildenbrand if (rc < 0) { 34159b0d721aSDavid Hildenbrand return rc; 34169b0d721aSDavid Hildenbrand } else if (rc) { 34179b0d721aSDavid Hildenbrand /* Instruction-Fetching Exceptions - we can't detect the ilen. 34189b0d721aSDavid Hildenbrand * Forward by arbitrary ilc, injection will take care of 34199b0d721aSDavid Hildenbrand * nullification if necessary. 34209b0d721aSDavid Hildenbrand */ 34219b0d721aSDavid Hildenbrand pgm_info = vcpu->arch.pgm; 34229b0d721aSDavid Hildenbrand ilen = 4; 34239b0d721aSDavid Hildenbrand } 342456317920SDavid Hildenbrand pgm_info.flags = ilen | KVM_S390_PGM_FLAGS_ILC_VALID; 342556317920SDavid Hildenbrand kvm_s390_forward_psw(vcpu, ilen); 342656317920SDavid Hildenbrand return kvm_s390_inject_prog_irq(vcpu, &pgm_info); 3427492d8642SThomas Huth } 3428492d8642SThomas Huth 34293fb4c40fSThomas Huth static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason) 34303fb4c40fSThomas Huth { 34314d62fcc0SQingFeng Hao struct mcck_volatile_info *mcck_info; 34324d62fcc0SQingFeng Hao struct sie_page *sie_page; 34334d62fcc0SQingFeng Hao 34342b29a9fdSDominik Dingel VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", 34352b29a9fdSDominik Dingel vcpu->arch.sie_block->icptcode); 34362b29a9fdSDominik Dingel trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode); 34372b29a9fdSDominik Dingel 343827291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) 343927291e21SDavid Hildenbrand kvm_s390_restore_guest_per_regs(vcpu); 344027291e21SDavid Hildenbrand 34417ec7c8c7SChristian Borntraeger vcpu->run->s.regs.gprs[14] = vcpu->arch.sie_block->gg14; 34427ec7c8c7SChristian Borntraeger vcpu->run->s.regs.gprs[15] = vcpu->arch.sie_block->gg15; 344371f116bfSDavid Hildenbrand 34444d62fcc0SQingFeng Hao if (exit_reason == -EINTR) { 34454d62fcc0SQingFeng Hao VCPU_EVENT(vcpu, 3, "%s", "machine check"); 34464d62fcc0SQingFeng Hao sie_page = container_of(vcpu->arch.sie_block, 34474d62fcc0SQingFeng Hao struct sie_page, sie_block); 34484d62fcc0SQingFeng Hao mcck_info = &sie_page->mcck_info; 34494d62fcc0SQingFeng Hao kvm_s390_reinject_machine_check(vcpu, mcck_info); 34504d62fcc0SQingFeng Hao return 0; 34514d62fcc0SQingFeng Hao } 34524d62fcc0SQingFeng Hao 345371f116bfSDavid Hildenbrand if (vcpu->arch.sie_block->icptcode > 0) { 345471f116bfSDavid Hildenbrand int rc = kvm_handle_sie_intercept(vcpu); 345571f116bfSDavid Hildenbrand 345671f116bfSDavid Hildenbrand if (rc != -EOPNOTSUPP) 345771f116bfSDavid Hildenbrand return rc; 345871f116bfSDavid Hildenbrand vcpu->run->exit_reason = KVM_EXIT_S390_SIEIC; 345971f116bfSDavid Hildenbrand vcpu->run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode; 346071f116bfSDavid Hildenbrand vcpu->run->s390_sieic.ipa = vcpu->arch.sie_block->ipa; 346171f116bfSDavid Hildenbrand vcpu->run->s390_sieic.ipb = vcpu->arch.sie_block->ipb; 346271f116bfSDavid Hildenbrand return -EREMOTE; 346371f116bfSDavid Hildenbrand } else if (exit_reason != -EFAULT) { 346471f116bfSDavid Hildenbrand vcpu->stat.exit_null++; 346571f116bfSDavid Hildenbrand return 0; 3466210b1607SThomas Huth } else if (kvm_is_ucontrol(vcpu->kvm)) { 3467210b1607SThomas Huth vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL; 3468210b1607SThomas Huth vcpu->run->s390_ucontrol.trans_exc_code = 3469210b1607SThomas Huth current->thread.gmap_addr; 3470210b1607SThomas Huth vcpu->run->s390_ucontrol.pgm_code = 0x10; 347171f116bfSDavid Hildenbrand return -EREMOTE; 347224eb3a82SDominik Dingel } else if (current->thread.gmap_pfault) { 34733c038e6bSDominik Dingel trace_kvm_s390_major_guest_pfault(vcpu); 347424eb3a82SDominik Dingel current->thread.gmap_pfault = 0; 347571f116bfSDavid Hildenbrand if (kvm_arch_setup_async_pf(vcpu)) 347671f116bfSDavid Hildenbrand return 0; 347771f116bfSDavid Hildenbrand return kvm_arch_fault_in_page(vcpu, current->thread.gmap_addr, 1); 3478fa576c58SThomas Huth } 347971f116bfSDavid Hildenbrand return vcpu_post_run_fault_in_sie(vcpu); 34803fb4c40fSThomas Huth } 34813fb4c40fSThomas Huth 34823fb4c40fSThomas Huth static int __vcpu_run(struct kvm_vcpu *vcpu) 34833fb4c40fSThomas Huth { 34843fb4c40fSThomas Huth int rc, exit_reason; 34853fb4c40fSThomas Huth 3486800c1065SThomas Huth /* 3487800c1065SThomas Huth * We try to hold kvm->srcu during most of vcpu_run (except when run- 3488800c1065SThomas Huth * ning the guest), so that memslots (and other stuff) are protected 3489800c1065SThomas Huth */ 3490800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 3491800c1065SThomas Huth 3492a76ccff6SThomas Huth do { 34933fb4c40fSThomas Huth rc = vcpu_pre_run(vcpu); 34943fb4c40fSThomas Huth if (rc) 3495a76ccff6SThomas Huth break; 34963fb4c40fSThomas Huth 3497800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 34983fb4c40fSThomas Huth /* 3499a76ccff6SThomas Huth * As PF_VCPU will be used in fault handler, between 3500a76ccff6SThomas Huth * guest_enter and guest_exit should be no uaccess. 35013fb4c40fSThomas Huth */ 35020097d12eSChristian Borntraeger local_irq_disable(); 35036edaa530SPaolo Bonzini guest_enter_irqoff(); 3504db0758b2SDavid Hildenbrand __disable_cpu_timer_accounting(vcpu); 35050097d12eSChristian Borntraeger local_irq_enable(); 3506a76ccff6SThomas Huth exit_reason = sie64a(vcpu->arch.sie_block, 3507a76ccff6SThomas Huth vcpu->run->s.regs.gprs); 35080097d12eSChristian Borntraeger local_irq_disable(); 3509db0758b2SDavid Hildenbrand __enable_cpu_timer_accounting(vcpu); 35106edaa530SPaolo Bonzini guest_exit_irqoff(); 35110097d12eSChristian Borntraeger local_irq_enable(); 3512800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 35133fb4c40fSThomas Huth 35143fb4c40fSThomas Huth rc = vcpu_post_run(vcpu, exit_reason); 351527291e21SDavid Hildenbrand } while (!signal_pending(current) && !guestdbg_exit_pending(vcpu) && !rc); 35163fb4c40fSThomas Huth 3517800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 3518e168bf8dSCarsten Otte return rc; 3519b0c632dbSHeiko Carstens } 3520b0c632dbSHeiko Carstens 3521b028ee3eSDavid Hildenbrand static void sync_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 3522b028ee3eSDavid Hildenbrand { 35234d5f2c04SChristian Borntraeger struct runtime_instr_cb *riccb; 35244e0b1ab7SFan Zhang struct gs_cb *gscb; 35254d5f2c04SChristian Borntraeger 35264d5f2c04SChristian Borntraeger riccb = (struct runtime_instr_cb *) &kvm_run->s.regs.riccb; 35274e0b1ab7SFan Zhang gscb = (struct gs_cb *) &kvm_run->s.regs.gscb; 3528b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask; 3529b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr; 3530b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) 3531b028ee3eSDavid Hildenbrand kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix); 3532b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) { 3533b028ee3eSDavid Hildenbrand memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128); 3534d3d692c8SDavid Hildenbrand /* some control register changes require a tlb flush */ 3535d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 3536b028ee3eSDavid Hildenbrand } 3537b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_ARCH0) { 35384287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, kvm_run->s.regs.cputm); 3539b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->ckc = kvm_run->s.regs.ckc; 3540b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->todpr = kvm_run->s.regs.todpr; 3541b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->pp = kvm_run->s.regs.pp; 3542b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gbea = kvm_run->s.regs.gbea; 3543b028ee3eSDavid Hildenbrand } 3544b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PFAULT) { 3545b028ee3eSDavid Hildenbrand vcpu->arch.pfault_token = kvm_run->s.regs.pft; 3546b028ee3eSDavid Hildenbrand vcpu->arch.pfault_select = kvm_run->s.regs.pfs; 3547b028ee3eSDavid Hildenbrand vcpu->arch.pfault_compare = kvm_run->s.regs.pfc; 35489fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 35499fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 3550b028ee3eSDavid Hildenbrand } 355180cd8763SFan Zhang /* 355280cd8763SFan Zhang * If userspace sets the riccb (e.g. after migration) to a valid state, 355380cd8763SFan Zhang * we should enable RI here instead of doing the lazy enablement. 355480cd8763SFan Zhang */ 355580cd8763SFan Zhang if ((kvm_run->kvm_dirty_regs & KVM_SYNC_RICCB) && 35564d5f2c04SChristian Borntraeger test_kvm_facility(vcpu->kvm, 64) && 3557bb59c2daSAlice Frosi riccb->v && 35580c9d8683SDavid Hildenbrand !(vcpu->arch.sie_block->ecb3 & ECB3_RI)) { 35594d5f2c04SChristian Borntraeger VCPU_EVENT(vcpu, 3, "%s", "ENABLE: RI (sync_regs)"); 35600c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb3 |= ECB3_RI; 356180cd8763SFan Zhang } 35624e0b1ab7SFan Zhang /* 35634e0b1ab7SFan Zhang * If userspace sets the gscb (e.g. after migration) to non-zero, 35644e0b1ab7SFan Zhang * we should enable GS here instead of doing the lazy enablement. 35654e0b1ab7SFan Zhang */ 35664e0b1ab7SFan Zhang if ((kvm_run->kvm_dirty_regs & KVM_SYNC_GSCB) && 35674e0b1ab7SFan Zhang test_kvm_facility(vcpu->kvm, 133) && 35684e0b1ab7SFan Zhang gscb->gssm && 35694e0b1ab7SFan Zhang !vcpu->arch.gs_enabled) { 35704e0b1ab7SFan Zhang VCPU_EVENT(vcpu, 3, "%s", "ENABLE: GS (sync_regs)"); 35714e0b1ab7SFan Zhang vcpu->arch.sie_block->ecb |= ECB_GS; 35724e0b1ab7SFan Zhang vcpu->arch.sie_block->ecd |= ECD_HOSTREGMGMT; 35734e0b1ab7SFan Zhang vcpu->arch.gs_enabled = 1; 357480cd8763SFan Zhang } 357535b3fde6SChristian Borntraeger if ((kvm_run->kvm_dirty_regs & KVM_SYNC_BPBC) && 357635b3fde6SChristian Borntraeger test_kvm_facility(vcpu->kvm, 82)) { 357735b3fde6SChristian Borntraeger vcpu->arch.sie_block->fpf &= ~FPF_BPBC; 357835b3fde6SChristian Borntraeger vcpu->arch.sie_block->fpf |= kvm_run->s.regs.bpbc ? FPF_BPBC : 0; 357935b3fde6SChristian Borntraeger } 358031d8b8d4SChristian Borntraeger save_access_regs(vcpu->arch.host_acrs); 358131d8b8d4SChristian Borntraeger restore_access_regs(vcpu->run->s.regs.acrs); 3582e1788bb9SChristian Borntraeger /* save host (userspace) fprs/vrs */ 3583e1788bb9SChristian Borntraeger save_fpu_regs(); 3584e1788bb9SChristian Borntraeger vcpu->arch.host_fpregs.fpc = current->thread.fpu.fpc; 3585e1788bb9SChristian Borntraeger vcpu->arch.host_fpregs.regs = current->thread.fpu.regs; 3586e1788bb9SChristian Borntraeger if (MACHINE_HAS_VX) 3587e1788bb9SChristian Borntraeger current->thread.fpu.regs = vcpu->run->s.regs.vrs; 3588e1788bb9SChristian Borntraeger else 3589e1788bb9SChristian Borntraeger current->thread.fpu.regs = vcpu->run->s.regs.fprs; 3590e1788bb9SChristian Borntraeger current->thread.fpu.fpc = vcpu->run->s.regs.fpc; 3591e1788bb9SChristian Borntraeger if (test_fp_ctl(current->thread.fpu.fpc)) 3592e1788bb9SChristian Borntraeger /* User space provided an invalid FPC, let's clear it */ 3593e1788bb9SChristian Borntraeger current->thread.fpu.fpc = 0; 35944e0b1ab7SFan Zhang if (MACHINE_HAS_GS) { 35954e0b1ab7SFan Zhang preempt_disable(); 35964e0b1ab7SFan Zhang __ctl_set_bit(2, 4); 35974e0b1ab7SFan Zhang if (current->thread.gs_cb) { 35984e0b1ab7SFan Zhang vcpu->arch.host_gscb = current->thread.gs_cb; 35994e0b1ab7SFan Zhang save_gs_cb(vcpu->arch.host_gscb); 36004e0b1ab7SFan Zhang } 36014e0b1ab7SFan Zhang if (vcpu->arch.gs_enabled) { 36024e0b1ab7SFan Zhang current->thread.gs_cb = (struct gs_cb *) 36034e0b1ab7SFan Zhang &vcpu->run->s.regs.gscb; 36044e0b1ab7SFan Zhang restore_gs_cb(current->thread.gs_cb); 36054e0b1ab7SFan Zhang } 36064e0b1ab7SFan Zhang preempt_enable(); 36074e0b1ab7SFan Zhang } 3608a3da7b4aSChristian Borntraeger /* SIE will load etoken directly from SDNX and therefore kvm_run */ 360980cd8763SFan Zhang 3610b028ee3eSDavid Hildenbrand kvm_run->kvm_dirty_regs = 0; 3611b028ee3eSDavid Hildenbrand } 3612b028ee3eSDavid Hildenbrand 3613b028ee3eSDavid Hildenbrand static void store_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 3614b028ee3eSDavid Hildenbrand { 3615b028ee3eSDavid Hildenbrand kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask; 3616b028ee3eSDavid Hildenbrand kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr; 3617b028ee3eSDavid Hildenbrand kvm_run->s.regs.prefix = kvm_s390_get_prefix(vcpu); 3618b028ee3eSDavid Hildenbrand memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128); 36194287f247SDavid Hildenbrand kvm_run->s.regs.cputm = kvm_s390_get_cpu_timer(vcpu); 3620b028ee3eSDavid Hildenbrand kvm_run->s.regs.ckc = vcpu->arch.sie_block->ckc; 3621b028ee3eSDavid Hildenbrand kvm_run->s.regs.todpr = vcpu->arch.sie_block->todpr; 3622b028ee3eSDavid Hildenbrand kvm_run->s.regs.pp = vcpu->arch.sie_block->pp; 3623b028ee3eSDavid Hildenbrand kvm_run->s.regs.gbea = vcpu->arch.sie_block->gbea; 3624b028ee3eSDavid Hildenbrand kvm_run->s.regs.pft = vcpu->arch.pfault_token; 3625b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfs = vcpu->arch.pfault_select; 3626b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfc = vcpu->arch.pfault_compare; 362735b3fde6SChristian Borntraeger kvm_run->s.regs.bpbc = (vcpu->arch.sie_block->fpf & FPF_BPBC) == FPF_BPBC; 362831d8b8d4SChristian Borntraeger save_access_regs(vcpu->run->s.regs.acrs); 362931d8b8d4SChristian Borntraeger restore_access_regs(vcpu->arch.host_acrs); 3630e1788bb9SChristian Borntraeger /* Save guest register state */ 3631e1788bb9SChristian Borntraeger save_fpu_regs(); 3632e1788bb9SChristian Borntraeger vcpu->run->s.regs.fpc = current->thread.fpu.fpc; 3633e1788bb9SChristian Borntraeger /* Restore will be done lazily at return */ 3634e1788bb9SChristian Borntraeger current->thread.fpu.fpc = vcpu->arch.host_fpregs.fpc; 3635e1788bb9SChristian Borntraeger current->thread.fpu.regs = vcpu->arch.host_fpregs.regs; 36364e0b1ab7SFan Zhang if (MACHINE_HAS_GS) { 36374e0b1ab7SFan Zhang __ctl_set_bit(2, 4); 36384e0b1ab7SFan Zhang if (vcpu->arch.gs_enabled) 36394e0b1ab7SFan Zhang save_gs_cb(current->thread.gs_cb); 36404e0b1ab7SFan Zhang preempt_disable(); 36414e0b1ab7SFan Zhang current->thread.gs_cb = vcpu->arch.host_gscb; 36424e0b1ab7SFan Zhang restore_gs_cb(vcpu->arch.host_gscb); 36434e0b1ab7SFan Zhang preempt_enable(); 36444e0b1ab7SFan Zhang if (!vcpu->arch.host_gscb) 36454e0b1ab7SFan Zhang __ctl_clear_bit(2, 4); 36464e0b1ab7SFan Zhang vcpu->arch.host_gscb = NULL; 36474e0b1ab7SFan Zhang } 3648a3da7b4aSChristian Borntraeger /* SIE will save etoken directly into SDNX and therefore kvm_run */ 3649b028ee3eSDavid Hildenbrand } 3650b028ee3eSDavid Hildenbrand 3651b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 3652b0c632dbSHeiko Carstens { 36538f2abe6aSChristian Borntraeger int rc; 3654b0c632dbSHeiko Carstens 3655460df4c1SPaolo Bonzini if (kvm_run->immediate_exit) 3656460df4c1SPaolo Bonzini return -EINTR; 3657460df4c1SPaolo Bonzini 3658accb757dSChristoffer Dall vcpu_load(vcpu); 3659accb757dSChristoffer Dall 366027291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu)) { 366127291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 3662accb757dSChristoffer Dall rc = 0; 3663accb757dSChristoffer Dall goto out; 366427291e21SDavid Hildenbrand } 366527291e21SDavid Hildenbrand 366620b7035cSJan H. Schönherr kvm_sigset_activate(vcpu); 3667b0c632dbSHeiko Carstens 36686352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) { 36696852d7b6SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 36706352e4d2SDavid Hildenbrand } else if (is_vcpu_stopped(vcpu)) { 3671ea2cdd27SDavid Hildenbrand pr_err_ratelimited("can't run stopped vcpu %d\n", 36726352e4d2SDavid Hildenbrand vcpu->vcpu_id); 3673accb757dSChristoffer Dall rc = -EINVAL; 3674accb757dSChristoffer Dall goto out; 36756352e4d2SDavid Hildenbrand } 3676b0c632dbSHeiko Carstens 3677b028ee3eSDavid Hildenbrand sync_regs(vcpu, kvm_run); 3678db0758b2SDavid Hildenbrand enable_cpu_timer_accounting(vcpu); 3679d7b0b5ebSCarsten Otte 3680dab4079dSHeiko Carstens might_fault(); 3681e168bf8dSCarsten Otte rc = __vcpu_run(vcpu); 36829ace903dSChristian Ehrhardt 3683b1d16c49SChristian Ehrhardt if (signal_pending(current) && !rc) { 3684b1d16c49SChristian Ehrhardt kvm_run->exit_reason = KVM_EXIT_INTR; 36858f2abe6aSChristian Borntraeger rc = -EINTR; 3686b1d16c49SChristian Ehrhardt } 36878f2abe6aSChristian Borntraeger 368827291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu) && !rc) { 368927291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 369027291e21SDavid Hildenbrand rc = 0; 369127291e21SDavid Hildenbrand } 369227291e21SDavid Hildenbrand 36938f2abe6aSChristian Borntraeger if (rc == -EREMOTE) { 369471f116bfSDavid Hildenbrand /* userspace support is needed, kvm_run has been prepared */ 36958f2abe6aSChristian Borntraeger rc = 0; 36968f2abe6aSChristian Borntraeger } 36978f2abe6aSChristian Borntraeger 3698db0758b2SDavid Hildenbrand disable_cpu_timer_accounting(vcpu); 3699b028ee3eSDavid Hildenbrand store_regs(vcpu, kvm_run); 3700d7b0b5ebSCarsten Otte 370120b7035cSJan H. Schönherr kvm_sigset_deactivate(vcpu); 3702b0c632dbSHeiko Carstens 3703b0c632dbSHeiko Carstens vcpu->stat.exit_userspace++; 3704accb757dSChristoffer Dall out: 3705accb757dSChristoffer Dall vcpu_put(vcpu); 37067e8e6ab4SHeiko Carstens return rc; 3707b0c632dbSHeiko Carstens } 3708b0c632dbSHeiko Carstens 3709b0c632dbSHeiko Carstens /* 3710b0c632dbSHeiko Carstens * store status at address 3711b0c632dbSHeiko Carstens * we use have two special cases: 3712b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit 3713b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_PREFIXED: -> prefix 3714b0c632dbSHeiko Carstens */ 3715d0bce605SHeiko Carstens int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long gpa) 3716b0c632dbSHeiko Carstens { 3717092670cdSCarsten Otte unsigned char archmode = 1; 37189abc2a08SDavid Hildenbrand freg_t fprs[NUM_FPRS]; 3719fda902cbSMichael Mueller unsigned int px; 37204287f247SDavid Hildenbrand u64 clkcomp, cputm; 3721d0bce605SHeiko Carstens int rc; 3722b0c632dbSHeiko Carstens 3723d9a3a09aSMartin Schwidefsky px = kvm_s390_get_prefix(vcpu); 3724d0bce605SHeiko Carstens if (gpa == KVM_S390_STORE_STATUS_NOADDR) { 3725d0bce605SHeiko Carstens if (write_guest_abs(vcpu, 163, &archmode, 1)) 3726b0c632dbSHeiko Carstens return -EFAULT; 3727d9a3a09aSMartin Schwidefsky gpa = 0; 3728d0bce605SHeiko Carstens } else if (gpa == KVM_S390_STORE_STATUS_PREFIXED) { 3729d0bce605SHeiko Carstens if (write_guest_real(vcpu, 163, &archmode, 1)) 3730b0c632dbSHeiko Carstens return -EFAULT; 3731d9a3a09aSMartin Schwidefsky gpa = px; 3732d9a3a09aSMartin Schwidefsky } else 3733d9a3a09aSMartin Schwidefsky gpa -= __LC_FPREGS_SAVE_AREA; 37349abc2a08SDavid Hildenbrand 37359abc2a08SDavid Hildenbrand /* manually convert vector registers if necessary */ 37369abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) { 37379522b37fSDavid Hildenbrand convert_vx_to_fp(fprs, (__vector128 *) vcpu->run->s.regs.vrs); 3738d9a3a09aSMartin Schwidefsky rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA, 37399abc2a08SDavid Hildenbrand fprs, 128); 37409abc2a08SDavid Hildenbrand } else { 37419abc2a08SDavid Hildenbrand rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA, 37426fd8e67dSDavid Hildenbrand vcpu->run->s.regs.fprs, 128); 37439abc2a08SDavid Hildenbrand } 3744d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_GPREGS_SAVE_AREA, 3745d0bce605SHeiko Carstens vcpu->run->s.regs.gprs, 128); 3746d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_PSW_SAVE_AREA, 3747d0bce605SHeiko Carstens &vcpu->arch.sie_block->gpsw, 16); 3748d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_PREFIX_SAVE_AREA, 3749fda902cbSMichael Mueller &px, 4); 3750d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_FP_CREG_SAVE_AREA, 37519abc2a08SDavid Hildenbrand &vcpu->run->s.regs.fpc, 4); 3752d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_TOD_PROGREG_SAVE_AREA, 3753d0bce605SHeiko Carstens &vcpu->arch.sie_block->todpr, 4); 37544287f247SDavid Hildenbrand cputm = kvm_s390_get_cpu_timer(vcpu); 3755d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CPU_TIMER_SAVE_AREA, 37564287f247SDavid Hildenbrand &cputm, 8); 3757178bd789SThomas Huth clkcomp = vcpu->arch.sie_block->ckc >> 8; 3758d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CLOCK_COMP_SAVE_AREA, 3759d0bce605SHeiko Carstens &clkcomp, 8); 3760d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_AREGS_SAVE_AREA, 3761d0bce605SHeiko Carstens &vcpu->run->s.regs.acrs, 64); 3762d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CREGS_SAVE_AREA, 3763d0bce605SHeiko Carstens &vcpu->arch.sie_block->gcr, 128); 3764d0bce605SHeiko Carstens return rc ? -EFAULT : 0; 3765b0c632dbSHeiko Carstens } 3766b0c632dbSHeiko Carstens 3767e879892cSThomas Huth int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr) 3768e879892cSThomas Huth { 3769e879892cSThomas Huth /* 3770e879892cSThomas Huth * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy 377131d8b8d4SChristian Borntraeger * switch in the run ioctl. Let's update our copies before we save 3772e879892cSThomas Huth * it into the save area 3773e879892cSThomas Huth */ 3774d0164ee2SHendrik Brueckner save_fpu_regs(); 37759abc2a08SDavid Hildenbrand vcpu->run->s.regs.fpc = current->thread.fpu.fpc; 3776e879892cSThomas Huth save_access_regs(vcpu->run->s.regs.acrs); 3777e879892cSThomas Huth 3778e879892cSThomas Huth return kvm_s390_store_status_unloaded(vcpu, addr); 3779e879892cSThomas Huth } 3780e879892cSThomas Huth 37818ad35755SDavid Hildenbrand static void __disable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 37828ad35755SDavid Hildenbrand { 37838ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu); 37848e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_DISABLE_IBS, vcpu); 37858ad35755SDavid Hildenbrand } 37868ad35755SDavid Hildenbrand 37878ad35755SDavid Hildenbrand static void __disable_ibs_on_all_vcpus(struct kvm *kvm) 37888ad35755SDavid Hildenbrand { 37898ad35755SDavid Hildenbrand unsigned int i; 37908ad35755SDavid Hildenbrand struct kvm_vcpu *vcpu; 37918ad35755SDavid Hildenbrand 37928ad35755SDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 37938ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 37948ad35755SDavid Hildenbrand } 37958ad35755SDavid Hildenbrand } 37968ad35755SDavid Hildenbrand 37978ad35755SDavid Hildenbrand static void __enable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 37988ad35755SDavid Hildenbrand { 379909a400e7SDavid Hildenbrand if (!sclp.has_ibs) 380009a400e7SDavid Hildenbrand return; 38018ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu); 38028e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_ENABLE_IBS, vcpu); 38038ad35755SDavid Hildenbrand } 38048ad35755SDavid Hildenbrand 38056852d7b6SDavid Hildenbrand void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu) 38066852d7b6SDavid Hildenbrand { 38078ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 38088ad35755SDavid Hildenbrand 38098ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 38108ad35755SDavid Hildenbrand return; 38118ad35755SDavid Hildenbrand 38126852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 1); 38138ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 3814433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 38158ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 38168ad35755SDavid Hildenbrand 38178ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 38188ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) 38198ad35755SDavid Hildenbrand started_vcpus++; 38208ad35755SDavid Hildenbrand } 38218ad35755SDavid Hildenbrand 38228ad35755SDavid Hildenbrand if (started_vcpus == 0) { 38238ad35755SDavid Hildenbrand /* we're the only active VCPU -> speed it up */ 38248ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(vcpu); 38258ad35755SDavid Hildenbrand } else if (started_vcpus == 1) { 38268ad35755SDavid Hildenbrand /* 38278ad35755SDavid Hildenbrand * As we are starting a second VCPU, we have to disable 38288ad35755SDavid Hildenbrand * the IBS facility on all VCPUs to remove potentially 38298ad35755SDavid Hildenbrand * oustanding ENABLE requests. 38308ad35755SDavid Hildenbrand */ 38318ad35755SDavid Hildenbrand __disable_ibs_on_all_vcpus(vcpu->kvm); 38328ad35755SDavid Hildenbrand } 38338ad35755SDavid Hildenbrand 38349daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_STOPPED); 38358ad35755SDavid Hildenbrand /* 38368ad35755SDavid Hildenbrand * Another VCPU might have used IBS while we were offline. 38378ad35755SDavid Hildenbrand * Let's play safe and flush the VCPU at startup. 38388ad35755SDavid Hildenbrand */ 3839d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 3840433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 38418ad35755SDavid Hildenbrand return; 38426852d7b6SDavid Hildenbrand } 38436852d7b6SDavid Hildenbrand 38446852d7b6SDavid Hildenbrand void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu) 38456852d7b6SDavid Hildenbrand { 38468ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 38478ad35755SDavid Hildenbrand struct kvm_vcpu *started_vcpu = NULL; 38488ad35755SDavid Hildenbrand 38498ad35755SDavid Hildenbrand if (is_vcpu_stopped(vcpu)) 38508ad35755SDavid Hildenbrand return; 38518ad35755SDavid Hildenbrand 38526852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 0); 38538ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 3854433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 38558ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 38568ad35755SDavid Hildenbrand 385732f5ff63SDavid Hildenbrand /* SIGP STOP and SIGP STOP AND STORE STATUS has been fully processed */ 38586cddd432SDavid Hildenbrand kvm_s390_clear_stop_irq(vcpu); 385932f5ff63SDavid Hildenbrand 3860ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_STOPPED); 38618ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 38628ad35755SDavid Hildenbrand 38638ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 38648ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) { 38658ad35755SDavid Hildenbrand started_vcpus++; 38668ad35755SDavid Hildenbrand started_vcpu = vcpu->kvm->vcpus[i]; 38678ad35755SDavid Hildenbrand } 38688ad35755SDavid Hildenbrand } 38698ad35755SDavid Hildenbrand 38708ad35755SDavid Hildenbrand if (started_vcpus == 1) { 38718ad35755SDavid Hildenbrand /* 38728ad35755SDavid Hildenbrand * As we only have one VCPU left, we want to enable the 38738ad35755SDavid Hildenbrand * IBS facility for that VCPU to speed it up. 38748ad35755SDavid Hildenbrand */ 38758ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(started_vcpu); 38768ad35755SDavid Hildenbrand } 38778ad35755SDavid Hildenbrand 3878433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 38798ad35755SDavid Hildenbrand return; 38806852d7b6SDavid Hildenbrand } 38816852d7b6SDavid Hildenbrand 3882d6712df9SCornelia Huck static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 3883d6712df9SCornelia Huck struct kvm_enable_cap *cap) 3884d6712df9SCornelia Huck { 3885d6712df9SCornelia Huck int r; 3886d6712df9SCornelia Huck 3887d6712df9SCornelia Huck if (cap->flags) 3888d6712df9SCornelia Huck return -EINVAL; 3889d6712df9SCornelia Huck 3890d6712df9SCornelia Huck switch (cap->cap) { 3891fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 3892fa6b7fe9SCornelia Huck if (!vcpu->kvm->arch.css_support) { 3893fa6b7fe9SCornelia Huck vcpu->kvm->arch.css_support = 1; 3894c92ea7b9SChristian Borntraeger VM_EVENT(vcpu->kvm, 3, "%s", "ENABLE: CSS support"); 3895fa6b7fe9SCornelia Huck trace_kvm_s390_enable_css(vcpu->kvm); 3896fa6b7fe9SCornelia Huck } 3897fa6b7fe9SCornelia Huck r = 0; 3898fa6b7fe9SCornelia Huck break; 3899d6712df9SCornelia Huck default: 3900d6712df9SCornelia Huck r = -EINVAL; 3901d6712df9SCornelia Huck break; 3902d6712df9SCornelia Huck } 3903d6712df9SCornelia Huck return r; 3904d6712df9SCornelia Huck } 3905d6712df9SCornelia Huck 390641408c28SThomas Huth static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu, 390741408c28SThomas Huth struct kvm_s390_mem_op *mop) 390841408c28SThomas Huth { 390941408c28SThomas Huth void __user *uaddr = (void __user *)mop->buf; 391041408c28SThomas Huth void *tmpbuf = NULL; 391141408c28SThomas Huth int r, srcu_idx; 391241408c28SThomas Huth const u64 supported_flags = KVM_S390_MEMOP_F_INJECT_EXCEPTION 391341408c28SThomas Huth | KVM_S390_MEMOP_F_CHECK_ONLY; 391441408c28SThomas Huth 391541408c28SThomas Huth if (mop->flags & ~supported_flags) 391641408c28SThomas Huth return -EINVAL; 391741408c28SThomas Huth 391841408c28SThomas Huth if (mop->size > MEM_OP_MAX_SIZE) 391941408c28SThomas Huth return -E2BIG; 392041408c28SThomas Huth 392141408c28SThomas Huth if (!(mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY)) { 392241408c28SThomas Huth tmpbuf = vmalloc(mop->size); 392341408c28SThomas Huth if (!tmpbuf) 392441408c28SThomas Huth return -ENOMEM; 392541408c28SThomas Huth } 392641408c28SThomas Huth 392741408c28SThomas Huth srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 392841408c28SThomas Huth 392941408c28SThomas Huth switch (mop->op) { 393041408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_READ: 393141408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 393292c96321SDavid Hildenbrand r = check_gva_range(vcpu, mop->gaddr, mop->ar, 393392c96321SDavid Hildenbrand mop->size, GACC_FETCH); 393441408c28SThomas Huth break; 393541408c28SThomas Huth } 393641408c28SThomas Huth r = read_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 393741408c28SThomas Huth if (r == 0) { 393841408c28SThomas Huth if (copy_to_user(uaddr, tmpbuf, mop->size)) 393941408c28SThomas Huth r = -EFAULT; 394041408c28SThomas Huth } 394141408c28SThomas Huth break; 394241408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_WRITE: 394341408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 394492c96321SDavid Hildenbrand r = check_gva_range(vcpu, mop->gaddr, mop->ar, 394592c96321SDavid Hildenbrand mop->size, GACC_STORE); 394641408c28SThomas Huth break; 394741408c28SThomas Huth } 394841408c28SThomas Huth if (copy_from_user(tmpbuf, uaddr, mop->size)) { 394941408c28SThomas Huth r = -EFAULT; 395041408c28SThomas Huth break; 395141408c28SThomas Huth } 395241408c28SThomas Huth r = write_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 395341408c28SThomas Huth break; 395441408c28SThomas Huth default: 395541408c28SThomas Huth r = -EINVAL; 395641408c28SThomas Huth } 395741408c28SThomas Huth 395841408c28SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, srcu_idx); 395941408c28SThomas Huth 396041408c28SThomas Huth if (r > 0 && (mop->flags & KVM_S390_MEMOP_F_INJECT_EXCEPTION) != 0) 396141408c28SThomas Huth kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm); 396241408c28SThomas Huth 396341408c28SThomas Huth vfree(tmpbuf); 396441408c28SThomas Huth return r; 396541408c28SThomas Huth } 396641408c28SThomas Huth 39675cb0944cSPaolo Bonzini long kvm_arch_vcpu_async_ioctl(struct file *filp, 3968b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 3969b0c632dbSHeiko Carstens { 3970b0c632dbSHeiko Carstens struct kvm_vcpu *vcpu = filp->private_data; 3971b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 3972b0c632dbSHeiko Carstens 397393736624SAvi Kivity switch (ioctl) { 397447b43c52SJens Freimann case KVM_S390_IRQ: { 397547b43c52SJens Freimann struct kvm_s390_irq s390irq; 397647b43c52SJens Freimann 397747b43c52SJens Freimann if (copy_from_user(&s390irq, argp, sizeof(s390irq))) 39789b062471SChristoffer Dall return -EFAULT; 39799b062471SChristoffer Dall return kvm_s390_inject_vcpu(vcpu, &s390irq); 398047b43c52SJens Freimann } 398193736624SAvi Kivity case KVM_S390_INTERRUPT: { 3982ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 3983383d0b05SJens Freimann struct kvm_s390_irq s390irq; 3984ba5c1e9bSCarsten Otte 3985ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 39869b062471SChristoffer Dall return -EFAULT; 3987383d0b05SJens Freimann if (s390int_to_s390irq(&s390int, &s390irq)) 3988383d0b05SJens Freimann return -EINVAL; 39899b062471SChristoffer Dall return kvm_s390_inject_vcpu(vcpu, &s390irq); 3990ba5c1e9bSCarsten Otte } 39919b062471SChristoffer Dall } 39925cb0944cSPaolo Bonzini return -ENOIOCTLCMD; 39935cb0944cSPaolo Bonzini } 39945cb0944cSPaolo Bonzini 39955cb0944cSPaolo Bonzini long kvm_arch_vcpu_ioctl(struct file *filp, 39965cb0944cSPaolo Bonzini unsigned int ioctl, unsigned long arg) 39975cb0944cSPaolo Bonzini { 39985cb0944cSPaolo Bonzini struct kvm_vcpu *vcpu = filp->private_data; 39995cb0944cSPaolo Bonzini void __user *argp = (void __user *)arg; 40005cb0944cSPaolo Bonzini int idx; 40015cb0944cSPaolo Bonzini long r; 40029b062471SChristoffer Dall 40039b062471SChristoffer Dall vcpu_load(vcpu); 40049b062471SChristoffer Dall 40059b062471SChristoffer Dall switch (ioctl) { 4006b0c632dbSHeiko Carstens case KVM_S390_STORE_STATUS: 4007800c1065SThomas Huth idx = srcu_read_lock(&vcpu->kvm->srcu); 4008bc923cc9SAvi Kivity r = kvm_s390_vcpu_store_status(vcpu, arg); 4009800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, idx); 4010bc923cc9SAvi Kivity break; 4011b0c632dbSHeiko Carstens case KVM_S390_SET_INITIAL_PSW: { 4012b0c632dbSHeiko Carstens psw_t psw; 4013b0c632dbSHeiko Carstens 4014bc923cc9SAvi Kivity r = -EFAULT; 4015b0c632dbSHeiko Carstens if (copy_from_user(&psw, argp, sizeof(psw))) 4016bc923cc9SAvi Kivity break; 4017bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw); 4018bc923cc9SAvi Kivity break; 4019b0c632dbSHeiko Carstens } 4020b0c632dbSHeiko Carstens case KVM_S390_INITIAL_RESET: 4021bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_initial_reset(vcpu); 4022bc923cc9SAvi Kivity break; 402314eebd91SCarsten Otte case KVM_SET_ONE_REG: 402414eebd91SCarsten Otte case KVM_GET_ONE_REG: { 402514eebd91SCarsten Otte struct kvm_one_reg reg; 402614eebd91SCarsten Otte r = -EFAULT; 402714eebd91SCarsten Otte if (copy_from_user(®, argp, sizeof(reg))) 402814eebd91SCarsten Otte break; 402914eebd91SCarsten Otte if (ioctl == KVM_SET_ONE_REG) 403014eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, ®); 403114eebd91SCarsten Otte else 403214eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, ®); 403314eebd91SCarsten Otte break; 403414eebd91SCarsten Otte } 403527e0393fSCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 403627e0393fSCarsten Otte case KVM_S390_UCAS_MAP: { 403727e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 403827e0393fSCarsten Otte 403927e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 404027e0393fSCarsten Otte r = -EFAULT; 404127e0393fSCarsten Otte break; 404227e0393fSCarsten Otte } 404327e0393fSCarsten Otte 404427e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 404527e0393fSCarsten Otte r = -EINVAL; 404627e0393fSCarsten Otte break; 404727e0393fSCarsten Otte } 404827e0393fSCarsten Otte 404927e0393fSCarsten Otte r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr, 405027e0393fSCarsten Otte ucasmap.vcpu_addr, ucasmap.length); 405127e0393fSCarsten Otte break; 405227e0393fSCarsten Otte } 405327e0393fSCarsten Otte case KVM_S390_UCAS_UNMAP: { 405427e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 405527e0393fSCarsten Otte 405627e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 405727e0393fSCarsten Otte r = -EFAULT; 405827e0393fSCarsten Otte break; 405927e0393fSCarsten Otte } 406027e0393fSCarsten Otte 406127e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 406227e0393fSCarsten Otte r = -EINVAL; 406327e0393fSCarsten Otte break; 406427e0393fSCarsten Otte } 406527e0393fSCarsten Otte 406627e0393fSCarsten Otte r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr, 406727e0393fSCarsten Otte ucasmap.length); 406827e0393fSCarsten Otte break; 406927e0393fSCarsten Otte } 407027e0393fSCarsten Otte #endif 4071ccc7910fSCarsten Otte case KVM_S390_VCPU_FAULT: { 4072527e30b4SMartin Schwidefsky r = gmap_fault(vcpu->arch.gmap, arg, 0); 4073ccc7910fSCarsten Otte break; 4074ccc7910fSCarsten Otte } 4075d6712df9SCornelia Huck case KVM_ENABLE_CAP: 4076d6712df9SCornelia Huck { 4077d6712df9SCornelia Huck struct kvm_enable_cap cap; 4078d6712df9SCornelia Huck r = -EFAULT; 4079d6712df9SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 4080d6712df9SCornelia Huck break; 4081d6712df9SCornelia Huck r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 4082d6712df9SCornelia Huck break; 4083d6712df9SCornelia Huck } 408441408c28SThomas Huth case KVM_S390_MEM_OP: { 408541408c28SThomas Huth struct kvm_s390_mem_op mem_op; 408641408c28SThomas Huth 408741408c28SThomas Huth if (copy_from_user(&mem_op, argp, sizeof(mem_op)) == 0) 408841408c28SThomas Huth r = kvm_s390_guest_mem_op(vcpu, &mem_op); 408941408c28SThomas Huth else 409041408c28SThomas Huth r = -EFAULT; 409141408c28SThomas Huth break; 409241408c28SThomas Huth } 4093816c7667SJens Freimann case KVM_S390_SET_IRQ_STATE: { 4094816c7667SJens Freimann struct kvm_s390_irq_state irq_state; 4095816c7667SJens Freimann 4096816c7667SJens Freimann r = -EFAULT; 4097816c7667SJens Freimann if (copy_from_user(&irq_state, argp, sizeof(irq_state))) 4098816c7667SJens Freimann break; 4099816c7667SJens Freimann if (irq_state.len > VCPU_IRQS_MAX_BUF || 4100816c7667SJens Freimann irq_state.len == 0 || 4101816c7667SJens Freimann irq_state.len % sizeof(struct kvm_s390_irq) > 0) { 4102816c7667SJens Freimann r = -EINVAL; 4103816c7667SJens Freimann break; 4104816c7667SJens Freimann } 4105bb64da9aSChristian Borntraeger /* do not use irq_state.flags, it will break old QEMUs */ 4106816c7667SJens Freimann r = kvm_s390_set_irq_state(vcpu, 4107816c7667SJens Freimann (void __user *) irq_state.buf, 4108816c7667SJens Freimann irq_state.len); 4109816c7667SJens Freimann break; 4110816c7667SJens Freimann } 4111816c7667SJens Freimann case KVM_S390_GET_IRQ_STATE: { 4112816c7667SJens Freimann struct kvm_s390_irq_state irq_state; 4113816c7667SJens Freimann 4114816c7667SJens Freimann r = -EFAULT; 4115816c7667SJens Freimann if (copy_from_user(&irq_state, argp, sizeof(irq_state))) 4116816c7667SJens Freimann break; 4117816c7667SJens Freimann if (irq_state.len == 0) { 4118816c7667SJens Freimann r = -EINVAL; 4119816c7667SJens Freimann break; 4120816c7667SJens Freimann } 4121bb64da9aSChristian Borntraeger /* do not use irq_state.flags, it will break old QEMUs */ 4122816c7667SJens Freimann r = kvm_s390_get_irq_state(vcpu, 4123816c7667SJens Freimann (__u8 __user *) irq_state.buf, 4124816c7667SJens Freimann irq_state.len); 4125816c7667SJens Freimann break; 4126816c7667SJens Freimann } 4127b0c632dbSHeiko Carstens default: 41283e6afcf1SCarsten Otte r = -ENOTTY; 4129b0c632dbSHeiko Carstens } 41309b062471SChristoffer Dall 41319b062471SChristoffer Dall vcpu_put(vcpu); 4132bc923cc9SAvi Kivity return r; 4133b0c632dbSHeiko Carstens } 4134b0c632dbSHeiko Carstens 41351499fa80SSouptick Joarder vm_fault_t kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) 41365b1c1493SCarsten Otte { 41375b1c1493SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 41385b1c1493SCarsten Otte if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET) 41395b1c1493SCarsten Otte && (kvm_is_ucontrol(vcpu->kvm))) { 41405b1c1493SCarsten Otte vmf->page = virt_to_page(vcpu->arch.sie_block); 41415b1c1493SCarsten Otte get_page(vmf->page); 41425b1c1493SCarsten Otte return 0; 41435b1c1493SCarsten Otte } 41445b1c1493SCarsten Otte #endif 41455b1c1493SCarsten Otte return VM_FAULT_SIGBUS; 41465b1c1493SCarsten Otte } 41475b1c1493SCarsten Otte 41485587027cSAneesh Kumar K.V int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, 41495587027cSAneesh Kumar K.V unsigned long npages) 4150db3fe4ebSTakuya Yoshikawa { 4151db3fe4ebSTakuya Yoshikawa return 0; 4152db3fe4ebSTakuya Yoshikawa } 4153db3fe4ebSTakuya Yoshikawa 4154b0c632dbSHeiko Carstens /* Section: memory related */ 4155f7784b8eSMarcelo Tosatti int kvm_arch_prepare_memory_region(struct kvm *kvm, 4156f7784b8eSMarcelo Tosatti struct kvm_memory_slot *memslot, 415709170a49SPaolo Bonzini const struct kvm_userspace_memory_region *mem, 41587b6195a9STakuya Yoshikawa enum kvm_mr_change change) 4159b0c632dbSHeiko Carstens { 4160dd2887e7SNick Wang /* A few sanity checks. We can have memory slots which have to be 4161dd2887e7SNick Wang located/ended at a segment boundary (1MB). The memory in userland is 4162dd2887e7SNick Wang ok to be fragmented into various different vmas. It is okay to mmap() 4163dd2887e7SNick Wang and munmap() stuff in this slot after doing this call at any time */ 4164b0c632dbSHeiko Carstens 4165598841caSCarsten Otte if (mem->userspace_addr & 0xffffful) 4166b0c632dbSHeiko Carstens return -EINVAL; 4167b0c632dbSHeiko Carstens 4168598841caSCarsten Otte if (mem->memory_size & 0xffffful) 4169b0c632dbSHeiko Carstens return -EINVAL; 4170b0c632dbSHeiko Carstens 4171a3a92c31SDominik Dingel if (mem->guest_phys_addr + mem->memory_size > kvm->arch.mem_limit) 4172a3a92c31SDominik Dingel return -EINVAL; 4173a3a92c31SDominik Dingel 4174f7784b8eSMarcelo Tosatti return 0; 4175f7784b8eSMarcelo Tosatti } 4176f7784b8eSMarcelo Tosatti 4177f7784b8eSMarcelo Tosatti void kvm_arch_commit_memory_region(struct kvm *kvm, 417809170a49SPaolo Bonzini const struct kvm_userspace_memory_region *mem, 41798482644aSTakuya Yoshikawa const struct kvm_memory_slot *old, 4180f36f3f28SPaolo Bonzini const struct kvm_memory_slot *new, 41818482644aSTakuya Yoshikawa enum kvm_mr_change change) 4182f7784b8eSMarcelo Tosatti { 4183f7850c92SCarsten Otte int rc; 4184f7784b8eSMarcelo Tosatti 41852cef4debSChristian Borntraeger /* If the basics of the memslot do not change, we do not want 41862cef4debSChristian Borntraeger * to update the gmap. Every update causes several unnecessary 41872cef4debSChristian Borntraeger * segment translation exceptions. This is usually handled just 41882cef4debSChristian Borntraeger * fine by the normal fault handler + gmap, but it will also 41892cef4debSChristian Borntraeger * cause faults on the prefix page of running guest CPUs. 41902cef4debSChristian Borntraeger */ 41912cef4debSChristian Borntraeger if (old->userspace_addr == mem->userspace_addr && 41922cef4debSChristian Borntraeger old->base_gfn * PAGE_SIZE == mem->guest_phys_addr && 41932cef4debSChristian Borntraeger old->npages * PAGE_SIZE == mem->memory_size) 41942cef4debSChristian Borntraeger return; 4195598841caSCarsten Otte 4196598841caSCarsten Otte rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr, 4197598841caSCarsten Otte mem->guest_phys_addr, mem->memory_size); 4198598841caSCarsten Otte if (rc) 4199ea2cdd27SDavid Hildenbrand pr_warn("failed to commit memory region\n"); 4200598841caSCarsten Otte return; 4201b0c632dbSHeiko Carstens } 4202b0c632dbSHeiko Carstens 420360a37709SAlexander Yarygin static inline unsigned long nonhyp_mask(int i) 420460a37709SAlexander Yarygin { 420560a37709SAlexander Yarygin unsigned int nonhyp_fai = (sclp.hmfai << i * 2) >> 30; 420660a37709SAlexander Yarygin 420760a37709SAlexander Yarygin return 0x0000ffffffffffffUL >> (nonhyp_fai << 4); 420860a37709SAlexander Yarygin } 420960a37709SAlexander Yarygin 42103491caf2SChristian Borntraeger void kvm_arch_vcpu_block_finish(struct kvm_vcpu *vcpu) 42113491caf2SChristian Borntraeger { 42123491caf2SChristian Borntraeger vcpu->valid_wakeup = false; 42133491caf2SChristian Borntraeger } 42143491caf2SChristian Borntraeger 4215b0c632dbSHeiko Carstens static int __init kvm_s390_init(void) 4216b0c632dbSHeiko Carstens { 421760a37709SAlexander Yarygin int i; 421860a37709SAlexander Yarygin 421907197fd0SDavid Hildenbrand if (!sclp.has_sief2) { 422007197fd0SDavid Hildenbrand pr_info("SIE not available\n"); 422107197fd0SDavid Hildenbrand return -ENODEV; 422207197fd0SDavid Hildenbrand } 422307197fd0SDavid Hildenbrand 4224a4499382SJanosch Frank if (nested && hpage) { 4225a4499382SJanosch Frank pr_info("nested (vSIE) and hpage (huge page backing) can currently not be activated concurrently"); 4226a4499382SJanosch Frank return -EINVAL; 4227a4499382SJanosch Frank } 4228a4499382SJanosch Frank 422960a37709SAlexander Yarygin for (i = 0; i < 16; i++) 4230c3b9e3e1SChristian Borntraeger kvm_s390_fac_base[i] |= 423160a37709SAlexander Yarygin S390_lowcore.stfle_fac_list[i] & nonhyp_mask(i); 423260a37709SAlexander Yarygin 42339d8d5786SMichael Mueller return kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); 4234b0c632dbSHeiko Carstens } 4235b0c632dbSHeiko Carstens 4236b0c632dbSHeiko Carstens static void __exit kvm_s390_exit(void) 4237b0c632dbSHeiko Carstens { 4238b0c632dbSHeiko Carstens kvm_exit(); 4239b0c632dbSHeiko Carstens } 4240b0c632dbSHeiko Carstens 4241b0c632dbSHeiko Carstens module_init(kvm_s390_init); 4242b0c632dbSHeiko Carstens module_exit(kvm_s390_exit); 4243566af940SCornelia Huck 4244566af940SCornelia Huck /* 4245566af940SCornelia Huck * Enable autoloading of the kvm module. 4246566af940SCornelia Huck * Note that we add the module alias here instead of virt/kvm/kvm_main.c 4247566af940SCornelia Huck * since x86 takes a different approach. 4248566af940SCornelia Huck */ 4249566af940SCornelia Huck #include <linux/miscdevice.h> 4250566af940SCornelia Huck MODULE_ALIAS_MISCDEV(KVM_MINOR); 4251566af940SCornelia Huck MODULE_ALIAS("devname:kvm"); 4252