Currently, except for the crate and remove. The rest fields of mdev_parent_ops is just designed for vfio-mdev driver and may not help for kernel mdev driver. So follow the device id support by previous patch, this patch introduces device specific ops which points to device specific ops (e.g vfio ops). This allows the future drivers like virtio-mdev to implement its own device specific ops.

Signed-off-by: Jason Wang jasowang@redhat.com --- .../driver-api/vfio-mediated-device.rst | 4 +- drivers/gpu/drm/i915/gvt/kvmgt.c | 15 +++--- drivers/s390/cio/vfio_ccw_ops.c | 15 ++++-- drivers/s390/crypto/vfio_ap_ops.c | 11 ++-- drivers/vfio/mdev/vfio_mdev.c | 31 +++++++----- include/linux/mdev.h | 39 ++------------- include/linux/vfio_mdev.h | 50 +++++++++++++++++++ samples/vfio-mdev/mbochs.c | 17 ++++--- samples/vfio-mdev/mdpy.c | 17 ++++--- samples/vfio-mdev/mtty.c | 15 ++++-- 10 files changed, 136 insertions(+), 78 deletions(-) create mode 100644 include/linux/vfio_mdev.h

diff --git a/Documentation/driver-api/vfio-mediated-device.rst b/Documentation/driver-api/vfio-mediated-device.rst index 0d6e85155b9b..f48454bb60b9 100644 --- a/Documentation/driver-api/vfio-mediated-device.rst +++ b/Documentation/driver-api/vfio-mediated-device.rst @@ -152,7 +152,9 @@ callbacks per mdev parent device, per mdev type, or any other categorization. Vendor drivers are expected to be fully asynchronous in this respect or provide their own internal resource protection.)

-The callbacks in the mdev_parent_ops structure are as follows: +The device specific callbacks are referred through device_ops pointer +in mdev_parent_ops. For vfio-mdev device, its callbacks in device_ops +are as follows:

* open: open callback of mediated device * close: close callback of mediated device diff --git a/drivers/gpu/drm/i915/gvt/kvmgt.c b/drivers/gpu/drm/i915/gvt/kvmgt.c index 19d51a35f019..8ea86b1e69f1 100644 --- a/drivers/gpu/drm/i915/gvt/kvmgt.c +++ b/drivers/gpu/drm/i915/gvt/kvmgt.c @@ -42,6 +42,7 @@ #include <linux/kvm_host.h> #include <linux/vfio.h> #include <linux/mdev.h> +#include <linux/vfio_mdev.h> #include <linux/debugfs.h>

#include <linux/nospec.h> @@ -1600,20 +1601,22 @@ static const struct attribute_group *intel_vgpu_groups[] = { NULL, };

