Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

KVM: s390: Use ESCA instead of BSCA at VM init

All modern IBM Z and Linux One machines do offer support for the
Extended System Control Area (ESCA). The ESCA is available since the
z114/z196 released in 2010.
KVM needs to allocate and manage the SCA for guest VMs. Prior to this
change the SCA was setup as Basic SCA only supporting a maximum of 64
vCPUs when initializing the VM. With addition of the 65th vCPU the SCA
was needed to be converted to a ESCA.

Instead of allocating a BSCA and upgrading it for PV or when adding the
65th cpu we can always allocate the ESCA directly upon VM creation
simplifying the code in multiple places as well as completely removing
the need to convert an existing SCA.

In cases where the ESCA is not supported (z10 and earlier) the use of
the SCA entries and with that SIGP interpretation are disabled for VMs.
This increases the number of exits from the VM in multiprocessor
scenarios and thus decreases performance.
The same is true for VSIE where SIGP is currently disabled and thus no
SCA entries are used.

The only downside of the change is that we will always allocate 4 pages
for a 248 cpu ESCA instead of a single page for the BSCA per VM.
In return we can delete a bunch of checks and special handling depending
on the SCA type as well as the whole BSCA to ESCA conversion.

With that behavior change we are no longer referencing a bsca_block in
kvm->arch.sca. This will always be esca_block instead.
By specifying the type of the sca as esca_block we can simplify access
to the sca and get rid of some helpers while making the code clearer.

KVM_MAX_VCPUS is also moved to kvm_host_types to allow using this in
future type definitions.

Reviewed-by: Janosch Frank <frankja@linux.ibm.com>
Signed-off-by: Christoph Schlameuss <schlameuss@linux.ibm.com>
Signed-off-by: Janosch Frank <frankja@linux.ibm.com>

authored by

Christoph Schlameuss and committed by
Janosch Frank
e72753ed 211ddde0

+67 -205
+2 -3
arch/s390/include/asm/kvm_host.h
··· 631 631 struct mmu_notifier mmu_notifier; 632 632 }; 633 633 634 - struct kvm_arch{ 635 - void *sca; 636 - int use_esca; 634 + struct kvm_arch { 635 + struct esca_block *sca; 637 636 rwlock_t sca_lock; 638 637 debug_info_t *dbf; 639 638 struct kvm_s390_float_interrupt float_int;
+5 -5
arch/s390/kvm/gaccess.c
··· 113 113 int rc; 114 114 115 115 read_lock(&kvm->arch.sca_lock); 116 - rc = kvm_s390_get_ipte_control(kvm)->kh != 0; 116 + rc = kvm->arch.sca->ipte_control.kh != 0; 117 117 read_unlock(&kvm->arch.sca_lock); 118 118 return rc; 119 119 } ··· 130 130 goto out; 131 131 retry: 132 132 read_lock(&kvm->arch.sca_lock); 133 - ic = kvm_s390_get_ipte_control(kvm); 133 + ic = &kvm->arch.sca->ipte_control; 134 134 old = READ_ONCE(*ic); 135 135 do { 136 136 if (old.k) { ··· 155 155 if (kvm->arch.ipte_lock_count) 156 156 goto out; 157 157 read_lock(&kvm->arch.sca_lock); 158 - ic = kvm_s390_get_ipte_control(kvm); 158 + ic = &kvm->arch.sca->ipte_control; 159 159 old = READ_ONCE(*ic); 160 160 do { 161 161 new = old; ··· 173 173 174 174 retry: 175 175 read_lock(&kvm->arch.sca_lock); 176 - ic = kvm_s390_get_ipte_control(kvm); 176 + ic = &kvm->arch.sca->ipte_control; 177 177 old = READ_ONCE(*ic); 178 178 do { 179 179 if (old.kg) { ··· 193 193 union ipte_control old, new, *ic; 194 194 195 195 read_lock(&kvm->arch.sca_lock); 196 - ic = kvm_s390_get_ipte_control(kvm); 196 + ic = &kvm->arch.sca->ipte_control; 197 197 old = READ_ONCE(*ic); 198 198 do { 199 199 new = old;
+25 -53
arch/s390/kvm/interrupt.c
··· 45 45 /* handle external calls via sigp interpretation facility */ 46 46 static int sca_ext_call_pending(struct kvm_vcpu *vcpu, int *src_id) 47 47 { 48 + union esca_sigp_ctrl sigp_ctrl; 49 + struct esca_block *sca; 48 50 int c, scn; 49 51 50 52 if (!kvm_s390_test_cpuflags(vcpu, CPUSTAT_ECALL_PEND)) ··· 54 52 55 53 BUG_ON(!kvm_s390_use_sca_entries()); 56 54 read_lock(&vcpu->kvm->arch.sca_lock); 57 - if (vcpu->kvm->arch.use_esca) { 58 - struct esca_block *sca = vcpu->kvm->arch.sca; 59 - union esca_sigp_ctrl sigp_ctrl = 60 - sca->cpu[vcpu->vcpu_id].sigp_ctrl; 55 + sca = vcpu->kvm->arch.sca; 56 + sigp_ctrl = sca->cpu[vcpu->vcpu_id].sigp_ctrl; 61 57 62 - c = sigp_ctrl.c; 63 - scn = sigp_ctrl.scn; 64 - } else { 65 - struct bsca_block *sca = vcpu->kvm->arch.sca; 66 - union bsca_sigp_ctrl sigp_ctrl = 67 - sca->cpu[vcpu->vcpu_id].sigp_ctrl; 68 - 69 - c = sigp_ctrl.c; 70 - scn = sigp_ctrl.scn; 71 - } 58 + c = sigp_ctrl.c; 59 + scn = sigp_ctrl.scn; 72 60 read_unlock(&vcpu->kvm->arch.sca_lock); 73 61 74 62 if (src_id) ··· 69 77 70 78 static int sca_inject_ext_call(struct kvm_vcpu *vcpu, int src_id) 71 79 { 80 + union esca_sigp_ctrl old_val, new_val = {0}; 81 + union esca_sigp_ctrl *sigp_ctrl; 82 + struct esca_block *sca; 72 83 int expect, rc; 73 84 74 85 BUG_ON(!kvm_s390_use_sca_entries()); 75 86 read_lock(&vcpu->kvm->arch.sca_lock); 76 - if (vcpu->kvm->arch.use_esca) { 77 - struct esca_block *sca = vcpu->kvm->arch.sca; 78 - union esca_sigp_ctrl *sigp_ctrl = 79 - &(sca->cpu[vcpu->vcpu_id].sigp_ctrl); 80 - union esca_sigp_ctrl new_val = {0}, old_val; 87 + sca = vcpu->kvm->arch.sca; 88 + sigp_ctrl = &sca->cpu[vcpu->vcpu_id].sigp_ctrl; 81 89 82 - old_val = READ_ONCE(*sigp_ctrl); 83 - new_val.scn = src_id; 84 - new_val.c = 1; 85 - old_val.c = 0; 90 + old_val = READ_ONCE(*sigp_ctrl); 91 + new_val.scn = src_id; 92 + new_val.c = 1; 93 + old_val.c = 0; 86 94 87 - expect = old_val.value; 88 - rc = cmpxchg(&sigp_ctrl->value, old_val.value, new_val.value); 89 - } else { 90 - struct bsca_block *sca = vcpu->kvm->arch.sca; 91 - union bsca_sigp_ctrl *sigp_ctrl = 92 - &(sca->cpu[vcpu->vcpu_id].sigp_ctrl); 93 - union bsca_sigp_ctrl new_val = {0}, old_val; 94 - 95 - old_val = READ_ONCE(*sigp_ctrl); 96 - new_val.scn = src_id; 97 - new_val.c = 1; 98 - old_val.c = 0; 99 - 100 - expect = old_val.value; 101 - rc = cmpxchg(&sigp_ctrl->value, old_val.value, new_val.value); 102 - } 95 + expect = old_val.value; 96 + rc = cmpxchg(&sigp_ctrl->value, old_val.value, new_val.value); 103 97 read_unlock(&vcpu->kvm->arch.sca_lock); 104 98 105 99 if (rc != expect) { ··· 98 120 99 121 static void sca_clear_ext_call(struct kvm_vcpu *vcpu) 100 122 { 123 + union esca_sigp_ctrl *sigp_ctrl; 124 + struct esca_block *sca; 125 + 101 126 if (!kvm_s390_use_sca_entries()) 102 127 return; 103 128 kvm_s390_clear_cpuflags(vcpu, CPUSTAT_ECALL_PEND); 104 129 read_lock(&vcpu->kvm->arch.sca_lock); 105 - if (vcpu->kvm->arch.use_esca) { 106 - struct esca_block *sca = vcpu->kvm->arch.sca; 107 - union esca_sigp_ctrl *sigp_ctrl = 108 - &(sca->cpu[vcpu->vcpu_id].sigp_ctrl); 130 + sca = vcpu->kvm->arch.sca; 131 + sigp_ctrl = &sca->cpu[vcpu->vcpu_id].sigp_ctrl; 109 132 110 - WRITE_ONCE(sigp_ctrl->value, 0); 111 - } else { 112 - struct bsca_block *sca = vcpu->kvm->arch.sca; 113 - union bsca_sigp_ctrl *sigp_ctrl = 114 - &(sca->cpu[vcpu->vcpu_id].sigp_ctrl); 115 - 116 - WRITE_ONCE(sigp_ctrl->value, 0); 117 - } 133 + WRITE_ONCE(sigp_ctrl->value, 0); 118 134 read_unlock(&vcpu->kvm->arch.sca_lock); 119 135 } 120 136 ··· 1196 1224 { 1197 1225 struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int; 1198 1226 1199 - if (!sclp.has_sigpif) 1227 + if (!kvm_s390_use_sca_entries()) 1200 1228 return test_bit(IRQ_PEND_EXT_EXTERNAL, &li->pending_irqs); 1201 1229 1202 1230 return sca_ext_call_pending(vcpu, NULL); ··· 1521 1549 if (kvm_get_vcpu_by_id(vcpu->kvm, src_id) == NULL) 1522 1550 return -EINVAL; 1523 1551 1524 - if (sclp.has_sigpif && !kvm_s390_pv_cpu_get_handle(vcpu)) 1552 + if (kvm_s390_use_sca_entries() && !kvm_s390_pv_cpu_get_handle(vcpu)) 1525 1553 return sca_inject_ext_call(vcpu, src_id); 1526 1554 1527 1555 if (test_and_set_bit(IRQ_PEND_EXT_EXTERNAL, &li->pending_irqs))
+34 -136
arch/s390/kvm/kvm-s390.c
··· 272 272 /* forward declarations */ 273 273 static void kvm_gmap_notifier(struct gmap *gmap, unsigned long start, 274 274 unsigned long end); 275 - static int sca_switch_to_extended(struct kvm *kvm); 276 275 277 276 static void kvm_clock_sync_scb(struct kvm_s390_sie_block *scb, u64 delta) 278 277 { ··· 631 632 case KVM_CAP_NR_VCPUS: 632 633 case KVM_CAP_MAX_VCPUS: 633 634 case KVM_CAP_MAX_VCPU_ID: 634 - r = KVM_S390_BSCA_CPU_SLOTS; 635 + /* 636 + * Return the same value for KVM_CAP_MAX_VCPUS and 637 + * KVM_CAP_MAX_VCPU_ID to conform with the KVM API. 638 + */ 639 + r = KVM_S390_ESCA_CPU_SLOTS; 635 640 if (!kvm_s390_use_sca_entries()) 636 641 r = KVM_MAX_VCPUS; 637 - else if (sclp.has_esca && sclp.has_64bscao) 638 - r = KVM_S390_ESCA_CPU_SLOTS; 639 642 if (ext == KVM_CAP_NR_VCPUS) 640 643 r = min_t(unsigned int, num_online_cpus(), r); 641 644 break; ··· 1932 1931 * Updates the Multiprocessor Topology-Change-Report bit to signal 1933 1932 * the guest with a topology change. 1934 1933 * This is only relevant if the topology facility is present. 1935 - * 1936 - * The SCA version, bsca or esca, doesn't matter as offset is the same. 1937 1934 */ 1938 1935 static void kvm_s390_update_topology_change_report(struct kvm *kvm, bool val) 1939 1936 { 1940 1937 union sca_utility new, old; 1941 - struct bsca_block *sca; 1938 + struct esca_block *sca; 1942 1939 1943 1940 read_lock(&kvm->arch.sca_lock); 1944 1941 sca = kvm->arch.sca; ··· 1967 1968 return -ENXIO; 1968 1969 1969 1970 read_lock(&kvm->arch.sca_lock); 1970 - topo = ((struct bsca_block *)kvm->arch.sca)->utility.mtcr; 1971 + topo = kvm->arch.sca->utility.mtcr; 1971 1972 read_unlock(&kvm->arch.sca_lock); 1972 1973 1973 1974 return put_user(topo, (u8 __user *)attr->addr); ··· 2666 2667 if (kvm_s390_pv_is_protected(kvm)) 2667 2668 break; 2668 2669 2669 - /* 2670 - * FMT 4 SIE needs esca. As we never switch back to bsca from 2671 - * esca, we need no cleanup in the error cases below 2672 - */ 2673 - r = sca_switch_to_extended(kvm); 2674 - if (r) 2675 - break; 2676 - 2677 2670 mmap_write_lock(kvm->mm); 2678 2671 r = gmap_helper_disable_cow_sharing(); 2679 2672 mmap_write_unlock(kvm->mm); ··· 3308 3317 3309 3318 static void sca_dispose(struct kvm *kvm) 3310 3319 { 3311 - if (kvm->arch.use_esca) 3312 - free_pages_exact(kvm->arch.sca, sizeof(struct esca_block)); 3313 - else 3314 - free_page((unsigned long)(kvm->arch.sca)); 3320 + free_pages_exact(kvm->arch.sca, sizeof(*kvm->arch.sca)); 3315 3321 kvm->arch.sca = NULL; 3316 3322 } 3317 3323 ··· 3322 3334 3323 3335 int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 3324 3336 { 3325 - gfp_t alloc_flags = GFP_KERNEL_ACCOUNT; 3326 - int i, rc; 3337 + gfp_t alloc_flags = GFP_KERNEL_ACCOUNT | __GFP_ZERO; 3327 3338 char debug_name[16]; 3328 - static unsigned long sca_offset; 3339 + int i, rc; 3329 3340 3330 3341 rc = -EINVAL; 3331 3342 #ifdef CONFIG_KVM_S390_UCONTROL ··· 3346 3359 if (!sclp.has_64bscao) 3347 3360 alloc_flags |= GFP_DMA; 3348 3361 rwlock_init(&kvm->arch.sca_lock); 3349 - /* start with basic SCA */ 3350 - kvm->arch.sca = (struct bsca_block *) get_zeroed_page(alloc_flags); 3362 + mutex_lock(&kvm_lock); 3363 + 3364 + kvm->arch.sca = alloc_pages_exact(sizeof(*kvm->arch.sca), alloc_flags); 3365 + mutex_unlock(&kvm_lock); 3351 3366 if (!kvm->arch.sca) 3352 3367 goto out_err; 3353 - mutex_lock(&kvm_lock); 3354 - sca_offset += 16; 3355 - if (sca_offset + sizeof(struct bsca_block) > PAGE_SIZE) 3356 - sca_offset = 0; 3357 - kvm->arch.sca = (struct bsca_block *) 3358 - ((char *) kvm->arch.sca + sca_offset); 3359 - mutex_unlock(&kvm_lock); 3360 3368 3361 3369 sprintf(debug_name, "kvm-%u", current->pid); 3362 3370 ··· 3530 3548 3531 3549 static void sca_del_vcpu(struct kvm_vcpu *vcpu) 3532 3550 { 3551 + struct esca_block *sca; 3552 + 3533 3553 if (!kvm_s390_use_sca_entries()) 3534 3554 return; 3535 3555 read_lock(&vcpu->kvm->arch.sca_lock); 3536 - if (vcpu->kvm->arch.use_esca) { 3537 - struct esca_block *sca = vcpu->kvm->arch.sca; 3556 + sca = vcpu->kvm->arch.sca; 3538 3557 3539 - clear_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn); 3540 - sca->cpu[vcpu->vcpu_id].sda = 0; 3541 - } else { 3542 - struct bsca_block *sca = vcpu->kvm->arch.sca; 3543 - 3544 - clear_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn); 3545 - sca->cpu[vcpu->vcpu_id].sda = 0; 3546 - } 3558 + clear_bit_inv(vcpu->vcpu_id, (unsigned long *)sca->mcn); 3559 + sca->cpu[vcpu->vcpu_id].sda = 0; 3547 3560 read_unlock(&vcpu->kvm->arch.sca_lock); 3548 3561 } 3549 3562 3550 3563 static void sca_add_vcpu(struct kvm_vcpu *vcpu) 3551 3564 { 3565 + struct esca_block *sca; 3566 + phys_addr_t sca_phys; 3567 + 3552 3568 if (!kvm_s390_use_sca_entries()) { 3553 - phys_addr_t sca_phys = virt_to_phys(vcpu->kvm->arch.sca); 3569 + sca_phys = virt_to_phys(vcpu->kvm->arch.sca); 3554 3570 3555 3571 /* we still need the basic sca for the ipte control */ 3556 3572 vcpu->arch.sie_block->scaoh = sca_phys >> 32; ··· 3556 3576 return; 3557 3577 } 3558 3578 read_lock(&vcpu->kvm->arch.sca_lock); 3559 - if (vcpu->kvm->arch.use_esca) { 3560 - struct esca_block *sca = vcpu->kvm->arch.sca; 3561 - phys_addr_t sca_phys = virt_to_phys(sca); 3579 + sca = vcpu->kvm->arch.sca; 3580 + sca_phys = virt_to_phys(sca); 3562 3581 3563 - sca->cpu[vcpu->vcpu_id].sda = virt_to_phys(vcpu->arch.sie_block); 3564 - vcpu->arch.sie_block->scaoh = sca_phys >> 32; 3565 - vcpu->arch.sie_block->scaol = sca_phys & ESCA_SCAOL_MASK; 3566 - vcpu->arch.sie_block->ecb2 |= ECB2_ESCA; 3567 - set_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn); 3568 - } else { 3569 - struct bsca_block *sca = vcpu->kvm->arch.sca; 3570 - phys_addr_t sca_phys = virt_to_phys(sca); 3571 - 3572 - sca->cpu[vcpu->vcpu_id].sda = virt_to_phys(vcpu->arch.sie_block); 3573 - vcpu->arch.sie_block->scaoh = sca_phys >> 32; 3574 - vcpu->arch.sie_block->scaol = sca_phys; 3575 - set_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn); 3576 - } 3582 + sca->cpu[vcpu->vcpu_id].sda = virt_to_phys(vcpu->arch.sie_block); 3583 + vcpu->arch.sie_block->scaoh = sca_phys >> 32; 3584 + vcpu->arch.sie_block->scaol = sca_phys & ESCA_SCAOL_MASK; 3585 + vcpu->arch.sie_block->ecb2 |= ECB2_ESCA; 3586 + set_bit_inv(vcpu->vcpu_id, (unsigned long *)sca->mcn); 3577 3587 read_unlock(&vcpu->kvm->arch.sca_lock); 3578 - } 3579 - 3580 - /* Basic SCA to Extended SCA data copy routines */ 3581 - static inline void sca_copy_entry(struct esca_entry *d, struct bsca_entry *s) 3582 - { 3583 - d->sda = s->sda; 3584 - d->sigp_ctrl.c = s->sigp_ctrl.c; 3585 - d->sigp_ctrl.scn = s->sigp_ctrl.scn; 3586 - } 3587 - 3588 - static void sca_copy_b_to_e(struct esca_block *d, struct bsca_block *s) 3589 - { 3590 - int i; 3591 - 3592 - d->ipte_control = s->ipte_control; 3593 - d->mcn[0] = s->mcn; 3594 - for (i = 0; i < KVM_S390_BSCA_CPU_SLOTS; i++) 3595 - sca_copy_entry(&d->cpu[i], &s->cpu[i]); 3596 - } 3597 - 3598 - static int sca_switch_to_extended(struct kvm *kvm) 3599 - { 3600 - struct bsca_block *old_sca = kvm->arch.sca; 3601 - struct esca_block *new_sca; 3602 - struct kvm_vcpu *vcpu; 3603 - unsigned long vcpu_idx; 3604 - u32 scaol, scaoh; 3605 - phys_addr_t new_sca_phys; 3606 - 3607 - if (kvm->arch.use_esca) 3608 - return 0; 3609 - 3610 - new_sca = alloc_pages_exact(sizeof(*new_sca), GFP_KERNEL_ACCOUNT | __GFP_ZERO); 3611 - if (!new_sca) 3612 - return -ENOMEM; 3613 - 3614 - new_sca_phys = virt_to_phys(new_sca); 3615 - scaoh = new_sca_phys >> 32; 3616 - scaol = new_sca_phys & ESCA_SCAOL_MASK; 3617 - 3618 - kvm_s390_vcpu_block_all(kvm); 3619 - write_lock(&kvm->arch.sca_lock); 3620 - 3621 - sca_copy_b_to_e(new_sca, old_sca); 3622 - 3623 - kvm_for_each_vcpu(vcpu_idx, vcpu, kvm) { 3624 - vcpu->arch.sie_block->scaoh = scaoh; 3625 - vcpu->arch.sie_block->scaol = scaol; 3626 - vcpu->arch.sie_block->ecb2 |= ECB2_ESCA; 3627 - } 3628 - kvm->arch.sca = new_sca; 3629 - kvm->arch.use_esca = 1; 3630 - 3631 - write_unlock(&kvm->arch.sca_lock); 3632 - kvm_s390_vcpu_unblock_all(kvm); 3633 - 3634 - free_page((unsigned long)old_sca); 3635 - 3636 - VM_EVENT(kvm, 2, "Switched to ESCA (0x%p -> 0x%p)", 3637 - old_sca, kvm->arch.sca); 3638 - return 0; 3639 3588 } 3640 3589 3641 3590 static int sca_can_add_vcpu(struct kvm *kvm, unsigned int id) 3642 3591 { 3643 - int rc; 3592 + if (!kvm_s390_use_sca_entries()) 3593 + return id < KVM_MAX_VCPUS; 3644 3594 3645 - if (!kvm_s390_use_sca_entries()) { 3646 - if (id < KVM_MAX_VCPUS) 3647 - return true; 3648 - return false; 3649 - } 3650 - if (id < KVM_S390_BSCA_CPU_SLOTS) 3651 - return true; 3652 - if (!sclp.has_esca || !sclp.has_64bscao) 3653 - return false; 3654 - 3655 - rc = kvm->arch.use_esca ? 0 : sca_switch_to_extended(kvm); 3656 - 3657 - return rc == 0 && id < KVM_S390_ESCA_CPU_SLOTS; 3595 + return id < KVM_S390_ESCA_CPU_SLOTS; 3658 3596 } 3659 3597 3660 3598 /* needs disabled preemption to protect from TOD sync and vcpu_load/put */ ··· 3818 3920 vcpu->arch.sie_block->eca |= ECA_IB; 3819 3921 if (sclp.has_siif) 3820 3922 vcpu->arch.sie_block->eca |= ECA_SII; 3821 - if (sclp.has_sigpif) 3923 + if (kvm_s390_use_sca_entries()) 3822 3924 vcpu->arch.sie_block->eca |= ECA_SIGPI; 3823 3925 if (test_kvm_facility(vcpu->kvm, 129)) { 3824 3926 vcpu->arch.sie_block->eca |= ECA_VX;
+1 -8
arch/s390/kvm/kvm-s390.h
··· 570 570 int kvm_s390_handle_per_ifetch_icpt(struct kvm_vcpu *vcpu); 571 571 int kvm_s390_handle_per_event(struct kvm_vcpu *vcpu); 572 572 573 - /* support for Basic/Extended SCA handling */ 574 - static inline union ipte_control *kvm_s390_get_ipte_control(struct kvm *kvm) 575 - { 576 - struct bsca_block *sca = kvm->arch.sca; /* SCA version doesn't matter */ 577 - 578 - return &sca->ipte_control; 579 - } 580 573 static inline int kvm_s390_use_sca_entries(void) 581 574 { 582 575 /* ··· 577 584 * might use the entries. By not setting the entries and keeping them 578 585 * invalid, hardware will not access them but intercept. 579 586 */ 580 - return sclp.has_sigpif; 587 + return sclp.has_sigpif && sclp.has_esca; 581 588 } 582 589 void kvm_s390_reinject_machine_check(struct kvm_vcpu *vcpu, 583 590 struct mcck_volatile_info *mcck_info);