iommu: Refactoring domain allocation interface
Subsystems (29)
Lu Baolu
maintainerv2 cover iommu: Refactoring domain allocation interface
The IOMMU subsystem has undergone some changes, including the removal of iommu_ops from the bus structure. Consequently, the existing domain allocation interface, which relies on a bus type argument, is no longer relevant:
struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
This series is designed to refactor the use of this interface. It proposes two new interfaces to replace iommu_domain_alloc():
- iommu_user_domain_alloc(): This interface is intended for allocating iommu domains managed by userspace for device passthrough scenarios, such as those used by iommufd, vfio, and vdpa. It clearly indicates that the domain is for user-managed device DMA.
If an IOMMU driver does not implement iommu_ops->domain_alloc_user, this interface will rollback to the generic paging domain allocation.
- iommu_paging_domain_alloc(): This interface is for allocating iommu domains managed by kernel drivers for kernel DMA purposes. It takes a device pointer as a parameter, which better reflects the current design of the IOMMU subsystem.
The majority of device drivers currently using iommu_domain_alloc() do so to allocate a domain for a specific device and then attach that domain to the device. These cases can be straightforwardly migrated to the new interfaces.
The drm/tegra driver is a bit different in that the device pointer passed to the helper, which allocates the iommu domain, is not the one that will be used for the kernel DMA API. Move the existing logic in iommu_domain_alloc() into the driver to ensure it works as intended.
Now that all consumers of iommu_domain_alloc() have switched to the new interfaces, we can finally remove iommu_domain_alloc(). This removal paves the way for the IOMMU subsystem to support multiple iommu drivers. Additionally, the individual iommu driver implementation for domain allocation could also be simplified, as there will always be a valid device pointer passed along the path.
The whole series is also available on GitHub:
https://github.com/LuBaolu/intel-iommu/commits/iommu-domain-allocation-refactor-v2
Change log:
v2:
- Drop the vt-d patches which implement paging domain support from this series. I will post them in a separate series later.
- Convert all drivers that call iommu_domain_alloc() to use the new interface and remove iommu_domain_alloc() from the tree.
- For the drm/msm driver, make the code compatible with the no-IOMMU case.
- Various cleanups and refinements.
v1: https://lore.kernel.org/linux-iommu/[email protected]/
Lu Baolu (21):
iommu: Add iommu_user_domain_alloc() interface
iommufd: Use iommu_user_domain_alloc() vfio/type1: Use iommu_user_domain_alloc()
vhost-vdpa: Use iommu_user_domain_alloc()
iommu: Add iommu_paging_domain_alloc() interface drm/msm: Use iommu_paging_domain_alloc() drm/nouveau/tegra: Use iommu_paging_domain_alloc()
gpu: host1x: Use iommu_paging_domain_alloc()
media: nvidia: tegra: Use iommu_paging_domain_alloc()
media: venus: firmware: Use iommu_paging_domain_alloc()
ath10k: Use iommu_paging_domain_alloc()
wifi: ath11k: Use iommu_paging_domain_alloc()
remoteproc: Use iommu_paging_domain_alloc() soc/fsl/qbman: Use iommu_paging_domain_alloc() RDMA/usnic: Use iommu_paging_domain_alloc() iommu/vt-d: Add helper to allocate paging domain
ARM: dma-mapping: Use iommu_paging_domain_alloc() drm/rockchip: Use iommu_paging_domain_alloc() drm/tegra: Remove call to iommu_domain_alloc()
iommu: Remove iommu_present()
iommu: Remove iommu_domain_alloc()
Robin Murphy (1):
ARM: dma-mapping: Pass device to arm_iommu_create_mapping()
include/linux/iommu.h | 18 +-- arch/arm/include/asm/dma-iommu.h | 2 +- arch/arm/mm/dma-mapping.c | 12 +- drivers/gpu/drm/exynos/exynos_drm_dma.c | 2 +- drivers/gpu/drm/msm/msm_iommu.c | 7 +- .../drm/nouveau/nvkm/engine/device/tegra.c | 4 +- drivers/gpu/drm/rockchip/rockchip_drm_drv.c | 10 +- drivers/gpu/drm/tegra/drm.c | 34 ++++-- drivers/gpu/host1x/dev.c | 7 +- drivers/infiniband/hw/usnic/usnic_uiom.c | 6 +- drivers/iommu/intel/iommu.c | 87 +++++++++++++-- drivers/iommu/iommu.c | 103 +++++++++--------- drivers/iommu/iommufd/hw_pagetable.c | 20 +--- drivers/iommu/ipmmu-vmsa.c | 3 +- drivers/iommu/mtk_iommu_v1.c | 3 +- .../media/platform/nvidia/tegra-vde/iommu.c | 7 +- drivers/media/platform/qcom/venus/firmware.c | 6 +- drivers/media/platform/ti/omap3isp/isp.c | 2 +- drivers/net/wireless/ath/ath10k/snoc.c | 6 +- drivers/net/wireless/ath/ath11k/ahb.c | 6 +- drivers/remoteproc/remoteproc_core.c | 6 +- drivers/soc/fsl/qbman/qman_portal.c | 5 +- drivers/vfio/vfio_iommu_type1.c | 7 +- drivers/vhost/vdpa.c | 14 +-- 24 files changed, 231 insertions(+), 146 deletions(-)
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v2 1/22 iommu: Add iommu_user_domain_alloc() interface
Commit <909f4abd1097> ("iommu: Add new iommu op to create domains owned by userspace") added a dedicated iommu op to allocate a user domain. While IOMMUFD has already made use of this callback, other frameworks like vfio/type1 and vDPA still use the paging domain allocation interface.
Add a new interface named iommu_user_domain_alloc(), which indicates the allocation of a domain for device DMA managed by user space driver. All device passthrough frameworks could use this interface for their domain allocation.
Although it is expected that all iommu drivers could implement their own domain_alloc_user ops, most drivers haven't implemented it yet. Rollback to the paging domain allocation interface if the iommu driver hasn't implemented this op yet.
--- include/linux/iommu.h | 6 ++++++ drivers/iommu/iommu.c | 42 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 48 insertions(+)
include/linux/iommu.h +6 -0
@@ -780,6 +780,7 @@ extern bool iommu_present(const struct bus_type *bus);extern bool device_iommu_capable (struct device *dev,enum iommu_cap cap);extern bool iommu_group_has_isolated_msi (struct iommu_group *group);extern struct iommu_domain *iommu_domain_alloc (const struct bus_type *bus); +struct iommu_domain *iommu_user_domain_alloc (struct device *dev,u32 flags);extern void iommu_domain_free (struct iommu_domain *domain);extern int iommu_attach_device (struct iommu_domain *domain,struct device *dev);
@@ -1086,6 +1087,11 @@ static inline struct iommu_domain *iommu_domain_alloc(const struct bus_type *busreturn NULL ; } +static inline struct iommu_domain *iommu_user_domain_alloc (struct device *dev,u32 flags) +{ +return ERR_PTR (-ENODEV ); +} +static inline void iommu_domain_free (struct iommu_domain *domain) { }
drivers/iommu/iommu.c +42 -0
48 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCH v2 01/22] iommu: Add iommu_user_domain_alloc() interface
Quoted 50 lines · Lu Baolu
Commit <
909f4abd1097> ("iommu: Add new iommu op to create domains owned by userspace") added a dedicated iommu op to allocate a user domain. While IOMMUFD has already made use of this callback, other frameworks like vfio/type1 and vDPA still use the paging domain allocation interface.Add a new interface named
iommu_user_domain_alloc(), which indicates the allocation of a domain for device DMA managed by user space driver. All device passthrough frameworks could use this interface for their domain allocation.Although it is expected that all iommu drivers could implement their own
domain_alloc_userops, most drivers haven't implemented it yet. Rollback to the paging domain allocation interface if the iommu driver hasn't implemented this op yet.Signed-off-by Lu Baolu <[email protected]>--- include/linux/iommu.h | 6 ++++++ drivers/iommu/iommu.c | 42 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 48 insertions(+)include/linux/iommu.h +6
-0@@ -780,6 +780,7 @@ extern bool iommu_present(const struct bus_type *bus);extern bool device_iommu_capable (struct device *dev,enum iommu_cap cap);extern bool iommu_group_has_isolated_msi (struct iommu_group *group);extern struct iommu_domain *iommu_domain_alloc (const struct bus_type *bus); +struct iommu_domain *iommu_user_domain_alloc (struct device *dev,u32 flags);extern void iommu_domain_free (struct iommu_domain *domain);extern int iommu_attach_device (struct iommu_domain *domain,struct device *dev);@@ -1086,6 +1087,11 @@ static inline struct iommu_domain *iommu_domain_alloc(const struct bus_type *busreturn NULL ; } +static inline struct iommu_domain *iommu_user_domain_alloc (struct device *dev,u32 flags) +{ +return ERR_PTR (-ENODEV ); +} +static inline void iommu_domain_free (struct iommu_domain *domain) { }drivers/iommu/iommu.c +0
-0
drivers/iommu/iommu.c struct iommu_domain *iommu_domain_alloc(const struct bus_type *bus) · line 2041
Quoted 10 lines
drivers/iommu/iommu.c +7
-0@@ -2032,6 +2032,48 @@ struct iommu_domain *iommu_domain_alloc(const struct bus_type *bus) }EXPORT_SYMBOL_GPL (iommu_domain_alloc); +/** +* iommu_user_domain_alloc() - Allocate a user domain +* @dev: device for which the domain is allocated +* @flags: iommufd_hwpt_alloc_flags defined in uapi/linux/iommufd.h +* +* Allocate a user domain which will be managed by a userspace driver. Return +* allocated domain if successful, or a ERR pointer for failure.
do you want to mention that this is for paging domain allocation?
Quoted 8 lines
drivers/iommu/iommu.c +8
-0+*/ +struct iommu_domain *iommu_user_domain_alloc (struct device *dev,u32 flags) +{ +struct iommu_domain *domain; +const struct iommu_ops *ops; + +if (!dev_has_iommu (dev)) +return ERR_PTR (-ENODEV );
drivers/iommu/iommu.c struct iommu_domain *iommu_domain_alloc(const struct bus_type *bus) · line 2059
Quoted 10 lines
drivers/iommu/iommu.c +10
-0+ + ops =dev_iommu_ops (dev); +if (ops->domain_alloc_user) { + domain = ops->domain_alloc_user (dev, flags,NULL ,NULL ); +if (IS_ERR (domain)) +return domain; + + domain->type =IOMMU_DOMAIN_UNMANAGED ; + domain->owner = ops; + domain->pgsize_bitmap = ops->pgsize_bitmap;
this seems to break the iommufd selftest as the mock driver sets extra bits in the domain->pgsize_bitmap in allocation. Override it may fail something in the testing. you may need to check if domain->pgsize_bitmap is set or use &=.
static struct iommu_domain *mock_domain_alloc_paging(struct device *dev)
{
struct mock_dev *mdev = container_of(dev, struct mock_dev, dev);
struct mock_iommu_domain *mock;
mock = kzalloc(sizeof(*mock), GFP_KERNEL);
if (!mock)
return NULL;
mock->domain.geometry.aperture_start = MOCK_APERTURE_START;
mock->domain.geometry.aperture_end = MOCK_APERTURE_LAST;
mock->domain.pgsize_bitmap = MOCK_IO_PAGE_SIZE;
if (dev && mdev->flags & MOCK_FLAGS_DEVICE_HUGE_IOVA)
mock->domain.pgsize_bitmap |= MOCK_HUGE_PAGE_SIZE;
mock->domain.ops = mock_ops.default_domain_ops;
mock->domain.type = IOMMU_DOMAIN_UNMANAGED;
xa_init(&mock->pfns);
return &mock->domain;
}Quoted 20 lines
drivers/iommu/iommu.c +17
-0+ domain->ops = ops->default_domain_ops; + +return domain; + } + +/* +* The iommu driver doesn't support domain_alloc_user callback. +* Rollback to a UNMANAGED paging domain which doesn't support +* the allocation flags. +*/ +if (flags) +return ERR_PTR (-EOPNOTSUPP ); + +return __iommu_domain_alloc (ops, dev,IOMMU_DOMAIN_UNMANAGED ); +} +EXPORT_SYMBOL_GPL (iommu_user_domain_alloc); +void iommu_domain_free (struct iommu_domain *domain) {if (domain->type ==IOMMU_DOMAIN_SVA )
Signature · 2 lines
Regards, Yi Liu
Baolu Lu
maintainerRe: [PATCH v2 01/22] iommu: Add iommu_user_domain_alloc() interface
Quoted 59 lines · Yi Liu
Quoted 58 lines · Lu Baolu
Commit <
909f4abd1097> ("iommu: Add new iommu op to create domains owned by userspace") added a dedicated iommu op to allocate a user domain. While IOMMUFD has already made use of this callback, other frameworks like vfio/type1 and vDPA still use the paging domain allocation interface.Add a new interface named
iommu_user_domain_alloc(), which indicates the allocation of a domain for device DMA managed by user space driver. All device passthrough frameworks could use this interface for their domain allocation.Although it is expected that all iommu drivers could implement their own
domain_alloc_userops, most drivers haven't implemented it yet. Rollback to the paging domain allocation interface if the iommu driver hasn't implemented this op yet.Signed-off-by Lu Baolu <[email protected]>---
include/linux/iommu.h| 6 ++++++
drivers/iommu/iommu.c| 42 ++++++++++++++++++++++++++++++++++++++++++2 files changed, 48 insertions(+)include/linux/iommu.h +1
-0@@ -780,6 +780,7 @@ extern bool iommu_present(const struct bus_type *bus); extern bool device_iommu_capable(struct device *dev, enum iommu_cap cap); extern bool iommu_group_has_isolated_msi(struct iommu_group *group); extern struct iommu_domain *iommu_domain_alloc(const struct bus_type *bus); +struct iommu_domain *iommu_user_domain_alloc (struct device *dev,u32 flags); extern void iommu_domain_free(struct iommu_domain *domain);extern int
iommu_attach_device(struct iommu_domain *domain, struct device *dev);include/linux/iommu.h +5
-0@@ -1086,6 +1087,11 @@ static inline struct iommu_domain *iommu_domain_alloc(const struct bus_type *bus return NULL; } +static inline struct iommu_domain *iommu_user_domain_alloc (struct device *dev,u32 flags) +{ + return ERR_PTR(-ENODEV); +} + static inline void iommu_domain_free(struct iommu_domain *domain) {}
drivers/iommu/iommu.c +2
-0@@ -2032,6 +2032,48 @@ struct iommu_domain *iommu_domain_alloc(const struct bus_type *bus) } EXPORT_SYMBOL_GPL(iommu_domain_alloc); +/** +* iommu_user_domain_alloc() - Allocate a user domain
Quoted 8 lines
Quoted 6 lines
drivers/iommu/iommu.c +4
-0+* @dev: device for which the domain is allocated +* @flags: iommufd_hwpt_alloc_flags defined in uapi/linux/iommufd.h +* +* Allocate a user domain which will be managed by a userspace driver. Return
+ * allocated domain if successful, or a ERR pointer for failure.do you want to mention that this is for paging domain allocation?
You are worrying about its confusion with nesting domain allocation, right? My understanding is that if we want a common interface for nesting domain allocation, we should make it in another interface. Here, the user domain is a paging domain for GVA->HPA mapping, which is common across iommufd, vfio, and vdpa.
Quoted 31 lines
Quoted 10 lines
+ */
+structiommu_domain*iommu_user_domain_alloc(struct device *dev, u32 flags)drivers/iommu/iommu.c +6
-0+{ + struct iommu_domain *domain; + const struct iommu_ops *ops; + + if (!dev_has_iommu(dev)) + return ERR_PTR(-ENODEV);drivers/iommu/iommu.c struct iommu_domain *iommu_domain_alloc(const struct bus_type *bus) · line 2059
Quoted 10 lines
drivers/iommu/iommu.c +10
-0+ + ops = dev_iommu_ops(dev); + if (ops->domain_alloc_user) { + domain = ops->domain_alloc_user(dev, flags, NULL, NULL); + if (IS_ERR(domain)) + return domain; + + domain->type = IOMMU_DOMAIN_UNMANAGED; + domain->owner = ops; + domain->pgsize_bitmap = ops->pgsize_bitmap;this seems to break the iommufd selftest as the mock driver sets extra bits in the
domain->pgsize_bitmapin allocation. Override it may fail something in the testing. you may need to check ifdomain->pgsize_bitmapis set or use &=.static struct
iommu_domain*mock_domain_alloc_paging(struct device *dev) {
structmock_dev*mdev =container_of(dev, struct mock_dev, dev); structmock_iommu_domain*mock;
Quoted 13 lines
mock =
kzalloc(sizeof(*mock), GFP_KERNEL);
if (!mock)
return NULL;mock->domain.geometry.aperture_start=MOCK_APERTURE_START;mock->domain.geometry.aperture_end=MOCK_APERTURE_LAST;mock->domain.pgsize_bitmap=MOCK_IO_PAGE_SIZE; if (dev &&mdev->flags&MOCK_FLAGS_DEVICE_HUGE_IOVA)mock->domain.pgsize_bitmap|=MOCK_HUGE_PAGE_SIZE;mock->domain.ops= mock_ops.default_domain_ops;mock->domain.type=IOMMU_DOMAIN_UNMANAGED;xa_init(&mock->pfns);
return&mock->domain;
}
You are right. I should follow the code in __iommu_domain_alloc()
/*
* If not already set, assume all sizes by default; the driver
* may override this later
*/
if (!domain->pgsize_bitmap)
domain->pgsize_bitmap = ops->pgsize_bitmap;Does it work?
Best regards,
baolu
Re: [PATCH v2 01/22] iommu: Add iommu_user_domain_alloc() interface
Quoted 68 lines · Baolu Lu
Quoted 58 lines · Yi Liu
Quoted 57 lines · Lu Baolu
Commit <
909f4abd1097> ("iommu: Add new iommu op to create domains owned by userspace") added a dedicated iommu op to allocate a user domain. While IOMMUFD has already made use of this callback, other frameworks like vfio/type1 and vDPA still use the paging domain allocation interface.Add a new interface named
iommu_user_domain_alloc(), which indicates the allocation of a domain for device DMA managed by user space driver. All device passthrough frameworks could use this interface for their domain allocation.Although it is expected that all iommu drivers could implement their own
domain_alloc_userops, most drivers haven't implemented it yet. Rollback to the paging domain allocation interface if the iommu driver hasn't implemented this op yet.Signed-off-by Lu Baolu <[email protected]>---
include/linux/iommu.h| 6 ++++++
drivers/iommu/iommu.c| 42 ++++++++++++++++++++++++++++++++++++++++++2 files changed, 48 insertions(+)include/linux/iommu.h +1
-0@@ -780,6 +780,7 @@ extern bool iommu_present(const struct bus_type *bus); extern bool device_iommu_capable(struct device *dev, enum iommu_cap cap); extern bool iommu_group_has_isolated_msi(struct iommu_group *group); extern struct iommu_domain *iommu_domain_alloc(const struct bus_type *bus); +struct iommu_domain *iommu_user_domain_alloc (struct device *dev,u32 flags); extern void iommu_domain_free(struct iommu_domain *domain); extern int iommu_attach_device(struct iommu_domain *domain,struct device *dev);
include/linux/iommu.h +5
-0@@ -1086,6 +1087,11 @@ static inline struct iommu_domain *iommu_domain_alloc(const struct bus_type *bus return NULL; } +static inline struct iommu_domain *iommu_user_domain_alloc (struct device *dev,u32 flags) +{ + return ERR_PTR(-ENODEV); +} + static inline void iommu_domain_free(struct iommu_domain *domain) {}
drivers/iommu/iommu.c +2
-0@@ -2032,6 +2032,48 @@ struct iommu_domain *iommu_domain_alloc(const struct bus_type *bus) } EXPORT_SYMBOL_GPL(iommu_domain_alloc); +/** +* iommu_user_domain_alloc() - Allocate a user domain Quoted 8 lines
Quoted 6 lines
drivers/iommu/iommu.c +4
-0+* @dev: device for which the domain is allocated +* @flags: iommufd_hwpt_alloc_flags defined in uapi/linux/iommufd.h +* +* Allocate a user domain which will be managed by a userspace driver. Return
+ * allocated domain if successful, or a ERR pointer for failure.do you want to mention that this is for paging domain allocation?
Quoted 2 lines
You are worrying about its confusion with nesting domain allocation, right?
yes. As I replied in last version, user_domain is a bit confusing since nested domain is also a user_domain. That's why we introduced the alloc_domain_user op.
Quoted 4 lines
My understanding is that if we want a common interface for nesting domain allocation, we should make it in another interface. Here, the user domain is a paging domain for
GVA->HPAmapping, which is common across iommufd, vfio, and vdpa.
do you mean user_domain only includes paging domain?
Quoted 47 lines
Quoted 31 lines
Quoted 10 lines
+ */
+structiommu_domain*iommu_user_domain_alloc(struct device *dev, u32 flags)drivers/iommu/iommu.c +6
-0+{ + struct iommu_domain *domain; + const struct iommu_ops *ops; + + if (!dev_has_iommu(dev)) + return ERR_PTR(-ENODEV);drivers/iommu/iommu.c struct iommu_domain *iommu_domain_alloc(const struct bus_type *bus) · line 2059
Quoted 10 lines
drivers/iommu/iommu.c +10
-0+ + ops = dev_iommu_ops(dev); + if (ops->domain_alloc_user) { + domain = ops->domain_alloc_user(dev, flags, NULL, NULL); + if (IS_ERR(domain)) + return domain; + + domain->type = IOMMU_DOMAIN_UNMANAGED; + domain->owner = ops; + domain->pgsize_bitmap = ops->pgsize_bitmap;this seems to break the iommufd selftest as the mock driver sets extra bits in the
domain->pgsize_bitmapin allocation. Override it may fail something in the testing. you may need to check ifdomain->pgsize_bitmapis set or use &=.static struct
iommu_domain*mock_domain_alloc_paging(struct device *dev) {
structmock_dev*mdev =container_of(dev, struct mock_dev, dev); structmock_iommu_domain*mock;Quoted 13 lines
mock =
kzalloc(sizeof(*mock), GFP_KERNEL);
if (!mock)
return NULL;mock->domain.geometry.aperture_start=MOCK_APERTURE_START;mock->domain.geometry.aperture_end=MOCK_APERTURE_LAST;mock->domain.pgsize_bitmap=MOCK_IO_PAGE_SIZE; if (dev &&mdev->flags&MOCK_FLAGS_DEVICE_HUGE_IOVA)mock->domain.pgsize_bitmap|=MOCK_HUGE_PAGE_SIZE;mock->domain.ops= mock_ops.default_domain_ops;mock->domain.type=IOMMU_DOMAIN_UNMANAGED;xa_init(&mock->pfns);
return&mock->domain;
}You are right. I should follow the code in
__iommu_domain_alloc()
Quoted 8 lines
/*
* If not already set, assume all sizes by default; the driver
* may override this later
*/
if (!domain->pgsize_bitmap)
domain->pgsize_bitmap=ops->pgsize_bitmap;Does it work?
I think so. This should work.
Signature · 2 lines
Regards, Yi Liu
Baolu Lu
maintainerRe: [PATCH v2 01/22] iommu: Add iommu_user_domain_alloc() interface
Quoted 70 lines · Yi Liu
Quoted 69 lines · Baolu Lu
Quoted 67 lines · Yi Liu
Quoted 62 lines · Lu Baolu
Commit <
909f4abd1097> ("iommu: Add new iommu op to create domains owned by userspace") added a dedicated iommu op to allocate a user domain. While IOMMUFD has already made use of this callback, other frameworks like vfio/type1 and vDPA still use the paging domain allocation interface.Add a new interface named
iommu_user_domain_alloc(), which indicates the allocation of a domain for device DMA managed by user space driver. All device passthrough frameworks could use this interface for their domain allocation.Although it is expected that all iommu drivers could implement their own
domain_alloc_userops, most drivers haven't implemented it yet. Rollback to the paging domain allocation interface if the iommu driver hasn't implemented this op yet.Signed-off-by Lu Baolu <[email protected]>---
include/linux/iommu.h| 6 ++++++
drivers/iommu/iommu.c| 42 ++++++++++++++++++++++++++++++++++++++++++2 files changed, 48 insertions(+)include/linux/iommu.h +1
-0@@ -780,6 +780,7 @@ extern bool iommu_present(const struct bus_type *bus); extern bool device_iommu_capable(struct device *dev, enum iommu_cap cap); extern bool iommu_group_has_isolated_msi(struct iommu_group *group); extern struct iommu_domain *iommu_domain_alloc(const struct bus_type *bus); +struct iommu_domain *iommu_user_domain_alloc (struct device *dev,u32 flags); extern void iommu_domain_free(struct iommu_domain *domain);extern int
iommu_attach_device(struct iommu_domain *domain, struct device *dev);include/linux/iommu.h +5
-0@@ -1086,6 +1087,11 @@ static inline struct iommu_domain *iommu_domain_alloc(const struct bus_type *bus return NULL; } +static inline struct iommu_domain *iommu_user_domain_alloc (struct device *dev,u32 flags) +{ + return ERR_PTR(-ENODEV); +} + static inline void iommu_domain_free(struct iommu_domain *domain) {}
drivers/iommu/iommu.c +6
-0@@ -2032,6 +2032,48 @@ struct iommu_domain *iommu_domain_alloc(const struct bus_type *bus) } EXPORT_SYMBOL_GPL(iommu_domain_alloc); +/** +* iommu_user_domain_alloc() - Allocate a user domain +* @dev: device for which the domain is allocated +* @flags: iommufd_hwpt_alloc_flags defined in uapi/linux/iommufd.h +* +* Allocate a user domain which will be managed by a userspace Quoted 2 lines
driver. Return
+ * allocated domain if successful, or a ERR pointer for failure.do you want to mention that this is for paging domain allocation?
Quoted 6 lines
Quoted 2 lines
You are worrying about its confusion with nesting domain allocation, right?
yes. As I replied in last version,
user_domainis a bit confusing since nested domain is also auser_domain. That's why we introduced thealloc_domain_userop.
As I discussed with Jason in another reply, I will drop the iommu_user_domain_alloc() interface as it is currently iommfd-specific only and not generic for a common interface.
Best regards,
baolu
Lu Baolu
maintainerPATCH v2 2/22 iommufd: Use iommu_user_domain_alloc()
In reply to Lu BaoluReplace iommu_domain_alloc() with iommu_user_domain_alloc().
--- drivers/iommu/iommufd/hw_pagetable.c | 20 +++++--------------- 1 file changed, 5 insertions(+), 15 deletions(-)
drivers/iommu/iommufd/hw_pagetable.c +5 -15
@@ -127,21 +127,11 @@ iommufd_hwpt_paging_alloc(struct iommufd_ctx *ictx, struct iommufd_ioas *ioas, hwpt_paging->ioas = ioas; hwpt_paging->nest_parent = flags &IOMMU_HWPT_ALLOC_NEST_PARENT ; -if (ops->domain_alloc_user) { - hwpt->domain = ops->domain_alloc_user (idev->dev, flags,NULL , - user_data); -if (IS_ERR (hwpt->domain)) { - rc =PTR_ERR (hwpt->domain); - hwpt->domain =NULL ; - goto out_abort; - } - hwpt->domain->owner = ops; - }else { - hwpt->domain =iommu_domain_alloc (idev->dev->bus); -if (!hwpt->domain) { - rc = -ENOMEM ; - goto out_abort; - } + hwpt->domain =iommu_user_domain_alloc (idev->dev, flags); +if (IS_ERR (hwpt->domain)) { + rc =PTR_ERR (hwpt->domain); + hwpt->domain =NULL ; + goto out_abort; }/*
Signature · 1 line
2.34.1
Re: [PATCH v2 02/22] iommufd: Use iommu_user_domain_alloc()
Quoted 12 lines · Lu Baolu
Replace
iommu_domain_alloc()withiommu_user_domain_alloc().Signed-off-by Lu Baolu <[email protected]>--- drivers/iommu/iommufd/hw_pagetable.c | 20 +++++--------------- 1 file changed, 5 insertions(+), 15 deletions(-)drivers/iommu/iommufd/hw_pagetable.c +0
-0
drivers/iommu/iommufd/hw_pagetable.c iommufd_hwpt_paging_alloc(struct iommufd_ctx *ictx, struct iommufd_ioas *ioas, · line 132
Quoted 6 lines
drivers/iommu/iommufd/hw_pagetable.c +0
-3@@ -127,21 +127,11 @@ iommufd_hwpt_paging_alloc(struct iommufd_ctx *ictx, struct iommufd_ioas *ioas, hwpt_paging->ioas = ioas; hwpt_paging->nest_parent = flags &IOMMU_HWPT_ALLOC_NEST_PARENT ; -if (ops->domain_alloc_user) { - hwpt->domain = ops->domain_alloc_user (idev->dev, flags,NULL , - user_data);
^^^^^^^^^^^^
Quoted 4 lines
drivers/iommu/iommufd/hw_pagetable.c +0
-4-if (IS_ERR (hwpt->domain)) { - rc =PTR_ERR (hwpt->domain); - hwpt->domain =NULL ; - goto out_abort;
drivers/iommu/iommufd/hw_pagetable.c iommufd_hwpt_paging_alloc(struct iommufd_ctx *ictx, struct iommufd_ioas *ioas, · line 131
Quoted 10 lines
drivers/iommu/iommufd/hw_pagetable.c +2
-8- } - hwpt->domain->owner = ops; - }else { - hwpt->domain =iommu_domain_alloc (idev->dev->bus); -if (!hwpt->domain) { - rc = -ENOMEM ; - goto out_abort; - } + hwpt->domain =iommu_user_domain_alloc (idev->dev, flags); +if (IS_ERR (hwpt->domain)) {
Where did the user_data go???
If you are going to wrapper the op function then all the args need to be provided.
I'm not sure there is value in having vfio and vdpa call this variation since they won't pass a user_data or flags?
Do you imagine there will ever be a difference between what domain_alloc_user(dev, 0, NULL, NULL) returns from domain_alloc_paging(dev) ?
That seems like questionable driver behavior to me.
Jason
Baolu Lu
maintainerRe: [PATCH v2 02/22] iommufd: Use iommu_user_domain_alloc()
Quoted 21 lines · Jason Gunthorpe
Quoted 12 lines · Lu Baolu
Replace
iommu_domain_alloc()withiommu_user_domain_alloc().Signed-off-by Lu Baolu <[email protected]>--- drivers/iommu/iommufd/hw_pagetable.c | 20 +++++--------------- 1 file changed, 5 insertions(+), 15 deletions(-)drivers/iommu/iommufd/hw_pagetable.c +0
-0drivers/iommu/iommufd/hw_pagetable.c iommufd_hwpt_paging_alloc(struct iommufd_ctx *ictx, struct iommufd_ioas *ioas, · line 132
Quoted 6 lines
drivers/iommu/iommufd/hw_pagetable.c +0
-3@@ -127,21 +127,11 @@ iommufd_hwpt_paging_alloc(struct iommufd_ctx *ictx, struct iommufd_ioas *ioas, hwpt_paging->ioas = ioas; hwpt_paging->nest_parent = flags &IOMMU_HWPT_ALLOC_NEST_PARENT ; -if (ops->domain_alloc_user) { - hwpt->domain = ops->domain_alloc_user (idev->dev, flags,NULL , - user_data);^^^^^^^^^^^^
Quoted 16 lines
Quoted 4 lines
drivers/iommu/iommufd/hw_pagetable.c +0
-4-if (IS_ERR (hwpt->domain)) { - rc =PTR_ERR (hwpt->domain); - hwpt->domain =NULL ; - goto out_abort;drivers/iommu/iommufd/hw_pagetable.c iommufd_hwpt_paging_alloc(struct iommufd_ctx *ictx, struct iommufd_ioas *ioas, · line 131
Quoted 10 lines
drivers/iommu/iommufd/hw_pagetable.c +2
-8- } - hwpt->domain->owner = ops; - }else { - hwpt->domain =iommu_domain_alloc (idev->dev->bus); -if (!hwpt->domain) { - rc = -ENOMEM ; - goto out_abort; - } + hwpt->domain =iommu_user_domain_alloc (idev->dev, flags); +if (IS_ERR (hwpt->domain)) {Where did the
user_datago???
The user_data is not used in allocating a paging user domain, so I skipped it.
Quoted 3 lines
If you are going to wrapper the op function then all the args need to be provided.
Yes. Agreed.
Quoted 6 lines
I'm not sure there is value in having vfio and vdpa call this variation since they won't pass a
user_dataor flags?Do you imagine there will ever be a difference between what
domain_alloc_user(dev, 0, NULL, NULL)returns fromdomain_alloc_paging(dev)?
No.
Quoted 2 lines
That seems like questionable driver behavior to me.
In my first try, I simply replaced iommu_domain_alloc() with a new paging domain allocation interface. On second thought, it occurred to me why not use separate interfaces for different purposes? Even though from an iommu perspective, they both use paging domains.
The @flags and @user_data are defined in uapi/linux/iommufd.h, which is specific to iommufd. Wrapping them in a common interface for broader use seems awkward.
So, perhaps we could return to my original idea? Let's just expose one interface, iommu_paging_domain_alloc(), and replace iommu_domain_alloc() with it everywhere?
Best regards,
baolu
Re: [PATCH v2 02/22] iommufd: Use iommu_user_domain_alloc()
Quoted 38 lines · Baolu Lu
Quoted 20 lines · Jason Gunthorpe
Quoted 12 lines · Lu Baolu
Replace
iommu_domain_alloc()withiommu_user_domain_alloc().Signed-off-by Lu Baolu <[email protected]>--- drivers/iommu/iommufd/hw_pagetable.c | 20 +++++--------------- 1 file changed, 5 insertions(+), 15 deletions(-)drivers/iommu/iommufd/hw_pagetable.c +0
-0drivers/iommu/iommufd/hw_pagetable.c iommufd_hwpt_paging_alloc(struct iommufd_ctx *ictx, struct iommufd_ioas *ioas, · line 131
Quoted 5 lines
drivers/iommu/iommufd/hw_pagetable.c +0
-3@@ -127,21 +127,11 @@ iommufd_hwpt_paging_alloc(struct iommufd_ctx *ictx, struct iommufd_ioas *ioas, hwpt_paging->ioas = ioas; hwpt_paging->nest_parent = flags &IOMMU_HWPT_ALLOC_NEST_PARENT ; -if (ops->domain_alloc_user) { - hwpt->domain = ops->domain_alloc_user (idev->dev, flags,NULL , - user_data);^^^^^^^^^^^^Quoted 16 lines
Quoted 4 lines
drivers/iommu/iommufd/hw_pagetable.c +0
-4-if (IS_ERR (hwpt->domain)) { - rc =PTR_ERR (hwpt->domain); - hwpt->domain =NULL ; - goto out_abort;drivers/iommu/iommufd/hw_pagetable.c iommufd_hwpt_paging_alloc(struct iommufd_ctx *ictx, struct iommufd_ioas *ioas, · line 131
Quoted 10 lines
drivers/iommu/iommufd/hw_pagetable.c +2
-8- } - hwpt->domain->owner = ops; - }else { - hwpt->domain =iommu_domain_alloc (idev->dev->bus); -if (!hwpt->domain) { - rc = -ENOMEM ; - goto out_abort; - } + hwpt->domain =iommu_user_domain_alloc (idev->dev, flags); +if (IS_ERR (hwpt->domain)) {Where did the
user_datago???
Quoted 2 lines
The
user_datais not used in allocating a paging user domain, so I skipped it.
That's not true.. We have no driver using it right now, but it is definately part of the uAPI and a driver could start using it. That is why it was hooked up in the first place.
Quoted 4 lines
In my first try, I simply replaced
iommu_domain_alloc()with a new paging domain allocation interface. On second thought, it occurred to me why not use separate interfaces for different purposes? Even though from an iommu perspective, they both use paging domains.
If we want to do that then it needs to forward all the args
Quoted 3 lines
The @flags and @user_data are defined in
uapi/linux/iommufd.h, which is specific to iommufd. Wrapping them in a common interface for broader use seems awkward.
Right, you'd have to forward declare the struct and just let it be. Really nothing but iommufd could call this API.
Quoted 3 lines
So, perhaps we could return to my original idea? Let's just expose one interface,
iommu_paging_domain_alloc(), and replaceiommu_domain_alloc()with it everywhere?
That's OK too, this above doesn't really need to be changed, some of the concept here was that iommufd-only ops would just be directly called by iommufd itself, to discourage future abuse.
Jason
Lu Baolu
maintainerPATCH v2 3/22 vfio/type1: Use iommu_user_domain_alloc()
In reply to Lu BaoluReplace iommu_domain_alloc() with iommu_user_domain_alloc().
--- drivers/vfio/vfio_iommu_type1.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
drivers/vfio/vfio_iommu_type1.c +4 -3
@@ -2135,7 +2135,7 @@ static int vfio_iommu_domain_alloc(struct device *dev, void *data) {struct iommu_domain **domain = data; - *domain =iommu_domain_alloc (dev->bus); + *domain =iommu_user_domain_alloc (dev,0 );return 1 ;/* Don't iterate */ }
@@ -2192,11 +2192,12 @@ static int vfio_iommu_type1_attach_group(void *iommu_data,* us a representative device for the IOMMU API call. We don't actually * want to iterate beyond the first device (if any). */ - ret = -EIO ;iommu_group_for_each_dev (iommu_group, &domain->domain, vfio_iommu_domain_alloc); -if (!domain->domain) +if (IS_ERR (domain->domain)) { + ret =PTR_ERR (domain->domain); goto out_free_domain; + }if (iommu->nesting) { ret =iommu_enable_nesting (domain->domain);
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v2 4/22 vhost-vdpa: Use iommu_user_domain_alloc()
In reply to Lu BaoluReplace iommu_domain_alloc() with iommu_user_domain_alloc().
--- drivers/vhost/vdpa.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-)
drivers/vhost/vdpa.c +6 -8
@@ -1312,26 +1312,24 @@ static int vhost_vdpa_alloc_domain(struct vhost_vdpa *v)struct vdpa_device *vdpa = v->vdpa;const struct vdpa_config_ops *ops = vdpa->config;struct device *dma_dev =vdpa_get_dma_dev (vdpa); -const struct bus_type *bus;int ret;/* Device want to do DMA by itself */ if (ops->set_map || ops->dma_map)return 0 ; - bus = dma_dev->bus; -if (!bus) -return -EFAULT ; -if (!device_iommu_capable (dma_dev,IOMMU_CAP_CACHE_COHERENCY )) {dev_warn_once (&v->dev,"Failed to allocate domain, device is not IOMMU cache coherent capable\n" );return -ENOTSUPP ; } - v->domain =iommu_domain_alloc (bus); -if (!v->domain) -return -EIO ; + v->domain =iommu_user_domain_alloc (dma_dev,0 ); +if (IS_ERR (v->domain)) { + ret =PTR_ERR (v->domain); + v->domain =NULL ; +return ret; + } ret =iommu_attach_device (v->domain, dma_dev);if (ret)
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v2 5/22 iommu: Add iommu_paging_domain_alloc() interface
In reply to Lu BaoluCommit <17de3f5fdd35> ("iommu: Retire bus ops") removes iommu ops from bus. The iommu subsystem no longer relies on bus for operations. So the bus parameter in iommu_domain_alloc() is no longer relevant.
Add a new interface named iommu_paging_domain_alloc(), which explicitly indicates the allocation of a paging domain for DMA managed by a kernel driver. The new interface takes a device pointer as its parameter, that better aligns with the current iommu subsystem.
--- include/linux/iommu.h | 6 ++++++ drivers/iommu/iommu.c | 20 ++++++++++++++++++++ 2 files changed, 26 insertions(+)
include/linux/iommu.h +6 -0
@@ -781,6 +781,7 @@ extern bool device_iommu_capable(struct device *dev, enum iommu_cap cap);extern bool iommu_group_has_isolated_msi (struct iommu_group *group);extern struct iommu_domain *iommu_domain_alloc (const struct bus_type *bus);struct iommu_domain *iommu_user_domain_alloc (struct device *dev,u32 flags); +struct iommu_domain *iommu_paging_domain_alloc (struct device *dev);extern void iommu_domain_free (struct iommu_domain *domain);extern int iommu_attach_device (struct iommu_domain *domain,struct device *dev);
@@ -1092,6 +1093,11 @@ static inline struct iommu_domain *iommu_user_domain_alloc(struct device *dev, ureturn ERR_PTR (-ENODEV ); } +static inline struct iommu_domain *iommu_paging_domain_alloc (struct device *dev) +{ +return ERR_PTR (-ENODEV ); +} +static inline void iommu_domain_free (struct iommu_domain *domain) { }
drivers/iommu/iommu.c +20 -0
@@ -2016,6 +2016,10 @@ static int __iommu_domain_alloc_dev(struct device *dev, void *data)return 0 ; } +/* +* The iommu ops in bus has been retired. Do not use this interface in +* new drivers. +*/ struct iommu_domain *iommu_domain_alloc (const struct bus_type *bus) {const struct iommu_ops *ops =NULL ;
@@ -2074,6 +2078,22 @@ struct iommu_domain *iommu_user_domain_alloc(struct device *dev, u32 flags) }EXPORT_SYMBOL_GPL (iommu_user_domain_alloc); +/** +* iommu_paging_domain_alloc() - Allocate a paging domain +* @dev: device for which the domain is allocated +* +* Allocate a paging domain which will be managed by a kernel driver. Return +* allocated domain if successful, or a ERR pointer for failure. +*/ +struct iommu_domain *iommu_paging_domain_alloc (struct device *dev) +{ +if (!dev_has_iommu (dev)) +return ERR_PTR (-ENODEV ); + +return __iommu_domain_alloc (dev_iommu_ops (dev), dev,IOMMU_DOMAIN_UNMANAGED ); +} +EXPORT_SYMBOL_GPL (iommu_paging_domain_alloc); +void iommu_domain_free (struct iommu_domain *domain) {if (domain->type ==IOMMU_DOMAIN_SVA )
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v2 6/22 drm/msm: Use iommu_paging_domain_alloc()
In reply to Lu BaoluThe domain allocated in msm_iommu_new() is for the @dev. Replace iommu_domain_alloc() with iommu_paging_domain_alloc() to make it explicit.
--- drivers/gpu/drm/msm/msm_iommu.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
drivers/gpu/drm/msm/msm_iommu.c +5 -2
@@ -407,10 +407,13 @@ struct msm_mmu *msm_iommu_new(struct device *dev, unsigned long quirks)struct msm_iommu *iommu;int ret; - domain =iommu_domain_alloc (dev->bus); -if (!domain) +if (!device_iommu_mapped (dev))return NULL ; + domain =iommu_paging_domain_alloc (dev); +if (IS_ERR (domain)) +return ERR_CAST (domain); +iommu_set_pgtable_quirks (domain, quirks); iommu =kzalloc (sizeof (*iommu),GFP_KERNEL );
Signature · 1 line
2.34.1
Re: [PATCH v2 06/22] drm/msm: Use iommu_paging_domain_alloc()
Quoted 7 lines · Lu Baolu
The domain allocated in
msm_iommu_new()is for the @dev. Replaceiommu_domain_alloc()withiommu_paging_domain_alloc()to make it explicit.Signed-off-by Lu Baolu <[email protected]>--- drivers/gpu/drm/msm/msm_iommu.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
Thank you!
Quoted 24 lines
drivers/gpu/drm/msm/msm_iommu.c +5
-2@@ -407,10 +407,13 @@ struct msm_mmu *msm_iommu_new(struct device *dev, unsigned long quirks)struct msm_iommu *iommu;int ret; - domain =iommu_domain_alloc (dev->bus); -if (!domain) +if (!device_iommu_mapped (dev))return NULL ; + domain =iommu_paging_domain_alloc (dev); +if (IS_ERR (domain)) +return ERR_CAST (domain); +iommu_set_pgtable_quirks (domain, quirks); iommu =kzalloc (sizeof (*iommu),GFP_KERNEL );Signature · 1 line
2.34.1
Signature · 2 lines
With best wishes Dmitry
Lu Baolu
maintainerPATCH v2 7/22 drm/nouveau/tegra: Use iommu_paging_domain_alloc()
In reply to Lu BaoluIn nvkm_device_tegra_probe_iommu(), a paging domain is allocated for @dev and attached to it on success. Use iommu_paging_domain_alloc() to make it explicit.
--- drivers/gpu/drm/nouveau/nvkm/engine/device/tegra.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/gpu/drm/nouveau/nvkm/engine/device/tegra.c +2 -2
@@ -120,8 +120,8 @@ nvkm_device_tegra_probe_iommu(struct nvkm_device_tegra *tdev)mutex_init (&tdev->iommu.mutex);if (device_iommu_mapped (dev)) { - tdev->iommu.domain =iommu_domain_alloc (&platform_bus_type); -if (!tdev->iommu.domain) + tdev->iommu.domain =iommu_paging_domain_alloc (dev); +if (IS_ERR (tdev->iommu.domain)) goto error;/*
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v2 8/22 gpu: host1x: Use iommu_paging_domain_alloc()
In reply to Lu BaoluAn iommu domain is allocated in host1x_iommu_attach() and is attached to host->dev. Use iommu_paging_domain_alloc() to make it explicit.
--- drivers/gpu/host1x/dev.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
drivers/gpu/host1x/dev.c +4 -3
@@ -404,9 +404,10 @@ static struct iommu_domain *host1x_iommu_attach(struct host1x *host)if (err <0 ) goto put_group; - host->domain =iommu_domain_alloc (&platform_bus_type); -if (!host->domain) { - err = -ENOMEM ; + host->domain =iommu_paging_domain_alloc (host->dev); +if (IS_ERR (host->domain)) { + err =PTR_ERR (host->domain); + host->domain =NULL ; goto put_cache; }
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v2 9/22 media: nvidia: tegra: Use iommu_paging_domain_alloc()
In reply to Lu BaoluAn iommu domain is allocated in tegra_vde_iommu_init() and is attached to vde->dev. Use iommu_paging_domain_alloc() to make it explicit.
--- drivers/media/platform/nvidia/tegra-vde/iommu.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
drivers/media/platform/nvidia/tegra-vde/iommu.c +4 -3
@@ -78,9 +78,10 @@ int tegra_vde_iommu_init(struct tegra_vde *vde) arm_iommu_release_mapping(mapping); }#endif - vde->domain =iommu_domain_alloc (&platform_bus_type); -if (!vde->domain) { - err = -ENOMEM ; + vde->domain =iommu_paging_domain_alloc (dev); +if (IS_ERR (vde->domain)) { + err =PTR_ERR (vde->domain); + vde->domain =NULL ; goto put_group; }
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v2 10/22 media: venus: firmware: Use iommu_paging_domain_alloc()
In reply to Lu BaoluAn iommu domain is allocated in venus_firmware_init() and is attached to core->fw.dev in the same function. Use iommu_paging_domain_alloc() to make it explicit.
--- drivers/media/platform/qcom/venus/firmware.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/media/platform/qcom/venus/firmware.c +3 -3
@@ -316,10 +316,10 @@ int venus_firmware_init(struct venus_core *core) core->fw.dev = &pdev->dev; - iommu_dom =iommu_domain_alloc (&platform_bus_type); -if (!iommu_dom) { + iommu_dom =iommu_paging_domain_alloc (core->fw.dev); +if (IS_ERR (iommu_dom)) {dev_err (core->fw.dev,"Failed to allocate iommu domain\n" ); - ret = -ENOMEM ; + ret =PTR_ERR (iommu_dom); goto err_unregister; }
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v2 11/22 ath10k: Use iommu_paging_domain_alloc()
In reply to Lu BaoluAn iommu domain is allocated in ath10k_fw_init() and is attached to ar_snoc->fw.dev in the same function. Use iommu_paging_domain_alloc() to make it explicit.
--- drivers/net/wireless/ath/ath10k/snoc.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/net/wireless/ath/ath10k/snoc.c +3 -3
@@ -1635,10 +1635,10 @@ static int ath10k_fw_init(struct ath10k *ar) ar_snoc->fw.dev = &pdev->dev; - iommu_dom =iommu_domain_alloc (&platform_bus_type); -if (!iommu_dom) { + iommu_dom =iommu_paging_domain_alloc (ar_snoc->fw.dev); +if (IS_ERR (iommu_dom)) {ath10k_err (ar,"failed to allocate iommu domain\n" ); - ret = -ENOMEM ; + ret =PTR_ERR (iommu_dom); goto err_unregister; }
Signature · 1 line
2.34.1
Re: [PATCH v2 11/22] ath10k: Use iommu_paging_domain_alloc()
Quoted 5 lines · Lu Baolu
An iommu domain is allocated in
ath10k_fw_init()and is attached toar_snoc->fw.devin the same function. Useiommu_paging_domain_alloc()to make it explicit.Signed-off-by Lu Baolu <[email protected]>
nit: although the subject prefix you used probably matches the prefix in git history, subject prefix should now be "wifi: ath10k: "
with that addressed,
Re: [PATCH v2 11/22] ath10k: Use iommu_paging_domain_alloc()
In reply to Lu Baolu+ath10k list for viibility
Quoted 27 lines · Lu Baolu
An iommu domain is allocated in
ath10k_fw_init()and is attached toar_snoc->fw.devin the same function. Useiommu_paging_domain_alloc()to make it explicit.Signed-off-by Lu Baolu <[email protected]>--- drivers/net/wireless/ath/ath10k/snoc.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)drivers/net/wireless/ath/ath10k/snoc.c +3
-3@@ -1635,10 +1635,10 @@ static int ath10k_fw_init(struct ath10k *ar) ar_snoc->fw.dev = &pdev->dev; - iommu_dom =iommu_domain_alloc (&platform_bus_type); -if (!iommu_dom) { + iommu_dom =iommu_paging_domain_alloc (ar_snoc->fw.dev); +if (IS_ERR (iommu_dom)) {ath10k_err (ar,"failed to allocate iommu domain\n" ); - ret = -ENOMEM ; + ret =PTR_ERR (iommu_dom); goto err_unregister; }
Lu Baolu
maintainerPATCH v2 12/22 wifi: ath11k: Use iommu_paging_domain_alloc()
In reply to Lu BaoluAn iommu domain is allocated in ath11k_ahb_fw_resources_init() and is attached to ab_ahb->fw.dev in the same function.
Use iommu_paging_domain_alloc() to make it explicit.
--- drivers/net/wireless/ath/ath11k/ahb.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/net/wireless/ath/ath11k/ahb.c +3 -3
@@ -1001,10 +1001,10 @@ static int ath11k_ahb_fw_resources_init(struct ath11k_base *ab) ab_ahb->fw.dev = &pdev->dev; - iommu_dom =iommu_domain_alloc (&platform_bus_type); -if (!iommu_dom) { + iommu_dom =iommu_paging_domain_alloc (ab_ahb->fw.dev); +if (IS_ERR (iommu_dom)) {ath11k_err (ab,"failed to allocate iommu domain\n" ); - ret = -ENOMEM ; + ret =PTR_ERR (iommu_dom); goto err_unregister; }
Signature · 1 line
2.34.1
Re: [PATCH v2 12/22] wifi: ath11k: Use iommu_paging_domain_alloc()
Quoted 17 lines · Lu Baolu
An iommu domain is allocated in
ath11k_ahb_fw_resources_init()and is attached toab_ahb->fw.devin the same function.Use
iommu_paging_domain_alloc()to make it explicit.Signed-off-by Lu Baolu <[email protected]>--- drivers/net/wireless/ath/ath11k/ahb.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)drivers/net/wireless/ath/ath11k/ahb.c +0
-0@@ -1001,10 +1001,10 @@ static int ath11k_ahb_fw_resources_init(struct ath11k_base *ab) ab_ahb->fw.dev = &pdev->dev;
drivers/net/wireless/ath/ath11k/ahb.c static int ath11k_ahb_fw_resources_init(struct ath11k_base *ab) · line 1009
Quoted 10 lines
drivers/net/wireless/ath/ath11k/ahb.c +3
-3- iommu_dom =iommu_domain_alloc (&platform_bus_type); -if (!iommu_dom) { + iommu_dom =iommu_paging_domain_alloc (ab_ahb->fw.dev); +if (IS_ERR (iommu_dom)) {ath11k_err (ab,"failed to allocate iommu domain\n" ); - ret = -ENOMEM ; + ret =PTR_ERR (iommu_dom); goto err_unregister; }
Adding Jeff and ath11k list so that they can review this as well.
Signature · 3 lines
https://patchwork.kernel.org/project/linux-wireless/list/ https://wireless.wiki.kernel.org/en/developers/documentation/submittingpatches
Re: [PATCH v2 12/22] wifi: ath11k: Use iommu_paging_domain_alloc()
In reply to Lu BaoluQuoted 6 lines · Lu Baolu
An iommu domain is allocated in
ath11k_ahb_fw_resources_init()and is attached toab_ahb->fw.devin the same function.Use
iommu_paging_domain_alloc()to make it explicit.Signed-off-by Lu Baolu <[email protected]>
Quoted 22 lines
--- drivers/net/wireless/ath/ath11k/ahb.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)drivers/net/wireless/ath/ath11k/ahb.c +3
-3@@ -1001,10 +1001,10 @@ static int ath11k_ahb_fw_resources_init(struct ath11k_base *ab) ab_ahb->fw.dev = &pdev->dev; - iommu_dom =iommu_domain_alloc (&platform_bus_type); -if (!iommu_dom) { + iommu_dom =iommu_paging_domain_alloc (ab_ahb->fw.dev); +if (IS_ERR (iommu_dom)) {ath11k_err (ab,"failed to allocate iommu domain\n" ); - ret = -ENOMEM ; + ret =PTR_ERR (iommu_dom); goto err_unregister; }
Lu Baolu
maintainerPATCH v2 13/22 remoteproc: Use iommu_paging_domain_alloc()
In reply to Lu BaoluAn iommu domain is allocated in rproc_enable_iommu() and is attached to rproc->dev.parent in the same function.
Use iommu_paging_domain_alloc() to make it explicit.
--- drivers/remoteproc/remoteproc_core.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/remoteproc/remoteproc_core.c +3 -3
@@ -109,10 +109,10 @@ static int rproc_enable_iommu(struct rproc *rproc)return 0 ; } - domain =iommu_domain_alloc (dev->bus); -if (!domain) { + domain =iommu_paging_domain_alloc (dev); +if (IS_ERR (domain)) {dev_err (dev,"can't alloc iommu domain\n" ); -return -ENOMEM ; +return PTR_ERR (domain); }iommu_set_fault_handler (domain, rproc_iommu_fault, rproc);
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v2 14/22 soc/fsl/qbman: Use iommu_paging_domain_alloc()
In reply to Lu BaoluAn iommu domain is allocated in portal_set_cpu() and is attached to pcfg->dev in the same function.
Use iommu_paging_domain_alloc() to make it explicit.
--- drivers/soc/fsl/qbman/qman_portal.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
drivers/soc/fsl/qbman/qman_portal.c +3 -2
@@ -48,9 +48,10 @@ static void portal_set_cpu(struct qm_portal_config *pcfg, int cpu)struct device *dev = pcfg->dev;int ret; - pcfg->iommu_domain =iommu_domain_alloc (&platform_bus_type); -if (!pcfg->iommu_domain) { + pcfg->iommu_domain =iommu_paging_domain_alloc (dev); +if (IS_ERR (pcfg->iommu_domain)) {dev_err (dev,"%s(): iommu_domain_alloc() failed" , __func__); + pcfg->iommu_domain =NULL ; goto no_iommu; } ret =fsl_pamu_configure_l1_stash (pcfg->iommu_domain, cpu);
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v2 15/22 RDMA/usnic: Use iommu_paging_domain_alloc()
In reply to Lu Baoluusnic_uiom_alloc_pd() allocates a paging domain for a given device. In this case, iommu_domain_alloc(dev->bus) is equivalent to iommu_paging_domain_alloc(dev). Replace it as iommu_domain_alloc() has been deprecated.
--- drivers/infiniband/hw/usnic/usnic_uiom.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/infiniband/hw/usnic/usnic_uiom.c +3 -3
@@ -443,11 +443,11 @@ struct usnic_uiom_pd *usnic_uiom_alloc_pd(struct device *dev)if (!pd)return ERR_PTR (-ENOMEM ); - pd->domain = domain =iommu_domain_alloc (dev->bus); -if (!domain) { + pd->domain = domain =iommu_paging_domain_alloc (dev); +if (IS_ERR (domain)) {usnic_err ("Failed to allocate IOMMU domain" );kfree (pd); -return ERR_PTR (-ENOMEM ); +return ERR_CAST (domain); }iommu_set_fault_handler (pd->domain, usnic_uiom_dma_fault,NULL );
Signature · 1 line
2.34.1
Re: [PATCH v2 15/22] RDMA/usnic: Use iommu_paging_domain_alloc()
Quoted 9 lines · Lu Baolu
usnic_uiom_alloc_pd()allocates a paging domain for a given device. In this case,iommu_domain_alloc(dev->bus)is equivalent toiommu_paging_domain_alloc(dev). Replace it asiommu_domain_alloc()has been deprecated.Signed-off-by Lu Baolu <[email protected]>--- drivers/infiniband/hw/usnic/usnic_uiom.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
Jason
Lu Baolu
maintainerPATCH v2 16/22 iommu/vt-d: Add helper to allocate paging domain
In reply to Lu BaoluThe domain_alloc_user operation is currently implemented by allocating a paging domain using iommu_domain_alloc(). This is because it needs to fully initialize the domain before return. Add a helper to do this to avoid using iommu_domain_alloc().
--- drivers/iommu/intel/iommu.c | 87 +++++++++++++++++++++++++++++++++---- 1 file changed, 78 insertions(+), 9 deletions(-)
drivers/iommu/intel/iommu.c +78 -9
@@ -3633,6 +3633,79 @@ static struct iommu_domain blocking_domain = { } }; +static int iommu_superpage_capability (struct intel_iommu *iommu,bool first_stage) +{ +if (!intel_iommu_superpage) +return 0 ; + +if (first_stage) +return cap_fl1gp_support (iommu->cap) ?2 :1 ; + +return fls (cap_super_page_val (iommu->cap)); +} + +static struct dmar_domain *paging_domain_alloc (struct device *dev,bool first_stage) +{ +struct device_domain_info *info =dev_iommu_priv_get (dev); +struct intel_iommu *iommu = info->iommu; +struct dmar_domain *domain; +int addr_width; + + domain =kzalloc (sizeof (*domain),GFP_KERNEL ); +if (!domain) +return ERR_PTR (-ENOMEM ); + +INIT_LIST_HEAD (&domain->devices); +INIT_LIST_HEAD (&domain->dev_pasids); +INIT_LIST_HEAD (&domain->cache_tags); +spin_lock_init (&domain->lock); +spin_lock_init (&domain->cache_lock); +xa_init (&domain->iommu_array); + + domain->nid =dev_to_node (dev); + domain->has_iotlb_device = info->ats_enabled; + domain->use_first_level = first_stage; + +/* calculate the address width */ + addr_width =agaw_to_width (iommu->agaw); +if (addr_width >cap_mgaw (iommu->cap)) + addr_width =cap_mgaw (iommu->cap); + domain->gaw = addr_width; + domain->agaw = iommu->agaw; + domain->max_addr =__DOMAIN_MAX_ADDR (addr_width); + +/* iommu memory access coherency */ + domain->iommu_coherency =iommu_paging_structure_coherency (iommu); + +/* pagesize bitmap */ + domain->domain.pgsize_bitmap =SZ_4K ; + domain->iommu_superpage =iommu_superpage_capability (iommu, first_stage); + domain->domain.pgsize_bitmap |=domain_super_pgsize_bitmap (domain); + +/* +* IOVA aperture: First-level translation restricts the input-address +* to a canonical address (i.e., address bits 63:N have the same value +* as address bit [N-1], where N is 48-bits with 4-level paging and +* 57-bits with 5-level paging). Hence, skip bit [N-1]. +*/ + domain->domain.geometry.force_aperture = true; + domain->domain.geometry.aperture_start =0 ; +if (first_stage) + domain->domain.geometry.aperture_end =__DOMAIN_MAX_ADDR (domain->gaw -1 ); +else + domain->domain.geometry.aperture_end =__DOMAIN_MAX_ADDR (domain->gaw); + +/* always allocate the top pgd */ + domain->pgd =iommu_alloc_page_node (domain->nid,GFP_KERNEL ); +if (!domain->pgd) { +kfree (domain); +return ERR_PTR (-ENOMEM ); + } +domain_flush_cache (domain, domain->pgd,PAGE_SIZE ); + +return domain; +} +static struct iommu_domain *intel_iommu_domain_alloc (unsigned type) {struct dmar_domain *dmar_domain;
@@ -3695,15 +3768,11 @@ intel_iommu_domain_alloc_user(struct device *dev, u32 flags,if (user_data || (dirty_tracking && !ssads_supported (iommu)))return ERR_PTR (-EOPNOTSUPP ); -/* -* domain_alloc_user op needs to fully initialize a domain before -* return, so uses iommu_domain_alloc() here for simple. -*/ - domain =iommu_domain_alloc (dev->bus); -if (!domain) -return ERR_PTR (-ENOMEM ); - - dmar_domain =to_dmar_domain (domain); +/* Do not use first stage for user domain translation. */ + dmar_domain =paging_domain_alloc (dev, false); +if (IS_ERR (dmar_domain)) +return ERR_CAST (dmar_domain); + domain = &dmar_domain->domain;if (nested_parent) { dmar_domain->nested_parent = true;
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v2 17/22 ARM: dma-mapping: Pass device to arm_iommu_create_mapping()
In reply to Lu BaoluFrom: Robin Murphy <[email protected]>
All users of ARM IOMMU mappings create them for a particular device, so change the interface to accept the device rather than forcing a vague indirection through a bus type. This prepares for making a similar change to iommu_domain_alloc() itself.
--- arch/arm/include/asm/dma-iommu.h | 2 +- arch/arm/mm/dma-mapping.c | 8 ++++---- drivers/gpu/drm/exynos/exynos_drm_dma.c | 2 +- drivers/iommu/ipmmu-vmsa.c | 3 +-- drivers/iommu/mtk_iommu_v1.c | 3 +-- drivers/media/platform/ti/omap3isp/isp.c | 2 +- 6 files changed, 9 insertions(+), 11 deletions(-)
arch/arm/include/asm/dma-iommu.h +1 -1
@@ -24,7 +24,7 @@ struct dma_iommu_mapping { };struct dma_iommu_mapping * -arm_iommu_create_mapping (const struct bus_type *bus,dma_addr_t base,u64 size); +arm_iommu_create_mapping (struct device *dev,dma_addr_t base,u64 size);void arm_iommu_release_mapping (struct dma_iommu_mapping *mapping);
arch/arm/mm/dma-mapping.c +4 -4
@@ -1532,7 +1532,7 @@ static const struct dma_map_ops iommu_ops = {/** * arm_iommu_create_mapping -* @bus: pointer to the bus holding the client device (for IOMMU calls) +* @dev: pointer to the client device (for IOMMU calls) * @base: start address of the valid IO address space * @size: maximum size of the valid IO address space *
@@ -1544,7 +1544,7 @@ static const struct dma_map_ops iommu_ops = {* arm_iommu_attach_device function. */ struct dma_iommu_mapping * -arm_iommu_create_mapping (const struct bus_type *bus,dma_addr_t base,u64 size) +arm_iommu_create_mapping (struct device *dev,dma_addr_t base,u64 size) {unsigned int bits = size >>PAGE_SHIFT ;unsigned int bitmap_size =BITS_TO_LONGS (bits) *sizeof (long );
@@ -1585,7 +1585,7 @@ arm_iommu_create_mapping(const struct bus_type *bus, dma_addr_t base, u64 size)spin_lock_init (&mapping->lock); - mapping->domain =iommu_domain_alloc (bus); + mapping->domain =iommu_domain_alloc (dev->bus);if (!mapping->domain) goto err4;
@@ -1718,7 +1718,7 @@ static void arm_setup_iommu_dma_ops(struct device *dev) dma_base =dma_range_map_min (dev->dma_range_map); size =dma_range_map_max (dev->dma_range_map) - dma_base; } - mapping =arm_iommu_create_mapping (dev->bus, dma_base, size); + mapping =arm_iommu_create_mapping (dev, dma_base, size);if (IS_ERR (mapping)) {pr_warn ("Failed to create %llu-byte IOMMU mapping for device %s\n" , size,dev_name (dev));
drivers/gpu/drm/exynos/exynos_drm_dma.c +1 -1
@@ -110,7 +110,7 @@ int exynos_drm_register_dma(struct drm_device *drm, struct device *dev,void *mapping =NULL ;if (IS_ENABLED (CONFIG_ARM_DMA_USE_IOMMU )) - mapping =arm_iommu_create_mapping (&platform_bus_type, + mapping =arm_iommu_create_mapping (dev,EXYNOS_DEV_ADDR_START ,EXYNOS_DEV_ADDR_SIZE );else if (IS_ENABLED (CONFIG_IOMMU_DMA )) mapping =iommu_get_domain_for_dev (priv->dma_dev);
drivers/iommu/ipmmu-vmsa.c +1 -2
@@ -804,8 +804,7 @@ static int ipmmu_init_arm_mapping(struct device *dev)if (!mmu->mapping) {struct dma_iommu_mapping *mapping; - mapping =arm_iommu_create_mapping (&platform_bus_type, -SZ_1G ,SZ_2G ); + mapping =arm_iommu_create_mapping (dev,SZ_1G ,SZ_2G );if (IS_ERR (mapping)) {dev_err (mmu->dev,"failed to create ARM IOMMU mapping\n" ); ret =PTR_ERR (mapping);
drivers/iommu/mtk_iommu_v1.c +1 -2
@@ -439,8 +439,7 @@ static int mtk_iommu_v1_create_mapping(struct device *dev, mtk_mapping = data->mapping;if (!mtk_mapping) {/* MTK iommu support 4GB iova address space. */ - mtk_mapping =arm_iommu_create_mapping (&platform_bus_type, -0 ,1ULL <<32 ); + mtk_mapping =arm_iommu_create_mapping (dev,0 ,1ULL <<32 );if (IS_ERR (mtk_mapping))return PTR_ERR (mtk_mapping);
drivers/media/platform/ti/omap3isp/isp.c +1 -1
@@ -1965,7 +1965,7 @@ static int isp_attach_iommu(struct isp_device *isp)* Create the ARM mapping, used by the ARM DMA mapping core to allocate * VAs. This will allocate a corresponding IOMMU domain. */ - mapping =arm_iommu_create_mapping (&platform_bus_type,SZ_1G ,SZ_2G ); + mapping =arm_iommu_create_mapping (isp->dev,SZ_1G ,SZ_2G );if (IS_ERR (mapping)) {dev_err (isp->dev,"failed to create ARM IOMMU mapping\n" );return PTR_ERR (mapping);
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v2 18/22 ARM: dma-mapping: Use iommu_paging_domain_alloc()
In reply to Lu BaoluSince arm_iommu_create_mapping() now accepts the device, let's replace iommu_domain_alloc() with iommu_paging_domain_alloc() to retire the former.
--- arch/arm/mm/dma-mapping.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
arch/arm/mm/dma-mapping.c +4 -2
@@ -1585,9 +1585,11 @@ arm_iommu_create_mapping(struct device *dev, dma_addr_t base, u64 size)spin_lock_init (&mapping->lock); - mapping->domain =iommu_domain_alloc (dev->bus); -if (!mapping->domain) + mapping->domain =iommu_paging_domain_alloc (dev); +if (IS_ERR (mapping->domain)) { + err =PTR_ERR (mapping->domain); goto err4; + }kref_init (&mapping->kref);return mapping;
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v2 19/22 drm/rockchip: Use iommu_paging_domain_alloc()
In reply to Lu BaoluCommit <421be3ee36a4> ("drm/rockchip: Refactor IOMMU initialisation") has refactored rockchip_drm_init_iommu() to pass a device that the domain is allocated for. Replace iommu_domain_alloc() with iommu_paging_domain_alloc() to retire the former.
--- drivers/gpu/drm/rockchip/rockchip_drm_drv.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-)
drivers/gpu/drm/rockchip/rockchip_drm_drv.c +7 -3
@@ -103,13 +103,17 @@ static int rockchip_drm_init_iommu(struct drm_device *drm_dev)struct rockchip_drm_private *private = drm_dev->dev_private;struct iommu_domain_geometry *geometry;u64 start, end; +int ret;if (IS_ERR_OR_NULL (private->iommu_dev))return 0 ; - private->domain =iommu_domain_alloc (private->iommu_dev->bus); -if (!private->domain) -return -ENOMEM ; + private->domain =iommu_paging_domain_alloc (private->iommu_dev); +if (IS_ERR (private->domain)) { + ret =PTR_ERR (private->domain); + private->domain =NULL ; +return ret; + } geometry = &private->domain->geometry; start = geometry->aperture_start;
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v2 20/22 drm/tegra: Remove call to iommu_domain_alloc()
In reply to Lu BaoluCommit <17de3f5fdd35> ("iommu: Retire bus ops") removes iommu ops from the bus structure. The iommu subsystem no longer relies on bus for operations. So iommu_domain_alloc() interface is no longer relevant.
Normally, iommu_paging_domain_alloc() could be a replacement for iommu_domain_alloc() if the caller has the right device for IOMMU API use. Unfortunately, this is not the case for this driver.
Iterate the devices on the platform bus and find a suitable device whose device DMA is translated by an IOMMU. Then use this device to allocate an iommu domain. The iommu subsystem prevents domains allocated by one iommu driver from being attached to devices managed by any different iommu driver.
--- drivers/gpu/drm/tegra/drm.c | 34 +++++++++++++++++++++++++--------- 1 file changed, 25 insertions(+), 9 deletions(-)
drivers/gpu/drm/tegra/drm.c +25 -9
@@ -1133,6 +1133,17 @@ static bool host1x_drm_wants_iommu(struct host1x_device *dev)return domain !=NULL ; } +static int iommu_mapped_device (struct device *dev,void *data) +{ +struct device **iommu_dev = data; + +if (!device_iommu_mapped (dev)) +return 0 ; + + *iommu_dev = dev; +return 1 ; +} +static int host1x_drm_probe (struct host1x_device *dev) {struct tegra_drm *tegra;
@@ -1149,16 +1160,21 @@ static int host1x_drm_probe(struct host1x_device *dev) goto put; } -if (host1x_drm_wants_iommu (dev) &&iommu_present (&platform_bus_type)) { - tegra->domain =iommu_domain_alloc (&platform_bus_type); -if (!tegra->domain) { - err = -ENOMEM ; - goto free; +if (host1x_drm_wants_iommu (dev)) { +struct device *iommu_dev =NULL ; + +bus_for_each_dev (&platform_bus_type,NULL , &iommu_dev, iommu_mapped_device); +if (iommu_dev) { + tegra->domain =iommu_paging_domain_alloc (iommu_dev); +if (IS_ERR (tegra->domain)) { + err =PTR_ERR (tegra->domain); + goto free; + } + + err =iova_cache_get (); +if (err <0 ) + goto domain; } - - err =iova_cache_get (); -if (err <0 ) - goto domain; }mutex_init (&tegra->clients_lock);
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v2 21/22 iommu: Remove iommu_present()
In reply to Lu BaoluThe iommu_present() interface is no longer used in the tree anymore. Remove it to avoid dead code.
--- include/linux/iommu.h | 6 ------ drivers/iommu/iommu.c | 25 ------------------------- 2 files changed, 31 deletions(-)
include/linux/iommu.h +0 -6
@@ -776,7 +776,6 @@ static inline void iommu_iotlb_gather_init(struct iommu_iotlb_gather *gather) }extern int bus_iommu_probe (const struct bus_type *bus); -extern bool iommu_present (const struct bus_type *bus);extern bool device_iommu_capable (struct device *dev,enum iommu_cap cap);extern bool iommu_group_has_isolated_msi (struct iommu_group *group);extern struct iommu_domain *iommu_domain_alloc (const struct bus_type *bus);
@@ -1073,11 +1072,6 @@ struct iommu_iotlb_gather {};struct iommu_dirty_bitmap {};struct iommu_dirty_ops {}; -static inline bool iommu_present (const struct bus_type *bus) -{ -return false; -} -static inline bool device_iommu_capable (struct device *dev,enum iommu_cap cap) {return false;
drivers/iommu/iommu.c +0 -25
@@ -1846,31 +1846,6 @@ int bus_iommu_probe(const struct bus_type *bus)return 0 ; } -/** -* iommu_present() - make platform-specific assumptions about an IOMMU -* @bus: bus to check -* -* Do not use this function. You want device_iommu_mapped() instead. -* -* Return: true if some IOMMU is present and aware of devices on the given bus; -* in general it may not be the only IOMMU, and it may not have anything to do -* with whatever device you are ultimately interested in. -*/ -bool iommu_present (const struct bus_type *bus) -{ -bool ret = false; - -for (int i =0 ; i <ARRAY_SIZE (iommu_buses); i++) { -if (iommu_buses[i] == bus) { -spin_lock (&iommu_device_lock); - ret = !list_empty (&iommu_device_list); -spin_unlock (&iommu_device_lock); - } - } -return ret; -} -EXPORT_SYMBOL_GPL (iommu_present); -/** * device_iommu_capable() - check for a general IOMMU capability * @dev: device to which the capability would be relevant, if available
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v2 22/22 iommu: Remove iommu_domain_alloc()
In reply to Lu BaoluThe iommu_domain_alloc() interface is no longer used in the tree anymore. Remove it to avoid dead code.
There is increasing demand for supporting multiple IOMMU drivers, and this is the last bus-based thing standing in the way of that.
--- include/linux/iommu.h | 6 ------ drivers/iommu/iommu.c | 36 ------------------------------------ 2 files changed, 42 deletions(-)
include/linux/iommu.h +0 -6
@@ -778,7 +778,6 @@ static inline void iommu_iotlb_gather_init(struct iommu_iotlb_gather *gather)extern int bus_iommu_probe (const struct bus_type *bus);extern bool device_iommu_capable (struct device *dev,enum iommu_cap cap);extern bool iommu_group_has_isolated_msi (struct iommu_group *group); -extern struct iommu_domain *iommu_domain_alloc (const struct bus_type *bus);struct iommu_domain *iommu_user_domain_alloc (struct device *dev,u32 flags);struct iommu_domain *iommu_paging_domain_alloc (struct device *dev);extern void iommu_domain_free (struct iommu_domain *domain);
@@ -1077,11 +1076,6 @@ static inline bool device_iommu_capable(struct device *dev, enum iommu_cap cap)return false; } -static inline struct iommu_domain *iommu_domain_alloc (const struct bus_type *bus) -{ -return NULL ; -} -static inline struct iommu_domain *iommu_user_domain_alloc (struct device *dev,u32 flags) {return ERR_PTR (-ENODEV );
drivers/iommu/iommu.c +0 -36
@@ -1975,42 +1975,6 @@ __iommu_group_domain_alloc(struct iommu_group *group, unsigned int type)return __iommu_domain_alloc (dev_iommu_ops (dev), dev, type); } -static int __iommu_domain_alloc_dev (struct device *dev,void *data) -{ -const struct iommu_ops **ops = data; - -if (!dev_has_iommu (dev)) -return 0 ; - -if (WARN_ONCE (*ops && *ops !=dev_iommu_ops (dev), -"Multiple IOMMU drivers present for bus %s, which the public IOMMU API can't fully support yet. You will still need to disable one or more for this to work, sorry!\n" , -dev_bus_name (dev))) -return -EBUSY ; - - *ops =dev_iommu_ops (dev); -return 0 ; -} - -/* -* The iommu ops in bus has been retired. Do not use this interface in -* new drivers. -*/ -struct iommu_domain *iommu_domain_alloc (const struct bus_type *bus) -{ -const struct iommu_ops *ops =NULL ; -int err =bus_for_each_dev (bus,NULL , &ops, __iommu_domain_alloc_dev); -struct iommu_domain *domain; - -if (err || !ops) -return NULL ; - - domain =__iommu_domain_alloc (ops,NULL ,IOMMU_DOMAIN_UNMANAGED ); -if (IS_ERR (domain)) -return NULL ; -return domain; -} -EXPORT_SYMBOL_GPL (iommu_domain_alloc); -/** * iommu_user_domain_alloc() - Allocate a user domain * @dev: device for which the domain is allocated
Signature · 1 line
2.34.1