Commit 5fcc2696 authored by Yi Liu's avatar Yi Liu Committed by Alex Williamson
Browse files

vfio: Add VFIO_DEVICE_BIND_IOMMUFD 



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_device
			      op is called after bind_iommufd op.

Tested-by: default avatarNicolin Chen <nicolinc@nvidia.com>
Tested-by: default avatarMatthew Rosato <mjrosato@linux.ibm.com>
Tested-by: default avatarYanting Jiang <yanting.jiang@intel.com>
Tested-by: default avatarShameer Kolothum <shameerali.kolothum.thodi@huawei.com>
Tested-by: default avatarTerrence Xu <terrence.xu@intel.com>
Tested-by: default avatarZhenzhong Duan <zhenzhong.duan@intel.com>
Signed-off-by: default avatarYi Liu <yi.l.liu@intel.com>
Reviewed-by: default avatarJason Gunthorpe <jgg@nvidia.com>
Link: https://lore.kernel.org/r/20230718135551.6592-23-yi.l.liu@intel.com


Signed-off-by: default avatarAlex Williamson <alex.williamson@redhat.com>
parent ca9e45b4

drivers/vfio/device_cdev.c

+107 −0
Original line number Diff line number Diff line
@@ -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
Original line number Diff line number Diff line
@@ -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
Original line number Diff line number Diff line
@@ -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
Original line number Diff line number Diff line
@@ -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
Original line number Diff line number Diff line
@@ -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