10 files changed, 122 insertions, 35 deletions

diff --git a/arch/s390/include/asm/kvm_host.h b/arch/s390/include/asm/kvm_host.h
index 6da41fab70fb..37b9017c6a96 100644
--- a/arch/s390/include/asm/kvm_host.h
+++ b/arch/s390/include/asm/kvm_host.h
@@ -38,7 +38,7 @@
  */
 #define KVM_NR_IRQCHIPS 1
 #define KVM_IRQCHIP_NUM_PINS 4096
-#define KVM_HALT_POLL_NS_DEFAULT 0
+#define KVM_HALT_POLL_NS_DEFAULT 80000
 
 /* s390-specific vcpu->requests bit members */
 #define KVM_REQ_ENABLE_IBS         8
@@ -247,6 +247,7 @@ struct kvm_vcpu_stat {
         u32 exit_instruction;
         u32 halt_successful_poll;
         u32 halt_attempted_poll;
+        u32 halt_poll_invalid;
         u32 halt_wakeup;
         u32 instruction_lctl;
         u32 instruction_lctlg;
@@ -544,10 +545,6 @@ struct kvm_vcpu_arch {
         struct kvm_s390_local_interrupt local_int;
         struct hrtimer    ckc_timer;
         struct kvm_s390_pgm_info pgm;
-        union  {
-                struct cpuid    cpu_id;
-                u64             stidp_data;
-        };
         struct gmap *gmap;
         struct kvm_guestdbg_info_arch guestdbg;
         unsigned long pfault_token;
@@ -605,7 +602,7 @@ struct kvm_s390_cpu_model {
         __u64 fac_mask[S390_ARCH_FAC_LIST_SIZE_U64];
         /* facility list requested by guest (in dma page) */
         __u64 *fac_list;
-        struct cpuid cpu_id;
+        u64 cpuid;
         unsigned short ibc;
 };
 
@@ -700,4 +697,6 @@ static inline void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
 static inline void kvm_arch_vcpu_blocking(struct kvm_vcpu *vcpu) {}
 static inline void kvm_arch_vcpu_unblocking(struct kvm_vcpu *vcpu) {}
 
+void kvm_arch_vcpu_block_finish(struct kvm_vcpu *vcpu);
+
 #endif
diff --git a/arch/s390/include/asm/sclp.h b/arch/s390/include/asm/sclp.h
index bd7893d274fa..e4f6f73afe2f 100644
--- a/arch/s390/include/asm/sclp.h
+++ b/arch/s390/include/asm/sclp.h
@@ -69,6 +69,7 @@ struct sclp_info {
         unsigned int max_cores;
         unsigned long hsa_size;
         unsigned long facilities;
+        unsigned int hmfai;
 };
 extern struct sclp_info sclp;
 
diff --git a/arch/s390/include/asm/sigp.h b/arch/s390/include/asm/sigp.h
index ec60cf7fa0a2..1c8f33fca356 100644
--- a/arch/s390/include/asm/sigp.h
+++ b/arch/s390/include/asm/sigp.h
@@ -27,6 +27,7 @@
 
 /* SIGP cpu status bits */
 
+#define SIGP_STATUS_INVALID_ORDER       0x00000002UL
 #define SIGP_STATUS_CHECK_STOP          0x00000010UL
 #define SIGP_STATUS_STOPPED             0x00000040UL
 #define SIGP_STATUS_EXT_CALL_PENDING    0x00000080UL
diff --git a/arch/s390/include/uapi/asm/kvm.h b/arch/s390/include/uapi/asm/kvm.h
index 347fe5afa419..3b8e99ef9d58 100644
--- a/arch/s390/include/uapi/asm/kvm.h
+++ b/arch/s390/include/uapi/asm/kvm.h
@@ -25,6 +25,7 @@
 #define KVM_DEV_FLIC_APF_DISABLE_WAIT   5
 #define KVM_DEV_FLIC_ADAPTER_REGISTER   6
 #define KVM_DEV_FLIC_ADAPTER_MODIFY     7
+#define KVM_DEV_FLIC_CLEAR_IO_IRQ       8
 /*
  * We can have up to 4*64k pending subchannels + 8 adapter interrupts,
  * as well as up  to ASYNC_PF_PER_VCPU*KVM_MAX_VCPUS pfault done interrupts.
diff --git a/arch/s390/include/uapi/asm/sie.h b/arch/s390/include/uapi/asm/sie.h
index 5dbaa72baa64..8fb5d4a6dd25 100644
--- a/arch/s390/include/uapi/asm/sie.h
+++ b/arch/s390/include/uapi/asm/sie.h
@@ -16,14 +16,19 @@
         { 0x01, "SIGP sense" },                                 \
         { 0x02, "SIGP external call" },                         \
         { 0x03, "SIGP emergency signal" },                      \
+        { 0x04, "SIGP start" },                                 \
         { 0x05, "SIGP stop" },                                  \
         { 0x06, "SIGP restart" },                               \
         { 0x09, "SIGP stop and store status" },                 \
         { 0x0b, "SIGP initial cpu reset" },                     \
+        { 0x0c, "SIGP cpu reset" },                             \
         { 0x0d, "SIGP set prefix" },                            \
         { 0x0e, "SIGP store status at address" },               \
         { 0x12, "SIGP set architecture" },                      \
-        { 0x15, "SIGP sense running" }
+        { 0x13, "SIGP conditional emergency signal" },          \
+        { 0x15, "SIGP sense running" },                         \
+        { 0x16, "SIGP set multithreading"},                     \
+        { 0x17, "SIGP store additional status ait address"}
 
 #define icpt_prog_codes                                         \
         { 0x0001, "Prog Operation" },                           \
diff --git a/arch/s390/kvm/Kconfig b/arch/s390/kvm/Kconfig
index 5ea5af3c7db7..b1900239b0ab 100644
--- a/arch/s390/kvm/Kconfig
+++ b/arch/s390/kvm/Kconfig
@@ -28,6 +28,7 @@ config KVM
         select HAVE_KVM_IRQCHIP
         select HAVE_KVM_IRQFD
         select HAVE_KVM_IRQ_ROUTING
+        select HAVE_KVM_INVALID_WAKEUPS
         select SRCU
         select KVM_VFIO
         ---help---
diff --git a/arch/s390/kvm/interrupt.c b/arch/s390/kvm/interrupt.c
index 84efc2ba6a90..5a80af740d3e 100644
--- a/arch/s390/kvm/interrupt.c
+++ b/arch/s390/kvm/interrupt.c
@@ -977,6 +977,11 @@ no_timer:
 
 void kvm_s390_vcpu_wakeup(struct kvm_vcpu *vcpu)
 {
+        /*
+         * We cannot move this into the if, as the CPU might be already
+         * in kvm_vcpu_block without having the waitqueue set (polling)
+         */
+        vcpu->valid_wakeup = true;
         if (swait_active(&vcpu->wq)) {
                 /*
                  * The vcpu gave up the cpu voluntarily, mark it as a good
@@ -2034,6 +2039,27 @@ static int modify_io_adapter(struct kvm_device *dev,
         return ret;
 }
 
+static int clear_io_irq(struct kvm *kvm, struct kvm_device_attr *attr)
+
+{
+        const u64 isc_mask = 0xffUL << 24; /* all iscs set */
+        u32 schid;
+
+        if (attr->flags)
+                return -EINVAL;
+        if (attr->attr != sizeof(schid))
+                return -EINVAL;
+        if (copy_from_user(&schid, (void __user *) attr->addr, sizeof(schid)))
+                return -EFAULT;
+        kfree(kvm_s390_get_io_int(kvm, isc_mask, schid));
+        /*
+         * If userspace is conforming to the architecture, we can have at most
+         * one pending I/O interrupt per subchannel, so this is effectively a
+         * clear all.
+         */
+        return 0;
+}
+
 static int flic_set_attr(struct kvm_device *dev, struct kvm_device_attr *attr)
 {
         int r = 0;
@@ -2067,6 +2093,9 @@ static int flic_set_attr(struct kvm_device *dev, struct kvm_device_attr *attr)
         case KVM_DEV_FLIC_ADAPTER_MODIFY:
                 r = modify_io_adapter(dev, attr);
                 break;
+        case KVM_DEV_FLIC_CLEAR_IO_IRQ:
+                r = clear_io_irq(dev->kvm, attr);
+                break;
         default:
                 r = -EINVAL;
         }
@@ -2074,6 +2103,23 @@ static int flic_set_attr(struct kvm_device *dev, struct kvm_device_attr *attr)
         return r;
 }
 
+static int flic_has_attr(struct kvm_device *dev,
+                             struct kvm_device_attr *attr)
+{
+        switch (attr->group) {
+        case KVM_DEV_FLIC_GET_ALL_IRQS:
+        case KVM_DEV_FLIC_ENQUEUE:
+        case KVM_DEV_FLIC_CLEAR_IRQS:
+        case KVM_DEV_FLIC_APF_ENABLE:
+        case KVM_DEV_FLIC_APF_DISABLE_WAIT:
+        case KVM_DEV_FLIC_ADAPTER_REGISTER:
+        case KVM_DEV_FLIC_ADAPTER_MODIFY:
+        case KVM_DEV_FLIC_CLEAR_IO_IRQ:
+                return 0;
+        }
+        return -ENXIO;
+}
+
 static int flic_create(struct kvm_device *dev, u32 type)
 {
         if (!dev)
@@ -2095,6 +2141,7 @@ struct kvm_device_ops kvm_flic_ops = {
         .name = "kvm-flic",
         .get_attr = flic_get_attr,
         .set_attr = flic_set_attr,
+        .has_attr = flic_has_attr,
         .create = flic_create,
         .destroy = flic_destroy,
 };
diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c
index 668c087513e5..6d8ec3ac9dd8 100644
--- a/arch/s390/kvm/kvm-s390.c
+++ b/arch/s390/kvm/kvm-s390.c
@@ -65,6 +65,7 @@ struct kvm_stats_debugfs_item debugfs_entries[] = {
         { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) },
         { "halt_successful_poll", VCPU_STAT(halt_successful_poll) },
         { "halt_attempted_poll", VCPU_STAT(halt_attempted_poll) },
+        { "halt_poll_invalid", VCPU_STAT(halt_poll_invalid) },
         { "halt_wakeup", VCPU_STAT(halt_wakeup) },
         { "instruction_lctlg", VCPU_STAT(instruction_lctlg) },
         { "instruction_lctl", VCPU_STAT(instruction_lctl) },
@@ -118,9 +119,9 @@ struct kvm_stats_debugfs_item debugfs_entries[] = {
 };
 
 /* upper facilities limit for kvm */
-unsigned long kvm_s390_fac_list_mask[] = {
-        0xffe6fffbfcfdfc40UL,
-        0x005e800000000000UL,
+unsigned long kvm_s390_fac_list_mask[16] = {
+        0xffe6000000000000UL,
+        0x005e000000000000UL,
 };
 
 unsigned long kvm_s390_fac_list_mask_size(void)
@@ -638,6 +639,7 @@ static int kvm_s390_get_tod(struct kvm *kvm, struct kvm_device_attr *attr)
 static int kvm_s390_set_processor(struct kvm *kvm, struct kvm_device_attr *attr)
 {
         struct kvm_s390_vm_cpu_processor *proc;
+        u16 lowest_ibc, unblocked_ibc;
         int ret = 0;
 
         mutex_lock(&kvm->lock);
@@ -652,9 +654,17 @@ static int kvm_s390_set_processor(struct kvm *kvm, struct kvm_device_attr *attr)
         }
         if (!copy_from_user(proc, (void __user *)attr->addr,
                             sizeof(*proc))) {
-                memcpy(&kvm->arch.model.cpu_id, &proc->cpuid,
-                       sizeof(struct cpuid));
-                kvm->arch.model.ibc = proc->ibc;
+                kvm->arch.model.cpuid = proc->cpuid;
+                lowest_ibc = sclp.ibc >> 16 & 0xfff;
+                unblocked_ibc = sclp.ibc & 0xfff;
+                if (lowest_ibc) {
+                        if (proc->ibc > unblocked_ibc)
+                                kvm->arch.model.ibc = unblocked_ibc;
+                        else if (proc->ibc < lowest_ibc)
+                                kvm->arch.model.ibc = lowest_ibc;
+                        else
+                                kvm->arch.model.ibc = proc->ibc;
+                }
                 memcpy(kvm->arch.model.fac_list, proc->fac_list,
                        S390_ARCH_FAC_LIST_SIZE_BYTE);
         } else
@@ -687,7 +697,7 @@ static int kvm_s390_get_processor(struct kvm *kvm, struct kvm_device_attr *attr)
                 ret = -ENOMEM;
                 goto out;
         }
-        memcpy(&proc->cpuid, &kvm->arch.model.cpu_id, sizeof(struct cpuid));
+        proc->cpuid = kvm->arch.model.cpuid;
         proc->ibc = kvm->arch.model.ibc;
         memcpy(&proc->fac_list, kvm->arch.model.fac_list,
                S390_ARCH_FAC_LIST_SIZE_BYTE);
@@ -1081,10 +1091,13 @@ static void kvm_s390_set_crycb_format(struct kvm *kvm)
                 kvm->arch.crypto.crycbd |= CRYCB_FORMAT1;
 }
 
-static void kvm_s390_get_cpu_id(struct cpuid *cpu_id)
+static u64 kvm_s390_get_initial_cpuid(void)
 {
-        get_cpu_id(cpu_id);
-        cpu_id->version = 0xff;
+        struct cpuid cpuid;
+
+        get_cpu_id(&cpuid);
+        cpuid.version = 0xff;
+        return *((u64 *) &cpuid);
 }
 
 static void kvm_s390_crypto_init(struct kvm *kvm)
@@ -1175,7 +1188,7 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
         memcpy(kvm->arch.model.fac_list, kvm->arch.model.fac_mask,
                S390_ARCH_FAC_LIST_SIZE_BYTE);
 
-        kvm_s390_get_cpu_id(&kvm->arch.model.cpu_id);
+        kvm->arch.model.cpuid = kvm_s390_get_initial_cpuid();
         kvm->arch.model.ibc = sclp.ibc & 0x0fff;
 
         kvm_s390_crypto_init(kvm);
@@ -1624,7 +1637,6 @@ static void kvm_s390_vcpu_setup_model(struct kvm_vcpu *vcpu)
 {
         struct kvm_s390_cpu_model *model = &vcpu->kvm->arch.model;
 
-        vcpu->arch.cpu_id = model->cpu_id;
         vcpu->arch.sie_block->ibc = model->ibc;
         if (test_kvm_facility(vcpu->kvm, 7))
                 vcpu->arch.sie_block->fac = (u32)(u64) model->fac_list;
@@ -1645,11 +1657,14 @@ int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
 
         kvm_s390_vcpu_setup_model(vcpu);
 
-        vcpu->arch.sie_block->ecb   = 6;
+        vcpu->arch.sie_block->ecb = 0x02;
+        if (test_kvm_facility(vcpu->kvm, 9))
+                vcpu->arch.sie_block->ecb |= 0x04;
         if (test_kvm_facility(vcpu->kvm, 50) && test_kvm_facility(vcpu->kvm, 73))
                 vcpu->arch.sie_block->ecb |= 0x10;
 
-        vcpu->arch.sie_block->ecb2  = 8;
+        if (test_kvm_facility(vcpu->kvm, 8))
+                vcpu->arch.sie_block->ecb2 |= 0x08;
         vcpu->arch.sie_block->eca   = 0xC1002000U;
         if (sclp.has_siif)
                 vcpu->arch.sie_block->eca |= 1;
@@ -2971,13 +2986,31 @@ void kvm_arch_commit_memory_region(struct kvm *kvm,
         return;
 }
 
+static inline unsigned long nonhyp_mask(int i)
+{
+        unsigned int nonhyp_fai = (sclp.hmfai << i * 2) >> 30;
+
+        return 0x0000ffffffffffffUL >> (nonhyp_fai << 4);
+}
+
+void kvm_arch_vcpu_block_finish(struct kvm_vcpu *vcpu)
+{
+        vcpu->valid_wakeup = false;
+}
+
 static int __init kvm_s390_init(void)
 {
+        int i;
+
         if (!sclp.has_sief2) {
                 pr_info("SIE not available\n");
                 return -ENODEV;
         }
 
+        for (i = 0; i < 16; i++)
+                kvm_s390_fac_list_mask[i] |=
+                        S390_lowcore.stfle_fac_list[i] & nonhyp_mask(i);
+
         return kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
 }
 
diff --git a/arch/s390/kvm/priv.c b/arch/s390/kvm/priv.c
index 0a1591d3d25d..95916fa7c670 100644
--- a/arch/s390/kvm/priv.c
+++ b/arch/s390/kvm/priv.c
@@ -439,7 +439,7 @@ static int handle_lpswe(struct kvm_vcpu *vcpu)
 
 static int handle_stidp(struct kvm_vcpu *vcpu)
 {
-        u64 stidp_data = vcpu->arch.stidp_data;
+        u64 stidp_data = vcpu->kvm->arch.model.cpuid;
         u64 operand2;
         int rc;
         ar_t ar;
@@ -670,8 +670,9 @@ static int handle_pfmf(struct kvm_vcpu *vcpu)
         if (vcpu->run->s.regs.gprs[reg1] & PFMF_RESERVED)
                 return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
 
-        /* Only provide non-quiescing support if the host supports it */
-        if (vcpu->run->s.regs.gprs[reg1] & PFMF_NQ && !test_facility(14))
+        /* Only provide non-quiescing support if enabled for the guest */
+        if (vcpu->run->s.regs.gprs[reg1] & PFMF_NQ &&
+            !test_kvm_facility(vcpu->kvm, 14))
                 return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
 
         /* No support for conditional-SSKE */
@@ -744,7 +745,7 @@ static int handle_essa(struct kvm_vcpu *vcpu)
 {
         /* entries expected to be 1FF */
         int entries = (vcpu->arch.sie_block->cbrlo & ~PAGE_MASK) >> 3;
-        unsigned long *cbrlo, cbrle;
+        unsigned long *cbrlo;
         struct gmap *gmap;
         int i;
 
@@ -765,17 +766,9 @@ static int handle_essa(struct kvm_vcpu *vcpu)
         vcpu->arch.sie_block->cbrlo &= PAGE_MASK;       /* reset nceo */
         cbrlo = phys_to_virt(vcpu->arch.sie_block->cbrlo);
         down_read(&gmap->mm->mmap_sem);
-        for (i = 0; i < entries; ++i) {
-                cbrle = cbrlo[i];
-                if (unlikely(cbrle & ~PAGE_MASK || cbrle < 2 * PAGE_SIZE))
-                        /* invalid entry */
-                        break;
-                /* try to free backing */
-                __gmap_zap(gmap, cbrle);
-        }
+        for (i = 0; i < entries; ++i)
+                __gmap_zap(gmap, cbrlo[i]);
         up_read(&gmap->mm->mmap_sem);
-        if (i < entries)
-                return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
         return 0;
 }
 
diff --git a/arch/s390/kvm/sigp.c b/arch/s390/kvm/sigp.c
index 77c22d685c7a..28ea0cab1f1b 100644
--- a/arch/s390/kvm/sigp.c
+++ b/arch/s390/kvm/sigp.c
@@ -240,6 +240,12 @@ static int __sigp_sense_running(struct kvm_vcpu *vcpu,
         struct kvm_s390_local_interrupt *li;
         int rc;
 
+        if (!test_kvm_facility(vcpu->kvm, 9)) {
+                *reg &= 0xffffffff00000000UL;
+                *reg |= SIGP_STATUS_INVALID_ORDER;
+                return SIGP_CC_STATUS_STORED;
+        }
+
         li = &dst_vcpu->arch.local_int;
         if (atomic_read(li->cpuflags) & CPUSTAT_RUNNING) {
                 /* running */