Simplify vfio_iommu_type1 attach/detach routine
Subsystems (18)
v2 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
v2:
* 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 | 12 +- drivers/iommu/arm/arm-smmu/arm-smmu.c | 4 +- drivers/iommu/arm/arm-smmu/qcom_iommu.c | 4 +- drivers/iommu/intel/iommu.c | 6 +- drivers/iommu/iommu.c | 28 ++ drivers/iommu/ipmmu-vmsa.c | 4 +- drivers/iommu/mtk_iommu_v1.c | 2 +- drivers/iommu/omap-iommu.c | 4 +- drivers/iommu/s390-iommu.c | 2 +- drivers/iommu/sprd-iommu.c | 4 +- drivers/iommu/tegra-gart.c | 2 +- drivers/iommu/virtio-iommu.c | 4 +- drivers/vfio/vfio_iommu_type1.c | 317 ++++++++++---------- 15 files changed, 220 insertions(+), 179 deletions(-)
Signature · 1 line
2.17.1
PATCH v2 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 turn adjacent error prints into debug prints, for these soft failures, to prevent a kernel log spam.
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 | 12 ++++----- drivers/iommu/arm/arm-smmu/arm-smmu.c | 4 +-- drivers/iommu/arm/arm-smmu/qcom_iommu.c | 4 +-- drivers/iommu/intel/iommu.c | 6 ++--- drivers/iommu/iommu.c | 28 +++++++++++++++++++++ drivers/iommu/ipmmu-vmsa.c | 4 +-- drivers/iommu/mtk_iommu_v1.c | 2 +- drivers/iommu/omap-iommu.c | 4 +-- drivers/iommu/s390-iommu.c | 2 +- drivers/iommu/sprd-iommu.c | 4 +-- drivers/iommu/tegra-gart.c | 2 +- drivers/iommu/virtio-iommu.c | 4 +-- 14 files changed, 55 insertions(+), 27 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 +6 -6
@@ -2420,24 +2420,24 @@ 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, +dev_dbg (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, +dev_dbg (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" , +dev_dbg (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 -2
@@ -1136,8 +1136,8 @@ static int arm_smmu_attach_dev(struct iommu_domain *domain, struct device *dev)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 ; +dev_dbg (dev,"cannot attach to SMMU, is it on the same bus?\n" ); +return -EMEDIUMTYPE ; }/*
drivers/iommu/arm/arm-smmu/qcom_iommu.c +2 -2
@@ -382,11 +382,11 @@ static int qcom_iommu_attach_dev(struct iommu_domain *domain, struct device *dev* different IOMMUs. */ if (qcom_domain->iommu != qcom_iommu) { -dev_err (dev,"cannot attach to IOMMU %s while already " +dev_dbg (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 ; +return -EMEDIUMTYPE ; }return 0 ;
drivers/iommu/intel/iommu.c +3 -3
@@ -4323,7 +4323,7 @@ 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);
@@ -4331,10 +4331,10 @@ static int prepare_domain_attach_device(struct iommu_domain *domain, addr_width =cap_mgaw (iommu->cap);if (dmar_domain->max_addr > (1LL << addr_width)) { -dev_err (dev,"%s: iommu width (%d) is not " +dev_dbg (dev,"%s: iommu width (%d) is not " "sufficient for the mapped address (%llx)\n" , __func__, addr_width, dmar_domain->max_addr); -return -EFAULT ; +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 or simply use dev_dbg() when reporting +* -EMEDIUMTYPE error, since 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 or simply use dev_dbg() when reporting +* -EMEDIUMTYPE error, since 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 +2 -2
@@ -628,9 +628,9 @@ 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_dbg (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 +2 -2
@@ -1471,8 +1471,8 @@ 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 ; +dev_dbg (dev,"iommu domain is already attached\n" ); + 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 -2
@@ -238,8 +238,8 @@ static int sprd_iommu_attach_device(struct iommu_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 ; +pr_debug ("There's already a device attached to this domain.\n" ); +return -EMEDIUMTYPE ; } dom->pgt_va =dma_alloc_coherent (sdev->dev, pgt_size, &dom->pgt_pa,GFP_KERNEL );
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 +2 -2
@@ -733,8 +733,8 @@ 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 ; +dev_dbg (dev,"cannot attach to foreign vIOMMU\n" ); + ret = -EMEDIUMTYPE ; }mutex_unlock (&vdomain->mutex);
Signature · 1 line
2.17.1
Baolu Lu
maintainerRe: [PATCH v2 1/5] iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
Quoted 15 lines · Nicolin Chen
drivers/iommu/intel/iommu.c +1
-1@@ -4323,7 +4323,7 @@ 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);@@ -4331,10 +4331,10 @@ static int prepare_domain_attach_device(struct iommu_domain *domain, addr_width =cap_mgaw (iommu->cap);
drivers/iommu/intel/iommu.c static int prepare_domain_attach_device(struct iommu_domain *domain, · line 4339
Quoted 10 lines
drivers/iommu/intel/iommu.c +2
-2if (dmar_domain->max_addr > (1LL << addr_width)) { -dev_err (dev,"%s: iommu width (%d) is not " +dev_dbg (dev,"%s: iommu width (%d) is not " "sufficient for the mapped address (%llx)\n" , __func__, addr_width, dmar_domain->max_addr); -return -EFAULT ; +return -EMEDIUMTYPE ; } dmar_domain->gaw = addr_width;
Can we simply remove the dev_err()? As the return value has explicitly explained the failure reason, putting a print statement won't help much.
Best regards,
baolu
Re: [PATCH v2 1/5] iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
Quoted 20 lines · Baolu Lu
External email: Use caution opening links or attachments
Quoted 16 lines · Nicolin Chen
drivers/iommu/intel/iommu.c +1
-1@@ -4323,7 +4323,7 @@ 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);@@ -4331,10 +4331,10 @@ static int prepare_domain_attach_device(struct iommu_domain *domain, addr_width =cap_mgaw (iommu->cap);
Quoted 12 lines
drivers/iommu/intel/iommu.c static int prepare_domain_attach_device(struct iommu_domain *domain, · line 4339
Quoted 9 lines
drivers/iommu/intel/iommu.c +2
-2if (dmar_domain->max_addr > (1LL << addr_width)) { -dev_err (dev,"%s: iommu width (%d) is not " +dev_dbg (dev,"%s: iommu width (%d) is not " "sufficient for the mapped address (%llx)\n" , __func__, addr_width, dmar_domain->max_addr); -return -EFAULT ; +return -EMEDIUMTYPE ; } dmar_domain->gaw = addr_width;Can we simply remove the
dev_err()? As the return value has explicitly explained the failure reason, putting a print statement won't help much.
Yes. As long as no one has objection, I can remove that in the next version.
RE: [PATCH v2 1/5] iommu: Return -EMEDIUMTYPE for incompatible domain and device/group
In reply to Nicolin ChenQuoted 19 lines
From: Nicolin Chen <[email protected]>
Sent: Thursday, June 16, 2022 8:03 AMCases 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.
Quoted 8 lines
Update all drivers to return EMEDIUMTYPE in their failure paths that are related to domain incompatability. Also turn adjacent error prints into debug prints, for these soft failures, to prevent a kernel log spam.
Add kdocs describing this behavior.
Suggested-by Jason Gunthorpe <[email protected]>Signed-off-by Nicolin Chen <[email protected]>
PATCH v2 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 those devices are attached to a single domain or multiple domains.
So, there is no value in 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 since KVM won't be able to take advantage of it. This just wastes domain memory.
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 · 6 lines
2.17.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
RE: [PATCH v2 2/5] vfio/iommu_type1: Prefer to reuse domains vs match enforced cache coherency
Quoted 26 lines
From: Nicolin Chen <[email protected]>
Sent: Thursday, June 16, 2022 8:03 AMFrom: 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 those devices are attached to a single domain or multiple domains.
So, there is no value in 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 since KVM won't be able to take advantage of it. This just wastes domain memory.
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.
Quoted 2 lines
Signed-off-by Jason Gunthorpe <[email protected]>Signed-off-by Nicolin Chen <[email protected]>
Re: [PATCH v2 2/5] vfio/iommu_type1: Prefer to reuse domains vs match enforced cache coherency
In reply to Nicolin ChenQuoted 15 lines · On Wed, 15 Jun 2022 17:03:01 -0700 Nicolin Chen <[email protected]> wrote:
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 those devices are attached to a single domain or multiple domains.
So, there is no value in 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 since KVM won't be able to take advantage of it. This just wastes domain memory.
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.
Quoted 7 lines
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.
The 2nd paragraph above is quite misleading in this respect. I think it would be more accurate to explain that the benefit to using separate domains was that 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. We can then go on to discuss that in practice 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. Thanks,
Alex
Quoted 22 lines
Signed-off-by Jason Gunthorpe <[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 +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)) {
Re: [PATCH v2 2/5] vfio/iommu_type1: Prefer to reuse domains vs match enforced cache coherency
Quoted 29 lines · Alex Williamson
External email: Use caution opening links or attachments
Quoted 15 lines · On Wed, 15 Jun 2022 17:03:01 -0700 Nicolin Chen <[email protected]> wrote:
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 those devices are attached to a single domain or multiple domains.
So, there is no value in 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 since KVM won't be able to take advantage of it. This just wastes domain memory.
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.
Quoted 7 lines
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.
Quoted 10 lines
The 2nd paragraph above is quite misleading in this respect. I think it would be more accurate to explain that the benefit to using separate domains was that 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. We can then go on to discuss that in practice 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. Thanks,
Thanks for the input. I integrated that into the commit log:
vfio/iommu_type1: Prefer to reuse domains vs match enforced cache coherency
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.
PATCH v2 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. However, at this moment only one iommu driver is possible. So remove it.
Per discussion with Robin, in future when many can be permitted we will rely on the IOMMU core code to check the domain->ops:
https://lore.kernel.org/linux-iommu/[email protected]/
--- 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 · 6 lines
2.17.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
RE: [PATCH v2 3/5] vfio/iommu_type1: Remove the domain->ops comparison
Quoted 6 lines
From: Nicolin Chen <[email protected]>
Sent: Thursday, June 16, 2022 8:03 AMThe
domain->opsvalidation was added, as a precaution, for mixed-driver systems. However, at this moment only one iommu driver is possible. So remove it.
It's true on a physical platform. But I'm not sure whether a virtual platform is allowed to include multiple e.g. one virtio-iommu alongside a virtual VT-d or a virtual smmu. It might be clearer to claim that (as Robin pointed out) there is plenty more significant problems than this to solve instead of simply saying that only one iommu driver is possible if we don't have explicit code to reject such configuration. 😊
Quoted 7 lines
Per discussion with Robin, in future when many can be permitted we will rely on the IOMMU core code to check the
domain->ops:
https://lore.kernel.org/linux-iommu/6575de6d-94ba-c427-5b1e-
[email protected]/Signed-off-by Nicolin Chen <[email protected]>
Apart from that,
Re: [PATCH v2 3/5] vfio/iommu_type1: Remove the domain->ops comparison
Quoted 10 lines · Kevin
Quoted 3 lines
The
domain->opsvalidation was added, as a precaution, for mixed-driver systems. However, at this moment only one iommu driver is possible. So remove it.It's true on a physical platform. But I'm not sure whether a virtual platform is allowed to include multiple e.g. one virtio-iommu alongside a virtual VT-d or a virtual smmu. It might be clearer to claim that (as Robin pointed out) there is plenty more significant problems than this to solve instead of simply saying that only one iommu driver is possible if we don't have explicit code to reject such configuration. 😊
Will edit this part. Thanks!
Robin Murphy
reviewerRe: [PATCH v2 3/5] vfio/iommu_type1: Remove the domain->ops comparison
Quoted 6 lines · Nicolin Chen
Quoted 4 lines · Kevin
Quoted 3 lines
The
domain->opsvalidation was added, as a precaution, for mixed-driver systems. However, at this moment only one iommu driver is possible. So remove it.
Quoted 8 lines
Quoted 6 lines
It's true on a physical platform. But I'm not sure whether a virtual platform is allowed to include multiple e.g. one virtio-iommu alongside a virtual VT-d or a virtual smmu. It might be clearer to claim that (as Robin pointed out) there is plenty more significant problems than this to solve instead of simply saying that only one iommu driver is possible if we don't have explicit code to reject such configuration. 😊
Will edit this part. Thanks!
Oh, physical platforms with mixed IOMMUs definitely exist already. The main point is that while bus_set_iommu still exists, the core code effectively *does* prevent multiple drivers from registering - even in emulated cases like the example above, virtio-iommu and VT-d would both try to bus_set_iommu(&pci_bus_type), and one of them will lose. The aspect which might warrant clarification is that there's no combination of supported drivers which claim non-overlapping buses *and* could appear in the same system - even if you tried to contrive something by emulating, say, VT-d (PCI) alongside rockchip-iommu (platform), you could still only describe one or the other due to ACPI vs. Devicetree.
Thanks,
Robin.
RE: [PATCH v2 3/5] vfio/iommu_type1: Remove the domain->ops comparison
Quoted 24 lines
From: Robin Murphy <[email protected]>
Sent: Wednesday, June 22, 2022 3:55 PMQuoted 3 lines · Nicolin Chen
Quoted 1 line · Kevin
Quoted 1 line
The
domain->opsvalidation was added, as a precaution, for mixed-driver
Quoted 4 lines
Quoted 4 lines
Quoted 2 lines
systems. However, at this moment only one iommu driver is possible. So remove it.
It's true on a physical platform. But I'm not sure whether a virtual
platform
Quoted 1 line
Quoted 1 line
is allowed to include multiple e.g. one virtio-iommu alongside a virtual VT-
d
Quoted 2 lines
Quoted 2 lines
or a virtual smmu. It might be clearer to claim that (as Robin pointed out) there is plenty more significant problems than this to solve instead of
simply
Quoted 1 line
Quoted 1 line
saying that only one iommu driver is possible if we don't have explicit
code
Quoted 3 lines
Quoted 1 line
to reject such configuration. 😊
Will edit this part. Thanks!
Quoted 11 lines
Oh, physical platforms with mixed IOMMUs definitely exist already. The main point is that while
bus_set_iommustill exists, the core code effectively *does* prevent multiple drivers from registering - even in emulated cases like the example above, virtio-iommu and VT-d would both try tobus_set_iommu(&pci_bus_type), and one of them will lose. The aspect which might warrant clarification is that there's no combination of supported drivers which claim non-overlapping buses *and* could appear in the same system - even if you tried to contrive something by emulating, say, VT-d (PCI) alongside rockchip-iommu (platform), you could still only describe one or the other due to ACPI vs. Devicetree.
This explanation is much clearer! thanks.
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Re: [PATCH v2 3/5] vfio/iommu_type1: Remove the domain->ops comparison
Quoted 39 lines · Kevin
External email: Use caution opening links or attachments
Quoted 24 lines
From: Robin Murphy <[email protected]>
Sent: Wednesday, June 22, 2022 3:55 PMQuoted 3 lines · Nicolin Chen
Quoted 1 line · Kevin
Quoted 1 line
The
domain->opsvalidation was added, as a precaution, for mixed-driver
Quoted 4 lines
Quoted 4 lines
Quoted 2 lines
systems. However, at this moment only one iommu driver is possible. So remove it.
It's true on a physical platform. But I'm not sure whether a virtual
platform
Quoted 1 line
Quoted 1 line
is allowed to include multiple e.g. one virtio-iommu alongside a virtual VT-
d
Quoted 2 lines
Quoted 2 lines
or a virtual smmu. It might be clearer to claim that (as Robin pointed out) there is plenty more significant problems than this to solve instead of
simply
Quoted 1 line
Quoted 1 line
saying that only one iommu driver is possible if we don't have explicit
code
Quoted 3 lines
Quoted 1 line
to reject such configuration. 😊
Will edit this part. Thanks!
Quoted 11 lines
Oh, physical platforms with mixed IOMMUs definitely exist already. The main point is that while
bus_set_iommustill exists, the core code effectively *does* prevent multiple drivers from registering - even in emulated cases like the example above, virtio-iommu and VT-d would both try tobus_set_iommu(&pci_bus_type), and one of them will lose. The aspect which might warrant clarification is that there's no combination of supported drivers which claim non-overlapping buses *and* could appear in the same system - even if you tried to contrive something by emulating, say, VT-d (PCI) alongside rockchip-iommu (platform), you could still only describe one or the other due to ACPI vs. Devicetree.
Quoted 1 line
This explanation is much clearer! thanks.
Thanks +1
I've also updated the commit log.
Re: [PATCH v2 3/5] vfio/iommu_type1: Remove the domain->ops comparison
In reply to Robin MurphyQuoted 16 lines · Robin Murphy
Quoted 6 lines · Nicolin Chen
Quoted 4 lines · Kevin
Quoted 3 lines
The
domain->opsvalidation was added, as a precaution, for mixed-driver systems. However, at this moment only one iommu driver is possible. So remove it.Quoted 8 lines
Quoted 6 lines
It's true on a physical platform. But I'm not sure whether a virtual platform is allowed to include multiple e.g. one virtio-iommu alongside a virtual VT-d or a virtual smmu. It might be clearer to claim that (as Robin pointed out) there is plenty more significant problems than this to solve instead of simply saying that only one iommu driver is possible if we don't have explicit code to reject such configuration. 😊
Will edit this part. Thanks!
Quoted 10 lines
Oh, physical platforms with mixed IOMMUs definitely exist already. The main point is that while
bus_set_iommustill exists, the core code effectively *does* prevent multiple drivers from registering - even in emulated cases like the example above, virtio-iommu and VT-d would both try tobus_set_iommu(&pci_bus_type), and one of them will lose. The aspect which might warrant clarification is that there's no combination of supported drivers which claim non-overlapping buses *and* could appear in the same system - even if you tried to contrive something by emulating, say, VT-d (PCI) alongside rockchip-iommu (platform), you could still only describe one or the other due to ACPI vs. Devicetree.
Right, and that is still something we need to protect against with this ops check. VFIO is not checking that the bus's are the same before attempting to re-use a domain.
So it is actually functional and does protect against systems with multiple iommu drivers on different busses.
Jason
Robin Murphy
reviewerRe: [PATCH v2 3/5] vfio/iommu_type1: Remove the domain->ops comparison
Quoted 28 lines · Jason Gunthorpe
Quoted 16 lines · Robin Murphy
Quoted 6 lines · Nicolin Chen
Quoted 4 lines · Kevin
Quoted 3 lines
The
domain->opsvalidation was added, as a precaution, for mixed-driver systems. However, at this moment only one iommu driver is possible. So remove it.Quoted 8 lines
Quoted 6 lines
It's true on a physical platform. But I'm not sure whether a virtual platform is allowed to include multiple e.g. one virtio-iommu alongside a virtual VT-d or a virtual smmu. It might be clearer to claim that (as Robin pointed out) there is plenty more significant problems than this to solve instead of simply saying that only one iommu driver is possible if we don't have explicit code to reject such configuration. 😊
Will edit this part. Thanks!
Quoted 10 lines
Oh, physical platforms with mixed IOMMUs definitely exist already. The main point is that while
bus_set_iommustill exists, the core code effectively *does* prevent multiple drivers from registering - even in emulated cases like the example above, virtio-iommu and VT-d would both try tobus_set_iommu(&pci_bus_type), and one of them will lose. The aspect which might warrant clarification is that there's no combination of supported drivers which claim non-overlapping buses *and* could appear in the same system - even if you tried to contrive something by emulating, say, VT-d (PCI) alongside rockchip-iommu (platform), you could still only describe one or the other due to ACPI vs. Devicetree.
Quoted 6 lines
Right, and that is still something we need to protect against with this ops check. VFIO is not checking that the bus's are the same before attempting to re-use a domain.
So it is actually functional and does protect against systems with multiple iommu drivers on different busses.
But as above, which systems *are* those? Everything that's on my radar would have drivers all competing for the platform bus - Intel and s390 are somewhat the odd ones out in that respect, but are also non-issues as above. FWIW my iommu/bus dev branch has got as far as the final bus ops removal and allowing multiple driver registrations, and before it allows that, it does now have the common attach check that I sketched out in the previous discussion of this.
It's probably also noteworthy that domain->ops is no longer the same domain->ops that this code was written to check, and may now be different between domains from the same driver.
Thanks,
Robin.
Re: [PATCH v2 3/5] vfio/iommu_type1: Remove the domain->ops comparison
Quoted 11 lines · Robin Murphy
Quoted 11 lines
Quoted 10 lines
Oh, physical platforms with mixed IOMMUs definitely exist already. The main point is that while
bus_set_iommustill exists, the core code effectively *does* prevent multiple drivers from registering - even in emulated cases like the example above, virtio-iommu and VT-d would both try tobus_set_iommu(&pci_bus_type), and one of them will lose. The aspect which might warrant clarification is that there's no combination of supported drivers which claim non-overlapping buses *and* could appear in the same system - even if you tried to contrive something by emulating, say, VT-d (PCI) alongside rockchip-iommu (platform), you could still only describe one or the other due to ACPI vs. Devicetree.
Quoted 8 lines
Quoted 6 lines
Right, and that is still something we need to protect against with this ops check. VFIO is not checking that the bus's are the same before attempting to re-use a domain.
So it is actually functional and does protect against systems with multiple iommu drivers on different busses.
But as above, which systems *are* those?
IDK it seems wrong that the system today will allow different buses to have different IOMMU drivers and not provide a trivial protection check.
Quoted 4 lines
FWIW my iommu/bus dev branch has got as far as the final bus ops removal and allowing multiple driver registrations, and before it allows that, it does now have the common attach check that I sketched out in the previous discussion of this.
If you want to put the check in your series that seems fine too, as long as we get it in the end.
Quoted 3 lines
It's probably also noteworthy that
domain->opsis no longer the samedomain->opsthat this code was written to check, and may now be different between domains from the same driver.
Yes, the vfio check is not good anymore.
Jason
PATCH v2 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.
Rename the "detach_group_done" goto label accordingly.
--- 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,7 @@ 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; + goto out_unlock; }/*
@@ -2485,9 +2483,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 +2506,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 +2524,7 @@ 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); - } +out_unlock:mutex_unlock (&iommu->lock); }
Signature · 6 lines
2.17.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
RE: [PATCH v2 4/5] vfio/iommu_type1: Clean up update_dirty_scope in detach_group()
Quoted 8 lines
From: Nicolin Chen
Sent: Thursday, June 16, 2022 8:03 AMAll devices in
emulated_iommu_groupshavepinned_page_dirty_scopeset, so theupdate_dirty_scopein the firstlist_for_each_entryis always false. Clean it up, and move the "ifupdate_dirty_scope" part from thedetach_group_doneroutine to thedomain_listpart.
Quoted 4 lines
Rename the "
detach_group_done" goto label accordingly.Suggested-by Jason Gunthorpe <[email protected]>Signed-off-by Nicolin Chen <[email protected]>
Quoted 7 lines
drivers/vfio/vfio_iommu_type1.c +1
-1@@ -2469,7 +2467,7 @@ 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; + goto out_unlock;
...
drivers/vfio/vfio_iommu_type1.c static void vfio_iommu_type1_detach_group(void *iommu_data, · line 2529
Quoted 4 lines
drivers/vfio/vfio_iommu_type1.c +1
-0+out_unlock:mutex_unlock (&iommu->lock); }
I'd just replace the goto with a direct unlock and then return there. the readability is slightly better.
Re: [PATCH v2 4/5] vfio/iommu_type1: Clean up update_dirty_scope in detach_group()
Quoted 7 lines · Kevin
Quoted 4 lines
+out_unlock:
mutex_unlock(&iommu->lock);}
I'd just replace the goto with a direct unlock and then return there. the readability is slightly better.
OK. Will do that.
PATCH v2 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 | 298 +++++++++++++++++--------------- 1 file changed, 163 insertions(+), 135 deletions(-)
drivers/vfio/vfio_iommu_type1.c +163 -135
@@ -86,6 +86,7 @@ struct vfio_domain {struct list_head group_list; bool fgsp : 1; /* Fine-grained super pages */ bool enforce_cache_coherency : 1; + bool msi_cookie : 1; };struct vfio_dma {
@@ -2153,12 +2154,163 @@ 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 iommu_domain *new_domain; +struct vfio_domain *domain; +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); +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; + +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 ;
@@ -2197,26 +2349,12 @@ 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) + domain =vfio_iommu_alloc_attach_domain (bus, iommu, group); +if (IS_ERR (domain)) { + ret =PTR_ERR (domain); 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; } - 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,
@@ -2254,9 +2392,6 @@ static int vfio_iommu_type1_attach_group(void *iommu_data, 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 +2402,32 @@ 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) { +if (resv_msi && !domain->msi_cookie) { ret =iommu_get_msi_cookie (domain->domain, resv_msi_base);if (ret && ret != -ENODEV ) goto out_detach; + domain->msi_cookie = true; } -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
@@ -2481,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 v2 5/5] vfio/iommu_type1: Simplify group attachment
Quoted 21 lines
From: Nicolin Chen
Sent: Thursday, June 16, 2022 8:03 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.Co-developed-by Jason Gunthorpe <[email protected]>Signed-off-by Jason Gunthorpe <[email protected]>Signed-off-by Nicolin Chen <[email protected]>--- drivers/vfio/vfio_iommu_type1.c | 298 +++++++++++++++++--------------- 1 file changed, 163 insertions(+), 135 deletions(-)
...
Quoted 13 lines
(quoted diff) +2
-0+static struct vfio_domain * +vfio_iommu_alloc_attach_domain(struct bus_type *bus, struct vfio_iommu*iommu,
drivers/vfio/vfio_iommu_type1.c +9
-0+ struct vfio_iommu_group *group) +{ +struct iommu_domain *new_domain; +struct vfio_domain *domain; +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-Quoted 1 line
iommu_group);
drivers/vfio/vfio_iommu_type1.c static void vfio_iommu_iova_insert_copy(struct vfio_iommu *iommu, · line 2169
Quoted 2 lines
drivers/vfio/vfio_iommu_type1.c +2
-0+if (ret == -EMEDIUMTYPE ) +continue ;
Probably good to add one line comment here for what EMEDIUMTYPE represents. It's not a widely-used retry type like EAGAIN. A comment can save the time of digging out the fact by jumping to iommu file.
...
drivers/vfio/vfio_iommu_type1.c static int vfio_iommu_type1_attach_group(void *iommu_data, · line 2410
Quoted 8 lines
drivers/vfio/vfio_iommu_type1.c +1
-1-if (resv_msi) { +if (resv_msi && !domain->msi_cookie) { ret = iommu_get_msi_cookie(domain->domain,
resv_msi_base);drivers/vfio/vfio_iommu_type1.c +1
-0if (ret && ret != -ENODEV ) goto out_detach; + domain->msi_cookie = true; }
why not moving to alloc_attach_domain() then no need for the new domain field? It's required only when a new domain is allocated.
...
Quoted 10 lines
drivers/vfio/vfio_iommu_type1.c +0
-3-if (list_empty (&domain->group_list)) { -if (list_is_singular (&iommu->domain_list)) { - if (list_empty(&iommu-Quoted 1 line
emulated_iommu_groups)) {(quoted diff) +0
-2- WARN_ON(iommu->notifier.head); -vfio_iommu_unmap_unpin_all(iommu);(quoted diff) +0
-2- } else { -vfio_iommu_unmap_unpin_reaccount(iommu);
drivers/vfio/vfio_iommu_type1.c static void vfio_iommu_type1_detach_group(void *iommu_data, · line 2506
Quoted 6 lines
drivers/vfio/vfio_iommu_type1.c +0
-6- } - } -iommu_domain_free (domain->domain); -list_del (&domain->next); -kfree (domain); -vfio_iommu_aper_expand (iommu, &iova_copy);
Previously the aperture is adjusted when a domain is freed...
Quoted 13 lines
drivers/vfio/vfio_iommu_type1.c +1
-11-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);
drivers/vfio/vfio_iommu_type1.c static void vfio_iommu_type1_detach_group(void *iommu_data, · line 2549
Quoted 5 lines
drivers/vfio/vfio_iommu_type1.c +1
-0kfree (group);break ; } +vfio_iommu_aper_expand (iommu, &iova_copy);
but now it's done for every group detach. The aperture is decided by domain geometry which is not affected by attached groups.
Re: [PATCH v2 5/5] vfio/iommu_type1: Simplify group attachment
Quoted 13 lines · Kevin
...
Quoted 12 lines
(quoted diff) +2
-0+static struct vfio_domain * +vfio_iommu_alloc_attach_domain(struct bus_type *bus, struct vfio_iommu*iommu,
drivers/vfio/vfio_iommu_type1.c +9
-0+ struct vfio_iommu_group *group) +{ +struct iommu_domain *new_domain; +struct vfio_domain *domain; +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-
Quoted 7 lines
drivers/vfio/vfio_iommu_type1.c static void vfio_iommu_iova_insert_copy(struct vfio_iommu *iommu, · line 2169
Quoted 3 lines
Quoted 1 line
iommu_group);drivers/vfio/vfio_iommu_type1.c +2
-0+if (ret == -EMEDIUMTYPE ) +continue ;Probably good to add one line comment here for what EMEDIUMTYPE represents. It's not a widely-used retry type like EAGAIN. A comment can save the time of digging out the fact by jumping to iommu file.
Sure. I can add that.
Quoted 10 lines
...
Quoted 8 lines
drivers/vfio/vfio_iommu_type1.c +1
-1-if (resv_msi) { +if (resv_msi && !domain->msi_cookie) { ret = iommu_get_msi_cookie(domain->domain,resv_msi_base); if (ret && ret != -ENODEV) goto out_detach; + domain->msi_cookie = true; }
Quoted 2 lines
why not moving to
alloc_attach_domain()then no need for the new domain field? It's required only when a new domain is allocated.
When reusing an existing domain that doesn't have an msi_cookie, we can do iommu_get_msi_cookie() if resv_msi is found. So it is not limited to a new domain.
Quoted 37 lines
...
Quoted 6 lines
drivers/vfio/vfio_iommu_type1.c +0
-3-if (list_empty (&domain->group_list)) { -if (list_is_singular (&iommu->domain_list)) { - if (list_empty(&iommu-Quoted 1 line
emulated_iommu_groups)) {drivers/vfio/vfio_iommu_type1.c +0
-2-WARN_ON (iommu->notifier.head); -drivers/vfio/vfio_iommu_type1.c static void vfio_iommu_type1_detach_group(void *iommu_data, · line 2506
Quoted 10 lines
drivers/vfio/vfio_iommu_type1.c +0
-8vfio_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);Previously the aperture is adjusted when a domain is freed...
Quoted 17 lines
drivers/vfio/vfio_iommu_type1.c +1
-11-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; }
Quoted 4 lines
Quoted 1 line
+
vfio_iommu_aper_expand(iommu, &iova_copy);but now it's done for every group detach. The aperture is decided by domain geometry which is not affected by attached groups.
Yea, I've noticed this part. Actually Jason did this change for simplicity, and I think it'd be safe to do so?
RE: [PATCH v2 5/5] vfio/iommu_type1: Simplify group attachment
Quoted 13 lines
From: Nicolin Chen <[email protected]>
Sent: Friday, June 17, 2022 6:41 AMQuoted 10 lines
...
Quoted 8 lines
drivers/vfio/vfio_iommu_type1.c +1
-1-if (resv_msi) { +if (resv_msi && !domain->msi_cookie) { ret = iommu_get_msi_cookie(domain->domain,resv_msi_base); if (ret && ret != -ENODEV) goto out_detach; + domain->msi_cookie = true; }
Quoted 6 lines
Quoted 2 lines
why not moving to
alloc_attach_domain()then no need for the new domain field? It's required only when a new domain is allocated.When reusing an existing domain that doesn't have an
msi_cookie, we can doiommu_get_msi_cookie()ifresv_msiis found. So it is not limited to a new domain.
Looks msi_cookie requirement is per platform (currently only for smmu. see arm_smmu_get_resv_regions()). If there is no mixed case then above check is not required.
But let's hear whether Robin has a different thought here.
Quoted 38 lines
Quoted 38 lines
...
Quoted 6 lines
drivers/vfio/vfio_iommu_type1.c +0
-3-if (list_empty (&domain->group_list)) { -if (list_is_singular (&iommu->domain_list)) { - if (list_empty(&iommu-Quoted 1 line
emulated_iommu_groups)) {drivers/vfio/vfio_iommu_type1.c +0
-2-WARN_ON (iommu->notifier.head); -drivers/vfio/vfio_iommu_type1.c static void vfio_iommu_type1_detach_group(void *iommu_data, · line 2506
Quoted 10 lines
drivers/vfio/vfio_iommu_type1.c +0
-8vfio_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);Previously the aperture is adjusted when a domain is freed...
Quoted 17 lines
drivers/vfio/vfio_iommu_type1.c +1
-11-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; }
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
+
vfio_iommu_aper_expand(iommu, &iova_copy);but now it's done for every group detach. The aperture is decided by domain geometry which is not affected by attached groups.
Yea, I've noticed this part. Actually Jason did this change for simplicity, and I think it'd be safe to do so?
Perhaps detach_destroy() can return a Boolean to indicate whether a domain is destroyed.
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Re: [PATCH v2 5/5] vfio/iommu_type1: Simplify group attachment
Quoted 13 lines · Kevin
Quoted 13 lines
Quoted 12 lines
...
Quoted 8 lines
drivers/vfio/vfio_iommu_type1.c +1
-1-if (resv_msi) { +if (resv_msi && !domain->msi_cookie) { ret = iommu_get_msi_cookie(domain->domain,resv_msi_base); if (ret && ret != -ENODEV) goto out_detach; + domain->msi_cookie = true; }why not moving to
alloc_attach_domain()then no need for the new domain field? It's required only when a new domain is allocated.
Quoted 7 lines
Quoted 3 lines
When reusing an existing domain that doesn't have an
msi_cookie, we can doiommu_get_msi_cookie()ifresv_msiis found. So it is not limited to a new domain.Looks
msi_cookierequirement is per platform (currently only for smmu. seearm_smmu_get_resv_regions()). If there is no mixed case then above check is not required.
Do you mean "reusing existing domain" for the "mixed case"?
Quoted 1 line
But let's hear whether Robin has a different thought here.
Yea, sure.
Quoted 26 lines
Quoted 26 lines
Quoted 26 lines
drivers/vfio/vfio_iommu_type1.c static void vfio_iommu_type1_detach_group(void *iommu_data, · line 2506
Quoted 4 lines
drivers/vfio/vfio_iommu_type1.c +0
-4-iommu_domain_free (domain->domain); -list_del (&domain->next); -kfree (domain); -vfio_iommu_aper_expand (iommu, &iova_copy);Previously the aperture is adjusted when a domain is freed...
Quoted 18 lines
drivers/vfio/vfio_iommu_type1.c +1
-11-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);
Quoted 8 lines
Quoted 5 lines
Quoted 2 lines
but now it's done for every group detach. The aperture is decided by domain geometry which is not affected by attached groups.
Yea, I've noticed this part. Actually Jason did this change for simplicity, and I think it'd be safe to do so?
Perhaps
detach_destroy()can return a Boolean to indicate whether a domain is destroyed.
It could be a solution but doesn't feel that common for a clean function to have a return value indicating a special case. Maybe passing in "&domain" so that we can check if it's NULL after?
Re: [PATCH v2 5/5] vfio/iommu_type1: Simplify group attachment
Quoted 8 lines · Nicolin Chen
Quoted 8 lines
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
+
vfio_iommu_aper_expand(iommu, &iova_copy);but now it's done for every group detach. The aperture is decided by domain geometry which is not affected by attached groups.
Yea, I've noticed this part. Actually Jason did this change for simplicity, and I think it'd be safe to do so?
Quoted 6 lines
Quoted 2 lines
Perhaps
detach_destroy()can return a Boolean to indicate whether a domain is destroyed.It could be a solution but doesn't feel that common for a clean function to have a return value indicating a special case. Maybe passing in "&domain" so that we can check if it's NULL after?
It is harmless to do every time, it just burns a few CPU cycles on a slow path. We don't need complexity to optmize it.
Jason
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Re: [PATCH v2 5/5] vfio/iommu_type1: Simplify group attachment
Quoted 13 lines · Jason Gunthorpe
Quoted 11 lines · Nicolin Chen
Quoted 10 lines
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
+
vfio_iommu_aper_expand(iommu, &iova_copy);but now it's done for every group detach. The aperture is decided by domain geometry which is not affected by attached groups.
Yea, I've noticed this part. Actually Jason did this change for simplicity, and I think it'd be safe to do so?
Perhaps
detach_destroy()can return a Boolean to indicate whether a domain is destroyed.
Quoted 6 lines
Quoted 3 lines
It could be a solution but doesn't feel that common for a clean function to have a return value indicating a special case. Maybe passing in "&domain" so that we can check if it's NULL after?
It is harmless to do every time, it just burns a few CPU cycles on a slow path. We don't need complexity to optmize it.
OK. I will keep it simple then. If Kevin or other has a further objection, please let us know.
Thanks
Nic
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Robin Murphy
reviewerRe: [PATCH v2 5/5] vfio/iommu_type1: Simplify group attachment
In reply to Tian, KevinQuoted 20 lines · Kevin
Quoted 13 lines
From: Nicolin Chen <[email protected]>
Sent: Friday, June 17, 2022 6:41 AMQuoted 10 lines
...
Quoted 8 lines
drivers/vfio/vfio_iommu_type1.c +1
-1-if (resv_msi) { +if (resv_msi && !domain->msi_cookie) { ret = iommu_get_msi_cookie(domain->domain,resv_msi_base); if (ret && ret != -ENODEV) goto out_detach; + domain->msi_cookie = true; }Quoted 6 lines
Quoted 2 lines
why not moving to
alloc_attach_domain()then no need for the new domain field? It's required only when a new domain is allocated.When reusing an existing domain that doesn't have an
msi_cookie, we can doiommu_get_msi_cookie()ifresv_msiis found. So it is not limited to a new domain.
Quoted 5 lines
Looks
msi_cookierequirement is per platform (currently only for smmu. seearm_smmu_get_resv_regions()). If there is no mixed case then above check is not required.But let's hear whether Robin has a different thought here.
Yes, the cookie should logically be tied to the lifetime of the domain itself. In the relevant context, "an existing domain that doesn't have an msi_cookie" should never exist.
Thanks,
Robin.
Re: [PATCH v2 5/5] vfio/iommu_type1: Simplify group attachment
Quoted 28 lines · Robin Murphy
External email: Use caution opening links or attachments
Quoted 24 lines · Kevin
Quoted 13 lines
From: Nicolin Chen <[email protected]>
Sent: Friday, June 17, 2022 6:41 AMQuoted 10 lines
...
Quoted 8 lines
drivers/vfio/vfio_iommu_type1.c +1
-1-if (resv_msi) { +if (resv_msi && !domain->msi_cookie) { ret = iommu_get_msi_cookie(domain->domain,resv_msi_base); if (ret && ret != -ENODEV) goto out_detach; + domain->msi_cookie = true; }Quoted 6 lines
Quoted 2 lines
why not moving to
alloc_attach_domain()then no need for the new domain field? It's required only when a new domain is allocated.When reusing an existing domain that doesn't have an
msi_cookie, we can doiommu_get_msi_cookie()ifresv_msiis found. So it is not limited to a new domain.Looks
msi_cookierequirement is per platform (currently only for smmu. seearm_smmu_get_resv_regions()). If there is no mixed case then above check is not required.
Quoted 5 lines
Quoted 1 line
But let's hear whether Robin has a different thought here.
Yes, the cookie should logically be tied to the lifetime of the domain itself. In the relevant context, "an existing domain that doesn't have an
msi_cookie" should never exist.
Thanks for the explanation. I will move the iommu_get_msi_cookie() into alloc_attach_domain(), as Kevin suggested.
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu