All guest devices now use a common device address structure summarized by: enum virDomainDeviceAddressType { VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE, VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI, }; enum virDomainDeviceAddressMode { VIR_DOMAIN_DEVICE_ADDRESS_MODE_DYNAMIC, VIR_DOMAIN_DEVICE_ADDRESS_MODE_STATIC, }; struct _virDomainDevicePCIAddress { unsigned int domain; unsigned int bus; unsigned int slot; unsigned int function; }; struct _virDomainDeviceAddress { int type; int mode; union { virDomainDevicePCIAddress pci; } data; }; This replaces the anonymous structs in Disk/Net/Hostdev data structures. Where available, the address is *always* printed in the XML file, instead of being hidden in the internal state file. <address type='pci' mode='static' domain='0x0000' bus='0x1e' slot='0x07' function='0x0'/> A 'static' address is one assigned by the user, never changing, while a 'dynamic' address is one assigned on the fly by QEMU. 'dynamic' addresses are thrown away when a VM stops. The structure definition is based on Wolfgang Mauerer's disk controller patch series. --- src/conf/domain_conf.c | 432 ++++++++++++++++++++++++++++++++++----------- src/conf/domain_conf.h | 90 ++++++----- src/libvirt_private.syms | 5 + src/qemu/qemu_driver.c | 64 ++++--- 4 files changed, 418 insertions(+), 173 deletions(-) diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index dca2e49..975b62b 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -88,6 +88,14 @@ VIR_ENUM_IMPL(virDomainDevice, VIR_DOMAIN_DEVICE_LAST, "hostdev", "watchdog") +VIR_ENUM_IMPL(virDomainDeviceAddress, VIR_DOMAIN_DEVICE_ADDRESS_TYPE_LAST, + "none", + "pci") + +VIR_ENUM_IMPL(virDomainDeviceAddressMode, VIR_DOMAIN_DEVICE_ADDRESS_MODE_LAST, + "dynamic", + "static") + VIR_ENUM_IMPL(virDomainDisk, VIR_DOMAIN_DISK_TYPE_LAST, "block", "file", @@ -729,6 +737,245 @@ void virDomainRemoveInactive(virDomainObjListPtr doms, } +int virDomainDeviceAddressIsValid(virDomainDeviceAddressPtr addr, + int type) +{ + if (addr->type != type) + return 0; + + switch (addr->type) { + case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI: + return virDomainDevicePCIAddressIsValid(&addr->data.pci); + } + + return 0; +} + + +int virDomainDevicePCIAddressIsValid(virDomainDevicePCIAddressPtr addr) +{ + return addr->domain || addr->bus || addr->slot; +} + + +void virDomainDeviceAddressClear(virDomainDeviceAddressPtr addr) +{ + memset(addr, 0, sizeof(addr)); + addr->type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE; +} + + +/* Generate a string representation of a device address + * @param address Device address to stringify + */ +static int virDomainDeviceAddressFormat(virBufferPtr buf, + virDomainDeviceAddressPtr addr, + int flags) +{ + if (!addr) { + virDomainReportError(NULL, VIR_ERR_INTERNAL_ERROR, "%s", + _("missing address information")); + return -1; + } + + if (addr->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) + return 0; + + /* Don't output dynamically allocated addresses when doing inactive XML dump */ + if ((addr->mode == VIR_DOMAIN_DEVICE_ADDRESS_MODE_DYNAMIC) && + (flags & VIR_DOMAIN_XML_INACTIVE)) + return 0; + + /* We'll be in domain/devices/[device type]/ so 3 level indent */ + virBufferVSprintf(buf, " <address type='%s'", + virDomainDeviceAddressTypeToString(addr->type)); + virBufferVSprintf(buf, " mode='%s'", + virDomainDeviceAddressModeTypeToString(addr->mode)); + + switch (addr->type) { + case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI: + virBufferVSprintf(buf, " domain='0x%.4x' bus='0x%.2x' slot='0x%.2x' function='0x%.1x'", + addr->data.pci.domain, + addr->data.pci.bus, + addr->data.pci.slot, + addr->data.pci.function); + break; + + default: + virDomainReportError(NULL, VIR_ERR_INTERNAL_ERROR, + _("unknown address type '%d'"), addr->type); + return -1; + } + + virBufferAddLit(buf, "/>\n"); + + return 0; +} + +/* Compare two device addresses. Returns true if addresses are + * identical and false if the they differ (or are of different types) + * @param a, @para b Pointers to the addresses + */ +int virDomainDeviceAddressEqual(virDomainDeviceAddressPtr a, + virDomainDeviceAddressPtr b) +{ + if (!a || !b || a->type != b-> type) { + return 0; + } + + switch (a->type) { + case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI: + return virDomainDevicePCIAddressEqual(&a->data.pci, + &b->data.pci); + } + + return 0; +} + + +int virDomainDevicePCIAddressEqual(virDomainDevicePCIAddressPtr a, + virDomainDevicePCIAddressPtr b) +{ + if (a->domain == b->domain && + a->bus == b->bus && + a->slot == b->slot && + a->function == b->function) + return 1; + + return 0; +} + + +static int +virDomainDevicePCIAddressParseXML(virConnectPtr conn, + xmlNodePtr node, + virDomainDevicePCIAddressPtr addr) +{ + char *domain, *slot, *bus, *function; + int ret = -1; + + memset(addr, 0, sizeof(*addr)); + + domain = virXMLPropString(node, "domain"); + bus = virXMLPropString(node, "bus"); + slot = virXMLPropString(node, "slot"); + function = virXMLPropString(node, "function"); + + if (domain && + virStrToLong_ui(domain, NULL, 16, &addr->domain) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s", + _("Cannot parse <address> 'domain' attribute")); + goto cleanup; + } + + if (bus && + virStrToLong_ui(bus, NULL, 16, &addr->bus) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s", + _("Cannot parse <address> 'bus' attribute")); + goto cleanup; + } + + if (slot && + virStrToLong_ui(slot, NULL, 16, &addr->slot) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s", + _("Cannot parse <address> 'slot' attribute")); + goto cleanup; + } + + if (function && + virStrToLong_ui(function, NULL, 16, &addr->function) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s", + _("Cannot parse <address> 'function' attribute")); + goto cleanup; + } + + if (!virDomainDevicePCIAddressIsValid(addr)) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s", + _("Insufficient specification for PCI address")); + goto cleanup; + } + + ret = 0; + +cleanup: + VIR_FREE(domain); + VIR_FREE(bus); + VIR_FREE(slot); + VIR_FREE(function); + return ret; +} + + +/* Parse the XML definition for a device address + * @param node XML nodeset to parse for device address definition + */ +static int +virDomainDeviceAddressParseXML(virConnectPtr conn, + xmlNodePtr node, + virDomainDeviceAddressPtr addr, + int flags) +{ + char *type = NULL; + char *mode = NULL; + int ret = -1; + + memset(addr, 0, sizeof(*addr)); + + type = virXMLPropString(node, "type"); + mode = virXMLPropString(node, "mode"); + + if (type) { + if ((addr->type = virDomainDeviceAddressTypeFromString(type)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unknown address type '%s'"), type); + goto cleanup; + } + } else { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("No type specified for device address")); + goto cleanup; + } + + if (mode) { + if ((addr->mode = virDomainDeviceAddressModeTypeFromString(mode)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unknown address mode '%s'"), mode); + goto cleanup; + } + } else { + addr->mode = VIR_DOMAIN_DEVICE_ADDRESS_MODE_DYNAMIC; + } + + /* Dynamic addresses are only valid in the live config */ + if ((flags & VIR_DOMAIN_XML_INACTIVE) && + addr->mode == VIR_DOMAIN_DEVICE_ADDRESS_MODE_DYNAMIC) { + addr->type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE; + ret = 0; + goto cleanup; + } + + switch (addr->type) { + case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI: + if (virDomainDevicePCIAddressParseXML(conn, node, &addr->data.pci) < 0) + goto cleanup; + break; + + default: + /* Should not happen */ + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("Unknown device address type")); + goto cleanup; + } + + ret = 0; + +cleanup: + VIR_FREE(type); + VIR_FREE(mode); + return ret; +} + + /* Parse the XML definition for a disk * @param node XML nodeset to parse for disk definition */ @@ -747,6 +994,7 @@ virDomainDiskDefParseXML(virConnectPtr conn, char *bus = NULL; char *cachetag = NULL; char *devaddr = NULL; + xmlNodePtr addr = NULL; virStorageEncryptionPtr encryption = NULL; char *serial = NULL; @@ -827,6 +1075,9 @@ virDomainDiskDefParseXML(virConnectPtr conn, } else if ((serial == NULL) && (xmlStrEqual(cur->name, BAD_CAST "serial"))) { serial = (char *)xmlNodeGetContent(cur); + } else if ((addr == NULL) && + (xmlStrEqual(cur->name, BAD_CAST "address"))) { + addr = cur; } } cur = cur->next; @@ -926,15 +1177,20 @@ virDomainDiskDefParseXML(virConnectPtr conn, goto error; } - if (devaddr && - sscanf(devaddr, "%x:%x:%x", - &def->pci_addr.domain, - &def->pci_addr.bus, - &def->pci_addr.slot) < 3) { - virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, - _("Unable to parse devaddr parameter '%s'"), - devaddr); - goto error; + if (devaddr) { + if (sscanf(devaddr, "%x:%x:%x", + &def->addr.data.pci.domain, + &def->addr.data.pci.bus, + &def->addr.data.pci.slot) < 3) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("Unable to parse devaddr parameter '%s'"), + devaddr); + goto error; + } + def->addr.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI; + } else if (addr) { + if (virDomainDeviceAddressParseXML(conn, addr, &def->addr, flags) < 0) + goto error; } def->src = source; @@ -1083,6 +1339,7 @@ virDomainNetDefParseXML(virConnectPtr conn, char *hostnet_name = NULL; char *devaddr = NULL; char *vlan = NULL; + xmlNodePtr addr = NULL; if (VIR_ALLOC(def) < 0) { virReportOOMError(conn); @@ -1155,6 +1412,9 @@ virDomainNetDefParseXML(virConnectPtr conn, hostnet_name = virXMLPropString(cur, "hostnet"); devaddr = virXMLPropString(cur, "devaddr"); vlan = virXMLPropString(cur, "vlan"); + } else if ((addr == NULL) && + (xmlStrEqual(cur->name, BAD_CAST "address"))) { + addr = cur; } } cur = cur->next; @@ -1171,14 +1431,28 @@ virDomainNetDefParseXML(virConnectPtr conn, virCapabilitiesGenerateMac(caps, def->mac); } - if (devaddr && - sscanf(devaddr, "%x:%x:%x", - &def->pci_addr.domain, - &def->pci_addr.bus, - &def->pci_addr.slot) < 3) { - virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, - _("Unable to parse devaddr parameter '%s'"), - devaddr); + if (devaddr) { + if (sscanf(devaddr, "%x:%x:%x", + &def->addr.data.pci.domain, + &def->addr.data.pci.bus, + &def->addr.data.pci.slot) < 3) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("Unable to parse devaddr parameter '%s'"), + devaddr); + goto error; + } + def->addr.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI; + } else if (addr) { + if (virDomainDeviceAddressParseXML(conn, addr, &def->addr, flags) < 0) + goto error; + } + + /* XXX what about ISA/USB based NIC models - once we support + * them we should make sure address type is correct */ + if (def->addr.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE && + def->addr.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s", + _("Network interfaces must use 'pci' address type")); goto error; } @@ -2319,83 +2593,26 @@ virDomainHostdevSubsysPciDefParseXML(virConnectPtr conn, while (cur != NULL) { if (cur->type == XML_ELEMENT_NODE) { if (xmlStrEqual(cur->name, BAD_CAST "address")) { + virDomainDevicePCIAddressPtr addr = + &def->source.subsys.u.pci; - char *domain = virXMLPropString(cur, "domain"); - if (domain) { - if (virStrToLong_ui(domain, NULL, 0, - &def->source.subsys.u.pci.domain) < 0) { - virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, - _("cannot parse domain %s"), - domain); - VIR_FREE(domain); - goto out; - } - VIR_FREE(domain); - } - - char *bus = virXMLPropString(cur, "bus"); - if (bus) { - if (virStrToLong_ui(bus, NULL, 0, - &def->source.subsys.u.pci.bus) < 0) { - virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, - _("cannot parse bus %s"), bus); - VIR_FREE(bus); - goto out; - } - VIR_FREE(bus); - } else { - virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, - "%s", _("pci address needs bus id")); - goto out; - } - - char *slot = virXMLPropString(cur, "slot"); - if (slot) { - if (virStrToLong_ui(slot, NULL, 0, - &def->source.subsys.u.pci.slot) < 0) { - virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, - _("cannot parse slot %s"), - slot); - VIR_FREE(slot); - goto out; - } - VIR_FREE(slot); - } else { - virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, - "%s", _("pci address needs slot id")); - goto out; - } - - char *function = virXMLPropString(cur, "function"); - if (function) { - if (virStrToLong_ui(function, NULL, 0, - &def->source.subsys.u.pci.function) < 0) { - virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, - _("cannot parse function %s"), - function); - VIR_FREE(function); - goto out; - } - VIR_FREE(function); - } else { - virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s", - _("pci address needs function id")); + if (virDomainDevicePCIAddressParseXML(conn, cur, addr) < 0) goto out; - } } else if ((flags & VIR_DOMAIN_XML_INTERNAL_STATUS) && xmlStrEqual(cur->name, BAD_CAST "state")) { char *devaddr = virXMLPropString(cur, "devaddr"); if (devaddr && sscanf(devaddr, "%x:%x:%x", - &def->source.subsys.u.pci.guest_addr.domain, - &def->source.subsys.u.pci.guest_addr.bus, - &def->source.subsys.u.pci.guest_addr.slot) < 3) { + &def->addr.data.pci.domain, + &def->addr.data.pci.bus, + &def->addr.data.pci.slot) < 3) { virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, _("Unable to parse devaddr parameter '%s'"), devaddr); VIR_FREE(devaddr); goto out; } + def->addr.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI; } else { virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, _("unknown pci source type '%s'"), @@ -2473,6 +2690,9 @@ virDomainHostdevDefParseXML(virConnectPtr conn, if (virDomainHostdevSubsysPciDefParseXML(conn, cur, def, flags) < 0) goto error; } + } else if (xmlStrEqual(cur->name, BAD_CAST "address")) { + if (virDomainDeviceAddressParseXML(conn, cur, &def->addr, flags) < 0) + goto error; } else { virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, _("unknown node %s"), cur->name); @@ -2481,6 +2701,18 @@ virDomainHostdevDefParseXML(virConnectPtr conn, cur = cur->next; } + if (def->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) { + switch (def->source.subsys.type) { + case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI: + if (def->addr.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s", + _("PCI host devices must use 'pci' address type")); + goto error; + } + break; + } + } + cleanup: VIR_FREE(type); VIR_FREE(mode); @@ -3934,15 +4166,9 @@ virDomainDiskDefFormat(virConnectPtr conn, virStorageEncryptionFormat(conn, buf, def->encryption) < 0) return -1; - if (flags & VIR_DOMAIN_XML_INTERNAL_STATUS) { - virBufferAddLit(buf, " <state"); - if (virDiskHasValidPciAddr(def)) - virBufferVSprintf(buf, " devaddr='%.4x:%.2x:%.2x'", - def->pci_addr.domain, - def->pci_addr.bus, - def->pci_addr.slot); - virBufferAddLit(buf, "/>\n"); - } + if (def->addr.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE && + virDomainDeviceAddressFormat(buf, &def->addr, flags) < 0) + return -1; virBufferAddLit(buf, " </disk>\n"); @@ -4081,16 +4307,15 @@ virDomainNetDefFormat(virConnectPtr conn, virBufferEscapeString(buf, " nic='%s'", def->nic_name); if (def->hostnet_name) virBufferEscapeString(buf, " hostnet='%s'", def->hostnet_name); - if (virNetHasValidPciAddr(def)) - virBufferVSprintf(buf, " devaddr='%.4x:%.2x:%.2x'", - def->pci_addr.domain, - def->pci_addr.bus, - def->pci_addr.slot); if (def->vlan > 0) virBufferVSprintf(buf, " vlan='%d'", def->vlan); virBufferAddLit(buf, "/>\n"); } + if (def->addr.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE && + virDomainDeviceAddressFormat(buf, &def->addr, flags) < 0) + return -1; + virBufferAddLit(buf, " </interface>\n"); return 0; @@ -4499,25 +4724,20 @@ virDomainHostdevDefFormat(virConnectPtr conn, def->source.subsys.u.usb.bus, def->source.subsys.u.usb.device); } - } - if (def->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) { + } else if (def->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) { virBufferVSprintf(buf, " <address domain='0x%.4x' bus='0x%.2x' slot='0x%.2x' function='0x%.1x'/>\n", def->source.subsys.u.pci.domain, def->source.subsys.u.pci.bus, def->source.subsys.u.pci.slot, def->source.subsys.u.pci.function); - if (flags & VIR_DOMAIN_XML_INTERNAL_STATUS) { - virBufferAddLit(buf, " <state"); - if (virHostdevHasValidGuestAddr(def)) - virBufferVSprintf(buf, " devaddr='%.4x:%.2x:%.2x'", - def->source.subsys.u.pci.guest_addr.domain, - def->source.subsys.u.pci.guest_addr.bus, - def->source.subsys.u.pci.guest_addr.slot); - virBufferAddLit(buf, "/>\n"); - } } virBufferAddLit(buf, " </source>\n"); + + if (def->addr.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE && + virDomainDeviceAddressFormat(buf, &def->addr, flags) < 0) + return -1; + virBufferAddLit(buf, " </hostdev>\n"); return 0; diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h index ac39dcd..31a2f9d 100644 --- a/src/conf/domain_conf.h +++ b/src/conf/domain_conf.h @@ -63,6 +63,40 @@ enum virDomainVirtType { VIR_DOMAIN_VIRT_LAST, }; +enum virDomainDeviceAddressType { + VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE, + VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI, + + VIR_DOMAIN_DEVICE_ADDRESS_TYPE_LAST +}; + +enum virDomainDeviceAddressMode { + VIR_DOMAIN_DEVICE_ADDRESS_MODE_DYNAMIC, + VIR_DOMAIN_DEVICE_ADDRESS_MODE_STATIC, + + VIR_DOMAIN_DEVICE_ADDRESS_MODE_LAST +}; + +typedef struct _virDomainDevicePCIAddress virDomainDevicePCIAddress; +typedef virDomainDevicePCIAddress *virDomainDevicePCIAddressPtr; +struct _virDomainDevicePCIAddress { + unsigned int domain; + unsigned int bus; + unsigned int slot; + unsigned int function; +}; + +typedef struct _virDomainDeviceAddress virDomainDeviceAddress; +typedef virDomainDeviceAddress *virDomainDeviceAddressPtr; +struct _virDomainDeviceAddress { + int type; + int mode; + union { + virDomainDevicePCIAddress pci; + } data; +}; + + /* Two types of disk backends */ enum virDomainDiskType { VIR_DOMAIN_DISK_TYPE_BLOCK, @@ -118,20 +152,10 @@ struct _virDomainDiskDef { int cachemode; unsigned int readonly : 1; unsigned int shared : 1; - struct { - unsigned domain; - unsigned bus; - unsigned slot; - } pci_addr; + virDomainDeviceAddress addr; virStorageEncryptionPtr encryption; }; -static inline int -virDiskHasValidPciAddr(virDomainDiskDefPtr def) -{ - return def->pci_addr.domain || def->pci_addr.bus || def->pci_addr.slot; -} - /* Two types of disk backends */ enum virDomainFSType { @@ -200,20 +224,10 @@ struct _virDomainNetDef { char *ifname; char *nic_name; char *hostnet_name; - struct { - unsigned domain; - unsigned bus; - unsigned slot; - } pci_addr; + virDomainDeviceAddress addr; int vlan; }; -static inline int -virNetHasValidPciAddr(virDomainNetDefPtr def) -{ - return def->pci_addr.domain || def->pci_addr.bus || def->pci_addr.slot; -} - enum virDomainChrTargetType { VIR_DOMAIN_CHR_TARGET_TYPE_NULL = 0, VIR_DOMAIN_CHR_TARGET_TYPE_MONITOR, @@ -441,17 +455,7 @@ struct _virDomainHostdevDef { unsigned vendor; unsigned product; } usb; - struct { - unsigned domain; - unsigned bus; - unsigned slot; - unsigned function; - struct { - unsigned domain; - unsigned bus; - unsigned slot; - } guest_addr; - } pci; + virDomainDevicePCIAddress pci; /* host address */ } u; } subsys; struct { @@ -462,16 +466,9 @@ struct _virDomainHostdevDef { } caps; } source; char* target; + virDomainDeviceAddress addr; /* Guest address */ }; -static inline int -virHostdevHasValidGuestAddr(virDomainHostdevDefPtr def) -{ - return def->source.subsys.u.pci.guest_addr.domain || - def->source.subsys.u.pci.guest_addr.bus || - def->source.subsys.u.pci.guest_addr.slot; -} - /* Flags for the 'type' field in next struct */ enum virDomainDeviceType { VIR_DOMAIN_DEVICE_DISK, @@ -671,6 +668,7 @@ virDomainObjIsActive(virDomainObjPtr dom) return dom->def->id != -1; } + int virDomainObjListInit(virDomainObjListPtr objs); void virDomainObjListDeinit(virDomainObjListPtr objs); @@ -693,6 +691,14 @@ void virDomainWatchdogDefFree(virDomainWatchdogDefPtr def); void virDomainVideoDefFree(virDomainVideoDefPtr def); void virDomainHostdevDefFree(virDomainHostdevDefPtr def); void virDomainDeviceDefFree(virDomainDeviceDefPtr def); +int virDomainDeviceAddressEqual(virDomainDeviceAddressPtr a, + virDomainDeviceAddressPtr b); +int virDomainDevicePCIAddressEqual(virDomainDevicePCIAddressPtr a, + virDomainDevicePCIAddressPtr b); +int virDomainDeviceAddressIsValid(virDomainDeviceAddressPtr addr, + int type); +int virDomainDevicePCIAddressIsValid(virDomainDevicePCIAddressPtr addr); +void virDomainDeviceAddressClear(virDomainDeviceAddressPtr addr); void virDomainDefFree(virDomainDefPtr vm); void virDomainObjRef(virDomainObjPtr vm); /* Returns 1 if the object was freed, 0 if more refs exist */ @@ -830,6 +836,8 @@ VIR_ENUM_DECL(virDomainBoot) VIR_ENUM_DECL(virDomainFeature) VIR_ENUM_DECL(virDomainLifecycle) VIR_ENUM_DECL(virDomainDevice) +VIR_ENUM_DECL(virDomainDeviceAddress) +VIR_ENUM_DECL(virDomainDeviceAddressMode) VIR_ENUM_DECL(virDomainDisk) VIR_ENUM_DECL(virDomainDiskDevice) VIR_ENUM_DECL(virDomainDiskBus) diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 72257d7..963206b 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -154,6 +154,11 @@ virDomainObjListInit; virDomainObjListDeinit; virDomainObjRef; virDomainObjUnref; +virDomainDeviceAddressEqual; +virDomainDevicePCIAddressEqual; +virDomainDeviceAddressIsValid; +virDomainDevicePCIAddressIsValid; +virDomainDeviceAddressClear; # domain_event.h diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 7e60d0e..5920ab3 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -4947,13 +4947,15 @@ static int qemudDomainAttachPciDiskDevice(virConnectPtr conn, ret = qemuMonitorAddPCIDisk(priv->mon, dev->data.disk->src, type, - &dev->data.disk->pci_addr.domain, - &dev->data.disk->pci_addr.bus, - &dev->data.disk->pci_addr.slot); + &dev->data.disk->addr.data.pci.domain, + &dev->data.disk->addr.data.pci.bus, + &dev->data.disk->addr.data.pci.slot); qemuDomainObjExitMonitorWithDriver(driver, vm); - if (ret == 0) + if (ret == 0) { + dev->data.disk->addr.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI; virDomainDiskInsertPreAlloced(vm->def, dev->data.disk); + } return ret; } @@ -5076,12 +5078,13 @@ static int qemudDomainAttachNetDevice(virConnectPtr conn, qemuDomainObjEnterMonitorWithDriver(driver, vm); if (qemuMonitorAddPCINetwork(priv->mon, nicstr, - &net->pci_addr.domain, - &net->pci_addr.bus, - &net->pci_addr.slot) < 0) { + &net->addr.data.pci.domain, + &net->addr.data.pci.bus, + &net->addr.data.pci.slot) < 0) { qemuDomainObjExitMonitorWithDriver(driver, vm); goto try_remove; } + net->addr.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI; qemuDomainObjExitMonitorWithDriver(driver, vm); ret = 0; @@ -5164,12 +5167,13 @@ static int qemudDomainAttachHostPciDevice(virConnectPtr conn, hostdev->source.subsys.u.pci.bus, hostdev->source.subsys.u.pci.slot, hostdev->source.subsys.u.pci.function, - &hostdev->source.subsys.u.pci.guest_addr.domain, - &hostdev->source.subsys.u.pci.guest_addr.bus, - &hostdev->source.subsys.u.pci.guest_addr.slot); + &hostdev->addr.data.pci.domain, + &hostdev->addr.data.pci.bus, + &hostdev->addr.data.pci.slot); qemuDomainObjExitMonitorWithDriver(driver, vm); if (ret < 0) goto error; + hostdev->addr.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI; vm->def->hostdevs[vm->def->nhostdevs++] = hostdev; @@ -5399,18 +5403,18 @@ static int qemudDomainDetachPciDiskDevice(virConnectPtr conn, goto cleanup; } - if (!virDiskHasValidPciAddr(detach)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED, - _("disk %s cannot be detached - no PCI address for device"), - detach->dst); + if (!virDomainDeviceAddressIsValid(&detach->addr, + VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) { + qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED, "%s", + _("device cannot be detached without a PCI address")); goto cleanup; } qemuDomainObjEnterMonitorWithDriver(driver, vm); if (qemuMonitorRemovePCIDevice(priv->mon, - detach->pci_addr.domain, - detach->pci_addr.bus, - detach->pci_addr.slot) < 0) { + detach->addr.data.pci.domain, + detach->addr.data.pci.bus, + detach->addr.data.pci.slot) < 0) { qemuDomainObjExitMonitor(vm); goto cleanup; } @@ -5465,7 +5469,14 @@ qemudDomainDetachNetDevice(virConnectPtr conn, goto cleanup; } - if (!virNetHasValidPciAddr(detach) || detach->vlan < 0 || !detach->hostnet_name) { + if (!virDomainDeviceAddressIsValid(&detach->addr, + VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) { + qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED, + "%s", _("device cannot be detached without a PCI address")); + goto cleanup; + } + + if (detach->vlan < 0 || !detach->hostnet_name) { qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED, "%s", _("network device cannot be detached - device state missing")); goto cleanup; @@ -5473,9 +5484,9 @@ qemudDomainDetachNetDevice(virConnectPtr conn, qemuDomainObjEnterMonitorWithDriver(driver, vm); if (qemuMonitorRemovePCIDevice(priv->mon, - detach->pci_addr.domain, - detach->pci_addr.bus, - detach->pci_addr.slot) < 0) { + detach->addr.data.pci.domain, + detach->addr.data.pci.bus, + detach->addr.data.pci.slot) < 0) { qemuDomainObjExitMonitorWithDriver(driver, vm); goto cleanup; } @@ -5553,17 +5564,18 @@ static int qemudDomainDetachHostPciDevice(virConnectPtr conn, return -1; } - if (!virHostdevHasValidGuestAddr(detach)) { + if (!virDomainDeviceAddressIsValid(&detach->addr, + VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) { qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED, - "%s", _("hostdev cannot be detached - device state missing")); + "%s", _("device cannot be detached without a PCI address")); return -1; } qemuDomainObjEnterMonitorWithDriver(driver, vm); if (qemuMonitorRemovePCIDevice(priv->mon, - detach->source.subsys.u.pci.guest_addr.domain, - detach->source.subsys.u.pci.guest_addr.bus, - detach->source.subsys.u.pci.guest_addr.slot) < 0) { + detach->addr.data.pci.domain, + detach->addr.data.pci.bus, + detach->addr.data.pci.slot) < 0) { qemuDomainObjExitMonitorWithDriver(driver, vm); return -1; } -- 1.6.5.2

