Merge tag 'mac80211-for-davem-2017-05-23' of git://git.kernel.org/pub/scm/linux/kerne...

[karo-tx-linux.git] / virt / kvm / arm / vgic / vgic-its.c

diff --git a/virt/kvm/arm/vgic/vgic-its.c b/virt/kvm/arm/vgic/vgic-its.c
index 18318c67ed93a93047a8fa5b6da28687a9c6b20d..2dff288b3a668e401d924e52cee10b9e85ecd8df 100644 (file)
--- a/virt/kvm/arm/vgic/vgic-its.c
+++ b/virt/kvm/arm/vgic/vgic-its.c
@@ -1540,14 +1540,19 @@ void vgic_enable_lpis(struct kvm_vcpu *vcpu)
                its_sync_lpi_pending_table(vcpu);
 }
 
-static int vgic_register_its_iodev(struct kvm *kvm, struct vgic_its *its)
+static int vgic_register_its_iodev(struct kvm *kvm, struct vgic_its *its,
+                                  u64 addr)
 {
        struct vgic_io_device *iodev = &its->iodev;
        int ret;
 
-       if (IS_VGIC_ADDR_UNDEF(its->vgic_its_base))
-               return -ENXIO;
+       mutex_lock(&kvm->slots_lock);
+       if (!IS_VGIC_ADDR_UNDEF(its->vgic_its_base)) {
+               ret = -EBUSY;
+               goto out;
+       }
 
+       its->vgic_its_base = addr;
        iodev->regions = its_registers;
        iodev->nr_regions = ARRAY_SIZE(its_registers);
        kvm_iodevice_init(&iodev->dev, &kvm_io_gic_ops);
@@ -1555,9 +1560,9 @@ static int vgic_register_its_iodev(struct kvm *kvm, struct vgic_its *its)
        iodev->base_addr = its->vgic_its_base;
        iodev->iodev_type = IODEV_ITS;
        iodev->its = its;
-       mutex_lock(&kvm->slots_lock);
        ret = kvm_io_bus_register_dev(kvm, KVM_MMIO_BUS, iodev->base_addr,
                                      KVM_VGIC_V3_ITS_SIZE, &iodev->dev);
+out:
        mutex_unlock(&kvm->slots_lock);
 
        return ret;
@@ -1608,13 +1613,20 @@ static int vgic_its_create(struct kvm_device *dev, u32 type)
        return vgic_its_set_abi(its, NR_ITS_ABIS - 1);
 }
 
+static void vgic_its_free_device(struct kvm *kvm, struct its_device *dev)
+{
+       struct its_ite *ite, *tmp;
+
+       list_for_each_entry_safe(ite, tmp, &dev->itt_head, ite_list)
+               its_free_ite(kvm, ite);
+       list_del(&dev->dev_list);
+       kfree(dev);
+}
+
 static void vgic_its_destroy(struct kvm_device *kvm_dev)
 {
        struct kvm *kvm = kvm_dev->kvm;
        struct vgic_its *its = kvm_dev->private;
-       struct its_device *dev;
-       struct its_ite *ite;
-       struct list_head *dev_cur, *dev_temp;
        struct list_head *cur, *temp;
 
        /*
@@ -1625,19 +1637,19 @@ static void vgic_its_destroy(struct kvm_device *kvm_dev)
                return;
 
        mutex_lock(&its->its_lock);
-       list_for_each_safe(dev_cur, dev_temp, &its->device_list) {
-               dev = container_of(dev_cur, struct its_device, dev_list);
-               list_for_each_safe(cur, temp, &dev->itt_head) {
-                       ite = (container_of(cur, struct its_ite, ite_list));
-                       its_free_ite(kvm, ite);
-               }
-               list_del(dev_cur);
-               kfree(dev);
+       list_for_each_safe(cur, temp, &its->device_list) {
+               struct its_device *dev;
+
+               dev = list_entry(cur, struct its_device, dev_list);
+               vgic_its_free_device(kvm, dev);
        }
 
        list_for_each_safe(cur, temp, &its->collection_list) {
+               struct its_collection *coll;
+
+               coll = list_entry(cur, struct its_collection, coll_list);
                list_del(cur);
-               kfree(container_of(cur, struct its_collection, coll_list));
+               kfree(coll);
        }
        mutex_unlock(&its->its_lock);
 
@@ -2007,8 +2019,10 @@ static int vgic_its_restore_dte(struct vgic_its *its, u32 id,
                return PTR_ERR(dev);
 
        ret = vgic_its_restore_itt(its, dev);
-       if (ret)
+       if (ret) {
+               vgic_its_free_device(its->dev->kvm, dev);
                return ret;
+       }
 
        return offset;
 }
@@ -2303,20 +2317,12 @@ static int vgic_its_restore_tables_v0(struct vgic_its *its)
                goto out;
 
        ret = vgic_its_restore_device_tables(its);
-
 out:
        unlock_all_vcpus(kvm);
        mutex_unlock(&its->its_lock);
        mutex_unlock(&kvm->lock);
 
-       if (ret)
-               return ret;
-
-       /*
-        * On restore path, MSI injections can happen before the
-        * first VCPU run so let's complete the GIC init here.
-        */
-       return kvm_vgic_map_resources(its->dev->kvm);
+       return ret;
 }
 
 static int vgic_its_commit_v0(struct vgic_its *its)
@@ -2384,9 +2390,7 @@ static int vgic_its_set_attr(struct kvm_device *dev,
                if (ret)
                        return ret;
 
-               its->vgic_its_base = addr;
-
-               return 0;
+               return vgic_register_its_iodev(dev->kvm, its, addr);
        }
        case KVM_DEV_ARM_VGIC_GRP_CTRL: {
                const struct vgic_its_abi *abi = vgic_its_get_abi(its);
@@ -2462,30 +2466,3 @@ int kvm_vgic_register_its_device(void)
        return kvm_register_device_ops(&kvm_arm_vgic_its_ops,
                                       KVM_DEV_TYPE_ARM_VGIC_ITS);
 }
-
-/*
- * Registers all ITSes with the kvm_io_bus framework.
- * To follow the existing VGIC initialization sequence, this has to be
- * done as late as possible, just before the first VCPU runs.
- */
-int vgic_register_its_iodevs(struct kvm *kvm)
-{
-       struct kvm_device *dev;
-       int ret = 0;
-
-       list_for_each_entry(dev, &kvm->devices, vm_node) {
-               if (dev->ops != &kvm_arm_vgic_its_ops)
-                       continue;
-
-               ret = vgic_register_its_iodev(kvm, dev->private);
-               if (ret)
-                       return ret;
-               /*
-                * We don't need to care about tearing down previously
-                * registered ITSes, as the kvm_io_bus framework removes
-                * them for us if the VM gets destroyed.
-                */
-       }
-
-       return ret;
-}