Re: [Qemu-devel] [PATCH 5/8] virtio: Implement MMIO based virtio transport

[Anthony Liguori <aliguori@us.ibm.com>]

Peter Maydell <peter.maydell@linaro.org> writes:

> Add support for the generic MMIO based virtio transport.
>
> This patch includes some fixes for bugs spotted by
> Ying-Shiuan Pan <yspan@itri.org.tw>.
>
> Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
> [Fred changes: updated to new virtio-bus mechanisms]
> Signed-off-by: KONRAD Frederic <fred.konrad@greensocs.com>
> [PMM changes:
>  * fixed trivial makefile conflict
>  * removed unused int_enable
>  * host_features doesn't need migrating
>  * reset guest accessible state in the reset function
>  * minor style fixes like extra blank lines
>  * RAZ/WI if there's no backend
>  * made transport size 0x200, in line with kvmtool
>  * set has_variable_vring_alignment
> ]

Reviewed-by: Anthony Liguori <aliguori@us.ibm.com>

Regards,

Anthony Liguori

> ---
>  hw/virtio/Makefile.objs |    1 +
>  hw/virtio/virtio-mmio.c |  424 +++++++++++++++++++++++++++++++++++++++++++++++
>  2 files changed, 425 insertions(+)
>  create mode 100644 hw/virtio/virtio-mmio.c
>
> diff --git a/hw/virtio/Makefile.objs b/hw/virtio/Makefile.objs
> index cbe6d51..1ba53d9 100644
> --- a/hw/virtio/Makefile.objs
> +++ b/hw/virtio/Makefile.objs
> @@ -1,6 +1,7 @@
>  common-obj-y += virtio-rng.o
>  common-obj-$(CONFIG_VIRTIO_PCI) += virtio-pci.o
>  common-obj-y += virtio-bus.o
> +common-obj-y += virtio-mmio.o
>  common-obj-$(CONFIG_VIRTIO_BLK_DATA_PLANE) += dataplane/
>  
>  obj-y += virtio.o virtio-balloon.o 
> diff --git a/hw/virtio/virtio-mmio.c b/hw/virtio/virtio-mmio.c
> new file mode 100644
> index 0000000..4c16616
> --- /dev/null
> +++ b/hw/virtio/virtio-mmio.c
> @@ -0,0 +1,424 @@
> +/*
> + * Virtio MMIO bindings
> + *
> + * Copyright (c) 2011 Linaro Limited
> + *
> + * Author:
> + *  Peter Maydell <peter.maydell@linaro.org>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License; either version 2
> + * of the License, or (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License along
> + * with this program; if not, see <http://www.gnu.org/licenses/>.
> + */
> +
> +#include "hw/sysbus.h"
> +#include "hw/virtio/virtio.h"
> +#include "qemu/host-utils.h"
> +#include "hw/virtio/virtio-bus.h"
> +
> +/* #define DEBUG_VIRTIO_MMIO */
> +
> +#ifdef DEBUG_VIRTIO_MMIO
> +
> +#define DPRINTF(fmt, ...) \
> +do { printf("virtio_mmio: " fmt , ## __VA_ARGS__); } while (0)
> +#else
> +#define DPRINTF(fmt, ...) do {} while (0)
> +#endif
> +
> +/* QOM macros */
> +/* virtio-mmio-bus */
> +#define TYPE_VIRTIO_MMIO_BUS "virtio-mmio-bus"
> +#define VIRTIO_MMIO_BUS(obj) \
> +        OBJECT_CHECK(VirtioBusState, (obj), TYPE_VIRTIO_MMIO_BUS)
> +#define VIRTIO_MMIO_BUS_GET_CLASS(obj) \
> +        OBJECT_GET_CLASS(VirtioBusClass, (obj), TYPE_VIRTIO_MMIO_BUS)
> +#define VIRTIO_MMIO_BUS_CLASS(klass) \
> +        OBJECT_CLASS_CHECK(VirtioBusClass, (klass), TYPE_VIRTIO_MMIO_BUS)
> +
> +/* virtio-mmio */
> +#define TYPE_VIRTIO_MMIO "virtio-mmio"
> +#define VIRTIO_MMIO(obj) \
> +        OBJECT_CHECK(VirtIOMMIOProxy, (obj), TYPE_VIRTIO_MMIO)
> +
> +/* Memory mapped register offsets */
> +#define VIRTIO_MMIO_MAGIC 0x0
> +#define VIRTIO_MMIO_VERSION 0x4
> +#define VIRTIO_MMIO_DEVICEID 0x8
> +#define VIRTIO_MMIO_VENDORID 0xc
> +#define VIRTIO_MMIO_HOSTFEATURES 0x10
> +#define VIRTIO_MMIO_HOSTFEATURESSEL 0x14
> +#define VIRTIO_MMIO_GUESTFEATURES 0x20
> +#define VIRTIO_MMIO_GUESTFEATURESSEL 0x24
> +#define VIRTIO_MMIO_GUESTPAGESIZE 0x28
> +#define VIRTIO_MMIO_QUEUESEL 0x30
> +#define VIRTIO_MMIO_QUEUENUMMAX 0x34
> +#define VIRTIO_MMIO_QUEUENUM 0x38
> +#define VIRTIO_MMIO_QUEUEALIGN 0x3c
> +#define VIRTIO_MMIO_QUEUEPFN 0x40
> +#define VIRTIO_MMIO_QUEUENOTIFY 0x50
> +#define VIRTIO_MMIO_INTERRUPTSTATUS 0x60
> +#define VIRTIO_MMIO_INTERRUPTACK 0x64
> +#define VIRTIO_MMIO_STATUS 0x70
> +/* Device specific config space starts here */
> +#define VIRTIO_MMIO_CONFIG 0x100
> +
> +#define VIRT_MAGIC 0x74726976 /* 'virt' */
> +#define VIRT_VERSION 1
> +#define VIRT_VENDOR 0x554D4551 /* 'QEMU' */
> +
> +typedef struct {
> +    /* Generic */
> +    SysBusDevice parent_obj;
> +    MemoryRegion iomem;
> +    qemu_irq irq;
> +    uint32_t host_features;
> +    /* Guest accessible state needing migration and reset */
> +    uint32_t host_features_sel;
> +    uint32_t guest_features_sel;
> +    uint32_t guest_page_shift;
> +    /* virtio-bus */
> +    VirtioBusState bus;
> +} VirtIOMMIOProxy;
> +
> +static void virtio_mmio_bus_new(VirtioBusState *bus, VirtIOMMIOProxy *dev);
> +
> +static uint64_t virtio_mmio_read(void *opaque, hwaddr offset, unsigned size)
> +{
> +    VirtIOMMIOProxy *proxy = (VirtIOMMIOProxy *)opaque;
> +    VirtIODevice *vdev = proxy->bus.vdev;
> +
> +    DPRINTF("virtio_mmio_read offset 0x%x\n", (int)offset);
> +
> +    if (!vdev) {
> +        /* If no backend is present, we treat most registers as
> +         * read-as-zero, except for the magic number, version and
> +         * vendor ID. This is not strictly sanctioned by the virtio
> +         * spec, but it allows us to provide transports with no backend
> +         * plugged in which don't confuse Linux's virtio code: the
> +         * probe won't complain about the bad magic number, but the
> +         * device ID of zero means no backend will claim it.
> +         */
> +        switch (offset) {
> +        case VIRTIO_MMIO_MAGIC:
> +            return VIRT_MAGIC;
> +        case VIRTIO_MMIO_VERSION:
> +            return VIRT_VERSION;
> +        case VIRTIO_MMIO_VENDORID:
> +            return VIRT_VENDOR;
> +        default:
> +            return 0;
> +        }
> +    }
> +
> +    if (offset >= VIRTIO_MMIO_CONFIG) {
> +        offset -= VIRTIO_MMIO_CONFIG;
> +        switch (size) {
> +        case 1:
> +            return virtio_config_readb(vdev, offset);
> +        case 2:
> +            return virtio_config_readw(vdev, offset);
> +        case 4:
> +            return virtio_config_readl(vdev, offset);
> +        default:
> +            abort();
> +        }
> +    }
> +    if (size != 4) {
> +        DPRINTF("wrong size access to register!\n");
> +        return 0;
> +    }
> +    switch (offset) {
> +    case VIRTIO_MMIO_MAGIC:
> +        return VIRT_MAGIC;
> +    case VIRTIO_MMIO_VERSION:
> +        return VIRT_VERSION;
> +    case VIRTIO_MMIO_DEVICEID:
> +        return vdev->device_id;
> +    case VIRTIO_MMIO_VENDORID:
> +        return VIRT_VENDOR;
> +    case VIRTIO_MMIO_HOSTFEATURES:
> +        if (proxy->host_features_sel) {
> +            return 0;
> +        }
> +        return proxy->host_features;
> +    case VIRTIO_MMIO_QUEUENUMMAX:
> +        return VIRTQUEUE_MAX_SIZE;
> +    case VIRTIO_MMIO_QUEUEPFN:
> +        return virtio_queue_get_addr(vdev, vdev->queue_sel)
> +            >> proxy->guest_page_shift;
> +    case VIRTIO_MMIO_INTERRUPTSTATUS:
> +        return vdev->isr;
> +    case VIRTIO_MMIO_STATUS:
> +        return vdev->status;
> +    case VIRTIO_MMIO_HOSTFEATURESSEL:
> +    case VIRTIO_MMIO_GUESTFEATURES:
> +    case VIRTIO_MMIO_GUESTFEATURESSEL:
> +    case VIRTIO_MMIO_GUESTPAGESIZE:
> +    case VIRTIO_MMIO_QUEUESEL:
> +    case VIRTIO_MMIO_QUEUENUM:
> +    case VIRTIO_MMIO_QUEUEALIGN:
> +    case VIRTIO_MMIO_QUEUENOTIFY:
> +    case VIRTIO_MMIO_INTERRUPTACK:
> +        DPRINTF("read of write-only register\n");
> +        return 0;
> +    default:
> +        DPRINTF("bad register offset\n");
> +        return 0;
> +    }
> +    return 0;
> +}
> +
> +static void virtio_mmio_write(void *opaque, hwaddr offset, uint64_t value,
> +                              unsigned size)
> +{
> +    VirtIOMMIOProxy *proxy = (VirtIOMMIOProxy *)opaque;
> +    VirtIODevice *vdev = proxy->bus.vdev;
> +
> +    DPRINTF("virtio_mmio_write offset 0x%x value 0x%" PRIx64 "\n",
> +            (int)offset, value);
> +
> +    if (!vdev) {
> +        /* If no backend is present, we just make all registers
> +         * write-ignored. This allows us to provide transports with
> +         * no backend plugged in.
> +         */
> +        return;
> +    }
> +
> +    if (offset >= VIRTIO_MMIO_CONFIG) {
> +        offset -= VIRTIO_MMIO_CONFIG;
> +        switch (size) {
> +        case 1:
> +            virtio_config_writeb(vdev, offset, value);
> +            break;
> +        case 2:
> +            virtio_config_writew(vdev, offset, value);
> +            break;
> +        case 4:
> +            virtio_config_writel(vdev, offset, value);
> +            break;
> +        default:
> +            abort();
> +        }
> +        return;
> +    }
> +    if (size != 4) {
> +        DPRINTF("wrong size access to register!\n");
> +        return;
> +    }
> +    switch (offset) {
> +    case VIRTIO_MMIO_HOSTFEATURESSEL:
> +        proxy->host_features_sel = value;
> +        break;
> +    case VIRTIO_MMIO_GUESTFEATURES:
> +        if (!proxy->guest_features_sel) {
> +            virtio_set_features(vdev, value);
> +        }
> +        break;
> +    case VIRTIO_MMIO_GUESTFEATURESSEL:
> +        proxy->guest_features_sel = value;
> +        break;
> +    case VIRTIO_MMIO_GUESTPAGESIZE:
> +        proxy->guest_page_shift = ctz32(value);
> +        if (proxy->guest_page_shift > 31) {
> +            proxy->guest_page_shift = 0;
> +        }
> +        DPRINTF("guest page size %" PRIx64 " shift %d\n", value,
> +                proxy->guest_page_shift);
> +        break;
> +    case VIRTIO_MMIO_QUEUESEL:
> +        if (value < VIRTIO_PCI_QUEUE_MAX) {
> +            vdev->queue_sel = value;
> +        }
> +        break;
> +    case VIRTIO_MMIO_QUEUENUM:
> +        DPRINTF("mmio_queue write %d max %d\n", (int)value, VIRTQUEUE_MAX_SIZE);
> +        if (value <= VIRTQUEUE_MAX_SIZE) {
> +            DPRINTF("calling virtio_queue_set_num\n");
> +            virtio_queue_set_num(vdev, vdev->queue_sel, value);
> +        }
> +        break;
> +    case VIRTIO_MMIO_QUEUEALIGN:
> +        virtio_queue_set_align(vdev, vdev->queue_sel, value);
> +        break;
> +    case VIRTIO_MMIO_QUEUEPFN:
> +        if (value == 0) {
> +            virtio_reset(vdev);
> +        } else {
> +            virtio_queue_set_addr(vdev, vdev->queue_sel,
> +                                  value << proxy->guest_page_shift);
> +        }
> +        break;
> +    case VIRTIO_MMIO_QUEUENOTIFY:
> +        if (value < VIRTIO_PCI_QUEUE_MAX) {
> +            virtio_queue_notify(vdev, value);
> +        }
> +        break;
> +    case VIRTIO_MMIO_INTERRUPTACK:
> +        vdev->isr &= ~value;
> +        virtio_update_irq(vdev);
> +        break;
> +    case VIRTIO_MMIO_STATUS:
> +        virtio_set_status(vdev, value & 0xff);
> +        if (vdev->status == 0) {
> +            virtio_reset(vdev);
> +        }
> +        break;
> +    case VIRTIO_MMIO_MAGIC:
> +    case VIRTIO_MMIO_VERSION:
> +    case VIRTIO_MMIO_DEVICEID:
> +    case VIRTIO_MMIO_VENDORID:
> +    case VIRTIO_MMIO_HOSTFEATURES:
> +    case VIRTIO_MMIO_QUEUENUMMAX:
> +    case VIRTIO_MMIO_INTERRUPTSTATUS:
> +        DPRINTF("write to readonly register\n");
> +        break;
> +
> +    default:
> +        DPRINTF("bad register offset\n");
> +    }
> +}
> +
> +static const MemoryRegionOps virtio_mem_ops = {
> +    .read = virtio_mmio_read,
> +    .write = virtio_mmio_write,
> +    .endianness = DEVICE_NATIVE_ENDIAN,
> +};
> +
> +static void virtio_mmio_update_irq(DeviceState *opaque, uint16_t vector)
> +{
> +    VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
> +    int level;
> +
> +    if (!proxy->bus.vdev) {
> +        return;
> +    }
> +    level = (proxy->bus.vdev->isr != 0);
> +    DPRINTF("virtio_mmio setting IRQ %d\n", level);
> +    qemu_set_irq(proxy->irq, level);
> +}
> +
> +static unsigned int virtio_mmio_get_features(DeviceState *opaque)
> +{
> +    VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
> +
> +    return proxy->host_features;
> +}
> +
> +static int virtio_mmio_load_config(DeviceState *opaque, QEMUFile *f)
> +{
> +    VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
> +
> +    proxy->host_features_sel = qemu_get_be32(f);
> +    proxy->guest_features_sel = qemu_get_be32(f);
> +    proxy->guest_page_shift = qemu_get_be32(f);
> +    return 0;
> +}
> +
> +static void virtio_mmio_save_config(DeviceState *opaque, QEMUFile *f)
> +{
> +    VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
> +
> +    qemu_put_be32(f, proxy->host_features_sel);
> +    qemu_put_be32(f, proxy->guest_features_sel);
> +    qemu_put_be32(f, proxy->guest_page_shift);
> +}
> +
> +static void virtio_mmio_reset(DeviceState *d)
> +{
> +    VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
> +
> +    virtio_bus_reset(&proxy->bus);
> +    proxy->host_features_sel = 0;
> +    proxy->guest_features_sel = 0;
> +    proxy->guest_page_shift = 0;
> +}
> +
> +/* virtio-mmio device */
> +
> +/* This is called by virtio-bus just after the device is plugged. */
> +static void virtio_mmio_device_plugged(DeviceState *opaque)
> +{
> +    VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
> +
> +    proxy->host_features |= (0x1 << VIRTIO_F_NOTIFY_ON_EMPTY);
> +    proxy->host_features = virtio_bus_get_vdev_features(&proxy->bus,
> +                                                        proxy->host_features);
> +}
> +
> +static void virtio_mmio_realizefn(DeviceState *d, Error **errp)
> +{
> +    VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
> +    SysBusDevice *sbd = SYS_BUS_DEVICE(d);
> +
> +    virtio_mmio_bus_new(&proxy->bus, proxy);
> +    sysbus_init_irq(sbd, &proxy->irq);
> +    memory_region_init_io(&proxy->iomem, &virtio_mem_ops, proxy,
> +                          TYPE_VIRTIO_MMIO, 0x200);
> +    sysbus_init_mmio(sbd, &proxy->iomem);
> +}
> +
> +static void virtio_mmio_class_init(ObjectClass *klass, void *data)
> +{
> +    DeviceClass *dc = DEVICE_CLASS(klass);
> +
> +    dc->realize = virtio_mmio_realizefn;
> +    dc->reset = virtio_mmio_reset;
> +}
> +
> +static const TypeInfo virtio_mmio_info = {
> +    .name          = TYPE_VIRTIO_MMIO,
> +    .parent        = TYPE_SYS_BUS_DEVICE,
> +    .instance_size = sizeof(VirtIOMMIOProxy),
> +    .class_init    = virtio_mmio_class_init,
> +};
> +
> +/* virtio-mmio-bus. */
> +
> +static void virtio_mmio_bus_new(VirtioBusState *bus, VirtIOMMIOProxy *dev)
> +{
> +    DeviceState *qdev = DEVICE(dev);
> +    BusState *qbus;
> +
> +    qbus_create_inplace((BusState *)bus, TYPE_VIRTIO_MMIO_BUS, qdev, NULL);
> +    qbus = BUS(bus);
> +    qbus->allow_hotplug = 0;
> +}
> +
> +static void virtio_mmio_bus_class_init(ObjectClass *klass, void *data)
> +{
> +    BusClass *bus_class = BUS_CLASS(klass);
> +    VirtioBusClass *k = VIRTIO_BUS_CLASS(klass);
> +
> +    k->notify = virtio_mmio_update_irq;
> +    k->save_config = virtio_mmio_save_config;
> +    k->load_config = virtio_mmio_load_config;
> +    k->get_features = virtio_mmio_get_features;
> +    k->device_plugged = virtio_mmio_device_plugged;
> +    k->has_variable_vring_alignment = true;
> +    bus_class->max_dev = 1;
> +}
> +
> +static const TypeInfo virtio_mmio_bus_info = {
> +    .name          = TYPE_VIRTIO_MMIO_BUS,
> +    .parent        = TYPE_VIRTIO_BUS,
> +    .instance_size = sizeof(VirtioBusState),
> +    .class_init    = virtio_mmio_bus_class_init,
> +};
> +
> +static void virtio_mmio_register_types(void)
> +{
> +    type_register_static(&virtio_mmio_bus_info);
> +    type_register_static(&virtio_mmio_info);
> +}
> +
> +type_init(virtio_mmio_register_types)
> -- 
> 1.7.9.5