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 147aedd9d4SMichael Mueller #define KMSG_COMPONENT "kvm-s390" 157aedd9d4SMichael Mueller #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 167aedd9d4SMichael Mueller 17b0c632dbSHeiko Carstens #include <linux/compiler.h> 18b0c632dbSHeiko Carstens #include <linux/err.h> 19b0c632dbSHeiko Carstens #include <linux/fs.h> 20ca872302SChristian Borntraeger #include <linux/hrtimer.h> 21b0c632dbSHeiko Carstens #include <linux/init.h> 22b0c632dbSHeiko Carstens #include <linux/kvm.h> 23b0c632dbSHeiko Carstens #include <linux/kvm_host.h> 24b2d73b2aSMartin Schwidefsky #include <linux/mman.h> 25b0c632dbSHeiko Carstens #include <linux/module.h> 26d3217967SPaul Gortmaker #include <linux/moduleparam.h> 27a374e892STony Krowiak #include <linux/random.h> 28b0c632dbSHeiko Carstens #include <linux/slab.h> 29ba5c1e9bSCarsten Otte #include <linux/timer.h> 3041408c28SThomas Huth #include <linux/vmalloc.h> 3115c9705fSDavid Hildenbrand #include <linux/bitmap.h> 32174cd4b1SIngo Molnar #include <linux/sched/signal.h> 33190df4a2SClaudio Imbrenda #include <linux/string.h> 34174cd4b1SIngo Molnar 35cbb870c8SHeiko Carstens #include <asm/asm-offsets.h> 36b0c632dbSHeiko Carstens #include <asm/lowcore.h> 37fd5ada04SMartin Schwidefsky #include <asm/stp.h> 38b0c632dbSHeiko Carstens #include <asm/pgtable.h> 391e133ab2SMartin Schwidefsky #include <asm/gmap.h> 40f5daba1dSHeiko Carstens #include <asm/nmi.h> 41a0616cdeSDavid Howells #include <asm/switch_to.h> 426d3da241SJens Freimann #include <asm/isc.h> 431526bf9cSChristian Borntraeger #include <asm/sclp.h> 440a763c78SDavid Hildenbrand #include <asm/cpacf.h> 45221bb8a4SLinus Torvalds #include <asm/timex.h> 46e585b24aSTony Krowiak #include <asm/ap.h> 478f2abe6aSChristian Borntraeger #include "kvm-s390.h" 48b0c632dbSHeiko Carstens #include "gaccess.h" 49b0c632dbSHeiko Carstens 505786fffaSCornelia Huck #define CREATE_TRACE_POINTS 515786fffaSCornelia Huck #include "trace.h" 52ade38c31SCornelia Huck #include "trace-s390.h" 535786fffaSCornelia Huck 5441408c28SThomas Huth #define MEM_OP_MAX_SIZE 65536 /* Maximum transfer size for KVM_S390_MEM_OP */ 55816c7667SJens Freimann #define LOCAL_IRQS 32 56816c7667SJens Freimann #define VCPU_IRQS_MAX_BUF (sizeof(struct kvm_s390_irq) * \ 57816c7667SJens Freimann (KVM_MAX_VCPUS + LOCAL_IRQS)) 5841408c28SThomas Huth 59b0c632dbSHeiko Carstens #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU 60ccc40c53SChristian Borntraeger #define VM_STAT(x) offsetof(struct kvm, stat.x), KVM_STAT_VM 61b0c632dbSHeiko Carstens 62b0c632dbSHeiko Carstens struct kvm_stats_debugfs_item debugfs_entries[] = { 63b0c632dbSHeiko Carstens { "userspace_handled", VCPU_STAT(exit_userspace) }, 640eaeafa1SChristian Borntraeger { "exit_null", VCPU_STAT(exit_null) }, 658f2abe6aSChristian Borntraeger { "exit_validity", VCPU_STAT(exit_validity) }, 668f2abe6aSChristian Borntraeger { "exit_stop_request", VCPU_STAT(exit_stop_request) }, 678f2abe6aSChristian Borntraeger { "exit_external_request", VCPU_STAT(exit_external_request) }, 68a5e0aceaSChristian Borntraeger { "exit_io_request", VCPU_STAT(exit_io_request) }, 698f2abe6aSChristian Borntraeger { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) }, 70ba5c1e9bSCarsten Otte { "exit_instruction", VCPU_STAT(exit_instruction) }, 719ec6de19SAlexander Yarygin { "exit_pei", VCPU_STAT(exit_pei) }, 72ba5c1e9bSCarsten Otte { "exit_program_interruption", VCPU_STAT(exit_program_interruption) }, 73ba5c1e9bSCarsten Otte { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) }, 74a011eeb2SJanosch Frank { "exit_operation_exception", VCPU_STAT(exit_operation_exception) }, 75f7819512SPaolo Bonzini { "halt_successful_poll", VCPU_STAT(halt_successful_poll) }, 7662bea5bfSPaolo Bonzini { "halt_attempted_poll", VCPU_STAT(halt_attempted_poll) }, 773491caf2SChristian Borntraeger { "halt_poll_invalid", VCPU_STAT(halt_poll_invalid) }, 788b905d28SChristian Borntraeger { "halt_no_poll_steal", VCPU_STAT(halt_no_poll_steal) }, 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) }, 1588474e5caSChristian Borntraeger { "diag_9c_ignored", VCPU_STAT(diagnose_9c_ignored) }, 159866c138cSChristian Borntraeger { "instruction_diag_258", VCPU_STAT(diagnose_258) }, 160866c138cSChristian Borntraeger { "instruction_diag_308", VCPU_STAT(diagnose_308) }, 161866c138cSChristian Borntraeger { "instruction_diag_500", VCPU_STAT(diagnose_500) }, 162a37cb07aSChristian Borntraeger { "instruction_diag_other", VCPU_STAT(diagnose_other) }, 163b0c632dbSHeiko Carstens { NULL } 164b0c632dbSHeiko Carstens }; 165b0c632dbSHeiko Carstens 1668fa1696eSCollin L. Walling struct kvm_s390_tod_clock_ext { 1678fa1696eSCollin L. Walling __u8 epoch_idx; 1688fa1696eSCollin L. Walling __u64 tod; 1698fa1696eSCollin L. Walling __u8 reserved[7]; 1708fa1696eSCollin L. Walling } __packed; 1718fa1696eSCollin L. Walling 172a411edf1SDavid Hildenbrand /* allow nested virtualization in KVM (if enabled by user space) */ 173a411edf1SDavid Hildenbrand static int nested; 174a411edf1SDavid Hildenbrand module_param(nested, int, S_IRUGO); 175a411edf1SDavid Hildenbrand MODULE_PARM_DESC(nested, "Nested virtualization support"); 176a411edf1SDavid Hildenbrand 177a4499382SJanosch Frank /* allow 1m huge page guest backing, if !nested */ 178a4499382SJanosch Frank static int hpage; 179a4499382SJanosch Frank module_param(hpage, int, 0444); 180a4499382SJanosch Frank MODULE_PARM_DESC(hpage, "1m huge page backing support"); 181b0c632dbSHeiko Carstens 1828b905d28SChristian Borntraeger /* maximum percentage of steal time for polling. >100 is treated like 100 */ 1838b905d28SChristian Borntraeger static u8 halt_poll_max_steal = 10; 1848b905d28SChristian Borntraeger module_param(halt_poll_max_steal, byte, 0644); 185b41fb528SWei Yongjun MODULE_PARM_DESC(halt_poll_max_steal, "Maximum percentage of steal time to allow polling"); 1868b905d28SChristian Borntraeger 187c3b9e3e1SChristian Borntraeger /* 188c3b9e3e1SChristian Borntraeger * For now we handle at most 16 double words as this is what the s390 base 189c3b9e3e1SChristian Borntraeger * kernel handles and stores in the prefix page. If we ever need to go beyond 190c3b9e3e1SChristian Borntraeger * this, this requires changes to code, but the external uapi can stay. 191c3b9e3e1SChristian Borntraeger */ 192c3b9e3e1SChristian Borntraeger #define SIZE_INTERNAL 16 193c3b9e3e1SChristian Borntraeger 194c3b9e3e1SChristian Borntraeger /* 195c3b9e3e1SChristian Borntraeger * Base feature mask that defines default mask for facilities. Consists of the 196c3b9e3e1SChristian Borntraeger * defines in FACILITIES_KVM and the non-hypervisor managed bits. 197c3b9e3e1SChristian Borntraeger */ 198c3b9e3e1SChristian Borntraeger static unsigned long kvm_s390_fac_base[SIZE_INTERNAL] = { FACILITIES_KVM }; 199c3b9e3e1SChristian Borntraeger /* 200c3b9e3e1SChristian Borntraeger * Extended feature mask. Consists of the defines in FACILITIES_KVM_CPUMODEL 201c3b9e3e1SChristian Borntraeger * and defines the facilities that can be enabled via a cpu model. 202c3b9e3e1SChristian Borntraeger */ 203c3b9e3e1SChristian Borntraeger static unsigned long kvm_s390_fac_ext[SIZE_INTERNAL] = { FACILITIES_KVM_CPUMODEL }; 204c3b9e3e1SChristian Borntraeger 205c3b9e3e1SChristian Borntraeger static unsigned long kvm_s390_fac_size(void) 20678c4b59fSMichael Mueller { 207c3b9e3e1SChristian Borntraeger BUILD_BUG_ON(SIZE_INTERNAL > S390_ARCH_FAC_MASK_SIZE_U64); 208c3b9e3e1SChristian Borntraeger BUILD_BUG_ON(SIZE_INTERNAL > S390_ARCH_FAC_LIST_SIZE_U64); 209c3b9e3e1SChristian Borntraeger BUILD_BUG_ON(SIZE_INTERNAL * sizeof(unsigned long) > 210c3b9e3e1SChristian Borntraeger sizeof(S390_lowcore.stfle_fac_list)); 211c3b9e3e1SChristian Borntraeger 212c3b9e3e1SChristian Borntraeger return SIZE_INTERNAL; 21378c4b59fSMichael Mueller } 21478c4b59fSMichael Mueller 21515c9705fSDavid Hildenbrand /* available cpu features supported by kvm */ 21615c9705fSDavid Hildenbrand static DECLARE_BITMAP(kvm_s390_available_cpu_feat, KVM_S390_VM_CPU_FEAT_NR_BITS); 2170a763c78SDavid Hildenbrand /* available subfunctions indicated via query / "test bit" */ 2180a763c78SDavid Hildenbrand static struct kvm_s390_vm_cpu_subfunc kvm_s390_available_subfunc; 21915c9705fSDavid Hildenbrand 2209d8d5786SMichael Mueller static struct gmap_notifier gmap_notifier; 221a3508fbeSDavid Hildenbrand static struct gmap_notifier vsie_gmap_notifier; 22278f26131SChristian Borntraeger debug_info_t *kvm_s390_dbf; 2239d8d5786SMichael Mueller 224b0c632dbSHeiko Carstens /* Section: not file related */ 22513a34e06SRadim Krčmář int kvm_arch_hardware_enable(void) 226b0c632dbSHeiko Carstens { 227b0c632dbSHeiko Carstens /* every s390 is virtualization enabled ;-) */ 22810474ae8SAlexander Graf return 0; 229b0c632dbSHeiko Carstens } 230b0c632dbSHeiko Carstens 231f257d6dcSSean Christopherson int kvm_arch_check_processor_compat(void) 232f257d6dcSSean Christopherson { 233f257d6dcSSean Christopherson return 0; 234f257d6dcSSean Christopherson } 235f257d6dcSSean Christopherson 236414d3b07SMartin Schwidefsky static void kvm_gmap_notifier(struct gmap *gmap, unsigned long start, 237414d3b07SMartin Schwidefsky unsigned long end); 2382c70fe44SChristian Borntraeger 2391575767eSDavid Hildenbrand static void kvm_clock_sync_scb(struct kvm_s390_sie_block *scb, u64 delta) 2401575767eSDavid Hildenbrand { 2411575767eSDavid Hildenbrand u8 delta_idx = 0; 2421575767eSDavid Hildenbrand 2431575767eSDavid Hildenbrand /* 2441575767eSDavid Hildenbrand * The TOD jumps by delta, we have to compensate this by adding 2451575767eSDavid Hildenbrand * -delta to the epoch. 2461575767eSDavid Hildenbrand */ 2471575767eSDavid Hildenbrand delta = -delta; 2481575767eSDavid Hildenbrand 2491575767eSDavid Hildenbrand /* sign-extension - we're adding to signed values below */ 2501575767eSDavid Hildenbrand if ((s64)delta < 0) 2511575767eSDavid Hildenbrand delta_idx = -1; 2521575767eSDavid Hildenbrand 2531575767eSDavid Hildenbrand scb->epoch += delta; 2541575767eSDavid Hildenbrand if (scb->ecd & ECD_MEF) { 2551575767eSDavid Hildenbrand scb->epdx += delta_idx; 2561575767eSDavid Hildenbrand if (scb->epoch < delta) 2571575767eSDavid Hildenbrand scb->epdx += 1; 2581575767eSDavid Hildenbrand } 2591575767eSDavid Hildenbrand } 2601575767eSDavid Hildenbrand 261fdf03650SFan Zhang /* 262fdf03650SFan Zhang * This callback is executed during stop_machine(). All CPUs are therefore 263fdf03650SFan Zhang * temporarily stopped. In order not to change guest behavior, we have to 264fdf03650SFan Zhang * disable preemption whenever we touch the epoch of kvm and the VCPUs, 265fdf03650SFan Zhang * so a CPU won't be stopped while calculating with the epoch. 266fdf03650SFan Zhang */ 267fdf03650SFan Zhang static int kvm_clock_sync(struct notifier_block *notifier, unsigned long val, 268fdf03650SFan Zhang void *v) 269fdf03650SFan Zhang { 270fdf03650SFan Zhang struct kvm *kvm; 271fdf03650SFan Zhang struct kvm_vcpu *vcpu; 272fdf03650SFan Zhang int i; 273fdf03650SFan Zhang unsigned long long *delta = v; 274fdf03650SFan Zhang 275fdf03650SFan Zhang list_for_each_entry(kvm, &vm_list, vm_list) { 276fdf03650SFan Zhang kvm_for_each_vcpu(i, vcpu, kvm) { 2771575767eSDavid Hildenbrand kvm_clock_sync_scb(vcpu->arch.sie_block, *delta); 2781575767eSDavid Hildenbrand if (i == 0) { 2791575767eSDavid Hildenbrand kvm->arch.epoch = vcpu->arch.sie_block->epoch; 2801575767eSDavid Hildenbrand kvm->arch.epdx = vcpu->arch.sie_block->epdx; 2811575767eSDavid Hildenbrand } 282db0758b2SDavid Hildenbrand if (vcpu->arch.cputm_enabled) 283db0758b2SDavid Hildenbrand vcpu->arch.cputm_start += *delta; 28491473b48SDavid Hildenbrand if (vcpu->arch.vsie_block) 2851575767eSDavid Hildenbrand kvm_clock_sync_scb(vcpu->arch.vsie_block, 2861575767eSDavid Hildenbrand *delta); 287fdf03650SFan Zhang } 288fdf03650SFan Zhang } 289fdf03650SFan Zhang return NOTIFY_OK; 290fdf03650SFan Zhang } 291fdf03650SFan Zhang 292fdf03650SFan Zhang static struct notifier_block kvm_clock_notifier = { 293fdf03650SFan Zhang .notifier_call = kvm_clock_sync, 294fdf03650SFan Zhang }; 295fdf03650SFan Zhang 296b0c632dbSHeiko Carstens int kvm_arch_hardware_setup(void) 297b0c632dbSHeiko Carstens { 2982c70fe44SChristian Borntraeger gmap_notifier.notifier_call = kvm_gmap_notifier; 299b2d73b2aSMartin Schwidefsky gmap_register_pte_notifier(&gmap_notifier); 300a3508fbeSDavid Hildenbrand vsie_gmap_notifier.notifier_call = kvm_s390_vsie_gmap_notifier; 301a3508fbeSDavid Hildenbrand gmap_register_pte_notifier(&vsie_gmap_notifier); 302fdf03650SFan Zhang atomic_notifier_chain_register(&s390_epoch_delta_notifier, 303fdf03650SFan Zhang &kvm_clock_notifier); 304b0c632dbSHeiko Carstens return 0; 305b0c632dbSHeiko Carstens } 306b0c632dbSHeiko Carstens 307b0c632dbSHeiko Carstens void kvm_arch_hardware_unsetup(void) 308b0c632dbSHeiko Carstens { 309b2d73b2aSMartin Schwidefsky gmap_unregister_pte_notifier(&gmap_notifier); 310a3508fbeSDavid Hildenbrand gmap_unregister_pte_notifier(&vsie_gmap_notifier); 311fdf03650SFan Zhang atomic_notifier_chain_unregister(&s390_epoch_delta_notifier, 312fdf03650SFan Zhang &kvm_clock_notifier); 313b0c632dbSHeiko Carstens } 314b0c632dbSHeiko Carstens 31522be5a13SDavid Hildenbrand static void allow_cpu_feat(unsigned long nr) 31622be5a13SDavid Hildenbrand { 31722be5a13SDavid Hildenbrand set_bit_inv(nr, kvm_s390_available_cpu_feat); 31822be5a13SDavid Hildenbrand } 31922be5a13SDavid Hildenbrand 3200a763c78SDavid Hildenbrand static inline int plo_test_bit(unsigned char nr) 3210a763c78SDavid Hildenbrand { 3220a763c78SDavid Hildenbrand register unsigned long r0 asm("0") = (unsigned long) nr | 0x100; 323d051ae53SHeiko Carstens int cc; 3240a763c78SDavid Hildenbrand 3250a763c78SDavid Hildenbrand asm volatile( 3260a763c78SDavid Hildenbrand /* Parameter registers are ignored for "test bit" */ 3270a763c78SDavid Hildenbrand " plo 0,0,0,0(0)\n" 3280a763c78SDavid Hildenbrand " ipm %0\n" 3290a763c78SDavid Hildenbrand " srl %0,28\n" 3300a763c78SDavid Hildenbrand : "=d" (cc) 3310a763c78SDavid Hildenbrand : "d" (r0) 3320a763c78SDavid Hildenbrand : "cc"); 3330a763c78SDavid Hildenbrand return cc == 0; 3340a763c78SDavid Hildenbrand } 3350a763c78SDavid Hildenbrand 336d0dea733SHeiko Carstens static __always_inline void __insn32_query(unsigned int opcode, u8 *query) 337d6681397SChristian Borntraeger { 338d6681397SChristian Borntraeger register unsigned long r0 asm("0") = 0; /* query function */ 339d6681397SChristian Borntraeger register unsigned long r1 asm("1") = (unsigned long) query; 340d6681397SChristian Borntraeger 341d6681397SChristian Borntraeger asm volatile( 342d6681397SChristian Borntraeger /* Parameter regs are ignored */ 343d6681397SChristian Borntraeger " .insn rrf,%[opc] << 16,2,4,6,0\n" 344b1c41ac3SHeiko Carstens : 345d6681397SChristian Borntraeger : "d" (r0), "a" (r1), [opc] "i" (opcode) 346b1c41ac3SHeiko Carstens : "cc", "memory"); 347d6681397SChristian Borntraeger } 348d6681397SChristian Borntraeger 349173aec2dSChristian Borntraeger #define INSN_SORTL 0xb938 3504f45b90eSChristian Borntraeger #define INSN_DFLTCC 0xb939 351173aec2dSChristian Borntraeger 35222be5a13SDavid Hildenbrand static void kvm_s390_cpu_feat_init(void) 35322be5a13SDavid Hildenbrand { 3540a763c78SDavid Hildenbrand int i; 3550a763c78SDavid Hildenbrand 3560a763c78SDavid Hildenbrand for (i = 0; i < 256; ++i) { 3570a763c78SDavid Hildenbrand if (plo_test_bit(i)) 3580a763c78SDavid Hildenbrand kvm_s390_available_subfunc.plo[i >> 3] |= 0x80 >> (i & 7); 3590a763c78SDavid Hildenbrand } 3600a763c78SDavid Hildenbrand 3610a763c78SDavid Hildenbrand if (test_facility(28)) /* TOD-clock steering */ 362221bb8a4SLinus Torvalds ptff(kvm_s390_available_subfunc.ptff, 363221bb8a4SLinus Torvalds sizeof(kvm_s390_available_subfunc.ptff), 364221bb8a4SLinus Torvalds PTFF_QAF); 3650a763c78SDavid Hildenbrand 3660a763c78SDavid Hildenbrand if (test_facility(17)) { /* MSA */ 36769c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMAC, (cpacf_mask_t *) 36869c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmac); 36969c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMC, (cpacf_mask_t *) 37069c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmc); 37169c0e360SMartin Schwidefsky __cpacf_query(CPACF_KM, (cpacf_mask_t *) 37269c0e360SMartin Schwidefsky kvm_s390_available_subfunc.km); 37369c0e360SMartin Schwidefsky __cpacf_query(CPACF_KIMD, (cpacf_mask_t *) 37469c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kimd); 37569c0e360SMartin Schwidefsky __cpacf_query(CPACF_KLMD, (cpacf_mask_t *) 37669c0e360SMartin Schwidefsky kvm_s390_available_subfunc.klmd); 3770a763c78SDavid Hildenbrand } 3780a763c78SDavid Hildenbrand if (test_facility(76)) /* MSA3 */ 37969c0e360SMartin Schwidefsky __cpacf_query(CPACF_PCKMO, (cpacf_mask_t *) 38069c0e360SMartin Schwidefsky kvm_s390_available_subfunc.pckmo); 3810a763c78SDavid Hildenbrand if (test_facility(77)) { /* MSA4 */ 38269c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMCTR, (cpacf_mask_t *) 38369c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmctr); 38469c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMF, (cpacf_mask_t *) 38569c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmf); 38669c0e360SMartin Schwidefsky __cpacf_query(CPACF_KMO, (cpacf_mask_t *) 38769c0e360SMartin Schwidefsky kvm_s390_available_subfunc.kmo); 38869c0e360SMartin Schwidefsky __cpacf_query(CPACF_PCC, (cpacf_mask_t *) 38969c0e360SMartin Schwidefsky kvm_s390_available_subfunc.pcc); 3900a763c78SDavid Hildenbrand } 3910a763c78SDavid Hildenbrand if (test_facility(57)) /* MSA5 */ 392985a9d20SHarald Freudenberger __cpacf_query(CPACF_PRNO, (cpacf_mask_t *) 39369c0e360SMartin Schwidefsky kvm_s390_available_subfunc.ppno); 3940a763c78SDavid Hildenbrand 395e000b8e0SJason J. Herne if (test_facility(146)) /* MSA8 */ 396e000b8e0SJason J. Herne __cpacf_query(CPACF_KMA, (cpacf_mask_t *) 397e000b8e0SJason J. Herne kvm_s390_available_subfunc.kma); 398e000b8e0SJason J. Herne 39913209ad0SChristian Borntraeger if (test_facility(155)) /* MSA9 */ 40013209ad0SChristian Borntraeger __cpacf_query(CPACF_KDSA, (cpacf_mask_t *) 40113209ad0SChristian Borntraeger kvm_s390_available_subfunc.kdsa); 40213209ad0SChristian Borntraeger 403173aec2dSChristian Borntraeger if (test_facility(150)) /* SORTL */ 404173aec2dSChristian Borntraeger __insn32_query(INSN_SORTL, kvm_s390_available_subfunc.sortl); 405173aec2dSChristian Borntraeger 4064f45b90eSChristian Borntraeger if (test_facility(151)) /* DFLTCC */ 4074f45b90eSChristian Borntraeger __insn32_query(INSN_DFLTCC, kvm_s390_available_subfunc.dfltcc); 4084f45b90eSChristian Borntraeger 40922be5a13SDavid Hildenbrand if (MACHINE_HAS_ESOP) 41022be5a13SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_ESOP); 411a3508fbeSDavid Hildenbrand /* 412a3508fbeSDavid Hildenbrand * We need SIE support, ESOP (PROT_READ protection for gmap_shadow), 413a3508fbeSDavid Hildenbrand * 64bit SCAO (SCA passthrough) and IDTE (for gmap_shadow unshadowing). 414a3508fbeSDavid Hildenbrand */ 415a3508fbeSDavid Hildenbrand if (!sclp.has_sief2 || !MACHINE_HAS_ESOP || !sclp.has_64bscao || 416a411edf1SDavid Hildenbrand !test_facility(3) || !nested) 417a3508fbeSDavid Hildenbrand return; 418a3508fbeSDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_SIEF2); 41919c439b5SDavid Hildenbrand if (sclp.has_64bscao) 42019c439b5SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_64BSCAO); 4210615a326SDavid Hildenbrand if (sclp.has_siif) 4220615a326SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_SIIF); 42377d18f6dSDavid Hildenbrand if (sclp.has_gpere) 42477d18f6dSDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_GPERE); 425a1b7b9b2SDavid Hildenbrand if (sclp.has_gsls) 426a1b7b9b2SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_GSLS); 4275630a8e8SDavid Hildenbrand if (sclp.has_ib) 4285630a8e8SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_IB); 42913ee3f67SDavid Hildenbrand if (sclp.has_cei) 43013ee3f67SDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_CEI); 4317fd7f39dSDavid Hildenbrand if (sclp.has_ibs) 4327fd7f39dSDavid Hildenbrand allow_cpu_feat(KVM_S390_VM_CPU_FEAT_IBS); 433730cd632SFarhan Ali if (sclp.has_kss) 434730cd632SFarhan Ali allow_cpu_feat(KVM_S390_VM_CPU_FEAT_KSS); 4355d3876a8SDavid Hildenbrand /* 4365d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_SKEY: Wrong shadow of PTE.I bits will make 4375d3876a8SDavid Hildenbrand * all skey handling functions read/set the skey from the PGSTE 4385d3876a8SDavid Hildenbrand * instead of the real storage key. 4395d3876a8SDavid Hildenbrand * 4405d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_CMMA: Wrong shadow of PTE.I bits will make 4415d3876a8SDavid Hildenbrand * pages being detected as preserved although they are resident. 4425d3876a8SDavid Hildenbrand * 4435d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_PFMFI: Wrong shadow of PTE.I bits will 4445d3876a8SDavid Hildenbrand * have the same effect as for KVM_S390_VM_CPU_FEAT_SKEY. 4455d3876a8SDavid Hildenbrand * 4465d3876a8SDavid Hildenbrand * For KVM_S390_VM_CPU_FEAT_SKEY, KVM_S390_VM_CPU_FEAT_CMMA and 4475d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_PFMFI, all PTE.I and PGSTE bits have to be 4485d3876a8SDavid Hildenbrand * correctly shadowed. We can do that for the PGSTE but not for PTE.I. 4495d3876a8SDavid Hildenbrand * 4505d3876a8SDavid Hildenbrand * KVM_S390_VM_CPU_FEAT_SIGPIF: Wrong SCB addresses in the SCA. We 4515d3876a8SDavid Hildenbrand * cannot easily shadow the SCA because of the ipte lock. 4525d3876a8SDavid Hildenbrand */ 45322be5a13SDavid Hildenbrand } 45422be5a13SDavid Hildenbrand 455b0c632dbSHeiko Carstens int kvm_arch_init(void *opaque) 456b0c632dbSHeiko Carstens { 457f76f6371SJanosch Frank int rc = -ENOMEM; 458308c3e66SMichael Mueller 45978f26131SChristian Borntraeger kvm_s390_dbf = debug_register("kvm-trace", 32, 1, 7 * sizeof(long)); 46078f26131SChristian Borntraeger if (!kvm_s390_dbf) 46178f26131SChristian Borntraeger return -ENOMEM; 46278f26131SChristian Borntraeger 463f76f6371SJanosch Frank if (debug_register_view(kvm_s390_dbf, &debug_sprintf_view)) 464f76f6371SJanosch Frank goto out; 46578f26131SChristian Borntraeger 46622be5a13SDavid Hildenbrand kvm_s390_cpu_feat_init(); 46722be5a13SDavid Hildenbrand 46884877d93SCornelia Huck /* Register floating interrupt controller interface. */ 469308c3e66SMichael Mueller rc = kvm_register_device_ops(&kvm_flic_ops, KVM_DEV_TYPE_FLIC); 470308c3e66SMichael Mueller if (rc) { 4718d43d570SMichael Mueller pr_err("A FLIC registration call failed with rc=%d\n", rc); 472f76f6371SJanosch Frank goto out; 473308c3e66SMichael Mueller } 474b1d1e76eSMichael Mueller 475b1d1e76eSMichael Mueller rc = kvm_s390_gib_init(GAL_ISC); 476b1d1e76eSMichael Mueller if (rc) 477f76f6371SJanosch Frank goto out; 478b1d1e76eSMichael Mueller 479308c3e66SMichael Mueller return 0; 480308c3e66SMichael Mueller 481f76f6371SJanosch Frank out: 482f76f6371SJanosch Frank kvm_arch_exit(); 483308c3e66SMichael Mueller return rc; 484b0c632dbSHeiko Carstens } 485b0c632dbSHeiko Carstens 48678f26131SChristian Borntraeger void kvm_arch_exit(void) 48778f26131SChristian Borntraeger { 4881282c21eSMichael Mueller kvm_s390_gib_destroy(); 48978f26131SChristian Borntraeger debug_unregister(kvm_s390_dbf); 49078f26131SChristian Borntraeger } 49178f26131SChristian Borntraeger 492b0c632dbSHeiko Carstens /* Section: device related */ 493b0c632dbSHeiko Carstens long kvm_arch_dev_ioctl(struct file *filp, 494b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 495b0c632dbSHeiko Carstens { 496b0c632dbSHeiko Carstens if (ioctl == KVM_S390_ENABLE_SIE) 497b0c632dbSHeiko Carstens return s390_enable_sie(); 498b0c632dbSHeiko Carstens return -EINVAL; 499b0c632dbSHeiko Carstens } 500b0c632dbSHeiko Carstens 501784aa3d7SAlexander Graf int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) 502b0c632dbSHeiko Carstens { 503d7b0b5ebSCarsten Otte int r; 504d7b0b5ebSCarsten Otte 5052bd0ac4eSCarsten Otte switch (ext) { 506d7b0b5ebSCarsten Otte case KVM_CAP_S390_PSW: 507b6cf8788SChristian Borntraeger case KVM_CAP_S390_GMAP: 50852e16b18SChristian Borntraeger case KVM_CAP_SYNC_MMU: 5091efd0f59SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 5101efd0f59SCarsten Otte case KVM_CAP_S390_UCONTROL: 5111efd0f59SCarsten Otte #endif 5123c038e6bSDominik Dingel case KVM_CAP_ASYNC_PF: 51360b413c9SChristian Borntraeger case KVM_CAP_SYNC_REGS: 51414eebd91SCarsten Otte case KVM_CAP_ONE_REG: 515d6712df9SCornelia Huck case KVM_CAP_ENABLE_CAP: 516fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 51710ccaa1eSCornelia Huck case KVM_CAP_IOEVENTFD: 518c05c4186SJens Freimann case KVM_CAP_DEVICE_CTRL: 51978599d90SCornelia Huck case KVM_CAP_S390_IRQCHIP: 520f2061656SDominik Dingel case KVM_CAP_VM_ATTRIBUTES: 5216352e4d2SDavid Hildenbrand case KVM_CAP_MP_STATE: 522460df4c1SPaolo Bonzini case KVM_CAP_IMMEDIATE_EXIT: 52347b43c52SJens Freimann case KVM_CAP_S390_INJECT_IRQ: 5242444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 525e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 52630ee2a98SJason J. Herne case KVM_CAP_S390_SKEYS: 527816c7667SJens Freimann case KVM_CAP_S390_IRQ_STATE: 5286502a34cSDavid Hildenbrand case KVM_CAP_S390_USER_INSTR0: 5294036e387SClaudio Imbrenda case KVM_CAP_S390_CMMA_MIGRATION: 53047a4693eSYi Min Zhao case KVM_CAP_S390_AIS: 531da9a1446SChristian Borntraeger case KVM_CAP_S390_AIS_MIGRATION: 532d7b0b5ebSCarsten Otte r = 1; 533d7b0b5ebSCarsten Otte break; 534a4499382SJanosch Frank case KVM_CAP_S390_HPAGE_1M: 535a4499382SJanosch Frank r = 0; 53640ebdb8eSJanosch Frank if (hpage && !kvm_is_ucontrol(kvm)) 537a4499382SJanosch Frank r = 1; 538a4499382SJanosch Frank break; 53941408c28SThomas Huth case KVM_CAP_S390_MEM_OP: 54041408c28SThomas Huth r = MEM_OP_MAX_SIZE; 54141408c28SThomas Huth break; 542e726b1bdSChristian Borntraeger case KVM_CAP_NR_VCPUS: 543e726b1bdSChristian Borntraeger case KVM_CAP_MAX_VCPUS: 544a86cb413SThomas Huth case KVM_CAP_MAX_VCPU_ID: 54576a6dd72SDavid Hildenbrand r = KVM_S390_BSCA_CPU_SLOTS; 546a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) 547a6940674SDavid Hildenbrand r = KVM_MAX_VCPUS; 548a6940674SDavid Hildenbrand else if (sclp.has_esca && sclp.has_64bscao) 54976a6dd72SDavid Hildenbrand r = KVM_S390_ESCA_CPU_SLOTS; 550e726b1bdSChristian Borntraeger break; 5511526bf9cSChristian Borntraeger case KVM_CAP_S390_COW: 552abf09bedSMartin Schwidefsky r = MACHINE_HAS_ESOP; 5531526bf9cSChristian Borntraeger break; 55468c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 55568c55750SEric Farman r = MACHINE_HAS_VX; 55668c55750SEric Farman break; 557c6e5f166SFan Zhang case KVM_CAP_S390_RI: 558c6e5f166SFan Zhang r = test_facility(64); 559c6e5f166SFan Zhang break; 5604e0b1ab7SFan Zhang case KVM_CAP_S390_GS: 5614e0b1ab7SFan Zhang r = test_facility(133); 5624e0b1ab7SFan Zhang break; 56335b3fde6SChristian Borntraeger case KVM_CAP_S390_BPB: 56435b3fde6SChristian Borntraeger r = test_facility(82); 56535b3fde6SChristian Borntraeger break; 5662bd0ac4eSCarsten Otte default: 567d7b0b5ebSCarsten Otte r = 0; 568b0c632dbSHeiko Carstens } 569d7b0b5ebSCarsten Otte return r; 5702bd0ac4eSCarsten Otte } 571b0c632dbSHeiko Carstens 57215f36ebdSJason J. Herne static void kvm_s390_sync_dirty_log(struct kvm *kvm, 57315f36ebdSJason J. Herne struct kvm_memory_slot *memslot) 57415f36ebdSJason J. Herne { 5750959e168SJanosch Frank int i; 57615f36ebdSJason J. Herne gfn_t cur_gfn, last_gfn; 5770959e168SJanosch Frank unsigned long gaddr, vmaddr; 57815f36ebdSJason J. Herne struct gmap *gmap = kvm->arch.gmap; 5790959e168SJanosch Frank DECLARE_BITMAP(bitmap, _PAGE_ENTRIES); 58015f36ebdSJason J. Herne 5810959e168SJanosch Frank /* Loop over all guest segments */ 5820959e168SJanosch Frank cur_gfn = memslot->base_gfn; 58315f36ebdSJason J. Herne last_gfn = memslot->base_gfn + memslot->npages; 5840959e168SJanosch Frank for (; cur_gfn <= last_gfn; cur_gfn += _PAGE_ENTRIES) { 5850959e168SJanosch Frank gaddr = gfn_to_gpa(cur_gfn); 5860959e168SJanosch Frank vmaddr = gfn_to_hva_memslot(memslot, cur_gfn); 5870959e168SJanosch Frank if (kvm_is_error_hva(vmaddr)) 5880959e168SJanosch Frank continue; 58915f36ebdSJason J. Herne 5900959e168SJanosch Frank bitmap_zero(bitmap, _PAGE_ENTRIES); 5910959e168SJanosch Frank gmap_sync_dirty_log_pmd(gmap, bitmap, gaddr, vmaddr); 5920959e168SJanosch Frank for (i = 0; i < _PAGE_ENTRIES; i++) { 5930959e168SJanosch Frank if (test_bit(i, bitmap)) 5940959e168SJanosch Frank mark_page_dirty(kvm, cur_gfn + i); 5950959e168SJanosch Frank } 5960959e168SJanosch Frank 5971763f8d0SChristian Borntraeger if (fatal_signal_pending(current)) 5981763f8d0SChristian Borntraeger return; 59970c88a00SChristian Borntraeger cond_resched(); 60015f36ebdSJason J. Herne } 60115f36ebdSJason J. Herne } 60215f36ebdSJason J. Herne 603b0c632dbSHeiko Carstens /* Section: vm related */ 604a6e2f683SEugene (jno) Dvurechenski static void sca_del_vcpu(struct kvm_vcpu *vcpu); 605a6e2f683SEugene (jno) Dvurechenski 606b0c632dbSHeiko Carstens /* 607b0c632dbSHeiko Carstens * Get (and clear) the dirty memory log for a memory slot. 608b0c632dbSHeiko Carstens */ 609b0c632dbSHeiko Carstens int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, 610b0c632dbSHeiko Carstens struct kvm_dirty_log *log) 611b0c632dbSHeiko Carstens { 61215f36ebdSJason J. Herne int r; 61315f36ebdSJason J. Herne unsigned long n; 6149f6b8029SPaolo Bonzini struct kvm_memslots *slots; 61515f36ebdSJason J. Herne struct kvm_memory_slot *memslot; 61615f36ebdSJason J. Herne int is_dirty = 0; 61715f36ebdSJason J. Herne 618e1e8a962SJanosch Frank if (kvm_is_ucontrol(kvm)) 619e1e8a962SJanosch Frank return -EINVAL; 620e1e8a962SJanosch Frank 62115f36ebdSJason J. Herne mutex_lock(&kvm->slots_lock); 62215f36ebdSJason J. Herne 62315f36ebdSJason J. Herne r = -EINVAL; 62415f36ebdSJason J. Herne if (log->slot >= KVM_USER_MEM_SLOTS) 62515f36ebdSJason J. Herne goto out; 62615f36ebdSJason J. Herne 6279f6b8029SPaolo Bonzini slots = kvm_memslots(kvm); 6289f6b8029SPaolo Bonzini memslot = id_to_memslot(slots, log->slot); 62915f36ebdSJason J. Herne r = -ENOENT; 63015f36ebdSJason J. Herne if (!memslot->dirty_bitmap) 63115f36ebdSJason J. Herne goto out; 63215f36ebdSJason J. Herne 63315f36ebdSJason J. Herne kvm_s390_sync_dirty_log(kvm, memslot); 63415f36ebdSJason J. Herne r = kvm_get_dirty_log(kvm, log, &is_dirty); 63515f36ebdSJason J. Herne if (r) 63615f36ebdSJason J. Herne goto out; 63715f36ebdSJason J. Herne 63815f36ebdSJason J. Herne /* Clear the dirty log */ 63915f36ebdSJason J. Herne if (is_dirty) { 64015f36ebdSJason J. Herne n = kvm_dirty_bitmap_bytes(memslot); 64115f36ebdSJason J. Herne memset(memslot->dirty_bitmap, 0, n); 64215f36ebdSJason J. Herne } 64315f36ebdSJason J. Herne r = 0; 64415f36ebdSJason J. Herne out: 64515f36ebdSJason J. Herne mutex_unlock(&kvm->slots_lock); 64615f36ebdSJason J. Herne return r; 647b0c632dbSHeiko Carstens } 648b0c632dbSHeiko Carstens 6496502a34cSDavid Hildenbrand static void icpt_operexc_on_all_vcpus(struct kvm *kvm) 6506502a34cSDavid Hildenbrand { 6516502a34cSDavid Hildenbrand unsigned int i; 6526502a34cSDavid Hildenbrand struct kvm_vcpu *vcpu; 6536502a34cSDavid Hildenbrand 6546502a34cSDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 6556502a34cSDavid Hildenbrand kvm_s390_sync_request(KVM_REQ_ICPT_OPEREXC, vcpu); 6566502a34cSDavid Hildenbrand } 6576502a34cSDavid Hildenbrand } 6586502a34cSDavid Hildenbrand 659e5d83c74SPaolo Bonzini int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap) 660d938dc55SCornelia Huck { 661d938dc55SCornelia Huck int r; 662d938dc55SCornelia Huck 663d938dc55SCornelia Huck if (cap->flags) 664d938dc55SCornelia Huck return -EINVAL; 665d938dc55SCornelia Huck 666d938dc55SCornelia Huck switch (cap->cap) { 66784223598SCornelia Huck case KVM_CAP_S390_IRQCHIP: 668c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_IRQCHIP"); 66984223598SCornelia Huck kvm->arch.use_irqchip = 1; 67084223598SCornelia Huck r = 0; 67184223598SCornelia Huck break; 6722444b352SDavid Hildenbrand case KVM_CAP_S390_USER_SIGP: 673c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_SIGP"); 6742444b352SDavid Hildenbrand kvm->arch.user_sigp = 1; 6752444b352SDavid Hildenbrand r = 0; 6762444b352SDavid Hildenbrand break; 67768c55750SEric Farman case KVM_CAP_S390_VECTOR_REGISTERS: 6785967c17bSDavid Hildenbrand mutex_lock(&kvm->lock); 679a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 6805967c17bSDavid Hildenbrand r = -EBUSY; 6815967c17bSDavid Hildenbrand } else if (MACHINE_HAS_VX) { 682c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 129); 683c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 129); 6842f87d942SGuenther Hutzl if (test_facility(134)) { 6852f87d942SGuenther Hutzl set_kvm_facility(kvm->arch.model.fac_mask, 134); 6862f87d942SGuenther Hutzl set_kvm_facility(kvm->arch.model.fac_list, 134); 6872f87d942SGuenther Hutzl } 68853743aa7SMaxim Samoylov if (test_facility(135)) { 68953743aa7SMaxim Samoylov set_kvm_facility(kvm->arch.model.fac_mask, 135); 69053743aa7SMaxim Samoylov set_kvm_facility(kvm->arch.model.fac_list, 135); 69153743aa7SMaxim Samoylov } 6927832e91cSChristian Borntraeger if (test_facility(148)) { 6937832e91cSChristian Borntraeger set_kvm_facility(kvm->arch.model.fac_mask, 148); 6947832e91cSChristian Borntraeger set_kvm_facility(kvm->arch.model.fac_list, 148); 6957832e91cSChristian Borntraeger } 696d5cb6ab1SChristian Borntraeger if (test_facility(152)) { 697d5cb6ab1SChristian Borntraeger set_kvm_facility(kvm->arch.model.fac_mask, 152); 698d5cb6ab1SChristian Borntraeger set_kvm_facility(kvm->arch.model.fac_list, 152); 699d5cb6ab1SChristian Borntraeger } 70018280d8bSMichael Mueller r = 0; 70118280d8bSMichael Mueller } else 70218280d8bSMichael Mueller r = -EINVAL; 7035967c17bSDavid Hildenbrand mutex_unlock(&kvm->lock); 704c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "ENABLE: CAP_S390_VECTOR_REGISTERS %s", 705c92ea7b9SChristian Borntraeger r ? "(not available)" : "(success)"); 70668c55750SEric Farman break; 707c6e5f166SFan Zhang case KVM_CAP_S390_RI: 708c6e5f166SFan Zhang r = -EINVAL; 709c6e5f166SFan Zhang mutex_lock(&kvm->lock); 710a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 711c6e5f166SFan Zhang r = -EBUSY; 712c6e5f166SFan Zhang } else if (test_facility(64)) { 713c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 64); 714c54f0d6aSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 64); 715c6e5f166SFan Zhang r = 0; 716c6e5f166SFan Zhang } 717c6e5f166SFan Zhang mutex_unlock(&kvm->lock); 718c6e5f166SFan Zhang VM_EVENT(kvm, 3, "ENABLE: CAP_S390_RI %s", 719c6e5f166SFan Zhang r ? "(not available)" : "(success)"); 720c6e5f166SFan Zhang break; 72147a4693eSYi Min Zhao case KVM_CAP_S390_AIS: 72247a4693eSYi Min Zhao mutex_lock(&kvm->lock); 72347a4693eSYi Min Zhao if (kvm->created_vcpus) { 72447a4693eSYi Min Zhao r = -EBUSY; 72547a4693eSYi Min Zhao } else { 72647a4693eSYi Min Zhao set_kvm_facility(kvm->arch.model.fac_mask, 72); 72747a4693eSYi Min Zhao set_kvm_facility(kvm->arch.model.fac_list, 72); 72847a4693eSYi Min Zhao r = 0; 72947a4693eSYi Min Zhao } 73047a4693eSYi Min Zhao mutex_unlock(&kvm->lock); 73147a4693eSYi Min Zhao VM_EVENT(kvm, 3, "ENABLE: AIS %s", 73247a4693eSYi Min Zhao r ? "(not available)" : "(success)"); 73347a4693eSYi Min Zhao break; 7344e0b1ab7SFan Zhang case KVM_CAP_S390_GS: 7354e0b1ab7SFan Zhang r = -EINVAL; 7364e0b1ab7SFan Zhang mutex_lock(&kvm->lock); 737241e3ec0SChristian Borntraeger if (kvm->created_vcpus) { 7384e0b1ab7SFan Zhang r = -EBUSY; 7394e0b1ab7SFan Zhang } else if (test_facility(133)) { 7404e0b1ab7SFan Zhang set_kvm_facility(kvm->arch.model.fac_mask, 133); 7414e0b1ab7SFan Zhang set_kvm_facility(kvm->arch.model.fac_list, 133); 7424e0b1ab7SFan Zhang r = 0; 7434e0b1ab7SFan Zhang } 7444e0b1ab7SFan Zhang mutex_unlock(&kvm->lock); 7454e0b1ab7SFan Zhang VM_EVENT(kvm, 3, "ENABLE: CAP_S390_GS %s", 7464e0b1ab7SFan Zhang r ? "(not available)" : "(success)"); 7474e0b1ab7SFan Zhang break; 748a4499382SJanosch Frank case KVM_CAP_S390_HPAGE_1M: 749a4499382SJanosch Frank mutex_lock(&kvm->lock); 750a4499382SJanosch Frank if (kvm->created_vcpus) 751a4499382SJanosch Frank r = -EBUSY; 75240ebdb8eSJanosch Frank else if (!hpage || kvm->arch.use_cmma || kvm_is_ucontrol(kvm)) 753a4499382SJanosch Frank r = -EINVAL; 754a4499382SJanosch Frank else { 755a4499382SJanosch Frank r = 0; 756df88f318SJanosch Frank down_write(&kvm->mm->mmap_sem); 757a4499382SJanosch Frank kvm->mm->context.allow_gmap_hpage_1m = 1; 758df88f318SJanosch Frank up_write(&kvm->mm->mmap_sem); 759a4499382SJanosch Frank /* 760a4499382SJanosch Frank * We might have to create fake 4k page 761a4499382SJanosch Frank * tables. To avoid that the hardware works on 762a4499382SJanosch Frank * stale PGSTEs, we emulate these instructions. 763a4499382SJanosch Frank */ 764a4499382SJanosch Frank kvm->arch.use_skf = 0; 765a4499382SJanosch Frank kvm->arch.use_pfmfi = 0; 766a4499382SJanosch Frank } 767a4499382SJanosch Frank mutex_unlock(&kvm->lock); 768a4499382SJanosch Frank VM_EVENT(kvm, 3, "ENABLE: CAP_S390_HPAGE %s", 769a4499382SJanosch Frank r ? "(not available)" : "(success)"); 770a4499382SJanosch Frank break; 771e44fc8c9SEkaterina Tumanova case KVM_CAP_S390_USER_STSI: 772c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_STSI"); 773e44fc8c9SEkaterina Tumanova kvm->arch.user_stsi = 1; 774e44fc8c9SEkaterina Tumanova r = 0; 775e44fc8c9SEkaterina Tumanova break; 7766502a34cSDavid Hildenbrand case KVM_CAP_S390_USER_INSTR0: 7776502a34cSDavid Hildenbrand VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_INSTR0"); 7786502a34cSDavid Hildenbrand kvm->arch.user_instr0 = 1; 7796502a34cSDavid Hildenbrand icpt_operexc_on_all_vcpus(kvm); 7806502a34cSDavid Hildenbrand r = 0; 7816502a34cSDavid Hildenbrand break; 782d938dc55SCornelia Huck default: 783d938dc55SCornelia Huck r = -EINVAL; 784d938dc55SCornelia Huck break; 785d938dc55SCornelia Huck } 786d938dc55SCornelia Huck return r; 787d938dc55SCornelia Huck } 788d938dc55SCornelia Huck 7898c0a7ce6SDominik Dingel static int kvm_s390_get_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 7908c0a7ce6SDominik Dingel { 7918c0a7ce6SDominik Dingel int ret; 7928c0a7ce6SDominik Dingel 7938c0a7ce6SDominik Dingel switch (attr->attr) { 7948c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 7958c0a7ce6SDominik Dingel ret = 0; 796c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: max guest memory: %lu bytes", 797a3a92c31SDominik Dingel kvm->arch.mem_limit); 798a3a92c31SDominik Dingel if (put_user(kvm->arch.mem_limit, (u64 __user *)attr->addr)) 7998c0a7ce6SDominik Dingel ret = -EFAULT; 8008c0a7ce6SDominik Dingel break; 8018c0a7ce6SDominik Dingel default: 8028c0a7ce6SDominik Dingel ret = -ENXIO; 8038c0a7ce6SDominik Dingel break; 8048c0a7ce6SDominik Dingel } 8058c0a7ce6SDominik Dingel return ret; 8068c0a7ce6SDominik Dingel } 8078c0a7ce6SDominik Dingel 8088c0a7ce6SDominik Dingel static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *attr) 8094f718eabSDominik Dingel { 8104f718eabSDominik Dingel int ret; 8114f718eabSDominik Dingel unsigned int idx; 8124f718eabSDominik Dingel switch (attr->attr) { 8134f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 814f9cbd9b0SDavid Hildenbrand ret = -ENXIO; 815c24cc9c8SDavid Hildenbrand if (!sclp.has_cmma) 816e6db1d61SDominik Dingel break; 817e6db1d61SDominik Dingel 818c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: CMMA support"); 8194f718eabSDominik Dingel mutex_lock(&kvm->lock); 820a4499382SJanosch Frank if (kvm->created_vcpus) 821a4499382SJanosch Frank ret = -EBUSY; 822a4499382SJanosch Frank else if (kvm->mm->context.allow_gmap_hpage_1m) 823a4499382SJanosch Frank ret = -EINVAL; 824a4499382SJanosch Frank else { 8254f718eabSDominik Dingel kvm->arch.use_cmma = 1; 826c9f0a2b8SJanosch Frank /* Not compatible with cmma. */ 827c9f0a2b8SJanosch Frank kvm->arch.use_pfmfi = 0; 8284f718eabSDominik Dingel ret = 0; 8294f718eabSDominik Dingel } 8304f718eabSDominik Dingel mutex_unlock(&kvm->lock); 8314f718eabSDominik Dingel break; 8324f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 833f9cbd9b0SDavid Hildenbrand ret = -ENXIO; 834f9cbd9b0SDavid Hildenbrand if (!sclp.has_cmma) 835f9cbd9b0SDavid Hildenbrand break; 836c3489155SDominik Dingel ret = -EINVAL; 837c3489155SDominik Dingel if (!kvm->arch.use_cmma) 838c3489155SDominik Dingel break; 839c3489155SDominik Dingel 840c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "RESET: CMMA states"); 8414f718eabSDominik Dingel mutex_lock(&kvm->lock); 8424f718eabSDominik Dingel idx = srcu_read_lock(&kvm->srcu); 843a13cff31SDominik Dingel s390_reset_cmma(kvm->arch.gmap->mm); 8444f718eabSDominik Dingel srcu_read_unlock(&kvm->srcu, idx); 8454f718eabSDominik Dingel mutex_unlock(&kvm->lock); 8464f718eabSDominik Dingel ret = 0; 8474f718eabSDominik Dingel break; 8488c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: { 8498c0a7ce6SDominik Dingel unsigned long new_limit; 8508c0a7ce6SDominik Dingel 8518c0a7ce6SDominik Dingel if (kvm_is_ucontrol(kvm)) 8528c0a7ce6SDominik Dingel return -EINVAL; 8538c0a7ce6SDominik Dingel 8548c0a7ce6SDominik Dingel if (get_user(new_limit, (u64 __user *)attr->addr)) 8558c0a7ce6SDominik Dingel return -EFAULT; 8568c0a7ce6SDominik Dingel 857a3a92c31SDominik Dingel if (kvm->arch.mem_limit != KVM_S390_NO_MEM_LIMIT && 858a3a92c31SDominik Dingel new_limit > kvm->arch.mem_limit) 8598c0a7ce6SDominik Dingel return -E2BIG; 8608c0a7ce6SDominik Dingel 861a3a92c31SDominik Dingel if (!new_limit) 862a3a92c31SDominik Dingel return -EINVAL; 863a3a92c31SDominik Dingel 8646ea427bbSMartin Schwidefsky /* gmap_create takes last usable address */ 865a3a92c31SDominik Dingel if (new_limit != KVM_S390_NO_MEM_LIMIT) 866a3a92c31SDominik Dingel new_limit -= 1; 867a3a92c31SDominik Dingel 8688c0a7ce6SDominik Dingel ret = -EBUSY; 8698c0a7ce6SDominik Dingel mutex_lock(&kvm->lock); 870a03825bbSPaolo Bonzini if (!kvm->created_vcpus) { 8716ea427bbSMartin Schwidefsky /* gmap_create will round the limit up */ 8726ea427bbSMartin Schwidefsky struct gmap *new = gmap_create(current->mm, new_limit); 8738c0a7ce6SDominik Dingel 8748c0a7ce6SDominik Dingel if (!new) { 8758c0a7ce6SDominik Dingel ret = -ENOMEM; 8768c0a7ce6SDominik Dingel } else { 8776ea427bbSMartin Schwidefsky gmap_remove(kvm->arch.gmap); 8788c0a7ce6SDominik Dingel new->private = kvm; 8798c0a7ce6SDominik Dingel kvm->arch.gmap = new; 8808c0a7ce6SDominik Dingel ret = 0; 8818c0a7ce6SDominik Dingel } 8828c0a7ce6SDominik Dingel } 8838c0a7ce6SDominik Dingel mutex_unlock(&kvm->lock); 884a3a92c31SDominik Dingel VM_EVENT(kvm, 3, "SET: max guest address: %lu", new_limit); 885a3a92c31SDominik Dingel VM_EVENT(kvm, 3, "New guest asce: 0x%pK", 886a3a92c31SDominik Dingel (void *) kvm->arch.gmap->asce); 8878c0a7ce6SDominik Dingel break; 8888c0a7ce6SDominik Dingel } 8894f718eabSDominik Dingel default: 8904f718eabSDominik Dingel ret = -ENXIO; 8914f718eabSDominik Dingel break; 8924f718eabSDominik Dingel } 8934f718eabSDominik Dingel return ret; 8944f718eabSDominik Dingel } 8954f718eabSDominik Dingel 896a374e892STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu); 897a374e892STony Krowiak 89820c922f0STony Krowiak void kvm_s390_vcpu_crypto_reset_all(struct kvm *kvm) 899a374e892STony Krowiak { 900a374e892STony Krowiak struct kvm_vcpu *vcpu; 901a374e892STony Krowiak int i; 902a374e892STony Krowiak 90320c922f0STony Krowiak kvm_s390_vcpu_block_all(kvm); 90420c922f0STony Krowiak 9053194cdb7SDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 90620c922f0STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 9073194cdb7SDavid Hildenbrand /* recreate the shadow crycb by leaving the VSIE handler */ 9083194cdb7SDavid Hildenbrand kvm_s390_sync_request(KVM_REQ_VSIE_RESTART, vcpu); 9093194cdb7SDavid Hildenbrand } 91020c922f0STony Krowiak 91120c922f0STony Krowiak kvm_s390_vcpu_unblock_all(kvm); 91220c922f0STony Krowiak } 91320c922f0STony Krowiak 91420c922f0STony Krowiak static int kvm_s390_vm_set_crypto(struct kvm *kvm, struct kvm_device_attr *attr) 91520c922f0STony Krowiak { 916a374e892STony Krowiak mutex_lock(&kvm->lock); 917a374e892STony Krowiak switch (attr->attr) { 918a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 9198e41bd54SChristian Borntraeger if (!test_kvm_facility(kvm, 76)) { 9208e41bd54SChristian Borntraeger mutex_unlock(&kvm->lock); 92137940fb0STony Krowiak return -EINVAL; 9228e41bd54SChristian Borntraeger } 923a374e892STony Krowiak get_random_bytes( 924a374e892STony Krowiak kvm->arch.crypto.crycb->aes_wrapping_key_mask, 925a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 926a374e892STony Krowiak kvm->arch.crypto.aes_kw = 1; 927c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: AES keywrapping support"); 928a374e892STony Krowiak break; 929a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 9308e41bd54SChristian Borntraeger if (!test_kvm_facility(kvm, 76)) { 9318e41bd54SChristian Borntraeger mutex_unlock(&kvm->lock); 93237940fb0STony Krowiak return -EINVAL; 9338e41bd54SChristian Borntraeger } 934a374e892STony Krowiak get_random_bytes( 935a374e892STony Krowiak kvm->arch.crypto.crycb->dea_wrapping_key_mask, 936a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 937a374e892STony Krowiak kvm->arch.crypto.dea_kw = 1; 938c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "ENABLE: DEA keywrapping support"); 939a374e892STony Krowiak break; 940a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 9418e41bd54SChristian Borntraeger if (!test_kvm_facility(kvm, 76)) { 9428e41bd54SChristian Borntraeger mutex_unlock(&kvm->lock); 94337940fb0STony Krowiak return -EINVAL; 9448e41bd54SChristian Borntraeger } 945a374e892STony Krowiak kvm->arch.crypto.aes_kw = 0; 946a374e892STony Krowiak memset(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 0, 947a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 948c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "DISABLE: AES keywrapping support"); 949a374e892STony Krowiak break; 950a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 9518e41bd54SChristian Borntraeger if (!test_kvm_facility(kvm, 76)) { 9528e41bd54SChristian Borntraeger mutex_unlock(&kvm->lock); 95337940fb0STony Krowiak return -EINVAL; 9548e41bd54SChristian Borntraeger } 955a374e892STony Krowiak kvm->arch.crypto.dea_kw = 0; 956a374e892STony Krowiak memset(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 0, 957a374e892STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 958c92ea7b9SChristian Borntraeger VM_EVENT(kvm, 3, "%s", "DISABLE: DEA keywrapping support"); 959a374e892STony Krowiak break; 96037940fb0STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_APIE: 96137940fb0STony Krowiak if (!ap_instructions_available()) { 96237940fb0STony Krowiak mutex_unlock(&kvm->lock); 96337940fb0STony Krowiak return -EOPNOTSUPP; 96437940fb0STony Krowiak } 96537940fb0STony Krowiak kvm->arch.crypto.apie = 1; 96637940fb0STony Krowiak break; 96737940fb0STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_APIE: 96837940fb0STony Krowiak if (!ap_instructions_available()) { 96937940fb0STony Krowiak mutex_unlock(&kvm->lock); 97037940fb0STony Krowiak return -EOPNOTSUPP; 97137940fb0STony Krowiak } 97237940fb0STony Krowiak kvm->arch.crypto.apie = 0; 97337940fb0STony Krowiak break; 974a374e892STony Krowiak default: 975a374e892STony Krowiak mutex_unlock(&kvm->lock); 976a374e892STony Krowiak return -ENXIO; 977a374e892STony Krowiak } 978a374e892STony Krowiak 97920c922f0STony Krowiak kvm_s390_vcpu_crypto_reset_all(kvm); 980a374e892STony Krowiak mutex_unlock(&kvm->lock); 981a374e892STony Krowiak return 0; 982a374e892STony Krowiak } 983a374e892STony Krowiak 984190df4a2SClaudio Imbrenda static void kvm_s390_sync_request_broadcast(struct kvm *kvm, int req) 985190df4a2SClaudio Imbrenda { 986190df4a2SClaudio Imbrenda int cx; 987190df4a2SClaudio Imbrenda struct kvm_vcpu *vcpu; 988190df4a2SClaudio Imbrenda 989190df4a2SClaudio Imbrenda kvm_for_each_vcpu(cx, vcpu, kvm) 990190df4a2SClaudio Imbrenda kvm_s390_sync_request(req, vcpu); 991190df4a2SClaudio Imbrenda } 992190df4a2SClaudio Imbrenda 993190df4a2SClaudio Imbrenda /* 994190df4a2SClaudio Imbrenda * Must be called with kvm->srcu held to avoid races on memslots, and with 9951de1ea7eSChristian Borntraeger * kvm->slots_lock to avoid races with ourselves and kvm_s390_vm_stop_migration. 996190df4a2SClaudio Imbrenda */ 997190df4a2SClaudio Imbrenda static int kvm_s390_vm_start_migration(struct kvm *kvm) 998190df4a2SClaudio Imbrenda { 999190df4a2SClaudio Imbrenda struct kvm_memory_slot *ms; 1000190df4a2SClaudio Imbrenda struct kvm_memslots *slots; 1001afdad616SClaudio Imbrenda unsigned long ram_pages = 0; 1002190df4a2SClaudio Imbrenda int slotnr; 1003190df4a2SClaudio Imbrenda 1004190df4a2SClaudio Imbrenda /* migration mode already enabled */ 1005afdad616SClaudio Imbrenda if (kvm->arch.migration_mode) 1006190df4a2SClaudio Imbrenda return 0; 1007190df4a2SClaudio Imbrenda slots = kvm_memslots(kvm); 1008190df4a2SClaudio Imbrenda if (!slots || !slots->used_slots) 1009190df4a2SClaudio Imbrenda return -EINVAL; 1010190df4a2SClaudio Imbrenda 1011afdad616SClaudio Imbrenda if (!kvm->arch.use_cmma) { 1012afdad616SClaudio Imbrenda kvm->arch.migration_mode = 1; 1013afdad616SClaudio Imbrenda return 0; 1014190df4a2SClaudio Imbrenda } 1015190df4a2SClaudio Imbrenda /* mark all the pages in active slots as dirty */ 1016190df4a2SClaudio Imbrenda for (slotnr = 0; slotnr < slots->used_slots; slotnr++) { 1017190df4a2SClaudio Imbrenda ms = slots->memslots + slotnr; 101813a17cc0SIgor Mammedov if (!ms->dirty_bitmap) 101913a17cc0SIgor Mammedov return -EINVAL; 1020afdad616SClaudio Imbrenda /* 1021afdad616SClaudio Imbrenda * The second half of the bitmap is only used on x86, 1022afdad616SClaudio Imbrenda * and would be wasted otherwise, so we put it to good 1023afdad616SClaudio Imbrenda * use here to keep track of the state of the storage 1024afdad616SClaudio Imbrenda * attributes. 1025afdad616SClaudio Imbrenda */ 1026afdad616SClaudio Imbrenda memset(kvm_second_dirty_bitmap(ms), 0xff, kvm_dirty_bitmap_bytes(ms)); 1027afdad616SClaudio Imbrenda ram_pages += ms->npages; 1028190df4a2SClaudio Imbrenda } 1029afdad616SClaudio Imbrenda atomic64_set(&kvm->arch.cmma_dirty_pages, ram_pages); 1030afdad616SClaudio Imbrenda kvm->arch.migration_mode = 1; 1031190df4a2SClaudio Imbrenda kvm_s390_sync_request_broadcast(kvm, KVM_REQ_START_MIGRATION); 1032190df4a2SClaudio Imbrenda return 0; 1033190df4a2SClaudio Imbrenda } 1034190df4a2SClaudio Imbrenda 1035190df4a2SClaudio Imbrenda /* 10361de1ea7eSChristian Borntraeger * Must be called with kvm->slots_lock to avoid races with ourselves and 1037190df4a2SClaudio Imbrenda * kvm_s390_vm_start_migration. 1038190df4a2SClaudio Imbrenda */ 1039190df4a2SClaudio Imbrenda static int kvm_s390_vm_stop_migration(struct kvm *kvm) 1040190df4a2SClaudio Imbrenda { 1041190df4a2SClaudio Imbrenda /* migration mode already disabled */ 1042afdad616SClaudio Imbrenda if (!kvm->arch.migration_mode) 1043190df4a2SClaudio Imbrenda return 0; 1044afdad616SClaudio Imbrenda kvm->arch.migration_mode = 0; 1045afdad616SClaudio Imbrenda if (kvm->arch.use_cmma) 1046190df4a2SClaudio Imbrenda kvm_s390_sync_request_broadcast(kvm, KVM_REQ_STOP_MIGRATION); 1047190df4a2SClaudio Imbrenda return 0; 1048190df4a2SClaudio Imbrenda } 1049190df4a2SClaudio Imbrenda 1050190df4a2SClaudio Imbrenda static int kvm_s390_vm_set_migration(struct kvm *kvm, 1051190df4a2SClaudio Imbrenda struct kvm_device_attr *attr) 1052190df4a2SClaudio Imbrenda { 10531de1ea7eSChristian Borntraeger int res = -ENXIO; 1054190df4a2SClaudio Imbrenda 10551de1ea7eSChristian Borntraeger mutex_lock(&kvm->slots_lock); 1056190df4a2SClaudio Imbrenda switch (attr->attr) { 1057190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION_START: 1058190df4a2SClaudio Imbrenda res = kvm_s390_vm_start_migration(kvm); 1059190df4a2SClaudio Imbrenda break; 1060190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION_STOP: 1061190df4a2SClaudio Imbrenda res = kvm_s390_vm_stop_migration(kvm); 1062190df4a2SClaudio Imbrenda break; 1063190df4a2SClaudio Imbrenda default: 1064190df4a2SClaudio Imbrenda break; 1065190df4a2SClaudio Imbrenda } 10661de1ea7eSChristian Borntraeger mutex_unlock(&kvm->slots_lock); 1067190df4a2SClaudio Imbrenda 1068190df4a2SClaudio Imbrenda return res; 1069190df4a2SClaudio Imbrenda } 1070190df4a2SClaudio Imbrenda 1071190df4a2SClaudio Imbrenda static int kvm_s390_vm_get_migration(struct kvm *kvm, 1072190df4a2SClaudio Imbrenda struct kvm_device_attr *attr) 1073190df4a2SClaudio Imbrenda { 1074afdad616SClaudio Imbrenda u64 mig = kvm->arch.migration_mode; 1075190df4a2SClaudio Imbrenda 1076190df4a2SClaudio Imbrenda if (attr->attr != KVM_S390_VM_MIGRATION_STATUS) 1077190df4a2SClaudio Imbrenda return -ENXIO; 1078190df4a2SClaudio Imbrenda 1079190df4a2SClaudio Imbrenda if (copy_to_user((void __user *)attr->addr, &mig, sizeof(mig))) 1080190df4a2SClaudio Imbrenda return -EFAULT; 1081190df4a2SClaudio Imbrenda return 0; 1082190df4a2SClaudio Imbrenda } 1083190df4a2SClaudio Imbrenda 10848fa1696eSCollin L. Walling static int kvm_s390_set_tod_ext(struct kvm *kvm, struct kvm_device_attr *attr) 10858fa1696eSCollin L. Walling { 10868fa1696eSCollin L. Walling struct kvm_s390_vm_tod_clock gtod; 10878fa1696eSCollin L. Walling 10888fa1696eSCollin L. Walling if (copy_from_user(>od, (void __user *)attr->addr, sizeof(gtod))) 10898fa1696eSCollin L. Walling return -EFAULT; 10908fa1696eSCollin L. Walling 10910e7def5fSDavid Hildenbrand if (!test_kvm_facility(kvm, 139) && gtod.epoch_idx) 10928fa1696eSCollin L. Walling return -EINVAL; 10930e7def5fSDavid Hildenbrand kvm_s390_set_tod_clock(kvm, >od); 10948fa1696eSCollin L. Walling 10958fa1696eSCollin L. Walling VM_EVENT(kvm, 3, "SET: TOD extension: 0x%x, TOD base: 0x%llx", 10968fa1696eSCollin L. Walling gtod.epoch_idx, gtod.tod); 10978fa1696eSCollin L. Walling 10988fa1696eSCollin L. Walling return 0; 10998fa1696eSCollin L. Walling } 11008fa1696eSCollin L. Walling 110172f25020SJason J. Herne static int kvm_s390_set_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 110272f25020SJason J. Herne { 110372f25020SJason J. Herne u8 gtod_high; 110472f25020SJason J. Herne 110572f25020SJason J. Herne if (copy_from_user(>od_high, (void __user *)attr->addr, 110672f25020SJason J. Herne sizeof(gtod_high))) 110772f25020SJason J. Herne return -EFAULT; 110872f25020SJason J. Herne 110972f25020SJason J. Herne if (gtod_high != 0) 111072f25020SJason J. Herne return -EINVAL; 111158c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "SET: TOD extension: 0x%x", gtod_high); 111272f25020SJason J. Herne 111372f25020SJason J. Herne return 0; 111472f25020SJason J. Herne } 111572f25020SJason J. Herne 111672f25020SJason J. Herne static int kvm_s390_set_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 111772f25020SJason J. Herne { 11180e7def5fSDavid Hildenbrand struct kvm_s390_vm_tod_clock gtod = { 0 }; 111972f25020SJason J. Herne 11200e7def5fSDavid Hildenbrand if (copy_from_user(>od.tod, (void __user *)attr->addr, 11210e7def5fSDavid Hildenbrand sizeof(gtod.tod))) 112272f25020SJason J. Herne return -EFAULT; 112372f25020SJason J. Herne 11240e7def5fSDavid Hildenbrand kvm_s390_set_tod_clock(kvm, >od); 11250e7def5fSDavid Hildenbrand VM_EVENT(kvm, 3, "SET: TOD base: 0x%llx", gtod.tod); 112672f25020SJason J. Herne return 0; 112772f25020SJason J. Herne } 112872f25020SJason J. Herne 112972f25020SJason J. Herne static int kvm_s390_set_tod(struct kvm *kvm, struct kvm_device_attr *attr) 113072f25020SJason J. Herne { 113172f25020SJason J. Herne int ret; 113272f25020SJason J. Herne 113372f25020SJason J. Herne if (attr->flags) 113472f25020SJason J. Herne return -EINVAL; 113572f25020SJason J. Herne 113672f25020SJason J. Herne switch (attr->attr) { 11378fa1696eSCollin L. Walling case KVM_S390_VM_TOD_EXT: 11388fa1696eSCollin L. Walling ret = kvm_s390_set_tod_ext(kvm, attr); 11398fa1696eSCollin L. Walling break; 114072f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 114172f25020SJason J. Herne ret = kvm_s390_set_tod_high(kvm, attr); 114272f25020SJason J. Herne break; 114372f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 114472f25020SJason J. Herne ret = kvm_s390_set_tod_low(kvm, attr); 114572f25020SJason J. Herne break; 114672f25020SJason J. Herne default: 114772f25020SJason J. Herne ret = -ENXIO; 114872f25020SJason J. Herne break; 114972f25020SJason J. Herne } 115072f25020SJason J. Herne return ret; 115172f25020SJason J. Herne } 115272f25020SJason J. Herne 115333d1b272SDavid Hildenbrand static void kvm_s390_get_tod_clock(struct kvm *kvm, 11548fa1696eSCollin L. Walling struct kvm_s390_vm_tod_clock *gtod) 11558fa1696eSCollin L. Walling { 11568fa1696eSCollin L. Walling struct kvm_s390_tod_clock_ext htod; 11578fa1696eSCollin L. Walling 11588fa1696eSCollin L. Walling preempt_disable(); 11598fa1696eSCollin L. Walling 11608fa1696eSCollin L. Walling get_tod_clock_ext((char *)&htod); 11618fa1696eSCollin L. Walling 11628fa1696eSCollin L. Walling gtod->tod = htod.tod + kvm->arch.epoch; 116333d1b272SDavid Hildenbrand gtod->epoch_idx = 0; 116433d1b272SDavid Hildenbrand if (test_kvm_facility(kvm, 139)) { 11658fa1696eSCollin L. Walling gtod->epoch_idx = htod.epoch_idx + kvm->arch.epdx; 11668fa1696eSCollin L. Walling if (gtod->tod < htod.tod) 11678fa1696eSCollin L. Walling gtod->epoch_idx += 1; 116833d1b272SDavid Hildenbrand } 11698fa1696eSCollin L. Walling 11708fa1696eSCollin L. Walling preempt_enable(); 11718fa1696eSCollin L. Walling } 11728fa1696eSCollin L. Walling 11738fa1696eSCollin L. Walling static int kvm_s390_get_tod_ext(struct kvm *kvm, struct kvm_device_attr *attr) 11748fa1696eSCollin L. Walling { 11758fa1696eSCollin L. Walling struct kvm_s390_vm_tod_clock gtod; 11768fa1696eSCollin L. Walling 11778fa1696eSCollin L. Walling memset(>od, 0, sizeof(gtod)); 117833d1b272SDavid Hildenbrand kvm_s390_get_tod_clock(kvm, >od); 11798fa1696eSCollin L. Walling if (copy_to_user((void __user *)attr->addr, >od, sizeof(gtod))) 11808fa1696eSCollin L. Walling return -EFAULT; 11818fa1696eSCollin L. Walling 11828fa1696eSCollin L. Walling VM_EVENT(kvm, 3, "QUERY: TOD extension: 0x%x, TOD base: 0x%llx", 11838fa1696eSCollin L. Walling gtod.epoch_idx, gtod.tod); 11848fa1696eSCollin L. Walling return 0; 11858fa1696eSCollin L. Walling } 11868fa1696eSCollin L. Walling 118772f25020SJason J. Herne static int kvm_s390_get_tod_high(struct kvm *kvm, struct kvm_device_attr *attr) 118872f25020SJason J. Herne { 118972f25020SJason J. Herne u8 gtod_high = 0; 119072f25020SJason J. Herne 119172f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od_high, 119272f25020SJason J. Herne sizeof(gtod_high))) 119372f25020SJason J. Herne return -EFAULT; 119458c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: TOD extension: 0x%x", gtod_high); 119572f25020SJason J. Herne 119672f25020SJason J. Herne return 0; 119772f25020SJason J. Herne } 119872f25020SJason J. Herne 119972f25020SJason J. Herne static int kvm_s390_get_tod_low(struct kvm *kvm, struct kvm_device_attr *attr) 120072f25020SJason J. Herne { 12015a3d883aSDavid Hildenbrand u64 gtod; 120272f25020SJason J. Herne 120360417fccSDavid Hildenbrand gtod = kvm_s390_get_tod_clock_fast(kvm); 120472f25020SJason J. Herne if (copy_to_user((void __user *)attr->addr, >od, sizeof(gtod))) 120572f25020SJason J. Herne return -EFAULT; 120658c383c6SChristian Borntraeger VM_EVENT(kvm, 3, "QUERY: TOD base: 0x%llx", gtod); 120772f25020SJason J. Herne 120872f25020SJason J. Herne return 0; 120972f25020SJason J. Herne } 121072f25020SJason J. Herne 121172f25020SJason J. Herne static int kvm_s390_get_tod(struct kvm *kvm, struct kvm_device_attr *attr) 121272f25020SJason J. Herne { 121372f25020SJason J. Herne int ret; 121472f25020SJason J. Herne 121572f25020SJason J. Herne if (attr->flags) 121672f25020SJason J. Herne return -EINVAL; 121772f25020SJason J. Herne 121872f25020SJason J. Herne switch (attr->attr) { 12198fa1696eSCollin L. Walling case KVM_S390_VM_TOD_EXT: 12208fa1696eSCollin L. Walling ret = kvm_s390_get_tod_ext(kvm, attr); 12218fa1696eSCollin L. Walling break; 122272f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 122372f25020SJason J. Herne ret = kvm_s390_get_tod_high(kvm, attr); 122472f25020SJason J. Herne break; 122572f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 122672f25020SJason J. Herne ret = kvm_s390_get_tod_low(kvm, attr); 122772f25020SJason J. Herne break; 122872f25020SJason J. Herne default: 122972f25020SJason J. Herne ret = -ENXIO; 123072f25020SJason J. Herne break; 123172f25020SJason J. Herne } 123272f25020SJason J. Herne return ret; 123372f25020SJason J. Herne } 123472f25020SJason J. Herne 1235658b6edaSMichael Mueller static int kvm_s390_set_processor(struct kvm *kvm, struct kvm_device_attr *attr) 1236658b6edaSMichael Mueller { 1237658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 1238053dd230SDavid Hildenbrand u16 lowest_ibc, unblocked_ibc; 1239658b6edaSMichael Mueller int ret = 0; 1240658b6edaSMichael Mueller 1241658b6edaSMichael Mueller mutex_lock(&kvm->lock); 1242a03825bbSPaolo Bonzini if (kvm->created_vcpus) { 1243658b6edaSMichael Mueller ret = -EBUSY; 1244658b6edaSMichael Mueller goto out; 1245658b6edaSMichael Mueller } 1246658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 1247658b6edaSMichael Mueller if (!proc) { 1248658b6edaSMichael Mueller ret = -ENOMEM; 1249658b6edaSMichael Mueller goto out; 1250658b6edaSMichael Mueller } 1251658b6edaSMichael Mueller if (!copy_from_user(proc, (void __user *)attr->addr, 1252658b6edaSMichael Mueller sizeof(*proc))) { 12539bb0ec09SDavid Hildenbrand kvm->arch.model.cpuid = proc->cpuid; 1254053dd230SDavid Hildenbrand lowest_ibc = sclp.ibc >> 16 & 0xfff; 1255053dd230SDavid Hildenbrand unblocked_ibc = sclp.ibc & 0xfff; 12560487c44dSDavid Hildenbrand if (lowest_ibc && proc->ibc) { 1257053dd230SDavid Hildenbrand if (proc->ibc > unblocked_ibc) 1258053dd230SDavid Hildenbrand kvm->arch.model.ibc = unblocked_ibc; 1259053dd230SDavid Hildenbrand else if (proc->ibc < lowest_ibc) 1260053dd230SDavid Hildenbrand kvm->arch.model.ibc = lowest_ibc; 1261053dd230SDavid Hildenbrand else 1262658b6edaSMichael Mueller kvm->arch.model.ibc = proc->ibc; 1263053dd230SDavid Hildenbrand } 1264c54f0d6aSDavid Hildenbrand memcpy(kvm->arch.model.fac_list, proc->fac_list, 1265658b6edaSMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 1266a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest ibc: 0x%4.4x, guest cpuid: 0x%16.16llx", 1267a8c39dd7SChristian Borntraeger kvm->arch.model.ibc, 1268a8c39dd7SChristian Borntraeger kvm->arch.model.cpuid); 1269a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest faclist: 0x%16.16llx.%16.16llx.%16.16llx", 1270a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[0], 1271a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[1], 1272a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[2]); 1273658b6edaSMichael Mueller } else 1274658b6edaSMichael Mueller ret = -EFAULT; 1275658b6edaSMichael Mueller kfree(proc); 1276658b6edaSMichael Mueller out: 1277658b6edaSMichael Mueller mutex_unlock(&kvm->lock); 1278658b6edaSMichael Mueller return ret; 1279658b6edaSMichael Mueller } 1280658b6edaSMichael Mueller 128115c9705fSDavid Hildenbrand static int kvm_s390_set_processor_feat(struct kvm *kvm, 128215c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 128315c9705fSDavid Hildenbrand { 128415c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 128515c9705fSDavid Hildenbrand 128615c9705fSDavid Hildenbrand if (copy_from_user(&data, (void __user *)attr->addr, sizeof(data))) 128715c9705fSDavid Hildenbrand return -EFAULT; 128815c9705fSDavid Hildenbrand if (!bitmap_subset((unsigned long *) data.feat, 128915c9705fSDavid Hildenbrand kvm_s390_available_cpu_feat, 129015c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS)) 129115c9705fSDavid Hildenbrand return -EINVAL; 129215c9705fSDavid Hildenbrand 129315c9705fSDavid Hildenbrand mutex_lock(&kvm->lock); 12942f8311c9SChristian Borntraeger if (kvm->created_vcpus) { 12952f8311c9SChristian Borntraeger mutex_unlock(&kvm->lock); 12962f8311c9SChristian Borntraeger return -EBUSY; 12972f8311c9SChristian Borntraeger } 129815c9705fSDavid Hildenbrand bitmap_copy(kvm->arch.cpu_feat, (unsigned long *) data.feat, 129915c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 130015c9705fSDavid Hildenbrand mutex_unlock(&kvm->lock); 13012f8311c9SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx", 13022f8311c9SChristian Borntraeger data.feat[0], 13032f8311c9SChristian Borntraeger data.feat[1], 13042f8311c9SChristian Borntraeger data.feat[2]); 13052f8311c9SChristian Borntraeger return 0; 130615c9705fSDavid Hildenbrand } 130715c9705fSDavid Hildenbrand 13080a763c78SDavid Hildenbrand static int kvm_s390_set_processor_subfunc(struct kvm *kvm, 13090a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 13100a763c78SDavid Hildenbrand { 1311346fa2f8SChristian Borntraeger mutex_lock(&kvm->lock); 1312346fa2f8SChristian Borntraeger if (kvm->created_vcpus) { 1313346fa2f8SChristian Borntraeger mutex_unlock(&kvm->lock); 1314346fa2f8SChristian Borntraeger return -EBUSY; 1315346fa2f8SChristian Borntraeger } 1316346fa2f8SChristian Borntraeger 1317346fa2f8SChristian Borntraeger if (copy_from_user(&kvm->arch.model.subfuncs, (void __user *)attr->addr, 1318346fa2f8SChristian Borntraeger sizeof(struct kvm_s390_vm_cpu_subfunc))) { 1319346fa2f8SChristian Borntraeger mutex_unlock(&kvm->lock); 1320346fa2f8SChristian Borntraeger return -EFAULT; 1321346fa2f8SChristian Borntraeger } 1322346fa2f8SChristian Borntraeger mutex_unlock(&kvm->lock); 1323346fa2f8SChristian Borntraeger 132411ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest PLO subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", 132511ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.plo)[0], 132611ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.plo)[1], 132711ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.plo)[2], 132811ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.plo)[3]); 132911ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest PTFF subfunc 0x%16.16lx.%16.16lx", 133011ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.ptff)[0], 133111ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.ptff)[1]); 133211ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest KMAC subfunc 0x%16.16lx.%16.16lx", 133311ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmac)[0], 133411ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmac)[1]); 133511ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest KMC subfunc 0x%16.16lx.%16.16lx", 133611ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmc)[0], 133711ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmc)[1]); 133811ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest KM subfunc 0x%16.16lx.%16.16lx", 133911ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.km)[0], 134011ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.km)[1]); 134111ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest KIMD subfunc 0x%16.16lx.%16.16lx", 134211ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kimd)[0], 134311ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kimd)[1]); 134411ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest KLMD subfunc 0x%16.16lx.%16.16lx", 134511ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.klmd)[0], 134611ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.klmd)[1]); 134711ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest PCKMO subfunc 0x%16.16lx.%16.16lx", 134811ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.pckmo)[0], 134911ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.pckmo)[1]); 135011ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest KMCTR subfunc 0x%16.16lx.%16.16lx", 135111ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmctr)[0], 135211ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmctr)[1]); 135311ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest KMF subfunc 0x%16.16lx.%16.16lx", 135411ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmf)[0], 135511ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmf)[1]); 135611ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest KMO subfunc 0x%16.16lx.%16.16lx", 135711ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmo)[0], 135811ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmo)[1]); 135911ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest PCC subfunc 0x%16.16lx.%16.16lx", 136011ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.pcc)[0], 136111ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.pcc)[1]); 136211ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest PPNO subfunc 0x%16.16lx.%16.16lx", 136311ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.ppno)[0], 136411ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.ppno)[1]); 136511ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest KMA subfunc 0x%16.16lx.%16.16lx", 136611ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kma)[0], 136711ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kma)[1]); 136813209ad0SChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest KDSA subfunc 0x%16.16lx.%16.16lx", 136913209ad0SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kdsa)[0], 137013209ad0SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kdsa)[1]); 1371173aec2dSChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest SORTL subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", 1372173aec2dSChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[0], 1373173aec2dSChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[1], 1374173aec2dSChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[2], 1375173aec2dSChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[3]); 13764f45b90eSChristian Borntraeger VM_EVENT(kvm, 3, "SET: guest DFLTCC subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", 13774f45b90eSChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[0], 13784f45b90eSChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[1], 13794f45b90eSChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[2], 13804f45b90eSChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[3]); 138111ba5961SChristian Borntraeger 1382346fa2f8SChristian Borntraeger return 0; 13830a763c78SDavid Hildenbrand } 13840a763c78SDavid Hildenbrand 1385658b6edaSMichael Mueller static int kvm_s390_set_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 1386658b6edaSMichael Mueller { 1387658b6edaSMichael Mueller int ret = -ENXIO; 1388658b6edaSMichael Mueller 1389658b6edaSMichael Mueller switch (attr->attr) { 1390658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 1391658b6edaSMichael Mueller ret = kvm_s390_set_processor(kvm, attr); 1392658b6edaSMichael Mueller break; 139315c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 139415c9705fSDavid Hildenbrand ret = kvm_s390_set_processor_feat(kvm, attr); 139515c9705fSDavid Hildenbrand break; 13960a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 13970a763c78SDavid Hildenbrand ret = kvm_s390_set_processor_subfunc(kvm, attr); 13980a763c78SDavid Hildenbrand break; 1399658b6edaSMichael Mueller } 1400658b6edaSMichael Mueller return ret; 1401658b6edaSMichael Mueller } 1402658b6edaSMichael Mueller 1403658b6edaSMichael Mueller static int kvm_s390_get_processor(struct kvm *kvm, struct kvm_device_attr *attr) 1404658b6edaSMichael Mueller { 1405658b6edaSMichael Mueller struct kvm_s390_vm_cpu_processor *proc; 1406658b6edaSMichael Mueller int ret = 0; 1407658b6edaSMichael Mueller 1408658b6edaSMichael Mueller proc = kzalloc(sizeof(*proc), GFP_KERNEL); 1409658b6edaSMichael Mueller if (!proc) { 1410658b6edaSMichael Mueller ret = -ENOMEM; 1411658b6edaSMichael Mueller goto out; 1412658b6edaSMichael Mueller } 14139bb0ec09SDavid Hildenbrand proc->cpuid = kvm->arch.model.cpuid; 1414658b6edaSMichael Mueller proc->ibc = kvm->arch.model.ibc; 1415c54f0d6aSDavid Hildenbrand memcpy(&proc->fac_list, kvm->arch.model.fac_list, 1416c54f0d6aSDavid Hildenbrand S390_ARCH_FAC_LIST_SIZE_BYTE); 1417a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest ibc: 0x%4.4x, guest cpuid: 0x%16.16llx", 1418a8c39dd7SChristian Borntraeger kvm->arch.model.ibc, 1419a8c39dd7SChristian Borntraeger kvm->arch.model.cpuid); 1420a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest faclist: 0x%16.16llx.%16.16llx.%16.16llx", 1421a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[0], 1422a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[1], 1423a8c39dd7SChristian Borntraeger kvm->arch.model.fac_list[2]); 1424658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, proc, sizeof(*proc))) 1425658b6edaSMichael Mueller ret = -EFAULT; 1426658b6edaSMichael Mueller kfree(proc); 1427658b6edaSMichael Mueller out: 1428658b6edaSMichael Mueller return ret; 1429658b6edaSMichael Mueller } 1430658b6edaSMichael Mueller 1431658b6edaSMichael Mueller static int kvm_s390_get_machine(struct kvm *kvm, struct kvm_device_attr *attr) 1432658b6edaSMichael Mueller { 1433658b6edaSMichael Mueller struct kvm_s390_vm_cpu_machine *mach; 1434658b6edaSMichael Mueller int ret = 0; 1435658b6edaSMichael Mueller 1436658b6edaSMichael Mueller mach = kzalloc(sizeof(*mach), GFP_KERNEL); 1437658b6edaSMichael Mueller if (!mach) { 1438658b6edaSMichael Mueller ret = -ENOMEM; 1439658b6edaSMichael Mueller goto out; 1440658b6edaSMichael Mueller } 1441658b6edaSMichael Mueller get_cpu_id((struct cpuid *) &mach->cpuid); 144237c5f6c8SDavid Hildenbrand mach->ibc = sclp.ibc; 1443c54f0d6aSDavid Hildenbrand memcpy(&mach->fac_mask, kvm->arch.model.fac_mask, 1444981467c9SMichael Mueller S390_ARCH_FAC_LIST_SIZE_BYTE); 1445658b6edaSMichael Mueller memcpy((unsigned long *)&mach->fac_list, S390_lowcore.stfle_fac_list, 144604478197SChristian Borntraeger sizeof(S390_lowcore.stfle_fac_list)); 1447a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host ibc: 0x%4.4x, host cpuid: 0x%16.16llx", 1448a8c39dd7SChristian Borntraeger kvm->arch.model.ibc, 1449a8c39dd7SChristian Borntraeger kvm->arch.model.cpuid); 1450a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host facmask: 0x%16.16llx.%16.16llx.%16.16llx", 1451a8c39dd7SChristian Borntraeger mach->fac_mask[0], 1452a8c39dd7SChristian Borntraeger mach->fac_mask[1], 1453a8c39dd7SChristian Borntraeger mach->fac_mask[2]); 1454a8c39dd7SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host faclist: 0x%16.16llx.%16.16llx.%16.16llx", 1455a8c39dd7SChristian Borntraeger mach->fac_list[0], 1456a8c39dd7SChristian Borntraeger mach->fac_list[1], 1457a8c39dd7SChristian Borntraeger mach->fac_list[2]); 1458658b6edaSMichael Mueller if (copy_to_user((void __user *)attr->addr, mach, sizeof(*mach))) 1459658b6edaSMichael Mueller ret = -EFAULT; 1460658b6edaSMichael Mueller kfree(mach); 1461658b6edaSMichael Mueller out: 1462658b6edaSMichael Mueller return ret; 1463658b6edaSMichael Mueller } 1464658b6edaSMichael Mueller 146515c9705fSDavid Hildenbrand static int kvm_s390_get_processor_feat(struct kvm *kvm, 146615c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 146715c9705fSDavid Hildenbrand { 146815c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 146915c9705fSDavid Hildenbrand 147015c9705fSDavid Hildenbrand bitmap_copy((unsigned long *) data.feat, kvm->arch.cpu_feat, 147115c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 147215c9705fSDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &data, sizeof(data))) 147315c9705fSDavid Hildenbrand return -EFAULT; 14742f8311c9SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx", 14752f8311c9SChristian Borntraeger data.feat[0], 14762f8311c9SChristian Borntraeger data.feat[1], 14772f8311c9SChristian Borntraeger data.feat[2]); 147815c9705fSDavid Hildenbrand return 0; 147915c9705fSDavid Hildenbrand } 148015c9705fSDavid Hildenbrand 148115c9705fSDavid Hildenbrand static int kvm_s390_get_machine_feat(struct kvm *kvm, 148215c9705fSDavid Hildenbrand struct kvm_device_attr *attr) 148315c9705fSDavid Hildenbrand { 148415c9705fSDavid Hildenbrand struct kvm_s390_vm_cpu_feat data; 148515c9705fSDavid Hildenbrand 148615c9705fSDavid Hildenbrand bitmap_copy((unsigned long *) data.feat, 148715c9705fSDavid Hildenbrand kvm_s390_available_cpu_feat, 148815c9705fSDavid Hildenbrand KVM_S390_VM_CPU_FEAT_NR_BITS); 148915c9705fSDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &data, sizeof(data))) 149015c9705fSDavid Hildenbrand return -EFAULT; 14912f8311c9SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx", 14922f8311c9SChristian Borntraeger data.feat[0], 14932f8311c9SChristian Borntraeger data.feat[1], 14942f8311c9SChristian Borntraeger data.feat[2]); 149515c9705fSDavid Hildenbrand return 0; 149615c9705fSDavid Hildenbrand } 149715c9705fSDavid Hildenbrand 14980a763c78SDavid Hildenbrand static int kvm_s390_get_processor_subfunc(struct kvm *kvm, 14990a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 15000a763c78SDavid Hildenbrand { 1501346fa2f8SChristian Borntraeger if (copy_to_user((void __user *)attr->addr, &kvm->arch.model.subfuncs, 1502346fa2f8SChristian Borntraeger sizeof(struct kvm_s390_vm_cpu_subfunc))) 1503346fa2f8SChristian Borntraeger return -EFAULT; 1504346fa2f8SChristian Borntraeger 150511ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest PLO subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", 150611ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.plo)[0], 150711ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.plo)[1], 150811ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.plo)[2], 150911ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.plo)[3]); 151011ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest PTFF subfunc 0x%16.16lx.%16.16lx", 151111ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.ptff)[0], 151211ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.ptff)[1]); 151311ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest KMAC subfunc 0x%16.16lx.%16.16lx", 151411ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmac)[0], 151511ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmac)[1]); 151611ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest KMC subfunc 0x%16.16lx.%16.16lx", 151711ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmc)[0], 151811ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmc)[1]); 151911ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest KM subfunc 0x%16.16lx.%16.16lx", 152011ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.km)[0], 152111ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.km)[1]); 152211ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest KIMD subfunc 0x%16.16lx.%16.16lx", 152311ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kimd)[0], 152411ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kimd)[1]); 152511ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest KLMD subfunc 0x%16.16lx.%16.16lx", 152611ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.klmd)[0], 152711ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.klmd)[1]); 152811ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest PCKMO subfunc 0x%16.16lx.%16.16lx", 152911ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.pckmo)[0], 153011ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.pckmo)[1]); 153111ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest KMCTR subfunc 0x%16.16lx.%16.16lx", 153211ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmctr)[0], 153311ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmctr)[1]); 153411ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest KMF subfunc 0x%16.16lx.%16.16lx", 153511ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmf)[0], 153611ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmf)[1]); 153711ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest KMO subfunc 0x%16.16lx.%16.16lx", 153811ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmo)[0], 153911ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kmo)[1]); 154011ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest PCC subfunc 0x%16.16lx.%16.16lx", 154111ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.pcc)[0], 154211ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.pcc)[1]); 154311ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest PPNO subfunc 0x%16.16lx.%16.16lx", 154411ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.ppno)[0], 154511ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.ppno)[1]); 154611ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest KMA subfunc 0x%16.16lx.%16.16lx", 154711ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kma)[0], 154811ba5961SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kma)[1]); 154913209ad0SChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest KDSA subfunc 0x%16.16lx.%16.16lx", 155013209ad0SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kdsa)[0], 155113209ad0SChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.kdsa)[1]); 1552173aec2dSChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest SORTL subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", 1553173aec2dSChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[0], 1554173aec2dSChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[1], 1555173aec2dSChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[2], 1556173aec2dSChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[3]); 15574f45b90eSChristian Borntraeger VM_EVENT(kvm, 3, "GET: guest DFLTCC subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", 15584f45b90eSChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[0], 15594f45b90eSChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[1], 15604f45b90eSChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[2], 15614f45b90eSChristian Borntraeger ((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[3]); 156211ba5961SChristian Borntraeger 1563346fa2f8SChristian Borntraeger return 0; 15640a763c78SDavid Hildenbrand } 15650a763c78SDavid Hildenbrand 15660a763c78SDavid Hildenbrand static int kvm_s390_get_machine_subfunc(struct kvm *kvm, 15670a763c78SDavid Hildenbrand struct kvm_device_attr *attr) 15680a763c78SDavid Hildenbrand { 15690a763c78SDavid Hildenbrand if (copy_to_user((void __user *)attr->addr, &kvm_s390_available_subfunc, 15700a763c78SDavid Hildenbrand sizeof(struct kvm_s390_vm_cpu_subfunc))) 15710a763c78SDavid Hildenbrand return -EFAULT; 157211ba5961SChristian Borntraeger 157311ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host PLO subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", 157411ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.plo)[0], 157511ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.plo)[1], 157611ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.plo)[2], 157711ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.plo)[3]); 157811ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host PTFF subfunc 0x%16.16lx.%16.16lx", 157911ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.ptff)[0], 158011ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.ptff)[1]); 158111ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host KMAC subfunc 0x%16.16lx.%16.16lx", 158211ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.kmac)[0], 158311ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.kmac)[1]); 158411ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host KMC subfunc 0x%16.16lx.%16.16lx", 158511ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.kmc)[0], 158611ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.kmc)[1]); 158711ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host KM subfunc 0x%16.16lx.%16.16lx", 158811ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.km)[0], 158911ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.km)[1]); 159011ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host KIMD subfunc 0x%16.16lx.%16.16lx", 159111ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.kimd)[0], 159211ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.kimd)[1]); 159311ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host KLMD subfunc 0x%16.16lx.%16.16lx", 159411ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.klmd)[0], 159511ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.klmd)[1]); 159611ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host PCKMO subfunc 0x%16.16lx.%16.16lx", 159711ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.pckmo)[0], 159811ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.pckmo)[1]); 159911ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host KMCTR subfunc 0x%16.16lx.%16.16lx", 160011ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.kmctr)[0], 160111ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.kmctr)[1]); 160211ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host KMF subfunc 0x%16.16lx.%16.16lx", 160311ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.kmf)[0], 160411ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.kmf)[1]); 160511ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host KMO subfunc 0x%16.16lx.%16.16lx", 160611ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.kmo)[0], 160711ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.kmo)[1]); 160811ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host PCC subfunc 0x%16.16lx.%16.16lx", 160911ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.pcc)[0], 161011ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.pcc)[1]); 161111ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host PPNO subfunc 0x%16.16lx.%16.16lx", 161211ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.ppno)[0], 161311ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.ppno)[1]); 161411ba5961SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host KMA subfunc 0x%16.16lx.%16.16lx", 161511ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.kma)[0], 161611ba5961SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.kma)[1]); 161713209ad0SChristian Borntraeger VM_EVENT(kvm, 3, "GET: host KDSA subfunc 0x%16.16lx.%16.16lx", 161813209ad0SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.kdsa)[0], 161913209ad0SChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.kdsa)[1]); 1620173aec2dSChristian Borntraeger VM_EVENT(kvm, 3, "GET: host SORTL subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", 1621173aec2dSChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.sortl)[0], 1622173aec2dSChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.sortl)[1], 1623173aec2dSChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.sortl)[2], 1624173aec2dSChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.sortl)[3]); 16254f45b90eSChristian Borntraeger VM_EVENT(kvm, 3, "GET: host DFLTCC subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", 16264f45b90eSChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.dfltcc)[0], 16274f45b90eSChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.dfltcc)[1], 16284f45b90eSChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.dfltcc)[2], 16294f45b90eSChristian Borntraeger ((unsigned long *) &kvm_s390_available_subfunc.dfltcc)[3]); 163011ba5961SChristian Borntraeger 16310a763c78SDavid Hildenbrand return 0; 16320a763c78SDavid Hildenbrand } 1633346fa2f8SChristian Borntraeger 1634658b6edaSMichael Mueller static int kvm_s390_get_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) 1635658b6edaSMichael Mueller { 1636658b6edaSMichael Mueller int ret = -ENXIO; 1637658b6edaSMichael Mueller 1638658b6edaSMichael Mueller switch (attr->attr) { 1639658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 1640658b6edaSMichael Mueller ret = kvm_s390_get_processor(kvm, attr); 1641658b6edaSMichael Mueller break; 1642658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 1643658b6edaSMichael Mueller ret = kvm_s390_get_machine(kvm, attr); 1644658b6edaSMichael Mueller break; 164515c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 164615c9705fSDavid Hildenbrand ret = kvm_s390_get_processor_feat(kvm, attr); 164715c9705fSDavid Hildenbrand break; 164815c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_FEAT: 164915c9705fSDavid Hildenbrand ret = kvm_s390_get_machine_feat(kvm, attr); 165015c9705fSDavid Hildenbrand break; 16510a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 16520a763c78SDavid Hildenbrand ret = kvm_s390_get_processor_subfunc(kvm, attr); 16530a763c78SDavid Hildenbrand break; 16540a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_SUBFUNC: 16550a763c78SDavid Hildenbrand ret = kvm_s390_get_machine_subfunc(kvm, attr); 16560a763c78SDavid Hildenbrand break; 1657658b6edaSMichael Mueller } 1658658b6edaSMichael Mueller return ret; 1659658b6edaSMichael Mueller } 1660658b6edaSMichael Mueller 1661f2061656SDominik Dingel static int kvm_s390_vm_set_attr(struct kvm *kvm, struct kvm_device_attr *attr) 1662f2061656SDominik Dingel { 1663f2061656SDominik Dingel int ret; 1664f2061656SDominik Dingel 1665f2061656SDominik Dingel switch (attr->group) { 16664f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 16678c0a7ce6SDominik Dingel ret = kvm_s390_set_mem_control(kvm, attr); 16684f718eabSDominik Dingel break; 166972f25020SJason J. Herne case KVM_S390_VM_TOD: 167072f25020SJason J. Herne ret = kvm_s390_set_tod(kvm, attr); 167172f25020SJason J. Herne break; 1672658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 1673658b6edaSMichael Mueller ret = kvm_s390_set_cpu_model(kvm, attr); 1674658b6edaSMichael Mueller break; 1675a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 1676a374e892STony Krowiak ret = kvm_s390_vm_set_crypto(kvm, attr); 1677a374e892STony Krowiak break; 1678190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION: 1679190df4a2SClaudio Imbrenda ret = kvm_s390_vm_set_migration(kvm, attr); 1680190df4a2SClaudio Imbrenda break; 1681f2061656SDominik Dingel default: 1682f2061656SDominik Dingel ret = -ENXIO; 1683f2061656SDominik Dingel break; 1684f2061656SDominik Dingel } 1685f2061656SDominik Dingel 1686f2061656SDominik Dingel return ret; 1687f2061656SDominik Dingel } 1688f2061656SDominik Dingel 1689f2061656SDominik Dingel static int kvm_s390_vm_get_attr(struct kvm *kvm, struct kvm_device_attr *attr) 1690f2061656SDominik Dingel { 16918c0a7ce6SDominik Dingel int ret; 16928c0a7ce6SDominik Dingel 16938c0a7ce6SDominik Dingel switch (attr->group) { 16948c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_CTRL: 16958c0a7ce6SDominik Dingel ret = kvm_s390_get_mem_control(kvm, attr); 16968c0a7ce6SDominik Dingel break; 169772f25020SJason J. Herne case KVM_S390_VM_TOD: 169872f25020SJason J. Herne ret = kvm_s390_get_tod(kvm, attr); 169972f25020SJason J. Herne break; 1700658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 1701658b6edaSMichael Mueller ret = kvm_s390_get_cpu_model(kvm, attr); 1702658b6edaSMichael Mueller break; 1703190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION: 1704190df4a2SClaudio Imbrenda ret = kvm_s390_vm_get_migration(kvm, attr); 1705190df4a2SClaudio Imbrenda break; 17068c0a7ce6SDominik Dingel default: 17078c0a7ce6SDominik Dingel ret = -ENXIO; 17088c0a7ce6SDominik Dingel break; 17098c0a7ce6SDominik Dingel } 17108c0a7ce6SDominik Dingel 17118c0a7ce6SDominik Dingel return ret; 1712f2061656SDominik Dingel } 1713f2061656SDominik Dingel 1714f2061656SDominik Dingel static int kvm_s390_vm_has_attr(struct kvm *kvm, struct kvm_device_attr *attr) 1715f2061656SDominik Dingel { 1716f2061656SDominik Dingel int ret; 1717f2061656SDominik Dingel 1718f2061656SDominik Dingel switch (attr->group) { 17194f718eabSDominik Dingel case KVM_S390_VM_MEM_CTRL: 17204f718eabSDominik Dingel switch (attr->attr) { 17214f718eabSDominik Dingel case KVM_S390_VM_MEM_ENABLE_CMMA: 17224f718eabSDominik Dingel case KVM_S390_VM_MEM_CLR_CMMA: 1723f9cbd9b0SDavid Hildenbrand ret = sclp.has_cmma ? 0 : -ENXIO; 1724f9cbd9b0SDavid Hildenbrand break; 17258c0a7ce6SDominik Dingel case KVM_S390_VM_MEM_LIMIT_SIZE: 17264f718eabSDominik Dingel ret = 0; 17274f718eabSDominik Dingel break; 17284f718eabSDominik Dingel default: 17294f718eabSDominik Dingel ret = -ENXIO; 17304f718eabSDominik Dingel break; 17314f718eabSDominik Dingel } 17324f718eabSDominik Dingel break; 173372f25020SJason J. Herne case KVM_S390_VM_TOD: 173472f25020SJason J. Herne switch (attr->attr) { 173572f25020SJason J. Herne case KVM_S390_VM_TOD_LOW: 173672f25020SJason J. Herne case KVM_S390_VM_TOD_HIGH: 173772f25020SJason J. Herne ret = 0; 173872f25020SJason J. Herne break; 173972f25020SJason J. Herne default: 174072f25020SJason J. Herne ret = -ENXIO; 174172f25020SJason J. Herne break; 174272f25020SJason J. Herne } 174372f25020SJason J. Herne break; 1744658b6edaSMichael Mueller case KVM_S390_VM_CPU_MODEL: 1745658b6edaSMichael Mueller switch (attr->attr) { 1746658b6edaSMichael Mueller case KVM_S390_VM_CPU_PROCESSOR: 1747658b6edaSMichael Mueller case KVM_S390_VM_CPU_MACHINE: 174815c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_PROCESSOR_FEAT: 174915c9705fSDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_FEAT: 17500a763c78SDavid Hildenbrand case KVM_S390_VM_CPU_MACHINE_SUBFUNC: 1751346fa2f8SChristian Borntraeger case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: 1752658b6edaSMichael Mueller ret = 0; 1753658b6edaSMichael Mueller break; 1754658b6edaSMichael Mueller default: 1755658b6edaSMichael Mueller ret = -ENXIO; 1756658b6edaSMichael Mueller break; 1757658b6edaSMichael Mueller } 1758658b6edaSMichael Mueller break; 1759a374e892STony Krowiak case KVM_S390_VM_CRYPTO: 1760a374e892STony Krowiak switch (attr->attr) { 1761a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_AES_KW: 1762a374e892STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW: 1763a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_AES_KW: 1764a374e892STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW: 1765a374e892STony Krowiak ret = 0; 1766a374e892STony Krowiak break; 176737940fb0STony Krowiak case KVM_S390_VM_CRYPTO_ENABLE_APIE: 176837940fb0STony Krowiak case KVM_S390_VM_CRYPTO_DISABLE_APIE: 176937940fb0STony Krowiak ret = ap_instructions_available() ? 0 : -ENXIO; 177037940fb0STony Krowiak break; 1771a374e892STony Krowiak default: 1772a374e892STony Krowiak ret = -ENXIO; 1773a374e892STony Krowiak break; 1774a374e892STony Krowiak } 1775a374e892STony Krowiak break; 1776190df4a2SClaudio Imbrenda case KVM_S390_VM_MIGRATION: 1777190df4a2SClaudio Imbrenda ret = 0; 1778190df4a2SClaudio Imbrenda break; 1779f2061656SDominik Dingel default: 1780f2061656SDominik Dingel ret = -ENXIO; 1781f2061656SDominik Dingel break; 1782f2061656SDominik Dingel } 1783f2061656SDominik Dingel 1784f2061656SDominik Dingel return ret; 1785f2061656SDominik Dingel } 1786f2061656SDominik Dingel 178730ee2a98SJason J. Herne static long kvm_s390_get_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 178830ee2a98SJason J. Herne { 178930ee2a98SJason J. Herne uint8_t *keys; 179030ee2a98SJason J. Herne uint64_t hva; 17914f899147SChristian Borntraeger int srcu_idx, i, r = 0; 179230ee2a98SJason J. Herne 179330ee2a98SJason J. Herne if (args->flags != 0) 179430ee2a98SJason J. Herne return -EINVAL; 179530ee2a98SJason J. Herne 179630ee2a98SJason J. Herne /* Is this guest using storage keys? */ 179755531b74SJanosch Frank if (!mm_uses_skeys(current->mm)) 179830ee2a98SJason J. Herne return KVM_S390_GET_SKEYS_NONE; 179930ee2a98SJason J. Herne 180030ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 180130ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 180230ee2a98SJason J. Herne return -EINVAL; 180330ee2a98SJason J. Herne 1804752ade68SMichal Hocko keys = kvmalloc_array(args->count, sizeof(uint8_t), GFP_KERNEL); 180530ee2a98SJason J. Herne if (!keys) 180630ee2a98SJason J. Herne return -ENOMEM; 180730ee2a98SJason J. Herne 1808d3ed1ceeSMartin Schwidefsky down_read(¤t->mm->mmap_sem); 18094f899147SChristian Borntraeger srcu_idx = srcu_read_lock(&kvm->srcu); 181030ee2a98SJason J. Herne for (i = 0; i < args->count; i++) { 181130ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 181230ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 181330ee2a98SJason J. Herne r = -EFAULT; 1814d3ed1ceeSMartin Schwidefsky break; 181530ee2a98SJason J. Herne } 181630ee2a98SJason J. Herne 1817154c8c19SDavid Hildenbrand r = get_guest_storage_key(current->mm, hva, &keys[i]); 1818154c8c19SDavid Hildenbrand if (r) 1819d3ed1ceeSMartin Schwidefsky break; 182030ee2a98SJason J. Herne } 18214f899147SChristian Borntraeger srcu_read_unlock(&kvm->srcu, srcu_idx); 1822d3ed1ceeSMartin Schwidefsky up_read(¤t->mm->mmap_sem); 182330ee2a98SJason J. Herne 1824d3ed1ceeSMartin Schwidefsky if (!r) { 182530ee2a98SJason J. Herne r = copy_to_user((uint8_t __user *)args->skeydata_addr, keys, 182630ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 182730ee2a98SJason J. Herne if (r) 182830ee2a98SJason J. Herne r = -EFAULT; 1829d3ed1ceeSMartin Schwidefsky } 1830d3ed1ceeSMartin Schwidefsky 183130ee2a98SJason J. Herne kvfree(keys); 183230ee2a98SJason J. Herne return r; 183330ee2a98SJason J. Herne } 183430ee2a98SJason J. Herne 183530ee2a98SJason J. Herne static long kvm_s390_set_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) 183630ee2a98SJason J. Herne { 183730ee2a98SJason J. Herne uint8_t *keys; 183830ee2a98SJason J. Herne uint64_t hva; 18394f899147SChristian Borntraeger int srcu_idx, i, r = 0; 1840bd096f64SJanosch Frank bool unlocked; 184130ee2a98SJason J. Herne 184230ee2a98SJason J. Herne if (args->flags != 0) 184330ee2a98SJason J. Herne return -EINVAL; 184430ee2a98SJason J. Herne 184530ee2a98SJason J. Herne /* Enforce sane limit on memory allocation */ 184630ee2a98SJason J. Herne if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX) 184730ee2a98SJason J. Herne return -EINVAL; 184830ee2a98SJason J. Herne 1849752ade68SMichal Hocko keys = kvmalloc_array(args->count, sizeof(uint8_t), GFP_KERNEL); 185030ee2a98SJason J. Herne if (!keys) 185130ee2a98SJason J. Herne return -ENOMEM; 185230ee2a98SJason J. Herne 185330ee2a98SJason J. Herne r = copy_from_user(keys, (uint8_t __user *)args->skeydata_addr, 185430ee2a98SJason J. Herne sizeof(uint8_t) * args->count); 185530ee2a98SJason J. Herne if (r) { 185630ee2a98SJason J. Herne r = -EFAULT; 185730ee2a98SJason J. Herne goto out; 185830ee2a98SJason J. Herne } 185930ee2a98SJason J. Herne 186030ee2a98SJason J. Herne /* Enable storage key handling for the guest */ 186114d4a425SDominik Dingel r = s390_enable_skey(); 186214d4a425SDominik Dingel if (r) 186314d4a425SDominik Dingel goto out; 186430ee2a98SJason J. Herne 1865bd096f64SJanosch Frank i = 0; 1866d3ed1ceeSMartin Schwidefsky down_read(¤t->mm->mmap_sem); 18674f899147SChristian Borntraeger srcu_idx = srcu_read_lock(&kvm->srcu); 1868bd096f64SJanosch Frank while (i < args->count) { 1869bd096f64SJanosch Frank unlocked = false; 187030ee2a98SJason J. Herne hva = gfn_to_hva(kvm, args->start_gfn + i); 187130ee2a98SJason J. Herne if (kvm_is_error_hva(hva)) { 187230ee2a98SJason J. Herne r = -EFAULT; 1873d3ed1ceeSMartin Schwidefsky break; 187430ee2a98SJason J. Herne } 187530ee2a98SJason J. Herne 187630ee2a98SJason J. Herne /* Lowest order bit is reserved */ 187730ee2a98SJason J. Herne if (keys[i] & 0x01) { 187830ee2a98SJason J. Herne r = -EINVAL; 1879d3ed1ceeSMartin Schwidefsky break; 188030ee2a98SJason J. Herne } 188130ee2a98SJason J. Herne 1882fe69eabfSDavid Hildenbrand r = set_guest_storage_key(current->mm, hva, keys[i], 0); 1883bd096f64SJanosch Frank if (r) { 1884bd096f64SJanosch Frank r = fixup_user_fault(current, current->mm, hva, 1885bd096f64SJanosch Frank FAULT_FLAG_WRITE, &unlocked); 188630ee2a98SJason J. Herne if (r) 1887d3ed1ceeSMartin Schwidefsky break; 188830ee2a98SJason J. Herne } 1889bd096f64SJanosch Frank if (!r) 1890bd096f64SJanosch Frank i++; 1891bd096f64SJanosch Frank } 18924f899147SChristian Borntraeger srcu_read_unlock(&kvm->srcu, srcu_idx); 1893d3ed1ceeSMartin Schwidefsky up_read(¤t->mm->mmap_sem); 189430ee2a98SJason J. Herne out: 189530ee2a98SJason J. Herne kvfree(keys); 189630ee2a98SJason J. Herne return r; 189730ee2a98SJason J. Herne } 189830ee2a98SJason J. Herne 18994036e387SClaudio Imbrenda /* 19004036e387SClaudio Imbrenda * Base address and length must be sent at the start of each block, therefore 19014036e387SClaudio Imbrenda * it's cheaper to send some clean data, as long as it's less than the size of 19024036e387SClaudio Imbrenda * two longs. 19034036e387SClaudio Imbrenda */ 19044036e387SClaudio Imbrenda #define KVM_S390_MAX_BIT_DISTANCE (2 * sizeof(void *)) 19054036e387SClaudio Imbrenda /* for consistency */ 19064036e387SClaudio Imbrenda #define KVM_S390_CMMA_SIZE_MAX ((u32)KVM_S390_SKEYS_MAX) 19074036e387SClaudio Imbrenda 19084036e387SClaudio Imbrenda /* 1909afdad616SClaudio Imbrenda * Similar to gfn_to_memslot, but returns the index of a memslot also when the 1910afdad616SClaudio Imbrenda * address falls in a hole. In that case the index of one of the memslots 1911afdad616SClaudio Imbrenda * bordering the hole is returned. 1912afdad616SClaudio Imbrenda */ 1913afdad616SClaudio Imbrenda static int gfn_to_memslot_approx(struct kvm_memslots *slots, gfn_t gfn) 1914afdad616SClaudio Imbrenda { 1915afdad616SClaudio Imbrenda int start = 0, end = slots->used_slots; 1916afdad616SClaudio Imbrenda int slot = atomic_read(&slots->lru_slot); 1917afdad616SClaudio Imbrenda struct kvm_memory_slot *memslots = slots->memslots; 1918afdad616SClaudio Imbrenda 1919afdad616SClaudio Imbrenda if (gfn >= memslots[slot].base_gfn && 1920afdad616SClaudio Imbrenda gfn < memslots[slot].base_gfn + memslots[slot].npages) 1921afdad616SClaudio Imbrenda return slot; 1922afdad616SClaudio Imbrenda 1923afdad616SClaudio Imbrenda while (start < end) { 1924afdad616SClaudio Imbrenda slot = start + (end - start) / 2; 1925afdad616SClaudio Imbrenda 1926afdad616SClaudio Imbrenda if (gfn >= memslots[slot].base_gfn) 1927afdad616SClaudio Imbrenda end = slot; 1928afdad616SClaudio Imbrenda else 1929afdad616SClaudio Imbrenda start = slot + 1; 1930afdad616SClaudio Imbrenda } 1931afdad616SClaudio Imbrenda 1932afdad616SClaudio Imbrenda if (gfn >= memslots[start].base_gfn && 1933afdad616SClaudio Imbrenda gfn < memslots[start].base_gfn + memslots[start].npages) { 1934afdad616SClaudio Imbrenda atomic_set(&slots->lru_slot, start); 1935afdad616SClaudio Imbrenda } 1936afdad616SClaudio Imbrenda 1937afdad616SClaudio Imbrenda return start; 1938afdad616SClaudio Imbrenda } 1939afdad616SClaudio Imbrenda 1940afdad616SClaudio Imbrenda static int kvm_s390_peek_cmma(struct kvm *kvm, struct kvm_s390_cmma_log *args, 1941afdad616SClaudio Imbrenda u8 *res, unsigned long bufsize) 1942afdad616SClaudio Imbrenda { 1943afdad616SClaudio Imbrenda unsigned long pgstev, hva, cur_gfn = args->start_gfn; 1944afdad616SClaudio Imbrenda 1945afdad616SClaudio Imbrenda args->count = 0; 1946afdad616SClaudio Imbrenda while (args->count < bufsize) { 1947afdad616SClaudio Imbrenda hva = gfn_to_hva(kvm, cur_gfn); 1948afdad616SClaudio Imbrenda /* 1949afdad616SClaudio Imbrenda * We return an error if the first value was invalid, but we 1950afdad616SClaudio Imbrenda * return successfully if at least one value was copied. 1951afdad616SClaudio Imbrenda */ 1952afdad616SClaudio Imbrenda if (kvm_is_error_hva(hva)) 1953afdad616SClaudio Imbrenda return args->count ? 0 : -EFAULT; 1954afdad616SClaudio Imbrenda if (get_pgste(kvm->mm, hva, &pgstev) < 0) 1955afdad616SClaudio Imbrenda pgstev = 0; 1956afdad616SClaudio Imbrenda res[args->count++] = (pgstev >> 24) & 0x43; 1957afdad616SClaudio Imbrenda cur_gfn++; 1958afdad616SClaudio Imbrenda } 1959afdad616SClaudio Imbrenda 1960afdad616SClaudio Imbrenda return 0; 1961afdad616SClaudio Imbrenda } 1962afdad616SClaudio Imbrenda 1963afdad616SClaudio Imbrenda static unsigned long kvm_s390_next_dirty_cmma(struct kvm_memslots *slots, 1964afdad616SClaudio Imbrenda unsigned long cur_gfn) 1965afdad616SClaudio Imbrenda { 1966afdad616SClaudio Imbrenda int slotidx = gfn_to_memslot_approx(slots, cur_gfn); 1967afdad616SClaudio Imbrenda struct kvm_memory_slot *ms = slots->memslots + slotidx; 1968afdad616SClaudio Imbrenda unsigned long ofs = cur_gfn - ms->base_gfn; 1969afdad616SClaudio Imbrenda 1970afdad616SClaudio Imbrenda if (ms->base_gfn + ms->npages <= cur_gfn) { 1971afdad616SClaudio Imbrenda slotidx--; 1972afdad616SClaudio Imbrenda /* If we are above the highest slot, wrap around */ 1973afdad616SClaudio Imbrenda if (slotidx < 0) 1974afdad616SClaudio Imbrenda slotidx = slots->used_slots - 1; 1975afdad616SClaudio Imbrenda 1976afdad616SClaudio Imbrenda ms = slots->memslots + slotidx; 1977afdad616SClaudio Imbrenda ofs = 0; 1978afdad616SClaudio Imbrenda } 1979afdad616SClaudio Imbrenda ofs = find_next_bit(kvm_second_dirty_bitmap(ms), ms->npages, ofs); 1980afdad616SClaudio Imbrenda while ((slotidx > 0) && (ofs >= ms->npages)) { 1981afdad616SClaudio Imbrenda slotidx--; 1982afdad616SClaudio Imbrenda ms = slots->memslots + slotidx; 1983afdad616SClaudio Imbrenda ofs = find_next_bit(kvm_second_dirty_bitmap(ms), ms->npages, 0); 1984afdad616SClaudio Imbrenda } 1985afdad616SClaudio Imbrenda return ms->base_gfn + ofs; 1986afdad616SClaudio Imbrenda } 1987afdad616SClaudio Imbrenda 1988afdad616SClaudio Imbrenda static int kvm_s390_get_cmma(struct kvm *kvm, struct kvm_s390_cmma_log *args, 1989afdad616SClaudio Imbrenda u8 *res, unsigned long bufsize) 1990afdad616SClaudio Imbrenda { 1991afdad616SClaudio Imbrenda unsigned long mem_end, cur_gfn, next_gfn, hva, pgstev; 1992afdad616SClaudio Imbrenda struct kvm_memslots *slots = kvm_memslots(kvm); 1993afdad616SClaudio Imbrenda struct kvm_memory_slot *ms; 1994afdad616SClaudio Imbrenda 1995afdad616SClaudio Imbrenda cur_gfn = kvm_s390_next_dirty_cmma(slots, args->start_gfn); 1996afdad616SClaudio Imbrenda ms = gfn_to_memslot(kvm, cur_gfn); 1997afdad616SClaudio Imbrenda args->count = 0; 1998afdad616SClaudio Imbrenda args->start_gfn = cur_gfn; 1999afdad616SClaudio Imbrenda if (!ms) 2000afdad616SClaudio Imbrenda return 0; 2001afdad616SClaudio Imbrenda next_gfn = kvm_s390_next_dirty_cmma(slots, cur_gfn + 1); 2002afdad616SClaudio Imbrenda mem_end = slots->memslots[0].base_gfn + slots->memslots[0].npages; 2003afdad616SClaudio Imbrenda 2004afdad616SClaudio Imbrenda while (args->count < bufsize) { 2005afdad616SClaudio Imbrenda hva = gfn_to_hva(kvm, cur_gfn); 2006afdad616SClaudio Imbrenda if (kvm_is_error_hva(hva)) 2007afdad616SClaudio Imbrenda return 0; 2008afdad616SClaudio Imbrenda /* Decrement only if we actually flipped the bit to 0 */ 2009afdad616SClaudio Imbrenda if (test_and_clear_bit(cur_gfn - ms->base_gfn, kvm_second_dirty_bitmap(ms))) 2010afdad616SClaudio Imbrenda atomic64_dec(&kvm->arch.cmma_dirty_pages); 2011afdad616SClaudio Imbrenda if (get_pgste(kvm->mm, hva, &pgstev) < 0) 2012afdad616SClaudio Imbrenda pgstev = 0; 2013afdad616SClaudio Imbrenda /* Save the value */ 2014afdad616SClaudio Imbrenda res[args->count++] = (pgstev >> 24) & 0x43; 2015afdad616SClaudio Imbrenda /* If the next bit is too far away, stop. */ 2016afdad616SClaudio Imbrenda if (next_gfn > cur_gfn + KVM_S390_MAX_BIT_DISTANCE) 2017afdad616SClaudio Imbrenda return 0; 2018afdad616SClaudio Imbrenda /* If we reached the previous "next", find the next one */ 2019afdad616SClaudio Imbrenda if (cur_gfn == next_gfn) 2020afdad616SClaudio Imbrenda next_gfn = kvm_s390_next_dirty_cmma(slots, cur_gfn + 1); 2021afdad616SClaudio Imbrenda /* Reached the end of memory or of the buffer, stop */ 2022afdad616SClaudio Imbrenda if ((next_gfn >= mem_end) || 2023afdad616SClaudio Imbrenda (next_gfn - args->start_gfn >= bufsize)) 2024afdad616SClaudio Imbrenda return 0; 2025afdad616SClaudio Imbrenda cur_gfn++; 2026afdad616SClaudio Imbrenda /* Reached the end of the current memslot, take the next one. */ 2027afdad616SClaudio Imbrenda if (cur_gfn - ms->base_gfn >= ms->npages) { 2028afdad616SClaudio Imbrenda ms = gfn_to_memslot(kvm, cur_gfn); 2029afdad616SClaudio Imbrenda if (!ms) 2030afdad616SClaudio Imbrenda return 0; 2031afdad616SClaudio Imbrenda } 2032afdad616SClaudio Imbrenda } 2033afdad616SClaudio Imbrenda return 0; 2034afdad616SClaudio Imbrenda } 2035afdad616SClaudio Imbrenda 2036afdad616SClaudio Imbrenda /* 20374036e387SClaudio Imbrenda * This function searches for the next page with dirty CMMA attributes, and 20384036e387SClaudio Imbrenda * saves the attributes in the buffer up to either the end of the buffer or 20394036e387SClaudio Imbrenda * until a block of at least KVM_S390_MAX_BIT_DISTANCE clean bits is found; 20404036e387SClaudio Imbrenda * no trailing clean bytes are saved. 20414036e387SClaudio Imbrenda * In case no dirty bits were found, or if CMMA was not enabled or used, the 20424036e387SClaudio Imbrenda * output buffer will indicate 0 as length. 20434036e387SClaudio Imbrenda */ 20444036e387SClaudio Imbrenda static int kvm_s390_get_cmma_bits(struct kvm *kvm, 20454036e387SClaudio Imbrenda struct kvm_s390_cmma_log *args) 20464036e387SClaudio Imbrenda { 2047afdad616SClaudio Imbrenda unsigned long bufsize; 2048afdad616SClaudio Imbrenda int srcu_idx, peek, ret; 2049afdad616SClaudio Imbrenda u8 *values; 20504036e387SClaudio Imbrenda 2051afdad616SClaudio Imbrenda if (!kvm->arch.use_cmma) 20524036e387SClaudio Imbrenda return -ENXIO; 20534036e387SClaudio Imbrenda /* Invalid/unsupported flags were specified */ 20544036e387SClaudio Imbrenda if (args->flags & ~KVM_S390_CMMA_PEEK) 20554036e387SClaudio Imbrenda return -EINVAL; 20564036e387SClaudio Imbrenda /* Migration mode query, and we are not doing a migration */ 20574036e387SClaudio Imbrenda peek = !!(args->flags & KVM_S390_CMMA_PEEK); 2058afdad616SClaudio Imbrenda if (!peek && !kvm->arch.migration_mode) 20594036e387SClaudio Imbrenda return -EINVAL; 20604036e387SClaudio Imbrenda /* CMMA is disabled or was not used, or the buffer has length zero */ 20614036e387SClaudio Imbrenda bufsize = min(args->count, KVM_S390_CMMA_SIZE_MAX); 2062c9f0a2b8SJanosch Frank if (!bufsize || !kvm->mm->context.uses_cmm) { 20634036e387SClaudio Imbrenda memset(args, 0, sizeof(*args)); 20644036e387SClaudio Imbrenda return 0; 20654036e387SClaudio Imbrenda } 20664036e387SClaudio Imbrenda /* We are not peeking, and there are no dirty pages */ 2067afdad616SClaudio Imbrenda if (!peek && !atomic64_read(&kvm->arch.cmma_dirty_pages)) { 20684036e387SClaudio Imbrenda memset(args, 0, sizeof(*args)); 20694036e387SClaudio Imbrenda return 0; 20704036e387SClaudio Imbrenda } 20714036e387SClaudio Imbrenda 2072afdad616SClaudio Imbrenda values = vmalloc(bufsize); 2073afdad616SClaudio Imbrenda if (!values) 20744036e387SClaudio Imbrenda return -ENOMEM; 20754036e387SClaudio Imbrenda 20764036e387SClaudio Imbrenda down_read(&kvm->mm->mmap_sem); 20774036e387SClaudio Imbrenda srcu_idx = srcu_read_lock(&kvm->srcu); 2078afdad616SClaudio Imbrenda if (peek) 2079afdad616SClaudio Imbrenda ret = kvm_s390_peek_cmma(kvm, args, values, bufsize); 2080afdad616SClaudio Imbrenda else 2081afdad616SClaudio Imbrenda ret = kvm_s390_get_cmma(kvm, args, values, bufsize); 20824036e387SClaudio Imbrenda srcu_read_unlock(&kvm->srcu, srcu_idx); 20834036e387SClaudio Imbrenda up_read(&kvm->mm->mmap_sem); 20844036e387SClaudio Imbrenda 2085afdad616SClaudio Imbrenda if (kvm->arch.migration_mode) 2086afdad616SClaudio Imbrenda args->remaining = atomic64_read(&kvm->arch.cmma_dirty_pages); 2087afdad616SClaudio Imbrenda else 2088afdad616SClaudio Imbrenda args->remaining = 0; 20894036e387SClaudio Imbrenda 2090afdad616SClaudio Imbrenda if (copy_to_user((void __user *)args->values, values, args->count)) 2091afdad616SClaudio Imbrenda ret = -EFAULT; 2092afdad616SClaudio Imbrenda 2093afdad616SClaudio Imbrenda vfree(values); 2094afdad616SClaudio Imbrenda return ret; 20954036e387SClaudio Imbrenda } 20964036e387SClaudio Imbrenda 20974036e387SClaudio Imbrenda /* 20984036e387SClaudio Imbrenda * This function sets the CMMA attributes for the given pages. If the input 20994036e387SClaudio Imbrenda * buffer has zero length, no action is taken, otherwise the attributes are 2100c9f0a2b8SJanosch Frank * set and the mm->context.uses_cmm flag is set. 21014036e387SClaudio Imbrenda */ 21024036e387SClaudio Imbrenda static int kvm_s390_set_cmma_bits(struct kvm *kvm, 21034036e387SClaudio Imbrenda const struct kvm_s390_cmma_log *args) 21044036e387SClaudio Imbrenda { 21054036e387SClaudio Imbrenda unsigned long hva, mask, pgstev, i; 21064036e387SClaudio Imbrenda uint8_t *bits; 21074036e387SClaudio Imbrenda int srcu_idx, r = 0; 21084036e387SClaudio Imbrenda 21094036e387SClaudio Imbrenda mask = args->mask; 21104036e387SClaudio Imbrenda 21114036e387SClaudio Imbrenda if (!kvm->arch.use_cmma) 21124036e387SClaudio Imbrenda return -ENXIO; 21134036e387SClaudio Imbrenda /* invalid/unsupported flags */ 21144036e387SClaudio Imbrenda if (args->flags != 0) 21154036e387SClaudio Imbrenda return -EINVAL; 21164036e387SClaudio Imbrenda /* Enforce sane limit on memory allocation */ 21174036e387SClaudio Imbrenda if (args->count > KVM_S390_CMMA_SIZE_MAX) 21184036e387SClaudio Imbrenda return -EINVAL; 21194036e387SClaudio Imbrenda /* Nothing to do */ 21204036e387SClaudio Imbrenda if (args->count == 0) 21214036e387SClaudio Imbrenda return 0; 21224036e387SClaudio Imbrenda 212342bc47b3SKees Cook bits = vmalloc(array_size(sizeof(*bits), args->count)); 21244036e387SClaudio Imbrenda if (!bits) 21254036e387SClaudio Imbrenda return -ENOMEM; 21264036e387SClaudio Imbrenda 21274036e387SClaudio Imbrenda r = copy_from_user(bits, (void __user *)args->values, args->count); 21284036e387SClaudio Imbrenda if (r) { 21294036e387SClaudio Imbrenda r = -EFAULT; 21304036e387SClaudio Imbrenda goto out; 21314036e387SClaudio Imbrenda } 21324036e387SClaudio Imbrenda 21334036e387SClaudio Imbrenda down_read(&kvm->mm->mmap_sem); 21344036e387SClaudio Imbrenda srcu_idx = srcu_read_lock(&kvm->srcu); 21354036e387SClaudio Imbrenda for (i = 0; i < args->count; i++) { 21364036e387SClaudio Imbrenda hva = gfn_to_hva(kvm, args->start_gfn + i); 21374036e387SClaudio Imbrenda if (kvm_is_error_hva(hva)) { 21384036e387SClaudio Imbrenda r = -EFAULT; 21394036e387SClaudio Imbrenda break; 21404036e387SClaudio Imbrenda } 21414036e387SClaudio Imbrenda 21424036e387SClaudio Imbrenda pgstev = bits[i]; 21434036e387SClaudio Imbrenda pgstev = pgstev << 24; 21441bab1c02SClaudio Imbrenda mask &= _PGSTE_GPS_USAGE_MASK | _PGSTE_GPS_NODAT; 21454036e387SClaudio Imbrenda set_pgste_bits(kvm->mm, hva, mask, pgstev); 21464036e387SClaudio Imbrenda } 21474036e387SClaudio Imbrenda srcu_read_unlock(&kvm->srcu, srcu_idx); 21484036e387SClaudio Imbrenda up_read(&kvm->mm->mmap_sem); 21494036e387SClaudio Imbrenda 2150c9f0a2b8SJanosch Frank if (!kvm->mm->context.uses_cmm) { 21514036e387SClaudio Imbrenda down_write(&kvm->mm->mmap_sem); 2152c9f0a2b8SJanosch Frank kvm->mm->context.uses_cmm = 1; 21534036e387SClaudio Imbrenda up_write(&kvm->mm->mmap_sem); 21544036e387SClaudio Imbrenda } 21554036e387SClaudio Imbrenda out: 21564036e387SClaudio Imbrenda vfree(bits); 21574036e387SClaudio Imbrenda return r; 21584036e387SClaudio Imbrenda } 21594036e387SClaudio Imbrenda 2160b0c632dbSHeiko Carstens long kvm_arch_vm_ioctl(struct file *filp, 2161b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 2162b0c632dbSHeiko Carstens { 2163b0c632dbSHeiko Carstens struct kvm *kvm = filp->private_data; 2164b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 2165f2061656SDominik Dingel struct kvm_device_attr attr; 2166b0c632dbSHeiko Carstens int r; 2167b0c632dbSHeiko Carstens 2168b0c632dbSHeiko Carstens switch (ioctl) { 2169ba5c1e9bSCarsten Otte case KVM_S390_INTERRUPT: { 2170ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 2171ba5c1e9bSCarsten Otte 2172ba5c1e9bSCarsten Otte r = -EFAULT; 2173ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 2174ba5c1e9bSCarsten Otte break; 2175ba5c1e9bSCarsten Otte r = kvm_s390_inject_vm(kvm, &s390int); 2176ba5c1e9bSCarsten Otte break; 2177ba5c1e9bSCarsten Otte } 217884223598SCornelia Huck case KVM_CREATE_IRQCHIP: { 217984223598SCornelia Huck struct kvm_irq_routing_entry routing; 218084223598SCornelia Huck 218184223598SCornelia Huck r = -EINVAL; 218284223598SCornelia Huck if (kvm->arch.use_irqchip) { 218384223598SCornelia Huck /* Set up dummy routing. */ 218484223598SCornelia Huck memset(&routing, 0, sizeof(routing)); 2185152b2839SNicholas Krause r = kvm_set_irq_routing(kvm, &routing, 0, 0); 218684223598SCornelia Huck } 218784223598SCornelia Huck break; 218884223598SCornelia Huck } 2189f2061656SDominik Dingel case KVM_SET_DEVICE_ATTR: { 2190f2061656SDominik Dingel r = -EFAULT; 2191f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 2192f2061656SDominik Dingel break; 2193f2061656SDominik Dingel r = kvm_s390_vm_set_attr(kvm, &attr); 2194f2061656SDominik Dingel break; 2195f2061656SDominik Dingel } 2196f2061656SDominik Dingel case KVM_GET_DEVICE_ATTR: { 2197f2061656SDominik Dingel r = -EFAULT; 2198f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 2199f2061656SDominik Dingel break; 2200f2061656SDominik Dingel r = kvm_s390_vm_get_attr(kvm, &attr); 2201f2061656SDominik Dingel break; 2202f2061656SDominik Dingel } 2203f2061656SDominik Dingel case KVM_HAS_DEVICE_ATTR: { 2204f2061656SDominik Dingel r = -EFAULT; 2205f2061656SDominik Dingel if (copy_from_user(&attr, (void __user *)arg, sizeof(attr))) 2206f2061656SDominik Dingel break; 2207f2061656SDominik Dingel r = kvm_s390_vm_has_attr(kvm, &attr); 2208f2061656SDominik Dingel break; 2209f2061656SDominik Dingel } 221030ee2a98SJason J. Herne case KVM_S390_GET_SKEYS: { 221130ee2a98SJason J. Herne struct kvm_s390_skeys args; 221230ee2a98SJason J. Herne 221330ee2a98SJason J. Herne r = -EFAULT; 221430ee2a98SJason J. Herne if (copy_from_user(&args, argp, 221530ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 221630ee2a98SJason J. Herne break; 221730ee2a98SJason J. Herne r = kvm_s390_get_skeys(kvm, &args); 221830ee2a98SJason J. Herne break; 221930ee2a98SJason J. Herne } 222030ee2a98SJason J. Herne case KVM_S390_SET_SKEYS: { 222130ee2a98SJason J. Herne struct kvm_s390_skeys args; 222230ee2a98SJason J. Herne 222330ee2a98SJason J. Herne r = -EFAULT; 222430ee2a98SJason J. Herne if (copy_from_user(&args, argp, 222530ee2a98SJason J. Herne sizeof(struct kvm_s390_skeys))) 222630ee2a98SJason J. Herne break; 222730ee2a98SJason J. Herne r = kvm_s390_set_skeys(kvm, &args); 222830ee2a98SJason J. Herne break; 222930ee2a98SJason J. Herne } 22304036e387SClaudio Imbrenda case KVM_S390_GET_CMMA_BITS: { 22314036e387SClaudio Imbrenda struct kvm_s390_cmma_log args; 22324036e387SClaudio Imbrenda 22334036e387SClaudio Imbrenda r = -EFAULT; 22344036e387SClaudio Imbrenda if (copy_from_user(&args, argp, sizeof(args))) 22354036e387SClaudio Imbrenda break; 22361de1ea7eSChristian Borntraeger mutex_lock(&kvm->slots_lock); 22374036e387SClaudio Imbrenda r = kvm_s390_get_cmma_bits(kvm, &args); 22381de1ea7eSChristian Borntraeger mutex_unlock(&kvm->slots_lock); 22394036e387SClaudio Imbrenda if (!r) { 22404036e387SClaudio Imbrenda r = copy_to_user(argp, &args, sizeof(args)); 22414036e387SClaudio Imbrenda if (r) 22424036e387SClaudio Imbrenda r = -EFAULT; 22434036e387SClaudio Imbrenda } 22444036e387SClaudio Imbrenda break; 22454036e387SClaudio Imbrenda } 22464036e387SClaudio Imbrenda case KVM_S390_SET_CMMA_BITS: { 22474036e387SClaudio Imbrenda struct kvm_s390_cmma_log args; 22484036e387SClaudio Imbrenda 22494036e387SClaudio Imbrenda r = -EFAULT; 22504036e387SClaudio Imbrenda if (copy_from_user(&args, argp, sizeof(args))) 22514036e387SClaudio Imbrenda break; 22521de1ea7eSChristian Borntraeger mutex_lock(&kvm->slots_lock); 22534036e387SClaudio Imbrenda r = kvm_s390_set_cmma_bits(kvm, &args); 22541de1ea7eSChristian Borntraeger mutex_unlock(&kvm->slots_lock); 22554036e387SClaudio Imbrenda break; 22564036e387SClaudio Imbrenda } 2257b0c632dbSHeiko Carstens default: 2258367e1319SAvi Kivity r = -ENOTTY; 2259b0c632dbSHeiko Carstens } 2260b0c632dbSHeiko Carstens 2261b0c632dbSHeiko Carstens return r; 2262b0c632dbSHeiko Carstens } 2263b0c632dbSHeiko Carstens 226445c9b47cSTony Krowiak static int kvm_s390_apxa_installed(void) 226545c9b47cSTony Krowiak { 2266e585b24aSTony Krowiak struct ap_config_info info; 226745c9b47cSTony Krowiak 2268e585b24aSTony Krowiak if (ap_instructions_available()) { 2269e585b24aSTony Krowiak if (ap_qci(&info) == 0) 2270e585b24aSTony Krowiak return info.apxa; 227145c9b47cSTony Krowiak } 227245c9b47cSTony Krowiak 227345c9b47cSTony Krowiak return 0; 227445c9b47cSTony Krowiak } 227545c9b47cSTony Krowiak 2276e585b24aSTony Krowiak /* 2277e585b24aSTony Krowiak * The format of the crypto control block (CRYCB) is specified in the 3 low 2278e585b24aSTony Krowiak * order bits of the CRYCB designation (CRYCBD) field as follows: 2279e585b24aSTony Krowiak * Format 0: Neither the message security assist extension 3 (MSAX3) nor the 2280e585b24aSTony Krowiak * AP extended addressing (APXA) facility are installed. 2281e585b24aSTony Krowiak * Format 1: The APXA facility is not installed but the MSAX3 facility is. 2282e585b24aSTony Krowiak * Format 2: Both the APXA and MSAX3 facilities are installed 2283e585b24aSTony Krowiak */ 228445c9b47cSTony Krowiak static void kvm_s390_set_crycb_format(struct kvm *kvm) 228545c9b47cSTony Krowiak { 228645c9b47cSTony Krowiak kvm->arch.crypto.crycbd = (__u32)(unsigned long) kvm->arch.crypto.crycb; 228745c9b47cSTony Krowiak 2288e585b24aSTony Krowiak /* Clear the CRYCB format bits - i.e., set format 0 by default */ 2289e585b24aSTony Krowiak kvm->arch.crypto.crycbd &= ~(CRYCB_FORMAT_MASK); 2290e585b24aSTony Krowiak 2291e585b24aSTony Krowiak /* Check whether MSAX3 is installed */ 2292e585b24aSTony Krowiak if (!test_kvm_facility(kvm, 76)) 2293e585b24aSTony Krowiak return; 2294e585b24aSTony Krowiak 229545c9b47cSTony Krowiak if (kvm_s390_apxa_installed()) 229645c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT2; 229745c9b47cSTony Krowiak else 229845c9b47cSTony Krowiak kvm->arch.crypto.crycbd |= CRYCB_FORMAT1; 229945c9b47cSTony Krowiak } 230045c9b47cSTony Krowiak 23010e237e44SPierre Morel void kvm_arch_crypto_set_masks(struct kvm *kvm, unsigned long *apm, 23020e237e44SPierre Morel unsigned long *aqm, unsigned long *adm) 23030e237e44SPierre Morel { 23040e237e44SPierre Morel struct kvm_s390_crypto_cb *crycb = kvm->arch.crypto.crycb; 23050e237e44SPierre Morel 23060e237e44SPierre Morel mutex_lock(&kvm->lock); 23070e237e44SPierre Morel kvm_s390_vcpu_block_all(kvm); 23080e237e44SPierre Morel 23090e237e44SPierre Morel switch (kvm->arch.crypto.crycbd & CRYCB_FORMAT_MASK) { 23100e237e44SPierre Morel case CRYCB_FORMAT2: /* APCB1 use 256 bits */ 23110e237e44SPierre Morel memcpy(crycb->apcb1.apm, apm, 32); 23120e237e44SPierre Morel VM_EVENT(kvm, 3, "SET CRYCB: apm %016lx %016lx %016lx %016lx", 23130e237e44SPierre Morel apm[0], apm[1], apm[2], apm[3]); 23140e237e44SPierre Morel memcpy(crycb->apcb1.aqm, aqm, 32); 23150e237e44SPierre Morel VM_EVENT(kvm, 3, "SET CRYCB: aqm %016lx %016lx %016lx %016lx", 23160e237e44SPierre Morel aqm[0], aqm[1], aqm[2], aqm[3]); 23170e237e44SPierre Morel memcpy(crycb->apcb1.adm, adm, 32); 23180e237e44SPierre Morel VM_EVENT(kvm, 3, "SET CRYCB: adm %016lx %016lx %016lx %016lx", 23190e237e44SPierre Morel adm[0], adm[1], adm[2], adm[3]); 23200e237e44SPierre Morel break; 23210e237e44SPierre Morel case CRYCB_FORMAT1: 23220e237e44SPierre Morel case CRYCB_FORMAT0: /* Fall through both use APCB0 */ 23230e237e44SPierre Morel memcpy(crycb->apcb0.apm, apm, 8); 23240e237e44SPierre Morel memcpy(crycb->apcb0.aqm, aqm, 2); 23250e237e44SPierre Morel memcpy(crycb->apcb0.adm, adm, 2); 23260e237e44SPierre Morel VM_EVENT(kvm, 3, "SET CRYCB: apm %016lx aqm %04x adm %04x", 23270e237e44SPierre Morel apm[0], *((unsigned short *)aqm), 23280e237e44SPierre Morel *((unsigned short *)adm)); 23290e237e44SPierre Morel break; 23300e237e44SPierre Morel default: /* Can not happen */ 23310e237e44SPierre Morel break; 23320e237e44SPierre Morel } 23330e237e44SPierre Morel 23340e237e44SPierre Morel /* recreate the shadow crycb for each vcpu */ 23350e237e44SPierre Morel kvm_s390_sync_request_broadcast(kvm, KVM_REQ_VSIE_RESTART); 23360e237e44SPierre Morel kvm_s390_vcpu_unblock_all(kvm); 23370e237e44SPierre Morel mutex_unlock(&kvm->lock); 23380e237e44SPierre Morel } 23390e237e44SPierre Morel EXPORT_SYMBOL_GPL(kvm_arch_crypto_set_masks); 23400e237e44SPierre Morel 234142104598STony Krowiak void kvm_arch_crypto_clear_masks(struct kvm *kvm) 234242104598STony Krowiak { 234342104598STony Krowiak mutex_lock(&kvm->lock); 234442104598STony Krowiak kvm_s390_vcpu_block_all(kvm); 234542104598STony Krowiak 234642104598STony Krowiak memset(&kvm->arch.crypto.crycb->apcb0, 0, 234742104598STony Krowiak sizeof(kvm->arch.crypto.crycb->apcb0)); 234842104598STony Krowiak memset(&kvm->arch.crypto.crycb->apcb1, 0, 234942104598STony Krowiak sizeof(kvm->arch.crypto.crycb->apcb1)); 235042104598STony Krowiak 23510e237e44SPierre Morel VM_EVENT(kvm, 3, "%s", "CLR CRYCB:"); 23526cc571b1SPierre Morel /* recreate the shadow crycb for each vcpu */ 23536cc571b1SPierre Morel kvm_s390_sync_request_broadcast(kvm, KVM_REQ_VSIE_RESTART); 235442104598STony Krowiak kvm_s390_vcpu_unblock_all(kvm); 235542104598STony Krowiak mutex_unlock(&kvm->lock); 235642104598STony Krowiak } 235742104598STony Krowiak EXPORT_SYMBOL_GPL(kvm_arch_crypto_clear_masks); 235842104598STony Krowiak 23599bb0ec09SDavid Hildenbrand static u64 kvm_s390_get_initial_cpuid(void) 23609d8d5786SMichael Mueller { 23619bb0ec09SDavid Hildenbrand struct cpuid cpuid; 23629bb0ec09SDavid Hildenbrand 23639bb0ec09SDavid Hildenbrand get_cpu_id(&cpuid); 23649bb0ec09SDavid Hildenbrand cpuid.version = 0xff; 23659bb0ec09SDavid Hildenbrand return *((u64 *) &cpuid); 23669d8d5786SMichael Mueller } 23679d8d5786SMichael Mueller 2368c54f0d6aSDavid Hildenbrand static void kvm_s390_crypto_init(struct kvm *kvm) 23695102ee87STony Krowiak { 2370c54f0d6aSDavid Hildenbrand kvm->arch.crypto.crycb = &kvm->arch.sie_page2->crycb; 237145c9b47cSTony Krowiak kvm_s390_set_crycb_format(kvm); 23725102ee87STony Krowiak 2373e585b24aSTony Krowiak if (!test_kvm_facility(kvm, 76)) 2374e585b24aSTony Krowiak return; 2375e585b24aSTony Krowiak 2376ed6f76b4STony Krowiak /* Enable AES/DEA protected key functions by default */ 2377ed6f76b4STony Krowiak kvm->arch.crypto.aes_kw = 1; 2378ed6f76b4STony Krowiak kvm->arch.crypto.dea_kw = 1; 2379ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 2380ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask)); 2381ed6f76b4STony Krowiak get_random_bytes(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 2382ed6f76b4STony Krowiak sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask)); 23835102ee87STony Krowiak } 23845102ee87STony Krowiak 23857d43bafcSEugene (jno) Dvurechenski static void sca_dispose(struct kvm *kvm) 23867d43bafcSEugene (jno) Dvurechenski { 23877d43bafcSEugene (jno) Dvurechenski if (kvm->arch.use_esca) 23885e044315SEugene (jno) Dvurechenski free_pages_exact(kvm->arch.sca, sizeof(struct esca_block)); 23897d43bafcSEugene (jno) Dvurechenski else 23907d43bafcSEugene (jno) Dvurechenski free_page((unsigned long)(kvm->arch.sca)); 23917d43bafcSEugene (jno) Dvurechenski kvm->arch.sca = NULL; 23927d43bafcSEugene (jno) Dvurechenski } 23937d43bafcSEugene (jno) Dvurechenski 2394e08b9637SCarsten Otte int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 2395b0c632dbSHeiko Carstens { 239676a6dd72SDavid Hildenbrand gfp_t alloc_flags = GFP_KERNEL; 23979d8d5786SMichael Mueller int i, rc; 2398b0c632dbSHeiko Carstens char debug_name[16]; 2399f6c137ffSChristian Borntraeger static unsigned long sca_offset; 2400b0c632dbSHeiko Carstens 2401e08b9637SCarsten Otte rc = -EINVAL; 2402e08b9637SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 2403e08b9637SCarsten Otte if (type & ~KVM_VM_S390_UCONTROL) 2404e08b9637SCarsten Otte goto out_err; 2405e08b9637SCarsten Otte if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN))) 2406e08b9637SCarsten Otte goto out_err; 2407e08b9637SCarsten Otte #else 2408e08b9637SCarsten Otte if (type) 2409e08b9637SCarsten Otte goto out_err; 2410e08b9637SCarsten Otte #endif 2411e08b9637SCarsten Otte 2412b0c632dbSHeiko Carstens rc = s390_enable_sie(); 2413b0c632dbSHeiko Carstens if (rc) 2414d89f5effSJan Kiszka goto out_err; 2415b0c632dbSHeiko Carstens 2416b290411aSCarsten Otte rc = -ENOMEM; 2417b290411aSCarsten Otte 241876a6dd72SDavid Hildenbrand if (!sclp.has_64bscao) 241976a6dd72SDavid Hildenbrand alloc_flags |= GFP_DMA; 24205e044315SEugene (jno) Dvurechenski rwlock_init(&kvm->arch.sca_lock); 24219ac96d75SDavid Hildenbrand /* start with basic SCA */ 242276a6dd72SDavid Hildenbrand kvm->arch.sca = (struct bsca_block *) get_zeroed_page(alloc_flags); 2423b0c632dbSHeiko Carstens if (!kvm->arch.sca) 2424d89f5effSJan Kiszka goto out_err; 24250d9ce162SJunaid Shahid mutex_lock(&kvm_lock); 2426c5c2c393SDavid Hildenbrand sca_offset += 16; 2427bc784cceSEugene (jno) Dvurechenski if (sca_offset + sizeof(struct bsca_block) > PAGE_SIZE) 2428c5c2c393SDavid Hildenbrand sca_offset = 0; 2429bc784cceSEugene (jno) Dvurechenski kvm->arch.sca = (struct bsca_block *) 2430bc784cceSEugene (jno) Dvurechenski ((char *) kvm->arch.sca + sca_offset); 24310d9ce162SJunaid Shahid mutex_unlock(&kvm_lock); 2432b0c632dbSHeiko Carstens 2433b0c632dbSHeiko Carstens sprintf(debug_name, "kvm-%u", current->pid); 2434b0c632dbSHeiko Carstens 24351cb9cf72SChristian Borntraeger kvm->arch.dbf = debug_register(debug_name, 32, 1, 7 * sizeof(long)); 2436b0c632dbSHeiko Carstens if (!kvm->arch.dbf) 243740f5b735SDominik Dingel goto out_err; 2438b0c632dbSHeiko Carstens 243919114bebSMichael Mueller BUILD_BUG_ON(sizeof(struct sie_page2) != 4096); 2440c54f0d6aSDavid Hildenbrand kvm->arch.sie_page2 = 2441c54f0d6aSDavid Hildenbrand (struct sie_page2 *) get_zeroed_page(GFP_KERNEL | GFP_DMA); 2442c54f0d6aSDavid Hildenbrand if (!kvm->arch.sie_page2) 244340f5b735SDominik Dingel goto out_err; 24449d8d5786SMichael Mueller 244525c84dbaSMichael Mueller kvm->arch.sie_page2->kvm = kvm; 2446c54f0d6aSDavid Hildenbrand kvm->arch.model.fac_list = kvm->arch.sie_page2->fac_list; 2447c3b9e3e1SChristian Borntraeger 2448c3b9e3e1SChristian Borntraeger for (i = 0; i < kvm_s390_fac_size(); i++) { 2449c3b9e3e1SChristian Borntraeger kvm->arch.model.fac_mask[i] = S390_lowcore.stfle_fac_list[i] & 2450c3b9e3e1SChristian Borntraeger (kvm_s390_fac_base[i] | 2451c3b9e3e1SChristian Borntraeger kvm_s390_fac_ext[i]); 2452c3b9e3e1SChristian Borntraeger kvm->arch.model.fac_list[i] = S390_lowcore.stfle_fac_list[i] & 2453c3b9e3e1SChristian Borntraeger kvm_s390_fac_base[i]; 2454c3b9e3e1SChristian Borntraeger } 2455346fa2f8SChristian Borntraeger kvm->arch.model.subfuncs = kvm_s390_available_subfunc; 2456981467c9SMichael Mueller 24571935222dSDavid Hildenbrand /* we are always in czam mode - even on pre z14 machines */ 24581935222dSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_mask, 138); 24591935222dSDavid Hildenbrand set_kvm_facility(kvm->arch.model.fac_list, 138); 24601935222dSDavid Hildenbrand /* we emulate STHYI in kvm */ 246195ca2cb5SJanosch Frank set_kvm_facility(kvm->arch.model.fac_mask, 74); 246295ca2cb5SJanosch Frank set_kvm_facility(kvm->arch.model.fac_list, 74); 24631bab1c02SClaudio Imbrenda if (MACHINE_HAS_TLB_GUEST) { 24641bab1c02SClaudio Imbrenda set_kvm_facility(kvm->arch.model.fac_mask, 147); 24651bab1c02SClaudio Imbrenda set_kvm_facility(kvm->arch.model.fac_list, 147); 24661bab1c02SClaudio Imbrenda } 246795ca2cb5SJanosch Frank 246805f31e3bSPierre Morel if (css_general_characteristics.aiv && test_facility(65)) 246905f31e3bSPierre Morel set_kvm_facility(kvm->arch.model.fac_mask, 65); 247005f31e3bSPierre Morel 24719bb0ec09SDavid Hildenbrand kvm->arch.model.cpuid = kvm_s390_get_initial_cpuid(); 247237c5f6c8SDavid Hildenbrand kvm->arch.model.ibc = sclp.ibc & 0x0fff; 24739d8d5786SMichael Mueller 2474c54f0d6aSDavid Hildenbrand kvm_s390_crypto_init(kvm); 24755102ee87STony Krowiak 247651978393SFei Li mutex_init(&kvm->arch.float_int.ais_lock); 2477ba5c1e9bSCarsten Otte spin_lock_init(&kvm->arch.float_int.lock); 24786d3da241SJens Freimann for (i = 0; i < FIRQ_LIST_COUNT; i++) 24796d3da241SJens Freimann INIT_LIST_HEAD(&kvm->arch.float_int.lists[i]); 24808a242234SHeiko Carstens init_waitqueue_head(&kvm->arch.ipte_wq); 2481a6b7e459SThomas Huth mutex_init(&kvm->arch.ipte_mutex); 2482ba5c1e9bSCarsten Otte 2483b0c632dbSHeiko Carstens debug_register_view(kvm->arch.dbf, &debug_sprintf_view); 248478f26131SChristian Borntraeger VM_EVENT(kvm, 3, "vm created with type %lu", type); 2485b0c632dbSHeiko Carstens 2486e08b9637SCarsten Otte if (type & KVM_VM_S390_UCONTROL) { 2487e08b9637SCarsten Otte kvm->arch.gmap = NULL; 2488a3a92c31SDominik Dingel kvm->arch.mem_limit = KVM_S390_NO_MEM_LIMIT; 2489e08b9637SCarsten Otte } else { 249032e6b236SGuenther Hutzl if (sclp.hamax == U64_MAX) 2491ee71d16dSMartin Schwidefsky kvm->arch.mem_limit = TASK_SIZE_MAX; 249232e6b236SGuenther Hutzl else 2493ee71d16dSMartin Schwidefsky kvm->arch.mem_limit = min_t(unsigned long, TASK_SIZE_MAX, 249432e6b236SGuenther Hutzl sclp.hamax + 1); 24956ea427bbSMartin Schwidefsky kvm->arch.gmap = gmap_create(current->mm, kvm->arch.mem_limit - 1); 2496598841caSCarsten Otte if (!kvm->arch.gmap) 249740f5b735SDominik Dingel goto out_err; 24982c70fe44SChristian Borntraeger kvm->arch.gmap->private = kvm; 249924eb3a82SDominik Dingel kvm->arch.gmap->pfault_enabled = 0; 2500e08b9637SCarsten Otte } 2501fa6b7fe9SCornelia Huck 2502c9f0a2b8SJanosch Frank kvm->arch.use_pfmfi = sclp.has_pfmfi; 250355531b74SJanosch Frank kvm->arch.use_skf = sclp.has_skey; 25048ad35755SDavid Hildenbrand spin_lock_init(&kvm->arch.start_stop_lock); 2505a3508fbeSDavid Hildenbrand kvm_s390_vsie_init(kvm); 2506d7c5cb01SMichael Mueller kvm_s390_gisa_init(kvm); 25078335713aSChristian Borntraeger KVM_EVENT(3, "vm 0x%pK created by pid %u", kvm, current->pid); 25088ad35755SDavid Hildenbrand 2509d89f5effSJan Kiszka return 0; 2510d89f5effSJan Kiszka out_err: 2511c54f0d6aSDavid Hildenbrand free_page((unsigned long)kvm->arch.sie_page2); 251240f5b735SDominik Dingel debug_unregister(kvm->arch.dbf); 25137d43bafcSEugene (jno) Dvurechenski sca_dispose(kvm); 251478f26131SChristian Borntraeger KVM_EVENT(3, "creation of vm failed: %d", rc); 2515d89f5effSJan Kiszka return rc; 2516b0c632dbSHeiko Carstens } 2517b0c632dbSHeiko Carstens 2518d329c035SChristian Borntraeger void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 2519d329c035SChristian Borntraeger { 2520d329c035SChristian Borntraeger VCPU_EVENT(vcpu, 3, "%s", "free cpu"); 2521ade38c31SCornelia Huck trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id); 252267335e63SChristian Borntraeger kvm_s390_clear_local_irqs(vcpu); 25233c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 2524bc784cceSEugene (jno) Dvurechenski if (!kvm_is_ucontrol(vcpu->kvm)) 2525a6e2f683SEugene (jno) Dvurechenski sca_del_vcpu(vcpu); 252627e0393fSCarsten Otte 252727e0393fSCarsten Otte if (kvm_is_ucontrol(vcpu->kvm)) 25286ea427bbSMartin Schwidefsky gmap_remove(vcpu->arch.gmap); 252927e0393fSCarsten Otte 2530e6db1d61SDominik Dingel if (vcpu->kvm->arch.use_cmma) 2531b31605c1SDominik Dingel kvm_s390_vcpu_unsetup_cmma(vcpu); 2532d329c035SChristian Borntraeger free_page((unsigned long)(vcpu->arch.sie_block)); 2533b31288faSKonstantin Weitz 25346692cef3SChristian Borntraeger kvm_vcpu_uninit(vcpu); 2535b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 2536d329c035SChristian Borntraeger } 2537d329c035SChristian Borntraeger 2538d329c035SChristian Borntraeger static void kvm_free_vcpus(struct kvm *kvm) 2539d329c035SChristian Borntraeger { 2540d329c035SChristian Borntraeger unsigned int i; 2541988a2caeSGleb Natapov struct kvm_vcpu *vcpu; 2542d329c035SChristian Borntraeger 2543988a2caeSGleb Natapov kvm_for_each_vcpu(i, vcpu, kvm) 2544988a2caeSGleb Natapov kvm_arch_vcpu_destroy(vcpu); 2545988a2caeSGleb Natapov 2546988a2caeSGleb Natapov mutex_lock(&kvm->lock); 2547988a2caeSGleb Natapov for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 2548d329c035SChristian Borntraeger kvm->vcpus[i] = NULL; 2549988a2caeSGleb Natapov 2550988a2caeSGleb Natapov atomic_set(&kvm->online_vcpus, 0); 2551988a2caeSGleb Natapov mutex_unlock(&kvm->lock); 2552d329c035SChristian Borntraeger } 2553d329c035SChristian Borntraeger 2554b0c632dbSHeiko Carstens void kvm_arch_destroy_vm(struct kvm *kvm) 2555b0c632dbSHeiko Carstens { 2556d329c035SChristian Borntraeger kvm_free_vcpus(kvm); 25577d43bafcSEugene (jno) Dvurechenski sca_dispose(kvm); 2558d329c035SChristian Borntraeger debug_unregister(kvm->arch.dbf); 2559d7c5cb01SMichael Mueller kvm_s390_gisa_destroy(kvm); 2560c54f0d6aSDavid Hildenbrand free_page((unsigned long)kvm->arch.sie_page2); 256127e0393fSCarsten Otte if (!kvm_is_ucontrol(kvm)) 25626ea427bbSMartin Schwidefsky gmap_remove(kvm->arch.gmap); 2563841b91c5SCornelia Huck kvm_s390_destroy_adapters(kvm); 256467335e63SChristian Borntraeger kvm_s390_clear_float_irqs(kvm); 2565a3508fbeSDavid Hildenbrand kvm_s390_vsie_destroy(kvm); 25668335713aSChristian Borntraeger KVM_EVENT(3, "vm 0x%pK destroyed", kvm); 2567b0c632dbSHeiko Carstens } 2568b0c632dbSHeiko Carstens 2569b0c632dbSHeiko Carstens /* Section: vcpu related */ 2570dafd032aSDominik Dingel static int __kvm_ucontrol_vcpu_init(struct kvm_vcpu *vcpu) 2571b0c632dbSHeiko Carstens { 25726ea427bbSMartin Schwidefsky vcpu->arch.gmap = gmap_create(current->mm, -1UL); 257327e0393fSCarsten Otte if (!vcpu->arch.gmap) 257427e0393fSCarsten Otte return -ENOMEM; 25752c70fe44SChristian Borntraeger vcpu->arch.gmap->private = vcpu->kvm; 2576dafd032aSDominik Dingel 257727e0393fSCarsten Otte return 0; 257827e0393fSCarsten Otte } 257927e0393fSCarsten Otte 2580a6e2f683SEugene (jno) Dvurechenski static void sca_del_vcpu(struct kvm_vcpu *vcpu) 2581a6e2f683SEugene (jno) Dvurechenski { 2582a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) 2583a6940674SDavid Hildenbrand return; 25845e044315SEugene (jno) Dvurechenski read_lock(&vcpu->kvm->arch.sca_lock); 25857d43bafcSEugene (jno) Dvurechenski if (vcpu->kvm->arch.use_esca) { 25867d43bafcSEugene (jno) Dvurechenski struct esca_block *sca = vcpu->kvm->arch.sca; 25877d43bafcSEugene (jno) Dvurechenski 25887d43bafcSEugene (jno) Dvurechenski clear_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn); 25897d43bafcSEugene (jno) Dvurechenski sca->cpu[vcpu->vcpu_id].sda = 0; 25907d43bafcSEugene (jno) Dvurechenski } else { 2591bc784cceSEugene (jno) Dvurechenski struct bsca_block *sca = vcpu->kvm->arch.sca; 2592a6e2f683SEugene (jno) Dvurechenski 2593a6e2f683SEugene (jno) Dvurechenski clear_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn); 2594a6e2f683SEugene (jno) Dvurechenski sca->cpu[vcpu->vcpu_id].sda = 0; 2595a6e2f683SEugene (jno) Dvurechenski } 25965e044315SEugene (jno) Dvurechenski read_unlock(&vcpu->kvm->arch.sca_lock); 25977d43bafcSEugene (jno) Dvurechenski } 2598a6e2f683SEugene (jno) Dvurechenski 2599eaa78f34SDavid Hildenbrand static void sca_add_vcpu(struct kvm_vcpu *vcpu) 2600a6e2f683SEugene (jno) Dvurechenski { 2601a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) { 2602a6940674SDavid Hildenbrand struct bsca_block *sca = vcpu->kvm->arch.sca; 2603a6940674SDavid Hildenbrand 2604a6940674SDavid Hildenbrand /* we still need the basic sca for the ipte control */ 2605a6940674SDavid Hildenbrand vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 2606a6940674SDavid Hildenbrand vcpu->arch.sie_block->scaol = (__u32)(__u64)sca; 2607f07afa04SDavid Hildenbrand return; 2608a6940674SDavid Hildenbrand } 2609eaa78f34SDavid Hildenbrand read_lock(&vcpu->kvm->arch.sca_lock); 2610eaa78f34SDavid Hildenbrand if (vcpu->kvm->arch.use_esca) { 2611eaa78f34SDavid Hildenbrand struct esca_block *sca = vcpu->kvm->arch.sca; 26127d43bafcSEugene (jno) Dvurechenski 2613eaa78f34SDavid Hildenbrand sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block; 26147d43bafcSEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 26157d43bafcSEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = (__u32)(__u64)sca & ~0x3fU; 26160c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= ECB2_ESCA; 2617eaa78f34SDavid Hildenbrand set_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn); 26187d43bafcSEugene (jno) Dvurechenski } else { 2619eaa78f34SDavid Hildenbrand struct bsca_block *sca = vcpu->kvm->arch.sca; 2620a6e2f683SEugene (jno) Dvurechenski 2621eaa78f34SDavid Hildenbrand sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block; 2622a6e2f683SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32); 2623a6e2f683SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = (__u32)(__u64)sca; 2624eaa78f34SDavid Hildenbrand set_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn); 2625a6e2f683SEugene (jno) Dvurechenski } 2626eaa78f34SDavid Hildenbrand read_unlock(&vcpu->kvm->arch.sca_lock); 26275e044315SEugene (jno) Dvurechenski } 26285e044315SEugene (jno) Dvurechenski 26295e044315SEugene (jno) Dvurechenski /* Basic SCA to Extended SCA data copy routines */ 26305e044315SEugene (jno) Dvurechenski static inline void sca_copy_entry(struct esca_entry *d, struct bsca_entry *s) 26315e044315SEugene (jno) Dvurechenski { 26325e044315SEugene (jno) Dvurechenski d->sda = s->sda; 26335e044315SEugene (jno) Dvurechenski d->sigp_ctrl.c = s->sigp_ctrl.c; 26345e044315SEugene (jno) Dvurechenski d->sigp_ctrl.scn = s->sigp_ctrl.scn; 26355e044315SEugene (jno) Dvurechenski } 26365e044315SEugene (jno) Dvurechenski 26375e044315SEugene (jno) Dvurechenski static void sca_copy_b_to_e(struct esca_block *d, struct bsca_block *s) 26385e044315SEugene (jno) Dvurechenski { 26395e044315SEugene (jno) Dvurechenski int i; 26405e044315SEugene (jno) Dvurechenski 26415e044315SEugene (jno) Dvurechenski d->ipte_control = s->ipte_control; 26425e044315SEugene (jno) Dvurechenski d->mcn[0] = s->mcn; 26435e044315SEugene (jno) Dvurechenski for (i = 0; i < KVM_S390_BSCA_CPU_SLOTS; i++) 26445e044315SEugene (jno) Dvurechenski sca_copy_entry(&d->cpu[i], &s->cpu[i]); 26455e044315SEugene (jno) Dvurechenski } 26465e044315SEugene (jno) Dvurechenski 26475e044315SEugene (jno) Dvurechenski static int sca_switch_to_extended(struct kvm *kvm) 26485e044315SEugene (jno) Dvurechenski { 26495e044315SEugene (jno) Dvurechenski struct bsca_block *old_sca = kvm->arch.sca; 26505e044315SEugene (jno) Dvurechenski struct esca_block *new_sca; 26515e044315SEugene (jno) Dvurechenski struct kvm_vcpu *vcpu; 26525e044315SEugene (jno) Dvurechenski unsigned int vcpu_idx; 26535e044315SEugene (jno) Dvurechenski u32 scaol, scaoh; 26545e044315SEugene (jno) Dvurechenski 26555e044315SEugene (jno) Dvurechenski new_sca = alloc_pages_exact(sizeof(*new_sca), GFP_KERNEL|__GFP_ZERO); 26565e044315SEugene (jno) Dvurechenski if (!new_sca) 26575e044315SEugene (jno) Dvurechenski return -ENOMEM; 26585e044315SEugene (jno) Dvurechenski 26595e044315SEugene (jno) Dvurechenski scaoh = (u32)((u64)(new_sca) >> 32); 26605e044315SEugene (jno) Dvurechenski scaol = (u32)(u64)(new_sca) & ~0x3fU; 26615e044315SEugene (jno) Dvurechenski 26625e044315SEugene (jno) Dvurechenski kvm_s390_vcpu_block_all(kvm); 26635e044315SEugene (jno) Dvurechenski write_lock(&kvm->arch.sca_lock); 26645e044315SEugene (jno) Dvurechenski 26655e044315SEugene (jno) Dvurechenski sca_copy_b_to_e(new_sca, old_sca); 26665e044315SEugene (jno) Dvurechenski 26675e044315SEugene (jno) Dvurechenski kvm_for_each_vcpu(vcpu_idx, vcpu, kvm) { 26685e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaoh = scaoh; 26695e044315SEugene (jno) Dvurechenski vcpu->arch.sie_block->scaol = scaol; 26700c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= ECB2_ESCA; 26715e044315SEugene (jno) Dvurechenski } 26725e044315SEugene (jno) Dvurechenski kvm->arch.sca = new_sca; 26735e044315SEugene (jno) Dvurechenski kvm->arch.use_esca = 1; 26745e044315SEugene (jno) Dvurechenski 26755e044315SEugene (jno) Dvurechenski write_unlock(&kvm->arch.sca_lock); 26765e044315SEugene (jno) Dvurechenski kvm_s390_vcpu_unblock_all(kvm); 26775e044315SEugene (jno) Dvurechenski 26785e044315SEugene (jno) Dvurechenski free_page((unsigned long)old_sca); 26795e044315SEugene (jno) Dvurechenski 26808335713aSChristian Borntraeger VM_EVENT(kvm, 2, "Switched to ESCA (0x%pK -> 0x%pK)", 26818335713aSChristian Borntraeger old_sca, kvm->arch.sca); 26825e044315SEugene (jno) Dvurechenski return 0; 26837d43bafcSEugene (jno) Dvurechenski } 2684a6e2f683SEugene (jno) Dvurechenski 2685a6e2f683SEugene (jno) Dvurechenski static int sca_can_add_vcpu(struct kvm *kvm, unsigned int id) 2686a6e2f683SEugene (jno) Dvurechenski { 26875e044315SEugene (jno) Dvurechenski int rc; 26885e044315SEugene (jno) Dvurechenski 2689a6940674SDavid Hildenbrand if (!kvm_s390_use_sca_entries()) { 2690a6940674SDavid Hildenbrand if (id < KVM_MAX_VCPUS) 2691a6940674SDavid Hildenbrand return true; 2692a6940674SDavid Hildenbrand return false; 2693a6940674SDavid Hildenbrand } 26945e044315SEugene (jno) Dvurechenski if (id < KVM_S390_BSCA_CPU_SLOTS) 26955e044315SEugene (jno) Dvurechenski return true; 269676a6dd72SDavid Hildenbrand if (!sclp.has_esca || !sclp.has_64bscao) 26975e044315SEugene (jno) Dvurechenski return false; 26985e044315SEugene (jno) Dvurechenski 26995e044315SEugene (jno) Dvurechenski mutex_lock(&kvm->lock); 27005e044315SEugene (jno) Dvurechenski rc = kvm->arch.use_esca ? 0 : sca_switch_to_extended(kvm); 27015e044315SEugene (jno) Dvurechenski mutex_unlock(&kvm->lock); 27025e044315SEugene (jno) Dvurechenski 27035e044315SEugene (jno) Dvurechenski return rc == 0 && id < KVM_S390_ESCA_CPU_SLOTS; 2704a6e2f683SEugene (jno) Dvurechenski } 2705a6e2f683SEugene (jno) Dvurechenski 2706dafd032aSDominik Dingel int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 2707dafd032aSDominik Dingel { 2708b0c632dbSHeiko Carstens return 0; 2709b0c632dbSHeiko Carstens } 2710b0c632dbSHeiko Carstens 2711db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 2712db0758b2SDavid Hildenbrand static void __start_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2713db0758b2SDavid Hildenbrand { 2714db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_start != 0); 27159c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 2716db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = get_tod_clock_fast(); 27179c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 2718db0758b2SDavid Hildenbrand } 2719db0758b2SDavid Hildenbrand 2720db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 2721db0758b2SDavid Hildenbrand static void __stop_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2722db0758b2SDavid Hildenbrand { 2723db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_start == 0); 27249c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 2725db0758b2SDavid Hildenbrand vcpu->arch.sie_block->cputm -= get_tod_clock_fast() - vcpu->arch.cputm_start; 2726db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = 0; 27279c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 2728db0758b2SDavid Hildenbrand } 2729db0758b2SDavid Hildenbrand 2730db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 2731db0758b2SDavid Hildenbrand static void __enable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2732db0758b2SDavid Hildenbrand { 2733db0758b2SDavid Hildenbrand WARN_ON_ONCE(vcpu->arch.cputm_enabled); 2734db0758b2SDavid Hildenbrand vcpu->arch.cputm_enabled = true; 2735db0758b2SDavid Hildenbrand __start_cpu_timer_accounting(vcpu); 2736db0758b2SDavid Hildenbrand } 2737db0758b2SDavid Hildenbrand 2738db0758b2SDavid Hildenbrand /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ 2739db0758b2SDavid Hildenbrand static void __disable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2740db0758b2SDavid Hildenbrand { 2741db0758b2SDavid Hildenbrand WARN_ON_ONCE(!vcpu->arch.cputm_enabled); 2742db0758b2SDavid Hildenbrand __stop_cpu_timer_accounting(vcpu); 2743db0758b2SDavid Hildenbrand vcpu->arch.cputm_enabled = false; 2744db0758b2SDavid Hildenbrand } 2745db0758b2SDavid Hildenbrand 2746db0758b2SDavid Hildenbrand static void enable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2747db0758b2SDavid Hildenbrand { 2748db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 2749db0758b2SDavid Hildenbrand __enable_cpu_timer_accounting(vcpu); 2750db0758b2SDavid Hildenbrand preempt_enable(); 2751db0758b2SDavid Hildenbrand } 2752db0758b2SDavid Hildenbrand 2753db0758b2SDavid Hildenbrand static void disable_cpu_timer_accounting(struct kvm_vcpu *vcpu) 2754db0758b2SDavid Hildenbrand { 2755db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 2756db0758b2SDavid Hildenbrand __disable_cpu_timer_accounting(vcpu); 2757db0758b2SDavid Hildenbrand preempt_enable(); 2758db0758b2SDavid Hildenbrand } 2759db0758b2SDavid Hildenbrand 27604287f247SDavid Hildenbrand /* set the cpu timer - may only be called from the VCPU thread itself */ 27614287f247SDavid Hildenbrand void kvm_s390_set_cpu_timer(struct kvm_vcpu *vcpu, __u64 cputm) 27624287f247SDavid Hildenbrand { 2763db0758b2SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 27649c23a131SDavid Hildenbrand raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount); 2765db0758b2SDavid Hildenbrand if (vcpu->arch.cputm_enabled) 2766db0758b2SDavid Hildenbrand vcpu->arch.cputm_start = get_tod_clock_fast(); 27674287f247SDavid Hildenbrand vcpu->arch.sie_block->cputm = cputm; 27689c23a131SDavid Hildenbrand raw_write_seqcount_end(&vcpu->arch.cputm_seqcount); 2769db0758b2SDavid Hildenbrand preempt_enable(); 27704287f247SDavid Hildenbrand } 27714287f247SDavid Hildenbrand 2772db0758b2SDavid Hildenbrand /* update and get the cpu timer - can also be called from other VCPU threads */ 27734287f247SDavid Hildenbrand __u64 kvm_s390_get_cpu_timer(struct kvm_vcpu *vcpu) 27744287f247SDavid Hildenbrand { 27759c23a131SDavid Hildenbrand unsigned int seq; 2776db0758b2SDavid Hildenbrand __u64 value; 2777db0758b2SDavid Hildenbrand 2778db0758b2SDavid Hildenbrand if (unlikely(!vcpu->arch.cputm_enabled)) 27794287f247SDavid Hildenbrand return vcpu->arch.sie_block->cputm; 2780db0758b2SDavid Hildenbrand 27819c23a131SDavid Hildenbrand preempt_disable(); /* protect from TOD sync and vcpu_load/put */ 27829c23a131SDavid Hildenbrand do { 27839c23a131SDavid Hildenbrand seq = raw_read_seqcount(&vcpu->arch.cputm_seqcount); 27849c23a131SDavid Hildenbrand /* 27859c23a131SDavid Hildenbrand * If the writer would ever execute a read in the critical 27869c23a131SDavid Hildenbrand * section, e.g. in irq context, we have a deadlock. 27879c23a131SDavid Hildenbrand */ 27889c23a131SDavid Hildenbrand WARN_ON_ONCE((seq & 1) && smp_processor_id() == vcpu->cpu); 2789db0758b2SDavid Hildenbrand value = vcpu->arch.sie_block->cputm; 27909c23a131SDavid Hildenbrand /* if cputm_start is 0, accounting is being started/stopped */ 27919c23a131SDavid Hildenbrand if (likely(vcpu->arch.cputm_start)) 2792db0758b2SDavid Hildenbrand value -= get_tod_clock_fast() - vcpu->arch.cputm_start; 27939c23a131SDavid Hildenbrand } while (read_seqcount_retry(&vcpu->arch.cputm_seqcount, seq & ~1)); 27949c23a131SDavid Hildenbrand preempt_enable(); 2795db0758b2SDavid Hildenbrand return value; 27964287f247SDavid Hildenbrand } 27974287f247SDavid Hildenbrand 2798b0c632dbSHeiko Carstens void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 2799b0c632dbSHeiko Carstens { 28009977e886SHendrik Brueckner 280137d9df98SDavid Hildenbrand gmap_enable(vcpu->arch.enabled_gmap); 2802ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_RUNNING); 28035ebda316SDavid Hildenbrand if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu)) 2804db0758b2SDavid Hildenbrand __start_cpu_timer_accounting(vcpu); 280501a745acSDavid Hildenbrand vcpu->cpu = cpu; 2806b0c632dbSHeiko Carstens } 2807b0c632dbSHeiko Carstens 2808b0c632dbSHeiko Carstens void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 2809b0c632dbSHeiko Carstens { 281001a745acSDavid Hildenbrand vcpu->cpu = -1; 28115ebda316SDavid Hildenbrand if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu)) 2812db0758b2SDavid Hildenbrand __stop_cpu_timer_accounting(vcpu); 28139daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_RUNNING); 281437d9df98SDavid Hildenbrand vcpu->arch.enabled_gmap = gmap_get_enabled(); 281537d9df98SDavid Hildenbrand gmap_disable(vcpu->arch.enabled_gmap); 28169977e886SHendrik Brueckner 2817b0c632dbSHeiko Carstens } 2818b0c632dbSHeiko Carstens 2819b0c632dbSHeiko Carstens static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu) 2820b0c632dbSHeiko Carstens { 2821b0c632dbSHeiko Carstens /* this equals initial cpu reset in pop, but we don't switch to ESA */ 2822b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.mask = 0UL; 2823b0c632dbSHeiko Carstens vcpu->arch.sie_block->gpsw.addr = 0UL; 28248d26cf7bSChristian Borntraeger kvm_s390_set_prefix(vcpu, 0); 28254287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, 0); 2826b0c632dbSHeiko Carstens vcpu->arch.sie_block->ckc = 0UL; 2827b0c632dbSHeiko Carstens vcpu->arch.sie_block->todpr = 0; 2828b0c632dbSHeiko Carstens memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64)); 2829b9224cd7SDavid Hildenbrand vcpu->arch.sie_block->gcr[0] = CR0_UNUSED_56 | 2830b9224cd7SDavid Hildenbrand CR0_INTERRUPT_KEY_SUBMASK | 2831b9224cd7SDavid Hildenbrand CR0_MEASUREMENT_ALERT_SUBMASK; 2832b9224cd7SDavid Hildenbrand vcpu->arch.sie_block->gcr[14] = CR14_UNUSED_32 | 2833b9224cd7SDavid Hildenbrand CR14_UNUSED_33 | 2834b9224cd7SDavid Hildenbrand CR14_EXTERNAL_DAMAGE_SUBMASK; 28359abc2a08SDavid Hildenbrand /* make sure the new fpc will be lazily loaded */ 28369abc2a08SDavid Hildenbrand save_fpu_regs(); 28379abc2a08SDavid Hildenbrand current->thread.fpu.fpc = 0; 2838b0c632dbSHeiko Carstens vcpu->arch.sie_block->gbea = 1; 2839672550fbSChristian Borntraeger vcpu->arch.sie_block->pp = 0; 284035b3fde6SChristian Borntraeger vcpu->arch.sie_block->fpf &= ~FPF_BPBC; 28413c038e6bSDominik Dingel vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 28423c038e6bSDominik Dingel kvm_clear_async_pf_completion_queue(vcpu); 28436352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) 28446852d7b6SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 28452ed10cc1SJens Freimann kvm_s390_clear_local_irqs(vcpu); 2846b0c632dbSHeiko Carstens } 2847b0c632dbSHeiko Carstens 284831928aa5SDominik Dingel void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu) 284942897d86SMarcelo Tosatti { 285072f25020SJason J. Herne mutex_lock(&vcpu->kvm->lock); 2851fdf03650SFan Zhang preempt_disable(); 285272f25020SJason J. Herne vcpu->arch.sie_block->epoch = vcpu->kvm->arch.epoch; 2853d16b52cbSDavid Hildenbrand vcpu->arch.sie_block->epdx = vcpu->kvm->arch.epdx; 2854fdf03650SFan Zhang preempt_enable(); 285572f25020SJason J. Herne mutex_unlock(&vcpu->kvm->lock); 285625508824SDavid Hildenbrand if (!kvm_is_ucontrol(vcpu->kvm)) { 2857dafd032aSDominik Dingel vcpu->arch.gmap = vcpu->kvm->arch.gmap; 2858eaa78f34SDavid Hildenbrand sca_add_vcpu(vcpu); 285925508824SDavid Hildenbrand } 28606502a34cSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 74) || vcpu->kvm->arch.user_instr0) 28616502a34cSDavid Hildenbrand vcpu->arch.sie_block->ictl |= ICTL_OPEREXC; 286237d9df98SDavid Hildenbrand /* make vcpu_load load the right gmap on the first trigger */ 286337d9df98SDavid Hildenbrand vcpu->arch.enabled_gmap = vcpu->arch.gmap; 286442897d86SMarcelo Tosatti } 286542897d86SMarcelo Tosatti 28668ec2fa52SChristian Borntraeger static bool kvm_has_pckmo_subfunc(struct kvm *kvm, unsigned long nr) 28678ec2fa52SChristian Borntraeger { 28688ec2fa52SChristian Borntraeger if (test_bit_inv(nr, (unsigned long *)&kvm->arch.model.subfuncs.pckmo) && 28698ec2fa52SChristian Borntraeger test_bit_inv(nr, (unsigned long *)&kvm_s390_available_subfunc.pckmo)) 28708ec2fa52SChristian Borntraeger return true; 28718ec2fa52SChristian Borntraeger return false; 28728ec2fa52SChristian Borntraeger } 28738ec2fa52SChristian Borntraeger 28748ec2fa52SChristian Borntraeger static bool kvm_has_pckmo_ecc(struct kvm *kvm) 28758ec2fa52SChristian Borntraeger { 28768ec2fa52SChristian Borntraeger /* At least one ECC subfunction must be present */ 28778ec2fa52SChristian Borntraeger return kvm_has_pckmo_subfunc(kvm, 32) || 28788ec2fa52SChristian Borntraeger kvm_has_pckmo_subfunc(kvm, 33) || 28798ec2fa52SChristian Borntraeger kvm_has_pckmo_subfunc(kvm, 34) || 28808ec2fa52SChristian Borntraeger kvm_has_pckmo_subfunc(kvm, 40) || 28818ec2fa52SChristian Borntraeger kvm_has_pckmo_subfunc(kvm, 41); 28828ec2fa52SChristian Borntraeger 28838ec2fa52SChristian Borntraeger } 28848ec2fa52SChristian Borntraeger 28855102ee87STony Krowiak static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu) 28865102ee87STony Krowiak { 2887e585b24aSTony Krowiak /* 2888e585b24aSTony Krowiak * If the AP instructions are not being interpreted and the MSAX3 2889e585b24aSTony Krowiak * facility is not configured for the guest, there is nothing to set up. 2890e585b24aSTony Krowiak */ 2891e585b24aSTony Krowiak if (!vcpu->kvm->arch.crypto.apie && !test_kvm_facility(vcpu->kvm, 76)) 28925102ee87STony Krowiak return; 28935102ee87STony Krowiak 2894e585b24aSTony Krowiak vcpu->arch.sie_block->crycbd = vcpu->kvm->arch.crypto.crycbd; 2895a374e892STony Krowiak vcpu->arch.sie_block->ecb3 &= ~(ECB3_AES | ECB3_DEA); 289637940fb0STony Krowiak vcpu->arch.sie_block->eca &= ~ECA_APIE; 28978ec2fa52SChristian Borntraeger vcpu->arch.sie_block->ecd &= ~ECD_ECC; 2898a374e892STony Krowiak 2899e585b24aSTony Krowiak if (vcpu->kvm->arch.crypto.apie) 2900e585b24aSTony Krowiak vcpu->arch.sie_block->eca |= ECA_APIE; 2901e585b24aSTony Krowiak 2902e585b24aSTony Krowiak /* Set up protected key support */ 29038ec2fa52SChristian Borntraeger if (vcpu->kvm->arch.crypto.aes_kw) { 2904a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_AES; 29058ec2fa52SChristian Borntraeger /* ecc is also wrapped with AES key */ 29068ec2fa52SChristian Borntraeger if (kvm_has_pckmo_ecc(vcpu->kvm)) 29078ec2fa52SChristian Borntraeger vcpu->arch.sie_block->ecd |= ECD_ECC; 29088ec2fa52SChristian Borntraeger } 29098ec2fa52SChristian Borntraeger 2910a374e892STony Krowiak if (vcpu->kvm->arch.crypto.dea_kw) 2911a374e892STony Krowiak vcpu->arch.sie_block->ecb3 |= ECB3_DEA; 29125102ee87STony Krowiak } 29135102ee87STony Krowiak 2914b31605c1SDominik Dingel void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu) 2915b31605c1SDominik Dingel { 2916b31605c1SDominik Dingel free_page(vcpu->arch.sie_block->cbrlo); 2917b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = 0; 2918b31605c1SDominik Dingel } 2919b31605c1SDominik Dingel 2920b31605c1SDominik Dingel int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu) 2921b31605c1SDominik Dingel { 2922b31605c1SDominik Dingel vcpu->arch.sie_block->cbrlo = get_zeroed_page(GFP_KERNEL); 2923b31605c1SDominik Dingel if (!vcpu->arch.sie_block->cbrlo) 2924b31605c1SDominik Dingel return -ENOMEM; 2925b31605c1SDominik Dingel return 0; 2926b31605c1SDominik Dingel } 2927b31605c1SDominik Dingel 292891520f1aSMichael Mueller static void kvm_s390_vcpu_setup_model(struct kvm_vcpu *vcpu) 292991520f1aSMichael Mueller { 293091520f1aSMichael Mueller struct kvm_s390_cpu_model *model = &vcpu->kvm->arch.model; 293191520f1aSMichael Mueller 293291520f1aSMichael Mueller vcpu->arch.sie_block->ibc = model->ibc; 293380bc79dcSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 7)) 2934c54f0d6aSDavid Hildenbrand vcpu->arch.sie_block->fac = (u32)(u64) model->fac_list; 293591520f1aSMichael Mueller } 293691520f1aSMichael Mueller 2937b0c632dbSHeiko Carstens int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) 2938b0c632dbSHeiko Carstens { 2939b31605c1SDominik Dingel int rc = 0; 2940b31288faSKonstantin Weitz 29419e6dabefSCornelia Huck atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH | 29429e6dabefSCornelia Huck CPUSTAT_SM | 2943a4a4f191SGuenther Hutzl CPUSTAT_STOPPED); 2944a4a4f191SGuenther Hutzl 294553df84f8SGuenther Hutzl if (test_kvm_facility(vcpu->kvm, 78)) 2946ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_GED2); 294753df84f8SGuenther Hutzl else if (test_kvm_facility(vcpu->kvm, 8)) 2948ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_GED); 2949a4a4f191SGuenther Hutzl 295091520f1aSMichael Mueller kvm_s390_vcpu_setup_model(vcpu); 295191520f1aSMichael Mueller 2952bdab09f3SDavid Hildenbrand /* pgste_set_pte has special handling for !MACHINE_HAS_ESOP */ 2953bdab09f3SDavid Hildenbrand if (MACHINE_HAS_ESOP) 29540c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb |= ECB_HOSTPROTINT; 2955bd50e8ecSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 9)) 29560c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb |= ECB_SRSI; 2957f597d24eSDavid Hildenbrand if (test_kvm_facility(vcpu->kvm, 73)) 29580c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb |= ECB_TE; 29597feb6bb8SMichael Mueller 2960c9f0a2b8SJanosch Frank if (test_kvm_facility(vcpu->kvm, 8) && vcpu->kvm->arch.use_pfmfi) 29610c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= ECB2_PFMFI; 2962cd1836f5SJanosch Frank if (test_kvm_facility(vcpu->kvm, 130)) 29630c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb2 |= ECB2_IEP; 29640c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca = ECA_MVPGI | ECA_PROTEXCI; 296548ee7d3aSDavid Hildenbrand if (sclp.has_cei) 29660c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_CEI; 296711ad65b7SDavid Hildenbrand if (sclp.has_ib) 29680c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_IB; 296937c5f6c8SDavid Hildenbrand if (sclp.has_siif) 29700c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_SII; 297137c5f6c8SDavid Hildenbrand if (sclp.has_sigpif) 29720c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_SIGPI; 297318280d8bSMichael Mueller if (test_kvm_facility(vcpu->kvm, 129)) { 29740c9d8683SDavid Hildenbrand vcpu->arch.sie_block->eca |= ECA_VX; 29750c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecd |= ECD_HOSTREGMGMT; 297613211ea7SEric Farman } 29778fa1696eSCollin L. Walling if (test_kvm_facility(vcpu->kvm, 139)) 29788fa1696eSCollin L. Walling vcpu->arch.sie_block->ecd |= ECD_MEF; 2979a3da7b4aSChristian Borntraeger if (test_kvm_facility(vcpu->kvm, 156)) 2980a3da7b4aSChristian Borntraeger vcpu->arch.sie_block->ecd |= ECD_ETOKENF; 2981d7c5cb01SMichael Mueller if (vcpu->arch.sie_block->gd) { 2982d7c5cb01SMichael Mueller vcpu->arch.sie_block->eca |= ECA_AIV; 2983d7c5cb01SMichael Mueller VCPU_EVENT(vcpu, 3, "AIV gisa format-%u enabled for cpu %03u", 2984d7c5cb01SMichael Mueller vcpu->arch.sie_block->gd & 0x3, vcpu->vcpu_id); 2985d7c5cb01SMichael Mueller } 29864e0b1ab7SFan Zhang vcpu->arch.sie_block->sdnxo = ((unsigned long) &vcpu->run->s.regs.sdnx) 29874e0b1ab7SFan Zhang | SDNXC; 2988c6e5f166SFan Zhang vcpu->arch.sie_block->riccbd = (unsigned long) &vcpu->run->s.regs.riccb; 2989730cd632SFarhan Ali 2990730cd632SFarhan Ali if (sclp.has_kss) 2991ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_KSS); 2992730cd632SFarhan Ali else 2993492d8642SThomas Huth vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE; 29945a5e6536SMatthew Rosato 2995e6db1d61SDominik Dingel if (vcpu->kvm->arch.use_cmma) { 2996b31605c1SDominik Dingel rc = kvm_s390_vcpu_setup_cmma(vcpu); 2997b31605c1SDominik Dingel if (rc) 2998b31605c1SDominik Dingel return rc; 2999b31288faSKonstantin Weitz } 30000ac96cafSDavid Hildenbrand hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 3001ca872302SChristian Borntraeger vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup; 30029d8d5786SMichael Mueller 300367d49d52SCollin Walling vcpu->arch.sie_block->hpid = HPID_KVM; 300467d49d52SCollin Walling 30055102ee87STony Krowiak kvm_s390_vcpu_crypto_setup(vcpu); 30065102ee87STony Krowiak 3007b31605c1SDominik Dingel return rc; 3008b0c632dbSHeiko Carstens } 3009b0c632dbSHeiko Carstens 3010897cc38eSSean Christopherson int kvm_arch_vcpu_precreate(struct kvm *kvm, unsigned int id) 3011897cc38eSSean Christopherson { 3012897cc38eSSean Christopherson if (!kvm_is_ucontrol(kvm) && !sca_can_add_vcpu(kvm, id)) 3013897cc38eSSean Christopherson return -EINVAL; 3014897cc38eSSean Christopherson return 0; 3015897cc38eSSean Christopherson } 3016897cc38eSSean Christopherson 3017b0c632dbSHeiko Carstens struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, 3018b0c632dbSHeiko Carstens unsigned int id) 3019b0c632dbSHeiko Carstens { 30204d47555aSCarsten Otte struct kvm_vcpu *vcpu; 30217feb6bb8SMichael Mueller struct sie_page *sie_page; 3022897cc38eSSean Christopherson int rc; 30234d47555aSCarsten Otte 30244d47555aSCarsten Otte rc = -ENOMEM; 30254d47555aSCarsten Otte 3026b110feafSMichael Mueller vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL); 3027b0c632dbSHeiko Carstens if (!vcpu) 30284d47555aSCarsten Otte goto out; 3029b0c632dbSHeiko Carstens 3030da72ca4dSQingFeng Hao BUILD_BUG_ON(sizeof(struct sie_page) != 4096); 30317feb6bb8SMichael Mueller sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL); 30327feb6bb8SMichael Mueller if (!sie_page) 3033b0c632dbSHeiko Carstens goto out_free_cpu; 3034b0c632dbSHeiko Carstens 30357feb6bb8SMichael Mueller vcpu->arch.sie_block = &sie_page->sie_block; 30367feb6bb8SMichael Mueller vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb; 30377feb6bb8SMichael Mueller 3038efed1104SDavid Hildenbrand /* the real guest size will always be smaller than msl */ 3039efed1104SDavid Hildenbrand vcpu->arch.sie_block->mso = 0; 3040efed1104SDavid Hildenbrand vcpu->arch.sie_block->msl = sclp.hamax; 3041efed1104SDavid Hildenbrand 3042b0c632dbSHeiko Carstens vcpu->arch.sie_block->icpua = id; 3043ba5c1e9bSCarsten Otte spin_lock_init(&vcpu->arch.local_int.lock); 3044982cff42SMichael Mueller vcpu->arch.sie_block->gd = (u32)(u64)kvm->arch.gisa_int.origin; 30454b9f9525SMichael Mueller if (vcpu->arch.sie_block->gd && sclp.has_gisaf) 30464b9f9525SMichael Mueller vcpu->arch.sie_block->gd |= GISA_FORMAT1; 30479c23a131SDavid Hildenbrand seqcount_init(&vcpu->arch.cputm_seqcount); 3048ba5c1e9bSCarsten Otte 3049b0c632dbSHeiko Carstens rc = kvm_vcpu_init(vcpu, kvm, id); 3050b0c632dbSHeiko Carstens if (rc) 30519abc2a08SDavid Hildenbrand goto out_free_sie_block; 3052*321f8ee5SSean Christopherson 3053*321f8ee5SSean Christopherson vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID; 3054*321f8ee5SSean Christopherson kvm_clear_async_pf_completion_queue(vcpu); 3055*321f8ee5SSean Christopherson vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX | 3056*321f8ee5SSean Christopherson KVM_SYNC_GPRS | 3057*321f8ee5SSean Christopherson KVM_SYNC_ACRS | 3058*321f8ee5SSean Christopherson KVM_SYNC_CRS | 3059*321f8ee5SSean Christopherson KVM_SYNC_ARCH0 | 3060*321f8ee5SSean Christopherson KVM_SYNC_PFAULT; 3061*321f8ee5SSean Christopherson kvm_s390_set_prefix(vcpu, 0); 3062*321f8ee5SSean Christopherson if (test_kvm_facility(vcpu->kvm, 64)) 3063*321f8ee5SSean Christopherson vcpu->run->kvm_valid_regs |= KVM_SYNC_RICCB; 3064*321f8ee5SSean Christopherson if (test_kvm_facility(vcpu->kvm, 82)) 3065*321f8ee5SSean Christopherson vcpu->run->kvm_valid_regs |= KVM_SYNC_BPBC; 3066*321f8ee5SSean Christopherson if (test_kvm_facility(vcpu->kvm, 133)) 3067*321f8ee5SSean Christopherson vcpu->run->kvm_valid_regs |= KVM_SYNC_GSCB; 3068*321f8ee5SSean Christopherson if (test_kvm_facility(vcpu->kvm, 156)) 3069*321f8ee5SSean Christopherson vcpu->run->kvm_valid_regs |= KVM_SYNC_ETOKEN; 3070*321f8ee5SSean Christopherson /* fprs can be synchronized via vrs, even if the guest has no vx. With 3071*321f8ee5SSean Christopherson * MACHINE_HAS_VX, (load|store)_fpu_regs() will work with vrs format. 3072*321f8ee5SSean Christopherson */ 3073*321f8ee5SSean Christopherson if (MACHINE_HAS_VX) 3074*321f8ee5SSean Christopherson vcpu->run->kvm_valid_regs |= KVM_SYNC_VRS; 3075*321f8ee5SSean Christopherson else 3076*321f8ee5SSean Christopherson vcpu->run->kvm_valid_regs |= KVM_SYNC_FPRS; 3077*321f8ee5SSean Christopherson 3078*321f8ee5SSean Christopherson if (kvm_is_ucontrol(vcpu->kvm)) { 3079*321f8ee5SSean Christopherson rc = __kvm_ucontrol_vcpu_init(vcpu); 3080*321f8ee5SSean Christopherson if (rc) 3081*321f8ee5SSean Christopherson goto out_uninit_vcpu; 3082*321f8ee5SSean Christopherson } 3083*321f8ee5SSean Christopherson 30848335713aSChristian Borntraeger VM_EVENT(kvm, 3, "create cpu %d at 0x%pK, sie block at 0x%pK", id, vcpu, 3085b0c632dbSHeiko Carstens vcpu->arch.sie_block); 3086ade38c31SCornelia Huck trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block); 3087b0c632dbSHeiko Carstens 3088b0c632dbSHeiko Carstens return vcpu; 3089*321f8ee5SSean Christopherson out_uninit_vcpu: 3090*321f8ee5SSean Christopherson kvm_vcpu_uninit(vcpu); 30917b06bf2fSWei Yongjun out_free_sie_block: 30927b06bf2fSWei Yongjun free_page((unsigned long)(vcpu->arch.sie_block)); 3093b0c632dbSHeiko Carstens out_free_cpu: 3094b110feafSMichael Mueller kmem_cache_free(kvm_vcpu_cache, vcpu); 30954d47555aSCarsten Otte out: 3096b0c632dbSHeiko Carstens return ERR_PTR(rc); 3097b0c632dbSHeiko Carstens } 3098b0c632dbSHeiko Carstens 3099b0c632dbSHeiko Carstens int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu) 3100b0c632dbSHeiko Carstens { 31019a022067SDavid Hildenbrand return kvm_s390_vcpu_has_irq(vcpu, 0); 3102b0c632dbSHeiko Carstens } 3103b0c632dbSHeiko Carstens 3104199b5763SLongpeng(Mike) bool kvm_arch_vcpu_in_kernel(struct kvm_vcpu *vcpu) 3105199b5763SLongpeng(Mike) { 31060546c63dSLongpeng(Mike) return !(vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE); 3107199b5763SLongpeng(Mike) } 3108199b5763SLongpeng(Mike) 310927406cd5SChristian Borntraeger void kvm_s390_vcpu_block(struct kvm_vcpu *vcpu) 311049b99e1eSChristian Borntraeger { 3111805de8f4SPeter Zijlstra atomic_or(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 311261a6df54SDavid Hildenbrand exit_sie(vcpu); 311349b99e1eSChristian Borntraeger } 311449b99e1eSChristian Borntraeger 311527406cd5SChristian Borntraeger void kvm_s390_vcpu_unblock(struct kvm_vcpu *vcpu) 311649b99e1eSChristian Borntraeger { 3117805de8f4SPeter Zijlstra atomic_andnot(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20); 311849b99e1eSChristian Borntraeger } 311949b99e1eSChristian Borntraeger 31208e236546SChristian Borntraeger static void kvm_s390_vcpu_request(struct kvm_vcpu *vcpu) 31218e236546SChristian Borntraeger { 3122805de8f4SPeter Zijlstra atomic_or(PROG_REQUEST, &vcpu->arch.sie_block->prog20); 312361a6df54SDavid Hildenbrand exit_sie(vcpu); 31248e236546SChristian Borntraeger } 31258e236546SChristian Borntraeger 31269ea59728SDavid Hildenbrand bool kvm_s390_vcpu_sie_inhibited(struct kvm_vcpu *vcpu) 31279ea59728SDavid Hildenbrand { 31289ea59728SDavid Hildenbrand return atomic_read(&vcpu->arch.sie_block->prog20) & 31299ea59728SDavid Hildenbrand (PROG_BLOCK_SIE | PROG_REQUEST); 31309ea59728SDavid Hildenbrand } 31319ea59728SDavid Hildenbrand 31328e236546SChristian Borntraeger static void kvm_s390_vcpu_request_handled(struct kvm_vcpu *vcpu) 31338e236546SChristian Borntraeger { 31349bf9fde2SJason J. Herne atomic_andnot(PROG_REQUEST, &vcpu->arch.sie_block->prog20); 31358e236546SChristian Borntraeger } 31368e236546SChristian Borntraeger 313749b99e1eSChristian Borntraeger /* 31389ea59728SDavid Hildenbrand * Kick a guest cpu out of (v)SIE and wait until (v)SIE is not running. 313949b99e1eSChristian Borntraeger * If the CPU is not running (e.g. waiting as idle) the function will 314049b99e1eSChristian Borntraeger * return immediately. */ 314149b99e1eSChristian Borntraeger void exit_sie(struct kvm_vcpu *vcpu) 314249b99e1eSChristian Borntraeger { 3143ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_STOP_INT); 31449ea59728SDavid Hildenbrand kvm_s390_vsie_kick(vcpu); 314549b99e1eSChristian Borntraeger while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE) 314649b99e1eSChristian Borntraeger cpu_relax(); 314749b99e1eSChristian Borntraeger } 314849b99e1eSChristian Borntraeger 31498e236546SChristian Borntraeger /* Kick a guest cpu out of SIE to process a request synchronously */ 31508e236546SChristian Borntraeger void kvm_s390_sync_request(int req, struct kvm_vcpu *vcpu) 315149b99e1eSChristian Borntraeger { 31528e236546SChristian Borntraeger kvm_make_request(req, vcpu); 31538e236546SChristian Borntraeger kvm_s390_vcpu_request(vcpu); 315449b99e1eSChristian Borntraeger } 315549b99e1eSChristian Borntraeger 3156414d3b07SMartin Schwidefsky static void kvm_gmap_notifier(struct gmap *gmap, unsigned long start, 3157414d3b07SMartin Schwidefsky unsigned long end) 31582c70fe44SChristian Borntraeger { 31592c70fe44SChristian Borntraeger struct kvm *kvm = gmap->private; 31602c70fe44SChristian Borntraeger struct kvm_vcpu *vcpu; 3161414d3b07SMartin Schwidefsky unsigned long prefix; 3162414d3b07SMartin Schwidefsky int i; 31632c70fe44SChristian Borntraeger 316465d0b0d4SDavid Hildenbrand if (gmap_is_shadow(gmap)) 316565d0b0d4SDavid Hildenbrand return; 3166414d3b07SMartin Schwidefsky if (start >= 1UL << 31) 3167414d3b07SMartin Schwidefsky /* We are only interested in prefix pages */ 3168414d3b07SMartin Schwidefsky return; 31692c70fe44SChristian Borntraeger kvm_for_each_vcpu(i, vcpu, kvm) { 31702c70fe44SChristian Borntraeger /* match against both prefix pages */ 3171414d3b07SMartin Schwidefsky prefix = kvm_s390_get_prefix(vcpu); 3172414d3b07SMartin Schwidefsky if (prefix <= end && start <= prefix + 2*PAGE_SIZE - 1) { 3173414d3b07SMartin Schwidefsky VCPU_EVENT(vcpu, 2, "gmap notifier for %lx-%lx", 3174414d3b07SMartin Schwidefsky start, end); 31758e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_MMU_RELOAD, vcpu); 31762c70fe44SChristian Borntraeger } 31772c70fe44SChristian Borntraeger } 31782c70fe44SChristian Borntraeger } 31792c70fe44SChristian Borntraeger 31808b905d28SChristian Borntraeger bool kvm_arch_no_poll(struct kvm_vcpu *vcpu) 31818b905d28SChristian Borntraeger { 31828b905d28SChristian Borntraeger /* do not poll with more than halt_poll_max_steal percent of steal time */ 31838b905d28SChristian Borntraeger if (S390_lowcore.avg_steal_timer * 100 / (TICK_USEC << 12) >= 31848b905d28SChristian Borntraeger halt_poll_max_steal) { 31858b905d28SChristian Borntraeger vcpu->stat.halt_no_poll_steal++; 31868b905d28SChristian Borntraeger return true; 31878b905d28SChristian Borntraeger } 31888b905d28SChristian Borntraeger return false; 31898b905d28SChristian Borntraeger } 31908b905d28SChristian Borntraeger 3191b6d33834SChristoffer Dall int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu) 3192b6d33834SChristoffer Dall { 3193b6d33834SChristoffer Dall /* kvm common code refers to this, but never calls it */ 3194b6d33834SChristoffer Dall BUG(); 3195b6d33834SChristoffer Dall return 0; 3196b6d33834SChristoffer Dall } 3197b6d33834SChristoffer Dall 319814eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, 319914eebd91SCarsten Otte struct kvm_one_reg *reg) 320014eebd91SCarsten Otte { 320114eebd91SCarsten Otte int r = -EINVAL; 320214eebd91SCarsten Otte 320314eebd91SCarsten Otte switch (reg->id) { 320429b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 320529b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->todpr, 320629b7c71bSCarsten Otte (u32 __user *)reg->addr); 320729b7c71bSCarsten Otte break; 320829b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 320929b7c71bSCarsten Otte r = put_user(vcpu->arch.sie_block->epoch, 321029b7c71bSCarsten Otte (u64 __user *)reg->addr); 321129b7c71bSCarsten Otte break; 321246a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 32134287f247SDavid Hildenbrand r = put_user(kvm_s390_get_cpu_timer(vcpu), 321446a6dd1cSJason J. herne (u64 __user *)reg->addr); 321546a6dd1cSJason J. herne break; 321646a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 321746a6dd1cSJason J. herne r = put_user(vcpu->arch.sie_block->ckc, 321846a6dd1cSJason J. herne (u64 __user *)reg->addr); 321946a6dd1cSJason J. herne break; 3220536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 3221536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_token, 3222536336c2SDominik Dingel (u64 __user *)reg->addr); 3223536336c2SDominik Dingel break; 3224536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 3225536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_compare, 3226536336c2SDominik Dingel (u64 __user *)reg->addr); 3227536336c2SDominik Dingel break; 3228536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 3229536336c2SDominik Dingel r = put_user(vcpu->arch.pfault_select, 3230536336c2SDominik Dingel (u64 __user *)reg->addr); 3231536336c2SDominik Dingel break; 3232672550fbSChristian Borntraeger case KVM_REG_S390_PP: 3233672550fbSChristian Borntraeger r = put_user(vcpu->arch.sie_block->pp, 3234672550fbSChristian Borntraeger (u64 __user *)reg->addr); 3235672550fbSChristian Borntraeger break; 3236afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 3237afa45ff5SChristian Borntraeger r = put_user(vcpu->arch.sie_block->gbea, 3238afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 3239afa45ff5SChristian Borntraeger break; 324014eebd91SCarsten Otte default: 324114eebd91SCarsten Otte break; 324214eebd91SCarsten Otte } 324314eebd91SCarsten Otte 324414eebd91SCarsten Otte return r; 324514eebd91SCarsten Otte } 324614eebd91SCarsten Otte 324714eebd91SCarsten Otte static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, 324814eebd91SCarsten Otte struct kvm_one_reg *reg) 324914eebd91SCarsten Otte { 325014eebd91SCarsten Otte int r = -EINVAL; 32514287f247SDavid Hildenbrand __u64 val; 325214eebd91SCarsten Otte 325314eebd91SCarsten Otte switch (reg->id) { 325429b7c71bSCarsten Otte case KVM_REG_S390_TODPR: 325529b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->todpr, 325629b7c71bSCarsten Otte (u32 __user *)reg->addr); 325729b7c71bSCarsten Otte break; 325829b7c71bSCarsten Otte case KVM_REG_S390_EPOCHDIFF: 325929b7c71bSCarsten Otte r = get_user(vcpu->arch.sie_block->epoch, 326029b7c71bSCarsten Otte (u64 __user *)reg->addr); 326129b7c71bSCarsten Otte break; 326246a6dd1cSJason J. herne case KVM_REG_S390_CPU_TIMER: 32634287f247SDavid Hildenbrand r = get_user(val, (u64 __user *)reg->addr); 32644287f247SDavid Hildenbrand if (!r) 32654287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, val); 326646a6dd1cSJason J. herne break; 326746a6dd1cSJason J. herne case KVM_REG_S390_CLOCK_COMP: 326846a6dd1cSJason J. herne r = get_user(vcpu->arch.sie_block->ckc, 326946a6dd1cSJason J. herne (u64 __user *)reg->addr); 327046a6dd1cSJason J. herne break; 3271536336c2SDominik Dingel case KVM_REG_S390_PFTOKEN: 3272536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_token, 3273536336c2SDominik Dingel (u64 __user *)reg->addr); 32749fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 32759fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 3276536336c2SDominik Dingel break; 3277536336c2SDominik Dingel case KVM_REG_S390_PFCOMPARE: 3278536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_compare, 3279536336c2SDominik Dingel (u64 __user *)reg->addr); 3280536336c2SDominik Dingel break; 3281536336c2SDominik Dingel case KVM_REG_S390_PFSELECT: 3282536336c2SDominik Dingel r = get_user(vcpu->arch.pfault_select, 3283536336c2SDominik Dingel (u64 __user *)reg->addr); 3284536336c2SDominik Dingel break; 3285672550fbSChristian Borntraeger case KVM_REG_S390_PP: 3286672550fbSChristian Borntraeger r = get_user(vcpu->arch.sie_block->pp, 3287672550fbSChristian Borntraeger (u64 __user *)reg->addr); 3288672550fbSChristian Borntraeger break; 3289afa45ff5SChristian Borntraeger case KVM_REG_S390_GBEA: 3290afa45ff5SChristian Borntraeger r = get_user(vcpu->arch.sie_block->gbea, 3291afa45ff5SChristian Borntraeger (u64 __user *)reg->addr); 3292afa45ff5SChristian Borntraeger break; 329314eebd91SCarsten Otte default: 329414eebd91SCarsten Otte break; 329514eebd91SCarsten Otte } 329614eebd91SCarsten Otte 329714eebd91SCarsten Otte return r; 329814eebd91SCarsten Otte } 3299b6d33834SChristoffer Dall 3300b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) 3301b0c632dbSHeiko Carstens { 3302b0c632dbSHeiko Carstens kvm_s390_vcpu_initial_reset(vcpu); 3303b0c632dbSHeiko Carstens return 0; 3304b0c632dbSHeiko Carstens } 3305b0c632dbSHeiko Carstens 3306b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 3307b0c632dbSHeiko Carstens { 3308875656feSChristoffer Dall vcpu_load(vcpu); 33095a32c1afSChristian Borntraeger memcpy(&vcpu->run->s.regs.gprs, ®s->gprs, sizeof(regs->gprs)); 3310875656feSChristoffer Dall vcpu_put(vcpu); 3311b0c632dbSHeiko Carstens return 0; 3312b0c632dbSHeiko Carstens } 3313b0c632dbSHeiko Carstens 3314b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 3315b0c632dbSHeiko Carstens { 33161fc9b76bSChristoffer Dall vcpu_load(vcpu); 33175a32c1afSChristian Borntraeger memcpy(®s->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs)); 33181fc9b76bSChristoffer Dall vcpu_put(vcpu); 3319b0c632dbSHeiko Carstens return 0; 3320b0c632dbSHeiko Carstens } 3321b0c632dbSHeiko Carstens 3322b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, 3323b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 3324b0c632dbSHeiko Carstens { 3325b4ef9d4eSChristoffer Dall vcpu_load(vcpu); 3326b4ef9d4eSChristoffer Dall 332759674c1aSChristian Borntraeger memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs)); 3328b0c632dbSHeiko Carstens memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs)); 3329b4ef9d4eSChristoffer Dall 3330b4ef9d4eSChristoffer Dall vcpu_put(vcpu); 3331b0c632dbSHeiko Carstens return 0; 3332b0c632dbSHeiko Carstens } 3333b0c632dbSHeiko Carstens 3334b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, 3335b0c632dbSHeiko Carstens struct kvm_sregs *sregs) 3336b0c632dbSHeiko Carstens { 3337bcdec41cSChristoffer Dall vcpu_load(vcpu); 3338bcdec41cSChristoffer Dall 333959674c1aSChristian Borntraeger memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs)); 3340b0c632dbSHeiko Carstens memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs)); 3341bcdec41cSChristoffer Dall 3342bcdec41cSChristoffer Dall vcpu_put(vcpu); 3343b0c632dbSHeiko Carstens return 0; 3344b0c632dbSHeiko Carstens } 3345b0c632dbSHeiko Carstens 3346b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 3347b0c632dbSHeiko Carstens { 33486a96bc7fSChristoffer Dall int ret = 0; 33496a96bc7fSChristoffer Dall 33506a96bc7fSChristoffer Dall vcpu_load(vcpu); 33516a96bc7fSChristoffer Dall 33526a96bc7fSChristoffer Dall if (test_fp_ctl(fpu->fpc)) { 33536a96bc7fSChristoffer Dall ret = -EINVAL; 33546a96bc7fSChristoffer Dall goto out; 33556a96bc7fSChristoffer Dall } 3356e1788bb9SChristian Borntraeger vcpu->run->s.regs.fpc = fpu->fpc; 33579abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) 3358a7d4b8f2SDavid Hildenbrand convert_fp_to_vx((__vector128 *) vcpu->run->s.regs.vrs, 3359a7d4b8f2SDavid Hildenbrand (freg_t *) fpu->fprs); 33609abc2a08SDavid Hildenbrand else 3361a7d4b8f2SDavid Hildenbrand memcpy(vcpu->run->s.regs.fprs, &fpu->fprs, sizeof(fpu->fprs)); 33626a96bc7fSChristoffer Dall 33636a96bc7fSChristoffer Dall out: 33646a96bc7fSChristoffer Dall vcpu_put(vcpu); 33656a96bc7fSChristoffer Dall return ret; 3366b0c632dbSHeiko Carstens } 3367b0c632dbSHeiko Carstens 3368b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 3369b0c632dbSHeiko Carstens { 33701393123eSChristoffer Dall vcpu_load(vcpu); 33711393123eSChristoffer Dall 33729abc2a08SDavid Hildenbrand /* make sure we have the latest values */ 33739abc2a08SDavid Hildenbrand save_fpu_regs(); 33749abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) 3375a7d4b8f2SDavid Hildenbrand convert_vx_to_fp((freg_t *) fpu->fprs, 3376a7d4b8f2SDavid Hildenbrand (__vector128 *) vcpu->run->s.regs.vrs); 33779abc2a08SDavid Hildenbrand else 3378a7d4b8f2SDavid Hildenbrand memcpy(fpu->fprs, vcpu->run->s.regs.fprs, sizeof(fpu->fprs)); 3379e1788bb9SChristian Borntraeger fpu->fpc = vcpu->run->s.regs.fpc; 33801393123eSChristoffer Dall 33811393123eSChristoffer Dall vcpu_put(vcpu); 3382b0c632dbSHeiko Carstens return 0; 3383b0c632dbSHeiko Carstens } 3384b0c632dbSHeiko Carstens 3385b0c632dbSHeiko Carstens static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw) 3386b0c632dbSHeiko Carstens { 3387b0c632dbSHeiko Carstens int rc = 0; 3388b0c632dbSHeiko Carstens 33897a42fdc2SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 3390b0c632dbSHeiko Carstens rc = -EBUSY; 3391d7b0b5ebSCarsten Otte else { 3392d7b0b5ebSCarsten Otte vcpu->run->psw_mask = psw.mask; 3393d7b0b5ebSCarsten Otte vcpu->run->psw_addr = psw.addr; 3394d7b0b5ebSCarsten Otte } 3395b0c632dbSHeiko Carstens return rc; 3396b0c632dbSHeiko Carstens } 3397b0c632dbSHeiko Carstens 3398b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, 3399b0c632dbSHeiko Carstens struct kvm_translation *tr) 3400b0c632dbSHeiko Carstens { 3401b0c632dbSHeiko Carstens return -EINVAL; /* not implemented yet */ 3402b0c632dbSHeiko Carstens } 3403b0c632dbSHeiko Carstens 340427291e21SDavid Hildenbrand #define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \ 340527291e21SDavid Hildenbrand KVM_GUESTDBG_USE_HW_BP | \ 340627291e21SDavid Hildenbrand KVM_GUESTDBG_ENABLE) 340727291e21SDavid Hildenbrand 3408d0bfb940SJan Kiszka int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 3409d0bfb940SJan Kiszka struct kvm_guest_debug *dbg) 3410b0c632dbSHeiko Carstens { 341127291e21SDavid Hildenbrand int rc = 0; 341227291e21SDavid Hildenbrand 341366b56562SChristoffer Dall vcpu_load(vcpu); 341466b56562SChristoffer Dall 341527291e21SDavid Hildenbrand vcpu->guest_debug = 0; 341627291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 341727291e21SDavid Hildenbrand 341866b56562SChristoffer Dall if (dbg->control & ~VALID_GUESTDBG_FLAGS) { 341966b56562SChristoffer Dall rc = -EINVAL; 342066b56562SChristoffer Dall goto out; 342166b56562SChristoffer Dall } 342266b56562SChristoffer Dall if (!sclp.has_gpere) { 342366b56562SChristoffer Dall rc = -EINVAL; 342466b56562SChristoffer Dall goto out; 342566b56562SChristoffer Dall } 342627291e21SDavid Hildenbrand 342727291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_ENABLE) { 342827291e21SDavid Hildenbrand vcpu->guest_debug = dbg->control; 342927291e21SDavid Hildenbrand /* enforce guest PER */ 3430ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_P); 343127291e21SDavid Hildenbrand 343227291e21SDavid Hildenbrand if (dbg->control & KVM_GUESTDBG_USE_HW_BP) 343327291e21SDavid Hildenbrand rc = kvm_s390_import_bp_data(vcpu, dbg); 343427291e21SDavid Hildenbrand } else { 34359daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_P); 343627291e21SDavid Hildenbrand vcpu->arch.guestdbg.last_bp = 0; 343727291e21SDavid Hildenbrand } 343827291e21SDavid Hildenbrand 343927291e21SDavid Hildenbrand if (rc) { 344027291e21SDavid Hildenbrand vcpu->guest_debug = 0; 344127291e21SDavid Hildenbrand kvm_s390_clear_bp_data(vcpu); 34429daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_P); 344327291e21SDavid Hildenbrand } 344427291e21SDavid Hildenbrand 344566b56562SChristoffer Dall out: 344666b56562SChristoffer Dall vcpu_put(vcpu); 344727291e21SDavid Hildenbrand return rc; 3448b0c632dbSHeiko Carstens } 3449b0c632dbSHeiko Carstens 345062d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 345162d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 345262d9f0dbSMarcelo Tosatti { 3453fd232561SChristoffer Dall int ret; 3454fd232561SChristoffer Dall 3455fd232561SChristoffer Dall vcpu_load(vcpu); 3456fd232561SChristoffer Dall 34576352e4d2SDavid Hildenbrand /* CHECK_STOP and LOAD are not supported yet */ 3458fd232561SChristoffer Dall ret = is_vcpu_stopped(vcpu) ? KVM_MP_STATE_STOPPED : 34596352e4d2SDavid Hildenbrand KVM_MP_STATE_OPERATING; 3460fd232561SChristoffer Dall 3461fd232561SChristoffer Dall vcpu_put(vcpu); 3462fd232561SChristoffer Dall return ret; 346362d9f0dbSMarcelo Tosatti } 346462d9f0dbSMarcelo Tosatti 346562d9f0dbSMarcelo Tosatti int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 346662d9f0dbSMarcelo Tosatti struct kvm_mp_state *mp_state) 346762d9f0dbSMarcelo Tosatti { 34686352e4d2SDavid Hildenbrand int rc = 0; 34696352e4d2SDavid Hildenbrand 3470e83dff5eSChristoffer Dall vcpu_load(vcpu); 3471e83dff5eSChristoffer Dall 34726352e4d2SDavid Hildenbrand /* user space knows about this interface - let it control the state */ 34736352e4d2SDavid Hildenbrand vcpu->kvm->arch.user_cpu_state_ctrl = 1; 34746352e4d2SDavid Hildenbrand 34756352e4d2SDavid Hildenbrand switch (mp_state->mp_state) { 34766352e4d2SDavid Hildenbrand case KVM_MP_STATE_STOPPED: 34776352e4d2SDavid Hildenbrand kvm_s390_vcpu_stop(vcpu); 34786352e4d2SDavid Hildenbrand break; 34796352e4d2SDavid Hildenbrand case KVM_MP_STATE_OPERATING: 34806352e4d2SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 34816352e4d2SDavid Hildenbrand break; 34826352e4d2SDavid Hildenbrand case KVM_MP_STATE_LOAD: 34836352e4d2SDavid Hildenbrand case KVM_MP_STATE_CHECK_STOP: 34846352e4d2SDavid Hildenbrand /* fall through - CHECK_STOP and LOAD are not supported yet */ 34856352e4d2SDavid Hildenbrand default: 34866352e4d2SDavid Hildenbrand rc = -ENXIO; 34876352e4d2SDavid Hildenbrand } 34886352e4d2SDavid Hildenbrand 3489e83dff5eSChristoffer Dall vcpu_put(vcpu); 34906352e4d2SDavid Hildenbrand return rc; 349162d9f0dbSMarcelo Tosatti } 349262d9f0dbSMarcelo Tosatti 34938ad35755SDavid Hildenbrand static bool ibs_enabled(struct kvm_vcpu *vcpu) 34948ad35755SDavid Hildenbrand { 34958d5fb0dcSDavid Hildenbrand return kvm_s390_test_cpuflags(vcpu, CPUSTAT_IBS); 34968ad35755SDavid Hildenbrand } 34978ad35755SDavid Hildenbrand 34982c70fe44SChristian Borntraeger static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu) 34992c70fe44SChristian Borntraeger { 35008ad35755SDavid Hildenbrand retry: 35018e236546SChristian Borntraeger kvm_s390_vcpu_request_handled(vcpu); 35022fa6e1e1SRadim Krčmář if (!kvm_request_pending(vcpu)) 3503586b7ccdSChristian Borntraeger return 0; 35042c70fe44SChristian Borntraeger /* 35052c70fe44SChristian Borntraeger * We use MMU_RELOAD just to re-arm the ipte notifier for the 3506b2d73b2aSMartin Schwidefsky * guest prefix page. gmap_mprotect_notify will wait on the ptl lock. 35072c70fe44SChristian Borntraeger * This ensures that the ipte instruction for this request has 35082c70fe44SChristian Borntraeger * already finished. We might race against a second unmapper that 35092c70fe44SChristian Borntraeger * wants to set the blocking bit. Lets just retry the request loop. 35102c70fe44SChristian Borntraeger */ 35118ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) { 35122c70fe44SChristian Borntraeger int rc; 3513b2d73b2aSMartin Schwidefsky rc = gmap_mprotect_notify(vcpu->arch.gmap, 3514fda902cbSMichael Mueller kvm_s390_get_prefix(vcpu), 3515b2d73b2aSMartin Schwidefsky PAGE_SIZE * 2, PROT_WRITE); 3516aca411a4SJulius Niedworok if (rc) { 3517aca411a4SJulius Niedworok kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu); 35182c70fe44SChristian Borntraeger return rc; 3519aca411a4SJulius Niedworok } 35208ad35755SDavid Hildenbrand goto retry; 35212c70fe44SChristian Borntraeger } 35228ad35755SDavid Hildenbrand 3523d3d692c8SDavid Hildenbrand if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu)) { 3524d3d692c8SDavid Hildenbrand vcpu->arch.sie_block->ihcpu = 0xffff; 3525d3d692c8SDavid Hildenbrand goto retry; 3526d3d692c8SDavid Hildenbrand } 3527d3d692c8SDavid Hildenbrand 35288ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu)) { 35298ad35755SDavid Hildenbrand if (!ibs_enabled(vcpu)) { 35308ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 1); 3531ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_IBS); 35328ad35755SDavid Hildenbrand } 35338ad35755SDavid Hildenbrand goto retry; 35348ad35755SDavid Hildenbrand } 35358ad35755SDavid Hildenbrand 35368ad35755SDavid Hildenbrand if (kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu)) { 35378ad35755SDavid Hildenbrand if (ibs_enabled(vcpu)) { 35388ad35755SDavid Hildenbrand trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 0); 35399daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_IBS); 35408ad35755SDavid Hildenbrand } 35418ad35755SDavid Hildenbrand goto retry; 35428ad35755SDavid Hildenbrand } 35438ad35755SDavid Hildenbrand 35446502a34cSDavid Hildenbrand if (kvm_check_request(KVM_REQ_ICPT_OPEREXC, vcpu)) { 35456502a34cSDavid Hildenbrand vcpu->arch.sie_block->ictl |= ICTL_OPEREXC; 35466502a34cSDavid Hildenbrand goto retry; 35476502a34cSDavid Hildenbrand } 35486502a34cSDavid Hildenbrand 3549190df4a2SClaudio Imbrenda if (kvm_check_request(KVM_REQ_START_MIGRATION, vcpu)) { 3550190df4a2SClaudio Imbrenda /* 3551c9f0a2b8SJanosch Frank * Disable CMM virtualization; we will emulate the ESSA 3552190df4a2SClaudio Imbrenda * instruction manually, in order to provide additional 3553190df4a2SClaudio Imbrenda * functionalities needed for live migration. 3554190df4a2SClaudio Imbrenda */ 3555190df4a2SClaudio Imbrenda vcpu->arch.sie_block->ecb2 &= ~ECB2_CMMA; 3556190df4a2SClaudio Imbrenda goto retry; 3557190df4a2SClaudio Imbrenda } 3558190df4a2SClaudio Imbrenda 3559190df4a2SClaudio Imbrenda if (kvm_check_request(KVM_REQ_STOP_MIGRATION, vcpu)) { 3560190df4a2SClaudio Imbrenda /* 3561c9f0a2b8SJanosch Frank * Re-enable CMM virtualization if CMMA is available and 3562c9f0a2b8SJanosch Frank * CMM has been used. 3563190df4a2SClaudio Imbrenda */ 3564190df4a2SClaudio Imbrenda if ((vcpu->kvm->arch.use_cmma) && 3565c9f0a2b8SJanosch Frank (vcpu->kvm->mm->context.uses_cmm)) 3566190df4a2SClaudio Imbrenda vcpu->arch.sie_block->ecb2 |= ECB2_CMMA; 3567190df4a2SClaudio Imbrenda goto retry; 3568190df4a2SClaudio Imbrenda } 3569190df4a2SClaudio Imbrenda 35700759d068SDavid Hildenbrand /* nothing to do, just clear the request */ 357172875d8aSRadim Krčmář kvm_clear_request(KVM_REQ_UNHALT, vcpu); 35723194cdb7SDavid Hildenbrand /* we left the vsie handler, nothing to do, just clear the request */ 35733194cdb7SDavid Hildenbrand kvm_clear_request(KVM_REQ_VSIE_RESTART, vcpu); 35740759d068SDavid Hildenbrand 35752c70fe44SChristian Borntraeger return 0; 35762c70fe44SChristian Borntraeger } 35772c70fe44SChristian Borntraeger 35780e7def5fSDavid Hildenbrand void kvm_s390_set_tod_clock(struct kvm *kvm, 35798fa1696eSCollin L. Walling const struct kvm_s390_vm_tod_clock *gtod) 35808fa1696eSCollin L. Walling { 35818fa1696eSCollin L. Walling struct kvm_vcpu *vcpu; 35828fa1696eSCollin L. Walling struct kvm_s390_tod_clock_ext htod; 35838fa1696eSCollin L. Walling int i; 35848fa1696eSCollin L. Walling 35858fa1696eSCollin L. Walling mutex_lock(&kvm->lock); 35868fa1696eSCollin L. Walling preempt_disable(); 35878fa1696eSCollin L. Walling 35888fa1696eSCollin L. Walling get_tod_clock_ext((char *)&htod); 35898fa1696eSCollin L. Walling 35908fa1696eSCollin L. Walling kvm->arch.epoch = gtod->tod - htod.tod; 35910e7def5fSDavid Hildenbrand kvm->arch.epdx = 0; 35920e7def5fSDavid Hildenbrand if (test_kvm_facility(kvm, 139)) { 35938fa1696eSCollin L. Walling kvm->arch.epdx = gtod->epoch_idx - htod.epoch_idx; 35948fa1696eSCollin L. Walling if (kvm->arch.epoch > gtod->tod) 35958fa1696eSCollin L. Walling kvm->arch.epdx -= 1; 35960e7def5fSDavid Hildenbrand } 35978fa1696eSCollin L. Walling 35988fa1696eSCollin L. Walling kvm_s390_vcpu_block_all(kvm); 35998fa1696eSCollin L. Walling kvm_for_each_vcpu(i, vcpu, kvm) { 36008fa1696eSCollin L. Walling vcpu->arch.sie_block->epoch = kvm->arch.epoch; 36018fa1696eSCollin L. Walling vcpu->arch.sie_block->epdx = kvm->arch.epdx; 36028fa1696eSCollin L. Walling } 36038fa1696eSCollin L. Walling 36048fa1696eSCollin L. Walling kvm_s390_vcpu_unblock_all(kvm); 36058fa1696eSCollin L. Walling preempt_enable(); 36068fa1696eSCollin L. Walling mutex_unlock(&kvm->lock); 36078fa1696eSCollin L. Walling } 36088fa1696eSCollin L. Walling 3609fa576c58SThomas Huth /** 3610fa576c58SThomas Huth * kvm_arch_fault_in_page - fault-in guest page if necessary 3611fa576c58SThomas Huth * @vcpu: The corresponding virtual cpu 3612fa576c58SThomas Huth * @gpa: Guest physical address 3613fa576c58SThomas Huth * @writable: Whether the page should be writable or not 3614fa576c58SThomas Huth * 3615fa576c58SThomas Huth * Make sure that a guest page has been faulted-in on the host. 3616fa576c58SThomas Huth * 3617fa576c58SThomas Huth * Return: Zero on success, negative error code otherwise. 3618fa576c58SThomas Huth */ 3619fa576c58SThomas Huth long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable) 362024eb3a82SDominik Dingel { 3621527e30b4SMartin Schwidefsky return gmap_fault(vcpu->arch.gmap, gpa, 3622527e30b4SMartin Schwidefsky writable ? FAULT_FLAG_WRITE : 0); 362324eb3a82SDominik Dingel } 362424eb3a82SDominik Dingel 36253c038e6bSDominik Dingel static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token, 36263c038e6bSDominik Dingel unsigned long token) 36273c038e6bSDominik Dingel { 36283c038e6bSDominik Dingel struct kvm_s390_interrupt inti; 3629383d0b05SJens Freimann struct kvm_s390_irq irq; 36303c038e6bSDominik Dingel 36313c038e6bSDominik Dingel if (start_token) { 3632383d0b05SJens Freimann irq.u.ext.ext_params2 = token; 3633383d0b05SJens Freimann irq.type = KVM_S390_INT_PFAULT_INIT; 3634383d0b05SJens Freimann WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &irq)); 36353c038e6bSDominik Dingel } else { 36363c038e6bSDominik Dingel inti.type = KVM_S390_INT_PFAULT_DONE; 3637383d0b05SJens Freimann inti.parm64 = token; 36383c038e6bSDominik Dingel WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti)); 36393c038e6bSDominik Dingel } 36403c038e6bSDominik Dingel } 36413c038e6bSDominik Dingel 36423c038e6bSDominik Dingel void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu, 36433c038e6bSDominik Dingel struct kvm_async_pf *work) 36443c038e6bSDominik Dingel { 36453c038e6bSDominik Dingel trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token); 36463c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token); 36473c038e6bSDominik Dingel } 36483c038e6bSDominik Dingel 36493c038e6bSDominik Dingel void kvm_arch_async_page_present(struct kvm_vcpu *vcpu, 36503c038e6bSDominik Dingel struct kvm_async_pf *work) 36513c038e6bSDominik Dingel { 36523c038e6bSDominik Dingel trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token); 36533c038e6bSDominik Dingel __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token); 36543c038e6bSDominik Dingel } 36553c038e6bSDominik Dingel 36563c038e6bSDominik Dingel void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu, 36573c038e6bSDominik Dingel struct kvm_async_pf *work) 36583c038e6bSDominik Dingel { 36593c038e6bSDominik Dingel /* s390 will always inject the page directly */ 36603c038e6bSDominik Dingel } 36613c038e6bSDominik Dingel 36623c038e6bSDominik Dingel bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu) 36633c038e6bSDominik Dingel { 36643c038e6bSDominik Dingel /* 36653c038e6bSDominik Dingel * s390 will always inject the page directly, 36663c038e6bSDominik Dingel * but we still want check_async_completion to cleanup 36673c038e6bSDominik Dingel */ 36683c038e6bSDominik Dingel return true; 36693c038e6bSDominik Dingel } 36703c038e6bSDominik Dingel 36713c038e6bSDominik Dingel static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu) 36723c038e6bSDominik Dingel { 36733c038e6bSDominik Dingel hva_t hva; 36743c038e6bSDominik Dingel struct kvm_arch_async_pf arch; 36753c038e6bSDominik Dingel int rc; 36763c038e6bSDominik Dingel 36773c038e6bSDominik Dingel if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 36783c038e6bSDominik Dingel return 0; 36793c038e6bSDominik Dingel if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) != 36803c038e6bSDominik Dingel vcpu->arch.pfault_compare) 36813c038e6bSDominik Dingel return 0; 36823c038e6bSDominik Dingel if (psw_extint_disabled(vcpu)) 36833c038e6bSDominik Dingel return 0; 36849a022067SDavid Hildenbrand if (kvm_s390_vcpu_has_irq(vcpu, 0)) 36853c038e6bSDominik Dingel return 0; 3686b9224cd7SDavid Hildenbrand if (!(vcpu->arch.sie_block->gcr[0] & CR0_SERVICE_SIGNAL_SUBMASK)) 36873c038e6bSDominik Dingel return 0; 36883c038e6bSDominik Dingel if (!vcpu->arch.gmap->pfault_enabled) 36893c038e6bSDominik Dingel return 0; 36903c038e6bSDominik Dingel 369181480cc1SHeiko Carstens hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(current->thread.gmap_addr)); 369281480cc1SHeiko Carstens hva += current->thread.gmap_addr & ~PAGE_MASK; 369381480cc1SHeiko Carstens if (read_guest_real(vcpu, vcpu->arch.pfault_token, &arch.pfault_token, 8)) 36943c038e6bSDominik Dingel return 0; 36953c038e6bSDominik Dingel 36963c038e6bSDominik Dingel rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch); 36973c038e6bSDominik Dingel return rc; 36983c038e6bSDominik Dingel } 36993c038e6bSDominik Dingel 37003fb4c40fSThomas Huth static int vcpu_pre_run(struct kvm_vcpu *vcpu) 3701b0c632dbSHeiko Carstens { 37023fb4c40fSThomas Huth int rc, cpuflags; 3703e168bf8dSCarsten Otte 37043c038e6bSDominik Dingel /* 37053c038e6bSDominik Dingel * On s390 notifications for arriving pages will be delivered directly 37063c038e6bSDominik Dingel * to the guest but the house keeping for completed pfaults is 37073c038e6bSDominik Dingel * handled outside the worker. 37083c038e6bSDominik Dingel */ 37093c038e6bSDominik Dingel kvm_check_async_pf_completion(vcpu); 37103c038e6bSDominik Dingel 37117ec7c8c7SChristian Borntraeger vcpu->arch.sie_block->gg14 = vcpu->run->s.regs.gprs[14]; 37127ec7c8c7SChristian Borntraeger vcpu->arch.sie_block->gg15 = vcpu->run->s.regs.gprs[15]; 3713b0c632dbSHeiko Carstens 3714b0c632dbSHeiko Carstens if (need_resched()) 3715b0c632dbSHeiko Carstens schedule(); 3716b0c632dbSHeiko Carstens 3717d3a73acbSMartin Schwidefsky if (test_cpu_flag(CIF_MCCK_PENDING)) 371871cde587SChristian Borntraeger s390_handle_mcck(); 371971cde587SChristian Borntraeger 372079395031SJens Freimann if (!kvm_is_ucontrol(vcpu->kvm)) { 372179395031SJens Freimann rc = kvm_s390_deliver_pending_interrupts(vcpu); 372279395031SJens Freimann if (rc) 372379395031SJens Freimann return rc; 372479395031SJens Freimann } 37250ff31867SCarsten Otte 37262c70fe44SChristian Borntraeger rc = kvm_s390_handle_requests(vcpu); 37272c70fe44SChristian Borntraeger if (rc) 37282c70fe44SChristian Borntraeger return rc; 37292c70fe44SChristian Borntraeger 373027291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) { 373127291e21SDavid Hildenbrand kvm_s390_backup_guest_per_regs(vcpu); 373227291e21SDavid Hildenbrand kvm_s390_patch_guest_per_regs(vcpu); 373327291e21SDavid Hildenbrand } 373427291e21SDavid Hildenbrand 37359f30f621SMichael Mueller clear_bit(vcpu->vcpu_id, vcpu->kvm->arch.gisa_int.kicked_mask); 37369f30f621SMichael Mueller 3737b0c632dbSHeiko Carstens vcpu->arch.sie_block->icptcode = 0; 37383fb4c40fSThomas Huth cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags); 37393fb4c40fSThomas Huth VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags); 37403fb4c40fSThomas Huth trace_kvm_s390_sie_enter(vcpu, cpuflags); 37412b29a9fdSDominik Dingel 37423fb4c40fSThomas Huth return 0; 37433fb4c40fSThomas Huth } 37443fb4c40fSThomas Huth 3745492d8642SThomas Huth static int vcpu_post_run_fault_in_sie(struct kvm_vcpu *vcpu) 3746492d8642SThomas Huth { 374756317920SDavid Hildenbrand struct kvm_s390_pgm_info pgm_info = { 374856317920SDavid Hildenbrand .code = PGM_ADDRESSING, 374956317920SDavid Hildenbrand }; 375056317920SDavid Hildenbrand u8 opcode, ilen; 3751492d8642SThomas Huth int rc; 3752492d8642SThomas Huth 3753492d8642SThomas Huth VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction"); 3754492d8642SThomas Huth trace_kvm_s390_sie_fault(vcpu); 3755492d8642SThomas Huth 3756492d8642SThomas Huth /* 3757492d8642SThomas Huth * We want to inject an addressing exception, which is defined as a 3758492d8642SThomas Huth * suppressing or terminating exception. However, since we came here 3759492d8642SThomas Huth * by a DAT access exception, the PSW still points to the faulting 3760492d8642SThomas Huth * instruction since DAT exceptions are nullifying. So we've got 3761492d8642SThomas Huth * to look up the current opcode to get the length of the instruction 3762492d8642SThomas Huth * to be able to forward the PSW. 3763492d8642SThomas Huth */ 37643fa8cad7SDavid Hildenbrand rc = read_guest_instr(vcpu, vcpu->arch.sie_block->gpsw.addr, &opcode, 1); 376556317920SDavid Hildenbrand ilen = insn_length(opcode); 37669b0d721aSDavid Hildenbrand if (rc < 0) { 37679b0d721aSDavid Hildenbrand return rc; 37689b0d721aSDavid Hildenbrand } else if (rc) { 37699b0d721aSDavid Hildenbrand /* Instruction-Fetching Exceptions - we can't detect the ilen. 37709b0d721aSDavid Hildenbrand * Forward by arbitrary ilc, injection will take care of 37719b0d721aSDavid Hildenbrand * nullification if necessary. 37729b0d721aSDavid Hildenbrand */ 37739b0d721aSDavid Hildenbrand pgm_info = vcpu->arch.pgm; 37749b0d721aSDavid Hildenbrand ilen = 4; 37759b0d721aSDavid Hildenbrand } 377656317920SDavid Hildenbrand pgm_info.flags = ilen | KVM_S390_PGM_FLAGS_ILC_VALID; 377756317920SDavid Hildenbrand kvm_s390_forward_psw(vcpu, ilen); 377856317920SDavid Hildenbrand return kvm_s390_inject_prog_irq(vcpu, &pgm_info); 3779492d8642SThomas Huth } 3780492d8642SThomas Huth 37813fb4c40fSThomas Huth static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason) 37823fb4c40fSThomas Huth { 37834d62fcc0SQingFeng Hao struct mcck_volatile_info *mcck_info; 37844d62fcc0SQingFeng Hao struct sie_page *sie_page; 37854d62fcc0SQingFeng Hao 37862b29a9fdSDominik Dingel VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", 37872b29a9fdSDominik Dingel vcpu->arch.sie_block->icptcode); 37882b29a9fdSDominik Dingel trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode); 37892b29a9fdSDominik Dingel 379027291e21SDavid Hildenbrand if (guestdbg_enabled(vcpu)) 379127291e21SDavid Hildenbrand kvm_s390_restore_guest_per_regs(vcpu); 379227291e21SDavid Hildenbrand 37937ec7c8c7SChristian Borntraeger vcpu->run->s.regs.gprs[14] = vcpu->arch.sie_block->gg14; 37947ec7c8c7SChristian Borntraeger vcpu->run->s.regs.gprs[15] = vcpu->arch.sie_block->gg15; 379571f116bfSDavid Hildenbrand 37964d62fcc0SQingFeng Hao if (exit_reason == -EINTR) { 37974d62fcc0SQingFeng Hao VCPU_EVENT(vcpu, 3, "%s", "machine check"); 37984d62fcc0SQingFeng Hao sie_page = container_of(vcpu->arch.sie_block, 37994d62fcc0SQingFeng Hao struct sie_page, sie_block); 38004d62fcc0SQingFeng Hao mcck_info = &sie_page->mcck_info; 38014d62fcc0SQingFeng Hao kvm_s390_reinject_machine_check(vcpu, mcck_info); 38024d62fcc0SQingFeng Hao return 0; 38034d62fcc0SQingFeng Hao } 38044d62fcc0SQingFeng Hao 380571f116bfSDavid Hildenbrand if (vcpu->arch.sie_block->icptcode > 0) { 380671f116bfSDavid Hildenbrand int rc = kvm_handle_sie_intercept(vcpu); 380771f116bfSDavid Hildenbrand 380871f116bfSDavid Hildenbrand if (rc != -EOPNOTSUPP) 380971f116bfSDavid Hildenbrand return rc; 381071f116bfSDavid Hildenbrand vcpu->run->exit_reason = KVM_EXIT_S390_SIEIC; 381171f116bfSDavid Hildenbrand vcpu->run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode; 381271f116bfSDavid Hildenbrand vcpu->run->s390_sieic.ipa = vcpu->arch.sie_block->ipa; 381371f116bfSDavid Hildenbrand vcpu->run->s390_sieic.ipb = vcpu->arch.sie_block->ipb; 381471f116bfSDavid Hildenbrand return -EREMOTE; 381571f116bfSDavid Hildenbrand } else if (exit_reason != -EFAULT) { 381671f116bfSDavid Hildenbrand vcpu->stat.exit_null++; 381771f116bfSDavid Hildenbrand return 0; 3818210b1607SThomas Huth } else if (kvm_is_ucontrol(vcpu->kvm)) { 3819210b1607SThomas Huth vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL; 3820210b1607SThomas Huth vcpu->run->s390_ucontrol.trans_exc_code = 3821210b1607SThomas Huth current->thread.gmap_addr; 3822210b1607SThomas Huth vcpu->run->s390_ucontrol.pgm_code = 0x10; 382371f116bfSDavid Hildenbrand return -EREMOTE; 382424eb3a82SDominik Dingel } else if (current->thread.gmap_pfault) { 38253c038e6bSDominik Dingel trace_kvm_s390_major_guest_pfault(vcpu); 382624eb3a82SDominik Dingel current->thread.gmap_pfault = 0; 382771f116bfSDavid Hildenbrand if (kvm_arch_setup_async_pf(vcpu)) 382871f116bfSDavid Hildenbrand return 0; 382971f116bfSDavid Hildenbrand return kvm_arch_fault_in_page(vcpu, current->thread.gmap_addr, 1); 3830fa576c58SThomas Huth } 383171f116bfSDavid Hildenbrand return vcpu_post_run_fault_in_sie(vcpu); 38323fb4c40fSThomas Huth } 38333fb4c40fSThomas Huth 38343fb4c40fSThomas Huth static int __vcpu_run(struct kvm_vcpu *vcpu) 38353fb4c40fSThomas Huth { 38363fb4c40fSThomas Huth int rc, exit_reason; 38373fb4c40fSThomas Huth 3838800c1065SThomas Huth /* 3839800c1065SThomas Huth * We try to hold kvm->srcu during most of vcpu_run (except when run- 3840800c1065SThomas Huth * ning the guest), so that memslots (and other stuff) are protected 3841800c1065SThomas Huth */ 3842800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 3843800c1065SThomas Huth 3844a76ccff6SThomas Huth do { 38453fb4c40fSThomas Huth rc = vcpu_pre_run(vcpu); 38463fb4c40fSThomas Huth if (rc) 3847a76ccff6SThomas Huth break; 38483fb4c40fSThomas Huth 3849800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 38503fb4c40fSThomas Huth /* 3851a76ccff6SThomas Huth * As PF_VCPU will be used in fault handler, between 3852a76ccff6SThomas Huth * guest_enter and guest_exit should be no uaccess. 38533fb4c40fSThomas Huth */ 38540097d12eSChristian Borntraeger local_irq_disable(); 38556edaa530SPaolo Bonzini guest_enter_irqoff(); 3856db0758b2SDavid Hildenbrand __disable_cpu_timer_accounting(vcpu); 38570097d12eSChristian Borntraeger local_irq_enable(); 3858a76ccff6SThomas Huth exit_reason = sie64a(vcpu->arch.sie_block, 3859a76ccff6SThomas Huth vcpu->run->s.regs.gprs); 38600097d12eSChristian Borntraeger local_irq_disable(); 3861db0758b2SDavid Hildenbrand __enable_cpu_timer_accounting(vcpu); 38626edaa530SPaolo Bonzini guest_exit_irqoff(); 38630097d12eSChristian Borntraeger local_irq_enable(); 3864800c1065SThomas Huth vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 38653fb4c40fSThomas Huth 38663fb4c40fSThomas Huth rc = vcpu_post_run(vcpu, exit_reason); 386727291e21SDavid Hildenbrand } while (!signal_pending(current) && !guestdbg_exit_pending(vcpu) && !rc); 38683fb4c40fSThomas Huth 3869800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); 3870e168bf8dSCarsten Otte return rc; 3871b0c632dbSHeiko Carstens } 3872b0c632dbSHeiko Carstens 3873b028ee3eSDavid Hildenbrand static void sync_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 3874b028ee3eSDavid Hildenbrand { 38754d5f2c04SChristian Borntraeger struct runtime_instr_cb *riccb; 38764e0b1ab7SFan Zhang struct gs_cb *gscb; 38774d5f2c04SChristian Borntraeger 38784d5f2c04SChristian Borntraeger riccb = (struct runtime_instr_cb *) &kvm_run->s.regs.riccb; 38794e0b1ab7SFan Zhang gscb = (struct gs_cb *) &kvm_run->s.regs.gscb; 3880b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask; 3881b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr; 3882b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) 3883b028ee3eSDavid Hildenbrand kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix); 3884b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) { 3885b028ee3eSDavid Hildenbrand memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128); 3886d3d692c8SDavid Hildenbrand /* some control register changes require a tlb flush */ 3887d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 3888b028ee3eSDavid Hildenbrand } 3889b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_ARCH0) { 38904287f247SDavid Hildenbrand kvm_s390_set_cpu_timer(vcpu, kvm_run->s.regs.cputm); 3891b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->ckc = kvm_run->s.regs.ckc; 3892b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->todpr = kvm_run->s.regs.todpr; 3893b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->pp = kvm_run->s.regs.pp; 3894b028ee3eSDavid Hildenbrand vcpu->arch.sie_block->gbea = kvm_run->s.regs.gbea; 3895b028ee3eSDavid Hildenbrand } 3896b028ee3eSDavid Hildenbrand if (kvm_run->kvm_dirty_regs & KVM_SYNC_PFAULT) { 3897b028ee3eSDavid Hildenbrand vcpu->arch.pfault_token = kvm_run->s.regs.pft; 3898b028ee3eSDavid Hildenbrand vcpu->arch.pfault_select = kvm_run->s.regs.pfs; 3899b028ee3eSDavid Hildenbrand vcpu->arch.pfault_compare = kvm_run->s.regs.pfc; 39009fbd8082SDavid Hildenbrand if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID) 39019fbd8082SDavid Hildenbrand kvm_clear_async_pf_completion_queue(vcpu); 3902b028ee3eSDavid Hildenbrand } 390380cd8763SFan Zhang /* 390480cd8763SFan Zhang * If userspace sets the riccb (e.g. after migration) to a valid state, 390580cd8763SFan Zhang * we should enable RI here instead of doing the lazy enablement. 390680cd8763SFan Zhang */ 390780cd8763SFan Zhang if ((kvm_run->kvm_dirty_regs & KVM_SYNC_RICCB) && 39084d5f2c04SChristian Borntraeger test_kvm_facility(vcpu->kvm, 64) && 3909bb59c2daSAlice Frosi riccb->v && 39100c9d8683SDavid Hildenbrand !(vcpu->arch.sie_block->ecb3 & ECB3_RI)) { 39114d5f2c04SChristian Borntraeger VCPU_EVENT(vcpu, 3, "%s", "ENABLE: RI (sync_regs)"); 39120c9d8683SDavid Hildenbrand vcpu->arch.sie_block->ecb3 |= ECB3_RI; 391380cd8763SFan Zhang } 39144e0b1ab7SFan Zhang /* 39154e0b1ab7SFan Zhang * If userspace sets the gscb (e.g. after migration) to non-zero, 39164e0b1ab7SFan Zhang * we should enable GS here instead of doing the lazy enablement. 39174e0b1ab7SFan Zhang */ 39184e0b1ab7SFan Zhang if ((kvm_run->kvm_dirty_regs & KVM_SYNC_GSCB) && 39194e0b1ab7SFan Zhang test_kvm_facility(vcpu->kvm, 133) && 39204e0b1ab7SFan Zhang gscb->gssm && 39214e0b1ab7SFan Zhang !vcpu->arch.gs_enabled) { 39224e0b1ab7SFan Zhang VCPU_EVENT(vcpu, 3, "%s", "ENABLE: GS (sync_regs)"); 39234e0b1ab7SFan Zhang vcpu->arch.sie_block->ecb |= ECB_GS; 39244e0b1ab7SFan Zhang vcpu->arch.sie_block->ecd |= ECD_HOSTREGMGMT; 39254e0b1ab7SFan Zhang vcpu->arch.gs_enabled = 1; 392680cd8763SFan Zhang } 392735b3fde6SChristian Borntraeger if ((kvm_run->kvm_dirty_regs & KVM_SYNC_BPBC) && 392835b3fde6SChristian Borntraeger test_kvm_facility(vcpu->kvm, 82)) { 392935b3fde6SChristian Borntraeger vcpu->arch.sie_block->fpf &= ~FPF_BPBC; 393035b3fde6SChristian Borntraeger vcpu->arch.sie_block->fpf |= kvm_run->s.regs.bpbc ? FPF_BPBC : 0; 393135b3fde6SChristian Borntraeger } 393231d8b8d4SChristian Borntraeger save_access_regs(vcpu->arch.host_acrs); 393331d8b8d4SChristian Borntraeger restore_access_regs(vcpu->run->s.regs.acrs); 3934e1788bb9SChristian Borntraeger /* save host (userspace) fprs/vrs */ 3935e1788bb9SChristian Borntraeger save_fpu_regs(); 3936e1788bb9SChristian Borntraeger vcpu->arch.host_fpregs.fpc = current->thread.fpu.fpc; 3937e1788bb9SChristian Borntraeger vcpu->arch.host_fpregs.regs = current->thread.fpu.regs; 3938e1788bb9SChristian Borntraeger if (MACHINE_HAS_VX) 3939e1788bb9SChristian Borntraeger current->thread.fpu.regs = vcpu->run->s.regs.vrs; 3940e1788bb9SChristian Borntraeger else 3941e1788bb9SChristian Borntraeger current->thread.fpu.regs = vcpu->run->s.regs.fprs; 3942e1788bb9SChristian Borntraeger current->thread.fpu.fpc = vcpu->run->s.regs.fpc; 3943e1788bb9SChristian Borntraeger if (test_fp_ctl(current->thread.fpu.fpc)) 3944e1788bb9SChristian Borntraeger /* User space provided an invalid FPC, let's clear it */ 3945e1788bb9SChristian Borntraeger current->thread.fpu.fpc = 0; 39464e0b1ab7SFan Zhang if (MACHINE_HAS_GS) { 39474e0b1ab7SFan Zhang preempt_disable(); 39484e0b1ab7SFan Zhang __ctl_set_bit(2, 4); 39494e0b1ab7SFan Zhang if (current->thread.gs_cb) { 39504e0b1ab7SFan Zhang vcpu->arch.host_gscb = current->thread.gs_cb; 39514e0b1ab7SFan Zhang save_gs_cb(vcpu->arch.host_gscb); 39524e0b1ab7SFan Zhang } 39534e0b1ab7SFan Zhang if (vcpu->arch.gs_enabled) { 39544e0b1ab7SFan Zhang current->thread.gs_cb = (struct gs_cb *) 39554e0b1ab7SFan Zhang &vcpu->run->s.regs.gscb; 39564e0b1ab7SFan Zhang restore_gs_cb(current->thread.gs_cb); 39574e0b1ab7SFan Zhang } 39584e0b1ab7SFan Zhang preempt_enable(); 39594e0b1ab7SFan Zhang } 3960a3da7b4aSChristian Borntraeger /* SIE will load etoken directly from SDNX and therefore kvm_run */ 396180cd8763SFan Zhang 3962b028ee3eSDavid Hildenbrand kvm_run->kvm_dirty_regs = 0; 3963b028ee3eSDavid Hildenbrand } 3964b028ee3eSDavid Hildenbrand 3965b028ee3eSDavid Hildenbrand static void store_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 3966b028ee3eSDavid Hildenbrand { 3967b028ee3eSDavid Hildenbrand kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask; 3968b028ee3eSDavid Hildenbrand kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr; 3969b028ee3eSDavid Hildenbrand kvm_run->s.regs.prefix = kvm_s390_get_prefix(vcpu); 3970b028ee3eSDavid Hildenbrand memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128); 39714287f247SDavid Hildenbrand kvm_run->s.regs.cputm = kvm_s390_get_cpu_timer(vcpu); 3972b028ee3eSDavid Hildenbrand kvm_run->s.regs.ckc = vcpu->arch.sie_block->ckc; 3973b028ee3eSDavid Hildenbrand kvm_run->s.regs.todpr = vcpu->arch.sie_block->todpr; 3974b028ee3eSDavid Hildenbrand kvm_run->s.regs.pp = vcpu->arch.sie_block->pp; 3975b028ee3eSDavid Hildenbrand kvm_run->s.regs.gbea = vcpu->arch.sie_block->gbea; 3976b028ee3eSDavid Hildenbrand kvm_run->s.regs.pft = vcpu->arch.pfault_token; 3977b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfs = vcpu->arch.pfault_select; 3978b028ee3eSDavid Hildenbrand kvm_run->s.regs.pfc = vcpu->arch.pfault_compare; 397935b3fde6SChristian Borntraeger kvm_run->s.regs.bpbc = (vcpu->arch.sie_block->fpf & FPF_BPBC) == FPF_BPBC; 398031d8b8d4SChristian Borntraeger save_access_regs(vcpu->run->s.regs.acrs); 398131d8b8d4SChristian Borntraeger restore_access_regs(vcpu->arch.host_acrs); 3982e1788bb9SChristian Borntraeger /* Save guest register state */ 3983e1788bb9SChristian Borntraeger save_fpu_regs(); 3984e1788bb9SChristian Borntraeger vcpu->run->s.regs.fpc = current->thread.fpu.fpc; 3985e1788bb9SChristian Borntraeger /* Restore will be done lazily at return */ 3986e1788bb9SChristian Borntraeger current->thread.fpu.fpc = vcpu->arch.host_fpregs.fpc; 3987e1788bb9SChristian Borntraeger current->thread.fpu.regs = vcpu->arch.host_fpregs.regs; 39884e0b1ab7SFan Zhang if (MACHINE_HAS_GS) { 39894e0b1ab7SFan Zhang __ctl_set_bit(2, 4); 39904e0b1ab7SFan Zhang if (vcpu->arch.gs_enabled) 39914e0b1ab7SFan Zhang save_gs_cb(current->thread.gs_cb); 39924e0b1ab7SFan Zhang preempt_disable(); 39934e0b1ab7SFan Zhang current->thread.gs_cb = vcpu->arch.host_gscb; 39944e0b1ab7SFan Zhang restore_gs_cb(vcpu->arch.host_gscb); 39954e0b1ab7SFan Zhang preempt_enable(); 39964e0b1ab7SFan Zhang if (!vcpu->arch.host_gscb) 39974e0b1ab7SFan Zhang __ctl_clear_bit(2, 4); 39984e0b1ab7SFan Zhang vcpu->arch.host_gscb = NULL; 39994e0b1ab7SFan Zhang } 4000a3da7b4aSChristian Borntraeger /* SIE will save etoken directly into SDNX and therefore kvm_run */ 4001b028ee3eSDavid Hildenbrand } 4002b028ee3eSDavid Hildenbrand 4003b0c632dbSHeiko Carstens int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 4004b0c632dbSHeiko Carstens { 40058f2abe6aSChristian Borntraeger int rc; 4006b0c632dbSHeiko Carstens 4007460df4c1SPaolo Bonzini if (kvm_run->immediate_exit) 4008460df4c1SPaolo Bonzini return -EINTR; 4009460df4c1SPaolo Bonzini 4010200824f5SThomas Huth if (kvm_run->kvm_valid_regs & ~KVM_SYNC_S390_VALID_FIELDS || 4011200824f5SThomas Huth kvm_run->kvm_dirty_regs & ~KVM_SYNC_S390_VALID_FIELDS) 4012200824f5SThomas Huth return -EINVAL; 4013200824f5SThomas Huth 4014accb757dSChristoffer Dall vcpu_load(vcpu); 4015accb757dSChristoffer Dall 401627291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu)) { 401727291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 4018accb757dSChristoffer Dall rc = 0; 4019accb757dSChristoffer Dall goto out; 402027291e21SDavid Hildenbrand } 402127291e21SDavid Hildenbrand 402220b7035cSJan H. Schönherr kvm_sigset_activate(vcpu); 4023b0c632dbSHeiko Carstens 40246352e4d2SDavid Hildenbrand if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) { 40256852d7b6SDavid Hildenbrand kvm_s390_vcpu_start(vcpu); 40266352e4d2SDavid Hildenbrand } else if (is_vcpu_stopped(vcpu)) { 4027ea2cdd27SDavid Hildenbrand pr_err_ratelimited("can't run stopped vcpu %d\n", 40286352e4d2SDavid Hildenbrand vcpu->vcpu_id); 4029accb757dSChristoffer Dall rc = -EINVAL; 4030accb757dSChristoffer Dall goto out; 40316352e4d2SDavid Hildenbrand } 4032b0c632dbSHeiko Carstens 4033b028ee3eSDavid Hildenbrand sync_regs(vcpu, kvm_run); 4034db0758b2SDavid Hildenbrand enable_cpu_timer_accounting(vcpu); 4035d7b0b5ebSCarsten Otte 4036dab4079dSHeiko Carstens might_fault(); 4037e168bf8dSCarsten Otte rc = __vcpu_run(vcpu); 40389ace903dSChristian Ehrhardt 4039b1d16c49SChristian Ehrhardt if (signal_pending(current) && !rc) { 4040b1d16c49SChristian Ehrhardt kvm_run->exit_reason = KVM_EXIT_INTR; 40418f2abe6aSChristian Borntraeger rc = -EINTR; 4042b1d16c49SChristian Ehrhardt } 40438f2abe6aSChristian Borntraeger 404427291e21SDavid Hildenbrand if (guestdbg_exit_pending(vcpu) && !rc) { 404527291e21SDavid Hildenbrand kvm_s390_prepare_debug_exit(vcpu); 404627291e21SDavid Hildenbrand rc = 0; 404727291e21SDavid Hildenbrand } 404827291e21SDavid Hildenbrand 40498f2abe6aSChristian Borntraeger if (rc == -EREMOTE) { 405071f116bfSDavid Hildenbrand /* userspace support is needed, kvm_run has been prepared */ 40518f2abe6aSChristian Borntraeger rc = 0; 40528f2abe6aSChristian Borntraeger } 40538f2abe6aSChristian Borntraeger 4054db0758b2SDavid Hildenbrand disable_cpu_timer_accounting(vcpu); 4055b028ee3eSDavid Hildenbrand store_regs(vcpu, kvm_run); 4056d7b0b5ebSCarsten Otte 405720b7035cSJan H. Schönherr kvm_sigset_deactivate(vcpu); 4058b0c632dbSHeiko Carstens 4059b0c632dbSHeiko Carstens vcpu->stat.exit_userspace++; 4060accb757dSChristoffer Dall out: 4061accb757dSChristoffer Dall vcpu_put(vcpu); 40627e8e6ab4SHeiko Carstens return rc; 4063b0c632dbSHeiko Carstens } 4064b0c632dbSHeiko Carstens 4065b0c632dbSHeiko Carstens /* 4066b0c632dbSHeiko Carstens * store status at address 4067b0c632dbSHeiko Carstens * we use have two special cases: 4068b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit 4069b0c632dbSHeiko Carstens * KVM_S390_STORE_STATUS_PREFIXED: -> prefix 4070b0c632dbSHeiko Carstens */ 4071d0bce605SHeiko Carstens int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long gpa) 4072b0c632dbSHeiko Carstens { 4073092670cdSCarsten Otte unsigned char archmode = 1; 40749abc2a08SDavid Hildenbrand freg_t fprs[NUM_FPRS]; 4075fda902cbSMichael Mueller unsigned int px; 40764287f247SDavid Hildenbrand u64 clkcomp, cputm; 4077d0bce605SHeiko Carstens int rc; 4078b0c632dbSHeiko Carstens 4079d9a3a09aSMartin Schwidefsky px = kvm_s390_get_prefix(vcpu); 4080d0bce605SHeiko Carstens if (gpa == KVM_S390_STORE_STATUS_NOADDR) { 4081d0bce605SHeiko Carstens if (write_guest_abs(vcpu, 163, &archmode, 1)) 4082b0c632dbSHeiko Carstens return -EFAULT; 4083d9a3a09aSMartin Schwidefsky gpa = 0; 4084d0bce605SHeiko Carstens } else if (gpa == KVM_S390_STORE_STATUS_PREFIXED) { 4085d0bce605SHeiko Carstens if (write_guest_real(vcpu, 163, &archmode, 1)) 4086b0c632dbSHeiko Carstens return -EFAULT; 4087d9a3a09aSMartin Schwidefsky gpa = px; 4088d9a3a09aSMartin Schwidefsky } else 4089d9a3a09aSMartin Schwidefsky gpa -= __LC_FPREGS_SAVE_AREA; 40909abc2a08SDavid Hildenbrand 40919abc2a08SDavid Hildenbrand /* manually convert vector registers if necessary */ 40929abc2a08SDavid Hildenbrand if (MACHINE_HAS_VX) { 40939522b37fSDavid Hildenbrand convert_vx_to_fp(fprs, (__vector128 *) vcpu->run->s.regs.vrs); 4094d9a3a09aSMartin Schwidefsky rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA, 40959abc2a08SDavid Hildenbrand fprs, 128); 40969abc2a08SDavid Hildenbrand } else { 40979abc2a08SDavid Hildenbrand rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA, 40986fd8e67dSDavid Hildenbrand vcpu->run->s.regs.fprs, 128); 40999abc2a08SDavid Hildenbrand } 4100d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_GPREGS_SAVE_AREA, 4101d0bce605SHeiko Carstens vcpu->run->s.regs.gprs, 128); 4102d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_PSW_SAVE_AREA, 4103d0bce605SHeiko Carstens &vcpu->arch.sie_block->gpsw, 16); 4104d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_PREFIX_SAVE_AREA, 4105fda902cbSMichael Mueller &px, 4); 4106d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_FP_CREG_SAVE_AREA, 41079abc2a08SDavid Hildenbrand &vcpu->run->s.regs.fpc, 4); 4108d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_TOD_PROGREG_SAVE_AREA, 4109d0bce605SHeiko Carstens &vcpu->arch.sie_block->todpr, 4); 41104287f247SDavid Hildenbrand cputm = kvm_s390_get_cpu_timer(vcpu); 4111d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CPU_TIMER_SAVE_AREA, 41124287f247SDavid Hildenbrand &cputm, 8); 4113178bd789SThomas Huth clkcomp = vcpu->arch.sie_block->ckc >> 8; 4114d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CLOCK_COMP_SAVE_AREA, 4115d0bce605SHeiko Carstens &clkcomp, 8); 4116d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_AREGS_SAVE_AREA, 4117d0bce605SHeiko Carstens &vcpu->run->s.regs.acrs, 64); 4118d9a3a09aSMartin Schwidefsky rc |= write_guest_abs(vcpu, gpa + __LC_CREGS_SAVE_AREA, 4119d0bce605SHeiko Carstens &vcpu->arch.sie_block->gcr, 128); 4120d0bce605SHeiko Carstens return rc ? -EFAULT : 0; 4121b0c632dbSHeiko Carstens } 4122b0c632dbSHeiko Carstens 4123e879892cSThomas Huth int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr) 4124e879892cSThomas Huth { 4125e879892cSThomas Huth /* 4126e879892cSThomas Huth * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy 412731d8b8d4SChristian Borntraeger * switch in the run ioctl. Let's update our copies before we save 4128e879892cSThomas Huth * it into the save area 4129e879892cSThomas Huth */ 4130d0164ee2SHendrik Brueckner save_fpu_regs(); 41319abc2a08SDavid Hildenbrand vcpu->run->s.regs.fpc = current->thread.fpu.fpc; 4132e879892cSThomas Huth save_access_regs(vcpu->run->s.regs.acrs); 4133e879892cSThomas Huth 4134e879892cSThomas Huth return kvm_s390_store_status_unloaded(vcpu, addr); 4135e879892cSThomas Huth } 4136e879892cSThomas Huth 41378ad35755SDavid Hildenbrand static void __disable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 41388ad35755SDavid Hildenbrand { 41398ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu); 41408e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_DISABLE_IBS, vcpu); 41418ad35755SDavid Hildenbrand } 41428ad35755SDavid Hildenbrand 41438ad35755SDavid Hildenbrand static void __disable_ibs_on_all_vcpus(struct kvm *kvm) 41448ad35755SDavid Hildenbrand { 41458ad35755SDavid Hildenbrand unsigned int i; 41468ad35755SDavid Hildenbrand struct kvm_vcpu *vcpu; 41478ad35755SDavid Hildenbrand 41488ad35755SDavid Hildenbrand kvm_for_each_vcpu(i, vcpu, kvm) { 41498ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 41508ad35755SDavid Hildenbrand } 41518ad35755SDavid Hildenbrand } 41528ad35755SDavid Hildenbrand 41538ad35755SDavid Hildenbrand static void __enable_ibs_on_vcpu(struct kvm_vcpu *vcpu) 41548ad35755SDavid Hildenbrand { 415509a400e7SDavid Hildenbrand if (!sclp.has_ibs) 415609a400e7SDavid Hildenbrand return; 41578ad35755SDavid Hildenbrand kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu); 41588e236546SChristian Borntraeger kvm_s390_sync_request(KVM_REQ_ENABLE_IBS, vcpu); 41598ad35755SDavid Hildenbrand } 41608ad35755SDavid Hildenbrand 41616852d7b6SDavid Hildenbrand void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu) 41626852d7b6SDavid Hildenbrand { 41638ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 41648ad35755SDavid Hildenbrand 41658ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu)) 41668ad35755SDavid Hildenbrand return; 41678ad35755SDavid Hildenbrand 41686852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 1); 41698ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 4170433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 41718ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 41728ad35755SDavid Hildenbrand 41738ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 41748ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) 41758ad35755SDavid Hildenbrand started_vcpus++; 41768ad35755SDavid Hildenbrand } 41778ad35755SDavid Hildenbrand 41788ad35755SDavid Hildenbrand if (started_vcpus == 0) { 41798ad35755SDavid Hildenbrand /* we're the only active VCPU -> speed it up */ 41808ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(vcpu); 41818ad35755SDavid Hildenbrand } else if (started_vcpus == 1) { 41828ad35755SDavid Hildenbrand /* 41838ad35755SDavid Hildenbrand * As we are starting a second VCPU, we have to disable 41848ad35755SDavid Hildenbrand * the IBS facility on all VCPUs to remove potentially 41858ad35755SDavid Hildenbrand * oustanding ENABLE requests. 41868ad35755SDavid Hildenbrand */ 41878ad35755SDavid Hildenbrand __disable_ibs_on_all_vcpus(vcpu->kvm); 41888ad35755SDavid Hildenbrand } 41898ad35755SDavid Hildenbrand 41909daecfc6SDavid Hildenbrand kvm_s390_clear_cpuflags(vcpu, CPUSTAT_STOPPED); 41918ad35755SDavid Hildenbrand /* 41928ad35755SDavid Hildenbrand * Another VCPU might have used IBS while we were offline. 41938ad35755SDavid Hildenbrand * Let's play safe and flush the VCPU at startup. 41948ad35755SDavid Hildenbrand */ 4195d3d692c8SDavid Hildenbrand kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); 4196433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 41978ad35755SDavid Hildenbrand return; 41986852d7b6SDavid Hildenbrand } 41996852d7b6SDavid Hildenbrand 42006852d7b6SDavid Hildenbrand void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu) 42016852d7b6SDavid Hildenbrand { 42028ad35755SDavid Hildenbrand int i, online_vcpus, started_vcpus = 0; 42038ad35755SDavid Hildenbrand struct kvm_vcpu *started_vcpu = NULL; 42048ad35755SDavid Hildenbrand 42058ad35755SDavid Hildenbrand if (is_vcpu_stopped(vcpu)) 42068ad35755SDavid Hildenbrand return; 42078ad35755SDavid Hildenbrand 42086852d7b6SDavid Hildenbrand trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 0); 42098ad35755SDavid Hildenbrand /* Only one cpu at a time may enter/leave the STOPPED state. */ 4210433b9ee4SDavid Hildenbrand spin_lock(&vcpu->kvm->arch.start_stop_lock); 42118ad35755SDavid Hildenbrand online_vcpus = atomic_read(&vcpu->kvm->online_vcpus); 42128ad35755SDavid Hildenbrand 421332f5ff63SDavid Hildenbrand /* SIGP STOP and SIGP STOP AND STORE STATUS has been fully processed */ 42146cddd432SDavid Hildenbrand kvm_s390_clear_stop_irq(vcpu); 421532f5ff63SDavid Hildenbrand 4216ef8f4f49SDavid Hildenbrand kvm_s390_set_cpuflags(vcpu, CPUSTAT_STOPPED); 42178ad35755SDavid Hildenbrand __disable_ibs_on_vcpu(vcpu); 42188ad35755SDavid Hildenbrand 42198ad35755SDavid Hildenbrand for (i = 0; i < online_vcpus; i++) { 42208ad35755SDavid Hildenbrand if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) { 42218ad35755SDavid Hildenbrand started_vcpus++; 42228ad35755SDavid Hildenbrand started_vcpu = vcpu->kvm->vcpus[i]; 42238ad35755SDavid Hildenbrand } 42248ad35755SDavid Hildenbrand } 42258ad35755SDavid Hildenbrand 42268ad35755SDavid Hildenbrand if (started_vcpus == 1) { 42278ad35755SDavid Hildenbrand /* 42288ad35755SDavid Hildenbrand * As we only have one VCPU left, we want to enable the 42298ad35755SDavid Hildenbrand * IBS facility for that VCPU to speed it up. 42308ad35755SDavid Hildenbrand */ 42318ad35755SDavid Hildenbrand __enable_ibs_on_vcpu(started_vcpu); 42328ad35755SDavid Hildenbrand } 42338ad35755SDavid Hildenbrand 4234433b9ee4SDavid Hildenbrand spin_unlock(&vcpu->kvm->arch.start_stop_lock); 42358ad35755SDavid Hildenbrand return; 42366852d7b6SDavid Hildenbrand } 42376852d7b6SDavid Hildenbrand 4238d6712df9SCornelia Huck static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 4239d6712df9SCornelia Huck struct kvm_enable_cap *cap) 4240d6712df9SCornelia Huck { 4241d6712df9SCornelia Huck int r; 4242d6712df9SCornelia Huck 4243d6712df9SCornelia Huck if (cap->flags) 4244d6712df9SCornelia Huck return -EINVAL; 4245d6712df9SCornelia Huck 4246d6712df9SCornelia Huck switch (cap->cap) { 4247fa6b7fe9SCornelia Huck case KVM_CAP_S390_CSS_SUPPORT: 4248fa6b7fe9SCornelia Huck if (!vcpu->kvm->arch.css_support) { 4249fa6b7fe9SCornelia Huck vcpu->kvm->arch.css_support = 1; 4250c92ea7b9SChristian Borntraeger VM_EVENT(vcpu->kvm, 3, "%s", "ENABLE: CSS support"); 4251fa6b7fe9SCornelia Huck trace_kvm_s390_enable_css(vcpu->kvm); 4252fa6b7fe9SCornelia Huck } 4253fa6b7fe9SCornelia Huck r = 0; 4254fa6b7fe9SCornelia Huck break; 4255d6712df9SCornelia Huck default: 4256d6712df9SCornelia Huck r = -EINVAL; 4257d6712df9SCornelia Huck break; 4258d6712df9SCornelia Huck } 4259d6712df9SCornelia Huck return r; 4260d6712df9SCornelia Huck } 4261d6712df9SCornelia Huck 426241408c28SThomas Huth static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu, 426341408c28SThomas Huth struct kvm_s390_mem_op *mop) 426441408c28SThomas Huth { 426541408c28SThomas Huth void __user *uaddr = (void __user *)mop->buf; 426641408c28SThomas Huth void *tmpbuf = NULL; 426741408c28SThomas Huth int r, srcu_idx; 426841408c28SThomas Huth const u64 supported_flags = KVM_S390_MEMOP_F_INJECT_EXCEPTION 426941408c28SThomas Huth | KVM_S390_MEMOP_F_CHECK_ONLY; 427041408c28SThomas Huth 4271a13b03bbSThomas Huth if (mop->flags & ~supported_flags || mop->ar >= NUM_ACRS || !mop->size) 427241408c28SThomas Huth return -EINVAL; 427341408c28SThomas Huth 427441408c28SThomas Huth if (mop->size > MEM_OP_MAX_SIZE) 427541408c28SThomas Huth return -E2BIG; 427641408c28SThomas Huth 427741408c28SThomas Huth if (!(mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY)) { 427841408c28SThomas Huth tmpbuf = vmalloc(mop->size); 427941408c28SThomas Huth if (!tmpbuf) 428041408c28SThomas Huth return -ENOMEM; 428141408c28SThomas Huth } 428241408c28SThomas Huth 428341408c28SThomas Huth srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); 428441408c28SThomas Huth 428541408c28SThomas Huth switch (mop->op) { 428641408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_READ: 428741408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 428892c96321SDavid Hildenbrand r = check_gva_range(vcpu, mop->gaddr, mop->ar, 428992c96321SDavid Hildenbrand mop->size, GACC_FETCH); 429041408c28SThomas Huth break; 429141408c28SThomas Huth } 429241408c28SThomas Huth r = read_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 429341408c28SThomas Huth if (r == 0) { 429441408c28SThomas Huth if (copy_to_user(uaddr, tmpbuf, mop->size)) 429541408c28SThomas Huth r = -EFAULT; 429641408c28SThomas Huth } 429741408c28SThomas Huth break; 429841408c28SThomas Huth case KVM_S390_MEMOP_LOGICAL_WRITE: 429941408c28SThomas Huth if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) { 430092c96321SDavid Hildenbrand r = check_gva_range(vcpu, mop->gaddr, mop->ar, 430192c96321SDavid Hildenbrand mop->size, GACC_STORE); 430241408c28SThomas Huth break; 430341408c28SThomas Huth } 430441408c28SThomas Huth if (copy_from_user(tmpbuf, uaddr, mop->size)) { 430541408c28SThomas Huth r = -EFAULT; 430641408c28SThomas Huth break; 430741408c28SThomas Huth } 430841408c28SThomas Huth r = write_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); 430941408c28SThomas Huth break; 431041408c28SThomas Huth default: 431141408c28SThomas Huth r = -EINVAL; 431241408c28SThomas Huth } 431341408c28SThomas Huth 431441408c28SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, srcu_idx); 431541408c28SThomas Huth 431641408c28SThomas Huth if (r > 0 && (mop->flags & KVM_S390_MEMOP_F_INJECT_EXCEPTION) != 0) 431741408c28SThomas Huth kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm); 431841408c28SThomas Huth 431941408c28SThomas Huth vfree(tmpbuf); 432041408c28SThomas Huth return r; 432141408c28SThomas Huth } 432241408c28SThomas Huth 43235cb0944cSPaolo Bonzini long kvm_arch_vcpu_async_ioctl(struct file *filp, 4324b0c632dbSHeiko Carstens unsigned int ioctl, unsigned long arg) 4325b0c632dbSHeiko Carstens { 4326b0c632dbSHeiko Carstens struct kvm_vcpu *vcpu = filp->private_data; 4327b0c632dbSHeiko Carstens void __user *argp = (void __user *)arg; 4328b0c632dbSHeiko Carstens 432993736624SAvi Kivity switch (ioctl) { 433047b43c52SJens Freimann case KVM_S390_IRQ: { 433147b43c52SJens Freimann struct kvm_s390_irq s390irq; 433247b43c52SJens Freimann 433347b43c52SJens Freimann if (copy_from_user(&s390irq, argp, sizeof(s390irq))) 43349b062471SChristoffer Dall return -EFAULT; 43359b062471SChristoffer Dall return kvm_s390_inject_vcpu(vcpu, &s390irq); 433647b43c52SJens Freimann } 433793736624SAvi Kivity case KVM_S390_INTERRUPT: { 4338ba5c1e9bSCarsten Otte struct kvm_s390_interrupt s390int; 433953936b5bSThomas Huth struct kvm_s390_irq s390irq = {}; 4340ba5c1e9bSCarsten Otte 4341ba5c1e9bSCarsten Otte if (copy_from_user(&s390int, argp, sizeof(s390int))) 43429b062471SChristoffer Dall return -EFAULT; 4343383d0b05SJens Freimann if (s390int_to_s390irq(&s390int, &s390irq)) 4344383d0b05SJens Freimann return -EINVAL; 43459b062471SChristoffer Dall return kvm_s390_inject_vcpu(vcpu, &s390irq); 4346ba5c1e9bSCarsten Otte } 43479b062471SChristoffer Dall } 43485cb0944cSPaolo Bonzini return -ENOIOCTLCMD; 43495cb0944cSPaolo Bonzini } 43505cb0944cSPaolo Bonzini 43515cb0944cSPaolo Bonzini long kvm_arch_vcpu_ioctl(struct file *filp, 43525cb0944cSPaolo Bonzini unsigned int ioctl, unsigned long arg) 43535cb0944cSPaolo Bonzini { 43545cb0944cSPaolo Bonzini struct kvm_vcpu *vcpu = filp->private_data; 43555cb0944cSPaolo Bonzini void __user *argp = (void __user *)arg; 43565cb0944cSPaolo Bonzini int idx; 43575cb0944cSPaolo Bonzini long r; 43589b062471SChristoffer Dall 43599b062471SChristoffer Dall vcpu_load(vcpu); 43609b062471SChristoffer Dall 43619b062471SChristoffer Dall switch (ioctl) { 4362b0c632dbSHeiko Carstens case KVM_S390_STORE_STATUS: 4363800c1065SThomas Huth idx = srcu_read_lock(&vcpu->kvm->srcu); 4364bc923cc9SAvi Kivity r = kvm_s390_vcpu_store_status(vcpu, arg); 4365800c1065SThomas Huth srcu_read_unlock(&vcpu->kvm->srcu, idx); 4366bc923cc9SAvi Kivity break; 4367b0c632dbSHeiko Carstens case KVM_S390_SET_INITIAL_PSW: { 4368b0c632dbSHeiko Carstens psw_t psw; 4369b0c632dbSHeiko Carstens 4370bc923cc9SAvi Kivity r = -EFAULT; 4371b0c632dbSHeiko Carstens if (copy_from_user(&psw, argp, sizeof(psw))) 4372bc923cc9SAvi Kivity break; 4373bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw); 4374bc923cc9SAvi Kivity break; 4375b0c632dbSHeiko Carstens } 4376b0c632dbSHeiko Carstens case KVM_S390_INITIAL_RESET: 4377bc923cc9SAvi Kivity r = kvm_arch_vcpu_ioctl_initial_reset(vcpu); 4378bc923cc9SAvi Kivity break; 437914eebd91SCarsten Otte case KVM_SET_ONE_REG: 438014eebd91SCarsten Otte case KVM_GET_ONE_REG: { 438114eebd91SCarsten Otte struct kvm_one_reg reg; 438214eebd91SCarsten Otte r = -EFAULT; 438314eebd91SCarsten Otte if (copy_from_user(®, argp, sizeof(reg))) 438414eebd91SCarsten Otte break; 438514eebd91SCarsten Otte if (ioctl == KVM_SET_ONE_REG) 438614eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, ®); 438714eebd91SCarsten Otte else 438814eebd91SCarsten Otte r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, ®); 438914eebd91SCarsten Otte break; 439014eebd91SCarsten Otte } 439127e0393fSCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 439227e0393fSCarsten Otte case KVM_S390_UCAS_MAP: { 439327e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 439427e0393fSCarsten Otte 439527e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 439627e0393fSCarsten Otte r = -EFAULT; 439727e0393fSCarsten Otte break; 439827e0393fSCarsten Otte } 439927e0393fSCarsten Otte 440027e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 440127e0393fSCarsten Otte r = -EINVAL; 440227e0393fSCarsten Otte break; 440327e0393fSCarsten Otte } 440427e0393fSCarsten Otte 440527e0393fSCarsten Otte r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr, 440627e0393fSCarsten Otte ucasmap.vcpu_addr, ucasmap.length); 440727e0393fSCarsten Otte break; 440827e0393fSCarsten Otte } 440927e0393fSCarsten Otte case KVM_S390_UCAS_UNMAP: { 441027e0393fSCarsten Otte struct kvm_s390_ucas_mapping ucasmap; 441127e0393fSCarsten Otte 441227e0393fSCarsten Otte if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 441327e0393fSCarsten Otte r = -EFAULT; 441427e0393fSCarsten Otte break; 441527e0393fSCarsten Otte } 441627e0393fSCarsten Otte 441727e0393fSCarsten Otte if (!kvm_is_ucontrol(vcpu->kvm)) { 441827e0393fSCarsten Otte r = -EINVAL; 441927e0393fSCarsten Otte break; 442027e0393fSCarsten Otte } 442127e0393fSCarsten Otte 442227e0393fSCarsten Otte r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr, 442327e0393fSCarsten Otte ucasmap.length); 442427e0393fSCarsten Otte break; 442527e0393fSCarsten Otte } 442627e0393fSCarsten Otte #endif 4427ccc7910fSCarsten Otte case KVM_S390_VCPU_FAULT: { 4428527e30b4SMartin Schwidefsky r = gmap_fault(vcpu->arch.gmap, arg, 0); 4429ccc7910fSCarsten Otte break; 4430ccc7910fSCarsten Otte } 4431d6712df9SCornelia Huck case KVM_ENABLE_CAP: 4432d6712df9SCornelia Huck { 4433d6712df9SCornelia Huck struct kvm_enable_cap cap; 4434d6712df9SCornelia Huck r = -EFAULT; 4435d6712df9SCornelia Huck if (copy_from_user(&cap, argp, sizeof(cap))) 4436d6712df9SCornelia Huck break; 4437d6712df9SCornelia Huck r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 4438d6712df9SCornelia Huck break; 4439d6712df9SCornelia Huck } 444041408c28SThomas Huth case KVM_S390_MEM_OP: { 444141408c28SThomas Huth struct kvm_s390_mem_op mem_op; 444241408c28SThomas Huth 444341408c28SThomas Huth if (copy_from_user(&mem_op, argp, sizeof(mem_op)) == 0) 444441408c28SThomas Huth r = kvm_s390_guest_mem_op(vcpu, &mem_op); 444541408c28SThomas Huth else 444641408c28SThomas Huth r = -EFAULT; 444741408c28SThomas Huth break; 444841408c28SThomas Huth } 4449816c7667SJens Freimann case KVM_S390_SET_IRQ_STATE: { 4450816c7667SJens Freimann struct kvm_s390_irq_state irq_state; 4451816c7667SJens Freimann 4452816c7667SJens Freimann r = -EFAULT; 4453816c7667SJens Freimann if (copy_from_user(&irq_state, argp, sizeof(irq_state))) 4454816c7667SJens Freimann break; 4455816c7667SJens Freimann if (irq_state.len > VCPU_IRQS_MAX_BUF || 4456816c7667SJens Freimann irq_state.len == 0 || 4457816c7667SJens Freimann irq_state.len % sizeof(struct kvm_s390_irq) > 0) { 4458816c7667SJens Freimann r = -EINVAL; 4459816c7667SJens Freimann break; 4460816c7667SJens Freimann } 4461bb64da9aSChristian Borntraeger /* do not use irq_state.flags, it will break old QEMUs */ 4462816c7667SJens Freimann r = kvm_s390_set_irq_state(vcpu, 4463816c7667SJens Freimann (void __user *) irq_state.buf, 4464816c7667SJens Freimann irq_state.len); 4465816c7667SJens Freimann break; 4466816c7667SJens Freimann } 4467816c7667SJens Freimann case KVM_S390_GET_IRQ_STATE: { 4468816c7667SJens Freimann struct kvm_s390_irq_state irq_state; 4469816c7667SJens Freimann 4470816c7667SJens Freimann r = -EFAULT; 4471816c7667SJens Freimann if (copy_from_user(&irq_state, argp, sizeof(irq_state))) 4472816c7667SJens Freimann break; 4473816c7667SJens Freimann if (irq_state.len == 0) { 4474816c7667SJens Freimann r = -EINVAL; 4475816c7667SJens Freimann break; 4476816c7667SJens Freimann } 4477bb64da9aSChristian Borntraeger /* do not use irq_state.flags, it will break old QEMUs */ 4478816c7667SJens Freimann r = kvm_s390_get_irq_state(vcpu, 4479816c7667SJens Freimann (__u8 __user *) irq_state.buf, 4480816c7667SJens Freimann irq_state.len); 4481816c7667SJens Freimann break; 4482816c7667SJens Freimann } 4483b0c632dbSHeiko Carstens default: 44843e6afcf1SCarsten Otte r = -ENOTTY; 4485b0c632dbSHeiko Carstens } 44869b062471SChristoffer Dall 44879b062471SChristoffer Dall vcpu_put(vcpu); 4488bc923cc9SAvi Kivity return r; 4489b0c632dbSHeiko Carstens } 4490b0c632dbSHeiko Carstens 44911499fa80SSouptick Joarder vm_fault_t kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) 44925b1c1493SCarsten Otte { 44935b1c1493SCarsten Otte #ifdef CONFIG_KVM_S390_UCONTROL 44945b1c1493SCarsten Otte if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET) 44955b1c1493SCarsten Otte && (kvm_is_ucontrol(vcpu->kvm))) { 44965b1c1493SCarsten Otte vmf->page = virt_to_page(vcpu->arch.sie_block); 44975b1c1493SCarsten Otte get_page(vmf->page); 44985b1c1493SCarsten Otte return 0; 44995b1c1493SCarsten Otte } 45005b1c1493SCarsten Otte #endif 45015b1c1493SCarsten Otte return VM_FAULT_SIGBUS; 45025b1c1493SCarsten Otte } 45035b1c1493SCarsten Otte 45045587027cSAneesh Kumar K.V int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, 45055587027cSAneesh Kumar K.V unsigned long npages) 4506db3fe4ebSTakuya Yoshikawa { 4507db3fe4ebSTakuya Yoshikawa return 0; 4508db3fe4ebSTakuya Yoshikawa } 4509db3fe4ebSTakuya Yoshikawa 4510b0c632dbSHeiko Carstens /* Section: memory related */ 4511f7784b8eSMarcelo Tosatti int kvm_arch_prepare_memory_region(struct kvm *kvm, 4512f7784b8eSMarcelo Tosatti struct kvm_memory_slot *memslot, 451309170a49SPaolo Bonzini const struct kvm_userspace_memory_region *mem, 45147b6195a9STakuya Yoshikawa enum kvm_mr_change change) 4515b0c632dbSHeiko Carstens { 4516dd2887e7SNick Wang /* A few sanity checks. We can have memory slots which have to be 4517dd2887e7SNick Wang located/ended at a segment boundary (1MB). The memory in userland is 4518dd2887e7SNick Wang ok to be fragmented into various different vmas. It is okay to mmap() 4519dd2887e7SNick Wang and munmap() stuff in this slot after doing this call at any time */ 4520b0c632dbSHeiko Carstens 4521598841caSCarsten Otte if (mem->userspace_addr & 0xffffful) 4522b0c632dbSHeiko Carstens return -EINVAL; 4523b0c632dbSHeiko Carstens 4524598841caSCarsten Otte if (mem->memory_size & 0xffffful) 4525b0c632dbSHeiko Carstens return -EINVAL; 4526b0c632dbSHeiko Carstens 4527a3a92c31SDominik Dingel if (mem->guest_phys_addr + mem->memory_size > kvm->arch.mem_limit) 4528a3a92c31SDominik Dingel return -EINVAL; 4529a3a92c31SDominik Dingel 4530f7784b8eSMarcelo Tosatti return 0; 4531f7784b8eSMarcelo Tosatti } 4532f7784b8eSMarcelo Tosatti 4533f7784b8eSMarcelo Tosatti void kvm_arch_commit_memory_region(struct kvm *kvm, 453409170a49SPaolo Bonzini const struct kvm_userspace_memory_region *mem, 45358482644aSTakuya Yoshikawa const struct kvm_memory_slot *old, 4536f36f3f28SPaolo Bonzini const struct kvm_memory_slot *new, 45378482644aSTakuya Yoshikawa enum kvm_mr_change change) 4538f7784b8eSMarcelo Tosatti { 453919ec166cSChristian Borntraeger int rc = 0; 4540f7784b8eSMarcelo Tosatti 454119ec166cSChristian Borntraeger switch (change) { 454219ec166cSChristian Borntraeger case KVM_MR_DELETE: 454319ec166cSChristian Borntraeger rc = gmap_unmap_segment(kvm->arch.gmap, old->base_gfn * PAGE_SIZE, 454419ec166cSChristian Borntraeger old->npages * PAGE_SIZE); 454519ec166cSChristian Borntraeger break; 454619ec166cSChristian Borntraeger case KVM_MR_MOVE: 454719ec166cSChristian Borntraeger rc = gmap_unmap_segment(kvm->arch.gmap, old->base_gfn * PAGE_SIZE, 454819ec166cSChristian Borntraeger old->npages * PAGE_SIZE); 454919ec166cSChristian Borntraeger if (rc) 455019ec166cSChristian Borntraeger break; 455119ec166cSChristian Borntraeger /* FALLTHROUGH */ 455219ec166cSChristian Borntraeger case KVM_MR_CREATE: 4553598841caSCarsten Otte rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr, 4554598841caSCarsten Otte mem->guest_phys_addr, mem->memory_size); 455519ec166cSChristian Borntraeger break; 455619ec166cSChristian Borntraeger case KVM_MR_FLAGS_ONLY: 455719ec166cSChristian Borntraeger break; 455819ec166cSChristian Borntraeger default: 455919ec166cSChristian Borntraeger WARN(1, "Unknown KVM MR CHANGE: %d\n", change); 456019ec166cSChristian Borntraeger } 4561598841caSCarsten Otte if (rc) 4562ea2cdd27SDavid Hildenbrand pr_warn("failed to commit memory region\n"); 4563598841caSCarsten Otte return; 4564b0c632dbSHeiko Carstens } 4565b0c632dbSHeiko Carstens 456660a37709SAlexander Yarygin static inline unsigned long nonhyp_mask(int i) 456760a37709SAlexander Yarygin { 456860a37709SAlexander Yarygin unsigned int nonhyp_fai = (sclp.hmfai << i * 2) >> 30; 456960a37709SAlexander Yarygin 457060a37709SAlexander Yarygin return 0x0000ffffffffffffUL >> (nonhyp_fai << 4); 457160a37709SAlexander Yarygin } 457260a37709SAlexander Yarygin 45733491caf2SChristian Borntraeger void kvm_arch_vcpu_block_finish(struct kvm_vcpu *vcpu) 45743491caf2SChristian Borntraeger { 45753491caf2SChristian Borntraeger vcpu->valid_wakeup = false; 45763491caf2SChristian Borntraeger } 45773491caf2SChristian Borntraeger 4578b0c632dbSHeiko Carstens static int __init kvm_s390_init(void) 4579b0c632dbSHeiko Carstens { 458060a37709SAlexander Yarygin int i; 458160a37709SAlexander Yarygin 458207197fd0SDavid Hildenbrand if (!sclp.has_sief2) { 45838d43d570SMichael Mueller pr_info("SIE is not available\n"); 458407197fd0SDavid Hildenbrand return -ENODEV; 458507197fd0SDavid Hildenbrand } 458607197fd0SDavid Hildenbrand 4587a4499382SJanosch Frank if (nested && hpage) { 45888d43d570SMichael Mueller pr_info("A KVM host that supports nesting cannot back its KVM guests with huge pages\n"); 4589a4499382SJanosch Frank return -EINVAL; 4590a4499382SJanosch Frank } 4591a4499382SJanosch Frank 459260a37709SAlexander Yarygin for (i = 0; i < 16; i++) 4593c3b9e3e1SChristian Borntraeger kvm_s390_fac_base[i] |= 459460a37709SAlexander Yarygin S390_lowcore.stfle_fac_list[i] & nonhyp_mask(i); 459560a37709SAlexander Yarygin 45969d8d5786SMichael Mueller return kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); 4597b0c632dbSHeiko Carstens } 4598b0c632dbSHeiko Carstens 4599b0c632dbSHeiko Carstens static void __exit kvm_s390_exit(void) 4600b0c632dbSHeiko Carstens { 4601b0c632dbSHeiko Carstens kvm_exit(); 4602b0c632dbSHeiko Carstens } 4603b0c632dbSHeiko Carstens 4604b0c632dbSHeiko Carstens module_init(kvm_s390_init); 4605b0c632dbSHeiko Carstens module_exit(kvm_s390_exit); 4606566af940SCornelia Huck 4607566af940SCornelia Huck /* 4608566af940SCornelia Huck * Enable autoloading of the kvm module. 4609566af940SCornelia Huck * Note that we add the module alias here instead of virt/kvm/kvm_main.c 4610566af940SCornelia Huck * since x86 takes a different approach. 4611566af940SCornelia Huck */ 4612566af940SCornelia Huck #include <linux/miscdevice.h> 4613566af940SCornelia Huck MODULE_ALIAS_MISCDEV(KVM_MINOR); 4614566af940SCornelia Huck MODULE_ALIAS("devname:kvm"); 4615