iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

vfio: remove the unused mdev iommu hook

Browse Source 
The iommu_device field in struct mdev_device has never been used
since it was added more than 2 years ago.

This is a manual revert of commit 7bd50f0cd2
("vfio/type1: Add domain at(de)taching group helpers").

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Jason Gunthorpe <jgg@nvidia.com>
Reviewed-by: Kevin Tian <kevin.tian@intel.com>
Link: https://lore.kernel.org/r/20210924155705.4258-11-hch@lst.de
Signed-off-by: Alex Williamson <alex.williamson@redhat.com>
This commit is contained in:
Christoph Hellwig 2021-09-24 17:57:00 +02:00 committed by Alex Williamson
parent 8cc02d22d7
commit fda49d97f2
2 changed files with 26 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
drivers/vfio/vfio_iommu_type1.c
View File

@ -114,7 +114,6 @@ struct vfio_batch {
struct vfio_iommu_group { struct vfio_iommu_group {
struct iommu_group *iommu_group; struct iommu_group *iommu_group;
struct list_head next; struct list_head next;
bool mdev_group; /* An mdev group */
bool pinned_page_dirty_scope; bool pinned_page_dirty_scope;
}; };
@ -1935,61 +1934,6 @@ static bool vfio_iommu_has_sw_msi(struct list_head *group_resv_regions,
return ret; return ret;
} }
static int vfio_mdev_attach_domain(struct device *dev, void *data)
{
struct mdev_device *mdev = to_mdev_device(dev);
struct iommu_domain *domain = data;
struct device *iommu_device;
iommu_device = mdev_get_iommu_device(mdev);
if (iommu_device) {
if (iommu_dev_feature_enabled(iommu_device, IOMMU_DEV_FEAT_AUX))
return iommu_aux_attach_device(domain, iommu_device);
else
return iommu_attach_device(domain, iommu_device);
}
return -EINVAL;
}
static int vfio_mdev_detach_domain(struct device *dev, void *data)
{
struct mdev_device *mdev = to_mdev_device(dev);
struct iommu_domain *domain = data;
struct device *iommu_device;
iommu_device = mdev_get_iommu_device(mdev);
if (iommu_device) {
if (iommu_dev_feature_enabled(iommu_device, IOMMU_DEV_FEAT_AUX))
iommu_aux_detach_device(domain, iommu_device);
else
iommu_detach_device(domain, iommu_device);
}
return 0;
}
static int vfio_iommu_attach_group(struct vfio_domain *domain,
struct vfio_iommu_group *group)
{
if (group->mdev_group)
return iommu_group_for_each_dev(group->iommu_group,
domain->domain,
vfio_mdev_attach_domain);
else
return iommu_attach_group(domain->domain, group->iommu_group);
}
static void vfio_iommu_detach_group(struct vfio_domain *domain,
struct vfio_iommu_group *group)
{
if (group->mdev_group)
iommu_group_for_each_dev(group->iommu_group, domain->domain,
vfio_mdev_detach_domain);
else
iommu_detach_group(domain->domain, group->iommu_group);
}
static bool vfio_bus_is_mdev(struct bus_type *bus) static bool vfio_bus_is_mdev(struct bus_type *bus)
{ {
struct bus_type *mdev_bus; struct bus_type *mdev_bus;
@ -2004,20 +1948,6 @@ static bool vfio_bus_is_mdev(struct bus_type *bus)
return ret; return ret;
} }
static int vfio_mdev_iommu_device(struct device *dev, void *data)
{
struct mdev_device *mdev = to_mdev_device(dev);
struct device **old = data, *new;
new = mdev_get_iommu_device(mdev);
if (!new || (*old && *old != new))
return -EINVAL;
*old = new;
return 0;
}
/* /*
* This is a helper function to insert an address range to iova list. * This is a helper function to insert an address range to iova list.
* The list is initially created with a single entry corresponding to * The list is initially created with a single entry corresponding to
@ -2278,38 +2208,25 @@ static int vfio_iommu_type1_attach_group(void *iommu_data,
goto out_free; goto out_free;
if (vfio_bus_is_mdev(bus)) { if (vfio_bus_is_mdev(bus)) {
struct device *iommu_device = NULL; if (!iommu->external_domain) {
INIT_LIST_HEAD(&domain->group_list);
group->mdev_group = true; iommu->external_domain = domain;
vfio_update_pgsize_bitmap(iommu);
/* Determine the isolation type */ } else {
ret = iommu_group_for_each_dev(iommu_group, &iommu_device, kfree(domain);
vfio_mdev_iommu_device);
if (ret || !iommu_device) {
if (!iommu->external_domain) {
INIT_LIST_HEAD(&domain->group_list);
iommu->external_domain = domain;
vfio_update_pgsize_bitmap(iommu);
} else {
kfree(domain);
}
list_add(&group->next,
&iommu->external_domain->group_list);
/*
* Non-iommu backed group cannot dirty memory directly,
* it can only use interfaces that provide dirty
* tracking.
* The iommu scope can only be promoted with the
* addition of a dirty tracking group.
*/
group->pinned_page_dirty_scope = true;
mutex_unlock(&iommu->lock);
return 0;
} }
bus = iommu_device->bus; list_add(&group->next, &iommu->external_domain->group_list);
/*
* Non-iommu backed group cannot dirty memory directly, it can
* only use interfaces that provide dirty tracking.
* The iommu scope can only be promoted with the addition of a
* dirty tracking group.
*/
group->pinned_page_dirty_scope = true;
mutex_unlock(&iommu->lock);
return 0;
} }
domain->domain = iommu_domain_alloc(bus); domain->domain = iommu_domain_alloc(bus);
@ -2324,7 +2241,7 @@ static int vfio_iommu_type1_attach_group(void *iommu_data,
goto out_domain; goto out_domain;
} }
ret = vfio_iommu_attach_group(domain, group); ret = iommu_attach_group(domain->domain, group->iommu_group);
if (ret) if (ret)
goto out_domain; goto out_domain;
@ -2391,15 +2308,17 @@ static int vfio_iommu_type1_attach_group(void *iommu_data,
list_for_each_entry(d, &iommu->domain_list, next) { list_for_each_entry(d, &iommu->domain_list, next) {
if (d->domain->ops == domain->domain->ops && if (d->domain->ops == domain->domain->ops &&
d->prot == domain->prot) { d->prot == domain->prot) {
vfio_iommu_detach_group(domain, group); iommu_detach_group(domain->domain, group->iommu_group);
if (!vfio_iommu_attach_group(d, group)) { if (!iommu_attach_group(d->domain,
group->iommu_group)) {
list_add(&group->next, &d->group_list); list_add(&group->next, &d->group_list);
iommu_domain_free(domain->domain); iommu_domain_free(domain->domain);
kfree(domain); kfree(domain);
goto done; goto done;
} }
ret = vfio_iommu_attach_group(domain, group); ret = iommu_attach_group(domain->domain,
group->iommu_group);
if (ret) if (ret)
goto out_domain; goto out_domain;
} }
@ -2436,7 +2355,7 @@ done:
return 0; return 0;
out_detach: out_detach:
vfio_iommu_detach_group(domain, group); iommu_detach_group(domain->domain, group->iommu_group);
out_domain: out_domain:
iommu_domain_free(domain->domain); iommu_domain_free(domain->domain);
vfio_iommu_iova_free(&iova_copy); vfio_iommu_iova_free(&iova_copy);
@ -2601,7 +2520,7 @@ static void vfio_iommu_type1_detach_group(void *iommu_data,
if (!group) if (!group)
continue; continue;
vfio_iommu_detach_group(domain, group); iommu_detach_group(domain->domain, group->iommu_group);
update_dirty_scope = !group->pinned_page_dirty_scope; update_dirty_scope = !group->pinned_page_dirty_scope;
list_del(&group->next); list_del(&group->next);
kfree(group); kfree(group);
@ -2689,7 +2608,7 @@ static void vfio_release_domain(struct vfio_domain *domain, bool external)
list_for_each_entry_safe(group, group_tmp, list_for_each_entry_safe(group, group_tmp,
&domain->group_list, next) { &domain->group_list, next) {
if (!external) if (!external)
vfio_iommu_detach_group(domain, group); iommu_detach_group(domain->domain, group->iommu_group);
list_del(&group->next); list_del(&group->next);
kfree(group); kfree(group);
} }

20
include/linux/mdev.h
View File

@ -18,7 +18,6 @@ struct mdev_device {
void *driver_data; void *driver_data;
struct list_head next; struct list_head next;
struct mdev_type *type; struct mdev_type *type;
struct device *iommu_device;
bool active; bool active;
}; };
@ -27,25 +26,6 @@ static inline struct mdev_device *to_mdev_device(struct device *dev)
return container_of(dev, struct mdev_device, dev); return container_of(dev, struct mdev_device, dev);
} }
/*
* Called by the parent device driver to set the device which represents
* this mdev in iommu protection scope. By default, the iommu device is
* NULL, that indicates using vendor defined isolation.
*
* @dev: the mediated device that iommu will isolate.
* @iommu_device: a pci device which represents the iommu for @dev.
*/
static inline void mdev_set_iommu_device(struct mdev_device *mdev,
struct device *iommu_device)
{
mdev->iommu_device = iommu_device;
}
static inline struct device *mdev_get_iommu_device(struct mdev_device *mdev)
{
return mdev->iommu_device;
}
unsigned int mdev_get_type_group_id(struct mdev_device *mdev); unsigned int mdev_get_type_group_id(struct mdev_device *mdev);
unsigned int mtype_get_type_group_id(struct mdev_type *mtype); unsigned int mtype_get_type_group_id(struct mdev_type *mtype);
struct device *mtype_get_parent_dev(struct mdev_type *mtype); struct device *mtype_get_parent_dev(struct mdev_type *mtype);