Add iommufd nesting (part 2/2)
Subsystems (5)
v9 cover Add iommufd nesting (part 2/2)
Nested translation is a hardware feature that is supported by many modern IOMMU hardwares. It has two stages (stage-1, stage-2) address translation to get access to the physical address. stage-1 translation table is owned by userspace (e.g. by a guest OS), while stage-2 is owned by kernel. Changes to stage-1 translation table should be followed by an IOTLB invalidation.
Take Intel VT-d as an example, the stage-1 translation table is I/O page table. As the below diagram shows, guest I/O page table pointer in GPA (guest physical address) is passed to host and be used to perform the stage-1 address translation. Along with it, modifications to present mappings in the guest I/O page table should be followed with an IOTLB invalidation.
.-------------. .---------------------------.
| vIOMMU | | Guest I/O page table |
| | '---------------------------' .----------------/
| PASID Entry |--- PASID cache flush --+
'-------------' |
| | V
| | I/O page table pointer in GPA
'-------------'
Guest
------| Shadow |---------------------------|--------
v v v
Host
.-------------. .------------------------.
| pIOMMU | | FS for GIOVA->GPA |
| | '------------------------'
.----------------/ |
| PASID Entry | V (Nested xlate)
'----------------\.----------------------------------.
| | | SS for GPA->HPA, unmanaged domain|
| | '----------------------------------'
'-------------'Where:
- FS = First stage page tables
- SS = Second stage page tables
<Intel VT-d Nested translation>
This series is based on the first part which was merged [1], this series is to add the cache invalidation interface or the userspace to invalidate cache after modifying the stage-1 page table. This includes both the iommufd changes and the VT-d driver changes.
Complete code can be found in [2], QEMU could can be found in [3].
At last, this is a team work together with Nicolin Chen, Lu Baolu. Thanks them for the help. ^_^. Look forward to your feedbacks.
[1] https://lore.kernel.org/linux-iommu/[email protected]/ - merged
[2] https://github.com/yiliu1765/iommufd/tree/iommufd_nesting
[3] https://github.com/yiliu1765/qemu/tree/zhenzhong/wip/iommufd_nesting_rfcv1
Change log:
v9:
- Add a test case which sets both IOMMU_TEST_INVALIDATE_FLAG_ALL and IOMMU_TEST_INVALIDATE_FLAG_TRIGGER_ERROR in flags, and expect to succeed and see an 'error'. (Kevin)
- Returns -ETIMEOUT in qi_check_fault() if caller is interested with the fault when timeout happens. If not, the qi_submit_sync() will keep retry hence unable to report the error back to user. For now, only the user cache invalidation path has interest on the time out error. So this change only affects the user cache invalidation path. Other path will still hang in qi_submit_sync() when timeout happens. (Kevin)
v8: https://lore.kernel.org/linux-iommu/[email protected]/
- Pass invalidation hint to the cache invalidation helper in the cache_invalidate_user op path (Kevin)
- Move the devTLB invalidation out of info->iommu loop (Kevin, Weijiang)
- Clear *fault per restart in qi_submit_sync() to avoid acroos submission error accumulation. (Kevin)
- Define the vtd cache invalidation uapi structure in separate patch (Kevin)
- Rename inv_error to be hw_error (Kevin)
- Rename 'reqs_uptr', 'req_type', 'req_len' and 'req_num' to be 'data_uptr', 'data_type', "entry_len' and 'entry_num" (Kevin)
- Allow user to set IOMMU_TEST_INVALIDATE_FLAG_ALL and IOMMU_TEST_INVALIDATE_FLAG_TRIGGER_ERROR in the same time (Kevin)
v7: https://lore.kernel.org/linux-iommu/[email protected]/
- Remove domain->ops->cache_invalidate_user check in hwpt alloc path due to failure in bisect (Baolu)
- Remove out_driver_error_code from struct iommu_hwpt_invalidate after discussion in v6. Should expect per-entry error code.
- Rework the selftest cache invalidation part to report a per-entry error
- Allow user to pass in an empty array to have a try-and-fail mechanism for user to check if a given req_type is supported by the kernel (Jason)
- Define a separate enum type for cache invalidation data (Jason)
- Fix the IOMMU_HWPT_INVALIDATE to always update the req_num field before returning (Nicolin)
- Merge the VT-d nesting part 2/2
https://lore.kernel.org/linux-iommu/[email protected]/
into this series to avoid defining empty enum in the middle of the series. The major difference is adding the VT-d related invalidation uapi structures together with the generic data structures in patch 02 of this series.
- VT-d driver was refined to report ICE/ITE error from the bottom cache invalidation submit helpers, hence the cache_invalidate_user op could report such errors via the per-entry error field to user. VT-d driver will not stop the invalidation array walking due to the ICE/ITE errors as such errors are defined by VT-d spec, userspace should be able to handle it and let the real user (say Virtual Machine) know about it. But for other errors like invalid uapi data structure configuration, memory copy failure, such errors should stop the array walking as it may have more issues if go on.
- Minor fixes per Jason and Kevin's review comments
v6: https://lore.kernel.org/linux-iommu/[email protected]/
- No much change, just rebase on top of 6.7-rc1 as part 1/2 is merged
v5: https://lore.kernel.org/linux-iommu/[email protected]/#t
- Split the iommufd nesting series into two parts of alloc_user and invalidation (Jason)
- Split IOMMUFD_OBJ_HW_PAGETABLE to IOMMUFD_OBJ_HWPT_PAGING/_NESTED, and do the same with the structures/alloc()/abort()/destroy(). Reworked the selftest accordingly too. (Jason)
- Move hwpt/data_type into struct iommu_user_data from standalone op arguments. (Jason)
- Rename hwpt_type to be data_type, the HWPT_TYPE to be HWPT_ALLOC_DATA, _TYPE_DEFAULT to be _ALLOC_DATA_NONE (Jason, Kevin)
- Rename iommu_copy_user_data() to iommu_copy_struct_from_user() (Kevin)
- Add macro to the iommu_copy_struct_from_user() to calculate min_size (Jason)
- Fix two bugs spotted by ZhaoYan
v4: https://lore.kernel.org/linux-iommu/[email protected]/
- Separate HWPT alloc/destroy/abort functions between user-managed HWPTs and kernel-managed HWPTs
- Rework invalidate uAPI to be a multi-request array-based design
- Add a struct iommu_user_data_array and a helper for driver to sanitize and copy the entry data from user space invalidation array
- Add a patch fixing TEST_LENGTH() in selftest program
- Drop IOMMU_RESV_IOVA_RANGES patches
- Update kdoc and inline comments
- Drop the code to add IOMMU_RESV_SW_MSI to kernel-managed HWPT in nested translation, this does not change the rule that resv regions should only be added to the kernel-managed HWPT. The IOMMU_RESV_SW_MSI stuff will be added in later series as it is needed only by SMMU so far.
v3: https://lore.kernel.org/linux-iommu/[email protected]/
- Add new uAPI things in alphabetical order
- Pass in "enum iommu_hwpt_type hwpt_type" to op->domain_alloc_user for sanity, replacing the previous op->domain_alloc_user_data_len solution
- Return ERR_PTR from domain_alloc_user instead of NULL
- Only add IOMMU_RESV_SW_MSI to kernel-managed HWPT in nested translation (Kevin)
- Add IOMMU_RESV_IOVA_RANGES to report resv iova ranges to userspace hence userspace is able to exclude the ranges in the stage-1 HWPT (e.g. guest I/O page table). (Kevin)
- Add selftest coverage for the new IOMMU_RESV_IOVA_RANGES ioctl
- Minor changes per Kevin's inputs
v2: https://lore.kernel.org/linux-iommu/[email protected]/
- Add union iommu_domain_user_data to include all user data structures to avoid passing void * in kernel APIs.
- Add iommu op to return user data length for user domain allocation
- Rename struct iommu_hwpt_alloc::data_type to be hwpt_type
- Store the invalidation data length in iommu_domain_ops::cache_invalidate_user_data_len
- Convert cache_invalidate_user op to be int instead of void
- Remove @data_type in struct iommu_hwpt_invalidate
- Remove out_hwpt_type_bitmap in struct iommu_hw_info hence drop patch 08 of v1
v1: https://lore.kernel.org/linux-iommu/[email protected]/
Thanks,
Yi Liu
Lu Baolu (4):
iommu: Add cache_invalidate_user op
iommu/vt-d: Allow qi_submit_sync() to return the QI faults iommu/vt-d: Convert stage-1 cache invalidation to return QI fault iommu/vt-d: Add iotlb flush for nested domain
Nicolin Chen (4):
iommu: Add iommu_copy_struct_from_user_array helper iommufd/selftest: Add mock_domain_cache_invalidate_user support iommufd/selftest: Add IOMMU_TEST_OP_MD_CHECK_IOTLB test op iommufd/selftest: Add coverage for IOMMU_HWPT_INVALIDATE ioctl
Yi Liu (2):
iommufd: Add IOMMU_HWPT_INVALIDATE
iommufd: Add data structure for Intel VT-d stage-1 cache invalidation
drivers/iommu/intel/dmar.c | 49 +++-- drivers/iommu/intel/iommu.c | 12 +- drivers/iommu/intel/iommu.h | 8 +- drivers/iommu/intel/irq_remapping.c | 2 +- drivers/iommu/intel/nested.c | 107 ++++++++++ drivers/iommu/intel/pasid.c | 14 +- drivers/iommu/intel/svm.c | 14 +- drivers/iommu/iommufd/hw_pagetable.c | 41 ++++ drivers/iommu/iommufd/iommufd_private.h | 10 + drivers/iommu/iommufd/iommufd_test.h | 39 ++++ drivers/iommu/iommufd/main.c | 3 + drivers/iommu/iommufd/selftest.c | 86 ++++++++ include/linux/iommu.h | 100 +++++++++ include/uapi/linux/iommufd.h | 101 ++++++++++ tools/testing/selftests/iommu/iommufd.c | 190 ++++++++++++++++++ tools/testing/selftests/iommu/iommufd_utils.h | 57 ++++++ 16 files changed, 794 insertions(+), 39 deletions(-)
Signature · 1 line
2.34.1
PATCH v9 1/10 iommu: Add cache_invalidate_user op
From: Lu Baolu <[email protected]>
The updates of the PTEs in the nested page table will be propagated to the hardware caches.
Add a new domain op cache_invalidate_user for the userspace to flush the hardware caches for a nested domain through iommufd. No wrapper for it, as it's only supposed to be used by iommufd. Then, pass in invalidation requests in form of a user data array conatining a number of invalidation data entries.
--- include/linux/iommu.h | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+)
include/linux/iommu.h +26 -0
@@ -284,6 +284,23 @@ struct iommu_user_data {size_t len; }; +/** +* struct iommu_user_data_array - iommu driver specific user space data array +* @type: The data type of all the entries in the user buffer array +* @uptr: Pointer to the user buffer array +* @entry_len: The fixed-width length of an entry in the array, in bytes +* @entry_num: The number of total entries in the array +* +* The user buffer includes an array of requests with format defined in +* include/uapi/linux/iommufd.h +*/ +struct iommu_user_data_array { +unsigned int type; +void __user *uptr; +size_t entry_len; +u32 entry_num; +}; +/** * __iommu_copy_struct_from_user - Copy iommu driver specific user space data * @dst_data: Pointer to an iommu driver specific user data that is defined in
@@ -440,6 +457,13 @@ struct iommu_ops {* @iotlb_sync_map: Sync mappings created recently using @map to the hardware * @iotlb_sync: Flush all queued ranges from the hardware TLBs and empty flush * queue +* @cache_invalidate_user: Flush hardware cache for user space IO page table. +* The @domain must be IOMMU_DOMAIN_NESTED. The @array +* passes in the cache invalidation requests, in form +* of a driver data structure. The driver must update +* array->entry_num to report the number of handled +* invalidation requests. The driver data structure +* must be defined in include/uapi/linux/iommufd.h * @iova_to_phys: translate iova to physical address * @enforce_cache_coherency: Prevent any kind of DMA from bypassing IOMMU_CACHE, * including no-snoop TLPs on PCIe or other platform
@@ -465,6 +489,8 @@ struct iommu_domain_ops { size_t size);void (*iotlb_sync)(struct iommu_domain *domain,struct iommu_iotlb_gather *iotlb_gather); +int (*cache_invalidate_user)(struct iommu_domain *domain, +struct iommu_user_data_array *array);phys_addr_t (*iova_to_phys)(struct iommu_domain *domain,dma_addr_t iova);
Signature · 1 line
2.34.1
PATCH v9 2/10 iommufd: Add IOMMU_HWPT_INVALIDATE
In reply to Yi LiuIn nested translation, the stage-1 page table is user-managed but cached by the IOMMU hardware, so an update on present page table entries in the stage-1 page table should be followed with a cache invalidation.
Add an IOMMU_HWPT_INVALIDATE ioctl to support such a cache invalidation. It takes hwpt_id to specify the iommu_domain, and a multi-entry array to support multiple invalidation data in one ioctl.
enum iommu_hwpt_invalidate_data_type is defined to tag the data type of the entries in the multi-entry array.
--- drivers/iommu/iommufd/hw_pagetable.c | 41 +++++++++++++++++++++++ drivers/iommu/iommufd/iommufd_private.h | 10 ++++++ drivers/iommu/iommufd/main.c | 3 ++ include/uapi/linux/iommufd.h | 43 +++++++++++++++++++++++++ 4 files changed, 97 insertions(+)
drivers/iommu/iommufd/hw_pagetable.c +41 -0
@@ -371,3 +371,44 @@ int iommufd_hwpt_get_dirty_bitmap(struct iommufd_ucmd *ucmd)iommufd_put_object (ucmd->ictx, &hwpt_paging->common.obj);return rc; } + +int iommufd_hwpt_invalidate (struct iommufd_ucmd *ucmd) +{ +struct iommu_hwpt_invalidate *cmd = ucmd->cmd; +struct iommu_user_data_array data_array = { + .type = cmd->data_type, + .uptr =u64_to_user_ptr (cmd->data_uptr), + .entry_len = cmd->entry_len, + .entry_num = cmd->entry_num, + }; +struct iommufd_hw_pagetable *hwpt; +u32 done_num =0 ; +int rc; + +if (cmd->__reserved) { + rc = -EOPNOTSUPP ; + goto out; + } + +if (cmd->entry_num && (!cmd->data_uptr || !cmd->entry_len)) { + rc = -EINVAL ; + goto out; + } + + hwpt =iommufd_get_hwpt_nested (ucmd, cmd->hwpt_id); +if (IS_ERR (hwpt)) { + rc =PTR_ERR (hwpt); + goto out; + } + + rc = hwpt->domain->ops->cache_invalidate_user (hwpt->domain, + &data_array); + done_num = data_array.entry_num; + +iommufd_put_object (ucmd->ictx, &hwpt->obj); +out: + cmd->entry_num = done_num; +if (iommufd_ucmd_respond (ucmd,sizeof (*cmd))) +return -EFAULT ; +return rc; +}
drivers/iommu/iommufd/iommufd_private.h +10 -0
@@ -328,6 +328,15 @@ iommufd_get_hwpt_paging(struct iommufd_ucmd *ucmd, u32 id) IOMMUFD_OBJ_HWPT_PAGING), struct iommufd_hwpt_paging, common.obj); } + +static inline struct iommufd_hw_pagetable * +iommufd_get_hwpt_nested (struct iommufd_ucmd *ucmd,u32 id) +{ +return container_of (iommufd_get_object (ucmd->ictx, id, +IOMMUFD_OBJ_HWPT_NESTED ), + struct iommufd_hw_pagetable, obj); +} +int iommufd_hwpt_set_dirty_tracking (struct iommufd_ucmd *ucmd);int iommufd_hwpt_get_dirty_bitmap (struct iommufd_ucmd *ucmd);
@@ -345,6 +354,7 @@ void iommufd_hwpt_paging_abort(struct iommufd_object *obj);void iommufd_hwpt_nested_destroy (struct iommufd_object *obj);void iommufd_hwpt_nested_abort (struct iommufd_object *obj);int iommufd_hwpt_alloc (struct iommufd_ucmd *ucmd); +int iommufd_hwpt_invalidate (struct iommufd_ucmd *ucmd);static inline void iommufd_hw_pagetable_put (struct iommufd_ctx *ictx,struct iommufd_hw_pagetable *hwpt)
drivers/iommu/iommufd/main.c +3 -0
@@ -322,6 +322,7 @@ union ucmd_buffer {struct iommu_hw_info info;struct iommu_hwpt_alloc hwpt;struct iommu_hwpt_get_dirty_bitmap get_dirty_bitmap; +struct iommu_hwpt_invalidate cache;struct iommu_hwpt_set_dirty_tracking set_dirty_tracking;struct iommu_ioas_alloc alloc;struct iommu_ioas_allow_iovas allow_iovas;
@@ -360,6 +361,8 @@ static const struct iommufd_ioctl_op iommufd_ioctl_ops[] = { __reserved),IOCTL_OP (IOMMU_HWPT_GET_DIRTY_BITMAP ,iommufd_hwpt_get_dirty_bitmap ,struct iommu_hwpt_get_dirty_bitmap ,data ), +IOCTL_OP (IOMMU_HWPT_INVALIDATE ,iommufd_hwpt_invalidate , +struct iommu_hwpt_invalidate ,__reserved ),IOCTL_OP (IOMMU_HWPT_SET_DIRTY_TRACKING ,iommufd_hwpt_set_dirty_tracking , struct iommu_hwpt_set_dirty_tracking, __reserved), IOCTL_OP(IOMMU_IOAS_ALLOC, iommufd_ioas_alloc_ioctl,
include/uapi/linux/iommufd.h +43 -0
53 lines not on this page · raw message
Signature · 1 line
2.34.1
PATCH v9 3/10 iommu: Add iommu_copy_struct_from_user_array helper
In reply to Yi LiuFrom: Nicolin Chen <[email protected]>
Wrap up the data pointer/num sanity and __iommu_copy_struct_from_user call for iommu drivers to copy driver specific data at a specific location in the struct iommu_user_data_array, and iommu_respond_struct_to_user_array() to copy response to a specific location in the struct iommu_user_data_array.
And expect it to be used in cache_invalidate_user ops for example.
--- include/linux/iommu.h | 74 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+)
include/linux/iommu.h +74 -0
@@ -341,6 +341,80 @@ static inline int __iommu_copy_struct_from_user( sizeof(*kdst), \ offsetofend(typeof(*kdst), min_last)) +/** +* __iommu_copy_struct_from_user_array - Copy iommu driver specific user space +* data from an iommu_user_data_array +* @dst_data: Pointer to an iommu driver specific user data that is defined in +* include/uapi/linux/iommufd.h +* @src_array: Pointer to a struct iommu_user_data_array for a user space array +* @data_type: The data type of the @dst_data. Must match with @src_array.type +* @index: Index to the location in the array to copy user data from +* @data_len: Length of current user data structure, i.e. sizeof(struct _dst) +* @min_len: Initial length of user data structure for backward compatibility. +* This should be offsetofend using the last member in the user data +* struct that was initially added to include/uapi/linux/iommufd.h +*/ +static inline int +__iommu_copy_struct_from_user_array (void *dst_data, +const struct iommu_user_data_array *src_array, +unsigned int data_type,unsigned int index, +size_t data_len,size_t min_len) +{ +struct iommu_user_data src_data; + +if (WARN_ON (!src_array || index >= src_array->entry_num)) +return -EINVAL ; +if (!src_array->entry_num) +return -EINVAL ; + src_data.uptr = src_array->uptr + src_array->entry_len * index; + src_data.len = src_array->entry_len; + src_data.type = src_array->type; + +return __iommu_copy_struct_from_user (dst_data, &src_data, data_type, + data_len, min_len); +} + +/** +* iommu_copy_struct_from_user_array - Copy iommu driver specific user space +* data from an iommu_user_data_array +* @kdst: Pointer to an iommu driver specific user data that is defined in +* include/uapi/linux/iommufd.h +* @user_array: Pointer to a struct iommu_user_data_array for a user space +* array +* @data_type: The data type of the @kdst. Must match with @user_array->type +* @index: Index to the location in the array to copy user data from +* @min_last: The last memember of the data structure @kdst points in the +* initial version. +* Return 0 for success, otherwise -error. +*/ +#define iommu_copy_struct_from_user_array (kdst, user_array, data_type, \ + index, min_last) \ + __iommu_copy_struct_from_user_array(kdst, user_array, data_type, \ + index, sizeof(*kdst), \ + offsetofend(typeof(*kdst), \ + min_last)) + +/** +* iommu_respond_struct_to_user_array - Copy the response in @ksrc back to +* a specific entry of user array +* @user_array: Pointer to a struct iommu_user_data_array for a user space +* array +* @index: Index to the location in the array to copy response +* @ksrc: Pointer to kernel structure +* @klen: Length of @ksrc struct +* +* This only copies response of one entry (@index) in @user_array. +*/ +static inline int +iommu_respond_struct_to_user_array (const struct iommu_user_data_array *array, +unsigned int index,void *ksrc,size_t klen) +{ +if (copy_to_user (array->uptr + array->entry_len * index, + ksrc,min_t (size_t, array->entry_len, klen))) +return -EFAULT ; +return 0 ; +} +/** * struct iommu_ops - iommu ops and capabilities * @capable: check capability
Signature · 1 line
2.34.1
PATCH v9 4/10 iommufd/selftest: Add mock_domain_cache_invalidate_user support
In reply to Yi LiuFrom: Nicolin Chen <[email protected]>
Add mock_domain_cache_invalidate_user() data structure to support user space selftest program to cover user cache invalidation pathway.
--- drivers/iommu/iommufd/iommufd_test.h | 34 ++++++++++++++++ drivers/iommu/iommufd/selftest.c | 60 ++++++++++++++++++++++++++++ 2 files changed, 94 insertions(+)
drivers/iommu/iommufd/iommufd_test.h +34 -0
@@ -148,4 +148,38 @@ struct iommu_hwpt_selftest { __u32 iotlb; }; +/* Should not be equal to any defined value in enum iommu_hwpt_invalidate_data_type */ +#define IOMMU_HWPT_INVALIDATE_DATA_SELFTEST 0xdeadbeef +#define IOMMU_HWPT_INVALIDATE_DATA_SELFTEST_INVALID 0xdadbeef + +/** +* enum iommu_hwpt_invalidate_selftest_error - Hardware error of invalidation +* @IOMMU_TEST_INVALIDATE_FAKE_ERROR: Fake hw error per test program's request +*/ +enum iommu_hwpt_invalidate_selftest_error { +IOMMU_TEST_INVALIDATE_FAKE_ERROR = (1 <<0 ) +}; + +/** +* struct iommu_hwpt_invalidate_selftest - Invalidation data for Mock driver +* (IOMMU_HWPT_INVALIDATE_DATA_SELFTEST) +* @flags: Invalidate flags +* @iotlb_id: Invalidate iotlb entry index +* @hw_error: One of enum iommu_hwpt_invalidate_selftest_error +* @__reserved: Must be 0 +* +* If IOMMU_TEST_INVALIDATE_ALL is set in @flags, @iotlb_id will be ignored +* @hw_error meaningful only if the request is processed successfully. +* If IOMMU_TEST_INVALIDATE_FLAG_TRIGGER_ERROR is set in @flags, report a +* hw error back, cache would not be invalidated in this case. +*/ +struct iommu_hwpt_invalidate_selftest { +#define IOMMU_TEST_INVALIDATE_FLAG_ALL (1 << 0) +#define IOMMU_TEST_INVALIDATE_FLAG_TRIGGER_ERROR (1 << 1) +__u32 flags; +__u32 iotlb_id; +__u32 hw_error; +__u32 __reserved; +}; +#endif
drivers/iommu/iommufd/selftest.c +60 -0
69 lines not on this page · raw message
Signature · 1 line
2.34.1
PATCH v9 5/10 iommufd/selftest: Add IOMMU_TEST_OP_MD_CHECK_IOTLB test op
In reply to Yi LiuFrom: Nicolin Chen <[email protected]>
Allow to test whether IOTLB has been invalidated or not.
--- drivers/iommu/iommufd/iommufd_test.h | 5 ++++ drivers/iommu/iommufd/selftest.c | 26 +++++++++++++++++++ tools/testing/selftests/iommu/iommufd.c | 4 +++ tools/testing/selftests/iommu/iommufd_utils.h | 24 +++++++++++++++++ 4 files changed, 59 insertions(+)
drivers/iommu/iommufd/iommufd_test.h +5 -0
@@ -21,6 +21,7 @@ enum {IOMMU_TEST_OP_ACCESS_REPLACE_IOAS ,IOMMU_TEST_OP_MOCK_DOMAIN_FLAGS ,IOMMU_TEST_OP_DIRTY , + IOMMU_TEST_OP_MD_CHECK_IOTLB, }; enum {
@@ -121,6 +122,10 @@ struct iommu_test_cmd {__aligned_u64 uptr;__aligned_u64 out_nr_dirty; } dirty; +struct { +__u32 id; +__u32 iotlb; + } check_iotlb; };__u32 last; };
drivers/iommu/iommufd/selftest.c +26 -0
@@ -853,6 +853,28 @@ static int iommufd_test_md_check_refs(struct iommufd_ucmd *ucmd,return 0 ; } +static int iommufd_test_md_check_iotlb (struct iommufd_ucmd *ucmd, +u32 mockpt_id,unsigned int iotlb_id, +u32 iotlb) +{ +struct mock_iommu_domain_nested *mock_nested; +struct iommufd_hw_pagetable *hwpt; +int rc =0 ; + + hwpt =get_md_pagetable_nested (ucmd, mockpt_id, &mock_nested); +if (IS_ERR (hwpt)) +return PTR_ERR (hwpt); + + mock_nested =container_of (hwpt->domain, + struct mock_iommu_domain_nested, domain); + +if (iotlb_id >MOCK_NESTED_DOMAIN_IOTLB_ID_MAX || + mock_nested->iotlb[iotlb_id] != iotlb) + rc = -EINVAL ; +iommufd_put_object (ucmd->ictx, &hwpt->obj); +return rc; +} +struct selftest_access {struct iommufd_access *access;struct file *file;
@@ -1334,6 +1356,10 @@ int iommufd_test(struct iommufd_ucmd *ucmd)return iommufd_test_md_check_refs ( ucmd,u64_to_user_ptr (cmd->check_refs.uptr), cmd->check_refs.length, cmd->check_refs.refs); +case IOMMU_TEST_OP_MD_CHECK_IOTLB : +return iommufd_test_md_check_iotlb (ucmd, cmd->id, + cmd->check_iotlb.id, + cmd->check_iotlb.iotlb);case IOMMU_TEST_OP_CREATE_ACCESS :return iommufd_test_create_access (ucmd, cmd->id, cmd->create_access.flags);
tools/testing/selftests/iommu/iommufd.c +4 -0
@@ -330,6 +330,10 @@ TEST_F(iommufd_ioas, alloc_hwpt_nested) &nested_hwpt_id[1 ],IOMMU_HWPT_DATA_SELFTEST , &data, sizeof(data)); +test_cmd_hwpt_check_iotlb_all (nested_hwpt_id[0 ], +IOMMU_TEST_IOTLB_DEFAULT ); +test_cmd_hwpt_check_iotlb_all (nested_hwpt_id[1 ], +IOMMU_TEST_IOTLB_DEFAULT );/* Negative test: a nested hwpt on top of a nested hwpt */ test_err_hwpt_alloc_nested(EINVAL, self->device_id,
tools/testing/selftests/iommu/iommufd_utils.h +24 -0
@@ -195,6 +195,30 @@ static int _test_cmd_hwpt_alloc(int fd, __u32 device_id, __u32 pt_id, _test_cmd_hwpt_alloc(self->fd, device_id, pt_id, flags, \ hwpt_id, data_type, data, data_len)) +#define test_cmd_hwpt_check_iotlb (hwpt_id, iotlb_id, expected) \ + ({ \ + struct iommu_test_cmd test_cmd = { \ + .size = sizeof(test_cmd), \ + .op = IOMMU_TEST_OP_MD_CHECK_IOTLB, \ + .id = hwpt_id, \ + .check_iotlb = { \ + .id = iotlb_id, \ + .iotlb = expected, \ + }, \ + }; \ + ASSERT_EQ(0, \ + ioctl(self->fd, \ + _IOMMU_TEST_CMD(IOMMU_TEST_OP_MD_CHECK_IOTLB), \ + &test_cmd)); \ + }) + +#define test_cmd_hwpt_check_iotlb_all (hwpt_id, expected) \ + ({ \ + int i; \ + for (i = 0; i < MOCK_NESTED_DOMAIN_IOTLB_NUM; i++) \ + test_cmd_hwpt_check_iotlb(hwpt_id, i, expected); \ + }) +static int _test_cmd_access_replace_ioas (int fd,__u32 access_id,unsigned int ioas_id) {
Signature · 1 line
2.34.1
PATCH v9 6/10 iommufd/selftest: Add coverage for IOMMU_HWPT_INVALIDATE ioctl
In reply to Yi LiuFrom: Nicolin Chen <[email protected]>
Add test cases for the IOMMU_HWPT_INVALIDATE ioctl and verify it by using the new IOMMU_TEST_OP_MD_CHECK_IOTLB.
--- tools/testing/selftests/iommu/iommufd.c | 186 ++++++++++++++++++ tools/testing/selftests/iommu/iommufd_utils.h | 33 ++++ 2 files changed, 219 insertions(+)
tools/testing/selftests/iommu/iommufd.c +186 -0
@@ -116,6 +116,7 @@ TEST_F(iommufd, cmd_length)TEST_LENGTH (iommu_destroy,IOMMU_DESTROY , id);TEST_LENGTH (iommu_hw_info,IOMMU_GET_HW_INFO , __reserved);TEST_LENGTH (iommu_hwpt_alloc,IOMMU_HWPT_ALLOC , __reserved); +TEST_LENGTH (iommu_hwpt_invalidate,IOMMU_HWPT_INVALIDATE , __reserved);TEST_LENGTH (iommu_ioas_alloc,IOMMU_IOAS_ALLOC , out_ioas_id);TEST_LENGTH (iommu_ioas_iova_ranges,IOMMU_IOAS_IOVA_RANGES , out_iova_alignment);
@@ -271,7 +272,9 @@ TEST_F(iommufd_ioas, alloc_hwpt_nested)struct iommu_hwpt_selftest data = { .iotlb =IOMMU_TEST_IOTLB_DEFAULT , }; +struct iommu_hwpt_invalidate_selftest inv_reqs[2 ] = {};uint32_t nested_hwpt_id[2 ] = {}; +uint32_t num_inv;uint32_t parent_hwpt_id =0 ;uint32_t parent_hwpt_id_not_work =0 ;uint32_t test_hwpt_id =0 ;
@@ -344,6 +347,189 @@ TEST_F(iommufd_ioas, alloc_hwpt_nested)EXPECT_ERRNO (EBUSY ,_test_ioctl_destroy (self->fd, parent_hwpt_id)); +/* hwpt_invalidate only supports a user-managed hwpt (nested) */ + num_inv =1 ; +test_err_hwpt_invalidate (ENOENT , parent_hwpt_id, inv_reqs, +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST , +sizeof (*inv_reqs), &num_inv); +assert (!num_inv); + +/* Check data_type by passing zero-length array */ + num_inv =0 ; +test_cmd_hwpt_invalidate (nested_hwpt_id[0 ], inv_reqs, +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST , +sizeof (*inv_reqs), &num_inv); +assert (!num_inv); + +/* Negative test: Invalid data_type */ + num_inv =1 ; +test_err_hwpt_invalidate (EINVAL , nested_hwpt_id[0 ], inv_reqs, +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST_INVALID , +sizeof (*inv_reqs), &num_inv); +assert (!num_inv); + +/* Negative test: structure size sanity */ + num_inv =1 ; +test_err_hwpt_invalidate (EINVAL , nested_hwpt_id[0 ], inv_reqs, +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST , +sizeof (*inv_reqs) +1 , &num_inv); +assert (!num_inv); + + num_inv =1 ; +test_err_hwpt_invalidate (EINVAL , nested_hwpt_id[0 ], inv_reqs, +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST , +1 , &num_inv); +assert (!num_inv); + +/* Negative test: invalid flag is passed */ + num_inv =1 ; + inv_reqs[0 ].flags =0xffffffff ; +test_err_hwpt_invalidate (EOPNOTSUPP , nested_hwpt_id[0 ], inv_reqs, +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST , +sizeof (*inv_reqs), &num_inv); +assert (!num_inv); + +/* Negative test: non-zero __reserved is passed */ + num_inv =1 ; + inv_reqs[0 ].flags =0 ; + inv_reqs[0 ].__reserved =0x1234 ; +test_err_hwpt_invalidate (EOPNOTSUPP , nested_hwpt_id[0 ], inv_reqs, +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST , +sizeof (*inv_reqs), &num_inv); +assert (!num_inv); + +/* Negative test: invalid data_uptr when array is not empty */ + num_inv =1 ; + inv_reqs[0 ].flags =0 ; +test_err_hwpt_invalidate (EINVAL , nested_hwpt_id[0 ],NULL , +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST , +sizeof (*inv_reqs), &num_inv); +assert (!num_inv); + +/* Negative test: invalid entry_len when array is not empty */ + num_inv =1 ; + inv_reqs[0 ].flags =0 ; +test_err_hwpt_invalidate (EINVAL , nested_hwpt_id[0 ], inv_reqs, +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST , +0 , &num_inv); +assert (!num_inv); + +/* Negative test: invalid iotlb_id */ + num_inv =1 ; + inv_reqs[0 ].flags =0 ; + inv_reqs[0 ].__reserved =0 ; + inv_reqs[0 ].iotlb_id =MOCK_NESTED_DOMAIN_IOTLB_ID_MAX +1 ; +test_err_hwpt_invalidate (EINVAL , nested_hwpt_id[0 ], inv_reqs, +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST , +sizeof (*inv_reqs), &num_inv); +assert (!num_inv); + +/* Negative test: trigger error */ + num_inv =1 ; + inv_reqs[0 ].flags =IOMMU_TEST_INVALIDATE_FLAG_TRIGGER_ERROR ; + inv_reqs[0 ].iotlb_id =0 ; +test_cmd_hwpt_invalidate (nested_hwpt_id[0 ], inv_reqs, +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST , +sizeof (*inv_reqs), &num_inv); +assert (num_inv ==1 ); +assert (inv_reqs[0 ].hw_error ==IOMMU_TEST_INVALIDATE_FAKE_ERROR ); + +/* Negative test: trigger error with ALL flag set */ + num_inv =1 ; + inv_reqs[0 ].flags =IOMMU_TEST_INVALIDATE_FLAG_TRIGGER_ERROR | +IOMMU_TEST_INVALIDATE_FLAG_ALL ; + inv_reqs[0 ].iotlb_id =0 ; +test_cmd_hwpt_invalidate (nested_hwpt_id[0 ], inv_reqs, +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST , +sizeof (*inv_reqs), &num_inv); +assert (num_inv ==1 ); +assert (inv_reqs[0 ].hw_error ==IOMMU_TEST_INVALIDATE_FAKE_ERROR ); + +/* +* Invalidate the 1st iotlb entry but fail the 2nd request +* - mock driver error, the hw_error field is meaningful, +* the ioctl returns 0. +*/ + num_inv =2 ; + inv_reqs[0 ].flags =0 ; + inv_reqs[0 ].iotlb_id =0 ; + inv_reqs[1 ].flags =IOMMU_TEST_INVALIDATE_FLAG_TRIGGER_ERROR ; + inv_reqs[1 ].iotlb_id =1 ; +test_cmd_hwpt_invalidate (nested_hwpt_id[0 ], inv_reqs, +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST , +sizeof (*inv_reqs), &num_inv); +assert (num_inv ==2 ); +assert (!inv_reqs[0 ].hw_error); +assert (inv_reqs[1 ].hw_error ==IOMMU_TEST_INVALIDATE_FAKE_ERROR ); +test_cmd_hwpt_check_iotlb (nested_hwpt_id[0 ],0 ,0 ); +test_cmd_hwpt_check_iotlb (nested_hwpt_id[0 ],1 , +IOMMU_TEST_IOTLB_DEFAULT ); +test_cmd_hwpt_check_iotlb (nested_hwpt_id[0 ],2 , +IOMMU_TEST_IOTLB_DEFAULT ); +test_cmd_hwpt_check_iotlb (nested_hwpt_id[0 ],3 , +IOMMU_TEST_IOTLB_DEFAULT ); + +/* +* Invalidate the 1st iotlb entry but fail the 2nd request +* - ioctl error, the hw_error field is meaningless +*/ + num_inv =2 ; + inv_reqs[0 ].flags =0 ; + inv_reqs[0 ].iotlb_id =0 ; + inv_reqs[1 ].flags =0 ; + inv_reqs[1 ].iotlb_id =MOCK_NESTED_DOMAIN_IOTLB_ID_MAX +1 ; +test_err_hwpt_invalidate (EINVAL , nested_hwpt_id[0 ], inv_reqs, +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST , +sizeof (*inv_reqs), &num_inv); +assert (num_inv ==1 ); +assert (!inv_reqs[0 ].hw_error); +test_cmd_hwpt_check_iotlb (nested_hwpt_id[0 ],0 ,0 ); +test_cmd_hwpt_check_iotlb (nested_hwpt_id[0 ],1 , +IOMMU_TEST_IOTLB_DEFAULT ); +test_cmd_hwpt_check_iotlb (nested_hwpt_id[0 ],2 , +IOMMU_TEST_IOTLB_DEFAULT ); +test_cmd_hwpt_check_iotlb (nested_hwpt_id[0 ],3 , +IOMMU_TEST_IOTLB_DEFAULT ); + +/* Invalidate the 2nd iotlb entry and verify */ + num_inv =1 ; + inv_reqs[0 ].flags =0 ; + inv_reqs[0 ].iotlb_id =1 ; +test_cmd_hwpt_invalidate (nested_hwpt_id[0 ], inv_reqs, +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST , +sizeof (*inv_reqs), &num_inv); +assert (!inv_reqs[0 ].hw_error); +test_cmd_hwpt_check_iotlb (nested_hwpt_id[0 ],0 ,0 ); +test_cmd_hwpt_check_iotlb (nested_hwpt_id[0 ],1 ,0 ); +test_cmd_hwpt_check_iotlb (nested_hwpt_id[0 ],2 , +IOMMU_TEST_IOTLB_DEFAULT ); +test_cmd_hwpt_check_iotlb (nested_hwpt_id[0 ],3 , +IOMMU_TEST_IOTLB_DEFAULT ); + +/* Invalidate the 3rd and 4th iotlb entries and verify */ + num_inv =2 ; + inv_reqs[0 ].flags =0 ; + inv_reqs[0 ].iotlb_id =2 ; + inv_reqs[1 ].flags =0 ; + inv_reqs[1 ].iotlb_id =3 ; +test_cmd_hwpt_invalidate (nested_hwpt_id[0 ], inv_reqs, +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST , +sizeof (*inv_reqs), &num_inv); +assert (num_inv ==2 ); +assert (!inv_reqs[0 ].hw_error); +assert (!inv_reqs[1 ].hw_error); +test_cmd_hwpt_check_iotlb_all (nested_hwpt_id[0 ],0 ); + +/* Invalidate all iotlb entries for nested_hwpt_id[1] and verify */ + num_inv =1 ; + inv_reqs[0 ].flags =IOMMU_TEST_INVALIDATE_FLAG_ALL ; +test_cmd_hwpt_invalidate (nested_hwpt_id[1 ], inv_reqs, +IOMMU_HWPT_INVALIDATE_DATA_SELFTEST , +sizeof (*inv_reqs), &num_inv); +assert (num_inv ==1 ); +assert (!inv_reqs[0 ].hw_error); +test_cmd_hwpt_check_iotlb_all (nested_hwpt_id[1 ],0 ); +/* Attach device to nested_hwpt_id[0] that then will be busy */ test_cmd_mock_domain_replace (self->stdev_id, nested_hwpt_id[0 ]); EXPECT_ERRNO(EBUSY,
tools/testing/selftests/iommu/iommufd_utils.h +33 -0
@@ -219,6 +219,39 @@ static int _test_cmd_hwpt_alloc(int fd, __u32 device_id, __u32 pt_id,test_cmd_hwpt_check_iotlb (hwpt_id, i, expected); \ }) +static int _test_cmd_hwpt_invalidate (int fd,__u32 hwpt_id,void *reqs, +uint32_t data_type,uint32_t lreq, +uint32_t *nreqs) +{ +struct iommu_hwpt_invalidate cmd = { + .size =sizeof (cmd), + .hwpt_id = hwpt_id, + .data_type = data_type, + .data_uptr = (uint64_t )reqs, + .entry_len = lreq, + .entry_num = *nreqs, + }; +int rc =ioctl (fd,IOMMU_HWPT_INVALIDATE , &cmd); + *nreqs = cmd.entry_num; +return rc; +} + +#define test_cmd_hwpt_invalidate (hwpt_id, reqs, data_type, lreq, nreqs) \ + ({ \ + ASSERT_EQ(0, \ + _test_cmd_hwpt_invalidate(self->fd, hwpt_id, reqs, \ + data_type, \ + lreq, nreqs)); \ + }) +#define test_err_hwpt_invalidate (_errno, hwpt_id, reqs, data_type, lreq, \ + nreqs) \ + ({ \ + EXPECT_ERRNO(_errno, \ + _test_cmd_hwpt_invalidate(self->fd, hwpt_id, \ + reqs, data_type, \ + lreq, nreqs)); \ + }) +static int _test_cmd_access_replace_ioas (int fd,__u32 access_id,unsigned int ioas_id) {
Signature · 1 line
2.34.1
PATCH v9 7/10 iommu/vt-d: Allow qi_submit_sync() to return the QI faults
In reply to Yi LiuFrom: Lu Baolu <[email protected]>
This allows qi_submit_sync() to return back faults to callers.
--- drivers/iommu/intel/dmar.c | 42 ++++++++++++++++++++--------- drivers/iommu/intel/iommu.h | 2 +- drivers/iommu/intel/irq_remapping.c | 2 +- drivers/iommu/intel/pasid.c | 2 +- drivers/iommu/intel/svm.c | 6 ++--- 5 files changed, 36 insertions(+), 18 deletions(-)
drivers/iommu/intel/dmar.c +30 -12
@@ -1267,7 +1267,8 @@ static void qi_dump_fault(struct intel_iommu *iommu, u32 fault) (unsigned long long)desc->qw1); } -static int qi_check_fault (struct intel_iommu *iommu,int index,int wait_index) +static int qi_check_fault (struct intel_iommu *iommu,int index, +int wait_index,u32 *fsts) {u32 fault;int head, tail;
@@ -1278,8 +1279,12 @@ static int qi_check_fault(struct intel_iommu *iommu, int index, int wait_index)return -EAGAIN ; fault =readl (iommu->reg +DMAR_FSTS_REG ); -if (fault & (DMA_FSTS_IQE |DMA_FSTS_ITE |DMA_FSTS_ICE )) + fault &=DMA_FSTS_IQE |DMA_FSTS_ITE |DMA_FSTS_ICE ; +if (fault) { +if (fsts) + *fsts |= fault;qi_dump_fault (iommu, fault); + }/* * If IQE happens, the head points to the descriptor associated
@@ -1324,7 +1329,15 @@ static int qi_check_fault(struct intel_iommu *iommu, int index, int wait_index) head = (head -2 +QI_LENGTH ) %QI_LENGTH ; }while (head != tail); -if (qi->desc_status[wait_index] ==QI_ABORT ) +if (qi->desc_status[wait_index] ==QI_ABORT ) { +/* +* If the caller is interested in the error, no need +* to retry, just return the time out error to the +* caller. +*/ +if (fsts) +return -ETIMEDOUT ; + }return -EAGAIN ; }
@@ -1342,9 +1355,11 @@ static int qi_check_fault(struct intel_iommu *iommu, int index, int wait_index)* time, a wait descriptor will be appended to each submission to ensure * hardware has completed the invalidation before return. Wait descriptors * can be part of the submission but it will not be polled for completion. +* If callers are interested in the QI faults that occur during the handling +* of requests, the QI faults are saved in @fault. */ int qi_submit_sync (struct intel_iommu *iommu,struct qi_desc *desc, -unsigned int count,unsigned long options) +unsigned int count,unsigned long options,u32 *fault) {struct q_inval *qi = iommu->qi;s64 devtlb_start_ktime =0 ;
@@ -1422,6 +1437,9 @@ int qi_submit_sync(struct intel_iommu *iommu, struct qi_desc *desc,*/ writel (qi->free_head << shift, iommu->reg +DMAR_IQT_REG ); +if (fault) + *fault =0 ; +while (qi->desc_status[wait_index] !=QI_DONE ) {/* * We will leave the interrupts disabled, to prevent interrupt
@@ -1430,7 +1448,7 @@ int qi_submit_sync(struct intel_iommu *iommu, struct qi_desc *desc,* a deadlock where the interrupt context can wait indefinitely * for free slots in the queue. */ - rc =qi_check_fault (iommu, index, wait_index); + rc =qi_check_fault (iommu, index, wait_index, fault);if (rc)break ;
@@ -1476,7 +1494,7 @@ void qi_global_iec(struct intel_iommu *iommu) desc.qw3 =0 ;/* should never fail */ -qi_submit_sync (iommu, &desc,1 ,0 ); +qi_submit_sync (iommu, &desc,1 ,0 ,NULL ); } void qi_flush_context(struct intel_iommu *iommu, u16 did, u16 sid, u8 fm,
@@ -1490,7 +1508,7 @@ void qi_flush_context(struct intel_iommu *iommu, u16 did, u16 sid, u8 fm, desc.qw2 =0 ; desc.qw3 =0 ; -qi_submit_sync (iommu, &desc,1 ,0 ); +qi_submit_sync (iommu, &desc,1 ,0 ,NULL ); } void qi_flush_iotlb(struct intel_iommu *iommu, u16 did, u64 addr,
@@ -1514,7 +1532,7 @@ void qi_flush_iotlb(struct intel_iommu *iommu, u16 did, u64 addr, desc.qw2 =0 ; desc.qw3 =0 ; -qi_submit_sync (iommu, &desc,1 ,0 ); +qi_submit_sync (iommu, &desc,1 ,0 ,NULL ); } void qi_flush_dev_iotlb(struct intel_iommu *iommu, u16 sid, u16 pfsid,
@@ -1545,7 +1563,7 @@ void qi_flush_dev_iotlb(struct intel_iommu *iommu, u16 sid, u16 pfsid, desc.qw2 =0 ; desc.qw3 =0 ; -qi_submit_sync (iommu, &desc,1 ,0 ); +qi_submit_sync (iommu, &desc,1 ,0 ,NULL ); }/* PASID-based IOTLB invalidation */
@@ -1586,7 +1604,7 @@ void qi_flush_piotlb(struct intel_iommu *iommu, u16 did, u32 pasid, u64 addr,QI_EIOTLB_AM (mask); } -qi_submit_sync (iommu, &desc,1 ,0 ); +qi_submit_sync (iommu, &desc,1 ,0 ,NULL ); }/* PASID-based device IOTLB Invalidate */
@@ -1639,7 +1657,7 @@ void qi_flush_dev_iotlb_pasid(struct intel_iommu *iommu, u16 sid, u16 pfsid, desc.qw1 |=QI_DEV_EIOTLB_SIZE ; } -qi_submit_sync (iommu, &desc,1 ,0 ); +qi_submit_sync (iommu, &desc,1 ,0 ,NULL ); } void qi_flush_pasid_cache(struct intel_iommu *iommu, u16 did,
@@ -1649,7 +1667,7 @@ void qi_flush_pasid_cache(struct intel_iommu *iommu, u16 did, desc.qw0 =QI_PC_PASID (pasid) |QI_PC_DID (did) |QI_PC_GRAN (granu) |QI_PC_TYPE ; -qi_submit_sync (iommu, &desc,1 ,0 ); +qi_submit_sync (iommu, &desc,1 ,0 ,NULL ); }/*
drivers/iommu/intel/iommu.h +1 -1
@@ -881,7 +881,7 @@ void qi_flush_pasid_cache(struct intel_iommu *iommu, u16 did, u64 granu, u32 pasid);int qi_submit_sync (struct intel_iommu *iommu,struct qi_desc *desc, -unsigned int count,unsigned long options); +unsigned int count,unsigned long options,u32 *fault);/* * Options used in qi_submit_sync: * QI_OPT_WAIT_DRAIN - Wait for PRQ drain completion, spec 6.5.2.8.
drivers/iommu/intel/irq_remapping.c +1 -1
@@ -153,7 +153,7 @@ static int qi_flush_iec(struct intel_iommu *iommu, int index, int mask) desc.qw2 =0 ; desc.qw3 =0 ; -return qi_submit_sync (iommu, &desc,1 ,0 ); +return qi_submit_sync (iommu, &desc,1 ,0 ,NULL ); } static int modify_irte(struct irq_2_iommu *irq_iommu,
drivers/iommu/intel/pasid.c +1 -1
@@ -467,7 +467,7 @@ pasid_cache_invalidation_with_pasid(struct intel_iommu *iommu, desc.qw2 =0 ; desc.qw3 =0 ; -qi_submit_sync (iommu, &desc,1 ,0 ); +qi_submit_sync (iommu, &desc,1 ,0 ,NULL ); } static void
drivers/iommu/intel/svm.c +3 -3
@@ -543,7 +543,7 @@ void intel_drain_pasid_prq(struct device *dev, u32 pasid)QI_DEV_IOTLB_PFSID (info->pfsid); qi_retry:reinit_completion (&iommu->prq_complete); -qi_submit_sync (iommu, desc,3 ,QI_OPT_WAIT_DRAIN ); +qi_submit_sync (iommu, desc,3 ,QI_OPT_WAIT_DRAIN ,NULL );if (readl (iommu->reg +DMAR_PRS_REG ) &DMA_PRS_PRO ) {wait_for_completion (&iommu->prq_complete); goto qi_retry;
@@ -646,7 +646,7 @@ static void handle_bad_prq_event(struct intel_iommu *iommu, desc.qw3 =0 ; } -qi_submit_sync (iommu, &desc,1 ,0 ); +qi_submit_sync (iommu, &desc,1 ,0 ,NULL ); }static irqreturn_t prq_event_thread (int irq,void *d)
@@ -811,7 +811,7 @@ int intel_svm_page_response(struct device *dev, ktime_to_ns(ktime_get()) - prm->private_data[0]); } -qi_submit_sync (iommu, &desc,1 ,0 ); +qi_submit_sync (iommu, &desc,1 ,0 ,NULL ); } out:return ret;
Signature · 1 line
2.34.1
RE: [PATCH v9 07/10] iommu/vt-d: Allow qi_submit_sync() to return the QI faults
Quoted 6 lines
From: Liu, Yi L <[email protected]>
Sent: Thursday, December 28, 2023 11:06 PMFrom: Lu Baolu <[email protected]>
This allows
qi_submit_sync()to return back faults to callers.
this might be useful to add a note that the retry logic itself is being discussed in a separate thread [1]. Here we keep it intact and just make sure no retry for the newly added user domain cache invalidation.
[1] https://lore.kernel.org/all/[email protected]/
drivers/iommu/intel/dmar.c static int qi_check_fault(struct intel_iommu *iommu, int index, int wait_index) · line 1341
Quoted 12 lines
drivers/iommu/intel/dmar.c +9
-1-if (qi->desc_status[wait_index] ==QI_ABORT ) +if (qi->desc_status[wait_index] ==QI_ABORT ) { +/* +* If the caller is interested in the error, no need +* to retry, just return the time out error to the +* caller. +*/ +if (fsts) +return -ETIMEDOUT ; + }return -EAGAIN ;
indent should be adjusted and it changes the original logic which returns -EAGAIN only if QI_ABORT is set for the wait_index.
the simpler form is:
/* No need to retry if the caller is interested in the timeout error */ if (qi->desc_status[wait_index] == QI_ABORT) return fsts ? -ETIMEDOUT : -EAGAIN;
otherwise,
Re: [PATCH v9 07/10] iommu/vt-d: Allow qi_submit_sync() to return the QI faults
Quoted 14 lines · Kevin
Quoted 6 lines
From: Liu, Yi L <[email protected]>
Sent: Thursday, December 28, 2023 11:06 PMFrom: Lu Baolu <[email protected]>
This allows
qi_submit_sync()to return back faults to callers.this might be useful to add a note that the retry logic itself is being discussed in a separate thread [1]. Here we keep it intact and just make sure no retry for the newly added user domain cache invalidation.
[1] https://lore.kernel.org/all/[email protected]/
Quoted 1 line
Quoted 14 lines
drivers/iommu/intel/dmar.c static int qi_check_fault(struct intel_iommu *iommu, int index, int wait_index) · line 1341
Quoted 11 lines
drivers/iommu/intel/dmar.c +9
-1-if (qi->desc_status[wait_index] ==QI_ABORT ) +if (qi->desc_status[wait_index] ==QI_ABORT ) { +/* +* If the caller is interested in the error, no need +* to retry, just return the time out error to the +* caller. +*/ +if (fsts) +return -ETIMEDOUT ; + }return -EAGAIN ;indent should be adjusted and it changes the original logic which returns
-EAGAINonly ifQI_ABORTis set for thewait_index.
oops. this is a mistake. :) '}' should be after 'return -EAGAIN'
Quoted 9 lines
the simpler form is:
/* No need to retry if the caller is interested in the timeout error */ if (qi->desc_status[wait_index] == QI_ABORT) return fsts ? -ETIMEDOUT : -EAGAIN;otherwise,
Reviewed-by Kevin Tian <[email protected]>
sure.
Signature · 2 lines
Regards, Yi Liu
PATCH v9 8/10 iommu/vt-d: Convert stage-1 cache invalidation to return QI fault
In reply to Yi LiuFrom: Lu Baolu <[email protected]>
This makes the pasid based cache invalidation and device TLB invalidation to return QI faults to callers. This is needed when usersapce invalidates cache after modifying the stage-1 page table used in nested translation. Hardware errors during invalidation should be reported to user.
--- drivers/iommu/intel/dmar.c | 13 +++++++------ drivers/iommu/intel/iommu.c | 12 ++++++------ drivers/iommu/intel/iommu.h | 6 +++--- drivers/iommu/intel/pasid.c | 12 +++++++----- drivers/iommu/intel/svm.c | 8 ++++---- 5 files changed, 27 insertions(+), 24 deletions(-)
drivers/iommu/intel/dmar.c +7 -6
@@ -1536,7 +1536,7 @@ void qi_flush_iotlb(struct intel_iommu *iommu, u16 did, u64 addr, }void qi_flush_dev_iotlb (struct intel_iommu *iommu,u16 sid,u16 pfsid, -u16 qdep,u64 addr,unsigned mask) +u16 qdep,u64 addr,unsigned mask,u32 *fault) {struct qi_desc desc;
@@ -1563,12 +1563,12 @@ void qi_flush_dev_iotlb(struct intel_iommu *iommu, u16 sid, u16 pfsid, desc.qw2 =0 ; desc.qw3 =0 ; -qi_submit_sync (iommu, &desc,1 ,0 ,NULL ); +qi_submit_sync (iommu, &desc,1 ,0 , fault); }/* PASID-based IOTLB invalidation */ void qi_flush_piotlb (struct intel_iommu *iommu,u16 did,u32 pasid,u64 addr, -unsigned long npages,bool ih) +unsigned long npages,bool ih,u32 *fault) {struct qi_desc desc = {.qw2 =0 , .qw3 =0 };
@@ -1604,12 +1604,13 @@ void qi_flush_piotlb(struct intel_iommu *iommu, u16 did, u32 pasid, u64 addr,QI_EIOTLB_AM (mask); } -qi_submit_sync (iommu, &desc,1 ,0 ,NULL ); +qi_submit_sync (iommu, &desc,1 ,0 , fault); }/* PASID-based device IOTLB Invalidate */ void qi_flush_dev_iotlb_pasid (struct intel_iommu *iommu,u16 sid,u16 pfsid, -u32 pasid,u16 qdep,u64 addr,unsigned int size_order) +u32 pasid,u16 qdep,u64 addr, +unsigned int size_order,u32 *fault) {unsigned long mask =1UL << (VTD_PAGE_SHIFT + size_order -1 );struct qi_desc desc = {.qw1 =0 , .qw2 =0 , .qw3 =0 };
@@ -1657,7 +1658,7 @@ void qi_flush_dev_iotlb_pasid(struct intel_iommu *iommu, u16 sid, u16 pfsid, desc.qw1 |=QI_DEV_EIOTLB_SIZE ; } -qi_submit_sync (iommu, &desc,1 ,0 ,NULL ); +qi_submit_sync (iommu, &desc,1 ,0 , fault); } void qi_flush_pasid_cache(struct intel_iommu *iommu, u16 did,
drivers/iommu/intel/iommu.c +6 -6
@@ -1462,7 +1462,7 @@ static void __iommu_flush_dev_iotlb(struct device_domain_info *info, sid = info->bus <<8 | info->devfn; qdep = info->ats_qdep;qi_flush_dev_iotlb (info->iommu, sid, info->pfsid, - qdep, addr, mask); + qdep, addr, mask,NULL );quirk_extra_dev_tlb_flush (info, addr, mask,IOMMU_NO_PASID , qdep); }
@@ -1490,7 +1490,7 @@ static void iommu_flush_dev_iotlb(struct dmar_domain *domain,PCI_DEVID (info->bus, info->devfn), info->pfsid, dev_pasid->pasid, info->ats_qdep, addr, - mask); + mask, NULL); }spin_unlock_irqrestore (&domain->lock, flags); }
@@ -1505,10 +1505,10 @@ static void domain_flush_pasid_iotlb(struct intel_iommu *iommu,spin_lock_irqsave (&domain->lock, flags);list_for_each_entry (dev_pasid, &domain->dev_pasids, link_domain) -qi_flush_piotlb (iommu, did, dev_pasid->pasid, addr, npages, ih); +qi_flush_piotlb (iommu, did, dev_pasid->pasid, addr, npages, ih,NULL );if (!list_empty (&domain->devices)) -qi_flush_piotlb (iommu, did,IOMMU_NO_PASID , addr, npages, ih); +qi_flush_piotlb (iommu, did,IOMMU_NO_PASID , addr, npages, ih,NULL );spin_unlock_irqrestore (&domain->lock, flags); }
@@ -5195,10 +5195,10 @@ void quirk_extra_dev_tlb_flush(struct device_domain_info *info, sid =PCI_DEVID (info->bus, info->devfn);if (pasid ==IOMMU_NO_PASID ) {qi_flush_dev_iotlb (info->iommu, sid, info->pfsid, - qdep, address, mask); + qdep, address, mask,NULL ); }else {qi_flush_dev_iotlb_pasid (info->iommu, sid, info->pfsid, - pasid, qdep, address, mask); + pasid, qdep, address, mask,NULL ); } }
drivers/iommu/intel/iommu.h +3 -3
@@ -866,14 +866,14 @@ void qi_flush_context(struct intel_iommu *iommu, u16 did,void qi_flush_iotlb (struct intel_iommu *iommu,u16 did,u64 addr,unsigned int size_order,u64 type);void qi_flush_dev_iotlb (struct intel_iommu *iommu,u16 sid,u16 pfsid, -u16 qdep,u64 addr,unsigned mask); +u16 qdep,u64 addr,unsigned mask,u32 *fault);void qi_flush_piotlb (struct intel_iommu *iommu,u16 did,u32 pasid,u64 addr, -unsigned long npages,bool ih); +unsigned long npages,bool ih,u32 *fault);void qi_flush_dev_iotlb_pasid (struct intel_iommu *iommu,u16 sid,u16 pfsid,u32 pasid,u16 qdep,u64 addr, -unsigned int size_order); +unsigned int size_order,u32 *fault);void quirk_extra_dev_tlb_flush (struct device_domain_info *info,unsigned long address,unsigned long pages,u32 pasid,u16 qdep);
drivers/iommu/intel/pasid.c +7 -5
@@ -492,9 +492,11 @@ devtlb_invalidation_with_pasid(struct intel_iommu *iommu,* efficient to flush devTLB specific to the PASID. */ if (pasid ==IOMMU_NO_PASID ) -qi_flush_dev_iotlb (iommu, sid, pfsid, qdep,0 ,64 -VTD_PAGE_SHIFT ); +qi_flush_dev_iotlb (iommu, sid, pfsid, qdep,0 , +64 -VTD_PAGE_SHIFT ,NULL );else -qi_flush_dev_iotlb_pasid (iommu, sid, pfsid, pasid, qdep,0 ,64 -VTD_PAGE_SHIFT ); +qi_flush_dev_iotlb_pasid (iommu, sid, pfsid, pasid, qdep,0 , +64 -VTD_PAGE_SHIFT ,NULL ); } void intel_pasid_tear_down_entry(struct intel_iommu *iommu, struct device *dev,
@@ -521,7 +523,7 @@ void intel_pasid_tear_down_entry(struct intel_iommu *iommu, struct device *dev,pasid_cache_invalidation_with_pasid (iommu, did, pasid);if (pgtt ==PASID_ENTRY_PGTT_PT || pgtt ==PASID_ENTRY_PGTT_FL_ONLY ) -qi_flush_piotlb (iommu, did, pasid,0 ,-1 ,0 ); +qi_flush_piotlb (iommu, did, pasid,0 ,-1 ,0 ,NULL );else iommu->flush.flush_iotlb (iommu, did,0 ,0 ,DMA_TLB_DSI_FLUSH );
@@ -543,7 +545,7 @@ static void pasid_flush_caches(struct intel_iommu *iommu,if (cap_caching_mode (iommu->cap)) {pasid_cache_invalidation_with_pasid (iommu, did, pasid); -qi_flush_piotlb (iommu, did, pasid,0 ,-1 ,0 ); +qi_flush_piotlb (iommu, did, pasid,0 ,-1 ,0 ,NULL ); }else {iommu_flush_write_buffer (iommu); }
@@ -834,7 +836,7 @@ void intel_pasid_setup_page_snoop_control(struct intel_iommu *iommu,* Addr[63:12]=0x7FFFFFFF_FFFFF) to affected functions */ pasid_cache_invalidation_with_pasid (iommu, did, pasid); -qi_flush_piotlb (iommu, did, pasid,0 ,-1 ,0 ); +qi_flush_piotlb (iommu, did, pasid,0 ,-1 ,0 ,NULL );/* Device IOTLB doesn't need to be flushed in caching mode. */ if (!cap_caching_mode (iommu->cap))
drivers/iommu/intel/svm.c +4 -4
@@ -179,11 +179,11 @@ static void __flush_svm_range_dev(struct intel_svm *svm,if (WARN_ON (!pages))return ; -qi_flush_piotlb (sdev->iommu, sdev->did, svm->pasid, address, pages, ih); +qi_flush_piotlb (sdev->iommu, sdev->did, svm->pasid, address, pages, ih,NULL );if (info->ats_enabled) {qi_flush_dev_iotlb_pasid (sdev->iommu, sdev->sid, info->pfsid, svm->pasid, sdev->qdep, address, -order_base_2 (pages)); +order_base_2 (pages),NULL );quirk_extra_dev_tlb_flush (info, address,order_base_2 (pages), svm->pasid, sdev->qdep); }
@@ -225,11 +225,11 @@ static void intel_flush_svm_all(struct intel_svm *svm)list_for_each_entry_rcu (sdev, &svm->devs, list) { info =dev_iommu_priv_get (sdev->dev); -qi_flush_piotlb (sdev->iommu, sdev->did, svm->pasid,0 ,-1UL ,0 ); +qi_flush_piotlb (sdev->iommu, sdev->did, svm->pasid,0 ,-1UL ,0 ,NULL );if (info->ats_enabled) {qi_flush_dev_iotlb_pasid (sdev->iommu, sdev->sid, info->pfsid, svm->pasid, sdev->qdep, -0 ,64 -VTD_PAGE_SHIFT ); +0 ,64 -VTD_PAGE_SHIFT ,NULL );quirk_extra_dev_tlb_flush (info,0 ,64 -VTD_PAGE_SHIFT , svm->pasid, sdev->qdep); }
Signature · 1 line
2.34.1
PATCH v9 9/10 iommufd: Add data structure for Intel VT-d stage-1 cache invalidation
In reply to Yi LiuThis adds the data structure invalidating caches for the nested domain allocated with IOMMU_HWPT_DATA_VTD_S1 type.
--- include/uapi/linux/iommufd.h | 58 ++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+)
include/uapi/linux/iommufd.h +58 -0
@@ -623,6 +623,64 @@ enum iommu_hwpt_invalidate_data_type { IOMMU_HWPT_INVALIDATE_DATA_VTD_S1, }; +/** +* enum iommu_hwpt_vtd_s1_invalidate_flags - Flags for Intel VT-d +* stage-1 cache invalidation +* @IOMMU_VTD_INV_FLAGS_LEAF: Indicates whether the invalidation applies +* to all-levels page structure cache or just +* the leaf PTE cache. +*/ +enum iommu_hwpt_vtd_s1_invalidate_flags { +IOMMU_VTD_INV_FLAGS_LEAF =1 <<0 , +}; + +/** +* enum iommu_hwpt_vtd_s1_invalidate_error - Hardware error of invalidation +* @IOMMU_HWPT_INVALIDATE_VTD_S1_ICE: Invalidation Completion Error, details +* refer to 11.4.7.1 Fault Status Register +* of VT-d specification. +* @IOMMU_HWPT_INVALIDATE_VTD_S1_ITE: Invalidation Time-out Error, details +* refer to 11.4.7.1 Fault Status Register +* of VT-d specification. +*/ +enum iommu_hwpt_vtd_s1_invalidate_error { +IOMMU_HWPT_INVALIDATE_VTD_S1_ICE =1 <<0 , +IOMMU_HWPT_INVALIDATE_VTD_S1_ITE =1 <<1 , +}; + +/** +* struct iommu_hwpt_vtd_s1_invalidate - Intel VT-d cache invalidation +* (IOMMU_HWPT_INVALIDATE_DATA_VTD_S1) +* @addr: The start address of the range to be invalidated. It needs to +* be 4KB aligned. +* @npages: Number of contiguous 4K pages to be invalidated. +* @flags: Combination of enum iommu_hwpt_vtd_s1_invalidate_flags +* @hw_error: One of enum iommu_hwpt_vtd_s1_invalidate_error +* +* The Intel VT-d specific invalidation data for user-managed stage-1 cache +* invalidation in nested translation. Userspace uses this structure to +* tell the impacted cache scope after modifying the stage-1 page table. +* +* Invalidating all the caches related to the page table by setting @addr +* to be 0 and @npages to be U64_MAX. +* +* The device TLB will be invalidated automatically if ATS is enabled. +* +* An entry is considered 'handled' after it passes the audit and submitted +* to the IOMMU by the underlying driver. Check the @entry_num output of +* struct iommu_hwpt_invalidate for the number of handled entries. A 'handled' +* request may still fail in hardware for various reasons, e.g. due to timeout +* on waiting for device response upon a device TLB invalidation request. In +* such case the hardware error info is reported in the @hw_error field of the +* handled entry. +*/ +struct iommu_hwpt_vtd_s1_invalidate { +__aligned_u64 addr; +__aligned_u64 npages; +__u32 flags; +__u32 hw_error; +}; +/** * struct iommu_hwpt_invalidate - ioctl(IOMMU_HWPT_INVALIDATE) * @size: sizeof(struct iommu_hwpt_invalidate)
Signature · 1 line
2.34.1
PATCH v9 10/10 iommu/vt-d: Add iotlb flush for nested domain
In reply to Yi LiuFrom: Lu Baolu <[email protected]>
This implements the .cache_invalidate_user() callback to support iotlb flush for nested domain.
--- drivers/iommu/intel/nested.c | 107 +++++++++++++++++++++++++++++++++++ 1 file changed, 107 insertions(+)
drivers/iommu/intel/nested.c +107 -0
@@ -73,9 +73,116 @@ static void intel_nested_domain_free(struct iommu_domain *domain)kfree (to_dmar_domain (domain)); } +static void nested_flush_dev_iotlb (struct dmar_domain *domain,u64 addr, +unsigned mask,u32 *fault) +{ +struct device_domain_info *info; +unsigned long flags; +u16 sid, qdep; + +spin_lock_irqsave (&domain->lock, flags); +list_for_each_entry (info, &domain->devices, link) { +if (!info->ats_enabled) +continue ; + sid = info->bus <<8 | info->devfn; + qdep = info->ats_qdep; +qi_flush_dev_iotlb (info->iommu, sid, info->pfsid, + qdep, addr, mask, fault); +quirk_extra_dev_tlb_flush (info, addr, mask, +IOMMU_NO_PASID , qdep); + } +spin_unlock_irqrestore (&domain->lock, flags); +} + +static void intel_nested_flush_cache (struct dmar_domain *domain,u64 addr, +unsigned long npages,bool ih,u32 *error) +{ +struct iommu_domain_info *info; +unsigned long i; +unsigned mask; +u32 fault; + +xa_for_each (&domain->iommu_array, i, info) +qi_flush_piotlb (info->iommu, +domain_id_iommu (domain, info->iommu), +IOMMU_NO_PASID , addr, npages, ih,NULL ); + +if (!domain->has_iotlb_device) +return ; + +if (npages ==U64_MAX ) + mask =64 -VTD_PAGE_SHIFT ; +else + mask =ilog2 (__roundup_pow_of_two (npages)); + +nested_flush_dev_iotlb (domain, addr, mask, &fault); + + *error =0 ; +/* +* Invalidation queue error (i.e. IQE) will not be reported to user +* as it's caused only by driver internal bug. +*/ +if (fault &DMA_FSTS_ICE ) + *error |=IOMMU_HWPT_INVALIDATE_VTD_S1_ICE ; +if (fault &DMA_FSTS_ITE ) + *error |=IOMMU_HWPT_INVALIDATE_VTD_S1_ITE ; +} + +static int intel_nested_cache_invalidate_user (struct iommu_domain *domain, +struct iommu_user_data_array *array) +{ +struct dmar_domain *dmar_domain =to_dmar_domain (domain); +struct iommu_hwpt_vtd_s1_invalidate inv_entry; +u32 processed =0 ; +int ret =0 ; +u32 index; + +if (array->type !=IOMMU_HWPT_INVALIDATE_DATA_VTD_S1 ) { + ret = -EINVAL ; + goto out; + } + +for (index =0 ; index < array->entry_num; index++) { + ret =iommu_copy_struct_from_user_array (&inv_entry, array, +IOMMU_HWPT_INVALIDATE_DATA_VTD_S1 , + index, hw_error); +if (ret) +break ; + +if (inv_entry.flags & ~IOMMU_VTD_INV_FLAGS_LEAF ) { + ret = -EOPNOTSUPP ; +break ; + } + +if (!IS_ALIGNED (inv_entry.addr,VTD_PAGE_SIZE ) || + ((inv_entry.npages ==U64_MAX ) && inv_entry.addr)) { + ret = -EINVAL ; +break ; + } + +intel_nested_flush_cache (dmar_domain, inv_entry.addr, + inv_entry.npages, + inv_entry.flags &IOMMU_VTD_INV_FLAGS_LEAF , + &inv_entry.hw_error); + + ret =iommu_respond_struct_to_user_array (array, index, + (void *)&inv_entry, +sizeof (inv_entry)); +if (ret) +break ; + + processed++; + } + +out: + array->entry_num = processed; +return ret; +} +static const struct iommu_domain_ops intel_nested_domain_ops = { .attach_dev = intel_nested_attach_dev, .free = intel_nested_domain_free, + .cache_invalidate_user = intel_nested_cache_invalidate_user, }; struct iommu_domain *intel_nested_domain_alloc(struct iommu_domain *parent,
Signature · 1 line
2.34.1
RE: [PATCH v9 10/10] iommu/vt-d: Add iotlb flush for nested domain
Quoted 11 lines
From: Liu, Yi L <[email protected]>
Sent: Thursday, December 28, 2023 11:06 PMFrom: Lu Baolu <[email protected]>
This implements the .cache_invalidate_user() callback to support iotlb flush for nested domain.
Signed-off-by Lu Baolu <[email protected]>Co-developed-by Yi Liu <[email protected]>Signed-off-by Yi Liu <[email protected]>
Tian, Kevin
maintainerQuoted 15 lines
From: Liu, Yi L <[email protected]>
Sent: Thursday, December 28, 2023 11:06 PMThis series is based on the first part which was merged [1], this series is to add the cache invalidation interface or the userspace to invalidate cache after
modifying the stage-1 page table. This includes both the iommufd changes and the
VT-d driver changes.Complete code can be found in [2], QEMU could can be found in [3].
At last, this is a team work together with Nicolin Chen, Lu Baolu. Thanks them for the help. ^_^. Look forward to your feedbacks.
Quoted 7 lines
[1] https://lore.kernel.org/linux-iommu/20231026044216.64964-1-
[email protected]/ - merged
[2] https://github.com/yiliu1765/iommufd/tree/iommufd_nesting
[3]
https://github.com/yiliu1765/qemu/tree/zhenzhong/wip/iommufd_nesting_
rfcv1
this looks good to me now, except a few minor comments to patch7.
let's see whether Jason may have a chance to look in his holiday and if ok whether he wants to see a new version or just change it while committing.
Quoted 23 lines · Kevin
Quoted 15 lines
From: Liu, Yi L <[email protected]>
Sent: Thursday, December 28, 2023 11:06 PMThis series is based on the first part which was merged [1], this series is to add the cache invalidation interface or the userspace to invalidate cache after
modifying the stage-1 page table. This includes both the iommufd changes and the
VT-d driver changes.Complete code can be found in [2], QEMU could can be found in [3].
At last, this is a team work together with Nicolin Chen, Lu Baolu. Thanks them for the help. ^_^. Look forward to your feedbacks.
Quoted 4 lines
this looks good to me now, except a few minor comments to patch7.
let's see whether Jason may have a chance to look in his holiday and if ok whether he wants to see a new version or just change it while committing.
anyhow, I've updated it in below branch.
https://github.com/yiliu1765/iommufd/tree/iommufd_nesting
Signature · 2 lines
Regards, Yi Liu