niansa-misc/linux
1
0
Fork 0
mirror of synced 2025-03-06 20:59:54 +01:00
Code Issues Projects Releases Packages Wiki Activity

vfio/mtty: Convert to use vfio_register_group_dev()

Browse source 
This is straightforward conversion, the mdev_state is actually serving as
the vfio_device and we can replace all the mdev_get_drvdata()'s and the
wonky dead code with a simple container_of()

Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Kirti Wankhede <kwankhede@nvidia.com>
Link: https://lore.kernel.org/r/20210617142218.1877096-9-hch@lst.de
Signed-off-by: Alex Williamson <alex.williamson@redhat.com>
This commit is contained in:
Jason Gunthorpe 2021-06-17 16:22:16 +02:00 • committed by Alex Williamson
parent 88a21f265c
commit 09177ac919
1 changed files with 83 additions and 102 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

181
samples/vfio-mdev/mtty.c
View file

@ -127,6 +127,7 @@ struct serial_port {
/* State of each mdev device */ /* State of each mdev device */
struct mdev_state { struct mdev_state {
struct vfio_device vdev;
int irq_fd; int irq_fd;
struct eventfd_ctx *intx_evtfd; struct eventfd_ctx *intx_evtfd;
struct eventfd_ctx *msi_evtfd; struct eventfd_ctx *msi_evtfd;
@ -150,6 +151,8 @@ static const struct file_operations vd_fops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
}; };
static const struct vfio_device_ops mtty_dev_ops;
/* function prototypes */ /* function prototypes */
static int mtty_trigger_interrupt(struct mdev_state *mdev_state); static int mtty_trigger_interrupt(struct mdev_state *mdev_state);
@ -631,23 +634,16 @@ static void mdev_read_base(struct mdev_state *mdev_state)
} }
} }
static ssize_t mdev_access(struct mdev_device *mdev, u8 *buf, size_t count, static ssize_t mdev_access(struct mdev_state *mdev_state, u8 *buf, size_t count,
loff_t pos, bool is_write) loff_t pos, bool is_write)
{ {
struct mdev_state *mdev_state;
unsigned int index; unsigned int index;
loff_t offset; loff_t offset;
int ret = 0; int ret = 0;
if (!mdev || !buf) if (!buf)
return -EINVAL; return -EINVAL;
mdev_state = mdev_get_drvdata(mdev);
if (!mdev_state) {
pr_err("%s mdev_state not found\n", __func__);
return -EINVAL;
}
mutex_lock(&mdev_state->ops_lock); mutex_lock(&mdev_state->ops_lock);
index = MTTY_VFIO_PCI_OFFSET_TO_INDEX(pos); index = MTTY_VFIO_PCI_OFFSET_TO_INDEX(pos);
@ -708,15 +704,18 @@ accessfailed:
return ret; return ret;
} }
static int mtty_create(struct mdev_device *mdev) static int mtty_probe(struct mdev_device *mdev)
{ {
struct mdev_state *mdev_state; struct mdev_state *mdev_state;
int nr_ports = mdev_get_type_group_id(mdev) + 1; int nr_ports = mdev_get_type_group_id(mdev) + 1;
int ret;
mdev_state = kzalloc(sizeof(struct mdev_state), GFP_KERNEL); mdev_state = kzalloc(sizeof(struct mdev_state), GFP_KERNEL);
if (mdev_state == NULL) if (mdev_state == NULL)
return -ENOMEM; return -ENOMEM;
vfio_init_group_dev(&mdev_state->vdev, &mdev->dev, &mtty_dev_ops);
mdev_state->nr_ports = nr_ports; mdev_state->nr_ports = nr_ports;
mdev_state->irq_index = -1; mdev_state->irq_index = -1;
mdev_state->s[0].max_fifo_size = MAX_FIFO_SIZE; mdev_state->s[0].max_fifo_size = MAX_FIFO_SIZE;
@ -731,7 +730,6 @@ static int mtty_create(struct mdev_device *mdev)
mutex_init(&mdev_state->ops_lock); mutex_init(&mdev_state->ops_lock);
mdev_state->mdev = mdev; mdev_state->mdev = mdev;
mdev_set_drvdata(mdev, mdev_state);
mtty_create_config_space(mdev_state); mtty_create_config_space(mdev_state);
@ -739,50 +737,40 @@ static int mtty_create(struct mdev_device *mdev)
list_add(&mdev_state->next, &mdev_devices_list); list_add(&mdev_state->next, &mdev_devices_list);
mutex_unlock(&mdev_list_lock); mutex_unlock(&mdev_list_lock);
ret = vfio_register_group_dev(&mdev_state->vdev);
if (ret) {
kfree(mdev_state);
return ret;
}
dev_set_drvdata(&mdev->dev, mdev_state);
return 0; return 0;
} }
static int mtty_remove(struct mdev_device *mdev) static void mtty_remove(struct mdev_device *mdev)
{ {
struct mdev_state *mds, *tmp_mds; struct mdev_state *mdev_state = dev_get_drvdata(&mdev->dev);
struct mdev_state *mdev_state = mdev_get_drvdata(mdev);
int ret = -EINVAL;
vfio_unregister_group_dev(&mdev_state->vdev);
mutex_lock(&mdev_list_lock); mutex_lock(&mdev_list_lock);
list_for_each_entry_safe(mds, tmp_mds, &mdev_devices_list, next) {
if (mdev_state == mds) {
list_del(&mdev_state->next); list_del(&mdev_state->next);
mdev_set_drvdata(mdev, NULL);
kfree(mdev_state->vconfig);
kfree(mdev_state);
ret = 0;
break;
}
}
mutex_unlock(&mdev_list_lock); mutex_unlock(&mdev_list_lock);
return ret; kfree(mdev_state->vconfig);
kfree(mdev_state);
} }
static int mtty_reset(struct mdev_device *mdev) static int mtty_reset(struct mdev_state *mdev_state)
{ {
struct mdev_state *mdev_state;
if (!mdev)
return -EINVAL;
mdev_state = mdev_get_drvdata(mdev);
if (!mdev_state)
return -EINVAL;
pr_info("%s: called\n", __func__); pr_info("%s: called\n", __func__);
return 0; return 0;
} }
static ssize_t mtty_read(struct mdev_device *mdev, char __user *buf, static ssize_t mtty_read(struct vfio_device *vdev, char __user *buf,
size_t count, loff_t *ppos) size_t count, loff_t *ppos)
{ {
struct mdev_state *mdev_state =
container_of(vdev, struct mdev_state, vdev);
unsigned int done = 0; unsigned int done = 0;
int ret; int ret;
@ -792,7 +780,7 @@ static ssize_t mtty_read(struct mdev_device *mdev, char __user *buf,
if (count >= 4 && !(*ppos % 4)) { if (count >= 4 && !(*ppos % 4)) {
u32 val; u32 val;
ret = mdev_access(mdev, (u8 *)&val, sizeof(val), ret = mdev_access(mdev_state, (u8 *)&val, sizeof(val),
*ppos, false); *ppos, false);
if (ret <= 0) if (ret <= 0)
goto read_err; goto read_err;
@ -804,7 +792,7 @@ static ssize_t mtty_read(struct mdev_device *mdev, char __user *buf,
} else if (count >= 2 && !(*ppos % 2)) { } else if (count >= 2 && !(*ppos % 2)) {
u16 val; u16 val;
ret = mdev_access(mdev, (u8 *)&val, sizeof(val), ret = mdev_access(mdev_state, (u8 *)&val, sizeof(val),
*ppos, false); *ppos, false);
if (ret <= 0) if (ret <= 0)
goto read_err; goto read_err;
@ -816,7 +804,7 @@ static ssize_t mtty_read(struct mdev_device *mdev, char __user *buf,
} else { } else {
u8 val; u8 val;
ret = mdev_access(mdev, (u8 *)&val, sizeof(val), ret = mdev_access(mdev_state, (u8 *)&val, sizeof(val),
*ppos, false); *ppos, false);
if (ret <= 0) if (ret <= 0)
goto read_err; goto read_err;
@ -839,9 +827,11 @@ read_err:
return -EFAULT; return -EFAULT;
} }
static ssize_t mtty_write(struct mdev_device *mdev, const char __user *buf, static ssize_t mtty_write(struct vfio_device *vdev, const char __user *buf,
size_t count, loff_t *ppos) size_t count, loff_t *ppos)
{ {
struct mdev_state *mdev_state =
container_of(vdev, struct mdev_state, vdev);
unsigned int done = 0; unsigned int done = 0;
int ret; int ret;
@ -854,7 +844,7 @@ static ssize_t mtty_write(struct mdev_device *mdev, const char __user *buf,
if (copy_from_user(&val, buf, sizeof(val))) if (copy_from_user(&val, buf, sizeof(val)))
goto write_err; goto write_err;
ret = mdev_access(mdev, (u8 *)&val, sizeof(val), ret = mdev_access(mdev_state, (u8 *)&val, sizeof(val),
*ppos, true); *ppos, true);
if (ret <= 0) if (ret <= 0)
goto write_err; goto write_err;
@ -866,7 +856,7 @@ static ssize_t mtty_write(struct mdev_device *mdev, const char __user *buf,
if (copy_from_user(&val, buf, sizeof(val))) if (copy_from_user(&val, buf, sizeof(val)))
goto write_err; goto write_err;
ret = mdev_access(mdev, (u8 *)&val, sizeof(val), ret = mdev_access(mdev_state, (u8 *)&val, sizeof(val),
*ppos, true); *ppos, true);
if (ret <= 0) if (ret <= 0)
goto write_err; goto write_err;
@ -878,7 +868,7 @@ static ssize_t mtty_write(struct mdev_device *mdev, const char __user *buf,
if (copy_from_user(&val, buf, sizeof(val))) if (copy_from_user(&val, buf, sizeof(val)))
goto write_err; goto write_err;
ret = mdev_access(mdev, (u8 *)&val, sizeof(val), ret = mdev_access(mdev_state, (u8 *)&val, sizeof(val),
*ppos, true); *ppos, true);
if (ret <= 0) if (ret <= 0)
goto write_err; goto write_err;
@ -896,19 +886,11 @@ write_err:
return -EFAULT; return -EFAULT;
} }
static int mtty_set_irqs(struct mdev_device *mdev, uint32_t flags, static int mtty_set_irqs(struct mdev_state *mdev_state, uint32_t flags,
unsigned int index, unsigned int start, unsigned int index, unsigned int start,
unsigned int count, void *data) unsigned int count, void *data)
{ {
int ret = 0; int ret = 0;
struct mdev_state *mdev_state;
if (!mdev)
return -EINVAL;
mdev_state = mdev_get_drvdata(mdev);
if (!mdev_state)
return -EINVAL;
mutex_lock(&mdev_state->ops_lock); mutex_lock(&mdev_state->ops_lock);
switch (index) { switch (index) {
@ -1024,21 +1006,13 @@ static int mtty_trigger_interrupt(struct mdev_state *mdev_state)
return ret; return ret;
} }
static int mtty_get_region_info(struct mdev_device *mdev, static int mtty_get_region_info(struct mdev_state *mdev_state,
struct vfio_region_info *region_info, struct vfio_region_info *region_info,
u16 *cap_type_id, void **cap_type) u16 *cap_type_id, void **cap_type)
{ {
unsigned int size = 0; unsigned int size = 0;
struct mdev_state *mdev_state;
u32 bar_index; u32 bar_index;
if (!mdev)
return -EINVAL;
mdev_state = mdev_get_drvdata(mdev);
if (!mdev_state)
return -EINVAL;
bar_index = region_info->index; bar_index = region_info->index;
if (bar_index >= VFIO_PCI_NUM_REGIONS) if (bar_index >= VFIO_PCI_NUM_REGIONS)
return -EINVAL; return -EINVAL;
@ -1073,8 +1047,7 @@ static int mtty_get_region_info(struct mdev_device *mdev,
return 0; return 0;
} }
static int mtty_get_irq_info(struct mdev_device *mdev, static int mtty_get_irq_info(struct vfio_irq_info *irq_info)
struct vfio_irq_info *irq_info)
{ {
switch (irq_info->index) { switch (irq_info->index) {
case VFIO_PCI_INTX_IRQ_INDEX: case VFIO_PCI_INTX_IRQ_INDEX:
@ -1098,8 +1071,7 @@ static int mtty_get_irq_info(struct mdev_device *mdev,
return 0; return 0;
} }
static int mtty_get_device_info(struct mdev_device *mdev, static int mtty_get_device_info(struct vfio_device_info *dev_info)
struct vfio_device_info *dev_info)
{ {
dev_info->flags = VFIO_DEVICE_FLAGS_PCI; dev_info->flags = VFIO_DEVICE_FLAGS_PCI;
dev_info->num_regions = VFIO_PCI_NUM_REGIONS; dev_info->num_regions = VFIO_PCI_NUM_REGIONS;
@ -1108,19 +1080,13 @@ static int mtty_get_device_info(struct mdev_device *mdev,
return 0; return 0;
} }
static long mtty_ioctl(struct mdev_device *mdev, unsigned int cmd, static long mtty_ioctl(struct vfio_device *vdev, unsigned int cmd,
unsigned long arg) unsigned long arg)
{ {
struct mdev_state *mdev_state =
container_of(vdev, struct mdev_state, vdev);
int ret = 0; int ret = 0;
unsigned long minsz; unsigned long minsz;
struct mdev_state *mdev_state;
if (!mdev)
return -EINVAL;
mdev_state = mdev_get_drvdata(mdev);
if (!mdev_state)
return -ENODEV;
switch (cmd) { switch (cmd) {
case VFIO_DEVICE_GET_INFO: case VFIO_DEVICE_GET_INFO:
@ -1135,7 +1101,7 @@ static long mtty_ioctl(struct mdev_device *mdev, unsigned int cmd,
if (info.argsz < minsz) if (info.argsz < minsz)
return -EINVAL; return -EINVAL;
ret = mtty_get_device_info(mdev, &info); ret = mtty_get_device_info(&info);
if (ret) if (ret)
return ret; return ret;
@ -1160,7 +1126,7 @@ static long mtty_ioctl(struct mdev_device *mdev, unsigned int cmd,
if (info.argsz < minsz) if (info.argsz < minsz)
return -EINVAL; return -EINVAL;
ret = mtty_get_region_info(mdev, &info, &cap_type_id, ret = mtty_get_region_info(mdev_state, &info, &cap_type_id,
&cap_type); &cap_type);
if (ret) if (ret)
return ret; return ret;
@ -1184,7 +1150,7 @@ static long mtty_ioctl(struct mdev_device *mdev, unsigned int cmd,
(info.index >= mdev_state->dev_info.num_irqs)) (info.index >= mdev_state->dev_info.num_irqs))
return -EINVAL; return -EINVAL;
ret = mtty_get_irq_info(mdev, &info); ret = mtty_get_irq_info(&info);
if (ret) if (ret)
return ret; return ret;
@ -1218,25 +1184,25 @@ static long mtty_ioctl(struct mdev_device *mdev, unsigned int cmd,
return PTR_ERR(data); return PTR_ERR(data);
} }
ret = mtty_set_irqs(mdev, hdr.flags, hdr.index, hdr.start, ret = mtty_set_irqs(mdev_state, hdr.flags, hdr.index, hdr.start,
hdr.count, data); hdr.count, data);
kfree(ptr); kfree(ptr);
return ret; return ret;
} }
case VFIO_DEVICE_RESET: case VFIO_DEVICE_RESET:
return mtty_reset(mdev); return mtty_reset(mdev_state);
} }
return -ENOTTY; return -ENOTTY;
} }
static int mtty_open(struct mdev_device *mdev) static int mtty_open(struct vfio_device *vdev)
{ {
pr_info("%s\n", __func__); pr_info("%s\n", __func__);
return 0; return 0;
} }
static void mtty_close(struct mdev_device *mdev) static void mtty_close(struct vfio_device *mdev)
{ {
pr_info("%s\n", __func__); pr_info("%s\n", __func__);
} }
@ -1351,13 +1317,8 @@ static struct attribute_group *mdev_type_groups[] = {
NULL, NULL,
}; };
static const struct mdev_parent_ops mdev_fops = { static const struct vfio_device_ops mtty_dev_ops = {
.owner = THIS_MODULE, .name = "vfio-mtty",
.dev_attr_groups = mtty_dev_groups,
.mdev_attr_groups = mdev_dev_groups,
.supported_type_groups = mdev_type_groups,
.create = mtty_create,
.remove = mtty_remove,
.open = mtty_open, .open = mtty_open,
.release = mtty_close, .release = mtty_close,
.read = mtty_read, .read = mtty_read,
@ -1365,6 +1326,24 @@ static const struct mdev_parent_ops mdev_fops = {
.ioctl = mtty_ioctl, .ioctl = mtty_ioctl,
}; };
static struct mdev_driver mtty_driver = {
.driver = {
.name = "mtty",
.owner = THIS_MODULE,
.mod_name = KBUILD_MODNAME,
.dev_groups = mdev_dev_groups,
},
.probe = mtty_probe,
.remove = mtty_remove,
};
static const struct mdev_parent_ops mdev_fops = {
.owner = THIS_MODULE,
.device_driver = &mtty_driver,
.dev_attr_groups = mtty_dev_groups,
.supported_type_groups = mdev_type_groups,
};
static void mtty_device_release(struct device *dev) static void mtty_device_release(struct device *dev)
{ {
dev_dbg(dev, "mtty: released\n"); dev_dbg(dev, "mtty: released\n");
@ -1393,12 +1372,16 @@ static int __init mtty_dev_init(void)
pr_info("major_number:%d\n", MAJOR(mtty_dev.vd_devt)); pr_info("major_number:%d\n", MAJOR(mtty_dev.vd_devt));
ret = mdev_register_driver(&mtty_driver);
if (ret)
goto err_cdev;
mtty_dev.vd_class = class_create(THIS_MODULE, MTTY_CLASS_NAME); mtty_dev.vd_class = class_create(THIS_MODULE, MTTY_CLASS_NAME);
if (IS_ERR(mtty_dev.vd_class)) { if (IS_ERR(mtty_dev.vd_class)) {
pr_err("Error: failed to register mtty_dev class\n"); pr_err("Error: failed to register mtty_dev class\n");
ret = PTR_ERR(mtty_dev.vd_class); ret = PTR_ERR(mtty_dev.vd_class);
goto failed1; goto err_driver;
} }
mtty_dev.dev.class = mtty_dev.vd_class; mtty_dev.dev.class = mtty_dev.vd_class;
@ -1407,28 +1390,25 @@ static int __init mtty_dev_init(void)
ret = device_register(&mtty_dev.dev); ret = device_register(&mtty_dev.dev);
if (ret) if (ret)
goto failed2; goto err_class;
ret = mdev_register_device(&mtty_dev.dev, &mdev_fops); ret = mdev_register_device(&mtty_dev.dev, &mdev_fops);
if (ret) if (ret)
goto failed3; goto err_device;
mutex_init(&mdev_list_lock); mutex_init(&mdev_list_lock);
INIT_LIST_HEAD(&mdev_devices_list); INIT_LIST_HEAD(&mdev_devices_list);
return 0;
goto all_done; err_device:
failed3:
device_unregister(&mtty_dev.dev); device_unregister(&mtty_dev.dev);
failed2: err_class:
class_destroy(mtty_dev.vd_class); class_destroy(mtty_dev.vd_class);
err_driver:
failed1: mdev_unregister_driver(&mtty_driver);
err_cdev:
cdev_del(&mtty_dev.vd_cdev); cdev_del(&mtty_dev.vd_cdev);
unregister_chrdev_region(mtty_dev.vd_devt, MINORMASK + 1); unregister_chrdev_region(mtty_dev.vd_devt, MINORMASK + 1);
all_done:
return ret; return ret;
} }
@ -1439,6 +1419,7 @@ static void __exit mtty_dev_exit(void)
device_unregister(&mtty_dev.dev); device_unregister(&mtty_dev.dev);
idr_destroy(&mtty_dev.vd_idr); idr_destroy(&mtty_dev.vd_idr);
mdev_unregister_driver(&mtty_driver);
cdev_del(&mtty_dev.vd_cdev); cdev_del(&mtty_dev.vd_cdev);
unregister_chrdev_region(mtty_dev.vd_devt, MINORMASK + 1); unregister_chrdev_region(mtty_dev.vd_devt, MINORMASK + 1);
class_destroy(mtty_dev.vd_class); class_destroy(mtty_dev.vd_class);