iommu: Remove IOMMU_DEV_FEAT_SVA/_IOPF
Subsystems (12)
Lu Baolu
maintainerv3 cover iommu: Remove IOMMU_DEV_FEAT_SVA/_IOPF
The new method for driver fault reporting support relies on the domain to specify a iopf_handler. The driver should detect this and setup the HW when fault capable domains are attached.
Move SMMUv3 to use this method and have VT-D validate support during attach so that all three fault capable drivers have a no-op FEAT_SVA and _IOPF. Then remove them.
This was initiated by Jason. I'm following up to remove FEAT_IOPF and further clean up.
The whole series is also available at github:
https://github.com/LuBaolu/intel-iommu/commits/iommu_no_feat-v3
Change log:
v3:
- Series has been tested by Zhangfei Gao with arm-smmu-v3 driver.
- Refined some code according to Kevin's suggestions.
- No functional change.
v2: https://lore.kernel.org/linux-iommu/[email protected]/
- Fix removing wrong nesting master_domain in arm_smmu_remove_master_domain().
- Fix iopf enable/disable in iommufd mock driver for domain
replacement.
v1: https://lore.kernel.org/linux-iommu/[email protected]/
Jason Gunthorpe (3):
iommu/arm-smmu-v3: Put iopf enablement in the domain attach path iommu/vt-d: Check if SVA is supported when attaching the SVA domain
iommu: Remove IOMMU_DEV_FEAT_SVA
Lu Baolu (9):
iommu/vt-d: Move scalable mode ATS enablement to probe path iommu/vt-d: Move PRI enablement in probe path iommu/vt-d: Cleanup intel_context_flush_present() iommu/vt-d: Put iopf enablement in domain attach path iommufd/selftest: Put iopf enablement in domain attach path
dmaengine: idxd: Remove unnecessary IOMMU_DEV_FEAT_IOPF
uacce: Remove unnecessary IOMMU_DEV_FEAT_IOPF
iommufd: Remove unnecessary IOMMU_DEV_FEAT_IOPF
iommu: Remove iommu_dev_enable/disable_feature()
drivers/accel/amdxdna/aie2_pci.c | 13 +- drivers/dma/idxd/init.c | 43 +-- drivers/iommu/amd/iommu.c | 34 --- .../iommu/arm/arm-smmu-v3/arm-smmu-v3-sva.c | 86 +----- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 137 +++++---- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h | 39 +-- drivers/iommu/intel/iommu.c | 282 +++++++----------- drivers/iommu/intel/iommu.h | 42 ++- drivers/iommu/intel/nested.c | 16 +- drivers/iommu/intel/pasid.c | 43 +-- drivers/iommu/intel/prq.c | 2 +- drivers/iommu/intel/svm.c | 52 +++- drivers/iommu/iommu-sva.c | 3 - drivers/iommu/iommu.c | 32 -- drivers/iommu/iommufd/device.c | 1 - drivers/iommu/iommufd/fault.c | 111 ++----- drivers/iommu/iommufd/iommufd_private.h | 3 - drivers/iommu/iommufd/selftest.c | 64 +++- drivers/misc/uacce/uacce.c | 40 --- include/linux/iommu.h | 35 --- 20 files changed, 395 insertions(+), 683 deletions(-)
Signature · 1 line
2.43.0
Lu Baolu
maintainerPATCH v3 1/12 iommu/arm-smmu-v3: Put iopf enablement in the domain attach path
From: Jason Gunthorpe <[email protected]>
SMMUv3 co-mingles FEAT_IOPF and FEAT_SVA behaviors so that fault reporting doesn't work unless both are enabled. This is not correct and causes problems for iommufd which does not enable FEAT_SVA for it's fault capable domains.
These APIs are both obsolete, update SMMUv3 to use the new method like AMD implements.
A driver should enable iopf support when a domain with an iopf_handler is attached, and disable iopf support when the domain is removed.
Move the fault support logic to sva domain allocation and to domain attach, refusing to create or attach fault capable domains if the HW doesn't support it.
Move all the logic for controlling the iopf queue under arm_smmu_attach_prepare(). Keep track of the number of domains on the master (over all the SSIDs) that require iopf. When the first domain requiring iopf is attached create the iopf queue, when the last domain is detached destroy it.
Turn FEAT_IOPF and FEAT_SVA into no ops.
Remove the sva_lock, this is all protected by the group mutex.
--- .../iommu/arm/arm-smmu-v3/arm-smmu-v3-sva.c | 86 +------------- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 105 +++++++++++++----- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h | 39 ++----- 3 files changed, 91 insertions(+), 139 deletions(-)
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-sva.c +6 -80
@@ -13,8 +13,6 @@#include "arm-smmu-v3.h" #include "../../io-pgtable-arm.h" -static DEFINE_MUTEX (sva_lock); -static void __maybe_unused arm_smmu_update_s1_domain_cd_entry (struct arm_smmu_domain *smmu_domain) {
@@ -257,84 +255,6 @@ bool arm_smmu_sva_supported(struct arm_smmu_device *smmu)return true; } -bool arm_smmu_master_iopf_supported (struct arm_smmu_master *master) -{ -/* We're not keeping track of SIDs in fault events */ -if (master->num_streams !=1 ) -return false; - -return master->stall_enabled; -} - -bool arm_smmu_master_sva_supported (struct arm_smmu_master *master) -{ -if (!(master->smmu->features &ARM_SMMU_FEAT_SVA )) -return false; - -/* SSID support is mandatory for the moment */ -return master->ssid_bits; -} - -bool arm_smmu_master_sva_enabled (struct arm_smmu_master *master) -{ -bool enabled; - -mutex_lock (&sva_lock); - enabled = master->sva_enabled; -mutex_unlock (&sva_lock); -return enabled; -} - -static int arm_smmu_master_sva_enable_iopf (struct arm_smmu_master *master) -{ -struct device *dev = master->dev; - -/* -* Drivers for devices supporting PRI or stall should enable IOPF first. -* Others have device-specific fault handlers and don't need IOPF. -*/ -if (!arm_smmu_master_iopf_supported (master)) -return 0 ; - -if (!master->iopf_enabled) -return -EINVAL ; - -return iopf_queue_add_device (master->smmu->evtq.iopf, dev); -} - -static void arm_smmu_master_sva_disable_iopf (struct arm_smmu_master *master) -{ -struct device *dev = master->dev; - -if (!master->iopf_enabled) -return ; - -iopf_queue_remove_device (master->smmu->evtq.iopf, dev); -} - -int arm_smmu_master_enable_sva (struct arm_smmu_master *master) -{ -int ret; - -mutex_lock (&sva_lock); - ret =arm_smmu_master_sva_enable_iopf (master); -if (!ret) - master->sva_enabled = true; -mutex_unlock (&sva_lock); - -return ret; -} - -int arm_smmu_master_disable_sva (struct arm_smmu_master *master) -{ -mutex_lock (&sva_lock); -arm_smmu_master_sva_disable_iopf (master); - master->sva_enabled = false; -mutex_unlock (&sva_lock); - -return 0 ; -} -void arm_smmu_sva_notifier_synchronize (void ) {/*
@@ -353,6 +273,9 @@ static int arm_smmu_sva_set_dev_pasid(struct iommu_domain *domain,struct arm_smmu_cd target;int ret; +if (!(master->smmu->features &ARM_SMMU_FEAT_SVA )) +return -EOPNOTSUPP ; +/* Prevent arm_smmu_mm_release from being called while we are attaching */ if (!mmget_not_zero (domain->mm))return -EINVAL ;
@@ -406,6 +329,9 @@ struct iommu_domain *arm_smmu_sva_domain_alloc(struct device *dev,u32 asid;int ret; +if (!(master->smmu->features &ARM_SMMU_FEAT_SVA )) +return ERR_PTR (-EOPNOTSUPP ); + smmu_domain =arm_smmu_domain_alloc ();if (IS_ERR (smmu_domain))return ERR_CAST (smmu_domain);
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +78 -27
185 lines not on this page · raw message
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h +7 -32
@@ -830,9 +830,8 @@ struct arm_smmu_master { bool ats_enabled : 1; bool ste_ats_enabled : 1;bool stall_enabled; -bool sva_enabled; -bool iopf_enabled;unsigned int ssid_bits; +unsigned int iopf_refcount; };/* SMMU private data for an IOMMU domain */
@@ -908,8 +907,14 @@ void arm_smmu_make_sva_cd(struct arm_smmu_cd *target,struct arm_smmu_master_domain {struct list_head devices_elm;struct arm_smmu_master *master; +/* +* For nested domains the master_domain is threaded onto the S2 parent, +* this points to the IOMMU_DOMAIN_NESTED to disambiguate the masters. +*/ +struct iommu_domain *domain;ioasid_t ssid;bool nested_ats_flush :1 ; +bool using_iopf :1 ; };static inline struct arm_smmu_domain *to_smmu_domain (struct iommu_domain *dom)
@@ -987,11 +992,6 @@ int arm_smmu_cmdq_issue_cmdlist(struct arm_smmu_device *smmu,#ifdef CONFIG_ARM_SMMU_V3_SVA bool arm_smmu_sva_supported (struct arm_smmu_device *smmu); -bool arm_smmu_master_sva_supported (struct arm_smmu_master *master); -bool arm_smmu_master_sva_enabled (struct arm_smmu_master *master); -int arm_smmu_master_enable_sva (struct arm_smmu_master *master); -int arm_smmu_master_disable_sva (struct arm_smmu_master *master); -bool arm_smmu_master_iopf_supported (struct arm_smmu_master *master);void arm_smmu_sva_notifier_synchronize (void );struct iommu_domain *arm_smmu_sva_domain_alloc (struct device *dev,struct mm_struct *mm);
@@ -1001,31 +1001,6 @@ static inline bool arm_smmu_sva_supported(struct arm_smmu_device *smmu)return false; } -static inline bool arm_smmu_master_sva_supported (struct arm_smmu_master *master) -{ -return false; -} - -static inline bool arm_smmu_master_sva_enabled (struct arm_smmu_master *master) -{ -return false; -} - -static inline int arm_smmu_master_enable_sva (struct arm_smmu_master *master) -{ -return -ENODEV ; -} - -static inline int arm_smmu_master_disable_sva (struct arm_smmu_master *master) -{ -return -ENODEV ; -} - -static inline bool arm_smmu_master_iopf_supported (struct arm_smmu_master *master) -{ -return false; -} -static inline void arm_smmu_sva_notifier_synchronize (void ) {}#define arm_smmu_sva_domain_alloc NULL
Signature · 1 line
2.43.0
Re: [PATCH v3 01/12] iommu/arm-smmu-v3: Put iopf enablement in the domain attach path
Quoted 35 lines · Lu Baolu
From: Jason Gunthorpe <[email protected]>
SMMUv3 co-mingles
FEAT_IOPFandFEAT_SVAbehaviors so that fault reporting doesn't work unless both are enabled. This is not correct and causes problems for iommufd which does not enableFEAT_SVAfor it's fault capable domains.These APIs are both obsolete, update SMMUv3 to use the new method like AMD implements.
A driver should enable iopf support when a domain with an
iopf_handleris attached, and disable iopf support when the domain is removed.Move the fault support logic to sva domain allocation and to domain attach, refusing to create or attach fault capable domains if the HW doesn't support it.
Move all the logic for controlling the iopf queue under
arm_smmu_attach_prepare(). Keep track of the number of domains on the master (over all the SSIDs) that require iopf. When the first domain requiring iopf is attached create the iopf queue, when the last domain is detached destroy it.Turn
FEAT_IOPFandFEAT_SVAinto no ops.Remove the
sva_lock, this is all protected by the group mutex.Signed-off-by Jason Gunthorpe <[email protected]>Signed-off-by Lu Baolu <[email protected]>Tested-by Zhangfei Gao <[email protected]>--- .../iommu/arm/arm-smmu-v3/arm-smmu-v3-sva.c | 86 +------------- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 105 +++++++++++++----- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h | 39 ++----- 3 files changed, 91 insertions(+), 139 deletions(-)
[...]
Quoted 36 lines
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +32
-0@@ -2748,6 +2750,54 @@ to_smmu_domain_devices(struct iommu_domain *domain)return NULL ; } +static int arm_smmu_enable_iopf (struct arm_smmu_master *master, +struct arm_smmu_master_domain *master_domain) +{ +int ret; + +iommu_group_mutex_assert (master->dev); + +if (!IS_ENABLED (CONFIG_ARM_SMMU_V3_SVA )) +return -EOPNOTSUPP ; + +/* +* Drivers for devices supporting PRI or stall require iopf others have +* device-specific fault handlers and don't need IOPF, so this is not a +* failure. +*/ +if (!master->stall_enabled) +return 0 ; + +/* We're not keeping track of SIDs in fault events */ +if (master->num_streams !=1 ) +return -EOPNOTSUPP ; + +if (master->iopf_refcount) { + master->iopf_refcount++; + master_domain->using_iopf = true; +return 0 ; + } + + ret =iopf_queue_add_device (master->smmu->evtq.iopf, master->dev); +if (ret) +return ret; + master->iopf_refcount =1 ;
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c to_smmu_domain_devices(struct iommu_domain *domain) · line 2794
Quoted 10 lines
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +10
-0+ master_domain->using_iopf = true; +return 0 ; +} + +static void arm_smmu_disable_iopf (struct arm_smmu_master *master) +{ +iommu_group_mutex_assert (master->dev); + +if (!IS_ENABLED (CONFIG_ARM_SMMU_V3_SVA )) +return ;
I think it would be a little cleaner to push the '->using_iopf' check in here rather than have the callers check it. Then the SVA check above makes more sense and I think the enable/disable paths are a bit more symmetric.
With that:
Will
Baolu Lu
maintainerRe: [PATCH v3 01/12] iommu/arm-smmu-v3: Put iopf enablement in the domain attach path
Quoted 82 lines · Will Deacon
Quoted 35 lines · Lu Baolu
From: Jason Gunthorpe <[email protected]>
SMMUv3 co-mingles
FEAT_IOPFandFEAT_SVAbehaviors so that fault reporting doesn't work unless both are enabled. This is not correct and causes problems for iommufd which does not enableFEAT_SVAfor it's fault capable domains.These APIs are both obsolete, update SMMUv3 to use the new method like AMD implements.
A driver should enable iopf support when a domain with an
iopf_handleris attached, and disable iopf support when the domain is removed.Move the fault support logic to sva domain allocation and to domain attach, refusing to create or attach fault capable domains if the HW doesn't support it.
Move all the logic for controlling the iopf queue under
arm_smmu_attach_prepare(). Keep track of the number of domains on the master (over all the SSIDs) that require iopf. When the first domain requiring iopf is attached create the iopf queue, when the last domain is detached destroy it.Turn
FEAT_IOPFandFEAT_SVAinto no ops.Remove the
sva_lock, this is all protected by the group mutex.Signed-off-by Jason Gunthorpe <[email protected]>Signed-off-by Lu Baolu <[email protected]>Tested-by Zhangfei Gao <[email protected]>--- .../iommu/arm/arm-smmu-v3/arm-smmu-v3-sva.c | 86 +------------- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 105 +++++++++++++----- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h | 39 ++----- 3 files changed, 91 insertions(+), 139 deletions(-)[...]
Quoted 43 lines
(quoted diff) +39
-0@@ -2748,6 +2750,54 @@ to_smmu_domain_devices(struct iommu_domain *domain) return NULL; } +static int arm_smmu_enable_iopf(struct arm_smmu_master *master, + struct arm_smmu_master_domain *master_domain) +{ + int ret; + + iommu_group_mutex_assert(master->dev); + + if (!IS_ENABLED(CONFIG_ARM_SMMU_V3_SVA)) + return -EOPNOTSUPP; + + /* + * Drivers for devices supporting PRI or stall require iopf others have + * device-specific fault handlers and don't need IOPF, so this is not a + * failure. + */ + if (!master->stall_enabled) + return 0; + + /* We're not keeping track of SIDs in fault events */ + if (master->num_streams != 1) + return -EOPNOTSUPP; + + if (master->iopf_refcount) { + master->iopf_refcount++; + master_domain->using_iopf = true; + return 0; + } + + ret = iopf_queue_add_device(master->smmu->evtq.iopf, master->dev); + if (ret) + return ret; + master->iopf_refcount = 1; + master_domain->using_iopf = true; + return 0; +} + +static void arm_smmu_disable_iopf(struct arm_smmu_master *master) +{ + iommu_group_mutex_assert(master->dev);
Quoted 8 lines
Review to_smmu_domain_devices(struct iommu_domain *domain) · line 2794
Quoted 3 lines
(quoted diff) +3
-0+ + if (!IS_ENABLED(CONFIG_ARM_SMMU_V3_SVA)) + return;I think it would be a little cleaner to push the '->using_iopf' check in here rather than have the callers check it. Then the SVA check above makes more sense and I think the enable/disable paths are a bit more symmetric.
Yes, sure. I will address it like this,
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +5 -1
@@ -2786,13 +2786,17 @@ static int arm_smmu_enable_iopf(struct arm_smmu_master *master,return 0 ; } -static void arm_smmu_disable_iopf (struct arm_smmu_master *master) +static void arm_smmu_disable_iopf (struct arm_smmu_master *master, +struct arm_smmu_master_domain *master_domain) {iommu_group_mutex_assert (master->dev);if (!IS_ENABLED (CONFIG_ARM_SMMU_V3_SVA ))return ; +if (!master_domain || !master_domain->using_iopf) +return ; + master->iopf_refcount--;if (master->iopf_refcount ==0 ) iopf_queue_remove_device(master->smmu->evtq.iopf,
master->dev);
@@ -2823,11 +2827,8 @@ static void arm_smmu_remove_master_domain(struct arm_smmu_master *master,
}
spin_unlock_irqrestore(&smmu_domain->devices_lock, flags);- if (master_domain) {
- if (master_domain->using_iopf)
- arm_smmu_disable_iopf(master);
- kfree(master_domain);
- } + arm_smmu_disable_iopf(master, master_domain); + kfree(master_domain);
}
/*
@@ -2945,8 +2946,7 @@ int arm_smmu_attach_prepare(struct arm_smmu_attach_state *state,
return 0;
err_iopf:
- if (master_domain && master_domain->using_iopf)
- arm_smmu_disable_iopf(master);
+ arm_smmu_disable_iopf(master);
err_free_master_domain:
kfree(master_domain);
return ret;Quoted 6 lines
With that:
Acked-by Will Deacon <[email protected]>Will
Thanks,
baolu
Jason Gunthorpe
maintainerRe: [PATCH v3 01/12] iommu/arm-smmu-v3: Put iopf enablement in the domain attach path
Quoted 52 lines · Baolu Lu
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +5
-1@@ -2786,13 +2786,17 @@ static int arm_smmu_enable_iopf(structarm_smmu_master *master, return 0; } -static void arm_smmu_disable_iopf (struct arm_smmu_master *master) +static void arm_smmu_disable_iopf (struct arm_smmu_master *master, +struct arm_smmu_master_domain *master_domain) {iommu_group_mutex_assert (master->dev);if (!IS_ENABLED (CONFIG_ARM_SMMU_V3_SVA ))return ; +if (!master_domain || !master_domain->using_iopf) +return ; + master->iopf_refcount--;if (master->iopf_refcount == 0) iopf_queue_remove_device(master->smmu->evtq.iopf,
master->dev);drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +2
-5@@ -2823,11 +2827,8 @@ static void arm_smmu_remove_master_domain(struct arm_smmu_master *master, }spin_unlock_irqrestore (&smmu_domain->devices_lock, flags); -if (master_domain) { -if (master_domain->using_iopf) -arm_smmu_disable_iopf (master); -kfree (master_domain); - } +arm_smmu_disable_iopf (master, master_domain); +kfree (master_domain); }/*
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +1
-2@@ -2945,8 +2946,7 @@ int arm_smmu_attach_prepare(structarm_smmu_attach_state *state, return 0; err_iopf: -if (master_domain && master_domain->using_iopf) -arm_smmu_disable_iopf (master); +arm_smmu_disable_iopf (master); err_free_master_domain:kfree (master_domain);
Quoted 1 line
return ret;
Looks OK
Thanks,
Jason
Lu Baolu
maintainerPATCH v3 2/12 iommu/vt-d: Check if SVA is supported when attaching the SVA domain
In reply to Lu BaoluFrom: Jason Gunthorpe <[email protected]>
Attach of a SVA domain should fail if SVA is not supported, move the check for SVA support out of IOMMU_DEV_FEAT_SVA and into attach.
Also check when allocating a SVA domain to match other drivers.
--- drivers/iommu/intel/iommu.c | 37 +------------------------------ drivers/iommu/intel/svm.c | 43 +++++++++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+), 36 deletions(-)
drivers/iommu/intel/iommu.c +1 -36
@@ -3851,41 +3851,6 @@ static struct iommu_group *intel_iommu_device_group(struct device *dev)return generic_device_group (dev); } -static int intel_iommu_enable_sva (struct device *dev) -{ -struct device_domain_info *info =dev_iommu_priv_get (dev); -struct intel_iommu *iommu; - -if (!info || dmar_disabled) -return -EINVAL ; - - iommu = info->iommu; -if (!iommu) -return -EINVAL ; - -if (!(iommu->flags &VTD_FLAG_SVM_CAPABLE )) -return -ENODEV ; - -if (!info->pasid_enabled || !info->ats_enabled) -return -EINVAL ; - -/* -* Devices having device-specific I/O fault handling should not -* support PCI/PRI. The IOMMU side has no means to check the -* capability of device-specific IOPF. Therefore, IOMMU can only -* default that if the device driver enables SVA on a non-PRI -* device, it will handle IOPF in its own way. -*/ -if (!info->pri_supported) -return 0 ; - -/* Devices supporting PRI should have it enabled. */ -if (!info->pri_enabled) -return -EINVAL ; - -return 0 ; -} -static int context_flip_pri (struct device_domain_info *info,bool enable) {struct intel_iommu *iommu = info->iommu;
@@ -4006,7 +3971,7 @@ intel_iommu_dev_enable_feat(struct device *dev, enum iommu_dev_features feat)return intel_iommu_enable_iopf (dev);case IOMMU_DEV_FEAT_SVA : -return intel_iommu_enable_sva (dev); +return 0 ;default :return -ENODEV ;
drivers/iommu/intel/svm.c +43 -0
61 lines not on this page · raw message
Signature · 1 line
2.43.0
Lu Baolu
maintainerPATCH v3 3/12 iommu: Remove IOMMU_DEV_FEAT_SVA
In reply to Lu BaoluFrom: Jason Gunthorpe <[email protected]>
None of the drivers implement anything here anymore, remove the dead code.
--- drivers/accel/amdxdna/aie2_pci.c | 13 ++----------- drivers/dma/idxd/init.c | 8 +------- drivers/iommu/amd/iommu.c | 2 -- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 2 -- drivers/iommu/intel/iommu.c | 6 ------ drivers/iommu/iommu-sva.c | 3 --- drivers/misc/uacce/uacce.c | 9 --------- include/linux/iommu.h | 9 +-------- 8 files changed, 4 insertions(+), 48 deletions(-)
drivers/accel/amdxdna/aie2_pci.c +2 -11
@@ -512,12 +512,6 @@ static int aie2_init(struct amdxdna_dev *xdna) goto release_fw; } - ret =iommu_dev_enable_feature (&pdev->dev,IOMMU_DEV_FEAT_SVA ); -if (ret) { -XDNA_ERR (xdna,"Enable PASID failed, ret %d" , ret); - goto free_irq; - } - psp_conf.fw_size = fw->size; psp_conf.fw_buf = fw->data;for (i =0 ; i <PSP_MAX_REGS ; i++)
@@ -526,14 +520,14 @@ static int aie2_init(struct amdxdna_dev *xdna)if (!ndev->psp_hdl) {XDNA_ERR (xdna,"failed to create psp" ); ret = -ENOMEM ; - goto disable_sva; + goto free_irq; } xdna->dev_handle = ndev; ret =aie2_hw_start (xdna);if (ret) {XDNA_ERR (xdna,"start npu failed, ret %d" , ret); - goto disable_sva; + goto free_irq; } ret =aie2_mgmt_fw_query (ndev);
@@ -584,8 +578,6 @@ static int aie2_init(struct amdxdna_dev *xdna)aie2_error_async_events_free (ndev); stop_hw:aie2_hw_stop (xdna); -disable_sva: -iommu_dev_disable_feature (&pdev->dev,IOMMU_DEV_FEAT_SVA ); free_irq:pci_free_irq_vectors (pdev); release_fw:
@@ -601,7 +593,6 @@ static void aie2_fini(struct amdxdna_dev *xdna)aie2_hw_stop (xdna);aie2_error_async_events_free (ndev); -iommu_dev_disable_feature (&pdev->dev,IOMMU_DEV_FEAT_SVA );pci_free_irq_vectors (pdev); }
drivers/dma/idxd/init.c +1 -7
@@ -633,17 +633,11 @@ static int idxd_enable_sva(struct pci_dev *pdev) ret =iommu_dev_enable_feature (&pdev->dev,IOMMU_DEV_FEAT_IOPF );if (ret)return ret; - - ret =iommu_dev_enable_feature (&pdev->dev,IOMMU_DEV_FEAT_SVA ); -if (ret) -iommu_dev_disable_feature (&pdev->dev,IOMMU_DEV_FEAT_IOPF ); - -return ret; +return 0 ; }static void idxd_disable_sva (struct pci_dev *pdev) { -iommu_dev_disable_feature (&pdev->dev,IOMMU_DEV_FEAT_SVA );iommu_dev_disable_feature (&pdev->dev,IOMMU_DEV_FEAT_IOPF ); }
drivers/iommu/amd/iommu.c +0 -2
@@ -2990,7 +2990,6 @@ static int amd_iommu_dev_enable_feature(struct device *dev,switch (feat) {case IOMMU_DEV_FEAT_IOPF : -case IOMMU_DEV_FEAT_SVA :break ;default : ret = -EINVAL ;
@@ -3006,7 +3005,6 @@ static int amd_iommu_dev_disable_feature(struct device *dev,switch (feat) {case IOMMU_DEV_FEAT_IOPF : -case IOMMU_DEV_FEAT_SVA :break ;default : ret = -EINVAL ;
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +0 -2
@@ -3630,7 +3630,6 @@ static int arm_smmu_dev_enable_feature(struct device *dev,switch (feat) {case IOMMU_DEV_FEAT_IOPF : -case IOMMU_DEV_FEAT_SVA :return 0 ;default :return -EINVAL ;
@@ -3647,7 +3646,6 @@ static int arm_smmu_dev_disable_feature(struct device *dev,switch (feat) {case IOMMU_DEV_FEAT_IOPF : -case IOMMU_DEV_FEAT_SVA :return 0 ;default :return -EINVAL ;
drivers/iommu/intel/iommu.c +0 -6
@@ -3970,9 +3970,6 @@ intel_iommu_dev_enable_feat(struct device *dev, enum iommu_dev_features feat)case IOMMU_DEV_FEAT_IOPF :return intel_iommu_enable_iopf (dev); -case IOMMU_DEV_FEAT_SVA : -return 0 ; -default :return -ENODEV ; }
@@ -3985,9 +3982,6 @@ intel_iommu_dev_disable_feat(struct device *dev, enum iommu_dev_features feat)case IOMMU_DEV_FEAT_IOPF :return intel_iommu_disable_iopf (dev); -case IOMMU_DEV_FEAT_SVA : -return 0 ; -default :return -ENODEV ; }
drivers/iommu/iommu-sva.c +0 -3
@@ -63,9 +63,6 @@ static struct iommu_mm_data *iommu_alloc_mm_data(struct mm_struct *mm, struct de* reference is taken. Caller must call iommu_sva_unbind_device() * to release each reference. * -* iommu_dev_enable_feature(dev, IOMMU_DEV_FEAT_SVA) must be called first, to -* initialize the required SVA features. -* * On error, returns an ERR_PTR value. */ struct iommu_sva *iommu_sva_bind_device (struct device *dev,struct mm_struct *mm)
drivers/misc/uacce/uacce.c +0 -9
@@ -479,14 +479,6 @@ static unsigned int uacce_enable_sva(struct device *parent, unsigned int flags)dev_err (parent,"failed to enable IOPF feature! ret = %pe\n" ,ERR_PTR (ret));return flags; } - - ret =iommu_dev_enable_feature (parent,IOMMU_DEV_FEAT_SVA ); -if (ret) { -dev_err (parent,"failed to enable SVA feature! ret = %pe\n" ,ERR_PTR (ret)); -iommu_dev_disable_feature (parent,IOMMU_DEV_FEAT_IOPF ); -return flags; - } -return flags |UACCE_DEV_SVA ; }
@@ -495,7 +487,6 @@ static void uacce_disable_sva(struct uacce_device *uacce)if (!(uacce->flags &UACCE_DEV_SVA ))return ; -iommu_dev_disable_feature (uacce->parent,IOMMU_DEV_FEAT_SVA );iommu_dev_disable_feature (uacce->parent,IOMMU_DEV_FEAT_IOPF ); }
include/linux/iommu.h +1 -8
@@ -303,18 +303,11 @@ struct iommu_iort_rmr_data {/** * enum iommu_dev_features - Per device IOMMU features -* @IOMMU_DEV_FEAT_SVA: Shared Virtual Addresses -* @IOMMU_DEV_FEAT_IOPF: I/O Page Faults such as PRI or Stall. Generally -* enabling %IOMMU_DEV_FEAT_SVA requires -* %IOMMU_DEV_FEAT_IOPF, but some devices manage I/O Page -* Faults themselves instead of relying on the IOMMU. When -* supported, this feature must be enabled before and -* disabled after %IOMMU_DEV_FEAT_SVA. +* @IOMMU_DEV_FEAT_IOPF: I/O Page Faults such as PRI or Stall. * * Device drivers enable a feature using iommu_dev_enable_feature(). */ enum iommu_dev_features { -IOMMU_DEV_FEAT_SVA ,IOMMU_DEV_FEAT_IOPF , };
Signature · 1 line
2.43.0
Lu Baolu
maintainerPATCH v3 4/12 iommu/vt-d: Move scalable mode ATS enablement to probe path
In reply to Lu BaoluDevice ATS is currently enabled when a domain is attached to the device and disabled when the domain is detached. This creates a limitation:
when the IOMMU is operating in scalable mode and IOPF is enabled, the device's domain cannot be changed.
Remove this limitation by moving ATS enablement to the device probe path.
--- drivers/iommu/intel/iommu.c | 51 ++++++++++++++++++++----------------- 1 file changed, 27 insertions(+), 24 deletions(-)
drivers/iommu/intel/iommu.c +27 -24
@@ -1172,32 +1172,28 @@ static bool dev_needs_extra_dtlb_flush(struct pci_dev *pdev)return true; } -static void iommu_enable_pci_caps (struct device_domain_info *info) +static void iommu_enable_pci_ats (struct device_domain_info *info) {struct pci_dev *pdev; -if (!dev_is_pci (info->dev)) +if (!info->ats_supported)return ; pdev =to_pci_dev (info->dev); -if (info->ats_supported &&pci_ats_page_aligned (pdev) && - !pci_enable_ats (pdev,VTD_PAGE_SHIFT )) +if (!pci_ats_page_aligned (pdev)) +return ; + +if (!pci_enable_ats (pdev,VTD_PAGE_SHIFT )) info->ats_enabled =1 ; } -static void iommu_disable_pci_caps (struct device_domain_info *info) +static void iommu_disable_pci_ats (struct device_domain_info *info) { -struct pci_dev *pdev; - -if (!dev_is_pci (info->dev)) +if (!info->ats_enabled)return ; - pdev =to_pci_dev (info->dev); - -if (info->ats_enabled) { -pci_disable_ats (pdev); - info->ats_enabled =0 ; - } +pci_disable_ats (to_pci_dev (info->dev)); + info->ats_enabled =0 ; }static void intel_flush_iotlb_all (struct iommu_domain *domain)
@@ -1556,12 +1552,19 @@ domain_context_mapping(struct dmar_domain *domain, struct device *dev)struct device_domain_info *info =dev_iommu_priv_get (dev);struct intel_iommu *iommu = info->iommu;u8 bus = info->bus, devfn = info->devfn; +int ret;if (!dev_is_pci (dev))return domain_context_mapping_one (domain, iommu, bus, devfn); -return pci_for_each_dma_alias (to_pci_dev (dev), - domain_context_mapping_cb, domain); + ret =pci_for_each_dma_alias (to_pci_dev (dev), + domain_context_mapping_cb, domain); +if (ret) +return ret; + +iommu_enable_pci_ats (info); + +return 0 ; }/* Return largest possible superpage level for a given mapping */
@@ -1843,8 +1846,6 @@ static int dmar_domain_attach_device(struct dmar_domain *domain,if (ret) goto out_block_translation; -iommu_enable_pci_caps (info); - ret =cache_tag_assign_domain (domain, dev,IOMMU_NO_PASID );if (ret) goto out_block_translation;
@@ -3198,6 +3199,7 @@ static void domain_context_clear(struct device_domain_info *info)pci_for_each_dma_alias (to_pci_dev (info->dev), &domain_context_clear_one_cb, info); +iommu_disable_pci_ats (info); }/*
@@ -3214,7 +3216,6 @@ void device_block_translation(struct device *dev)if (info->domain)cache_tag_unassign_domain (info->domain, dev,IOMMU_NO_PASID ); -iommu_disable_pci_caps (info);if (!dev_is_real_dma_subdevice (dev)) {if (sm_supported (iommu)) intel_pasid_tear_down_entry(iommu, dev,
@@ -3749,6 +3750,9 @@ static struct iommu_device *intel_iommu_probe_device(struct device *dev) !pci_enable_pasid(pdev, info->pasid_supported & ~1)) info->pasid_enabled = 1; +if (sm_supported (iommu)) +iommu_enable_pci_ats (info); +return &iommu->iommu; free_table:intel_pasid_free_table (dev);
@@ -3765,6 +3769,8 @@ static void intel_iommu_release_device(struct device *dev)struct device_domain_info *info =dev_iommu_priv_get (dev);struct intel_iommu *iommu = info->iommu; +iommu_disable_pci_ats (info); +if (info->pasid_enabled) {pci_disable_pasid (to_pci_dev (dev)); info->pasid_enabled =0 ;
@@ -4365,13 +4371,10 @@ static int identity_domain_attach_dev(struct iommu_domain *domain, struct deviceif (dev_is_real_dma_subdevice (dev))return 0 ; -if (sm_supported (iommu)) { +if (sm_supported (iommu)) ret =intel_pasid_setup_pass_through (iommu, dev,IOMMU_NO_PASID ); -if (!ret) -iommu_enable_pci_caps (info); - }else { +else ret =device_setup_pass_through (dev); - }return ret; }
Signature · 1 line
2.43.0
Tian, Kevin
maintainerRE: [PATCH v3 04/12] iommu/vt-d: Move scalable mode ATS enablement to probe path
Quoted 7 lines
From: Lu Baolu <[email protected]>
Sent: Friday, February 28, 2025 5:26 PMDevice ATS is currently enabled when a domain is attached to the device and disabled when the domain is detached. This creates a limitation:
when the IOMMU is operating in scalable mode and IOPF is enabled, the device's domain cannot be changed.
could you extend it with your earlier reply?
https://lore.kernel.org/linux-iommu/[email protected]/
Quoted 10 lines
drivers/iommu/intel/iommu.c +2
-2-static void iommu_enable_pci_caps (struct device_domain_info *info) +static void iommu_enable_pci_ats (struct device_domain_info *info) {struct pci_dev *pdev; -if (!dev_is_pci (info->dev)) +if (!info->ats_supported)return ;
drivers/iommu/intel/iommu.c static bool dev_needs_extra_dtlb_flush(struct pci_dev *pdev) · line 1188
Quoted 10 lines
drivers/iommu/intel/iommu.c +4
-2pdev =to_pci_dev (info->dev); -if (info->ats_supported &&pci_ats_page_aligned (pdev) && - !pci_enable_ats (pdev,VTD_PAGE_SHIFT )) +if (!pci_ats_page_aligned (pdev)) +return ; + +if (!pci_enable_ats (pdev,VTD_PAGE_SHIFT )) info->ats_enabled =1 ; }
still prefer to some comment above as you explained in above reply. It's not obvious w/o knowing the tricky background.
Baolu Lu
maintainerRe: [PATCH v3 04/12] iommu/vt-d: Move scalable mode ATS enablement to probe path
Quoted 20 lines · Kevin
Quoted 7 lines
From: Lu Baolu<[email protected]>
Sent: Friday, February 28, 2025 5:26 PMDevice ATS is currently enabled when a domain is attached to the device and disabled when the domain is detached. This creates a limitation:
when the IOMMU is operating in scalable mode and IOPF is enabled, the device's domain cannot be changed.could you extend it with your earlier reply?
https://lore.kernel.org/linux-iommu/6a418974-d06e-46e3-879f- [email protected]/
Quoted 9 lines
drivers/iommu/intel/iommu.c +2
-2-static void iommu_enable_pci_caps (struct device_domain_info *info) +static void iommu_enable_pci_ats (struct device_domain_info *info) {struct pci_dev *pdev; -if (!dev_is_pci (info->dev)) +if (!info->ats_supported)return ;
Quoted 12 lines
drivers/iommu/intel/iommu.c static bool dev_needs_extra_dtlb_flush(struct pci_dev *pdev) · line 1188
Quoted 10 lines
pdev = to_pci_dev(info->dev);drivers/iommu/intel/iommu.c +4
-2-if (info->ats_supported &&pci_ats_page_aligned (pdev) && - !pci_enable_ats (pdev,VTD_PAGE_SHIFT )) +if (!pci_ats_page_aligned (pdev)) +return ; + +if (!pci_enable_ats (pdev,VTD_PAGE_SHIFT )) info->ats_enabled =1 ; }still prefer to some comment above as you explained in above reply. It's not obvious w/o knowing the tricky background.
Okay, sure.
Lu Baolu
maintainerPATCH v3 5/12 iommu/vt-d: Move PRI enablement in probe path
In reply to Lu BaoluUpdate PRI enablement to use the new method, similar to the amd iommu driver. Enable PRI in the device probe path and disable it when the device is released. PRI is enabled throughout the device's iommu lifecycle. The infrastructure for the iommu subsystem to handle iopf requests is created during iopf enablement and released during iopf disablement. All invalid page requests from the device are automatically handled by the iommu subsystem if iopf is not enabled. Add iopf_refcount to track the iopf enablement.
Convert the return type of intel_iommu_disable_iopf() to void, as there is no way to handle a failure when disabling this feature. Make intel_iommu_enable/disable_iopf() helpers global, as they will be used beyond the current file in the subsequent patch.
The iopf_refcount is not protected by any lock. This is acceptable, as there is no concurrent access to it in the current code. The following patch will address this by moving it to the domain attach/detach paths, which are protected by the iommu group mutex.
--- drivers/iommu/intel/iommu.c | 137 +++++++++++++----------------------- drivers/iommu/intel/iommu.h | 4 ++ drivers/iommu/intel/pasid.c | 2 + drivers/iommu/intel/prq.c | 2 +- 4 files changed, 55 insertions(+), 90 deletions(-)
drivers/iommu/intel/iommu.c +48 -89
@@ -1196,6 +1196,37 @@ static void iommu_disable_pci_ats(struct device_domain_info *info) info->ats_enabled =0 ; } +static void iommu_enable_pci_pri (struct device_domain_info *info) +{ +struct pci_dev *pdev; + +if (!info->ats_enabled || !info->pri_supported) +return ; + + pdev =to_pci_dev (info->dev); +/* PASID is required in PRG Response Message. */ +if (info->pasid_enabled && !pci_prg_resp_pasid_required (pdev)) +return ; + +if (pci_reset_pri (pdev)) +return ; + +if (!pci_enable_pri (pdev,PRQ_DEPTH )) + info->pri_enabled =1 ; +} + +static void iommu_disable_pci_pri (struct device_domain_info *info) +{ +if (!info->pri_enabled) +return ; + +if (WARN_ON (info->iopf_refcount)) +iopf_queue_remove_device (info->iommu->iopf_queue, info->dev); + +pci_disable_pri (to_pci_dev (info->dev)); + info->pri_enabled =0 ; +} +static void intel_flush_iotlb_all (struct iommu_domain *domain) {cache_tag_flush_all (to_dmar_domain (domain));
@@ -3752,6 +3783,7 @@ static struct iommu_device *intel_iommu_probe_device(struct device *dev)if (sm_supported (iommu))iommu_enable_pci_ats (info); +iommu_enable_pci_pri (info);return &iommu->iommu; free_table:
@@ -3769,6 +3801,7 @@ static void intel_iommu_release_device(struct device *dev)struct device_domain_info *info =dev_iommu_priv_get (dev);struct intel_iommu *iommu = info->iommu; +iommu_disable_pci_pri (info);iommu_disable_pci_ats (info);if (info->pasid_enabled) {
@@ -3857,116 +3890,41 @@ static struct iommu_group *intel_iommu_device_group(struct device *dev)return generic_device_group (dev); } -static int context_flip_pri (struct device_domain_info *info,bool enable) +int intel_iommu_enable_iopf (struct device *dev) { -struct intel_iommu *iommu = info->iommu; -u8 bus = info->bus, devfn = info->devfn; -struct context_entry *context; -u16 did; - -spin_lock (&iommu->lock); -if (context_copied (iommu, bus, devfn)) { -spin_unlock (&iommu->lock); -return -EINVAL ; - } - - context =iommu_context_addr (iommu, bus, devfn, false); -if (!context || !context_present (context)) { -spin_unlock (&iommu->lock); -return -ENODEV ; - } - did =context_domain_id (context); - -if (enable) -context_set_sm_pre (context); -else -context_clear_sm_pre (context); - -if (!ecap_coherent (iommu->ecap)) -clflush_cache_range (context,sizeof (*context)); -intel_context_flush_present (info, context, did, true); -spin_unlock (&iommu->lock); - -return 0 ; -} - -static int intel_iommu_enable_iopf (struct device *dev) -{ -struct pci_dev *pdev =dev_is_pci (dev) ?to_pci_dev (dev) :NULL ;struct device_domain_info *info =dev_iommu_priv_get (dev); -struct intel_iommu *iommu; +struct intel_iommu *iommu = info->iommu;int ret; -if (!pdev || !info || !info->ats_enabled || !info->pri_supported) +if (!info->pri_enabled)return -ENODEV ; -if (info->pri_enabled) -return -EBUSY ; - - iommu = info->iommu; -if (!iommu) -return -EINVAL ; - -/* PASID is required in PRG Response Message. */ -if (info->pasid_enabled && !pci_prg_resp_pasid_required (pdev)) -return -EINVAL ; - - ret =pci_reset_pri (pdev); -if (ret) -return ret; +if (info->iopf_refcount) { + info->iopf_refcount++; +return 0 ; + } ret =iopf_queue_add_device (iommu->iopf_queue, dev);if (ret)return ret; - ret =context_flip_pri (info, true); -if (ret) - goto err_remove_device; - - ret =pci_enable_pri (pdev,PRQ_DEPTH ); -if (ret) - goto err_clear_pri; - - info->pri_enabled =1 ; + info->iopf_refcount =1 ;return 0 ; -err_clear_pri: -context_flip_pri (info, false); -err_remove_device: -iopf_queue_remove_device (iommu->iopf_queue, dev); - -return ret; } -static int intel_iommu_disable_iopf (struct device *dev) +void intel_iommu_disable_iopf (struct device *dev) {struct device_domain_info *info =dev_iommu_priv_get (dev);struct intel_iommu *iommu = info->iommu; -if (!info->pri_enabled) -return -EINVAL ; +if (WARN_ON (!info->pri_enabled || !info->iopf_refcount)) +return ; -/* Disable new PRI reception: */ -context_flip_pri (info, false); +if (--info->iopf_refcount) +return ; -/* -* Remove device from fault queue and acknowledge all outstanding -* PRQs to the device: -*/ iopf_queue_remove_device (iommu->iopf_queue, dev); - -/* -* PCIe spec states that by clearing PRI enable bit, the Page -* Request Interface will not issue new page requests, but has -* outstanding page requests that have been transmitted or are -* queued for transmission. This is supposed to be called after -* the device driver has stopped DMA, all PASIDs have been -* unbound and the outstanding PRQs have been drained. -*/ -pci_disable_pri (to_pci_dev (dev)); - info->pri_enabled =0 ; - -return 0 ; } static int
@@ -3986,7 +3944,8 @@ intel_iommu_dev_disable_feat(struct device *dev, enum iommu_dev_features feat) {switch (feat) {case IOMMU_DEV_FEAT_IOPF : -return intel_iommu_disable_iopf (dev); +intel_iommu_disable_iopf (dev); +return 0 ;default :return -ENODEV ;
drivers/iommu/intel/iommu.h +4 -0
@@ -774,6 +774,7 @@ struct device_domain_info { u8 ats_enabled:1; u8 dtlb_extra_inval:1; /* Quirk for devices need extra flush */u8 ats_qdep; +unsigned int iopf_refcount;struct device *dev;/* it's NULL for PCIe-to-PCI bridge */ struct intel_iommu *iommu;/* IOMMU used by this device */ struct dmar_domain *domain;/* pointer to domain */
@@ -1314,6 +1315,9 @@ void intel_iommu_page_response(struct device *dev, struct iopf_fault *evt, struct iommu_page_response *msg);void intel_iommu_drain_pasid_prq (struct device *dev,u32 pasid); +int intel_iommu_enable_iopf (struct device *dev); +void intel_iommu_disable_iopf (struct device *dev); +#ifdef CONFIG_INTEL_IOMMU_SVM void intel_svm_check (struct intel_iommu *iommu); struct iommu_domain *intel_svm_domain_alloc(struct device *dev,
drivers/iommu/intel/pasid.c +2 -0
@@ -992,6 +992,8 @@ static int context_entry_set_pasid_table(struct context_entry *context,context_set_sm_dte (context);if (info->pasid_supported)context_set_pasid (context); +if (info->pri_supported) +context_set_sm_pre (context);context_set_fault_enable (context);context_set_present (context);
drivers/iommu/intel/prq.c +1 -1
@@ -67,7 +67,7 @@ void intel_iommu_drain_pasid_prq(struct device *dev, u32 pasid)u16 sid, did; info =dev_iommu_priv_get (dev); -if (!info->pri_enabled) +if (!info->iopf_refcount)return ; iommu = info->iommu;
Signature · 1 line
2.43.0
RE: [PATCH v3 05/12] iommu/vt-d: Move PRI enablement in probe path
drivers/iommu/intel/iommu.c static void iommu_disable_pci_ats(struct device_domain_info *info) · line 1218
Quoted 5 lines
From: Lu Baolu <[email protected]>
Sent: Friday, February 28, 2025 5:26 PMdrivers/iommu/intel/iommu.c +2
-0+static void iommu_enable_pci_pri(struct device_domain_info *info) +static void iommu_disable_pci_pri(struct device_domain_info *info)
no need to have '_pci_'
Lu Baolu
maintainerPATCH v3 6/12 iommu/vt-d: Cleanup intel_context_flush_present()
In reply to Lu BaoluThe intel_context_flush_present() is called in places where either the scalable mode is disabled, or scalable mode is enabled but all PASID entries are known to be non-present. In these cases, the flush_domains path within intel_context_flush_present() will never execute. This dead code is therefore removed.
--- drivers/iommu/intel/iommu.c | 2 +- drivers/iommu/intel/iommu.h | 5 ++--- drivers/iommu/intel/pasid.c | 41 +++++++------------------------------ 3 files changed, 10 insertions(+), 38 deletions(-)
drivers/iommu/intel/iommu.c +1 -1
@@ -1782,7 +1782,7 @@ static void domain_context_clear_one(struct device_domain_info *info, u8 bus, u8context_clear_entry (context);__iommu_flush_cache (iommu, context,sizeof (*context));spin_unlock (&iommu->lock); -intel_context_flush_present (info, context, did, true); +intel_context_flush_no_pasid (info, context, did); } int __domain_setup_first_level(struct intel_iommu *iommu,
drivers/iommu/intel/iommu.h +2 -3
@@ -1305,9 +1305,8 @@ void cache_tag_flush_all(struct dmar_domain *domain);void cache_tag_flush_range_np (struct dmar_domain *domain,unsigned long start,unsigned long end); -void intel_context_flush_present (struct device_domain_info *info, -struct context_entry *context, -u16 did,bool affect_domains); +void intel_context_flush_no_pasid (struct device_domain_info *info, +struct context_entry *context,u16 did);int intel_iommu_enable_prq (struct intel_iommu *iommu);int intel_iommu_finish_prq (struct intel_iommu *iommu);
drivers/iommu/intel/pasid.c +7 -34
61 lines not on this page · raw message
Signature · 1 line
2.43.0
Lu Baolu
maintainerPATCH v3 7/12 iommu/vt-d: Put iopf enablement in domain attach path
In reply to Lu BaoluUpdate iopf enablement in the driver to use the new method, similar to the arm-smmu-v3 driver. Enable iopf support when any domain with an iopf_handler is attached, and disable it when the domain is removed.
Place all the logic for controlling the PRI and iopf queue in the domain set/remove/replace paths. Keep track of the number of domains set to the device and PASIDs that require iopf. When the first domain requiring iopf is attached, add the device to the iopf queue and enable PRI. When the last domain is removed, remove it from the iopf queue and disable PRI.
--- drivers/iommu/intel/iommu.c | 42 ++++++++++++++++++++++++++++++------ drivers/iommu/intel/iommu.h | 33 ++++++++++++++++++++++++++++ drivers/iommu/intel/nested.c | 16 ++++++++++++-- drivers/iommu/intel/svm.c | 9 ++++++-- 4 files changed, 90 insertions(+), 10 deletions(-)
drivers/iommu/intel/iommu.c +36 -6
@@ -3269,6 +3269,9 @@ void device_block_translation(struct device *dev)static int blocking_domain_attach_dev (struct iommu_domain *domain,struct device *dev) { +struct device_domain_info *info =dev_iommu_priv_get (dev); + +iopf_for_domain_remove (info->domain ? &info->domain->domain :NULL , dev);device_block_translation (dev);return 0 ; }
@@ -3478,7 +3481,15 @@ static int intel_iommu_attach_device(struct iommu_domain *domain,if (ret)return ret; -return dmar_domain_attach_device (to_dmar_domain (domain), dev); + ret =iopf_for_domain_set (domain, dev); +if (ret) +return ret; + + ret =dmar_domain_attach_device (to_dmar_domain (domain), dev); +if (ret) +iopf_for_domain_remove (domain, dev); + +return ret; } static int intel_iommu_map(struct iommu_domain *domain,
@@ -3899,6 +3910,8 @@ int intel_iommu_enable_iopf(struct device *dev)if (!info->pri_enabled)return -ENODEV ; +/* pri_enabled is protected by the group mutex. */ +iommu_group_mutex_assert (dev);if (info->iopf_refcount) { info->iopf_refcount++;return 0 ;
@@ -3921,6 +3934,7 @@ void intel_iommu_disable_iopf(struct device *dev)if (WARN_ON (!info->pri_enabled || !info->iopf_refcount))return ; +iommu_group_mutex_assert (dev);if (--info->iopf_refcount)return ;
@@ -3932,8 +3946,7 @@ intel_iommu_dev_enable_feat(struct device *dev, enum iommu_dev_features feat) {switch (feat) {case IOMMU_DEV_FEAT_IOPF : -return intel_iommu_enable_iopf (dev); - +return 0 ;default :return -ENODEV ; }
@@ -3944,7 +3957,6 @@ intel_iommu_dev_disable_feat(struct device *dev, enum iommu_dev_features feat) {switch (feat) {case IOMMU_DEV_FEAT_IOPF : -intel_iommu_disable_iopf (dev);return 0 ;default :
@@ -4025,6 +4037,7 @@ static int blocking_domain_set_dev_pasid(struct iommu_domain *domain, {struct device_domain_info *info =dev_iommu_priv_get (dev); +iopf_for_domain_remove (old, dev);intel_pasid_tear_down_entry (info->iommu, dev, pasid, false);domain_remove_dev_pasid (old, dev, pasid);
@@ -4098,6 +4111,10 @@ static int intel_iommu_set_dev_pasid(struct iommu_domain *domain,if (IS_ERR (dev_pasid))return PTR_ERR (dev_pasid); + ret =iopf_for_domain_replace (domain, old, dev); +if (ret) + goto out_remove_dev_pasid; +if (dmar_domain->use_first_level) ret =domain_setup_first_level (iommu, dmar_domain, dev, pasid, old);
@@ -4105,7 +4122,7 @@ static int intel_iommu_set_dev_pasid(struct iommu_domain *domain, ret =domain_setup_second_level (iommu, dmar_domain, dev, pasid, old);if (ret) - goto out_remove_dev_pasid; + goto out_unwind_iopf;domain_remove_dev_pasid (old, dev, pasid);
@@ -4113,6 +4130,8 @@ static int intel_iommu_set_dev_pasid(struct iommu_domain *domain,return 0 ; +out_unwind_iopf: +iopf_for_domain_replace (old, domain, dev); out_remove_dev_pasid:domain_remove_dev_pasid (domain, dev, pasid);return ret;
@@ -4330,6 +4349,11 @@ static int identity_domain_attach_dev(struct iommu_domain *domain, struct deviceif (dev_is_real_dma_subdevice (dev))return 0 ; +/* +* No PRI support with the global identity domain. No need to enable or +* disable PRI in this path as the iommu has been put in the blocking +* state. +*/ if (sm_supported (iommu)) ret =intel_pasid_setup_pass_through (iommu, dev,IOMMU_NO_PASID );else
@@ -4349,9 +4373,15 @@ static int identity_domain_set_dev_pasid(struct iommu_domain *domain,if (!pasid_supported (iommu) ||dev_is_real_dma_subdevice (dev))return -EOPNOTSUPP ; + ret =iopf_for_domain_replace (domain, old, dev); +if (ret) +return ret; + ret =domain_setup_passthrough (iommu, dev, pasid, old); -if (ret) +if (ret) { +iopf_for_domain_replace (old, domain, dev);return ret; + }domain_remove_dev_pasid (old, dev, pasid);return 0 ;
drivers/iommu/intel/iommu.h +33 -0
@@ -1317,6 +1317,39 @@ void intel_iommu_drain_pasid_prq(struct device *dev, u32 pasid);int intel_iommu_enable_iopf (struct device *dev);void intel_iommu_disable_iopf (struct device *dev); +static inline int iopf_for_domain_set (struct iommu_domain *domain, +struct device *dev) +{ +if (!domain || !domain->iopf_handler) +return 0 ; + +return intel_iommu_enable_iopf (dev); +} + +static inline void iopf_for_domain_remove (struct iommu_domain *domain, +struct device *dev) +{ +if (!domain || !domain->iopf_handler) +return ; + +intel_iommu_disable_iopf (dev); +} + +static inline int iopf_for_domain_replace (struct iommu_domain *new, +struct iommu_domain *old, +struct device *dev) +{ +int ret; + + ret =iopf_for_domain_set (new, dev); +if (ret) +return ret; + +iopf_for_domain_remove (old, dev); + +return 0 ; +} +#ifdef CONFIG_INTEL_IOMMU_SVM void intel_svm_check (struct intel_iommu *iommu); struct iommu_domain *intel_svm_domain_alloc(struct device *dev,
drivers/iommu/intel/nested.c +14 -2
@@ -56,10 +56,14 @@ static int intel_nested_attach_dev(struct iommu_domain *domain,if (ret) goto detach_iommu; + ret =iopf_for_domain_set (domain, dev); +if (ret) + goto unassign_tag; + ret =intel_pasid_setup_nested (iommu, dev,IOMMU_NO_PASID , dmar_domain);if (ret) - goto unassign_tag; + goto disable_iopf; info->domain = dmar_domain;spin_lock_irqsave (&dmar_domain->lock, flags);
@@ -67,6 +71,8 @@ static int intel_nested_attach_dev(struct iommu_domain *domain,spin_unlock_irqrestore (&dmar_domain->lock, flags);return 0 ; +disable_iopf: +iopf_for_domain_remove (domain, dev); unassign_tag:cache_tag_unassign_domain (dmar_domain, dev,IOMMU_NO_PASID ); detach_iommu:
@@ -166,14 +172,20 @@ static int intel_nested_set_dev_pasid(struct iommu_domain *domain,if (IS_ERR (dev_pasid))return PTR_ERR (dev_pasid); - ret =domain_setup_nested (iommu, dmar_domain, dev, pasid, old); + ret =iopf_for_domain_replace (domain, old, dev);if (ret) goto out_remove_dev_pasid; + ret =domain_setup_nested (iommu, dmar_domain, dev, pasid, old); +if (ret) + goto out_unwind_iopf; +domain_remove_dev_pasid (old, dev, pasid);return 0 ; +out_unwind_iopf: +iopf_for_domain_replace (old, domain, dev); out_remove_dev_pasid:domain_remove_dev_pasid (domain, dev, pasid);return ret;
drivers/iommu/intel/svm.c +7 -2
@@ -164,18 +164,23 @@ static int intel_svm_set_dev_pasid(struct iommu_domain *domain,if (IS_ERR (dev_pasid))return PTR_ERR (dev_pasid); + ret =iopf_for_domain_replace (domain, old, dev); +if (ret) + goto out_remove_dev_pasid; +/* Setup the pasid table: */ sflags =cpu_feature_enabled (X86_FEATURE_LA57 ) ?PASID_FLAG_FL5LP :0 ; ret =__domain_setup_first_level (iommu, dev, pasid,FLPT_DEFAULT_DID , mm->pgd, sflags, old);if (ret) - goto out_remove_dev_pasid; + goto out_unwind_iopf;domain_remove_dev_pasid (old, dev, pasid);return 0 ; - +out_unwind_iopf: +iopf_for_domain_replace (old, domain, dev); out_remove_dev_pasid:domain_remove_dev_pasid (domain, dev, pasid);return ret;
Signature · 1 line
2.43.0
Lu Baolu
maintainerPATCH v3 8/12 iommufd/selftest: Put iopf enablement in domain attach path
In reply to Lu BaoluUpdate iopf enablement in the iommufd mock device driver to use the new method, similar to the arm-smmu-v3 driver. Enable iopf support when any domain with an iopf_handler is attached, and disable it when the domain is removed.
Add a refcount in the mock device state structure to keep track of the number of domains set to the device and PASIDs that require iopf.
--- drivers/iommu/iommufd/selftest.c | 64 ++++++++++++++++++++++++++------ 1 file changed, 53 insertions(+), 11 deletions(-)
drivers/iommu/iommufd/selftest.c +53 -11
@@ -58,6 +58,9 @@ enum { MOCK_PFN_HUGE_IOVA = _MOCK_PFN_START << 2, }; +static int mock_dev_enable_iopf (struct device *dev,struct iommu_domain *domain); +static void mock_dev_disable_iopf (struct device *dev,struct iommu_domain *domain); +/* * Syzkaller has trouble randomizing the correct iova to use since it is linked * to the map ioctl's output, and it has no ide about that. So, simplify things.
@@ -164,6 +167,8 @@ struct mock_dev {unsigned long flags;int id;u32 cache[MOCK_DEV_CACHE_NUM ]; +unsigned int iopf_refcount; +struct iommu_domain *domain; };static inline struct mock_dev *to_mock_dev (struct device *dev)
@@ -193,15 +198,34 @@ static int mock_domain_nop_attach(struct iommu_domain *domain, struct device *dev) {struct mock_dev *mdev =to_mock_dev (dev); +int ret;if (domain->dirty_ops && (mdev->flags &MOCK_FLAGS_DEVICE_NO_DIRTY ))return -EINVAL ; + ret =mock_dev_enable_iopf (dev, domain); +if (ret) +return ret; + +mock_dev_disable_iopf (dev, mdev->domain); + mdev->domain = domain; + +return 0 ; +} + +static int mock_domain_blocking_attach (struct iommu_domain *domain, +struct device *dev) +{ +struct mock_dev *mdev =to_mock_dev (dev); + +mock_dev_disable_iopf (dev, mdev->domain); + mdev->domain =NULL ; +return 0 ; }static const struct iommu_domain_ops mock_blocking_ops = { - .attach_dev = mock_domain_nop_attach, + .attach_dev = mock_domain_blocking_attach, };static struct iommu_domain mock_blocking_domain = {
@@ -549,22 +573,42 @@ static void mock_domain_page_response(struct device *dev, struct iopf_fault *evt { } -static int mock_dev_enable_feat (struct device *dev,enum iommu_dev_features feat) +static int mock_dev_enable_iopf (struct device *dev,struct iommu_domain *domain) { -if (feat !=IOMMU_DEV_FEAT_IOPF || !mock_iommu_iopf_queue) +struct mock_dev *mdev =to_mock_dev (dev); +int ret; + +if (!domain || !domain->iopf_handler) +return 0 ; + +if (!mock_iommu_iopf_queue)return -ENODEV ; -return iopf_queue_add_device (mock_iommu_iopf_queue, dev); +if (mdev->iopf_refcount) { + mdev->iopf_refcount++; +return 0 ; + } + + ret =iopf_queue_add_device (mock_iommu_iopf_queue, dev); +if (ret) +return ret; + + mdev->iopf_refcount =1 ; + +return 0 ; } -static int mock_dev_disable_feat (struct device *dev,enum iommu_dev_features feat) +static void mock_dev_disable_iopf (struct device *dev,struct iommu_domain *domain) { -if (feat !=IOMMU_DEV_FEAT_IOPF || !mock_iommu_iopf_queue) -return -ENODEV ; +struct mock_dev *mdev =to_mock_dev (dev); + +if (!domain || !domain->iopf_handler) +return ; + +if (--mdev->iopf_refcount) +return ;iopf_queue_remove_device (mock_iommu_iopf_queue, dev); - -return 0 ; }static void mock_viommu_destroy (struct iommufd_viommu *viommu)
@@ -709,8 +753,6 @@ static const struct iommu_ops mock_ops = { .device_group = generic_device_group, .probe_device = mock_probe_device, .page_response = mock_domain_page_response, - .dev_enable_feat = mock_dev_enable_feat, - .dev_disable_feat = mock_dev_disable_feat, .user_pasid_table = true, .viommu_alloc = mock_viommu_alloc, .default_domain_ops =
Signature · 1 line
2.43.0
Lu Baolu
maintainerPATCH v3 9/12 dmaengine: idxd: Remove unnecessary IOMMU_DEV_FEAT_IOPF
In reply to Lu BaoluThe IOMMU_DEV_FEAT_IOPF implementation in the iommu driver is just a no-op. It will also be removed from the iommu driver in the subsequent patch. Remove it to avoid dead code.
--- drivers/dma/idxd/init.c | 37 ++++++------------------------------- 1 file changed, 6 insertions(+), 31 deletions(-)
drivers/dma/idxd/init.c +6 -31
@@ -626,21 +626,6 @@ static void idxd_disable_system_pasid(struct idxd_device *idxd) idxd->pasid =IOMMU_PASID_INVALID ; } -static int idxd_enable_sva (struct pci_dev *pdev) -{ -int ret; - - ret =iommu_dev_enable_feature (&pdev->dev,IOMMU_DEV_FEAT_IOPF ); -if (ret) -return ret; -return 0 ; -} - -static void idxd_disable_sva (struct pci_dev *pdev) -{ -iommu_dev_disable_feature (&pdev->dev,IOMMU_DEV_FEAT_IOPF ); -} -static int idxd_probe (struct idxd_device *idxd) {struct pci_dev *pdev = idxd->pdev;
@@ -655,17 +640,13 @@ static int idxd_probe(struct idxd_device *idxd)dev_dbg (dev,"IDXD reset complete\n" );if (IS_ENABLED (CONFIG_INTEL_IDXD_SVM ) && sva) { -if (idxd_enable_sva (pdev)) { -dev_warn (dev,"Unable to turn on user SVA feature.\n" ); - }else { -set_bit (IDXD_FLAG_USER_PASID_ENABLED , &idxd->flags); +set_bit (IDXD_FLAG_USER_PASID_ENABLED , &idxd->flags); - rc =idxd_enable_system_pasid (idxd); -if (rc) -dev_warn (dev,"No in-kernel DMA with PASID. %d\n" , rc); -else -set_bit (IDXD_FLAG_PASID_ENABLED , &idxd->flags); - } + rc =idxd_enable_system_pasid (idxd); +if (rc) +dev_warn (dev,"No in-kernel DMA with PASID. %d\n" , rc); +else +set_bit (IDXD_FLAG_PASID_ENABLED , &idxd->flags); }else if (!sva) {dev_warn (dev,"User forced SVA off via module param.\n" ); }
@@ -703,8 +684,6 @@ static int idxd_probe(struct idxd_device *idxd) err:if (device_pasid_enabled (idxd))idxd_disable_system_pasid (idxd); -if (device_user_pasid_enabled (idxd)) -idxd_disable_sva (pdev);return rc; }
@@ -715,8 +694,6 @@ static void idxd_cleanup(struct idxd_device *idxd)idxd_cleanup_internals (idxd);if (device_pasid_enabled (idxd))idxd_disable_system_pasid (idxd); -if (device_user_pasid_enabled (idxd)) -idxd_disable_sva (idxd->pdev); }/*
@@ -1248,8 +1225,6 @@ static void idxd_remove(struct pci_dev *pdev)free_irq (irq_entry->vector, irq_entry);pci_free_irq_vectors (pdev);pci_iounmap (pdev, idxd->reg_base); -if (device_user_pasid_enabled (idxd)) -idxd_disable_sva (pdev);pci_disable_device (pdev);destroy_workqueue (idxd->wq);perfmon_pmu_remove (idxd);
Signature · 1 line
2.43.0
Lu Baolu
maintainerPATCH v3 10/12 uacce: Remove unnecessary IOMMU_DEV_FEAT_IOPF
In reply to Lu BaoluNone of the drivers implement anything for IOMMU_DEV_FEAT_IOPF anymore, remove it to avoid dead code.
--- drivers/misc/uacce/uacce.c | 31 ------------------------------- 1 file changed, 31 deletions(-)
drivers/misc/uacce/uacce.c +0 -31
@@ -465,31 +465,6 @@ static void uacce_release(struct device *dev)kfree (uacce); } -static unsigned int uacce_enable_sva (struct device *parent,unsigned int flags) -{ -int ret; - -if (!(flags &UACCE_DEV_SVA )) -return flags; - - flags &= ~UACCE_DEV_SVA ; - - ret =iommu_dev_enable_feature (parent,IOMMU_DEV_FEAT_IOPF ); -if (ret) { -dev_err (parent,"failed to enable IOPF feature! ret = %pe\n" ,ERR_PTR (ret)); -return flags; - } -return flags |UACCE_DEV_SVA ; -} - -static void uacce_disable_sva (struct uacce_device *uacce) -{ -if (!(uacce->flags &UACCE_DEV_SVA )) -return ; - -iommu_dev_disable_feature (uacce->parent,IOMMU_DEV_FEAT_IOPF ); -} -/** * uacce_alloc() - alloc an accelerator * @parent: pointer of uacce parent device
@@ -509,8 +484,6 @@ struct uacce_device *uacce_alloc(struct device *parent,if (!uacce)return ERR_PTR (-ENOMEM ); - flags =uacce_enable_sva (parent, flags); - uacce->parent = parent; uacce->flags = flags; uacce->ops = interface->ops;
@@ -533,7 +506,6 @@ struct uacce_device *uacce_alloc(struct device *parent,return uacce; err_with_uacce: -uacce_disable_sva (uacce);kfree (uacce);return ERR_PTR (ret); }
@@ -596,9 +568,6 @@ void uacce_remove(struct uacce_device *uacce)unmap_mapping_range (q->mapping,0 ,0 ,1 ); } -/* disable sva now since no opened queues */ -uacce_disable_sva (uacce); -if (uacce->cdev)cdev_device_del (uacce->cdev, &uacce->dev);xa_erase (&uacce_xa, uacce->dev_id);
Signature · 1 line
2.43.0
Lu Baolu
maintainerPATCH v3 11/12 iommufd: Remove unnecessary IOMMU_DEV_FEAT_IOPF
In reply to Lu BaoluThe iopf enablement has been moved to the iommu drivers. It is unnecessary for iommufd to handle iopf enablement. Remove the iopf enablement logic to avoid duplication.
--- drivers/iommu/iommufd/device.c | 1 - drivers/iommu/iommufd/fault.c | 111 ++++++------------------ drivers/iommu/iommufd/iommufd_private.h | 3 - 3 files changed, 28 insertions(+), 87 deletions(-)
drivers/iommu/iommufd/device.c +0 -1
@@ -215,7 +215,6 @@ struct iommufd_device *iommufd_device_bind(struct iommufd_ctx *ictx,refcount_inc (&idev->obj.users);/* igroup refcount moves into iommufd_device */ idev->igroup = igroup; -mutex_init (&idev->iopf_lock);/* * If the caller fails after this success it must call
drivers/iommu/iommufd/fault.c +28 -83
149 lines not on this page · raw message
drivers/iommu/iommufd/iommufd_private.h +0 -3
@@ -399,9 +399,6 @@ struct iommufd_device {/* always the physical device */ struct device *dev;bool enforce_cache_coherency; -/* protect iopf_enabled counter */ -struct mutex iopf_lock; -unsigned int iopf_enabled; }; static inline struct iommufd_device *
Signature · 1 line
2.43.0
Lu Baolu
maintainerPATCH v3 12/12 iommu: Remove iommu_dev_enable/disable_feature()
In reply to Lu BaoluNo external drivers use these interfaces anymore. Furthermore, no existing iommu drivers implement anything in the callbacks. Remove them to avoid dead code.
--- drivers/iommu/amd/iommu.c | 32 ------------------- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 34 --------------------- drivers/iommu/intel/iommu.c | 25 --------------- drivers/iommu/iommu.c | 32 ------------------- include/linux/iommu.h | 28 ----------------- 5 files changed, 151 deletions(-)
drivers/iommu/amd/iommu.c +0 -32
@@ -2983,36 +2983,6 @@ static const struct iommu_dirty_ops amd_dirty_ops = { .read_and_clear_dirty = amd_iommu_read_and_clear_dirty, }; -static int amd_iommu_dev_enable_feature (struct device *dev, -enum iommu_dev_features feat) -{ -int ret =0 ; - -switch (feat) { -case IOMMU_DEV_FEAT_IOPF : -break ; -default : - ret = -EINVAL ; -break ; - } -return ret; -} - -static int amd_iommu_dev_disable_feature (struct device *dev, -enum iommu_dev_features feat) -{ -int ret =0 ; - -switch (feat) { -case IOMMU_DEV_FEAT_IOPF : -break ; -default : - ret = -EINVAL ; -break ; - } -return ret; -} -const struct iommu_ops amd_iommu_ops = { .capable = amd_iommu_capable, .blocked_domain = &blocked_domain,
@@ -3026,8 +2996,6 @@ const struct iommu_ops amd_iommu_ops = { .get_resv_regions = amd_iommu_get_resv_regions, .is_attach_deferred = amd_iommu_is_attach_deferred, .def_domain_type = amd_iommu_def_domain_type, - .dev_enable_feat = amd_iommu_dev_enable_feature, - .dev_disable_feat = amd_iommu_dev_disable_feature, .page_response = amd_iommu_page_response, .default_domain_ops = &(const struct iommu_domain_ops ) { .attach_dev = amd_iommu_attach_device,
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +0 -34
@@ -3620,38 +3620,6 @@ static void arm_smmu_get_resv_regions(struct device *dev,iommu_dma_get_resv_regions (dev, head); } -static int arm_smmu_dev_enable_feature (struct device *dev, -enum iommu_dev_features feat) -{ -struct arm_smmu_master *master =dev_iommu_priv_get (dev); - -if (!master) -return -ENODEV ; - -switch (feat) { -case IOMMU_DEV_FEAT_IOPF : -return 0 ; -default : -return -EINVAL ; - } -} - -static int arm_smmu_dev_disable_feature (struct device *dev, -enum iommu_dev_features feat) -{ -struct arm_smmu_master *master =dev_iommu_priv_get (dev); - -if (!master) -return -EINVAL ; - -switch (feat) { -case IOMMU_DEV_FEAT_IOPF : -return 0 ; -default : -return -EINVAL ; - } -} -/* * HiSilicon PCIe tune and trace device can be used to trace TLP headers on the * PCIe link and save the data to memory by DMA. The hardware is restricted to
@@ -3684,8 +3652,6 @@ static struct iommu_ops arm_smmu_ops = { .device_group = arm_smmu_device_group, .of_xlate = arm_smmu_of_xlate, .get_resv_regions = arm_smmu_get_resv_regions, - .dev_enable_feat = arm_smmu_dev_enable_feature, - .dev_disable_feat = arm_smmu_dev_disable_feature, .page_response = arm_smmu_page_response, .def_domain_type = arm_smmu_def_domain_type, .viommu_alloc = arm_vsmmu_alloc,
drivers/iommu/intel/iommu.c +0 -25
@@ -3941,29 +3941,6 @@ void intel_iommu_disable_iopf(struct device *dev)iopf_queue_remove_device (iommu->iopf_queue, dev); } -static int -intel_iommu_dev_enable_feat (struct device *dev,enum iommu_dev_features feat) -{ -switch (feat) { -case IOMMU_DEV_FEAT_IOPF : -return 0 ; -default : -return -ENODEV ; - } -} - -static int -intel_iommu_dev_disable_feat (struct device *dev,enum iommu_dev_features feat) -{ -switch (feat) { -case IOMMU_DEV_FEAT_IOPF : -return 0 ; - -default : -return -ENODEV ; - } -} -static bool intel_iommu_is_attach_deferred (struct device *dev) {struct device_domain_info *info =dev_iommu_priv_get (dev);
@@ -4408,8 +4385,6 @@ const struct iommu_ops intel_iommu_ops = { .release_device = intel_iommu_release_device, .get_resv_regions = intel_iommu_get_resv_regions, .device_group = intel_iommu_device_group, - .dev_enable_feat = intel_iommu_dev_enable_feat, - .dev_disable_feat = intel_iommu_dev_disable_feat, .is_attach_deferred = intel_iommu_is_attach_deferred, .def_domain_type = device_def_domain_type, .pgsize_bitmap = SZ_4K,
drivers/iommu/iommu.c +0 -32
@@ -2877,38 +2877,6 @@ int iommu_fwspec_add_ids(struct device *dev, const u32 *ids, int num_ids) }EXPORT_SYMBOL_GPL (iommu_fwspec_add_ids); -/* -* Per device IOMMU features. -*/ -int iommu_dev_enable_feature (struct device *dev,enum iommu_dev_features feat) -{ -if (dev_has_iommu (dev)) { -const struct iommu_ops *ops =dev_iommu_ops (dev); - -if (ops->dev_enable_feat) -return ops->dev_enable_feat (dev, feat); - } - -return -ENODEV ; -} -EXPORT_SYMBOL_GPL (iommu_dev_enable_feature); - -/* -* The device drivers should do the necessary cleanups before calling this. -*/ -int iommu_dev_disable_feature (struct device *dev,enum iommu_dev_features feat) -{ -if (dev_has_iommu (dev)) { -const struct iommu_ops *ops =dev_iommu_ops (dev); - -if (ops->dev_disable_feat) -return ops->dev_disable_feat (dev, feat); - } - -return -EBUSY ; -} -EXPORT_SYMBOL_GPL (iommu_dev_disable_feature); -/** * iommu_setup_default_domain - Set the default_domain for the group * @group: Group to change
include/linux/iommu.h +0 -28
@@ -301,16 +301,6 @@ struct iommu_iort_rmr_data {u32 num_sids; }; -/** -* enum iommu_dev_features - Per device IOMMU features -* @IOMMU_DEV_FEAT_IOPF: I/O Page Faults such as PRI or Stall. -* -* Device drivers enable a feature using iommu_dev_enable_feature(). -*/ -enum iommu_dev_features { -IOMMU_DEV_FEAT_IOPF , -}; -#define IOMMU_NO_PASID (0U)/* Reserved for DMA w/o PASID */ #define IOMMU_FIRST_GLOBAL_PASID (1U)/*starting range for allocation */ #define IOMMU_PASID_INVALID (-1U)
@@ -630,9 +620,6 @@ struct iommu_ops {bool (*is_attach_deferred)(struct device *dev);/* Per device IOMMU features */ -int (*dev_enable_feat)(struct device *dev,enum iommu_dev_features f); -int (*dev_disable_feat)(struct device *dev,enum iommu_dev_features f); -void (*page_response)(struct device *dev,struct iopf_fault *evt,struct iommu_page_response *msg);
@@ -1102,9 +1089,6 @@ void dev_iommu_priv_set(struct device *dev, void *priv);extern struct mutex iommu_probe_device_lock;int iommu_probe_device (struct device *dev); -int iommu_dev_enable_feature (struct device *dev,enum iommu_dev_features f); -int iommu_dev_disable_feature (struct device *dev,enum iommu_dev_features f); -int iommu_device_use_default_domain (struct device *dev);void iommu_device_unuse_default_domain (struct device *dev);
@@ -1393,18 +1377,6 @@ static inline int iommu_fwspec_add_ids(struct device *dev, u32 *ids,return -ENODEV ; } -static inline int -iommu_dev_enable_feature (struct device *dev,enum iommu_dev_features feat) -{ -return -ENODEV ; -} - -static inline int -iommu_dev_disable_feature (struct device *dev,enum iommu_dev_features feat) -{ -return -ENODEV ; -} -static inline struct iommu_fwspec *dev_iommu_fwspec_get (struct device *dev) {return NULL ;
Signature · 1 line
2.43.0