Commit 6b42f491 authored by Jason Gunthorpe's avatar Jason Gunthorpe Committed by Zhi Wang
Browse files

vfio/mdev: Remove mdev_parent_ops 



The last useful member in this struct is the supported_type_groups, move
it to the mdev_driver and delete mdev_parent_ops.

Replace it with mdev_driver as an argument to mdev_register_device()

Signed-off-by: default avatarJason Gunthorpe <jgg@nvidia.com>
Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Signed-off-by: default avatarZhi Wang <zhi.a.wang@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20220411141403.86980-33-hch@lst.de


Reviewed-by: default avatarKirti Wankhede <kwankhede@nvidia.com>
Reviewed-by: default avatarZhi Wang <zhi.a.wang@intel.com>
parent e6486939

Documentation/driver-api/vfio-mediated-device.rst

+5 −19
Original line number Diff line number Diff line
@@ -105,6 +105,7 @@ structure to represent a mediated device's driver:: 
     struct mdev_driver {

	     int  (*probe)  (struct mdev_device *dev);

	     void (*remove) (struct mdev_device *dev);

	     struct attribute_group **supported_type_groups;

	     struct device_driver    driver;

     };
@@ -119,30 +120,15 @@ to register and unregister itself with the core driver: 


    extern void mdev_unregister_driver(struct mdev_driver *drv);



The mediated bus driver is responsible for adding mediated devices to the VFIO

group when devices are bound to the driver and removing mediated devices from

the VFIO when devices are unbound from the driver.





Physical Device Driver Interface

--------------------------------



The physical device driver interface provides the mdev_parent_ops[3] structure

to define the APIs to manage work in the mediated core driver that is related

to the physical device.



The structures in the mdev_parent_ops structure are as follows:



* dev_attr_groups: attributes of the parent device

* mdev_attr_groups: attributes of the mediated device

* supported_config: attributes to define supported configurations

* device_driver: device driver to bind for mediated device instances

The mediated bus driver's probe function should create a vfio_device on top of

the mdev_device and connect it to an appropriate implementation of

vfio_device_ops.



When a driver wants to add the GUID creation sysfs to an existing device it has

probe'd to then it should call::



	extern int  mdev_register_device(struct device *dev,

	                                 const struct mdev_parent_ops *ops);

	                                 struct mdev_driver *mdev_driver);



This will provide the 'mdev_supported_types/XX/create' files which can then be

used to trigger the creation of a mdev_device. The created mdev_device will be

drivers/gpu/drm/i915/gvt/kvmgt.c

+1 −6
Original line number Diff line number Diff line
@@ -1723,12 +1723,7 @@ static struct mdev_driver intel_vgpu_mdev_driver = { 
	},

	.probe		= intel_vgpu_probe,

	.remove		= intel_vgpu_remove,

};



static const struct mdev_parent_ops intel_vgpu_mdev_ops = {

	.owner			= THIS_MODULE,

	.supported_type_groups	= gvt_vgpu_type_groups,

	.device_driver		= &intel_vgpu_mdev_driver,

};



int intel_gvt_page_track_add(struct intel_vgpu *info, u64 gfn)
@@ -2131,7 +2126,7 @@ static int intel_gvt_init_device(struct drm_i915_private *i915) 
	if (ret)

		goto out_destroy_idle_vgpu;



	ret = mdev_register_device(i915->drm.dev, &intel_vgpu_mdev_ops);

	ret = mdev_register_device(i915->drm.dev, &intel_vgpu_mdev_driver);

	if (ret)

		goto out_cleanup_vgpu_type_groups;

drivers/s390/cio/vfio_ccw_ops.c

+1 −6
Original line number Diff line number Diff line
@@ -656,17 +656,12 @@ struct mdev_driver vfio_ccw_mdev_driver = { 
	},

	.probe = vfio_ccw_mdev_probe,

	.remove = vfio_ccw_mdev_remove,

};