Add the virDomainDeviceAddress information to the sound, video and watchdog devices. This means all of them gain a new XML element <address .... /> * src/conf/domain_conf.h: Add virDomainDeviceAddress to sound, video & watchdog device struts. * src/conf/domain_conf.c: Hook up parsing/formatting for virDomainDeviceAddress in sound, video & watchdog devices --- src/conf/domain_conf.c | 85 ++++++++++++++++++++++++++++++++++++++++++----- src/conf/domain_conf.h | 3 ++ 2 files changed, 79 insertions(+), 9 deletions(-) diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index 9c0b8cf..a1eeb06 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -2369,6 +2369,19 @@ virDomainSoundDefParseXML(virConnectPtr conn, char *model; virDomainSoundDefPtr def; + xmlNodePtr addr = NULL; + xmlNodePtr cur; + + cur = node->children; + while (cur != NULL) { + if (cur->type == XML_ELEMENT_NODE) { + if ((addr == NULL) && + xmlStrEqual(cur->name, BAD_CAST "address")) { + addr = cur; + } + } + cur = cur->next; + } if (VIR_ALLOC(def) < 0) { virReportOOMError(conn); @@ -2382,6 +2395,10 @@ virDomainSoundDefParseXML(virConnectPtr conn, goto error; } + if (addr && + virDomainDeviceAddressParseXML(conn, addr, &def->addr, flags) < 0) + goto error; + cleanup: VIR_FREE(model); @@ -2397,11 +2414,24 @@ error: static virDomainWatchdogDefPtr virDomainWatchdogDefParseXML(virConnectPtr conn, const xmlNodePtr node, - int flags ATTRIBUTE_UNUSED) { + int flags) { char *model = NULL; char *action = NULL; virDomainWatchdogDefPtr def; + xmlNodePtr addr = NULL; + xmlNodePtr cur; + + cur = node->children; + while (cur != NULL) { + if (cur->type == XML_ELEMENT_NODE) { + if ((addr == NULL) && + xmlStrEqual(cur->name, BAD_CAST "address")) { + addr = cur; + } + } + cur = cur->next; + } if (VIR_ALLOC (def) < 0) { virReportOOMError (conn); @@ -2433,6 +2463,10 @@ virDomainWatchdogDefParseXML(virConnectPtr conn, } } + if (addr && (def->model == VIR_DOMAIN_WATCHDOG_MODEL_I6300ESB) && + virDomainDeviceAddressParseXML(conn, addr, &def->addr, flags) < 0) + goto error; + cleanup: VIR_FREE (action); VIR_FREE (model); @@ -2548,6 +2582,7 @@ virDomainVideoDefParseXML(virConnectPtr conn, int flags ATTRIBUTE_UNUSED) { virDomainVideoDefPtr def; xmlNodePtr cur; + xmlNodePtr addr = NULL; char *type = NULL; char *heads = NULL; char *vram = NULL; @@ -2566,6 +2601,9 @@ virDomainVideoDefParseXML(virConnectPtr conn, vram = virXMLPropString(cur, "vram"); heads = virXMLPropString(cur, "heads"); def->accel = virDomainVideoAccelDefParseXML(conn, cur); + } else if ((addr == NULL) && + xmlStrEqual(cur->name, BAD_CAST "address")) { + addr = cur; } } cur = cur->next; @@ -2605,6 +2643,10 @@ virDomainVideoDefParseXML(virConnectPtr conn, def->heads = 1; } + if (addr && + virDomainDeviceAddressParseXML(conn, addr, &def->addr, flags) < 0) + goto error; + VIR_FREE(type); VIR_FREE(vram); VIR_FREE(heads); @@ -4645,7 +4687,8 @@ cleanup: static int virDomainSoundDefFormat(virConnectPtr conn, virBufferPtr buf, - virDomainSoundDefPtr def) + virDomainSoundDefPtr def, + int flags) { const char *model = virDomainSoundModelTypeToString(def->model); @@ -4655,9 +4698,18 @@ virDomainSoundDefFormat(virConnectPtr conn, return -1; } - virBufferVSprintf(buf, " <sound model='%s'/>\n", + virBufferVSprintf(buf, " <sound model='%s'", model); + if (def->addr.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) { + virBufferAddLit(buf, ">\n"); + if (virDomainDeviceAddressFormat(buf, &def->addr, flags) < 0) + return -1; + virBufferAddLit(buf, " </sound>\n"); + } else { + virBufferAddLit(buf, "/>\n"); + } + return 0; } @@ -4665,7 +4717,8 @@ virDomainSoundDefFormat(virConnectPtr conn, static int virDomainWatchdogDefFormat(virConnectPtr conn, virBufferPtr buf, - virDomainWatchdogDefPtr def) + virDomainWatchdogDefPtr def, + int flags) { const char *model = virDomainWatchdogModelTypeToString (def->model); const char *action = virDomainWatchdogActionTypeToString (def->action); @@ -4682,9 +4735,18 @@ virDomainWatchdogDefFormat(virConnectPtr conn, return -1; } - virBufferVSprintf(buf, " <watchdog model='%s' action='%s'/>\n", + virBufferVSprintf(buf, " <watchdog model='%s' action='%s'", model, action); + if (def->addr.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) { + virBufferAddLit(buf, ">\n"); + if (virDomainDeviceAddressFormat(buf, &def->addr, flags) < 0) + return -1; + virBufferAddLit(buf, " </watchdog>\n"); + } else { + virBufferAddLit(buf, "/>\n"); + } + return 0; } @@ -4704,7 +4766,8 @@ virDomainVideoAccelDefFormat(virBufferPtr buf, static int virDomainVideoDefFormat(virConnectPtr conn, virBufferPtr buf, - virDomainVideoDefPtr def) + virDomainVideoDefPtr def, + int flags) { const char *model = virDomainVideoTypeToString(def->type); @@ -4729,6 +4792,10 @@ virDomainVideoDefFormat(virConnectPtr conn, virBufferAddLit(buf, "/>\n"); } + if (def->addr.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE && + virDomainDeviceAddressFormat(buf, &def->addr, flags) < 0) + return -1; + virBufferAddLit(buf, " </video>\n"); return 0; @@ -5128,11 +5195,11 @@ char *virDomainDefFormat(virConnectPtr conn, } for (n = 0 ; n < def->nsounds ; n++) - if (virDomainSoundDefFormat(conn, &buf, def->sounds[n]) < 0) + if (virDomainSoundDefFormat(conn, &buf, def->sounds[n], flags) < 0) goto cleanup; for (n = 0 ; n < def->nvideos ; n++) - if (virDomainVideoDefFormat(conn, &buf, def->videos[n]) < 0) + if (virDomainVideoDefFormat(conn, &buf, def->videos[n], flags) < 0) goto cleanup; for (n = 0 ; n < def->nhostdevs ; n++) @@ -5140,7 +5207,7 @@ char *virDomainDefFormat(virConnectPtr conn, goto cleanup; if (def->watchdog) - virDomainWatchdogDefFormat (conn, &buf, def->watchdog); + virDomainWatchdogDefFormat (conn, &buf, def->watchdog, flags); virBufferAddLit(&buf, " </devices>\n"); diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h index d1c1b67..f06c2dc 100644 --- a/src/conf/domain_conf.h +++ b/src/conf/domain_conf.h @@ -348,6 +348,7 @@ typedef struct _virDomainSoundDef virDomainSoundDef; typedef virDomainSoundDef *virDomainSoundDefPtr; struct _virDomainSoundDef { int model; + virDomainDeviceAddress addr; }; enum virDomainWatchdogModel { @@ -372,6 +373,7 @@ typedef virDomainWatchdogDef *virDomainWatchdogDefPtr; struct _virDomainWatchdogDef { int model; int action; + virDomainDeviceAddress addr; }; @@ -401,6 +403,7 @@ struct _virDomainVideoDef { unsigned int vram; unsigned int heads; virDomainVideoAccelDefPtr accel; + virDomainDeviceAddress addr; }; /* 3 possible graphics console modes */ -- 1.6.5.2

From: Wolfgang Mauerer <wolfgang.mauerer@siemens.com> This augments virDomainDevice with a <controller> element that is used to represent disk controllers (e.g., scsi controllers). The XML format is given by <controller type="scsi" index="<num>"> <address type="pci" domain="0xNUM" bus="0xNUM" slot="0xNUM"/> </controller> where type denotes the disk interface (scsi, ide,...), index is an integer that identifies the controller for association with disks, and the <address> element specifies the controller address on the PCI bus as described in previous commits The address element can be omitted; in this case, an address will be assigned automatically. Most of the code in this patch is from Wolfgang Mauerer's previous disk controller series --- src/conf/domain_conf.c | 207 +++++++++++++++++++++++++++++++++++++++++++++- src/conf/domain_conf.h | 30 +++++++ src/libvirt_private.syms | 2 + 3 files changed, 238 insertions(+), 1 deletions(-) diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index 533a1b0..95a9d52 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -86,7 +86,8 @@ VIR_ENUM_IMPL(virDomainDevice, VIR_DOMAIN_DEVICE_LAST, "sound", "video", "hostdev", - "watchdog") + "watchdog", + "controller") VIR_ENUM_IMPL(virDomainDeviceAddress, VIR_DOMAIN_DEVICE_ADDRESS_TYPE_LAST, "none", @@ -124,6 +125,12 @@ VIR_ENUM_IMPL(virDomainDiskCache, VIR_DOMAIN_DISK_CACHE_LAST, "writethrough", "writeback") +VIR_ENUM_IMPL(virDomainController, VIR_DOMAIN_CONTROLLER_TYPE_LAST, + "ide", + "fdc", + "scsi", + "sata") + VIR_ENUM_IMPL(virDomainFS, VIR_DOMAIN_FS_TYPE_LAST, "mount", "block", @@ -371,6 +378,14 @@ void virDomainDiskDefFree(virDomainDiskDefPtr def) VIR_FREE(def); } +void virDomainControllerDefFree(virDomainControllerDefPtr def) +{ + if (!def) + return; + + VIR_FREE(def); +} + void virDomainFSDefFree(virDomainFSDefPtr def) { if (!def) @@ -523,6 +538,9 @@ void virDomainDeviceDefFree(virDomainDeviceDefPtr def) case VIR_DOMAIN_DEVICE_WATCHDOG: virDomainWatchdogDefFree(def->data.watchdog); break; + case VIR_DOMAIN_DEVICE_CONTROLLER: + virDomainControllerDefFree(def->data.controller); + break; } VIR_FREE(def); @@ -556,6 +574,10 @@ void virDomainDefFree(virDomainDefPtr def) virDomainDiskDefFree(def->disks[i]); VIR_FREE(def->disks); + for (i = 0 ; i < def->ncontrollers ; i++) + virDomainControllerDefFree(def->controllers[i]); + VIR_FREE(def->controllers); + for (i = 0 ; i < def->nfss ; i++) virDomainFSDefFree(def->fss[i]); VIR_FREE(def->fss); @@ -1390,6 +1412,76 @@ cleanup: } +/* Parse the XML definition for a controller + * @param node XML nodeset to parse for controller definition + */ +static virDomainControllerDefPtr +virDomainControllerDefParseXML(virConnectPtr conn, + xmlNodePtr node, + int flags) { + virDomainControllerDefPtr def; + xmlNodePtr cur; + char *type = NULL; + char *idx = NULL; + xmlNodePtr addr = NULL; + + if (VIR_ALLOC(def) < 0) { + virReportOOMError(conn); + return NULL; + } + + type = virXMLPropString(node, "type"); + if (type) { + if ((def->type = virDomainDiskBusTypeFromString(type)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unknown disk controller type '%s'"), type); + goto error; + } + } + + idx = virXMLPropString(node, "index"); + if (idx) { + if (virStrToLong_i(idx, NULL, 10, &def->idx) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("cannot parse disk controller index %s"), idx); + goto error; + } + } + + cur = node->children; + while (cur != NULL) { + if (cur->type == XML_ELEMENT_NODE && + addr == NULL) { + addr = cur; + } + + cur = cur->next; + } + + if (addr) { + if (virDomainDeviceAddressParseXML(conn, addr, &def->addr,flags) < 0) + goto error; + } + + if (def->addr.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE && + def->addr.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s", + _("Disk controllers must use the 'pci' address type")); + goto error; + } + +cleanup: + VIR_FREE(type); + VIR_FREE(idx); + + return def; + + error: + virDomainControllerDefFree(def); + def = NULL; + goto cleanup; +} + /* Parse the XML definition for a disk * @param node XML nodeset to parse for disk definition */ @@ -3092,6 +3184,10 @@ virDomainDeviceDefPtr virDomainDeviceDefParse(virConnectPtr conn, dev->type = VIR_DOMAIN_DEVICE_HOSTDEV; if (!(dev->data.hostdev = virDomainHostdevDefParseXML(conn, node, flags))) goto error; + } else if (xmlStrEqual(node->name, BAD_CAST "controller")) { + dev->type = VIR_DOMAIN_DEVICE_CONTROLLER; + if (!(dev->data.controller = virDomainControllerDefParseXML(conn, node, flags))) + goto error; } else { virDomainReportError(conn, VIR_ERR_XML_ERROR, "%s", _("unknown device type")); @@ -3164,6 +3260,59 @@ void virDomainDiskInsertPreAlloced(virDomainDefPtr def, } +int virDomainControllerInsert(virDomainDefPtr def, + virDomainControllerDefPtr controller) +{ + + if (VIR_REALLOC_N(def->controllers, def->ncontrollers+1) < 0) + return -1; + + virDomainControllerInsertPreAlloced(def, controller); + + return 0; +} + +void virDomainControllerInsertPreAlloced(virDomainDefPtr def, + virDomainControllerDefPtr controller) +{ + int i; + /* Tenatively plan to insert controller at the end. */ + int insertAt = -1; + + /* Then work backwards looking for controllers of + * the same type. If we find a controller with a + * index greater than the new one, insert at + * that position + */ + for (i = (def->ncontrollers - 1) ; i >= 0 ; i--) { + /* If bus matches and current controller is after + * new controller, then new controller should go here */ + if ((def->controllers[i]->type == controller->type) && + (def->controllers[i]->idx > controller->idx)) { + insertAt = i; + } else if (def->controllers[i]->type == controller->type && + insertAt == -1) { + /* Last controller with match bus is before the + * new controller, then put new controller just after + */ + insertAt = i + 1; + } + } + + /* No controllers with this bus yet, so put at end of list */ + if (insertAt == -1) + insertAt = def->ncontrollers; + + if (insertAt < def->ncontrollers) + memmove(def->controllers + insertAt + 1, + def->controllers + insertAt, + (sizeof(def->controllers[0]) * (def->ncontrollers-insertAt))); + + def->controllers[insertAt] = controller; + def->ncontrollers++; +} + + #ifndef PROXY static char *virDomainDefDefaultEmulator(virConnectPtr conn, virDomainDefPtr def, @@ -3479,6 +3628,25 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn, } VIR_FREE(nodes); + /* analysis of the controller devices */ + if ((n = virXPathNodeSet(conn, "./devices/controller", ctxt, &nodes)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("cannot extract controller devices")); + goto error; + } + if (n && VIR_ALLOC_N(def->controllers, n) < 0) + goto no_memory; + for (i = 0 ; i < n ; i++) { + virDomainControllerDefPtr controller = virDomainControllerDefParseXML(conn, + nodes[i], + flags); + if (!controller) + goto error; + + def->controllers[def->ncontrollers++] = controller; + } + VIR_FREE(nodes); + /* analysis of the filesystems */ if ((n = virXPathNodeSet(conn, "./devices/filesystem", ctxt, &nodes)) < 0) { virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, @@ -4387,6 +4555,36 @@ virDomainDiskDefFormat(virConnectPtr conn, } static int +virDomainControllerDefFormat(virConnectPtr conn, + virBufferPtr buf, + virDomainControllerDefPtr def, + int flags) +{ + const char *type = virDomainControllerTypeToString(def->type); + + if (!type) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unexpected controller type %d"), def->type); + return -1; + } + + virBufferVSprintf(buf, + " <controller type='%s' index='%d'", + type, def->idx); + + if (def->addr.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) { + virBufferAddLit(buf, ">\n"); + if (virDomainDeviceAddressFormat(buf, &def->addr, flags) < 0) + return -1; + virBufferAddLit(buf, " </controller>\n"); + } else { + virBufferAddLit(buf, "/>\n"); + } + + return 0; +} + +static int virDomainFSDefFormat(virConnectPtr conn, virBufferPtr buf, virDomainFSDefPtr def) @@ -5138,6 +5336,10 @@ char *virDomainDefFormat(virConnectPtr conn, if (virDomainDiskDefFormat(conn, &buf, def->disks[n], flags) < 0) goto cleanup; + for (n = 0 ; n < def->ncontrollers ; n++) + if (virDomainControllerDefFormat(conn, &buf, def->controllers[n], flags) < 0) + goto cleanup; + for (n = 0 ; n < def->nfss ; n++) if (virDomainFSDefFormat(conn, &buf, def->fss[n]) < 0) goto cleanup; @@ -5316,6 +5518,9 @@ void virDomainDefClearDynamicValues(virDomainDefPtr def) for (i = 0 ; i < def->nnets ; i++) { virDomainDeviceAddressClearDynamicValues(&def->nets[i]->addr); } + for (i = 0 ; i < def->ncontrollers ; i++) { + virDomainDeviceAddressClearDynamicValues(&def->controllers[i]->addr); + } if (def->seclabel.type == VIR_DOMAIN_SECLABEL_DYNAMIC) { VIR_FREE(def->seclabel.label); diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h index c93aed6..413647b 100644 --- a/src/conf/domain_conf.h +++ b/src/conf/domain_conf.h @@ -176,6 +176,25 @@ struct _virDomainDiskDef { }; +enum virDomainControllerType { + VIR_DOMAIN_CONTROLLER_TYPE_IDE, + VIR_DOMAIN_CONTROLLER_TYPE_FDC, + VIR_DOMAIN_CONTROLLER_TYPE_SCSI, + VIR_DOMAIN_CONTROLLER_TYPE_SATA, + + VIR_DOMAIN_CONTROLLER_TYPE_LAST +}; + +/* Stores the virtual disk controller configuration */ +typedef struct _virDomainControllerDef virDomainControllerDef; +typedef virDomainControllerDef *virDomainControllerDefPtr; +struct _virDomainControllerDef { + int type; + int idx; + virDomainDeviceAddress addr; +}; + + /* Two types of disk backends */ enum virDomainFSType { VIR_DOMAIN_FS_TYPE_MOUNT, /* Better named 'bind' */ @@ -500,6 +519,7 @@ enum virDomainDeviceType { VIR_DOMAIN_DEVICE_VIDEO, VIR_DOMAIN_DEVICE_HOSTDEV, VIR_DOMAIN_DEVICE_WATCHDOG, + VIR_DOMAIN_DEVICE_CONTROLLER, VIR_DOMAIN_DEVICE_LAST, }; @@ -510,6 +530,7 @@ struct _virDomainDeviceDef { int type; union { virDomainDiskDefPtr disk; + virDomainControllerDefPtr controller; virDomainFSDefPtr fs; virDomainNetDefPtr net; virDomainInputDefPtr input; @@ -622,6 +643,9 @@ struct _virDomainDef { int ndisks; virDomainDiskDefPtr *disks; + int ncontrollers; + virDomainControllerDefPtr *controllers; + int nfss; virDomainFSDefPtr *fss; @@ -704,6 +728,7 @@ virDomainObjPtr virDomainFindByName(const virDomainObjListPtr doms, void virDomainGraphicsDefFree(virDomainGraphicsDefPtr def); void virDomainInputDefFree(virDomainInputDefPtr def); void virDomainDiskDefFree(virDomainDiskDefPtr def); +void virDomainControllerDefFree(virDomainControllerDefPtr def); void virDomainFSDefFree(virDomainFSDefPtr def); void virDomainNetDefFree(virDomainNetDefPtr def); void virDomainChrDefFree(virDomainChrDefPtr def); @@ -790,6 +815,10 @@ int virDomainDiskInsert(virDomainDefPtr def, virDomainDiskDefPtr disk); void virDomainDiskInsertPreAlloced(virDomainDefPtr def, virDomainDiskDefPtr disk); +int virDomainControllerInsert(virDomainDefPtr def, + virDomainControllerDefPtr controller); +void virDomainControllerInsertPreAlloced(virDomainDefPtr def, + virDomainControllerDefPtr controller); int virDomainSaveXML(virConnectPtr conn, const char *configDir, @@ -871,6 +900,7 @@ VIR_ENUM_DECL(virDomainDisk) VIR_ENUM_DECL(virDomainDiskDevice) VIR_ENUM_DECL(virDomainDiskBus) VIR_ENUM_DECL(virDomainDiskCache) +VIR_ENUM_DECL(virDomainController) VIR_ENUM_DECL(virDomainFS) VIR_ENUM_DECL(virDomainNet) VIR_ENUM_DECL(virDomainChrTarget) diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 285715d..8622e5b 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -109,6 +109,8 @@ virDomainDiskDefFree; virDomainDiskDeviceTypeToString; virDomainDiskInsert; virDomainDiskInsertPreAlloced; +virDomainControllerInsert; +virDomainControllerInsertPreAlloced; virDomainFindByID; virDomainFindByName; virDomainFindByUUID; -- 1.6.5.2

To enable it to be called from multiple locations, split out the code for building the -drive arg string * src/qemu/qemu_conf.c, src/qemu/qemu_conf.h: Add qemuBuildDriveStr for building -drive arg string --- src/qemu/qemu_conf.c | 188 ++++++++++++++++++++++++++++---------------------- src/qemu/qemu_conf.h | 7 ++ 2 files changed, 112 insertions(+), 83 deletions(-) diff --git a/src/qemu/qemu_conf.c b/src/qemu/qemu_conf.c index 39d9314..27faa3f 100644 --- a/src/qemu/qemu_conf.c +++ b/src/qemu/qemu_conf.c @@ -1313,6 +1313,110 @@ qemuAssignNetNames(virDomainDefPtr def, return 0; } +#define QEMU_SERIAL_PARAM_ACCEPTED_CHARS \ + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_" + +static int +qemuSafeSerialParamValue(virConnectPtr conn, + const char *value) +{ + if (strspn(value, QEMU_SERIAL_PARAM_ACCEPTED_CHARS) != strlen (value)) { + qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, + _("driver serial '%s' contains unsafe characters"), + value); + return -1; + } + + return 0; +} + + +int +qemuBuildDriveStr(virConnectPtr conn, + virDomainDiskDefPtr disk, + int bootable, + int qemuCmdFlags, + char **str) +{ + virBuffer opt = VIR_BUFFER_INITIALIZER; + const char *bus = virDomainDiskQEMUBusTypeToString(disk->bus); + int idx = virDiskNameToIndex(disk->dst); + char *optstr = NULL; + + if (idx < 0) { + qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, + _("unsupported disk type '%s'"), disk->dst); + goto error; + } + + if (disk->src) { + if (disk->type == VIR_DOMAIN_DISK_TYPE_DIR) { + /* QEMU only supports magic FAT format for now */ + if (disk->driverType && + STRNEQ(disk->driverType, "fat")) { + qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, + _("unsupported disk driver type for '%s'"), + disk->driverType); + goto error; + } + if (!disk->readonly) { + qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, "%s", + _("cannot create virtual FAT disks in read-write mode")); + goto error; + } + if (disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) + virBufferVSprintf(&opt, "file=fat:floppy:%s,", disk->src); + else + virBufferVSprintf(&opt, "file=fat:%s,", disk->src); + } else { + virBufferVSprintf(&opt, "file=%s,", disk->src); + } + } + virBufferVSprintf(&opt, "if=%s", bus); + if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) + virBufferAddLit(&opt, ",media=cdrom"); + virBufferVSprintf(&opt, ",index=%d", idx); + if (bootable && + disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) + virBufferAddLit(&opt, ",boot=on"); + if (disk->driverType && + disk->type != VIR_DOMAIN_DISK_TYPE_DIR && + qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE_FORMAT) + virBufferVSprintf(&opt, ",format=%s", disk->driverType); + if (disk->serial && + (qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE_SERIAL)) { + if (qemuSafeSerialParamValue(conn, disk->serial) < 0) + goto error; + virBufferVSprintf(&opt, ",serial=%s", disk->serial); + } + + if (disk->cachemode) { + const char *mode = + (qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE_CACHE_V2) ? + qemuDiskCacheV2TypeToString(disk->cachemode) : + qemuDiskCacheV1TypeToString(disk->cachemode); + + virBufferVSprintf(&opt, ",cache=%s", mode); + } else if (disk->shared && !disk->readonly) { + virBufferAddLit(&opt, ",cache=off"); + } + + if (virBufferError(&opt)) { + virReportOOMError(conn); + goto error; + } + + *str = virBufferContentAndReset(&opt); + return 0; + +error: + optstr = virBufferContentAndReset(&opt); + VIR_FREE(optstr); + *str = NULL; + return -1; +} + + int qemuBuildNicStr(virConnectPtr conn, virDomainNetDefPtr net, @@ -1562,23 +1666,6 @@ static void qemudBuildCommandLineChrDevStr(virDomainChrDefPtr dev, } } -#define QEMU_SERIAL_PARAM_ACCEPTED_CHARS \ - "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_" - -static int -qemuSafeSerialParamValue(virConnectPtr conn, - const char *value) -{ - if (strspn(value, QEMU_SERIAL_PARAM_ACCEPTED_CHARS) != strlen (value)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("driver serial '%s' contains unsafe characters"), - value); - return -1; - } - - return 0; -} - /* * Constructs a argv suitable for launching qemu with config defined * for a given virtual machine. @@ -1960,12 +2047,9 @@ int qemudBuildCommandLine(virConnectPtr conn, } for (i = 0 ; i < def->ndisks ; i++) { - virBuffer opt = VIR_BUFFER_INITIALIZER; char *optstr; int bootable = 0; virDomainDiskDefPtr disk = def->disks[i]; - int idx = virDiskNameToIndex(disk->dst); - const char *bus = virDomainDiskQEMUBusTypeToString(disk->bus); if (disk->bus == VIR_DOMAIN_DISK_BUS_USB) { if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) { @@ -1980,12 +2064,6 @@ int qemudBuildCommandLine(virConnectPtr conn, ADD_ARG_SPACE; - if (idx < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("unsupported disk type '%s'"), disk->dst); - goto error; - } - switch (disk->device) { case VIR_DOMAIN_DISK_DEVICE_CDROM: bootable = bootCD; @@ -2001,64 +2079,8 @@ int qemudBuildCommandLine(virConnectPtr conn, break; } - if (disk->src) { - if (disk->type == VIR_DOMAIN_DISK_TYPE_DIR) { - /* QEMU only supports magic FAT format for now */ - if (disk->driverType && - STRNEQ(disk->driverType, "fat")) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("unsupported disk driver type for '%s'"), - disk->driverType); - goto error; - } - if (!disk->readonly) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, "%s", - _("cannot create virtual FAT disks in read-write mode")); - goto error; - } - if (disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) - virBufferVSprintf(&opt, "file=fat:floppy:%s,", disk->src); - else - virBufferVSprintf(&opt, "file=fat:%s,", disk->src); - } else { - virBufferVSprintf(&opt, "file=%s,", disk->src); - } - } - virBufferVSprintf(&opt, "if=%s", bus); - if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) - virBufferAddLit(&opt, ",media=cdrom"); - virBufferVSprintf(&opt, ",index=%d", idx); - if (bootable && - disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) - virBufferAddLit(&opt, ",boot=on"); - if (disk->driverType && - disk->type != VIR_DOMAIN_DISK_TYPE_DIR && - qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE_FORMAT) - virBufferVSprintf(&opt, ",format=%s", disk->driverType); - if (disk->serial && - (qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE_SERIAL)) { - if (qemuSafeSerialParamValue(conn, disk->serial) < 0) - goto error; - virBufferVSprintf(&opt, ",serial=%s", disk->serial); - } - - if (disk->cachemode) { - const char *mode = - (qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE_CACHE_V2) ? - qemuDiskCacheV2TypeToString(disk->cachemode) : - qemuDiskCacheV1TypeToString(disk->cachemode); - - virBufferVSprintf(&opt, ",cache=%s", mode); - } else if (disk->shared && !disk->readonly) { - virBufferAddLit(&opt, ",cache=off"); - } - - if (virBufferError(&opt)) { - virReportOOMError(conn); + if (qemuBuildDriveStr(conn, disk, bootable, qemuCmdFlags, &optstr) < 0) goto error; - } - - optstr = virBufferContentAndReset(&opt); if ((qargv[qargc++] = strdup("-drive")) == NULL) { VIR_FREE(optstr); diff --git a/src/qemu/qemu_conf.h b/src/qemu/qemu_conf.h index 248677a..cd59d4c 100644 --- a/src/qemu/qemu_conf.h +++ b/src/qemu/qemu_conf.h @@ -191,6 +191,13 @@ int qemuBuildNicStr (virConnectPtr conn, int vlan, char **str); + +int qemuBuildDriveStr (virConnectPtr conn, + virDomainDiskDefPtr disk, + int bootable, + int qemuCmdFlags, + char **str); + int qemudNetworkIfaceConnect (virConnectPtr conn, struct qemud_driver *driver, virDomainNetDefPtr net, -- 1.6.5.2

From: Wolfgang Mauerer <wolfgang.mauerer@siemens.com> This patch allows for explicit hotplug/unplug of SCSI controllers. Ordinarily this is not required, since QEMU/libvirt will attach a new SCSI controller whenever one is required. Allowing explicit hotplug of controllers though, enables the caller to specify a static PCI address, instead of auto-assigning the next available PCI slot. Or it will when we have static PCI addressing. This patch is derived from Wolfgang Mauerer's disk controller patch series. * src/qemu/qemu_driver.c: Support hotplug & unplug of SCSI controllers * src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h, src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h, src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add new API for attaching PCI SCSI controllers --- src/libvirt_private.syms | 2 + src/qemu/qemu_driver.c | 117 ++++++++++++++++++++++++++++++++++++++++++ src/qemu/qemu_monitor.c | 16 ++++++ src/qemu/qemu_monitor.h | 3 + src/qemu/qemu_monitor_json.c | 40 ++++++++++++++ src/qemu/qemu_monitor_json.h | 4 ++ src/qemu/qemu_monitor_text.c | 43 +++++++++++++++ src/qemu/qemu_monitor_text.h | 5 ++ 8 files changed, 230 insertions(+), 0 deletions(-) diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 8622e5b..3e98800 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -165,6 +165,8 @@ virDomainDeviceUSBAddressIsValid; virDomainDeviceAddressClear; virDomainDeviceAddressTypeToString; virDomainDefClearDynamicValues; +virDomainControllerTypeToString; +virDomainControllerDefFree; # domain_event.h diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 321cd4e..0a91c2a 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -4961,6 +4961,44 @@ static int qemudDomainAttachPciDiskDevice(virConnectPtr conn, return ret; } +static int qemudDomainAttachPciControllerDevice(virConnectPtr conn, + struct qemud_driver *driver, + virDomainObjPtr vm, + virDomainDeviceDefPtr dev) +{ + int i, ret; + const char* type = virDomainControllerTypeToString(dev->data.controller->type); + qemuDomainObjPrivatePtr priv = vm->privateData; + + for (i = 0 ; i < vm->def->ncontrollers ; i++) { + if ((vm->def->controllers[i]->type == dev->data.controller->type) && + (vm->def->controllers[i]->idx == dev->data.controller->idx)) { + qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED, + _("target %s:%d already exists"), + type, dev->data.controller->idx); + return -1; + } + } + + if (VIR_REALLOC_N(vm->def->controllers, vm->def->ncontrollers+1) < 0) { + virReportOOMError(conn); + return -1; + } + + qemuDomainObjEnterMonitorWithDriver(driver, vm); + ret = qemuMonitorAttachPCIDiskController(priv->mon, + type, + &dev->data.controller->addr.data.pci); + qemuDomainObjExitMonitorWithDriver(driver, vm); + + if (ret == 0) { + dev->data.controller->addr.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI; + virDomainControllerInsertPreAlloced(vm->def, dev->data.controller); + } + + return ret; +} + static int qemudDomainAttachUsbMassstorageDevice(virConnectPtr conn, struct qemud_driver *driver, virDomainObjPtr vm, @@ -5345,6 +5383,15 @@ static int qemudDomainAttachDevice(virDomainPtr dom, virCgroupDenyDevicePath(cgroup, dev->data.disk->src); } + } else if (dev->type == VIR_DOMAIN_DEVICE_CONTROLLER) { + if (dev->data.controller->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI) { + ret = qemudDomainAttachPciControllerDevice(dom->conn, driver, vm, dev); + } else { + qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT, + _("disk controller bus '%s' cannot be hotplugged."), + virDomainControllerTypeToString(dev->data.controller->type)); + /* fallthrough */ + } } else if (dev->type == VIR_DOMAIN_DEVICE_NET) { ret = qemudDomainAttachNetDevice(dom->conn, driver, vm, dev, qemuCmdFlags); } else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) { @@ -5436,6 +5483,67 @@ cleanup: return ret; } +static int qemudDomainDetachPciControllerDevice(virConnectPtr conn, + struct qemud_driver *driver, + virDomainObjPtr vm, + virDomainDeviceDefPtr dev) +{ + int i, ret = -1; + virDomainControllerDefPtr detach = NULL; + qemuDomainObjPrivatePtr priv = vm->privateData; + + for (i = 0 ; i < vm->def->ncontrollers ; i++) { + if ((vm->def->controllers[i]->type == dev->data.controller->type) && + (vm->def->controllers[i]->idx == dev->data.controller->idx)) { + detach = vm->def->controllers[i]; + break; + } + } + + if (!detach) { + qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED, + _("disk controller %s:%d not found"), + virDomainControllerTypeToString(dev->data.controller->type), + dev->data.controller->idx); + goto cleanup; + } + + if (!virDomainDeviceAddressIsValid(&detach->addr, + VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) { + qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED, "%s", + _("device cannot be detached without a PCI address")); + goto cleanup; + } + + qemuDomainObjEnterMonitorWithDriver(driver, vm); + if (qemuMonitorRemovePCIDevice(priv->mon, + &detach->addr.data.pci) < 0) { + qemuDomainObjExitMonitor(vm); + goto cleanup; + } + qemuDomainObjExitMonitorWithDriver(driver, vm); + + if (vm->def->ncontrollers > 1) { + memmove(vm->def->controllers + i, + vm->def->controllers + i + 1, + sizeof(*vm->def->controllers) * + (vm->def->ncontrollers - (i + 1))); + vm->def->ncontrollers--; + if (VIR_REALLOC_N(vm->def->controllers, vm->def->ncontrollers) < 0) { + /* ignore, harmless */ + } + } else { + VIR_FREE(vm->def->controllers); + vm->def->ncontrollers = 0; + } + virDomainControllerDefFree(detach); + + ret = 0; + +cleanup: + return ret; +} + static int qemudDomainDetachNetDevice(virConnectPtr conn, struct qemud_driver *driver, @@ -5687,6 +5795,15 @@ static int qemudDomainDetachDevice(virDomainPtr dom, VIR_WARN0("Fail to restore disk device ownership"); } else if (dev->type == VIR_DOMAIN_DEVICE_NET) { ret = qemudDomainDetachNetDevice(dom->conn, driver, vm, dev); + } else if (dev->type == VIR_DOMAIN_DEVICE_CONTROLLER) { + if (dev->data.controller->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI) { + ret = qemudDomainDetachPciControllerDevice(dom->conn, driver, vm, dev); + } else { + qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT, + _("disk controller bus '%s' cannot be hotunplugged."), + virDomainControllerTypeToString(dev->data.controller->type)); + /* fallthrough */ + } } else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) { ret = qemudDomainDetachHostDevice(dom->conn, driver, vm, dev); } else diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c index ded1622..4ecbcba 100644 --- a/src/qemu/qemu_monitor.c +++ b/src/qemu/qemu_monitor.c @@ -1240,3 +1240,19 @@ int qemuMonitorRemoveHostNetwork(qemuMonitorPtr mon, ret = qemuMonitorTextRemoveHostNetwork(mon, vlan, netname); return ret; } + + +int qemuMonitorAttachPCIDiskController(qemuMonitorPtr mon, + const char *bus, + virDomainDevicePCIAddress *guestAddr) +{ + DEBUG("mon=%p, fd=%d type=%s", mon, mon->fd, bus); + int ret; + + if (mon->json) + ret = qemuMonitorJSONAttachPCIDiskController(mon, bus, guestAddr); + else + ret = qemuMonitorTextAttachPCIDiskController(mon, bus, guestAddr); + + return ret; +} diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h index 46f412e..70827c7 100644 --- a/src/qemu/qemu_monitor.h +++ b/src/qemu/qemu_monitor.h @@ -260,5 +260,8 @@ int qemuMonitorRemoveHostNetwork(qemuMonitorPtr mon, int vlan, const char *netname); +int qemuMonitorAttachPCIDiskController(qemuMonitorPtr mon, + const char *bus, + virDomainDevicePCIAddress *guestAddr); #endif /* QEMU_MONITOR_H */ diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c index 48eca13..2e605ac 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -1481,3 +1481,43 @@ int qemuMonitorJSONRemoveHostNetwork(qemuMonitorPtr mon, virJSONValueFree(reply); return ret; } + + +int qemuMonitorJSONAttachPCIDiskController(qemuMonitorPtr mon, + const char *bus, + virDomainDevicePCIAddress *guestAddr) +{ + int ret; + virJSONValuePtr cmd; + virJSONValuePtr reply = NULL; + char *dev; + + memset(guestAddr, 0, sizeof(*guestAddr)); + + if (virAsprintf(&dev, "if=%s", bus) < 0) { + virReportOOMError(NULL); + return -1; + } + + cmd = qemuMonitorJSONMakeCommand("pci_add", + "s:pci_addr", "auto", + "s:type", "storage", + "s:opts", dev, + NULL); + VIR_FREE(dev); + if (!cmd) + return -1; + + ret = qemuMonitorJSONCommand(mon, cmd, &reply); + + if (ret == 0) + ret = qemuMonitorJSONCheckError(cmd, reply); + + if (ret == 0 && + qemuMonitorJSONGetGuestAddress(reply, guestAddr) < 0) + ret = -1; + + virJSONValueFree(cmd); + virJSONValueFree(reply); + return ret; +} diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h index 9df96f5..221dfa7 100644 --- a/src/qemu/qemu_monitor_json.h +++ b/src/qemu/qemu_monitor_json.h @@ -140,4 +140,8 @@ int qemuMonitorJSONRemoveHostNetwork(qemuMonitorPtr mon, int vlan, const char *netname); +int qemuMonitorJSONAttachPCIDiskController(qemuMonitorPtr mon, + const char *bus, + virDomainDevicePCIAddress *guestAddr); + #endif /* QEMU_MONITOR_JSON_H */ diff --git a/src/qemu/qemu_monitor_text.c b/src/qemu/qemu_monitor_text.c index 27c213d..a9d8a4c 100644 --- a/src/qemu/qemu_monitor_text.c +++ b/src/qemu/qemu_monitor_text.c @@ -1577,3 +1577,46 @@ cleanup: VIR_FREE(reply); return ret; } + +int qemuMonitorTextAttachPCIDiskController(qemuMonitorPtr mon, + const char *bus, + virDomainDevicePCIAddress *guestAddr) +{ + char *cmd = NULL; + char *reply = NULL; + int tryOldSyntax = 0; + int ret = -1; + +try_command: + if (virAsprintf(&cmd, "pci_add %s storage if=%s", + (tryOldSyntax ? "0": "pci_addr=auto"), bus) < 0) { + virReportOOMError(NULL); + goto cleanup; + } + + if (qemuMonitorCommand(mon, cmd, &reply) < 0) { + qemudReportError(NULL, NULL, NULL, VIR_ERR_OPERATION_FAILED, + _("cannot attach %s disk controller"), bus); + goto cleanup; + } + + if (qemuMonitorTextParsePciAddReply(mon, reply, guestAddr) < 0) { + if (!tryOldSyntax && strstr(reply, "invalid char in expression")) { + VIR_FREE(reply); + VIR_FREE(cmd); + tryOldSyntax = 1; + goto try_command; + } + + qemudReportError (NULL, NULL, NULL, VIR_ERR_OPERATION_FAILED, + _("adding %s disk controller failed: %s"), bus, reply); + goto cleanup; + } + + ret = 0; + +cleanup: + VIR_FREE(cmd); + VIR_FREE(reply); + return ret; +} diff --git a/src/qemu/qemu_monitor_text.h b/src/qemu/qemu_monitor_text.h index f304795..0e131ea 100644 --- a/src/qemu/qemu_monitor_text.h +++ b/src/qemu/qemu_monitor_text.h @@ -140,4 +140,9 @@ int qemuMonitorTextRemoveHostNetwork(qemuMonitorPtr mon, int vlan, const char *netname); +int qemuMonitorTextAttachPCIDiskController(qemuMonitorPtr mon, + const char *bus, + virDomainDevicePCIAddress *guestAddr); + + #endif /* QEMU_MONITOR_TEXT_H */ -- 1.6.5.2

The current SCSI hotplug support attaches a brand new SCSI controller for every disk. This is broken because the semantics differ from those used when starting the VM initially. In the latter case, each SCSI controller is filled before a new one is added. If the user specifies an high drive index (sdazz) then at initial startup, many intermediate SCSI controllers may be added with no drives. This patch changes SCSI hotplug so that it exactly matches the behaviour of initial startup. First the SCSI controller number is determined for the drive to be hotplugged. If any controller upto and including that controller number is not yet present, it is attached. Then finally the drive is attached to the last controller. NB, this breaks SCSI hotunplug, because there is no 'drive_del' command in current QEMU. Previous SCSI hotunplug was broken in any case because it was unplugging the entire controller, not just the drive in question. A future QEMU will allow proper SCSI hotunplug of a drive. This patch is derived from work done by Wolfgang Mauerer on disk controllers. * src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to the correct controller, instead of just attaching a new controller. * src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h, src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h, src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add support for 'drive_add' command --- src/libvirt_private.syms | 1 + src/qemu/qemu_driver.c | 145 +++++++++++++++++++++++++++++++++++++---- src/qemu/qemu_monitor.c | 20 ++++++ src/qemu/qemu_monitor.h | 5 ++ src/qemu/qemu_monitor_json.c | 81 +++++++++++++++++++++-- src/qemu/qemu_monitor_json.h | 5 ++ src/qemu/qemu_monitor_text.c | 102 +++++++++++++++++++++++++++++ src/qemu/qemu_monitor_text.h | 5 ++ 8 files changed, 342 insertions(+), 22 deletions(-) diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 3e98800..963f9b2 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -167,6 +167,7 @@ virDomainDeviceAddressTypeToString; virDomainDefClearDynamicValues; virDomainControllerTypeToString; virDomainControllerDefFree; +virDomainDeviceAddressTypeToString; # domain_event.h diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 0a91c2a..527b5d7 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -4964,18 +4964,18 @@ static int qemudDomainAttachPciDiskDevice(virConnectPtr conn, static int qemudDomainAttachPciControllerDevice(virConnectPtr conn, struct qemud_driver *driver, virDomainObjPtr vm, - virDomainDeviceDefPtr dev) + virDomainControllerDefPtr dev) { int i, ret; - const char* type = virDomainControllerTypeToString(dev->data.controller->type); + const char* type = virDomainControllerTypeToString(dev->type); qemuDomainObjPrivatePtr priv = vm->privateData; for (i = 0 ; i < vm->def->ncontrollers ; i++) { - if ((vm->def->controllers[i]->type == dev->data.controller->type) && - (vm->def->controllers[i]->idx == dev->data.controller->idx)) { + if ((vm->def->controllers[i]->type == dev->type) && + (vm->def->controllers[i]->idx == dev->idx)) { qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED, _("target %s:%d already exists"), - type, dev->data.controller->idx); + type, dev->idx); return -1; } } @@ -4988,17 +4988,130 @@ static int qemudDomainAttachPciControllerDevice(virConnectPtr conn, qemuDomainObjEnterMonitorWithDriver(driver, vm); ret = qemuMonitorAttachPCIDiskController(priv->mon, type, - &dev->data.controller->addr.data.pci); + &dev->addr.data.pci); qemuDomainObjExitMonitorWithDriver(driver, vm); if (ret == 0) { - dev->data.controller->addr.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI; - virDomainControllerInsertPreAlloced(vm->def, dev->data.controller); + dev->addr.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI; + virDomainControllerInsertPreAlloced(vm->def, dev); } return ret; } +static virDomainControllerDefPtr +qemuDomainFindOrCreateSCSIDiskController(virConnectPtr conn, + struct qemud_driver *driver, + virDomainObjPtr vm, + int controller) +{ + int i; + virDomainControllerDefPtr cont; + for (i = 0 ; i < vm->def->ncontrollers ; i++) { + cont = vm->def->controllers[i]; + + if (cont->type != VIR_DOMAIN_CONTROLLER_TYPE_SCSI) + continue; + + if (cont->idx == controller) + return cont; + } + + /* No SCSI controller present, for back compatability we + * now hotplug a controller */ + if (VIR_ALLOC(cont) < 0) { + virReportOOMError(conn); + return NULL; + } + cont->type = VIR_DOMAIN_CONTROLLER_TYPE_SCSI; + cont->idx = 0; + + VIR_INFO0("No SCSI controller present, hotplugging one"); + if (qemudDomainAttachPciControllerDevice(conn, driver, + vm, cont) < 0) { + VIR_FREE(cont); + return NULL; + } + return cont; +} + +static int qemudDomainAttachSCSIDisk(virConnectPtr conn, + struct qemud_driver *driver, + virDomainObjPtr vm, + virDomainDiskDefPtr dev, + int qemuCmdFlags) +{ + int i; + qemuDomainObjPrivatePtr priv = vm->privateData; + virDomainDeviceDriveAddress driveAddr; + virDomainControllerDefPtr cont; + char *drivestr = NULL; + int ret = -1; + + for (i = 0 ; i < vm->def->ndisks ; i++) { + if (STREQ(vm->def->disks[i]->dst, dev->dst)) { + qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED, + _("target %s already exists"), dev->dst); + goto cleanup; + } + } + + /* This func allocates the bus/unit IDs so must be before + * we search for controller + */ + if (qemuBuildDriveStr(conn, dev, 0, qemuCmdFlags, &drivestr) < 0) + goto cleanup; + + + /* We should have an adddress now, so make sure */ + if (dev->addr.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) { + qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, + _("unexpected disk address type %s"), + virDomainDeviceAddressTypeToString(dev->addr.type)); + goto cleanup; + } + + for (i = 0 ; i < dev->addr.data.drive.controller ; i++) { + cont = qemuDomainFindOrCreateSCSIDiskController(conn, driver, vm, i); + if (!cont) + goto cleanup; + } + + if (cont->addr.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) { + qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, + _("SCSI controller %d was missing its PCI address"), cont->idx); + goto cleanup; + } + + if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) { + virReportOOMError(conn); + goto cleanup; + } + + qemuDomainObjEnterMonitorWithDriver(driver, vm); + ret = qemuMonitorAttachDrive(priv->mon, + drivestr, + &cont->addr.data.pci, + &driveAddr); + + qemuDomainObjExitMonitorWithDriver(driver, vm); + + if (ret == 0) { + if (dev->addr.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE || + dev->addr.mode == VIR_DOMAIN_DEVICE_ADDRESS_MODE_DYNAMIC) { + dev->addr.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE; + dev->addr.mode = VIR_DOMAIN_DEVICE_ADDRESS_MODE_DYNAMIC; + memcpy(&dev->addr.data.drive, &driveAddr, sizeof(driveAddr)); + } + virDomainDiskInsertPreAlloced(vm->def, dev); + } + +cleanup: + VIR_FREE(drivestr); + return ret; +} + + static int qemudDomainAttachUsbMassstorageDevice(virConnectPtr conn, struct qemud_driver *driver, virDomainObjPtr vm, @@ -5362,9 +5475,10 @@ static int qemudDomainAttachDevice(virDomainPtr dom, if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_USB) { ret = qemudDomainAttachUsbMassstorageDevice(dom->conn, driver, vm, dev); - } else if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_SCSI || - dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO) { + } else if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO) { ret = qemudDomainAttachPciDiskDevice(dom->conn, driver, vm, dev); + } else if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_SCSI) { + ret = qemudDomainAttachSCSIDisk(dom->conn, driver, vm, dev->data.disk, qemuCmdFlags); } else { qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT, _("disk bus '%s' cannot be hotplugged."), @@ -5385,7 +5499,8 @@ static int qemudDomainAttachDevice(virDomainPtr dom, } } else if (dev->type == VIR_DOMAIN_DEVICE_CONTROLLER) { if (dev->data.controller->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI) { - ret = qemudDomainAttachPciControllerDevice(dom->conn, driver, vm, dev); + ret = qemudDomainAttachPciControllerDevice(dom->conn, driver, vm, + dev->data.controller); } else { qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT, _("disk controller bus '%s' cannot be hotplugged."), @@ -5786,8 +5901,7 @@ static int qemudDomainDetachDevice(virDomainPtr dom, if (dev->type == VIR_DOMAIN_DEVICE_DISK && dev->data.disk->device == VIR_DOMAIN_DISK_DEVICE_DISK && - (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_SCSI || - dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO)) { + dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO) { ret = qemudDomainDetachPciDiskDevice(dom->conn, driver, vm, dev); if (driver->securityDriver) driver->securityDriver->domainRestoreSecurityImageLabel(dom->conn, vm, dev->data.disk); @@ -5806,9 +5920,10 @@ static int qemudDomainDetachDevice(virDomainPtr dom, } } else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) { ret = qemudDomainDetachHostDevice(dom->conn, driver, vm, dev); - } else + } else { qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT, - "%s", _("only SCSI or virtio disk device can be detached dynamically")); + "%s", _("This type of device cannot be hot unplugged")); + } if (!ret && virDomainSaveStatus(dom->conn, driver->caps, driver->stateDir, vm) < 0) ret = -1; diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c index 4ecbcba..30f2cce 100644 --- a/src/qemu/qemu_monitor.c +++ b/src/qemu/qemu_monitor.c @@ -1256,3 +1256,23 @@ int qemuMonitorAttachPCIDiskController(qemuMonitorPtr mon, return ret; } + + +int qemuMonitorAttachDrive(qemuMonitorPtr mon, + const char *drivestr, + virDomainDevicePCIAddress *controllerAddr, + virDomainDeviceDriveAddress *driveAddr) +{ + DEBUG("mon=%p, fd=%d drivestr=%s domain=%d bus=%d slot=%d function=%d", + mon, mon->fd, drivestr, + controllerAddr->domain, controllerAddr->bus, + controllerAddr->slot, controllerAddr->function); + int ret; + + if (mon->json) + ret = qemuMonitorJSONAttachDrive(mon, drivestr, controllerAddr, driveAddr); + else + ret = qemuMonitorTextAttachDrive(mon, drivestr, controllerAddr, driveAddr); + + return ret; +} diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h index 70827c7..fcfdcd5 100644 --- a/src/qemu/qemu_monitor.h +++ b/src/qemu/qemu_monitor.h @@ -264,4 +264,9 @@ int qemuMonitorAttachPCIDiskController(qemuMonitorPtr mon, const char *bus, virDomainDevicePCIAddress *guestAddr); +int qemuMonitorAttachDrive(qemuMonitorPtr mon, + const char *drivestr, + virDomainDevicePCIAddress *controllerAddr, + virDomainDeviceDriveAddress *driveAddr); + #endif /* QEMU_MONITOR_H */ diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c index 2e605ac..61df373 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -1202,10 +1202,9 @@ int qemuMonitorJSONAddUSBDeviceMatch(qemuMonitorPtr mon, } -/* XXX qemu also returns a 'function' number now */ static int -qemuMonitorJSONGetGuestAddress(virJSONValuePtr reply, - virDomainDevicePCIAddress *guestAddr) +qemuMonitorJSONGetGuestPCIAddress(virJSONValuePtr reply, + virDomainDevicePCIAddress *guestAddr) { virJSONValuePtr addr; @@ -1277,7 +1276,7 @@ int qemuMonitorJSONAddPCIHostDevice(qemuMonitorPtr mon, ret = qemuMonitorJSONCheckError(cmd, reply); if (ret == 0 && - qemuMonitorJSONGetGuestAddress(reply, guestAddr) < 0) + qemuMonitorJSONGetGuestPCIAddress(reply, guestAddr) < 0) ret = -1; virJSONValueFree(cmd); @@ -1318,7 +1317,7 @@ int qemuMonitorJSONAddPCIDisk(qemuMonitorPtr mon, ret = qemuMonitorJSONCheckError(cmd, reply); if (ret == 0 && - qemuMonitorJSONGetGuestAddress(reply, guestAddr) < 0) + qemuMonitorJSONGetGuestPCIAddress(reply, guestAddr) < 0) ret = -1; virJSONValueFree(cmd); @@ -1350,7 +1349,7 @@ int qemuMonitorJSONAddPCINetwork(qemuMonitorPtr mon, ret = qemuMonitorJSONCheckError(cmd, reply); if (ret == 0 && - qemuMonitorJSONGetGuestAddress(reply, guestAddr) < 0) + qemuMonitorJSONGetGuestPCIAddress(reply, guestAddr) < 0) ret = -1; virJSONValueFree(cmd); @@ -1514,7 +1513,75 @@ int qemuMonitorJSONAttachPCIDiskController(qemuMonitorPtr mon, ret = qemuMonitorJSONCheckError(cmd, reply); if (ret == 0 && - qemuMonitorJSONGetGuestAddress(reply, guestAddr) < 0) + qemuMonitorJSONGetGuestPCIAddress(reply, guestAddr) < 0) + ret = -1; + + virJSONValueFree(cmd); + virJSONValueFree(reply); + return ret; +} + + +static int +qemuMonitorJSONGetGuestDriveAddress(virJSONValuePtr reply, + virDomainDeviceDriveAddress *driveAddr) +{ + virJSONValuePtr addr; + + addr = virJSONValueObjectGet(reply, "return"); + if (!addr || addr->type != VIR_JSON_TYPE_OBJECT) { + qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR, + _("drive_add reply was missing device address")); + return -1; + } + + if (virJSONValueObjectGetNumberUint(addr, "bus", &driveAddr->bus) < 0) { + qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR, + _("drive_add reply was missing device bus number")); + return -1; + } + + if (virJSONValueObjectGetNumberUint(addr, "unit", &driveAddr->unit) < 0) { + qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR, + _("drive_add reply was missing device unit number")); + return -1; + } + + return 0; +} + + +int qemuMonitorJSONAttachDrive(qemuMonitorPtr mon, + const char *drivestr, + virDomainDevicePCIAddress* controllerAddr, + virDomainDeviceDriveAddress* driveAddr) +{ + int ret; + virJSONValuePtr cmd = NULL; + virJSONValuePtr reply = NULL; + char *dev; + + if (virAsprintf(&dev, "%.2x:%.2x.%.1x", + controllerAddr->bus, controllerAddr->slot, controllerAddr->function) < 0) { + virReportOOMError(NULL); + return -1; + } + + cmd = qemuMonitorJSONMakeCommand("drive_add", + "s:pci_addr", dev, + "s:opts", drivestr, + NULL); + VIR_FREE(dev); + if (!cmd) + return -1; + + ret = qemuMonitorJSONCommand(mon, cmd, &reply); + + if (ret == 0) + ret = qemuMonitorJSONCheckError(cmd, reply); + + if (ret == 0 && + qemuMonitorJSONGetGuestDriveAddress(reply, driveAddr) < 0) ret = -1; virJSONValueFree(cmd); diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h index 221dfa7..1997dbb 100644 --- a/src/qemu/qemu_monitor_json.h +++ b/src/qemu/qemu_monitor_json.h @@ -144,4 +144,9 @@ int qemuMonitorJSONAttachPCIDiskController(qemuMonitorPtr mon, const char *bus, virDomainDevicePCIAddress *guestAddr); +int qemuMonitorJSONAttachDrive(qemuMonitorPtr mon, + const char *drivestr, + virDomainDevicePCIAddress *controllerAddr, + virDomainDeviceDriveAddress *driveAddr); + #endif /* QEMU_MONITOR_JSON_H */ diff --git a/src/qemu/qemu_monitor_text.c b/src/qemu/qemu_monitor_text.c index a9d8a4c..16bc81f 100644 --- a/src/qemu/qemu_monitor_text.c +++ b/src/qemu/qemu_monitor_text.c @@ -1620,3 +1620,105 @@ cleanup: VIR_FREE(reply); return ret; } + + +static int +qemudParseDriveAddReply(const char *reply, + virDomainDeviceDriveAddressPtr addr) +{ + char *s, *e; + + /* If the command succeeds qemu prints: + * OK bus X, unit Y + */ + + if (!(s = strstr(reply, "OK "))) + return -1; + + s += 3; + + if (STRPREFIX(s, "bus ")) { + s += strlen("bus "); + + if (virStrToLong_ui(s, &e, 10, &addr->bus) == -1) { + VIR_WARN(_("Unable to parse bus '%s'\n"), s); + return -1; + } + + if (!STRPREFIX(e, ", ")) { + VIR_WARN(_("Expected ', ' parsing drive_add reply '%s'\n"), s); + return -1; + } + s = e + 2; + } + + if (!STRPREFIX(s, "unit ")) { + VIR_WARN(_("Expected 'unit ' parsing drive_add reply '%s'\n"), s); + return -1; + } + s += strlen("bus "); + + if (virStrToLong_ui(s, &e, 10, &addr->unit) == -1) { + VIR_WARN(_("Unable to parse unit number '%s'\n"), s); + return -1; + } + + return 0; +} + + +int qemuMonitorTextAttachDrive(qemuMonitorPtr mon, + const char *drivestr, + virDomainDevicePCIAddress *controllerAddr, + virDomainDeviceDriveAddress *driveAddr) +{ + char *cmd = NULL; + char *reply = NULL; + int ret = -1; + char *safe_str; + int tryOldSyntax = 0; + + safe_str = qemuMonitorEscapeArg(drivestr); + if (!safe_str) { + virReportOOMError(NULL); + return -1; + } + +try_command: + ret = virAsprintf(&cmd, "drive_add %s%.2x:%.2x:%.2x %s", + (tryOldSyntax ? "" : "pci_addr="), + controllerAddr->domain, controllerAddr->bus, + controllerAddr->slot, safe_str); + if (ret == -1) { + virReportOOMError(NULL); + goto cleanup; + } + + if (qemuMonitorCommand(mon, cmd, &reply) < 0) { + qemudReportError(NULL, NULL, NULL, VIR_ERR_OPERATION_FAILED, + _("failed to close fd in qemu with '%s'"), cmd); + goto cleanup; + } + + if (qemudParseDriveAddReply(reply, driveAddr) < 0) { + if (!tryOldSyntax && strstr(reply, "invalid char in expression")) { + VIR_FREE(reply); + tryOldSyntax = 1; + goto try_command; + } + qemudReportError (NULL, NULL, NULL, VIR_ERR_OPERATION_FAILED, + _("adding %s disk failed: %s"), drivestr, reply); + VIR_FREE(reply); + return -1; + } + + ret = 0; + +cleanup: + VIR_FREE(cmd); + VIR_FREE(reply); + VIR_FREE(safe_str); + return ret; +} + + diff --git a/src/qemu/qemu_monitor_text.h b/src/qemu/qemu_monitor_text.h index 0e131ea..94fcc02 100644 --- a/src/qemu/qemu_monitor_text.h +++ b/src/qemu/qemu_monitor_text.h @@ -144,5 +144,10 @@ int qemuMonitorTextAttachPCIDiskController(qemuMonitorPtr mon, const char *bus, virDomainDevicePCIAddress *guestAddr); +int qemuMonitorTextAttachDrive(qemuMonitorPtr mon, + const char *drivestr, + virDomainDevicePCIAddress *controllerAddr, + virDomainDeviceDriveAddress *driveAddr); + #endif /* QEMU_MONITOR_TEXT_H */ -- 1.6.5.2