8 files changed, 312 insertions, 51 deletions

diff --git a/Documentation/virtual/kvm/devices/s390_flic.txt b/Documentation/virtual/kvm/devices/s390_flic.txt
new file mode 100644
index 000000000000..6b557953066a
--- /dev/null
+++ b/Documentation/virtual/kvm/devices/s390_flic.txt
@@ -0,0 +1,36 @@
+FLIC (floating interrupt controller)
+====================================
+
+FLIC handles floating (non per-cpu) interrupts, i.e. I/O, service and some
+machine check interruptions. All interrupts are stored in a per-vm list of
+pending interrupts. FLIC performs operations on this list.
+
+Only one FLIC instance may be instantiated.
+
+FLIC provides support to
+- add interrupts (KVM_DEV_FLIC_ENQUEUE)
+- inspect currently pending interrupts (KVM_FLIC_GET_ALL_IRQS)
+- purge all pending floating interrupts (KVM_DEV_FLIC_CLEAR_IRQS)
+
+Groups:
+  KVM_DEV_FLIC_ENQUEUE
+    Passes a buffer and length into the kernel which are then injected into
+    the list of pending interrupts.
+    attr->addr contains the pointer to the buffer and attr->attr contains
+    the length of the buffer.
+    The format of the data structure kvm_s390_irq as it is copied from userspace
+    is defined in usr/include/linux/kvm.h.
+
+  KVM_DEV_FLIC_GET_ALL_IRQS
+    Copies all floating interrupts into a buffer provided by userspace.
+    When the buffer is too small it returns -ENOMEM, which is the indication
+    for userspace to try again with a bigger buffer.
+    All interrupts remain pending, i.e. are not deleted from the list of
+    currently pending interrupts.
+    attr->addr contains the userspace address of the buffer into which all
+    interrupt data will be copied.
+    attr->attr contains the size of the buffer in bytes.
+
+  KVM_DEV_FLIC_CLEAR_IRQS
+    Simply deletes all elements from the list of currently pending floating
+    interrupts.  No interrupts are injected into the guest.
diff --git a/arch/s390/include/asm/kvm_host.h b/arch/s390/include/asm/kvm_host.h
index 3ffc9646e742..59635b5c59a6 100644
--- a/arch/s390/include/asm/kvm_host.h
+++ b/arch/s390/include/asm/kvm_host.h
@@ -243,6 +243,7 @@ struct kvm_arch{
         struct sca_block *sca;
         debug_info_t *dbf;
         struct kvm_s390_float_interrupt float_int;
+        struct kvm_device *flic;
         struct gmap *gmap;
         int css_support;
 };
diff --git a/arch/s390/include/uapi/asm/kvm.h b/arch/s390/include/uapi/asm/kvm.h
index d25da598ec62..38d5f98552bb 100644
--- a/arch/s390/include/uapi/asm/kvm.h
+++ b/arch/s390/include/uapi/asm/kvm.h
@@ -16,6 +16,20 @@
 
 #define __KVM_S390
 
