mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-10-03 15:47:36 +00:00
c68ea0d00a
Reuse the logic in vfio_noiommu_group_alloc to allocate a fake single-device iommu group for mediated devices by factoring out a common function, and replacing the noiommu boolean field in struct vfio_group with an enum to distinguish the three different kinds of groups. Signed-off-by: Christoph Hellwig <hch@lst.de> Reviewed-by: Kevin Tian <kevin.tian@intel.com> Link: https://lore.kernel.org/r/20210924155705.4258-8-hch@lst.de Signed-off-by: Alex Williamson <alex.williamson@redhat.com>
152 lines
3.7 KiB
C
152 lines
3.7 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* VFIO based driver for Mediated device
|
|
*
|
|
* Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
|
|
* Author: Neo Jia <cjia@nvidia.com>
|
|
* Kirti Wankhede <kwankhede@nvidia.com>
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/module.h>
|
|
#include <linux/device.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/vfio.h>
|
|
#include <linux/mdev.h>
|
|
|
|
#include "mdev_private.h"
|
|
|
|
static int vfio_mdev_open_device(struct vfio_device *core_vdev)
|
|
{
|
|
struct mdev_device *mdev = to_mdev_device(core_vdev->dev);
|
|
struct mdev_parent *parent = mdev->type->parent;
|
|
|
|
if (unlikely(!parent->ops->open_device))
|
|
return 0;
|
|
|
|
return parent->ops->open_device(mdev);
|
|
}
|
|
|
|
static void vfio_mdev_close_device(struct vfio_device *core_vdev)
|
|
{
|
|
struct mdev_device *mdev = to_mdev_device(core_vdev->dev);
|
|
struct mdev_parent *parent = mdev->type->parent;
|
|
|
|
if (likely(parent->ops->close_device))
|
|
parent->ops->close_device(mdev);
|
|
}
|
|
|
|
static long vfio_mdev_unlocked_ioctl(struct vfio_device *core_vdev,
|
|
unsigned int cmd, unsigned long arg)
|
|
{
|
|
struct mdev_device *mdev = to_mdev_device(core_vdev->dev);
|
|
struct mdev_parent *parent = mdev->type->parent;
|
|
|
|
if (unlikely(!parent->ops->ioctl))
|
|
return 0;
|
|
|
|
return parent->ops->ioctl(mdev, cmd, arg);
|
|
}
|
|
|
|
static ssize_t vfio_mdev_read(struct vfio_device *core_vdev, char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct mdev_device *mdev = to_mdev_device(core_vdev->dev);
|
|
struct mdev_parent *parent = mdev->type->parent;
|
|
|
|
if (unlikely(!parent->ops->read))
|
|
return -EINVAL;
|
|
|
|
return parent->ops->read(mdev, buf, count, ppos);
|
|
}
|
|
|
|
static ssize_t vfio_mdev_write(struct vfio_device *core_vdev,
|
|
const char __user *buf, size_t count,
|
|
loff_t *ppos)
|
|
{
|
|
struct mdev_device *mdev = to_mdev_device(core_vdev->dev);
|
|
struct mdev_parent *parent = mdev->type->parent;
|
|
|
|
if (unlikely(!parent->ops->write))
|
|
return -EINVAL;
|
|
|
|
return parent->ops->write(mdev, buf, count, ppos);
|
|
}
|
|
|
|
static int vfio_mdev_mmap(struct vfio_device *core_vdev,
|
|
struct vm_area_struct *vma)
|
|
{
|
|
struct mdev_device *mdev = to_mdev_device(core_vdev->dev);
|
|
struct mdev_parent *parent = mdev->type->parent;
|
|
|
|
if (unlikely(!parent->ops->mmap))
|
|
return -EINVAL;
|
|
|
|
return parent->ops->mmap(mdev, vma);
|
|
}
|
|
|
|
static void vfio_mdev_request(struct vfio_device *core_vdev, unsigned int count)
|
|
{
|
|
struct mdev_device *mdev = to_mdev_device(core_vdev->dev);
|
|
struct mdev_parent *parent = mdev->type->parent;
|
|
|
|
if (parent->ops->request)
|
|
parent->ops->request(mdev, count);
|
|
else if (count == 0)
|
|
dev_notice(mdev_dev(mdev),
|
|
"No mdev vendor driver request callback support, blocked until released by user\n");
|
|
}
|
|
|
|
static const struct vfio_device_ops vfio_mdev_dev_ops = {
|
|
.name = "vfio-mdev",
|
|
.open_device = vfio_mdev_open_device,
|
|
.close_device = vfio_mdev_close_device,
|
|
.ioctl = vfio_mdev_unlocked_ioctl,
|
|
.read = vfio_mdev_read,
|
|
.write = vfio_mdev_write,
|
|
.mmap = vfio_mdev_mmap,
|
|
.request = vfio_mdev_request,
|
|
};
|
|
|
|
static int vfio_mdev_probe(struct mdev_device *mdev)
|
|
{
|
|
struct vfio_device *vdev;
|
|
int ret;
|
|
|
|
vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
|
|
if (!vdev)
|
|
return -ENOMEM;
|
|
|
|
vfio_init_group_dev(vdev, &mdev->dev, &vfio_mdev_dev_ops);
|
|
ret = vfio_register_emulated_iommu_dev(vdev);
|
|
if (ret)
|
|
goto out_uninit;
|
|
|
|
dev_set_drvdata(&mdev->dev, vdev);
|
|
return 0;
|
|
|
|
out_uninit:
|
|
vfio_uninit_group_dev(vdev);
|
|
kfree(vdev);
|
|
return ret;
|
|
}
|
|
|
|
static void vfio_mdev_remove(struct mdev_device *mdev)
|
|
{
|
|
struct vfio_device *vdev = dev_get_drvdata(&mdev->dev);
|
|
|
|
vfio_unregister_group_dev(vdev);
|
|
vfio_uninit_group_dev(vdev);
|
|
kfree(vdev);
|
|
}
|
|
|
|
struct mdev_driver vfio_mdev_driver = {
|
|
.driver = {
|
|
.name = "vfio_mdev",
|
|
.owner = THIS_MODULE,
|
|
.mod_name = KBUILD_MODNAME,
|
|
},
|
|
.probe = vfio_mdev_probe,
|
|
.remove = vfio_mdev_remove,
|
|
};
|