-static struct mdev_parent_ops intel_vgpu_ops = { - .mdev_attr_groups = intel_vgpu_groups, - .create = intel_vgpu_create, - .remove = intel_vgpu_remove, - +static struct vfio_mdev_parent_ops intel_vfio_vgpu_ops = { .open = intel_vgpu_open, .release = intel_vgpu_release, - .read = intel_vgpu_read, .write = intel_vgpu_write, .mmap = intel_vgpu_mmap, .ioctl = intel_vgpu_ioctl, };

+static struct mdev_parent_ops intel_vgpu_ops = { + .mdev_attr_groups = intel_vgpu_groups, + .create = intel_vgpu_create, + .remove = intel_vgpu_remove, + .device_ops = &intel_vfio_vgpu_ops, +}; + static int kvmgt_host_init(struct device *dev, void *gvt, const void *ops) { struct attribute **kvm_type_attrs; diff --git a/drivers/s390/cio/vfio_ccw_ops.c b/drivers/s390/cio/vfio_ccw_ops.c index f87d9409e290..e01247cc61b8 100644 --- a/drivers/s390/cio/vfio_ccw_ops.c +++ b/drivers/s390/cio/vfio_ccw_ops.c @@ -12,6 +12,7 @@

#include <linux/vfio.h> #include <linux/mdev.h> +#include <linux/vfio_mdev.h> #include <linux/nospec.h> #include <linux/slab.h>

@@ -564,11 +565,7 @@ static ssize_t vfio_ccw_mdev_ioctl(struct mdev_device *mdev, } }

-static const struct mdev_parent_ops vfio_ccw_mdev_ops = { - .owner = THIS_MODULE, - .supported_type_groups = mdev_type_groups, - .create = vfio_ccw_mdev_create, - .remove = vfio_ccw_mdev_remove, +static const struct vfio_mdev_parent_ops vfio_mdev_ops = { .open = vfio_ccw_mdev_open, .release = vfio_ccw_mdev_release, .read = vfio_ccw_mdev_read, @@ -576,6 +573,14 @@ static const struct mdev_parent_ops vfio_ccw_mdev_ops = { .ioctl = vfio_ccw_mdev_ioctl, };

+static const struct mdev_parent_ops vfio_ccw_mdev_ops = { + .owner = THIS_MODULE, + .supported_type_groups = mdev_type_groups, + .create = vfio_ccw_mdev_create, + .remove = vfio_ccw_mdev_remove, + .device_ops = &vfio_mdev_ops, +}; + int vfio_ccw_mdev_reg(struct subchannel *sch) { return mdev_register_vfio_device(&sch->dev, &vfio_ccw_mdev_ops); diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c index eacbde3c7a97..685ec5946c7b 100644 --- a/drivers/s390/crypto/vfio_ap_ops.c +++ b/drivers/s390/crypto/vfio_ap_ops.c @@ -16,6 +16,7 @@ #include <linux/bitops.h> #include <linux/kvm_host.h> #include <linux/module.h> +#include <linux/vfio_mdev.h> #include <asm/kvm.h> #include <asm/zcrypt.h>

@@ -1280,15 +1281,19 @@ static ssize_t vfio_ap_mdev_ioctl(struct mdev_device *mdev, return ret; }

+static const struct vfio_mdev_parent_ops vfio_mdev_ops = { + .open = vfio_ap_mdev_open, + .release = vfio_ap_mdev_release, + .ioctl = vfio_ap_mdev_ioctl, +}; + static const struct mdev_parent_ops vfio_ap_matrix_ops = { .owner = THIS_MODULE, .supported_type_groups = vfio_ap_mdev_type_groups, .mdev_attr_groups = vfio_ap_mdev_attr_groups, .create = vfio_ap_mdev_create, .remove = vfio_ap_mdev_remove, - .open = vfio_ap_mdev_open, - .release = vfio_ap_mdev_release, - .ioctl = vfio_ap_mdev_ioctl, + .device_ops = &vfio_mdev_ops, };

int vfio_ap_mdev_register(void) diff --git a/drivers/vfio/mdev/vfio_mdev.c b/drivers/vfio/mdev/vfio_mdev.c index fd2a4d9a3f26..d23c9f58c84f 100644 --- a/drivers/vfio/mdev/vfio_mdev.c +++ b/drivers/vfio/mdev/vfio_mdev.c @@ -14,6 +14,7 @@ #include <linux/slab.h> #include <linux/vfio.h> #include <linux/mdev.h> +#include <linux/vfio_mdev.h>

#include "mdev_private.h"

@@ -25,15 +26,16 @@ static int vfio_mdev_open(void *device_data) { struct mdev_device *mdev = device_data; struct mdev_parent *parent = mdev->parent; + const struct vfio_mdev_parent_ops *ops = parent->ops->device_ops; int ret;

- if (unlikely(!parent->ops->open)) + if (unlikely(!ops->open)) return -EINVAL;

if (!try_module_get(THIS_MODULE)) return -ENODEV;

- ret = parent->ops->open(mdev); + ret = ops->open(mdev); if (ret) module_put(THIS_MODULE);

@@ -44,9 +46,10 @@ static void vfio_mdev_release(void *device_data) { struct mdev_device *mdev = device_data; struct mdev_parent *parent = mdev->parent; + const struct vfio_mdev_parent_ops *ops = parent->ops->device_ops;

- if (likely(parent->ops->release)) - parent->ops->release(mdev); + if (likely(ops->release)) + ops->release(mdev);

module_put(THIS_MODULE); } @@ -56,11 +59,12 @@ static long vfio_mdev_unlocked_ioctl(void *device_data, { struct mdev_device *mdev = device_data; struct mdev_parent *parent = mdev->parent; + const struct vfio_mdev_parent_ops *ops = parent->ops->device_ops;

- if (unlikely(!parent->ops->ioctl)) + if (unlikely(!ops->ioctl)) return -EINVAL;

- return parent->ops->ioctl(mdev, cmd, arg); + return ops->ioctl(mdev, cmd, arg); }

static ssize_t vfio_mdev_read(void *device_data, char __user *buf, @@ -68,11 +72,12 @@ static ssize_t vfio_mdev_read(void *device_data, char __user *buf, { struct mdev_device *mdev = device_data; struct mdev_parent *parent = mdev->parent; + const struct vfio_mdev_parent_ops *ops = parent->ops->device_ops;

- if (unlikely(!parent->ops->read)) + if (unlikely(!ops->read)) return -EINVAL;

- return parent->ops->read(mdev, buf, count, ppos); + return ops->read(mdev, buf, count, ppos); }

static ssize_t vfio_mdev_write(void *device_data, const char __user *buf, @@ -80,22 +85,24 @@ static ssize_t vfio_mdev_write(void *device_data, const char __user *buf, { struct mdev_device *mdev = device_data; struct mdev_parent *parent = mdev->parent; + const struct vfio_mdev_parent_ops *ops = parent->ops->device_ops;

- if (unlikely(!parent->ops->write)) + if (unlikely(!ops->write)) return -EINVAL;

- return parent->ops->write(mdev, buf, count, ppos); + return ops->write(mdev, buf, count, ppos); }

static int vfio_mdev_mmap(void *device_data, struct vm_area_struct *vma) { struct mdev_device *mdev = device_data; struct mdev_parent *parent = mdev->parent; + const struct vfio_mdev_parent_ops *ops = parent->ops->device_ops;

- if (unlikely(!parent->ops->mmap)) + if (unlikely(!ops->mmap)) return -EINVAL;

- return parent->ops->mmap(mdev, vma); + return ops->mmap(mdev, vma); }

static const struct vfio_device_ops vfio_mdev_dev_ops = { diff --git a/include/linux/mdev.h b/include/linux/mdev.h index bb0a743e5a03..99fdfd74433d 100644 --- a/include/linux/mdev.h +++ b/include/linux/mdev.h @@ -48,30 +48,8 @@ struct device *mdev_get_iommu_device(struct device *dev); * @mdev: mdev_device device structure which is being * destroyed * Returns integer: success (0) or error (< 0) - * @open: Open mediated device. - * @mdev: mediated device. - * Returns integer: success (0) or error (< 0) - * @release: release mediated device - * @mdev: mediated device. - * @read: Read emulation callback - * @mdev: mediated device structure - * @buf: read buffer - * @count: number of bytes to read - * @ppos: address. - * Retuns number on bytes read on success or error. - * @write: Write emulation callback - * @mdev: mediated device structure - * @buf: write buffer - * @count: number of bytes to be written - * @ppos: address. - * Retuns number on bytes written on success or error. - * @ioctl: IOCTL callback - * @mdev: mediated device structure - * @cmd: ioctl command - * @arg: arguments to ioctl - * @mmap: mmap callback - * @mdev: mediated device structure - * @vma: vma structure + * @device_ops: Device specific emulation callback. + * * Parent device that support mediated device should be registered with mdev * module with mdev_parent_ops structure. **/ @@ -83,15 +61,7 @@ struct mdev_parent_ops {

int (*create)(struct kobject *kobj, struct mdev_device *mdev); int (*remove)(struct mdev_device *mdev); - int (*open)(struct mdev_device *mdev); - void (*release)(struct mdev_device *mdev); - ssize_t (*read)(struct mdev_device *mdev, char __user *buf, - size_t count, loff_t *ppos); - ssize_t (*write)(struct mdev_device *mdev, const char __user *buf, - size_t count, loff_t *ppos); - long (*ioctl)(struct mdev_device *mdev, unsigned int cmd, - unsigned long arg); - int (*mmap)(struct mdev_device *mdev, struct vm_area_struct *vma); + const void *device_ops; };

/* interface for exporting mdev supported type attributes */ @@ -137,7 +107,8 @@ const guid_t *mdev_uuid(struct mdev_device *mdev);

extern struct bus_type mdev_bus_type;

-int mdev_register_vfio_device(struct device *dev, const struct mdev_parent_ops *ops); +int mdev_register_vfio_device(struct device *dev, + const struct mdev_parent_ops *ops); void mdev_unregister_device(struct device *dev);

int mdev_register_driver(struct mdev_driver *drv, struct module *owner); diff --git a/include/linux/vfio_mdev.h b/include/linux/vfio_mdev.h new file mode 100644 index 000000000000..7f884b946cba --- /dev/null +++ b/include/linux/vfio_mdev.h @@ -0,0 +1,50 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * VFIO Mediated device definition + */ + +#ifndef VFIO_MDEV_H +#define VFIO_MDEV_H + +/** + * struct vfio_mdev_parent_ops - Structure to be registered for each + * parent device to register the device to vfio-mdev module. + * + * @open: Open mediated device. + * @mdev: mediated device. + * Returns integer: success (0) or error (< 0) + * @release: release mediated device + * @mdev: mediated device. + * @read: Read emulation callback + * @mdev: mediated device structure + * @buf: read buffer + * @count: number of bytes to read + * @ppos: address. + * Retuns number on bytes read on success or error. + * @write: Write emulation callback + * @mdev: mediated device structure + * @buf: write buffer + * @count: number of bytes to be written + * @ppos: address. + * Retuns number on bytes written on success or error. + * @ioctl: IOCTL callback + * @mdev: mediated device structure + * @cmd: ioctl command + * @arg: arguments to ioctl + * @mmap: mmap callback + * @mdev: mediated device structure + * @vma: vma structure + */ +struct vfio_mdev_parent_ops { + int (*open)(struct mdev_device *mdev); + void (*release)(struct mdev_device *mdev); + ssize_t (*read)(struct mdev_device *mdev, char __user *buf, + size_t count, loff_t *ppos); + ssize_t (*write)(struct mdev_device *mdev, const char __user *buf, + size_t count, loff_t *ppos); + long (*ioctl)(struct mdev_device *mdev, unsigned int cmd, + unsigned long arg); + int (*mmap)(struct mdev_device *mdev, struct vm_area_struct *vma); +}; + +#endif diff --git a/samples/vfio-mdev/mbochs.c b/samples/vfio-mdev/mbochs.c index 71a4469be85d..107cc30d0f45 100644 --- a/samples/vfio-mdev/mbochs.c +++ b/samples/vfio-mdev/mbochs.c @@ -30,6 +30,7 @@ #include <linux/iommu.h> #include <linux/sysfs.h> #include <linux/mdev.h> +#include <linux/vfio_mdev.h> #include <linux/pci.h> #include <linux/dma-buf.h> #include <linux/highmem.h> @@ -1418,12 +1419,7 @@ static struct attribute_group *mdev_type_groups[] = { NULL, };

-static const struct mdev_parent_ops mdev_fops = { - .owner = THIS_MODULE, - .mdev_attr_groups = mdev_dev_groups, - .supported_type_groups = mdev_type_groups, - .create = mbochs_create, - .remove = mbochs_remove, +static const struct vfio_mdev_parent_ops vfio_mdev_ops = { .open = mbochs_open, .release = mbochs_close, .read = mbochs_read, @@ -1432,6 +1428,15 @@ static const struct mdev_parent_ops mdev_fops = { .mmap = mbochs_mmap, };

+static const struct mdev_parent_ops mdev_fops = { + .owner = THIS_MODULE, + .mdev_attr_groups = mdev_dev_groups, + .supported_type_groups = mdev_type_groups, + .create = mbochs_create, + .remove = mbochs_remove, + .device_ops = &vfio_mdev_ops, +}; + static const struct file_operations vd_fops = { .owner = THIS_MODULE, }; diff --git a/samples/vfio-mdev/mdpy.c b/samples/vfio-mdev/mdpy.c index d3029dd27d91..2cd2018a53f9 100644 --- a/samples/vfio-mdev/mdpy.c +++ b/samples/vfio-mdev/mdpy.c @@ -26,6 +26,7 @@ #include <linux/iommu.h> #include <linux/sysfs.h> #include <linux/mdev.h> +#include <linux/vfio_mdev.h> #include <linux/pci.h> #include <drm/drm_fourcc.h> #include "mdpy-defs.h" @@ -725,12 +726,7 @@ static struct attribute_group *mdev_type_groups[] = { NULL, };

-static const struct mdev_parent_ops mdev_fops = { - .owner = THIS_MODULE, - .mdev_attr_groups = mdev_dev_groups, - .supported_type_groups = mdev_type_groups, - .create = mdpy_create, - .remove = mdpy_remove, +static const struct vfio_mdev_parent_ops vfio_mdev_ops = { .open = mdpy_open, .release = mdpy_close, .read = mdpy_read, @@ -739,6 +735,15 @@ static const struct mdev_parent_ops mdev_fops = { .mmap = mdpy_mmap, };

+static const struct mdev_parent_ops mdev_fops = { + .owner = THIS_MODULE, + .mdev_attr_groups = mdev_dev_groups, + .supported_type_groups = mdev_type_groups, + .create = mdpy_create, + .remove = mdpy_remove, + .device_ops = &vfio_mdev_ops, +}; + static const struct file_operations vd_fops = { .owner = THIS_MODULE, }; diff --git a/samples/vfio-mdev/mtty.c b/samples/vfio-mdev/mtty.c index 744c88a6b22c..e427425b5daf 100644 --- a/samples/vfio-mdev/mtty.c +++ b/samples/vfio-mdev/mtty.c @@ -27,6 +27,7 @@ #include <linux/ctype.h> #include <linux/file.h> #include <linux/mdev.h> +#include <linux/vfio_mdev.h> #include <linux/pci.h> #include <linux/serial.h> #include <uapi/linux/serial_reg.h> @@ -1410,6 +1411,14 @@ static struct attribute_group *mdev_type_groups[] = { NULL, };

+static const struct vfio_mdev_parent_ops vfio_mdev_ops = { + .open = mtty_open, + .release = mtty_close, + .read = mtty_read, + .write = mtty_write, + .ioctl = mtty_ioctl, +}; + static const struct mdev_parent_ops mdev_fops = { .owner = THIS_MODULE, .dev_attr_groups = mtty_dev_groups, @@ -1417,11 +1426,7 @@ static const struct mdev_parent_ops mdev_fops = { .supported_type_groups = mdev_type_groups, .create = mtty_create, .remove = mtty_remove, - .open = mtty_open, - .release = mtty_close, - .read = mtty_read, - .write = mtty_write, - .ioctl = mtty_ioctl, + .device_ops = &vfio_mdev_ops, };

static void mtty_device_release(struct device *dev)

This path introduces a new mdev transport for virtio. This is used to use kernel virtio driver to drive the mediated device that is capable of populating virtqueue directly.

A new virtio-mdev driver will be registered to the mdev bus, when a new virtio-mdev device is probed, it will register the device with mdev based config ops. This means, unlike the exist hardware transport, this is a software transport between mdev driver and mdev device. The transport was implemented through device specific ops which is a part of mdev_parent_ops now.

Signed-off-by: Jason Wang jasowang@redhat.com --- drivers/vfio/mdev/Kconfig | 7 + drivers/vfio/mdev/Makefile | 1 + drivers/vfio/mdev/virtio_mdev.c | 418 ++++++++++++++++++++++++++++++++ 3 files changed, 426 insertions(+) create mode 100644 drivers/vfio/mdev/virtio_mdev.c

diff --git a/drivers/vfio/mdev/Kconfig b/drivers/vfio/mdev/Kconfig index 5da27f2100f9..c488c31fc137 100644 --- a/drivers/vfio/mdev/Kconfig +++ b/drivers/vfio/mdev/Kconfig @@ -16,3 +16,10 @@ config VFIO_MDEV_DEVICE default n help VFIO based driver for Mediated devices. + +config VIRTIO_MDEV_DEVICE + tristate "VIRTIO driver for Mediated devices" + depends on VFIO_MDEV && VIRTIO + default n + help + VIRTIO based driver for Mediated devices. diff --git a/drivers/vfio/mdev/Makefile b/drivers/vfio/mdev/Makefile index 101516fdf375..99d31e29c23e 100644 --- a/drivers/vfio/mdev/Makefile +++ b/drivers/vfio/mdev/Makefile @@ -4,3 +4,4 @@ mdev-y := mdev_core.o mdev_sysfs.o mdev_driver.o

obj-$(CONFIG_VFIO_MDEV) += mdev.o obj-$(CONFIG_VFIO_MDEV_DEVICE) += vfio_mdev.o +obj-$(CONFIG_VIRTIO_MDEV_DEVICE) += virtio_mdev.o diff --git a/drivers/vfio/mdev/virtio_mdev.c b/drivers/vfio/mdev/virtio_mdev.c new file mode 100644 index 000000000000..cee73fe392bb --- /dev/null +++ b/drivers/vfio/mdev/virtio_mdev.c @@ -0,0 +1,418 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * VIRTIO based driver for Mediated device + * + * Copyright (c) 2019, Red Hat. All rights reserved. + * Author: Jason Wang jasowang@redhat.com + * + */ + +#include <linux/init.h> +#include <linux/module.h> +#include <linux/device.h> +#include <linux/kernel.h> +#include <linux/slab.h> +#include <linux/uuid.h> +#include <linux/mdev.h> +#include <linux/virtio_mdev.h> +#include <linux/virtio.h> +#include <linux/virtio_config.h> +#include <linux/virtio_ring.h> +#include "mdev_private.h" + +#define DRIVER_VERSION "0.1" +#define DRIVER_AUTHOR "Red Hat Corporation" +#define DRIVER_DESC "VIRTIO based driver for Mediated device" + +#define to_virtio_mdev_device(dev) \ + container_of(dev, struct virtio_mdev_device, vdev) + +struct virtio_mdev_device { + struct virtio_device vdev; + struct mdev_device *mdev; + unsigned long version; + + struct virtqueue **vqs; + spinlock_t lock; +}; + +struct virtio_mdev_vq_info { + /* the actual virtqueue */ + struct virtqueue *vq; + + /* the list node for the virtqueues list */ + struct list_head node; +}; + +static struct mdev_device *vm_get_mdev(struct virtio_device *vdev) +{ + struct virtio_mdev_device *vm_dev = to_virtio_mdev_device(vdev); + struct mdev_device *mdev = vm_dev->mdev; + + return mdev; +} + +static const struct virtio_mdev_parent_ops +*mdev_get_parent_ops(struct mdev_device *mdev) +{ + struct mdev_parent *parent = mdev->parent; + + return parent->ops->device_ops; +} + +static void virtio_mdev_get(struct virtio_device *vdev, unsigned offset, + void *buf, unsigned len) +{ + struct mdev_device *mdev = vm_get_mdev(vdev); + const struct virtio_mdev_parent_ops *ops = mdev_get_parent_ops(mdev); + + ops->get_config(mdev, offset, buf, len); +} + +static void virtio_mdev_set(struct virtio_device *vdev, unsigned offset, + const void *buf, unsigned len) +{ + struct mdev_device *mdev = vm_get_mdev(vdev); + const struct virtio_mdev_parent_ops *ops = mdev_get_parent_ops(mdev); + + ops->set_config(mdev, offset, buf, len); +} + +static u32 virtio_mdev_generation(struct virtio_device *vdev) +{ + struct mdev_device *mdev = vm_get_mdev(vdev); + const struct virtio_mdev_parent_ops *ops = mdev_get_parent_ops(mdev); + + return ops->get_generation(mdev); +} + +static u8 virtio_mdev_get_status(struct virtio_device *vdev) +{ + struct mdev_device *mdev = vm_get_mdev(vdev); + const struct virtio_mdev_parent_ops *ops = mdev_get_parent_ops(mdev); + + return ops->get_status(mdev); +} + +static void virtio_mdev_set_status(struct virtio_device *vdev, u8 status) +{ + struct mdev_device *mdev = vm_get_mdev(vdev); + const struct virtio_mdev_parent_ops *ops = mdev_get_parent_ops(mdev); + + return ops->set_status(mdev, status); +} + +static void virtio_mdev_reset(struct virtio_device *vdev) +{ + struct mdev_device *mdev = vm_get_mdev(vdev); + const struct virtio_mdev_parent_ops *ops = mdev_get_parent_ops(mdev); + + return ops->set_status(mdev, 0); +} + +static bool virtio_mdev_notify(struct virtqueue *vq) +{ + struct mdev_device *mdev = vm_get_mdev(vq->vdev); + const struct virtio_mdev_parent_ops *ops = mdev_get_parent_ops(mdev); + + ops->kick_vq(mdev, vq->index); + + return true; +} + +static irqreturn_t virtio_mdev_config_cb(void *private) +{ + struct virtio_mdev_device *vm_dev = private; + + virtio_config_changed(&vm_dev->vdev); + + return IRQ_HANDLED; +} + +static irqreturn_t virtio_mdev_virtqueue_cb(void *private) +{ + struct virtio_mdev_vq_info *info = private; + + return vring_interrupt(0, info->vq); +} + +/* FIXME: return */ +static struct virtqueue * +virtio_mdev_setup_vq(struct virtio_device *vdev, unsigned index, + void (*callback)(struct virtqueue *vq), + const char *name, bool ctx) +{ + struct mdev_device *mdev = vm_get_mdev(vdev); + const struct virtio_mdev_parent_ops *ops = mdev_get_parent_ops(mdev); + struct virtio_mdev_vq_info *info; + struct virtio_mdev_callback cb; + struct virtqueue *vq; + u32 align, num; + u64 desc_addr, driver_addr, device_addr; + int err; + + if (!name) + return NULL; + + /* Queue shouldn't already be set up. */ + if (ops->get_vq_ready(mdev, index)) { + err = -ENOENT; + goto error_available; + } + + /* Allocate and fill out our active queue description */ + info = kmalloc(sizeof(*info), GFP_KERNEL); + if (!info) { + err = -ENOMEM; + goto error_kmalloc; + } + + num = ops->get_queue_max(mdev); + if (num == 0) { + err = -ENOENT; + goto error_new_virtqueue; + } + + /* Create the vring */ + align = ops->get_vq_align(mdev); + vq = vring_create_virtqueue(index, num, align, vdev, + true, true, ctx, + virtio_mdev_notify, callback, name); + if (!vq) { + err = -ENOMEM; + goto error_new_virtqueue; + } + + /* Setup virtqueue callback */ + cb.callback = virtio_mdev_virtqueue_cb; + cb.private = info; + ops->set_vq_cb(mdev, index, &cb); + ops->set_vq_num(mdev, index, virtqueue_get_vring_size(vq)); + + desc_addr = virtqueue_get_desc_addr(vq); + driver_addr = virtqueue_get_avail_addr(vq); + device_addr = virtqueue_get_used_addr(vq); + + if (ops->set_vq_address(mdev, index, + desc_addr, driver_addr, + device_addr)) { + err = -EINVAL; + goto err_vq; + } + + ops->set_vq_ready(mdev, index, 1); + + vq->priv = info; + info->vq = vq; + + return vq; + +err_vq: + vring_del_virtqueue(vq); +error_new_virtqueue: + ops->set_vq_ready(mdev, index, 0); + WARN_ON(ops->get_vq_ready(mdev, index)); + kfree(info); +error_kmalloc: +error_available: + return ERR_PTR(err); + +} + +static void virtio_mdev_del_vq(struct virtqueue *vq) +{ + struct mdev_device *mdev = vm_get_mdev(vq->vdev); + const struct virtio_mdev_parent_ops *ops = mdev_get_parent_ops(mdev); + struct virtio_mdev_vq_info *info = vq->priv; + unsigned int index = vq->index; + + /* Select and deactivate the queue */ + ops->set_vq_ready(mdev, index, 0); + WARN_ON(ops->get_vq_ready(mdev, index)); + + vring_del_virtqueue(vq); + + kfree(info); +} + +static void virtio_mdev_del_vqs(struct virtio_device *vdev) +{ + struct virtqueue *vq, *n; + + list_for_each_entry_safe(vq, n, &vdev->vqs, list) + virtio_mdev_del_vq(vq); + + return; +} + +static int virtio_mdev_find_vqs(struct virtio_device *vdev, unsigned nvqs, + struct virtqueue *vqs[], + vq_callback_t *callbacks[], + const char * const names[], + const bool *ctx, + struct irq_affinity *desc) +{ + struct virtio_mdev_device *vm_dev = to_virtio_mdev_device(vdev); + struct mdev_device *mdev = vm_get_mdev(vdev); + const struct virtio_mdev_parent_ops *ops = mdev_get_parent_ops(mdev); + struct virtio_mdev_callback cb; + int i, err, queue_idx = 0; + vm_dev->vqs = kmalloc_array(queue_idx, sizeof(*vm_dev->vqs), + GFP_KERNEL); + if (!vm_dev->vqs) + return -ENOMEM; + + for (i = 0; i < nvqs; ++i) { + if (!names[i]) { + vqs[i] = NULL; + continue; + } + + vqs[i] = virtio_mdev_setup_vq(vdev, queue_idx++, + callbacks[i], names[i], ctx ? + ctx[i] : false); + if (IS_ERR(vqs[i])) { + err = PTR_ERR(vqs[i]); + goto err_setup_vq; + } + } + + cb.callback = virtio_mdev_config_cb; + cb.private = vm_dev; + ops->set_config_cb(mdev, &cb); + + return 0; + +err_setup_vq: + kfree(vm_dev->vqs); + virtio_mdev_del_vqs(vdev); + return err; +} + +static u64 virtio_mdev_get_features(struct virtio_device *vdev) +{ + struct mdev_device *mdev = vm_get_mdev(vdev); + const struct virtio_mdev_parent_ops *ops = mdev_get_parent_ops(mdev); + + return ops->get_features(mdev); +} + +static int virtio_mdev_finalize_features(struct virtio_device *vdev) +{ + struct mdev_device *mdev = vm_get_mdev(vdev); + const struct virtio_mdev_parent_ops *ops = mdev_get_parent_ops(mdev); + + /* Give virtio_ring a chance to accept features. */ + vring_transport_features(vdev); + + return ops->set_features(mdev, vdev->features); +} + +static const char *virtio_mdev_bus_name(struct virtio_device *vdev) +{ + struct virtio_mdev_device *vm_dev = to_virtio_mdev_device(vdev); + struct mdev_device *mdev = vm_dev->mdev; + + return dev_name(&mdev->dev); +} + +static const struct virtio_config_ops virtio_mdev_config_ops = { + .get = virtio_mdev_get, + .set = virtio_mdev_set, + .generation = virtio_mdev_generation, + .get_status = virtio_mdev_get_status, + .set_status = virtio_mdev_set_status, + .reset = virtio_mdev_reset, + .find_vqs = virtio_mdev_find_vqs, + .del_vqs = virtio_mdev_del_vqs, + .get_features = virtio_mdev_get_features, + .finalize_features = virtio_mdev_finalize_features, + .bus_name = virtio_mdev_bus_name, +}; + +static void virtio_mdev_release_dev(struct device *_d) +{ + struct virtio_device *vdev = + container_of(_d, struct virtio_device, dev); + struct virtio_mdev_device *vm_dev = + container_of(vdev, struct virtio_mdev_device, vdev); + + devm_kfree(_d, vm_dev); +} + +static int virtio_mdev_probe(struct device *dev) +{ + struct mdev_device *mdev = to_mdev_device(dev); + const struct virtio_mdev_parent_ops *ops = mdev_get_parent_ops(mdev); + struct virtio_mdev_device *vm_dev; + int rc; + + vm_dev = devm_kzalloc(dev, sizeof(*vm_dev), GFP_KERNEL); + if (!vm_dev) + return -ENOMEM; + + vm_dev->vdev.dev.parent = dev; + vm_dev->vdev.dev.release = virtio_mdev_release_dev; + vm_dev->vdev.config = &virtio_mdev_config_ops; + vm_dev->mdev = mdev; + vm_dev->vqs = NULL; + spin_lock_init(&vm_dev->lock); + + vm_dev->version = ops->get_version(mdev); + if (vm_dev->version != 1) { + dev_err(dev, "Version %ld not supported!\n", + vm_dev->version); + return -ENXIO; + } + + vm_dev->vdev.id.device = ops->get_device_id(mdev); + if (vm_dev->vdev.id.device == 0) + return -ENODEV; + + vm_dev->vdev.id.vendor = ops->get_vendor_id(mdev); + rc = register_virtio_device(&vm_dev->vdev); + if (rc) + put_device(dev); + + dev_set_drvdata(dev, vm_dev); + + return rc; + +} + +static void virtio_mdev_remove(struct device *dev) +{ + struct virtio_mdev_device *vm_dev = dev_get_drvdata(dev); + + unregister_virtio_device(&vm_dev->vdev); +} + +static struct mdev_class_id id_table[] = { + { MDEV_ID_VIRTIO }, + { 0 }, +}; + +static struct mdev_driver virtio_mdev_driver = { + .name = "virtio_mdev", + .probe = virtio_mdev_probe, + .remove = virtio_mdev_remove, + .id_table = id_table, +}; + +static int __init virtio_mdev_init(void) +{ + return mdev_register_driver(&virtio_mdev_driver, THIS_MODULE); +} + +static void __exit virtio_mdev_exit(void) +{ + mdev_unregister_driver(&virtio_mdev_driver); +} + +module_init(virtio_mdev_init) +module_exit(virtio_mdev_exit) + +MODULE_VERSION(DRIVER_VERSION); +MODULE_LICENSE("GPL v2"); +MODULE_AUTHOR(DRIVER_AUTHOR); +MODULE_DESCRIPTION(DRIVER_DESC);

This sample driver creates mdev device that simulate virtio net device over virtio mdev transport. The device is implemented through vringh and workqueue. A device specific dma ops is to make sure HVA is used directly as the IOVA. This should be sufficient for kernel virtio driver to work.

No more work for userspace VFIO based vhost-mdev driver to work. E.g through notifier, it will be addressed in the future.

Signed-off-by: Jason Wang jasowang@redhat.com --- samples/Kconfig | 7 + samples/vfio-mdev/Makefile | 1 + samples/vfio-mdev/mvnet.c | 688 +++++++++++++++++++++++++++++++++++++ 3 files changed, 696 insertions(+) create mode 100644 samples/vfio-mdev/mvnet.c

diff --git a/samples/Kconfig b/samples/Kconfig index c8dacb4dda80..a1a1ca2c00b7 100644 --- a/samples/Kconfig +++ b/samples/Kconfig @@ -131,6 +131,13 @@ config SAMPLE_VFIO_MDEV_MDPY mediated device. It is a simple framebuffer and supports the region display interface (VFIO_GFX_PLANE_TYPE_REGION).

+config SAMPLE_VIRTIO_MDEV_NET + tristate "Build virtio mdev net example mediated device sample code -- loadable modules only" + depends on VIRTIO_MDEV_DEVICE && VHOST_RING && m + help + Build a networking sample device for use as a virtio + mediated device. + config SAMPLE_VFIO_MDEV_MDPY_FB tristate "Build VFIO mdpy example guest fbdev driver -- loadable module only" depends on FB && m diff --git a/samples/vfio-mdev/Makefile b/samples/vfio-mdev/Makefile index 10d179c4fdeb..f34af90ed0a0 100644 --- a/samples/vfio-mdev/Makefile +++ b/samples/vfio-mdev/Makefile @@ -3,3 +3,4 @@ obj-$(CONFIG_SAMPLE_VFIO_MDEV_MTTY) += mtty.o obj-$(CONFIG_SAMPLE_VFIO_MDEV_MDPY) += mdpy.o obj-$(CONFIG_SAMPLE_VFIO_MDEV_MDPY_FB) += mdpy-fb.o obj-$(CONFIG_SAMPLE_VFIO_MDEV_MBOCHS) += mbochs.o +obj-$(CONFIG_SAMPLE_VIRTIO_MDEV_NET) += mvnet.o diff --git a/samples/vfio-mdev/mvnet.c b/samples/vfio-mdev/mvnet.c new file mode 100644 index 000000000000..e1036e753c76 --- /dev/null +++ b/samples/vfio-mdev/mvnet.c @@ -0,0 +1,688 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Mediated virtual virtio-net device driver. + * + * Copyright (c) 2019, Red Hat Inc. All rights reserved. + * Author: Jason Wang jasowang@redhat.com + * + * Sample driver that creates mdev device that simulates ethernet loopback + * device. + * + * Usage: + * + * # modprobe virtio_mdev + * # modprobe mvnet + * # cd /sys/devices/virtual/mvnet/mvnet/mdev_supported_types/mvnet- + * # echo "83b8f4f2-509f-382f-3c1e-e6bfe0fa1001" > ./create + * # cd devices/83b8f4f2-509f-382f-3c1e-e6bfe0fa1001 + * # ls -d virtio0 + * virtio0 + */ + +#include <linux/init.h> +#include <linux/module.h> +#include <linux/device.h> +#include <linux/kernel.h> +#include <linux/fs.h> +#include <linux/poll.h> +#include <linux/slab.h> +#include <linux/sched.h> +#include <linux/wait.h> +#include <linux/uuid.h> +#include <linux/iommu.h> +#include <linux/sysfs.h> +#include <linux/file.h> +#include <linux/etherdevice.h> +#include <linux/mdev.h> +#include <linux/vringh.h> +#include <linux/virtio_mdev.h> +#include <uapi/linux/virtio_config.h> +#include <uapi/linux/virtio_net.h> + +#define VERSION_STRING "0.1" +#define DRIVER_AUTHOR "Red Hat Corporation" + +#define MVNET_CLASS_NAME "mvnet" +#define MVNET_NAME "mvnet" + +/* + * Global Structures + */ + +static struct mvnet_dev { + struct class *vd_class; + struct idr vd_idr; + struct device dev; +} mvnet_dev; + +struct mvnet_virtqueue { + struct vringh vring; + struct vringh_kiov iov; + unsigned short head; + bool ready; + u64 desc_addr; + u64 device_addr; + u64 driver_addr; + u32 num; + void *private; + irqreturn_t (*cb)(void *); +}; + +#define MVNET_QUEUE_ALIGN PAGE_SIZE +#define MVNET_QUEUE_MAX 256 +#define MVNET_DEVICE_ID 0x1 +#define MVNET_VENDOR_ID 0 + +u64 mvnet_features = (1ULL << VIRTIO_F_ANY_LAYOUT) | + (1ULL << VIRTIO_F_VERSION_1) | + (1ULL << VIRTIO_F_IOMMU_PLATFORM) ; + +/* State of each mdev device */ +struct mvnet_state { + struct mvnet_virtqueue vqs[2]; + struct work_struct work; + spinlock_t lock; + struct mdev_device *mdev; + struct virtio_net_config config; + void *buffer; + u32 status; + u32 generation; + u64 features; + struct list_head next; +}; + +static struct mutex mdev_list_lock; +static struct list_head mdev_devices_list; + +static void mvnet_queue_ready(struct mvnet_state *mvnet, unsigned idx) +{ + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + int ret; + + ret = vringh_init_kern(&vq->vring, mvnet_features, MVNET_QUEUE_MAX, + false, (struct vring_desc *)vq->desc_addr, + (struct vring_avail *)vq->driver_addr, + (struct vring_used *)vq->device_addr); +} + +static void mvnet_vq_reset(struct mvnet_virtqueue *vq) +{ + vq->ready = 0; + vq->desc_addr = 0; + vq->driver_addr = 0; + vq->device_addr = 0; + vq->cb = NULL; + vq->private = NULL; + vringh_init_kern(&vq->vring, mvnet_features, MVNET_QUEUE_MAX, + false, 0, 0, 0); +} + +static void mvnet_reset(struct mvnet_state *mvnet) +{ + int i; + + for (i = 0; i < 2; i++) + mvnet_vq_reset(&mvnet->vqs[i]); + + mvnet->features = 0; + mvnet->status = 0; + ++mvnet->generation; +} + +static void mvnet_work(struct work_struct *work) +{ + struct mvnet_state *mvnet = container_of(work, struct + mvnet_state, work); + struct mvnet_virtqueue *txq = &mvnet->vqs[1]; + struct mvnet_virtqueue *rxq = &mvnet->vqs[0]; + size_t read, write, total_write; + int err; + int pkts = 0; + + spin_lock(&mvnet->lock); + + if (!txq->ready || !rxq->ready) + goto out; + + while (true) { + total_write = 0; + err = vringh_getdesc_kern(&txq->vring, &txq->iov, NULL, + &txq->head, GFP_ATOMIC); + if (err <= 0) + break; + + err = vringh_getdesc_kern(&rxq->vring, NULL, &rxq->iov, + &rxq->head, GFP_ATOMIC); + if (err <= 0) { + vringh_complete_kern(&txq->vring, txq->head, 0); + break; + } + + while (true) { + read = vringh_iov_pull_kern(&txq->iov, mvnet->buffer, + PAGE_SIZE); + if (read <= 0) + break; + + write = vringh_iov_push_kern(&rxq->iov, mvnet->buffer, + read); + if (write <= 0) + break; + + total_write += write; + } + + /* Make sure data is wrote before advancing index */ + smp_wmb(); + + vringh_complete_kern(&txq->vring, txq->head, 0); + vringh_complete_kern(&rxq->vring, rxq->head, total_write); + + /* Make sure used is visible before rasing the + interrupt */ + smp_wmb(); + + local_bh_disable(); + if (txq->cb) + txq->cb(txq->private); + if (rxq->cb) + rxq->cb(rxq->private); + local_bh_enable(); + + if (++pkts > 4) { + schedule_work(&mvnet->work); + goto out; + } + } + +out: + spin_unlock(&mvnet->lock); +} + +static dma_addr_t mvnet_map_page(struct device *dev, struct page *page, + unsigned long offset, size_t size, + enum dma_data_direction dir, + unsigned long attrs) +{ + /* Vringh can only use HVA */ + return (dma_addr_t)(page_address(page) + offset); +} + +static void mvnet_unmap_page(struct device *dev, dma_addr_t dma_addr, + size_t size, enum dma_data_direction dir, + unsigned long attrs) +{ + return ; +} + +static void *mvnet_alloc_coherent(struct device *dev, size_t size, + dma_addr_t *dma_addr, gfp_t flag, + unsigned long attrs) +{ + void *addr = kmalloc(size, flag); + + if (addr == NULL) + *dma_addr = DMA_MAPPING_ERROR; + else + *dma_addr = (dma_addr_t) addr; + + return addr; +} + +static void mvnet_free_coherent(struct device *dev, size_t size, + void *vaddr, dma_addr_t dma_addr, + unsigned long attrs) +{ + kfree((void *)dma_addr); +} + +static const struct dma_map_ops mvnet_dma_ops = { + .map_page = mvnet_map_page, + .unmap_page = mvnet_unmap_page, + .alloc = mvnet_alloc_coherent, + .free = mvnet_free_coherent, +}; + +static int mvnet_create(struct kobject *kobj, struct mdev_device *mdev) +{ + struct mvnet_state *mvnet; + struct virtio_net_config *config; + struct device *dev = mdev_dev(mdev); + + if (!mdev) + return -EINVAL; + + mvnet = kzalloc(sizeof(struct mvnet_state), GFP_KERNEL); + if (mvnet == NULL) + return -ENOMEM; + + mvnet->buffer = kmalloc(PAGE_SIZE, GFP_KERNEL); + if (!mvnet->buffer) { + kfree(mvnet); + return -ENOMEM; + } + + config = &mvnet->config; + config->mtu = 1500; + config->status = VIRTIO_NET_S_LINK_UP; + eth_random_addr(config->mac); + + INIT_WORK(&mvnet->work, mvnet_work); + + spin_lock_init(&mvnet->lock); + mvnet->mdev = mdev; + mdev_set_drvdata(mdev, mvnet); + + mutex_lock(&mdev_list_lock); + list_add(&mvnet->next, &mdev_devices_list); + mutex_unlock(&mdev_list_lock); + + dev->coherent_dma_mask = DMA_BIT_MASK(64); + set_dma_ops(dev, &mvnet_dma_ops); + + return 0; +} + +static int mvnet_remove(struct mdev_device *mdev) +{ + struct mvnet_state *mds, *tmp_mds; + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + int ret = -EINVAL; + + mutex_lock(&mdev_list_lock); + list_for_each_entry_safe(mds, tmp_mds, &mdev_devices_list, next) { + if (mvnet == mds) { + list_del(&mvnet->next); + mdev_set_drvdata(mdev, NULL); + kfree(mvnet->buffer); + kfree(mvnet); + ret = 0; + break; + } + } + mutex_unlock(&mdev_list_lock); + + return ret; +} + +static ssize_t +sample_mvnet_dev_show(struct device *dev, struct device_attribute *attr, + char *buf) +{ + if (mdev_from_dev(dev)) + return sprintf(buf, "This is MDEV %s\n", dev_name(dev)); + + return sprintf(buf, "\n"); +} + +static DEVICE_ATTR_RO(sample_mvnet_dev); + +static struct attribute *mvnet_dev_attrs[] = { + &dev_attr_sample_mvnet_dev.attr, + NULL, +}; + +static const struct attribute_group mvnet_dev_group = { + .name = "mvnet_dev", + .attrs = mvnet_dev_attrs, +}; + +static const struct attribute_group *mvnet_dev_groups[] = { + &mvnet_dev_group, + NULL, +}; + +static ssize_t +sample_mdev_dev_show(struct device *dev, struct device_attribute *attr, + char *buf) +{ + if (mdev_from_dev(dev)) + return sprintf(buf, "This is MDEV %s\n", dev_name(dev)); + + return sprintf(buf, "\n"); +} + +static DEVICE_ATTR_RO(sample_mdev_dev); + +static struct attribute *mdev_dev_attrs[] = { + &dev_attr_sample_mdev_dev.attr, + NULL, +}; + +static const struct attribute_group mdev_dev_group = { + .name = "vendor", + .attrs = mdev_dev_attrs, +}; + +static const struct attribute_group *mdev_dev_groups[] = { + &mdev_dev_group, + NULL, +}; + +#define MVNET_STRING_LEN 16 + +static ssize_t +name_show(struct kobject *kobj, struct device *dev, char *buf) +{ + char name[MVNET_STRING_LEN]; + const char *name_str = "virtio-net"; + + snprintf(name, MVNET_STRING_LEN, "%s", dev_driver_string(dev)); + if (!strcmp(kobj->name, name)) + return sprintf(buf, "%s\n", name_str); + + return -EINVAL; +} + +static MDEV_TYPE_ATTR_RO(name); + +static ssize_t +available_instances_show(struct kobject *kobj, struct device *dev, char *buf) +{ + return sprintf(buf, "%d\n", INT_MAX); +} + +static MDEV_TYPE_ATTR_RO(available_instances); + +static ssize_t device_api_show(struct kobject *kobj, struct device *dev, + char *buf) +{ + return sprintf(buf, "%s\n", VIRTIO_MDEV_DEVICE_API_STRING); +} + +static MDEV_TYPE_ATTR_RO(device_api); + +static struct attribute *mdev_types_attrs[] = { + &mdev_type_attr_name.attr, + &mdev_type_attr_device_api.attr, + &mdev_type_attr_available_instances.attr, + NULL, +}; + +static struct attribute_group mdev_type_group = { + .name = "", + .attrs = mdev_types_attrs, +}; + +static struct attribute_group *mdev_type_groups[] = { + &mdev_type_group, + NULL, +}; + +static int mvnet_set_vq_address(struct mdev_device *mdev, u16 idx, + u64 desc_area, u64 driver_area, u64 device_area) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + + vq->desc_addr = desc_area; + vq->driver_addr = driver_area; + vq->device_addr = device_area; + + return 0; +} + +static void mvnet_set_vq_num(struct mdev_device *mdev, u16 idx, u32 num) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + + vq->num = num; +} + +static void mvnet_kick_vq(struct mdev_device *mdev, u16 idx) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + + if (vq->ready) + schedule_work(&mvnet->work); +} + +static void mvnet_set_vq_cb(struct mdev_device *mdev, u16 idx, + struct virtio_mdev_callback *cb) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + + vq->cb = cb->callback; + vq->private = cb->private; +} + +static void mvnet_set_vq_ready(struct mdev_device *mdev, u16 idx, bool ready) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + + spin_lock(&mvnet->lock); + vq->ready = ready; + if (vq->ready) + mvnet_queue_ready(mvnet, idx); + spin_unlock(&mvnet->lock); +} + +static bool mvnet_get_vq_ready(struct mdev_device *mdev, u16 idx) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + + return vq->ready; +} + +static int mvnet_set_vq_state(struct mdev_device *mdev, u16 idx, u64 state) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + struct vringh *vrh = &vq->vring; + + spin_lock(&mvnet->lock); + vrh->last_avail_idx = state; + spin_unlock(&mvnet->lock); + + return 0; +} + +static u64 mvnet_get_vq_state(struct mdev_device *mdev, u16 idx) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + struct vringh *vrh = &vq->vring; + + return vrh->last_avail_idx; +} + +static u16 mvnet_get_vq_align(struct mdev_device *mdev) +{ + return MVNET_QUEUE_ALIGN; +} + +static u64 mvnet_get_features(struct mdev_device *mdev) +{ + return mvnet_features; +} + +static int mvnet_set_features(struct mdev_device *mdev, u64 features) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + + /* DMA mapping must be done by driver */ + if (!(features & (1ULL << VIRTIO_F_IOMMU_PLATFORM))) + return -EINVAL; + + mvnet->features = features & mvnet_features; + + return 0; +} + +static void mvnet_set_config_cb(struct mdev_device *mdev, + struct virtio_mdev_callback *cb) +{ + /* We don't support config interrupt */ +} + +static u16 mvnet_get_queue_max(struct mdev_device *mdev) +{ + return MVNET_QUEUE_MAX; +} + +static u32 mvnet_get_device_id(struct mdev_device *mdev) +{ + return MVNET_DEVICE_ID; +} + +static u32 mvnet_get_vendor_id(struct mdev_device *mdev) +{ + return MVNET_VENDOR_ID; +} + +static u8 mvnet_get_status(struct mdev_device *mdev) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + + return mvnet->status; +} + +static void mvnet_set_status(struct mdev_device *mdev, u8 status) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + + mvnet->status = status; + + if (status == 0) { + spin_lock(&mvnet->lock); + mvnet_reset(mvnet); + spin_unlock(&mvnet->lock); + } +} + +static void mvnet_get_config(struct mdev_device *mdev, unsigned offset, + void *buf, unsigned len) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + + if (offset + len < sizeof(struct virtio_net_config)) + memcpy(buf, &mvnet->config + offset, len); +} + +static void mvnet_set_config(struct mdev_device *mdev, unsigned offset, + const void *buf, unsigned len) +{ + /* No writable config supportted by mvnet */ +} + +static int mvnet_get_version(struct mdev_device *mdev) +{ + return 0x1; +} + +static u32 mvnet_get_generation(struct mdev_device *mdev) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + + return mvnet->generation; +} + +static const struct virtio_mdev_parent_ops virtio_mdev_ops = { + .set_vq_address = mvnet_set_vq_address, + .set_vq_num = mvnet_set_vq_num, + .kick_vq = mvnet_kick_vq, + .set_vq_cb = mvnet_set_vq_cb, + .set_vq_ready = mvnet_set_vq_ready, + .get_vq_ready = mvnet_get_vq_ready, + .set_vq_state = mvnet_set_vq_state, + .get_vq_state = mvnet_get_vq_state, + .get_vq_align = mvnet_get_vq_align, + .get_features = mvnet_get_features, + .set_features = mvnet_set_features, + .set_config_cb = mvnet_set_config_cb, + .get_queue_max = mvnet_get_queue_max, + .get_device_id = mvnet_get_device_id, + .get_vendor_id = mvnet_get_vendor_id, + .get_status = mvnet_get_status, + .set_status = mvnet_set_status, + .get_config = mvnet_get_config, + .set_config = mvnet_set_config, + .get_version = mvnet_get_version, + .get_generation = mvnet_get_generation, +}; + +static const struct mdev_parent_ops mdev_fops = { + .owner = THIS_MODULE, + .dev_attr_groups = mvnet_dev_groups, + .mdev_attr_groups = mdev_dev_groups, + .supported_type_groups = mdev_type_groups, + .create = mvnet_create, + .remove = mvnet_remove, + .device_ops = &virtio_mdev_ops, +}; + +static void mvnet_device_release(struct device *dev) +{ + dev_dbg(dev, "mvnet: released\n"); +} + +static int __init mvnet_dev_init(void) +{ + int ret = 0; + + pr_info("mvnet_dev: %s\n", __func__); + + memset(&mvnet_dev, 0, sizeof(mvnet_dev)); + + idr_init(&mvnet_dev.vd_idr); + + mvnet_dev.vd_class = class_create(THIS_MODULE, MVNET_CLASS_NAME); + + if (IS_ERR(mvnet_dev.vd_class)) { + pr_err("Error: failed to register mvnet_dev class\n"); + ret = PTR_ERR(mvnet_dev.vd_class); + goto failed1; + } + + mvnet_dev.dev.class = mvnet_dev.vd_class; + mvnet_dev.dev.release = mvnet_device_release; + dev_set_name(&mvnet_dev.dev, "%s", MVNET_NAME); + + ret = device_register(&mvnet_dev.dev); + if (ret) + goto failed2; + + ret = mdev_register_virtio_device(&mvnet_dev.dev, &mdev_fops); + if (ret) + goto failed3; + + mutex_init(&mdev_list_lock); + INIT_LIST_HEAD(&mdev_devices_list); + + goto all_done; + +failed3: + + device_unregister(&mvnet_dev.dev); +failed2: + class_destroy(mvnet_dev.vd_class); + +failed1: +all_done: + return ret; +} + +static void __exit mvnet_dev_exit(void) +{ + mvnet_dev.dev.bus = NULL; + mdev_unregister_device(&mvnet_dev.dev); + + device_unregister(&mvnet_dev.dev); + idr_destroy(&mvnet_dev.vd_idr); + class_destroy(mvnet_dev.vd_class); + mvnet_dev.vd_class = NULL; + pr_info("mvnet_dev: Unloaded!\n"); +} + +module_init(mvnet_dev_init) +module_exit(mvnet_dev_exit) + +MODULE_LICENSE("GPL v2"); +MODULE_INFO(supported, "Test driver that simulate serial port over PCI"); +MODULE_VERSION(VERSION_STRING); +MODULE_AUTHOR(DRIVER_AUTHOR);