Archipelago » qemu

/*

 * virtio ccw target implementation

 *

 * Copyright 2012 IBM Corp.

 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>

 *

 * This work is licensed under the terms of the GNU GPL, version 2 or (at

 * your option) any later version. See the COPYING file in the top-level

 * directory.

 */

#include "hw/hw.h"

#include "block/block.h"

#include "sysemu/blockdev.h"

#include "sysemu/sysemu.h"

#include "net/net.h"

#include "monitor/monitor.h"

#include "hw/virtio/virtio.h"

#include "hw/virtio/virtio-serial.h"

#include "hw/virtio/virtio-net.h"

#include "hw/sysbus.h"

#include "qemu/bitops.h"

#include "hw/virtio/virtio-bus.h"

#include "ioinst.h"

#include "css.h"

#include "virtio-ccw.h"

#include "trace.h"

static void virtio_ccw_bus_new(VirtioBusState *bus, size_t bus_size,

                               VirtioCcwDevice *dev);

static void virtual_css_bus_reset(BusState *qbus)

{

    /* This should actually be modelled via the generic css */

    css_reset();

}

static void virtual_css_bus_class_init(ObjectClass *klass, void *data)

{

    BusClass *k = BUS_CLASS(klass);

    k->reset = virtual_css_bus_reset;

}

static const TypeInfo virtual_css_bus_info = {

    .name = TYPE_VIRTUAL_CSS_BUS,

    .parent = TYPE_BUS,

    .instance_size = sizeof(VirtualCssBus),

    .class_init = virtual_css_bus_class_init,

};

VirtIODevice *virtio_ccw_get_vdev(SubchDev *sch)

{

    VirtIODevice *vdev = NULL;

    VirtioCcwDevice *dev = sch->driver_data;

    if (dev) {

        vdev = virtio_bus_get_device(&dev->bus);

    }

    return vdev;

}

static int virtio_ccw_set_guest2host_notifier(VirtioCcwDevice *dev, int n,

                                              bool assign, bool set_handler)

{

    VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);

    VirtQueue *vq = virtio_get_queue(vdev, n);

    EventNotifier *notifier = virtio_queue_get_host_notifier(vq);

    int r = 0;

    SubchDev *sch = dev->sch;

    uint32_t sch_id = (css_build_subchannel_id(sch) << 16) | sch->schid;

    if (assign) {

        r = event_notifier_init(notifier, 1);

        if (r < 0) {

            error_report("%s: unable to init event notifier: %d", __func__, r);

            return r;

        }

        virtio_queue_set_host_notifier_fd_handler(vq, true, set_handler);

        r = s390_assign_subch_ioeventfd(notifier, sch_id, n, assign);

        if (r < 0) {

            error_report("%s: unable to assign ioeventfd: %d", __func__, r);

            virtio_queue_set_host_notifier_fd_handler(vq, false, false);

            event_notifier_cleanup(notifier);

            return r;

        }

    } else {

        virtio_queue_set_host_notifier_fd_handler(vq, false, false);

        s390_assign_subch_ioeventfd(notifier, sch_id, n, assign);

        event_notifier_cleanup(notifier);

    }

    return r;

}

static void virtio_ccw_start_ioeventfd(VirtioCcwDevice *dev)

{

    VirtIODevice *vdev;

    int n, r;

    if (!(dev->flags & VIRTIO_CCW_FLAG_USE_IOEVENTFD) ||

        dev->ioeventfd_disabled ||

        dev->ioeventfd_started) {

        return;

    }

    vdev = virtio_bus_get_device(&dev->bus);

    for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) {

        if (!virtio_queue_get_num(vdev, n)) {

            continue;

        }

        r = virtio_ccw_set_guest2host_notifier(dev, n, true, true);

        if (r < 0) {

            goto assign_error;

        }

    }

    dev->ioeventfd_started = true;

    return;

  assign_error:

    while (--n >= 0) {

        if (!virtio_queue_get_num(vdev, n)) {

            continue;

        }

        r = virtio_ccw_set_guest2host_notifier(dev, n, false, false);

        assert(r >= 0);

    }

    dev->ioeventfd_started = false;

    /* Disable ioeventfd for this device. */

    dev->flags &= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD;

    error_report("%s: failed. Fallback to userspace (slower).", __func__);

}

static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice *dev)

{

    VirtIODevice *vdev;

    int n, r;

    if (!dev->ioeventfd_started) {

        return;

    }

    vdev = virtio_bus_get_device(&dev->bus);

    for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) {

        if (!virtio_queue_get_num(vdev, n)) {

            continue;

        }

        r = virtio_ccw_set_guest2host_notifier(dev, n, false, false);

        assert(r >= 0);

    }

    dev->ioeventfd_started = false;

}

VirtualCssBus *virtual_css_bus_init(void)

{

    VirtualCssBus *cbus;

    BusState *bus;

    DeviceState *dev;

    /* Create bridge device */

    dev = qdev_create(NULL, "virtual-css-bridge");

    qdev_init_nofail(dev);

    /* Create bus on bridge device */

    bus = qbus_create(TYPE_VIRTUAL_CSS_BUS, dev, "virtual-css");

    cbus = VIRTUAL_CSS_BUS(bus);

    /* Enable hotplugging */

    bus->allow_hotplug = 1;

    return cbus;

}

/* Communication blocks used by several channel commands. */

typedef struct VqInfoBlock {

    uint64_t queue;

    uint32_t align;

    uint16_t index;

    uint16_t num;

} QEMU_PACKED VqInfoBlock;

typedef struct VqConfigBlock {

    uint16_t index;

    uint16_t num_max;

} QEMU_PACKED VqConfigBlock;

typedef struct VirtioFeatDesc {

    uint32_t features;

    uint8_t index;

} QEMU_PACKED VirtioFeatDesc;

/* Specify where the virtqueues for the subchannel are in guest memory. */

static int virtio_ccw_set_vqs(SubchDev *sch, uint64_t addr, uint32_t align,

                              uint16_t index, uint16_t num)

{

    VirtIODevice *vdev = virtio_ccw_get_vdev(sch);

    if (index > VIRTIO_PCI_QUEUE_MAX) {

        return -EINVAL;

    }

    /* Current code in virtio.c relies on 4K alignment. */

    if (addr && (align != 4096)) {

        return -EINVAL;

    }

    if (!vdev) {

        return -EINVAL;

    }

    virtio_queue_set_addr(vdev, index, addr);

    if (!addr) {

        virtio_queue_set_vector(vdev, index, 0);

    } else {

        /* Fail if we don't have a big enough queue. */

        /* TODO: Add interface to handle vring.num changing */

        if (virtio_queue_get_num(vdev, index) > num) {

            return -EINVAL;

        }

        virtio_queue_set_vector(vdev, index, index);

    }

    /* tell notify handler in case of config change */

    vdev->config_vector = VIRTIO_PCI_QUEUE_MAX;

    return 0;

}

static int virtio_ccw_cb(SubchDev *sch, CCW1 ccw)

{

    int ret;

    VqInfoBlock info;

    uint8_t status;

    VirtioFeatDesc features;

    void *config;

    hwaddr indicators;

    VqConfigBlock vq_config;

    VirtioCcwDevice *dev = sch->driver_data;

    VirtIODevice *vdev = virtio_ccw_get_vdev(sch);

    bool check_len;

    int len;

    hwaddr hw_len;

    if (!dev) {

        return -EINVAL;

    }

    trace_virtio_ccw_interpret_ccw(sch->cssid, sch->ssid, sch->schid,

                                   ccw.cmd_code);

    check_len = !((ccw.flags & CCW_FLAG_SLI) && !(ccw.flags & CCW_FLAG_DC));

    /* Look at the command. */

    switch (ccw.cmd_code) {

    case CCW_CMD_SET_VQ:

        if (check_len) {

            if (ccw.count != sizeof(info)) {

                ret = -EINVAL;

                break;

            }

        } else if (ccw.count < sizeof(info)) {

            /* Can't execute command. */

            ret = -EINVAL;

            break;

        }

        if (!ccw.cda) {

            ret = -EFAULT;

        } else {

            info.queue = ldq_phys(&address_space_memory, ccw.cda);

            info.align = ldl_phys(&address_space_memory,

                                  ccw.cda + sizeof(info.queue));

            info.index = lduw_phys(&address_space_memory,

                                   ccw.cda + sizeof(info.queue)

                                   + sizeof(info.align));

            info.num = lduw_phys(&address_space_memory,

                                 ccw.cda + sizeof(info.queue)

                                 + sizeof(info.align)

                                 + sizeof(info.index));

            ret = virtio_ccw_set_vqs(sch, info.queue, info.align, info.index,

                                     info.num);

            sch->curr_status.scsw.count = 0;

        }

        break;

    case CCW_CMD_VDEV_RESET:

        virtio_ccw_stop_ioeventfd(dev);

        virtio_reset(vdev);

        ret = 0;

        break;

    case CCW_CMD_READ_FEAT:

        if (check_len) {

            if (ccw.count != sizeof(features)) {

                ret = -EINVAL;

                break;

            }

        } else if (ccw.count < sizeof(features)) {

            /* Can't execute command. */

            ret = -EINVAL;

            break;

        }

        if (!ccw.cda) {

            ret = -EFAULT;

        } else {

            features.index = ldub_phys(&address_space_memory,

                                       ccw.cda + sizeof(features.features));

            if (features.index < ARRAY_SIZE(dev->host_features)) {

                features.features = dev->host_features[features.index];

            } else {

                /* Return zeroes if the guest supports more feature bits. */

                features.features = 0;

            }

            stl_le_phys(&address_space_memory, ccw.cda, features.features);

            sch->curr_status.scsw.count = ccw.count - sizeof(features);

            ret = 0;

        }

        break;

    case CCW_CMD_WRITE_FEAT:

        if (check_len) {

            if (ccw.count != sizeof(features)) {

                ret = -EINVAL;

                break;

            }

        } else if (ccw.count < sizeof(features)) {

            /* Can't execute command. */

            ret = -EINVAL;

            break;

        }

        if (!ccw.cda) {

            ret = -EFAULT;

        } else {

            features.index = ldub_phys(&address_space_memory,

                                       ccw.cda + sizeof(features.features));

            features.features = ldl_le_phys(&address_space_memory, ccw.cda);

            if (features.index < ARRAY_SIZE(dev->host_features)) {

                virtio_bus_set_vdev_features(&dev->bus, features.features);

                vdev->guest_features = features.features;

            } else {

                /*

                 * If the guest supports more feature bits, assert that it

                 * passes us zeroes for those we don't support.

                 */

                if (features.features) {

                    fprintf(stderr, "Guest bug: features[%i]=%x (expected 0)\n",

                            features.index, features.features);

                    /* XXX: do a unit check here? */

                }

            }

            sch->curr_status.scsw.count = ccw.count - sizeof(features);

            ret = 0;

        }

        break;

    case CCW_CMD_READ_CONF:

        if (check_len) {

            if (ccw.count > vdev->config_len) {

                ret = -EINVAL;

                break;

            }

        }

        len = MIN(ccw.count, vdev->config_len);

        if (!ccw.cda) {

            ret = -EFAULT;

        } else {

            virtio_bus_get_vdev_config(&dev->bus, vdev->config);

            /* XXX config space endianness */

            cpu_physical_memory_write(ccw.cda, vdev->config, len);

            sch->curr_status.scsw.count = ccw.count - len;

            ret = 0;

        }

        break;

    case CCW_CMD_WRITE_CONF:

        if (check_len) {

            if (ccw.count > vdev->config_len) {

                ret = -EINVAL;

                break;

            }

        }

        len = MIN(ccw.count, vdev->config_len);

        hw_len = len;

        if (!ccw.cda) {

            ret = -EFAULT;

        } else {

            config = cpu_physical_memory_map(ccw.cda, &hw_len, 0);

            if (!config) {

                ret = -EFAULT;

            } else {

                len = hw_len;

                /* XXX config space endianness */

                memcpy(vdev->config, config, len);

                cpu_physical_memory_unmap(config, hw_len, 0, hw_len);

                virtio_bus_set_vdev_config(&dev->bus, vdev->config);

                sch->curr_status.scsw.count = ccw.count - len;

                ret = 0;

            }

        }

        break;

    case CCW_CMD_WRITE_STATUS:

        if (check_len) {

            if (ccw.count != sizeof(status)) {

                ret = -EINVAL;

                break;

            }

        } else if (ccw.count < sizeof(status)) {

            /* Can't execute command. */

            ret = -EINVAL;

            break;

        }

        if (!ccw.cda) {

            ret = -EFAULT;

        } else {

            status = ldub_phys(&address_space_memory, ccw.cda);

            if (!(status & VIRTIO_CONFIG_S_DRIVER_OK)) {

                virtio_ccw_stop_ioeventfd(dev);

            }

            virtio_set_status(vdev, status);

            if (vdev->status == 0) {

                virtio_reset(vdev);

            }

            if (status & VIRTIO_CONFIG_S_DRIVER_OK) {

                virtio_ccw_start_ioeventfd(dev);

            }

            sch->curr_status.scsw.count = ccw.count - sizeof(status);

            ret = 0;

        }

        break;

    case CCW_CMD_SET_IND:

        if (check_len) {

            if (ccw.count != sizeof(indicators)) {

                ret = -EINVAL;

                break;

            }

        } else if (ccw.count < sizeof(indicators)) {

            /* Can't execute command. */

            ret = -EINVAL;

            break;

        }

        if (!ccw.cda) {

            ret = -EFAULT;

        } else {

            indicators = ldq_phys(&address_space_memory, ccw.cda);

            dev->indicators = indicators;

            sch->curr_status.scsw.count = ccw.count - sizeof(indicators);

            ret = 0;

        }

        break;

    case CCW_CMD_SET_CONF_IND:

        if (check_len) {

            if (ccw.count != sizeof(indicators)) {

                ret = -EINVAL;

                break;

            }

        } else if (ccw.count < sizeof(indicators)) {

            /* Can't execute command. */

            ret = -EINVAL;

            break;

        }

        if (!ccw.cda) {

            ret = -EFAULT;

        } else {

            indicators = ldq_phys(&address_space_memory, ccw.cda);

            dev->indicators2 = indicators;

            sch->curr_status.scsw.count = ccw.count - sizeof(indicators);

            ret = 0;

        }

        break;

    case CCW_CMD_READ_VQ_CONF:

        if (check_len) {

            if (ccw.count != sizeof(vq_config)) {

                ret = -EINVAL;

                break;

            }

        } else if (ccw.count < sizeof(vq_config)) {

            /* Can't execute command. */

            ret = -EINVAL;

            break;

        }

        if (!ccw.cda) {

            ret = -EFAULT;

        } else {

            vq_config.index = lduw_phys(&address_space_memory, ccw.cda);

            vq_config.num_max = virtio_queue_get_num(vdev,

                                                     vq_config.index);

            stw_phys(&address_space_memory,

                     ccw.cda + sizeof(vq_config.index), vq_config.num_max);

            sch->curr_status.scsw.count = ccw.count - sizeof(vq_config);

            ret = 0;

        }

        break;

    default:

        ret = -ENOSYS;

        break;

    }

    return ret;

}

static int virtio_ccw_device_init(VirtioCcwDevice *dev, VirtIODevice *vdev)

{

    unsigned int cssid = 0;

    unsigned int ssid = 0;

    unsigned int schid;

    unsigned int devno;

    bool have_devno = false;

    bool found = false;

    SubchDev *sch;

    int ret;

    int num;

    DeviceState *parent = DEVICE(dev);

    sch = g_malloc0(sizeof(SubchDev));

    sch->driver_data = dev;

    dev->sch = sch;

    dev->indicators = 0;

    /* Initialize subchannel structure. */

    sch->channel_prog = 0x0;

    sch->last_cmd_valid = false;

    sch->orb = NULL;

    /*

     * Use a device number if provided. Otherwise, fall back to subchannel

     * number.

     */

    if (dev->bus_id) {

        num = sscanf(dev->bus_id, "%x.%x.%04x", &cssid, &ssid, &devno);

        if (num == 3) {

            if ((cssid > MAX_CSSID) || (ssid > MAX_SSID)) {

                ret = -EINVAL;

                error_report("Invalid cssid or ssid: cssid %x, ssid %x",

                             cssid, ssid);

                goto out_err;

            }

            /* Enforce use of virtual cssid. */

            if (cssid != VIRTUAL_CSSID) {

                ret = -EINVAL;

                error_report("cssid %x not valid for virtio devices", cssid);

                goto out_err;

            }

            if (css_devno_used(cssid, ssid, devno)) {

                ret = -EEXIST;

                error_report("Device %x.%x.%04x already exists", cssid, ssid,

                             devno);

                goto out_err;

            }

            sch->cssid = cssid;

            sch->ssid = ssid;

            sch->devno = devno;

            have_devno = true;

        } else {

            ret = -EINVAL;

            error_report("Malformed devno parameter '%s'", dev->bus_id);

            goto out_err;

        }

    }

    /* Find the next free id. */

    if (have_devno) {

        for (schid = 0; schid <= MAX_SCHID; schid++) {

            if (!css_find_subch(1, cssid, ssid, schid)) {

                sch->schid = schid;

                css_subch_assign(cssid, ssid, schid, devno, sch);

                found = true;

                break;

            }

        }

        if (!found) {

            ret = -ENODEV;

            error_report("No free subchannel found for %x.%x.%04x", cssid, ssid,

                         devno);

            goto out_err;

        }

        trace_virtio_ccw_new_device(cssid, ssid, schid, devno,

                                    "user-configured");

    } else {

        cssid = VIRTUAL_CSSID;

        for (ssid = 0; ssid <= MAX_SSID; ssid++) {

            for (schid = 0; schid <= MAX_SCHID; schid++) {

                if (!css_find_subch(1, cssid, ssid, schid)) {

                    sch->cssid = cssid;

                    sch->ssid = ssid;

                    sch->schid = schid;

                    devno = schid;

                    /*

                     * If the devno is already taken, look further in this

                     * subchannel set.

                     */

                    while (css_devno_used(cssid, ssid, devno)) {

                        if (devno == MAX_SCHID) {

                            devno = 0;

                        } else if (devno == schid - 1) {

                            ret = -ENODEV;

                            error_report("No free devno found");

                            goto out_err;

                        } else {

                            devno++;

                        }

                    }

                    sch->devno = devno;

                    css_subch_assign(cssid, ssid, schid, devno, sch);

                    found = true;

                    break;

                }

            }

            if (found) {

                break;

            }

        }

        if (!found) {

            ret = -ENODEV;

            error_report("Virtual channel subsystem is full!");

            goto out_err;

        }

        trace_virtio_ccw_new_device(cssid, ssid, schid, devno,

                                    "auto-configured");

    }

    /* Build initial schib. */

    css_sch_build_virtual_schib(sch, 0, VIRTIO_CCW_CHPID_TYPE);

    sch->ccw_cb = virtio_ccw_cb;

    /* Build senseid data. */

    memset(&sch->id, 0, sizeof(SenseId));

    sch->id.reserved = 0xff;

    sch->id.cu_type = VIRTIO_CCW_CU_TYPE;

    sch->id.cu_model = vdev->device_id;

    /* Only the first 32 feature bits are used. */

    dev->host_features[0] = virtio_bus_get_vdev_features(&dev->bus,

                                                         dev->host_features[0]);

    dev->host_features[0] |= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY;

    dev->host_features[0] |= 0x1 << VIRTIO_F_BAD_FEATURE;

    css_generate_sch_crws(sch->cssid, sch->ssid, sch->schid,

                          parent->hotplugged, 1);

    return 0;

out_err:

    dev->sch = NULL;

    g_free(sch);

    return ret;

}

static int virtio_ccw_exit(VirtioCcwDevice *dev)

{

    SubchDev *sch = dev->sch;

    if (sch) {

        css_subch_assign(sch->cssid, sch->ssid, sch->schid, sch->devno, NULL);

        g_free(sch);

    }

    dev->indicators = 0;

    return 0;

}

static int virtio_ccw_net_init(VirtioCcwDevice *ccw_dev)

{

    DeviceState *qdev = DEVICE(ccw_dev);

    VirtIONetCcw *dev = VIRTIO_NET_CCW(ccw_dev);

    DeviceState *vdev = DEVICE(&dev->vdev);

    virtio_net_set_config_size(&dev->vdev, ccw_dev->host_features[0]);

    virtio_net_set_netclient_name(&dev->vdev, qdev->id,

                                  object_get_typename(OBJECT(qdev)));

    qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));

    if (qdev_init(vdev) < 0) {

        return -1;

    }

    return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev));

}

static void virtio_ccw_net_instance_init(Object *obj)

{

    VirtIONetCcw *dev = VIRTIO_NET_CCW(obj);

    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_NET);

    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);

}

static int virtio_ccw_blk_init(VirtioCcwDevice *ccw_dev)

{

    VirtIOBlkCcw *dev = VIRTIO_BLK_CCW(ccw_dev);

    DeviceState *vdev = DEVICE(&dev->vdev);

    virtio_blk_set_conf(vdev, &(dev->blk));

    qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));

    if (qdev_init(vdev) < 0) {

        return -1;

    }

    return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev));

}

