Merge tag 'kvm-3.15-1' of git://git.kernel.org/pub/scm/virt/kvm/kvm

Pull kvm updates from Paolo Bonzini:
 "PPC and ARM do not have much going on this time.  Most of the cool
  stuff, instead, is in s390 and (after a few releases) x86.

  ARM has some caching fixes and PPC has transactional memory support in
  guests.  MIPS has some fixes, with more probably coming in 3.16 as
  QEMU will soon get support for MIPS KVM.

  For x86 there are optimizations for debug registers, which trigger on
  some Windows games, and other important fixes for Windows guests.  We
  now expose to the guest Broadwell instruction set extensions and also
  Intel MPX.  There's also a fix/workaround for OS X guests, nested
  virtualization features (preemption timer), and a couple kvmclock
  refinements.

  For s390, the main news is asynchronous page faults, together with
  improvements to IRQs (floating irqs and adapter irqs) that speed up
  virtio devices"

* tag 'kvm-3.15-1' of git://git.kernel.org/pub/scm/virt/kvm/kvm: (96 commits)
  KVM: PPC: Book3S HV: Save/restore host PMU registers that are new in POWER8
  KVM: PPC: Book3S HV: Fix decrementer timeouts with non-zero TB offset
  KVM: PPC: Book3S HV: Don't use kvm_memslots() in real mode
  KVM: PPC: Book3S HV: Return ENODEV error rather than EIO
  KVM: PPC: Book3S: Trim top 4 bits of physical address in RTAS code
  KVM: PPC: Book3S HV: Add get/set_one_reg for new TM state
  KVM: PPC: Book3S HV: Add transactional memory support
  KVM: Specify byte order for KVM_EXIT_MMIO
  KVM: vmx: fix MPX detection
  KVM: PPC: Book3S HV: Fix KVM hang with CONFIG_KVM_XICS=n
  KVM: PPC: Book3S: Introduce hypervisor call H_GET_TCE
  KVM: PPC: Book3S HV: Fix incorrect userspace exit on ioeventfd write
  KVM: s390: clear local interrupts at cpu initial reset
  KVM: s390: Fix possible memory leak in SIGP functions
  KVM: s390: fix calculation of idle_mask array size
  KVM: s390: randomize sca address
  KVM: ioapic: reinject pending interrupts on KVM_SET_IRQCHIP
  KVM: Bump KVM_MAX_IRQ_ROUTES for s390
  KVM: s390: irq routing for adapter interrupts.
  KVM: s390: adapter interrupt sources
  ...

1 files changed, 306 insertions, 17 deletions

diff --git a/drivers/s390/kvm/virtio_ccw.c b/drivers/s390/kvm/virtio_ccw.c
index 0fc584832001..1e1fc671f89a 100644
--- a/drivers/s390/kvm/virtio_ccw.c
+++ b/drivers/s390/kvm/virtio_ccw.c
@@ -1,7 +1,7 @@
 /*
  * ccw based virtio transport
  *
- * Copyright IBM Corp. 2012
+ * Copyright IBM Corp. 2012, 2014
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License (version 2 only)
@@ -32,6 +32,8 @@
 #include <asm/cio.h>
 #include <asm/ccwdev.h>
 #include <asm/virtio-ccw.h>
+#include <asm/isc.h>
+#include <asm/airq.h>
 
 /*
  * virtio related functions
@@ -58,6 +60,9 @@ struct virtio_ccw_device {
         unsigned long indicators;
         unsigned long indicators2;
         struct vq_config_block *config_block;
+        bool is_thinint;
+        bool going_away;
+        void *airq_info;
 };
 
 struct vq_info_block {
@@ -72,15 +77,38 @@ struct virtio_feature_desc {
         __u8 index;
 } __packed;
 
+struct virtio_thinint_area {
+        unsigned long summary_indicator;
+        unsigned long indicator;
+        u64 bit_nr;
+        u8 isc;
+} __packed;
+
 struct virtio_ccw_vq_info {
         struct virtqueue *vq;
         int num;
         void *queue;
         struct vq_info_block *info_block;
+        int bit_nr;
         struct list_head node;
         long cookie;
 };
 
+#define VIRTIO_AIRQ_ISC IO_SCH_ISC /* inherit from subchannel */
+
+#define VIRTIO_IV_BITS (L1_CACHE_BYTES * 8)
+#define MAX_AIRQ_AREAS 20
+
+static int virtio_ccw_use_airq = 1;
+
+struct airq_info {
+        rwlock_t lock;
+        u8 summary_indicator;
+        struct airq_struct airq;
+        struct airq_iv *aiv;
+};
+static struct airq_info *airq_areas[MAX_AIRQ_AREAS];
+
 #define CCW_CMD_SET_VQ 0x13
 #define CCW_CMD_VDEV_RESET 0x33
 #define CCW_CMD_SET_IND 0x43
