On Fri, Jun 07, 2013 at 08:18:57PM +0200, Andreas Färber wrote:
> VirtioDevice's DeviceClass::exit code cleaning up bus_name is no longer
> overwritten by virtio-{blk,serial,net,scsi,balloon,rng} and vhost-scsi.
>
> Note: VirtIOSCSI and VHostSCSI now perform some initializations after
> VirtIOSCSICommon's realize calls virtio_bus_plug_device(), namely
> creating the SCSIBus and initializing /dev/vhost-scsi respectively.
>
> While at it, drop duplicate VIRTIO_DEVICE() casts and avoid qdev.
There are also improvements to error handling here, they can
be done by a separate patch.
Please don't mix refactoring and functional changes -
this patch is huge as it is.
Also, could changes to each device be done in a separate patch?
This last might be hard, not a must IMO.
> Signed-off-by: Andreas Färber <afaer...@suse.de>
> ---
> hw/9pfs/virtio-9p-device.c | 67 ++++++++++++++++--------------
> hw/9pfs/virtio-9p.h | 13 ++++++
> hw/block/virtio-blk.c | 52 ++++++++++++++---------
> hw/char/virtio-serial-bus.c | 49 ++++++++++++++--------
> hw/net/virtio-net.c | 48 ++++++++++++---------
> hw/scsi/vhost-scsi.c | 59 +++++++++++++++-----------
> hw/scsi/virtio-scsi.c | 85
> ++++++++++++++++++++++++--------------
> hw/virtio/virtio-balloon.c | 50 +++++++++++++---------
> hw/virtio/virtio-rng.c | 53 ++++++++++++++----------
> hw/virtio/virtio.c | 20 ++++-----
> include/hw/virtio/vhost-scsi.h | 13 ++++++
> include/hw/virtio/virtio-balloon.h | 13 ++++++
> include/hw/virtio/virtio-blk.h | 13 ++++++
> include/hw/virtio/virtio-net.h | 13 ++++++
> include/hw/virtio/virtio-rng.h | 13 ++++++
> include/hw/virtio/virtio-scsi.h | 29 +++++++++++--
> include/hw/virtio/virtio-serial.h | 13 ++++++
> include/hw/virtio/virtio.h | 6 ++-
> 18 files changed, 406 insertions(+), 203 deletions(-)
>
> diff --git a/hw/9pfs/virtio-9p-device.c b/hw/9pfs/virtio-9p-device.c
> index dc6f4e4..409d315 100644
> --- a/hw/9pfs/virtio-9p-device.c
> +++ b/hw/9pfs/virtio-9p-device.c
> @@ -41,15 +41,17 @@ static void virtio_9p_get_config(VirtIODevice *vdev,
> uint8_t *config)
> g_free(cfg);
> }
>
> -static int virtio_9p_device_init(VirtIODevice *vdev)
> +static void virtio_9p_device_realize(DeviceState *dev, Error **errp)
> {
> - V9fsState *s = VIRTIO_9P(vdev);
> + VirtIODevice *vdev = VIRTIO_DEVICE(dev);
> + V9fsState *s = VIRTIO_9P(dev);
> + V9fsClass *v9c = VIRTIO_9P_GET_CLASS(dev);
> int i, len;
> struct stat stat;
> FsDriverEntry *fse;
> V9fsPath path;
>
> - virtio_init(VIRTIO_DEVICE(s), "virtio-9p", VIRTIO_ID_9P,
> + virtio_init(vdev, "virtio-9p", VIRTIO_ID_9P,
> sizeof(struct virtio_9p_config) + MAX_TAG_LEN);
>
> /* initialize pdu allocator */
> @@ -65,17 +67,17 @@ static int virtio_9p_device_init(VirtIODevice *vdev)
>
> if (!fse) {
> /* We don't have a fsdev identified by fsdev_id */
> - fprintf(stderr, "Virtio-9p device couldn't find fsdev with the "
> - "id = %s\n",
> - s->fsconf.fsdev_id ? s->fsconf.fsdev_id : "NULL");
> - return -1;
> + error_setg(errp, "Virtio-9p device couldn't find fsdev with the "
> + "id = %s",
> + s->fsconf.fsdev_id ? s->fsconf.fsdev_id : "NULL");
> + return;
> }
>
> if (!s->fsconf.tag) {
> /* we haven't specified a mount_tag */
> - fprintf(stderr, "fsdev with id %s needs mount_tag arguments\n",
> - s->fsconf.fsdev_id);
> - return -1;
> + error_setg(errp, "fsdev with id %s needs mount_tag arguments",
> + s->fsconf.fsdev_id);
> + return;
> }
>
> s->ctx.export_flags = fse->export_flags;
> @@ -83,9 +85,9 @@ static int virtio_9p_device_init(VirtIODevice *vdev)
> s->ctx.exops.get_st_gen = NULL;
> len = strlen(s->fsconf.tag);
> if (len > MAX_TAG_LEN - 1) {
> - fprintf(stderr, "mount tag '%s' (%d bytes) is longer than "
> - "maximum (%d bytes)", s->fsconf.tag, len, MAX_TAG_LEN - 1);
> - return -1;
> + error_setg(errp, "mount tag '%s' (%d bytes) is longer than "
> + "maximum (%d bytes)", s->fsconf.tag, len, MAX_TAG_LEN -
> 1);
> + return;
> }
>
> s->tag = strdup(s->fsconf.tag);
> @@ -97,13 +99,13 @@ static int virtio_9p_device_init(VirtIODevice *vdev)
> qemu_co_rwlock_init(&s->rename_lock);
>
> if (s->ops->init(&s->ctx) < 0) {
> - fprintf(stderr, "Virtio-9p Failed to initialize fs-driver with id:%s"
> - " and export path:%s\n", s->fsconf.fsdev_id, s->ctx.fs_root);
> - return -1;
> + error_setg(errp, "Virtio-9p Failed to initialize fs-driver with
> id:%s"
> + " and export path:%s", s->fsconf.fsdev_id,
> s->ctx.fs_root);
> + return;
> }
> if (v9fs_init_worker_threads() < 0) {
> - fprintf(stderr, "worker thread initialization failed\n");
> - return -1;
> + error_setg(errp, "worker thread initialization failed");
> + return;
> }
>
> /*
> @@ -113,20 +115,20 @@ static int virtio_9p_device_init(VirtIODevice *vdev)
> */
> v9fs_path_init(&path);
> if (s->ops->name_to_path(&s->ctx, NULL, "/", &path) < 0) {
> - fprintf(stderr,
> - "error in converting name to path %s", strerror(errno));
> - return -1;
> + error_setg(errp,
> + "error in converting name to path %s", strerror(errno));
> + return;
> }
> if (s->ops->lstat(&s->ctx, &path, &stat)) {
> - fprintf(stderr, "share path %s does not exist\n", fse->path);
> - return -1;
> + error_setg(errp, "share path %s does not exist", fse->path);
> + return;
> } else if (!S_ISDIR(stat.st_mode)) {
> - fprintf(stderr, "share path %s is not a directory\n", fse->path);
> - return -1;
> + error_setg(errp, "share path %s is not a directory", fse->path);
> + return;
> }
> v9fs_path_free(&path);
>
> - return 0;
> + v9c->parent_realize(dev, errp);
> }
>
> /* virtio-9p device */
> @@ -136,12 +138,16 @@ static Property virtio_9p_properties[] = {
> DEFINE_PROP_END_OF_LIST(),
> };
>
> -static void virtio_9p_class_init(ObjectClass *klass, void *data)
> +static void virtio_9p_class_init(ObjectClass *oc, void *data)
> {
> - DeviceClass *dc = DEVICE_CLASS(klass);
> - VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
> + DeviceClass *dc = DEVICE_CLASS(oc);
> + VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(oc);
> + V9fsClass *v9c = VIRTIO_9P_CLASS(oc);
> +
> + v9c->parent_realize = dc->realize;
> + dc->realize = virtio_9p_device_realize;
> +
> dc->props = virtio_9p_properties;
> - vdc->init = virtio_9p_device_init;
> vdc->get_features = virtio_9p_get_features;
> vdc->get_config = virtio_9p_get_config;
> }
> @@ -151,6 +157,7 @@ static const TypeInfo virtio_device_info = {
> .parent = TYPE_VIRTIO_DEVICE,
> .instance_size = sizeof(V9fsState),
> .class_init = virtio_9p_class_init,
> + .class_size = sizeof(V9fsClass),
> };
>
> static void virtio_9p_register_types(void)
> diff --git a/hw/9pfs/virtio-9p.h b/hw/9pfs/virtio-9p.h
> index 1d6eedb..85699a7 100644
> --- a/hw/9pfs/virtio-9p.h
> +++ b/hw/9pfs/virtio-9p.h
> @@ -227,6 +227,15 @@ typedef struct V9fsState
> V9fsConf fsconf;
> } V9fsState;
>
> +typedef struct V9fsClass {
> + /*< private >*/
> + VirtioDeviceClass parent_class;
> + /*< public >*/
> +
> + DeviceRealize parent_realize;
> +} V9fsClass;
> +
> +
One empty line please.
> typedef struct V9fsStatState {
> V9fsPDU *pdu;
> size_t offset;
> @@ -404,6 +413,10 @@ extern int v9fs_name_to_path(V9fsState *s, V9fsPath
> *dirpath,
> #define TYPE_VIRTIO_9P "virtio-9p-device"
> #define VIRTIO_9P(obj) \
> OBJECT_CHECK(V9fsState, (obj), TYPE_VIRTIO_9P)
> +#define VIRTIO_9P_GET_CLASS(obj) \
> + OBJECT_GET_CLASS(V9fsClass, (obj), TYPE_VIRTIO_9P)
> +#define VIRTIO_9P_CLASS(cls) \
> + OBJECT_CLASS_CHECK(V9fsClass, (cls), TYPE_VIRTIO_9P)
>
> #define DEFINE_VIRTIO_9P_PROPERTIES(_state, _field) \
> DEFINE_PROP_STRING("mount_tag", _state, _field.tag), \
> diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
> index 8ea1f03..88e99a6 100644
> --- a/hw/block/virtio-blk.c
> +++ b/hw/block/virtio-blk.c
> @@ -628,10 +628,11 @@ void virtio_blk_set_conf(DeviceState *dev,
> VirtIOBlkConf *blk)
> memcpy(&(s->blk), blk, sizeof(struct VirtIOBlkConf));
> }
>
> -static int virtio_blk_device_init(VirtIODevice *vdev)
> +static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
> {
> - DeviceState *qdev = DEVICE(vdev);
> + VirtIODevice *vdev = VIRTIO_DEVICE(dev);
> VirtIOBlock *s = VIRTIO_BLK(vdev);
> + VirtIOBlockClass *vbc = VIRTIO_BLK_GET_CLASS(dev);
> VirtIOBlkConf *blk = &(s->blk);
> #ifdef CONFIG_VIRTIO_BLK_DATA_PLANE
> Error *err = NULL;
> @@ -639,17 +640,18 @@ static int virtio_blk_device_init(VirtIODevice *vdev)
> static int virtio_blk_id;
>
> if (!blk->conf.bs) {
> - error_report("drive property not set");
> - return -1;
> + error_setg(errp, "drive property not set");
> + return;
> }
> if (!bdrv_is_inserted(blk->conf.bs)) {
> - error_report("Device needs media, but drive is empty");
> - return -1;
> + error_setg(errp, "Device needs media, but drive is empty");
> + return;
> }
>
> blkconf_serial(&blk->conf, &blk->serial);
> if (blkconf_geometry(&blk->conf, NULL, 65535, 255, 255) < 0) {
> - return -1;
> + error_setg(errp, "Error setting geometry");
> + return;
> }
>
> virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK,
> @@ -665,29 +667,31 @@ static int virtio_blk_device_init(VirtIODevice *vdev)
> #ifdef CONFIG_VIRTIO_BLK_DATA_PLANE
> virtio_blk_data_plane_create(vdev, blk, &s->dataplane, &err);
> if (err != NULL) {
> - error_report("%s", error_get_pretty(err));
> - error_free(err);
> + error_propagate(errp, err);
> virtio_cleanup(vdev);
> - return -1;
> + return;
> }
> #endif
>
> s->change = qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb,
> s);
> - register_savevm(qdev, "virtio-blk", virtio_blk_id++, 2,
> + register_savevm(dev, "virtio-blk", virtio_blk_id++, 2,
> virtio_blk_save, virtio_blk_load, s);
> bdrv_set_dev_ops(s->bs, &virtio_block_ops, s);
> bdrv_set_buffer_alignment(s->bs, s->conf->logical_block_size);
>
> bdrv_iostatus_enable(s->bs);
>
> - add_boot_device_path(s->conf->bootindex, qdev, "/disk@0,0");
> - return 0;
> + add_boot_device_path(s->conf->bootindex, dev, "/disk@0,0");
> +
> + vbc->parent_realize(dev, errp);
> }
>
> -static int virtio_blk_device_exit(DeviceState *dev)
> +static void virtio_blk_device_unrealize(DeviceState *dev, Error **errp)
> {
> VirtIODevice *vdev = VIRTIO_DEVICE(dev);
> VirtIOBlock *s = VIRTIO_BLK(dev);
> + VirtIOBlockClass *vbc = VIRTIO_BLK_GET_CLASS(dev);
> +
> #ifdef CONFIG_VIRTIO_BLK_DATA_PLANE
> virtio_blk_data_plane_destroy(s->dataplane);
> s->dataplane = NULL;
> @@ -696,7 +700,8 @@ static int virtio_blk_device_exit(DeviceState *dev)
> unregister_savevm(dev, "virtio-blk", s);
> blockdev_mark_auto_del(s->bs);
> virtio_cleanup(vdev);
> - return 0;
> +
> + vbc->parent_unrealize(dev, errp);
> }
>
> static Property virtio_blk_properties[] = {
> @@ -704,13 +709,19 @@ static Property virtio_blk_properties[] = {
> DEFINE_PROP_END_OF_LIST(),
> };
>
> -static void virtio_blk_class_init(ObjectClass *klass, void *data)
> +static void virtio_blk_class_init(ObjectClass *oc, void *data)
> {
> - DeviceClass *dc = DEVICE_CLASS(klass);
> - VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
> - dc->exit = virtio_blk_device_exit;
> + DeviceClass *dc = DEVICE_CLASS(oc);
> + VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(oc);
> + VirtIOBlockClass *vbc = VIRTIO_BLK_CLASS(oc);
> +
> + vbc->parent_realize = dc->realize;
> + dc->realize = virtio_blk_device_realize;
> +
> + vbc->parent_unrealize = dc->unrealize;
> + dc->unrealize = virtio_blk_device_unrealize;
> +
> dc->props = virtio_blk_properties;
> - vdc->init = virtio_blk_device_init;
> vdc->get_config = virtio_blk_update_config;
> vdc->set_config = virtio_blk_set_config;
> vdc->get_features = virtio_blk_get_features;
> @@ -723,6 +734,7 @@ static const TypeInfo virtio_device_info = {
> .parent = TYPE_VIRTIO_DEVICE,
> .instance_size = sizeof(VirtIOBlock),
> .class_init = virtio_blk_class_init,
> + .class_size = sizeof(VirtIOBlockClass),
> };
>
> static void virtio_register_types(void)
> diff --git a/hw/char/virtio-serial-bus.c b/hw/char/virtio-serial-bus.c
> index cc3d1dd..1cdd659 100644
> --- a/hw/char/virtio-serial-bus.c
> +++ b/hw/char/virtio-serial-bus.c
> @@ -889,31 +889,35 @@ static int virtser_port_qdev_exit(DeviceState *qdev)
> return 0;
> }
>
> -static int virtio_serial_device_init(VirtIODevice *vdev)
> +static void virtio_serial_device_realize(DeviceState *dev, Error **errp)
> {
> - DeviceState *qdev = DEVICE(vdev);
> - VirtIOSerial *vser = VIRTIO_SERIAL(vdev);
> + VirtIODevice *vdev = VIRTIO_DEVICE(dev);
> + VirtIOSerial *vser = VIRTIO_SERIAL(dev);
> + VirtIOSerialClass *vsc = VIRTIO_SERIAL_GET_CLASS(dev);
> + BusState *bus;
> uint32_t i, max_supported_ports;
>
> if (!vser->serial.max_virtserial_ports) {
> - return -1;
> + error_setg(errp, "Maximum number of serial ports not specified");
> + return;
> }
>
> /* Each port takes 2 queues, and one pair is for the control queue */
> max_supported_ports = VIRTIO_PCI_QUEUE_MAX / 2 - 1;
>
> if (vser->serial.max_virtserial_ports > max_supported_ports) {
> - error_report("maximum ports supported: %u", max_supported_ports);
> - return -1;
> + error_setg(errp, "maximum ports supported: %u", max_supported_ports);
> + return;
> }
>
> virtio_init(vdev, "virtio-serial", VIRTIO_ID_CONSOLE,
> sizeof(struct virtio_console_config));
>
> /* Spawn a new virtio-serial bus on which the ports will ride as devices
> */
> - qbus_create_inplace(&vser->bus.qbus, TYPE_VIRTIO_SERIAL_BUS, qdev,
> + qbus_create_inplace(&vser->bus, TYPE_VIRTIO_SERIAL_BUS, dev,
> vdev->bus_name);
> - vser->bus.qbus.allow_hotplug = 1;
> + bus = BUS(&vser->bus);
> + bus->allow_hotplug = 1;
> vser->bus.vser = vser;
> QTAILQ_INIT(&vser->ports);
>
> @@ -961,10 +965,10 @@ static int virtio_serial_device_init(VirtIODevice *vdev)
> * Register for the savevm section with the virtio-console name
> * to preserve backward compat
> */
> - register_savevm(qdev, "virtio-console", -1, 3, virtio_serial_save,
> + register_savevm(dev, "virtio-console", -1, 3, virtio_serial_save,
> virtio_serial_load, vser);
>
> - return 0;
> + vsc->parent_realize(dev, errp);
> }
>
> static void virtio_serial_port_class_init(ObjectClass *klass, void *data)
> @@ -986,10 +990,11 @@ static const TypeInfo virtio_serial_port_type_info = {
> .class_init = virtio_serial_port_class_init,
> };
>
> -static int virtio_serial_device_exit(DeviceState *dev)
> +static void virtio_serial_device_unrealize(DeviceState *dev, Error **errp)
> {
> - VirtIOSerial *vser = VIRTIO_SERIAL(dev);
> VirtIODevice *vdev = VIRTIO_DEVICE(dev);
> + VirtIOSerial *vser = VIRTIO_SERIAL(dev);
> + VirtIOSerialClass *vsc = VIRTIO_SERIAL_GET_CLASS(dev);
>
> unregister_savevm(dev, "virtio-console", vser);
>
> @@ -1003,7 +1008,8 @@ static int virtio_serial_device_exit(DeviceState *dev)
> g_free(vser->post_load);
> }
> virtio_cleanup(vdev);
> - return 0;
> +
> + vsc->parent_unrealize(dev, errp);
> }
>
> static Property virtio_serial_properties[] = {
> @@ -1011,13 +1017,19 @@ static Property virtio_serial_properties[] = {
> DEFINE_PROP_END_OF_LIST(),
> };
>
> -static void virtio_serial_class_init(ObjectClass *klass, void *data)
> +static void virtio_serial_class_init(ObjectClass *oc, void *data)
> {
> - DeviceClass *dc = DEVICE_CLASS(klass);
> - VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
> - dc->exit = virtio_serial_device_exit;
> + DeviceClass *dc = DEVICE_CLASS(oc);
> + VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(oc);
> + VirtIOSerialClass *vsc = VIRTIO_SERIAL_CLASS(oc);
> +
> + vsc->parent_realize = dc->realize;
> + dc->realize = virtio_serial_device_realize;
> +
> + vsc->parent_unrealize = dc->unrealize;
> + dc->unrealize = virtio_serial_device_unrealize;
> +
> dc->props = virtio_serial_properties;
> - vdc->init = virtio_serial_device_init;
> vdc->get_features = get_features;
> vdc->get_config = get_config;
> vdc->set_config = set_config;
> @@ -1030,6 +1042,7 @@ static const TypeInfo virtio_device_info = {
> .parent = TYPE_VIRTIO_DEVICE,
> .instance_size = sizeof(VirtIOSerial),
> .class_init = virtio_serial_class_init,
> + .class_size = sizeof(VirtIOSerialClass),
> };
>
> static void virtio_serial_register_types(void)
> diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c
> index 1ea9556..9a3680c 100644
> --- a/hw/net/virtio-net.c
> +++ b/hw/net/virtio-net.c
> @@ -1367,15 +1367,16 @@ void virtio_net_set_netclient_name(VirtIONet *n,
> const char *name,
> n->netclient_type = g_strdup(type);
> }
>
> -static int virtio_net_device_init(VirtIODevice *vdev)
> +static void virtio_net_device_realize(DeviceState *dev, Error **errp)
> {
> int i;
>
> - DeviceState *qdev = DEVICE(vdev);
> - VirtIONet *n = VIRTIO_NET(vdev);
> + DeviceState *qdev = DEVICE(dev);
> + VirtIODevice *vdev = VIRTIO_DEVICE(dev);
> + VirtIONet *n = VIRTIO_NET(dev);
> + VirtIONetClass *vnc = VIRTIO_NET_GET_CLASS(dev);
>
> - virtio_init(VIRTIO_DEVICE(n), "virtio-net", VIRTIO_ID_NET,
> - n->config_size);
> + virtio_init(vdev, "virtio-net", VIRTIO_ID_NET, n->config_size);
>
> n->max_queues = MAX(n->nic_conf.queues, 1);
> n->vqs = g_malloc0(sizeof(VirtIONetQueue) * n->max_queues);
> @@ -1439,24 +1440,26 @@ static int virtio_net_device_init(VirtIODevice *vdev)
>
> n->vlans = g_malloc0(MAX_VLAN >> 3);
>
> - n->qdev = qdev;
> - register_savevm(qdev, "virtio-net", -1, VIRTIO_NET_VM_VERSION,
> + n->qdev = dev;
> + register_savevm(dev, "virtio-net", -1, VIRTIO_NET_VM_VERSION,
> virtio_net_save, virtio_net_load, n);
>
> - add_boot_device_path(n->nic_conf.bootindex, qdev, "/ethernet-phy@0");
> - return 0;
> + add_boot_device_path(n->nic_conf.bootindex, dev, "/ethernet-phy@0");
> +
> + vnc->parent_realize(dev, errp);
> }
>
> -static int virtio_net_device_exit(DeviceState *qdev)
> +static void virtio_net_device_unrealize(DeviceState *dev, Error **errp)
> {
> - VirtIONet *n = VIRTIO_NET(qdev);
> - VirtIODevice *vdev = VIRTIO_DEVICE(qdev);
> + VirtIODevice *vdev = VIRTIO_DEVICE(dev);
> + VirtIONet *n = VIRTIO_NET(dev);
> + VirtIONetClass *vnc = VIRTIO_NET_GET_CLASS(dev);
> int i;
>
> /* This will stop vhost backend if appropriate. */
> virtio_net_set_status(vdev, 0);
>
> - unregister_savevm(qdev, "virtio-net", n);
> + unregister_savevm(dev, "virtio-net", n);
>
> if (n->netclient_name) {
> g_free(n->netclient_name);
> @@ -1488,7 +1491,7 @@ static int virtio_net_device_exit(DeviceState *qdev)
> qemu_del_nic(n->nic);
> virtio_cleanup(vdev);
>
> - return 0;
> + vnc->parent_unrealize(dev, errp);
> }
>
> static void virtio_net_instance_init(Object *obj)
> @@ -1511,13 +1514,19 @@ static Property virtio_net_properties[] = {
> DEFINE_PROP_END_OF_LIST(),
> };
>
> -static void virtio_net_class_init(ObjectClass *klass, void *data)
> +static void virtio_net_class_init(ObjectClass *oc, void *data)
> {
> - DeviceClass *dc = DEVICE_CLASS(klass);
> - VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
> - dc->exit = virtio_net_device_exit;
> + DeviceClass *dc = DEVICE_CLASS(oc);
> + VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(oc);
> + VirtIONetClass *vnc = VIRTIO_NET_CLASS(oc);
> +
> + vnc->parent_realize = dc->realize;
> + dc->realize = virtio_net_device_realize;
> +
> + vnc->parent_unrealize = dc->unrealize;
> + dc->unrealize = virtio_net_device_unrealize;
> +
> dc->props = virtio_net_properties;
> - vdc->init = virtio_net_device_init;
> vdc->get_config = virtio_net_get_config;
> vdc->set_config = virtio_net_set_config;
> vdc->get_features = virtio_net_get_features;
> @@ -1535,6 +1544,7 @@ static const TypeInfo virtio_net_info = {
> .instance_size = sizeof(VirtIONet),
> .instance_init = virtio_net_instance_init,
> .class_init = virtio_net_class_init,
> + .class_size = sizeof(VirtIONetClass),
> };
>
> static void virtio_register_types(void)
> diff --git a/hw/scsi/vhost-scsi.c b/hw/scsi/vhost-scsi.c
> index d7a1c33..cacaf64 100644
> --- a/hw/scsi/vhost-scsi.c
> +++ b/hw/scsi/vhost-scsi.c
> @@ -196,29 +196,32 @@ static void vhost_scsi_set_status(VirtIODevice *vdev,
> uint8_t val)
> }
> }
>
> -static int vhost_scsi_init(VirtIODevice *vdev)
> +static void vhost_scsi_realize(DeviceState *dev, Error **errp)
> {
> - VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
> - VHostSCSI *s = VHOST_SCSI(vdev);
> + VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(dev);
> + VHostSCSI *s = VHOST_SCSI(dev);
> + VHostSCSIClass *vsc = VHOST_SCSI_GET_CLASS(dev);
> + Error *err = NULL;
> int vhostfd = -1;
> int ret;
>
> if (!vs->conf.wwpn) {
> - error_report("vhost-scsi: missing wwpn\n");
> - return -EINVAL;
> + error_setg(errp, "vhost-scsi: missing wwpn");
> + return;
> }
>
> if (vs->conf.vhostfd) {
> vhostfd = monitor_handle_fd_param(cur_mon, vs->conf.vhostfd);
> if (vhostfd == -1) {
> - error_report("vhost-scsi: unable to parse vhostfd\n");
> - return -EINVAL;
> + error_setg(errp, "vhost-scsi: unable to parse vhostfd");
> + return;
> }
> }
>
> - ret = virtio_scsi_common_init(vs);
> - if (ret < 0) {
> - return ret;
> + vsc->parent_realize(dev, &err);
> + if (err != NULL) {
> + error_propagate(errp, err);
> + return;
> }
>
> s->dev.nvqs = VHOST_SCSI_VQ_NUM_FIXED + vs->conf.num_queues;
> @@ -227,24 +230,22 @@ static int vhost_scsi_init(VirtIODevice *vdev)
>
> ret = vhost_dev_init(&s->dev, vhostfd, "/dev/vhost-scsi", true);
> if (ret < 0) {
> - error_report("vhost-scsi: vhost initialization failed: %s\n",
> - strerror(-ret));
> - return ret;
> + error_setg(errp, "vhost-scsi: vhost initialization failed: %s",
> + strerror(-ret));
> + return;
> }
> s->dev.backend_features = 0;
>
> error_setg(&s->migration_blocker,
> "vhost-scsi does not support migration");
> migrate_add_blocker(s->migration_blocker);
> -
> - return 0;
> }
>
> -static int vhost_scsi_exit(DeviceState *qdev)
> +static void vhost_scsi_unrealize(DeviceState *dev, Error **errp)
> {
> - VirtIODevice *vdev = VIRTIO_DEVICE(qdev);
> - VHostSCSI *s = VHOST_SCSI(qdev);
> - VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(qdev);
> + VirtIODevice *vdev = VIRTIO_DEVICE(dev);
> + VHostSCSI *s = VHOST_SCSI(dev);
> + VHostSCSIClass *vsc = VHOST_SCSI_GET_CLASS(dev);
>
> migrate_del_blocker(s->migration_blocker);
> error_free(s->migration_blocker);
> @@ -253,7 +254,8 @@ static int vhost_scsi_exit(DeviceState *qdev)
> vhost_scsi_set_status(vdev, 0);
>
> g_free(s->dev.vqs);
> - return virtio_scsi_common_exit(vs);
> +
> + vsc->parent_unrealize(dev, errp);
> }
>
> static Property vhost_scsi_properties[] = {
> @@ -261,13 +263,19 @@ static Property vhost_scsi_properties[] = {
> DEFINE_PROP_END_OF_LIST(),
> };
>
> -static void vhost_scsi_class_init(ObjectClass *klass, void *data)
> +static void vhost_scsi_class_init(ObjectClass *oc, void *data)
> {
> - DeviceClass *dc = DEVICE_CLASS(klass);
> - VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
> - dc->exit = vhost_scsi_exit;
> + DeviceClass *dc = DEVICE_CLASS(oc);
> + VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(oc);
> + VHostSCSIClass *vsc = VHOST_SCSI_CLASS(oc);
> +
> + vsc->parent_realize = dc->realize;
> + dc->realize = vhost_scsi_realize;
> +
> + vsc->parent_unrealize = dc->unrealize;
> + dc->unrealize = vhost_scsi_unrealize;
> +
> dc->props = vhost_scsi_properties;
> - vdc->init = vhost_scsi_init;
> vdc->get_features = vhost_scsi_get_features;
> vdc->set_config = vhost_scsi_set_config;
> vdc->set_status = vhost_scsi_set_status;
> @@ -278,6 +286,7 @@ static const TypeInfo vhost_scsi_info = {
> .parent = TYPE_VIRTIO_SCSI_COMMON,
> .instance_size = sizeof(VHostSCSI),
> .class_init = vhost_scsi_class_init,
> + .class_size = sizeof(VHostSCSIClass),
> };
>
> static void virtio_register_types(void)
> diff --git a/hw/scsi/virtio-scsi.c b/hw/scsi/virtio-scsi.c
> index 08dd3f3..6704f78 100644
> --- a/hw/scsi/virtio-scsi.c
> +++ b/hw/scsi/virtio-scsi.c
> @@ -587,12 +587,14 @@ static struct SCSIBusInfo virtio_scsi_scsi_info = {
> .load_request = virtio_scsi_load_request,
> };
>
> -int virtio_scsi_common_init(VirtIOSCSICommon *s)
> +static void virtio_scsi_common_realize(DeviceState *dev, Error **errp)
> {
> - VirtIODevice *vdev = VIRTIO_DEVICE(s);
> + VirtIODevice *vdev = VIRTIO_DEVICE(dev);
> + VirtIOSCSICommon *s = VIRTIO_SCSI_COMMON(dev);
> + VirtIOSCSICommonClass *vscc = VIRTIO_SCSI_COMMON_GET_CLASS(dev);
> int i;
>
> - virtio_init(VIRTIO_DEVICE(s), "virtio-scsi", VIRTIO_ID_SCSI,
> + virtio_init(vdev, "virtio-scsi", VIRTIO_ID_SCSI,
> sizeof(VirtIOSCSIConfig));
>
> s->cmd_vqs = g_malloc0(s->conf.num_queues * sizeof(VirtQueue *));
> @@ -608,50 +610,53 @@ int virtio_scsi_common_init(VirtIOSCSICommon *s)
> virtio_scsi_handle_cmd);
> }
>
> - return 0;
> + vscc->parent_realize(dev, errp);
> }
>
> -static int virtio_scsi_device_init(VirtIODevice *vdev)
> +static void virtio_scsi_device_realize(DeviceState *dev, Error **errp)
> {
> - DeviceState *qdev = DEVICE(vdev);
> - VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
> - VirtIOSCSI *s = VIRTIO_SCSI(vdev);
> + VirtIODevice *vdev = VIRTIO_DEVICE(dev);
> + VirtIOSCSI *s = VIRTIO_SCSI(dev);
> + VirtIOSCSIClass *vsc = VIRTIO_SCSI_GET_CLASS(dev);
> static int virtio_scsi_id;
> - int ret;
> + Error *err = NULL;
>
> - ret = virtio_scsi_common_init(vs);
> - if (ret < 0) {
> - return ret;
> + vsc->parent_realize(dev, &err);
> + if (err != NULL) {
> + error_propagate(errp, err);
> + return;
> }
>
> - scsi_bus_new(&s->bus, qdev, &virtio_scsi_scsi_info, vdev->bus_name);
> + scsi_bus_new(&s->bus, dev, &virtio_scsi_scsi_info, vdev->bus_name);
>
> - if (!qdev->hotplugged) {
> + if (!dev->hotplugged) {
> scsi_bus_legacy_handle_cmdline(&s->bus);
> }
>
> - register_savevm(qdev, "virtio-scsi", virtio_scsi_id++, 1,
> + register_savevm(dev, "virtio-scsi", virtio_scsi_id++, 1,
> virtio_scsi_save, virtio_scsi_load, s);
> -
> - return 0;
> }
>
> -int virtio_scsi_common_exit(VirtIOSCSICommon *vs)
> +static void virtio_scsi_common_unrealize(DeviceState *dev, Error **errp)
> {
> - VirtIODevice *vdev = VIRTIO_DEVICE(vs);
> + VirtIODevice *vdev = VIRTIO_DEVICE(dev);
> + VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(dev);
> + VirtIOSCSICommonClass *vscc = VIRTIO_SCSI_COMMON_GET_CLASS(dev);
>
> g_free(vs->cmd_vqs);
> virtio_cleanup(vdev);
> - return 0;
> +
> + vscc->parent_unrealize(dev, errp);
> }
>
> -static int virtio_scsi_device_exit(DeviceState *qdev)
> +static void virtio_scsi_device_unrealize(DeviceState *dev, Error **errp)
> {
> - VirtIOSCSI *s = VIRTIO_SCSI(qdev);
> - VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(qdev);
> + VirtIOSCSI *s = VIRTIO_SCSI(dev);
> + VirtIOSCSIClass *vsc = VIRTIO_SCSI_GET_CLASS(dev);
>
> - unregister_savevm(qdev, "virtio-scsi", s);
> - return virtio_scsi_common_exit(vs);
> + unregister_savevm(dev, "virtio-scsi", s);
> +
> + vsc->parent_unrealize(dev, errp);
> }
>
> static Property virtio_scsi_properties[] = {
> @@ -659,20 +664,34 @@ static Property virtio_scsi_properties[] = {
> DEFINE_PROP_END_OF_LIST(),
> };
>
> -static void virtio_scsi_common_class_init(ObjectClass *klass, void *data)
> +static void virtio_scsi_common_class_init(ObjectClass *oc, void *data)
> {
> - VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
> + DeviceClass *dc = DEVICE_CLASS(oc);
> + VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(oc);
> + VirtIOSCSICommonClass *vscc = VIRTIO_SCSI_COMMON_CLASS(oc);
> +
> + vscc->parent_realize = dc->realize;
> + dc->realize = virtio_scsi_common_realize;
> +
> + vscc->parent_unrealize = dc->unrealize;
> + dc->unrealize = virtio_scsi_common_unrealize;
>
> vdc->get_config = virtio_scsi_get_config;
> }
>
> -static void virtio_scsi_class_init(ObjectClass *klass, void *data)
> +static void virtio_scsi_class_init(ObjectClass *oc, void *data)
> {
> - DeviceClass *dc = DEVICE_CLASS(klass);
> - VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
> - dc->exit = virtio_scsi_device_exit;
> + DeviceClass *dc = DEVICE_CLASS(oc);
> + VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(oc);
> + VirtIOSCSIClass *vsc = VIRTIO_SCSI_CLASS(oc);
> +
> + vsc->parent_realize = dc->realize;
> + dc->realize = virtio_scsi_device_realize;
> +
> + vsc->parent_unrealize = dc->unrealize;
> + dc->unrealize = virtio_scsi_device_unrealize;
> +
> dc->props = virtio_scsi_properties;
> - vdc->init = virtio_scsi_device_init;
> vdc->set_config = virtio_scsi_set_config;
> vdc->get_features = virtio_scsi_get_features;
> vdc->reset = virtio_scsi_reset;
> @@ -683,6 +702,7 @@ static const TypeInfo virtio_scsi_common_info = {
> .parent = TYPE_VIRTIO_DEVICE,
> .instance_size = sizeof(VirtIOSCSICommon),
> .class_init = virtio_scsi_common_class_init,
> + .class_size = sizeof(VirtIOSCSICommonClass),
> };
>
> static const TypeInfo virtio_scsi_info = {
> @@ -690,6 +710,7 @@ static const TypeInfo virtio_scsi_info = {
> .parent = TYPE_VIRTIO_SCSI_COMMON,
> .instance_size = sizeof(VirtIOSCSI),
> .class_init = virtio_scsi_class_init,
> + .class_size = sizeof(VirtIOSCSIClass),
> };
>
> static void virtio_register_types(void)
> diff --git a/hw/virtio/virtio-balloon.c b/hw/virtio/virtio-balloon.c
> index d669756..0535062 100644
> --- a/hw/virtio/virtio-balloon.c
> +++ b/hw/virtio/virtio-balloon.c
> @@ -336,10 +336,11 @@ static int virtio_balloon_load(QEMUFile *f, void
> *opaque, int version_id)
> return 0;
> }
>
> -static int virtio_balloon_device_init(VirtIODevice *vdev)
> +static void virtio_balloon_device_realize(DeviceState *dev, Error **errp)
> {
> - DeviceState *qdev = DEVICE(vdev);
> - VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
> + VirtIODevice *vdev = VIRTIO_DEVICE(dev);
> + VirtIOBalloon *s = VIRTIO_BALLOON(dev);
> + VirtIOBalloonClass *vbc = VIRTIO_BALLOON_GET_CLASS(dev);
> int ret;
>
> virtio_init(vdev, "virtio-balloon", VIRTIO_ID_BALLOON, 8);
> @@ -348,50 +349,60 @@ static int virtio_balloon_device_init(VirtIODevice
> *vdev)
> virtio_balloon_stat, s);
>
> if (ret < 0) {
> - virtio_cleanup(VIRTIO_DEVICE(s));
> - return -1;
> + error_setg(errp, "Adding balloon handler failed");
> + virtio_cleanup(vdev);
> + return;
> }
>
> s->ivq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output);
> s->dvq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output);
> s->svq = virtio_add_queue(vdev, 128, virtio_balloon_receive_stats);
>
> - register_savevm(qdev, "virtio-balloon", -1, 1,
> + register_savevm(dev, "virtio-balloon", -1, 1,
> virtio_balloon_save, virtio_balloon_load, s);
>
> - object_property_add(OBJECT(qdev), "guest-stats", "guest statistics",
> + object_property_add(OBJECT(dev), "guest-stats", "guest statistics",
> balloon_stats_get_all, NULL, NULL, s, NULL);
>
> - object_property_add(OBJECT(qdev), "guest-stats-polling-interval", "int",
> + object_property_add(OBJECT(dev), "guest-stats-polling-interval", "int",
> balloon_stats_get_poll_interval,
> balloon_stats_set_poll_interval,
> NULL, s, NULL);
> - return 0;
> +
> + vbc->parent_realize(dev, errp);
> }
>
> -static int virtio_balloon_device_exit(DeviceState *qdev)
> +static void virtio_balloon_device_unrealize(DeviceState *dev, Error **errp)
> {
> - VirtIOBalloon *s = VIRTIO_BALLOON(qdev);
> - VirtIODevice *vdev = VIRTIO_DEVICE(qdev);
> + VirtIODevice *vdev = VIRTIO_DEVICE(dev);
> + VirtIOBalloon *s = VIRTIO_BALLOON(dev);
> + VirtIOBalloonClass *vbc = VIRTIO_BALLOON_GET_CLASS(dev);
>
> balloon_stats_destroy_timer(s);
> qemu_remove_balloon_handler(s);
> - unregister_savevm(qdev, "virtio-balloon", s);
> + unregister_savevm(dev, "virtio-balloon", s);
> virtio_cleanup(vdev);
> - return 0;
> +
> + vbc->parent_unrealize(dev, errp);
> }
>
> static Property virtio_balloon_properties[] = {
> DEFINE_PROP_END_OF_LIST(),
> };
>
> -static void virtio_balloon_class_init(ObjectClass *klass, void *data)
> +static void virtio_balloon_class_init(ObjectClass *oc, void *data)
> {
> - DeviceClass *dc = DEVICE_CLASS(klass);
> - VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
> - dc->exit = virtio_balloon_device_exit;
> + DeviceClass *dc = DEVICE_CLASS(oc);
> + VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(oc);
> + VirtIOBalloonClass *vbc = VIRTIO_BALLOON_CLASS(oc);
> +
> + vbc->parent_realize = dc->realize;
> + dc->realize = virtio_balloon_device_realize;
> +
> + vbc->parent_unrealize = dc->unrealize;
> + dc->unrealize = virtio_balloon_device_unrealize;
> +
> dc->props = virtio_balloon_properties;
> - vdc->init = virtio_balloon_device_init;
> vdc->get_config = virtio_balloon_get_config;
> vdc->set_config = virtio_balloon_set_config;
> vdc->get_features = virtio_balloon_get_features;
> @@ -402,6 +413,7 @@ static const TypeInfo virtio_balloon_info = {
> .parent = TYPE_VIRTIO_DEVICE,
> .instance_size = sizeof(VirtIOBalloon),
> .class_init = virtio_balloon_class_init,
> + .class_size = sizeof(VirtIOBalloonClass),
> };
>
> static void virtio_register_types(void)
> diff --git a/hw/virtio/virtio-rng.c b/hw/virtio/virtio-rng.c
> index cb787c7..108cfc9 100644
> --- a/hw/virtio/virtio-rng.c
> +++ b/hw/virtio/virtio-rng.c
> @@ -133,21 +133,22 @@ static void check_rate_limit(void *opaque)
> qemu_get_clock_ms(vm_clock) + vrng->conf.period_ms);
> }
>
> -static int virtio_rng_device_init(VirtIODevice *vdev)
> +static void virtio_rng_device_realize(DeviceState *dev, Error **errp)
> {
> - DeviceState *qdev = DEVICE(vdev);
> - VirtIORNG *vrng = VIRTIO_RNG(vdev);
> + VirtIODevice *vdev = VIRTIO_DEVICE(dev);
> + VirtIORNG *vrng = VIRTIO_RNG(dev);
> + VirtIORNGClass *vrc = VIRTIO_RNG_GET_CLASS(dev);
> Error *local_err = NULL;
>
> if (vrng->conf.rng == NULL) {
> vrng->conf.default_backend = RNG_RANDOM(object_new(TYPE_RNG_RANDOM));
>
> - object_property_add_child(OBJECT(qdev),
> + object_property_add_child(OBJECT(dev),
> "default-backend",
> OBJECT(vrng->conf.default_backend),
> NULL);
>
> - object_property_set_link(OBJECT(qdev),
> + object_property_set_link(OBJECT(dev),
> OBJECT(vrng->conf.default_backend),
> "rng", NULL);
> }
> @@ -156,15 +157,14 @@ static int virtio_rng_device_init(VirtIODevice *vdev)
>
> vrng->rng = vrng->conf.rng;
> if (vrng->rng == NULL) {
> - qerror_report(QERR_INVALID_PARAMETER_VALUE, "rng", "a valid object");
> - return -1;
> + error_set(errp, QERR_INVALID_PARAMETER_VALUE, "rng", "a valid
> object");
> + return;
> }
>
> rng_backend_open(vrng->rng, &local_err);
> if (local_err) {
> - qerror_report_err(local_err);
> - error_free(local_err);
> - return -1;
> + error_propagate(errp, local_err);
> + return;
> }
>
> vrng->vq = virtio_add_queue(vdev, 8, handle_input);
> @@ -178,22 +178,24 @@ static int virtio_rng_device_init(VirtIODevice *vdev)
> qemu_mod_timer(vrng->rate_limit_timer,
> qemu_get_clock_ms(vm_clock) + vrng->conf.period_ms);
>
> - register_savevm(qdev, "virtio-rng", -1, 1, virtio_rng_save,
> + register_savevm(dev, "virtio-rng", -1, 1, virtio_rng_save,
> virtio_rng_load, vrng);
>
> - return 0;
> + vrc->parent_realize(dev, errp);
> }
>
> -static int virtio_rng_device_exit(DeviceState *qdev)
> +static void virtio_rng_device_unrealize(DeviceState *dev, Error **errp)
> {
> - VirtIORNG *vrng = VIRTIO_RNG(qdev);
> - VirtIODevice *vdev = VIRTIO_DEVICE(qdev);
> + VirtIODevice *vdev = VIRTIO_DEVICE(dev);
> + VirtIORNG *vrng = VIRTIO_RNG(dev);
> + VirtIORNGClass *vrc = VIRTIO_RNG_GET_CLASS(dev);
>
> qemu_del_timer(vrng->rate_limit_timer);
> qemu_free_timer(vrng->rate_limit_timer);
> - unregister_savevm(qdev, "virtio-rng", vrng);
> + unregister_savevm(dev, "virtio-rng", vrng);
> virtio_cleanup(vdev);
> - return 0;
> +
> + vrc->parent_unrealize(dev, errp);
> }
>
> static Property virtio_rng_properties[] = {
> @@ -201,13 +203,19 @@ static Property virtio_rng_properties[] = {
> DEFINE_PROP_END_OF_LIST(),
> };
>
> -static void virtio_rng_class_init(ObjectClass *klass, void *data)
> +static void virtio_rng_class_init(ObjectClass *oc, void *data)
> {
> - DeviceClass *dc = DEVICE_CLASS(klass);
> - VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
> - dc->exit = virtio_rng_device_exit;
> + DeviceClass *dc = DEVICE_CLASS(oc);
> + VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(oc);
> + VirtIORNGClass *vrc = VIRTIO_RNG_CLASS(oc);
> +
> + vrc->parent_realize = dc->realize;
> + dc->realize = virtio_rng_device_realize;
> +
> + vrc->parent_unrealize = dc->unrealize;
> + dc->unrealize = virtio_rng_device_unrealize;
> +
> dc->props = virtio_rng_properties;
> - vdc->init = virtio_rng_device_init;
> vdc->get_features = get_features;
> }
>
> @@ -225,6 +233,7 @@ static const TypeInfo virtio_rng_info = {
> .instance_size = sizeof(VirtIORNG),
> .instance_init = virtio_rng_initfn,
> .class_init = virtio_rng_class_init,
> + .class_size = sizeof(VirtIORNGClass),
> };
>
> static void virtio_register_types(void)
> diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c
> index 8176c14..d369f9a 100644
> --- a/hw/virtio/virtio.c
> +++ b/hw/virtio/virtio.c
> @@ -1105,35 +1105,29 @@ void virtio_device_set_child_bus_name(VirtIODevice
> *vdev, char *bus_name)
> }
> }
>
> -static int virtio_device_init(DeviceState *qdev)
> +static void virtio_device_realize(DeviceState *dev, Error **errp)
> {
> - VirtIODevice *vdev = VIRTIO_DEVICE(qdev);
> - VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(qdev);
> - assert(k->init != NULL);
> - if (k->init(vdev) < 0) {
> - return -1;
> - }
> + VirtIODevice *vdev = VIRTIO_DEVICE(dev);
> +
> virtio_bus_plug_device(vdev);
> - return 0;
> }
>
> -static int virtio_device_exit(DeviceState *qdev)
> +static void virtio_device_unrealize(DeviceState *dev, Error **errp)
> {
> - VirtIODevice *vdev = VIRTIO_DEVICE(qdev);
> + VirtIODevice *vdev = VIRTIO_DEVICE(dev);
>
> if (vdev->bus_name) {
> g_free(vdev->bus_name);
> vdev->bus_name = NULL;
> }
> - return 0;
> }
>
> static void virtio_device_class_init(ObjectClass *klass, void *data)
> {
> /* Set the default value here. */
> DeviceClass *dc = DEVICE_CLASS(klass);
> - dc->init = virtio_device_init;
> - dc->exit = virtio_device_exit;
> + dc->realize = virtio_device_realize;
> + dc->unrealize = virtio_device_unrealize;
> dc->bus_type = TYPE_VIRTIO_BUS;
> }
>
> diff --git a/include/hw/virtio/vhost-scsi.h b/include/hw/virtio/vhost-scsi.h
> index 85cc031..b0d64e4 100644
> --- a/include/hw/virtio/vhost-scsi.h
> +++ b/include/hw/virtio/vhost-scsi.h
> @@ -53,6 +53,10 @@ enum vhost_scsi_vq_list {
> #define TYPE_VHOST_SCSI "vhost-scsi"
> #define VHOST_SCSI(obj) \
> OBJECT_CHECK(VHostSCSI, (obj), TYPE_VHOST_SCSI)
> +#define VHOST_SCSI_GET_CLASS(obj) \
> + OBJECT_GET_CLASS(VHostSCSIClass, (obj), TYPE_VHOST_SCSI)
> +#define VHOST_SCSI_CLASS(cls) \
> + OBJECT_CLASS_CHECK(VHostSCSIClass, (cls), TYPE_VHOST_SCSI)
>
> typedef struct VHostSCSI {
> VirtIOSCSICommon parent_obj;
> @@ -62,6 +66,15 @@ typedef struct VHostSCSI {
> struct vhost_dev dev;
> } VHostSCSI;
>
> +typedef struct VHostSCSIClass {
> + /*< private >*/
> + VirtIOSCSICommonClass parent_class;
> + /*< public >*/
> +
> + DeviceRealize parent_realize;
> + DeviceUnrealize parent_unrealize;
> +} VHostSCSIClass;
> +
> #define DEFINE_VHOST_SCSI_PROPERTIES(_state, _conf_field) \
> DEFINE_PROP_STRING("vhostfd", _state, _conf_field.vhostfd), \
> DEFINE_PROP_STRING("wwpn", _state, _conf_field.wwpn), \
> diff --git a/include/hw/virtio/virtio-balloon.h
> b/include/hw/virtio/virtio-balloon.h
> index f863bfe..146fa04 100644
> --- a/include/hw/virtio/virtio-balloon.h
> +++ b/include/hw/virtio/virtio-balloon.h
> @@ -21,6 +21,10 @@
> #define TYPE_VIRTIO_BALLOON "virtio-balloon-device"
> #define VIRTIO_BALLOON(obj) \
> OBJECT_CHECK(VirtIOBalloon, (obj), TYPE_VIRTIO_BALLOON)
> +#define VIRTIO_BALLOON_GET_CLASS(obj) \
> + OBJECT_GET_CLASS(VirtIOBalloonClass, (obj), TYPE_VIRTIO_BALLOON)
> +#define VIRTIO_BALLOON_CLASS(cls) \
> + OBJECT_CLASS_CHECK(VirtIOBalloonClass, (cls), TYPE_VIRTIO_BALLOON)
>
> /* from Linux's linux/virtio_balloon.h */
>
> @@ -69,4 +73,13 @@ typedef struct VirtIOBalloon {
> int64_t stats_poll_interval;
> } VirtIOBalloon;
>
> +typedef struct VirtIOBalloonClass {
> + /*< private >*/
> + VirtioDeviceClass parent_class;
> + /*< public >*/
> +
> + DeviceRealize parent_realize;
> + DeviceUnrealize parent_unrealize;
> +} VirtIOBalloonClass;
> +
> #endif
> diff --git a/include/hw/virtio/virtio-blk.h b/include/hw/virtio/virtio-blk.h
> index fc71853..5ed703d 100644
> --- a/include/hw/virtio/virtio-blk.h
> +++ b/include/hw/virtio/virtio-blk.h
> @@ -20,6 +20,10 @@
> #define TYPE_VIRTIO_BLK "virtio-blk-device"
> #define VIRTIO_BLK(obj) \
> OBJECT_CHECK(VirtIOBlock, (obj), TYPE_VIRTIO_BLK)
> +#define VIRTIO_BLK_GET_CLASS(obj) \
> + OBJECT_GET_CLASS(VirtIOBlockClass, (obj), TYPE_VIRTIO_BLK)
> +#define VIRTIO_BLK_CLASS(cls) \
> + OBJECT_CLASS_CHECK(VirtIOBlockClass, (cls), TYPE_VIRTIO_BLK)
>
> /* from Linux's linux/virtio_blk.h */
>
> @@ -129,6 +133,15 @@ typedef struct VirtIOBlock {
> #endif
> } VirtIOBlock;
>
> +typedef struct VirtIOBlockClass {
> + /*< private >*/
> + VirtioDeviceClass parent_class;
> + /*< public >*/
> +
> + DeviceRealize parent_realize;
> + DeviceUnrealize parent_unrealize;
> +} VirtIOBlockClass;
> +
> #define DEFINE_VIRTIO_BLK_FEATURES(_state, _field) \
> DEFINE_VIRTIO_COMMON_FEATURES(_state, _field)
>
> diff --git a/include/hw/virtio/virtio-net.h b/include/hw/virtio/virtio-net.h
> index b315ac9..0b8a06e 100644
> --- a/include/hw/virtio/virtio-net.h
> +++ b/include/hw/virtio/virtio-net.h
> @@ -20,6 +20,10 @@
> #define TYPE_VIRTIO_NET "virtio-net-device"
> #define VIRTIO_NET(obj) \
> OBJECT_CHECK(VirtIONet, (obj), TYPE_VIRTIO_NET)
> +#define VIRTIO_NET_GET_CLASS(obj) \
> + OBJECT_GET_CLASS(VirtIONetClass, (obj), TYPE_VIRTIO_NET)
> +#define VIRTIO_NET_CLASS(cls) \
> + OBJECT_CLASS_CHECK(VirtIONetClass, (cls), TYPE_VIRTIO_NET)
>
> #define ETH_ALEN 6
>
> @@ -195,6 +199,15 @@ typedef struct VirtIONet {
> uint64_t curr_guest_offloads;
> } VirtIONet;
>
> +typedef struct VirtIONetClass {
> + /*< private >*/
> + VirtioDeviceClass parent_class;
> + /*< public >*/
> +
> + DeviceRealize parent_realize;
> + DeviceUnrealize parent_unrealize;
> +} VirtIONetClass;
> +
> #define VIRTIO_NET_CTRL_MAC 1
> #define VIRTIO_NET_CTRL_MAC_TABLE_SET 0
> #define VIRTIO_NET_CTRL_MAC_ADDR_SET 1
> diff --git a/include/hw/virtio/virtio-rng.h b/include/hw/virtio/virtio-rng.h
> index debaa15..528f70c 100644
> --- a/include/hw/virtio/virtio-rng.h
> +++ b/include/hw/virtio/virtio-rng.h
> @@ -18,6 +18,10 @@
> #define TYPE_VIRTIO_RNG "virtio-rng-device"
> #define VIRTIO_RNG(obj) \
> OBJECT_CHECK(VirtIORNG, (obj), TYPE_VIRTIO_RNG)
> +#define VIRTIO_RNG_GET_CLASS(obj) \
> + OBJECT_GET_CLASS(VirtIORNGClass, (obj), TYPE_VIRTIO_RNG)
> +#define VIRTIO_RNG_CLASS(cls) \
> + OBJECT_CLASS_CHECK(VirtIORNGClass, (cls), TYPE_VIRTIO_RNG)
>
> /* The Virtio ID for the virtio rng device */
> #define VIRTIO_ID_RNG 4
> @@ -46,6 +50,15 @@ typedef struct VirtIORNG {
> int64_t quota_remaining;
> } VirtIORNG;
>
> +typedef struct VirtIORNGClass {
> + /*< private >*/
> + VirtioDeviceClass parent_class;
> + /*< public >*/
> +
> + DeviceRealize parent_realize;
> + DeviceUnrealize parent_unrealize;
> +} VirtIORNGClass;
> +
> /* Set a default rate limit of 2^47 bytes per minute or roughly 2TB/s. If
> you have an entropy source capable of generating more entropy than this
> and you can pass it through via virtio-rng, then hats off to you. Until
> diff --git a/include/hw/virtio/virtio-scsi.h b/include/hw/virtio/virtio-scsi.h
> index 9a98540..2ce58cd 100644
> --- a/include/hw/virtio/virtio-scsi.h
> +++ b/include/hw/virtio/virtio-scsi.h
> @@ -21,10 +21,18 @@
> #define TYPE_VIRTIO_SCSI_COMMON "virtio-scsi-common"
> #define VIRTIO_SCSI_COMMON(obj) \
> OBJECT_CHECK(VirtIOSCSICommon, (obj), TYPE_VIRTIO_SCSI_COMMON)
> +#define VIRTIO_SCSI_COMMON_GET_CLASS(obj) \
> + OBJECT_GET_CLASS(VirtIOSCSICommonClass, (obj),
> TYPE_VIRTIO_SCSI_COMMON)
> +#define VIRTIO_SCSI_COMMON_CLASS(cls) \
> + OBJECT_CHECK(VirtIOSCSICommonClass, (cls), TYPE_VIRTIO_SCSI_COMMON)
>
> #define TYPE_VIRTIO_SCSI "virtio-scsi-device"
> #define VIRTIO_SCSI(obj) \
> OBJECT_CHECK(VirtIOSCSI, (obj), TYPE_VIRTIO_SCSI)
> +#define VIRTIO_SCSI_GET_CLASS(obj) \
> + OBJECT_GET_CLASS(VirtIOSCSIClass, (obj), TYPE_VIRTIO_SCSI)
> +#define VIRTIO_SCSI_CLASS(cls) \
> + OBJECT_CHECK(VirtIOSCSIClass, (cls), TYPE_VIRTIO_SCSI)
>
>
> /* The ID for virtio_scsi */
> @@ -166,6 +174,15 @@ typedef struct VirtIOSCSICommon {
> VirtQueue **cmd_vqs;
> } VirtIOSCSICommon;
>
> +typedef struct VirtIOSCSICommonClass {
> + /*< private >*/
> + VirtioDeviceClass parent_class;
> + /*< public >*/
> +
> + DeviceRealize parent_realize;
> + DeviceUnrealize parent_unrealize;
> +} VirtIOSCSICommonClass;
> +
> typedef struct {
> VirtIOSCSICommon parent_obj;
>
> @@ -174,6 +191,15 @@ typedef struct {
> bool events_dropped;
> } VirtIOSCSI;
>
> +typedef struct VirtIOSCSIClass {
> + /*< private >*/
> + VirtIOSCSICommonClass parent_class;
> + /*< public >*/
> +
> + DeviceRealize parent_realize;
> + DeviceUnrealize parent_unrealize;
> +} VirtIOSCSIClass;
> +
> #define DEFINE_VIRTIO_SCSI_PROPERTIES(_state, _conf_field)
> \
> DEFINE_PROP_UINT32("num_queues", _state, _conf_field.num_queues, 1),
> \
> DEFINE_PROP_UINT32("max_sectors", _state, _conf_field.max_sectors,
> 0xFFFF),\
> @@ -186,7 +212,4 @@ typedef struct {
> DEFINE_PROP_BIT("param_change", _state, _feature_field,
> \
> VIRTIO_SCSI_F_CHANGE, true)
>
> -int virtio_scsi_common_init(VirtIOSCSICommon *vs);
> -int virtio_scsi_common_exit(VirtIOSCSICommon *vs);
> -
> #endif /* _QEMU_VIRTIO_SCSI_H */
> diff --git a/include/hw/virtio/virtio-serial.h
> b/include/hw/virtio/virtio-serial.h
> index 1d2040b..49af9e3 100644
> --- a/include/hw/virtio/virtio-serial.h
> +++ b/include/hw/virtio/virtio-serial.h
> @@ -212,6 +212,15 @@ struct VirtIOSerial {
> virtio_serial_conf serial;
> };
>
> +typedef struct VirtIOSerialClass {
> + /*< private >*/
> + VirtioDeviceClass parent_class;
> + /*< public >*/
> +
> + DeviceRealize parent_realize;
> + DeviceUnrealize parent_unrealize;
> +} VirtIOSerialClass;
> +
> /* Interface to the virtio-serial bus */
>
> /*
> @@ -247,6 +256,10 @@ void virtio_serial_throttle_port(VirtIOSerialPort *port,
> bool throttle);
> #define TYPE_VIRTIO_SERIAL "virtio-serial-device"
> #define VIRTIO_SERIAL(obj) \
> OBJECT_CHECK(VirtIOSerial, (obj), TYPE_VIRTIO_SERIAL)
> +#define VIRTIO_SERIAL_GET_CLASS(obj) \
> + OBJECT_GET_CLASS(VirtIOSerialClass, (obj), TYPE_VIRTIO_SERIAL)
> +#define VIRTIO_SERIAL_CLASS(cls) \
> + OBJECT_CLASS_CHECK(VirtIOSerialClass, (cls), TYPE_VIRTIO_SERIAL)
>
> #define DEFINE_VIRTIO_SERIAL_PROPERTIES(_state, _field) \
> DEFINE_PROP_UINT32("max_ports", _state, _field.max_virtserial_ports,
> 31)
> diff --git a/include/hw/virtio/virtio.h b/include/hw/virtio/virtio.h
> index a6c5c53..7e1854a 100644
> --- a/include/hw/virtio/virtio.h
> +++ b/include/hw/virtio/virtio.h
> @@ -122,9 +122,11 @@ struct VirtIODevice
> };
>
> typedef struct VirtioDeviceClass {
> - /* This is what a VirtioDevice must implement */
> + /*< private >*/
> DeviceClass parent;
> - int (*init)(VirtIODevice *vdev);
> + /*< public >*/
> +
> + /* This is what a VirtioDevice must implement */
> uint32_t (*get_features)(VirtIODevice *vdev, uint32_t
> requested_features);
> uint32_t (*bad_features)(VirtIODevice *vdev);
> void (*set_features)(VirtIODevice *vdev, uint32_t val);
> --
> 1.8.1.4