static void virtio_ccw_blk_instance_init(Object *obj)

{

    VirtIOBlkCcw *dev = VIRTIO_BLK_CCW(obj);

    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_BLK);

    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);

}

static int virtio_ccw_serial_init(VirtioCcwDevice *ccw_dev)

{

    VirtioSerialCcw *dev = VIRTIO_SERIAL_CCW(ccw_dev);

    DeviceState *vdev = DEVICE(&dev->vdev);

    DeviceState *proxy = DEVICE(ccw_dev);

    char *bus_name;

    /*

     * For command line compatibility, this sets the virtio-serial-device bus

     * name as before.

     */

    if (proxy->id) {

        bus_name = g_strdup_printf("%s.0", proxy->id);

        virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name);

        g_free(bus_name);

    }

    qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));

    if (qdev_init(vdev) < 0) {

        return -1;

    }

    return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev));

}

static void virtio_ccw_serial_instance_init(Object *obj)

{

    VirtioSerialCcw *dev = VIRTIO_SERIAL_CCW(obj);

    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_SERIAL);

    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);

}

static int virtio_ccw_balloon_init(VirtioCcwDevice *ccw_dev)

{

    VirtIOBalloonCcw *dev = VIRTIO_BALLOON_CCW(ccw_dev);

    DeviceState *vdev = DEVICE(&dev->vdev);

    qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));

    if (qdev_init(vdev) < 0) {

        return -1;

    }

    return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev));

}

static void balloon_ccw_stats_get_all(Object *obj, struct Visitor *v,

                                      void *opaque, const char *name,

                                      Error **errp)

{

    VirtIOBalloonCcw *dev = opaque;

    object_property_get(OBJECT(&dev->vdev), v, "guest-stats", errp);

}

static void balloon_ccw_stats_get_poll_interval(Object *obj, struct Visitor *v,

                                                void *opaque, const char *name,

                                                Error **errp)

{

    VirtIOBalloonCcw *dev = opaque;

    object_property_get(OBJECT(&dev->vdev), v, "guest-stats-polling-interval",

                        errp);

}

static void balloon_ccw_stats_set_poll_interval(Object *obj, struct Visitor *v,

                                                void *opaque, const char *name,

                                                Error **errp)

{

    VirtIOBalloonCcw *dev = opaque;

    object_property_set(OBJECT(&dev->vdev), v, "guest-stats-polling-interval",

                        errp);

}