+/* Device control API: s390-specific devices */
+#define KVM_DEV_FLIC_GET_ALL_IRQS       1
+#define KVM_DEV_FLIC_ENQUEUE            2
+#define KVM_DEV_FLIC_CLEAR_IRQS         3
+/*
+ * 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.
+ * There are also sclp and machine checks. This gives us
+ * sizeof(kvm_s390_irq)*(4*65536+8+64*64+1+1) = 72 * 266250 = 19170000
+ * Lets round up to 8192 pages.
+ */
+
+#define KVM_S390_FLIC_MAX_BUFFER        0x2000000
+
 /* for KVM_GET_REGS and KVM_SET_REGS */
 struct kvm_regs {
         /* general purpose regs for s390 */
diff --git a/arch/s390/kvm/interrupt.c b/arch/s390/kvm/interrupt.c
index 5f79d2d79ca7..a5f18babed4c 100644
--- a/arch/s390/kvm/interrupt.c
+++ b/arch/s390/kvm/interrupt.c
@@ -659,53 +659,86 @@ struct kvm_s390_interrupt_info *kvm_s390_get_io_int(struct kvm *kvm,
         return inti;
 }
 
-int kvm_s390_inject_vm(struct kvm *kvm,
-                       struct kvm_s390_interrupt *s390int)
+static void __inject_vm(struct kvm *kvm, struct kvm_s390_interrupt_info *inti)
 {
         struct kvm_s390_local_interrupt *li;
         struct kvm_s390_float_interrupt *fi;
-        struct kvm_s390_interrupt_info *inti, *iter;
+        struct kvm_s390_interrupt_info *iter;
         int sigcpu;
 
+        mutex_lock(&kvm->lock);
+        fi = &kvm->arch.float_int;
+        spin_lock(&fi->lock);
+        if (!is_ioint(inti->type)) {
+                list_add_tail(&inti->list, &fi->list);
+        } else {
+                u64 isc_bits = int_word_to_isc_bits(inti->io.io_int_word);
+
+                /* Keep I/O interrupts sorted in isc order. */
+                list_for_each_entry(iter, &fi->list, list) {
+                        if (!is_ioint(iter->type))
+                                continue;
+                        if (int_word_to_isc_bits(iter->io.io_int_word)
+                            <= isc_bits)
+                                continue;
+                        break;
+                }
+                list_add_tail(&inti->list, &iter->list);
+        }
+        atomic_set(&fi->active, 1);
+        sigcpu = find_first_bit(fi->idle_mask, KVM_MAX_VCPUS);
+        if (sigcpu == KVM_MAX_VCPUS) {
+                do {
+                        sigcpu = fi->next_rr_cpu++;
+                        if (sigcpu == KVM_MAX_VCPUS)
+                                sigcpu = fi->next_rr_cpu = 0;
+                } while (fi->local_int[sigcpu] == NULL);
+        }
+        li = fi->local_int[sigcpu];
+        spin_lock_bh(&li->lock);
+        atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
+        if (waitqueue_active(li->wq))
+                wake_up_interruptible(li->wq);
+        spin_unlock_bh(&li->lock);
+        spin_unlock(&fi->lock);
+        mutex_unlock(&kvm->lock);
+}
+
+int kvm_s390_inject_vm(struct kvm *kvm,
+                       struct kvm_s390_interrupt *s390int)
+{
+        struct kvm_s390_interrupt_info *inti;
+
         inti = kzalloc(sizeof(*inti), GFP_KERNEL);
         if (!inti)
                 return -ENOMEM;
 
-        switch (s390int->type) {
+        inti->type = s390int->type;
+        switch (inti->type) {
         case KVM_S390_INT_VIRTIO:
                 VM_EVENT(kvm, 5, "inject: virtio parm:%x,parm64:%llx",
                          s390int->parm, s390int->parm64);
-                inti->type = s390int->type;
                 inti->ext.ext_params = s390int->parm;
                 inti->ext.ext_params2 = s390int->parm64;
                 break;
         case KVM_S390_INT_SERVICE:
                 VM_EVENT(kvm, 5, "inject: sclp parm:%x", s390int->parm);
-                inti->type = s390int->type;
                 inti->ext.ext_params = s390int->parm;
                 break;
-        case KVM_S390_PROGRAM_INT:
-        case KVM_S390_SIGP_STOP:
-        case KVM_S390_INT_EXTERNAL_CALL:
-        case KVM_S390_INT_EMERGENCY:
-                kfree(inti);
-                return -EINVAL;
         case KVM_S390_MCHK:
                 VM_EVENT(kvm, 5, "inject: machine check parm64:%llx",
                          s390int->parm64);
-                inti->type = s390int->type;
                 inti->mchk.cr14 = s390int->parm; /* upper bits are not used */
                 inti->mchk.mcic = s390int->parm64;
                 break;
         case KVM_S390_INT_IO_MIN...KVM_S390_INT_IO_MAX: