Add vfio_device cdev for iommufd support
Subsystems (19)
v15 cover Add vfio_device cdev for iommufd support
Existing VFIO provides group-centric user APIs for userspace. Userspace opens the /dev/vfio/$group_id first before getting device fd and hence getting access to device. This is not the desired model for iommufd. Per the conclusion of community discussion[1], iommufd provides device-centric kAPIs and requires its consumer (like VFIO) to be device-centric user APIs. Such user APIs are used to associate device with iommufd and also the I/O address spaces managed by the iommufd.
This series first introduces a per device file structure to be prepared for further enhancement and refactors the kvm-vfio code to be prepared for accepting device file from userspace. After this, adds a mechanism for blocking device access before iommufd bind. Then refactors the vfio to be able to handle cdev paths (e.g. iommufd binding, no-iommufd, [de]attach ioas). This refactor includes making the device_open exclusive between the group and the cdev path, only allow single device open in cdev path; vfio-iommufd code is also refactored to support cdev. e.g. split the vfio_iommufd_bind() into two steps. Eventually, adds the cdev support for vfio device and the new ioctls, then makes group infrastructure optional as it is not needed when vfio device cdev is compiled.
This series is based on some preparation works done to vfio emulated devices[2] and vfio pci hot reset enhancements[3]. Per discussion[4], this series does not support cdev for physical devices that do not have IOMMU. Such devices only have group-centric user APIs.
This series is a prerequisite for iommu nesting for vfio device[5] [6].
The complete code can be found in below branch, simple tests done to the legacy group path and the cdev path. QEMU changes are in upstreaming[7] and the complete code can be found at[8]
https://github.com/yiliu1765/iommufd/tree/vfio_device_cdev_v15
(config CONFIG_IOMMUFD=y CONFIG_VFIO_DEVICE_CDEV=y)
base-commit: fdf0eaf11452d72945af31804e2a1048ee1b574c
[1] https://lore.kernel.org/kvm/BN9PR11MB5433B1E4AE5B0480369F97178C189@BN9PR11MB5433.namprd11.prod.outlook.com/
[2] https://lore.kernel.org/kvm/[email protected]/ - merged
[3] https://lore.kernel.org/kvm/[email protected]/
[4] https://lore.kernel.org/kvm/[email protected]/
[5] https://lore.kernel.org/linux-iommu/[email protected]/
[6] https://lore.kernel.org/linux-iommu/[email protected]/#t
[7] https://lore.kernel.org/qemu-devel/[email protected]/
[8] https://github.com/yiliu1765/qemu/tree/zhenzhong/iommufd_rfcv4
Change log:
v15:
- Add Jason's r-b to patch 14, 17, 19, 21, 23, 24 and 26 of cdev v14
- Tweak the iommufd_ctx_from_fd() in patch 20 per Jason's suggestion (Jason)
- Return -ENOTTY in vfio_df_ioctl_bind_iommufd() stub function (Jason)
- Add t-b from Zhenzhong (wrote a selftest app to verify functions of this patchset by referencing https://github.com/awilliam/tests/)
v14: https://lore.kernel.org/kvm/[email protected]/
- Add Jason's r-b to patch 10, 11, 12, 13, 15, 16, 17 and 23 of cdev v12
- Refine iommufd_access_detach() (Jason)
- Split the device_del() movement to be a separate patch (Jason)
- Move kvm !null test into _vfio_device_get_kvm_safe() to save some lines and rename it to be vfio_device_get_kvm_safe() (Jason)
- Make VFIO_DEVICE_CDEV depending on !SPAPR_TCE_IOMMU to suit the fact that SPAPR_TCE_IOMMU does not support cdev (Alex)
- Add iommufd_ctx_from_fd() to replace vfio_get_iommufd_from_fd() (Jason)
- Check cdev only ioctls in vfio_device_fops_unl_ioctl() (Jason)
- patch 17, 19, 20 and 21 of v14 is newly added per above review comemnts.
v13: https://lore.kernel.org/kvm/[email protected]/
- vfio_device_first_open() and vfio_device_last_close() to be vfio_df_device_first_open() vfio_df_device_last_close() (Alex)
- Define struct vfio_device_file::access_granted as u8 and also place the u32 devid to be behind this flag as this structure access is hot, so needs to avoid too much hole in the structure (Alex)
- Use u8 instead bool in the struct vfio_device for the flags (Alex)
- Define BIND, ATTACH, DETACH ioctl behind VFIO_DEVICE_FEATURE whose offset is 17 (Alex)
- Drop patch 20, 21, 22 of v12 (Alex)
- Per the patch drop, still needs to detect the physical devices that do not have IOMMU in the cdev registration as cdev does not support such devices. Per the suggestion from Jason, lift the IOMMU_CAP_CACHE_COHERENCY check to be in vfio_main.c so that it can fail the registration of such devices if only cdev is compiled. (Jason, Alex)
- Refine the vfio.rst doc, highlight that the cdev device access is stil bound with iommu group. (Alex)
- Reaffirm t-b from below folks:
Nicolin Chen - Test nesting branch which is based on cdev v12, the test is done on ARM64 (SMMUv3) Matthew Rosato - vfio-pci, vfio-ap, vfio-ccw under container, compat and cdev mode, and nesting
test on SMMUv3 and Intel.
Yanting Jiang - regression tests with NIC passthrough on Intel platform
v12: https://lore.kernel.org/kvm/[email protected]/#r
- Rename vfio_device_xx() to be vfio_df_xx() if the object is vfio_device_file (Alex)
- Refine patch 10 of v11 (Alex)
- Add new device ioctls from offset 18 (Alex)
- Add a patch to check group->type for noiommu test, no need to check CONFIG_VFIO_NOIOMMU (Alex)
- Refine the logic of vfio_device_set_noiommu() per Alex's suggestion. The noiommu taint is moved to __vfio_register_dev(), also add a check on group type before calling vfio_device_set_noiommu() as only physical device can be noiommu device.
- Drop noiommu support for cdev, patch 16 of v11 is dropped, the related changes are in patch 17 - 24 of this series.
v11: https://lore.kernel.org/kvm/[email protected]/
- Add back the noiommu determination at vfio device registration patch and put it prior to compiling vfio_group code optionally as compiling vfio_group optionaly is the major reason for it.
- Fix a typo related to SPAPR (Cédric Le Goater)
- Add t-b from Shameerali Kolothum Thodi, tested on HiSilicon D06(ARM64) platform with a NIC pass-through
v10: https://lore.kernel.org/kvm/[email protected]/
- Drop patch 03 of v9 as vfio_file_is_group() is still needed by pci hot reset path
- Drop 11 of v9 per the change of noiommu support
- Move patch 18 of v9 to hot-reset series [3]
- vfio_file_has_device_access() is dropped as no usage now (hot-reset does not accept device fd, hence no need for this helper)
- Minor change to patch 02, mainly make it back to patch v2 of v6 which is before splitting hot-reset series
- Minor change in 10 and 11 due to rebase
- Functional changes in patch 19, 20 and 21 per the latest noiommu support policy. noiommu device can be bound to valid iommufd now, this is different from the prior policy in which noiommu device is not allowed to be bound to valid iommufd. So may pay more attention on the three patches, previous r-b and t-b are dropped for these three patches.
v9: https://lore.kernel.org/kvm/[email protected]/
- Use smp_load_acquire() in vfio_file_has_device_access() for df->access_granted (Alex)
- Fix lock init in patch 16 of v8 (Jon Pan-Doh)
- Split patch 20 of v8 (Alex)
- Refine noiommu logic in BIND_IOMMUFD (Alex)
- Remove dev_cookie in BIND_IOMMUFD ioctl (Alex, Jason)
- Remove static_assert in ATTACH/DETACH ioctl handling (Alex)
- Remove device->ops->bind_iommufd presence check in BIND_IOMMUFD/ATTACH/DETACH handling (Alex)
- Remove VFIO dependecny for VFIO_CONTAINER as VFIO_GROUP should imply it (Alex)
- Improve the documentation per suggestions from Alex on patch 24 of v8 (Alex)
- Remove WARN_ON(df->group) in vfio_device_group_uses_container() of patch 11
- Add r-b from Kevin to patch 18/19 of v8
- Add r-b from Jason to patch 03/10/11 of v8
- Add t-b from Yanting Jiang and Nicolin Chen
v8: https://lore.kernel.org/kvm/[email protected]/
- Add patch 18 to determine noiommu device at vfio_device registration (Jason)
- Add patch 19 to name noiommu device with "noiommu-" prefix to be par with group path
- Add r-b from Kevin
- Add t-b from Terrence
v7: https://lore.kernel.org/kvm/[email protected]/
- Split the vfio-pci hot reset changes to be separate patch series (Jason, Kevin)
- More polish on no-iommufd support (patch 11 - 13) in cdev path (Kevin)
- iommufd_access_detach() in patch 16 is added by Nic for emulated devices (Kevin, Jason)
v6: https://lore.kernel.org/kvm/[email protected]/#t
- Add r-b from Jason on patch 01 - 08 and 13 in v5
- Based on the prerequisite mini-series which makes vfio emulated devices be prepared to cdev (Jason)
- Add the approach to pass a set of device fds to do hot reset ownership check, while the zero-length array approach is also kept. (Jason, Kevin, Alex)
- Drop patch 10 of v5, it is reworked by patch 13 and 17 in v6 (Jason)
- Store vfio_group pointer in vfio_device_file to check if user is using legacy vfio container (Jason)
- Drop the is_cdev_device flag (introduced in patch 14 of v5) as the group pointer stored in vfio_device_file can cover it.
- Add iommu_group check in the cdev no-iommu path patch 24 (Kevin)
- Add t-b from Terrence, Nicolin and Matthew (thanks for the help, some patches are new in this version, so I just added t-b to the patches that are also in v5 and no big change, for others would add in this version).
v5: https://lore.kernel.org/kvm/[email protected]/
- Add r-b from Kevin on patch 08, 13, 14, 15 and 17.
- Rename patch 02 to limit the change for KVM facing kAPIs. The vfio pci hot reset path only accepts group file until patch 09. (Kevin)
- Update comment around smp_load_acquire(&df->access_granted) (Yan)
- Adopt Jason's suggestion on the vfio pci hot reset path, passing zero-length fd array to indicate using bound iommufd_ctx as ownership check. (Jason, Kevin)
- Direct read df->access_granted value in vfio_device_cdev_close() (Kevin, Yan, Jason)
- Wrap the iommufd get/put into a helper to refine the error path of vfio_device_ioctl_bind_iommufd(). (Yan)
v4: https://lore.kernel.org/kvm/[email protected]/
- Add r-b from Kevin on patch 09/10
- Add a line in devices/vfio.rst to emphasize user should add group/device to KVM prior to invoke open_device op which may be called in the VFIO_GROUP_GET_DEVICE_FD or VFIO_DEVICE_BIND_IOMMUFD ioctl.
- Modify VFIO_GROUP/VFIO_DEVICE_CDEV Kconfig dependency (Alex)
- Select VFIO_GROUP for SPAPR (Jason)
- Check device fully-opened in PCI hotreset path for device fd (Jason)
- Set df->access_granted in the caller of vfio_device_open() since
the caller may fail in other operations, but df->access_granted
does not allow a true to false change. So it should be set only when
the open path is really done successfully. (Yan, Kevin)
- Fix missing iommufd_ctx_put() in the cdev path (Yan)
- Fix an issue found in testing exclusion between group and cdev path. vfio_device_cdev_close() should check df->access_granted before heading to other operations.
- Update vfio.rst for iommufd/cdev
v3: https://lore.kernel.org/kvm/[email protected]/
- Add r-b from Kevin on patch 03, 06, 07, 08.
- Refine the group and cdev path exclusion. Remove vfio_device:single_open; add vfio_group::cdev_device_open_cnt to achieve exlucsion between group path and cdev path (Kevin, Jason)
- Fix a bug in the error handling path (Yan Zhao)
- Address misc remarks from Kevin
v2: https://lore.kernel.org/kvm/[email protected]/
- Add r-b from Kevin and Eric on patch 01 02 04.
- "Split kvm/vfio: Provide struct kvm_device_ops::release() insted of ::destroy()" from this series and got applied. (Alex, Kevin, Jason, Mathhew)
- Add kvm_ref_lock to protect vfio_device_file->kvm instead of reusing dev_set->lock as dead-lock is observed with vfio-ap which would try to acquire kvm_lock. This is opposite lock order with kvm_device_release() which holds kvm_lock first and then hold dev_set->lock. (Kevin)
- Use a separate ioctl for detaching IOAS. (Alex)
- Rename vfio_device_file::single_open to be is_cdev_device (Kevin, Alex)
- Move the vfio device cdev code into device_cdev.c and add a VFIO_DEVICE_CDEV kconfig for it. (Kevin, Jason)
v1: https://lore.kernel.org/kvm/[email protected]/
- Fix the circular refcount between kvm struct and device file reference. (JasonG)
- Address comments from KevinT
- Remained the ioctl for detach, needs to Alex's taste
(https://lore.kernel.org/kvm/BN9PR11MB5276BE9F4B0613EE859317028CFF9@BN9PR11MB5276.namprd11.prod.outlook.com/)
rfc: https://lore.kernel.org/kvm/[email protected]/
Thanks,
Yi Liu
Nicolin Chen (1):
iommufd/device: Add iommufd_access_detach() API
Yi Liu (25):
vfio: Allocate per device file structure
vfio: Refine vfio file kAPIs for KVM
vfio: Accept vfio device file in the KVM facing kAPI kvm/vfio: Prepare for accepting vfio device fd
kvm/vfio: Accept vfio device file from userspace
vfio: Pass struct vfio_device_file * to vfio_device_open/close()
vfio: Block device access via device fd until device is opened
vfio: Add cdev_device_open_cnt to vfio_group
vfio: Make vfio_df_open() single open for device cdev path
vfio-iommufd: Move noiommu compat validation out of
vfio_iommufd_bind()
vfio-iommufd: Split bind/attach into two steps
vfio: Record devid in vfio_device_file
vfio-iommufd: Add detach_ioas support for physical VFIO devices
vfio-iommufd: Add detach_ioas support for emulated VFIO devices
vfio: Move vfio_device_group_unregister() to be the first operation in
unregister
vfio: Move device_del() before waiting for the last vfio_device
registration refcount
vfio: Add cdev for vfio_device
vfio: Test kvm pointer in _vfio_device_get_kvm_safe()
iommufd: Add iommufd_ctx_from_fd()
vfio: Avoid repeated user pointer cast in vfio_device_fops_unl_ioctl()
vfio: Add VFIO_DEVICE_BIND_IOMMUFD
vfio: Add VFIO_DEVICE_[AT|DE]TACH_IOMMUFD_PT
vfio: Move the IOMMU_CAP_CACHE_COHERENCY check in
__vfio_register_dev()
vfio: Compile vfio_group infrastructure optionally
docs: vfio: Add vfio device cdev description
Documentation/driver-api/vfio.rst | 147 ++++++++++- Documentation/virt/kvm/devices/vfio.rst | 47 ++-- drivers/gpu/drm/i915/gvt/kvmgt.c | 1 + drivers/iommu/iommufd/Kconfig | 4 +- drivers/iommu/iommufd/device.c | 74 +++++- drivers/iommu/iommufd/iommufd_private.h | 2 + drivers/iommu/iommufd/main.c | 24 ++ drivers/s390/cio/vfio_ccw_ops.c | 1 + drivers/s390/crypto/vfio_ap_ops.c | 1 + drivers/vfio/Kconfig | 27 ++ drivers/vfio/Makefile | 3 +- drivers/vfio/device_cdev.c | 228 +++++++++++++++++ drivers/vfio/fsl-mc/vfio_fsl_mc.c | 1 + drivers/vfio/group.c | 173 ++++++++----- drivers/vfio/iommufd.c | 94 ++++--- .../vfio/pci/hisilicon/hisi_acc_vfio_pci.c | 2 + drivers/vfio/pci/mlx5/main.c | 1 + drivers/vfio/pci/vfio_pci.c | 1 + drivers/vfio/platform/vfio_amba.c | 1 + drivers/vfio/platform/vfio_platform.c | 1 + drivers/vfio/vfio.h | 218 ++++++++++++++-- drivers/vfio/vfio_main.c | 239 ++++++++++++++++-- include/linux/iommufd.h | 2 + include/linux/vfio.h | 46 +++- include/uapi/linux/kvm.h | 13 +- include/uapi/linux/vfio.h | 71 ++++++ samples/vfio-mdev/mbochs.c | 1 + samples/vfio-mdev/mdpy.c | 1 + samples/vfio-mdev/mtty.c | 1 + virt/kvm/vfio.c | 137 +++++----- 30 files changed, 1318 insertions(+), 244 deletions(-) create mode 100644 drivers/vfio/device_cdev.c
Signature · 1 line
2.34.1
PATCH v15 1/26 vfio: Allocate per device file structure
This is preparation for adding vfio device cdev support. vfio device cdev requires:
1) A per device file memory to store the kvm pointer set by KVM. It will be propagated to vfio_device:kvm after the device cdev file is bound to an iommufd.
2) A mechanism to block device access through device cdev fd before it is bound to an iommufd.
To address the above requirements, this adds a per device file structure named vfio_device_file. For now, it's only a wrapper of struct vfio_device pointer. Other fields will be added to this per file structure in future commits.
--- drivers/vfio/group.c | 13 +++++++++++-- drivers/vfio/vfio.h | 6 ++++++ drivers/vfio/vfio_main.c | 31 ++++++++++++++++++++++++++----- 3 files changed, 43 insertions(+), 7 deletions(-)
drivers/vfio/group.c +11 -2
@@ -218,19 +218,26 @@ void vfio_device_group_close(struct vfio_device *device)static struct file *vfio_device_open_file (struct vfio_device *device) { +struct vfio_device_file *df;struct file *filep;int ret; + df =vfio_allocate_device_file (device); +if (IS_ERR (df)) { + ret =PTR_ERR (df); + goto err_out; + } + ret =vfio_device_group_open (device);if (ret) - goto err_out; + goto err_free;/* * We can't use anon_inode_getfd() because we need to modify * the f_mode flags directly to allow more than just ioctls */ filep =anon_inode_getfile ("[vfio-device]" , &vfio_device_fops, - device,O_RDWR ); + df,O_RDWR );if (IS_ERR (filep)) { ret =PTR_ERR (filep); goto err_close_device;
@@ -254,6 +261,8 @@ static struct file *vfio_device_open_file(struct vfio_device *device) err_close_device:vfio_device_group_close (device); +err_free: +kfree (df); err_out:return ERR_PTR (ret); }
drivers/vfio/vfio.h +6 -0
@@ -16,11 +16,17 @@ struct iommufd_ctx;struct iommu_group ;struct vfio_container ; +struct vfio_device_file { +struct vfio_device *device; +}; +void vfio_device_put_registration (struct vfio_device *device);bool vfio_device_try_get_registration (struct vfio_device *device);int vfio_device_open (struct vfio_device *device,struct iommufd_ctx *iommufd);void vfio_device_close (struct vfio_device *device,struct iommufd_ctx *iommufd); +struct vfio_device_file * +vfio_allocate_device_file (struct vfio_device *device);extern const struct file_operations vfio_device_fops;
drivers/vfio/vfio_main.c +26 -5
@@ -419,6 +419,20 @@ static bool vfio_assert_device_open(struct vfio_device *device)return !WARN_ON_ONCE (!READ_ONCE (device->open_count)); } +struct vfio_device_file * +vfio_allocate_device_file (struct vfio_device *device) +{ +struct vfio_device_file *df; + + df =kzalloc (sizeof (*df),GFP_KERNEL_ACCOUNT ); +if (!df) +return ERR_PTR (-ENOMEM ); + + df->device = device; + +return df; +} +static int vfio_device_first_open (struct vfio_device *device,struct iommufd_ctx *iommufd) {
@@ -532,12 +546,15 @@ static inline void vfio_device_pm_runtime_put(struct vfio_device *device)*/ static int vfio_device_fops_release (struct inode *inode,struct file *filep) { -struct vfio_device *device = filep->private_data; +struct vfio_device_file *df = filep->private_data; +struct vfio_device *device = df->device;vfio_device_group_close (device);vfio_device_put_registration (device); +kfree (df); +return 0 ; }
@@ -1102,7 +1119,8 @@ static int vfio_ioctl_device_feature(struct vfio_device *device,static long vfio_device_fops_unl_ioctl (struct file *filep,unsigned int cmd,unsigned long arg) { -struct vfio_device *device = filep->private_data; +struct vfio_device_file *df = filep->private_data; +struct vfio_device *device = df->device;int ret; ret =vfio_device_pm_runtime_get (device);
@@ -1129,7 +1147,8 @@ static long vfio_device_fops_unl_ioctl(struct file *filep,static ssize_t vfio_device_fops_read (struct file *filep,char __user *buf,size_t count,loff_t *ppos) { -struct vfio_device *device = filep->private_data; +struct vfio_device_file *df = filep->private_data; +struct vfio_device *device = df->device;if (unlikely (!device->ops->read))return -EINVAL ;
@@ -1141,7 +1160,8 @@ static ssize_t vfio_device_fops_write(struct file *filep,const char __user *buf, size_t count, loff_t *ppos) { - struct vfio_device *device = filep->private_data; + struct vfio_device_file *df = filep->private_data; +struct vfio_device *device = df->device;if (unlikely (!device->ops->write))return -EINVAL ;
@@ -1151,7 +1171,8 @@ static ssize_t vfio_device_fops_write(struct file *filep,static int vfio_device_fops_mmap (struct file *filep,struct vm_area_struct *vma) { -struct vfio_device *device = filep->private_data; +struct vfio_device_file *df = filep->private_data; +struct vfio_device *device = df->device;if (unlikely (!device->ops->mmap))return -EINVAL ;
Signature · 1 line
2.34.1
PATCH v15 2/26 vfio: Refine vfio file kAPIs for KVM
In reply to Yi LiuThis prepares for making the below kAPIs to accept both group file and device file instead of only vfio group file.
bool vfio_file_enforced_coherent(struct file *file); void vfio_file_set_kvm(struct file *file, struct kvm *kvm);
--- drivers/vfio/group.c | 53 +++++++++++++--------------------------- drivers/vfio/vfio.h | 3 +++ drivers/vfio/vfio_main.c | 49 +++++++++++++++++++++++++++++++++++++ include/linux/vfio.h | 1 + virt/kvm/vfio.c | 10 ++++---- 5 files changed, 75 insertions(+), 41 deletions(-)
drivers/vfio/group.c +17 -36
@@ -754,6 +754,15 @@ bool vfio_device_has_container(struct vfio_device *device)return device->group->container; } +struct vfio_group *vfio_group_from_file (struct file *file) +{ +struct vfio_group *group = file->private_data; + +if (file->f_op != &vfio_group_fops) +return NULL ; +return group; +} +/** * vfio_file_iommu_group - Return the struct iommu_group for the vfio group file * @file: VFIO group file
@@ -764,13 +773,13 @@ bool vfio_device_has_container(struct vfio_device *device)*/ struct iommu_group *vfio_file_iommu_group (struct file *file) { -struct vfio_group *group = file->private_data; +struct vfio_group *group =vfio_group_from_file (file);struct iommu_group *iommu_group =NULL ;if (!IS_ENABLED (CONFIG_SPAPR_TCE_IOMMU ))return NULL ; -if (!vfio_file_is_group (file)) +if (!group)return NULL ;mutex_lock (&group->group_lock);
@@ -784,33 +793,20 @@ struct iommu_group *vfio_file_iommu_group(struct file *file)EXPORT_SYMBOL_GPL (vfio_file_iommu_group);/** -* vfio_file_is_group - True if the file is usable with VFIO aPIS +* vfio_file_is_group - True if the file is a vfio group file * @file: VFIO group file */ bool vfio_file_is_group (struct file *file) { -return file->f_op == &vfio_group_fops; +return vfio_group_from_file (file); }EXPORT_SYMBOL_GPL (vfio_file_is_group); -/** -* vfio_file_enforced_coherent - True if the DMA associated with the VFIO file -* is always CPU cache coherent -* @file: VFIO group file -* -* Enforced coherency means that the IOMMU ignores things like the PCIe no-snoop -* bit in DMA transactions. A return of false indicates that the user has -* rights to access additional instructions such as wbinvd on x86. -*/ -bool vfio_file_enforced_coherent (struct file *file) +bool vfio_group_enforced_coherent (struct vfio_group *group) { -struct vfio_group *group = file->private_data;struct vfio_device *device;bool ret = true; -if (!vfio_file_is_group (file)) -return true; -/* * If the device does not have IOMMU_CAP_ENFORCE_CACHE_COHERENCY then * any domain later attached to it will also not support it. If the cap
@@ -828,28 +824,13 @@ bool vfio_file_enforced_coherent(struct file *file)mutex_unlock (&group->device_lock);return ret; } -EXPORT_SYMBOL_GPL (vfio_file_enforced_coherent); -/** -* vfio_file_set_kvm - Link a kvm with VFIO drivers -* @file: VFIO group file -* @kvm: KVM to link -* -* When a VFIO device is first opened the KVM will be available in -* device->kvm if one was associated with the group. -*/ -void vfio_file_set_kvm (struct file *file,struct kvm *kvm) +void vfio_group_set_kvm (struct vfio_group *group,struct kvm *kvm) { -struct vfio_group *group = file->private_data; - -if (!vfio_file_is_group (file)) -return ; -spin_lock (&group->kvm_ref_lock); group->kvm = kvm;spin_unlock (&group->kvm_ref_lock); } -EXPORT_SYMBOL_GPL (vfio_file_set_kvm);/** * vfio_file_has_dev - True if the VFIO file is a handle for device
@@ -860,9 +841,9 @@ EXPORT_SYMBOL_GPL(vfio_file_set_kvm);*/ bool vfio_file_has_dev (struct file *file,struct vfio_device *device) { -struct vfio_group *group = file->private_data; +struct vfio_group *group =vfio_group_from_file (file); -if (!vfio_file_is_group (file)) +if (!group)return false;return group == device->group;
drivers/vfio/vfio.h +3 -0
@@ -90,6 +90,9 @@ void vfio_device_group_unregister(struct vfio_device *device);int vfio_device_group_use_iommu (struct vfio_device *device);void vfio_device_group_unuse_iommu (struct vfio_device *device);void vfio_device_group_close (struct vfio_device *device); +struct vfio_group *vfio_group_from_file (struct file *file); +bool vfio_group_enforced_coherent (struct vfio_group *group); +void vfio_group_set_kvm (struct vfio_group *group,struct kvm *kvm);bool vfio_device_has_container (struct vfio_device *device);int __init vfio_group_init (void );void vfio_group_cleanup (void );
drivers/vfio/vfio_main.c +49 -0
55 lines not on this page · raw message
include/linux/vfio.h +1 -0
@@ -272,6 +272,7 @@ int vfio_mig_get_next_state(struct vfio_device *device,*/ struct iommu_group *vfio_file_iommu_group (struct file *file);bool vfio_file_is_group (struct file *file); +bool vfio_file_is_valid (struct file *file);bool vfio_file_enforced_coherent (struct file *file);void vfio_file_set_kvm (struct file *file,struct kvm *kvm);bool vfio_file_has_dev (struct file *file,struct vfio_device *device);
virt/kvm/vfio.c +5 -5
@@ -64,18 +64,18 @@ static bool kvm_vfio_file_enforced_coherent(struct file *file)return ret; } -static bool kvm_vfio_file_is_group (struct file *file) +static bool kvm_vfio_file_is_valid (struct file *file) {bool (*fn)(struct file *file);bool ret; - fn =symbol_get (vfio_file_is_group); + fn =symbol_get (vfio_file_is_valid);if (!fn)return false; ret =fn (file); -symbol_put (vfio_file_is_group); +symbol_put (vfio_file_is_valid);return ret; }
@@ -154,8 +154,8 @@ static int kvm_vfio_group_add(struct kvm_device *dev, unsigned int fd)if (!filp)return -EBADF ; -/* Ensure the FD is a vfio group FD.*/ -if (!kvm_vfio_file_is_group (filp)) { +/* Ensure the FD is a vfio FD. */ +if (!kvm_vfio_file_is_valid (filp)) { ret = -EINVAL ; goto err_fput; }
Signature · 1 line
2.34.1
PATCH v15 3/26 vfio: Accept vfio device file in the KVM facing kAPI
In reply to Yi LiuThis makes the vfio file kAPIs to accept vfio device files, also a preparation for vfio device cdev support.
For the kvm set with vfio device file, kvm pointer is stored in struct vfio_device_file, and use kvm_ref_lock to protect kvm set and kvm pointer usage within VFIO. This kvm pointer will be set to vfio_device after device file is bound to iommufd in the cdev path.
--- drivers/vfio/vfio.h | 3 +++ drivers/vfio/vfio_main.c | 36 +++++++++++++++++++++++++++++++++++- 2 files changed, 38 insertions(+), 1 deletion(-)
drivers/vfio/vfio.h +3 -0
@@ -18,6 +18,9 @@ struct vfio_container;struct vfio_device_file {struct vfio_device *device; + +spinlock_t kvm_ref_lock;/* protect kvm field */ +struct kvm *kvm; };void vfio_device_put_registration (struct vfio_device *device);
drivers/vfio/vfio_main.c +35 -1
@@ -429,6 +429,7 @@ vfio_allocate_device_file(struct vfio_device *device)return ERR_PTR (-ENOMEM ); df->device = device; +spin_lock_init (&df->kvm_ref_lock);return df; }
@@ -1190,13 +1191,23 @@ const struct file_operations vfio_device_fops = { .mmap = vfio_device_fops_mmap, }; +static struct vfio_device *vfio_device_from_file (struct file *file) +{ +struct vfio_device_file *df = file->private_data; + +if (file->f_op != &vfio_device_fops) +return NULL ; +return df->device; +} +/** * vfio_file_is_valid - True if the file is valid vfio file * @file: VFIO group file or VFIO device file */ bool vfio_file_is_valid (struct file *file) { -return vfio_group_from_file (file); +return vfio_group_from_file (file) || +vfio_device_from_file (file); }EXPORT_SYMBOL_GPL (vfio_file_is_valid);
@@ -1211,16 +1222,36 @@ EXPORT_SYMBOL_GPL(vfio_file_is_valid);*/ bool vfio_file_enforced_coherent (struct file *file) { +struct vfio_device *device;struct vfio_group *group; group =vfio_group_from_file (file);if (group)return vfio_group_enforced_coherent (group); + device =vfio_device_from_file (file); +if (device) +return device_iommu_capable (device->dev, +IOMMU_CAP_ENFORCE_CACHE_COHERENCY ); +return true; }EXPORT_SYMBOL_GPL (vfio_file_enforced_coherent); +static void vfio_device_file_set_kvm (struct file *file,struct kvm *kvm) +{ +struct vfio_device_file *df = file->private_data; + +/* +* The kvm is first recorded in the vfio_device_file, and will +* be propagated to vfio_device::kvm when the file is bound to +* iommufd successfully in the vfio device cdev path. +*/ +spin_lock (&df->kvm_ref_lock); + df->kvm = kvm; +spin_unlock (&df->kvm_ref_lock); +} +/** * vfio_file_set_kvm - Link a kvm with VFIO drivers * @file: VFIO group file or VFIO device file
@@ -1236,6 +1267,9 @@ void vfio_file_set_kvm(struct file *file, struct kvm *kvm) group =vfio_group_from_file (file);if (group)vfio_group_set_kvm (group, kvm); + +if (vfio_device_from_file (file)) +vfio_device_file_set_kvm (file, kvm); }EXPORT_SYMBOL_GPL (vfio_file_set_kvm);
Signature · 1 line
2.34.1
PATCH v15 4/26 kvm/vfio: Prepare for accepting vfio device fd
In reply to Yi LiuThis renames kvm_vfio_group related helpers to prepare for accepting vfio device fd. No functional change is intended.
--- virt/kvm/vfio.c | 115 ++++++++++++++++++++++++------------------------ 1 file changed, 58 insertions(+), 57 deletions(-)
virt/kvm/vfio.c +58 -57
@@ -21,7 +21,7 @@#include <asm/kvm_ppc.h> #endif -struct kvm_vfio_group { +struct kvm_vfio_file {struct list_head node;struct file *file;#ifdef CONFIG_SPAPR_TCE_IOMMU
@@ -30,7 +30,7 @@ struct kvm_vfio_group { };struct kvm_vfio { -struct list_head group_list; +struct list_head file_list;struct mutex lock;bool noncoherent; };
@@ -98,34 +98,35 @@ static struct iommu_group *kvm_vfio_file_iommu_group(struct file *file) }static void kvm_spapr_tce_release_vfio_group (struct kvm *kvm, -struct kvm_vfio_group *kvg) +struct kvm_vfio_file *kvf) { -if (WARN_ON_ONCE (!kvg->iommu_group)) +if (WARN_ON_ONCE (!kvf->iommu_group))return ; -kvm_spapr_tce_release_iommu_group (kvm, kvg->iommu_group); -iommu_group_put (kvg->iommu_group); - kvg->iommu_group =NULL ; +kvm_spapr_tce_release_iommu_group (kvm, kvf->iommu_group); +iommu_group_put (kvf->iommu_group); + kvf->iommu_group =NULL ; }#endif /* -* Groups can use the same or different IOMMU domains. If the same then -* adding a new group may change the coherency of groups we've previously -* been told about. We don't want to care about any of that so we retest -* each group and bail as soon as we find one that's noncoherent. This -* means we only ever [un]register_noncoherent_dma once for the whole device. +* Groups/devices can use the same or different IOMMU domains. If the same +* then adding a new group/device may change the coherency of groups/devices +* we've previously been told about. We don't want to care about any of +* that so we retest each group/device and bail as soon as we find one that's +* noncoherent. This means we only ever [un]register_noncoherent_dma once +* for the whole device. */ static void kvm_vfio_update_coherency (struct kvm_device *dev) {struct kvm_vfio *kv = dev->private;bool noncoherent = false; -struct kvm_vfio_group *kvg; +struct kvm_vfio_file *kvf;mutex_lock (&kv->lock); -list_for_each_entry (kvg, &kv->group_list, node) { -if (!kvm_vfio_file_enforced_coherent (kvg->file)) { +list_for_each_entry (kvf, &kv->file_list, node) { +if (!kvm_vfio_file_enforced_coherent (kvf->file)) { noncoherent = true;break ; }
@@ -143,10 +144,10 @@ static void kvm_vfio_update_coherency(struct kvm_device *dev)mutex_unlock (&kv->lock); } -static int kvm_vfio_group_add (struct kvm_device *dev,unsigned int fd) +static int kvm_vfio_file_add (struct kvm_device *dev,unsigned int fd) {struct kvm_vfio *kv = dev->private; -struct kvm_vfio_group *kvg; +struct kvm_vfio_file *kvf;struct file *filp;int ret;
@@ -162,27 +163,27 @@ static int kvm_vfio_group_add(struct kvm_device *dev, unsigned int fd)mutex_lock (&kv->lock); -list_for_each_entry (kvg, &kv->group_list, node) { -if (kvg->file == filp) { +list_for_each_entry (kvf, &kv->file_list, node) { +if (kvf->file == filp) { ret = -EEXIST ; goto err_unlock; } } - kvg =kzalloc (sizeof (*kvg),GFP_KERNEL_ACCOUNT ); -if (!kvg) { + kvf =kzalloc (sizeof (*kvf),GFP_KERNEL_ACCOUNT ); +if (!kvf) { ret = -ENOMEM ; goto err_unlock; } - kvg->file = filp; -list_add_tail (&kvg->node, &kv->group_list); + kvf->file = filp; +list_add_tail (&kvf->node, &kv->file_list);kvm_arch_start_assignment (dev->kvm);mutex_unlock (&kv->lock); -kvm_vfio_file_set_kvm (kvg->file, dev->kvm); +kvm_vfio_file_set_kvm (kvf->file, dev->kvm);kvm_vfio_update_coherency (dev);return 0 ;
@@ -193,10 +194,10 @@ static int kvm_vfio_group_add(struct kvm_device *dev, unsigned int fd)return ret; } -static int kvm_vfio_group_del (struct kvm_device *dev,unsigned int fd) +static int kvm_vfio_file_del (struct kvm_device *dev,unsigned int fd) {struct kvm_vfio *kv = dev->private; -struct kvm_vfio_group *kvg; +struct kvm_vfio_file *kvf;struct fd f;int ret;
@@ -208,18 +209,18 @@ static int kvm_vfio_group_del(struct kvm_device *dev, unsigned int fd)mutex_lock (&kv->lock); -list_for_each_entry (kvg, &kv->group_list, node) { -if (kvg->file != f.file) +list_for_each_entry (kvf, &kv->file_list, node) { +if (kvf->file != f.file)continue ; -list_del (&kvg->node); +list_del (&kvf->node);kvm_arch_end_assignment (dev->kvm);#ifdef CONFIG_SPAPR_TCE_IOMMU -kvm_spapr_tce_release_vfio_group (dev->kvm, kvg); +kvm_spapr_tce_release_vfio_group (dev->kvm, kvf);#endif -kvm_vfio_file_set_kvm (kvg->file,NULL ); -fput (kvg->file); -kfree (kvg); +kvm_vfio_file_set_kvm (kvf->file,NULL ); +fput (kvf->file); +kfree (kvf); ret =0 ;break ; }
@@ -234,12 +235,12 @@ static int kvm_vfio_group_del(struct kvm_device *dev, unsigned int fd) }#ifdef CONFIG_SPAPR_TCE_IOMMU -static int kvm_vfio_group_set_spapr_tce (struct kvm_device *dev, -void __user *arg) +static int kvm_vfio_file_set_spapr_tce (struct kvm_device *dev, +void __user *arg) {struct kvm_vfio_spapr_tce param;struct kvm_vfio *kv = dev->private; -struct kvm_vfio_group *kvg; +struct kvm_vfio_file *kvf;struct fd f;int ret;
@@ -254,20 +255,20 @@ static int kvm_vfio_group_set_spapr_tce(struct kvm_device *dev,mutex_lock (&kv->lock); -list_for_each_entry (kvg, &kv->group_list, node) { -if (kvg->file != f.file) +list_for_each_entry (kvf, &kv->file_list, node) { +if (kvf->file != f.file)continue ; -if (!kvg->iommu_group) { - kvg->iommu_group =kvm_vfio_file_iommu_group (kvg->file); -if (WARN_ON_ONCE (!kvg->iommu_group)) { +if (!kvf->iommu_group) { + kvf->iommu_group =kvm_vfio_file_iommu_group (kvf->file); +if (WARN_ON_ONCE (!kvf->iommu_group)) { ret = -EIO ; goto err_fdput; } } ret =kvm_spapr_tce_attach_iommu_group (dev->kvm, param.tablefd, - kvg->iommu_group); + kvf->iommu_group);break ; }
@@ -278,8 +279,8 @@ static int kvm_vfio_group_set_spapr_tce(struct kvm_device *dev, }#endif -static int kvm_vfio_set_group (struct kvm_device *dev,long attr, -void __user *arg) +static int kvm_vfio_set_file (struct kvm_device *dev,long attr, +void __user *arg) {int32_t __user *argp = arg;int32_t fd;
@@ -288,16 +289,16 @@ static int kvm_vfio_set_group(struct kvm_device *dev, long attr,case KVM_DEV_VFIO_GROUP_ADD :if (get_user (fd, argp))return -EFAULT ; -return kvm_vfio_group_add (dev, fd); +return kvm_vfio_file_add (dev, fd);case KVM_DEV_VFIO_GROUP_DEL :if (get_user (fd, argp))return -EFAULT ; -return kvm_vfio_group_del (dev, fd); +return kvm_vfio_file_del (dev, fd);#ifdef CONFIG_SPAPR_TCE_IOMMU case KVM_DEV_VFIO_GROUP_SET_SPAPR_TCE : -return kvm_vfio_group_set_spapr_tce (dev, arg); +return kvm_vfio_file_set_spapr_tce (dev, arg);#endif }
@@ -309,8 +310,8 @@ static int kvm_vfio_set_attr(struct kvm_device *dev, {switch (attr->group) {case KVM_DEV_VFIO_GROUP : -return kvm_vfio_set_group (dev, attr->attr, -u64_to_user_ptr (attr->addr)); +return kvm_vfio_set_file (dev, attr->attr, +u64_to_user_ptr (attr->addr)); }return -ENXIO ;
@@ -339,16 +340,16 @@ static int kvm_vfio_has_attr(struct kvm_device *dev,static void kvm_vfio_release (struct kvm_device *dev) {struct kvm_vfio *kv = dev->private; -struct kvm_vfio_group *kvg, *tmp; +struct kvm_vfio_file *kvf, *tmp; -list_for_each_entry_safe (kvg, tmp, &kv->group_list, node) { +list_for_each_entry_safe (kvf, tmp, &kv->file_list, node) {#ifdef CONFIG_SPAPR_TCE_IOMMU -kvm_spapr_tce_release_vfio_group (dev->kvm, kvg); +kvm_spapr_tce_release_vfio_group (dev->kvm, kvf);#endif -kvm_vfio_file_set_kvm (kvg->file,NULL ); -fput (kvg->file); -list_del (&kvg->node); -kfree (kvg); +kvm_vfio_file_set_kvm (kvf->file,NULL ); +fput (kvf->file); +list_del (&kvf->node); +kfree (kvf);kvm_arch_end_assignment (dev->kvm); }
@@ -382,7 +383,7 @@ static int kvm_vfio_create(struct kvm_device *dev, u32 type)if (!kv)return -ENOMEM ; -INIT_LIST_HEAD (&kv->group_list); +INIT_LIST_HEAD (&kv->file_list);mutex_init (&kv->lock); dev->private = kv;
Signature · 1 line
2.34.1
PATCH v15 5/26 kvm/vfio: Accept vfio device file from userspace
In reply to Yi LiuThis defines KVM_DEV_VFIO_FILE* and make alias with KVM_DEV_VFIO_GROUP*. Old userspace uses KVM_DEV_VFIO_GROUP* works as well.
--- Documentation/virt/kvm/devices/vfio.rst | 47 ++++++++++++++++--------- include/uapi/linux/kvm.h | 13 +++++-- virt/kvm/vfio.c | 12 +++---- 3 files changed, 47 insertions(+), 25 deletions(-)
Documentation/virt/kvm/devices/vfio.rst +31 -16
@@ -9,22 +9,34 @@ Device types supported: - KVM_DEV_TYPE_VFIO Only one VFIO instance may be created per VM. The created device -tracks VFIO groups in use by the VM and features of those groups -important to the correctness and acceleration of the VM. As groups -are enabled and disabled for use by the VM, KVM should be updated -about their presence. When registered with KVM, a reference to the -VFIO-group is held by KVM. +tracks VFIO files (group or device) in use by the VM and features +of those groups/devices important to the correctness and acceleration +of the VM. As groups/devices are enabled and disabled for use by the +VM, KVM should be updated about their presence. When registered with +KVM, a reference to the VFIO file is held by KVM. Groups: - KVM_DEV_VFIO_GROUP - -KVM_DEV_VFIO_GROUP attributes: - KVM_DEV_VFIO_GROUP_ADD: Add a VFIO group to VFIO-KVM device tracking - kvm_device_attr.addr points to an int32_t file descriptor - for the VFIO group. - KVM_DEV_VFIO_GROUP_DEL: Remove a VFIO group from VFIO-KVM device tracking - kvm_device_attr.addr points to an int32_t file descriptor - for the VFIO group. + KVM_DEV_VFIO_FILE + alias: KVM_DEV_VFIO_GROUP + +KVM_DEV_VFIO_FILE attributes: + KVM_DEV_VFIO_FILE_ADD: Add a VFIO file (group/device) to VFIO-KVM device + tracking + + kvm_device_attr.addr points to an int32_t file descriptor for the + VFIO file. + + KVM_DEV_VFIO_FILE_DEL: Remove a VFIO file (group/device) from VFIO-KVM + device tracking + + kvm_device_attr.addr points to an int32_t file descriptor for the + VFIO file. + +KVM_DEV_VFIO_GROUP (legacy kvm device group restricted to the handling of VFIO group fd): + KVM_DEV_VFIO_GROUP_ADD: same as KVM_DEV_VFIO_FILE_ADD for group fd only + + KVM_DEV_VFIO_GROUP_DEL: same as KVM_DEV_VFIO_FILE_DEL for group fd only + KVM_DEV_VFIO_GROUP_SET_SPAPR_TCE: attaches a guest visible TCE table allocated by sPAPR KVM. kvm_device_attr.addr points to a struct::
@@ -40,7 +52,10 @@ KVM_DEV_VFIO_GROUP attributes: - @tablefd is a file descriptor for a TCE table allocated via KVM_CREATE_SPAPR_TCE. -The GROUP_ADD operation above should be invoked prior to accessing the +The FILE/GROUP_ADD operation above should be invoked prior to accessing the device file descriptor via VFIO_GROUP_GET_DEVICE_FD in order to support drivers which require a kvm pointer to be set in their .open_device() -callback. +callback. It is the same for device file descriptor via character device +open which gets device access via VFIO_DEVICE_BIND_IOMMUFD. For such file +descriptors, FILE_ADD should be invoked before VFIO_DEVICE_BIND_IOMMUFD +to support the drivers mentioned in prior sentence as well.
include/uapi/linux/kvm.h +10 -3
@@ -1418,9 +1418,16 @@ struct kvm_device_attr {__u64 addr;/* userspace address of attr data */ }; -#define KVM_DEV_VFIO_GROUP 1 -#define KVM_DEV_VFIO_GROUP_ADD 1 -#define KVM_DEV_VFIO_GROUP_DEL 2 +#define KVM_DEV_VFIO_FILE 1 + +#define KVM_DEV_VFIO_FILE_ADD 1 +#define KVM_DEV_VFIO_FILE_DEL 2 + +/* KVM_DEV_VFIO_GROUP aliases are for compile time uapi compatibility */ +#define KVM_DEV_VFIO_GROUP KVM_DEV_VFIO_FILE + +#define KVM_DEV_VFIO_GROUP_ADD KVM_DEV_VFIO_FILE_ADD +#define KVM_DEV_VFIO_GROUP_DEL KVM_DEV_VFIO_FILE_DEL#define KVM_DEV_VFIO_GROUP_SET_SPAPR_TCE 3enum kvm_device_type {
virt/kvm/vfio.c +6 -6
@@ -286,12 +286,12 @@ static int kvm_vfio_set_file(struct kvm_device *dev, long attr,int32_t fd;switch (attr) { -case KVM_DEV_VFIO_GROUP_ADD : +case KVM_DEV_VFIO_FILE_ADD :if (get_user (fd, argp))return -EFAULT ;return kvm_vfio_file_add (dev, fd); -case KVM_DEV_VFIO_GROUP_DEL : +case KVM_DEV_VFIO_FILE_DEL :if (get_user (fd, argp))return -EFAULT ;return kvm_vfio_file_del (dev, fd);
@@ -309,7 +309,7 @@ static int kvm_vfio_set_attr(struct kvm_device *dev, struct kvm_device_attr *attr) {switch (attr->group) { -case KVM_DEV_VFIO_GROUP : +case KVM_DEV_VFIO_FILE :return kvm_vfio_set_file (dev, attr->attr,u64_to_user_ptr (attr->addr)); }
@@ -321,10 +321,10 @@ static int kvm_vfio_has_attr(struct kvm_device *dev, struct kvm_device_attr *attr) {switch (attr->group) { -case KVM_DEV_VFIO_GROUP : +case KVM_DEV_VFIO_FILE :switch (attr->attr) { -case KVM_DEV_VFIO_GROUP_ADD : -case KVM_DEV_VFIO_GROUP_DEL : +case KVM_DEV_VFIO_FILE_ADD : +case KVM_DEV_VFIO_FILE_DEL :#ifdef CONFIG_SPAPR_TCE_IOMMU case KVM_DEV_VFIO_GROUP_SET_SPAPR_TCE :#endif
Signature · 1 line
2.34.1
PATCH v15 6/26 vfio: Pass struct vfio_device_file * to vfio_device_open/close()
In reply to Yi LiuThis avoids passing too much parameters in multiple functions. Per the input parameter change, rename the function to be vfio_df_open/close().
--- drivers/vfio/group.c | 20 ++++++++++++++------ drivers/vfio/vfio.h | 8 ++++---- drivers/vfio/vfio_main.c | 25 +++++++++++++++---------- 3 files changed, 33 insertions(+), 20 deletions(-)
drivers/vfio/group.c +14 -6
@@ -169,8 +169,9 @@ static void vfio_device_group_get_kvm_safe(struct vfio_device *device)spin_unlock (&device->group->kvm_ref_lock); } -static int vfio_device_group_open (struct vfio_device *device) +static int vfio_df_group_open (struct vfio_device_file *df) { +struct vfio_device *device = df->device;int ret;mutex_lock (&device->group->group_lock);
@@ -190,7 +191,11 @@ static int vfio_device_group_open(struct vfio_device *device)if (device->open_count ==0 )vfio_device_group_get_kvm_safe (device); - ret =vfio_device_open (device, device->group->iommufd); + df->iommufd = device->group->iommufd; + + ret =vfio_df_open (df); +if (ret) + df->iommufd =NULL ;if (device->open_count ==0 )vfio_device_put_kvm (device);
@@ -202,12 +207,15 @@ static int vfio_device_group_open(struct vfio_device *device)return ret; } -void vfio_device_group_close (struct vfio_device *device) +void vfio_df_group_close (struct vfio_device_file *df) { +struct vfio_device *device = df->device; +mutex_lock (&device->group->group_lock);mutex_lock (&device->dev_set->lock); -vfio_device_close (device, device->group->iommufd); +vfio_df_close (df); + df->iommufd =NULL ;if (device->open_count ==0 )vfio_device_put_kvm (device);
@@ -228,7 +236,7 @@ static struct file *vfio_device_open_file(struct vfio_device *device) goto err_out; } - ret =vfio_device_group_open (device); + ret =vfio_df_group_open (df);if (ret) goto err_free;
@@ -260,7 +268,7 @@ static struct file *vfio_device_open_file(struct vfio_device *device)return filep; err_close_device: -vfio_device_group_close (device); +vfio_df_group_close (df); err_free:kfree (df); err_out:
drivers/vfio/vfio.h +4 -4
@@ -21,13 +21,13 @@ struct vfio_device_file {spinlock_t kvm_ref_lock;/* protect kvm field */ struct kvm *kvm; +struct iommufd_ctx *iommufd;/* protected by struct vfio_device_set::lock */ };void vfio_device_put_registration (struct vfio_device *device);bool vfio_device_try_get_registration (struct vfio_device *device); -int vfio_device_open (struct vfio_device *device,struct iommufd_ctx *iommufd); -void vfio_device_close (struct vfio_device *device, -struct iommufd_ctx *iommufd); +int vfio_df_open (struct vfio_device_file *df); +void vfio_df_close (struct vfio_device_file *df);struct vfio_device_file *vfio_allocate_device_file (struct vfio_device *device);
@@ -92,7 +92,7 @@ void vfio_device_group_register(struct vfio_device *device);void vfio_device_group_unregister (struct vfio_device *device);int vfio_device_group_use_iommu (struct vfio_device *device);void vfio_device_group_unuse_iommu (struct vfio_device *device); -void vfio_device_group_close (struct vfio_device *device); +void vfio_df_group_close (struct vfio_device_file *df);struct vfio_group *vfio_group_from_file (struct file *file);bool vfio_group_enforced_coherent (struct vfio_group *group);void vfio_group_set_kvm (struct vfio_group *group,struct kvm *kvm);
drivers/vfio/vfio_main.c +15 -10
@@ -434,9 +434,10 @@ vfio_allocate_device_file(struct vfio_device *device)return df; } -static int vfio_device_first_open (struct vfio_device *device, -struct iommufd_ctx *iommufd) +static int vfio_df_device_first_open (struct vfio_device_file *df) { +struct vfio_device *device = df->device; +struct iommufd_ctx *iommufd = df->iommufd;int ret;lockdep_assert_held (&device->dev_set->lock);
@@ -468,9 +469,11 @@ static int vfio_device_first_open(struct vfio_device *device,return ret; } -static void vfio_device_last_close (struct vfio_device *device, -struct iommufd_ctx *iommufd) +static void vfio_df_device_last_close (struct vfio_device_file *df) { +struct vfio_device *device = df->device; +struct iommufd_ctx *iommufd = df->iommufd; +lockdep_assert_held (&device->dev_set->lock);if (device->ops->close_device)
@@ -482,15 +485,16 @@ static void vfio_device_last_close(struct vfio_device *device,module_put (device->dev->driver->owner); } -int vfio_device_open (struct vfio_device *device,struct iommufd_ctx *iommufd) +int vfio_df_open (struct vfio_device_file *df) { +struct vfio_device *device = df->device;int ret =0 ;lockdep_assert_held (&device->dev_set->lock); device->open_count++;if (device->open_count ==1 ) { - ret =vfio_device_first_open (device, iommufd); + ret =vfio_df_device_first_open (df);if (ret) device->open_count--; }
@@ -498,14 +502,15 @@ int vfio_device_open(struct vfio_device *device, struct iommufd_ctx *iommufd)return ret; } -void vfio_device_close (struct vfio_device *device, -struct iommufd_ctx *iommufd) +void vfio_df_close (struct vfio_device_file *df) { +struct vfio_device *device = df->device; +lockdep_assert_held (&device->dev_set->lock);vfio_assert_device_open (device);if (device->open_count ==1 ) -vfio_device_last_close (device, iommufd); +vfio_df_device_last_close (df); device->open_count--; }
@@ -550,7 +555,7 @@ static int vfio_device_fops_release(struct inode *inode, struct file *filep)struct vfio_device_file *df = filep->private_data;struct vfio_device *device = df->device; -vfio_device_group_close (device); +vfio_df_group_close (df);vfio_device_put_registration (device);
Signature · 1 line
2.34.1
PATCH v15 7/26 vfio: Block device access via device fd until device is opened
In reply to Yi LiuAllow the vfio_device file to be in a state where the device FD is opened but the device cannot be used by userspace (i.e. its .open_device() hasn't been called). This inbetween state is not used when the device FD is spawned from the group FD, however when we create the device FD directly by opening a cdev it will be opened in the blocked state.
The reason for the inbetween state is that userspace only gets a FD but doesn't gain access permission until binding the FD to an iommufd. So in the blocked state, only the bind operation is allowed. Completing bind will allow user to further access the device.
This is implemented by adding a flag in struct vfio_device_file to mark the blocked state and using a simple smp_load_acquire() to obtain the flag value and serialize all the device setup with the thread accessing this device.
Following this lockless scheme, it can safely handle the device FD unbound->bound but it cannot handle bound->unbound. To allow this we'd need to add a lock on all the vfio ioctls which seems costly. So once device FD is bound, it remains bound until the FD is closed.
--- drivers/vfio/group.c | 11 ++++++++++- drivers/vfio/vfio.h | 1 + drivers/vfio/vfio_main.c | 16 ++++++++++++++++ 3 files changed, 27 insertions(+), 1 deletion(-)
drivers/vfio/group.c +10 -1
@@ -194,9 +194,18 @@ static int vfio_df_group_open(struct vfio_device_file *df) df->iommufd = device->group->iommufd; ret =vfio_df_open (df); -if (ret) +if (ret) { df->iommufd =NULL ; + goto out_put_kvm; + } + +/* +* Paired with smp_load_acquire() in vfio_device_fops::ioctl/ +* read/write/mmap and vfio_file_has_device_access() +*/ +smp_store_release (&df->access_granted, true); +out_put_kvm:if (device->open_count ==0 )vfio_device_put_kvm (device);
drivers/vfio/vfio.h +1 -0
@@ -19,6 +19,7 @@ struct vfio_container;struct vfio_device_file {struct vfio_device *device; +u8 access_granted;spinlock_t kvm_ref_lock;/* protect kvm field */ struct kvm *kvm;struct iommufd_ctx *iommufd;/* protected by struct vfio_device_set::lock */
drivers/vfio/vfio_main.c +16 -0
@@ -1129,6 +1129,10 @@ static long vfio_device_fops_unl_ioctl(struct file *filep,struct vfio_device *device = df->device;int ret; +/* Paired with smp_store_release() following vfio_df_open() */ +if (!smp_load_acquire (&df->access_granted)) +return -EINVAL ; + ret =vfio_device_pm_runtime_get (device);if (ret)return ret;
@@ -1156,6 +1160,10 @@ static ssize_t vfio_device_fops_read(struct file *filep, char __user *buf,struct vfio_device_file *df = filep->private_data;struct vfio_device *device = df->device; +/* Paired with smp_store_release() following vfio_df_open() */ +if (!smp_load_acquire (&df->access_granted)) +return -EINVAL ; +if (unlikely (!device->ops->read))return -EINVAL ;
@@ -1169,6 +1177,10 @@ static ssize_t vfio_device_fops_write(struct file *filep,struct vfio_device_file *df = filep->private_data;struct vfio_device *device = df->device; +/* Paired with smp_store_release() following vfio_df_open() */ +if (!smp_load_acquire (&df->access_granted)) +return -EINVAL ; +if (unlikely (!device->ops->write))return -EINVAL ;
@@ -1180,6 +1192,10 @@ static int vfio_device_fops_mmap(struct file *filep, struct vm_area_struct *vma)struct vfio_device_file *df = filep->private_data;struct vfio_device *device = df->device; +/* Paired with smp_store_release() following vfio_df_open() */ +if (!smp_load_acquire (&df->access_granted)) +return -EINVAL ; +if (unlikely (!device->ops->mmap))return -EINVAL ;
Signature · 1 line
2.34.1
PATCH v15 8/26 vfio: Add cdev_device_open_cnt to vfio_group
In reply to Yi LiuThis is for counting the devices that are opened via the cdev path. This count is increased and decreased by the cdev path. The group path checks it to achieve exclusion with the cdev path. With this, only one path (group path or cdev path) will claim DMA ownership. This avoids scenarios in which devices within the same group may be opened via different paths.
--- drivers/vfio/group.c | 33 +++++++++++++++++++++++++++++++++ drivers/vfio/vfio.h | 3 +++ 2 files changed, 36 insertions(+)
drivers/vfio/group.c +33 -0
@@ -383,6 +383,33 @@ static long vfio_group_fops_unl_ioctl(struct file *filep, } } +int vfio_device_block_group (struct vfio_device *device) +{ +struct vfio_group *group = device->group; +int ret =0 ; + +mutex_lock (&group->group_lock); +if (group->opened_file) { + ret = -EBUSY ; + goto out_unlock; + } + + group->cdev_device_open_cnt++; + +out_unlock: +mutex_unlock (&group->group_lock); +return ret; +} + +void vfio_device_unblock_group (struct vfio_device *device) +{ +struct vfio_group *group = device->group; + +mutex_lock (&group->group_lock); + group->cdev_device_open_cnt--; +mutex_unlock (&group->group_lock); +} +static int vfio_group_fops_open (struct inode *inode,struct file *filep) { struct vfio_group *group =
@@ -405,6 +432,11 @@ static int vfio_group_fops_open(struct inode *inode, struct file *filep) goto out_unlock; } +if (group->cdev_device_open_cnt) { + ret = -EBUSY ; + goto out_unlock; + } +/* * Do we need multiple instances of the group open? Seems not. */
@@ -479,6 +511,7 @@ static void vfio_group_release(struct device *dev)mutex_destroy (&group->device_lock);mutex_destroy (&group->group_lock);WARN_ON (group->iommu_group); +WARN_ON (group->cdev_device_open_cnt);ida_free (&vfio.group_ida,MINOR (group->dev.devt));kfree (group); }
drivers/vfio/vfio.h +3 -0
@@ -84,8 +84,11 @@ struct vfio_group {struct blocking_notifier_head notifier;struct iommufd_ctx *iommufd;spinlock_t kvm_ref_lock; +unsigned int cdev_device_open_cnt; }; +int vfio_device_block_group (struct vfio_device *device); +void vfio_device_unblock_group (struct vfio_device *device);int vfio_device_set_group (struct vfio_device *device,enum vfio_group_type type);void vfio_device_remove_group (struct vfio_device *device);
Signature · 1 line
2.34.1
PATCH v15 9/26 vfio: Make vfio_df_open() single open for device cdev path
In reply to Yi LiuVFIO group has historically allowed multi-open of the device FD. This was made secure because the "open" was executed via an ioctl to the group FD which is itself only single open.
However, no known use of multiple device FDs today. It is kind of a strange thing to do because new device FDs can naturally be created via dup().
When we implement the new device uAPI (only used in cdev path) there is no natural way to allow the device itself from being multi-opened in a secure manner. Without the group FD we cannot prove the security context of the opener.
Thus, when moving to the new uAPI we block the ability of opening a device multiple times. Given old group path still allows it we store a vfio_group pointer in struct vfio_device_file to differentiate.
--- drivers/vfio/group.c | 2 ++ drivers/vfio/vfio.h | 1 + drivers/vfio/vfio_main.c | 7 +++++++ 3 files changed, 10 insertions(+)
drivers/vfio/group.c +2 -0
@@ -245,6 +245,8 @@ static struct file *vfio_device_open_file(struct vfio_device *device) goto err_out; } + df->group = device->group; + ret =vfio_df_group_open (df);if (ret) goto err_free;
drivers/vfio/vfio.h +1 -0
@@ -18,6 +18,7 @@ struct vfio_container;struct vfio_device_file {struct vfio_device *device; +struct vfio_group *group;u8 access_granted;spinlock_t kvm_ref_lock;/* protect kvm field */
drivers/vfio/vfio_main.c +7 -0
@@ -492,6 +492,13 @@ int vfio_df_open(struct vfio_device_file *df)lockdep_assert_held (&device->dev_set->lock); +/* +* Only the group path allows the device to be opened multiple +* times. The device cdev path doesn't have a secure way for it. +*/ +if (device->open_count !=0 && !df->group) +return -EINVAL ; + device->open_count++;if (device->open_count ==1 ) { ret =vfio_df_device_first_open (df);
Signature · 1 line
2.34.1
PATCH v15 10/26 vfio-iommufd: Move noiommu compat validation out of vfio_iommufd_bind()
In reply to Yi LiuThis moves the noiommu compat validation logic into vfio_df_group_open(). This is more consistent with what will be done in vfio device cdev path.
--- drivers/vfio/group.c | 13 +++++++++++++ drivers/vfio/iommufd.c | 22 ++++++++-------------- drivers/vfio/vfio.h | 9 +++++++++ 3 files changed, 30 insertions(+), 14 deletions(-)
drivers/vfio/group.c +13 -0
@@ -192,6 +192,19 @@ static int vfio_df_group_open(struct vfio_device_file *df)vfio_device_group_get_kvm_safe (device); df->iommufd = device->group->iommufd; +if (df->iommufd &&vfio_device_is_noiommu (device) && device->open_count ==0 ) { +/* +* Require no compat ioas to be assigned to proceed. The basic +* statement is that the user cannot have done something that +* implies they expected translation to exist +*/ +if (!capable (CAP_SYS_RAWIO ) || +vfio_iommufd_device_has_compat_ioas (device, df->iommufd)) + ret = -EPERM ; +else + ret =0 ; + goto out_put_kvm; + } ret =vfio_df_open (df);if (ret) {
drivers/vfio/iommufd.c +8 -14
@@ -10,6 +10,14 @@MODULE_IMPORT_NS (IOMMUFD );MODULE_IMPORT_NS (IOMMUFD_VFIO ); +bool vfio_iommufd_device_has_compat_ioas (struct vfio_device *vdev, +struct iommufd_ctx *ictx) +{ +u32 ioas_id; + +return !iommufd_vfio_compat_ioas_get_id (ictx, &ioas_id); +} +int vfio_iommufd_bind (struct vfio_device *vdev,struct iommufd_ctx *ictx) {u32 ioas_id;
@@ -18,20 +26,6 @@ int vfio_iommufd_bind(struct vfio_device *vdev, struct iommufd_ctx *ictx)lockdep_assert_held (&vdev->dev_set->lock); -if (vfio_device_is_noiommu (vdev)) { -if (!capable (CAP_SYS_RAWIO )) -return -EPERM ; - -/* -* Require no compat ioas to be assigned to proceed. The basic -* statement is that the user cannot have done something that -* implies they expected translation to exist -*/ -if (!iommufd_vfio_compat_ioas_get_id (ictx, &ioas_id)) -return -EPERM ; -return 0 ; - } - ret = vdev->ops->bind_iommufd (vdev, ictx, &device_id);if (ret)return ret;
drivers/vfio/vfio.h +9 -0
@@ -234,9 +234,18 @@ static inline void vfio_container_cleanup(void)#endif #if IS_ENABLED (CONFIG_IOMMUFD ) +bool vfio_iommufd_device_has_compat_ioas (struct vfio_device *vdev, +struct iommufd_ctx *ictx);int vfio_iommufd_bind (struct vfio_device *device,struct iommufd_ctx *ictx);void vfio_iommufd_unbind (struct vfio_device *device);#else +static inline bool +vfio_iommufd_device_has_compat_ioas (struct vfio_device *vdev, +struct iommufd_ctx *ictx) +{ +return false; +} +static inline int vfio_iommufd_bind (struct vfio_device *device,struct iommufd_ctx *ictx) {
Signature · 1 line
2.34.1
PATCH v15 11/26 vfio-iommufd: Split bind/attach into two steps
In reply to Yi LiuThis aligns the bind/attach logic with the coming vfio device cdev support.
--- drivers/vfio/group.c | 17 +++++++++++++---- drivers/vfio/iommufd.c | 35 +++++++++++++++++------------------ drivers/vfio/vfio.h | 9 +++++++++ 3 files changed, 39 insertions(+), 22 deletions(-)
drivers/vfio/group.c +13 -4
@@ -207,9 +207,13 @@ static int vfio_df_group_open(struct vfio_device_file *df) } ret =vfio_df_open (df); -if (ret) { - df->iommufd =NULL ; +if (ret) goto out_put_kvm; + +if (df->iommufd && device->open_count ==1 ) { + ret =vfio_iommufd_compat_attach_ioas (device, df->iommufd); +if (ret) + goto out_close_device; }/*
@@ -218,12 +222,17 @@ static int vfio_df_group_open(struct vfio_device_file *df)*/ smp_store_release (&df->access_granted, true); +mutex_unlock (&device->dev_set->lock); +mutex_unlock (&device->group->group_lock); +return 0 ; + +out_close_device: +vfio_df_close (df); out_put_kvm: + df->iommufd =NULL ;if (device->open_count ==0 )vfio_device_put_kvm (device); -mutex_unlock (&device->dev_set->lock); - out_unlock:mutex_unlock (&device->group->group_lock);return ret;
drivers/vfio/iommufd.c +17 -18
@@ -20,33 +20,32 @@ bool vfio_iommufd_device_has_compat_ioas(struct vfio_device *vdev,int vfio_iommufd_bind (struct vfio_device *vdev,struct iommufd_ctx *ictx) { -u32 ioas_id;u32 device_id; + +lockdep_assert_held (&vdev->dev_set->lock); + +/* The legacy path has no way to return the device id */ +return vdev->ops->bind_iommufd (vdev, ictx, &device_id); +} + +int vfio_iommufd_compat_attach_ioas (struct vfio_device *vdev, +struct iommufd_ctx *ictx) +{ +u32 ioas_id;int ret;lockdep_assert_held (&vdev->dev_set->lock); - ret = vdev->ops->bind_iommufd (vdev, ictx, &device_id); -if (ret) -return ret; +/* compat noiommu does not need to do ioas attach */ +if (vfio_device_is_noiommu (vdev)) +return 0 ; ret =iommufd_vfio_compat_ioas_get_id (ictx, &ioas_id);if (ret) - goto err_unbind; - ret = vdev->ops->attach_ioas (vdev, &ioas_id); -if (ret) - goto err_unbind; - -/* -* The legacy path has no way to return the device id or the selected -* pt_id -*/ -return 0 ; +return ret; -err_unbind: -if (vdev->ops->unbind_iommufd) - vdev->ops->unbind_iommufd (vdev); -return ret; +/* The legacy path has no way to return the selected pt_id */ +return vdev->ops->attach_ioas (vdev, &ioas_id); }void vfio_iommufd_unbind (struct vfio_device *vdev)
drivers/vfio/vfio.h +9 -0
@@ -238,6 +238,8 @@ bool vfio_iommufd_device_has_compat_ioas(struct vfio_device *vdev, struct iommufd_ctx *ictx);int vfio_iommufd_bind (struct vfio_device *device,struct iommufd_ctx *ictx);void vfio_iommufd_unbind (struct vfio_device *device); +int vfio_iommufd_compat_attach_ioas (struct vfio_device *device, +struct iommufd_ctx *ictx);#else static inline bool vfio_iommufd_device_has_compat_ioas(struct vfio_device *vdev,
@@ -255,6 +257,13 @@ static inline int vfio_iommufd_bind(struct vfio_device *device,static inline void vfio_iommufd_unbind (struct vfio_device *device) { } + +static inline int +vfio_iommufd_compat_attach_ioas (struct vfio_device *device, +struct iommufd_ctx *ictx) +{ +return -EOPNOTSUPP ; +}#endif #if IS_ENABLED (CONFIG_VFIO_VIRQFD )
Signature · 1 line
2.34.1
PATCH v15 12/26 vfio: Record devid in vfio_device_file
In reply to Yi Liu.bind_iommufd() will generate an ID to represent this bond, which is needed by userspace for further usage. Store devid in vfio_device_file to avoid passing the pointer in multiple places.
--- drivers/vfio/iommufd.c | 12 +++++++----- drivers/vfio/vfio.h | 10 +++++----- drivers/vfio/vfio_main.c | 6 +++--- 3 files changed, 15 insertions(+), 13 deletions(-)
drivers/vfio/iommufd.c +7 -5
@@ -18,14 +18,14 @@ bool vfio_iommufd_device_has_compat_ioas(struct vfio_device *vdev,return !iommufd_vfio_compat_ioas_get_id (ictx, &ioas_id); } -int vfio_iommufd_bind (struct vfio_device *vdev,struct iommufd_ctx *ictx) +int vfio_df_iommufd_bind (struct vfio_device_file *df) { -u32 device_id; +struct vfio_device *vdev = df->device; +struct iommufd_ctx *ictx = df->iommufd;lockdep_assert_held (&vdev->dev_set->lock); -/* The legacy path has no way to return the device id */ -return vdev->ops->bind_iommufd (vdev, ictx, &device_id); +return vdev->ops->bind_iommufd (vdev, ictx, &df->devid); } int vfio_iommufd_compat_attach_ioas(struct vfio_device *vdev,
@@ -48,8 +48,10 @@ int vfio_iommufd_compat_attach_ioas(struct vfio_device *vdev,return vdev->ops->attach_ioas (vdev, &ioas_id); } -void vfio_iommufd_unbind (struct vfio_device *vdev) +void vfio_df_iommufd_unbind (struct vfio_device_file *df) { +struct vfio_device *vdev = df->device; +lockdep_assert_held (&vdev->dev_set->lock);if (vfio_device_is_noiommu (vdev))
drivers/vfio/vfio.h +5 -5
@@ -21,6 +21,7 @@ struct vfio_device_file {struct vfio_group *group;u8 access_granted; +u32 devid;/* only valid when iommufd is valid */ spinlock_t kvm_ref_lock;/* protect kvm field */ struct kvm *kvm;struct iommufd_ctx *iommufd;/* protected by struct vfio_device_set::lock */
@@ -236,8 +237,8 @@ static inline void vfio_container_cleanup(void)#if IS_ENABLED (CONFIG_IOMMUFD )bool vfio_iommufd_device_has_compat_ioas (struct vfio_device *vdev,struct iommufd_ctx *ictx); -int vfio_iommufd_bind (struct vfio_device *device,struct iommufd_ctx *ictx); -void vfio_iommufd_unbind (struct vfio_device *device); +int vfio_df_iommufd_bind (struct vfio_device_file *df); +void vfio_df_iommufd_unbind (struct vfio_device_file *df);int vfio_iommufd_compat_attach_ioas (struct vfio_device *device,struct iommufd_ctx *ictx);#else
@@ -248,13 +249,12 @@ vfio_iommufd_device_has_compat_ioas(struct vfio_device *vdev,return false; } -static inline int vfio_iommufd_bind (struct vfio_device *device, -struct iommufd_ctx *ictx) +static inline int vfio_df_iommufd_bind (struct vfio_device_file *fd) {return -EOPNOTSUPP ; } -static inline void vfio_iommufd_unbind (struct vfio_device *device) +static inline void vfio_df_iommufd_unbind (struct vfio_device_file *df) { }
drivers/vfio/vfio_main.c +3 -3
@@ -446,7 +446,7 @@ static int vfio_df_device_first_open(struct vfio_device_file *df)return -ENODEV ;if (iommufd) - ret =vfio_iommufd_bind (device, iommufd); + ret =vfio_df_iommufd_bind (df);else ret =vfio_device_group_use_iommu (device);if (ret)
@@ -461,7 +461,7 @@ static int vfio_df_device_first_open(struct vfio_device_file *df) err_unuse_iommu:if (iommufd) -vfio_iommufd_unbind (device); +vfio_df_iommufd_unbind (df);else vfio_device_group_unuse_iommu (device); err_module_put:
@@ -479,7 +479,7 @@ static void vfio_df_device_last_close(struct vfio_device_file *df)if (device->ops->close_device) device->ops->close_device (device);if (iommufd) -vfio_iommufd_unbind (device); +vfio_df_iommufd_unbind (df);else vfio_device_group_unuse_iommu (device);module_put (device->dev->driver->owner);
Signature · 1 line
2.34.1
PATCH v15 13/26 vfio-iommufd: Add detach_ioas support for physical VFIO devices
In reply to Yi LiuThis prepares for adding DETACH ioctl for physical VFIO devices.
--- Documentation/driver-api/vfio.rst | 8 +++++--- drivers/vfio/fsl-mc/vfio_fsl_mc.c | 1 + drivers/vfio/iommufd.c | 20 +++++++++++++++++++ .../vfio/pci/hisilicon/hisi_acc_vfio_pci.c | 2 ++ drivers/vfio/pci/mlx5/main.c | 1 + drivers/vfio/pci/vfio_pci.c | 1 + drivers/vfio/platform/vfio_amba.c | 1 + drivers/vfio/platform/vfio_platform.c | 1 + drivers/vfio/vfio_main.c | 3 ++- include/linux/vfio.h | 8 +++++++- 10 files changed, 41 insertions(+), 5 deletions(-)
Documentation/driver-api/vfio.rst +5 -3
@@ -279,6 +279,7 @@ similar to a file operations structure:: struct iommufd_ctx *ictx, u32 *out_device_id); void (*unbind_iommufd)(struct vfio_device *vdev); int (*attach_ioas)(struct vfio_device *vdev, u32 *pt_id); + void (*detach_ioas)(struct vfio_device *vdev); int (*open_device)(struct vfio_device *vdev); void (*close_device)(struct vfio_device *vdev); ssize_t (*read)(struct vfio_device *vdev, char __user *buf,
@@ -315,9 +316,10 @@ container_of(). - The [un]bind_iommufd callbacks are issued when the device is bound to and unbound from iommufd. - - The attach_ioas callback is issued when the device is attached to an - IOAS managed by the bound iommufd. The attached IOAS is automatically - detached when the device is unbound from iommufd. + - The [de]attach_ioas callback is issued when the device is attached to + and detached from an IOAS managed by the bound iommufd. However, the + attached IOAS can also be automatically detached when the device is + unbound from iommufd. - The read/write/mmap callbacks implement the device region access defined by the device's own VFIO_DEVICE_GET_REGION_INFO ioctl.
drivers/vfio/fsl-mc/vfio_fsl_mc.c +1 -0
@@ -593,6 +593,7 @@ static const struct vfio_device_ops vfio_fsl_mc_ops = { .bind_iommufd = vfio_iommufd_physical_bind, .unbind_iommufd = vfio_iommufd_physical_unbind, .attach_ioas = vfio_iommufd_physical_attach_ioas, + .detach_ioas = vfio_iommufd_physical_detach_ioas, };static struct fsl_mc_driver vfio_fsl_mc_driver = {
drivers/vfio/iommufd.c +20 -0
@@ -140,6 +140,14 @@ int vfio_iommufd_physical_attach_ioas(struct vfio_device *vdev, u32 *pt_id) {int rc; +lockdep_assert_held (&vdev->dev_set->lock); + +if (WARN_ON (!vdev->iommufd_device)) +return -EINVAL ; + +if (vdev->iommufd_attached) +return -EBUSY ; + rc =iommufd_device_attach (vdev->iommufd_device, pt_id);if (rc)return rc;
@@ -148,6 +156,18 @@ int vfio_iommufd_physical_attach_ioas(struct vfio_device *vdev, u32 *pt_id) }EXPORT_SYMBOL_GPL (vfio_iommufd_physical_attach_ioas); +void vfio_iommufd_physical_detach_ioas (struct vfio_device *vdev) +{ +lockdep_assert_held (&vdev->dev_set->lock); + +if (WARN_ON (!vdev->iommufd_device) || !vdev->iommufd_attached) +return ; + +iommufd_device_detach (vdev->iommufd_device); + vdev->iommufd_attached = false; +} +EXPORT_SYMBOL_GPL (vfio_iommufd_physical_detach_ioas); +/* * The emulated standard ops mean that vfio_device is going to use the * "mdev path" and will call vfio_pin_pages()/vfio_dma_rw(). Drivers using this
drivers/vfio/pci/hisilicon/hisi_acc_vfio_pci.c +2 -0
@@ -1373,6 +1373,7 @@ static const struct vfio_device_ops hisi_acc_vfio_pci_migrn_ops = { .bind_iommufd = vfio_iommufd_physical_bind, .unbind_iommufd = vfio_iommufd_physical_unbind, .attach_ioas = vfio_iommufd_physical_attach_ioas, + .detach_ioas = vfio_iommufd_physical_detach_ioas, };static const struct vfio_device_ops hisi_acc_vfio_pci_ops = {
@@ -1391,6 +1392,7 @@ static const struct vfio_device_ops hisi_acc_vfio_pci_ops = { .bind_iommufd = vfio_iommufd_physical_bind, .unbind_iommufd = vfio_iommufd_physical_unbind, .attach_ioas = vfio_iommufd_physical_attach_ioas, + .detach_ioas = vfio_iommufd_physical_detach_ioas, };static int hisi_acc_vfio_pci_probe (struct pci_dev *pdev,const struct pci_device_id *id)
drivers/vfio/pci/mlx5/main.c +1 -0
@@ -1320,6 +1320,7 @@ static const struct vfio_device_ops mlx5vf_pci_ops = { .bind_iommufd = vfio_iommufd_physical_bind, .unbind_iommufd = vfio_iommufd_physical_unbind, .attach_ioas = vfio_iommufd_physical_attach_ioas, + .detach_ioas = vfio_iommufd_physical_detach_ioas, }; static int mlx5vf_pci_probe(struct pci_dev *pdev,
drivers/vfio/pci/vfio_pci.c +1 -0
@@ -141,6 +141,7 @@ static const struct vfio_device_ops vfio_pci_ops = { .bind_iommufd = vfio_iommufd_physical_bind, .unbind_iommufd = vfio_iommufd_physical_unbind, .attach_ioas = vfio_iommufd_physical_attach_ioas, + .detach_ioas = vfio_iommufd_physical_detach_ioas, };static int vfio_pci_probe (struct pci_dev *pdev,const struct pci_device_id *id)
drivers/vfio/platform/vfio_amba.c +1 -0
@@ -119,6 +119,7 @@ static const struct vfio_device_ops vfio_amba_ops = { .bind_iommufd = vfio_iommufd_physical_bind, .unbind_iommufd = vfio_iommufd_physical_unbind, .attach_ioas = vfio_iommufd_physical_attach_ioas, + .detach_ioas = vfio_iommufd_physical_detach_ioas, };static const struct amba_id pl330_ids[] = {
drivers/vfio/platform/vfio_platform.c +1 -0
@@ -108,6 +108,7 @@ static const struct vfio_device_ops vfio_platform_ops = { .bind_iommufd = vfio_iommufd_physical_bind, .unbind_iommufd = vfio_iommufd_physical_unbind, .attach_ioas = vfio_iommufd_physical_attach_ioas, + .detach_ioas = vfio_iommufd_physical_detach_ioas, };static struct platform_driver vfio_platform_driver = {
drivers/vfio/vfio_main.c +2 -1
@@ -273,7 +273,8 @@ static int __vfio_register_dev(struct vfio_device *device,if (WARN_ON (IS_ENABLED (CONFIG_IOMMUFD ) && (!device->ops->bind_iommufd || !device->ops->unbind_iommufd || - !device->ops->attach_ioas))) + !device->ops->attach_ioas || + !device->ops->detach_ioas)))return -EINVAL ;/*
include/linux/vfio.h +7 -1
@@ -73,7 +73,9 @@ struct vfio_device {* @bind_iommufd: Called when binding the device to an iommufd * @unbind_iommufd: Opposite of bind_iommufd * @attach_ioas: Called when attaching device to an IOAS/HWPT managed by the -* bound iommufd. Undo in unbind_iommufd. +* bound iommufd. Undo in unbind_iommufd if @detach_ioas is not +* called. +* @detach_ioas: Opposite of attach_ioas * @open_device: Called when the first file descriptor is opened for this device * @close_device: Opposite of open_device * @read: Perform read(2) on device file descriptor
@@ -97,6 +99,7 @@ struct vfio_device_ops { struct iommufd_ctx *ictx, u32 *out_device_id);void (*unbind_iommufd)(struct vfio_device *vdev);int (*attach_ioas)(struct vfio_device *vdev,u32 *pt_id); +void (*detach_ioas)(struct vfio_device *vdev);int (*open_device)(struct vfio_device *vdev);void (*close_device)(struct vfio_device *vdev); ssize_t (*read)(struct vfio_device *vdev, char __user *buf,
@@ -120,6 +123,7 @@ int vfio_iommufd_physical_bind(struct vfio_device *vdev, struct iommufd_ctx *ictx, u32 *out_device_id);void vfio_iommufd_physical_unbind (struct vfio_device *vdev);int vfio_iommufd_physical_attach_ioas (struct vfio_device *vdev,u32 *pt_id); +void vfio_iommufd_physical_detach_ioas (struct vfio_device *vdev);int vfio_iommufd_emulated_bind (struct vfio_device *vdev,struct iommufd_ctx *ictx,u32 *out_device_id);void vfio_iommufd_emulated_unbind (struct vfio_device *vdev);
@@ -144,6 +148,8 @@ vfio_iommufd_get_dev_id(struct vfio_device *vdev, struct iommufd_ctx *ictx) ((void (*)(struct vfio_device *vdev)) NULL)#define vfio_iommufd_physical_attach_ioas \ ((int (*)(struct vfio_device *vdev, u32 *pt_id)) NULL) +#define vfio_iommufd_physical_detach_ioas \ + ((void (*)(struct vfio_device *vdev)) NULL)#define vfio_iommufd_emulated_bind \ ((int (*)(struct vfio_device *vdev, struct iommufd_ctx *ictx, \ u32 *out_device_id)) NULL)
Signature · 1 line
2.34.1
PATCH v15 14/26 iommufd/device: Add iommufd_access_detach() API
In reply to Yi LiuFrom: Nicolin Chen <[email protected]>
Previously, the detach routine is only done by the destroy(). And it was called by vfio_iommufd_emulated_unbind() when the device runs close(), so all the mappings in iopt were cleaned in that setup, when the call trace reaches this detach() routine.
Now, there's a need of a detach uAPI, meaning that it does not only need a new iommufd_access_detach() API, but also requires access->ops->unmap() call as a cleanup. So add one.
However, leaving that unprotected can introduce some potential of a race condition during the pin_/unpin_pages() call, where access->ioas->iopt is getting referenced. So, add an ioas_lock to protect the context of iopt referencings.
Also, to allow the iommufd_access_unpin_pages() callback to happen via this unmap() call, add an ioas_unpin pointer, so the unpin routine won't be affected by the "access->ioas = NULL" trick.
--- drivers/iommu/iommufd/device.c | 74 +++++++++++++++++++++++-- drivers/iommu/iommufd/iommufd_private.h | 2 + include/linux/iommufd.h | 1 + 3 files changed, 72 insertions(+), 5 deletions(-)
drivers/iommu/iommufd/device.c +69 -5
@@ -486,6 +486,7 @@ iommufd_access_create(struct iommufd_ctx *ictx,iommufd_ctx_get (ictx);iommufd_object_finalize (ictx, &access->obj); *id = access->obj.id; +mutex_init (&access->ioas_lock);return access; }EXPORT_SYMBOL_NS_GPL (iommufd_access_create,IOMMUFD );
@@ -505,26 +506,60 @@ void iommufd_access_destroy(struct iommufd_access *access) }EXPORT_SYMBOL_NS_GPL (iommufd_access_destroy,IOMMUFD ); +void iommufd_access_detach (struct iommufd_access *access) +{ +struct iommufd_ioas *cur_ioas = access->ioas; + +mutex_lock (&access->ioas_lock); +if (WARN_ON (!access->ioas)) + goto out; +/* +* Set ioas to NULL to block any further iommufd_access_pin_pages(). +* iommufd_access_unpin_pages() can continue using access->ioas_unpin. +*/ + access->ioas =NULL ; + +if (access->ops->unmap) { +mutex_unlock (&access->ioas_lock); + access->ops->unmap (access->data,0 ,ULONG_MAX ); +mutex_lock (&access->ioas_lock); + } +iopt_remove_access (&cur_ioas->iopt, access); +refcount_dec (&cur_ioas->obj.users); +out: + access->ioas_unpin =NULL ; +mutex_unlock (&access->ioas_lock); +} +EXPORT_SYMBOL_NS_GPL (iommufd_access_detach,IOMMUFD ); +int iommufd_access_attach (struct iommufd_access *access,u32 ioas_id) {struct iommufd_ioas *new_ioas;int rc =0 ; -if (access->ioas) +mutex_lock (&access->ioas_lock); +if (WARN_ON (access->ioas || access->ioas_unpin)) { +mutex_unlock (&access->ioas_lock);return -EINVAL ; + } new_ioas =iommufd_get_ioas (access->ictx, ioas_id); -if (IS_ERR (new_ioas)) +if (IS_ERR (new_ioas)) { +mutex_unlock (&access->ioas_lock);return PTR_ERR (new_ioas); + } rc =iopt_add_access (&new_ioas->iopt, access);if (rc) { +mutex_unlock (&access->ioas_lock);iommufd_put_object (&new_ioas->obj);return rc; }iommufd_ref_to_users (&new_ioas->obj); access->ioas = new_ioas; + access->ioas_unpin = new_ioas; +mutex_unlock (&access->ioas_lock);return 0 ; }EXPORT_SYMBOL_NS_GPL (iommufd_access_attach,IOMMUFD );
@@ -579,8 +614,8 @@ void iommufd_access_notify_unmap(struct io_pagetable *iopt, unsigned long iova,void iommufd_access_unpin_pages (struct iommufd_access *access,unsigned long iova,unsigned long length) { -struct io_pagetable *iopt = &access->ioas->iopt;struct iopt_area_contig_iter iter; +struct io_pagetable *iopt;unsigned long last_iova;struct iopt_area *area;
@@ -588,6 +623,17 @@ void iommufd_access_unpin_pages(struct iommufd_access *access, WARN_ON(check_add_overflow(iova, length - 1, &last_iova))) return; +mutex_lock (&access->ioas_lock); +/* +* The driver must be doing something wrong if it calls this before an +* iommufd_access_attach() or after an iommufd_access_detach(). +*/ +if (WARN_ON (!access->ioas_unpin)) { +mutex_unlock (&access->ioas_lock); +return ; + } + iopt = &access->ioas_unpin->iopt; +down_read (&iopt->iova_rwsem);iopt_for_each_contig_area (&iter, area, iopt, iova, last_iova) iopt_area_remove_access(
@@ -597,6 +643,7 @@ void iommufd_access_unpin_pages(struct iommufd_access *access, min(last_iova, iopt_area_last_iova(area))));WARN_ON (!iopt_area_contig_done (&iter));up_read (&iopt->iova_rwsem); +mutex_unlock (&access->ioas_lock); }EXPORT_SYMBOL_NS_GPL (iommufd_access_unpin_pages,IOMMUFD );
@@ -642,8 +689,8 @@ int iommufd_access_pin_pages(struct iommufd_access *access, unsigned long iova, unsigned long length, struct page **out_pages, unsigned int flags) { - struct io_pagetable *iopt = &access->ioas->iopt; struct iopt_area_contig_iter iter; +struct io_pagetable *iopt;unsigned long last_iova;struct iopt_area *area;int rc;
@@ -658,6 +705,13 @@ int iommufd_access_pin_pages(struct iommufd_access *access, unsigned long iova,if (check_add_overflow (iova, length -1 , &last_iova))return -EOVERFLOW ; +mutex_lock (&access->ioas_lock); +if (!access->ioas) { +mutex_unlock (&access->ioas_lock); +return -ENOENT ; + } + iopt = &access->ioas->iopt; +down_read (&iopt->iova_rwsem);iopt_for_each_contig_area (&iter, area, iopt, iova, last_iova) {unsigned long last =min (last_iova,iopt_area_last_iova (area));
@@ -688,6 +742,7 @@ int iommufd_access_pin_pages(struct iommufd_access *access, unsigned long iova, }up_read (&iopt->iova_rwsem); +mutex_unlock (&access->ioas_lock);return 0 ; err_remove:
@@ -702,6 +757,7 @@ int iommufd_access_pin_pages(struct iommufd_access *access, unsigned long iova, iopt_area_last_iova(area)))); }up_read (&iopt->iova_rwsem); +mutex_unlock (&access->ioas_lock);return rc; }EXPORT_SYMBOL_NS_GPL (iommufd_access_pin_pages,IOMMUFD );
@@ -721,8 +777,8 @@ EXPORT_SYMBOL_NS_GPL(iommufd_access_pin_pages, IOMMUFD);int iommufd_access_rw (struct iommufd_access *access,unsigned long iova,void *data,size_t length,unsigned int flags) { -struct io_pagetable *iopt = &access->ioas->iopt;struct iopt_area_contig_iter iter; +struct io_pagetable *iopt;struct iopt_area *area;unsigned long last_iova;int rc;
@@ -732,6 +788,13 @@ int iommufd_access_rw(struct iommufd_access *access, unsigned long iova,if (check_add_overflow (iova, length -1 , &last_iova))return -EOVERFLOW ; +mutex_lock (&access->ioas_lock); +if (!access->ioas) { +mutex_unlock (&access->ioas_lock); +return -ENOENT ; + } + iopt = &access->ioas->iopt; +down_read (&iopt->iova_rwsem);iopt_for_each_contig_area (&iter, area, iopt, iova, last_iova) {unsigned long last =min (last_iova,iopt_area_last_iova (area));
@@ -758,6 +821,7 @@ int iommufd_access_rw(struct iommufd_access *access, unsigned long iova, rc = -ENOENT ; err_out:up_read (&iopt->iova_rwsem); +mutex_unlock (&access->ioas_lock);return rc; }EXPORT_SYMBOL_NS_GPL (iommufd_access_rw,IOMMUFD );
drivers/iommu/iommufd/iommufd_private.h +2 -0
@@ -285,6 +285,8 @@ struct iommufd_access {struct iommufd_object obj;struct iommufd_ctx *ictx;struct iommufd_ioas *ioas; +struct iommufd_ioas *ioas_unpin; +struct mutex ioas_lock;const struct iommufd_access_ops *ops;void *data;unsigned long iova_alignment;
include/linux/iommufd.h +1 -0
@@ -48,6 +48,7 @@ iommufd_access_create(struct iommufd_ctx *ictx, const struct iommufd_access_ops *ops, void *data, u32 *id);void iommufd_access_destroy (struct iommufd_access *access);int iommufd_access_attach (struct iommufd_access *access,u32 ioas_id); +void iommufd_access_detach (struct iommufd_access *access);void iommufd_ctx_get (struct iommufd_ctx *ictx);
Signature · 1 line
2.34.1
PATCH v15 15/26 vfio-iommufd: Add detach_ioas support for emulated VFIO devices
In reply to Yi LiuThis prepares for adding DETACH ioctl for emulated VFIO devices.
--- drivers/gpu/drm/i915/gvt/kvmgt.c | 1 + drivers/s390/cio/vfio_ccw_ops.c | 1 + drivers/s390/crypto/vfio_ap_ops.c | 1 + drivers/vfio/iommufd.c | 13 +++++++++++++ include/linux/vfio.h | 3 +++ samples/vfio-mdev/mbochs.c | 1 + samples/vfio-mdev/mdpy.c | 1 + samples/vfio-mdev/mtty.c | 1 + 8 files changed, 22 insertions(+)
drivers/gpu/drm/i915/gvt/kvmgt.c +1 -0
@@ -1474,6 +1474,7 @@ static const struct vfio_device_ops intel_vgpu_dev_ops = { .bind_iommufd = vfio_iommufd_emulated_bind, .unbind_iommufd = vfio_iommufd_emulated_unbind, .attach_ioas = vfio_iommufd_emulated_attach_ioas, + .detach_ioas = vfio_iommufd_emulated_detach_ioas, };static int intel_vgpu_probe (struct mdev_device *mdev)
drivers/s390/cio/vfio_ccw_ops.c +1 -0
@@ -632,6 +632,7 @@ static const struct vfio_device_ops vfio_ccw_dev_ops = { .bind_iommufd = vfio_iommufd_emulated_bind, .unbind_iommufd = vfio_iommufd_emulated_unbind, .attach_ioas = vfio_iommufd_emulated_attach_ioas, + .detach_ioas = vfio_iommufd_emulated_detach_ioas, };struct mdev_driver vfio_ccw_mdev_driver = {
drivers/s390/crypto/vfio_ap_ops.c +1 -0
@@ -1975,6 +1975,7 @@ static const struct vfio_device_ops vfio_ap_matrix_dev_ops = { .bind_iommufd = vfio_iommufd_emulated_bind, .unbind_iommufd = vfio_iommufd_emulated_unbind, .attach_ioas = vfio_iommufd_emulated_attach_ioas, + .detach_ioas = vfio_iommufd_emulated_detach_ioas, .request = vfio_ap_mdev_request };
drivers/vfio/iommufd.c +13 -0
@@ -231,3 +231,16 @@ int vfio_iommufd_emulated_attach_ioas(struct vfio_device *vdev, u32 *pt_id)return 0 ; }EXPORT_SYMBOL_GPL (vfio_iommufd_emulated_attach_ioas); + +void vfio_iommufd_emulated_detach_ioas (struct vfio_device *vdev) +{ +lockdep_assert_held (&vdev->dev_set->lock); + +if (WARN_ON (!vdev->iommufd_access) || + !vdev->iommufd_attached) +return ; + +iommufd_access_detach (vdev->iommufd_access); + vdev->iommufd_attached = false; +} +EXPORT_SYMBOL_GPL (vfio_iommufd_emulated_detach_ioas);
include/linux/vfio.h +3 -0
@@ -128,6 +128,7 @@ int vfio_iommufd_emulated_bind(struct vfio_device *vdev, struct iommufd_ctx *ictx, u32 *out_device_id);void vfio_iommufd_emulated_unbind (struct vfio_device *vdev);int vfio_iommufd_emulated_attach_ioas (struct vfio_device *vdev,u32 *pt_id); +void vfio_iommufd_emulated_detach_ioas (struct vfio_device *vdev);#else static inline struct iommufd_ctx *vfio_iommufd_device_ictx (struct vfio_device *vdev)
@@ -157,6 +158,8 @@ vfio_iommufd_get_dev_id(struct vfio_device *vdev, struct iommufd_ctx *ictx) ((void (*)(struct vfio_device *vdev)) NULL)#define vfio_iommufd_emulated_attach_ioas \ ((int (*)(struct vfio_device *vdev, u32 *pt_id)) NULL) +#define vfio_iommufd_emulated_detach_ioas \ + ((void (*)(struct vfio_device *vdev)) NULL)#endif static inline bool vfio_device_cdev_opened (struct vfio_device *device)
samples/vfio-mdev/mbochs.c +1 -0
@@ -1377,6 +1377,7 @@ static const struct vfio_device_ops mbochs_dev_ops = { .bind_iommufd = vfio_iommufd_emulated_bind, .unbind_iommufd = vfio_iommufd_emulated_unbind, .attach_ioas = vfio_iommufd_emulated_attach_ioas, + .detach_ioas = vfio_iommufd_emulated_detach_ioas, };static struct mdev_driver mbochs_driver = {
samples/vfio-mdev/mdpy.c +1 -0
@@ -666,6 +666,7 @@ static const struct vfio_device_ops mdpy_dev_ops = { .bind_iommufd = vfio_iommufd_emulated_bind, .unbind_iommufd = vfio_iommufd_emulated_unbind, .attach_ioas = vfio_iommufd_emulated_attach_ioas, + .detach_ioas = vfio_iommufd_emulated_detach_ioas, };static struct mdev_driver mdpy_driver = {
samples/vfio-mdev/mtty.c +1 -0
@@ -1272,6 +1272,7 @@ static const struct vfio_device_ops mtty_dev_ops = { .bind_iommufd = vfio_iommufd_emulated_bind, .unbind_iommufd = vfio_iommufd_emulated_unbind, .attach_ioas = vfio_iommufd_emulated_attach_ioas, + .detach_ioas = vfio_iommufd_emulated_detach_ioas, };static struct mdev_driver mtty_driver = {
Signature · 1 line
2.34.1
PATCH v15 16/26 vfio: Move vfio_device_group_unregister() to be the first operation in unregister
In reply to Yi LiuThis avoids endless vfio_device refcount increment by userspace, which would keep blocking the vfio_unregister_group_dev().
--- drivers/vfio/vfio_main.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
drivers/vfio/vfio_main.c +6 -2
@@ -332,6 +332,12 @@ void vfio_unregister_group_dev(struct vfio_device *device)bool interrupted = false;long rc; +/* +* Prevent new device opened by userspace via the +* VFIO_GROUP_GET_DEVICE_FD in the group path. +*/ +vfio_device_group_unregister (device); +vfio_device_put_registration (device); rc =try_wait_for_completion (&device->comp);while (rc <=0 ) {
@@ -355,8 +361,6 @@ void vfio_unregister_group_dev(struct vfio_device *device) } } -vfio_device_group_unregister (device); -/* Balances device_add in register path */ device_del (&device->device);
Signature · 1 line
2.34.1
PATCH v15 17/26 vfio: Move device_del() before waiting for the last vfio_device registration refcount
In reply to Yi Liudevice_del() destroys the vfio-dev/vfioX under the sysfs for vfio_device. There is no reason to keep it while the device is going to be unregistered.
This movement is also a preparation for adding vfio_device cdev. Kernel should remove the cdev node of the vfio_device to avoid new registration refcount increment while the device is going to be unregistered.
--- drivers/vfio/vfio_main.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/vfio/vfio_main.c +3 -3
@@ -338,6 +338,9 @@ void vfio_unregister_group_dev(struct vfio_device *device)*/ vfio_device_group_unregister (device); +/* Balances device_add in register path */ +device_del (&device->device); +vfio_device_put_registration (device); rc =try_wait_for_completion (&device->comp);while (rc <=0 ) {
@@ -361,9 +364,6 @@ void vfio_unregister_group_dev(struct vfio_device *device) } } -/* Balances device_add in register path */ -device_del (&device->device); -/* Balances vfio_device_set_group in register path */ vfio_device_remove_group (device); }
Signature · 1 line
2.34.1
PATCH v15 18/26 vfio: Add cdev for vfio_device
In reply to Yi LiuThis adds cdev support for vfio_device. It allows the user to directly open a vfio device w/o using the legacy container/group interface, as a prerequisite for supporting new iommu features like nested translation and etc.
The device fd opened in this manner doesn't have the capability to access the device as the fops open() doesn't open the device until the successful VFIO_DEVICE_BIND_IOMMUFD ioctl which will be added in a later patch.
With this patch, devices registered to vfio core would have both the legacy group and the new device interfaces created.
- group interface : /dev/vfio/$groupID
- device interface: /dev/vfio/devices/vfioX - normal device ("X" is a unique number across vfio devices)
For a given device, the user can identify the matching vfioX by searching the vfio-dev folder under the sysfs path of the device. Take PCI device (0000:6a:01.0) as an example, /sys/bus/pci/devices/0000\:6a\:01.0/vfio-dev/vfioX implies the matching vfioX under /dev/vfio/devices/, and vfio-dev/vfioX/dev contains the major:minor number of the matching /dev/vfio/devices/vfioX. The user can get device fd by opening the /dev/vfio/devices/vfioX.
The vfio_device cdev logic in this patch:
*) __vfio_register_dev() path ends up doing cdev_device_add() for each
vfio_device if VFIO_DEVICE_CDEV configured.
*) vfio_unregister_group_dev() path does cdev_device_del();
cdev interface does not support noiommu devices, so VFIO only creates the legacy group interface for the physical devices that do not have IOMMU. noiommu users should use the legacy group interface.
--- drivers/vfio/Kconfig | 12 ++++++++ drivers/vfio/Makefile | 1 + drivers/vfio/device_cdev.c | 63 ++++++++++++++++++++++++++++++++++++++ drivers/vfio/vfio.h | 54 ++++++++++++++++++++++++++++++++ drivers/vfio/vfio_main.c | 21 ++++++++++--- include/linux/vfio.h | 4 +++ 6 files changed, 151 insertions(+), 4 deletions(-) create mode 100644 drivers/vfio/device_cdev.c
drivers/vfio/Kconfig +12 -0
@@ -12,6 +12,18 @@ menuconfig VFIO If you don't know what to do here, say N. if VFIO +config VFIO_DEVICE_CDEV + bool "Support for the VFIO cdev /dev/vfio/devices/vfioX" + depends on IOMMUFD && !SPAPR_TCE_IOMMU + help + The VFIO device cdev is another way for userspace to get device + access. Userspace gets device fd by opening device cdev under + /dev/vfio/devices/vfioX, and then bind the device fd with an iommufd + to set up secure DMA context for device access. This interface does + not support noiommu. + + If you don't know what to do here, say N. + config VFIO_CONTAINER bool "Support for the VFIO container /dev/vfio/vfio" select VFIO_IOMMU_TYPE1 if MMU && (X86 || S390 || ARM || ARM64)
drivers/vfio/Makefile +1 -0
@@ -4,6 +4,7 @@ obj-$(CONFIG_VFIO) += vfio.o vfio-y += vfio_main.o \ group.o \ iova_bitmap.o +vfio-$(CONFIG_VFIO_DEVICE_CDEV) += device_cdev.o vfio-$(CONFIG_IOMMUFD) += iommufd.o vfio-$(CONFIG_VFIO_CONTAINER) += container.o vfio-$(CONFIG_VFIO_VIRQFD) += virqfd.o
drivers/vfio/device_cdev.c new file +63 -0
63 lines not on this page · raw message
drivers/vfio/vfio.h +54 -0
60 lines not on this page · raw message
drivers/vfio/vfio_main.c +17 -4
@@ -292,7 +292,7 @@ static int __vfio_register_dev(struct vfio_device *device,if (ret)return ret; - ret =device_add (&device->device); + ret =vfio_device_add (device);if (ret) goto err_out;
@@ -338,8 +338,11 @@ void vfio_unregister_group_dev(struct vfio_device *device)*/ vfio_device_group_unregister (device); -/* Balances device_add in register path */ -device_del (&device->device); +/* +* Balances vfio_device_add() in register path, also prevents +* new device opened by userspace in the cdev path. +*/ +vfio_device_del (device);vfio_device_put_registration (device); rc =try_wait_for_completion (&device->comp);
@@ -567,7 +570,8 @@ static int vfio_device_fops_release(struct inode *inode, struct file *filep)struct vfio_device_file *df = filep->private_data;struct vfio_device *device = df->device; -vfio_df_group_close (df); +if (df->group) +vfio_df_group_close (df);vfio_device_put_registration (device);
@@ -1216,6 +1220,7 @@ static int vfio_device_fops_mmap(struct file *filep, struct vm_area_struct *vma)const struct file_operations vfio_device_fops = { .owner =THIS_MODULE , + .open = vfio_device_fops_cdev_open, .release = vfio_device_fops_release, .read = vfio_device_fops_read, .write = vfio_device_fops_write,
@@ -1567,9 +1572,16 @@ static int __init vfio_init(void) goto err_dev_class; } + ret =vfio_cdev_init (vfio.device_class); +if (ret) + goto err_alloc_dev_chrdev; +pr_info (DRIVER_DESC " version: " DRIVER_VERSION "\n" );return 0 ; +err_alloc_dev_chrdev: +class_destroy (vfio.device_class); + vfio.device_class =NULL ; err_dev_class:vfio_virqfd_exit (); err_virqfd:
@@ -1580,6 +1592,7 @@ static int __init vfio_init(void) static void __exit vfio_cleanup(void) {ida_destroy (&vfio.device_ida); +vfio_cdev_cleanup ();class_destroy (vfio.device_class); vfio.device_class =NULL ;vfio_virqfd_exit ();
include/linux/vfio.h +4 -0
@@ -13,6 +13,7 @@#include <linux/mm.h> #include <linux/workqueue.h> #include <linux/poll.h> +#include <linux/cdev.h> #include <uapi/linux/vfio.h> #include <linux/iova_bitmap.h>
@@ -51,6 +52,9 @@ struct vfio_device {/* Members below here are private, not for driver use */ unsigned int index;struct device device;/* device.kref covers object life circle */ +#if IS_ENABLED (CONFIG_VFIO_DEVICE_CDEV ) +struct cdev cdev; +#endif refcount_t refcount;/* user count on registered device*/ unsigned int open_count;struct completion comp;
Signature · 1 line
2.34.1
PATCH v15 19/26 vfio: Test kvm pointer in _vfio_device_get_kvm_safe()
In reply to Yi LiuThis saves some lines when adding the kvm get logic for the vfio_device cdev path.
This also renames _vfio_device_get_kvm_safe() to be vfio_device_get_kvm_safe().
--- drivers/vfio/group.c | 7 +------ drivers/vfio/vfio.h | 6 +++--- drivers/vfio/vfio_main.c | 5 ++++- 3 files changed, 8 insertions(+), 10 deletions(-)
drivers/vfio/group.c +1 -6
@@ -160,12 +160,7 @@ static int vfio_group_ioctl_set_container(struct vfio_group *group,static void vfio_device_group_get_kvm_safe (struct vfio_device *device) {spin_lock (&device->group->kvm_ref_lock); -if (!device->group->kvm) - goto unlock; - -_vfio_device_get_kvm_safe (device, device->group->kvm); - -unlock: +vfio_device_get_kvm_safe (device, device->group->kvm);spin_unlock (&device->group->kvm_ref_lock); }
drivers/vfio/vfio.h +3 -3
@@ -340,11 +340,11 @@ enum { vfio_noiommu = false };#endif #ifdef CONFIG_HAVE_KVM -void _vfio_device_get_kvm_safe (struct vfio_device *device,struct kvm *kvm); +void vfio_device_get_kvm_safe (struct vfio_device *device,struct kvm *kvm);void vfio_device_put_kvm (struct vfio_device *device);#else -static inline void _vfio_device_get_kvm_safe (struct vfio_device *device, -struct kvm *kvm) +static inline void vfio_device_get_kvm_safe (struct vfio_device *device, +struct kvm *kvm) { }
drivers/vfio/vfio_main.c +4 -1
@@ -373,7 +373,7 @@ void vfio_unregister_group_dev(struct vfio_device *device)EXPORT_SYMBOL_GPL (vfio_unregister_group_dev);#ifdef CONFIG_HAVE_KVM -void _vfio_device_get_kvm_safe (struct vfio_device *device,struct kvm *kvm) +void vfio_device_get_kvm_safe (struct vfio_device *device,struct kvm *kvm) {void (*pfn)(struct kvm *kvm);bool (*fn)(struct kvm *kvm);
@@ -381,6 +381,9 @@ void _vfio_device_get_kvm_safe(struct vfio_device *device, struct kvm *kvm)lockdep_assert_held (&device->dev_set->lock); +if (!kvm) +return ; + pfn =symbol_get (kvm_put_kvm);if (WARN_ON (!pfn))return ;
Signature · 1 line
2.34.1
PATCH v15 20/26 iommufd: Add iommufd_ctx_from_fd()
In reply to Yi LiuIt's common to get a reference to the iommufd context from a given file descriptor. So adds an API for it. Existing users of this API are compiled only when IOMMUFD is enabled, so no need to have a stub for the IOMMUFD disabled case.
--- drivers/iommu/iommufd/main.c | 24 ++++++++++++++++++++++++ include/linux/iommufd.h | 1 + 2 files changed, 25 insertions(+)
drivers/iommu/iommufd/main.c +24 -0
@@ -377,6 +377,30 @@ struct iommufd_ctx *iommufd_ctx_from_file(struct file *file) }EXPORT_SYMBOL_NS_GPL (iommufd_ctx_from_file,IOMMUFD ); +/** +* iommufd_ctx_from_fd - Acquires a reference to the iommufd context +* @fd: File descriptor to obtain the reference from +* +* Returns a pointer to the iommufd_ctx, otherwise ERR_PTR. On success +* the caller is responsible to call iommufd_ctx_put(). +*/ +struct iommufd_ctx *iommufd_ctx_from_fd (int fd) +{ +struct file *file; + + file =fget (fd); +if (!file) +return ERR_PTR (-EBADF ); + +if (file->f_op != &iommufd_fops) { +fput (file); +return ERR_PTR (-EBADFD ); + } +/* fget is the same as iommufd_ctx_get() */ +return file->private_data; +} +EXPORT_SYMBOL_NS_GPL (iommufd_ctx_from_fd,IOMMUFD ); +/** * iommufd_ctx_put - Put back a reference * @ictx: Context to put back
include/linux/iommufd.h +1 -0
@@ -54,6 +54,7 @@ void iommufd_ctx_get(struct iommufd_ctx *ictx);#if IS_ENABLED (CONFIG_IOMMUFD )struct iommufd_ctx *iommufd_ctx_from_file (struct file *file); +struct iommufd_ctx *iommufd_ctx_from_fd (int fd);void iommufd_ctx_put (struct iommufd_ctx *ictx);bool iommufd_ctx_has_group (struct iommufd_ctx *ictx,struct iommu_group *group);
Signature · 1 line
2.34.1
Re: [Intel-gfx] [PATCH v15 20/26] iommufd: Add iommufd_ctx_from_fd()
Quoted 10 lines · Yi Liu
It's common to get a reference to the iommufd context from a given file descriptor. So adds an API for it. Existing users of this API are compiled only when IOMMUFD is enabled, so no need to have a stub for the IOMMUFD disabled case.
Signed-off-by Yi Liu <[email protected]>--- drivers/iommu/iommufd/main.c | 24 ++++++++++++++++++++++++ include/linux/iommufd.h | 1 + 2 files changed, 25 insertions(+)
Jason
PATCH v15 21/26 vfio: Avoid repeated user pointer cast in vfio_device_fops_unl_ioctl()
In reply to Yi LiuThis adds a local variable to store the user pointer cast result from arg. It avoids the repeated casts in the code when more ioctls are added.
--- drivers/vfio/vfio_main.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/vfio/vfio_main.c +2 -1
@@ -1146,6 +1146,7 @@ static long vfio_device_fops_unl_ioctl(struct file *filep, {struct vfio_device_file *df = filep->private_data;struct vfio_device *device = df->device; +void __user *uptr = (void __user *)arg;int ret;/* Paired with smp_store_release() following vfio_df_open() */
@@ -1158,7 +1159,7 @@ static long vfio_device_fops_unl_ioctl(struct file *filep,switch (cmd) {case VFIO_DEVICE_FEATURE : - ret =vfio_ioctl_device_feature (device, (void __user *)arg); + ret =vfio_ioctl_device_feature (device, uptr);break ;default :
Signature · 1 line
2.34.1
PATCH v15 22/26 vfio: Add VFIO_DEVICE_BIND_IOMMUFD
In reply to Yi LiuThis adds ioctl for userspace to bind device cdev fd to iommufd.
VFIO_DEVICE_BIND_IOMMUFD: bind device to an iommufd, hence gain DMA
control provided by the iommufd. open_device op is called after bind_iommufd op.
--- drivers/vfio/device_cdev.c | 107 +++++++++++++++++++++++++++++++++++++ drivers/vfio/vfio.h | 13 +++++ drivers/vfio/vfio_main.c | 5 ++ include/linux/vfio.h | 5 +- include/uapi/linux/vfio.h | 27 ++++++++++ 5 files changed, 155 insertions(+), 2 deletions(-)
drivers/vfio/device_cdev.c +107 -0
@@ -3,6 +3,7 @@* Copyright (c) 2023 Intel Corporation. */ #include <linux/vfio.h> +#include <linux/iommufd.h> #include "vfio.h"
@@ -45,6 +46,112 @@ int vfio_device_fops_cdev_open(struct inode *inode, struct file *filep)return ret; } +static void vfio_df_get_kvm_safe (struct vfio_device_file *df) +{ +spin_lock (&df->kvm_ref_lock); +vfio_device_get_kvm_safe (df->device, df->kvm); +spin_unlock (&df->kvm_ref_lock); +} + +long vfio_df_ioctl_bind_iommufd (struct vfio_device_file *df, +struct vfio_device_bind_iommufd __user *arg) +{ +struct vfio_device *device = df->device; +struct vfio_device_bind_iommufd bind; +unsigned long minsz; +int ret; + +static_assert (__same_type (arg->out_devid, df->devid)); + + minsz = offsetofend(struct vfio_device_bind_iommufd, out_devid); + +if (copy_from_user (&bind, arg, minsz)) +return -EFAULT ; + +if (bind.argsz < minsz || bind.flags || bind.iommufd <0 ) +return -EINVAL ; + +/* BIND_IOMMUFD only allowed for cdev fds */ +if (df->group) +return -EINVAL ; + + ret =vfio_device_block_group (device); +if (ret) +return ret; + +mutex_lock (&device->dev_set->lock); +/* one device cannot be bound twice */ +if (df->access_granted) { + ret = -EINVAL ; + goto out_unlock; + } + + df->iommufd =iommufd_ctx_from_fd (bind.iommufd); +if (IS_ERR (df->iommufd)) { + ret =PTR_ERR (df->iommufd); + df->iommufd =NULL ; + goto out_unlock; + } + +/* +* Before the device open, get the KVM pointer currently +* associated with the device file (if there is) and obtain +* a reference. This reference is held until device closed. +* Save the pointer in the device for use by drivers. +*/ +vfio_df_get_kvm_safe (df); + + ret =vfio_df_open (df); +if (ret) + goto out_put_kvm; + + ret =copy_to_user (&arg->out_devid, &df->devid, +sizeof (df->devid)) ? -EFAULT :0 ; +if (ret) + goto out_close_device; + + device->cdev_opened = true; +/* +* Paired with smp_load_acquire() in vfio_device_fops::ioctl/ +* read/write/mmap +*/ +smp_store_release (&df->access_granted, true); +mutex_unlock (&device->dev_set->lock); +return 0 ; + +out_close_device: +vfio_df_close (df); +out_put_kvm: +vfio_device_put_kvm (device); +iommufd_ctx_put (df->iommufd); + df->iommufd =NULL ; +out_unlock: +mutex_unlock (&device->dev_set->lock); +vfio_device_unblock_group (device); +return ret; +} + +void vfio_df_unbind_iommufd (struct vfio_device_file *df) +{ +struct vfio_device *device = df->device; + +/* +* In the time of close, there is no contention with another one +* changing this flag. So read df->access_granted without lock +* and no smp_load_acquire() is ok. +*/ +if (!df->access_granted) +return ; + +mutex_lock (&device->dev_set->lock); +vfio_df_close (df); +vfio_device_put_kvm (device); +iommufd_ctx_put (df->iommufd); + device->cdev_opened = false; +mutex_unlock (&device->dev_set->lock); +vfio_device_unblock_group (device); +} +static char *vfio_device_devnode (const struct device *dev,umode_t *mode) {return kasprintf (GFP_KERNEL ,"vfio/devices/%s" ,dev_name (dev));
drivers/vfio/vfio.h +13 -0
@@ -287,6 +287,9 @@ static inline void vfio_device_del(struct vfio_device *device) }int vfio_device_fops_cdev_open (struct inode *inode,struct file *filep); +long vfio_df_ioctl_bind_iommufd (struct vfio_device_file *df, +struct vfio_device_bind_iommufd __user *arg); +void vfio_df_unbind_iommufd (struct vfio_device_file *df);int vfio_cdev_init (struct class *device_class);void vfio_cdev_cleanup (void );#else
@@ -310,6 +313,16 @@ static inline int vfio_device_fops_cdev_open(struct inode *inode,return 0 ; } +static inline long vfio_df_ioctl_bind_iommufd (struct vfio_device_file *df, +struct vfio_device_bind_iommufd __user *arg) +{ +return -ENOTTY ; +} + +static inline void vfio_df_unbind_iommufd (struct vfio_device_file *df) +{ +} +static inline int vfio_cdev_init (struct class *device_class) {return 0 ;
drivers/vfio/vfio_main.c +5 -0
@@ -575,6 +575,8 @@ static int vfio_device_fops_release(struct inode *inode, struct file *filep)if (df->group)vfio_df_group_close (df); +else +vfio_df_unbind_iommufd (df);vfio_device_put_registration (device);
@@ -1149,6 +1151,9 @@ static long vfio_device_fops_unl_ioctl(struct file *filep,void __user *uptr = (void __user *)arg;int ret; +if (cmd ==VFIO_DEVICE_BIND_IOMMUFD ) +return vfio_df_ioctl_bind_iommufd (df, uptr); +/* Paired with smp_store_release() following vfio_df_open() */ if (!smp_load_acquire (&df->access_granted))return -EINVAL ;
include/linux/vfio.h +3 -2
@@ -64,8 +64,9 @@ struct vfio_device {void (*put_kvm)(struct kvm *kvm);#if IS_ENABLED (CONFIG_IOMMUFD )struct iommufd_device *iommufd_device; -bool iommufd_attached; + u8 iommufd_attached:1;#endif + u8 cdev_opened:1; };/**
@@ -168,7 +169,7 @@ vfio_iommufd_get_dev_id(struct vfio_device *vdev, struct iommufd_ctx *ictx)static inline bool vfio_device_cdev_opened (struct vfio_device *device) { -return false; +return device->cdev_opened; }/**
include/uapi/linux/vfio.h +27 -0
@@ -897,6 +897,33 @@ struct vfio_device_feature {#define VFIO_DEVICE_FEATURE _IO(VFIO_TYPE, VFIO_BASE + 17) +/* +* VFIO_DEVICE_BIND_IOMMUFD - _IOR(VFIO_TYPE, VFIO_BASE + 18, +* struct vfio_device_bind_iommufd) +* @argsz: User filled size of this data. +* @flags: Must be 0. +* @iommufd: iommufd to bind. +* @out_devid: The device id generated by this bind. devid is a handle for +* this device/iommufd bond and can be used in IOMMUFD commands. +* +* Bind a vfio_device to the specified iommufd. +* +* User is restricted from accessing the device before the binding operation +* is completed. Only allowed on cdev fds. +* +* Unbind is automatically conducted when device fd is closed. +* +* Return: 0 on success, -errno on failure. +*/ +struct vfio_device_bind_iommufd { +__u32 argsz; +__u32 flags; +__s32 iommufd; +__u32 out_devid; +}; + +#define VFIO_DEVICE_BIND_IOMMUFD _IO(VFIO_TYPE, VFIO_BASE + 18) +/* * Provide support for setting a PCI VF Token, which is used as a shared * secret between PF and VF drivers. This feature may only be set on a
Signature · 1 line
2.34.1
Re: [Intel-gfx] [PATCH v15 22/26] vfio: Add VFIO_DEVICE_BIND_IOMMUFD
Quoted 13 lines · Yi Liu
This adds ioctl for userspace to bind device cdev fd to iommufd.
VFIO_DEVICE_BIND_IOMMUFD: bind device to an iommufd, hence gain DMA
control provided by the iommufd.open_deviceop is called afterbind_iommufdop.Tested-by Nicolin Chen <[email protected]>Tested-by Matthew Rosato <[email protected]>Tested-by Yanting Jiang <[email protected]>Tested-by Shameer Kolothum <[email protected]>Tested-by Terrence Xu <[email protected]>Tested-by Zhenzhong Duan <[email protected]>Signed-off-by Yi Liu <[email protected]>
Quoted 7 lines
--- drivers/vfio/device_cdev.c | 107 +++++++++++++++++++++++++++++++++++++ drivers/vfio/vfio.h | 13 +++++ drivers/vfio/vfio_main.c | 5 ++ include/linux/vfio.h | 5 +- include/uapi/linux/vfio.h | 27 ++++++++++ 5 files changed, 155 insertions(+), 2 deletions(-)
Jason
PATCH v15 23/26 vfio: Add VFIO_DEVICE_[AT|DE]TACH_IOMMUFD_PT
In reply to Yi LiuThis adds ioctl for userspace to attach device cdev fd to and detach from IOAS/hw_pagetable managed by iommufd.
VFIO_DEVICE_ATTACH_IOMMUFD_PT: attach vfio device to IOAS or hw_pagetable
managed by iommufd. Attach can be undo by VFIO_DEVICE_DETACH_IOMMUFD_PT or device fd close.
VFIO_DEVICE_DETACH_IOMMUFD_PT: detach vfio device from the current attached
IOAS or hw_pagetable managed by iommufd.
--- drivers/vfio/device_cdev.c | 58 ++++++++++++++++++++++++++++++++++++++ drivers/vfio/vfio.h | 5 ++++ drivers/vfio/vfio_main.c | 15 +++++++++- include/uapi/linux/vfio.h | 44 +++++++++++++++++++++++++++++ 4 files changed, 121 insertions(+), 1 deletion(-)
drivers/vfio/device_cdev.c +58 -0
@@ -152,6 +152,64 @@ void vfio_df_unbind_iommufd(struct vfio_device_file *df)vfio_device_unblock_group (device); } +int vfio_df_ioctl_attach_pt (struct vfio_device_file *df, +struct vfio_device_attach_iommufd_pt __user *arg) +{ +struct vfio_device *device = df->device; +struct vfio_device_attach_iommufd_pt attach; +unsigned long minsz; +int ret; + + minsz = offsetofend(struct vfio_device_attach_iommufd_pt, pt_id); + +if (copy_from_user (&attach, arg, minsz)) +return -EFAULT ; + +if (attach.argsz < minsz || attach.flags) +return -EINVAL ; + +mutex_lock (&device->dev_set->lock); + ret = device->ops->attach_ioas (device, &attach.pt_id); +if (ret) + goto out_unlock; + +if (copy_to_user (&arg->pt_id, &attach.pt_id,sizeof (attach.pt_id))) { + ret = -EFAULT ; + goto out_detach; + } +mutex_unlock (&device->dev_set->lock); + +return 0 ; + +out_detach: + device->ops->detach_ioas (device); +out_unlock: +mutex_unlock (&device->dev_set->lock); +return ret; +} + +int vfio_df_ioctl_detach_pt (struct vfio_device_file *df, +struct vfio_device_detach_iommufd_pt __user *arg) +{ +struct vfio_device *device = df->device; +struct vfio_device_detach_iommufd_pt detach; +unsigned long minsz; + + minsz = offsetofend(struct vfio_device_detach_iommufd_pt, flags); + +if (copy_from_user (&detach, arg, minsz)) +return -EFAULT ; + +if (detach.argsz < minsz || detach.flags) +return -EINVAL ; + +mutex_lock (&device->dev_set->lock); + device->ops->detach_ioas (device); +mutex_unlock (&device->dev_set->lock); + +return 0 ; +} +static char *vfio_device_devnode (const struct device *dev,umode_t *mode) {return kasprintf (GFP_KERNEL ,"vfio/devices/%s" ,dev_name (dev));
drivers/vfio/vfio.h +5 -0
@@ -266,6 +266,11 @@ vfio_iommufd_compat_attach_ioas(struct vfio_device *device, }#endif +int vfio_df_ioctl_attach_pt (struct vfio_device_file *df, +struct vfio_device_attach_iommufd_pt __user *arg); +int vfio_df_ioctl_detach_pt (struct vfio_device_file *df, +struct vfio_device_detach_iommufd_pt __user *arg); +#if IS_ENABLED (CONFIG_VFIO_DEVICE_CDEV )void vfio_init_device_cdev (struct vfio_device *device);
drivers/vfio/vfio_main.c +14 -1
@@ -1162,6 +1162,19 @@ static long vfio_device_fops_unl_ioctl(struct file *filep,if (ret)return ret; +/* cdev only ioctls */ +if (IS_ENABLED (CONFIG_VFIO_DEVICE_CDEV ) && !df->group) { +switch (cmd) { +case VFIO_DEVICE_ATTACH_IOMMUFD_PT : + ret =vfio_df_ioctl_attach_pt (df, uptr); + goto out; + +case VFIO_DEVICE_DETACH_IOMMUFD_PT : + ret =vfio_df_ioctl_detach_pt (df, uptr); + goto out; + } + } +switch (cmd) {case VFIO_DEVICE_FEATURE : ret =vfio_ioctl_device_feature (device, uptr);
@@ -1174,7 +1187,7 @@ static long vfio_device_fops_unl_ioctl(struct file *filep, ret = device->ops->ioctl (device, cmd, arg);break ; } - +out:vfio_device_pm_runtime_put (device);return ret; }
include/uapi/linux/vfio.h +44 -0
50 lines not on this page · raw message
Signature · 1 line
2.34.1
PATCH v15 24/26 vfio: Move the IOMMU_CAP_CACHE_COHERENCY check in __vfio_register_dev()
In reply to Yi LiuThe IOMMU_CAP_CACHE_COHERENCY check only applies to the physical devices that are IOMMU-backed. But it is now in the group code. If want to compile vfio_group infrastructure out, this check needs to be moved out of the group code.
Another reason for this change is to fail the device registration for the physical devices that do not have IOMMU if the group code is not compiled as the cdev interface does not support such devices.
--- drivers/vfio/group.c | 10 ---------- drivers/vfio/vfio_main.c | 11 +++++++++++ 2 files changed, 11 insertions(+), 10 deletions(-)
drivers/vfio/group.c +0 -10
@@ -682,16 +682,6 @@ static struct vfio_group *vfio_group_find_or_alloc(struct device *dev)if (!iommu_group)return ERR_PTR (-EINVAL ); -/* -* VFIO always sets IOMMU_CACHE because we offer no way for userspace to -* restore cache coherency. It has to be checked here because it is only -* valid for cases where we are using iommu groups. -*/ -if (!device_iommu_capable (dev,IOMMU_CAP_CACHE_COHERENCY )) { -iommu_group_put (iommu_group); -return ERR_PTR (-EINVAL ); - } -mutex_lock (&vfio.group_lock); group =vfio_group_find_from_iommu (iommu_group);if (group) {
drivers/vfio/vfio_main.c +11 -0
@@ -292,6 +292,17 @@ static int __vfio_register_dev(struct vfio_device *device,if (ret)return ret; +/* +* VFIO always sets IOMMU_CACHE because we offer no way for userspace to +* restore cache coherency. It has to be checked here because it is only +* valid for cases where we are using iommu groups. +*/ +if (type ==VFIO_IOMMU && !vfio_device_is_noiommu (device) && + !device_iommu_capable (device->dev,IOMMU_CAP_CACHE_COHERENCY )) { + ret = -EINVAL ; + goto err_out; + } + ret =vfio_device_add (device);if (ret) goto err_out;
Signature · 1 line
2.34.1
PATCH v15 25/26 vfio: Compile vfio_group infrastructure optionally
In reply to Yi Liuvfio_group is not needed for vfio device cdev, so with vfio device cdev introduced, the vfio_group infrastructures can be compiled out if only cdev is needed.
--- drivers/iommu/iommufd/Kconfig | 4 +- drivers/vfio/Kconfig | 15 ++++++ drivers/vfio/Makefile | 2 +- drivers/vfio/vfio.h | 89 ++++++++++++++++++++++++++++++++--- include/linux/vfio.h | 25 ++++++++-- 5 files changed, 123 insertions(+), 12 deletions(-)
drivers/iommu/iommufd/Kconfig +2 -2
@@ -14,8 +14,8 @@ config IOMMUFD if IOMMUFD config IOMMUFD_VFIO_CONTAINER bool "IOMMUFD provides the VFIO container /dev/vfio/vfio" - depends on VFIO && !VFIO_CONTAINER - default VFIO && !VFIO_CONTAINER + depends on VFIO_GROUP && !VFIO_CONTAINER + default VFIO_GROUP && !VFIO_CONTAINER help IOMMUFD will provide /dev/vfio/vfio instead of VFIO. This relies on IOMMUFD providing compatibility emulation to give the same ioctls.
drivers/vfio/Kconfig +15 -0
@@ -4,6 +4,8 @@ menuconfig VFIO select IOMMU_API depends on IOMMUFD || !IOMMUFD select INTERVAL_TREE + select VFIO_GROUP if SPAPR_TCE_IOMMU || IOMMUFD=n + select VFIO_DEVICE_CDEV if !VFIO_GROUP select VFIO_CONTAINER if IOMMUFD=n help VFIO provides a framework for secure userspace device drivers.
@@ -15,6 +17,7 @@ if VFIO config VFIO_DEVICE_CDEV bool "Support for the VFIO cdev /dev/vfio/devices/vfioX" depends on IOMMUFD && !SPAPR_TCE_IOMMU + default !VFIO_GROUP help The VFIO device cdev is another way for userspace to get device access. Userspace gets device fd by opening device cdev under
@@ -24,9 +27,20 @@ config VFIO_DEVICE_CDEV If you don't know what to do here, say N. +config VFIO_GROUP + bool "Support for the VFIO group /dev/vfio/$group_id" + default y + help + VFIO group support provides the traditional model for accessing + devices through VFIO and is used by the majority of userspace + applications and drivers making use of VFIO. + + If you don't know what to do here, say Y. + config VFIO_CONTAINER bool "Support for the VFIO container /dev/vfio/vfio" select VFIO_IOMMU_TYPE1 if MMU && (X86 || S390 || ARM || ARM64) + depends on VFIO_GROUP default y help The VFIO container is the classic interface to VFIO for establishing
@@ -48,6 +62,7 @@ endif config VFIO_NOIOMMU bool "VFIO No-IOMMU support" + depends on VFIO_GROUP help VFIO is built on the ability to isolate devices using the IOMMU. Only with an IOMMU can userspace access to DMA capable devices be
drivers/vfio/Makefile +1 -1
@@ -2,9 +2,9 @@ obj-$(CONFIG_VFIO) += vfio.o vfio-y += vfio_main.o \ - group.o \ iova_bitmap.o vfio-$(CONFIG_VFIO_DEVICE_CDEV) += device_cdev.o +vfio-$(CONFIG_VFIO_GROUP) += group.o vfio-$(CONFIG_IOMMUFD) += iommufd.o vfio-$(CONFIG_VFIO_CONTAINER) += container.o vfio-$(CONFIG_VFIO_VIRQFD) += virqfd.o
drivers/vfio/vfio.h +83 -6
113 lines not on this page · raw message
include/linux/vfio.h +22 -3
@@ -43,7 +43,11 @@ struct vfio_device {*/ const struct vfio_migration_ops *mig_ops;const struct vfio_log_ops *log_ops; +#if IS_ENABLED (CONFIG_VFIO_GROUP )struct vfio_group *group; +struct list_head group_next; +struct list_head iommu_entry; +#endif struct vfio_device_set *dev_set;struct list_head dev_set_list;unsigned int migration_flags;
@@ -58,8 +62,6 @@ struct vfio_device {refcount_t refcount;/* user count on registered device*/ unsigned int open_count;struct completion comp; -struct list_head group_next; -struct list_head iommu_entry;struct iommufd_access *iommufd_access;void (*put_kvm)(struct kvm *kvm);#if IS_ENABLED (CONFIG_IOMMUFD )
@@ -284,12 +286,29 @@ int vfio_mig_get_next_state(struct vfio_device *device,/* * External user API */ +#if IS_ENABLED (CONFIG_VFIO_GROUP )struct iommu_group *vfio_file_iommu_group (struct file *file);bool vfio_file_is_group (struct file *file); +bool vfio_file_has_dev (struct file *file,struct vfio_device *device); +#else +static inline struct iommu_group *vfio_file_iommu_group (struct file *file) +{ +return NULL ; +} + +static inline bool vfio_file_is_group (struct file *file) +{ +return false; +} + +static inline bool vfio_file_has_dev (struct file *file,struct vfio_device *device) +{ +return false; +} +#endif bool vfio_file_is_valid (struct file *file);bool vfio_file_enforced_coherent (struct file *file);void vfio_file_set_kvm (struct file *file,struct kvm *kvm); -bool vfio_file_has_dev (struct file *file,struct vfio_device *device);#define VFIO_PIN_PAGES_MAX_ENTRIES (PAGE_SIZE/sizeof(unsigned long))
Signature · 1 line
2.34.1
PATCH v15 26/26 docs: vfio: Add vfio device cdev description
In reply to Yi LiuThis gives notes for userspace applications on device cdev usage.
--- Documentation/driver-api/vfio.rst | 139 ++++++++++++++++++++++++++++++ 1 file changed, 139 insertions(+)
Documentation/driver-api/vfio.rst +139 -0
@@ -239,6 +239,137 @@ group and can access them as follows:: /* Gratuitous device reset and go... */ ioctl(device, VFIO_DEVICE_RESET); +IOMMUFD and vfio_iommu_type1 +---------------------------- + +IOMMUFD is the new user API to manage I/O page tables from userspace. +It intends to be the portal of delivering advanced userspace DMA +features (nested translation [5]_, PASID [6]_, etc.) while also providing +a backwards compatibility interface for existing VFIO_TYPE1v2_IOMMU use +cases. Eventually the vfio_iommu_type1 driver, as well as the legacy +vfio container and group model is intended to be deprecated. + +The IOMMUFD backwards compatibility interface can be enabled two ways. +In the first method, the kernel can be configured with +CONFIG_IOMMUFD_VFIO_CONTAINER, in which case the IOMMUFD subsystem +transparently provides the entire infrastructure for the VFIO +container and IOMMU backend interfaces. The compatibility mode can +also be accessed if the VFIO container interface, ie. /dev/vfio/vfio is +simply symlink'd to /dev/iommu. Note that at the time of writing, the +compatibility mode is not entirely feature complete relative to +VFIO_TYPE1v2_IOMMU (ex. DMA mapping MMIO) and does not attempt to +provide compatibility to the VFIO_SPAPR_TCE_IOMMU interface. Therefore +it is not generally advisable at this time to switch from native VFIO +implementations to the IOMMUFD compatibility interfaces. + +Long term, VFIO users should migrate to device access through the cdev +interface described below, and native access through the IOMMUFD +provided interfaces. + +VFIO Device cdev +---------------- + +Traditionally user acquires a device fd via VFIO_GROUP_GET_DEVICE_FD +in a VFIO group. + +With CONFIG_VFIO_DEVICE_CDEV=y the user can now acquire a device fd +by directly opening a character device /dev/vfio/devices/vfioX where +"X" is the number allocated uniquely by VFIO for registered devices. +cdev interface does not support noiommu devices, so user should use +the legacy group interface if noiommu is wanted. + +The cdev only works with IOMMUFD. Both VFIO drivers and applications +must adapt to the new cdev security model which requires using +VFIO_DEVICE_BIND_IOMMUFD to claim DMA ownership before starting to +actually use the device. Once BIND succeeds then a VFIO device can +be fully accessed by the user. + +VFIO device cdev doesn't rely on VFIO group/container/iommu drivers. +Hence those modules can be fully compiled out in an environment +where no legacy VFIO application exists. + +So far SPAPR does not support IOMMUFD yet. So it cannot support device +cdev either. + +vfio device cdev access is still bound by IOMMU group semantics, ie. there +can be only one DMA owner for the group. Devices belonging to the same +group can not be bound to multiple iommufd_ctx or shared between native +kernel and vfio bus driver or other driver supporting the driver_managed_dma +flag. A violation of this ownership requirement will fail at the +VFIO_DEVICE_BIND_IOMMUFD ioctl, which gates full device access. + +Device cdev Example +------------------- + +Assume user wants to access PCI device 0000:6a:01.0:: + + $ ls /sys/bus/pci/devices/0000:6a:01.0/vfio-dev/ + vfio0 + +This device is therefore represented as vfio0. The user can verify +its existence:: + + $ ls -l /dev/vfio/devices/vfio0 + crw------- 1 root root 511, 0 Feb 16 01:22 /dev/vfio/devices/vfio0 + $ cat /sys/bus/pci/devices/0000:6a:01.0/vfio-dev/vfio0/dev + 511:0 + $ ls -l /dev/char/511\:0 + lrwxrwxrwx 1 root root 21 Feb 16 01:22 /dev/char/511:0 -> ../vfio/devices/vfio0 + +Then provide the user with access to the device if unprivileged +operation is desired:: + + $ chown user:user /dev/vfio/devices/vfio0 + +Finally the user could get cdev fd by:: + + cdev_fd = open("/dev/vfio/devices/vfio0", O_RDWR); + +An opened cdev_fd doesn't give the user any permission of accessing +the device except binding the cdev_fd to an iommufd. After that point +then the device is fully accessible including attaching it to an +IOMMUFD IOAS/HWPT to enable userspace DMA:: + + struct vfio_device_bind_iommufd bind = { + .argsz = sizeof(bind), + .flags = 0, + }; + struct iommu_ioas_alloc alloc_data = { + .size = sizeof(alloc_data), + .flags = 0, + }; + struct vfio_device_attach_iommufd_pt attach_data = { + .argsz = sizeof(attach_data), + .flags = 0, + }; + struct iommu_ioas_map map = { + .size = sizeof(map), + .flags = IOMMU_IOAS_MAP_READABLE | + IOMMU_IOAS_MAP_WRITEABLE | + IOMMU_IOAS_MAP_FIXED_IOVA, + .__reserved = 0, + }; + + iommufd = open("/dev/iommu", O_RDWR); + + bind.iommufd = iommufd; + ioctl(cdev_fd, VFIO_DEVICE_BIND_IOMMUFD, &bind); + + ioctl(iommufd, IOMMU_IOAS_ALLOC, &alloc_data); + attach_data.pt_id = alloc_data.out_ioas_id; + ioctl(cdev_fd, VFIO_DEVICE_ATTACH_IOMMUFD_PT, &attach_data); + + /* Allocate some space and setup a DMA mapping */ + map.user_va = (int64_t)mmap(0, 1024 * 1024, PROT_READ | PROT_WRITE, + MAP_PRIVATE | MAP_ANONYMOUS, 0, 0); + map.iova = 0; /* 1MB starting at 0x0 from device view */ + map.length = 1024 * 1024; + map.ioas_id = alloc_data.out_ioas_id;; + + ioctl(iommufd, IOMMU_IOAS_MAP, &map); + + /* Other device operations as stated in "VFIO Usage Example" */ + VFIO User API -------------------------------------------------------------------------------
@@ -566,3 +697,11 @@ This implementation has some specifics: \-0d.1 00:1e.0 PCI bridge: Intel Corporation 82801 PCI Bridge (rev 90) + +.. [5] Nested translation is an IOMMU feature which supports two stage + address translations. This improves the address translation efficiency + in IOMMU virtualization. + +.. [6] PASID stands for Process Address Space ID, introduced by PCI + Express. It is a prerequisite for Shared Virtual Addressing (SVA) + and Scalable I/O Virtualization (Scalable IOV).
Signature · 1 line
2.34.1
Patchwork
CI[Intel-gfx] ✗ Fi.CI.BUILD: failure for Add vfio_device cdev for iommufd support (rev19)
In reply to Yi Liu== Series Details ==
== Series Details ==
Series: Add vfio_device cdev for iommufd support (rev19)
URL : https://patchwork.freedesktop.org/series/113696/
State : failure
== Summary ==
Error: patch https://patchwork.freedesktop.org/api/1.0/series/113696/revisions/19/mbox/ not applied
Applying: vfio: Allocate per device file structure
Applying: vfio: Refine vfio file kAPIs for KVM
Applying: vfio: Accept vfio device file in the KVM facing kAPI
Applying: kvm/vfio: Prepare for accepting vfio device fd
Applying: kvm/vfio: Accept vfio device file from userspace
Applying: vfio: Pass struct vfio_device_file * to vfio_device_open/close()
Applying: vfio: Block device access via device fd until device is opened
Applying: vfio: Add cdev_device_open_cnt to vfio_group
Applying: vfio: Make vfio_df_open() single open for device cdev path
Applying: vfio-iommufd: Move noiommu compat validation out of vfio_iommufd_bind()
Applying: vfio-iommufd: Split bind/attach into two steps
Applying: vfio: Record devid in vfio_device_file
Applying: vfio-iommufd: Add detach_ioas support for physical VFIO devices
Applying: iommufd/device: Add iommufd_access_detach() API
Applying: vfio-iommufd: Add detach_ioas support for emulated VFIO devices
error: sha1 information is lacking or useless (drivers/vfio/iommufd.c).
error: could not build fake ancestor
hint: Use 'git am --show-current-patch=diff' to see the failed patch
Patch failed at 0015 vfio-iommufd: Add detach_ioas support for emulated VFIO devices When you have resolved this problem, run "git am --continue".
If you prefer to skip this patch, run "git am --skip" instead.
To restore the original branch and stop patching, run "git am --abort".
Build failed, no error log produced
Jason Gunthorpe
maintainerQuoted 25 lines · Yi Liu
Existing VFIO provides group-centric user APIs for userspace. Userspace opens the
/dev/vfio/$group_idfirst before getting device fd and hence getting access to device. This is not the desired model for iommufd. Per the conclusion of community discussion[1], iommufd provides device-centric kAPIs and requires its consumer (like VFIO) to be device-centric user APIs. Such user APIs are used to associate device with iommufd and also the I/O address spaces managed by the iommufd.This series first introduces a per device file structure to be prepared for further enhancement and refactors the kvm-vfio code to be prepared for accepting device file from userspace. After this, adds a mechanism for blocking device access before iommufd bind. Then refactors the vfio to be able to handle cdev paths (e.g. iommufd binding, no-iommufd, [de]attach ioas). This refactor includes making the
device_openexclusive between the group and the cdev path, only allow single device open in cdev path; vfio-iommufd code is also refactored to support cdev. e.g. split thevfio_iommufd_bind()into two steps. Eventually, adds the cdev support for vfio device and the new ioctls, then makes group infrastructure optional as it is not needed when vfio device cdev is compiled.This series is based on some preparation works done to vfio emulated devices[2] and vfio pci hot reset enhancements[3]. Per discussion[4], this series does not support cdev for physical devices that do not have IOMMU. Such devices only have group-centric user APIs.
Quoted 8 lines
This series is a prerequisite for iommu nesting for vfio device[5] [6].
The complete code can be found in below branch, simple tests done to the legacy group path and the cdev path. QEMU changes are in upstreaming[7] and the complete code can be found at[8]
https://github.com/yiliu1765/iommufd/tree/vfio_device_cdev_v15
(configCONFIG_IOMMUFD=yCONFIG_VFIO_DEVICE_CDEV=y)
Alex, if you are still good with this lets make this into a shared branch, do you want to do it or would you like a PR from me?
Thanks,
Jason
Quoted 32 lines · On Tue, 18 Jul 2023 13:57:46 -0300 Jason Gunthorpe <[email protected]> wrote:
Quoted 31 lines · Yi Liu
Existing VFIO provides group-centric user APIs for userspace. Userspace opens the
/dev/vfio/$group_idfirst before getting device fd and hence getting access to device. This is not the desired model for iommufd. Per the conclusion of community discussion[1], iommufd provides device-centric kAPIs and requires its consumer (like VFIO) to be device-centric user APIs. Such user APIs are used to associate device with iommufd and also the I/O address spaces managed by the iommufd.This series first introduces a per device file structure to be prepared for further enhancement and refactors the kvm-vfio code to be prepared for accepting device file from userspace. After this, adds a mechanism for blocking device access before iommufd bind. Then refactors the vfio to be able to handle cdev paths (e.g. iommufd binding, no-iommufd, [de]attach ioas). This refactor includes making the
device_openexclusive between the group and the cdev path, only allow single device open in cdev path; vfio-iommufd code is also refactored to support cdev. e.g. split thevfio_iommufd_bind()into two steps. Eventually, adds the cdev support for vfio device and the new ioctls, then makes group infrastructure optional as it is not needed when vfio device cdev is compiled.This series is based on some preparation works done to vfio emulated devices[2] and vfio pci hot reset enhancements[3]. Per discussion[4], this series does not support cdev for physical devices that do not have IOMMU. Such devices only have group-centric user APIs.
This series is a prerequisite for iommu nesting for vfio device[5] [6].
The complete code can be found in below branch, simple tests done to the legacy group path and the cdev path. QEMU changes are in upstreaming[7] and the complete code can be found at[8]
Quoted 5 lines
Quoted 2 lines
https://github.com/yiliu1765/iommufd/tree/vfio_device_cdev_v15
(configCONFIG_IOMMUFD=yCONFIG_VFIO_DEVICE_CDEV=y)Alex, if you are still good with this lets make this into a shared branch, do you want to do it or would you like a PR from me?
Sorry, was out much of last week. Yes, my intent would be to put this both in a shared branch and my next branch for v6.6. Given this is mostly vfio, it seems like it'd make sense for me to provide that branch but I may not get to it until tomorrow. Thanks,
Alex
Quoted 38 lines · On Mon, 24 Jul 2023 13:09:22 -0600 Alex Williamson…
Quoted 35 lines · On Tue, 18 Jul 2023 13:57:46 -0300 Jason Gunthorpe <[email protected]> wrote:
Quoted 33 lines · Yi Liu
Existing VFIO provides group-centric user APIs for userspace. Userspace opens the
/dev/vfio/$group_idfirst before getting device fd and hence getting access to device. This is not the desired model for iommufd. Per the conclusion of community discussion[1], iommufd provides device-centric kAPIs and requires its consumer (like VFIO) to be device-centric user APIs. Such user APIs are used to associate device with iommufd and also the I/O address spaces managed by the iommufd.This series first introduces a per device file structure to be prepared for further enhancement and refactors the kvm-vfio code to be prepared for accepting device file from userspace. After this, adds a mechanism for blocking device access before iommufd bind. Then refactors the vfio to be able to handle cdev paths (e.g. iommufd binding, no-iommufd, [de]attach ioas). This refactor includes making the
device_openexclusive between the group and the cdev path, only allow single device open in cdev path; vfio-iommufd code is also refactored to support cdev. e.g. split thevfio_iommufd_bind()into two steps. Eventually, adds the cdev support for vfio device and the new ioctls, then makes group infrastructure optional as it is not needed when vfio device cdev is compiled.This series is based on some preparation works done to vfio emulated devices[2] and vfio pci hot reset enhancements[3]. Per discussion[4], this series does not support cdev for physical devices that do not have IOMMU. Such devices only have group-centric user APIs.
This series is a prerequisite for iommu nesting for vfio device[5] [6].
The complete code can be found in below branch, simple tests done to the legacy group path and the cdev path. QEMU changes are in upstreaming[7] and the complete code can be found at[8]
https://github.com/yiliu1765/iommufd/tree/vfio_device_cdev_v15
(configCONFIG_IOMMUFD=yCONFIG_VFIO_DEVICE_CDEV=y)
Quoted 7 lines
Quoted 2 lines
Alex, if you are still good with this lets make this into a shared branch, do you want to do it or would you like a PR from me?
Sorry, was out much of last week. Yes, my intent would be to put this both in a shared branch and my next branch for v6.6. Given this is mostly vfio, it seems like it'd make sense for me to provide that branch but I may not get to it until tomorrow. Thanks,
Both series are applied to my next branch for v6.6 and I've also published them to the v6.6/vfio/cdev branch[1]. Thanks for all the work and collaboration on this effort!
Alex
[1]https://github.com/awilliam/linux-vfio/tree/v6.6/vfio/cdev
Jason Gunthorpe
maintainerQuoted 44 lines · Alex Williamson
Quoted 41 lines · On Mon, 24 Jul 2023 13:09:22 -0600 Alex Williamson…
Quoted 37 lines · On Tue, 18 Jul 2023 13:57:46 -0300 Jason Gunthorpe <[email protected]> wrote:
Quoted 25 lines · Yi Liu
Existing VFIO provides group-centric user APIs for userspace. Userspace opens the
/dev/vfio/$group_idfirst before getting device fd and hence getting access to device. This is not the desired model for iommufd. Per the conclusion of community discussion[1], iommufd provides device-centric kAPIs and requires its consumer (like VFIO) to be device-centric user APIs. Such user APIs are used to associate device with iommufd and also the I/O address spaces managed by the iommufd.This series first introduces a per device file structure to be prepared for further enhancement and refactors the kvm-vfio code to be prepared for accepting device file from userspace. After this, adds a mechanism for blocking device access before iommufd bind. Then refactors the vfio to be able to handle cdev paths (e.g. iommufd binding, no-iommufd, [de]attach ioas). This refactor includes making the
device_openexclusive between the group and the cdev path, only allow single device open in cdev path; vfio-iommufd code is also refactored to support cdev. e.g. split thevfio_iommufd_bind()into two steps. Eventually, adds the cdev support for vfio device and the new ioctls, then makes group infrastructure optional as it is not needed when vfio device cdev is compiled.This series is based on some preparation works done to vfio emulated devices[2] and vfio pci hot reset enhancements[3]. Per discussion[4], this series does not support cdev for physical devices that do not have IOMMU. Such devices only have group-centric user APIs.
Quoted 8 lines
This series is a prerequisite for iommu nesting for vfio device[5] [6].
The complete code can be found in below branch, simple tests done to the legacy group path and the cdev path. QEMU changes are in upstreaming[7] and the complete code can be found at[8]
https://github.com/yiliu1765/iommufd/tree/vfio_device_cdev_v15
(configCONFIG_IOMMUFD=yCONFIG_VFIO_DEVICE_CDEV=y)Alex, if you are still good with this lets make this into a shared branch, do you want to do it or would you like a PR from me?
Quoted 8 lines
Quoted 4 lines
Sorry, was out much of last week. Yes, my intent would be to put this both in a shared branch and my next branch for v6.6. Given this is mostly vfio, it seems like it'd make sense for me to provide that branch but I may not get to it until tomorrow. Thanks,
Both series are applied to my next branch for v6.6 and I've also published them to the v6.6/vfio/cdev branch[1]. Thanks for all the work and collaboration on this effort!
Great, I pulled it and merged the next series
Thanks,
Jason