2 files changed, 136 insertions, 0 deletions

diff --git a/virt/kvm/arm/vgic.c b/virt/kvm/arm/vgic.c
index 8802ad73467f..e968179e592f 100644
--- a/virt/kvm/arm/vgic.c
+++ b/virt/kvm/arm/vgic.c
@@ -32,6 +32,8 @@
 #include <asm/kvm_arm.h>
 #include <asm/kvm_mmu.h>
 #include <trace/events/kvm.h>
+#include <asm/kvm.h>
+#include <kvm/iodev.h>
 
 /*
  * How the whole thing works (courtesy of Christoffer Dall):
@@ -837,6 +839,66 @@ bool vgic_handle_mmio_range(struct kvm_vcpu *vcpu, struct kvm_run *run,
 }
 
 /**
+ * vgic_handle_mmio_access - handle an in-kernel MMIO access
+ * This is called by the read/write KVM IO device wrappers below.
+ * @vcpu:       pointer to the vcpu performing the access
+ * @this:       pointer to the KVM IO device in charge
+ * @addr:       guest physical address of the access
+ * @len:        size of the access
+ * @val:        pointer to the data region
+ * @is_write:   read or write access
+ *
+ * returns true if the MMIO access could be performed
+ */
+static int vgic_handle_mmio_access(struct kvm_vcpu *vcpu,
+                                   struct kvm_io_device *this, gpa_t addr,
+                                   int len, void *val, bool is_write)
+{
+        struct vgic_dist *dist = &vcpu->kvm->arch.vgic;
+        struct vgic_io_device *iodev = container_of(this,
+                                                    struct vgic_io_device, dev);
+        struct kvm_run *run = vcpu->run;
+        const struct vgic_io_range *range;
+        struct kvm_exit_mmio mmio;
+        bool updated_state;
+        gpa_t offset;
+
+        offset = addr - iodev->addr;
+        range = vgic_find_range(iodev->reg_ranges, len, offset);
+        if (unlikely(!range || !range->handle_mmio)) {
+                pr_warn("Unhandled access %d %08llx %d\n", is_write, addr, len);
+                return -ENXIO;
+        }
+
+        mmio.phys_addr = addr;
+        mmio.len = len;
+        mmio.is_write = is_write;
+        if (is_write)
+                memcpy(mmio.data, val, len);
+        mmio.private = iodev->redist_vcpu;
+
+        spin_lock(&dist->lock);
+        offset -= range->base;
+        if (vgic_validate_access(dist, range, offset)) {
+                updated_state = call_range_handler(vcpu, &mmio, offset, range);
+                if (!is_write)
+                        memcpy(val, mmio.data, len);
+        } else {
+                if (!is_write)
+                        memset(val, 0, len);
+                updated_state = false;
+        }
+        spin_unlock(&dist->lock);
+        kvm_prepare_mmio(run, &mmio);
+        kvm_handle_mmio_return(vcpu, run);
+
+        if (updated_state)
+                vgic_kick_vcpus(vcpu->kvm);
+
+        return 0;
+}
+
+/**
  * vgic_handle_mmio - handle an in-kernel MMIO access for the GIC emulation
  * @vcpu:      pointer to the vcpu performing the access
  * @run:       pointer to the kvm_run structure
@@ -860,6 +922,73 @@ bool vgic_handle_mmio(struct kvm_vcpu *vcpu, struct kvm_run *run,
         return vcpu->kvm->arch.vgic.vm_ops.handle_mmio(vcpu, run, mmio);
 }
 
+static int vgic_handle_mmio_read(struct kvm_vcpu *vcpu,
+                                 struct kvm_io_device *this,
+                                 gpa_t addr, int len, void *val)
+{
+        return vgic_handle_mmio_access(vcpu, this, addr, len, val, false);
+}
+
+static int vgic_handle_mmio_write(struct kvm_vcpu *vcpu,
+                                  struct kvm_io_device *this,
+                                  gpa_t addr, int len, const void *val)
+{
+        return vgic_handle_mmio_access(vcpu, this, addr, len, (void *)val,
+                                       true);
+}
+
+struct kvm_io_device_ops vgic_io_ops = {
+        .read   = vgic_handle_mmio_read,
+        .write  = vgic_handle_mmio_write,
+};
+
+/**
+ * vgic_register_kvm_io_dev - register VGIC register frame on the KVM I/O bus
+ * @kvm:            The VM structure pointer
+ * @base:           The (guest) base address for the register frame
+ * @len:            Length of the register frame window
+ * @ranges:         Describing the handler functions for each register
+ * @redist_vcpu_id: The VCPU ID to pass on to the handlers on call
+ * @iodev:          Points to memory to be passed on to the handler
+ *
+ * @iodev stores the parameters of this function to be usable by the handler
+ * respectively the dispatcher function (since the KVM I/O bus framework lacks
+ * an opaque parameter). Initialization is done in this function, but the
+ * reference should be valid and unique for the whole VGIC lifetime.
+ * If the register frame is not mapped for a specific VCPU, pass -1 to
+ * @redist_vcpu_id.
+ */
+int vgic_register_kvm_io_dev(struct kvm *kvm, gpa_t base, int len,
+                             const struct vgic_io_range *ranges,
+                             int redist_vcpu_id,
+                             struct vgic_io_device *iodev)
+{
+        struct kvm_vcpu *vcpu = NULL;
+        int ret;
+
+        if (redist_vcpu_id >= 0)
+                vcpu = kvm_get_vcpu(kvm, redist_vcpu_id);
+
+        iodev->addr             = base;
+        iodev->len              = len;
+        iodev->reg_ranges       = ranges;
+        iodev->redist_vcpu      = vcpu;
+
+        kvm_iodevice_init(&iodev->dev, &vgic_io_ops);
+
+        mutex_lock(&kvm->slots_lock);
+
+        ret = kvm_io_bus_register_dev(kvm, KVM_MMIO_BUS, base, len,
+                                      &iodev->dev);
+        mutex_unlock(&kvm->slots_lock);
+
+        /* Mark the iodev as invalid if registration fails. */
+        if (ret)
+                iodev->dev.ops = NULL;
+
+        return ret;
+}
+
 static int vgic_nr_shared_irqs(struct vgic_dist *dist)
 {
         return dist->nr_irqs - VGIC_NR_PRIVATE_IRQS;
diff --git a/virt/kvm/arm/vgic.h b/virt/kvm/arm/vgic.h
index 01aa6228f88b..28fa3aaf6367 100644
--- a/virt/kvm/arm/vgic.h
+++ b/virt/kvm/arm/vgic.h
@@ -20,6 +20,8 @@
 #ifndef __KVM_VGIC_H__
 #define __KVM_VGIC_H__
 
+#include <kvm/iodev.h>
+
 #define VGIC_ADDR_UNDEF         (-1)
 #define IS_VGIC_ADDR_UNDEF(_x)  ((_x) == VGIC_ADDR_UNDEF)
 
@@ -82,6 +84,11 @@ struct vgic_io_range {
                             phys_addr_t offset);
 };
 
+int vgic_register_kvm_io_dev(struct kvm *kvm, gpa_t base, int len,
+                             const struct vgic_io_range *ranges,
+                             int redist_id,
+                             struct vgic_io_device *iodev);
+
 static inline bool is_in_range(phys_addr_t addr, unsigned long len,
                                phys_addr_t baseaddr, unsigned long size)
 {