irqchip/gic-v3-its: Add VLPI map/unmap operations

In order to let a VLPI being injected into a guest, the VLPI must
be mapped using the VMAPTI command. When moved to a different vcpu,
it must be moved with the VMOVI command.

These commands are issued via the irq_set_vcpu_affinity method,
making sure we unmap the corresponding host LPI first.

The reverse is also done when the VLPI is unmapped from the guest.

Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>

diff --git a/drivers/irqchip/irq-gic-v3-its.c b/drivers/irqchip/irq-gic-v3-its.c
index ead06d4..5187c4b 100644 (file)
--- a/drivers/irqchip/irq-gic-v3-its.c
+++ b/drivers/irqchip/irq-gic-v3-its.c
@@ -115,11 +115,17 @@ struct event_lpi_map {
        u16                     *col_map;
        irq_hw_number_t         lpi_base;
        int                     nr_lpis;
+       struct mutex            vlpi_lock;
+       struct its_vm           *vm;
+       struct its_vlpi_map     *vlpi_maps;
+       int                     nr_vlpis;
 };
 
 /*
- * The ITS view of a device - belongs to an ITS, a collection, owns an
- * interrupt translation table, and a list of interrupts.
+ * The ITS view of a device - belongs to an ITS, owns an interrupt
+ * translation table, and a list of interrupts.  If it some of its
+ * LPIs are injected into a guest (GICv4), the event_map.vm field
+ * indicates which one.
  */
 struct its_device {
        struct list_head        entry;
@@ -205,6 +211,21 @@ struct its_cmd_desc {
                struct {
                        struct its_collection *col;
                } its_invall_cmd;
+
+               struct {
+                       struct its_vpe *vpe;
+                       struct its_device *dev;
+                       u32 virt_id;
+                       u32 event_id;
+                       bool db_enabled;
+               } its_vmapti_cmd;
+
+               struct {
+                       struct its_vpe *vpe;
+                       struct its_device *dev;
+                       u32 event_id;
+                       bool db_enabled;
+               } its_vmovi_cmd;
        };
 };
 
@@ -221,6 +242,9 @@ struct its_cmd_block {
 typedef struct its_collection *(*its_cmd_builder_t)(struct its_cmd_block *,
                                                    struct its_cmd_desc *);
 
+typedef struct its_vpe *(*its_cmd_vbuilder_t)(struct its_cmd_block *,
+                                             struct its_cmd_desc *);
+
 static void its_mask_encode(u64 *raw_cmd, u64 val, int h, int l)
 {
        u64 mask = GENMASK_ULL(h, l);
@@ -273,6 +297,26 @@ static void its_encode_collection(struct its_cmd_block *cmd, u16 col)
        its_mask_encode(&cmd->raw_cmd[2], col, 15, 0);
 }
 
+static void its_encode_vpeid(struct its_cmd_block *cmd, u16 vpeid)
+{
+       its_mask_encode(&cmd->raw_cmd[1], vpeid, 47, 32);
+}
+
+static void its_encode_virt_id(struct its_cmd_block *cmd, u32 virt_id)
+{
+       its_mask_encode(&cmd->raw_cmd[2], virt_id, 31, 0);
+}
+
+static void its_encode_db_phys_id(struct its_cmd_block *cmd, u32 db_phys_id)
+{
+       its_mask_encode(&cmd->raw_cmd[2], db_phys_id, 63, 32);
+}
+
+static void its_encode_db_valid(struct its_cmd_block *cmd, bool db_valid)
+{
+       its_mask_encode(&cmd->raw_cmd[2], db_valid, 0, 0);
+}
+
 static inline void its_fixup_cmd(struct its_cmd_block *cmd)
 {
        /* Let's fixup BE commands */
@@ -431,6 +475,50 @@ static struct its_collection *its_build_invall_cmd(struct its_cmd_block *cmd,
        return NULL;
 }
 
+static struct its_vpe *its_build_vmapti_cmd(struct its_cmd_block *cmd,
+                                           struct its_cmd_desc *desc)
+{
+       u32 db;
+
+       if (desc->its_vmapti_cmd.db_enabled)
+               db = desc->its_vmapti_cmd.vpe->vpe_db_lpi;
+       else
+               db = 1023;
+
+       its_encode_cmd(cmd, GITS_CMD_VMAPTI);
+       its_encode_devid(cmd, desc->its_vmapti_cmd.dev->device_id);
+       its_encode_vpeid(cmd, desc->its_vmapti_cmd.vpe->vpe_id);
+       its_encode_event_id(cmd, desc->its_vmapti_cmd.event_id);
+       its_encode_db_phys_id(cmd, db);
+       its_encode_virt_id(cmd, desc->its_vmapti_cmd.virt_id);
+
+       its_fixup_cmd(cmd);
+
+       return desc->its_vmapti_cmd.vpe;
+}
+
+static struct its_vpe *its_build_vmovi_cmd(struct its_cmd_block *cmd,
+                                          struct its_cmd_desc *desc)
+{
+       u32 db;
+
+       if (desc->its_vmovi_cmd.db_enabled)
+               db = desc->its_vmovi_cmd.vpe->vpe_db_lpi;
+       else
+               db = 1023;
+
+       its_encode_cmd(cmd, GITS_CMD_VMOVI);
+       its_encode_devid(cmd, desc->its_vmovi_cmd.dev->device_id);
+       its_encode_vpeid(cmd, desc->its_vmovi_cmd.vpe->vpe_id);
+       its_encode_event_id(cmd, desc->its_vmovi_cmd.event_id);
+       its_encode_db_phys_id(cmd, db);
+       its_encode_db_valid(cmd, true);
+
+       its_fixup_cmd(cmd);
+
+       return desc->its_vmovi_cmd.vpe;
+}
+
 static u64 its_cmd_ptr_to_offset(struct its_node *its,
                                 struct its_cmd_block *ptr)
 {
@@ -582,6 +670,18 @@ static void its_build_sync_cmd(struct its_cmd_block *sync_cmd,
 static BUILD_SINGLE_CMD_FUNC(its_send_single_command, its_cmd_builder_t,
                             struct its_collection, its_build_sync_cmd)
 
+static void its_build_vsync_cmd(struct its_cmd_block *sync_cmd,
+                               struct its_vpe *sync_vpe)
+{
+       its_encode_cmd(sync_cmd, GITS_CMD_VSYNC);
+       its_encode_vpeid(sync_cmd, sync_vpe->vpe_id);
+
+       its_fixup_cmd(sync_cmd);
+}
+
+static BUILD_SINGLE_CMD_FUNC(its_send_single_vcommand, its_cmd_vbuilder_t,
+                            struct its_vpe, its_build_vsync_cmd)
+
 static void its_send_int(struct its_device *dev, u32 event_id)
 {
        struct its_cmd_desc desc;
@@ -675,6 +775,33 @@ static void its_send_invall(struct its_node *its, struct its_collection *col)
        its_send_single_command(its, its_build_invall_cmd, &desc);
 }
 
+static void its_send_vmapti(struct its_device *dev, u32 id)
+{
+       struct its_vlpi_map *map = &dev->event_map.vlpi_maps[id];
+       struct its_cmd_desc desc;
+
+       desc.its_vmapti_cmd.vpe = map->vpe;
+       desc.its_vmapti_cmd.dev = dev;
+       desc.its_vmapti_cmd.virt_id = map->vintid;
+       desc.its_vmapti_cmd.event_id = id;
+       desc.its_vmapti_cmd.db_enabled = map->db_enabled;
+
+       its_send_single_vcommand(dev->its, its_build_vmapti_cmd, &desc);
+}
+
+static void its_send_vmovi(struct its_device *dev, u32 id)
+{
+       struct its_vlpi_map *map = &dev->event_map.vlpi_maps[id];
+       struct its_cmd_desc desc;
+
+       desc.its_vmovi_cmd.vpe = map->vpe;
+       desc.its_vmovi_cmd.dev = dev;
+       desc.its_vmovi_cmd.event_id = id;
+       desc.its_vmovi_cmd.db_enabled = map->db_enabled;
+
+       its_send_single_vcommand(dev->its, its_build_vmovi_cmd, &desc);
+}
+
 /*
  * irqchip functions - assumes MSI, mostly.
  */
@@ -787,19 +914,135 @@ static int its_irq_set_irqchip_state(struct irq_data *d,
        return 0;
 }
 
+static int its_vlpi_map(struct irq_data *d, struct its_cmd_info *info)
+{
+       struct its_device *its_dev = irq_data_get_irq_chip_data(d);
+       u32 event = its_get_event_id(d);
+       int ret = 0;
+
+       if (!info->map)
+               return -EINVAL;
+
+       mutex_lock(&its_dev->event_map.vlpi_lock);
+
+       if (!its_dev->event_map.vm) {
+               struct its_vlpi_map *maps;
+
+               maps = kzalloc(sizeof(*maps) * its_dev->event_map.nr_lpis,
+                              GFP_KERNEL);
+               if (!maps) {
+                       ret = -ENOMEM;
+                       goto out;
+               }
+
+               its_dev->event_map.vm = info->map->vm;
+               its_dev->event_map.vlpi_maps = maps;
+       } else if (its_dev->event_map.vm != info->map->vm) {
+               ret = -EINVAL;
+               goto out;
+       }
+
+       /* Get our private copy of the mapping information */
+       its_dev->event_map.vlpi_maps[event] = *info->map;
+
+       if (irqd_is_forwarded_to_vcpu(d)) {
+               /* Already mapped, move it around */
+               its_send_vmovi(its_dev, event);
+       } else {
+               /* Drop the physical mapping */
+               its_send_discard(its_dev, event);
+
+               /* and install the virtual one */
+               its_send_vmapti(its_dev, event);
+               irqd_set_forwarded_to_vcpu(d);
+
+               /* Increment the number of VLPIs */
+               its_dev->event_map.nr_vlpis++;
+       }
+
+out:
+       mutex_unlock(&its_dev->event_map.vlpi_lock);
+       return ret;
+}
+
+static int its_vlpi_get(struct irq_data *d, struct its_cmd_info *info)
+{
+       struct its_device *its_dev = irq_data_get_irq_chip_data(d);
+       u32 event = its_get_event_id(d);
+       int ret = 0;
+
+       mutex_lock(&its_dev->event_map.vlpi_lock);
+
+       if (!its_dev->event_map.vm ||
+           !its_dev->event_map.vlpi_maps[event].vm) {
+               ret = -EINVAL;
+               goto out;
+       }
+
+       /* Copy our mapping information to the incoming request */
+       *info->map = its_dev->event_map.vlpi_maps[event];
+
+out:
+       mutex_unlock(&its_dev->event_map.vlpi_lock);
+       return ret;
+}
+
+static int its_vlpi_unmap(struct irq_data *d)
+{
+       struct its_device *its_dev = irq_data_get_irq_chip_data(d);
+       u32 event = its_get_event_id(d);
+       int ret = 0;
+
+       mutex_lock(&its_dev->event_map.vlpi_lock);
+
+       if (!its_dev->event_map.vm || !irqd_is_forwarded_to_vcpu(d)) {
+               ret = -EINVAL;
+               goto out;
+       }
+
+       /* Drop the virtual mapping */
+       its_send_discard(its_dev, event);
+
+       /* and restore the physical one */
+       irqd_clr_forwarded_to_vcpu(d);
+       its_send_mapti(its_dev, d->hwirq, event);
+       lpi_update_config(d, 0xff, (LPI_PROP_DEFAULT_PRIO |
+                                   LPI_PROP_ENABLED |
+                                   LPI_PROP_GROUP1));
+
+       /*
+        * Drop the refcount and make the device available again if
+        * this was the last VLPI.
+        */
+       if (!--its_dev->event_map.nr_vlpis) {
+               its_dev->event_map.vm = NULL;
+               kfree(its_dev->event_map.vlpi_maps);
+       }
+
+out:
+       mutex_unlock(&its_dev->event_map.vlpi_lock);
+       return ret;
+}
+
 static int its_irq_set_vcpu_affinity(struct irq_data *d, void *vcpu_info)
 {
        struct its_device *its_dev = irq_data_get_irq_chip_data(d);
        struct its_cmd_info *info = vcpu_info;
 
        /* Need a v4 ITS */
-       if (!its_dev->its->is_v4 || !info)
+       if (!its_dev->its->is_v4)
                return -EINVAL;
 
+       /* Unmap request? */
+       if (!info)
+               return its_vlpi_unmap(d);
+
        switch (info->cmd_type) {
        case MAP_VLPI:
+               return its_vlpi_map(d, info);
 
        case GET_VLPI:
+               return its_vlpi_get(d, info);
 
        case PROP_UPDATE_VLPI:
        case PROP_UPDATE_AND_INV_VLPI:
@@ -1518,6 +1761,7 @@ static struct its_device *its_create_device(struct its_node *its, u32 dev_id,
        dev->event_map.col_map = col_map;
        dev->event_map.lpi_base = lpi_base;
        dev->event_map.nr_lpis = nr_lpis;
+       mutex_init(&dev->event_map.vlpi_lock);
        dev->device_id = dev_id;
        INIT_LIST_HEAD(&dev->entry);