Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d011e4e6 authored by Marc Zyngier's avatar Marc Zyngier
Browse files

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: default avatarMarc Zyngier <marc.zyngier@arm.com>
parent c808eea8

drivers/irqchip/irq-gic-v3-its.c

+247 −3
Original line number Diff line number Diff line
@@ -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);