iommu/tegra-smmu: Two followup changes
Subsystems (3)
v2 cover iommu/tegra-smmu: Two followup changes
Two followup patches for tegra-smmu:
PATCH-1 is a clean-up patch for the recently applied SWGROUP change. PATCH-2 fixes a potential race condition
Changelogv1->v2:
* Separated first two changs of V1 so they may get applied first, since the other three changes need some extra time to finalize.
Nicolin Chen (2):
iommu/tegra-smmu: Unwrap tegra_smmu_group_get
iommu/tegra-smmu: Expend mutex protection range
drivers/iommu/tegra-smmu.c | 53 ++++++++++++++++++-------------------- 1 file changed, 25 insertions(+), 28 deletions(-)
Signature · 1 line
2.17.1
PATCH v2 1/2 iommu/tegra-smmu: Unwrap tegra_smmu_group_get
The tegra_smmu_group_get was added to group devices in different SWGROUPs and it'd return a NULL group pointer upon a mismatch at tegra_smmu_find_group(), so for most of clients/devices, it very likely would mismatch and need a fallback generic_device_group().
But now tegra_smmu_group_get handles devices in same SWGROUP too, which means that it would allocate a group for every new SWGROUP or would directly return an existing one upon matching a SWGROUP, i.e. any device will go through this function.
So possibility of having a NULL group pointer in device_group() is upon failure of either devm_kzalloc() or iommu_group_alloc(). In either case, calling generic_device_group() no longer makes a sense. Especially for devm_kzalloc() failing case, it'd cause a problem if it fails at devm_kzalloc() yet succeeds at a fallback generic_device_group(), because it does not create a group->list for other devices to match.
This patch simply unwraps the function to clean it up.
---
Changelogv1->v2:
* Changed type of swgroup to "unsigned int", following Thierry's commnets.
drivers/iommu/tegra-smmu.c | 19 ++++--------------- 1 file changed, 4 insertions(+), 15 deletions(-)
drivers/iommu/tegra-smmu.c +4 -15
@@ -903,10 +903,12 @@ static void tegra_smmu_group_release(void *iommu_data)mutex_unlock (&smmu->lock); } -static struct iommu_group *tegra_smmu_group_get (struct tegra_smmu *smmu, -unsigned int swgroup) +static struct iommu_group *tegra_smmu_device_group (struct device *dev) { +struct iommu_fwspec *fwspec =dev_iommu_fwspec_get (dev); +struct tegra_smmu *smmu =dev_iommu_priv_get (dev);const struct tegra_smmu_group_soc *soc; +unsigned int swgroup = fwspec->ids[0 ];struct tegra_smmu_group *group;struct iommu_group *grp;
@@ -950,19 +952,6 @@ static struct iommu_group *tegra_smmu_group_get(struct tegra_smmu *smmu,return group->group; } -static struct iommu_group *tegra_smmu_device_group (struct device *dev) -{ -struct iommu_fwspec *fwspec =dev_iommu_fwspec_get (dev); -struct tegra_smmu *smmu =dev_iommu_priv_get (dev); -struct iommu_group *group; - - group =tegra_smmu_group_get (smmu, fwspec->ids[0 ]); -if (!group) - group =generic_device_group (dev); - -return group; -} -static int tegra_smmu_of_xlate (struct device *dev,struct of_phandle_args *args) {
Signature · 1 line
2.17.1
PATCH v2 2/2 iommu/tegra-smmu: Expend mutex protection range
In reply to Nicolin ChenThis is used to protect potential race condition at use_count. since probes of client drivers, calling attach_dev(), may run concurrently.
---
Changelogv1->v2:
* N/A
drivers/iommu/tegra-smmu.c | 34 +++++++++++++++++++++------------- 1 file changed, 21 insertions(+), 13 deletions(-)
drivers/iommu/tegra-smmu.c +21 -13
@@ -256,26 +256,19 @@ static int tegra_smmu_alloc_asid(struct tegra_smmu *smmu, unsigned int *idp) {unsigned long id; -mutex_lock (&smmu->lock); - id =find_first_zero_bit (smmu->asids, smmu->soc->num_asids); -if (id >= smmu->soc->num_asids) { -mutex_unlock (&smmu->lock); +if (id >= smmu->soc->num_asids)return -ENOSPC ; - }set_bit (id, smmu->asids); *idp = id; -mutex_unlock (&smmu->lock);return 0 ; }static void tegra_smmu_free_asid (struct tegra_smmu *smmu,unsigned int id) { -mutex_lock (&smmu->lock);clear_bit (id, smmu->asids); -mutex_unlock (&smmu->lock); }static bool tegra_smmu_capable (enum iommu_cap cap)
@@ -420,17 +413,21 @@ static int tegra_smmu_as_prepare(struct tegra_smmu *smmu, struct tegra_smmu_as *as) {u32 value; -int err; +int err =0 ; + +mutex_lock (&smmu->lock);if (as->use_count >0 ) { as->use_count++; -return 0 ; + goto err_unlock; } as->pd_dma =dma_map_page (smmu->dev, as->pd,0 ,SMMU_SIZE_PD ,DMA_TO_DEVICE ); -if (dma_mapping_error (smmu->dev, as->pd_dma)) -return -ENOMEM ; +if (dma_mapping_error (smmu->dev, as->pd_dma)) { + err = -ENOMEM ; + goto err_unlock; + }/* We can't handle 64-bit DMA addresses */ if (!smmu_dma_addr_valid (smmu, as->pd_dma)) {
@@ -453,24 +450,35 @@ static int tegra_smmu_as_prepare(struct tegra_smmu *smmu, as->smmu = smmu; as->use_count++; +mutex_unlock (&smmu->lock); +return 0 ; err_unmap:dma_unmap_page (smmu->dev, as->pd_dma,SMMU_SIZE_PD ,DMA_TO_DEVICE ); +err_unlock: +mutex_unlock (&smmu->lock); +return err; }static void tegra_smmu_as_unprepare (struct tegra_smmu *smmu,struct tegra_smmu_as *as) { -if (--as->use_count >0 ) +mutex_lock (&smmu->lock); + +if (--as->use_count >0 ) { +mutex_unlock (&smmu->lock);return ; + }tegra_smmu_free_asid (smmu, as->id);dma_unmap_page (smmu->dev, as->pd_dma,SMMU_SIZE_PD ,DMA_TO_DEVICE ); as->smmu =NULL ; + +mutex_unlock (&smmu->lock); } static int tegra_smmu_attach_dev(struct iommu_domain *domain,
Signature · 1 line
2.17.1
Re: [PATCH v2 2/2] iommu/tegra-smmu: Expend mutex protection range
...
Quoted 4 lines
static bool
tegra_smmu_capable(enum iommu_cap cap)drivers/iommu/tegra-smmu.c +0
-0@@ -420,17 +413,21 @@ static int tegra_smmu_as_prepare(struct tegra_smmu *smmu, struct tegra_smmu_as *as) {
drivers/iommu/tegra-smmu.c static int tegra_smmu_as_prepare(struct tegra_smmu *smmu, · line 422
Quoted 10 lines
drivers/iommu/tegra-smmu.c +4
-2u32 value; -int err; +int err =0 ; + +mutex_lock (&smmu->lock);if (as->use_count >0 ) { as->use_count++; -return 0 ; + goto err_unlock;
This looks a bit odd because it's not a error condition. Perhaps should be better to "goto bump_usecount"?
Or make it similar to tegra_smmu_as_unprepare()?
Quoted 14 lines
drivers/iommu/tegra-smmu.c +4
-2} as->pd_dma =dma_map_page (smmu->dev, as->pd,0 ,SMMU_SIZE_PD ,DMA_TO_DEVICE ); -if (dma_mapping_error (smmu->dev, as->pd_dma)) -return -ENOMEM ; +if (dma_mapping_error (smmu->dev, as->pd_dma)) { + err = -ENOMEM ; + goto err_unlock; + }/* We can't handle 64-bit DMA addresses */ if (!smmu_dma_addr_valid (smmu, as->pd_dma)) {
drivers/iommu/tegra-smmu.c static int tegra_smmu_as_prepare(struct tegra_smmu *smmu, · line 450
Quoted 1 line
drivers/iommu/tegra-smmu.c +0
-0@@ -453,24 +450,35 @@ static int tegra_smmu_as_prepare(struct tegra_smmu *smmu, as->smmu = smmu;
bump_usecount:
Quoted 36 lines
drivers/iommu/tegra-smmu.c +12
-1as->use_count++; +mutex_unlock (&smmu->lock); +return 0 ; err_unmap:dma_unmap_page (smmu->dev, as->pd_dma,SMMU_SIZE_PD ,DMA_TO_DEVICE ); +err_unlock: +mutex_unlock (&smmu->lock); +return err; }static void tegra_smmu_as_unprepare (struct tegra_smmu *smmu,struct tegra_smmu_as *as) { -if (--as->use_count >0 ) +mutex_lock (&smmu->lock); + +if (--as->use_count >0 ) { +mutex_unlock (&smmu->lock);return ; + }tegra_smmu_free_asid (smmu, as->id);dma_unmap_page (smmu->dev, as->pd_dma,SMMU_SIZE_PD ,DMA_TO_DEVICE ); as->smmu =NULL ; + +mutex_unlock (&smmu->lock); } static int tegra_smmu_attach_dev(struct iommu_domain *domain,
Re: [PATCH v2 2/2] iommu/tegra-smmu: Expend mutex protection range
Quoted 19 lines · Dmitry Osipenko
...
Quoted 4 lines
static bool
tegra_smmu_capable(enum iommu_cap cap)drivers/iommu/tegra-smmu.c +0
-0@@ -420,17 +413,21 @@ static int tegra_smmu_as_prepare(struct tegra_smmu *smmu, struct tegra_smmu_as *as) {drivers/iommu/tegra-smmu.c static int tegra_smmu_as_prepare(struct tegra_smmu *smmu, · line 422
Quoted 10 lines
drivers/iommu/tegra-smmu.c +4
-2u32 value; -int err; +int err =0 ; + +mutex_lock (&smmu->lock);if (as->use_count >0 ) { as->use_count++; -return 0 ; + goto err_unlock;This looks a bit odd because it's not a error condition. Perhaps should be better to "goto
bump_usecount"?
Quoted 1 line
Or make it similar to
tegra_smmu_as_unprepare()?
Hmm...I think it's simple to just make it "goto unlock" then.