@@ -91,6 +119,7 @@ struct virtio_ccw_vq_info {
 #define CCW_CMD_WRITE_CONF 0x21
 #define CCW_CMD_WRITE_STATUS 0x31
 #define CCW_CMD_READ_VQ_CONF 0x32
+#define CCW_CMD_SET_IND_ADAPTER 0x73
 
 #define VIRTIO_CCW_DOING_SET_VQ 0x00010000
 #define VIRTIO_CCW_DOING_RESET 0x00040000
@@ -102,6 +131,7 @@ struct virtio_ccw_vq_info {
 #define VIRTIO_CCW_DOING_SET_IND 0x01000000
 #define VIRTIO_CCW_DOING_READ_VQ_CONF 0x02000000
 #define VIRTIO_CCW_DOING_SET_CONF_IND 0x04000000
+#define VIRTIO_CCW_DOING_SET_IND_ADAPTER 0x08000000
 #define VIRTIO_CCW_INTPARM_MASK 0xffff0000
 
 static struct virtio_ccw_device *to_vc_device(struct virtio_device *vdev)
@@ -109,6 +139,125 @@ static struct virtio_ccw_device *to_vc_device(struct virtio_device *vdev)
         return container_of(vdev, struct virtio_ccw_device, vdev);
 }
 
+static void drop_airq_indicator(struct virtqueue *vq, struct airq_info *info)
+{
+        unsigned long i, flags;
+
+        write_lock_irqsave(&info->lock, flags);
+        for (i = 0; i < airq_iv_end(info->aiv); i++) {
+                if (vq == (void *)airq_iv_get_ptr(info->aiv, i)) {
+                        airq_iv_free_bit(info->aiv, i);
+                        airq_iv_set_ptr(info->aiv, i, 0);
+                        break;
+                }
+        }
+        write_unlock_irqrestore(&info->lock, flags);
+}
+
+static void virtio_airq_handler(struct airq_struct *airq)
+{
+        struct airq_info *info = container_of(airq, struct airq_info, airq);
+        unsigned long ai;
+
+        inc_irq_stat(IRQIO_VAI);
+        read_lock(&info->lock);
+        /* Walk through indicators field, summary indicator active. */
+        for (ai = 0;;) {
+                ai = airq_iv_scan(info->aiv, ai, airq_iv_end(info->aiv));
+                if (ai == -1UL)
+                        break;
+                vring_interrupt(0, (void *)airq_iv_get_ptr(info->aiv, ai));
+        }
+        info->summary_indicator = 0;
+        smp_wmb();
+        /* Walk through indicators field, summary indicator not active. */
+        for (ai = 0;;) {
+                ai = airq_iv_scan(info->aiv, ai, airq_iv_end(info->aiv));
+                if (ai == -1UL)
+                        break;
+                vring_interrupt(0, (void *)airq_iv_get_ptr(info->aiv, ai));
+        }
+        read_unlock(&info->lock);
+}
+
+static struct airq_info *new_airq_info(void)
+{
+        struct airq_info *info;
+        int rc;
+
+        info = kzalloc(sizeof(*info), GFP_KERNEL);
+        if (!info)
+                return NULL;
+        rwlock_init(&info->lock);
+        info->aiv = airq_iv_create(VIRTIO_IV_BITS, AIRQ_IV_ALLOC | AIRQ_IV_PTR);
+        if (!info->aiv) {
+                kfree(info);
+                return NULL;
+        }
+        info->airq.handler = virtio_airq_handler;
+        info->airq.lsi_ptr = &info->summary_indicator;
+        info->airq.lsi_mask = 0xff;
+        info->airq.isc = VIRTIO_AIRQ_ISC;
+        rc = register_adapter_interrupt(&info->airq);
+        if (rc) {
+                airq_iv_release(info->aiv);
+                kfree(info);
+                return NULL;
+        }
+        return info;
+}
+
+static void destroy_airq_info(struct airq_info *info)
+{
+        if (!info)
+                return;
+
+        unregister_adapter_interrupt(&info->airq);
+        airq_iv_release(info->aiv);
+        kfree(info);
+}
+
+static unsigned long get_airq_indicator(struct virtqueue *vqs[], int nvqs,
+                                        u64 *first, void **airq_info)
+{
+        int i, j;
+        struct airq_info *info;
+        unsigned long indicator_addr = 0;
+        unsigned long bit, flags;
+
+        for (i = 0; i < MAX_AIRQ_AREAS && !indicator_addr; i++) {
+                if (!airq_areas[i])
+                        airq_areas[i] = new_airq_info();
+                info = airq_areas[i];
+                if (!info)
+                        return 0;
+                write_lock_irqsave(&info->lock, flags);
+                bit = airq_iv_alloc(info->aiv, nvqs);
+                if (bit == -1UL) {
+                        /* Not enough vacancies. */
+                        write_unlock_irqrestore(&info->lock, flags);
+                        continue;
+                }
+                *first = bit;
+                *airq_info = info;
+                indicator_addr = (unsigned long)info->aiv->vector;
+                for (j = 0; j < nvqs; j++) {
+                        airq_iv_set_ptr(info->aiv, bit + j,
+                                        (unsigned long)vqs[j]);
+                }
+                write_unlock_irqrestore(&info->lock, flags);
+        }
+        return indicator_addr;
+}
+
+static void virtio_ccw_drop_indicators(struct virtio_ccw_device *vcdev)
+{
+        struct virtio_ccw_vq_info *info;
+
+        list_for_each_entry(info, &vcdev->virtqueues, node)
+                drop_airq_indicator(info->vq, vcdev->airq_info);
+}
+
 static int doing_io(struct virtio_ccw_device *vcdev, __u32 flag)
 {
         unsigned long flags;
@@ -145,6 +294,51 @@ static int ccw_io_helper(struct virtio_ccw_device *vcdev,
         return ret ? ret : vcdev->err;
 }
 
+static void virtio_ccw_drop_indicator(struct virtio_ccw_device *vcdev,
+                                      struct ccw1 *ccw)
+{
+        int ret;
+        unsigned long *indicatorp = NULL;
+        struct virtio_thinint_area *thinint_area = NULL;
+        struct airq_info *airq_info = vcdev->airq_info;
+
+        if (vcdev->is_thinint) {
+                thinint_area = kzalloc(sizeof(*thinint_area),
+                                       GFP_DMA | GFP_KERNEL);
+                if (!thinint_area)
+                        return;
+                thinint_area->summary_indicator =
+                        (unsigned long) &airq_info->summary_indicator;
+                thinint_area->isc = VIRTIO_AIRQ_ISC;
+                ccw->cmd_code = CCW_CMD_SET_IND_ADAPTER;
+                ccw->count = sizeof(*thinint_area);
+                ccw->cda = (__u32)(unsigned long) thinint_area;
+        } else {
+                indicatorp = kmalloc(sizeof(&vcdev->indicators),
+                                     GFP_DMA | GFP_KERNEL);
+                if (!indicatorp)
+                        return;
+                *indicatorp = 0;
+                ccw->cmd_code = CCW_CMD_SET_IND;
+                ccw->count = sizeof(vcdev->indicators);
+                ccw->cda = (__u32)(unsigned long) indicatorp;
+        }
+        /* Deregister indicators from host. */
+        vcdev->indicators = 0;
+        ccw->flags = 0;
+        ret = ccw_io_helper(vcdev, ccw,
+                            vcdev->is_thinint ?
+                            VIRTIO_CCW_DOING_SET_IND_ADAPTER :
+                            VIRTIO_CCW_DOING_SET_IND);
+        if (ret && (ret != -ENODEV))
+                dev_info(&vcdev->cdev->dev,
+                         "Failed to deregister indicators (%d)\n", ret);
+        else if (vcdev->is_thinint)
+                virtio_ccw_drop_indicators(vcdev);
+        kfree(indicatorp);
+        kfree(thinint_area);
+}
+
 static inline long do_kvm_notify(struct subchannel_id schid,
                                  unsigned long queue_index,
                                  long cookie)
@@ -232,11 +426,13 @@ static void virtio_ccw_del_vqs(struct virtio_device *vdev)
 {
         struct virtqueue *vq, *n;
         struct ccw1 *ccw;
+        struct virtio_ccw_device *vcdev = to_vc_device(vdev);
 
         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
         if (!ccw)
                 return;
 
+        virtio_ccw_drop_indicator(vcdev, ccw);
 
         list_for_each_entry_safe(vq, n, &vdev->vqs, list)
                 virtio_ccw_del_vq(vq, ccw);
@@ -326,6 +522,54 @@ out_err:
         return ERR_PTR(err);
 }
 
+static int virtio_ccw_register_adapter_ind(struct virtio_ccw_device *vcdev,
+                                           struct virtqueue *vqs[], int nvqs,
+                                           struct ccw1 *ccw)
+{
+        int ret;
+        struct virtio_thinint_area *thinint_area = NULL;
+        struct airq_info *info;
+
+        thinint_area = kzalloc(sizeof(*thinint_area), GFP_DMA | GFP_KERNEL);
+        if (!thinint_area) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        /* Try to get an indicator. */
+        thinint_area->indicator = get_airq_indicator(vqs, nvqs,
+                                                     &thinint_area->bit_nr,
+                                                     &vcdev->airq_info);
+        if (!thinint_area->indicator) {
+                ret = -ENOSPC;
+                goto out;
+        }
+        info = vcdev->airq_info;
+        thinint_area->summary_indicator =
+                (unsigned long) &info->summary_indicator;
+        thinint_area->isc = VIRTIO_AIRQ_ISC;
+        ccw->cmd_code = CCW_CMD_SET_IND_ADAPTER;
+        ccw->flags = CCW_FLAG_SLI;
+        ccw->count = sizeof(*thinint_area);
+        ccw->cda = (__u32)(unsigned long)thinint_area;
+        ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_SET_IND_ADAPTER);
+        if (ret) {
+                if (ret == -EOPNOTSUPP) {
+                        /*
+                         * The host does not support adapter interrupts
+                         * for virtio-ccw, stop trying.
+                         */
+                        virtio_ccw_use_airq = 0;
+                        pr_info("Adapter interrupts unsupported on host\n");
+                } else
+                        dev_warn(&vcdev->cdev->dev,
+                                 "enabling adapter interrupts = %d\n", ret);
+                virtio_ccw_drop_indicators(vcdev);
+        }
+out:
+        kfree(thinint_area);
+        return ret;
+}
+
 static int virtio_ccw_find_vqs(struct virtio_device *vdev, unsigned nvqs,
                                struct virtqueue *vqs[],
                                vq_callback_t *callbacks[],
@@ -355,15 +599,23 @@ static int virtio_ccw_find_vqs(struct virtio_device *vdev, unsigned nvqs,
         if (!indicatorp)
                 goto out;
         *indicatorp = (unsigned long) &vcdev->indicators;
-        /* Register queue indicators with host. */
-        vcdev->indicators = 0;
-        ccw->cmd_code = CCW_CMD_SET_IND;
-        ccw->flags = 0;
-        ccw->count = sizeof(vcdev->indicators);
-        ccw->cda = (__u32)(unsigned long) indicatorp;
-        ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_SET_IND);
-        if (ret)
-                goto out;
+        if (vcdev->is_thinint) {
+                ret = virtio_ccw_register_adapter_ind(vcdev, vqs, nvqs, ccw);
+                if (ret)
+                        /* no error, just fall back to legacy interrupts */
+                        vcdev->is_thinint = 0;
+        }
+        if (!vcdev->is_thinint) {
+                /* Register queue indicators with host. */
+                vcdev->indicators = 0;
+                ccw->cmd_code = CCW_CMD_SET_IND;
+                ccw->flags = 0;
+                ccw->count = sizeof(vcdev->indicators);
+                ccw->cda = (__u32)(unsigned long) indicatorp;
+                ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_SET_IND);
+                if (ret)
+                        goto out;
+        }
         /* Register indicators2 with host for config changes */
         *indicatorp = (unsigned long) &vcdev->indicators2;
         vcdev->indicators2 = 0;
@@ -636,6 +888,8 @@ static void virtio_ccw_int_handler(struct ccw_device *cdev,
         struct virtqueue *vq;
         struct virtio_driver *drv;
 
+        if (!vcdev)
+                return;
         /* Check if it's a notification from the host. */
         if ((intparm == 0) &&
             (scsw_stctl(&irb->scsw) ==
@@ -663,6 +917,7 @@ static void virtio_ccw_int_handler(struct ccw_device *cdev,
                 case VIRTIO_CCW_DOING_SET_CONF_IND:
                 case VIRTIO_CCW_DOING_RESET:
                 case VIRTIO_CCW_DOING_READ_VQ_CONF:
+                case VIRTIO_CCW_DOING_SET_IND_ADAPTER:
                         vcdev->curr_io &= ~activity;
                         wake_up(&vcdev->wait_q);
                         break;
@@ -734,23 +989,46 @@ static int virtio_ccw_probe(struct ccw_device *cdev)
         return 0;
 }
 
+static struct virtio_ccw_device *virtio_grab_drvdata(struct ccw_device *cdev)
+{
+        unsigned long flags;
+        struct virtio_ccw_device *vcdev;
+
+        spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
+        vcdev = dev_get_drvdata(&cdev->dev);
+        if (!vcdev || vcdev->going_away) {
+                spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
+                return NULL;
+        }
+        vcdev->going_away = true;
+        spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
+        return vcdev;
+}
+
 static void virtio_ccw_remove(struct ccw_device *cdev)
 {
-        struct virtio_ccw_device *vcdev = dev_get_drvdata(&cdev->dev);
+        unsigned long flags;
+        struct virtio_ccw_device *vcdev = virtio_grab_drvdata(cdev);
 
-        if (cdev->online) {
+        if (vcdev && cdev->online)
                 unregister_virtio_device(&vcdev->vdev);
-                dev_set_drvdata(&cdev->dev, NULL);
-        }
+        spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
+        dev_set_drvdata(&cdev->dev, NULL);
+        spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
         cdev->handler = NULL;
 }
 
 static int virtio_ccw_offline(struct ccw_device *cdev)
 {
-        struct virtio_ccw_device *vcdev = dev_get_drvdata(&cdev->dev);
+        unsigned long flags;
+        struct virtio_ccw_device *vcdev = virtio_grab_drvdata(cdev);
 
-        unregister_virtio_device(&vcdev->vdev);
-        dev_set_drvdata(&cdev->dev, NULL);
+        if (vcdev) {
+                unregister_virtio_device(&vcdev->vdev);
+                spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
+                dev_set_drvdata(&cdev->dev, NULL);
+                spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
+        }
         return 0;
 }
 
@@ -759,6 +1037,7 @@ static int virtio_ccw_online(struct ccw_device *cdev)
 {
         int ret;
         struct virtio_ccw_device *vcdev;
+        unsigned long flags;
 
         vcdev = kzalloc(sizeof(*vcdev), GFP_KERNEL);
         if (!vcdev) {
@@ -778,6 +1057,8 @@ static int virtio_ccw_online(struct ccw_device *cdev)
                 goto out_free;
         }
 
+        vcdev->is_thinint = virtio_ccw_use_airq; /* at least try */
+
         vcdev->vdev.dev.parent = &cdev->dev;
         vcdev->vdev.dev.release = virtio_ccw_release_dev;
         vcdev->vdev.config = &virtio_ccw_config_ops;
@@ -786,7 +1067,9 @@ static int virtio_ccw_online(struct ccw_device *cdev)
         INIT_LIST_HEAD(&vcdev->virtqueues);
         spin_lock_init(&vcdev->lock);
 
+        spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
         dev_set_drvdata(&cdev->dev, vcdev);
+        spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
         vcdev->vdev.id.vendor = cdev->id.cu_type;
         vcdev->vdev.id.device = cdev->id.cu_model;
         ret = register_virtio_device(&vcdev->vdev);
@@ -797,7 +1080,9 @@ static int virtio_ccw_online(struct ccw_device *cdev)
         }
         return 0;
 out_put:
+        spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
         dev_set_drvdata(&cdev->dev, NULL);
+        spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
         put_device(&vcdev->vdev.dev);
         return ret;
 out_free:
@@ -935,6 +1220,10 @@ module_init(virtio_ccw_init);
 
 static void __exit virtio_ccw_exit(void)
 {
+        int i;
+
         ccw_driver_unregister(&virtio_ccw_driver);
+        for (i = 0; i < MAX_AIRQ_AREAS; i++)
+                destroy_airq_info(airq_areas[i]);
 }
 module_exit(virtio_ccw_exit);