External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-03-07 17:28:15 +00:00
Code

Make QEMU hotplug use cached qemu capabilities data

Browse Source 
* src/qemu/qemu_hotplug.h, src/qemu/qemu_hotplug.c: Remove
  qemuCaps parameters from all methods
* src/qemu/qemu_driver.c: Don't create & pass qemuCaps to
  hotplug methods
This commit is contained in:
Daniel P. Berrange 2011-05-04 13:09:09 +01:00
parent 43c01d3838
commit a623bff450
3 changed files with 127 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
src/qemu/qemu_driver.c
View File

@ -3794,8 +3794,7 @@ cleanup:
static int static int
qemuDomainAttachDeviceDiskLive(struct qemud_driver *driver, qemuDomainAttachDeviceDiskLive(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev)
virBitmapPtr qemuCaps)
{ {
virDomainDiskDefPtr disk = dev->data.disk; virDomainDiskDefPtr disk = dev->data.disk;
virCgroupPtr cgroup = NULL; virCgroupPtr cgroup = NULL;
@ -3821,16 +3820,16 @@ qemuDomainAttachDeviceDiskLive(struct qemud_driver *driver,
switch (disk->device) { switch (disk->device) {
case VIR_DOMAIN_DISK_DEVICE_CDROM: case VIR_DOMAIN_DISK_DEVICE_CDROM:
case VIR_DOMAIN_DISK_DEVICE_FLOPPY: case VIR_DOMAIN_DISK_DEVICE_FLOPPY:
ret = qemuDomainChangeEjectableMedia(driver, vm, disk, qemuCaps, false); ret = qemuDomainChangeEjectableMedia(driver, vm, disk, false);
break; break;
case VIR_DOMAIN_DISK_DEVICE_DISK: case VIR_DOMAIN_DISK_DEVICE_DISK:
if (disk->bus == VIR_DOMAIN_DISK_BUS_USB) if (disk->bus == VIR_DOMAIN_DISK_BUS_USB)
ret = qemuDomainAttachUsbMassstorageDevice(driver, vm, ret = qemuDomainAttachUsbMassstorageDevice(driver, vm,
disk, qemuCaps); disk);
else if (disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO) else if (disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO)
ret = qemuDomainAttachPciDiskDevice(driver, vm, disk, qemuCaps); ret = qemuDomainAttachPciDiskDevice(driver, vm, disk);
else if (disk->bus == VIR_DOMAIN_DISK_BUS_SCSI) else if (disk->bus == VIR_DOMAIN_DISK_BUS_SCSI)
ret = qemuDomainAttachSCSIDisk(driver, vm, disk, qemuCaps); ret = qemuDomainAttachSCSIDisk(driver, vm, disk);
else else
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("disk bus '%s' cannot be hotplugged."), _("disk bus '%s' cannot be hotplugged."),
@ -3857,15 +3856,14 @@ end:
static int static int
qemuDomainAttachDeviceControllerLive(struct qemud_driver *driver, qemuDomainAttachDeviceControllerLive(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev)
virBitmapPtr qemuCaps)
{ {
virDomainControllerDefPtr cont = dev->data.controller; virDomainControllerDefPtr cont = dev->data.controller;
int ret = -1; int ret = -1;
switch (cont->type) { switch (cont->type) {
case VIR_DOMAIN_CONTROLLER_TYPE_SCSI: case VIR_DOMAIN_CONTROLLER_TYPE_SCSI:
ret = qemuDomainAttachPciControllerDevice(driver, vm, cont, qemuCaps); ret = qemuDomainAttachPciControllerDevice(driver, vm, cont);
break; break;
default: default:
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
@ -3879,35 +3877,34 @@ qemuDomainAttachDeviceControllerLive(struct qemud_driver *driver,
static int static int
qemuDomainAttachDeviceLive(virDomainObjPtr vm, qemuDomainAttachDeviceLive(virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev,
virDomainPtr dom, virDomainPtr dom)
virBitmapPtr qemuCaps)
{ {
struct qemud_driver *driver = dom->conn->privateData; struct qemud_driver *driver = dom->conn->privateData;
int ret = -1; int ret = -1;
switch (dev->type) { switch (dev->type) {
case VIR_DOMAIN_DEVICE_DISK: case VIR_DOMAIN_DEVICE_DISK:
ret = qemuDomainAttachDeviceDiskLive(driver, vm, dev, qemuCaps); ret = qemuDomainAttachDeviceDiskLive(driver, vm, dev);
if (!ret) if (!ret)
dev->data.disk = NULL; dev->data.disk = NULL;
break; break;
case VIR_DOMAIN_DEVICE_CONTROLLER: case VIR_DOMAIN_DEVICE_CONTROLLER:
ret = qemuDomainAttachDeviceControllerLive(driver, vm, dev, qemuCaps); ret = qemuDomainAttachDeviceControllerLive(driver, vm, dev);
if (!ret) if (!ret)
dev->data.controller = NULL; dev->data.controller = NULL;
break; break;
case VIR_DOMAIN_DEVICE_NET: case VIR_DOMAIN_DEVICE_NET:
ret = qemuDomainAttachNetDevice(dom->conn, driver, vm, ret = qemuDomainAttachNetDevice(dom->conn, driver, vm,
dev->data.net, qemuCaps); dev->data.net);
if (!ret) if (!ret)
dev->data.net = NULL; dev->data.net = NULL;
break; break;
case VIR_DOMAIN_DEVICE_HOSTDEV: case VIR_DOMAIN_DEVICE_HOSTDEV:
ret = qemuDomainAttachHostDevice(driver, vm, ret = qemuDomainAttachHostDevice(driver, vm,
dev->data.hostdev, qemuCaps); dev->data.hostdev);
if (!ret) if (!ret)
dev->data.hostdev = NULL; dev->data.hostdev = NULL;
break; break;
@ -3925,8 +3922,7 @@ qemuDomainAttachDeviceLive(virDomainObjPtr vm,
static int static int
qemuDomainDetachDeviceDiskLive(struct qemud_driver *driver, qemuDomainDetachDeviceDiskLive(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev)
virBitmapPtr qemuCaps)
{ {
virDomainDiskDefPtr disk = dev->data.disk; virDomainDiskDefPtr disk = dev->data.disk;
int ret = -1; int ret = -1;
@ -3934,11 +3930,11 @@ qemuDomainDetachDeviceDiskLive(struct qemud_driver *driver,
switch (disk->device) { switch (disk->device) {
case VIR_DOMAIN_DISK_DEVICE_DISK: case VIR_DOMAIN_DISK_DEVICE_DISK:
if (disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO) if (disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO)
ret = qemuDomainDetachPciDiskDevice(driver, vm, dev, qemuCaps); ret = qemuDomainDetachPciDiskDevice(driver, vm, dev);
else if (disk->bus == VIR_DOMAIN_DISK_BUS_SCSI) else if (disk->bus == VIR_DOMAIN_DISK_BUS_SCSI)
ret = qemuDomainDetachDiskDevice(driver, vm, dev, qemuCaps); ret = qemuDomainDetachDiskDevice(driver, vm, dev);
else if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_USB) else if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_USB)
ret = qemuDomainDetachDiskDevice(driver, vm, dev, qemuCaps); ret = qemuDomainDetachDiskDevice(driver, vm, dev);
else else
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This type of disk cannot be hot unplugged")); _("This type of disk cannot be hot unplugged"));
@ -3955,15 +3951,14 @@ qemuDomainDetachDeviceDiskLive(struct qemud_driver *driver,
static int static int
qemuDomainDetachDeviceControllerLive(struct qemud_driver *driver, qemuDomainDetachDeviceControllerLive(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev)
virBitmapPtr qemuCaps)
{ {
virDomainControllerDefPtr cont = dev->data.controller; virDomainControllerDefPtr cont = dev->data.controller;
int ret = -1; int ret = -1;
switch (cont->type) { switch (cont->type) {
case VIR_DOMAIN_CONTROLLER_TYPE_SCSI: case VIR_DOMAIN_CONTROLLER_TYPE_SCSI:
ret = qemuDomainDetachPciControllerDevice(driver, vm, dev, qemuCaps); ret = qemuDomainDetachPciControllerDevice(driver, vm, dev);
break; break;
default : default :
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
@ -3976,24 +3971,23 @@ qemuDomainDetachDeviceControllerLive(struct qemud_driver *driver,
static int static int
qemuDomainDetachDeviceLive(virDomainObjPtr vm, qemuDomainDetachDeviceLive(virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev,
virDomainPtr dom, virDomainPtr dom)
virBitmapPtr qemuCaps)
{ {
struct qemud_driver *driver = dom->conn->privateData; struct qemud_driver *driver = dom->conn->privateData;
int ret = -1; int ret = -1;
switch (dev->type) { switch (dev->type) {
case VIR_DOMAIN_DEVICE_DISK: case VIR_DOMAIN_DEVICE_DISK:
ret = qemuDomainDetachDeviceDiskLive(driver, vm, dev, qemuCaps); ret = qemuDomainDetachDeviceDiskLive(driver, vm, dev);
break; break;
case VIR_DOMAIN_DEVICE_CONTROLLER: case VIR_DOMAIN_DEVICE_CONTROLLER:
ret = qemuDomainDetachDeviceControllerLive(driver, vm, dev, qemuCaps); ret = qemuDomainDetachDeviceControllerLive(driver, vm, dev);
break; break;
case VIR_DOMAIN_DEVICE_NET: case VIR_DOMAIN_DEVICE_NET:
ret = qemuDomainDetachNetDevice(driver, vm, dev, qemuCaps); ret = qemuDomainDetachNetDevice(driver, vm, dev);
break; break;
case VIR_DOMAIN_DEVICE_HOSTDEV: case VIR_DOMAIN_DEVICE_HOSTDEV:
ret = qemuDomainDetachHostDevice(driver, vm, dev, qemuCaps); ret = qemuDomainDetachHostDevice(driver, vm, dev);
break; break;
default: default:
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
@ -4008,7 +4002,6 @@ static int
qemuDomainChangeDiskMediaLive(virDomainObjPtr vm, qemuDomainChangeDiskMediaLive(virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev,
struct qemud_driver *driver, struct qemud_driver *driver,
virBitmapPtr qemuCaps,
bool force) bool force)
{ {
virDomainDiskDefPtr disk = dev->data.disk; virDomainDiskDefPtr disk = dev->data.disk;
@ -4030,7 +4023,7 @@ qemuDomainChangeDiskMediaLive(virDomainObjPtr vm,
switch (disk->device) { switch (disk->device) {
case VIR_DOMAIN_DISK_DEVICE_CDROM: case VIR_DOMAIN_DISK_DEVICE_CDROM:
case VIR_DOMAIN_DISK_DEVICE_FLOPPY: case VIR_DOMAIN_DISK_DEVICE_FLOPPY:
ret = qemuDomainChangeEjectableMedia(driver, vm, disk, qemuCaps, force); ret = qemuDomainChangeEjectableMedia(driver, vm, disk, force);
if (ret == 0) if (ret == 0)
dev->data.disk = NULL; dev->data.disk = NULL;
break; break;
@ -4056,7 +4049,6 @@ static int
qemuDomainUpdateDeviceLive(virDomainObjPtr vm, qemuDomainUpdateDeviceLive(virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev,
virDomainPtr dom, virDomainPtr dom,
virBitmapPtr qemuCaps,
bool force) bool force)
{ {
struct qemud_driver *driver = dom->conn->privateData; struct qemud_driver *driver = dom->conn->privateData;
@ -4064,7 +4056,7 @@ qemuDomainUpdateDeviceLive(virDomainObjPtr vm,
switch (dev->type) { switch (dev->type) {
case VIR_DOMAIN_DEVICE_DISK: case VIR_DOMAIN_DEVICE_DISK:
ret = qemuDomainChangeDiskMediaLive(vm, dev, driver, qemuCaps, force); ret = qemuDomainChangeDiskMediaLive(vm, dev, driver, force);
break; break;
case VIR_DOMAIN_DEVICE_GRAPHICS: case VIR_DOMAIN_DEVICE_GRAPHICS:
ret = qemuDomainChangeGraphics(driver, vm, dev->data.graphics); ret = qemuDomainChangeGraphics(driver, vm, dev->data.graphics);
@ -4202,7 +4194,6 @@ qemuDomainModifyDeviceFlags(virDomainPtr dom, const char *xml,
unsigned int flags, int action) unsigned int flags, int action)
{ {
struct qemud_driver *driver = dom->conn->privateData; struct qemud_driver *driver = dom->conn->privateData;
virBitmapPtr qemuCaps = NULL;
virDomainObjPtr vm = NULL; virDomainObjPtr vm = NULL;
virDomainDefPtr vmdef = NULL; virDomainDefPtr vmdef = NULL;
virDomainDeviceDefPtr dev = NULL; virDomainDeviceDefPtr dev = NULL;
@ -4253,11 +4244,6 @@ qemuDomainModifyDeviceFlags(virDomainPtr dom, const char *xml,
if (dev == NULL) if (dev == NULL)
goto endjob; goto endjob;
if (qemuCapsExtractVersionInfo(vm->def->emulator, vm->def->os.arch,
NULL,
&qemuCaps) < 0)
goto endjob;
if (flags & VIR_DOMAIN_DEVICE_MODIFY_CONFIG) { if (flags & VIR_DOMAIN_DEVICE_MODIFY_CONFIG) {
/* Make a copy for updated domain. */ /* Make a copy for updated domain. */
vmdef = virDomainObjCopyPersistentDef(driver->caps, vm); vmdef = virDomainObjCopyPersistentDef(driver->caps, vm);
@ -4284,13 +4270,13 @@ qemuDomainModifyDeviceFlags(virDomainPtr dom, const char *xml,
if (!ret && (flags & VIR_DOMAIN_DEVICE_MODIFY_LIVE)) { if (!ret && (flags & VIR_DOMAIN_DEVICE_MODIFY_LIVE)) {
switch (action) { switch (action) {
case QEMU_DEVICE_ATTACH: case QEMU_DEVICE_ATTACH:
ret = qemuDomainAttachDeviceLive(vm, dev, dom, qemuCaps); ret = qemuDomainAttachDeviceLive(vm, dev, dom);
break; break;
case QEMU_DEVICE_DETACH: case QEMU_DEVICE_DETACH:
ret = qemuDomainDetachDeviceLive(vm, dev, dom, qemuCaps); ret = qemuDomainDetachDeviceLive(vm, dev, dom);
break; break;
case QEMU_DEVICE_UPDATE: case QEMU_DEVICE_UPDATE:
ret = qemuDomainUpdateDeviceLive(vm, dev, dom, qemuCaps, force); ret = qemuDomainUpdateDeviceLive(vm, dev, dom, force);
break; break;
default: default:
qemuReportError(VIR_ERR_INTERNAL_ERROR, qemuReportError(VIR_ERR_INTERNAL_ERROR,
@ -4319,7 +4305,6 @@ endjob:
vm = NULL; vm = NULL;
cleanup: cleanup:
qemuCapsFree(qemuCaps);
virDomainDefFree(vmdef); virDomainDefFree(vmdef);
virDomainDeviceDefFree(dev); virDomainDeviceDefFree(dev);
if (vm) if (vm)

185
src/qemu/qemu_hotplug.c
View File

@ -44,14 +44,13 @@
int qemuDomainChangeEjectableMedia(struct qemud_driver *driver, int qemuDomainChangeEjectableMedia(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDiskDefPtr disk, virDomainDiskDefPtr disk,
virBitmapPtr qemuCaps,
bool force) bool force)
{ {
virDomainDiskDefPtr origdisk = NULL; virDomainDiskDefPtr origdisk = NULL;
int i; int i;
int ret; int ret;
char *driveAlias = NULL; char *driveAlias = NULL;
qemuDomainObjPrivatePtr priv; qemuDomainObjPrivatePtr priv = vm->privateData;
for (i = 0 ; i < vm->def->ndisks ; i++) { for (i = 0 ; i < vm->def->ndisks ; i++) {
if (vm->def->disks[i]->bus == disk->bus && if (vm->def->disks[i]->bus == disk->bus &&
@ -87,10 +86,9 @@ int qemuDomainChangeEjectableMedia(struct qemud_driver *driver,
vm, disk) < 0) vm, disk) < 0)
return -1; return -1;
if (!(driveAlias = qemuDeviceDriveHostAlias(origdisk, qemuCaps))) if (!(driveAlias = qemuDeviceDriveHostAlias(origdisk, priv->qemuCaps)))
goto error; goto error;
priv = vm->privateData;
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (disk->src) { if (disk->src) {
const char *format = NULL; const char *format = NULL;
@ -139,8 +137,7 @@ error:
int qemuDomainAttachPciDiskDevice(struct qemud_driver *driver, int qemuDomainAttachPciDiskDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDiskDefPtr disk, virDomainDiskDefPtr disk)
virBitmapPtr qemuCaps)
{ {
int i, ret; int i, ret;
const char* type = virDomainDiskBusTypeToString(disk->bus); const char* type = virDomainDiskBusTypeToString(disk->bus);
@ -161,17 +158,17 @@ int qemuDomainAttachPciDiskDevice(struct qemud_driver *driver,
vm, disk) < 0) vm, disk) < 0)
return -1; return -1;
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &disk->info) < 0) if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &disk->info) < 0)
goto error; goto error;
releaseaddr = true; releaseaddr = true;
if (qemuAssignDeviceDiskAlias(disk, qemuCaps) < 0) if (qemuAssignDeviceDiskAlias(disk, priv->qemuCaps) < 0)
goto error; goto error;
if (!(drivestr = qemuBuildDriveStr(disk, 0, qemuCaps))) if (!(drivestr = qemuBuildDriveStr(disk, 0, priv->qemuCaps)))
goto error; goto error;
if (!(devstr = qemuBuildDriveDevStr(disk, qemuCaps))) if (!(devstr = qemuBuildDriveDevStr(disk, priv->qemuCaps)))
goto error; goto error;
} }
@ -181,7 +178,7 @@ int qemuDomainAttachPciDiskDevice(struct qemud_driver *driver,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDrive(priv->mon, drivestr); ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) { if (ret == 0) {
ret = qemuMonitorAddDevice(priv->mon, devstr); ret = qemuMonitorAddDevice(priv->mon, devstr);
@ -221,7 +218,7 @@ error:
VIR_FREE(devstr); VIR_FREE(devstr);
VIR_FREE(drivestr); VIR_FREE(drivestr);
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE) && if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
(disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) && (disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
releaseaddr && releaseaddr &&
qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &disk->info) < 0) qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &disk->info) < 0)
@ -237,8 +234,7 @@ error:
int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver, int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainControllerDefPtr controller, virDomainControllerDefPtr controller)
virBitmapPtr qemuCaps)
{ {
int i; int i;
int ret = -1; int ret = -1;
@ -257,14 +253,14 @@ int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
} }
} }
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &controller->info) < 0) if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &controller->info) < 0)
goto cleanup; goto cleanup;
releaseaddr = true; releaseaddr = true;
if (qemuAssignDeviceControllerAlias(controller) < 0) if (qemuAssignDeviceControllerAlias(controller) < 0)
goto cleanup; goto cleanup;
if (!(devstr = qemuBuildControllerDevStr(controller, qemuCaps))) { if (!(devstr = qemuBuildControllerDevStr(controller, priv->qemuCaps))) {
goto cleanup; goto cleanup;
} }
} }
@ -275,7 +271,7 @@ int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDevice(priv->mon, devstr); ret = qemuMonitorAddDevice(priv->mon, devstr);
} else { } else {
ret = qemuMonitorAttachPCIDiskController(priv->mon, ret = qemuMonitorAttachPCIDiskController(priv->mon,
@ -291,7 +287,7 @@ int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
cleanup: cleanup:
if ((ret != 0) && if ((ret != 0) &&
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE) && qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
(controller->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) && (controller->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
releaseaddr && releaseaddr &&
qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &controller->info) < 0) qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &controller->info) < 0)
@ -305,11 +301,11 @@ cleanup:
static virDomainControllerDefPtr static virDomainControllerDefPtr
qemuDomainFindOrCreateSCSIDiskController(struct qemud_driver *driver, qemuDomainFindOrCreateSCSIDiskController(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
int controller, int controller)
virBitmapPtr qemuCaps)
{ {
int i; int i;
virDomainControllerDefPtr cont; virDomainControllerDefPtr cont;
for (i = 0 ; i < vm->def->ncontrollers ; i++) { for (i = 0 ; i < vm->def->ncontrollers ; i++) {
cont = vm->def->controllers[i]; cont = vm->def->controllers[i];
@ -332,7 +328,7 @@ qemuDomainFindOrCreateSCSIDiskController(struct qemud_driver *driver,
VIR_INFO0("No SCSI controller present, hotplugging one"); VIR_INFO0("No SCSI controller present, hotplugging one");
if (qemuDomainAttachPciControllerDevice(driver, if (qemuDomainAttachPciControllerDevice(driver,
vm, cont, qemuCaps) < 0) { vm, cont) < 0) {
VIR_FREE(cont); VIR_FREE(cont);
return NULL; return NULL;
} }
@ -351,8 +347,7 @@ qemuDomainFindOrCreateSCSIDiskController(struct qemud_driver *driver,
int qemuDomainAttachSCSIDisk(struct qemud_driver *driver, int qemuDomainAttachSCSIDisk(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDiskDefPtr disk, virDomainDiskDefPtr disk)
virBitmapPtr qemuCaps)
{ {
int i; int i;
qemuDomainObjPrivatePtr priv = vm->privateData; qemuDomainObjPrivatePtr priv = vm->privateData;
@ -382,18 +377,18 @@ int qemuDomainAttachSCSIDisk(struct qemud_driver *driver,
goto error; goto error;
} }
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceDiskAlias(disk, qemuCaps) < 0) if (qemuAssignDeviceDiskAlias(disk, priv->qemuCaps) < 0)
goto error; goto error;
if (!(devstr = qemuBuildDriveDevStr(disk, qemuCaps))) if (!(devstr = qemuBuildDriveDevStr(disk, priv->qemuCaps)))
goto error; goto error;
} }
if (!(drivestr = qemuBuildDriveStr(disk, 0, qemuCaps))) if (!(drivestr = qemuBuildDriveStr(disk, 0, priv->qemuCaps)))
goto error; goto error;
for (i = 0 ; i <= disk->info.addr.drive.controller ; i++) { for (i = 0 ; i <= disk->info.addr.drive.controller ; i++) {
cont = qemuDomainFindOrCreateSCSIDiskController(driver, vm, i, qemuCaps); cont = qemuDomainFindOrCreateSCSIDiskController(driver, vm, i);
if (!cont) if (!cont)
goto error; goto error;
} }
@ -415,7 +410,7 @@ int qemuDomainAttachSCSIDisk(struct qemud_driver *driver,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDrive(priv->mon, drivestr); ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) { if (ret == 0) {
ret = qemuMonitorAddDevice(priv->mon, devstr); ret = qemuMonitorAddDevice(priv->mon, devstr);
@ -467,8 +462,7 @@ error:
int qemuDomainAttachUsbMassstorageDevice(struct qemud_driver *driver, int qemuDomainAttachUsbMassstorageDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDiskDefPtr disk, virDomainDiskDefPtr disk)
virBitmapPtr qemuCaps)
{ {
qemuDomainObjPrivatePtr priv = vm->privateData; qemuDomainObjPrivatePtr priv = vm->privateData;
int i, ret; int i, ret;
@ -493,12 +487,12 @@ int qemuDomainAttachUsbMassstorageDevice(struct qemud_driver *driver,
goto error; goto error;
} }
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceDiskAlias(disk, qemuCaps) < 0) if (qemuAssignDeviceDiskAlias(disk, priv->qemuCaps) < 0)
goto error; goto error;
if (!(drivestr = qemuBuildDriveStr(disk, 0, qemuCaps))) if (!(drivestr = qemuBuildDriveStr(disk, 0, priv->qemuCaps)))
goto error; goto error;
if (!(devstr = qemuBuildDriveDevStr(disk, qemuCaps))) if (!(devstr = qemuBuildDriveDevStr(disk, priv->qemuCaps)))
goto error; goto error;
} }
@ -508,7 +502,7 @@ int qemuDomainAttachUsbMassstorageDevice(struct qemud_driver *driver,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDrive(priv->mon, drivestr); ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) { if (ret == 0) {
ret = qemuMonitorAddDevice(priv->mon, devstr); ret = qemuMonitorAddDevice(priv->mon, devstr);
@ -552,8 +546,7 @@ error:
int qemuDomainAttachNetDevice(virConnectPtr conn, int qemuDomainAttachNetDevice(virConnectPtr conn,
struct qemud_driver *driver, struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainNetDefPtr net, virDomainNetDefPtr net)
virBitmapPtr qemuCaps)
{ {
qemuDomainObjPrivatePtr priv = vm->privateData; qemuDomainObjPrivatePtr priv = vm->privateData;
char *tapfd_name = NULL; char *tapfd_name = NULL;
@ -567,7 +560,7 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
int vlan; int vlan;
bool releaseaddr = false; bool releaseaddr = false;
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_HOST_NET_ADD)) { if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_HOST_NET_ADD)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("installed qemu version does not support host_net_add")); _("installed qemu version does not support host_net_add"));
return -1; return -1;
@ -576,36 +569,36 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
if (net->type == VIR_DOMAIN_NET_TYPE_BRIDGE || if (net->type == VIR_DOMAIN_NET_TYPE_BRIDGE ||
net->type == VIR_DOMAIN_NET_TYPE_NETWORK) { net->type == VIR_DOMAIN_NET_TYPE_NETWORK) {
if ((tapfd = qemuNetworkIfaceConnect(vm->def, conn, driver, net, if ((tapfd = qemuNetworkIfaceConnect(vm->def, conn, driver, net,
qemuCaps)) < 0) priv->qemuCaps)) < 0)
return -1; return -1;
if (qemuOpenVhostNet(vm->def, net, qemuCaps, &vhostfd) < 0) if (qemuOpenVhostNet(vm->def, net, priv->qemuCaps, &vhostfd) < 0)
goto cleanup; goto cleanup;
} else if (net->type == VIR_DOMAIN_NET_TYPE_DIRECT) { } else if (net->type == VIR_DOMAIN_NET_TYPE_DIRECT) {
if ((tapfd = qemuPhysIfaceConnect(vm->def, conn, driver, net, if ((tapfd = qemuPhysIfaceConnect(vm->def, conn, driver, net,
qemuCaps, priv->qemuCaps,
VIR_VM_OP_CREATE)) < 0) VIR_VM_OP_CREATE)) < 0)
return -1; return -1;
if (qemuOpenVhostNet(vm->def, net, qemuCaps, &vhostfd) < 0) if (qemuOpenVhostNet(vm->def, net, priv->qemuCaps, &vhostfd) < 0)
goto cleanup; goto cleanup;
} }
if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets+1) < 0) if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets+1) < 0)
goto no_memory; goto no_memory;
if (qemuCapsGet(qemuCaps, QEMU_CAPS_NET_NAME) || if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NET_NAME) ||
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceNetAlias(vm->def, net, -1) < 0) if (qemuAssignDeviceNetAlias(vm->def, net, -1) < 0)
goto cleanup; goto cleanup;
} }
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE) && if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &net->info) < 0) qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &net->info) < 0)
goto cleanup; goto cleanup;
releaseaddr = true; releaseaddr = true;
if (qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) && if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
vlan = -1; vlan = -1;
} else { } else {
vlan = qemuDomainNetVLAN(net); vlan = qemuDomainNetVLAN(net);
@ -627,8 +620,8 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
goto no_memory; goto no_memory;
} }
if (qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) && if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (!(netstr = qemuBuildHostNetStr(net, ',', if (!(netstr = qemuBuildHostNetStr(net, ',',
-1, tapfd_name, vhostfd_name))) -1, tapfd_name, vhostfd_name)))
goto cleanup; goto cleanup;
@ -639,8 +632,8 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) && if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorAddNetdev(priv->mon, netstr, tapfd, tapfd_name, if (qemuMonitorAddNetdev(priv->mon, netstr, tapfd, tapfd_name,
vhostfd, vhostfd_name) < 0) { vhostfd, vhostfd_name) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm); qemuDomainObjExitMonitorWithDriver(driver, vm);
@ -666,8 +659,8 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
goto cleanup; goto cleanup;
} }
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (!(nicstr = qemuBuildNicDevStr(net, vlan, qemuCaps))) if (!(nicstr = qemuBuildNicDevStr(net, vlan, priv->qemuCaps)))
goto try_remove; goto try_remove;
} else { } else {
if (!(nicstr = qemuBuildNicStr(net, NULL, vlan))) if (!(nicstr = qemuBuildNicStr(net, NULL, vlan)))
@ -675,7 +668,7 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorAddDevice(priv->mon, nicstr) < 0) { if (qemuMonitorAddDevice(priv->mon, nicstr) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm); qemuDomainObjExitMonitorWithDriver(driver, vm);
qemuAuditNet(vm, NULL, net, "attach", false); qemuAuditNet(vm, NULL, net, "attach", false);
@ -701,7 +694,7 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
cleanup: cleanup:
if ((ret != 0) && if ((ret != 0) &&
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE) && qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
(net->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) && (net->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
releaseaddr && releaseaddr &&
qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &net->info) < 0) qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &net->info) < 0)
@ -724,8 +717,8 @@ try_remove:
goto cleanup; goto cleanup;
if (vlan < 0) { if (vlan < 0) {
if (qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) && if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
char *netdev_name; char *netdev_name;
if (virAsprintf(&netdev_name, "host%s", net->info.alias) < 0) if (virAsprintf(&netdev_name, "host%s", net->info.alias) < 0)
goto no_memory; goto no_memory;
@ -759,8 +752,7 @@ no_memory:
int qemuDomainAttachHostPciDevice(struct qemud_driver *driver, int qemuDomainAttachHostPciDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainHostdevDefPtr hostdev, virDomainHostdevDefPtr hostdev)
virBitmapPtr qemuCaps)
{ {
qemuDomainObjPrivatePtr priv = vm->privateData; qemuDomainObjPrivatePtr priv = vm->privateData;
int ret; int ret;
@ -777,13 +769,13 @@ int qemuDomainAttachHostPciDevice(struct qemud_driver *driver,
if (qemuPrepareHostdevPCIDevices(driver, &hostdev, 1) < 0) if (qemuPrepareHostdevPCIDevices(driver, &hostdev, 1) < 0)
return -1; return -1;
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0) if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0)
goto error; goto error;
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &hostdev->info) < 0) if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &hostdev->info) < 0)
goto error; goto error;
releaseaddr = true; releaseaddr = true;
if (qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_CONFIGFD)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_PCI_CONFIGFD)) {
configfd = qemuOpenPCIConfig(hostdev); configfd = qemuOpenPCIConfig(hostdev);
if (configfd >= 0) { if (configfd >= 0) {
if (virAsprintf(&configfd_name, "fd-%s", if (virAsprintf(&configfd_name, "fd-%s",
@ -801,7 +793,7 @@ int qemuDomainAttachHostPciDevice(struct qemud_driver *driver,
} }
if (!(devstr = qemuBuildPCIHostdevDevStr(hostdev, configfd_name, if (!(devstr = qemuBuildPCIHostdevDevStr(hostdev, configfd_name,
qemuCaps))) priv->qemuCaps)))
goto error; goto error;
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
@ -833,7 +825,7 @@ int qemuDomainAttachHostPciDevice(struct qemud_driver *driver,
return 0; return 0;
error: error:
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE) && if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
(hostdev->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) && (hostdev->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
releaseaddr && releaseaddr &&
qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &hostdev->info) < 0) qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &hostdev->info) < 0)
@ -851,14 +843,13 @@ error:
int qemuDomainAttachHostUsbDevice(struct qemud_driver *driver, int qemuDomainAttachHostUsbDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainHostdevDefPtr hostdev, virDomainHostdevDefPtr hostdev)
virBitmapPtr qemuCaps)
{ {
int ret; int ret;
qemuDomainObjPrivatePtr priv = vm->privateData; qemuDomainObjPrivatePtr priv = vm->privateData;
char *devstr = NULL; char *devstr = NULL;
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0) if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0)
goto error; goto error;
if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev))) if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev)))
@ -893,7 +884,7 @@ int qemuDomainAttachHostUsbDevice(struct qemud_driver *driver,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE))
ret = qemuMonitorAddDevice(priv->mon, devstr); ret = qemuMonitorAddDevice(priv->mon, devstr);
else else
ret = qemuMonitorAddUSBDeviceExact(priv->mon, ret = qemuMonitorAddUSBDeviceExact(priv->mon,
@ -918,8 +909,7 @@ error:
int qemuDomainAttachHostDevice(struct qemud_driver *driver, int qemuDomainAttachHostDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainHostdevDefPtr hostdev, virDomainHostdevDefPtr hostdev)
virBitmapPtr qemuCaps)
{ {
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) { if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
@ -952,13 +942,13 @@ int qemuDomainAttachHostDevice(struct qemud_driver *driver,
switch (hostdev->source.subsys.type) { switch (hostdev->source.subsys.type) {
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI: case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
if (qemuDomainAttachHostPciDevice(driver, vm, if (qemuDomainAttachHostPciDevice(driver, vm,
hostdev, qemuCaps) < 0) hostdev) < 0)
goto error; goto error;
break; break;
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB: case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
if (qemuDomainAttachHostUsbDevice(driver, vm, if (qemuDomainAttachHostUsbDevice(driver, vm,
hostdev, qemuCaps) < 0) hostdev) < 0)
goto error; goto error;
break; break;
@ -1113,8 +1103,7 @@ static inline int qemuFindDisk(virDomainDefPtr def, const char *dst)
int qemuDomainDetachPciDiskDevice(struct qemud_driver *driver, int qemuDomainDetachPciDiskDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev)
virBitmapPtr qemuCaps)
{ {
int i, ret = -1; int i, ret = -1;
virDomainDiskDefPtr detach = NULL; virDomainDiskDefPtr detach = NULL;
@ -1157,7 +1146,7 @@ int qemuDomainDetachPciDiskDevice(struct qemud_driver *driver,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) { if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
qemuDomainObjExitMonitor(vm); qemuDomainObjExitMonitor(vm);
goto cleanup; goto cleanup;
@ -1177,7 +1166,7 @@ int qemuDomainDetachPciDiskDevice(struct qemud_driver *driver,
qemuAuditDisk(vm, detach, NULL, "detach", ret >= 0); qemuAuditDisk(vm, detach, NULL, "detach", ret >= 0);
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE) && if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0) qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0)
VIR_WARN("Unable to release PCI address on %s", dev->data.disk->src); VIR_WARN("Unable to release PCI address on %s", dev->data.disk->src);
@ -1204,8 +1193,7 @@ cleanup:
int qemuDomainDetachDiskDevice(struct qemud_driver *driver, int qemuDomainDetachDiskDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev)
virBitmapPtr qemuCaps)
{ {
int i, ret = -1; int i, ret = -1;
virDomainDiskDefPtr detach = NULL; virDomainDiskDefPtr detach = NULL;
@ -1221,7 +1209,7 @@ int qemuDomainDetachDiskDevice(struct qemud_driver *driver,
goto cleanup; goto cleanup;
} }
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
qemuReportError(VIR_ERR_OPERATION_FAILED, qemuReportError(VIR_ERR_OPERATION_FAILED,
_("Underlying qemu does not support %s disk removal"), _("Underlying qemu does not support %s disk removal"),
virDomainDiskBusTypeToString(dev->data.disk->bus)); virDomainDiskBusTypeToString(dev->data.disk->bus));
@ -1334,8 +1322,7 @@ static bool qemuDomainControllerIsBusy(virDomainObjPtr vm,
int qemuDomainDetachPciControllerDevice(struct qemud_driver *driver, int qemuDomainDetachPciControllerDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev)
virBitmapPtr qemuCaps)
{ {
int i, ret = -1; int i, ret = -1;
virDomainControllerDefPtr detach = NULL; virDomainControllerDefPtr detach = NULL;
@ -1370,13 +1357,13 @@ int qemuDomainDetachPciControllerDevice(struct qemud_driver *driver,
goto cleanup; goto cleanup;
} }
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceControllerAlias(detach) < 0) if (qemuAssignDeviceControllerAlias(detach) < 0)
goto cleanup; goto cleanup;
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias)) { if (qemuMonitorDelDevice(priv->mon, detach->info.alias)) {
qemuDomainObjExitMonitor(vm); qemuDomainObjExitMonitor(vm);
goto cleanup; goto cleanup;
@ -1404,7 +1391,7 @@ int qemuDomainDetachPciControllerDevice(struct qemud_driver *driver,
vm->def->ncontrollers = 0; vm->def->ncontrollers = 0;
} }
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE) && if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0) qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0)
VIR_WARN0("Unable to release PCI address on controller"); VIR_WARN0("Unable to release PCI address on controller");
@ -1418,8 +1405,7 @@ cleanup:
int qemuDomainDetachNetDevice(struct qemud_driver *driver, int qemuDomainDetachNetDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev)
virBitmapPtr qemuCaps)
{ {
int i, ret = -1; int i, ret = -1;
virDomainNetDefPtr detach = NULL; virDomainNetDefPtr detach = NULL;
@ -1464,7 +1450,7 @@ int qemuDomainDetachNetDevice(struct qemud_driver *driver,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) { if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
qemuDomainObjExitMonitor(vm); qemuDomainObjExitMonitor(vm);
qemuAuditNet(vm, detach, NULL, "detach", false); qemuAuditNet(vm, detach, NULL, "detach", false);
@ -1479,8 +1465,8 @@ int qemuDomainDetachNetDevice(struct qemud_driver *driver,
} }
} }
if (qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) && if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorRemoveNetdev(priv->mon, hostnet_name) < 0) { if (qemuMonitorRemoveNetdev(priv->mon, hostnet_name) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm); qemuDomainObjExitMonitorWithDriver(driver, vm);
qemuAuditNet(vm, detach, NULL, "detach", false); qemuAuditNet(vm, detach, NULL, "detach", false);
@ -1497,7 +1483,7 @@ int qemuDomainDetachNetDevice(struct qemud_driver *driver,
qemuAuditNet(vm, detach, NULL, "detach", true); qemuAuditNet(vm, detach, NULL, "detach", true);
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE) && if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0) qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0)
VIR_WARN0("Unable to release PCI address on NIC"); VIR_WARN0("Unable to release PCI address on NIC");
@ -1545,8 +1531,7 @@ cleanup:
int qemuDomainDetachHostPciDevice(struct qemud_driver *driver, int qemuDomainDetachHostPciDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev)
virBitmapPtr qemuCaps)
{ {
virDomainHostdevDefPtr detach = NULL; virDomainHostdevDefPtr detach = NULL;
qemuDomainObjPrivatePtr priv = vm->privateData; qemuDomainObjPrivatePtr priv = vm->privateData;
@ -1590,7 +1575,7 @@ int qemuDomainDetachHostPciDevice(struct qemud_driver *driver,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorDelDevice(priv->mon, detach->info.alias); ret = qemuMonitorDelDevice(priv->mon, detach->info.alias);
} else { } else {
ret = qemuMonitorRemovePCIDevice(priv->mon, &detach->info.addr.pci); ret = qemuMonitorRemovePCIDevice(priv->mon, &detach->info.addr.pci);
@ -1615,7 +1600,7 @@ int qemuDomainDetachHostPciDevice(struct qemud_driver *driver,
pciFreeDevice(pci); pciFreeDevice(pci);
} }
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE) && if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0) qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0)
VIR_WARN0("Unable to release PCI address on host device"); VIR_WARN0("Unable to release PCI address on host device");
@ -1639,8 +1624,7 @@ int qemuDomainDetachHostPciDevice(struct qemud_driver *driver,
int qemuDomainDetachHostUsbDevice(struct qemud_driver *driver, int qemuDomainDetachHostUsbDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev)
virBitmapPtr qemuCaps)
{ {
virDomainHostdevDefPtr detach = NULL; virDomainHostdevDefPtr detach = NULL;
qemuDomainObjPrivatePtr priv = vm->privateData; qemuDomainObjPrivatePtr priv = vm->privateData;
@ -1686,7 +1670,7 @@ int qemuDomainDetachHostUsbDevice(struct qemud_driver *driver,
return -1; return -1;
} }
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
qemuReportError(VIR_ERR_OPERATION_FAILED, qemuReportError(VIR_ERR_OPERATION_FAILED,
"%s", _("device cannot be detached with this QEMU version")); "%s", _("device cannot be detached with this QEMU version"));
return -1; return -1;
@ -1719,8 +1703,7 @@ int qemuDomainDetachHostUsbDevice(struct qemud_driver *driver,
int qemuDomainDetachHostDevice(struct qemud_driver *driver, int qemuDomainDetachHostDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev)
virBitmapPtr qemuCaps)
{ {
virDomainHostdevDefPtr hostdev = dev->data.hostdev; virDomainHostdevDefPtr hostdev = dev->data.hostdev;
int ret; int ret;
@ -1734,10 +1717,10 @@ int qemuDomainDetachHostDevice(struct qemud_driver *driver,
switch (hostdev->source.subsys.type) { switch (hostdev->source.subsys.type) {
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI: case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
ret = qemuDomainDetachHostPciDevice(driver, vm, dev, qemuCaps); ret = qemuDomainDetachHostPciDevice(driver, vm, dev);
break; break;
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB: case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
ret = qemuDomainDetachHostUsbDevice(driver, vm, dev, qemuCaps); ret = qemuDomainDetachHostUsbDevice(driver, vm, dev);
break; break;
default: default:
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,

46
src/qemu/qemu_hotplug.h
View File

@ -30,41 +30,32 @@
int qemuDomainChangeEjectableMedia(struct qemud_driver *driver, int qemuDomainChangeEjectableMedia(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDiskDefPtr disk, virDomainDiskDefPtr disk,
virBitmapPtr qemuCaps,
bool force); bool force);
int qemuDomainAttachPciDiskDevice(struct qemud_driver *driver, int qemuDomainAttachPciDiskDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDiskDefPtr disk, virDomainDiskDefPtr disk);
virBitmapPtr qemuCaps);
int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver, int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainControllerDefPtr controller, virDomainControllerDefPtr controller);
virBitmapPtr qemuCaps);
int qemuDomainAttachSCSIDisk(struct qemud_driver *driver, int qemuDomainAttachSCSIDisk(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDiskDefPtr disk, virDomainDiskDefPtr disk);
virBitmapPtr qemuCaps);
int qemuDomainAttachUsbMassstorageDevice(struct qemud_driver *driver, int qemuDomainAttachUsbMassstorageDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDiskDefPtr disk, virDomainDiskDefPtr disk);
virBitmapPtr qemuCaps);
int qemuDomainAttachNetDevice(virConnectPtr conn, int qemuDomainAttachNetDevice(virConnectPtr conn,
struct qemud_driver *driver, struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainNetDefPtr net, virDomainNetDefPtr net);
virBitmapPtr qemuCaps);
int qemuDomainAttachHostPciDevice(struct qemud_driver *driver, int qemuDomainAttachHostPciDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainHostdevDefPtr hostdev, virDomainHostdevDefPtr hostdev);
virBitmapPtr qemuCaps);
int qemuDomainAttachHostUsbDevice(struct qemud_driver *driver, int qemuDomainAttachHostUsbDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainHostdevDefPtr hostdev, virDomainHostdevDefPtr hostdev);
virBitmapPtr qemuCaps);
int qemuDomainAttachHostDevice(struct qemud_driver *driver, int qemuDomainAttachHostDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainHostdevDefPtr hostdev, virDomainHostdevDefPtr hostdev);
virBitmapPtr qemuCaps);
int qemuDomainChangeGraphics(struct qemud_driver *driver, int qemuDomainChangeGraphics(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainGraphicsDefPtr dev); virDomainGraphicsDefPtr dev);
@ -75,32 +66,25 @@ int qemuDomainChangeGraphicsPasswords(struct qemud_driver *driver,
const char *defaultPasswd); const char *defaultPasswd);
int qemuDomainDetachPciDiskDevice(struct qemud_driver *driver, int qemuDomainDetachPciDiskDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev);
virBitmapPtr qemuCaps);
int qemuDomainDetachDiskDevice(struct qemud_driver *driver, int qemuDomainDetachDiskDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev);
virBitmapPtr qemuCaps);
int qemuDomainDetachPciControllerDevice(struct qemud_driver *driver, int qemuDomainDetachPciControllerDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev);
virBitmapPtr qemuCaps);
int qemuDomainDetachNetDevice(struct qemud_driver *driver, int qemuDomainDetachNetDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev);
virBitmapPtr qemuCaps);
int qemuDomainDetachHostPciDevice(struct qemud_driver *driver, int qemuDomainDetachHostPciDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev);
virBitmapPtr qemuCaps);
int qemuDomainDetachHostUsbDevice(struct qemud_driver *driver, int qemuDomainDetachHostUsbDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev);
virBitmapPtr qemuCaps);
int qemuDomainDetachHostDevice(struct qemud_driver *driver, int qemuDomainDetachHostDevice(struct qemud_driver *driver,
virDomainObjPtr vm, virDomainObjPtr vm,
virDomainDeviceDefPtr dev, virDomainDeviceDefPtr dev);
virBitmapPtr qemuCaps);
#endif /* __QEMU_HOTPLUG_H__ */ #endif /* __QEMU_HOTPLUG_H__ */