static void virtio_ccw_balloon_instance_init(Object *obj)

{

    VirtIOBalloonCcw *dev = VIRTIO_BALLOON_CCW(obj);

    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_BALLOON);

    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);

    object_property_add(obj, "guest-stats", "guest statistics",

                        balloon_ccw_stats_get_all, NULL, NULL, dev, NULL);

    object_property_add(obj, "guest-stats-polling-interval", "int",

                        balloon_ccw_stats_get_poll_interval,

                        balloon_ccw_stats_set_poll_interval,

                        NULL, dev, NULL);

}

static int virtio_ccw_scsi_init(VirtioCcwDevice *ccw_dev)

{

    VirtIOSCSICcw *dev = VIRTIO_SCSI_CCW(ccw_dev);

    DeviceState *vdev = DEVICE(&dev->vdev);

    DeviceState *qdev = DEVICE(ccw_dev);

    char *bus_name;

    /*

     * For command line compatibility, this sets the virtio-scsi-device bus

     * name as before.

     */

    if (qdev->id) {

        bus_name = g_strdup_printf("%s.0", qdev->id);

        virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name);

        g_free(bus_name);

    }

    qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));

    if (qdev_init(vdev) < 0) {

        return -1;

    }

    return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev));

}

static void virtio_ccw_scsi_instance_init(Object *obj)

{

    VirtIOSCSICcw *dev = VIRTIO_SCSI_CCW(obj);

    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_SCSI);

    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);

}

#ifdef CONFIG_VHOST_SCSI

static int vhost_ccw_scsi_init(VirtioCcwDevice *ccw_dev)

{

    VHostSCSICcw *dev = VHOST_SCSI_CCW(ccw_dev);

    DeviceState *vdev = DEVICE(&dev->vdev);

    qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));

    if (qdev_init(vdev) < 0) {

        return -1;

    }

    return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev));

}

static void vhost_ccw_scsi_instance_init(Object *obj)

{

    VHostSCSICcw *dev = VHOST_SCSI_CCW(obj);

    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VHOST_SCSI);

    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);

}

#endif

static int virtio_ccw_rng_init(VirtioCcwDevice *ccw_dev)

{

    VirtIORNGCcw *dev = VIRTIO_RNG_CCW(ccw_dev);

    DeviceState *vdev = DEVICE(&dev->vdev);

    qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));

    if (qdev_init(vdev) < 0) {

        return -1;

    }

    object_property_set_link(OBJECT(dev),

                             OBJECT(dev->vdev.conf.rng), "rng",

                             NULL);

    return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev));

}

/* DeviceState to VirtioCcwDevice. Note: used on datapath,

 * be careful and test performance if you change this.

 */

static inline VirtioCcwDevice *to_virtio_ccw_dev_fast(DeviceState *d)

{

    return container_of(d, VirtioCcwDevice, parent_obj);

}

static void virtio_ccw_notify(DeviceState *d, uint16_t vector)

{

    VirtioCcwDevice *dev = to_virtio_ccw_dev_fast(d);

    SubchDev *sch = dev->sch;

    uint64_t indicators;

    if (vector >= 128) {

        return;

    }

    if (vector < VIRTIO_PCI_QUEUE_MAX) {

        if (!dev->indicators) {

            return;

        }

        indicators = ldq_phys(&address_space_memory, dev->indicators);

        indicators |= 1ULL << vector;

        stq_phys(&address_space_memory, dev->indicators, indicators);

    } else {

        if (!dev->indicators2) {

            return;

        }

        vector = 0;

        indicators = ldq_phys(&address_space_memory, dev->indicators2);

        indicators |= 1ULL << vector;

        stq_phys(&address_space_memory, dev->indicators2, indicators);

    }

    css_conditional_io_interrupt(sch);

}

static unsigned virtio_ccw_get_features(DeviceState *d)

{

    VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);

    /* Only the first 32 feature bits are used. */

    return dev->host_features[0];

}

static void virtio_ccw_reset(DeviceState *d)

{

    VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);

    VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);