Simplify vfio_iommu_type1 attach/detach routine
Subsystems (18)
v3 cover Simplify vfio_iommu_type1 attach/detach routine
This is a preparatory series for IOMMUFD v2 patches. It enforces error code -EMEDIUMTYPE in iommu_attach_device() and iommu_attach_group() when an IOMMU domain and a device/group are incompatible. It also drops the useless domain->ops check since it won't fail in current environment.
These allow VFIO iommu code to simplify its group attachment routine, by avoiding the extra IOMMU domain allocations and attach/detach sequences of the old code.
Worths mentioning the exact match for enforce_cache_coherency is removed with this series, since there's very less value in doing that since KVM won't be able to take advantage of it -- this just wastes domain memory. Instead, we rely on Intel IOMMU driver taking care of that internally.
This is on github:
https://github.com/nicolinc/iommufd/commits/vfio_iommu_attach
Changelog
v3:
* Dropped all dev_err since -EMEDIUMTYPE clearly indicates what error.
* Updated commit message of enforce_cache_coherency removing patch.
* Updated commit message of domain->ops removing patch.
* Replaced "goto out_unlock" with simply mutex_unlock() and return.
* Added a line of comments for -EMEDIUMTYPE return check.
* Moved iommu_get_msi_cookie() into alloc_attach_domain() as a cookie should be logically tied to the lifetime of a domain itself.
* Added Kevin's "Reviewed-by".
v2: https://lore.kernel.org/kvm/[email protected]/
* Added -EMEDIUMTYPE to more IOMMU drivers that fit the category.
* Changed dev_err to dev_dbg for -EMEDIUMTYPE to avoid kernel log spam.
* Dropped iommu_ops patch, and removed domain->ops in VFIO directly, since there's no mixed-driver use case that would fail the sanity.
* Updated commit log of the patch removing enforce_cache_coherency.
* Fixed a misplace of "num_non_pinned_groups--" in detach_group patch.
* Moved "num_non_pinned_groups++" in PATCH-5 to the common path between domain-reusing and new-domain pathways, like the code previously did.
* Fixed a typo in EMEDIUMTYPE patch.
v1: https://lore.kernel.org/kvm/[email protected]/
Jason Gunthorpe (1):
vfio/iommu_type1: Prefer to reuse domains vs match enforced cache
coherency
Nicolin Chen (4):
iommu: Return -EMEDIUMTYPE for incompatible domain and device/group vfio/iommu_type1: Remove the domain->ops comparison vfio/iommu_type1: Clean up update_dirty_scope in detach_group() vfio/iommu_type1: Simplify group attachment
drivers/iommu/amd/iommu.c | 2 +- drivers/iommu/apple-dart.c | 4 +- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 15 +- drivers/iommu/arm/arm-smmu/arm-smmu.c | 6 +- drivers/iommu/arm/arm-smmu/qcom_iommu.c | 9 +- drivers/iommu/intel/iommu.c | 10 +- drivers/iommu/iommu.c | 28 ++ drivers/iommu/ipmmu-vmsa.c | 4 +- drivers/iommu/mtk_iommu_v1.c | 2 +- drivers/iommu/omap-iommu.c | 3 +- drivers/iommu/s390-iommu.c | 2 +- drivers/iommu/sprd-iommu.c | 6 +- drivers/iommu/tegra-gart.c | 2 +- drivers/iommu/virtio-iommu.c | 3 +- drivers/vfio/vfio_iommu_type1.c | 340 ++++++++++---------- 15 files changed, 225 insertions(+), 211 deletions(-)
Signature · 1 line
2.17.1
PATCH v3 1/5 iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
Cases like VFIO wish to attach a device to an existing domain that was not allocated specifically from the device. This raises a condition where the IOMMU driver can fail the domain attach because the domain and device are incompatible with each other.
This is a soft failure that can be resolved by using a different domain.
Provide a dedicated errno from the IOMMU driver during attach that the reason attached failed is because of domain incompatability. EMEDIUMTYPE is chosen because it is never used within the iommu subsystem today and evokes a sense that the 'medium' aka the domain is incompatible.
VFIO can use this to know attach is a soft failure and it should continue searching. Otherwise the attach will be a hard failure and VFIO will return the code to userspace.
Update all drivers to return EMEDIUMTYPE in their failure paths that are related to domain incompatability. Also remove adjacent error prints for these soft failures, to prevent a kernel log spam, since -EMEDIUMTYPE is clear enough to indicate an incompatability error.
Add kdocs describing this behavior.
--- drivers/iommu/amd/iommu.c | 2 +- drivers/iommu/apple-dart.c | 4 +-- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 15 +++-------- drivers/iommu/arm/arm-smmu/arm-smmu.c | 6 ++--- drivers/iommu/arm/arm-smmu/qcom_iommu.c | 9 ++----- drivers/iommu/intel/iommu.c | 10 +++----- drivers/iommu/iommu.c | 28 +++++++++++++++++++++ drivers/iommu/ipmmu-vmsa.c | 4 +-- drivers/iommu/mtk_iommu_v1.c | 2 +- drivers/iommu/omap-iommu.c | 3 +-- drivers/iommu/s390-iommu.c | 2 +- drivers/iommu/sprd-iommu.c | 6 ++--- drivers/iommu/tegra-gart.c | 2 +- drivers/iommu/virtio-iommu.c | 3 +-- 14 files changed, 49 insertions(+), 47 deletions(-)
drivers/iommu/amd/iommu.c +1 -1
@@ -1662,7 +1662,7 @@ static int attach_device(struct device *dev,if (domain->flags &PD_IOMMUV2_MASK ) {struct iommu_domain *def_domain =iommu_get_dma_domain (dev); - ret = -EINVAL ; + ret = -EMEDIUMTYPE ;if (def_domain->type !=IOMMU_DOMAIN_IDENTITY ) goto out;
drivers/iommu/apple-dart.c +2 -2
@@ -495,10 +495,10 @@ static int apple_dart_attach_dev(struct iommu_domain *domain,if (cfg->stream_maps[0 ].dart->force_bypass && domain->type !=IOMMU_DOMAIN_IDENTITY ) -return -EINVAL ; +return -EMEDIUMTYPE ;if (!cfg->stream_maps[0 ].dart->supports_bypass && domain->type ==IOMMU_DOMAIN_IDENTITY ) -return -EINVAL ; +return -EMEDIUMTYPE ; ret =apple_dart_finalize_domain (domain, cfg);if (ret)
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +3 -12
@@ -2420,24 +2420,15 @@ static int arm_smmu_attach_dev(struct iommu_domain *domain, struct device *dev) goto out_unlock; } }else if (smmu_domain->smmu != smmu) { -dev_err (dev, -"cannot attach to SMMU %s (upstream of %s)\n" , -dev_name (smmu_domain->smmu->dev), -dev_name (smmu->dev)); - ret = -ENXIO ; + ret = -EMEDIUMTYPE ; goto out_unlock; }else if (smmu_domain->stage ==ARM_SMMU_DOMAIN_S1 && master->ssid_bits != smmu_domain->s1_cfg.s1cdmax) { -dev_err (dev, -"cannot attach to incompatible domain (%u SSID bits != %u)\n" , - smmu_domain->s1_cfg.s1cdmax, master->ssid_bits); - ret = -EINVAL ; + ret = -EMEDIUMTYPE ; goto out_unlock; }else if (smmu_domain->stage ==ARM_SMMU_DOMAIN_S1 && smmu_domain->stall_enabled != master->stall_enabled) { -dev_err (dev,"cannot attach to stall-%s domain\n" , - smmu_domain->stall_enabled ?"enabled" :"disabled" ); - ret = -EINVAL ; + ret = -EMEDIUMTYPE ; goto out_unlock; }
drivers/iommu/arm/arm-smmu/arm-smmu.c +2 -4
@@ -1135,10 +1135,8 @@ static int arm_smmu_attach_dev(struct iommu_domain *domain, struct device *dev)struct arm_smmu_device *smmu;int ret; -if (!fwspec || fwspec->ops != &arm_smmu_ops) { -dev_err (dev,"cannot attach to SMMU, is it on the same bus?\n" ); -return -ENXIO ; - } +if (!fwspec || fwspec->ops != &arm_smmu_ops) +return -EMEDIUMTYPE ;/* * FIXME: The arch/arm DMA API code tries to attach devices to its own
drivers/iommu/arm/arm-smmu/qcom_iommu.c +2 -7
@@ -381,13 +381,8 @@ static int qcom_iommu_attach_dev(struct iommu_domain *domain, struct device *dev* Sanity check the domain. We don't support domains across * different IOMMUs. */ -if (qcom_domain->iommu != qcom_iommu) { -dev_err (dev,"cannot attach to IOMMU %s while already " -"attached to domain on IOMMU %s\n" , -dev_name (qcom_domain->iommu->dev), -dev_name (qcom_iommu->dev)); -return -EINVAL ; - } +if (qcom_domain->iommu != qcom_iommu) +return -EMEDIUMTYPE ;return 0 ; }
drivers/iommu/intel/iommu.c +3 -7
@@ -4323,19 +4323,15 @@ static int prepare_domain_attach_device(struct iommu_domain *domain,return -ENODEV ;if (dmar_domain->force_snooping && !ecap_sc_support (iommu->ecap)) -return -EOPNOTSUPP ; +return -EMEDIUMTYPE ;/* check if this iommu agaw is sufficient for max mapped address */ addr_width =agaw_to_width (iommu->agaw);if (addr_width >cap_mgaw (iommu->cap)) addr_width =cap_mgaw (iommu->cap); -if (dmar_domain->max_addr > (1LL << addr_width)) { -dev_err (dev,"%s: iommu width (%d) is not " -"sufficient for the mapped address (%llx)\n" , - __func__, addr_width, dmar_domain->max_addr); -return -EFAULT ; - } +if (dmar_domain->max_addr > (1LL << addr_width)) +return -EMEDIUMTYPE ; dmar_domain->gaw = addr_width;/*
drivers/iommu/iommu.c +28 -0
@@ -1972,6 +1972,20 @@ static int __iommu_attach_device(struct iommu_domain *domain,return ret; } +/** +* iommu_attach_device - Attach a device to an IOMMU domain +* @domain: IOMMU domain to attach +* @dev: Device that will be attached +* +* Returns 0 on success and error code on failure +* +* Specifically, -EMEDIUMTYPE is returned as a soft failure if the domain and +* the device are incompatible in some way. This indicates that a caller should +* try another existing IOMMU domain or allocate a new one. And note that it's +* recommended to keep kernel print free when reporting -EMEDIUMTYPE error, as +* this function can be called to test compatibility with domains that will fail +* the test, which will result in a kernel log spam. +*/ int iommu_attach_device (struct iommu_domain *domain,struct device *dev) {struct iommu_group *group;
@@ -2098,6 +2112,20 @@ static int __iommu_attach_group(struct iommu_domain *domain,return ret; } +/** +* iommu_attach_group - Attach an IOMMU group to an IOMMU domain +* @domain: IOMMU domain to attach +* @group: IOMMU group that will be attached +* +* Returns 0 on success and error code on failure +* +* Specifically, -EMEDIUMTYPE is returned as a soft failure if the domain and +* the device are incompatible in some way. This indicates that a caller should +* try another existing IOMMU domain or allocate a new one. And note that it's +* recommended to keep kernel print free when reporting -EMEDIUMTYPE error, as +* this function can be called to test compatibility with domains that will fail +* the test, which will result in a kernel log spam. +*/ int iommu_attach_group (struct iommu_domain *domain,struct iommu_group *group) {int ret;
drivers/iommu/ipmmu-vmsa.c +1 -3
@@ -628,9 +628,7 @@ static int ipmmu_attach_device(struct iommu_domain *io_domain,* Something is wrong, we can't attach two devices using * different IOMMUs to the same domain. */ -dev_err (dev,"Can't attach IPMMU %s to domain on IPMMU %s\n" , -dev_name (mmu->dev),dev_name (domain->mmu->dev)); - ret = -EINVAL ; + ret = -EMEDIUMTYPE ; }else dev_info (dev,"Reusing IPMMU context %u\n" , domain->context_id);
drivers/iommu/mtk_iommu_v1.c +1 -1
@@ -304,7 +304,7 @@ static int mtk_iommu_v1_attach_device(struct iommu_domain *domain, struct device/* Only allow the domain created internally. */ mtk_mapping = data->mapping;if (mtk_mapping->domain != domain) -return 0 ; +return -EMEDIUMTYPE ;if (!data->m4u_dom) { data->m4u_dom = dom;
drivers/iommu/omap-iommu.c +1 -2
@@ -1471,8 +1471,7 @@ omap_iommu_attach_dev(struct iommu_domain *domain, struct device *dev)/* only a single client device can be attached to a domain */ if (omap_domain->dev) { -dev_err (dev,"iommu domain is already attached\n" ); - ret = -EBUSY ; + ret = -EMEDIUMTYPE ; goto out; }
drivers/iommu/s390-iommu.c +1 -1
@@ -127,7 +127,7 @@ static int s390_iommu_attach_device(struct iommu_domain *domain,/* Allow only devices with identical DMA range limits */ }else if (domain->geometry.aperture_start != zdev->start_dma || domain->geometry.aperture_end != zdev->end_dma) { - rc = -EINVAL ; + rc = -EMEDIUMTYPE ;spin_unlock_irqrestore (&s390_domain->list_lock, flags); goto out_restore; }
drivers/iommu/sprd-iommu.c +2 -4
@@ -237,10 +237,8 @@ static int sprd_iommu_attach_device(struct iommu_domain *domain,struct sprd_iommu_domain *dom =to_sprd_domain (domain);size_t pgt_size =sprd_iommu_pgt_size (domain); -if (dom->sdev) { -pr_err ("There's already a device attached to this domain.\n" ); -return -EINVAL ; - } +if (dom->sdev) +return -EMEDIUMTYPE ; dom->pgt_va =dma_alloc_coherent (sdev->dev, pgt_size, &dom->pgt_pa,GFP_KERNEL );if (!dom->pgt_va)
drivers/iommu/tegra-gart.c +1 -1
@@ -112,7 +112,7 @@ static int gart_iommu_attach_dev(struct iommu_domain *domain,spin_lock (&gart->dom_lock);if (gart->active_domain && gart->active_domain != domain) { - ret = -EBUSY ; + ret = -EMEDIUMTYPE ; }else if (dev_iommu_priv_get (dev) != domain) {dev_iommu_priv_set (dev, domain); gart->active_domain = domain;
drivers/iommu/virtio-iommu.c +1 -2
@@ -733,8 +733,7 @@ static int viommu_attach_dev(struct iommu_domain *domain, struct device *dev)*/ ret =viommu_domain_finalise (vdev, domain); }else if (vdomain->viommu != vdev->viommu) { -dev_err (dev,"cannot attach to foreign vIOMMU\n" ); - ret = -EXDEV ; + ret = -EMEDIUMTYPE ; }mutex_unlock (&vdomain->mutex);
Signature · 6 lines
2.17.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
Baolu Lu
maintainerRe: [PATCH v3 1/5] iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
drivers/iommu/mtk_iommu_v1.c static int mtk_iommu_v1_attach_device(struct iommu_domain *domain, struct device · line 310
Quoted 13 lines · Nicolin Chen
drivers/iommu/mtk_iommu_v1.c +1
-1@@ -304,7 +304,7 @@ static int mtk_iommu_v1_attach_device(struct iommu_domain *domain, struct device/* Only allow the domain created internally. */ mtk_mapping = data->mapping;if (mtk_mapping->domain != domain) -return 0 ; +return -EMEDIUMTYPE ;if (!data->m4u_dom) { data->m4u_dom = dom;
This change looks odd. It turns the return value from success to failure. Is it a bug? If so, it should go through a separated fix patch.
Best regards,
baolu
Re: [PATCH v3 1/5] iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
Quoted 15 lines · Baolu Lu
External email: Use caution opening links or attachments
Quoted 11 lines · Nicolin Chen
drivers/iommu/mtk_iommu_v1.c +1
-1@@ -304,7 +304,7 @@ static int mtk_iommu_v1_attach_device(struct iommu_domain *domain, struct device/* Only allow the domain created internally. */ mtk_mapping = data->mapping;if (mtk_mapping->domain != domain) -return 0 ; +return -EMEDIUMTYPE ;
Quoted 5 lines
drivers/iommu/mtk_iommu_v1.c static int mtk_iommu_v1_attach_device(struct iommu_domain *domain, struct device · line 310
Quoted 2 lines
drivers/iommu/mtk_iommu_v1.c +0
-0if (!data->m4u_dom) { data->m4u_dom = dom;This change looks odd. It turns the return value from success to failure. Is it a bug? If so, it should go through a separated fix patch.
Makes sense.
I read the commit log of the original change:
https://lore.kernel.org/r/[email protected]
It doesn't seem to allow devices to get attached to different domains other than the shared mapping->domain, created in the in the mtk_iommu_probe_device(). So it looks like returning 0 is intentional. Though I am still very confused by this return value here, I doubt it has ever been used in a VFIO context.
Young, would you please give us some input?
Overall, I feel it's better to play it safe here by dropping this part. If we later confirm there is a need to fix it, we will do that in a separate patch anyway.
Thanks
Nic
Yong Wu
maintainerRe: [PATCH v3 1/5] iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
Quoted 18 lines · Nicolin Chen
Quoted 17 lines · Baolu Lu
External email: Use caution opening links or attachments
Quoted 13 lines · Nicolin Chen
drivers/iommu/mtk_iommu_v1.c +0
-0@@ -304,7 +304,7 @@ static int mtk_iommu_v1_attach_device(struct
iommu_domain*domain, struct device/* Only allow the domain created internally. */ mtk_mapping = data->mapping; if (mtk_mapping->domain != domain)drivers/iommu/mtk_iommu_v1.c +1
-1-return 0 ; +return -EMEDIUMTYPE ;
Quoted 6 lines
Quoted 6 lines
Quoted 2 lines
if (!data->m4u_dom) { data->m4u_dom = dom;This change looks odd. It turns the return value from success to failure. Is it a bug? If so, it should go through a separated fix patch.
Thanks for the review:)
Quoted 5 lines
Makes sense.
I read the commit log of the original change:
https://lore.kernel.org/r/[email protected]
Quoted 6 lines
It doesn't seem to allow devices to get attached to different domains other than the shared
mapping->domain, created in the in themtk_iommu_probe_device(). So it looks like returning 0 is intentional. Though I am still very confused by this return value here, I doubt it has ever been used in a VFIO context.
It's not used in VFIO context. "return 0" just satisfy the iommu framework to go ahead. and yes, here we only allow the shared "mapping-
Quoted 1 line
domain" (All the devices share a domain created internally).
thus I think we should still keep "return 0" here.
Thanks:)
Quoted 9 lines
Young, would you please give us some input?
Overall, I feel it's better to play it safe here by dropping this part. If we later confirm there is a need to fix it, we will do that in a separate patch anyway.
Thanks
Nic
Re: [PATCH v3 1/5] iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
Quoted 35 lines · Yong Wu
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
drivers/iommu/mtk_iommu_v1.c +0
-0@@ -304,7 +304,7 @@ static int mtk_iommu_v1_attach_device(struct
iommu_domain*domain, struct device/* Only allow the domain created internally. */ mtk_mapping = data->mapping; if (mtk_mapping->domain != domain)drivers/iommu/mtk_iommu_v1.c +1
-1-return 0 ; +return -EMEDIUMTYPE ;Quoted 6 lines
Quoted 6 lines
Quoted 2 lines
if (!data->m4u_dom) { data->m4u_dom = dom;This change looks odd. It turns the return value from success to failure. Is it a bug? If so, it should go through a separated fix patch.
Thanks for the review:)
Quoted 5 lines
Makes sense.
I read the commit log of the original change:
https://lore.kernel.org/r/[email protected]
Quoted 6 lines
It doesn't seem to allow devices to get attached to different domains other than the shared
mapping->domain, created in the in themtk_iommu_probe_device(). So it looks like returning 0 is intentional. Though I am still very confused by this return value here, I doubt it has ever been used in a VFIO context.
Quoted 5 lines
It's not used in VFIO context. "return 0" just satisfy the iommu framework to go ahead. and yes, here we only allow the shared "mapping-
Quoted 1 line
domain" (All the devices share a domain created internally).
thus I think we should still keep "return 0" here.
Thanks for the reply. I will just drop the change of this file.
RE: [PATCH v3 1/5] iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
In reply to Yong WuQuoted 45 lines
From: Yong Wu
Sent: Friday, June 24, 2022 1:39 PMQuoted 18 lines · Nicolin Chen
Quoted 17 lines · Baolu Lu
External email: Use caution opening links or attachments
Quoted 13 lines · Nicolin Chen
drivers/iommu/mtk_iommu_v1.c +0
-0@@ -304,7 +304,7 @@ static int mtk_iommu_v1_attach_device(struct
iommu_domain*domain, struct device/* Only allow the domain created internally. */ mtk_mapping = data->mapping; if (mtk_mapping->domain != domain)drivers/iommu/mtk_iommu_v1.c +1
-1-return 0 ; +return -EMEDIUMTYPE ;Quoted 6 lines
Quoted 6 lines
Quoted 2 lines
if (!data->m4u_dom) { data->m4u_dom = dom;This change looks odd. It turns the return value from success to failure. Is it a bug? If so, it should go through a separated fix patch.
Thanks for the review:)
Quoted 5 lines
Makes sense.
I read the commit log of the original change:
https://lore.kernel.org/r/1589530123-30240-1-git-send-email-
[email protected]Quoted 6 lines
It doesn't seem to allow devices to get attached to different domains other than the shared
mapping->domain, created in the in themtk_iommu_probe_device(). So it looks like returning 0 is intentional. Though I am still very confused by this return value here, I doubt it has ever been used in a VFIO context.
Quoted 6 lines
It's not used in VFIO context. "return 0" just satisfy the iommu framework to go ahead. and yes, here we only allow the shared "mapping-
Quoted 1 line
domain" (All the devices share a domain created internally).
thus I think we should still keep "return 0" here.
What prevent this driver from being used in VFIO context?
and why would we want to go ahead when an obvious error occurs i.e. when a device is attached to an unexpected domain?
Yong Wu
maintainerRe: [PATCH v3 1/5] iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
Quoted 52 lines · Kevin
Quoted 52 lines
From: Yong Wu
Sent: Friday, June 24, 2022 1:39 PMQuoted 19 lines · Nicolin Chen
Quoted 18 lines · Baolu Lu
External email: Use caution opening links or attachments
Quoted 14 lines · Nicolin Chen
drivers/iommu/mtk_iommu_v1.c +0
-0@@ -304,7 +304,7 @@ static intmtk_iommu_v1_attach_device(struct
iommu_domain*domain, struct device/* Only allow the domain created internally. */ mtk_mapping = data->mapping; if (mtk_mapping->domain != domain)drivers/iommu/mtk_iommu_v1.c +1
-1-return 0 ; +return -EMEDIUMTYPE ;Quoted 8 lines
Quoted 8 lines
Quoted 2 lines
if (!data->m4u_dom) { data->m4u_dom = dom;This change looks odd. It turns the return value from success to
failure. Is it a bug? If so, it should go through a separated fix
patch.Thanks for the review:)
Quoted 5 lines
Makes sense.
I read the commit log of the original change:
https://lore.kernel.org/r/1589530123-30240-1-git-send-email-
[email protected]Quoted 6 lines
It doesn't seem to allow devices to get attached to different domains other than the shared
mapping->domain, created in the in themtk_iommu_probe_device(). So it looks like returning 0 is intentional. Though I am still very confused by this return value here, I doubt it has ever been used in a VFIO context.It's not used in VFIO context. "return 0" just satisfy the iommu framework to go ahead. and yes, here we only allow the shared "mapping-
Quoted 6 lines
Quoted 4 lines
Quoted 1 line
domain" (All the devices share a domain created internally).
thus I think we should still keep "return 0" here.
What prevent this driver from being used in VFIO context?
Nothing prevent this. Just I didn't test. mtk_iommu_v1.c only is used in mt2701 and there is no VFIO scenario. I'm not sure if it supports VFIO. (mtk_iommu.c support VFIO.)
Quoted 2 lines
and why would we want to go ahead when an obvious error occurs i.e. when a device is attached to an unexpected domain?
The iommu flow in this file always is a bit odd as we need share iommu domain in ARM32. As I tested before in the above link, "The iommu framework will create a iommu domain for each a device.", therefore we have to *workaround* in this file.
And this was expected to be fixed by:
https://lore.kernel.org/linux-iommu/[email protected]/
sorry, I don't know its current status.
Thanks.
Re: [PATCH v3 1/5] iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
Quoted 4 lines · Yong Wu
Quoted 4 lines
Quoted 4 lines
It's not used in VFIO context. "return 0" just satisfy the iommu framework to go ahead. and yes, here we only allow the shared "mapping-domain" (All the devices share a domain created internally).
What part of the iommu framework is trying to attach a domain and wants to see success when the domain was not actually attached ?
Quoted 3 lines
Quoted 1 line
What prevent this driver from being used in VFIO context?
Nothing prevent this. Just I didn't test.
This is why it is wrong to return success here.
Jason
Re: [PATCH v3 1/5] iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
Quoted 7 lines · Jason Gunthorpe
Quoted 4 lines · Yong Wu
Quoted 4 lines
Quoted 4 lines
It's not used in VFIO context. "return 0" just satisfy the iommu framework to go ahead. and yes, here we only allow the shared "mapping-domain" (All the devices share a domain created internally).
Quoted 8 lines
What part of the iommu framework is trying to attach a domain and wants to see success when the domain was not actually attached ?
Quoted 3 lines
Quoted 1 line
What prevent this driver from being used in VFIO context?
Nothing prevent this. Just I didn't test.
This is why it is wrong to return success here.
Hi Yong, would you or someone you know be able to confirm whether this "return 0" is still a must or not?
Considering that it's an old 32-bit platform for MTK, if it would take time to do so, I'd like to drop the change in MTK driver and note in commit log for you or other MTK folks to change in future.
Thanks
Nic
Robin Murphy
reviewerRe: [PATCH v3 1/5] iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
Quoted 11 lines · Nicolin Chen
Quoted 10 lines · Jason Gunthorpe
Quoted 4 lines · Yong Wu
Quoted 4 lines
Quoted 4 lines
It's not used in VFIO context. "return 0" just satisfy the iommu framework to go ahead. and yes, here we only allow the shared "mapping-domain" (All the devices share a domain created internally).
What part of the iommu framework is trying to attach a domain and wants to see success when the domain was not actually attached ?
Quoted 8 lines
Quoted 5 lines
Quoted 3 lines
Quoted 1 line
What prevent this driver from being used in VFIO context?
Nothing prevent this. Just I didn't test.
This is why it is wrong to return success here.
Hi Yong, would you or someone you know be able to confirm whether this "return 0" is still a must or not?
From memory, it is unfortunately required, due to this driver being in the rare position of having to support multiple devices in a single address space on 32-bit ARM. Since the old ARM DMA code doesn't understand groups, the driver sets up its own canonical dma_iommu_mapping to act like a default domain, but then has to politely say "yeah OK" to arm_setup_iommu_dma_ops() for each device so that they do all end up with the right DMA ops rather than dying in screaming failure (the ARM code's per-device mappings then get leaked, but we can't really do any better).
The whole mess disappears in the proper default domain conversion, but in the meantime, it's still safe to assume that nobody's doing VFIO with embedded display/video codec/etc. blocks that don't even have reset drivers.
Thanks,
Robin.
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
RE: [PATCH v3 1/5] iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
Quoted 34 lines
From: Robin Murphy <[email protected]>
Sent: Thursday, June 30, 2022 4:22 PMQuoted 11 lines · Nicolin Chen
Quoted 10 lines · Jason Gunthorpe
Quoted 4 lines · Yong Wu
Quoted 4 lines
Quoted 4 lines
It's not used in VFIO context. "return 0" just satisfy the iommu framework to go ahead. and yes, here we only allow the shared "mapping-domain" (All the devices share a domain created internally).
What part of the iommu framework is trying to attach a domain and wants to see success when the domain was not actually attached ?
Quoted 8 lines
Quoted 5 lines
Quoted 3 lines
Quoted 1 line
What prevent this driver from being used in VFIO context?
Nothing prevent this. Just I didn't test.
This is why it is wrong to return success here.
Hi Yong, would you or someone you know be able to confirm whether this "return 0" is still a must or not?
From memory, it is unfortunately required, due to this driver being in
the rare position of having to support multiple devices in a single address space on 32-bit ARM. Since the old ARM DMA code doesn't understand groups, the driver sets up its own canonicaldma_iommu_mappingto act like a default domain, but then has to politely say "yeah OK" toarm_setup_iommu_dma_ops()for each device so that they do all end up with the right DMA ops rather than dying in screaming failure (the ARM code's per-device mappings then get leaked, but we can't really do any better).
Quoted 4 lines
The whole mess disappears in the proper default domain conversion, but in the meantime, it's still safe to assume that nobody's doing VFIO with embedded display/video codec/etc. blocks that don't even have reset drivers.
Probably above is worth a comment in mtk code so we don't need always dig it out from memory when similar question arises in the the future. 😊
Re: [PATCH v3 1/5] iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
In reply to Robin MurphyQuoted 34 lines · Robin Murphy
External email: Use caution opening links or attachments
Quoted 11 lines · Nicolin Chen
Quoted 10 lines · Jason Gunthorpe
Quoted 4 lines · Yong Wu
Quoted 4 lines
Quoted 4 lines
It's not used in VFIO context. "return 0" just satisfy the iommu framework to go ahead. and yes, here we only allow the shared "mapping-domain" (All the devices share a domain created internally).
What part of the iommu framework is trying to attach a domain and wants to see success when the domain was not actually attached ?
Quoted 8 lines
Quoted 5 lines
Quoted 3 lines
Quoted 1 line
What prevent this driver from being used in VFIO context?
Nothing prevent this. Just I didn't test.
This is why it is wrong to return success here.
Hi Yong, would you or someone you know be able to confirm whether this "return 0" is still a must or not?
From memory, it is unfortunately required, due to this driver being in the rare position of having to support multiple devices in a single address space on 32-bit ARM. Since the old ARM DMA code doesn't understand groups, the driver sets up its own canonical
dma_iommu_mappingto act like a default domain, but then has to politely say "yeah OK" toarm_setup_iommu_dma_ops()for each device so that they do all end up with the right DMA ops rather than dying in screaming failure (the ARM code's per-device mappings then get leaked, but we can't really do any better).
Quoted 3 lines
The whole mess disappears in the proper default domain conversion, but in the meantime, it's still safe to assume that nobody's doing VFIO with embedded display/video codec/etc. blocks that don't even have reset drivers.
Thanks for the input! I'll just respin it by dropping mtk_v1 diff.
Nic
Yong Wu
maintainerRe: [PATCH v3 1/5] iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
In reply to Nicolin ChenQuoted 16 lines · Nicolin Chen
Quoted 15 lines · Jason Gunthorpe
Quoted 5 lines · Yong Wu
Quoted 5 lines
Quoted 5 lines
It's not used in VFIO context. "return 0" just satisfy the iommu
framework to go ahead. and yes, here we only allow the shared "mapping-domain" (All the devices share a domain created internally).What part of the iommu framework is trying to attach a domain and wants to see success when the domain was not actually attached ?
Quoted 3 lines
Quoted 1 line
What prevent this driver from being used in VFIO context?
Nothing prevent this. Just I didn't test.
Quoted 8 lines
Quoted 1 line
This is why it is wrong to return success here.
Hi Yong, would you or someone you know be able to confirm whether this "return 0" is still a must or not?
Considering that it's an old 32-bit platform for MTK, if it would take time to do so, I'd like to drop the change in MTK driver and note in commit log for you or other MTK folks to change in future.
Yes. Please help drop the change in this file.
Sorry I don't have the board at hand right now and I could not list the backtrace where this is needed(should be bus_iommu_probe from the previous debug...)
Quoted 3 lines
Thanks
Nic
Re: [PATCH v3 1/5] iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
Quoted 29 lines · Yong Wu
External email: Use caution opening links or attachments
Quoted 16 lines · Nicolin Chen
Quoted 15 lines · Jason Gunthorpe
Quoted 5 lines · Yong Wu
Quoted 5 lines
Quoted 5 lines
It's not used in VFIO context. "return 0" just satisfy the iommu
framework to go ahead. and yes, here we only allow the shared "mapping-domain" (All the devices share a domain created internally).What part of the iommu framework is trying to attach a domain and wants to see success when the domain was not actually attached ?
Quoted 3 lines
Quoted 1 line
What prevent this driver from being used in VFIO context?
Nothing prevent this. Just I didn't test.
Quoted 8 lines
Quoted 1 line
This is why it is wrong to return success here.
Hi Yong, would you or someone you know be able to confirm whether this "return 0" is still a must or not?
Considering that it's an old 32-bit platform for MTK, if it would take time to do so, I'd like to drop the change in MTK driver and note in commit log for you or other MTK folks to change in future.
Quoted 5 lines
Yes. Please help drop the change in this file.
Sorry I don't have the board at hand right now and I could not list the backtrace where this is
needed(should be bus_iommu_probe from the previous debug...)
OK. Thanks for the reply.
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
PATCH v3 2/5 vfio/iommu_type1: Prefer to reuse domains vs match enforced cache coherency
In reply to Nicolin ChenFrom: Jason Gunthorpe <[email protected]>
The KVM mechanism for controlling wbinvd is based on OR of the coherency property of all devices attached to a guest, no matter whether those devices are attached to a single domain or multiple domains.
On the other hand, the benefit to using separate domains was that those devices attached to domains supporting enforced cache coherency always mapped with the attributes necessary to provide that feature, therefore if a non-enforced domain was dropped, the associated group removal would re-trigger an evaluation by KVM.
In practice however, the only known cases of such mixed domains included an Intel IGD device behind an IOMMU lacking snoop control, where such devices do not support hotplug, therefore this scenario lacks testing and is not considered sufficiently relevant to support.
After all, KVM won't take advantage of trying to push a device that could do enforced cache coherency to a dedicated domain vs re-using an existing domain, which is non-coherent.
Simplify this code and eliminate the test. This removes the only logic that needed to have a dummy domain attached prior to searching for a matching domain and simplifies the next patches.
It's unclear whether we want to further optimize the Intel driver to update the domain coherency after a device is detached from it, at least not before KVM can be verified to handle such dynamics in related emulation paths (wbinvd, vcpu load, write_cr0, ept, etc.). In reality we don't see an usage requiring such optimization as the only device which imposes such non-coherency is Intel GPU which even doesn't support hotplug/hot remove.
--- drivers/vfio/vfio_iommu_type1.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
drivers/vfio/vfio_iommu_type1.c +1 -3
@@ -2285,9 +2285,7 @@ static int vfio_iommu_type1_attach_group(void *iommu_data,* testing if they're on the same bus_type. */ list_for_each_entry (d, &iommu->domain_list, next) { -if (d->domain->ops == domain->domain->ops && - d->enforce_cache_coherency == - domain->enforce_cache_coherency) { +if (d->domain->ops == domain->domain->ops) {iommu_detach_group (domain->domain, group->iommu_group);if (!iommu_attach_group (d->domain, group->iommu_group)) {
Signature · 1 line
2.17.1
Re: [PATCH v3 2/5] vfio/iommu_type1: Prefer to reuse domains vs match enforced cache coherency
Quoted 45 lines · Nicolin Chen
From: Jason Gunthorpe <[email protected]>
The KVM mechanism for controlling wbinvd is based on OR of the coherency property of all devices attached to a guest, no matter whether those devices are attached to a single domain or multiple domains.
On the other hand, the benefit to using separate domains was that those devices attached to domains supporting enforced cache coherency always mapped with the attributes necessary to provide that feature, therefore if a non-enforced domain was dropped, the associated group removal would re-trigger an evaluation by KVM.
In practice however, the only known cases of such mixed domains included an Intel IGD device behind an IOMMU lacking snoop control, where such devices do not support hotplug, therefore this scenario lacks testing and is not considered sufficiently relevant to support.
After all, KVM won't take advantage of trying to push a device that could do enforced cache coherency to a dedicated domain vs re-using an existing domain, which is non-coherent.
Simplify this code and eliminate the test. This removes the only logic that needed to have a dummy domain attached prior to searching for a matching domain and simplifies the next patches.
It's unclear whether we want to further optimize the Intel driver to update the domain coherency after a device is detached from it, at least not before KVM can be verified to handle such dynamics in related emulation paths (wbinvd, vcpu load,
write_cr0, ept, etc.). In reality we don't see an usage requiring such optimization as the only device which imposes such non-coherency is Intel GPU which even doesn't support hotplug/hot remove.Signed-off-by Jason Gunthorpe <[email protected]>Reviewed-by Kevin Tian <[email protected]>Signed-off-by Nicolin Chen <[email protected]>--- drivers/vfio/vfio_iommu_type1.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)drivers/vfio/vfio_iommu_type1.c +0
-0
drivers/vfio/vfio_iommu_type1.c static int vfio_iommu_type1_attach_group(void *iommu_data, · line 2291
Quoted 10 lines
drivers/vfio/vfio_iommu_type1.c +1
-3@@ -2285,9 +2285,7 @@ static int vfio_iommu_type1_attach_group(void *iommu_data,* testing if they're on the same bus_type. */ list_for_each_entry (d, &iommu->domain_list, next) { -if (d->domain->ops == domain->domain->ops && - d->enforce_cache_coherency == - domain->enforce_cache_coherency) { +if (d->domain->ops == domain->domain->ops) {iommu_detach_group (domain->domain, group->iommu_group);if (!iommu_attach_group (d->domain, group->iommu_group)) {
Best regards,
baolu
PATCH v3 3/5 vfio/iommu_type1: Remove the domain->ops comparison
In reply to Nicolin ChenThe domain->ops validation was added, as a precaution, for mixed-driver systems.
Per Robin's remarks,
* While bus_set_iommu() still exists, the core code prevents multiple drivers from registering, so we can't really run into a situation of having a mixed-driver system:
https://lore.kernel.org/kvm/[email protected]/
* And there's plenty more significant problems than this to fix; in future when many can be permitted, we will rely on the IOMMU core code to check the domain->ops:
https://lore.kernel.org/kvm/[email protected]/
So remove the check in VFIO for simplicity.
--- drivers/vfio/vfio_iommu_type1.c | 32 +++++++++++--------------------- 1 file changed, 11 insertions(+), 21 deletions(-)
drivers/vfio/vfio_iommu_type1.c +11 -21
@@ -2277,29 +2277,19 @@ static int vfio_iommu_type1_attach_group(void *iommu_data, domain->domain->ops->enforce_cache_coherency ( domain->domain); -/* -* Try to match an existing compatible domain. We don't want to -* preclude an IOMMU driver supporting multiple bus_types and being -* able to include different bus_types in the same IOMMU domain, so -* we test whether the domains use the same iommu_ops rather than -* testing if they're on the same bus_type. -*/ +/* Try to match an existing compatible domain */ list_for_each_entry (d, &iommu->domain_list, next) { -if (d->domain->ops == domain->domain->ops) { -iommu_detach_group (domain->domain, group->iommu_group); -if (!iommu_attach_group (d->domain, - group->iommu_group)) { -list_add (&group->next, &d->group_list); -iommu_domain_free (domain->domain); -kfree (domain); - goto done; - } - - ret =iommu_attach_group (domain->domain, - group->iommu_group); -if (ret) - goto out_domain; +iommu_detach_group (domain->domain, group->iommu_group); +if (!iommu_attach_group (d->domain, group->iommu_group)) { +list_add (&group->next, &d->group_list); +iommu_domain_free (domain->domain); +kfree (domain); + goto done; } + + ret =iommu_attach_group (domain->domain, group->iommu_group); +if (ret) + goto out_domain; }vfio_test_domain_fgsp (domain);
Signature · 1 line
2.17.1
Re: [PATCH v3 3/5] vfio/iommu_type1: Remove the domain->ops comparison
Quoted 9 lines · Nicolin Chen
The
domain->opsvalidation was added, as a precaution, for mixed-driver systems.Per Robin's remarks,
* Whilebus_set_iommu()still exists, the core code prevents multiple drivers from registering, so we can't really run into a situation of having a mixed-driver system:
https://lore.kernel.org/kvm/[email protected]/
Quoted 6 lines
* And there's plenty more significant problems than this to fix; in future when many can be permitted, we will rely on the IOMMU core code to check the
domain->ops:
https://lore.kernel.org/kvm/[email protected]/So remove the check in VFIO for simplicity.
As discussed we can't remove this check, multiple iommus on different busses are allowed today and VFIO does not restrict its attempts to attach a pre-existing domain to a single group or bus.
Please go back to the original version with the ops check in the core code.
Jason
Re: [PATCH v3 3/5] vfio/iommu_type1: Remove the domain->ops comparison
Quoted 15 lines · Jason Gunthorpe
Quoted 14 lines · Nicolin Chen
The
domain->opsvalidation was added, as a precaution, for mixed-driver systems.Per Robin's remarks,
* Whilebus_set_iommu()still exists, the core code prevents multiple drivers from registering, so we can't really run into a situation of having a mixed-driver system:
https://lore.kernel.org/kvm/[email protected]/* And there's plenty more significant problems than this to fix; in future when many can be permitted, we will rely on the IOMMU core code to check the
domain->ops:
https://lore.kernel.org/kvm/[email protected]/
Quoted 8 lines
Quoted 1 line
So remove the check in VFIO for simplicity.
As discussed we can't remove this check, multiple iommus on different busses are allowed today and VFIO does not restrict its attempts to attach a pre-existing domain to a single group or bus.
Please go back to the original version with the ops check in the core code.
Robin convinced me, so never mind :)
Jason
PATCH v3 4/5 vfio/iommu_type1: Clean up update_dirty_scope in detach_group()
In reply to Nicolin ChenAll devices in emulated_iommu_groups have pinned_page_dirty_scope set, so the update_dirty_scope in the first list_for_each_entry is always false. Clean it up, and move the "if update_dirty_scope" part from the detach_group_done routine to the domain_list part.
--- drivers/vfio/vfio_iommu_type1.c | 27 ++++++++++++--------------- 1 file changed, 12 insertions(+), 15 deletions(-)
drivers/vfio/vfio_iommu_type1.c +12 -15
@@ -2453,14 +2453,12 @@ static void vfio_iommu_type1_detach_group(void *iommu_data,struct vfio_iommu *iommu = iommu_data;struct vfio_domain *domain;struct vfio_iommu_group *group; -bool update_dirty_scope = false;LIST_HEAD (iova_copy);mutex_lock (&iommu->lock);list_for_each_entry (group, &iommu->emulated_iommu_groups, next) {if (group->iommu_group != iommu_group)continue ; - update_dirty_scope = !group->pinned_page_dirty_scope;list_del (&group->next);kfree (group);
@@ -2469,7 +2467,8 @@ static void vfio_iommu_type1_detach_group(void *iommu_data,WARN_ON (iommu->notifier.head);vfio_iommu_unmap_unpin_all (iommu); } - goto detach_group_done; +mutex_unlock (&iommu->lock); +return ; }/*
@@ -2485,9 +2484,7 @@ static void vfio_iommu_type1_detach_group(void *iommu_data,continue ;iommu_detach_group (domain->domain, group->iommu_group); - update_dirty_scope = !group->pinned_page_dirty_scope;list_del (&group->next); -kfree (group);/* * Group ownership provides privilege, if the group list is * empty, the domain goes away. If it's the last domain with
@@ -2510,6 +2507,16 @@ static void vfio_iommu_type1_detach_group(void *iommu_data,vfio_iommu_aper_expand (iommu, &iova_copy);vfio_update_pgsize_bitmap (iommu); } +/* +* Removal of a group without dirty tracking may allow +* the iommu scope to be promoted. +*/ +if (!group->pinned_page_dirty_scope) { + iommu->num_non_pinned_groups--; +if (iommu->dirty_page_tracking) +vfio_iommu_populate_bitmap_full (iommu); + } +kfree (group);break ; }
@@ -2518,16 +2525,6 @@ static void vfio_iommu_type1_detach_group(void *iommu_data,else vfio_iommu_iova_free (&iova_copy); -detach_group_done: -/* -* Removal of a group without dirty tracking may allow the iommu scope -* to be promoted. -*/ -if (update_dirty_scope) { - iommu->num_non_pinned_groups--; -if (iommu->dirty_page_tracking) -vfio_iommu_populate_bitmap_full (iommu); - }mutex_unlock (&iommu->lock); }
Signature · 6 lines
2.17.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
PATCH v3 5/5 vfio/iommu_type1: Simplify group attachment
In reply to Nicolin ChenUn-inline the domain specific logic from the attach/detach_group ops into two paired functions vfio_iommu_alloc_attach_domain() and vfio_iommu_detach_destroy_domain() that strictly deal with creating and destroying struct vfio_domains.
Add the logic to check for EMEDIUMTYPE return code of iommu_attach_group() and avoid the extra domain allocations and attach/detach sequences of the old code. This allows properly detecting an actual attach error, like -ENOMEM, vs treating all attach errors as an incompatible domain.
--- drivers/vfio/vfio_iommu_type1.c | 321 +++++++++++++++++--------------- 1 file changed, 174 insertions(+), 147 deletions(-)
drivers/vfio/vfio_iommu_type1.c +174 -147
@@ -2153,15 +2153,174 @@ static void vfio_iommu_iova_insert_copy(struct vfio_iommu *iommu,list_splice_tail (iova_copy, iova); } +static struct vfio_domain * +vfio_iommu_alloc_attach_domain (struct bus_type *bus,struct vfio_iommu *iommu, +struct vfio_iommu_group *group, +struct list_head *group_resv_regions) +{ +struct iommu_domain *new_domain; +struct vfio_domain *domain; +phys_addr_t resv_msi_base; +int ret =0 ; + +/* Try to match an existing compatible domain */ + list_for_each_entry (domain, &iommu->domain_list, next) { + ret =iommu_attach_group (domain->domain, group->iommu_group); +/* -EMEDIUMTYPE means an incompatible domain, so try next one */ +if (ret == -EMEDIUMTYPE ) +continue ; +if (ret) +return ERR_PTR (ret); + goto done; + } + + new_domain =iommu_domain_alloc (bus); +if (!new_domain) +return ERR_PTR (-EIO ); + +if (iommu->nesting) { + ret =iommu_enable_nesting (new_domain); +if (ret) + goto out_free_iommu_domain; + } + + ret =iommu_attach_group (new_domain, group->iommu_group); +if (ret) + goto out_free_iommu_domain; + + domain =kzalloc (sizeof (*domain),GFP_KERNEL ); +if (!domain) { + ret = -ENOMEM ; + goto out_detach; + } + + domain->domain = new_domain; +vfio_test_domain_fgsp (domain); + +/* +* If the IOMMU can block non-coherent operations (ie PCIe TLPs with +* no-snoop set) then VFIO always turns this feature on because on Intel +* platforms it optimizes KVM to disable wbinvd emulation. +*/ +if (new_domain->ops->enforce_cache_coherency) + domain->enforce_cache_coherency = + new_domain->ops->enforce_cache_coherency (new_domain); + +/* replay mappings on new domains */ + ret =vfio_iommu_replay (iommu, domain); +if (ret) + goto out_free_domain; + +if (vfio_iommu_has_sw_msi (group_resv_regions, &resv_msi_base)) { + ret =iommu_get_msi_cookie (domain->domain, resv_msi_base); +if (ret && ret != -ENODEV ) + goto out_free_domain; + } + +INIT_LIST_HEAD (&domain->group_list); +list_add (&domain->next, &iommu->domain_list); +vfio_update_pgsize_bitmap (iommu); + +done: +list_add (&group->next, &domain->group_list); + +/* +* An iommu backed group can dirty memory directly and therefore +* demotes the iommu scope until it declares itself dirty tracking +* capable via the page pinning interface. +*/ + iommu->num_non_pinned_groups++; + +return domain; + +out_free_domain: +kfree (domain); +out_detach: +iommu_detach_group (new_domain, group->iommu_group); +out_free_iommu_domain: +iommu_domain_free (new_domain); +return ERR_PTR (ret); +} + +static void vfio_iommu_unmap_unpin_all (struct vfio_iommu *iommu) +{ +struct rb_node *node; + +while ((node =rb_first (&iommu->dma_list))) + vfio_remove_dma(iommu, rb_entry(node, struct vfio_dma, node)); +} + +static void vfio_iommu_unmap_unpin_reaccount (struct vfio_iommu *iommu) +{ +struct rb_node *n, *p; + + n =rb_first (&iommu->dma_list); +for (; n; n =rb_next (n)) { +struct vfio_dma *dma; +long locked =0 , unlocked =0 ; + + dma = rb_entry(n, struct vfio_dma, node); + unlocked +=vfio_unmap_unpin (iommu, dma, false); + p =rb_first (&dma->pfn_list); +for (; p; p =rb_next (p)) { + struct vfio_pfn *vpfn = rb_entry(p, struct vfio_pfn, + node); + +if (!is_invalid_reserved_pfn (vpfn->pfn)) + locked++; + } +vfio_lock_acct (dma, locked - unlocked, true); + } +} + +static void vfio_iommu_detach_destroy_domain (struct vfio_domain *domain, +struct vfio_iommu *iommu, +struct vfio_iommu_group *group) +{ +iommu_detach_group (domain->domain, group->iommu_group); +list_del (&group->next); +if (!list_empty (&domain->group_list)) + goto out_dirty; + +/* +* Group ownership provides privilege, if the group list is empty, the +* domain goes away. If it's the last domain with iommu and external +* domain doesn't exist, then all the mappings go away too. If it's the +* last domain with iommu and external domain exist, update accounting +*/ +if (list_is_singular (&iommu->domain_list)) { +if (list_empty (&iommu->emulated_iommu_groups)) { +WARN_ON (iommu->notifier.head); +vfio_iommu_unmap_unpin_all (iommu); + }else { +vfio_iommu_unmap_unpin_reaccount (iommu); + } + } +iommu_domain_free (domain->domain); +list_del (&domain->next); +kfree (domain); +vfio_update_pgsize_bitmap (iommu); + +out_dirty: +/* +* Removal of a group without dirty tracking may allow the iommu scope +* to be promoted. +*/ +if (!group->pinned_page_dirty_scope) { + iommu->num_non_pinned_groups--; +if (iommu->dirty_page_tracking) +vfio_iommu_populate_bitmap_full (iommu); + } +} +static int vfio_iommu_type1_attach_group (void *iommu_data,struct iommu_group *iommu_group,enum vfio_group_type type) {struct vfio_iommu *iommu = iommu_data;struct vfio_iommu_group *group; -struct vfio_domain *domain, *d; +struct vfio_domain *domain;struct bus_type *bus =NULL ; -bool resv_msi, msi_remap; -phys_addr_t resv_msi_base =0 ; +bool msi_remap;struct iommu_domain_geometry *geo;LIST_HEAD (iova_copy);LIST_HEAD (group_resv_regions);
@@ -2197,26 +2356,17 @@ static int vfio_iommu_type1_attach_group(void *iommu_data,if (ret) goto out_free_group; - ret = -ENOMEM ; - domain =kzalloc (sizeof (*domain),GFP_KERNEL ); -if (!domain) + ret =iommu_get_group_resv_regions (iommu_group, &group_resv_regions); +if (ret) goto out_free_group; - ret = -EIO ; - domain->domain =iommu_domain_alloc (bus); -if (!domain->domain) - goto out_free_domain; - -if (iommu->nesting) { - ret =iommu_enable_nesting (domain->domain); -if (ret) - goto out_domain; + domain =vfio_iommu_alloc_attach_domain (bus, iommu, group, + &group_resv_regions); +if (IS_ERR (domain)) { + ret =PTR_ERR (domain); + goto out_free_group; } - ret =iommu_attach_group (domain->domain, group->iommu_group); -if (ret) - goto out_domain; -/* Get aperture info */ geo = &domain->domain->geometry; if (vfio_iommu_aper_conflict(iommu, geo->aperture_start,
@@ -2225,10 +2375,6 @@ static int vfio_iommu_type1_attach_group(void *iommu_data, goto out_detach; } - ret =iommu_get_group_resv_regions (iommu_group, &group_resv_regions); -if (ret) - goto out_detach; -if (vfio_iommu_resv_conflict (iommu, &group_resv_regions)) { ret = -EINVAL ; goto out_detach;
@@ -2252,11 +2398,6 @@ static int vfio_iommu_type1_attach_group(void *iommu_data,if (ret) goto out_detach; - resv_msi =vfio_iommu_has_sw_msi (&group_resv_regions, &resv_msi_base); - -INIT_LIST_HEAD (&domain->group_list); -list_add (&group->next, &domain->group_list); - msi_remap =irq_domain_check_msi_remap () ||iommu_capable (bus,IOMMU_CAP_INTR_REMAP );
@@ -2267,107 +2408,25 @@ static int vfio_iommu_type1_attach_group(void *iommu_data, goto out_detach; } -/* -* If the IOMMU can block non-coherent operations (ie PCIe TLPs with -* no-snoop set) then VFIO always turns this feature on because on Intel -* platforms it optimizes KVM to disable wbinvd emulation. -*/ -if (domain->domain->ops->enforce_cache_coherency) - domain->enforce_cache_coherency = - domain->domain->ops->enforce_cache_coherency ( - domain->domain); - -/* Try to match an existing compatible domain */ -list_for_each_entry (d, &iommu->domain_list, next) { -iommu_detach_group (domain->domain, group->iommu_group); -if (!iommu_attach_group (d->domain, group->iommu_group)) { -list_add (&group->next, &d->group_list); -iommu_domain_free (domain->domain); -kfree (domain); - goto done; - } - - ret =iommu_attach_group (domain->domain, group->iommu_group); -if (ret) - goto out_domain; - } - -vfio_test_domain_fgsp (domain); - -/* replay mappings on new domains */ - ret =vfio_iommu_replay (iommu, domain); -if (ret) - goto out_detach; - -if (resv_msi) { - ret =iommu_get_msi_cookie (domain->domain, resv_msi_base); -if (ret && ret != -ENODEV ) - goto out_detach; - } - -list_add (&domain->next, &iommu->domain_list); -vfio_update_pgsize_bitmap (iommu); -done:/* Delete the old one and insert new iova list */ vfio_iommu_iova_insert_copy (iommu, &iova_copy); -/* -* An iommu backed group can dirty memory directly and therefore -* demotes the iommu scope until it declares itself dirty tracking -* capable via the page pinning interface. -*/ - iommu->num_non_pinned_groups++;mutex_unlock (&iommu->lock);vfio_iommu_resv_free (&group_resv_regions);return 0 ; out_detach: -iommu_detach_group (domain->domain, group->iommu_group); -out_domain: -iommu_domain_free (domain->domain); -vfio_iommu_iova_free (&iova_copy); -vfio_iommu_resv_free (&group_resv_regions); -out_free_domain: -kfree (domain); +vfio_iommu_detach_destroy_domain (domain, iommu, group); out_free_group:kfree (group); out_unlock:mutex_unlock (&iommu->lock); +vfio_iommu_iova_free (&iova_copy); +vfio_iommu_resv_free (&group_resv_regions);return ret; } -static void vfio_iommu_unmap_unpin_all (struct vfio_iommu *iommu) -{ -struct rb_node *node; - -while ((node =rb_first (&iommu->dma_list))) - vfio_remove_dma(iommu, rb_entry(node, struct vfio_dma, node)); -} - -static void vfio_iommu_unmap_unpin_reaccount (struct vfio_iommu *iommu) -{ -struct rb_node *n, *p; - - n =rb_first (&iommu->dma_list); -for (; n; n =rb_next (n)) { -struct vfio_dma *dma; -long locked =0 , unlocked =0 ; - - dma = rb_entry(n, struct vfio_dma, node); - unlocked +=vfio_unmap_unpin (iommu, dma, false); - p =rb_first (&dma->pfn_list); -for (; p; p =rb_next (p)) { - struct vfio_pfn *vpfn = rb_entry(p, struct vfio_pfn, - node); - -if (!is_invalid_reserved_pfn (vpfn->pfn)) - locked++; - } -vfio_lock_acct (dma, locked - unlocked, true); - } -} -/* * Called when a domain is removed in detach. It is possible that * the removed domain decided the iova aperture window. Modify the
@@ -2482,44 +2541,12 @@ static void vfio_iommu_type1_detach_group(void *iommu_data, group =find_iommu_group (domain, iommu_group);if (!group)continue ; - -iommu_detach_group (domain->domain, group->iommu_group); -list_del (&group->next); -/* -* Group ownership provides privilege, if the group list is -* empty, the domain goes away. If it's the last domain with -* iommu and external domain doesn't exist, then all the -* mappings go away too. If it's the last domain with iommu and -* external domain exist, update accounting -*/ -if (list_empty (&domain->group_list)) { -if (list_is_singular (&iommu->domain_list)) { -if (list_empty (&iommu->emulated_iommu_groups)) { -WARN_ON (iommu->notifier.head); -vfio_iommu_unmap_unpin_all (iommu); - }else { -vfio_iommu_unmap_unpin_reaccount (iommu); - } - } -iommu_domain_free (domain->domain); -list_del (&domain->next); -kfree (domain); -vfio_iommu_aper_expand (iommu, &iova_copy); -vfio_update_pgsize_bitmap (iommu); - } -/* -* Removal of a group without dirty tracking may allow -* the iommu scope to be promoted. -*/ -if (!group->pinned_page_dirty_scope) { - iommu->num_non_pinned_groups--; -if (iommu->dirty_page_tracking) -vfio_iommu_populate_bitmap_full (iommu); - } +vfio_iommu_detach_destroy_domain (domain, iommu, group);kfree (group);break ; } +vfio_iommu_aper_expand (iommu, &iova_copy);if (!vfio_iommu_resv_refresh (iommu, &iova_copy))vfio_iommu_iova_insert_copy (iommu, &iova_copy);else
Signature · 6 lines
2.17.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
RE: [PATCH v3 5/5] vfio/iommu_type1: Simplify group attachment
Quoted 14 lines
From: Nicolin Chen <[email protected]>
Sent: Friday, June 24, 2022 4:00 AMUn-inline the domain specific logic from the attach/detach_group ops into two paired functions
vfio_iommu_alloc_attach_domain()andvfio_iommu_detach_destroy_domain()that strictly deal with creating and destroying structvfio_domains.Add the logic to check for EMEDIUMTYPE return code of
iommu_attach_group()
and avoid the extra domain allocations and attach/detach sequences of the old code. This allows properly detecting an actual attach error, like-ENOMEM, vs treating all attach errors as an incompatible domain.
Quoted 3 lines
Co-developed-by Jason Gunthorpe <[email protected]>Signed-off-by Jason Gunthorpe <[email protected]>Signed-off-by Nicolin Chen <[email protected]>
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu