openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

vfio: Make vfio_device_ops pass a 'struct vfio_device *' instead of 'void *' 

This is the standard kernel pattern, the ops associated with a struct get
the struct pointer in for typesafety. The expected design is to use
container_of to cleanly go from the subsystem level type to the driver
level type without having any type erasure in a void *.

Reviewed-by: Dan Williams <dan.j.williams@intel.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Cornelia Huck <cohuck@redhat.com>
Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
Message-Id: <12-v3-225de1400dfc+4e074-vfio1_jgg@nvidia.com>
Signed-off-by: Alex Williamson <alex.williamson@redhat.com>
This commit is contained in:
Jason Gunthorpe 2021-03-30 09:53:08 -06:00 committed by Alex Williamson
parent 66873b5fa7
commit 6df62c5b05
7 changed files with 117 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
Documentation/driver-api/vfio.rst
View File

@ -269,20 +269,22 @@ ready before calling it. The driver provides an ops structure for callbacks
similar to a file operations structure:: similar to a file operations structure::
struct vfio_device_ops { struct vfio_device_ops {
int (*open)(void *device_data); int (*open)(struct vfio_device *vdev);
void (*release)(void *device_data); void (*release)(struct vfio_device *vdev);
ssize_t (*read)(void *device_data, char __user *buf, ssize_t (*read)(struct vfio_device *vdev, char __user *buf,
size_t count, loff_t *ppos); size_t count, loff_t *ppos);
ssize_t (*write)(void *device_data, const char __user *buf, ssize_t (*write)(struct vfio_device *vdev,
const char __user *buf,
size_t size, loff_t *ppos); size_t size, loff_t *ppos);
long (*ioctl)(void *device_data, unsigned int cmd, long (*ioctl)(struct vfio_device *vdev, unsigned int cmd,
unsigned long arg); unsigned long arg);
int (*mmap)(void *device_data, struct vm_area_struct *vma); int (*mmap)(struct vfio_device *vdev,
struct vm_area_struct *vma);
}; };
Each function is passed the device_data that was originally registered Each function is passed the vdev that was originally registered
in the vfio_register_group_dev() call above. This allows the bus driver in the vfio_register_group_dev() call above. This allows the bus driver
an easy place to store its opaque, private data. The open/release to obtain its private data using container_of(). The open/release
callbacks are issued when a new file descriptor is created for a callbacks are issued when a new file descriptor is created for a
device (via VFIO_GROUP_GET_DEVICE_FD). The ioctl interface provides device (via VFIO_GROUP_GET_DEVICE_FD). The ioctl interface provides
a direct pass through for VFIO_DEVICE_* ioctls. The read/write/mmap a direct pass through for VFIO_DEVICE_* ioctls. The read/write/mmap

36
drivers/vfio/fsl-mc/vfio_fsl_mc.c
View File

@ -135,9 +135,10 @@ static void vfio_fsl_mc_regions_cleanup(struct vfio_fsl_mc_device *vdev)
kfree(vdev->regions); kfree(vdev->regions);
} }
static int vfio_fsl_mc_open(void *device_data) static int vfio_fsl_mc_open(struct vfio_device *core_vdev)
{ {
struct vfio_fsl_mc_device *vdev = device_data; struct vfio_fsl_mc_device *vdev =
container_of(core_vdev, struct vfio_fsl_mc_device, vdev);
int ret; int ret;
if (!try_module_get(THIS_MODULE)) if (!try_module_get(THIS_MODULE))
@ -161,9 +162,10 @@ static int vfio_fsl_mc_open(void *device_data)
return ret; return ret;
} }
static void vfio_fsl_mc_release(void *device_data) static void vfio_fsl_mc_release(struct vfio_device *core_vdev)
{ {
struct vfio_fsl_mc_device *vdev = device_data; struct vfio_fsl_mc_device *vdev =
container_of(core_vdev, struct vfio_fsl_mc_device, vdev);
int ret; int ret;
mutex_lock(&vdev->reflck->lock); mutex_lock(&vdev->reflck->lock);
@ -197,11 +199,12 @@ static void vfio_fsl_mc_release(void *device_data)
module_put(THIS_MODULE); module_put(THIS_MODULE);
} }
static long vfio_fsl_mc_ioctl(void *device_data, unsigned int cmd, static long vfio_fsl_mc_ioctl(struct vfio_device *core_vdev,
unsigned long arg) unsigned int cmd, unsigned long arg)
{ {
unsigned long minsz; unsigned long minsz;
struct vfio_fsl_mc_device *vdev = device_data; struct vfio_fsl_mc_device *vdev =
container_of(core_vdev, struct vfio_fsl_mc_device, vdev);
struct fsl_mc_device *mc_dev = vdev->mc_dev; struct fsl_mc_device *mc_dev = vdev->mc_dev;
switch (cmd) { switch (cmd) {
@ -327,10 +330,11 @@ static long vfio_fsl_mc_ioctl(void *device_data, unsigned int cmd,
} }
} }
static ssize_t vfio_fsl_mc_read(void *device_data, char __user *buf, static ssize_t vfio_fsl_mc_read(struct vfio_device *core_vdev, char __user *buf,
size_t count, loff_t *ppos) size_t count, loff_t *ppos)
{ {
struct vfio_fsl_mc_device *vdev = device_data; struct vfio_fsl_mc_device *vdev =
container_of(core_vdev, struct vfio_fsl_mc_device, vdev);
unsigned int index = VFIO_FSL_MC_OFFSET_TO_INDEX(*ppos); unsigned int index = VFIO_FSL_MC_OFFSET_TO_INDEX(*ppos);
loff_t off = *ppos & VFIO_FSL_MC_OFFSET_MASK; loff_t off = *ppos & VFIO_FSL_MC_OFFSET_MASK;
struct fsl_mc_device *mc_dev = vdev->mc_dev; struct fsl_mc_device *mc_dev = vdev->mc_dev;
@ -404,10 +408,12 @@ static int vfio_fsl_mc_send_command(void __iomem *ioaddr, uint64_t *cmd_data)
return 0; return 0;
} }
static ssize_t vfio_fsl_mc_write(void *device_data, const char __user *buf, static ssize_t vfio_fsl_mc_write(struct vfio_device *core_vdev,
size_t count, loff_t *ppos) const char __user *buf, size_t count,
loff_t *ppos)
{ {
struct vfio_fsl_mc_device *vdev = device_data; struct vfio_fsl_mc_device *vdev =
container_of(core_vdev, struct vfio_fsl_mc_device, vdev);
unsigned int index = VFIO_FSL_MC_OFFSET_TO_INDEX(*ppos); unsigned int index = VFIO_FSL_MC_OFFSET_TO_INDEX(*ppos);
loff_t off = *ppos & VFIO_FSL_MC_OFFSET_MASK; loff_t off = *ppos & VFIO_FSL_MC_OFFSET_MASK;
struct fsl_mc_device *mc_dev = vdev->mc_dev; struct fsl_mc_device *mc_dev = vdev->mc_dev;
@ -468,9 +474,11 @@ static int vfio_fsl_mc_mmap_mmio(struct vfio_fsl_mc_region region,
size, vma->vm_page_prot); size, vma->vm_page_prot);
} }
static int vfio_fsl_mc_mmap(void *device_data, struct vm_area_struct *vma) static int vfio_fsl_mc_mmap(struct vfio_device *core_vdev,
struct vm_area_struct *vma)
{ {
struct vfio_fsl_mc_device *vdev = device_data; struct vfio_fsl_mc_device *vdev =
container_of(core_vdev, struct vfio_fsl_mc_device, vdev);
struct fsl_mc_device *mc_dev = vdev->mc_dev; struct fsl_mc_device *mc_dev = vdev->mc_dev;
unsigned int index; unsigned int index;

33
drivers/vfio/mdev/vfio_mdev.c
View File

@ -21,10 +21,11 @@
#define DRIVER_AUTHOR "NVIDIA Corporation" #define DRIVER_AUTHOR "NVIDIA Corporation"
#define DRIVER_DESC "VFIO based driver for Mediated device" #define DRIVER_DESC "VFIO based driver for Mediated device"
static int vfio_mdev_open(void *device_data) static int vfio_mdev_open(struct vfio_device *core_vdev)
{ {
struct mdev_device *mdev = device_data; struct mdev_device *mdev = to_mdev_device(core_vdev->dev);
struct mdev_parent *parent = mdev->parent; struct mdev_parent *parent = mdev->parent;
int ret; int ret;
if (unlikely(!parent->ops->open)) if (unlikely(!parent->ops->open))
@ -40,9 +41,9 @@ static int vfio_mdev_open(void *device_data)
return ret; return ret;
} }
static void vfio_mdev_release(void *device_data) static void vfio_mdev_release(struct vfio_device *core_vdev)
{ {
struct mdev_device *mdev = device_data; struct mdev_device *mdev = to_mdev_device(core_vdev->dev);
struct mdev_parent *parent = mdev->parent; struct mdev_parent *parent = mdev->parent;
if (likely(parent->ops->release)) if (likely(parent->ops->release))
@ -51,10 +52,10 @@ static void vfio_mdev_release(void *device_data)
module_put(THIS_MODULE); module_put(THIS_MODULE);
} }
static long vfio_mdev_unlocked_ioctl(void *device_data, static long vfio_mdev_unlocked_ioctl(struct vfio_device *core_vdev,
unsigned int cmd, unsigned long arg) unsigned int cmd, unsigned long arg)
{ {
struct mdev_device *mdev = device_data; struct mdev_device *mdev = to_mdev_device(core_vdev->dev);
struct mdev_parent *parent = mdev->parent; struct mdev_parent *parent = mdev->parent;
if (unlikely(!parent->ops->ioctl)) if (unlikely(!parent->ops->ioctl))
@ -63,10 +64,10 @@ static long vfio_mdev_unlocked_ioctl(void *device_data,
return parent->ops->ioctl(mdev, cmd, arg); return parent->ops->ioctl(mdev, cmd, arg);
} }
static ssize_t vfio_mdev_read(void *device_data, char __user *buf, static ssize_t vfio_mdev_read(struct vfio_device *core_vdev, char __user *buf,
size_t count, loff_t *ppos) size_t count, loff_t *ppos)
{ {
struct mdev_device *mdev = device_data; struct mdev_device *mdev = to_mdev_device(core_vdev->dev);
struct mdev_parent *parent = mdev->parent; struct mdev_parent *parent = mdev->parent;
if (unlikely(!parent->ops->read)) if (unlikely(!parent->ops->read))
@ -75,10 +76,11 @@ static ssize_t vfio_mdev_read(void *device_data, char __user *buf,
return parent->ops->read(mdev, buf, count, ppos); return parent->ops->read(mdev, buf, count, ppos);
} }
static ssize_t vfio_mdev_write(void *device_data, const char __user *buf, static ssize_t vfio_mdev_write(struct vfio_device *core_vdev,
size_t count, loff_t *ppos) const char __user *buf, size_t count,
loff_t *ppos)
{ {
struct mdev_device *mdev = device_data; struct mdev_device *mdev = to_mdev_device(core_vdev->dev);
struct mdev_parent *parent = mdev->parent; struct mdev_parent *parent = mdev->parent;
if (unlikely(!parent->ops->write)) if (unlikely(!parent->ops->write))
@ -87,9 +89,10 @@ static ssize_t vfio_mdev_write(void *device_data, const char __user *buf,
return parent->ops->write(mdev, buf, count, ppos); return parent->ops->write(mdev, buf, count, ppos);
} }
static int vfio_mdev_mmap(void *device_data, struct vm_area_struct *vma) static int vfio_mdev_mmap(struct vfio_device *core_vdev,
struct vm_area_struct *vma)
{ {
struct mdev_device *mdev = device_data; struct mdev_device *mdev = to_mdev_device(core_vdev->dev);
struct mdev_parent *parent = mdev->parent; struct mdev_parent *parent = mdev->parent;
if (unlikely(!parent->ops->mmap)) if (unlikely(!parent->ops->mmap))
@ -98,9 +101,9 @@ static int vfio_mdev_mmap(void *device_data, struct vm_area_struct *vma)
return parent->ops->mmap(mdev, vma); return parent->ops->mmap(mdev, vma);
} }
static void vfio_mdev_request(void *device_data, unsigned int count) static void vfio_mdev_request(struct vfio_device *core_vdev, unsigned int count)
{ {
struct mdev_device *mdev = device_data; struct mdev_device *mdev = to_mdev_device(core_vdev->dev);
struct mdev_parent *parent = mdev->parent; struct mdev_parent *parent = mdev->parent;
if (parent->ops->request) if (parent->ops->request)

47
drivers/vfio/pci/vfio_pci.c
View File

@ -553,9 +553,10 @@ static void vfio_pci_vf_token_user_add(struct vfio_pci_device *vdev, int val)
vfio_device_put(pf_dev); vfio_device_put(pf_dev);
} }
static void vfio_pci_release(void *device_data) static void vfio_pci_release(struct vfio_device *core_vdev)
{ {
struct vfio_pci_device *vdev = device_data; struct vfio_pci_device *vdev =
container_of(core_vdev, struct vfio_pci_device, vdev);
mutex_lock(&vdev->reflck->lock); mutex_lock(&vdev->reflck->lock);
@ -581,9 +582,10 @@ static void vfio_pci_release(void *device_data)
module_put(THIS_MODULE); module_put(THIS_MODULE);
} }
static int vfio_pci_open(void *device_data) static int vfio_pci_open(struct vfio_device *core_vdev)
{ {
struct vfio_pci_device *vdev = device_data; struct vfio_pci_device *vdev =
container_of(core_vdev, struct vfio_pci_device, vdev);
int ret = 0; int ret = 0;
if (!try_module_get(THIS_MODULE)) if (!try_module_get(THIS_MODULE))
@ -797,10 +799,11 @@ struct vfio_devices {
int max_index; int max_index;
}; };
static long vfio_pci_ioctl(void *device_data, static long vfio_pci_ioctl(struct vfio_device *core_vdev,
unsigned int cmd, unsigned long arg) unsigned int cmd, unsigned long arg)
{ {
struct vfio_pci_device *vdev = device_data; struct vfio_pci_device *vdev =
container_of(core_vdev, struct vfio_pci_device, vdev);
unsigned long minsz; unsigned long minsz;
if (cmd == VFIO_DEVICE_GET_INFO) { if (cmd == VFIO_DEVICE_GET_INFO) {
@ -1402,11 +1405,10 @@ static long vfio_pci_ioctl(void *device_data,
return -ENOTTY; return -ENOTTY;
} }
static ssize_t vfio_pci_rw(void *device_data, char __user *buf, static ssize_t vfio_pci_rw(struct vfio_pci_device *vdev, char __user *buf,
size_t count, loff_t *ppos, bool iswrite) size_t count, loff_t *ppos, bool iswrite)
{ {
unsigned int index = VFIO_PCI_OFFSET_TO_INDEX(*ppos); unsigned int index = VFIO_PCI_OFFSET_TO_INDEX(*ppos);
struct vfio_pci_device *vdev = device_data;
if (index >= VFIO_PCI_NUM_REGIONS + vdev->num_regions) if (index >= VFIO_PCI_NUM_REGIONS + vdev->num_regions)
return -EINVAL; return -EINVAL;
@ -1434,22 +1436,28 @@ static ssize_t vfio_pci_rw(void *device_data, char __user *buf,
return -EINVAL; return -EINVAL;
} }
static ssize_t vfio_pci_read(void *device_data, char __user *buf, static ssize_t vfio_pci_read(struct vfio_device *core_vdev, char __user *buf,
size_t count, loff_t *ppos) size_t count, loff_t *ppos)
{ {
struct vfio_pci_device *vdev =
container_of(core_vdev, struct vfio_pci_device, vdev);
if (!count) if (!count)
return 0; return 0;
return vfio_pci_rw(device_data, buf, count, ppos, false); return vfio_pci_rw(vdev, buf, count, ppos, false);
} }
static ssize_t vfio_pci_write(void *device_data, const char __user *buf, static ssize_t vfio_pci_write(struct vfio_device *core_vdev, const char __user *buf,
size_t count, loff_t *ppos) size_t count, loff_t *ppos)
{ {
struct vfio_pci_device *vdev =
container_of(core_vdev, struct vfio_pci_device, vdev);
if (!count) if (!count)
return 0; return 0;
return vfio_pci_rw(device_data, (char __user *)buf, count, ppos, true); return vfio_pci_rw(vdev, (char __user *)buf, count, ppos, true);
} }
/* Return 1 on zap and vma_lock acquired, 0 on contention (only with @try) */ /* Return 1 on zap and vma_lock acquired, 0 on contention (only with @try) */
@ -1646,9 +1654,10 @@ static const struct vm_operations_struct vfio_pci_mmap_ops = {
.fault = vfio_pci_mmap_fault, .fault = vfio_pci_mmap_fault,
}; };
static int vfio_pci_mmap(void *device_data, struct vm_area_struct *vma) static int vfio_pci_mmap(struct vfio_device *core_vdev, struct vm_area_struct *vma)
{ {
struct vfio_pci_device *vdev = device_data; struct vfio_pci_device *vdev =
container_of(core_vdev, struct vfio_pci_device, vdev);
struct pci_dev *pdev = vdev->pdev; struct pci_dev *pdev = vdev->pdev;
unsigned int index; unsigned int index;
u64 phys_len, req_len, pgoff, req_start; u64 phys_len, req_len, pgoff, req_start;
@ -1714,9 +1723,10 @@ static int vfio_pci_mmap(void *device_data, struct vm_area_struct *vma)
return 0; return 0;
} }
static void vfio_pci_request(void *device_data, unsigned int count) static void vfio_pci_request(struct vfio_device *core_vdev, unsigned int count)
{ {
struct vfio_pci_device *vdev = device_data; struct vfio_pci_device *vdev =
container_of(core_vdev, struct vfio_pci_device, vdev);
struct pci_dev *pdev = vdev->pdev; struct pci_dev *pdev = vdev->pdev;
mutex_lock(&vdev->igate); mutex_lock(&vdev->igate);
@ -1830,9 +1840,10 @@ static int vfio_pci_validate_vf_token(struct vfio_pci_device *vdev,
#define VF_TOKEN_ARG "vf_token=" #define VF_TOKEN_ARG "vf_token="
static int vfio_pci_match(void *device_data, char *buf) static int vfio_pci_match(struct vfio_device *core_vdev, char *buf)
{ {
struct vfio_pci_device *vdev = device_data; struct vfio_pci_device *vdev =
container_of(core_vdev, struct vfio_pci_device, vdev);
bool vf_token = false; bool vf_token = false;
uuid_t uuid; uuid_t uuid;
int ret; int ret;

33
drivers/vfio/platform/vfio_platform_common.c
View File

@ -218,9 +218,10 @@ static int vfio_platform_call_reset(struct vfio_platform_device *vdev,
return -EINVAL; return -EINVAL;
} }
static void vfio_platform_release(void *device_data) static void vfio_platform_release(struct vfio_device *core_vdev)
{ {
struct vfio_platform_device *vdev = device_data; struct vfio_platform_device *vdev =
container_of(core_vdev, struct vfio_platform_device, vdev);
mutex_lock(&driver_lock); mutex_lock(&driver_lock);
@ -244,9 +245,10 @@ static void vfio_platform_release(void *device_data)
module_put(vdev->parent_module); module_put(vdev->parent_module);
} }
static int vfio_platform_open(void *device_data) static int vfio_platform_open(struct vfio_device *core_vdev)
{ {
struct vfio_platform_device *vdev = device_data; struct vfio_platform_device *vdev =
container_of(core_vdev, struct vfio_platform_device, vdev);
int ret; int ret;
if (!try_module_get(vdev->parent_module)) if (!try_module_get(vdev->parent_module))
@ -293,10 +295,12 @@ static int vfio_platform_open(void *device_data)
return ret; return ret;
} }
static long vfio_platform_ioctl(void *device_data, static long vfio_platform_ioctl(struct vfio_device *core_vdev,
unsigned int cmd, unsigned long arg) unsigned int cmd, unsigned long arg)
{ {
struct vfio_platform_device *vdev = device_data; struct vfio_platform_device *vdev =
container_of(core_vdev, struct vfio_platform_device, vdev);
unsigned long minsz; unsigned long minsz;
if (cmd == VFIO_DEVICE_GET_INFO) { if (cmd == VFIO_DEVICE_GET_INFO) {
@ -455,10 +459,11 @@ static ssize_t vfio_platform_read_mmio(struct vfio_platform_region *reg,
return -EFAULT; return -EFAULT;
} }
static ssize_t vfio_platform_read(void *device_data, char __user *buf, static ssize_t vfio_platform_read(struct vfio_device *core_vdev,
size_t count, loff_t *ppos) char __user *buf, size_t count, loff_t *ppos)
{ {
struct vfio_platform_device *vdev = device_data; struct vfio_platform_device *vdev =
container_of(core_vdev, struct vfio_platform_device, vdev);
unsigned int index = VFIO_PLATFORM_OFFSET_TO_INDEX(*ppos); unsigned int index = VFIO_PLATFORM_OFFSET_TO_INDEX(*ppos);
loff_t off = *ppos & VFIO_PLATFORM_OFFSET_MASK; loff_t off = *ppos & VFIO_PLATFORM_OFFSET_MASK;
@ -531,10 +536,11 @@ static ssize_t vfio_platform_write_mmio(struct vfio_platform_region *reg,
return -EFAULT; return -EFAULT;
} }
static ssize_t vfio_platform_write(void *device_data, const char __user *buf, static ssize_t vfio_platform_write(struct vfio_device *core_vdev, const char __user *buf,
size_t count, loff_t *ppos) size_t count, loff_t *ppos)
{ {
struct vfio_platform_device *vdev = device_data; struct vfio_platform_device *vdev =
container_of(core_vdev, struct vfio_platform_device, vdev);
unsigned int index = VFIO_PLATFORM_OFFSET_TO_INDEX(*ppos); unsigned int index = VFIO_PLATFORM_OFFSET_TO_INDEX(*ppos);
loff_t off = *ppos & VFIO_PLATFORM_OFFSET_MASK; loff_t off = *ppos & VFIO_PLATFORM_OFFSET_MASK;
@ -573,9 +579,10 @@ static int vfio_platform_mmap_mmio(struct vfio_platform_region region,
req_len, vma->vm_page_prot); req_len, vma->vm_page_prot);
} }
static int vfio_platform_mmap(void *device_data, struct vm_area_struct *vma) static int vfio_platform_mmap(struct vfio_device *core_vdev, struct vm_area_struct *vma)
{ {
struct vfio_platform_device *vdev = device_data; struct vfio_platform_device *vdev =
container_of(core_vdev, struct vfio_platform_device, vdev);
unsigned int index; unsigned int index;
index = vma->vm_pgoff >> (VFIO_PLATFORM_OFFSET_SHIFT - PAGE_SHIFT); index = vma->vm_pgoff >> (VFIO_PLATFORM_OFFSET_SHIFT - PAGE_SHIFT);

20
drivers/vfio/vfio.c
View File

@ -832,7 +832,7 @@ static struct vfio_device *vfio_device_get_from_name(struct vfio_group *group,
int ret; int ret;
if (it->ops->match) { if (it->ops->match) {
ret = it->ops->match(it->device_data, buf); ret = it->ops->match(it, buf);
if (ret < 0) { if (ret < 0) {
device = ERR_PTR(ret); device = ERR_PTR(ret);
break; break;
@ -893,7 +893,7 @@ void vfio_unregister_group_dev(struct vfio_device *device)
rc = try_wait_for_completion(&device->comp); rc = try_wait_for_completion(&device->comp);
while (rc <= 0) { while (rc <= 0) {
if (device->ops->request) if (device->ops->request)
device->ops->request(device->device_data, i++); device->ops->request(device, i++);
if (interrupted) { if (interrupted) {
rc = wait_for_completion_timeout(&device->comp, rc = wait_for_completion_timeout(&device->comp,
@ -1379,7 +1379,7 @@ static int vfio_group_get_device_fd(struct vfio_group *group, char *buf)
if (IS_ERR(device)) if (IS_ERR(device))
return PTR_ERR(device); return PTR_ERR(device);
ret = device->ops->open(device->device_data); ret = device->ops->open(device);
if (ret) { if (ret) {
vfio_device_put(device); vfio_device_put(device);
return ret; return ret;
@ -1391,7 +1391,7 @@ static int vfio_group_get_device_fd(struct vfio_group *group, char *buf)
*/ */
ret = get_unused_fd_flags(O_CLOEXEC); ret = get_unused_fd_flags(O_CLOEXEC);
if (ret < 0) { if (ret < 0) {
device->ops->release(device->device_data); device->ops->release(device);
vfio_device_put(device); vfio_device_put(device);
return ret; return ret;
} }
@ -1401,7 +1401,7 @@ static int vfio_group_get_device_fd(struct vfio_group *group, char *buf)
if (IS_ERR(filep)) { if (IS_ERR(filep)) {
put_unused_fd(ret); put_unused_fd(ret);
ret = PTR_ERR(filep); ret = PTR_ERR(filep);
device->ops->release(device->device_data); device->ops->release(device);
vfio_device_put(device); vfio_device_put(device);
return ret; return ret;
} }
@ -1558,7 +1558,7 @@ static int vfio_device_fops_release(struct inode *inode, struct file *filep)
{ {
struct vfio_device *device = filep->private_data; struct vfio_device *device = filep->private_data;
device->ops->release(device->device_data); device->ops->release(device);
vfio_group_try_dissolve_container(device->group); vfio_group_try_dissolve_container(device->group);
@ -1575,7 +1575,7 @@ static long vfio_device_fops_unl_ioctl(struct file *filep,
if (unlikely(!device->ops->ioctl)) if (unlikely(!device->ops->ioctl))
return -EINVAL; return -EINVAL;
return device->ops->ioctl(device->device_data, cmd, arg); return device->ops->ioctl(device, cmd, arg);
} }
static ssize_t vfio_device_fops_read(struct file *filep, char __user *buf, static ssize_t vfio_device_fops_read(struct file *filep, char __user *buf,
@ -1586,7 +1586,7 @@ static ssize_t vfio_device_fops_read(struct file *filep, char __user *buf,
if (unlikely(!device->ops->read)) if (unlikely(!device->ops->read))
return -EINVAL; return -EINVAL;
return device->ops->read(device->device_data, buf, count, ppos); return device->ops->read(device, buf, count, ppos);
} }
static ssize_t vfio_device_fops_write(struct file *filep, static ssize_t vfio_device_fops_write(struct file *filep,
@ -1598,7 +1598,7 @@ static ssize_t vfio_device_fops_write(struct file *filep,
if (unlikely(!device->ops->write)) if (unlikely(!device->ops->write))
return -EINVAL; return -EINVAL;
return device->ops->write(device->device_data, buf, count, ppos); return device->ops->write(device, buf, count, ppos);
} }
static int vfio_device_fops_mmap(struct file *filep, struct vm_area_struct *vma) static int vfio_device_fops_mmap(struct file *filep, struct vm_area_struct *vma)
@ -1608,7 +1608,7 @@ static int vfio_device_fops_mmap(struct file *filep, struct vm_area_struct *vma)
if (unlikely(!device->ops->mmap)) if (unlikely(!device->ops->mmap))
return -EINVAL; return -EINVAL;
return device->ops->mmap(device->device_data, vma); return device->ops->mmap(device, vma);
} }
static const struct file_operations vfio_device_fops = { static const struct file_operations vfio_device_fops = {

16
include/linux/vfio.h
View File

@ -44,17 +44,17 @@ struct vfio_device {
*/ */
struct vfio_device_ops { struct vfio_device_ops {
char *name; char *name;
int (*open)(void *device_data); int (*open)(struct vfio_device *vdev);
void (*release)(void *device_data); void (*release)(struct vfio_device *vdev);
ssize_t (*read)(void *device_data, char __user *buf, ssize_t (*read)(struct vfio_device *vdev, char __user *buf,
size_t count, loff_t *ppos); size_t count, loff_t *ppos);
ssize_t (*write)(void *device_data, const char __user *buf, ssize_t (*write)(struct vfio_device *vdev, const char __user *buf,
size_t count, loff_t *size); size_t count, loff_t *size);
long (*ioctl)(void *device_data, unsigned int cmd, long (*ioctl)(struct vfio_device *vdev, unsigned int cmd,
unsigned long arg); unsigned long arg);
int (*mmap)(void *device_data, struct vm_area_struct *vma); int (*mmap)(struct vfio_device *vdev, struct vm_area_struct *vma);
void (*request)(void *device_data, unsigned int count); void (*request)(struct vfio_device *vdev, unsigned int count);
int (*match)(void *device_data, char *buf); int (*match)(struct vfio_device *vdev, char *buf);
}; };
extern struct iommu_group *vfio_iommu_group_get(struct device *dev); extern struct iommu_group *vfio_iommu_group_get(struct device *dev);