static const struct mdev_parent_ops vfio_ccw_mdev_ops = {

	.owner			= THIS_MODULE,

	.device_driver		= &vfio_ccw_mdev_driver,

	.supported_type_groups  = mdev_type_groups,

};



int vfio_ccw_mdev_reg(struct subchannel *sch)

{

	return mdev_register_device(&sch->dev, &vfio_ccw_mdev_ops);

	return mdev_register_device(&sch->dev, &vfio_ccw_mdev_driver);

}



void vfio_ccw_mdev_unreg(struct subchannel *sch)

drivers/s390/crypto/vfio_ap_ops.c

+2 −7
Original line number Diff line number Diff line
@@ -1496,11 +1496,6 @@ static struct mdev_driver vfio_ap_matrix_driver = { 
	},

	.probe = vfio_ap_mdev_probe,

	.remove = vfio_ap_mdev_remove,

};



static const struct mdev_parent_ops vfio_ap_matrix_ops = {

	.owner			= THIS_MODULE,

	.device_driver		= &vfio_ap_matrix_driver,

	.supported_type_groups = vfio_ap_mdev_type_groups,

};
@@ -1514,7 +1509,7 @@ int vfio_ap_mdev_register(void) 
	if (ret)

		return ret;



	ret = mdev_register_device(&matrix_dev->device, &vfio_ap_matrix_ops);

	ret = mdev_register_device(&matrix_dev->device, &vfio_ap_matrix_driver);

	if (ret)

		goto err_driver;

	return 0;

drivers/vfio/mdev/mdev_core.c

+5 −8
Original line number Diff line number Diff line
@@ -109,12 +109,12 @@ static int mdev_device_remove_cb(struct device *dev, void *data) 
/*

 * mdev_register_device : Register a device

 * @dev: device structure representing parent device.

 * @ops: Parent device operation structure to be registered.

 * @mdev_driver: Device driver to bind to the newly created mdev

 *

 * Add device to list of registered parent devices.

 * Returns a negative value on error, otherwise 0.

 */

int mdev_register_device(struct device *dev, const struct mdev_parent_ops *ops)

int mdev_register_device(struct device *dev, struct mdev_driver *mdev_driver)

{

	int ret;

	struct mdev_parent *parent;
@@ -122,9 +122,7 @@ int mdev_register_device(struct device *dev, const struct mdev_parent_ops *ops) 
	char *envp[] = { env_string, NULL };



	/* check for mandatory ops */

	if (!ops || !ops->supported_type_groups)

		return -EINVAL;

	if (!ops->device_driver)

	if (!mdev_driver->supported_type_groups)

		return -EINVAL;



	dev = get_device(dev);
@@ -151,7 +149,7 @@ int mdev_register_device(struct device *dev, const struct mdev_parent_ops *ops) 
	init_rwsem(&parent->unreg_sem);



	parent->dev = dev;

	parent->ops = ops;

	parent->mdev_driver = mdev_driver;



	if (!mdev_bus_compat_class) {

		mdev_bus_compat_class = class_compat_register("mdev_bus");
@@ -249,7 +247,7 @@ int mdev_device_create(struct mdev_type *type, const guid_t *uuid) 
	int ret;

	struct mdev_device *mdev, *tmp;

	struct mdev_parent *parent = type->parent;

	struct mdev_driver *drv = parent->ops->device_driver;

	struct mdev_driver *drv = parent->mdev_driver;



	mutex_lock(&mdev_list_lock);
@@ -271,7 +269,6 @@ int mdev_device_create(struct mdev_type *type, const guid_t *uuid) 
	mdev->dev.parent  = parent->dev;

	mdev->dev.bus = &mdev_bus_type;

	mdev->dev.release = mdev_device_release;

	mdev->dev.groups = parent->ops->mdev_attr_groups;

	mdev->type = type;

	/* Pairs with the put in mdev_device_release() */

	kobject_get(&type->kobj);