motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-16 14:41:55 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

virtio-ccw: Convert to realize()

Browse source 
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-Id: <1425045219-19958-1-git-send-email-armbru@redhat.com>
Reviewed-by: Cornelia Huck <cornelia.huck@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
This commit is contained in:
Markus Armbruster 2015-02-27 14:53:39 +01:00 • committed by Christian Borntraeger
parent f35dd56651
commit 5e5ced386a
2 changed files with 75 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

132
hw/s390x/virtio-ccw.c
View file

@ -607,7 +607,8 @@ static int virtio_ccw_cb(SubchDev *sch, CCW1 ccw)
return ret; return ret;
} }
static int virtio_ccw_device_init(VirtioCcwDevice *dev, VirtIODevice *vdev) static void virtio_ccw_device_realize(VirtioCcwDevice *dev,
VirtIODevice *vdev, Error **errp)
{ {
unsigned int cssid = 0; unsigned int cssid = 0;
unsigned int ssid = 0; unsigned int ssid = 0;
@ -616,7 +617,6 @@ static int virtio_ccw_device_init(VirtioCcwDevice *dev, VirtIODevice *vdev)
bool have_devno = false; bool have_devno = false;
bool found = false; bool found = false;
SubchDev *sch; SubchDev *sch;
int ret;
int num; int num;
DeviceState *parent = DEVICE(dev); DeviceState *parent = DEVICE(dev);
@ -639,21 +639,19 @@ static int virtio_ccw_device_init(VirtioCcwDevice *dev, VirtIODevice *vdev)
num = sscanf(dev->bus_id, "%x.%x.%04x", &cssid, &ssid, &devno); num = sscanf(dev->bus_id, "%x.%x.%04x", &cssid, &ssid, &devno);
if (num == 3) { if (num == 3) {
if ((cssid > MAX_CSSID) || (ssid > MAX_SSID)) { if ((cssid > MAX_CSSID) || (ssid > MAX_SSID)) {
ret = -EINVAL; error_setg(errp, "Invalid cssid or ssid: cssid %x, ssid %x",
error_report("Invalid cssid or ssid: cssid %x, ssid %x",
cssid, ssid); cssid, ssid);
goto out_err; goto out_err;
} }
/* Enforce use of virtual cssid. */ /* Enforce use of virtual cssid. */
if (cssid != VIRTUAL_CSSID) { if (cssid != VIRTUAL_CSSID) {
ret = -EINVAL; error_setg(errp, "cssid %x not valid for virtio devices",
error_report("cssid %x not valid for virtio devices", cssid); cssid);
goto out_err; goto out_err;
} }
if (css_devno_used(cssid, ssid, devno)) { if (css_devno_used(cssid, ssid, devno)) {
ret = -EEXIST; error_setg(errp, "Device %x.%x.%04x already exists",
error_report("Device %x.%x.%04x already exists", cssid, ssid, cssid, ssid, devno);
devno);
goto out_err; goto out_err;
} }
sch->cssid = cssid; sch->cssid = cssid;
@ -661,8 +659,7 @@ static int virtio_ccw_device_init(VirtioCcwDevice *dev, VirtIODevice *vdev)
sch->devno = devno; sch->devno = devno;
have_devno = true; have_devno = true;
} else { } else {
ret = -EINVAL; error_setg(errp, "Malformed devno parameter '%s'", dev->bus_id);
error_report("Malformed devno parameter '%s'", dev->bus_id);
goto out_err; goto out_err;
} }
} }
@ -678,9 +675,8 @@ static int virtio_ccw_device_init(VirtioCcwDevice *dev, VirtIODevice *vdev)
} }
} }
if (!found) { if (!found) {
ret = -ENODEV; error_setg(errp, "No free subchannel found for %x.%x.%04x",
error_report("No free subchannel found for %x.%x.%04x", cssid, ssid, cssid, ssid, devno);
devno);
goto out_err; goto out_err;
} }
trace_virtio_ccw_new_device(cssid, ssid, schid, devno, trace_virtio_ccw_new_device(cssid, ssid, schid, devno,
@ -702,8 +698,7 @@ static int virtio_ccw_device_init(VirtioCcwDevice *dev, VirtIODevice *vdev)
if (devno == MAX_SCHID) { if (devno == MAX_SCHID) {
devno = 0; devno = 0;
} else if (devno == schid - 1) { } else if (devno == schid - 1) {
ret = -ENODEV; error_setg(errp, "No free devno found");
error_report("No free devno found");
goto out_err; goto out_err;
} else { } else {
devno++; devno++;
@ -720,8 +715,7 @@ static int virtio_ccw_device_init(VirtioCcwDevice *dev, VirtIODevice *vdev)
} }
} }
if (!found) { if (!found) {
ret = -ENODEV; error_setg(errp, "Virtual channel subsystem is full!");
error_report("Virtual channel subsystem is full!");
goto out_err; goto out_err;
} }
trace_virtio_ccw_new_device(cssid, ssid, schid, devno, trace_virtio_ccw_new_device(cssid, ssid, schid, devno,
@ -748,12 +742,11 @@ static int virtio_ccw_device_init(VirtioCcwDevice *dev, VirtIODevice *vdev)
css_generate_sch_crws(sch->cssid, sch->ssid, sch->schid, css_generate_sch_crws(sch->cssid, sch->ssid, sch->schid,
parent->hotplugged, 1); parent->hotplugged, 1);
return 0; return;
out_err: out_err:
dev->sch = NULL; dev->sch = NULL;
g_free(sch); g_free(sch);
return ret;
} }
static int virtio_ccw_exit(VirtioCcwDevice *dev) static int virtio_ccw_exit(VirtioCcwDevice *dev)
@ -771,21 +764,24 @@ static int virtio_ccw_exit(VirtioCcwDevice *dev)
return 0; return 0;
} }
static int virtio_ccw_net_init(VirtioCcwDevice *ccw_dev) static void virtio_ccw_net_realize(VirtioCcwDevice *ccw_dev, Error **errp)
{ {
DeviceState *qdev = DEVICE(ccw_dev); DeviceState *qdev = DEVICE(ccw_dev);
VirtIONetCcw *dev = VIRTIO_NET_CCW(ccw_dev); VirtIONetCcw *dev = VIRTIO_NET_CCW(ccw_dev);
DeviceState *vdev = DEVICE(&dev->vdev); DeviceState *vdev = DEVICE(&dev->vdev);
Error *err = NULL;
virtio_net_set_config_size(&dev->vdev, ccw_dev->host_features[0]); virtio_net_set_config_size(&dev->vdev, ccw_dev->host_features[0]);
virtio_net_set_netclient_name(&dev->vdev, qdev->id, virtio_net_set_netclient_name(&dev->vdev, qdev->id,
object_get_typename(OBJECT(qdev))); object_get_typename(OBJECT(qdev)));
qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
if (qdev_init(vdev) < 0) { object_property_set_bool(OBJECT(vdev), true, "realized", &err);
return -1; if (err) {
error_propagate(errp, err);
return;
} }
return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); virtio_ccw_device_realize(ccw_dev, VIRTIO_DEVICE(vdev), errp);
} }
static void virtio_ccw_net_instance_init(Object *obj) static void virtio_ccw_net_instance_init(Object *obj)
@ -798,16 +794,20 @@ static void virtio_ccw_net_instance_init(Object *obj)
"bootindex", &error_abort); "bootindex", &error_abort);
} }
static int virtio_ccw_blk_init(VirtioCcwDevice *ccw_dev) static void virtio_ccw_blk_realize(VirtioCcwDevice *ccw_dev, Error **errp)
{ {
VirtIOBlkCcw *dev = VIRTIO_BLK_CCW(ccw_dev); VirtIOBlkCcw *dev = VIRTIO_BLK_CCW(ccw_dev);
DeviceState *vdev = DEVICE(&dev->vdev); DeviceState *vdev = DEVICE(&dev->vdev);
Error *err = NULL;
qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
if (qdev_init(vdev) < 0) { object_property_set_bool(OBJECT(vdev), true, "realized", &err);
return -1; if (err) {
error_propagate(errp, err);
return;
} }
return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); virtio_ccw_device_realize(ccw_dev, VIRTIO_DEVICE(vdev), errp);
} }
static void virtio_ccw_blk_instance_init(Object *obj) static void virtio_ccw_blk_instance_init(Object *obj)
@ -822,11 +822,12 @@ static void virtio_ccw_blk_instance_init(Object *obj)
"bootindex", &error_abort); "bootindex", &error_abort);
} }
static int virtio_ccw_serial_init(VirtioCcwDevice *ccw_dev) static void virtio_ccw_serial_realize(VirtioCcwDevice *ccw_dev, Error **errp)
{ {
VirtioSerialCcw *dev = VIRTIO_SERIAL_CCW(ccw_dev); VirtioSerialCcw *dev = VIRTIO_SERIAL_CCW(ccw_dev);
DeviceState *vdev = DEVICE(&dev->vdev); DeviceState *vdev = DEVICE(&dev->vdev);
DeviceState *proxy = DEVICE(ccw_dev); DeviceState *proxy = DEVICE(ccw_dev);
Error *err = NULL;
char *bus_name; char *bus_name;
/* /*
@ -840,11 +841,13 @@ static int virtio_ccw_serial_init(VirtioCcwDevice *ccw_dev)
} }
qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
if (qdev_init(vdev) < 0) { object_property_set_bool(OBJECT(vdev), true, "realized", &err);
return -1; if (err) {
error_propagate(errp, err);
return;
} }
return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); virtio_ccw_device_realize(ccw_dev, VIRTIO_DEVICE(vdev), errp);
} }
@ -856,17 +859,20 @@ static void virtio_ccw_serial_instance_init(Object *obj)
TYPE_VIRTIO_SERIAL); TYPE_VIRTIO_SERIAL);
} }
static int virtio_ccw_balloon_init(VirtioCcwDevice *ccw_dev) static void virtio_ccw_balloon_realize(VirtioCcwDevice *ccw_dev, Error **errp)
{ {
VirtIOBalloonCcw *dev = VIRTIO_BALLOON_CCW(ccw_dev); VirtIOBalloonCcw *dev = VIRTIO_BALLOON_CCW(ccw_dev);
DeviceState *vdev = DEVICE(&dev->vdev); DeviceState *vdev = DEVICE(&dev->vdev);
Error *err = NULL;
qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
if (qdev_init(vdev) < 0) { object_property_set_bool(OBJECT(vdev), true, "realized", &err);
return -1; if (err) {
error_propagate(errp, err);
return;
} }
return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); virtio_ccw_device_realize(ccw_dev, VIRTIO_DEVICE(vdev), errp);
} }
static void balloon_ccw_stats_get_all(Object *obj, struct Visitor *v, static void balloon_ccw_stats_get_all(Object *obj, struct Visitor *v,
@ -909,11 +915,12 @@ static void virtio_ccw_balloon_instance_init(Object *obj)
NULL, dev, NULL); NULL, dev, NULL);
} }
static int virtio_ccw_scsi_init(VirtioCcwDevice *ccw_dev) static void virtio_ccw_scsi_realize(VirtioCcwDevice *ccw_dev, Error **errp)
{ {
VirtIOSCSICcw *dev = VIRTIO_SCSI_CCW(ccw_dev); VirtIOSCSICcw *dev = VIRTIO_SCSI_CCW(ccw_dev);
DeviceState *vdev = DEVICE(&dev->vdev); DeviceState *vdev = DEVICE(&dev->vdev);
DeviceState *qdev = DEVICE(ccw_dev); DeviceState *qdev = DEVICE(ccw_dev);
Error *err = NULL;
char *bus_name; char *bus_name;
/* /*
@ -927,11 +934,13 @@ static int virtio_ccw_scsi_init(VirtioCcwDevice *ccw_dev)
} }
qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
if (qdev_init(vdev) < 0) { object_property_set_bool(OBJECT(vdev), true, "realized", &err);
return -1; if (err) {
error_propagate(errp, err);
return;
} }
return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); virtio_ccw_device_realize(ccw_dev, VIRTIO_DEVICE(vdev), errp);
} }
static void virtio_ccw_scsi_instance_init(Object *obj) static void virtio_ccw_scsi_instance_init(Object *obj)
@ -945,17 +954,20 @@ static void virtio_ccw_scsi_instance_init(Object *obj)
} }
#ifdef CONFIG_VHOST_SCSI #ifdef CONFIG_VHOST_SCSI
static int vhost_ccw_scsi_init(VirtioCcwDevice *ccw_dev) static void vhost_ccw_scsi_realize(VirtioCcwDevice *ccw_dev, Error **errp)
{ {
VHostSCSICcw *dev = VHOST_SCSI_CCW(ccw_dev); VHostSCSICcw *dev = VHOST_SCSI_CCW(ccw_dev);
DeviceState *vdev = DEVICE(&dev->vdev); DeviceState *vdev = DEVICE(&dev->vdev);
Error *err = NULL;
qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
if (qdev_init(vdev) < 0) { object_property_set_bool(OBJECT(vdev), true, "realized", &err);
return -1; if (err) {
error_propagate(errp, err);
return;
} }
return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); virtio_ccw_device_realize(ccw_dev, VIRTIO_DEVICE(vdev), errp);
} }
static void vhost_ccw_scsi_instance_init(Object *obj) static void vhost_ccw_scsi_instance_init(Object *obj)
@ -967,21 +979,24 @@ static void vhost_ccw_scsi_instance_init(Object *obj)
} }
#endif #endif
static int virtio_ccw_rng_init(VirtioCcwDevice *ccw_dev) static void virtio_ccw_rng_realize(VirtioCcwDevice *ccw_dev, Error **errp)
{ {
VirtIORNGCcw *dev = VIRTIO_RNG_CCW(ccw_dev); VirtIORNGCcw *dev = VIRTIO_RNG_CCW(ccw_dev);
DeviceState *vdev = DEVICE(&dev->vdev); DeviceState *vdev = DEVICE(&dev->vdev);
Error *err = NULL;
qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
if (qdev_init(vdev) < 0) { object_property_set_bool(OBJECT(vdev), true, "realized", &err);
return -1; if (err) {
error_propagate(errp, err);
return;
} }
object_property_set_link(OBJECT(dev), object_property_set_link(OBJECT(dev),
OBJECT(dev->vdev.conf.rng), "rng", OBJECT(dev->vdev.conf.rng), "rng",
NULL); NULL);
return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); virtio_ccw_device_realize(ccw_dev, VIRTIO_DEVICE(vdev), errp);
} }
/* DeviceState to VirtioCcwDevice. Note: used on datapath, /* DeviceState to VirtioCcwDevice. Note: used on datapath,
@ -1391,7 +1406,7 @@ static void virtio_ccw_net_class_init(ObjectClass *klass, void *data)
DeviceClass *dc = DEVICE_CLASS(klass); DeviceClass *dc = DEVICE_CLASS(klass);
VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
k->init = virtio_ccw_net_init; k->realize = virtio_ccw_net_realize;
k->exit = virtio_ccw_exit; k->exit = virtio_ccw_exit;
dc->reset = virtio_ccw_reset; dc->reset = virtio_ccw_reset;
dc->props = virtio_ccw_net_properties; dc->props = virtio_ccw_net_properties;
@ -1417,7 +1432,7 @@ static void virtio_ccw_blk_class_init(ObjectClass *klass, void *data)
DeviceClass *dc = DEVICE_CLASS(klass); DeviceClass *dc = DEVICE_CLASS(klass);
VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
k->init = virtio_ccw_blk_init; k->realize = virtio_ccw_blk_realize;
k->exit = virtio_ccw_exit; k->exit = virtio_ccw_exit;
dc->reset = virtio_ccw_reset; dc->reset = virtio_ccw_reset;
dc->props = virtio_ccw_blk_properties; dc->props = virtio_ccw_blk_properties;
@ -1443,7 +1458,7 @@ static void virtio_ccw_serial_class_init(ObjectClass *klass, void *data)
DeviceClass *dc = DEVICE_CLASS(klass); DeviceClass *dc = DEVICE_CLASS(klass);
VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
k->init = virtio_ccw_serial_init; k->realize = virtio_ccw_serial_realize;
k->exit = virtio_ccw_exit; k->exit = virtio_ccw_exit;
dc->reset = virtio_ccw_reset; dc->reset = virtio_ccw_reset;
dc->props = virtio_ccw_serial_properties; dc->props = virtio_ccw_serial_properties;
@ -1469,7 +1484,7 @@ static void virtio_ccw_balloon_class_init(ObjectClass *klass, void *data)
DeviceClass *dc = DEVICE_CLASS(klass); DeviceClass *dc = DEVICE_CLASS(klass);
VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
k->init = virtio_ccw_balloon_init; k->realize = virtio_ccw_balloon_realize;
k->exit = virtio_ccw_exit; k->exit = virtio_ccw_exit;
dc->reset = virtio_ccw_reset; dc->reset = virtio_ccw_reset;
dc->props = virtio_ccw_balloon_properties; dc->props = virtio_ccw_balloon_properties;
@ -1496,7 +1511,7 @@ static void virtio_ccw_scsi_class_init(ObjectClass *klass, void *data)
DeviceClass *dc = DEVICE_CLASS(klass); DeviceClass *dc = DEVICE_CLASS(klass);
VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
k->init = virtio_ccw_scsi_init; k->realize = virtio_ccw_scsi_realize;
k->exit = virtio_ccw_exit; k->exit = virtio_ccw_exit;
dc->reset = virtio_ccw_reset; dc->reset = virtio_ccw_reset;
dc->props = virtio_ccw_scsi_properties; dc->props = virtio_ccw_scsi_properties;
@ -1521,7 +1536,7 @@ static void vhost_ccw_scsi_class_init(ObjectClass *klass, void *data)
DeviceClass *dc = DEVICE_CLASS(klass); DeviceClass *dc = DEVICE_CLASS(klass);
VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
k->init = vhost_ccw_scsi_init; k->realize = vhost_ccw_scsi_realize;
k->exit = virtio_ccw_exit; k->exit = virtio_ccw_exit;
dc->reset = virtio_ccw_reset; dc->reset = virtio_ccw_reset;
dc->props = vhost_ccw_scsi_properties; dc->props = vhost_ccw_scsi_properties;
@ -1558,7 +1573,7 @@ static void virtio_ccw_rng_class_init(ObjectClass *klass, void *data)
DeviceClass *dc = DEVICE_CLASS(klass); DeviceClass *dc = DEVICE_CLASS(klass);
VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
k->init = virtio_ccw_rng_init; k->realize = virtio_ccw_rng_realize;
k->exit = virtio_ccw_exit; k->exit = virtio_ccw_exit;
dc->reset = virtio_ccw_reset; dc->reset = virtio_ccw_reset;
dc->props = virtio_ccw_rng_properties; dc->props = virtio_ccw_rng_properties;
@ -1572,14 +1587,13 @@ static const TypeInfo virtio_ccw_rng = {
.class_init = virtio_ccw_rng_class_init, .class_init = virtio_ccw_rng_class_init,
}; };
static int virtio_ccw_busdev_init(DeviceState *dev) static void virtio_ccw_busdev_realize(DeviceState *dev, Error **errp)
{ {
VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev; VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev;
VirtIOCCWDeviceClass *_info = VIRTIO_CCW_DEVICE_GET_CLASS(dev); VirtIOCCWDeviceClass *_info = VIRTIO_CCW_DEVICE_GET_CLASS(dev);
virtio_ccw_bus_new(&_dev->bus, sizeof(_dev->bus), _dev); virtio_ccw_bus_new(&_dev->bus, sizeof(_dev->bus), _dev);
_info->realize(_dev, errp);
return _info->init(_dev);
} }
static int virtio_ccw_busdev_exit(DeviceState *dev) static int virtio_ccw_busdev_exit(DeviceState *dev)
@ -1622,7 +1636,7 @@ static void virtio_ccw_device_class_init(ObjectClass *klass, void *data)
DeviceClass *dc = DEVICE_CLASS(klass); DeviceClass *dc = DEVICE_CLASS(klass);
dc->props = virtio_ccw_properties; dc->props = virtio_ccw_properties;
dc->init = virtio_ccw_busdev_init; dc->realize = virtio_ccw_busdev_realize;
dc->exit = virtio_ccw_busdev_exit; dc->exit = virtio_ccw_busdev_exit;
dc->bus_type = TYPE_VIRTUAL_CSS_BUS; dc->bus_type = TYPE_VIRTUAL_CSS_BUS;
} }

2
hw/s390x/virtio-ccw.h
View file

@ -64,7 +64,7 @@ typedef struct VirtioCcwDevice VirtioCcwDevice;
typedef struct VirtIOCCWDeviceClass { typedef struct VirtIOCCWDeviceClass {
DeviceClass parent_class; DeviceClass parent_class;
int (*init)(VirtioCcwDevice *dev); void (*realize)(VirtioCcwDevice *dev, Error **errp);
int (*exit)(VirtioCcwDevice *dev); int (*exit)(VirtioCcwDevice *dev);
} VirtIOCCWDeviceClass; } VirtIOCCWDeviceClass;