iommu: Prepare to deliver page faults to user space
Subsystems (5)
Lu Baolu
maintainerv3 cover iommu: Prepare to deliver page faults to user space
When a user-managed page table is attached to an IOMMU, it is necessary to deliver IO page faults to user space so that they can be handled appropriately. One use case for this is nested translation, which is currently being discussed in the mailing list.
I have posted a RFC series [1] that describes the implementation of delivering page faults to user space through IOMMUFD. This series has received several comments on the IOMMU refactoring, which I am trying to address in this series.
The major refactoring includes:
- [PATCH 01 ~ 04] Move include/uapi/linux/iommu.h to include/linux/iommu.h. Remove the unrecoverable fault data definition.
- [PATCH 05 ~ 06] Remove iommu_[un]register_device_fault_handler().
- [PATCH 07 ~ 11] Separate SVA and IOPF. Make IOPF a generic page fault handling framework.
This is also available at github [2]. I would appreciate your feedback on this series.
[1] https://lore.kernel.org/linux-iommu/[email protected]/
[2] https://github.com/LuBaolu/intel-iommu/commits/preparatory-io-pgfault-delivery-v3
Change log:
v3:
- Convert the fault data structures from uAPI to kAPI.
- Merge iopf_device_param into iommu_fault_param.
- Add debugging on domain lifetime for iopf.
- Remove patch "iommu: Change the return value of dev_iommu_get()".
- Remove patch "iommu: Add helper to set iopf handler for domain".
- Misc code refactoring and refining.
v2: https://lore.kernel.org/linux-iommu/[email protected]/
- Remove unrecoverable fault data definition as suggested by Kevin.
- Drop the per-device fault cookie code considering that doesn't make
much sense for SVA.
- Make the IOMMU page fault handling framework generic. So that it can avaible for use cases other than SVA.
v1: https://lore.kernel.org/linux-iommu/[email protected]/
Lu Baolu (11):
iommu: Move iommu fault data to linux/iommu.h iommu/arm-smmu-v3: Remove unrecoverable faults reporting
iommu: Remove unrecoverable fault data
iommu: Cleanup iopf data structure definitions
iommu: Merge iopf_device_param into iommu_fault_param
iommu: Remove iommu_[un]register_device_fault_handler()
iommu: Prepare for separating SVA and IOPF
iommu: Move iopf_handler() to iommu-sva.c
iommu: Make iommu_queue_iopf() more generic
iommu: Add debugging on domain lifetime for iopf
iommu: Separate SVA and IOPF in Makefile and Kconfig
include/linux/iommu.h | 202 ++++++++++++++--- drivers/iommu/iommu-sva.h | 71 ------ include/uapi/linux/iommu.h | 161 -------------- .../iommu/arm/arm-smmu-v3/arm-smmu-v3-sva.c | 14 +- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 47 ++-- drivers/iommu/intel/iommu.c | 25 +-- drivers/iommu/intel/svm.c | 1 - drivers/iommu/io-pgfault.c | 208 ++++++++---------- drivers/iommu/iommu-sva.c | 49 ++++- drivers/iommu/iommu.c | 132 +++-------- MAINTAINERS | 1 - drivers/iommu/Kconfig | 4 + drivers/iommu/Makefile | 3 +- drivers/iommu/intel/Kconfig | 1 + 14 files changed, 362 insertions(+), 557 deletions(-) delete mode 100644 drivers/iommu/iommu-sva.h delete mode 100644 include/uapi/linux/iommu.h
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v3 1/11 iommu: Move iommu fault data to linux/iommu.h
The iommu fault data is currently defined in uapi/linux/iommu.h, but is only used inside the iommu subsystem. Move it to linux/iommu.h, where it will be more accessible to kernel drivers.
With this done, uapi/linux/iommu.h becomes empty and can be removed from the tree.
--- include/linux/iommu.h | 152 +++++++++++++++++++++++++++++++++- include/uapi/linux/iommu.h | 161 ------------------------------------- MAINTAINERS | 1 - 3 files changed, 151 insertions(+), 163 deletions(-) delete mode 100644 include/uapi/linux/iommu.h
include/linux/iommu.h +151 -1
@@ -13,7 +13,6 @@#include <linux/errno.h> #include <linux/err.h> #include <linux/of.h> -#include <uapi/linux/iommu.h> #define IOMMU_READ (1 << 0)#define IOMMU_WRITE (1 << 1)
@@ -42,6 +41,157 @@ struct iommu_sva;struct iommu_fault_event ;struct iommu_dma_cookie ; +#define IOMMU_FAULT_PERM_READ (1 << 0)/* read */ +#define IOMMU_FAULT_PERM_WRITE (1 << 1)/* write */ +#define IOMMU_FAULT_PERM_EXEC (1 << 2)/* exec */ +#define IOMMU_FAULT_PERM_PRIV (1 << 3)/* privileged */ + +/* Generic fault types, can be expanded IRQ remapping fault */ +enum iommu_fault_type { +IOMMU_FAULT_DMA_UNRECOV =1 ,/* unrecoverable fault */ +IOMMU_FAULT_PAGE_REQ ,/* page request fault */ +}; + +enum iommu_fault_reason { +IOMMU_FAULT_REASON_UNKNOWN =0 , + +/* Could not access the PASID table (fetch caused external abort) */ +IOMMU_FAULT_REASON_PASID_FETCH , + +/* PASID entry is invalid or has configuration errors */ +IOMMU_FAULT_REASON_BAD_PASID_ENTRY , + +/* +* PASID is out of range (e.g. exceeds the maximum PASID +* supported by the IOMMU) or disabled. +*/ +IOMMU_FAULT_REASON_PASID_INVALID , + +/* +* An external abort occurred fetching (or updating) a translation +* table descriptor +*/ +IOMMU_FAULT_REASON_WALK_EABT , + +/* +* Could not access the page table entry (Bad address), +* actual translation fault +*/ +IOMMU_FAULT_REASON_PTE_FETCH , + +/* Protection flag check failed */ +IOMMU_FAULT_REASON_PERMISSION , + +/* access flag check failed */ +IOMMU_FAULT_REASON_ACCESS , + +/* Output address of a translation stage caused Address Size fault */ +IOMMU_FAULT_REASON_OOR_ADDRESS , +}; + +/** +* struct iommu_fault_unrecoverable - Unrecoverable fault data +* @reason: reason of the fault, from &enum iommu_fault_reason +* @flags: parameters of this fault (IOMMU_FAULT_UNRECOV_* values) +* @pasid: Process Address Space ID +* @perm: requested permission access using by the incoming transaction +* (IOMMU_FAULT_PERM_* values) +* @addr: offending page address +* @fetch_addr: address that caused a fetch abort, if any +*/ +struct iommu_fault_unrecoverable { +__u32 reason; +#define IOMMU_FAULT_UNRECOV_PASID_VALID (1 << 0) +#define IOMMU_FAULT_UNRECOV_ADDR_VALID (1 << 1) +#define IOMMU_FAULT_UNRECOV_FETCH_ADDR_VALID (1 << 2) +__u32 flags; +__u32 pasid; +__u32 perm; +__u64 addr; +__u64 fetch_addr; +}; + +/** +* struct iommu_fault_page_request - Page Request data +* @flags: encodes whether the corresponding fields are valid and whether this +* is the last page in group (IOMMU_FAULT_PAGE_REQUEST_* values). +* When IOMMU_FAULT_PAGE_RESPONSE_NEEDS_PASID is set, the page response +* must have the same PASID value as the page request. When it is clear, +* the page response should not have a PASID. +* @pasid: Process Address Space ID +* @grpid: Page Request Group Index +* @perm: requested page permissions (IOMMU_FAULT_PERM_* values) +* @addr: page address +* @private_data: device-specific private information +*/ +struct iommu_fault_page_request { +#define IOMMU_FAULT_PAGE_REQUEST_PASID_VALID (1 << 0) +#define IOMMU_FAULT_PAGE_REQUEST_LAST_PAGE (1 << 1) +#define IOMMU_FAULT_PAGE_REQUEST_PRIV_DATA (1 << 2) +#define IOMMU_FAULT_PAGE_RESPONSE_NEEDS_PASID (1 << 3) +__u32 flags; +__u32 pasid; +__u32 grpid; +__u32 perm; +__u64 addr; +__u64 private_data[2 ]; +}; + +/** +* struct iommu_fault - Generic fault data +* @type: fault type from &enum iommu_fault_type +* @padding: reserved for future use (should be zero) +* @event: fault event, when @type is %IOMMU_FAULT_DMA_UNRECOV +* @prm: Page Request message, when @type is %IOMMU_FAULT_PAGE_REQ +* @padding2: sets the fault size to allow for future extensions +*/ +struct iommu_fault { +__u32 type; +__u32 padding; +union { +struct iommu_fault_unrecoverable event; +struct iommu_fault_page_request prm; +__u8 padding2[56 ]; + }; +}; + +/** +* enum iommu_page_response_code - Return status of fault handlers +* @IOMMU_PAGE_RESP_SUCCESS: Fault has been handled and the page tables +* populated, retry the access. This is "Success" in PCI PRI. +* @IOMMU_PAGE_RESP_FAILURE: General error. Drop all subsequent faults from +* this device if possible. This is "Response Failure" in PCI PRI. +* @IOMMU_PAGE_RESP_INVALID: Could not handle this fault, don't retry the +* access. This is "Invalid Request" in PCI PRI. +*/ +enum iommu_page_response_code { +IOMMU_PAGE_RESP_SUCCESS =0 , +IOMMU_PAGE_RESP_INVALID , +IOMMU_PAGE_RESP_FAILURE , +}; + +/** +* struct iommu_page_response - Generic page response information +* @argsz: User filled size of this data +* @version: API version of this structure +* @flags: encodes whether the corresponding fields are valid +* (IOMMU_FAULT_PAGE_RESPONSE_* values) +* @pasid: Process Address Space ID +* @grpid: Page Request Group Index +* @code: response code from &enum iommu_page_response_code +*/ +struct iommu_page_response { +__u32 argsz; +#define IOMMU_PAGE_RESP_VERSION_1 1 +__u32 version; +#define IOMMU_PAGE_RESP_PASID_VALID (1 << 0) +__u32 flags; +__u32 pasid; +__u32 grpid; +__u32 code; +}; + +/* iommu fault flags */ #define IOMMU_FAULT_READ 0x0#define IOMMU_FAULT_WRITE 0x1
include/uapi/linux/iommu.h deleted +0 -161
161 lines not on this page · raw message
MAINTAINERS +0 -1
@@ -10889,7 +10889,6 @@ F: drivers/iommu/ F: include/linux/iommu.h F: include/linux/iova.h F: include/linux/of_iommu.h -F: include/uapi/linux/iommu.h IOMMUFD M: Jason Gunthorpe <[email protected]>
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v3 2/11 iommu/arm-smmu-v3: Remove unrecoverable faults reporting
In reply to Lu BaoluNo device driver registers fault handler to handle the reported unrecoveraable faults. Remove it to avoid dead code.
--- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 46 ++++++--------------- 1 file changed, 13 insertions(+), 33 deletions(-)
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +13 -33
@@ -1469,7 +1469,6 @@ arm_smmu_find_master(struct arm_smmu_device *smmu, u32 sid)static int arm_smmu_handle_evt (struct arm_smmu_device *smmu,u64 *evt) {int ret; -u32 reason;u32 perm =0 ;struct arm_smmu_master *master;bool ssid_valid = evt[0 ] &EVTQ_0_SSV ;
@@ -1479,16 +1478,9 @@ static int arm_smmu_handle_evt(struct arm_smmu_device *smmu, u64 *evt)switch (FIELD_GET (EVTQ_0_ID , evt[0 ])) {case EVT_ID_TRANSLATION_FAULT : - reason =IOMMU_FAULT_REASON_PTE_FETCH ; -break ;case EVT_ID_ADDR_SIZE_FAULT : - reason =IOMMU_FAULT_REASON_OOR_ADDRESS ; -break ;case EVT_ID_ACCESS_FAULT : - reason =IOMMU_FAULT_REASON_ACCESS ; -break ;case EVT_ID_PERMISSION_FAULT : - reason =IOMMU_FAULT_REASON_PERMISSION ;break ;default :return -EOPNOTSUPP ;
@@ -1498,6 +1490,9 @@ static int arm_smmu_handle_evt(struct arm_smmu_device *smmu, u64 *evt)if (evt[1 ] &EVTQ_1_S2 )return -EFAULT ; +if (!(evt[1 ] &EVTQ_1_STALL )) +return -EOPNOTSUPP ; +if (evt[1 ] & EVTQ_1_RnW) perm |=IOMMU_FAULT_PERM_READ ;else
@@ -1509,32 +1504,17 @@ static int arm_smmu_handle_evt(struct arm_smmu_device *smmu, u64 *evt)if (evt[1 ] & EVTQ_1_PnU) perm |=IOMMU_FAULT_PERM_PRIV ; -if (evt[1 ] &EVTQ_1_STALL ) { - flt->type =IOMMU_FAULT_PAGE_REQ ; - flt->prm = (struct iommu_fault_page_request ) { - .flags =IOMMU_FAULT_PAGE_REQUEST_LAST_PAGE , - .grpid =FIELD_GET (EVTQ_1_STAG , evt[1 ]), - .perm = perm, - .addr =FIELD_GET (EVTQ_2_ADDR , evt[2 ]), - }; + flt->type =IOMMU_FAULT_PAGE_REQ ; + flt->prm = (struct iommu_fault_page_request ) { + .flags =IOMMU_FAULT_PAGE_REQUEST_LAST_PAGE , + .grpid =FIELD_GET (EVTQ_1_STAG , evt[1 ]), + .perm = perm, + .addr =FIELD_GET (EVTQ_2_ADDR , evt[2 ]), + }; -if (ssid_valid) { - flt->prm.flags |=IOMMU_FAULT_PAGE_REQUEST_PASID_VALID ; - flt->prm.pasid =FIELD_GET (EVTQ_0_SSID , evt[0 ]); - } - }else { - flt->type =IOMMU_FAULT_DMA_UNRECOV ; - flt->event = (struct iommu_fault_unrecoverable ) { - .reason = reason, - .flags =IOMMU_FAULT_UNRECOV_ADDR_VALID , - .perm = perm, - .addr =FIELD_GET (EVTQ_2_ADDR , evt[2 ]), - }; - -if (ssid_valid) { - flt->event.flags |=IOMMU_FAULT_UNRECOV_PASID_VALID ; - flt->event.pasid =FIELD_GET (EVTQ_0_SSID , evt[0 ]); - } +if (ssid_valid) { + flt->prm.flags |=IOMMU_FAULT_PAGE_REQUEST_PASID_VALID ; + flt->prm.pasid =FIELD_GET (EVTQ_0_SSID , evt[0 ]); }mutex_lock (&smmu->streams_mutex);
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v3 3/11 iommu: Remove unrecoverable fault data
In reply to Lu BaoluThe unrecoverable fault data is not used anywhere. Remove it to avoid dead code.
--- include/linux/iommu.h | 70 +------------------------------------------ 1 file changed, 1 insertion(+), 69 deletions(-)
include/linux/iommu.h +1 -69
@@ -48,69 +48,9 @@ struct iommu_dma_cookie;/* Generic fault types, can be expanded IRQ remapping fault */ enum iommu_fault_type { -IOMMU_FAULT_DMA_UNRECOV =1 ,/* unrecoverable fault */ IOMMU_FAULT_PAGE_REQ ,/* page request fault */ }; -enum iommu_fault_reason { -IOMMU_FAULT_REASON_UNKNOWN =0 , - -/* Could not access the PASID table (fetch caused external abort) */ -IOMMU_FAULT_REASON_PASID_FETCH , - -/* PASID entry is invalid or has configuration errors */ -IOMMU_FAULT_REASON_BAD_PASID_ENTRY , - -/* -* PASID is out of range (e.g. exceeds the maximum PASID -* supported by the IOMMU) or disabled. -*/ -IOMMU_FAULT_REASON_PASID_INVALID , - -/* -* An external abort occurred fetching (or updating) a translation -* table descriptor -*/ -IOMMU_FAULT_REASON_WALK_EABT , - -/* -* Could not access the page table entry (Bad address), -* actual translation fault -*/ -IOMMU_FAULT_REASON_PTE_FETCH , - -/* Protection flag check failed */ -IOMMU_FAULT_REASON_PERMISSION , - -/* access flag check failed */ -IOMMU_FAULT_REASON_ACCESS , - -/* Output address of a translation stage caused Address Size fault */ -IOMMU_FAULT_REASON_OOR_ADDRESS , -}; - -/** -* struct iommu_fault_unrecoverable - Unrecoverable fault data -* @reason: reason of the fault, from &enum iommu_fault_reason -* @flags: parameters of this fault (IOMMU_FAULT_UNRECOV_* values) -* @pasid: Process Address Space ID -* @perm: requested permission access using by the incoming transaction -* (IOMMU_FAULT_PERM_* values) -* @addr: offending page address -* @fetch_addr: address that caused a fetch abort, if any -*/ -struct iommu_fault_unrecoverable { -__u32 reason; -#define IOMMU_FAULT_UNRECOV_PASID_VALID (1 << 0) -#define IOMMU_FAULT_UNRECOV_ADDR_VALID (1 << 1) -#define IOMMU_FAULT_UNRECOV_FETCH_ADDR_VALID (1 << 2) -__u32 flags; -__u32 pasid; -__u32 perm; -__u64 addr; -__u64 fetch_addr; -}; -/** * struct iommu_fault_page_request - Page Request data * @flags: encodes whether the corresponding fields are valid and whether this
@@ -140,19 +80,11 @@ struct iommu_fault_page_request {/** * struct iommu_fault - Generic fault data * @type: fault type from &enum iommu_fault_type -* @padding: reserved for future use (should be zero) -* @event: fault event, when @type is %IOMMU_FAULT_DMA_UNRECOV * @prm: Page Request message, when @type is %IOMMU_FAULT_PAGE_REQ -* @padding2: sets the fault size to allow for future extensions */ struct iommu_fault {__u32 type; -__u32 padding; -union { -struct iommu_fault_unrecoverable event; -struct iommu_fault_page_request prm; -__u8 padding2[56 ]; - }; +struct iommu_fault_page_request prm; };/**
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v3 4/11 iommu: Cleanup iopf data structure definitions
In reply to Lu Baolustruct iommu_fault_page_request and struct iommu_page_response are not part of uAPI anymore. Convert them to data structures for kAPI.
--- include/linux/iommu.h | 27 +++++++++++---------------- drivers/iommu/io-pgfault.c | 1 - drivers/iommu/iommu.c | 4 ---- 3 files changed, 11 insertions(+), 21 deletions(-)
include/linux/iommu.h +11 -16
@@ -69,12 +69,12 @@ struct iommu_fault_page_request {#define IOMMU_FAULT_PAGE_REQUEST_LAST_PAGE (1 << 1)#define IOMMU_FAULT_PAGE_REQUEST_PRIV_DATA (1 << 2)#define IOMMU_FAULT_PAGE_RESPONSE_NEEDS_PASID (1 << 3) -__u32 flags; -__u32 pasid; -__u32 grpid; -__u32 perm; -__u64 addr; -__u64 private_data[2 ]; +u32 flags; +u32 pasid; +u32 grpid; +u32 perm; +u64 addr; +u64 private_data[2 ]; };/**
@@ -83,7 +83,7 @@ struct iommu_fault_page_request {* @prm: Page Request message, when @type is %IOMMU_FAULT_PAGE_REQ */ struct iommu_fault { -__u32 type; +u32 type;struct iommu_fault_page_request prm; };
@@ -104,8 +104,6 @@ enum iommu_page_response_code {/** * struct iommu_page_response - Generic page response information -* @argsz: User filled size of this data -* @version: API version of this structure * @flags: encodes whether the corresponding fields are valid * (IOMMU_FAULT_PAGE_RESPONSE_* values) * @pasid: Process Address Space ID
@@ -113,14 +111,11 @@ enum iommu_page_response_code {* @code: response code from &enum iommu_page_response_code */ struct iommu_page_response { -__u32 argsz; -#define IOMMU_PAGE_RESP_VERSION_1 1 -__u32 version;#define IOMMU_PAGE_RESP_PASID_VALID (1 << 0) -__u32 flags; -__u32 pasid; -__u32 grpid; -__u32 code; +u32 flags; +u32 pasid; +u32 grpid; +u32 code; };
drivers/iommu/io-pgfault.c +0 -1
@@ -56,7 +56,6 @@ static int iopf_complete_group(struct device *dev, struct iopf_fault *iopf, enum iommu_page_response_code status) {struct iommu_page_response resp = { - .version =IOMMU_PAGE_RESP_VERSION_1 , .pasid = iopf->fault.prm.pasid, .grpid = iopf->fault.prm.grpid, .code = status,
drivers/iommu/iommu.c +0 -4
@@ -1455,10 +1455,6 @@ int iommu_page_response(struct device *dev,if (!param || !param->fault_param)return -EINVAL ; -if (msg->version !=IOMMU_PAGE_RESP_VERSION_1 || - msg->flags & ~IOMMU_PAGE_RESP_PASID_VALID ) -return -EINVAL ; -/* Only send response if there is a fault report pending */ mutex_lock (¶m->fault_param->lock);if (list_empty (¶m->fault_param->faults)) {
Signature · 1 line
2.34.1
Re: [PATCH v3 04/11] iommu: Cleanup iopf data structure definitions
Quoted 9 lines · Lu Baolu
struct
iommu_fault_page_requestand structiommu_page_responseare not part of uAPI anymore. Convert them to data structures for kAPI.Signed-off-by Lu Baolu <[email protected]>--- include/linux/iommu.h | 27 +++++++++++---------------- drivers/iommu/io-pgfault.c | 1 - drivers/iommu/iommu.c | 4 ---- 3 files changed, 11 insertions(+), 21 deletions(-)
Jason
Lu Baolu
maintainerPATCH v3 5/11 iommu: Merge iopf_device_param into iommu_fault_param
In reply to Lu BaoluThe struct dev_iommu contains two pointers, fault_param and iopf_param. The fault_param pointer points to a data structure that is used to store pending faults that are awaiting responses. The iopf_param pointer points to a data structure that is used to store partial faults that are part of a Page Request Group.
The fault_param and iopf_param pointers are essentially duplicate. This causes memory waste. Merge the iopf_device_param pointer into the iommu_fault_param pointer to consolidate the code and save memory. The consolidated pointer would be allocated on demand when the device driver enables the iopf on device, and would be freed after iopf is disabled.
--- include/linux/iommu.h | 20 +++++-- drivers/iommu/io-pgfault.c | 113 ++++++++++++++++++------------------- drivers/iommu/iommu.c | 34 ++--------- 3 files changed, 76 insertions(+), 91 deletions(-)
include/linux/iommu.h +15 -5
@@ -40,6 +40,7 @@ struct notifier_block;struct iommu_sva ;struct iommu_fault_event ;struct iommu_dma_cookie ; +struct iopf_queue ;#define IOMMU_FAULT_PERM_READ (1 << 0)/* read */ #define IOMMU_FAULT_PERM_WRITE (1 << 1)/* write */
@@ -472,21 +473,31 @@ struct iommu_fault_event {* struct iommu_fault_param - per-device IOMMU fault data * @handler: Callback function to handle IOMMU faults at device level * @data: handler private data -* @faults: holds the pending faults which needs response * @lock: protect pending faults list +* @dev: the device that owns this param +* @queue: IOPF queue +* @queue_list: index into queue->devices +* @partial: faults that are part of a Page Request Group for which the last +* request hasn't been submitted yet. +* @faults: holds the pending faults which needs response */ struct iommu_fault_param {iommu_dev_fault_handler_t handler;void *data; -struct list_head faults; -struct mutex lock; +struct mutex lock; + +struct device *dev; +struct iopf_queue *queue; +struct list_head queue_list; + +struct list_head partial; +struct list_head faults; };/** * struct dev_iommu - Collection of per-device IOMMU data * * @fault_param: IOMMU detected device fault reporting data -* @iopf_param: I/O Page Fault queue and data * @fwspec: IOMMU fwspec data * @iommu_dev: IOMMU device this device is linked to * @priv: IOMMU Driver private data
@@ -501,7 +512,6 @@ struct iommu_fault_param {struct dev_iommu {struct mutex lock;struct iommu_fault_param *fault_param; -struct iopf_device_param *iopf_param;struct iommu_fwspec *fwspec;struct iommu_device *iommu_dev;void *priv;
drivers/iommu/io-pgfault.c +55 -58
186 lines not on this page · raw message
drivers/iommu/iommu.c +6 -28
@@ -1316,27 +1316,18 @@ int iommu_register_device_fault_handler(struct device *dev,struct dev_iommu *param = dev->iommu;int ret =0 ; -if (!param) +if (!param || !param->fault_param)return -EINVAL ;mutex_lock (¶m->lock);/* Only allow one fault handler registered for each device */ -if (param->fault_param) { +if (param->fault_param->handler) { ret = -EBUSY ; goto done_unlock; } -get_device (dev); - param->fault_param =kzalloc (sizeof (*param->fault_param),GFP_KERNEL ); -if (!param->fault_param) { -put_device (dev); - ret = -ENOMEM ; - goto done_unlock; - } param->fault_param->handler = handler; param->fault_param->data = data; -mutex_init (¶m->fault_param->lock); -INIT_LIST_HEAD (¶m->fault_param->faults); done_unlock:mutex_unlock (¶m->lock);
@@ -1357,29 +1348,16 @@ EXPORT_SYMBOL_GPL(iommu_register_device_fault_handler);int iommu_unregister_device_fault_handler (struct device *dev) {struct dev_iommu *param = dev->iommu; -int ret =0 ; -if (!param) +if (!param || !param->fault_param)return -EINVAL ;mutex_lock (¶m->lock); - -if (!param->fault_param) - goto unlock; - -/* we cannot unregister handler if there are pending faults */ -if (!list_empty (¶m->fault_param->faults)) { - ret = -EBUSY ; - goto unlock; - } - -kfree (param->fault_param); - param->fault_param =NULL ; -put_device (dev); -unlock: + param->fault_param->handler =NULL ; + param->fault_param->data =NULL ;mutex_unlock (¶m->lock); -return ret; +return 0 ; }EXPORT_SYMBOL_GPL (iommu_unregister_device_fault_handler);
Signature · 1 line
2.34.1
Re: [PATCH v3 05/11] iommu: Merge iopf_device_param into iommu_fault_param
Quoted 17 lines · Lu Baolu
include/linux/iommu.h +6
-2@@ -472,21 +473,31 @@ struct iommu_fault_event {* struct iommu_fault_param - per-device IOMMU fault data * @handler: Callback function to handle IOMMU faults at device level * @data: handler private data -* @faults: holds the pending faults which needs response * @lock: protect pending faults list +* @dev: the device that owns this param +* @queue: IOPF queue +* @queue_list: index into queue->devices +* @partial: faults that are part of a Page Request Group for which the last +* request hasn't been submitted yet. +* @faults: holds the pending faults which needs response */ struct iommu_fault_param {iommu_dev_fault_handler_t handler;void *data; -struct list_head faults;
include/linux/iommu.h struct iommu_fault_event { · line 495
Quoted 10 lines
include/linux/iommu.h +8
-1-struct mutex lock; +struct mutex lock; + +struct device *dev; +struct iopf_queue *queue; +struct list_head queue_list; + +struct list_head partial; +struct list_head faults; };
Don't add the horizontal spaces
Jason
-
Baolu Lu
maintainerRe: [PATCH v3 05/11] iommu: Merge iopf_device_param into iommu_fault_param
Quoted 21 lines · Jason Gunthorpe
Quoted 20 lines · Lu Baolu
include/linux/iommu.h +8
-3@@ -472,21 +473,31 @@ struct iommu_fault_event {* struct iommu_fault_param - per-device IOMMU fault data * @handler: Callback function to handle IOMMU faults at device level * @data: handler private data -* @faults: holds the pending faults which needs response * @lock: protect pending faults list +* @dev: the device that owns this param +* @queue: IOPF queue +* @queue_list: index into queue->devices +* @partial: faults that are part of a Page Request Group for which the last +* request hasn't been submitted yet. +* @faults: holds the pending faults which needs response */ struct iommu_fault_param {iommu_dev_fault_handler_t handler;void *data; -struct list_head faults; -struct mutex lock; +struct mutex lock; +
Quoted 8 lines
include/linux/iommu.h struct iommu_fault_event { · line 495
Quoted 7 lines
include/linux/iommu.h +6
-0+struct device *dev; +struct iopf_queue *queue; +struct list_head queue_list; + +struct list_head partial; +struct list_head faults; };Don't add the horizontal spaces
Fixed. Thanks!
Best regards,
baolu
Lu Baolu
maintainerPATCH v3 6/11 iommu: Remove iommu_[un]register_device_fault_handler()
In reply to Lu BaoluThe individual iommu driver reports the iommu page faults by calling iommu_report_device_fault(), where a pre-registered device fault handler is called to route the fault to another fault handler installed on the corresponding iommu domain.
The pre-registered device fault handler is static and won't be dynamic as the fault handler is eventually per iommu domain. Replace calling device fault handler with iommu_queue_iopf().
After this replacement, the registering and unregistering fault handler interfaces are not needed anywhere. Remove the interfaces and the related data structures to avoid dead code.
Convert cookie parameter of iommu_queue_iopf() into a device pointer that is really passed.
--- include/linux/iommu.h | 23 ------ drivers/iommu/iommu-sva.h | 4 +- .../iommu/arm/arm-smmu-v3/arm-smmu-v3-sva.c | 13 +--- drivers/iommu/intel/iommu.c | 24 ++---- drivers/iommu/io-pgfault.c | 6 +- drivers/iommu/iommu.c | 76 +------------------ 6 files changed, 13 insertions(+), 133 deletions(-)
include/linux/iommu.h +0 -23
@@ -126,7 +126,6 @@ struct iommu_page_response {typedef int (*iommu_fault_handler_t )(struct iommu_domain *,struct device *,unsigned long ,int ,void *); -typedef int (*iommu_dev_fault_handler_t )(struct iommu_fault *,void *);struct iommu_domain_geometry {dma_addr_t aperture_start;/* First address that can be mapped */
@@ -471,8 +470,6 @@ struct iommu_fault_event {/** * struct iommu_fault_param - per-device IOMMU fault data -* @handler: Callback function to handle IOMMU faults at device level -* @data: handler private data * @lock: protect pending faults list * @dev: the device that owns this param * @queue: IOPF queue
@@ -482,8 +479,6 @@ struct iommu_fault_event {* @faults: holds the pending faults which needs response */ struct iommu_fault_param { -iommu_dev_fault_handler_t handler; -void *data;struct mutex lock;struct device *dev;
@@ -616,11 +611,6 @@ extern int iommu_group_for_each_dev(struct iommu_group *group, void *data,extern struct iommu_group *iommu_group_get (struct device *dev);extern struct iommu_group *iommu_group_ref_get (struct iommu_group *group);extern void iommu_group_put (struct iommu_group *group); -extern int iommu_register_device_fault_handler (struct device *dev, -iommu_dev_fault_handler_t handler, -void *data); - -extern int iommu_unregister_device_fault_handler (struct device *dev);extern int iommu_report_device_fault (struct device *dev,struct iommu_fault_event *evt);
@@ -1006,19 +996,6 @@ static inline void iommu_group_put(struct iommu_group *group) { } -static inline -int iommu_register_device_fault_handler (struct device *dev, -iommu_dev_fault_handler_t handler, -void *data) -{ -return -ENODEV ; -} - -static inline int iommu_unregister_device_fault_handler (struct device *dev) -{ -return 0 ; -} -static inline int iommu_report_device_fault (struct device *dev,struct iommu_fault_event *evt) {
drivers/iommu/iommu-sva.h +2 -2
@@ -13,7 +13,7 @@ struct iommu_fault;struct iopf_queue ;#ifdef CONFIG_IOMMU_SVA -int iommu_queue_iopf (struct iommu_fault *fault,void *cookie); +int iommu_queue_iopf (struct iommu_fault *fault,struct device *dev);int iopf_queue_add_device (struct iopf_queue *queue,struct device *dev); int iopf_queue_remove_device(struct iopf_queue *queue,
@@ -26,7 +26,7 @@ enum iommu_page_response_code iommu_sva_handle_iopf(struct iommu_fault *fault, void *data);#else /* CONFIG_IOMMU_SVA */ -static inline int iommu_queue_iopf (struct iommu_fault *fault,void *cookie) +static inline int iommu_queue_iopf (struct iommu_fault *fault,struct device *dev) {return -ENODEV ; }
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-sva.c +1 -12
@@ -437,7 +437,6 @@ bool arm_smmu_master_sva_enabled(struct arm_smmu_master *master)static int arm_smmu_master_sva_enable_iopf (struct arm_smmu_master *master) { -int ret;struct device *dev = master->dev;/*
@@ -450,16 +449,7 @@ static int arm_smmu_master_sva_enable_iopf(struct arm_smmu_master *master)if (!master->iopf_enabled)return -EINVAL ; - ret =iopf_queue_add_device (master->smmu->evtq.iopf, dev); -if (ret) -return ret; - - ret =iommu_register_device_fault_handler (dev, iommu_queue_iopf, dev); -if (ret) { -iopf_queue_remove_device (master->smmu->evtq.iopf, dev); -return ret; - } -return 0 ; +return iopf_queue_add_device (master->smmu->evtq.iopf, dev); }static void arm_smmu_master_sva_disable_iopf (struct arm_smmu_master *master)
@@ -469,7 +459,6 @@ static void arm_smmu_master_sva_disable_iopf(struct arm_smmu_master *master)if (!master->iopf_enabled)return ; -iommu_unregister_device_fault_handler (dev);iopf_queue_remove_device (master->smmu->evtq.iopf, dev); }
drivers/iommu/intel/iommu.c +7 -17
@@ -4574,23 +4574,15 @@ static int intel_iommu_enable_iopf(struct device *dev)if (ret)return ret; - ret =iommu_register_device_fault_handler (dev, iommu_queue_iopf, dev); -if (ret) - goto iopf_remove_device; - ret =pci_enable_pri (pdev,PRQ_DEPTH ); -if (ret) - goto iopf_unregister_handler; +if (ret) { +iopf_queue_remove_device (iommu->iopf_queue, dev); +return ret; + } + info->pri_enabled =1 ;return 0 ; - -iopf_unregister_handler: -iommu_unregister_device_fault_handler (dev); -iopf_remove_device: -iopf_queue_remove_device (iommu->iopf_queue, dev); - -return ret; }static int intel_iommu_disable_iopf (struct device *dev)
@@ -4613,11 +4605,9 @@ static int intel_iommu_disable_iopf(struct device *dev) info->pri_enabled =0 ;/* -* With PRI disabled and outstanding PRQs drained, unregistering -* fault handler and removing device from iopf queue should never -* fail. +* With PRI disabled and outstanding PRQs drained, removing device +* from iopf queue should never fail. */ -WARN_ON (iommu_unregister_device_fault_handler (dev));WARN_ON (iopf_queue_remove_device (iommu->iopf_queue, dev));return 0 ;
drivers/iommu/io-pgfault.c +2 -4
@@ -87,7 +87,7 @@ static void iopf_handler(struct work_struct *work)/** * iommu_queue_iopf - IO Page Fault handler * @fault: fault event -* @cookie: struct device, passed to iommu_register_device_fault_handler. +* @dev: struct device. * * Add a fault to the device workqueue, to be handled by mm. *
@@ -124,14 +124,12 @@ static void iopf_handler(struct work_struct *work)* * Return: 0 on success and <0 on error. */ -int iommu_queue_iopf (struct iommu_fault *fault,void *cookie) +int iommu_queue_iopf (struct iommu_fault *fault,struct device *dev) {int ret;struct iopf_group *group;struct iopf_fault *iopf, *next;struct iommu_fault_param *iopf_param; - -struct device *dev = cookie;struct dev_iommu *param = dev->iommu;lockdep_assert_held (¶m->lock);
drivers/iommu/iommu.c +1 -75
94 lines not on this page · raw message
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v3 7/11 iommu: Prepare for separating SVA and IOPF
In reply to Lu BaoluMove iopf_group data structure to iommu.h. This is being done to make it a minimal set of faults that a domain's page fault handler should handle.
Add two new helpers for the domain's page fault handler:
- iopf_free_group: free a fault group after all faults in the group are handled.
- iopf_queue_work: queue a given work item for a fault group.
This will simplify the sequential patches.
--- include/linux/iommu.h | 12 ++++++++++ drivers/iommu/io-pgfault.c | 49 ++++++++++++++++++++++---------------- 2 files changed, 41 insertions(+), 20 deletions(-)
include/linux/iommu.h +12 -0
@@ -516,6 +516,18 @@ struct dev_iommu { u32 require_direct:1; }; +struct iopf_fault { +struct iommu_fault fault; +struct list_head list; +}; + +struct iopf_group { +struct iopf_fault last_fault; +struct list_head faults; +struct work_struct work; +struct device *dev; +}; +int iommu_device_register (struct iommu_device *iommu,const struct iommu_ops *ops,struct device *hwdev);
drivers/iommu/io-pgfault.c +29 -20
91 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCH v3 07/11] iommu: Prepare for separating SVA and IOPF
Quoted 8 lines · Lu Baolu
Move
iopf_groupdata structure toiommu.h. This is being done to make it a minimal set of faults that a domain's page fault handler should handle.Add two new helpers for the domain's page fault handler:
-iopf_free_group: free a fault group after all faults in the group are handled.
-iopf_queue_work: queue a given work item for a fault group.
Quoted 7 lines
This will simplify the sequential patches.
Signed-off-by Lu Baolu <[email protected]>--- include/linux/iommu.h | 12 ++++++++++ drivers/iommu/io-pgfault.c | 49 ++++++++++++++++++++++---------------- 2 files changed, 41 insertions(+), 20 deletions(-)
Jason
Lu Baolu
maintainerPATCH v3 8/11 iommu: Move iopf_handler() to iommu-sva.c
In reply to Lu BaoluThe iopf_handler() function handles a fault_group for a SVA domain. Move it to the right place.
--- drivers/iommu/iommu-sva.h | 17 +++++++++++++ drivers/iommu/io-pgfault.c | 50 +++----------------------------------- drivers/iommu/iommu-sva.c | 48 ++++++++++++++++++++++++++++++++++++ 3 files changed, 69 insertions(+), 46 deletions(-)
drivers/iommu/iommu-sva.h +17 -0
@@ -24,6 +24,9 @@ void iopf_queue_free(struct iopf_queue *queue);int iopf_queue_discard_partial (struct iopf_queue *queue);enum iommu_page_response_code iommu_sva_handle_iopf (struct iommu_fault *fault,void *data); +void iopf_free_group (struct iopf_group *group); +int iopf_queue_work (struct iopf_group *group,work_func_t func); +int iommu_sva_handle_iopf_group (struct iopf_group *group);#else /* CONFIG_IOMMU_SVA */ static inline int iommu_queue_iopf (struct iommu_fault *fault,struct device *dev)
@@ -67,5 +70,19 @@ iommu_sva_handle_iopf(struct iommu_fault *fault, void *data) {return IOMMU_PAGE_RESP_INVALID ; } + +static inline void iopf_free_group (struct iopf_group *group) +{ +} + +static inline int iopf_queue_work (struct iopf_group *group,work_func_t func) +{ +return -ENODEV ; +} + +static inline int iommu_sva_handle_iopf_group (struct iopf_group *group) +{ +return -ENODEV ; +}#endif /* CONFIG_IOMMU_SVA */ #endif /* _IOMMU_SVA_H */
drivers/iommu/io-pgfault.c +4 -46
68 lines not on this page · raw message
drivers/iommu/iommu-sva.c +48 -0
51 lines not on this page · raw message
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v3 9/11 iommu: Make iommu_queue_iopf() more generic
In reply to Lu BaoluThis completely separates the IO page fault handling framework from the SVA implementation. Previously, the SVA implementation was tightly coupled with the IO page fault handling framework. This makes SVA a "customer" of the IO page fault handling framework by converting domain's page fault handler to handle a group of faults and calling it directly from iommu_queue_iopf().
--- include/linux/iommu.h | 5 +++-- drivers/iommu/iommu-sva.h | 8 -------- drivers/iommu/io-pgfault.c | 16 +++++++++++++--- drivers/iommu/iommu-sva.c | 14 ++++---------- drivers/iommu/iommu.c | 4 ++-- 5 files changed, 22 insertions(+), 25 deletions(-)
include/linux/iommu.h +3 -2
@@ -41,6 +41,7 @@ struct iommu_sva;struct iommu_fault_event ;struct iommu_dma_cookie ;struct iopf_queue ; +struct iopf_group ;#define IOMMU_FAULT_PERM_READ (1 << 0)/* read */ #define IOMMU_FAULT_PERM_WRITE (1 << 1)/* write */
@@ -175,8 +176,7 @@ struct iommu_domain {unsigned long pgsize_bitmap;/* Bitmap of page sizes in use */ struct iommu_domain_geometry geometry;struct iommu_dma_cookie *iova_cookie; -enum iommu_page_response_code (*iopf_handler)(struct iommu_fault *fault, -void *data); +int (*iopf_handler)(struct iopf_group *group);void *fault_data; union { struct {
@@ -526,6 +526,7 @@ struct iopf_group {struct list_head faults;struct work_struct work;struct device *dev; +void *data; }; int iommu_device_register(struct iommu_device *iommu,
drivers/iommu/iommu-sva.h +0 -8
@@ -22,8 +22,6 @@ int iopf_queue_flush_dev(struct device *dev);struct iopf_queue *iopf_queue_alloc (const char *name);void iopf_queue_free (struct iopf_queue *queue);int iopf_queue_discard_partial (struct iopf_queue *queue); -enum iommu_page_response_code -iommu_sva_handle_iopf (struct iommu_fault *fault,void *data);void iopf_free_group (struct iopf_group *group);int iopf_queue_work (struct iopf_group *group,work_func_t func);int iommu_sva_handle_iopf_group (struct iopf_group *group);
@@ -65,12 +63,6 @@ static inline int iopf_queue_discard_partial(struct iopf_queue *queue)return -ENODEV ; } -static inline enum iommu_page_response_code -iommu_sva_handle_iopf (struct iommu_fault *fault,void *data) -{ -return IOMMU_PAGE_RESP_INVALID ; -} -static inline void iopf_free_group (struct iopf_group *group) { }
drivers/iommu/io-pgfault.c +13 -3
@@ -11,8 +11,6 @@#include <linux/slab.h> #include <linux/workqueue.h> -#include "iommu-sva.h" -/** * struct iopf_queue - IO Page Fault queue * @wq: the fault workqueue
@@ -93,6 +91,7 @@ int iommu_queue_iopf(struct iommu_fault *fault, struct device *dev) {int ret;struct iopf_group *group; +struct iommu_domain *domain;struct iopf_fault *iopf, *next;struct iommu_fault_param *iopf_param;struct dev_iommu *param = dev->iommu;
@@ -124,6 +123,16 @@ int iommu_queue_iopf(struct iommu_fault *fault, struct device *dev)return 0 ; } +if (fault->prm.flags &IOMMU_FAULT_PAGE_REQUEST_PASID_VALID ) + domain =iommu_get_domain_for_dev_pasid (dev, fault->prm.pasid,0 ); +else + domain =iommu_get_domain_for_dev (dev); + +if (!domain || !domain->iopf_handler) { + ret = -ENODEV ; + goto cleanup_partial; + } + group =kzalloc (sizeof (*group),GFP_KERNEL );if (!group) {/*
@@ -137,6 +146,7 @@ int iommu_queue_iopf(struct iommu_fault *fault, struct device *dev) group->dev = dev; group->last_fault.fault = *fault; + group->data = domain->fault_data;INIT_LIST_HEAD (&group->faults);list_add (&group->last_fault.list, &group->faults);
@@ -147,7 +157,7 @@ int iommu_queue_iopf(struct iommu_fault *fault, struct device *dev)list_move (&iopf->list, &group->faults); } - ret =iommu_sva_handle_iopf_group (group); + ret = domain->iopf_handler (group);if (ret)iopf_free_group (group);
drivers/iommu/iommu-sva.c +4 -10
@@ -148,13 +148,14 @@ EXPORT_SYMBOL_GPL(iommu_sva_get_pasid);/* * I/O page fault handler for SVA */ -enum iommu_page_response_code +static enum iommu_page_response_code iommu_sva_handle_iopf (struct iommu_fault *fault,void *data) {vm_fault_t ret;struct vm_area_struct *vma; -struct mm_struct *mm = data;unsigned int access_flags =0 ; +struct iommu_domain *domain = data; +struct mm_struct *mm = domain->mm;unsigned int fault_flags =FAULT_FLAG_REMOTE ;struct iommu_fault_page_request *prm = &fault->prm;enum iommu_page_response_code status =IOMMU_PAGE_RESP_INVALID ;
@@ -231,23 +232,16 @@ static void iommu_sva_iopf_handler(struct work_struct *work) {struct iopf_fault *iopf;struct iopf_group *group; -struct iommu_domain *domain;enum iommu_page_response_code status =IOMMU_PAGE_RESP_SUCCESS ; group = container_of(work, struct iopf_group, work); - domain =iommu_get_domain_for_dev_pasid (group->dev, - group->last_fault.fault.prm.pasid,0 ); -if (!domain || !domain->iopf_handler) - status =IOMMU_PAGE_RESP_INVALID ; -list_for_each_entry (iopf, &group->faults, list) {/* * For the moment, errors are sticky: don't handle subsequent * faults in the group if there is an error. */ if (status ==IOMMU_PAGE_RESP_SUCCESS ) - status = domain->iopf_handler (&iopf->fault, - domain->fault_data); + status =iommu_sva_handle_iopf (&iopf->fault, group->data); }iommu_sva_complete_iopf (group->dev, &group->last_fault, status);
drivers/iommu/iommu.c +2 -2
@@ -3395,8 +3395,8 @@ struct iommu_domain *iommu_sva_domain_alloc(struct device *dev, domain->type =IOMMU_DOMAIN_SVA ;mmgrab (mm); domain->mm = mm; - domain->iopf_handler = iommu_sva_handle_iopf; - domain->fault_data = mm; + domain->iopf_handler = iommu_sva_handle_iopf_group; + domain->fault_data = domain;return domain; }
Signature · 1 line
2.34.1
Re: [PATCH v3 09/11] iommu: Make iommu_queue_iopf() more generic
Quoted 178 lines · Lu Baolu
This completely separates the IO page fault handling framework from the SVA implementation. Previously, the SVA implementation was tightly coupled with the IO page fault handling framework. This makes SVA a "customer" of the IO page fault handling framework by converting domain's page fault handler to handle a group of faults and calling it directly from
iommu_queue_iopf().Signed-off-by Lu Baolu <[email protected]>--- include/linux/iommu.h | 5 +++-- drivers/iommu/iommu-sva.h | 8 -------- drivers/iommu/io-pgfault.c | 16 +++++++++++++--- drivers/iommu/iommu-sva.c | 14 ++++---------- drivers/iommu/iommu.c | 4 ++-- 5 files changed, 22 insertions(+), 25 deletions(-)include/linux/iommu.h +3
-2@@ -41,6 +41,7 @@ struct iommu_sva;struct iommu_fault_event ;struct iommu_dma_cookie ;struct iopf_queue ; +struct iopf_group ;#define IOMMU_FAULT_PERM_READ (1 << 0)/* read */ #define IOMMU_FAULT_PERM_WRITE (1 << 1)/* write */ @@ -175,8 +176,7 @@ struct iommu_domain {unsigned long pgsize_bitmap;/* Bitmap of page sizes in use */ struct iommu_domain_geometry geometry;struct iommu_dma_cookie *iova_cookie; -enum iommu_page_response_code (*iopf_handler)(struct iommu_fault *fault, -void *data); +int (*iopf_handler)(struct iopf_group *group);void *fault_data; union { struct {@@ -526,6 +526,7 @@ struct iopf_group {struct list_head faults;struct work_struct work;struct device *dev; +void *data; }; int iommu_device_register(struct iommu_device *iommu,drivers/iommu/iommu-sva.h +0
-8@@ -22,8 +22,6 @@ int iopf_queue_flush_dev(struct device *dev);struct iopf_queue *iopf_queue_alloc (const char *name);void iopf_queue_free (struct iopf_queue *queue);int iopf_queue_discard_partial (struct iopf_queue *queue); -enum iommu_page_response_code -iommu_sva_handle_iopf (struct iommu_fault *fault,void *data);void iopf_free_group (struct iopf_group *group);int iopf_queue_work (struct iopf_group *group,work_func_t func);int iommu_sva_handle_iopf_group (struct iopf_group *group);@@ -65,12 +63,6 @@ static inline int iopf_queue_discard_partial(struct iopf_queue *queue)return -ENODEV ; } -static inline enum iommu_page_response_code -iommu_sva_handle_iopf (struct iommu_fault *fault,void *data) -{ -return IOMMU_PAGE_RESP_INVALID ; -} -static inline void iopf_free_group (struct iopf_group *group) { }drivers/iommu/io-pgfault.c +13
-3@@ -11,8 +11,6 @@#include <linux/slab.h> #include <linux/workqueue.h> -#include "iommu-sva.h" -/** * struct iopf_queue - IO Page Fault queue * @wq: the fault workqueue @@ -93,6 +91,7 @@ int iommu_queue_iopf(struct iommu_fault *fault, struct device *dev) {int ret;struct iopf_group *group; +struct iommu_domain *domain;struct iopf_fault *iopf, *next;struct iommu_fault_param *iopf_param;struct dev_iommu *param = dev->iommu;@@ -124,6 +123,16 @@ int iommu_queue_iopf(struct iommu_fault *fault, struct device *dev)return 0 ; } +if (fault->prm.flags &IOMMU_FAULT_PAGE_REQUEST_PASID_VALID ) + domain =iommu_get_domain_for_dev_pasid (dev, fault->prm.pasid,0 ); +else + domain =iommu_get_domain_for_dev (dev); + +if (!domain || !domain->iopf_handler) { + ret = -ENODEV ; + goto cleanup_partial; + } + group =kzalloc (sizeof (*group),GFP_KERNEL );if (!group) {/* @@ -137,6 +146,7 @@ int iommu_queue_iopf(struct iommu_fault *fault, struct device *dev) group->dev = dev; group->last_fault.fault = *fault; + group->data = domain->fault_data;INIT_LIST_HEAD (&group->faults);list_add (&group->last_fault.list, &group->faults);@@ -147,7 +157,7 @@ int iommu_queue_iopf(struct iommu_fault *fault, struct device *dev)list_move (&iopf->list, &group->faults); } - ret =iommu_sva_handle_iopf_group (group); + ret = domain->iopf_handler (group);if (ret)iopf_free_group (group);drivers/iommu/iommu-sva.c +4
-10@@ -148,13 +148,14 @@ EXPORT_SYMBOL_GPL(iommu_sva_get_pasid);/* * I/O page fault handler for SVA */ -enum iommu_page_response_code +static enum iommu_page_response_code iommu_sva_handle_iopf (struct iommu_fault *fault,void *data) {vm_fault_t ret;struct vm_area_struct *vma; -struct mm_struct *mm = data;unsigned int access_flags =0 ; +struct iommu_domain *domain = data; +struct mm_struct *mm = domain->mm;unsigned int fault_flags =FAULT_FLAG_REMOTE ;struct iommu_fault_page_request *prm = &fault->prm;enum iommu_page_response_code status =IOMMU_PAGE_RESP_INVALID ;@@ -231,23 +232,16 @@ static void iommu_sva_iopf_handler(struct work_struct *work) {struct iopf_fault *iopf;struct iopf_group *group; -struct iommu_domain *domain;enum iommu_page_response_code status =IOMMU_PAGE_RESP_SUCCESS ; group = container_of(work, struct iopf_group, work); - domain =iommu_get_domain_for_dev_pasid (group->dev, - group->last_fault.fault.prm.pasid,0 ); -if (!domain || !domain->iopf_handler) - status =IOMMU_PAGE_RESP_INVALID ; -list_for_each_entry (iopf, &group->faults, list) {/* * For the moment, errors are sticky: don't handle subsequent * faults in the group if there is an error. */ if (status ==IOMMU_PAGE_RESP_SUCCESS ) - status = domain->iopf_handler (&iopf->fault, - domain->fault_data); + status =iommu_sva_handle_iopf (&iopf->fault, group->data); }iommu_sva_complete_iopf (group->dev, &group->last_fault, status);drivers/iommu/iommu.c +0
-0
drivers/iommu/iommu.c struct iommu_domain *iommu_sva_domain_alloc(struct device *dev, · line 3399
Quoted 7 lines
drivers/iommu/iommu.c +2
-2@@ -3395,8 +3395,8 @@ struct iommu_domain *iommu_sva_domain_alloc(struct device *dev, domain->type =IOMMU_DOMAIN_SVA ;mmgrab (mm); domain->mm = mm; - domain->iopf_handler = iommu_sva_handle_iopf; - domain->fault_data = mm; + domain->iopf_handler = iommu_sva_handle_iopf_group; + domain->fault_data = domain;
Why fault_data? The domain handling the fault should be passed through naturally without relying on fault_data.
eg make
iommu_sva_handle_iopf(struct iommu_fault *fault, void *data)
into
iommu_sva_handle_iopf(struct iommu_fault *fault, struct iommu_domain *domain)
And delete domain->fault_data until we have some use for it.
The core code should be keeping track of the iommu_domain lifetime.
Jason
Baolu Lu
maintainerRe: [PATCH v3 09/11] iommu: Make iommu_queue_iopf() more generic
Quoted 190 lines · Jason Gunthorpe
Quoted 178 lines · Lu Baolu
This completely separates the IO page fault handling framework from the SVA implementation. Previously, the SVA implementation was tightly coupled with the IO page fault handling framework. This makes SVA a "customer" of the IO page fault handling framework by converting domain's page fault handler to handle a group of faults and calling it directly from
iommu_queue_iopf().Signed-off-by Lu Baolu <[email protected]>--- include/linux/iommu.h | 5 +++-- drivers/iommu/iommu-sva.h | 8 -------- drivers/iommu/io-pgfault.c | 16 +++++++++++++--- drivers/iommu/iommu-sva.c | 14 ++++---------- drivers/iommu/iommu.c | 4 ++-- 5 files changed, 22 insertions(+), 25 deletions(-)include/linux/iommu.h +3
-2@@ -41,6 +41,7 @@ struct iommu_sva;struct iommu_fault_event ;struct iommu_dma_cookie ;struct iopf_queue ; +struct iopf_group ;#define IOMMU_FAULT_PERM_READ (1 << 0)/* read */ #define IOMMU_FAULT_PERM_WRITE (1 << 1)/* write */ @@ -175,8 +176,7 @@ struct iommu_domain {unsigned long pgsize_bitmap;/* Bitmap of page sizes in use */ struct iommu_domain_geometry geometry;struct iommu_dma_cookie *iova_cookie; -enum iommu_page_response_code (*iopf_handler)(struct iommu_fault *fault, -void *data); +int (*iopf_handler)(struct iopf_group *group);void *fault_data; union { struct {@@ -526,6 +526,7 @@ struct iopf_group {struct list_head faults;struct work_struct work;struct device *dev; +void *data; }; int iommu_device_register(struct iommu_device *iommu,drivers/iommu/iommu-sva.h +0
-8@@ -22,8 +22,6 @@ int iopf_queue_flush_dev(struct device *dev);struct iopf_queue *iopf_queue_alloc (const char *name);void iopf_queue_free (struct iopf_queue *queue);int iopf_queue_discard_partial (struct iopf_queue *queue); -enum iommu_page_response_code -iommu_sva_handle_iopf (struct iommu_fault *fault,void *data);void iopf_free_group (struct iopf_group *group);int iopf_queue_work (struct iopf_group *group,work_func_t func);int iommu_sva_handle_iopf_group (struct iopf_group *group);@@ -65,12 +63,6 @@ static inline int iopf_queue_discard_partial(struct iopf_queue *queue)return -ENODEV ; } -static inline enum iommu_page_response_code -iommu_sva_handle_iopf (struct iommu_fault *fault,void *data) -{ -return IOMMU_PAGE_RESP_INVALID ; -} -static inline void iopf_free_group (struct iopf_group *group) { }drivers/iommu/io-pgfault.c +13
-3@@ -11,8 +11,6 @@#include <linux/slab.h> #include <linux/workqueue.h> -#include "iommu-sva.h" -/** * struct iopf_queue - IO Page Fault queue * @wq: the fault workqueue @@ -93,6 +91,7 @@ int iommu_queue_iopf(struct iommu_fault *fault, struct device *dev) {int ret;struct iopf_group *group; +struct iommu_domain *domain;struct iopf_fault *iopf, *next;struct iommu_fault_param *iopf_param;struct dev_iommu *param = dev->iommu;@@ -124,6 +123,16 @@ int iommu_queue_iopf(struct iommu_fault *fault, struct device *dev)return 0 ; } +if (fault->prm.flags &IOMMU_FAULT_PAGE_REQUEST_PASID_VALID ) + domain =iommu_get_domain_for_dev_pasid (dev, fault->prm.pasid,0 ); +else + domain =iommu_get_domain_for_dev (dev); + +if (!domain || !domain->iopf_handler) { + ret = -ENODEV ; + goto cleanup_partial; + } + group =kzalloc (sizeof (*group),GFP_KERNEL );if (!group) {/* @@ -137,6 +146,7 @@ int iommu_queue_iopf(struct iommu_fault *fault, struct device *dev) group->dev = dev; group->last_fault.fault = *fault; + group->data = domain->fault_data;INIT_LIST_HEAD (&group->faults);list_add (&group->last_fault.list, &group->faults);@@ -147,7 +157,7 @@ int iommu_queue_iopf(struct iommu_fault *fault, struct device *dev)list_move (&iopf->list, &group->faults); } - ret =iommu_sva_handle_iopf_group (group); + ret = domain->iopf_handler (group);if (ret)iopf_free_group (group);drivers/iommu/iommu-sva.c +4
-10@@ -148,13 +148,14 @@ EXPORT_SYMBOL_GPL(iommu_sva_get_pasid);/* * I/O page fault handler for SVA */ -enum iommu_page_response_code +static enum iommu_page_response_code iommu_sva_handle_iopf (struct iommu_fault *fault,void *data) {vm_fault_t ret;struct vm_area_struct *vma; -struct mm_struct *mm = data;unsigned int access_flags =0 ; +struct iommu_domain *domain = data; +struct mm_struct *mm = domain->mm;unsigned int fault_flags =FAULT_FLAG_REMOTE ;struct iommu_fault_page_request *prm = &fault->prm;enum iommu_page_response_code status =IOMMU_PAGE_RESP_INVALID ;@@ -231,23 +232,16 @@ static void iommu_sva_iopf_handler(struct work_struct *work) {struct iopf_fault *iopf;struct iopf_group *group; -struct iommu_domain *domain;enum iommu_page_response_code status =IOMMU_PAGE_RESP_SUCCESS ; group = container_of(work, struct iopf_group, work); - domain =iommu_get_domain_for_dev_pasid (group->dev, - group->last_fault.fault.prm.pasid,0 ); -if (!domain || !domain->iopf_handler) - status =IOMMU_PAGE_RESP_INVALID ; -list_for_each_entry (iopf, &group->faults, list) {/* * For the moment, errors are sticky: don't handle subsequent * faults in the group if there is an error. */ if (status ==IOMMU_PAGE_RESP_SUCCESS ) - status = domain->iopf_handler (&iopf->fault, - domain->fault_data); + status =iommu_sva_handle_iopf (&iopf->fault, group->data); }iommu_sva_complete_iopf (group->dev, &group->last_fault, status);drivers/iommu/iommu.c +0
-0drivers/iommu/iommu.c struct iommu_domain *iommu_sva_domain_alloc(struct device *dev, · line 3399
Quoted 7 lines
drivers/iommu/iommu.c +2
-2@@ -3395,8 +3395,8 @@ struct iommu_domain *iommu_sva_domain_alloc(struct device *dev, domain->type =IOMMU_DOMAIN_SVA ;mmgrab (mm); domain->mm = mm; - domain->iopf_handler = iommu_sva_handle_iopf; - domain->fault_data = mm; + domain->iopf_handler = iommu_sva_handle_iopf_group; + domain->fault_data = domain;Why
fault_data? The domain handling the fault should be passed through naturally without relying onfault_data.
Quoted 6 lines
eg make
iommu_sva_handle_iopf(struct iommu_fault *fault, void *data)into
iommu_sva_handle_iopf(struct iommu_fault *fault, struct iommu_domain *domain)
See your point now. I will remove "void *data" and move "domain" to "group->domain".
Quoted 2 lines
And delete
domain->fault_datauntil we have some use for it.
Perhaps we will soon have a use for it.
In the iommufd case, the iommufd iopf handler has a need to retrieve the hwpt pointer from a domain pointer, right? With the domain->fault_data pointing to the hwpt, the iopf handler has no need to lookup it in the critical path.
Quoted 2 lines
The core code should be keeping track of the
iommu_domainlifetime.
I added the debugging code in the next patch as you suggested.
Best regards,
baolu
Lu Baolu
maintainerPATCH v3 10/11 iommu: Add debugging on domain lifetime for iopf
In reply to Lu BaoluThe iopf handling framework in the core requires the domain's lifetime should cover all possible iopfs. This has been documented in the comments for iommu_queue_iopf() which is the entry of the framework.
Add some debugging to enforce this.
--- drivers/iommu/io-pgfault.c | 3 +++ drivers/iommu/iommu.c | 24 ++++++++++++++++++++++++ 2 files changed, 27 insertions(+)
drivers/iommu/io-pgfault.c +3 -0
@@ -129,6 +129,9 @@ int iommu_queue_iopf(struct iommu_fault *fault, struct device *dev) domain =iommu_get_domain_for_dev (dev);if (!domain || !domain->iopf_handler) { +dev_warn_ratelimited (dev, +"iopf from pasid %d received without handler installed\n" , + fault->prm.pasid); ret = -ENODEV ; goto cleanup_partial; }
drivers/iommu/iommu.c +24 -0
@@ -2032,6 +2032,28 @@ int iommu_deferred_attach(struct device *dev, struct iommu_domain *domain)return 0 ; } +static void assert_no_pending_iopf (struct device *dev,ioasid_t pasid) +{ +struct iommu_fault_param *iopf_param = dev->iommu->fault_param; +struct iommu_fault_event *evt; +struct iopf_fault *iopf; + +if (!iopf_param) +return ; + +mutex_lock (&iopf_param->lock); +list_for_each_entry (iopf, &iopf_param->partial, list) { +if (WARN_ON (iopf->fault.prm.pasid == pasid)) +break ; + } + +list_for_each_entry (evt, &iopf_param->faults, list) { +if (WARN_ON (evt->fault.prm.pasid == pasid)) +break ; + } +mutex_unlock (&iopf_param->lock); +} +void iommu_detach_device (struct iommu_domain *domain,struct device *dev) {/* Caller must be a probed driver on dev */
@@ -2040,6 +2062,7 @@ void iommu_detach_device(struct iommu_domain *domain, struct device *dev)if (!group)return ; +assert_no_pending_iopf (dev,IOMMU_NO_PASID );mutex_lock (&group->mutex);if (WARN_ON (domain != group->domain) ||WARN_ON (list_count_nodes (&group->devices) !=1 ))
@@ -3340,6 +3363,7 @@ void iommu_detach_device_pasid(struct iommu_domain *domain, struct device *dev,/* Caller must be a probed driver on dev */ struct iommu_group *group = dev->iommu_group; +assert_no_pending_iopf (dev, pasid);mutex_lock (&group->mutex);__iommu_remove_group_pasid (group, pasid);WARN_ON (xa_erase (&group->pasid_array, pasid) != domain);
Signature · 1 line
2.34.1
Lu Baolu
maintainerPATCH v3 11/11 iommu: Separate SVA and IOPF in Makefile and Kconfig
In reply to Lu BaoluAdd CONFIG_IOMMU_IOPF for page fault handling framework and select it from its real consumer. Move iopf function declaration from iommu-sva.h to iommu.h and remove iommu-sva.h as it's empty now.
--- include/linux/iommu.h | 63 +++++++++++++++ drivers/iommu/iommu-sva.h | 80 ------------------- .../iommu/arm/arm-smmu-v3/arm-smmu-v3-sva.c | 1 - drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 1 - drivers/iommu/intel/iommu.c | 1 - drivers/iommu/intel/svm.c | 1 - drivers/iommu/iommu-sva.c | 3 +- drivers/iommu/iommu.c | 2 - drivers/iommu/Kconfig | 4 + drivers/iommu/Makefile | 3 +- drivers/iommu/intel/Kconfig | 1 + 11 files changed, 71 insertions(+), 89 deletions(-) delete mode 100644 drivers/iommu/iommu-sva.h
include/linux/iommu.h +63 -0
@@ -42,6 +42,7 @@ struct iommu_fault_event;struct iommu_dma_cookie ;struct iopf_queue ;struct iopf_group ; +struct iopf_queue ;#define IOMMU_FAULT_PERM_READ (1 << 0)/* read */ #define IOMMU_FAULT_PERM_WRITE (1 << 1)/* write */
@@ -1284,6 +1285,7 @@ struct iommu_sva *iommu_sva_bind_device(struct device *dev, struct mm_struct *mm);void iommu_sva_unbind_device (struct iommu_sva *handle);u32 iommu_sva_get_pasid (struct iommu_sva *handle); +int iommu_sva_handle_iopf_group (struct iopf_group *group);#else static inline struct iommu_sva *iommu_sva_bind_device (struct device *dev,struct mm_struct *mm)
@@ -1302,6 +1304,67 @@ static inline u32 iommu_sva_get_pasid(struct iommu_sva *handle)static inline void mm_pasid_init (struct mm_struct *mm) {}static inline bool mm_valid_pasid (struct mm_struct *mm) {return false; }static inline void mm_pasid_drop (struct mm_struct *mm) {} +static inline int iommu_sva_handle_iopf_group (struct iopf_group *group) +{ +return -ENODEV ; +}#endif /* CONFIG_IOMMU_SVA */ +#ifdef CONFIG_IOMMU_IOPF +int iommu_queue_iopf (struct iommu_fault *fault,struct device *dev); +int iopf_queue_add_device (struct iopf_queue *queue,struct device *dev); +int iopf_queue_remove_device (struct iopf_queue *queue, +struct device *dev); +int iopf_queue_flush_dev (struct device *dev); +struct iopf_queue *iopf_queue_alloc (const char *name); +void iopf_queue_free (struct iopf_queue *queue); +int iopf_queue_discard_partial (struct iopf_queue *queue); +void iopf_free_group (struct iopf_group *group); +int iopf_queue_work (struct iopf_group *group,work_func_t func); +#else /* CONFIG_IOMMU_IOPF */ +static inline int iommu_queue_iopf (struct iommu_fault *fault,struct device *dev) +{ +return -ENODEV ; +} + +static inline int iopf_queue_add_device (struct iopf_queue *queue, +struct device *dev) +{ +return -ENODEV ; +} + +static inline int iopf_queue_remove_device (struct iopf_queue *queue, +struct device *dev) +{ +return -ENODEV ; +} + +static inline int iopf_queue_flush_dev (struct device *dev) +{ +return -ENODEV ; +} + +static inline struct iopf_queue *iopf_queue_alloc (const char *name) +{ +return NULL ; +} + +static inline void iopf_queue_free (struct iopf_queue *queue) +{ +} + +static inline int iopf_queue_discard_partial (struct iopf_queue *queue) +{ +return -ENODEV ; +} + +static inline void iopf_free_group (struct iopf_group *group) +{ +} + +static inline int iopf_queue_work (struct iopf_group *group,work_func_t func) +{ +return -ENODEV ; +} +#endif /* CONFIG_IOMMU_IOPF */ #endif /* __LINUX_IOMMU_H */
drivers/iommu/iommu-sva.h deleted +0 -80
80 lines not on this page · raw message
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-sva.c +0 -1
@@ -10,7 +10,6 @@#include <linux/slab.h> #include "arm-smmu-v3.h" -#include "../../iommu-sva.h" #include "../../io-pgtable-arm.h" struct arm_smmu_mmu_notifier {
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +0 -1
@@ -29,7 +29,6 @@#include "arm-smmu-v3.h" #include "../../dma-iommu.h" -#include "../../iommu-sva.h" static bool disable_bypass = true;module_param (disable_bypass, bool,0444 );
drivers/iommu/intel/iommu.c +0 -1
@@ -26,7 +26,6 @@#include "iommu.h" #include "../dma-iommu.h" #include "../irq_remapping.h" -#include "../iommu-sva.h" #include "pasid.h" #include "cap_audit.h" #include "perfmon.h"
drivers/iommu/intel/svm.c +0 -1
@@ -22,7 +22,6 @@#include "iommu.h" #include "pasid.h" #include "perf.h" -#include "../iommu-sva.h" #include "trace.h" static irqreturn_t prq_event_thread (int irq,void *d);
drivers/iommu/iommu-sva.c +1 -2
@@ -6,8 +6,7 @@#include <linux/mutex.h> #include <linux/sched/mm.h> #include <linux/iommu.h> - -#include "iommu-sva.h" +#include <linux/mm_types.h> static DEFINE_MUTEX (iommu_sva_lock);
drivers/iommu/iommu.c +0 -2
@@ -35,8 +35,6 @@#include "dma-iommu.h" -#include "iommu-sva.h" -static struct kset *iommu_group_kset;static DEFINE_IDA (iommu_group_ida);static DEFINE_IDA (iommu_global_pasid_ida);
drivers/iommu/Kconfig +4 -0
@@ -158,6 +158,9 @@ config IOMMU_DMA config IOMMU_SVA bool +config IOMMU_IOPF + bool + config FSL_PAMU bool "Freescale IOMMU support" depends on PCI
@@ -404,6 +407,7 @@ config ARM_SMMU_V3_SVA bool "Shared Virtual Addressing support for the ARM SMMUv3" depends on ARM_SMMU_V3 select IOMMU_SVA + select IOMMU_IOPF select MMU_NOTIFIER help Support for sharing process address spaces with devices using the
drivers/iommu/Makefile +2 -1
@@ -27,6 +27,7 @@ obj-$(CONFIG_FSL_PAMU) += fsl_pamu.o fsl_pamu_domain.o obj-$(CONFIG_S390_IOMMU) += s390-iommu.o obj-$(CONFIG_HYPERV_IOMMU) += hyperv-iommu.o obj-$(CONFIG_VIRTIO_IOMMU) += virtio-iommu.o -obj-$(CONFIG_IOMMU_SVA) += iommu-sva.o io-pgfault.o +obj-$(CONFIG_IOMMU_SVA) += iommu-sva.o +obj-$(CONFIG_IOMMU_IOPF) += io-pgfault.o obj-$(CONFIG_SPRD_IOMMU) += sprd-iommu.o obj-$(CONFIG_APPLE_DART) += apple-dart.o
drivers/iommu/intel/Kconfig +1 -0
@@ -50,6 +50,7 @@ config INTEL_IOMMU_SVM depends on X86_64 select MMU_NOTIFIER select IOMMU_SVA + select IOMMU_IOPF help Shared Virtual Memory (SVM) provides a facility for devices to access DMA resources through process address space by
Signature · 1 line
2.34.1
Quoted 9 lines · Lu Baolu
When a user-managed page table is attached to an IOMMU, it is necessary to deliver IO page faults to user space so that they can be handled appropriately. One use case for this is nested translation, which is currently being discussed in the mailing list.
I have posted a RFC series [1] that describes the implementation of delivering page faults to user space through IOMMUFD. This series has received several comments on the IOMMU refactoring, which I am trying to address in this series.
Looking at this after all the patches are applied..
iommu_report_device_fault() and iommu_queue_iopf() should be put in the same file.
iommu_queue_iopf() seems misnamed since it isn't queuing anything. It is delivering the fault to the domain.
It is weird that iommu_sva_domain_alloc is not in the sva file
iopf_queue_work() wrappers a work queue, but it should trampoline through another function before invoking the driver's callback and not invoke it with a weird work_struct - decode the group and get back the domain. Every single handler will require the group and domain.
Same for domain->iopf_handler, the domain should be an argument if we are invoking the function on a domain.
Perhaps group->domain is a simple answer.
Jason
Baolu Lu
maintainerQuoted 6 lines · Jason Gunthorpe
Quoted 5 lines · Lu Baolu
When a user-managed page table is attached to an IOMMU, it is necessary to deliver IO page faults to user space so that they can be handled appropriately. One use case for this is nested translation, which is currently being discussed in the mailing list.
Quoted 6 lines
Quoted 4 lines
I have posted a RFC series [1] that describes the implementation of delivering page faults to user space through IOMMUFD. This series has received several comments on the IOMMU refactoring, which I am trying to address in this series.
Looking at this after all the patches are applied..
Thank you very much for reviewing my patches.
Quoted 3 lines
iommu_report_device_fault()andiommu_queue_iopf()should be put in the same file.
Yes. I will move both into io-pgfault.c. After that, iommu_queue_iopf() becomes static.
Quoted 3 lines
iommu_queue_iopf()seems misnamed since it isn't queuing anything. It is delivering the fault to the domain.
Yeah, perhaps we can rename it to iommu_handle_iopf().
/**
* iommu_handle_iopf - IO Page Fault handler
* @fault: fault event
* @dev: struct device.
Quoted 2 lines
It is weird that
iommu_sva_domain_allocis not in the sva file
Agreed. I will move it to iommu-sva.c.
Quoted 4 lines
iopf_queue_work()wrappers a work queue, but it should trampoline through another function before invoking the driver's callback and not invoke it with a weirdwork_struct- decode the group and get back the domain. Every single handler will require the group and domain.
The work queue wrapper is duplicate. I will remove it and let the driver to call queue_work() directly.
Quoted 5 lines
Same for
domain->iopf_handler, the domain should be an argument if we are invoking the function on a domain.Perhaps
group->domainis a simple answer.
Yes. I will add domain in fault group and make it part of the parameters of the callback.
Best regards,
baolu