Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-10 22:21:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

vfio/mbochs: 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>
Link: https://lore.kernel.org/r/20210617142218.1877096-11-hch@lst.de
Signed-off-by: Alex Williamson <alex.williamson@redhat.com>
This commit is contained in:
Jason Gunthorpe 2021-06-17 16:22:18 +02:00 committed by Alex Williamson
parent 437e41368c
commit 681c1615f8
1 changed files with 91 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

155
samples/vfio-mdev/mbochs.c
View File

@ -130,6 +130,7 @@ static struct class *mbochs_class;
static struct cdev mbochs_cdev; static struct cdev mbochs_cdev;
static struct device mbochs_dev; static struct device mbochs_dev;
static int mbochs_used_mbytes; static int mbochs_used_mbytes;
static const struct vfio_device_ops mbochs_dev_ops;
struct vfio_region_info_ext { struct vfio_region_info_ext {
struct vfio_region_info base; struct vfio_region_info base;
@ -160,6 +161,7 @@ struct mbochs_dmabuf {
/* State of each mdev device */ /* State of each mdev device */
struct mdev_state { struct mdev_state {
struct vfio_device vdev;
u8 *vconfig; u8 *vconfig;
u64 bar_mask[3]; u64 bar_mask[3];
u32 memory_bar_mask; u32 memory_bar_mask;
@ -425,11 +427,9 @@ static void handle_edid_blob(struct mdev_state *mdev_state, u16 offset,
memcpy(buf, mdev_state->edid_blob + offset, count); memcpy(buf, mdev_state->edid_blob + offset, count);
} }
static ssize_t mdev_access(struct mdev_device *mdev, char *buf, size_t count, static ssize_t mdev_access(struct mdev_state *mdev_state, char *buf,
loff_t pos, bool is_write) size_t count, loff_t pos, bool is_write)
{ {
struct mdev_state *mdev_state = mdev_get_drvdata(mdev);
struct device *dev = mdev_dev(mdev);
struct page *pg; struct page *pg;
loff_t poff; loff_t poff;
char *map; char *map;
@ -478,7 +478,7 @@ static ssize_t mdev_access(struct mdev_device *mdev, char *buf, size_t count,
put_page(pg); put_page(pg);
} else { } else {
dev_dbg(dev, "%s: %s @0x%llx (unhandled)\n", dev_dbg(mdev_state->vdev.dev, "%s: %s @0x%llx (unhandled)\n",
__func__, is_write ? "WR" : "RD", pos); __func__, is_write ? "WR" : "RD", pos);
ret = -1; ret = -1;
goto accessfailed; goto accessfailed;
@ -493,9 +493,8 @@ accessfailed:
return ret; return ret;
} }
static int mbochs_reset(struct mdev_device *mdev) static int mbochs_reset(struct mdev_state *mdev_state)
{ {
struct mdev_state *mdev_state = mdev_get_drvdata(mdev);
u32 size64k = mdev_state->memsize / (64 * 1024); u32 size64k = mdev_state->memsize / (64 * 1024);
int i; int i;
@ -506,12 +505,13 @@ static int mbochs_reset(struct mdev_device *mdev)
return 0; return 0;
} }
static int mbochs_create(struct mdev_device *mdev) static int mbochs_probe(struct mdev_device *mdev)
{ {
const struct mbochs_type *type = const struct mbochs_type *type =
&mbochs_types[mdev_get_type_group_id(mdev)]; &mbochs_types[mdev_get_type_group_id(mdev)];
struct device *dev = mdev_dev(mdev); struct device *dev = mdev_dev(mdev);
struct mdev_state *mdev_state; struct mdev_state *mdev_state;
int ret = -ENOMEM;
if (type->mbytes + mbochs_used_mbytes > max_mbytes) if (type->mbytes + mbochs_used_mbytes > max_mbytes)
return -ENOMEM; return -ENOMEM;
@ -519,6 +519,7 @@ static int mbochs_create(struct mdev_device *mdev)
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, &mbochs_dev_ops);
mdev_state->vconfig = kzalloc(MBOCHS_CONFIG_SPACE_SIZE, GFP_KERNEL); mdev_state->vconfig = kzalloc(MBOCHS_CONFIG_SPACE_SIZE, GFP_KERNEL);
if (mdev_state->vconfig == NULL) if (mdev_state->vconfig == NULL)
@ -537,7 +538,6 @@ static int mbochs_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);
INIT_LIST_HEAD(&mdev_state->dmabufs); INIT_LIST_HEAD(&mdev_state->dmabufs);
mdev_state->next_id = 1; mdev_state->next_id = 1;
@ -547,32 +547,38 @@ static int mbochs_create(struct mdev_device *mdev)
mdev_state->edid_regs.edid_offset = MBOCHS_EDID_BLOB_OFFSET; mdev_state->edid_regs.edid_offset = MBOCHS_EDID_BLOB_OFFSET;
mdev_state->edid_regs.edid_max_size = sizeof(mdev_state->edid_blob); mdev_state->edid_regs.edid_max_size = sizeof(mdev_state->edid_blob);
mbochs_create_config_space(mdev_state); mbochs_create_config_space(mdev_state);
mbochs_reset(mdev); mbochs_reset(mdev_state);
mbochs_used_mbytes += type->mbytes; mbochs_used_mbytes += type->mbytes;
ret = vfio_register_group_dev(&mdev_state->vdev);
if (ret)
goto err_mem;
dev_set_drvdata(&mdev->dev, mdev_state);
return 0; return 0;
err_mem: err_mem:
kfree(mdev_state->vconfig); kfree(mdev_state->vconfig);
kfree(mdev_state); kfree(mdev_state);
return -ENOMEM; return ret;
} }
static int mbochs_remove(struct mdev_device *mdev) static void mbochs_remove(struct mdev_device *mdev)
{ {
struct mdev_state *mdev_state = mdev_get_drvdata(mdev); struct mdev_state *mdev_state = dev_get_drvdata(&mdev->dev);
mbochs_used_mbytes -= mdev_state->type->mbytes; mbochs_used_mbytes -= mdev_state->type->mbytes;
mdev_set_drvdata(mdev, NULL); vfio_unregister_group_dev(&mdev_state->vdev);
kfree(mdev_state->pages); kfree(mdev_state->pages);
kfree(mdev_state->vconfig); kfree(mdev_state->vconfig);
kfree(mdev_state); kfree(mdev_state);
return 0;
} }
static ssize_t mbochs_read(struct mdev_device *mdev, char __user *buf, static ssize_t mbochs_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;
@ -582,7 +588,7 @@ static ssize_t mbochs_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, (char *)&val, sizeof(val), ret = mdev_access(mdev_state, (char *)&val, sizeof(val),
*ppos, false); *ppos, false);
if (ret <= 0) if (ret <= 0)
goto read_err; goto read_err;
@ -594,7 +600,7 @@ static ssize_t mbochs_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, (char *)&val, sizeof(val), ret = mdev_access(mdev_state, (char *)&val, sizeof(val),
*ppos, false); *ppos, false);
if (ret <= 0) if (ret <= 0)
goto read_err; goto read_err;
@ -606,7 +612,7 @@ static ssize_t mbochs_read(struct mdev_device *mdev, char __user *buf,
} else { } else {
u8 val; u8 val;
ret = mdev_access(mdev, (char *)&val, sizeof(val), ret = mdev_access(mdev_state, (char *)&val, sizeof(val),
*ppos, false); *ppos, false);
if (ret <= 0) if (ret <= 0)
goto read_err; goto read_err;
@ -629,9 +635,11 @@ read_err:
return -EFAULT; return -EFAULT;
} }
static ssize_t mbochs_write(struct mdev_device *mdev, const char __user *buf, static ssize_t mbochs_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;
@ -644,7 +652,7 @@ static ssize_t mbochs_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, (char *)&val, sizeof(val), ret = mdev_access(mdev_state, (char *)&val, sizeof(val),
*ppos, true); *ppos, true);
if (ret <= 0) if (ret <= 0)
goto write_err; goto write_err;
@ -656,7 +664,7 @@ static ssize_t mbochs_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, (char *)&val, sizeof(val), ret = mdev_access(mdev_state, (char *)&val, sizeof(val),
*ppos, true); *ppos, true);
if (ret <= 0) if (ret <= 0)
goto write_err; goto write_err;
@ -668,7 +676,7 @@ static ssize_t mbochs_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, (char *)&val, sizeof(val), ret = mdev_access(mdev_state, (char *)&val, sizeof(val),
*ppos, true); *ppos, true);
if (ret <= 0) if (ret <= 0)
goto write_err; goto write_err;
@ -754,9 +762,10 @@ static const struct vm_operations_struct mbochs_region_vm_ops = {
.fault = mbochs_region_vm_fault, .fault = mbochs_region_vm_fault,
}; };
static int mbochs_mmap(struct mdev_device *mdev, struct vm_area_struct *vma) static int mbochs_mmap(struct vfio_device *vdev, struct vm_area_struct *vma)
{ {
struct mdev_state *mdev_state = mdev_get_drvdata(mdev); struct mdev_state *mdev_state =
container_of(vdev, struct mdev_state, vdev);
if (vma->vm_pgoff != MBOCHS_MEMORY_BAR_OFFSET >> PAGE_SHIFT) if (vma->vm_pgoff != MBOCHS_MEMORY_BAR_OFFSET >> PAGE_SHIFT)
return -EINVAL; return -EINVAL;
@ -963,7 +972,7 @@ mbochs_dmabuf_find_by_id(struct mdev_state *mdev_state, u32 id)
static int mbochs_dmabuf_export(struct mbochs_dmabuf *dmabuf) static int mbochs_dmabuf_export(struct mbochs_dmabuf *dmabuf)
{ {
struct mdev_state *mdev_state = dmabuf->mdev_state; struct mdev_state *mdev_state = dmabuf->mdev_state;
struct device *dev = mdev_dev(mdev_state->mdev); struct device *dev = mdev_state->vdev.dev;
DEFINE_DMA_BUF_EXPORT_INFO(exp_info); DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
struct dma_buf *buf; struct dma_buf *buf;
@ -991,15 +1000,10 @@ static int mbochs_dmabuf_export(struct mbochs_dmabuf *dmabuf)
return 0; return 0;
} }
static int mbochs_get_region_info(struct mdev_device *mdev, static int mbochs_get_region_info(struct mdev_state *mdev_state,
struct vfio_region_info_ext *ext) struct vfio_region_info_ext *ext)
{ {
struct vfio_region_info *region_info = &ext->base; struct vfio_region_info *region_info = &ext->base;
struct mdev_state *mdev_state;
mdev_state = mdev_get_drvdata(mdev);
if (!mdev_state)
return -EINVAL;
if (region_info->index >= MBOCHS_NUM_REGIONS) if (region_info->index >= MBOCHS_NUM_REGIONS)
return -EINVAL; return -EINVAL;
@ -1047,15 +1051,13 @@ static int mbochs_get_region_info(struct mdev_device *mdev,
return 0; return 0;
} }
static int mbochs_get_irq_info(struct mdev_device *mdev, static int mbochs_get_irq_info(struct vfio_irq_info *irq_info)
struct vfio_irq_info *irq_info)
{ {
irq_info->count = 0; irq_info->count = 0;
return 0; return 0;
} }
static int mbochs_get_device_info(struct mdev_device *mdev, static int mbochs_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 = MBOCHS_NUM_REGIONS; dev_info->num_regions = MBOCHS_NUM_REGIONS;
@ -1063,11 +1065,9 @@ static int mbochs_get_device_info(struct mdev_device *mdev,
return 0; return 0;
} }
static int mbochs_query_gfx_plane(struct mdev_device *mdev, static int mbochs_query_gfx_plane(struct mdev_state *mdev_state,
struct vfio_device_gfx_plane_info *plane) struct vfio_device_gfx_plane_info *plane)
{ {
struct mdev_state *mdev_state = mdev_get_drvdata(mdev);
struct device *dev = mdev_dev(mdev);
struct mbochs_dmabuf *dmabuf; struct mbochs_dmabuf *dmabuf;
struct mbochs_mode mode; struct mbochs_mode mode;
int ret; int ret;
@ -1121,18 +1121,16 @@ static int mbochs_query_gfx_plane(struct mdev_device *mdev,
done: done:
if (plane->drm_plane_type == DRM_PLANE_TYPE_PRIMARY && if (plane->drm_plane_type == DRM_PLANE_TYPE_PRIMARY &&
mdev_state->active_id != plane->dmabuf_id) { mdev_state->active_id != plane->dmabuf_id) {
dev_dbg(dev, "%s: primary: %d => %d\n", __func__, dev_dbg(mdev_state->vdev.dev, "%s: primary: %d => %d\n",
mdev_state->active_id, plane->dmabuf_id); __func__, mdev_state->active_id, plane->dmabuf_id);
mdev_state->active_id = plane->dmabuf_id; mdev_state->active_id = plane->dmabuf_id;
} }
mutex_unlock(&mdev_state->ops_lock); mutex_unlock(&mdev_state->ops_lock);
return 0; return 0;
} }
static int mbochs_get_gfx_dmabuf(struct mdev_device *mdev, static int mbochs_get_gfx_dmabuf(struct mdev_state *mdev_state, u32 id)
u32 id)
{ {
struct mdev_state *mdev_state = mdev_get_drvdata(mdev);
struct mbochs_dmabuf *dmabuf; struct mbochs_dmabuf *dmabuf;
mutex_lock(&mdev_state->ops_lock); mutex_lock(&mdev_state->ops_lock);
@ -1154,9 +1152,11 @@ static int mbochs_get_gfx_dmabuf(struct mdev_device *mdev,
return dma_buf_fd(dmabuf->buf, 0); return dma_buf_fd(dmabuf->buf, 0);
} }
static long mbochs_ioctl(struct mdev_device *mdev, unsigned int cmd, static long mbochs_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, outsz; unsigned long minsz, outsz;
@ -1173,7 +1173,7 @@ static long mbochs_ioctl(struct mdev_device *mdev, unsigned int cmd,
if (info.argsz < minsz) if (info.argsz < minsz)
return -EINVAL; return -EINVAL;
ret = mbochs_get_device_info(mdev, &info); ret = mbochs_get_device_info(&info);
if (ret) if (ret)
return ret; return ret;
@ -1197,7 +1197,7 @@ static long mbochs_ioctl(struct mdev_device *mdev, unsigned int cmd,
if (outsz > sizeof(info)) if (outsz > sizeof(info))
return -EINVAL; return -EINVAL;
ret = mbochs_get_region_info(mdev, &info); ret = mbochs_get_region_info(mdev_state, &info);
if (ret) if (ret)
return ret; return ret;
@ -1220,7 +1220,7 @@ static long mbochs_ioctl(struct mdev_device *mdev, unsigned int cmd,
(info.index >= VFIO_PCI_NUM_IRQS)) (info.index >= VFIO_PCI_NUM_IRQS))
return -EINVAL; return -EINVAL;
ret = mbochs_get_irq_info(mdev, &info); ret = mbochs_get_irq_info(&info);
if (ret) if (ret)
return ret; return ret;
@ -1243,7 +1243,7 @@ static long mbochs_ioctl(struct mdev_device *mdev, unsigned int cmd,
if (plane.argsz < minsz) if (plane.argsz < minsz)
return -EINVAL; return -EINVAL;
ret = mbochs_query_gfx_plane(mdev, &plane); ret = mbochs_query_gfx_plane(mdev_state, &plane);
if (ret) if (ret)
return ret; return ret;
@ -1260,19 +1260,19 @@ static long mbochs_ioctl(struct mdev_device *mdev, unsigned int cmd,
if (get_user(dmabuf_id, (__u32 __user *)arg)) if (get_user(dmabuf_id, (__u32 __user *)arg))
return -EFAULT; return -EFAULT;
return mbochs_get_gfx_dmabuf(mdev, dmabuf_id); return mbochs_get_gfx_dmabuf(mdev_state, dmabuf_id);
} }
case VFIO_DEVICE_SET_IRQS: case VFIO_DEVICE_SET_IRQS:
return -EINVAL; return -EINVAL;
case VFIO_DEVICE_RESET: case VFIO_DEVICE_RESET:
return mbochs_reset(mdev); return mbochs_reset(mdev_state);
} }
return -ENOTTY; return -ENOTTY;
} }
static int mbochs_open(struct mdev_device *mdev) static int mbochs_open(struct vfio_device *vdev)
{ {
if (!try_module_get(THIS_MODULE)) if (!try_module_get(THIS_MODULE))
return -ENODEV; return -ENODEV;
@ -1280,9 +1280,10 @@ static int mbochs_open(struct mdev_device *mdev)
return 0; return 0;
} }
static void mbochs_close(struct mdev_device *mdev) static void mbochs_close(struct vfio_device *vdev)
{ {
struct mdev_state *mdev_state = mdev_get_drvdata(mdev); struct mdev_state *mdev_state =
container_of(vdev, struct mdev_state, vdev);
struct mbochs_dmabuf *dmabuf, *tmp; struct mbochs_dmabuf *dmabuf, *tmp;
mutex_lock(&mdev_state->ops_lock); mutex_lock(&mdev_state->ops_lock);
@ -1306,8 +1307,7 @@ static ssize_t
memory_show(struct device *dev, struct device_attribute *attr, memory_show(struct device *dev, struct device_attribute *attr,
char *buf) char *buf)
{ {
struct mdev_device *mdev = mdev_from_dev(dev); struct mdev_state *mdev_state = dev_get_drvdata(dev);
struct mdev_state *mdev_state = mdev_get_drvdata(mdev);
return sprintf(buf, "%d MB\n", mdev_state->type->mbytes); return sprintf(buf, "%d MB\n", mdev_state->type->mbytes);
} }
@ -1398,12 +1398,7 @@ static struct attribute_group *mdev_type_groups[] = {
NULL, NULL,
}; };
static const struct mdev_parent_ops mdev_fops = { static const struct vfio_device_ops mbochs_dev_ops = {
.owner = THIS_MODULE,
.mdev_attr_groups = mdev_dev_groups,
.supported_type_groups = mdev_type_groups,
.create = mbochs_create,
.remove = mbochs_remove,
.open = mbochs_open, .open = mbochs_open,
.release = mbochs_close, .release = mbochs_close,
.read = mbochs_read, .read = mbochs_read,
@ -1412,6 +1407,23 @@ static const struct mdev_parent_ops mdev_fops = {
.mmap = mbochs_mmap, .mmap = mbochs_mmap,
}; };
static struct mdev_driver mbochs_driver = {
.driver = {
.name = "mbochs",
.owner = THIS_MODULE,
.mod_name = KBUILD_MODNAME,
.dev_groups = mdev_dev_groups,
},
.probe = mbochs_probe,
.remove = mbochs_remove,
};
static const struct mdev_parent_ops mdev_fops = {
.owner = THIS_MODULE,
.device_driver = &mbochs_driver,
.supported_type_groups = mdev_type_groups,
};
static const struct file_operations vd_fops = { static const struct file_operations vd_fops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
}; };
@ -1434,11 +1446,15 @@ static int __init mbochs_dev_init(void)
cdev_add(&mbochs_cdev, mbochs_devt, MINORMASK + 1); cdev_add(&mbochs_cdev, mbochs_devt, MINORMASK + 1);
pr_info("%s: major %d\n", __func__, MAJOR(mbochs_devt)); pr_info("%s: major %d\n", __func__, MAJOR(mbochs_devt));
ret = mdev_register_driver(&mbochs_driver);
if (ret)
goto err_cdev;
mbochs_class = class_create(THIS_MODULE, MBOCHS_CLASS_NAME); mbochs_class = class_create(THIS_MODULE, MBOCHS_CLASS_NAME);
if (IS_ERR(mbochs_class)) { if (IS_ERR(mbochs_class)) {
pr_err("Error: failed to register mbochs_dev class\n"); pr_err("Error: failed to register mbochs_dev class\n");
ret = PTR_ERR(mbochs_class); ret = PTR_ERR(mbochs_class);
goto failed1; goto err_driver;
} }
mbochs_dev.class = mbochs_class; mbochs_dev.class = mbochs_class;
mbochs_dev.release = mbochs_device_release; mbochs_dev.release = mbochs_device_release;
@ -1446,19 +1462,21 @@ static int __init mbochs_dev_init(void)
ret = device_register(&mbochs_dev); ret = device_register(&mbochs_dev);
if (ret) if (ret)
goto failed2; goto err_class;
ret = mdev_register_device(&mbochs_dev, &mdev_fops); ret = mdev_register_device(&mbochs_dev, &mdev_fops);
if (ret) if (ret)
goto failed3; goto err_device;
return 0; return 0;
failed3: err_device:
device_unregister(&mbochs_dev); device_unregister(&mbochs_dev);
failed2: err_class:
class_destroy(mbochs_class); class_destroy(mbochs_class);
failed1: err_driver:
mdev_unregister_driver(&mbochs_driver);
err_cdev:
cdev_del(&mbochs_cdev); cdev_del(&mbochs_cdev);
unregister_chrdev_region(mbochs_devt, MINORMASK + 1); unregister_chrdev_region(mbochs_devt, MINORMASK + 1);
return ret; return ret;
@ -1470,6 +1488,7 @@ static void __exit mbochs_dev_exit(void)
mdev_unregister_device(&mbochs_dev); mdev_unregister_device(&mbochs_dev);
device_unregister(&mbochs_dev); device_unregister(&mbochs_dev);
mdev_unregister_driver(&mbochs_driver);
cdev_del(&mbochs_cdev); cdev_del(&mbochs_cdev);
unregister_chrdev_region(mbochs_devt, MINORMASK + 1); unregister_chrdev_region(mbochs_devt, MINORMASK + 1);
class_destroy(mbochs_class); class_destroy(mbochs_class);