From: frankyj915 <yangjieyj.yang@huawei.com> vdpa inclusion category: feature CVE: NA -------------------------------- VHOST_VDPA_BIND_IOMMUFD, VHOST_VDPA_UNBIND_IOMMUFD, VHOST_VDPA_ATTACH_IOMMUFD_PT and VHOST_VDPA_DETACH_IOMMUFD_PT are introduced. Signed-off-by: frankyj915 <yangjieyj.yang@huawei.com> --- drivers/vhost/vdpa.c | 105 +++++++++++++++++++++++++++++++ include/uapi/linux/vhost.h | 28 +++++++++ include/uapi/linux/vhost_types.h | 5 ++ tools/include/uapi/linux/vhost.h | 28 +++++++++ 4 files changed, 166 insertions(+) diff --git a/drivers/vhost/vdpa.c b/drivers/vhost/vdpa.c index ef7009a9d5ec..6d18e8cca2f0 100644 --- a/drivers/vhost/vdpa.c +++ b/drivers/vhost/vdpa.c @@ -22,9 +22,12 @@ #include <linux/vdpa.h> #include <linux/nospec.h> #include <linux/vhost.h> +#include <linux/iommufd.h> #include "vhost.h" +MODULE_IMPORT_NS(IOMMUFD); + enum { VHOST_VDPA_BACKEND_FEATURES = (1ULL << VHOST_BACKEND_F_IOTLB_MSG_V2) | @@ -60,6 +63,8 @@ struct vhost_vdpa { int in_batch; struct vdpa_iova_range range; u32 batch_asid; + struct iommufd_device *iommufd_dev; + bool iommufd_attached; }; static DEFINE_IDA(vhost_vdpa_ida); @@ -569,6 +574,89 @@ static long vhost_vdpa_resume(struct vhost_vdpa *v) return ops->resume(vdpa); } +static long vhost_vdpa_bind_iommufd(struct vhost_vdpa *v, int __user *argp) +{ + struct vhost_vdpa_bind_iommufd bind; + struct iommufd_ctx *iommufd_ctx; + struct iommufd_device *idev; + struct device *dma_dev = vdpa_get_dma_dev(v->vdpa); + struct iommu_group *iommu_group = iommu_group_get(dma_dev); + int ret; + + if (copy_from_user(&bind, argp, sizeof(bind))) + return -EFAULT; + + iommufd_ctx = iommufd_ctx_from_fd(bind.iommufd); + if (IS_ERR(iommufd_ctx)) + return PTR_ERR(iommufd_ctx); + + if (v->domain) { + iommu_detach_device(v->domain, dma_dev); + iommu_domain_free(v->domain); + v->domain = NULL; + } + + // Default iommu domain is created when vdpa device driver probes. + // Unuse default domain first to avoid failure when claiming dma owner. + if (dma_dev->bus && dma_dev->bus->dma_cleanup) + dma_dev->bus->dma_cleanup(dma_dev); + ret = iommu_group_claim_dma_owner(iommu_group, iommufd_ctx); + if (ret) + return ret; + + idev = iommufd_device_bind(iommufd_ctx, dma_dev, &bind.out_devid); + if (IS_ERR(idev)) + return PTR_ERR(idev); + v->iommufd_dev = idev; + + if (copy_to_user(argp, &bind, sizeof(bind))) + return -EFAULT; + return 0; +} + +static long vhost_vdpa_attach_iommufd_pt(struct vhost_vdpa *v, u32 __user *argp) +{ + u32 pt_id = 0; + int ret; + + if (copy_from_user(&pt_id, argp, sizeof(pt_id))) + return -EFAULT; + + ret = iommufd_device_attach(v->iommufd_dev, &pt_id); + if (ret) + return ret; + v->iommufd_attached = true; + + if (copy_to_user(argp, &pt_id, sizeof(pt_id))) + return -EFAULT; + return 0; +} + +static void vhost_vdpa_detach_iommufd_pt(struct vhost_vdpa *v) +{ + if (WARN_ON(!v->iommufd_dev) || !v->iommufd_attached) + return; + + iommufd_device_detach(v->iommufd_dev); + v->iommufd_attached = false; +} + +static void vhost_vdpa_unbind_iommufd(struct vhost_vdpa *v) +{ + struct device *dma_dev = vdpa_get_dma_dev(v->vdpa); + struct iommu_group *iommu_group = iommu_group_get(dma_dev); + + if (!v->iommufd_dev) + return; + + vhost_vdpa_detach_iommufd_pt(v); + iommufd_device_unbind(v->iommufd_dev); + v->iommufd_dev = NULL; + iommu_group_release_dma_owner(iommu_group); + if (dma_dev->bus && dma_dev->bus->dma_configure) + dma_dev->bus->dma_configure(dma_dev); +} + #ifdef CONFIG_VHOST_VDPA_MIGRATION static int vhost_vdpa_get_dev_buffer_size(struct vhost_vdpa *v, uint32_t __user *argp) @@ -916,6 +1004,18 @@ static long vhost_vdpa_unlocked_ioctl(struct file *filep, case VHOST_VDPA_RESUME: r = vhost_vdpa_resume(v); break; + case VHOST_VDPA_BIND_IOMMUFD: + r = vhost_vdpa_bind_iommufd(v, argp); + break; + case VHOST_VDPA_UNBIND_IOMMUFD: + vhost_vdpa_unbind_iommufd(v); + break; + case VHOST_VDPA_ATTACH_IOMMUFD_PT: + r = vhost_vdpa_attach_iommufd_pt(v, argp); + break; + case VHOST_VDPA_DETACH_IOMMUFD_PT: + vhost_vdpa_detach_iommufd_pt(v); + break; #ifdef CONFIG_VHOST_VDPA_MIGRATION case VHOST_GET_DEV_BUFFER_SIZE: r = vhost_vdpa_get_dev_buffer_size(v, argp); @@ -1556,6 +1656,8 @@ static int vhost_vdpa_release(struct inode *inode, struct file *filep) struct vhost_vdpa *v = filep->private_data; struct vhost_dev *d = &v->vdev; + vhost_vdpa_unbind_iommufd(v); + mutex_lock(&d->mutex); filep->private_data = NULL; vhost_vdpa_clean_irq(v); @@ -1709,6 +1811,9 @@ static int vhost_vdpa_probe(struct vdpa_device *vdpa) for (i = 0; i < VHOST_VDPA_IOTLB_BUCKETS; i++) INIT_HLIST_HEAD(&v->as[i]); + v->iommufd_dev = NULL; + v->iommufd_attached = false; + return 0; err: diff --git a/include/uapi/linux/vhost.h b/include/uapi/linux/vhost.h index a54098c7b0bc..898cde933168 100644 --- a/include/uapi/linux/vhost.h +++ b/include/uapi/linux/vhost.h @@ -223,6 +223,34 @@ */ #define VHOST_VDPA_RESUME _IO(VHOST_VIRTIO, 0x7E) +/* Bind a vDPA device to the specified iommufd + * + * After the return of this ioctl the vDPA device is binded to the specified + * iommufd, and the device id is also returned. + */ +#define VHOST_VDPA_BIND_IOMMUFD _IO(VHOST_VIRTIO, 0x90) + +/* Unbind a vDPA device from the specified iommufd + * + * After the return of this ioctl the vDPA device is unbinded from the specified + * iommufd. + */ +#define VHOST_VDPA_UNBIND_IOMMUFD _IO(VHOST_VIRTIO, 0x91) + +/* Associate the vDPA device with an address space within the bound iommufd. + * + * After the return of this ioctl the vDPA device is attached to the bound + * iommufd. + */ +#define VHOST_VDPA_ATTACH_IOMMUFD_PT _IO(VHOST_VIRTIO, 0x92) + +/* Detach the vDPA device from an address space within the bound iommufd. + * + * After the return of this ioctl the vDPA device is detached from the address + * space within the bound iommufd. + */ +#define VHOST_VDPA_DETACH_IOMMUFD_PT _IO(VHOST_VIRTIO, 0x93) + /* set and get device buffer */ #define VHOST_GET_DEV_BUFFER _IOR(VHOST_VIRTIO, 0xb0, struct vhost_vdpa_config) #define VHOST_SET_DEV_BUFFER _IOW(VHOST_VIRTIO, 0xb1, struct vhost_vdpa_config) diff --git a/include/uapi/linux/vhost_types.h b/include/uapi/linux/vhost_types.h index c7f25b0f7645..450214d2ada5 100644 --- a/include/uapi/linux/vhost_types.h +++ b/include/uapi/linux/vhost_types.h @@ -163,6 +163,11 @@ struct vhost_vdpa_iova_range { __u64 last; }; +struct vhost_vdpa_bind_iommufd { + __s32 iommufd; + __u32 out_devid; +}; + /* vhost vdpa device migration statue */ enum { VHOST_VDPA_DEVICE_START, diff --git a/tools/include/uapi/linux/vhost.h b/tools/include/uapi/linux/vhost.h index f5c48b61ab62..679c7b137f75 100644 --- a/tools/include/uapi/linux/vhost.h +++ b/tools/include/uapi/linux/vhost.h @@ -219,4 +219,32 @@ */ #define VHOST_VDPA_RESUME _IO(VHOST_VIRTIO, 0x7E) +/* Bind a vDPA device to the specified iommufd + * + * After the return of this ioctl the vDPA device is binded to the specified + * iommufd, and the device id is also returned. + */ +#define VHOST_VDPA_BIND_IOMMUFD _IO(VHOST_VIRTIO, 0x90) + +/* Unbind a vDPA device from the specified iommufd + * + * After the return of this ioctl the vDPA device is unbinded from the specified + * iommufd. + */ +#define VHOST_VDPA_UNBIND_IOMMUFD _IO(VHOST_VIRTIO, 0x91) + +/* Associate the vDPA device with an address space within the bound iommufd. + * + * After the return of this ioctl the vDPA device is attached to the bound + * iommufd. + */ +#define VHOST_VDPA_ATTACH_IOMMUFD_PT _IO(VHOST_VIRTIO, 0x92) + +/* Detach the vDPA device from an address space within the bound iommufd. + * + * After the return of this ioctl the vDPA device is detached from the address + * space within the bound iommufd. + */ +#define VHOST_VDPA_DETACH_IOMMUFD_PT _IO(VHOST_VIRTIO, 0x93) + #endif -- 2.25.1