[PATCH v5 05/17] iommufd: Prepare software MSI maps for address lists
Andrew Jones
andrew.jones at oss.qualcomm.com
Mon Aug 31 07:59:31 PDT 2026
Teach iommufd_sw_msi_get_map() to match an ordered physical address list
against an existing contiguous IOVA range. Mark the first map with the
range size so an identical list can reuse the allocation.
Teach iommufd_sw_msi_alloc_map() to reserve identifiers and offsets for
the complete list and build its maps on a temporary list. Keep the
existing scalar installation behavior and only publish newly allocated
maps after installation succeeds.
Signed-off-by: Andrew Jones <andrew.jones at oss.qualcomm.com>
---
drivers/iommu/iommufd/driver.c | 161 ++++++++++++++++++------
drivers/iommu/iommufd/iommufd_private.h | 1 +
2 files changed, 123 insertions(+), 39 deletions(-)
diff --git a/drivers/iommu/iommufd/driver.c b/drivers/iommu/iommufd/driver.c
index 8bb47a81fed1..6a0527f4b058 100644
--- a/drivers/iommu/iommufd/driver.c
+++ b/drivers/iommu/iommufd/driver.c
@@ -179,35 +179,91 @@ EXPORT_SYMBOL_NS_GPL(iommufd_viommu_report_event, "IOMMUFD");
#ifdef CONFIG_IRQ_MSI_IOMMU
/*
- * Get a iommufd_sw_msi_map for the msi physical address requested by the irq
+ * Get an iommufd_sw_msi_map for the msi physical addresses requested by the irq
* layer. The mapping to IOVA is global to the iommufd file descriptor, every
* domain that is attached to a device using the same MSI parameters will use
- * the same IOVA.
+ * the same contiguous IOVA range.
*/
static struct iommufd_sw_msi_map *
-iommufd_sw_msi_get_map(struct iommufd_ctx *ictx, phys_addr_t msi_addr,
- const struct iommufd_sw_msi_range *sw_msi_range)
+iommufd_sw_msi_get_map(struct iommufd_ctx *ictx, const phys_addr_t *phys_addrs,
+ unsigned int nr_addrs, const struct iommufd_sw_msi_range *sw_msi_range)
{
- struct iommufd_sw_msi_map *cur;
+ struct iommufd_sw_msi_map *cur, *msi_map;
+ unsigned int nr_found;
lockdep_assert_held(&ictx->sw_msi_lock);
- list_for_each_entry(cur, &ictx->sw_msi_list, sw_msi_item) {
- if (cur->sw_msi_start != sw_msi_range->start ||
- cur->pgoff >= sw_msi_range->length / PAGE_SIZE)
+ list_for_each_entry(msi_map, &ictx->sw_msi_list, sw_msi_item) {
+ if (msi_map->sw_msi_start != sw_msi_range->start ||
+ msi_map->msi_addr != phys_addrs[0])
+ continue;
+ if (msi_map->range_size != nr_addrs * PAGE_SIZE)
continue;
- if (cur->msi_addr == msi_addr)
- return cur;
+ if (msi_map->pgoff > sw_msi_range->length / PAGE_SIZE ||
+ nr_addrs > sw_msi_range->length / PAGE_SIZE - msi_map->pgoff)
+ continue;
+
+ nr_found = 0;
+ list_for_each_entry(cur, &ictx->sw_msi_list, sw_msi_item) {
+ unsigned int index;
+
+ if (cur->sw_msi_start != sw_msi_range->start ||
+ cur->pgoff < msi_map->pgoff)
+ continue;
+ index = cur->pgoff - msi_map->pgoff;
+ if (index >= nr_addrs)
+ continue;
+ if (cur->msi_addr != phys_addrs[index])
+ break;
+ nr_found++;
+ }
+ if (nr_found == nr_addrs)
+ return msi_map;
}
return NULL;
}
+static int iommufd_sw_msi_check_alloc(struct iommufd_ctx *ictx,
+ const struct iommufd_sw_msi_range *sw_msi_range,
+ unsigned int first_pgoff, unsigned int nr_addrs,
+ size_t *range_size)
+{
+ unsigned long max_iova_pgoff;
+ unsigned int last_pgoff;
+ unsigned int last_id;
+ size_t range_pages;
+
+ if (!nr_addrs)
+ return -EINVAL;
+ if (sw_msi_range->start > ULONG_MAX)
+ return -EOVERFLOW;
+
+ range_pages = sw_msi_range->length / PAGE_SIZE;
+ max_iova_pgoff = (ULONG_MAX - sw_msi_range->start) / PAGE_SIZE;
+
+ if (check_add_overflow(ictx->sw_msi_id, nr_addrs - 1, &last_id) ||
+ last_id > IOMMUFD_SW_MSI_MAX_ID ||
+ check_add_overflow(first_pgoff, nr_addrs - 1, &last_pgoff) ||
+ last_pgoff > max_iova_pgoff ||
+ check_mul_overflow((size_t)nr_addrs, PAGE_SIZE, range_size))
+ return -EOVERFLOW;
+
+ if (last_pgoff >= range_pages)
+ return -ENOSPC;
+
+ return 0;
+}
+
static struct iommufd_sw_msi_map *
-iommufd_sw_msi_alloc_map(struct iommufd_ctx *ictx, phys_addr_t msi_addr,
- const struct iommufd_sw_msi_range *sw_msi_range)
+iommufd_sw_msi_alloc_map(struct iommufd_ctx *ictx, const phys_addr_t *phys_addrs,
+ unsigned int nr_addrs, const struct iommufd_sw_msi_range *sw_msi_range,
+ struct list_head *new_msi_maps)
{
- struct iommufd_sw_msi_map *cur;
- unsigned int max_pgoff = 0;
+ struct iommufd_sw_msi_map *cur, *first_map = NULL;
+ unsigned int next_pgoff = 0;
+ unsigned int i;
+ size_t size;
+ int rc;
lockdep_assert_held(&ictx->sw_msi_lock);
@@ -216,25 +272,38 @@ iommufd_sw_msi_alloc_map(struct iommufd_ctx *ictx, phys_addr_t msi_addr,
continue;
if (cur->pgoff == UINT_MAX)
return ERR_PTR(-EOVERFLOW);
- max_pgoff = max(max_pgoff, cur->pgoff + 1);
+ next_pgoff = max(next_pgoff, cur->pgoff + 1);
}
- if (ictx->sw_msi_id > IOMMUFD_SW_MSI_MAX_ID ||
- max_pgoff > (ULONG_MAX - sw_msi_range->start) / PAGE_SIZE)
- return ERR_PTR(-EOVERFLOW);
- if (max_pgoff >= sw_msi_range->length / PAGE_SIZE)
- return ERR_PTR(-ENOSPC);
-
- cur = kzalloc_obj(*cur);
- if (!cur)
- return ERR_PTR(-ENOMEM);
-
- cur->sw_msi_start = sw_msi_range->start;
- cur->msi_addr = msi_addr;
- cur->pgoff = max_pgoff;
- cur->id = ictx->sw_msi_id++;
- list_add_tail(&cur->sw_msi_item, &ictx->sw_msi_list);
- return cur;
+ rc = iommufd_sw_msi_check_alloc(ictx, sw_msi_range, next_pgoff, nr_addrs, &size);
+ if (rc)
+ return ERR_PTR(rc);
+
+ for (i = 0; i < nr_addrs; i++) {
+ cur = kzalloc_obj(*cur);
+ if (!cur)
+ goto err_free;
+
+ cur->sw_msi_start = sw_msi_range->start;
+ cur->msi_addr = phys_addrs[i];
+ cur->pgoff = next_pgoff + i;
+ cur->id = ictx->sw_msi_id + i;
+ if (!i) {
+ cur->range_size = size;
+ first_map = cur;
+ }
+ list_add_tail(&cur->sw_msi_item, new_msi_maps);
+ }
+
+ return first_map;
+
+err_free:
+ while (!list_empty(new_msi_maps)) {
+ cur = list_first_entry(new_msi_maps, typeof(*cur), sw_msi_item);
+ list_del(&cur->sw_msi_item);
+ kfree(cur);
+ }
+ return ERR_PTR(-ENOMEM);
}
int iommufd_sw_msi_install(struct iommufd_ctx *ictx,
@@ -280,7 +349,9 @@ int iommufd_sw_msi(struct iommu_domain *domain, struct msi_desc *desc,
struct iommufd_attach_handle *handle;
struct iommufd_sw_msi_map *msi_map;
struct iommufd_ctx *ictx;
+ LIST_HEAD(new_msi_maps);
unsigned long iova;
+ phys_addr_t phys_addr;
int rc;
/*
@@ -308,29 +379,41 @@ int iommufd_sw_msi(struct iommu_domain *domain, struct msi_desc *desc,
* assume the caller has checked that it is contained with a MMIO region
* that is secure to map at PAGE_SIZE.
*/
- msi_map = iommufd_sw_msi_get_map(handle->idev->ictx,
- msi_addr & PAGE_MASK,
- &handle->idev->igroup->sw_msi_range);
+ phys_addr = msi_addr & PAGE_MASK;
+ msi_map = iommufd_sw_msi_get_map(ictx, &phys_addr, 1, &handle->idev->igroup->sw_msi_range);
if (!msi_map)
- msi_map = iommufd_sw_msi_alloc_map(handle->idev->ictx,
- msi_addr & PAGE_MASK,
- &handle->idev->igroup->sw_msi_range);
+ msi_map = iommufd_sw_msi_alloc_map(ictx, &phys_addr, 1,
+ &handle->idev->igroup->sw_msi_range,
+ &new_msi_maps);
if (IS_ERR(msi_map))
return PTR_ERR(msi_map);
rc = iommufd_sw_msi_maps_ensure(&handle->idev->igroup->required_sw_msi,
msi_map->id);
if (rc)
- return rc;
+ goto err_free;
rc = iommufd_sw_msi_install(ictx, hwpt_paging, msi_map);
if (rc)
- return rc;
+ goto err_free;
__set_bit(msi_map->id, handle->idev->igroup->required_sw_msi.bitmap);
+ if (!list_empty(&new_msi_maps)) {
+ list_splice_tail_init(&new_msi_maps, &ictx->sw_msi_list);
+ ictx->sw_msi_id++;
+ }
+
iova = msi_map->sw_msi_start + msi_map->pgoff * PAGE_SIZE;
msi_desc_set_iommu_msi_iova(desc, iova, PAGE_SHIFT);
return 0;
+
+err_free:
+ while (!list_empty(&new_msi_maps)) {
+ msi_map = list_first_entry(&new_msi_maps, typeof(*msi_map), sw_msi_item);
+ list_del(&msi_map->sw_msi_item);
+ kfree(msi_map);
+ }
+ return rc;
}
EXPORT_SYMBOL_NS_GPL(iommufd_sw_msi, "IOMMUFD");
#endif
diff --git a/drivers/iommu/iommufd/iommufd_private.h b/drivers/iommu/iommufd/iommufd_private.h
index 4e2d32809695..797965557281 100644
--- a/drivers/iommu/iommufd/iommufd_private.h
+++ b/drivers/iommu/iommufd/iommufd_private.h
@@ -33,6 +33,7 @@ struct iommufd_sw_msi_map {
phys_addr_t msi_addr;
unsigned int pgoff;
unsigned int id;
+ size_t range_size; /* IOVA range size, or 0 if not the first map */
};
/* Bitmap of struct iommufd_sw_msi_map::id; starts empty, grows on demand. */
--
2.43.0
More information about the linux-riscv
mailing list