This change adjusts the XML parsing routines so that they will preserve the context node when evaluating XPath expressions. This allows us to use relative XPath expressions reliably in the parsers. Needed one tiny fix to a typo in the Xen driver to work xml.c | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) Daniel diff -r e72258d9d0d1 src/xml.c --- a/src/xml.c Mon Jul 07 11:13:21 2008 +0100 +++ b/src/xml.c Mon Jul 07 11:37:50 2008 +0100 @@ -386,6 +386,7 @@ virXPathString(const char *xpath, xmlXPathContextPtr ctxt) { xmlXPathObjectPtr obj; + xmlNodePtr relnode; char *ret; if ((ctxt == NULL) || (xpath == NULL)) { @@ -393,6 +394,7 @@ _("Invalid parameter to virXPathString()"), 0); return (NULL); } + relnode = ctxt->node; obj = xmlXPathEval(BAD_CAST xpath, ctxt); if ((obj == NULL) || (obj->type != XPATH_STRING) || (obj->stringval == NULL) || (obj->stringval[0] == 0)) { @@ -404,6 +406,7 @@ if (ret == NULL) { virXMLError(NULL, VIR_ERR_NO_MEMORY, _("strdup failed"), 0); } + ctxt->node = relnode; return (ret); } @@ -422,21 +425,25 @@ virXPathNumber(const char *xpath, xmlXPathContextPtr ctxt, double *value) { xmlXPathObjectPtr obj; + xmlNodePtr relnode; if ((ctxt == NULL) || (xpath == NULL) || (value == NULL)) { virXMLError(NULL, VIR_ERR_INTERNAL_ERROR, _("Invalid parameter to virXPathNumber()"), 0); return (-1); } + relnode = ctxt->node; obj = xmlXPathEval(BAD_CAST xpath, ctxt); if ((obj == NULL) || (obj->type != XPATH_NUMBER) || (isnan(obj->floatval))) { xmlXPathFreeObject(obj); + ctxt->node = relnode; return (-1); } *value = obj->floatval; xmlXPathFreeObject(obj); + ctxt->node = relnode; return (0); } @@ -456,6 +463,7 @@ virXPathLong(const char *xpath, xmlXPathContextPtr ctxt, long *value) { xmlXPathObjectPtr obj; + xmlNodePtr relnode; int ret = 0; if ((ctxt == NULL) || (xpath == NULL) || (value == NULL)) { @@ -463,6 +471,7 @@ _("Invalid parameter to virXPathNumber()"), 0); return (-1); } + relnode = ctxt->node; obj = xmlXPathEval(BAD_CAST xpath, ctxt); if ((obj != NULL) && (obj->type == XPATH_STRING) && (obj->stringval != NULL) && (obj->stringval[0] != 0)) { @@ -486,6 +495,7 @@ } xmlXPathFreeObject(obj); + ctxt->node = relnode; return (ret); } @@ -502,6 +512,7 @@ virXPathBoolean(const char *xpath, xmlXPathContextPtr ctxt) { xmlXPathObjectPtr obj; + xmlNodePtr relnode; int ret; if ((ctxt == NULL) || (xpath == NULL)) { @@ -509,6 +520,7 @@ _("Invalid parameter to virXPathBoolean()"), 0); return (-1); } + relnode = ctxt->node; obj = xmlXPathEval(BAD_CAST xpath, ctxt); if ((obj == NULL) || (obj->type != XPATH_BOOLEAN) || (obj->boolval < 0) || (obj->boolval > 1)) { @@ -518,6 +530,7 @@ ret = obj->boolval; xmlXPathFreeObject(obj); + ctxt->node = relnode; return (ret); } @@ -535,6 +548,7 @@ virXPathNode(const char *xpath, xmlXPathContextPtr ctxt) { xmlXPathObjectPtr obj; + xmlNodePtr relnode; xmlNodePtr ret; if ((ctxt == NULL) || (xpath == NULL)) { @@ -542,16 +556,19 @@ _("Invalid parameter to virXPathNode()"), 0); return (NULL); } + relnode = ctxt->node; obj = xmlXPathEval(BAD_CAST xpath, ctxt); if ((obj == NULL) || (obj->type != XPATH_NODESET) || (obj->nodesetval == NULL) || (obj->nodesetval->nodeNr <= 0) || (obj->nodesetval->nodeTab == NULL)) { xmlXPathFreeObject(obj); + ctxt->node = relnode; return (NULL); } ret = obj->nodesetval->nodeTab[0]; xmlXPathFreeObject(obj); + ctxt->node = relnode; return (ret); } @@ -571,6 +588,7 @@ xmlNodePtr ** list) { xmlXPathObjectPtr obj; + xmlNodePtr relnode; int ret; if ((ctxt == NULL) || (xpath == NULL)) { @@ -578,6 +596,7 @@ _("Invalid parameter to virXPathNodeSet()"), 0); return (-1); } + relnode = ctxt->node; obj = xmlXPathEval(BAD_CAST xpath, ctxt); if ((obj == NULL) || (obj->type != XPATH_NODESET) || (obj->nodesetval == NULL) || (obj->nodesetval->nodeNr <= 0) || @@ -585,6 +604,7 @@ xmlXPathFreeObject(obj); if (list != NULL) *list = NULL; + ctxt->node = relnode; return (-1); } @@ -601,6 +621,7 @@ } } xmlXPathFreeObject(obj); + ctxt->node = relnode; return (ret); } @@ -1139,7 +1160,7 @@ goto error; virBufferVSprintf(buf, "(serial %s)", scratch); } else { - res = virXPathBoolean("count(domain/devices/console) > 0", ctxt); + res = virXPathBoolean("count(/domain/devices/console) > 0", ctxt); if (res < 0) { virXMLError(conn, VIR_ERR_XML_ERROR, NULL, 0); goto error; -- |: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :| |: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|

We currently have five drivers which handle the domain XML containing duplicated parsers and formatters for the XML with varying degrees of buginess, and often very similar structs. This patch introduces a new general purpose internal API for parsing and formatting network XML, and representing it as a series of structs. This code is derived from the current equivalent code in the QEMU driver for domains, but with alot of extra config parsing added for stuff needed by the Xen drivers. I have not yet added the extra bits needed by the container based drivers, LXC and OpenVZ, but don't anticipate any problems in this regard. Again the naming conventions I'm adopting in this patch follow those in the storage and network drivers: - virDomainPtr - the public opaque object in libvirt.h - virDomainObjPtr - the primary internal object for domain state - virDomainDefPtr - the configuration data for a domain A virDomainObjPtr contains a reference to one or two virDomainDefPtr objects - the current live config, and potentially a secondary inactive config which will become live at the next restart. The structs are defined in domain_conf.h, along with a bunch of APIs for dealing with them. These APIs are the same as similarly named ones from the current qemu driver, but I'll go over them again for a reminder: virDomainObjPtr virDomainFindByUUID(const virDomainObjPtr doms, const unsigned char *uuid); virDomainObjPtr virDomainFindByName(const virDomainObjPtr doms, const char *name); virDomainObjPtr virDomainFindByID(const virDomainObjPtr doms, const char *id); Allow lookup of a virDomainObjPtr object based on its name, ID or UUID, as typically obtained from the public virDomainPtr object. The 'doms' parameter to both of thse is a linked list of domains which are currently known to the driver using this API. Not all drivers will use these APIs - the Xen driver will just query XenD - these are only for drivers which maintain state internally with the libvirt daemon. void virDomainGraphicsDefFree(virDomainGraphicsDefPtr def); void virDomainInputDefFree(virDomainInputDefPtr def); void virDomainDiskDefFree(virDomainDiskDefPtr def); void virDomainNetDefFree(virDomainNetDefPtr def); void virDomainChrDefFree(virDomainChrDefPtr def); void virDomainSoundDefFree(virDomainSoundDefPtr def); void virDomainDefFree(virDomainDefPtr def); void virDomainObjFree(virDomainObjPtr net); Convenience APIs to totally free the memory associated with these objects. virDomainObjPtr virDomainAssignDef(virConnectPtr conn, virDomainObjPtr *doms, const virDomainDefPtr def); Given a virDomainDefPtr object, it'll search for a pre-existing virDomainObjPtr object with matching config. If one is found, its config will be updated, otherwise a new object will be allocated. void virDomainRemoveInactive(virDomainObjPtr *doms, const virDomainObjPtr dom); Convenience for removing and free'ing a virDomainObjPtr object in the current list of active domains. virDomainDefPtr virDomainDefParseString(virConnectPtr conn, virCapsPtr caps, const char *xmlStr); virDomainDefPtr virDomainDefParseFile(virConnectPtr conn, virCapsPtr caps, const char *filename); virDomainDefPtr virDomainDefParseNode(virConnectPtr conn, virCapsPtr caps, xmlDocPtr doc, xmlNodePtr root); Based on DV's suggestion the parsing methods have changed slightly so instead of only allowing a string to be parsed, we can directly parse a file, or a XML node object. This is a little more advanced than the network parser because the various hypervisor drivers have slightly varying capabilities. So we pass a virCapsPtr object in so the parser can validate against the actual driver's capabilities. I'd like to extend the capabilities format to cover things like the boot parameters supported - eg PXE vs kernel+initrd vs bootloader vs BIOS, so we can further validate at time of parsing, instead of time of use. char *virDomainDefFormat(virConnectPtr conn, const virDomainDefPtr def, int secure); Given a virDomainDefPtr object, generate a XML document describing the domain. The secure flag controls whether passwords are included in the XML output. int virDomainCpuSetParse(virConnectPtr conn, const char **str, char sep, char *cpuset, int maxcpu); char *virDomainCpuSetFormat(virConnectPtr conn, char *cpuset, int maxcpu); These are just the APIs for dealing with CPU ranges moved from the xml.c file so they are in the expected place. A future patch will remove them from xml.c when the Xen driver is ported to this API. VIR_ENUM_DECL(virDomainVirt) VIR_ENUM_DECL(virDomainBoot) VIR_ENUM_DECL(virDomainFeature) VIR_ENUM_DECL(virDomainLifecycle) VIR_ENUM_DECL(virDomainDisk) VIR_ENUM_DECL(virDomainDiskDevice) VIR_ENUM_DECL(virDomainDiskBus) VIR_ENUM_DECL(virDomainNet) VIR_ENUM_DECL(virDomainChr) VIR_ENUM_DECL(virDomainSoundModel) VIR_ENUM_DECL(virDomainInput) VIR_ENUM_DECL(virDomainInputBus) VIR_ENUM_DECL(virDomainGraphics) This provides prototypes for all the enumerations useful to drivers using this API and struct definitions. For drivers which no other persistent storage native to their virt type, there are helper methods for loading and saving the XML configs to files. This is primarily for QEMU and LXC drivers int virDomainSaveConfig(virConnectPtr conn, const char *configDir, const char *autostartDir, virDomainObjPtr dom); virDomainObjPtr virDomainLoadConfig(virConnectPtr conn, virCapsPtr caps, virDomainObjPtr *doms, const char *configDir, const char *autostartDir, const char *file); int virDomainLoadAllConfigs(virConnectPtr conn, virCapsPtr caps, virDomainObjPtr *doms, const char *configDir, const char *autostartDir); int virDomainDeleteConfig(virConnectPtr conn, virDomainObjPtr dom); As a mentioned earlier, the impl of these APIs is just copied from the QEMU driver, but instead of using pre-declared char[PATH_MAX] fields, we allocate memory for strings as required. This dramatically reduces the memory needs of the QEMU driver (when ported to this API). It also switches to use the xml.c convenience routines instead of the regular libxml2 APIs, and in doing so I added a couple more convenience routines. There is no test suite explicitly against these parsers because when the QEMU and Xen drivers are ported to this API their existing test suites exercise nearly all the code. b/src/domain_conf.c | 2884 ++++++++++++++++++++++++++++++++++++++++++++ b/src/domain_conf.h | 489 +++++++ include/libvirt/virterror.h | 1 po/POTFILES.in | 1 src/Makefile.am | 1 src/util.h | 2 src/virterror.c | 3 src/xml.c | 18 src/xml.h | 10 9 files changed, 3403 insertions(+), 6 deletions(-) Daniel diff -r a77ea50ba693 include/libvirt/virterror.h --- a/include/libvirt/virterror.h Tue Jul 08 15:26:26 2008 +0100 +++ b/include/libvirt/virterror.h Tue Jul 08 15:26:51 2008 +0100 @@ -57,6 +57,7 @@ VIR_FROM_LXC, /* Error from Linux Container driver */ VIR_FROM_STORAGE, /* Error from storage driver */ VIR_FROM_NETWORK, /* Error from network config */ + VIR_FROM_DOMAIN, /* Error from domain config */ } virErrorDomain; diff -r a77ea50ba693 po/POTFILES.in --- a/po/POTFILES.in Tue Jul 08 15:26:26 2008 +0100 +++ b/po/POTFILES.in Tue Jul 08 15:26:51 2008 +0100 @@ -3,6 +3,7 @@ qemud/remote.c src/conf.c src/console.c +src/domain_conf.c src/hash.c src/iptables.c src/libvirt.c diff -r a77ea50ba693 src/Makefile.am --- a/src/Makefile.am Tue Jul 08 15:26:26 2008 +0100 +++ b/src/Makefile.am Tue Jul 08 15:26:51 2008 +0100 @@ -39,6 +39,7 @@ test.c test.h \ buf.c buf.h \ qparams.c qparams.h \ + domain_conf.c domain_conf.h \ capabilities.c capabilities.h \ xml.c xml.h \ event.c event.h \ diff -r a77ea50ba693 src/domain_conf.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/domain_conf.c Tue Jul 08 15:26:51 2008 +0100 @@ -0,0 +1,2884 @@ +/* + * domain_conf.c: domain XML processing + * + * Copyright (C) 2006-2008 Red Hat, Inc. + * Copyright (C) 2006-2008 Daniel P. Berrange + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Daniel P. Berrange <berrange(a)redhat.com&gt; + */ + +#include <config.h> + +#include <sys/types.h> +#include <unistd.h> +#include <fcntl.h> +#include <dirent.h> + +#include "internal.h" + +#include "domain_conf.h" +#include "memory.h" +#include "verify.h" +#include "xml.h" +#include "uuid.h" +#include "util.h" +#include "buf.h" +#include "c-ctype.h" + +VIR_ENUM_IMPL(virDomainVirt, VIR_DOMAIN_VIRT_LAST, + "qemu", + "kqemu", + "kvm", + "xen", + "lxc", + "uml", + "openvz", + "vserver", + "ldom", + "test", + "vmware", + "hyperv") + +VIR_ENUM_IMPL(virDomainBoot, VIR_DOMAIN_BOOT_LAST, + "fd", + "cdrom", + "hd", + "network") + +VIR_ENUM_IMPL(virDomainFeature, VIR_DOMAIN_FEATURE_LAST, + "acpi", + "apic", + "pae") + +VIR_ENUM_IMPL(virDomainLifecycle, VIR_DOMAIN_LIFECYCLE_LAST, + "destroy", + "restart", + "rename-restart", + "preserve") + +VIR_ENUM_IMPL(virDomainDisk, VIR_DOMAIN_DISK_TYPE_LAST, + "block", + "file") + +VIR_ENUM_IMPL(virDomainDiskDevice, VIR_DOMAIN_DISK_DEVICE_LAST, + "disk", + "cdrom", + "floppy") + +VIR_ENUM_IMPL(virDomainDiskBus, VIR_DOMAIN_DISK_BUS_LAST, + "ide", + "fdc", + "scsi", + "virtio", + "xen") + +VIR_ENUM_IMPL(virDomainNet, VIR_DOMAIN_NET_TYPE_LAST, + "user", + "ethernet", + "server", + "client", + "mcast", + "network", + "bridge") + +VIR_ENUM_IMPL(virDomainChr, VIR_DOMAIN_CHR_TYPE_LAST, + "null", + "vc", + "pty", + "dev", + "file", + "pipe", + "stdio", + "udp", + "tcp", + "unix") + +VIR_ENUM_IMPL(virDomainSoundModel, VIR_DOMAIN_SOUND_MODEL_LAST, + "sb16", + "es1370", + "pcspk"); + +VIR_ENUM_IMPL(virDomainInput, VIR_DOMAIN_INPUT_TYPE_LAST, + "mouse", + "tablet") + +VIR_ENUM_IMPL(virDomainInputBus, VIR_DOMAIN_INPUT_BUS_LAST, + "ps2", + "usb", + "xen") + +VIR_ENUM_IMPL(virDomainGraphics, VIR_DOMAIN_GRAPHICS_TYPE_LAST, + "sdl", + "vnc") + + +static void virDomainReportError(virConnectPtr conn, + int code, const char *fmt, ...) +{ + va_list args; + char errorMessage[1024]; + const char *virerr; + + if (fmt) { + va_start(args, fmt); + vsnprintf(errorMessage, sizeof(errorMessage)-1, fmt, args); + va_end(args); + } else { + errorMessage[0] = '\0'; + } + + virerr = __virErrorMsg(code, (errorMessage[0] ? errorMessage : NULL)); + __virRaiseError(conn, NULL, NULL, VIR_FROM_DOMAIN, code, VIR_ERR_ERROR, + virerr, errorMessage, NULL, -1, -1, virerr, errorMessage); +} + + +virDomainObjPtr virDomainFindByID(const virDomainObjPtr doms, + int id) +{ + virDomainObjPtr dom = doms; + while (dom) { + if (virDomainIsActive(dom) && dom->def->id == id) + return dom; + dom = dom->next; + } + + return NULL; +} + + +virDomainObjPtr virDomainFindByUUID(const virDomainObjPtr doms, + const unsigned char *uuid) +{ + virDomainObjPtr dom = doms; + + while (dom) { + if (!memcmp(dom->def->uuid, uuid, VIR_UUID_BUFLEN)) + return dom; + dom = dom->next; + } + + return NULL; +} + +virDomainObjPtr virDomainFindByName(const virDomainObjPtr doms, + const char *name) +{ + virDomainObjPtr dom = doms; + + while (dom) { + if (STREQ(dom->def->name, name)) + return dom; + dom = dom->next; + } + + return NULL; +} + +void virDomainGraphicsDefFree(virDomainGraphicsDefPtr def) +{ + if (!def) + return; + + switch (def->type) { + case VIR_DOMAIN_GRAPHICS_TYPE_VNC: + VIR_FREE(def->data.vnc.listenAddr); + VIR_FREE(def->data.vnc.keymap); + VIR_FREE(def->data.vnc.passwd); + break; + + case VIR_DOMAIN_GRAPHICS_TYPE_SDL: + VIR_FREE(def->data.sdl.display); + VIR_FREE(def->data.sdl.xauth); + break; + } + + VIR_FREE(def); +} + +void virDomainInputDefFree(virDomainInputDefPtr def) +{ + if (!def) + return; + + virDomainInputDefFree(def->next); + VIR_FREE(def); +} + +void virDomainDiskDefFree(virDomainDiskDefPtr def) +{ + if (!def) + return; + + VIR_FREE(def->src); + VIR_FREE(def->dst); + VIR_FREE(def->driverName); + VIR_FREE(def->driverType); + + virDomainDiskDefFree(def->next); + VIR_FREE(def); +} + +void virDomainNetDefFree(virDomainNetDefPtr def) +{ + if (!def) + return; + + VIR_FREE(def->model); + + switch (def->type) { + case VIR_DOMAIN_NET_TYPE_ETHERNET: + VIR_FREE(def->data.ethernet.dev); + VIR_FREE(def->data.ethernet.script); + VIR_FREE(def->data.ethernet.ipaddr); + break; + + case VIR_DOMAIN_NET_TYPE_SERVER: + case VIR_DOMAIN_NET_TYPE_CLIENT: + case VIR_DOMAIN_NET_TYPE_MCAST: + VIR_FREE(def->data.socket.address); + break; + + case VIR_DOMAIN_NET_TYPE_NETWORK: + VIR_FREE(def->data.network.name); + break; + + case VIR_DOMAIN_NET_TYPE_BRIDGE: + VIR_FREE(def->data.bridge.brname); + break; + } + + VIR_FREE(def->ifname); + virDomainNetDefFree(def->next); + VIR_FREE(def); +} + +void virDomainChrDefFree(virDomainChrDefPtr def) +{ + if (!def) + return; + + switch (def->type) { + case VIR_DOMAIN_CHR_TYPE_PTY: + case VIR_DOMAIN_CHR_TYPE_DEV: + case VIR_DOMAIN_CHR_TYPE_FILE: + case VIR_DOMAIN_CHR_TYPE_PIPE: + VIR_FREE(def->data.file.path); + break; + + case VIR_DOMAIN_CHR_TYPE_UDP: + VIR_FREE(def->data.udp.bindHost); + VIR_FREE(def->data.udp.bindService); + VIR_FREE(def->data.udp.connectHost); + VIR_FREE(def->data.udp.connectService); + break; + + case VIR_DOMAIN_CHR_TYPE_TCP: + VIR_FREE(def->data.tcp.host); + VIR_FREE(def->data.tcp.service); + break; + + case VIR_DOMAIN_CHR_TYPE_UNIX: + VIR_FREE(def->data.nix.path); + break; + } + + virDomainChrDefFree(def->next); + VIR_FREE(def); +} + +void virDomainSoundDefFree(virDomainSoundDefPtr def) +{ + if (!def) + return; + + virDomainSoundDefFree(def->next); + VIR_FREE(def); +} + +void virDomainDeviceDefFree(virDomainDeviceDefPtr def) +{ + if (!def) + return; + + switch (def->type) { + case VIR_DOMAIN_DEVICE_DISK: + virDomainDiskDefFree(def->data.disk); + break; + case VIR_DOMAIN_DEVICE_NET: + virDomainNetDefFree(def->data.net); + break; + case VIR_DOMAIN_DEVICE_INPUT: + virDomainInputDefFree(def->data.input); + break; + case VIR_DOMAIN_DEVICE_SOUND: + virDomainSoundDefFree(def->data.sound); + break; + } + + VIR_FREE(def); +} + +void virDomainDefFree(virDomainDefPtr def) +{ + if (!def) + return; + + virDomainGraphicsDefFree(def->graphics); + virDomainInputDefFree(def->inputs); + virDomainDiskDefFree(def->disks); + virDomainNetDefFree(def->nets); + virDomainChrDefFree(def->serials); + virDomainChrDefFree(def->parallels); + virDomainChrDefFree(def->console); + virDomainSoundDefFree(def->sounds); + + + VIR_FREE(def->os.type); + VIR_FREE(def->os.arch); + VIR_FREE(def->os.machine); + VIR_FREE(def->os.kernel); + VIR_FREE(def->os.initrd); + VIR_FREE(def->os.cmdline); + VIR_FREE(def->os.root); + VIR_FREE(def->os.loader); + VIR_FREE(def->os.bootloader); + VIR_FREE(def->os.bootloaderArgs); + + VIR_FREE(def->name); + VIR_FREE(def->cpumask); + VIR_FREE(def->emulator); + + VIR_FREE(def); +} + +void virDomainObjFree(virDomainObjPtr dom) +{ + if (!dom) + return; + + virDomainDefFree(dom->def); + virDomainDefFree(dom->newDef); + + VIR_FREE(dom->vcpupids); + VIR_FREE(dom->configFile); + VIR_FREE(dom->autostartLink); + + VIR_FREE(dom); +} + +virDomainObjPtr virDomainAssignDef(virConnectPtr conn, + virDomainObjPtr *doms, + const virDomainDefPtr def) +{ + virDomainObjPtr domain; + + if ((domain = virDomainFindByName(*doms, def->name))) { + if (!virDomainIsActive(domain)) { + virDomainDefFree(domain->def); + domain->def = def; + } else { + if (domain->newDef) + virDomainDefFree(domain->newDef); + domain->newDef = def; + } + + return domain; + } + + if (VIR_ALLOC(domain) < 0) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + return NULL; + } + + domain->def = def; + domain->next = *doms; + + *doms = domain; + + return domain; +} + +void virDomainRemoveInactive(virDomainObjPtr *doms, + virDomainObjPtr dom) +{ + virDomainObjPtr prev = NULL; + virDomainObjPtr curr = *doms; + + while (curr && + curr != dom) { + prev = curr; + curr = curr->next; + } + + if (curr) { + if (prev) + prev->next = curr->next; + else + *doms = curr->next; + } + + virDomainObjFree(dom); +} + +static int virDomainDiskCompare(virDomainDiskDefPtr a, + virDomainDiskDefPtr b) { + if (a->bus == b->bus) + return virDiskNameToIndex(a->dst) - virDiskNameToIndex(b->dst); + else + return a->bus - b->bus; +} + + +/* Parse the XML definition for a disk + * @param node XML nodeset to parse for disk definition + */ +static virDomainDiskDefPtr +virDomainDiskDefParseXML(virConnectPtr conn, + xmlNodePtr node) { + virDomainDiskDefPtr def; + xmlNodePtr cur; + char *type = NULL; + char *device = NULL; + char *driverName = NULL; + char *driverType = NULL; + char *source = NULL; + char *target = NULL; + char *bus = NULL; + + if (VIR_ALLOC(def) < 0) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + return NULL; + } + + type = virXMLPropString(node, "type"); + if (type) { + if ((def->type = virDomainDiskTypeFromString(type)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unknown disk type '%s'"), type); + goto error; + } + } else { + def->type = VIR_DOMAIN_DISK_TYPE_FILE; + } + + cur = node->children; + while (cur != NULL) { + if (cur->type == XML_ELEMENT_NODE) { + if ((source == NULL) && + (xmlStrEqual(cur->name, BAD_CAST "source"))) { + + if (def->type == VIR_DOMAIN_DISK_TYPE_FILE) + source = virXMLPropString(cur, "file"); + else + source = virXMLPropString(cur, "dev"); + } else if ((target == NULL) && + (xmlStrEqual(cur->name, BAD_CAST "target"))) { + target = virXMLPropString(cur, "dev"); + bus = virXMLPropString(cur, "bus"); + } else if ((driverName == NULL) && + (xmlStrEqual(cur->name, BAD_CAST "driver"))) { + driverName = virXMLPropString(cur, "name"); + driverType = virXMLPropString(cur, "type"); + } else if (xmlStrEqual(cur->name, BAD_CAST "readonly")) { + def->readonly = 1; + } else if (xmlStrEqual(cur->name, BAD_CAST "shareable")) { + def->shared = 1; + } + } + cur = cur->next; + } + + device = virXMLPropString(node, "device"); + if (device) { + if ((def->device = virDomainDiskDeviceTypeFromString(device)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unknown disk device '%s'"), device); + goto error; + } + } else { + def->device = VIR_DOMAIN_DISK_DEVICE_DISK; + } + + /* Only CDROM and Floppy devices are allowed missing source path + * to indicate no media present */ + if (source == NULL && + def->device != VIR_DOMAIN_DISK_DEVICE_CDROM && + def->device != VIR_DOMAIN_DISK_DEVICE_FLOPPY) { + virDomainReportError(conn, VIR_ERR_NO_SOURCE, + target ? "%s" : NULL, target); + goto error; + } + + if (target == NULL) { + virDomainReportError(conn, VIR_ERR_NO_TARGET, + source ? "%s" : NULL, source); + goto error; + } + + if (def->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY && + !STRPREFIX(target, "fd")) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("Invalid floppy device name: %s"), target); + goto error; + } + + /* Force CDROM to be listed as read only */ + if (def->device == VIR_DOMAIN_DISK_DEVICE_CDROM) + def->readonly = 1; + + if (def->device == VIR_DOMAIN_DISK_DEVICE_DISK && + !STRPREFIX((const char *)target, "hd") && + !STRPREFIX((const char *)target, "sd") && + !STRPREFIX((const char *)target, "vd") && + !STRPREFIX((const char *)target, "xvd")) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("Invalid harddisk device name: %s"), target); + goto error; + } + + if (bus) { + if ((def->bus = virDomainDiskBusTypeFromString(bus)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unknown disk bus type '%s'"), bus); + goto error; + } + } else { + if (def->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) { + def->bus = VIR_DOMAIN_DISK_BUS_FDC; + } else { + if (STRPREFIX(target, "hd")) + def->bus = VIR_DOMAIN_DISK_BUS_IDE; + else if (STRPREFIX(target, "sd")) + def->bus = VIR_DOMAIN_DISK_BUS_SCSI; + else if (STRPREFIX(target, "vd")) + def->bus = VIR_DOMAIN_DISK_BUS_VIRTIO; + else if (STRPREFIX(target, "xvd")) + def->bus = VIR_DOMAIN_DISK_BUS_XEN; + else + def->bus = VIR_DOMAIN_DISK_BUS_IDE; + } + } + + if (def->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY && + def->bus != VIR_DOMAIN_DISK_BUS_FDC) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("Invalid bus type '%s' for floppy disk"), bus); + goto error; + } + if (def->device != VIR_DOMAIN_DISK_DEVICE_FLOPPY && + def->bus == VIR_DOMAIN_DISK_BUS_FDC) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("Invalid bus type '%s' for disk"), bus); + goto error; + } + + def->src = source; + source = NULL; + def->dst = target; + target = NULL; + def->driverName = driverName; + driverName = NULL; + def->driverType = driverType; + driverType = NULL; + +cleanup: + VIR_FREE(bus); + VIR_FREE(type); + VIR_FREE(target); + VIR_FREE(source); + VIR_FREE(device); + VIR_FREE(driverType); + VIR_FREE(driverName); + + return def; + + error: + virDomainDiskDefFree(def); + def = NULL; + goto cleanup; +} + + +static void virDomainNetRandomMAC(virDomainNetDefPtr def) { + /* XXX there different vendor prefixes per hypervisor */ + def->mac[0] = 0x52; + def->mac[1] = 0x54; + def->mac[2] = 0x00; + def->mac[3] = 1 + (int)(256*(rand()/(RAND_MAX+1.0))); + def->mac[4] = 1 + (int)(256*(rand()/(RAND_MAX+1.0))); + def->mac[5] = 1 + (int)(256*(rand()/(RAND_MAX+1.0))); +} + + +/* Parse the XML definition for a network interface + * @param node XML nodeset to parse for net definition + * @return 0 on success, -1 on failure + */ +static virDomainNetDefPtr +virDomainNetDefParseXML(virConnectPtr conn, + xmlNodePtr node) { + virDomainNetDefPtr def; + xmlNodePtr cur; + char *macaddr = NULL; + char *type = NULL; + char *network = NULL; + char *bridge = NULL; + char *dev = NULL; + char *ifname = NULL; + char *script = NULL; + char *address = NULL; + char *port = NULL; + char *model = NULL; + + if (VIR_ALLOC(def) < 0) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + return NULL; + } + + type = virXMLPropString(node, "type"); + if (type != NULL) { + if ((def->type = virDomainNetTypeFromString(type)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unknown interface type '%s'"), type); + goto error; + } + } else { + def->type = VIR_DOMAIN_NET_TYPE_USER; + } + + cur = node->children; + while (cur != NULL) { + if (cur->type == XML_ELEMENT_NODE) { + if ((macaddr == NULL) && + (xmlStrEqual(cur->name, BAD_CAST "mac"))) { + macaddr = virXMLPropString(cur, "address"); + } else if ((network == NULL) && + (def->type == VIR_DOMAIN_NET_TYPE_NETWORK) && + (xmlStrEqual(cur->name, BAD_CAST "source"))) { + network = virXMLPropString(cur, "network"); + } else if ((network == NULL) && + (def->type == VIR_DOMAIN_NET_TYPE_BRIDGE) && + (xmlStrEqual(cur->name, BAD_CAST "source"))) { + bridge = virXMLPropString(cur, "bridge"); + } else if ((dev == NULL) && + (def->type == VIR_DOMAIN_NET_TYPE_ETHERNET) && + xmlStrEqual(cur->name, BAD_CAST "source")) { + dev = virXMLPropString(cur, "dev"); + } else if ((network == NULL) && + ((def->type == VIR_DOMAIN_NET_TYPE_SERVER) || + (def->type == VIR_DOMAIN_NET_TYPE_CLIENT) || + (def->type == VIR_DOMAIN_NET_TYPE_MCAST)) && + (xmlStrEqual(cur->name, BAD_CAST "source"))) { + address = virXMLPropString(cur, "address"); + port = virXMLPropString(cur, "port"); + } else if ((address == NULL) && + (def->type == VIR_DOMAIN_NET_TYPE_ETHERNET) && + (xmlStrEqual(cur->name, BAD_CAST "ip"))) { + address = virXMLPropString(cur, "address"); + } else if ((ifname == NULL) && + xmlStrEqual(cur->name, BAD_CAST "target")) { + ifname = virXMLPropString(cur, "dev"); + if (STRPREFIX((const char*)ifname, "vnet")) { + /* An auto-generated target name, blank it out */ + VIR_FREE(ifname); + ifname = NULL; + } + } else if ((script == NULL) && + (def->type == VIR_DOMAIN_NET_TYPE_ETHERNET) && + xmlStrEqual(cur->name, BAD_CAST "script")) { + script = virXMLPropString(cur, "path"); + } else if (xmlStrEqual (cur->name, BAD_CAST "model")) { + model = virXMLPropString(cur, "type"); + } + } + cur = cur->next; + } + + if (macaddr) { + unsigned int mac[6]; + sscanf((const char *)macaddr, "%02x:%02x:%02x:%02x:%02x:%02x", + (unsigned int*)&mac[0], + (unsigned int*)&mac[1], + (unsigned int*)&mac[2], + (unsigned int*)&mac[3], + (unsigned int*)&mac[4], + (unsigned int*)&mac[5]); + def->mac[0] = mac[0]; + def->mac[1] = mac[1]; + def->mac[2] = mac[2]; + def->mac[3] = mac[3]; + def->mac[4] = mac[4]; + def->mac[5] = mac[5]; + } else { + virDomainNetRandomMAC(def); + } + + switch (def->type) { + case VIR_DOMAIN_NET_TYPE_NETWORK: + if (network == NULL) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("No <source> 'network' attribute specified with <interface type='network'/>")); + goto error; + } + def->data.network.name = network; + network = NULL; + break; + + case VIR_DOMAIN_NET_TYPE_ETHERNET: + + if (script != NULL) { + def->data.ethernet.script = script; + script = NULL; + } + if (dev != NULL) { + def->data.ethernet.dev = dev; + dev = NULL; + } + if (address != NULL) { + def->data.ethernet.ipaddr = address; + address = NULL; + } + break; + + case VIR_DOMAIN_NET_TYPE_BRIDGE: + if (bridge == NULL) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("No <source> 'dev' attribute specified with <interface type='bridge'/>")); + goto error; + } + def->data.bridge.brname = bridge; + bridge = NULL; + break; + + case VIR_DOMAIN_NET_TYPE_CLIENT: + case VIR_DOMAIN_NET_TYPE_SERVER: + case VIR_DOMAIN_NET_TYPE_MCAST: + if (port == NULL) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("No <source> 'port' attribute specified with socket interface")); + goto error; + } + if (virStrToLong_i(port, NULL, 10, &def->data.socket.port) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("Cannot parse <source> 'port' attribute with socket interface")); + goto error; + } + + if (address == NULL) { + if (def->type == VIR_DOMAIN_NET_TYPE_CLIENT || + def->type == VIR_DOMAIN_NET_TYPE_MCAST) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("No <source> 'address' attribute specified with socket interface")); + goto error; + } + } else { + def->data.socket.address = address; + address = NULL; + } + } + + if (ifname != NULL) { + def->ifname = ifname; + ifname = NULL; + } + + /* NIC model (see -net nic,model=?). We only check that it looks + * reasonable, not that it is a supported NIC type. FWIW kvm + * supports these types as of April 2008: + * i82551 i82557b i82559er ne2k_pci pcnet rtl8139 e1000 virtio + */ + if (model != NULL) { + int i; + for (i = 0 ; i < strlen(model) ; i++) { + int char_ok = c_isalnum(model[i]) || model[i] == '_'; + if (!char_ok) { + virDomainReportError (conn, VIR_ERR_INVALID_ARG, "%s", + _("Model name contains invalid characters")); + goto error; + } + } + def->model = model; + model = NULL; + } + +cleanup: + VIR_FREE(macaddr); + VIR_FREE(network); + VIR_FREE(address); + VIR_FREE(port); + VIR_FREE(ifname); + VIR_FREE(dev); + VIR_FREE(script); + VIR_FREE(bridge); + VIR_FREE(model); + VIR_FREE(type); + + return def; + +error: + virDomainNetDefFree(def); + def = NULL; + goto cleanup; +} + + +/* Parse the XML definition for a character device + * @param node XML nodeset to parse for net definition + * + * The XML we're dealing with looks like + * + * <serial type="pty"> + * <source path="/dev/pts/3"/> + * <target port="1"/> + * </serial> + * + * <serial type="dev"> + * <source path="/dev/ttyS0"/> + * <target port="1"/> + * </serial> + * + * <serial type="tcp"> + * <source mode="connect" host="0.0.0.0" service="2445"/> + * <target port="1"/> + * </serial> + * + * <serial type="tcp"> + * <source mode="bind" host="0.0.0.0" service="2445"/> + * <target port="1"/> + * </serial> + * + * <serial type="udp"> + * <source mode="bind" host="0.0.0.0" service="2445"/> + * <source mode="connect" host="0.0.0.0" service="2445"/> + * <target port="1"/> + * </serial> + * + * <serial type="unix"> + * <source mode="bind" path="/tmp/foo"/> + * <target port="1"/> + * </serial> + * + */ +static virDomainChrDefPtr +virDomainChrDefParseXML(virConnectPtr conn, + xmlNodePtr node) { + xmlNodePtr cur; + char *type = NULL; + char *bindHost = NULL; + char *bindService = NULL; + char *connectHost = NULL; + char *connectService = NULL; + char *path = NULL; + char *mode = NULL; + char *protocol = NULL; + virDomainChrDefPtr def; + + if (VIR_ALLOC(def) < 0) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + return NULL; + } + + def->type = VIR_DOMAIN_CHR_TYPE_PTY; + type = virXMLPropString(node, "type"); + if (type != NULL) { + if (STREQ(type, "null")) + def->type = VIR_DOMAIN_CHR_TYPE_NULL; + else if (STREQ(type, "vc")) + def->type = VIR_DOMAIN_CHR_TYPE_VC; + else if (STREQ(type, "pty")) + def->type = VIR_DOMAIN_CHR_TYPE_PTY; + else if (STREQ(type, "dev")) + def->type = VIR_DOMAIN_CHR_TYPE_DEV; + else if (STREQ(type, "file")) + def->type = VIR_DOMAIN_CHR_TYPE_FILE; + else if (STREQ(type, "pipe")) + def->type = VIR_DOMAIN_CHR_TYPE_PIPE; + else if (STREQ(type, "stdio")) + def->type = VIR_DOMAIN_CHR_TYPE_STDIO; + else if (STREQ(type, "udp")) + def->type = VIR_DOMAIN_CHR_TYPE_UDP; + else if (STREQ(type, "tcp")) + def->type = VIR_DOMAIN_CHR_TYPE_TCP; + else if (STREQ(type, "unix")) + def->type = VIR_DOMAIN_CHR_TYPE_UNIX; + else + def->type = VIR_DOMAIN_CHR_TYPE_NULL; + } + + cur = node->children; + while (cur != NULL) { + if (cur->type == XML_ELEMENT_NODE) { + if (xmlStrEqual(cur->name, BAD_CAST "source")) { + if (mode == NULL) + mode = virXMLPropString(cur, "mode"); + + switch (def->type) { + case VIR_DOMAIN_CHR_TYPE_PTY: + case VIR_DOMAIN_CHR_TYPE_DEV: + case VIR_DOMAIN_CHR_TYPE_FILE: + case VIR_DOMAIN_CHR_TYPE_PIPE: + case VIR_DOMAIN_CHR_TYPE_UNIX: + if (path == NULL) + path = virXMLPropString(cur, "path"); + + break; + + case VIR_DOMAIN_CHR_TYPE_UDP: + case VIR_DOMAIN_CHR_TYPE_TCP: + if (mode == NULL || + STREQ((const char *)mode, "connect")) { + + if (connectHost == NULL) + connectHost = virXMLPropString(cur, "host"); + if (connectService == NULL) + connectService = virXMLPropString(cur, "service"); + } else { + if (bindHost == NULL) + bindHost = virXMLPropString(cur, "host"); + if (bindService == NULL) + bindService = virXMLPropString(cur, "service"); + } + + if (def->type == VIR_DOMAIN_CHR_TYPE_UDP) { + VIR_FREE(mode); + mode = NULL; + } + } + } else if (xmlStrEqual(cur->name, BAD_CAST "protocol")) { + if (protocol == NULL) + protocol = virXMLPropString(cur, "type"); + } + } + cur = cur->next; + } + + + switch (def->type) { + case VIR_DOMAIN_CHR_TYPE_NULL: + /* Nada */ + break; + + case VIR_DOMAIN_CHR_TYPE_VC: + break; + + case VIR_DOMAIN_CHR_TYPE_PTY: + /* @path attribute is an output only property - pty is auto-allocted */ + break; + + case VIR_DOMAIN_CHR_TYPE_DEV: + case VIR_DOMAIN_CHR_TYPE_FILE: + case VIR_DOMAIN_CHR_TYPE_PIPE: + if (path == NULL) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("Missing source path attribute for char device")); + goto error; + } + + def->data.file.path = path; + path = NULL; + break; + + case VIR_DOMAIN_CHR_TYPE_STDIO: + /* Nada */ + break; + + case VIR_DOMAIN_CHR_TYPE_TCP: + if (mode == NULL || + STREQ(mode, "connect")) { + if (connectHost == NULL) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("Missing source host attribute for char device")); + goto error; + } + if (connectService == NULL) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("Missing source service attribute for char device")); + goto error; + } + + def->data.tcp.host = connectHost; + connectHost = NULL; + def->data.tcp.service = connectService; + connectService = NULL; + def->data.tcp.listen = 0; + } else { + if (bindHost == NULL) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("Missing source host attribute for char device")); + goto error; + } + if (bindService == NULL) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("Missing source service attribute for char device")); + goto error; + } + + def->data.tcp.host = bindHost; + bindHost = NULL; + def->data.tcp.service = bindService; + bindService = NULL; + def->data.tcp.listen = 1; + } + if (protocol != NULL && + STREQ(protocol, "telnet")) + def->data.tcp.protocol = VIR_DOMAIN_CHR_TCP_PROTOCOL_TELNET; + else + def->data.tcp.protocol = VIR_DOMAIN_CHR_TCP_PROTOCOL_RAW; + break; + + case VIR_DOMAIN_CHR_TYPE_UDP: + if (connectService == NULL) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("Missing source service attribute for char device")); + goto error; + } + + def->data.udp.connectHost = connectHost; + connectHost = NULL; + def->data.udp.connectService = connectService; + connectService = NULL; + + def->data.udp.bindHost = bindHost; + bindHost = NULL; + def->data.udp.bindService = bindService; + bindService = NULL; + break; + + case VIR_DOMAIN_CHR_TYPE_UNIX: + if (path == NULL) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("Missing source path attribute for char device")); + goto error; + } + + if (mode != NULL && + STRNEQ(mode, "connect")) + def->data.nix.listen = 1; + else + def->data.nix.listen = 0; + + def->data.nix.path = path; + path = NULL; + break; + } + +cleanup: + VIR_FREE(mode); + VIR_FREE(protocol); + VIR_FREE(type); + VIR_FREE(bindHost); + VIR_FREE(bindService); + VIR_FREE(connectHost); + VIR_FREE(connectService); + VIR_FREE(path); + + return def; + +error: + virDomainChrDefFree(def); + def = NULL; + goto cleanup; +} + +/* Parse the XML definition for a network interface */ +static virDomainInputDefPtr +virDomainInputDefParseXML(virConnectPtr conn, + const char *ostype, + xmlNodePtr node) { + virDomainInputDefPtr def; + char *type = NULL; + char *bus = NULL; + + if (VIR_ALLOC(def) < 0) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + return NULL; + } + + type = virXMLPropString(node, "type"); + bus = virXMLPropString(node, "bus"); + + if (!type) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("missing input device type")); + goto error; + } + + if ((def->type = virDomainInputTypeFromString(type)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unknown input device type '%s'"), type); + goto error; + } + + if (bus) { + if ((def->bus = virDomainInputBusTypeFromString(bus)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unknown input bus type '%s'"), bus); + goto error; + } + + if (STREQ(ostype, "hvm")) { + if (def->bus == VIR_DOMAIN_INPUT_BUS_PS2 && /* Only allow mouse for ps2 */ + def->type != VIR_DOMAIN_INPUT_TYPE_MOUSE) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("ps2 bus does not support %s input device"), + type); + goto error; + } + if (def->bus == VIR_DOMAIN_INPUT_BUS_XEN) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unsupported input bus %s"), + bus); + goto error; + } + } else { + if (def->bus != VIR_DOMAIN_INPUT_BUS_XEN) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unsupported input bus %s"), + bus); + } + if (def->type != VIR_DOMAIN_INPUT_TYPE_MOUSE) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("xen bus does not support %s input device"), + type); + goto error; + } + } + } else { + if (STREQ(ostype, "hvm")) { + if (def->type == VIR_DOMAIN_INPUT_TYPE_MOUSE) + def->bus = VIR_DOMAIN_INPUT_BUS_PS2; + else + def->bus = VIR_DOMAIN_INPUT_BUS_USB; + } else { + def->bus = VIR_DOMAIN_INPUT_BUS_XEN; + } + } + +cleanup: + VIR_FREE(type); + VIR_FREE(bus); + + return def; + +error: + virDomainInputDefFree(def); + def = NULL; + goto cleanup; +} + + +/* Parse the XML definition for a graphics device */ +static virDomainGraphicsDefPtr +virDomainGraphicsDefParseXML(virConnectPtr conn, + xmlNodePtr node) { + virDomainGraphicsDefPtr def; + char *type = NULL; + + if (VIR_ALLOC(def) < 0) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + return NULL; + } + + type = virXMLPropString(node, "type"); + + if (!type) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("missing graphics device type")); + goto error; + } + + if ((def->type = virDomainGraphicsTypeFromString(type)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unknown graphics device type '%s'"), type); + goto error; + } + + if (def->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC) { + char *port = virXMLPropString(node, "port"); + char *autoport; + + if (port) { + if (virStrToLong_i(port, NULL, 10, &def->data.vnc.port) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("cannot parse vnc port %s"), port); + VIR_FREE(port); + goto error; + } + VIR_FREE(port); + /* Legacy compat syntax, used -1 for auto-port */ + if (def->data.vnc.port == -1) { + def->data.vnc.port = 0; + def->data.vnc.autoport = 1; + } + } else { + def->data.vnc.port = 0; + def->data.vnc.autoport = 1; + } + + if ((autoport = virXMLPropString(node, "autoport")) != NULL) { + if (STREQ(autoport, "yes")) { + def->data.vnc.port = 0; + def->data.vnc.autoport = 1; + } + VIR_FREE(autoport); + } + + def->data.vnc.listenAddr = virXMLPropString(node, "listen"); + def->data.vnc.passwd = virXMLPropString(node, "passwd"); + def->data.vnc.keymap = virXMLPropString(node, "keymap"); + } else if (def->type == VIR_DOMAIN_GRAPHICS_TYPE_SDL) { + def->data.sdl.xauth = virXMLPropString(node, "xauth"); + def->data.sdl.display = virXMLPropString(node, "display"); + } + +cleanup: + VIR_FREE(type); + + return def; + +error: + virDomainGraphicsDefFree(def); + def = NULL; + goto cleanup; +} + + +static virDomainSoundDefPtr +virDomainSoundDefParseXML(virConnectPtr conn, + const xmlNodePtr node) { + + char *model; + virDomainSoundDefPtr def; + + if (VIR_ALLOC(def) < 0) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + return NULL; + } + + model = virXMLPropString(node, "model"); + if ((def->model = virDomainSoundModelTypeFromString(model)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unknown sound model '%s'"), model); + goto error; + } + +cleanup: + VIR_FREE(model); + + return def; + +error: + virDomainSoundDefFree(def); + def = NULL; + goto cleanup; +} + + +static int virDomainLifecycleParseXML(virConnectPtr conn, + xmlXPathContextPtr ctxt, + const char *xpath, + int *val, + int defaultVal) +{ + char *tmp = virXPathString(xpath, ctxt); + if (tmp == NULL) { + *val = defaultVal; + } else { + *val = virDomainLifecycleTypeFromString(tmp); + if (*val < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unknown lifecycle action %s"), tmp); + VIR_FREE(tmp); + return -1; + } + VIR_FREE(tmp); + } + return 0; +} + + +virDomainDeviceDefPtr virDomainDeviceDefParse(virConnectPtr conn, + const virDomainDefPtr def, + const char *xmlStr) +{ + xmlDocPtr xml; + xmlNodePtr node; + virDomainDeviceDefPtr dev = NULL; + + if (!(xml = xmlReadDoc(BAD_CAST xmlStr, "device.xml", NULL, + XML_PARSE_NOENT | XML_PARSE_NONET | + XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) { + virDomainReportError(conn, VIR_ERR_XML_ERROR, NULL); + goto error; + } + + node = xmlDocGetRootElement(xml); + if (node == NULL) { + virDomainReportError(conn, VIR_ERR_XML_ERROR, + "%s", _("missing root element")); + goto error; + } + + if (VIR_ALLOC(dev) < 0) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + goto error; + } + + if (xmlStrEqual(node->name, BAD_CAST "disk")) { + dev->type = VIR_DOMAIN_DEVICE_DISK; + if (!(dev->data.disk = virDomainDiskDefParseXML(conn, node))) + goto error; + } else if (xmlStrEqual(node->name, BAD_CAST "interface")) { + dev->type = VIR_DOMAIN_DEVICE_NET; + if (!(dev->data.net = virDomainNetDefParseXML(conn, node))) + goto error; + } else if (xmlStrEqual(node->name, BAD_CAST "input")) { + dev->type = VIR_DOMAIN_DEVICE_DISK; + if (!(dev->data.input = virDomainInputDefParseXML(conn, def->os.type, node))) + goto error; + } else if (xmlStrEqual(node->name, BAD_CAST "sound")) { + dev->type = VIR_DOMAIN_DEVICE_SOUND; + if (!(dev->data.sound = virDomainSoundDefParseXML(conn, node))) + goto error; + } else { + virDomainReportError(conn, VIR_ERR_XML_ERROR, + "%s", _("unknown device type")); + goto error; + } + + xmlFreeDoc(xml); + + return dev; + + error: + xmlFreeDoc(xml); + VIR_FREE(dev); + return NULL; +} + + +static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn, + virCapsPtr caps, + xmlXPathContextPtr ctxt) +{ + xmlNodePtr *nodes = NULL, node = NULL; + char *tmp = NULL; + int i, n; + virDomainDefPtr def; + + if (VIR_ALLOC(def) < 0) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, + "%s", _("failed to allocate space for xmlXPathContext")); + return NULL; + } + def->id = -1; + + /* Find out what type of QEMU virtualization to use */ + if (!(tmp = virXPathString("string(./@type)", ctxt))) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("missing domain type attribute")); + goto error; + } + + if ((def->virtType = virDomainVirtTypeFromString(tmp)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("invalid domain type %s"), tmp); + goto error; + } + VIR_FREE(tmp); + + /* Extract domain name */ + if (!(def->name = virXPathString("string(./name[1])", ctxt))) { + virDomainReportError(conn, VIR_ERR_NO_NAME, NULL); + goto error; + } + + /* Extract domain uuid */ + tmp = virXPathString("string(./uuid[1])", ctxt); + if (!tmp) { + int err; + if ((err = virUUIDGenerate(def->uuid))) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("Failed to generate UUID: %s"), + strerror(err)); + goto error; + } + } else { + if (virUUIDParse(tmp, def->uuid) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("malformed uuid element")); + goto error; + } + VIR_FREE(tmp); + } + + /* Extract domain memory */ + if (virXPathULong("string(./memory[1])", ctxt, &def->maxmem) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("missing memory element")); + goto error; + } + + if (virXPathULong("string(./currentMemory[1])", ctxt, &def->memory) < 0) + def->memory = def->maxmem; + + if (virXPathULong("string(./vcpu[1])", ctxt, &def->vcpus) < 0) + def->vcpus = 1; + + tmp = virXPathString("string(./vcpu[1]/@cpuset)", ctxt); + if (tmp) { + char *set = tmp; + def->cpumasklen = VIR_DOMAIN_CPUMASK_LEN; + if (VIR_ALLOC_N(def->cpumask, def->cpumasklen) < 0) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + goto error; + } + if (virDomainCpuSetParse(conn, (const char **)&set, + 0, def->cpumask, + def->cpumasklen) < 0) + goto error; + VIR_FREE(tmp); + } + + if ((n = virXPathNodeSet("./features/*", ctxt, &nodes)) > 0) { + for (i = 0 ; i < n ; i++) { + int val = virDomainFeatureTypeFromString((const char *)nodes[i]->name); + if (val < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unexpected feature %s"), + nodes[i]->name); + goto error; + } + def->features |= (1 << val); + } + } + VIR_FREE(nodes); + + if (virDomainLifecycleParseXML(conn, ctxt, "string(./on_reboot[1])", + &def->onReboot, VIR_DOMAIN_LIFECYCLE_RESTART) < 0) + goto error; + + if (virDomainLifecycleParseXML(conn, ctxt, "string(./on_poweroff[1])", + &def->onPoweroff, VIR_DOMAIN_LIFECYCLE_DESTROY) < 0) + goto error; + + if (virDomainLifecycleParseXML(conn, ctxt, "string(./on_crash[1])", + &def->onCrash, VIR_DOMAIN_LIFECYCLE_DESTROY) < 0) + goto error; + + + tmp = virXPathString("string(./clock/@offset)", ctxt); + if (tmp && STREQ(tmp, "localtime")) + def->localtime = 1; + VIR_FREE(tmp); + + def->os.bootloader = virXPathString("string(./bootloader)", ctxt); + def->os.bootloaderArgs = virXPathString("string(./bootloader_args)", ctxt); + + def->os.type = virXPathString("string(./os/type[1])", ctxt); + if (!def->os.type) { + if (def->os.bootloader) { + def->os.type = strdup("xen"); + if (!def->os.type) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + goto error; + } + } else { + virDomainReportError(conn, VIR_ERR_OS_TYPE, + "%s", _("no OS type")); + goto error; + } + } + /* + * HACK: For xen driver we previously used bogus 'linux' as the + * os type for paravirt, whereas capabilities declare it to + * be 'xen'. So we accept the former and convert + */ + if (STREQ(def->os.type, "linux") && + def->virtType == VIR_DOMAIN_VIRT_XEN) { + VIR_FREE(def->os.type); + if (!(def->os.type = strdup("xen"))) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + goto error; + } + } + + if (!virCapabilitiesSupportsGuestOSType(caps, def->os.type)) { + virDomainReportError(conn, VIR_ERR_OS_TYPE, + "%s", def->os.type); + goto error; + } + + def->os.arch = virXPathString("string(./os/type[1]/@arch)", ctxt); + if (!def->os.arch) { + const char *defaultArch = virCapabilitiesDefaultGuestArch(caps, def->os.type); + if (defaultArch == NULL) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("no supported architecture for os type '%s'"), + def->os.type); + goto error; + } + if (!(def->os.arch = strdup(defaultArch))) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + goto error; + } + } + + def->os.machine = virXPathString("string(./os/type[1]/@machine)", ctxt); + if (!def->os.machine) { + const char *defaultMachine = virCapabilitiesDefaultGuestMachine(caps, + def->os.type, + def->os.arch); + if (defaultMachine != NULL) { + if (!(def->os.machine = strdup(defaultMachine))) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + goto error; + } + } + } + + if (!def->os.bootloader) { + def->os.kernel = virXPathString("string(./os/kernel[1])", ctxt); + def->os.initrd = virXPathString("string(./os/initrd[1])", ctxt); + def->os.cmdline = virXPathString("string(./os/cmdline[1])", ctxt); + def->os.root = virXPathString("string(./os/root[1])", ctxt); + def->os.loader = virXPathString("string(./os/loader[1])", ctxt); + + /* analysis of the boot devices */ + if ((n = virXPathNodeSet("./os/boot", ctxt, &nodes)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("cannot extract boot device")); + goto error; + } + for (i = 0 ; i < n && i < VIR_DOMAIN_BOOT_LAST ; i++) { + int val; + char *dev = virXMLPropString(nodes[i], "dev"); + if (!dev) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("missing boot device")); + goto error; + } + if ((val = virDomainBootTypeFromString(dev)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unknown boot device '%s'"), + dev); + VIR_FREE(dev); + goto error; + } + VIR_FREE(dev); + def->os.bootDevs[def->os.nBootDevs++] = val; + } + if (def->os.nBootDevs == 0) { + def->os.nBootDevs = 1; + def->os.bootDevs[0] = VIR_DOMAIN_BOOT_DISK; + } + VIR_FREE(nodes); + } + + def->emulator = virXPathString("string(./devices/emulator[1])", ctxt); + if (!def->emulator) { + const char *type = virDomainVirtTypeToString(def->virtType); + if (!type) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("unknown virt type")); + goto error; + } + const char *emulator = virCapabilitiesDefaultGuestEmulator(caps, + def->os.type, + def->os.arch, + type); + if (!emulator) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("unsupported guest type")); + goto error; + } + if (!(def->emulator = strdup(emulator))) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + goto error; + } + } + + /* analysis of the disk devices */ + if ((n = virXPathNodeSet("./devices/disk", ctxt, &nodes)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("cannot extract disk devices")); + goto error; + } + for (i = 0 ; i < n ; i++) { + virDomainDiskDefPtr disk = virDomainDiskDefParseXML(conn, + nodes[i]); + if (!disk) + goto error; + + /* Maintain list in sorted order according to target device name */ + if (def->disks == NULL) { + disk->next = def->disks; + def->disks = disk; + } else { + virDomainDiskDefPtr ptr = def->disks; + while (ptr) { + if (!ptr->next || virDomainDiskCompare(disk, ptr->next) < 0) { + disk->next = ptr->next; + ptr->next = disk; + break; + } + ptr = ptr->next; + } + } + } + VIR_FREE(nodes); + + /* analysis of the network devices */ + if ((n = virXPathNodeSet("./devices/interface", ctxt, &nodes)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("cannot extract network devices")); + goto error; + } + for (i = n - 1 ; i >= 0 ; i--) { + virDomainNetDefPtr net = virDomainNetDefParseXML(conn, + nodes[i]); + if (!net) + goto error; + + net->next = def->nets; + def->nets = net; + } + VIR_FREE(nodes); + + + /* analysis of the character devices */ + if ((n = virXPathNodeSet("./devices/parallel", ctxt, &nodes)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("cannot extract parallel devices")); + goto error; + } + for (i = n - 1 ; i >= 0 ; i--) { + virDomainChrDefPtr chr = virDomainChrDefParseXML(conn, + nodes[i]); + if (!chr) + goto error; + + chr->dstPort = i; + chr->next = def->parallels; + def->parallels = chr; + } + VIR_FREE(nodes); + + if ((n = virXPathNodeSet("./devices/serial", ctxt, &nodes)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("cannot extract serial devices")); + goto error; + } + for (i = n - 1 ; i >= 0 ; i--) { + virDomainChrDefPtr chr = virDomainChrDefParseXML(conn, + nodes[i]); + if (!chr) + goto error; + + chr->dstPort = i; + chr->next = def->serials; + def->serials = chr; + } + VIR_FREE(nodes); + + /* + * If no serial devices were listed, then look for console + * devices which is the legacy syntax for the same thing + */ + if (def->serials == NULL) { + if ((node = virXPathNode("./devices/console[1]", ctxt)) != NULL) { + virDomainChrDefPtr chr = virDomainChrDefParseXML(conn, + node); + if (!chr) + goto error; + + chr->dstPort = 0; + /* + * For HVM console actually created a serial device + * while for non-HVM it was a parvirt console + */ + if (STREQ(def->os.type, "hvm")) { + chr->next = def->serials; + def->serials = chr; + } else { + def->console = chr; + } + } + } + + + /* analysis of the input devices */ + if ((n = virXPathNodeSet("./devices/input", ctxt, &nodes)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("cannot extract input devices")); + goto error; + } + for (i = n - 1 ; i >= 0 ; i--) { + virDomainInputDefPtr input = virDomainInputDefParseXML(conn, + def->os.type, + nodes[i]); + if (!input) + goto error; + + + /* With QEMU / KVM / Xen graphics, mouse + PS/2 is implicit + * with graphics, so don't store it. + * XXX will this be true for other virt types ? */ + if ((STREQ(def->os.type, "hvm") && + input->bus == VIR_DOMAIN_INPUT_BUS_PS2 && + input->type == VIR_DOMAIN_INPUT_TYPE_MOUSE) || + (STRNEQ(def->os.type, "hvm") && + input->bus == VIR_DOMAIN_INPUT_BUS_XEN && + input->type == VIR_DOMAIN_INPUT_TYPE_MOUSE)) { + virDomainInputDefFree(input); + continue; + } + + input->next = def->inputs; + def->inputs = input; + } + VIR_FREE(nodes); + + /* analysis of the input devices */ + if ((n = virXPathNodeSet("./devices/graphics", ctxt, &nodes)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("cannot extract graphics devices")); + goto error; + } + if (n > 0) { + virDomainGraphicsDefPtr graphics = virDomainGraphicsDefParseXML(conn, + nodes[0]); + if (!graphics) + goto error; + + def->graphics = graphics; + } + VIR_FREE(nodes); + + /* If graphics are enabled, there's an implicit PS2 mouse */ + if (def->graphics != NULL) { + virDomainInputDefPtr input; + + if (VIR_ALLOC(input) < 0) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + goto error; + } + if (STREQ(def->os.type, "hvm")) { + input->type = VIR_DOMAIN_INPUT_TYPE_MOUSE; + input->bus = VIR_DOMAIN_INPUT_BUS_PS2; + } else { + input->type = VIR_DOMAIN_INPUT_TYPE_MOUSE; + input->bus = VIR_DOMAIN_INPUT_BUS_XEN; + } + input->next = def->inputs; + def->inputs = input; + } + + + /* analysis of the sound devices */ + if ((n = virXPathNodeSet("./devices/sound", ctxt, &nodes)) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("cannot extract sound devices")); + goto error; + } + for (i = n - 1 ; i >= 0 ; i--) { + int collision = 0; + virDomainSoundDefPtr check; + virDomainSoundDefPtr sound = virDomainSoundDefParseXML(conn, + nodes[i]); + if (!sound) + goto error; + + /* Verify there's no duplicated sound card */ + check = def->sounds; + while (check) { + if (check->model == sound->model) + collision = 1; + check = check->next; + } + if (collision) { + virDomainSoundDefFree(sound); + continue; + } + + sound->next = def->sounds; + def->sounds = sound; + } + VIR_FREE(nodes); + + return def; + + error: + VIR_FREE(tmp); + VIR_FREE(nodes); + virDomainDefFree(def); + return NULL; +} + + +virDomainDefPtr virDomainDefParseString(virConnectPtr conn, + virCapsPtr caps, + const char *xmlStr) +{ + xmlDocPtr xml; + xmlNodePtr root; + virDomainDefPtr def = NULL; + + if (!(xml = xmlReadDoc(BAD_CAST xmlStr, "network.xml", NULL, + XML_PARSE_NOENT | XML_PARSE_NONET | + XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) { + virDomainReportError(conn, VIR_ERR_XML_ERROR, NULL); + return NULL; + } + + if ((root = xmlDocGetRootElement(xml)) == NULL) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("missing root element")); + xmlFreeDoc(xml); + return NULL; + } + + def = virDomainDefParseNode(conn, caps, xml, root); + + xmlFreeDoc(xml); + return def; +} + +virDomainDefPtr virDomainDefParseFile(virConnectPtr conn, + virCapsPtr caps, + const char *filename) +{ + xmlDocPtr xml; + xmlNodePtr root; + virDomainDefPtr def = NULL; + + if (!(xml = xmlReadFile(filename, NULL, + XML_PARSE_NOENT | XML_PARSE_NONET | + XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) { + virDomainReportError(conn, VIR_ERR_XML_ERROR, NULL); + return NULL; + } + + if ((root = xmlDocGetRootElement(xml)) == NULL) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("missing root element")); + xmlFreeDoc(xml); + return NULL; + } + + def = virDomainDefParseNode(conn, caps, xml, root); + + xmlFreeDoc(xml); + return def; +} + + +virDomainDefPtr virDomainDefParseNode(virConnectPtr conn, + virCapsPtr caps, + xmlDocPtr xml, + xmlNodePtr root) +{ + xmlXPathContextPtr ctxt = NULL; + virDomainDefPtr def = NULL; + + if (!xmlStrEqual(root->name, BAD_CAST "domain")) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("incorrect root element")); + goto cleanup; + } + + ctxt = xmlXPathNewContext(xml); + if (ctxt == NULL) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + goto cleanup; + } + + ctxt->node = root; + def = virDomainDefParseXML(conn, caps, ctxt); + +cleanup: + xmlXPathFreeContext(ctxt); + return def; +} + + +/************************************************************************ + * * + * Parser and converter for the CPUset strings used in libvirt * + * * + ************************************************************************/ +/** + * virDomainCpuNumberParse + * @str: pointer to the char pointer used + * @maxcpu: maximum CPU number allowed + * + * Parse a CPU number + * + * Returns the CPU number or -1 in case of error. @str will be + * updated to skip the number. + */ +static int +virDomainCpuNumberParse(const char **str, int maxcpu) +{ + int ret = 0; + const char *cur = *str; + + if (!c_isdigit(*cur)) + return (-1); + + while (c_isdigit(*cur)) { + ret = ret * 10 + (*cur - '0'); + if (ret >= maxcpu) + return (-1); + cur++; + } + *str = cur; + return (ret); +} + +/** + * virDomainCpuSetFormat: + * @conn: connection + * @cpuset: pointer to a char array for the CPU set + * @maxcpu: number of elements available in @cpuset + * + * Serialize the cpuset to a string + * + * Returns the new string NULL in case of error. The string need to be + * freed by the caller. + */ +char * +virDomainCpuSetFormat(virConnectPtr conn, char *cpuset, int maxcpu) +{ + virBuffer buf = VIR_BUFFER_INITIALIZER; + int start, cur; + int first = 1; + + if ((cpuset == NULL) || (maxcpu <= 0) || (maxcpu > 100000)) + return (NULL); + + cur = 0; + start = -1; + while (cur < maxcpu) { + if (cpuset[cur]) { + if (start == -1) + start = cur; + } else if (start != -1) { + if (!first) + virBufferAddLit(&buf, ","); + else + first = 0; + if (cur == start + 1) + virBufferVSprintf(&buf, "%d", start); + else + virBufferVSprintf(&buf, "%d-%d", start, cur - 1); + start = -1; + } + cur++; + } + if (start != -1) { + if (!first) + virBufferAddLit(&buf, ","); + if (maxcpu == start + 1) + virBufferVSprintf(&buf, "%d", start); + else + virBufferVSprintf(&buf, "%d-%d", start, maxcpu - 1); + } + + if (virBufferError(&buf)) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + return NULL; + } + + return virBufferContentAndReset(&buf); +} + +/** + * virDomainCpuSetParse: + * @conn: connection + * @str: pointer to a CPU set string pointer + * @sep: potential character used to mark the end of string if not 0 + * @cpuset: pointer to a char array for the CPU set + * @maxcpu: number of elements available in @cpuset + * + * Parse the cpu set, it will set the value for enabled CPUs in the @cpuset + * to 1, and 0 otherwise. The syntax allows coma separated entries each + * can be either a CPU number, ^N to unset that CPU or N-M for ranges. + * + * Returns the number of CPU found in that set, or -1 in case of error. + * @cpuset is modified accordingly to the value parsed. + * @str is updated to the end of the part parsed + */ +int +virDomainCpuSetParse(virConnectPtr conn, const char **str, char sep, + char *cpuset, int maxcpu) +{ + const char *cur; + int ret = 0; + int i, start, last; + int neg = 0; + + if ((str == NULL) || (cpuset == NULL) || (maxcpu <= 0) || + (maxcpu > 100000)) + return (-1); + + cur = *str; + virSkipSpaces(&cur); + if (*cur == 0) + goto parse_error; + + /* initialize cpumap to all 0s */ + for (i = 0; i < maxcpu; i++) + cpuset[i] = 0; + ret = 0; + + while ((*cur != 0) && (*cur != sep)) { + /* + * 3 constructs are allowed: + * - N : a single CPU number + * - N-M : a range of CPU numbers with N < M + * - ^N : remove a single CPU number from the current set + */ + if (*cur == '^') { + cur++; + neg = 1; + } + + if (!c_isdigit(*cur)) + goto parse_error; + start = virDomainCpuNumberParse(&cur, maxcpu); + if (start < 0) + goto parse_error; + virSkipSpaces(&cur); + if ((*cur == ',') || (*cur == 0) || (*cur == sep)) { + if (neg) { + if (cpuset[start] == 1) { + cpuset[start] = 0; + ret--; + } + } else { + if (cpuset[start] == 0) { + cpuset[start] = 1; + ret++; + } + } + } else if (*cur == '-') { + if (neg) + goto parse_error; + cur++; + virSkipSpaces(&cur); + last = virDomainCpuNumberParse(&cur, maxcpu); + if (last < start) + goto parse_error; + for (i = start; i <= last; i++) { + if (cpuset[i] == 0) { + cpuset[i] = 1; + ret++; + } + } + virSkipSpaces(&cur); + } + if (*cur == ',') { + cur++; + virSkipSpaces(&cur); + neg = 0; + } else if ((*cur == 0) || (*cur == sep)) { + break; + } else + goto parse_error; + } + *str = cur; + return (ret); + + parse_error: + virDomainReportError(conn, VIR_ERR_XEN_CALL, + "%s", _("topology cpuset syntax error")); + return (-1); +} + + +static int +virDomainLifecycleDefFormat(virConnectPtr conn, + virBufferPtr buf, + int type, + const char *name) +{ + const char *typeStr = virDomainLifecycleTypeToString(type); + if (!typeStr) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unexpected lifecycle type %d"), type); + return -1; + } + + virBufferVSprintf(buf, " <%s>%s</%s>\n", name, typeStr, name); + + return 0; +} + + +static int +virDomainDiskDefFormat(virConnectPtr conn, + virBufferPtr buf, + virDomainDiskDefPtr def) +{ + const char *type = virDomainDiskTypeToString(def->type); + const char *device = virDomainDiskDeviceTypeToString(def->device); + const char *bus = virDomainDiskBusTypeToString(def->bus); + + if (!type) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unexpected disk type %d"), def->type); + return -1; + } + if (!device) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unexpected disk device %d"), def->device); + return -1; + } + if (!bus) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unexpected disk bus %d"), def->bus); + return -1; + } + + virBufferVSprintf(buf, + " <disk type='%s' device='%s'>\n", + type, device); + + if (def->driverName) { + if (def->driverType) + virBufferVSprintf(buf, + " <driver name='%s' type='%s'/>\n", + def->driverName, def->driverType); + else + virBufferVSprintf(buf, + " <driver name='%s'/>\n", + def->driverName); + } + + if (def->src) { + if (def->type == VIR_DOMAIN_DISK_TYPE_FILE) + virBufferEscapeString(buf, " <source file='%s'/>\n", + def->src); + else + virBufferEscapeString(buf, " <source dev='%s'/>\n", + def->src); + } + + virBufferVSprintf(buf, " <target dev='%s' bus='%s'/>\n", + def->dst, bus); + + if (def->readonly) + virBufferAddLit(buf, " <readonly/>\n"); + if (def->shared) + virBufferAddLit(buf, " <shareable/>\n"); + + virBufferAddLit(buf, " </disk>\n"); + + return 0; +} + +static int +virDomainNetDefFormat(virConnectPtr conn, + virBufferPtr buf, + virDomainNetDefPtr def) +{ + const char *type = virDomainNetTypeToString(def->type); + + if (!type) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unexpected net type %d"), def->type); + return -1; + } + + virBufferVSprintf(buf, " <interface type='%s'>\n", type); + + virBufferVSprintf(buf, + " <mac address='%02x:%02x:%02x:%02x:%02x:%02x'/>\n", + def->mac[0], def->mac[1], def->mac[2], + def->mac[3], def->mac[4], def->mac[5]); + + switch (def->type) { + case VIR_DOMAIN_NET_TYPE_NETWORK: + virBufferEscapeString(buf, " <source network='%s'/>\n", + def->data.network.name); + break; + + case VIR_DOMAIN_NET_TYPE_ETHERNET: + if (def->data.ethernet.dev) + virBufferEscapeString(buf, " <source dev='%s'/>\n", + def->data.ethernet.dev); + if (def->data.ethernet.ipaddr) + virBufferVSprintf(buf, " <ip address='%s'/>\n", + def->data.ethernet.ipaddr); + if (def->data.ethernet.script) + virBufferEscapeString(buf, " <script path='%s'/>\n", + def->data.ethernet.script); + break; + + case VIR_DOMAIN_NET_TYPE_BRIDGE: + virBufferEscapeString(buf, " <source bridge='%s'/>\n", + def->data.bridge.brname); + break; + + case VIR_DOMAIN_NET_TYPE_SERVER: + case VIR_DOMAIN_NET_TYPE_CLIENT: + case VIR_DOMAIN_NET_TYPE_MCAST: + if (def->data.socket.address) + virBufferVSprintf(buf, " <source address='%s' port='%d'/>\n", + def->data.socket.address, def->data.socket.port); + else + virBufferVSprintf(buf, " <source port='%d'/>\n", + def->data.socket.port); + } + + if (def->ifname) + virBufferEscapeString(buf, " <target dev='%s'/>\n", + def->ifname); + if (def->model) + virBufferEscapeString(buf, " <model type='%s'/>\n", + def->model); + + virBufferAddLit(buf, " </interface>\n"); + + return 0; +} + + +static int +virDomainChrDefFormat(virConnectPtr conn, + virBufferPtr buf, + virDomainChrDefPtr def, + const char *name) +{ + const char *type = virDomainChrTypeToString(def->type); + + if (!type) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unexpected char type %d"), def->type); + return -1; + } + + /* Compat with legacy <console tty='/dev/pts/5'/> syntax */ + virBufferVSprintf(buf, " <%s type='%s'", + name, type); + if (STREQ(name, "console") && + def->type == VIR_DOMAIN_CHR_TYPE_PTY && + def->data.file.path) { + virBufferEscapeString(buf, " tty='%s'>\n", + def->data.file.path); + } else { + virBufferAddLit(buf, ">\n"); + } + + switch (def->type) { + case VIR_DOMAIN_CHR_TYPE_NULL: + case VIR_DOMAIN_CHR_TYPE_VC: + case VIR_DOMAIN_CHR_TYPE_STDIO: + /* nada */ + break; + + case VIR_DOMAIN_CHR_TYPE_PTY: + case VIR_DOMAIN_CHR_TYPE_DEV: + case VIR_DOMAIN_CHR_TYPE_FILE: + case VIR_DOMAIN_CHR_TYPE_PIPE: + if (def->type != VIR_DOMAIN_CHR_TYPE_PTY || + def->data.file.path) { + virBufferEscapeString(buf, " <source path='%s'/>\n", + def->data.file.path); + } + break; + + case VIR_DOMAIN_CHR_TYPE_UDP: + if (def->data.udp.bindService && + def->data.udp.bindHost) { + virBufferVSprintf(buf, " <source mode='bind' host='%s' service='%s'/>\n", + def->data.udp.bindHost, + def->data.udp.bindService); + } else if (def->data.udp.bindHost) { + virBufferVSprintf(buf, " <source mode='bind' host='%s'/>\n", + def->data.udp.bindHost); + } else if (def->data.udp.bindService) { + virBufferVSprintf(buf, " <source mode='bind' service='%s'/>\n", + def->data.udp.bindService); + } + + if (def->data.udp.connectService && + def->data.udp.connectHost) { + virBufferVSprintf(buf, " <source mode='connect' host='%s' service='%s'/>\n", + def->data.udp.connectHost, + def->data.udp.connectService); + } else if (def->data.udp.connectHost) { + virBufferVSprintf(buf, " <source mode='connect' host='%s'/>\n", + def->data.udp.connectHost); + } else if (def->data.udp.connectService) { + virBufferVSprintf(buf, " <source mode='connect' service='%s'/>\n", + def->data.udp.connectService); + } + break; + + case VIR_DOMAIN_CHR_TYPE_TCP: + virBufferVSprintf(buf, " <source mode='%s' host='%s' service='%s'/>\n", + def->data.tcp.listen ? "bind" : "connect", + def->data.tcp.host, + def->data.tcp.service); + virBufferVSprintf(buf, " <protocol type='%s'/>\n", + def->data.tcp.protocol == + VIR_DOMAIN_CHR_TCP_PROTOCOL_TELNET + ? "telnet" : "raw"); + break; + + case VIR_DOMAIN_CHR_TYPE_UNIX: + virBufferVSprintf(buf, " <source mode='%s'", + def->data.nix.listen ? "bind" : "connect"); + virBufferEscapeString(buf, " path='%s'/>\n", + def->data.nix.path); + break; + } + + virBufferVSprintf(buf, " <target port='%d'/>\n", + def->dstPort); + + virBufferVSprintf(buf, " </%s>\n", + name); + + return 0; +} + +static int +virDomainSoundDefFormat(virConnectPtr conn, + virBufferPtr buf, + virDomainSoundDefPtr def) +{ + const char *model = virDomainSoundModelTypeToString(def->model); + + if (!model) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unexpected sound model %d"), def->model); + return -1; + } + + virBufferVSprintf(buf, " <sound model='%s'/>\n", + model); + + return 0; +} + +static int +virDomainInputDefFormat(virConnectPtr conn, + virBufferPtr buf, + virDomainInputDefPtr def) +{ + const char *type = virDomainInputTypeToString(def->type); + const char *bus = virDomainInputBusTypeToString(def->bus); + + if (!type) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unexpected input type %d"), def->type); + return -1; + } + if (!bus) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unexpected input bus type %d"), def->bus); + return -1; + } + + virBufferVSprintf(buf, " <input type='%s' bus='%s'/>\n", + type, bus); + + return 0; +} + + +static int +virDomainGraphicsDefFormat(virConnectPtr conn, + virBufferPtr buf, + virDomainGraphicsDefPtr def, + int flags) +{ + const char *type = virDomainGraphicsTypeToString(def->type); + + if (!type) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unexpected net type %d"), def->type); + return -1; + } + + virBufferVSprintf(buf, " <graphics type='%s'", type); + + switch (def->type) { + case VIR_DOMAIN_GRAPHICS_TYPE_VNC: + if (def->data.vnc.autoport) + virBufferAddLit(buf, " port='-1'"); + else if (def->data.vnc.port) + virBufferVSprintf(buf, " port='%d'", + def->data.vnc.port); + + virBufferVSprintf(buf, " autoport='%s'", + def->data.vnc.autoport ? "yes" : "no"); + + if (def->data.vnc.listenAddr) + virBufferVSprintf(buf, " listen='%s'", + def->data.vnc.listenAddr); + + if (def->data.vnc.keymap) + virBufferEscapeString(buf, " keymap='%s'", + def->data.vnc.keymap); + + if (def->data.vnc.passwd && + (flags & VIR_DOMAIN_XML_SECURE)) + virBufferEscapeString(buf, " passwd='%s'", + def->data.vnc.passwd); + + break; + + case VIR_DOMAIN_GRAPHICS_TYPE_SDL: + if (def->data.sdl.display) + virBufferEscapeString(buf, " display='%s'", + def->data.sdl.display); + + if (def->data.sdl.xauth) + virBufferEscapeString(buf, " xauth='%s'", + def->data.sdl.xauth); + break; + } + + virBufferAddLit(buf, "/>\n"); + + return 0; +} + +char *virDomainDefFormat(virConnectPtr conn, + virDomainDefPtr def, + int flags) +{ + virBuffer buf = VIR_BUFFER_INITIALIZER; + unsigned char *uuid; + char uuidstr[VIR_UUID_STRING_BUFLEN]; + virDomainDiskDefPtr disk; + virDomainNetDefPtr net; + virDomainSoundDefPtr sound; + virDomainInputDefPtr input; + virDomainChrDefPtr chr; + const char *type = NULL, *tmp; + int n, allones = 1; + + if (!(type = virDomainVirtTypeToString(def->virtType))) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unexpected domain type %d"), def->virtType); + goto cleanup; + } + + if (def->id >= 0) + virBufferVSprintf(&buf, "<domain type='%s' id='%d'>\n", type, def->id); + else + virBufferVSprintf(&buf, "<domain type='%s'>\n", type); + + virBufferEscapeString(&buf, " <name>%s</name>\n", def->name); + + uuid = def->uuid; + virUUIDFormat(uuid, uuidstr); + virBufferVSprintf(&buf, " <uuid>%s</uuid>\n", uuidstr); + + virBufferVSprintf(&buf, " <memory>%lu</memory>\n", def->maxmem); + virBufferVSprintf(&buf, " <currentMemory>%lu</currentMemory>\n", + def->memory); + + for (n = 0 ; n < def->cpumasklen ; n++) + if (def->cpumask[n] != 1) + allones = 0; + + if (allones) { + virBufferVSprintf(&buf, " <vcpu>%lu</vcpu>\n", def->vcpus); + } else { + char *cpumask = NULL; + if ((cpumask = + virDomainCpuSetFormat(conn, def->cpumask, def->cpumasklen)) == NULL) + goto cleanup; + virBufferVSprintf(&buf, " <vcpu cpuset='%s'>%lu</vcpu>\n", + cpumask, def->vcpus); + VIR_FREE(cpumask); + } + + if (def->os.bootloader) { + virBufferEscapeString(&buf, " <bootloader>%s</bootloader>\n", + def->os.bootloader); + if (def->os.bootloaderArgs) + virBufferEscapeString(&buf, " <bootloader_args>%s</bootloader_args>\n", + def->os.bootloaderArgs); + } + virBufferAddLit(&buf, " <os>\n"); + + virBufferAddLit(&buf, " <type"); + if (def->os.arch) + virBufferVSprintf(&buf, " arch='%s'", def->os.arch); + if (def->os.machine) + virBufferVSprintf(&buf, " machine='%s'", def->os.machine); + /* + * HACK: For xen driver we previously used bogus 'linux' as the + * os type for paravirt, whereas capabilities declare it to + * be 'xen'. So we convert to the former for backcompat + */ + if (def->virtType == VIR_DOMAIN_VIRT_XEN && + STREQ(def->os.type, "xen")) + virBufferVSprintf(&buf, ">%s</type>\n", "linux"); + else + virBufferVSprintf(&buf, ">%s</type>\n", def->os.type); + + if (def->os.loader) + virBufferEscapeString(&buf, " <loader>%s</loader>\n", + def->os.loader); + if (def->os.kernel) + virBufferEscapeString(&buf, " <kernel>%s</kernel>\n", + def->os.kernel); + if (def->os.initrd) + virBufferEscapeString(&buf, " <initrd>%s</initrd>\n", + def->os.initrd); + if (def->os.cmdline) + virBufferEscapeString(&buf, " <cmdline>%s</cmdline>\n", + def->os.cmdline); + if (def->os.root) + virBufferEscapeString(&buf, " <root>%s</root>\n", + def->os.root); + + if (!def->os.bootloader) { + for (n = 0 ; n < def->os.nBootDevs ; n++) { + const char *boottype = + virDomainBootTypeToString(def->os.bootDevs[n]); + if (!boottype) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unexpected boot device type %d"), + def->os.bootDevs[n]); + goto cleanup; + } + virBufferVSprintf(&buf, " <boot dev='%s'/>\n", boottype); + } + } + + virBufferAddLit(&buf, " </os>\n"); + + if (def->features) { + int i; + virBufferAddLit(&buf, " <features>\n"); + for (i = 0 ; i < VIR_DOMAIN_FEATURE_LAST ; i++) { + if (def->features & (1 << i)) { + const char *name = virDomainFeatureTypeToString(i); + if (!name) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unexpected feature %d"), i); + goto cleanup; + } + virBufferVSprintf(&buf, " <%s/>\n", name); + } + } + virBufferAddLit(&buf, " </features>\n"); + } + + virBufferVSprintf(&buf, " <clock offset='%s'/>\n", + def->localtime ? "localtime" : "utc"); + + if (virDomainLifecycleDefFormat(conn, &buf, def->onPoweroff, + "on_poweroff") < 0) + goto cleanup; + if (virDomainLifecycleDefFormat(conn, &buf, def->onReboot, + "on_reboot") < 0) + goto cleanup; + if (virDomainLifecycleDefFormat(conn, &buf, def->onCrash, + "on_crash") < 0) + goto cleanup; + + virBufferAddLit(&buf, " <devices>\n"); + + if (def->emulator) + virBufferEscapeString(&buf, " <emulator>%s</emulator>\n", + def->emulator); + + disk = def->disks; + while (disk) { + if (virDomainDiskDefFormat(conn, &buf, disk) < 0) + goto cleanup; + disk = disk->next; + } + + net = def->nets; + while (net) { + if (virDomainNetDefFormat(conn, &buf, net) < 0) + goto cleanup; + net = net->next; + } + + + chr = def->serials; + while (chr) { + if (virDomainChrDefFormat(conn, &buf, chr, "serial") < 0) + goto cleanup; + chr = chr->next; + } + + chr = def->parallels; + while (chr) { + if (virDomainChrDefFormat(conn, &buf, chr, "parallel") < 0) + goto cleanup; + chr = chr->next; + } + + /* If there's a PV console that's preferred.. */ + if (def->console) { + if (virDomainChrDefFormat(conn, &buf, def->console, "console") < 0) + goto cleanup; + } else if (def->serials != NULL) { + /* ..else for legacy compat duplicate the serial device as a console */ + if (virDomainChrDefFormat(conn, &buf, def->serials, "console") < 0) + goto cleanup; + } + + input = def->inputs; + while (input) { + if (input->bus == VIR_DOMAIN_INPUT_BUS_USB && + virDomainInputDefFormat(conn, &buf, input) < 0) + goto cleanup; + input = input->next; + } + + if (def->graphics) { + /* If graphics is enabled, add the implicit mouse */ + virDomainInputDef autoInput = { + VIR_DOMAIN_INPUT_TYPE_MOUSE, + STREQ(def->os.type, "hvm") ? + VIR_DOMAIN_INPUT_BUS_PS2 : VIR_DOMAIN_INPUT_BUS_XEN, + NULL }; + + if (virDomainInputDefFormat(conn, &buf, &autoInput) < 0) + goto cleanup; + + if (virDomainGraphicsDefFormat(conn, &buf, def->graphics, flags) < 0) + goto cleanup; + } + + sound = def->sounds; + while(sound) { + if (virDomainSoundDefFormat(conn, &buf, sound) < 0) + goto cleanup; + sound = sound->next; + } + + virBufferAddLit(&buf, " </devices>\n"); + virBufferAddLit(&buf, "</domain>\n"); + + if (virBufferError(&buf)) + goto no_memory; + + return virBufferContentAndReset(&buf); + + no_memory: + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + cleanup: + tmp = virBufferContentAndReset(&buf); + VIR_FREE(tmp); + return NULL; +} + + +int virDomainSaveConfig(virConnectPtr conn, + const char *configDir, + const char *autostartDir, + virDomainObjPtr dom) +{ + char *xml; + int fd = -1, ret = -1; + int towrite; + int err; + + if (!dom->configFile && + asprintf(&dom->configFile, "%s/%s.xml", + configDir, dom->def->name) < 0) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + goto cleanup; + } + if (!dom->autostartLink && + asprintf(&dom->autostartLink, "%s/%s.xml", + autostartDir, dom->def->name) < 0) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + goto cleanup; + } + + if (!(xml = virDomainDefFormat(conn, + dom->newDef ? dom->newDef : dom->def, + VIR_DOMAIN_XML_SECURE))) + return -1; + + if ((err = virFileMakePath(configDir))) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("cannot create config directory %s: %s"), + configDir, strerror(err)); + goto cleanup; + } + + if ((err = virFileMakePath(autostartDir))) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("cannot create autostart directory %s: %s"), + autostartDir, strerror(err)); + goto cleanup; + } + + if ((fd = open(dom->configFile, + O_WRONLY | O_CREAT | O_TRUNC, + S_IRUSR | S_IWUSR )) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("cannot create config file %s: %s"), + dom->configFile, strerror(errno)); + goto cleanup; + } + + towrite = strlen(xml); + if (safewrite(fd, xml, towrite) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("cannot write config file %s: %s"), + dom->configFile, strerror(errno)); + goto cleanup; + } + + if (close(fd) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("cannot save config file %s: %s"), + dom->configFile, strerror(errno)); + goto cleanup; + } + + ret = 0; + + cleanup: + VIR_FREE(xml); + close(fd); + + return ret; +} + +virDomainObjPtr virDomainLoadConfig(virConnectPtr conn, + virCapsPtr caps, + virDomainObjPtr *doms, + const char *configDir, + const char *autostartDir, + const char *file) +{ + char *configFile, *autostartLink; + virDomainDefPtr def = NULL; + virDomainObjPtr dom; + int autostart; + + if (asprintf(&configFile, "%s/%s", + configDir, file) < 0) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + goto error; + } + if (asprintf(&autostartLink, "%s/%s", + autostartDir, file) < 0) { + virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL); + goto error; + } + + if ((autostart = virFileLinkPointsTo(autostartLink, configFile)) < 0) + goto error; + + if (!(def = virDomainDefParseFile(conn, caps, file))) + goto error; + + if (!virFileMatchesNameSuffix(file, def->name, ".xml")) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("Domain config filename '%s'" + " does not match domain name '%s'"), + configFile, def->name); + goto error; + } + + if (!(dom = virDomainAssignDef(conn, doms, def))) + goto error; + + dom->configFile = configFile; + dom->autostartLink = autostartLink; + dom->autostart = autostart; + + return dom; + +error: + VIR_FREE(configFile); + VIR_FREE(autostartLink); + virDomainDefFree(def); + return NULL; +} + +int virDomainLoadAllConfigs(virConnectPtr conn, + virCapsPtr caps, + virDomainObjPtr *doms, + const char *configDir, + const char *autostartDir) +{ + DIR *dir; + struct dirent *entry; + + if (!(dir = opendir(configDir))) { + if (errno == ENOENT) + return 0; + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("Failed to open dir '%s': %s"), + configDir, strerror(errno)); + return -1; + } + + while ((entry = readdir(dir))) { + if (entry->d_name[0] == '.') + continue; + + if (!virFileHasSuffix(entry->d_name, ".xml")) + continue; + + /* NB: ignoring errors, so one malformed config doesn't + kill the whole process */ + virDomainLoadConfig(conn, + caps, + doms, + configDir, + autostartDir, + entry->d_name); + } + + closedir(dir); + + return 0; +} + +int virDomainDeleteConfig(virConnectPtr conn, + virDomainObjPtr dom) +{ + if (!dom->configFile || !dom->autostartLink) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("no config file for %s"), dom->def->name); + return -1; + } + + /* Not fatal if this doesn't work */ + unlink(dom->autostartLink); + + if (unlink(dom->configFile) < 0) { + virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("cannot remove config for %s"), dom->def->name); + return -1; + } + + return 0; +} diff -r a77ea50ba693 src/domain_conf.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/domain_conf.h Tue Jul 08 15:26:51 2008 +0100 @@ -0,0 +1,489 @@ +/* + * domain_conf.h: domain XML processing + * + * Copyright (C) 2006-2008 Red Hat, Inc. + * Copyright (C) 2006-2008 Daniel P. Berrange + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Daniel P. Berrange <berrange(a)redhat.com&gt; + */ + +#ifndef __DOMAIN_CONF_H +#define __DOMAIN_CONF_H + +#include <config.h> + +#include "internal.h" +#include "capabilities.h" +#include "util.h" + +/* Different types of hypervisor */ +/* NB: Keep in sync with virDomainVirtTypeToString impl */ +enum virDomainVirtType { + VIR_DOMAIN_VIRT_QEMU, + VIR_DOMAIN_VIRT_KQEMU, + VIR_DOMAIN_VIRT_KVM, + VIR_DOMAIN_VIRT_XEN, + VIR_DOMAIN_VIRT_LXC, + VIR_DOMAIN_VIRT_UML, + VIR_DOMAIN_VIRT_OPENVZ, + VIR_DOMAIN_VIRT_VSERVER, + VIR_DOMAIN_VIRT_LDOM, + VIR_DOMAIN_VIRT_TEST, + VIR_DOMAIN_VIRT_VMWARE, + VIR_DOMAIN_VIRT_HYPERV, + + VIR_DOMAIN_VIRT_LAST, +}; + +/* Two types of disk backends */ +enum virDomainDiskType { + VIR_DOMAIN_DISK_TYPE_BLOCK, + VIR_DOMAIN_DISK_TYPE_FILE, + + VIR_DOMAIN_DISK_TYPE_LAST +}; + +/* Three types of disk frontend */ +enum virDomainDiskDevice { + VIR_DOMAIN_DISK_DEVICE_DISK, + VIR_DOMAIN_DISK_DEVICE_CDROM, + VIR_DOMAIN_DISK_DEVICE_FLOPPY, + + VIR_DOMAIN_DISK_DEVICE_LAST +}; + +enum virDomainDiskBus { + VIR_DOMAIN_DISK_BUS_IDE, + VIR_DOMAIN_DISK_BUS_FDC, + VIR_DOMAIN_DISK_BUS_SCSI, + VIR_DOMAIN_DISK_BUS_VIRTIO, + VIR_DOMAIN_DISK_BUS_XEN, + + VIR_DOMAIN_DISK_BUS_LAST +}; + +/* Stores the virtual disk configuration */ +typedef struct _virDomainDiskDef virDomainDiskDef; +typedef virDomainDiskDef *virDomainDiskDefPtr; +struct _virDomainDiskDef { + int type; + int device; + int bus; + char *src; + char *dst; + char *driverName; + char *driverType; + unsigned int readonly : 1; + unsigned int shared : 1; + + virDomainDiskDefPtr next; +}; + + +/* 5 different types of networking config */ +enum virDomainNetType { + VIR_DOMAIN_NET_TYPE_USER, + VIR_DOMAIN_NET_TYPE_ETHERNET, + VIR_DOMAIN_NET_TYPE_SERVER, + VIR_DOMAIN_NET_TYPE_CLIENT, + VIR_DOMAIN_NET_TYPE_MCAST, + VIR_DOMAIN_NET_TYPE_NETWORK, + VIR_DOMAIN_NET_TYPE_BRIDGE, + + VIR_DOMAIN_NET_TYPE_LAST, +}; + + +#define VIR_DOMAIN_NET_MAC_SIZE 6 + +/* Stores the virtual network interface configuration */ +typedef struct _virDomainNetDef virDomainNetDef; +typedef virDomainNetDef *virDomainNetDefPtr; +struct _virDomainNetDef { + int type; + unsigned char mac[VIR_DOMAIN_NET_MAC_SIZE]; + char *model; + union { + struct { + char *dev; + char *script; + char *ipaddr; + } ethernet; + struct { + char *address; + int port; + } socket; /* any of NET_CLIENT or NET_SERVER or NET_MCAST */ + struct { + char *name; + } network; + struct { + char *brname; + } bridge; + } data; + char *ifname; + + virDomainNetDefPtr next; +}; + +enum virDomainChrSrcType { + VIR_DOMAIN_CHR_TYPE_NULL, + VIR_DOMAIN_CHR_TYPE_VC, + VIR_DOMAIN_CHR_TYPE_PTY, + VIR_DOMAIN_CHR_TYPE_DEV, + VIR_DOMAIN_CHR_TYPE_FILE, + VIR_DOMAIN_CHR_TYPE_PIPE, + VIR_DOMAIN_CHR_TYPE_STDIO, + VIR_DOMAIN_CHR_TYPE_UDP, + VIR_DOMAIN_CHR_TYPE_TCP, + VIR_DOMAIN_CHR_TYPE_UNIX, + + VIR_DOMAIN_CHR_TYPE_LAST, +}; + +enum virDomainChrTcpProtocol { + VIR_DOMAIN_CHR_TCP_PROTOCOL_RAW, + VIR_DOMAIN_CHR_TCP_PROTOCOL_TELNET, + + VIR_DOMAIN_CHR_TCP_PROTOCOL_LAST, +}; + +typedef struct _virDomainChrDef virDomainChrDef; +typedef virDomainChrDef *virDomainChrDefPtr; +struct _virDomainChrDef { + int dstPort; + + int type; + union { + struct { + char *path; + } file; /* pty, file, pipe, or device */ + struct { + char *host; + char *service; + int listen; + int protocol; + } tcp; + struct { + char *bindHost; + char *bindService; + char *connectHost; + char *connectService; + } udp; + struct { + char *path; + int listen; + } nix; + } data; + + virDomainChrDefPtr next; +}; + +enum virDomainInputType { + VIR_DOMAIN_INPUT_TYPE_MOUSE, + VIR_DOMAIN_INPUT_TYPE_TABLET, + + VIR_DOMAIN_INPUT_TYPE_LAST, +}; + +enum virDomainInputBus { + VIR_DOMAIN_INPUT_BUS_PS2, + VIR_DOMAIN_INPUT_BUS_USB, + VIR_DOMAIN_INPUT_BUS_XEN, + + VIR_DOMAIN_INPUT_BUS_LAST +}; + +typedef struct _virDomainInputDef virDomainInputDef; +typedef virDomainInputDef *virDomainInputDefPtr; +struct _virDomainInputDef { + int type; + int bus; + virDomainInputDefPtr next; +}; + +enum virDomainSoundModel { + VIR_DOMAIN_SOUND_MODEL_SB16, + VIR_DOMAIN_SOUND_MODEL_ES1370, + VIR_DOMAIN_SOUND_MODEL_PCSPK, + + VIR_DOMAIN_SOUND_MODEL_LAST +}; + +typedef struct _virDomainSoundDef virDomainSoundDef; +typedef virDomainSoundDef *virDomainSoundDefPtr; +struct _virDomainSoundDef { + int model; + virDomainSoundDefPtr next; +}; + +/* 3 possible graphics console modes */ +enum virDomainGraphicsType { + VIR_DOMAIN_GRAPHICS_TYPE_SDL, + VIR_DOMAIN_GRAPHICS_TYPE_VNC, + + VIR_DOMAIN_GRAPHICS_TYPE_LAST, +}; + +typedef struct _virDomainGraphicsDef virDomainGraphicsDef; +typedef virDomainGraphicsDef *virDomainGraphicsDefPtr; +struct _virDomainGraphicsDef { + int type; + union { + struct { + int port; + int autoport : 1; + char *listenAddr; + char *keymap; + char *passwd; + } vnc; + struct { + char *display; + char *xauth; + } sdl; + } data; +}; + + + +/* Flags for the 'type' field in next struct */ +enum virDomainDeviceType { + VIR_DOMAIN_DEVICE_DISK, + VIR_DOMAIN_DEVICE_NET, + VIR_DOMAIN_DEVICE_INPUT, + VIR_DOMAIN_DEVICE_SOUND, +}; + +typedef struct _virDomainDeviceDef virDomainDeviceDef; +typedef virDomainDeviceDef *virDomainDeviceDefPtr; +struct _virDomainDeviceDef { + int type; + union { + virDomainDiskDefPtr disk; + virDomainNetDefPtr net; + virDomainInputDefPtr input; + virDomainSoundDefPtr sound; + } data; +}; + + +#define VIR_DOMAIN_MAX_BOOT_DEVS 4 + +/* 3 possible boot devices */ +enum virDomainBootOrder { + VIR_DOMAIN_BOOT_FLOPPY, + VIR_DOMAIN_BOOT_CDROM, + VIR_DOMAIN_BOOT_DISK, + VIR_DOMAIN_BOOT_NET, + + VIR_DOMAIN_BOOT_LAST, +}; + +enum virDomainFeature { + VIR_DOMAIN_FEATURE_ACPI, + VIR_DOMAIN_FEATURE_APIC, + VIR_DOMAIN_FEATURE_PAE, + + VIR_DOMAIN_FEATURE_LAST +}; + +enum virDomainLifecycleAction { + VIR_DOMAIN_LIFECYCLE_DESTROY, + VIR_DOMAIN_LIFECYCLE_RESTART, + VIR_DOMAIN_LIFECYCLE_RESTART_RENAME, + VIR_DOMAIN_LIFECYCLE_PRESERVE, + + VIR_DOMAIN_LIFECYCLE_LAST +}; + +/* Operating system configuration data & machine / arch */ +typedef struct _virDomainOSDef virDomainOSDef; +typedef virDomainOSDef *virDomainOSDefPtr; +struct _virDomainOSDef { + char *type; + char *arch; + char *machine; + int nBootDevs; + int bootDevs[VIR_DOMAIN_BOOT_LAST]; + char *kernel; + char *initrd; + char *cmdline; + char *root; + char *loader; + char *bootloader; + char *bootloaderArgs; +}; + +#define VIR_DOMAIN_CPUMASK_LEN 1024 + +/* Guest VM main configuration */ +typedef struct _virDomainDef virDomainDef; +typedef virDomainDef *virDomainDefPtr; +struct _virDomainDef { + int virtType; + int id; + unsigned char uuid[VIR_UUID_BUFLEN]; + char *name; + + unsigned long memory; + unsigned long maxmem; + unsigned long vcpus; + int cpumasklen; + char *cpumask; + + /* These 3 are based on virDomainLifeCycleAction enum flags */ + int onReboot; + int onPoweroff; + int onCrash; + + virDomainOSDef os; + char *emulator; + int features; + + int localtime; + + virDomainGraphicsDefPtr graphics; + virDomainDiskDefPtr disks; + virDomainNetDefPtr nets; + virDomainInputDefPtr inputs; + virDomainSoundDefPtr sounds; + virDomainChrDefPtr serials; + virDomainChrDefPtr parallels; + virDomainChrDefPtr console; +}; + +/* Guest VM runtime state */ +typedef struct _virDomainObj virDomainObj; +typedef virDomainObj *virDomainObjPtr; +struct _virDomainObj { + int stdin; + int stdout; + int stderr; + int monitor; + int logfile; + int pid; + int state; + + int nvcpupids; + int *vcpupids; + + unsigned int autostart : 1; + unsigned int persistent : 1; + + char *configFile; + char *autostartLink; + + virDomainDefPtr def; /* The current definition */ + virDomainDefPtr newDef; /* New definition to activate at shutdown */ + + virDomainObjPtr next; +}; + + +static inline int +virDomainIsActive(virDomainObjPtr dom) +{ + return dom->def->id != -1; +} + + +virDomainObjPtr virDomainFindByID(const virDomainObjPtr doms, + int id); +virDomainObjPtr virDomainFindByUUID(const virDomainObjPtr doms, + const unsigned char *uuid); +virDomainObjPtr virDomainFindByName(const virDomainObjPtr doms, + const char *name); + + +void virDomainGraphicsDefFree(virDomainGraphicsDefPtr def); +void virDomainInputDefFree(virDomainInputDefPtr def); +void virDomainDiskDefFree(virDomainDiskDefPtr def); +void virDomainNetDefFree(virDomainNetDefPtr def); +void virDomainChrDefFree(virDomainChrDefPtr def); +void virDomainSoundDefFree(virDomainSoundDefPtr def); +void virDomainDeviceDefFree(virDomainDeviceDefPtr def); +void virDomainDefFree(virDomainDefPtr vm); +void virDomainObjFree(virDomainObjPtr vm); + +virDomainObjPtr virDomainAssignDef(virConnectPtr conn, + virDomainObjPtr *doms, + const virDomainDefPtr def); +void virDomainRemoveInactive(virDomainObjPtr *doms, + virDomainObjPtr dom); + +virDomainDeviceDefPtr virDomainDeviceDefParse(virConnectPtr conn, + const virDomainDefPtr def, + const char *xmlStr); +virDomainDefPtr virDomainDefParseString(virConnectPtr conn, + virCapsPtr caps, + const char *xmlStr); +virDomainDefPtr virDomainDefParseFile(virConnectPtr conn, + virCapsPtr caps, + const char *filename); +virDomainDefPtr virDomainDefParseNode(virConnectPtr conn, + virCapsPtr caps, + xmlDocPtr doc, + xmlNodePtr root); +char *virDomainDefFormat(virConnectPtr conn, + virDomainDefPtr def, + int flags); + +int virDomainCpuSetParse(virConnectPtr conn, + const char **str, + char sep, + char *cpuset, + int maxcpu); +char *virDomainCpuSetFormat(virConnectPtr conn, + char *cpuset, + int maxcpu); + + +int virDomainSaveConfig(virConnectPtr conn, + const char *configDir, + const char *autostartDir, + virDomainObjPtr dom); + +virDomainObjPtr virDomainLoadConfig(virConnectPtr conn, + virCapsPtr caps, + virDomainObjPtr *doms, + const char *configDir, + const char *autostartDir, + const char *file); + +int virDomainLoadAllConfigs(virConnectPtr conn, + virCapsPtr caps, + virDomainObjPtr *doms, + const char *configDir, + const char *autostartDir); + +int virDomainDeleteConfig(virConnectPtr conn, + virDomainObjPtr dom); + +VIR_ENUM_DECL(virDomainVirt) +VIR_ENUM_DECL(virDomainBoot) +VIR_ENUM_DECL(virDomainFeature) +VIR_ENUM_DECL(virDomainLifecycle) +VIR_ENUM_DECL(virDomainDisk) +VIR_ENUM_DECL(virDomainDiskDevice) +VIR_ENUM_DECL(virDomainDiskBus) +VIR_ENUM_DECL(virDomainNet) +VIR_ENUM_DECL(virDomainChr) +VIR_ENUM_DECL(virDomainSoundModel) +VIR_ENUM_DECL(virDomainInput) +VIR_ENUM_DECL(virDomainInputBus) +VIR_ENUM_DECL(virDomainGraphics) + +#endif /* __DOMAIN_CONF_H */ diff -r a77ea50ba693 src/util.h --- a/src/util.h Tue Jul 08 15:26:26 2008 +0100 +++ b/src/util.h Tue Jul 08 15:26:51 2008 +0100 @@ -100,7 +100,7 @@ #define VIR_ENUM_IMPL(name, lastVal, ...) \ static const char const *name ## TypeList[] = { __VA_ARGS__ }; \ - verify(ARRAY_CARDINALITY(name ## TypeList) == lastVal); \ + extern int (* name ## Verify (void)) [verify_true (ARRAY_CARDINALITY(name ## TypeList) == lastVal)]; \ const char *name ## TypeToString(int type) { \ return virEnumToString(name ## TypeList, \ ARRAY_CARDINALITY(name ## TypeList), \ diff -r a77ea50ba693 src/virterror.c --- a/src/virterror.c Tue Jul 08 15:26:26 2008 +0100 +++ b/src/virterror.c Tue Jul 08 15:26:51 2008 +0100 @@ -306,6 +306,9 @@ break; case VIR_FROM_NETWORK: dom = "Network Config "; + break; + case VIR_FROM_DOMAIN: + dom = "Domain Config "; break; } diff -r a77ea50ba693 src/xml.c --- a/src/xml.c Tue Jul 08 15:26:26 2008 +0100 +++ b/src/xml.c Tue Jul 08 15:26:51 2008 +0100 @@ -551,6 +551,13 @@ return (ret); } +char * +virXMLPropString(xmlNodePtr node, + const char *name) +{ + return (char *)xmlGetProp(node, BAD_CAST name); +} + /** * virXPathBoolean: * @xpath: the XPath string to evaluate @@ -648,20 +655,21 @@ _("Invalid parameter to virXPathNodeSet()"), 0); return (-1); } + + if (list != NULL) + *list = NULL; + relnode = ctxt->node; obj = xmlXPathEval(BAD_CAST xpath, ctxt); if ((obj == NULL) || (obj->type != XPATH_NODESET) || - (obj->nodesetval == NULL) || (obj->nodesetval->nodeNr <= 0) || - (obj->nodesetval->nodeTab == NULL)) { + (obj->nodesetval == NULL) || (obj->nodesetval->nodeNr < 0)) { xmlXPathFreeObject(obj); - if (list != NULL) - *list = NULL; ctxt->node = relnode; return (-1); } ret = obj->nodesetval->nodeNr; - if (list != NULL) { + if (list != NULL && ret) { if (VIR_ALLOC_N(*list, ret) < 0) { virXMLError(NULL, VIR_ERR_NO_MEMORY, _("allocate string array"), diff -r a77ea50ba693 src/xml.h --- a/src/xml.h Tue Jul 08 15:26:26 2008 +0100 +++ b/src/xml.h Tue Jul 08 15:26:51 2008 +0100 @@ -23,6 +23,12 @@ int virXPathNumber (const char *xpath, xmlXPathContextPtr ctxt, double *value); +int virXPathInt (const char *xpath, + xmlXPathContextPtr ctxt, + int *value); +int virXPathUInt (const char *xpath, + xmlXPathContextPtr ctxt, + unsigned int *value); int virXPathLong (const char *xpath, xmlXPathContextPtr ctxt, long *value); @@ -34,6 +40,10 @@ int virXPathNodeSet (const char *xpath, xmlXPathContextPtr ctxt, xmlNodePtr **list); + +char * virXMLPropString(xmlNodePtr node, + const char *name); + #if WITH_XEN || WITH_QEMU int virParseCpuSet (virConnectPtr conn, -- |: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :| |: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|

This patch ports the Test driver over to the domain XML apis. Basically the 'struct _testDom' is removed, and replaced by usage of the generic virDomainObjPtr and virDomainDefPtr objects. The XML parser and formatters are ripped out and replaced by calls to the generic APIs in domain_conf.h. Finally there is just alot of cleanup of all the individual domain driver implementations to adjust to the style of the new APIs used. This actually dramatically increases the functionality of the test driver - previously its XML parser didn't support any of the <device> section in the XML. This should make it much more useful for advanced apps like virt-manager Plenty of bug fixes since last time around. I've also implemented DV's suggestion of allowing the entire config to be loaded from a single XML file instead of having to reference external files for each domain. The 'docs/testnodeinline.xml' file illustrates this in practice. The old syntax is also supported of course. b/docs/testnodeinline.xml | 110 ++++ docs/testdomfc4.xml | 2 src/test.c | 1026 +++++++++++++++++----------------------------- src/test.h | 2 tests/read-non-seekable | 3 tests/virshtest.c | 4 6 files changed, 509 insertions(+), 638 deletions(-) Daniel diff -r 3c038ace4e38 docs/testdomfc4.xml --- a/docs/testdomfc4.xml Mon Jul 07 11:39:43 2008 +0100 +++ b/docs/testdomfc4.xml Mon Jul 07 11:39:51 2008 +0100 @@ -2,7 +2,7 @@ <name>fc4</name> <uuid>EF86180145B911CB88E3AFBFE5370493</uuid> <os> - <type>linux</type> + <type>xen</type> <kernel>/boot/vmlinuz-2.6.15-1.43_FC5guest</kernel> <initrd>/boot/initrd-2.6.15-1.43_FC5guest.img</initrd> <root>/dev/sda1</root> diff -r 3c038ace4e38 docs/testnodeinline.xml --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/testnodeinline.xml Mon Jul 07 11:39:51 2008 +0100 @@ -0,0 +1,110 @@ +<?xml version="1.0"?> +<node> + <!-- This file gives an example config for the mock 'test' backend + driver to libvirt. This is intended to allow relible unit testing + of applications using libvirt. To use this with virsh, run something + like: + + virsh -connect test:////path/to/this/dir/testnode.xml nodeinfo + + --> + <domain type="test"> + <name>fv0</name> + <uuid>4dea22b31d52d8f32516782e98ab3fa0</uuid> + <os> + <type>hvm</type> + <loader>/usr/lib/xen/boot/hvmloader</loader> + <boot dev="hd"/> + </os> + <memory>524288</memory> + <maxMemory>1524288</maxMemory> + <vcpu>4</vcpu> + <on_poweroff>destroy</on_poweroff> + <on_reboot>restart</on_reboot> + <on_crash>restart</on_crash> + <features> + <pae/> + <acpi/> + <apic/> + </features> + <devices> + <emulator>/usr/lib/xen/bin/qemu-dm</emulator> + <interface type="bridge"> + <source bridge="xenbr0"/> + <mac address="00:16:3e:5d:c7:9e"/> + <script path="vif-bridge"/> + </interface> + <disk type="file"> + <source file="/root/fv0"/> + <target dev="hda"/> + </disk> + <disk type="file" device="cdrom"> + <source file="/root/fc5-x86_64-boot.iso"/> + <target dev="hdc"/> + <readonly/> + </disk> + <disk type="file" device="floppy"> + <source file="/root/fd.img"/> + <target dev="fda"/> + </disk> + <graphics type="vnc" port="5904"/> + </devices> + </domain> + <domain type="test"> + <name>fc4</name> + <uuid>EF86180145B911CB88E3AFBFE5370493</uuid> + <os> + <type>xen</type> + <kernel>/boot/vmlinuz-2.6.15-1.43_FC5guest</kernel> + <initrd>/boot/initrd-2.6.15-1.43_FC5guest.img</initrd> + <root>/dev/sda1</root> + <cmdline> ro selinux=0 3</cmdline> + </os> + <memory>261072</memory> + <currentMemory>131072</currentMemory> + <vcpu>1</vcpu> + <devices> + <disk type="file"> + <source file="/u/fc4.img"/> + <target dev="sda1"/> + </disk> + <interface type="bridge"> + <source bridge="xenbr0"/> + <mac address="aa:00:00:00:00:11"/> + <script path="/etc/xen/scripts/vif-bridge"/> + </interface> + <console tty="/dev/pts/5"/> + </devices> + </domain> + <network> + <name>private</name> + <uuid>004b22212d78c30f5aa5f03c87d21e69</uuid> + <bridge name="brpriv"/> + <ip address="192.168.124.1" netmask="255.255.255.0"> + <dhcp> + <range start="192.168.124.128" end="192.168.124.253"/> + </dhcp> + </ip> + </network> + <network> + <name>default</name> + <uuid>004b96e12d78c30f5aa5f03c87d21e69</uuid> + <bridge name="brdefault"/> + <forward dev="eth0"/> + <ip address="192.168.122.1" netmask="255.255.255.0"> + <dhcp> + <range start="192.168.122.128" end="192.168.122.253"/> + </dhcp> + </ip> + </network> + <cpu> + <mhz>6000</mhz> + <model>i986</model> + <active>50</active> + <nodes>4</nodes> + <sockets>4</sockets> + <cores>4</cores> + <threads>2</threads> + </cpu> + <memory>8192000</memory> +</node> diff -r 3c038ace4e38 src/test.c --- a/src/test.c Mon Jul 07 11:39:43 2008 +0100 +++ b/src/test.c Mon Jul 07 11:39:51 2008 +0100 @@ -28,66 +28,22 @@ #include <stdio.h> #include <string.h> #include <sys/time.h> -#include <libxml/parser.h> -#include <libxml/tree.h> -#include <libxml/xpath.h> -#include <libxml/uri.h> #include <fcntl.h> #include <unistd.h> #include <sys/stat.h> #include "socketcompat.h" -#include "internal.h" #include "test.h" -#include "xml.h" #include "buf.h" #include "util.h" #include "uuid.h" #include "capabilities.h" #include "memory.h" #include "network_conf.h" +#include "domain_conf.h" +#include "xml.h" -/* Flags that determine the action to take on a shutdown or crash of a domain - */ -typedef enum { - VIR_DOMAIN_DESTROY = 1, /* destroy the domain */ - VIR_DOMAIN_RESTART = 2, /* restart the domain */ - VIR_DOMAIN_PRESERVE= 3, /* keep as is, need manual destroy, for debug */ - VIR_DOMAIN_RENAME_RESTART= 4/* restart under an new unique name */ -} virDomainRestart; - -struct _testDev { - char name[20]; - int mode; -}; -typedef struct _testDev testDev; -typedef struct _testDev *testDevPtr; - -#define MAX_DEVICES 10 - -struct _testDom { - int active; - int config; - int id; - char name[20]; - unsigned char uuid[VIR_UUID_BUFLEN]; - virDomainInfo info; - unsigned int maxVCPUs; - virDomainRestart onRestart; /* What to do at end of current shutdown procedure */ - virDomainRestart onReboot; - virDomainRestart onPoweroff; - virDomainRestart onCrash; - int numDevices; - testDev devices[MAX_DEVICES]; - int autostart; - unsigned int weight; -}; -typedef struct _testDom testDom; -typedef struct _testDom *testDomPtr; - -#define MAX_DOMAINS 20 -#define MAX_NETWORKS 20 #define MAX_CPUS 128 struct _testCell { @@ -103,9 +59,9 @@ struct _testConn { char path[PATH_MAX]; int nextDomID; + virCapsPtr caps; virNodeInfo nodeInfo; - int numDomains; - testDom domains[MAX_DOMAINS]; + virDomainObjPtr domains; virNetworkObjPtr networks; int numCells; testCell cells[MAX_CELLS]; @@ -115,6 +71,7 @@ #define TEST_MODEL "i686" #define TEST_MODEL_WORDSIZE 32 +#define TEST_EMULATOR "/usr/bin/test-hv" static const virNodeInfo defaultNodeInfo = { TEST_MODEL, @@ -128,17 +85,18 @@ }; #define GET_DOMAIN(dom, ret) \ - int domidx; \ testConnPtr privconn; \ - testDomPtr privdom; \ + virDomainObjPtr privdom; \ \ privconn = (testConnPtr)dom->conn->privateData; \ - if ((domidx = getDomainIndex(dom)) < 0) { \ - testError((dom)->conn, (dom), NULL, VIR_ERR_INVALID_ARG, \ - __FUNCTION__); \ - return (ret); \ - } \ - privdom = &privconn->domains[domidx]; + do { \ + if ((privdom = virDomainFindByName(privconn->domains, \ + (dom)->name)) == NULL) { \ + testError((dom)->conn, (dom), NULL, VIR_ERR_INVALID_ARG, \ + __FUNCTION__); \ + return (ret); \ + } \ + } while (0) #define GET_NETWORK(net, ret) \ testConnPtr privconn; \ @@ -154,7 +112,7 @@ } \ } while (0) -#define GET_CONNECTION(conn, ret) \ +#define GET_CONNECTION(conn) \ testConnPtr privconn; \ \ privconn = (testConnPtr)conn->privateData; @@ -177,231 +135,72 @@ errmsg, info, NULL, 0, 0, errmsg, info, 0); } -static int testRestartStringToFlag(const char *str) { - if (STREQ(str, "restart")) { - return VIR_DOMAIN_RESTART; - } else if (STREQ(str, "destroy")) { - return VIR_DOMAIN_DESTROY; - } else if (STREQ(str, "preserve")) { - return VIR_DOMAIN_PRESERVE; - } else if (STREQ(str, "rename-restart")) { - return VIR_DOMAIN_RENAME_RESTART; - } else { - return (0); +static virCapsPtr +testBuildCapabilities(virConnectPtr conn) { + virCapsPtr caps; + virCapsGuestPtr guest; + const char *const guest_types[] = { "hvm", "xen" }; + int i; + GET_CONNECTION(conn); + + if ((caps = virCapabilitiesNew(TEST_MODEL, 0, 0)) == NULL) + goto no_memory; + + if (virCapabilitiesAddHostFeature(caps, "pae") < 0) + goto no_memory; + if (virCapabilitiesAddHostFeature(caps ,"nonpae") < 0) + goto no_memory; + + for (i = 0; i < privconn->numCells; i++) { + if (virCapabilitiesAddHostNUMACell(caps, i, privconn->cells[i].numCpus, + privconn->cells[i].cpus) < 0) + goto no_memory; } + + for (i = 0; i < ARRAY_CARDINALITY(guest_types) ; i++) { + if ((guest = virCapabilitiesAddGuest(caps, + guest_types[i], + TEST_MODEL, + TEST_MODEL_WORDSIZE, + TEST_EMULATOR, + NULL, + 0, + NULL)) == NULL) + goto no_memory; + + if (virCapabilitiesAddGuestDomain(guest, + "test", + NULL, + NULL, + 0, + NULL) == NULL) + goto no_memory; + + if (virCapabilitiesAddGuestFeature(guest, "pae", 1, 1) == NULL) + goto no_memory; + if (virCapabilitiesAddGuestFeature(guest ,"nonpae", 1, 1) == NULL) + goto no_memory; + } + + return caps; + +no_memory: + testError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL); + virCapabilitiesFree(caps); + return NULL; } -static const char *testRestartFlagToString(int flag) { - switch (flag) { - case VIR_DOMAIN_RESTART: - return "restart"; - case VIR_DOMAIN_DESTROY: - return "destroy"; - case VIR_DOMAIN_PRESERVE: - return "preserve"; - case VIR_DOMAIN_RENAME_RESTART: - return "rename-restart"; - } - return (NULL); -} - -static int testLoadDomain(virConnectPtr conn, - int domid, - xmlDocPtr xml) { - xmlNodePtr root = NULL; - xmlXPathContextPtr ctxt = NULL; - char *name = NULL; - unsigned char uuid[VIR_UUID_BUFLEN]; - struct timeval tv; - unsigned long memory = 0; - unsigned long maxMem = 0; - int nrVirtCpu; - char *str; - int handle = -1, i, ret; - long l; - virDomainRestart onReboot = VIR_DOMAIN_RESTART; - virDomainRestart onPoweroff = VIR_DOMAIN_DESTROY; - virDomainRestart onCrash = VIR_DOMAIN_RENAME_RESTART; - GET_CONNECTION(conn, -1); - - if (gettimeofday(&tv, NULL) < 0) { - testError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("getting time of day")); - return (-1); - } - - root = xmlDocGetRootElement(xml); - if ((root == NULL) || (!xmlStrEqual(root->name, BAD_CAST "domain"))) { - testError(conn, NULL, NULL, VIR_ERR_XML_ERROR, _("domain")); - goto error; - } - - ctxt = xmlXPathNewContext(xml); - if (ctxt == NULL) { - testError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("creating xpath context")); - goto error; - } - - name = virXPathString("string(/domain/name[1])", ctxt); - if (name == NULL) { - testError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("domain name")); - goto error; - } - - str = virXPathString("string(/domain/uuid[1])", ctxt); - if (str == NULL) { - testError(conn, NULL, NULL, VIR_ERR_XML_ERROR, _("domain uuid")); - goto error; - } - if (virUUIDParse(str, uuid) < 0) { - testError(conn, NULL, NULL, VIR_ERR_XML_ERROR, _("domain uuid")); - goto error; - } - VIR_FREE(str); - - - ret = virXPathLong("string(/domain/memory[1])", ctxt, &l); - if (ret != 0) { - testError(conn, NULL, NULL, VIR_ERR_XML_ERROR, _("domain memory")); - goto error; - } - maxMem = l; - - ret = virXPathLong("string(/domain/currentMemory[1])", ctxt, &l); - if (ret == -1) { - memory = maxMem; - } else if (ret == -2) { - testError(conn, NULL, NULL, VIR_ERR_XML_ERROR, _("domain current memory")); - goto error; - } else { - memory = l; - } - - ret = virXPathLong("string(/domain/vcpu[1])", ctxt, &l); - if (ret == -1) { - nrVirtCpu = 1; - } else if (ret == -2) { - testError(conn, NULL, NULL, VIR_ERR_XML_ERROR, _("domain vcpus")); - goto error; - } else { - nrVirtCpu = l; - } - - str = virXPathString("string(/domain/on_reboot[1])", ctxt); - if (str != NULL) { - if (!(onReboot = testRestartStringToFlag(str))) { - testError(conn, NULL, NULL, VIR_ERR_XML_ERROR, _("domain reboot behaviour")); - VIR_FREE(str); - goto error; - } - VIR_FREE(str); - } - - str = virXPathString("string(/domain/on_poweroff[1])", ctxt); - if (str != NULL) { - if (!(onPoweroff = testRestartStringToFlag(str))) { - testError(conn, NULL, NULL, VIR_ERR_XML_ERROR, _("domain poweroff behaviour")); - VIR_FREE(str); - goto error; - } - VIR_FREE(str); - } - - str = virXPathString("string(/domain/on_crash[1])", ctxt); - if (str != NULL) { - if (!(onCrash = testRestartStringToFlag(str))) { - testError(conn, NULL, NULL, VIR_ERR_XML_ERROR, _("domain crash behaviour")); - VIR_FREE(str); - goto error; - } - VIR_FREE(str); - } - - for (i = 0 ; i < MAX_DOMAINS ; i++) { - if (!privconn->domains[i].active) { - handle = i; - break; - } - } - if (handle < 0) - goto error; - - privconn->domains[handle].active = 1; - privconn->domains[handle].id = domid; - strncpy(privconn->domains[handle].name, name, sizeof(privconn->domains[handle].name)-1); - privconn->domains[handle].name[sizeof(privconn->domains[handle].name)-1] = '\0'; - VIR_FREE(name); - name = NULL; - - if (memory > maxMem) - memory = maxMem; - - memmove(privconn->domains[handle].uuid, uuid, VIR_UUID_BUFLEN); - privconn->domains[handle].info.maxMem = maxMem; - privconn->domains[handle].info.memory = memory; - privconn->domains[handle].info.state = domid < 0 ? VIR_DOMAIN_SHUTOFF : VIR_DOMAIN_RUNNING; - privconn->domains[handle].info.nrVirtCpu = nrVirtCpu; - privconn->domains[handle].info.cpuTime = ((tv.tv_sec * 1000ll * 1000ll * 1000ll) + (tv.tv_usec * 1000ll)); - privconn->domains[handle].maxVCPUs = nrVirtCpu; - - privconn->domains[handle].onReboot = onReboot; - privconn->domains[handle].onPoweroff = onPoweroff; - privconn->domains[handle].onCrash = onCrash; - - xmlXPathFreeContext(ctxt); - return (handle); - - error: - xmlXPathFreeContext(ctxt); - VIR_FREE(name); - return (-1); -} - -static int testLoadDomainFromDoc(virConnectPtr conn, - int domid, - const char *doc) { - int ret; - xmlDocPtr xml; - if (!(xml = xmlReadDoc(BAD_CAST doc, "domain.xml", NULL, - XML_PARSE_NOENT | XML_PARSE_NONET | - XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) { - testError(conn, NULL, NULL, VIR_ERR_XML_ERROR, _("domain")); - return (-1); - } - - ret = testLoadDomain(conn, domid, xml); - - xmlFreeDoc(xml); - - return (ret); -} - - -static int testLoadDomainFromFile(virConnectPtr conn, - int domid, - const char *filename) { - int ret, fd; - xmlDocPtr xml; - - if ((fd = open(filename, O_RDONLY)) < 0) { - testError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("load domain definition file")); - return (-1); - } - - if (!(xml = xmlReadFd(fd, filename, NULL, - XML_PARSE_NOENT | XML_PARSE_NONET | - XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) { - testError(conn, NULL, NULL, VIR_ERR_XML_ERROR, _("domain")); - return (-1); - } - - ret = testLoadDomain(conn, domid, xml); - - xmlFreeDoc(xml); - close(fd); - - return (ret); -} +static const char *defaultDomainXML = +"<domain type='test'>" +" <name>test</name>" +" <memory>8388608</memory>" +" <currentMemory>2097152</currentMemory>" +" <vcpu>2</vcpu>" +" <os>" +" <type>hvm</type>" +" </os>" +"</domain>"; static const char *defaultNetworkXML = @@ -421,50 +220,23 @@ int u; struct timeval tv; testConnPtr privconn; - virNetworkDefPtr netdef; - virNetworkObjPtr netobj; + virDomainDefPtr domdef = NULL; + virDomainObjPtr domobj = NULL; + virNetworkDefPtr netdef = NULL; + virNetworkObjPtr netobj = NULL; if (VIR_ALLOC(privconn) < 0) { testError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, "testConn"); return VIR_DRV_OPEN_ERROR; } + conn->privateData = privconn; if (gettimeofday(&tv, NULL) < 0) { testError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("getting time of day")); - return VIR_DRV_OPEN_ERROR; + goto error; } memmove(&privconn->nodeInfo, &defaultNodeInfo, sizeof(defaultNodeInfo)); - - strcpy(privconn->path, "/default"); - privconn->nextDomID = 1; - privconn->numDomains = 1; - privconn->domains[0].active = 1; - privconn->domains[0].config = 1; - privconn->domains[0].id = privconn->nextDomID++; - privconn->domains[0].onReboot = VIR_DOMAIN_RESTART; - privconn->domains[0].onCrash = VIR_DOMAIN_RESTART; - privconn->domains[0].onPoweroff = VIR_DOMAIN_DESTROY; - strcpy(privconn->domains[0].name, "test"); - for (u = 0 ; u < VIR_UUID_BUFLEN ; u++) { - privconn->domains[0].uuid[u] = (u * 75)%255; - } - privconn->domains[0].info.maxMem = 8192 * 1024; - privconn->domains[0].info.memory = 2048 * 1024; - privconn->domains[0].info.state = VIR_DOMAIN_RUNNING; - privconn->domains[0].info.nrVirtCpu = 2; - privconn->domains[0].info.cpuTime = ((tv.tv_sec * 1000ll * 1000ll * 1000ll) + (tv.tv_usec * 1000ll)); - - - if (!(netdef = virNetworkDefParseString(conn, defaultNetworkXML))) { - return VIR_DRV_OPEN_ERROR; - } - if (!(netobj = virNetworkAssignDef(conn, &privconn->networks, netdef))) { - virNetworkDefFree(netdef); - return VIR_DRV_OPEN_ERROR; - } - netobj->active = 1; - netobj->persistent = 1; // Numa setup privconn->numCells = 2; @@ -476,8 +248,39 @@ privconn->cells[u % 2].cpus[(u / 2)] = u; } - conn->privateData = privconn; - return (VIR_DRV_OPEN_SUCCESS); + if (!(privconn->caps = testBuildCapabilities(conn))) + goto error; + + privconn->nextDomID = 1; + + if (!(domdef = virDomainDefParseString(conn, privconn->caps, defaultDomainXML))) + goto error; + if (!(domobj = virDomainAssignDef(conn, &privconn->domains, domdef))) { + virDomainDefFree(domdef); + goto error; + } + domobj->def->id = 1; + domobj->state = VIR_DOMAIN_RUNNING; + domobj->persistent = 1; + + if (!(netdef = virNetworkDefParseString(conn, defaultNetworkXML))) + goto error; + if (!(netobj = virNetworkAssignDef(conn, &privconn->networks, netdef))) { + virNetworkDefFree(netdef); + goto error; + } + + netobj->active = 1; + netobj->persistent = 1; + + return VIR_DRV_OPEN_SUCCESS; + +error: + virDomainObjFree(privconn->domains); + virNetworkObjFree(privconn->networks); + virCapabilitiesFree(privconn->caps); + VIR_FREE(privconn); + return VIR_DRV_OPEN_ERROR; } @@ -514,11 +317,17 @@ xmlNodePtr *domains, *networks = NULL; xmlXPathContextPtr ctxt = NULL; virNodeInfoPtr nodeInfo; + virNetworkObjPtr net; + virDomainObjPtr dom; testConnPtr privconn; if (VIR_ALLOC(privconn) < 0) { testError(NULL, NULL, NULL, VIR_ERR_NO_MEMORY, "testConn"); return VIR_DRV_OPEN_ERROR; } + conn->privateData = privconn; + + if (!(privconn->caps = testBuildCapabilities(conn))) + goto error; if ((fd = open(file, O_RDONLY)) < 0) { testError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("loading host definition file")); @@ -546,10 +355,7 @@ goto error; } - - conn->privateData = privconn; privconn->nextDomID = 1; - privconn->numDomains = 0; privconn->numCells = 0; strncpy(privconn->path, file, PATH_MAX-1); privconn->path[PATH_MAX-1] = '\0'; @@ -628,27 +434,37 @@ } for (i = 0 ; i < ret ; i++) { - xmlChar *domFile = xmlGetProp(domains[i], BAD_CAST "file"); - char *absFile = testBuildFilename(file, (const char *)domFile); - int domid = privconn->nextDomID++, handle; - VIR_FREE(domFile); - if (!absFile) { - testError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("resolving domain filename")); + virDomainDefPtr def; + char *relFile = virXMLPropString(domains[i], "file"); + if (relFile != NULL) { + char *absFile = testBuildFilename(file, relFile); + VIR_FREE(relFile); + if (!absFile) { + testError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("resolving domain filename")); + goto error; + } + def = virDomainDefParseFile(conn, privconn->caps, absFile); + VIR_FREE(absFile); + if (!def) + goto error; + } else { + if ((def = virDomainDefParseNode(conn, privconn->caps, xml, domains[i])) == NULL) + goto error; + } + + if (!(dom = virDomainAssignDef(conn, &privconn->domains, def))) { + virDomainDefFree(def); goto error; } - if ((handle = testLoadDomainFromFile(conn, domid, absFile)) < 0) { - VIR_FREE(absFile); - goto error; - } - privconn->domains[handle].config = 1; - VIR_FREE(absFile); - privconn->numDomains++; + + dom->state = VIR_DOMAIN_RUNNING; + dom->def->id = privconn->nextDomID++; + dom->persistent = 1; } if (domains != NULL) { VIR_FREE(domains); domains = NULL; } - ret = virXPathNodeSet("/node/network", ctxt, &networks); if (ret < 0) { @@ -657,7 +473,6 @@ } for (i = 0 ; i < ret ; i++) { virNetworkDefPtr def; - virNetworkObjPtr net; char *relFile = virXMLPropString(networks[i], "file"); if (relFile != NULL) { char *absFile = testBuildFilename(file, relFile); @@ -695,32 +510,28 @@ error: xmlXPathFreeContext(ctxt); + xmlFreeDoc(xml); VIR_FREE(domains); VIR_FREE(networks); - if (xml) - xmlFreeDoc(xml); if (fd != -1) close(fd); + dom = privconn->domains; + while (dom) { + virDomainObjPtr tmp = dom->next; + virDomainObjFree(dom); + dom = tmp; + } + net = privconn->networks; + while (net) { + virNetworkObjPtr tmp = net->next; + virNetworkObjFree(net); + net = tmp; + } VIR_FREE(privconn); conn->privateData = NULL; return VIR_DRV_OPEN_ERROR; } -static int getDomainIndex(virDomainPtr domain) { - int i; - GET_CONNECTION(domain->conn, -1); - - for (i = 0 ; i < MAX_DOMAINS ; i++) { - if (domain->id >= 0) { - if (domain->id == privconn->domains[i].id) - return (i); - } else { - if (STREQ(domain->name, privconn->domains[i].name)) - return (i); - } - } - return (-1); -} static int testOpen(virConnectPtr conn, xmlURIPtr uri, @@ -762,7 +573,22 @@ static int testClose(virConnectPtr conn) { - GET_CONNECTION(conn, -1); + virDomainObjPtr dom; + virNetworkObjPtr net; + GET_CONNECTION(conn); + virCapabilitiesFree(privconn->caps); + dom = privconn->domains; + while (dom) { + virDomainObjPtr tmp = dom->next; + virDomainObjFree(dom); + dom = tmp; + } + net = privconn->networks; + while (net) { + virNetworkObjPtr tmp = net->next; + virNetworkObjFree(net); + net = tmp; + } VIR_FREE (privconn); conn->privateData = conn; return 0; @@ -796,7 +622,7 @@ static char * testGetURI (virConnectPtr conn) { char *uri; - GET_CONNECTION(conn, NULL); + GET_CONNECTION(conn); if (asprintf (&uri, "test://%s", privconn->path) == -1) { testError (conn, NULL, NULL, VIR_ERR_SYSTEM_ERROR, strerror (errno)); @@ -814,224 +640,149 @@ static int testNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info) { - GET_CONNECTION(conn, -1); + GET_CONNECTION(conn); memcpy(info, &privconn->nodeInfo, sizeof(virNodeInfo)); return (0); } static char *testGetCapabilities (virConnectPtr conn) { - virCapsPtr caps; - virCapsGuestPtr guest; char *xml; - const char *guest_types[] = { "hvm", "xen" }; - int i; + GET_CONNECTION(conn); - GET_CONNECTION(conn, -1); - - if ((caps = virCapabilitiesNew(TEST_MODEL, 0, 0)) == NULL) - goto no_memory; - - if (virCapabilitiesAddHostFeature(caps, "pae") < 0) - goto no_memory; - if (virCapabilitiesAddHostFeature(caps ,"nonpae") < 0) - goto no_memory; - - for (i = 0; i < privconn->numCells; ++i) { - if (virCapabilitiesAddHostNUMACell(caps, i, privconn->cells[i].numCpus, - privconn->cells[i].cpus) < 0) - goto no_memory; + if ((xml = virCapabilitiesFormatXML(privconn->caps)) == NULL) { + testError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL); + return NULL; } - for (i = 0; i < (sizeof(guest_types)/sizeof(guest_types[0])); ++i) { - - if ((guest = virCapabilitiesAddGuest(caps, - guest_types[i], - TEST_MODEL, - TEST_MODEL_WORDSIZE, - NULL, - NULL, - 0, - NULL)) == NULL) - goto no_memory; - - if (virCapabilitiesAddGuestDomain(guest, - "test", - NULL, - NULL, - 0, - NULL) == NULL) - goto no_memory; - - if (virCapabilitiesAddGuestFeature(guest, "pae", 1, 1) == NULL) - goto no_memory; - if (virCapabilitiesAddGuestFeature(guest ,"nonpae", 1, 1) == NULL) - goto no_memory; - } - - if ((xml = virCapabilitiesFormatXML(caps)) == NULL) - goto no_memory; - - virCapabilitiesFree(caps); - return xml; - - no_memory: - virCapabilitiesFree(caps); - testError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, __FUNCTION__); - return NULL; } static int testNumOfDomains(virConnectPtr conn) { - int numActive = 0, i; - GET_CONNECTION(conn, -1); + int numActive = 0; + virDomainObjPtr dom; + GET_CONNECTION(conn); - for (i = 0 ; i < MAX_DOMAINS ; i++) { - if (!privconn->domains[i].active || - privconn->domains[i].info.state == VIR_DOMAIN_SHUTOFF) - continue; - numActive++; + dom = privconn->domains; + while (dom) { + if (virDomainIsActive(dom)) + numActive++; + dom = dom->next; } - return (numActive); + return numActive; } static virDomainPtr -testDomainCreateLinux(virConnectPtr conn, const char *xmlDesc, +testDomainCreateLinux(virConnectPtr conn, const char *xml, unsigned int flags ATTRIBUTE_UNUSED) { - int domid, handle = -1; - virDomainPtr dom; - GET_CONNECTION(conn, NULL); + virDomainPtr ret; + virDomainDefPtr def; + virDomainObjPtr dom; + GET_CONNECTION(conn); - if (xmlDesc == NULL) { - testError(conn, NULL, NULL, VIR_ERR_INVALID_ARG, __FUNCTION__); - return (NULL); + if ((def = virDomainDefParseString(conn, privconn->caps, xml)) == NULL) + return NULL; + + if ((dom = virDomainAssignDef(conn, &privconn->domains, + def)) == NULL) { + virDomainDefFree(def); + return NULL; } + dom->state = VIR_DOMAIN_RUNNING; + dom->def->id = privconn->nextDomID++; - if (privconn->numDomains == MAX_DOMAINS) { - testError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("too many domains")); - return (NULL); - } - - domid = privconn->nextDomID++; - if ((handle = testLoadDomainFromDoc(conn, domid, xmlDesc)) < 0) - return (NULL); - privconn->domains[handle].config = 0; - - dom = virGetDomain(conn, privconn->domains[handle].name, privconn->domains[handle].uuid); - if (dom == NULL) return NULL; - privconn->numDomains++; - return (dom); + ret = virGetDomain(conn, def->name, def->uuid); + if (!ret) + return NULL; + ret->id = def->id; + return ret; } static virDomainPtr testLookupDomainByID(virConnectPtr conn, int id) { - virDomainPtr dom; - int i, idx = -1; - GET_CONNECTION(conn, NULL); + virDomainObjPtr dom = NULL; + virDomainPtr ret; + GET_CONNECTION(conn); - for (i = 0 ; i < MAX_DOMAINS ; i++) { - if (privconn->domains[i].active && - privconn->domains[i].id == id) { - idx = i; - break; - } + if ((dom = virDomainFindByID(privconn->domains, id)) == NULL) { + testError (conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL); + return NULL; } - if (idx < 0) { - testError (conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL); - return(NULL); - } - - dom = virGetDomain(conn, privconn->domains[idx].name, privconn->domains[idx].uuid); - if (dom == NULL) return NULL; - dom->id = id; - return (dom); + ret = virGetDomain(conn, dom->def->name, dom->def->uuid); + if (!ret) + return NULL; + ret->id = dom->def->id; + return ret; } static virDomainPtr testLookupDomainByUUID(virConnectPtr conn, const unsigned char *uuid) { - virDomainPtr dom; - int i, idx = -1; - GET_CONNECTION(conn, NULL); + virDomainPtr ret; + virDomainObjPtr dom = NULL; + GET_CONNECTION(conn); - for (i = 0 ; i < MAX_DOMAINS ; i++) { - if (privconn->domains[i].active && - memcmp(uuid, privconn->domains[i].uuid, VIR_UUID_BUFLEN) == 0) { - idx = i; - break; - } - } - - if (idx < 0) { + if ((dom = virDomainFindByUUID(privconn->domains, uuid)) == NULL) { testError (conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL); return NULL; } - dom = virGetDomain(conn, privconn->domains[idx].name, privconn->domains[idx].uuid); - if (dom == NULL) return NULL; - dom->id = privconn->domains[idx].id; - - return dom; + ret = virGetDomain(conn, dom->def->name, dom->def->uuid); + if (!ret) + return NULL; + ret->id = dom->def->id; + return ret; } static virDomainPtr testLookupDomainByName(virConnectPtr conn, const char *name) { - virDomainPtr dom; - int i, idx = -1; - GET_CONNECTION(conn, NULL); + virDomainPtr ret; + virDomainObjPtr dom = NULL; + GET_CONNECTION(conn); - for (i = 0 ; i < MAX_DOMAINS ; i++) { - if (privconn->domains[i].active && - STREQ(name, privconn->domains[i].name)) { - idx = i; - break; - } - } - - if (idx < 0) { + if ((dom = virDomainFindByName(privconn->domains, name)) == NULL) { testError (conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL); return NULL; } - dom = virGetDomain(conn, privconn->domains[idx].name, privconn->domains[idx].uuid); - if (dom == NULL) return NULL; - dom->id = privconn->domains[idx].id; - - return dom; + ret = virGetDomain(conn, dom->def->name, dom->def->uuid); + if (!ret) + return NULL; + ret->id = dom->def->id; + return ret; } static int testListDomains (virConnectPtr conn, int *ids, int maxids) { - int n, i; - GET_CONNECTION(conn, -1); + int n = 0; + virDomainObjPtr dom; + GET_CONNECTION(conn); - for (i = 0, n = 0 ; i < MAX_DOMAINS && n < maxids ; i++) { - if (privconn->domains[i].active && - privconn->domains[i].info.state != VIR_DOMAIN_SHUTOFF) { - ids[n++] = privconn->domains[i].id; - } + dom = privconn->domains; + while (dom && n < maxids) { + if (virDomainIsActive(dom)) + ids[n++] = dom->def->id; + dom = dom->next; } - return (n); + return n; } static int testDestroyDomain (virDomainPtr domain) { GET_DOMAIN(domain, -1); - if (privdom->config) { - privdom->info.state = VIR_DOMAIN_SHUTOFF; - privdom->id = -1; - domain->id = -1; - } else { - privdom->active = 0; + privdom->state = VIR_DOMAIN_SHUTOFF; + if (!privdom->persistent) { + virDomainRemoveInactive(&privconn->domains, + privdom); } return (0); } @@ -1040,12 +791,13 @@ { GET_DOMAIN(domain, -1); - if (privdom->info.state != VIR_DOMAIN_PAUSED) { - testError(domain->conn, domain, NULL, VIR_ERR_INTERNAL_ERROR, "domain not paused"); + if (privdom->state != VIR_DOMAIN_PAUSED) { + testError(domain->conn, domain, NULL, + VIR_ERR_INTERNAL_ERROR, _("domain not paused")); return -1; } - privdom->info.state = VIR_DOMAIN_RUNNING; + privdom->state = VIR_DOMAIN_RUNNING; return (0); } @@ -1053,13 +805,14 @@ { GET_DOMAIN(domain, -1); - if (privdom->info.state == VIR_DOMAIN_SHUTOFF || - privdom->info.state == VIR_DOMAIN_PAUSED) { - testError(domain->conn, domain, NULL, VIR_ERR_INTERNAL_ERROR, "domain not running"); + if (privdom->state == VIR_DOMAIN_SHUTOFF || + privdom->state == VIR_DOMAIN_PAUSED) { + testError(domain->conn, domain, NULL, + VIR_ERR_INTERNAL_ERROR, _("domain not running")); return -1; } - privdom->info.state = VIR_DOMAIN_PAUSED; + privdom->state = VIR_DOMAIN_PAUSED; return (0); } @@ -1067,52 +820,50 @@ { GET_DOMAIN(domain, -1); - if (privdom->info.state == VIR_DOMAIN_SHUTOFF) { + if (privdom->state == VIR_DOMAIN_SHUTOFF) { testError(domain->conn, domain, NULL, VIR_ERR_INTERNAL_ERROR, "domain not running"); return -1; } - privdom->info.state = VIR_DOMAIN_SHUTOFF; + privdom->state = VIR_DOMAIN_SHUTOFF; domain->id = -1; - privdom->id = -1; + privdom->def->id = -1; return (0); } /* Similar behaviour as shutdown */ -static int testRebootDomain (virDomainPtr domain, virDomainRestart action) +static int testRebootDomain (virDomainPtr domain, + unsigned int action ATTRIBUTE_UNUSED) { GET_DOMAIN(domain, -1); - if (!action) - action = VIR_DOMAIN_RESTART; - - privdom->info.state = VIR_DOMAIN_SHUTDOWN; - switch (action) { - case VIR_DOMAIN_DESTROY: - privdom->info.state = VIR_DOMAIN_SHUTOFF; + privdom->state = VIR_DOMAIN_SHUTDOWN; + switch (privdom->def->onReboot) { + case VIR_DOMAIN_LIFECYCLE_DESTROY: + privdom->state = VIR_DOMAIN_SHUTOFF; domain->id = -1; - privdom->id = -1; + privdom->def->id = -1; break; - case VIR_DOMAIN_RESTART: - privdom->info.state = VIR_DOMAIN_RUNNING; + case VIR_DOMAIN_LIFECYCLE_RESTART: + privdom->state = VIR_DOMAIN_RUNNING; break; - case VIR_DOMAIN_PRESERVE: - privdom->info.state = VIR_DOMAIN_SHUTOFF; + case VIR_DOMAIN_LIFECYCLE_PRESERVE: + privdom->state = VIR_DOMAIN_SHUTOFF; domain->id = -1; - privdom->id = -1; + privdom->def->id = -1; break; - case VIR_DOMAIN_RENAME_RESTART: - privdom->info.state = VIR_DOMAIN_RUNNING; + case VIR_DOMAIN_LIFECYCLE_RESTART_RENAME: + privdom->state = VIR_DOMAIN_RUNNING; break; default: - privdom->info.state = VIR_DOMAIN_SHUTOFF; + privdom->state = VIR_DOMAIN_SHUTOFF; domain->id = -1; - privdom->id = -1; + privdom->def->id = -1; break; } @@ -1130,13 +881,11 @@ return (-1); } - if (privdom->info.state == VIR_DOMAIN_SHUTOFF) { - privdom->info.cpuTime = 0; - privdom->info.memory = 0; - } else { - privdom->info.cpuTime = ((tv.tv_sec * 1000ll * 1000ll * 1000ll) + (tv.tv_usec * 1000ll)); - } - memcpy(info, &privdom->info, sizeof(virDomainInfo)); + info->state = privdom->state; + info->memory = privdom->def->memory; + info->maxMem = privdom->def->maxmem; + info->nrVirtCpu = privdom->def->vcpus; + info->cpuTime = ((tv.tv_sec * 1000ll * 1000ll * 1000ll) + (tv.tv_usec * 1000ll)); return (0); } @@ -1190,12 +939,10 @@ close(fd); return (-1); } - if (privdom->config) { - privdom->info.state = VIR_DOMAIN_SHUTOFF; - privdom->id = -1; - domain->id = -1; - } else { - privdom->active = 0; + privdom->state = VIR_DOMAIN_SHUTOFF; + if (!privdom->persistent) { + virDomainRemoveInactive(&privconn->domains, + privdom); } return 0; } @@ -1205,8 +952,10 @@ { char *xml; char magic[15]; - int fd, len, ret, domid; - GET_CONNECTION(conn, -1); + int fd, len; + virDomainDefPtr def; + virDomainObjPtr dom; + GET_CONNECTION(conn); if ((fd = open(path, O_RDONLY)) < 0) { testError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, @@ -1250,10 +999,20 @@ } xml[len] = '\0'; close(fd); - domid = privconn->nextDomID++; - ret = testLoadDomainFromDoc(conn, domid, xml); + + def = virDomainDefParseString(conn, privconn->caps, xml); VIR_FREE(xml); - return ret < 0 ? -1 : 0; + if (!def) + return -1; + + if ((dom = virDomainAssignDef(conn, &privconn->domains, + def)) == NULL) { + virDomainDefFree(def); + return -1; + } + dom->state = VIR_DOMAIN_RUNNING; + dom->def->id = privconn->nextDomID++; + return dom->def->id; } static int testDomainCoreDump(virDomainPtr domain, @@ -1280,24 +1039,25 @@ close(fd); return (-1); } - if (privdom->config) { - privdom->info.state = VIR_DOMAIN_SHUTOFF; - privdom->id = -1; - domain->id = -1; - } else { - privdom->active = 0; + privdom->state = VIR_DOMAIN_SHUTOFF; + if (!privdom->persistent) { + virDomainRemoveInactive(&privconn->domains, + privdom); } return 0; } -static char *testGetOSType(virDomainPtr dom ATTRIBUTE_UNUSED) { - return strdup("linux"); +static char *testGetOSType(virDomainPtr dom) { + char *ret = strdup("linux"); + if (!ret) + testError(dom->conn, dom, NULL, VIR_ERR_NO_MEMORY, NULL); + return ret; } static unsigned long testGetMaxMemory(virDomainPtr domain) { GET_DOMAIN(domain, -1); - return privdom->info.maxMem; + return privdom->def->maxmem; } static int testSetMaxMemory(virDomainPtr domain, @@ -1306,7 +1066,7 @@ GET_DOMAIN(domain, -1); /* XXX validate not over host memory wrt to other domains */ - privdom->info.maxMem = memory; + privdom->def->maxmem = memory; return (0); } @@ -1315,12 +1075,13 @@ { GET_DOMAIN(domain, -1); - if (memory > privdom->info.maxMem) { - testError(domain->conn, domain, NULL, VIR_ERR_INVALID_ARG, __FUNCTION__); + if (memory > privdom->def->maxmem) { + testError(domain->conn, domain, NULL, + VIR_ERR_INVALID_ARG, __FUNCTION__); return (-1); } - privdom->info.memory = memory; + privdom->def->memory = memory; return (0); } @@ -1334,88 +1095,84 @@ return (-1); } - privdom->info.nrVirtCpu = nrCpus; + privdom->def->vcpus = nrCpus; return (0); } -static char *testDomainDumpXML(virDomainPtr domain, int flags ATTRIBUTE_UNUSED) +static char *testDomainDumpXML(virDomainPtr domain, int flags) { - virBuffer buf = VIR_BUFFER_INITIALIZER; - unsigned char *uuid; - char uuidstr[VIR_UUID_STRING_BUFLEN]; + virDomainDefPtr def; GET_DOMAIN(domain, NULL); - virBufferVSprintf(&buf, "<domain type='test' id='%d'>\n", domain->id); - virBufferVSprintf(&buf, " <name>%s</name>\n", domain->name); - uuid = domain->uuid; - virUUIDFormat(uuid, uuidstr); - virBufferVSprintf(&buf, " <uuid>%s</uuid>\n", uuidstr); - virBufferVSprintf(&buf, " <memory>%lu</memory>\n", privdom->info.maxMem); - virBufferVSprintf(&buf, " <vcpu>%d</vcpu>\n", privdom->info.nrVirtCpu); - virBufferVSprintf(&buf, " <on_reboot>%s</on_reboot>\n", testRestartFlagToString(privdom->onReboot)); - virBufferVSprintf(&buf, " <on_poweroff>%s</on_poweroff>\n", testRestartFlagToString(privdom->onPoweroff)); - virBufferVSprintf(&buf, " <on_crash>%s</on_crash>\n", testRestartFlagToString(privdom->onCrash)); + def = (flags & VIR_DOMAIN_XML_INACTIVE) && + privdom->newDef ? privdom->newDef : privdom->def; - virBufferAddLit(&buf, "</domain>\n"); - - if (virBufferError(&buf)) { - testError(domain->conn, domain, NULL, VIR_ERR_NO_MEMORY, __FUNCTION__); - return NULL; - } - - return virBufferContentAndReset(&buf); + return virDomainDefFormat(domain->conn, + def, + flags); } static int testNumOfDefinedDomains(virConnectPtr conn) { - int numInactive = 0, i; - GET_CONNECTION(conn, -1); + int numInactive = 0; + virDomainObjPtr dom; + GET_CONNECTION(conn); - for (i = 0 ; i < MAX_DOMAINS ; i++) { - if (!privconn->domains[i].active || - privconn->domains[i].info.state != VIR_DOMAIN_SHUTOFF) - continue; - numInactive++; + dom = privconn->domains; + while (dom) { + if (!virDomainIsActive(dom)) + numInactive++; + dom = dom->next; } - return (numInactive); + return numInactive; } static int testListDefinedDomains(virConnectPtr conn, char **const names, int maxnames) { - int n = 0, i; - GET_CONNECTION(conn, -1); + int n = 0; + virDomainObjPtr dom; + GET_CONNECTION(conn); - for (i = 0, n = 0 ; i < MAX_DOMAINS && n < maxnames ; i++) { - if (privconn->domains[i].active && - privconn->domains[i].info.state == VIR_DOMAIN_SHUTOFF) { - names[n++] = strdup(privconn->domains[i].name); - } + dom = privconn->domains; + memset(names, 0, sizeof(*names)*maxnames); + while (dom && n < maxnames) { + if (virDomainIsActive(dom) && + !(names[n++] = strdup(dom->def->name))) + goto no_memory; + dom = dom->next; } - return (n); + return n; + +no_memory: + testError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL); + for (n = 0 ; n < maxnames ; n++) + VIR_FREE(names[n]); + return -1; } static virDomainPtr testDomainDefineXML(virConnectPtr conn, - const char *doc) { - int handle; - xmlDocPtr xml; - GET_CONNECTION(conn, NULL); + const char *xml) { + virDomainPtr ret; + virDomainDefPtr def; + virDomainObjPtr dom; + GET_CONNECTION(conn); - if (!(xml = xmlReadDoc(BAD_CAST doc, "domain.xml", NULL, - XML_PARSE_NOENT | XML_PARSE_NONET | - XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) { - testError(conn, NULL, NULL, VIR_ERR_XML_ERROR, _("domain")); - return (NULL); + if ((def = virDomainDefParseString(conn, privconn->caps, xml)) == NULL) + return NULL; + + if ((dom = virDomainAssignDef(conn, &privconn->domains, + def)) == NULL) { + virDomainDefFree(def); + return NULL; } + dom->persistent = 1; + dom->def->id = -1; - handle = testLoadDomain(conn, -1, xml); - privconn->domains[handle].config = 1; - - xmlFreeDoc(xml); - - if (handle < 0) - return (NULL); - - return virGetDomain(conn, privconn->domains[handle].name, privconn->domains[handle].uuid); + ret = virGetDomain(conn, def->name, def->uuid); + if (!ret) + return NULL; + ret->id = -1; + return ret; } static int testNodeGetCellsFreeMemory(virConnectPtr conn, @@ -1423,7 +1180,7 @@ int startCell, int maxCells) { int i, j; - GET_CONNECTION(conn, -1); + GET_CONNECTION(conn); if (startCell > privconn->numCells) { testError(conn, NULL, NULL, VIR_ERR_INVALID_ARG, @@ -1444,14 +1201,14 @@ static int testDomainCreate(virDomainPtr domain) { GET_DOMAIN(domain, -1); - if (privdom->info.state != VIR_DOMAIN_SHUTOFF) { + if (privdom->state != VIR_DOMAIN_SHUTOFF) { testError(domain->conn, domain, NULL, VIR_ERR_INTERNAL_ERROR, _("Domain is already running")); return (-1); } - domain->id = privdom->id = privconn->nextDomID++; - privdom->info.state = VIR_DOMAIN_RUNNING; + domain->id = privdom->def->id = privconn->nextDomID++; + privdom->state = VIR_DOMAIN_RUNNING; return (0); } @@ -1459,13 +1216,15 @@ static int testDomainUndefine(virDomainPtr domain) { GET_DOMAIN(domain, -1); - if (privdom->info.state != VIR_DOMAIN_SHUTOFF) { + if (privdom->state != VIR_DOMAIN_SHUTOFF) { testError(domain->conn, domain, NULL, VIR_ERR_INTERNAL_ERROR, _("Domain is still running")); return (-1); } - privdom->active = 0; + privdom->state = VIR_DOMAIN_SHUTOFF; + virDomainRemoveInactive(&privconn->domains, + privdom); return (0); } @@ -1511,7 +1270,9 @@ } strcpy(params[0].field, "weight"); params[0].type = VIR_DOMAIN_SCHED_FIELD_UINT; - params[0].value.ui = privdom->weight; + /* XXX */ + /*params[0].value.ui = privdom->weight;*/ + params[0].value.ui = 50; return 0; } @@ -1533,7 +1294,8 @@ testError(domain->conn, domain, NULL, VIR_ERR_INVALID_ARG, "type"); return (-1); } - privdom->weight = params[0].value.ui; + /* XXX */ + /*privdom->weight = params[0].value.ui;*/ return 0; } @@ -1558,7 +1320,7 @@ const unsigned char *uuid) { virNetworkObjPtr net = NULL; - GET_CONNECTION(conn, NULL); + GET_CONNECTION(conn); if ((net = virNetworkFindByUUID(privconn->networks, uuid)) == NULL) { testError (conn, NULL, NULL, VIR_ERR_NO_NETWORK, NULL); @@ -1572,7 +1334,7 @@ const char *name) { virNetworkObjPtr net = NULL; - GET_CONNECTION(conn, NULL); + GET_CONNECTION(conn); if ((net = virNetworkFindByName(privconn->networks, name)) == NULL) { testError (conn, NULL, NULL, VIR_ERR_NO_NETWORK, NULL); @@ -1586,7 +1348,7 @@ static int testNumNetworks(virConnectPtr conn) { int numActive = 0; virNetworkObjPtr net; - GET_CONNECTION(conn, -1); + GET_CONNECTION(conn); net = privconn->networks; while (net) { @@ -1600,7 +1362,7 @@ static int testListNetworks(virConnectPtr conn, char **const names, int nnames) { int n = 0; virNetworkObjPtr net; - GET_CONNECTION(conn, -1); + GET_CONNECTION(conn); net = privconn->networks; memset(names, 0, sizeof(*names)*nnames); @@ -1622,7 +1384,7 @@ static int testNumDefinedNetworks(virConnectPtr conn) { int numInactive = 0; virNetworkObjPtr net; - GET_CONNECTION(conn, -1); + GET_CONNECTION(conn); net = privconn->networks; while (net) { @@ -1636,7 +1398,7 @@ static int testListDefinedNetworks(virConnectPtr conn, char **const names, int nnames) { int n = 0; virNetworkObjPtr net; - GET_CONNECTION(conn, -1); + GET_CONNECTION(conn); net = privconn->networks; memset(names, 0, sizeof(*names)*nnames); @@ -1658,7 +1420,7 @@ static virNetworkPtr testNetworkCreate(virConnectPtr conn, const char *xml) { virNetworkDefPtr def; virNetworkObjPtr net; - GET_CONNECTION(conn, NULL); + GET_CONNECTION(conn); if ((def = virNetworkDefParseString(conn, xml)) == NULL) return NULL; @@ -1676,7 +1438,7 @@ static virNetworkPtr testNetworkDefine(virConnectPtr conn, const char *xml) { virNetworkDefPtr def; virNetworkObjPtr net; - GET_CONNECTION(conn, NULL); + GET_CONNECTION(conn); if ((def = virNetworkDefParseString(conn, xml)) == NULL) return NULL; diff -r 3c038ace4e38 src/test.h --- a/src/test.h Mon Jul 07 11:39:43 2008 +0100 +++ b/src/test.h Mon Jul 07 11:39:51 2008 +0100 @@ -24,7 +24,7 @@ #ifndef __VIR_TEST_INTERNAL_H__ #define __VIR_TEST_INTERNAL_H__ -#include "libvirt/virterror.h" +#include "internal.h" #ifdef __cplusplus extern "C" { diff -r 3c038ace4e38 tests/read-non-seekable --- a/tests/read-non-seekable Mon Jul 07 11:39:43 2008 +0100 +++ b/tests/read-non-seekable Mon Jul 07 11:39:51 2008 +0100 @@ -31,6 +31,9 @@ <uuid>004b96e1-2d78-c30f-5aa5-000000000000</uuid> <memory>8388608</memory> <vcpu>2</vcpu> + <os> + <type>xen</type> + </os> <on_reboot>restart</on_reboot> <on_poweroff>destroy</on_poweroff> <on_crash>restart</on_crash> diff -r 3c038ace4e38 tests/virshtest.c --- a/tests/virshtest.c Mon Jul 07 11:39:43 2008 +0100 +++ b/tests/virshtest.c Mon Jul 07 11:39:51 2008 +0100 @@ -48,10 +48,6 @@ if (testFilterLine(actualData, filter) < 0) return -1; - if (getenv("DEBUG_TESTS")) { - printf("Expect %d '%s'\n", (int)strlen(expectData), expectData); - printf("Actual %d '%s'\n", (int)strlen(actualData), actualData); - } if (STRNEQ(expectData, actualData)) { virtTestDifference(stderr, expectData, actualData); return -1; -- |: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :| |: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|

This patch ports the QEMU driver to the domain XML apis. Obviously we delete alot of the struct defintions and all the code used for parsing and formatting XML. Then there follows alot of fixup to deal with API name changes. The other notable point is that the char * arrays are no longer pre-declared as PATH_MAX in size, instead being allocated on the heap. So we change alot of conditionals from looking like foo[0] == '\0' over to foo == NULL The qemudBuildCommandLine() functions gains a whole lot of extra args since we no longer pass our QEMU specific state in via the domain's config object (as that's shared between all drivers). Since the last version of the patch lots of bugs fixed, and also al the code for saving/loading the persistent config files has been moved into the generic network_conf.c module too. src/qemu_conf.c | 2781 +------------------ src/qemu_conf.h | 368 -- src/qemu_driver.c | 481 +-- tests/qemuxml2argvdata/qemuxml2argv-bootloader.xml | 2 tests/qemuxml2argvdata/qemuxml2argv-graphics-vnc.xml | 2 tests/qemuxml2argvdata/qemuxml2argv-input-xen.args | 2 tests/qemuxml2argvdata/qemuxml2argv-input-xen.xml | 4 tests/qemuxml2argvdata/qemuxml2argv-sound.xml | 7 tests/qemuxml2argvtest.c | 31 tests/qemuxml2xmltest.c | 20 10 files changed, 468 insertions(+), 3230 deletions(-) Daniel diff -r 8b6e9b6cbaa5 src/qemu_conf.c --- a/src/qemu_conf.c Tue Jul 08 15:26:54 2008 +0100 +++ b/src/qemu_conf.c Tue Jul 08 15:29:16 2008 +0100 @@ -37,16 +37,10 @@ #include <arpa/inet.h> #include <sys/utsname.h> -#include <libxml/parser.h> -#include <libxml/tree.h> -#include <libxml/xpath.h> -#include <libxml/uri.h> - #if HAVE_NUMACTL #include <numa.h> #endif -#include "internal.h" #include "qemu_conf.h" #include "uuid.h" #include "buf.h" @@ -55,7 +49,15 @@ #include "memory.h" #include "verify.h" #include "c-ctype.h" -#include "xml.h" + +VIR_ENUM_DECL(virDomainDiskQEMUBus) +VIR_ENUM_IMPL(virDomainDiskQEMUBus, VIR_DOMAIN_DISK_BUS_LAST, + "ide", + "floppy", + "scsi", + "virtio", + "xen") + #define qemudLog(level, msg...) fprintf(stderr, msg) @@ -64,12 +66,12 @@ virNetworkPtr net, int code, const char *fmt, ...) { va_list args; - char errorMessage[QEMUD_MAX_ERROR_LEN]; + char errorMessage[1024]; const char *virerr; if (fmt) { va_start(args, fmt); - vsnprintf(errorMessage, QEMUD_MAX_ERROR_LEN-1, fmt, args); + vsnprintf(errorMessage, sizeof(errorMessage)-1, fmt, args); va_end(args); } else { errorMessage[0] = '\0'; @@ -86,7 +88,11 @@ virConfValuePtr p; /* Setup 2 critical defaults */ - strcpy(driver->vncListen, "127.0.0.1"); + if (!(driver->vncListen = strdup("127.0.0.1"))) { + qemudReportError(NULL, NULL, NULL, VIR_ERR_NO_MEMORY, + "%s", _("failed to allocate vncListen")); + return -1; + } if (!(driver->vncTLSx509certdir = strdup(SYSCONF_DIR "/pki/libvirt-vnc"))) { qemudReportError(NULL, NULL, NULL, VIR_ERR_NO_MEMORY, "%s", _("failed to allocate vncTLSx509certdir")); @@ -133,104 +139,17 @@ p = virConfGetValue (conf, "vnc_listen"); CHECK_TYPE ("vnc_listen", VIR_CONF_STRING); if (p && p->str) { - strncpy(driver->vncListen, p->str, sizeof(driver->vncListen)); - driver->vncListen[sizeof(driver->vncListen)-1] = '\0'; + if (!(driver->vncListen = strdup(p->str))) { + qemudReportError(NULL, NULL, NULL, VIR_ERR_NO_MEMORY, + "%s", _("failed to allocate vncTLSx509certdir")); + virConfFree(conf); + return -1; + } } virConfFree (conf); return 0; } - - -struct qemud_vm *qemudFindVMByID(const struct qemud_driver *driver, int id) { - struct qemud_vm *vm = driver->vms; - - while (vm) { - if (qemudIsActiveVM(vm) && vm->id == id) - return vm; - vm = vm->next; - } - - return NULL; -} - -struct qemud_vm *qemudFindVMByUUID(const struct qemud_driver *driver, - const unsigned char *uuid) { - struct qemud_vm *vm = driver->vms; - - while (vm) { - if (!memcmp(vm->def->uuid, uuid, VIR_UUID_BUFLEN)) - return vm; - vm = vm->next; - } - - return NULL; -} - -struct qemud_vm *qemudFindVMByName(const struct qemud_driver *driver, - const char *name) { - struct qemud_vm *vm = driver->vms; - - while (vm) { - if (STREQ(vm->def->name, name)) - return vm; - vm = vm->next; - } - - return NULL; -} - - -/* Free all memory associated with a struct qemud_vm object */ -void qemudFreeVMDef(struct qemud_vm_def *def) { - struct qemud_vm_disk_def *disk = def->disks; - struct qemud_vm_net_def *net = def->nets; - struct qemud_vm_input_def *input = def->inputs; - struct qemud_vm_chr_def *serial = def->serials; - struct qemud_vm_chr_def *parallel = def->parallels; - struct qemud_vm_sound_def *sound = def->sounds; - - while (disk) { - struct qemud_vm_disk_def *prev = disk; - disk = disk->next; - VIR_FREE(prev); - } - while (net) { - struct qemud_vm_net_def *prev = net; - net = net->next; - VIR_FREE(prev); - } - while (input) { - struct qemud_vm_input_def *prev = input; - input = input->next; - VIR_FREE(prev); - } - while (serial) { - struct qemud_vm_chr_def *prev = serial; - serial = serial->next; - VIR_FREE(prev); - } - while (parallel) { - struct qemud_vm_chr_def *prev = parallel; - parallel = parallel->next; - VIR_FREE(prev); - } - while (sound) { - struct qemud_vm_sound_def *prev = sound; - sound = sound->next; - VIR_FREE(prev); - } - xmlFree(def->keymap); - VIR_FREE(def); -} - -void qemudFreeVM(struct qemud_vm *vm) { - qemudFreeVMDef(vm->def); - if (vm->newDef) - qemudFreeVMDef(vm->newDef); - VIR_FREE(vm); -} - /* The list of possible machine types for various architectures, as supported by QEMU - taken from 'qemu -M ?' for each arch */ @@ -477,12 +396,14 @@ } -static int qemudExtractVersionInfo(const char *qemu, int *version, int *flags) { +int qemudExtractVersionInfo(const char *qemu, int *version, int *flags) { pid_t child; int newstdout[2]; - *flags = 0; - *version = 0; + if (flags) + *flags = 0; + if (version) + *version = 0; if (pipe(newstdout) < 0) { return -1; @@ -538,19 +459,22 @@ goto cleanup2; } - *version = (major * 1000 * 1000) + (minor * 1000) + micro; - if (strstr(help, "-no-kqemu")) - *flags |= QEMUD_CMD_FLAG_KQEMU; - if (strstr(help, "-no-reboot")) - *flags |= QEMUD_CMD_FLAG_NO_REBOOT; - if (strstr(help, "-name")) - *flags |= QEMUD_CMD_FLAG_NAME; - if (strstr(help, "-drive")) - *flags |= QEMUD_CMD_FLAG_DRIVE; - if (strstr(help, "boot=on")) - *flags |= QEMUD_CMD_FLAG_DRIVE_BOOT; - if (*version >= 9000) - *flags |= QEMUD_CMD_FLAG_VNC_COLON; + if (version) + *version = (major * 1000 * 1000) + (minor * 1000) + micro; + if (flags) { + if (strstr(help, "-no-kqemu")) + *flags |= QEMUD_CMD_FLAG_KQEMU; + if (strstr(help, "-no-reboot")) + *flags |= QEMUD_CMD_FLAG_NO_REBOOT; + if (strstr(help, "-name")) + *flags |= QEMUD_CMD_FLAG_NAME; + if (strstr(help, "-drive")) + *flags |= QEMUD_CMD_FLAG_DRIVE; + if (strstr(help, "boot=on")) + *flags |= QEMUD_CMD_FLAG_DRIVE_BOOT; + if (*version >= 9000) + *flags |= QEMUD_CMD_FLAG_VNC_COLON; + } ret = 0; qemudDebug("Version %d %d %d Cooked version: %d, with flags ? %d", @@ -612,1620 +536,13 @@ return 0; } -/* Converts def->virtType to applicable string type - * @param type integer virt type - * @return string type on success, NULL on fail - */ -const char * qemudVirtTypeToString(int type) { - switch (type) { - case QEMUD_VIRT_QEMU: - return "qemu"; - case QEMUD_VIRT_KQEMU: - return "kqemu"; - case QEMUD_VIRT_KVM: - return "kvm"; - } - return NULL; -} - -/* Parse the XML definition for a disk - * @param disk pre-allocated & zero'd disk record - * @param node XML nodeset to parse for disk definition - * @return 0 on success, -1 on failure - */ -static int qemudParseDiskXML(virConnectPtr conn, - struct qemud_vm_disk_def *disk, - xmlNodePtr node) { - xmlNodePtr cur; - xmlChar *device = NULL; - xmlChar *source = NULL; - xmlChar *target = NULL; - xmlChar *type = NULL; - xmlChar *bus = NULL; - int typ = 0; - - type = xmlGetProp(node, BAD_CAST "type"); - if (type != NULL) { - if (xmlStrEqual(type, BAD_CAST "file")) - typ = QEMUD_DISK_FILE; - else if (xmlStrEqual(type, BAD_CAST "block")) - typ = QEMUD_DISK_BLOCK; - else { - typ = QEMUD_DISK_FILE; - } - xmlFree(type); - type = NULL; - } - - device = xmlGetProp(node, BAD_CAST "device"); - - cur = node->children; - while (cur != NULL) { - if (cur->type == XML_ELEMENT_NODE) { - if ((source == NULL) && - (xmlStrEqual(cur->name, BAD_CAST "source"))) { - - if (typ == QEMUD_DISK_FILE) - source = xmlGetProp(cur, BAD_CAST "file"); - else - source = xmlGetProp(cur, BAD_CAST "dev"); - } else if ((target == NULL) && - (xmlStrEqual(cur->name, BAD_CAST "target"))) { - target = xmlGetProp(cur, BAD_CAST "dev"); - bus = xmlGetProp(cur, BAD_CAST "bus"); - } else if (xmlStrEqual(cur->name, BAD_CAST "readonly")) { - disk->readonly = 1; - } - } - cur = cur->next; - } - - if (source == NULL) { - /* There is a case without the source - * to the CD-ROM device - */ - if (!device || STRNEQ((const char *) device, "cdrom")) { - qemudReportError(conn, NULL, NULL, VIR_ERR_NO_SOURCE, - target ? "%s" : NULL, target); - goto error; - } - } - - if (target == NULL) { - qemudReportError(conn, NULL, NULL, VIR_ERR_NO_TARGET, source ? "%s" : NULL, source); - goto error; - } - - if (device && - STREQ((const char *)device, "floppy") && - STRNEQ((const char *)target, "fda") && - STRNEQ((const char *)target, "fdb")) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("Invalid floppy device name: %s"), target); - goto error; - } - - if (device && - STREQ((const char *)device, "cdrom") && - STRNEQ((const char *)target, "hdc")) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("Invalid cdrom device name: %s"), target); - goto error; - } - - if (device && - STREQ((const char *)device, "cdrom")) - disk->readonly = 1; - - if ((!device || STREQ((const char *)device, "disk")) && - !STRPREFIX((const char *)target, "hd") && - !STRPREFIX((const char *)target, "sd") && - !STRPREFIX((const char *)target, "vd") && - !STRPREFIX((const char *)target, "xvd")) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("Invalid harddisk device name: %s"), target); - goto error; - } - - strncpy(disk->src, (source ? (const char *) source : "\0"), NAME_MAX-1); - disk->src[NAME_MAX-1] = '\0'; - - strncpy(disk->dst, (const char *)target, NAME_MAX-1); - disk->dst[NAME_MAX-1] = '\0'; - disk->type = typ; - - if (!device) - disk->device = QEMUD_DISK_DISK; - else if (STREQ((const char *)device, "disk")) - disk->device = QEMUD_DISK_DISK; - else if (STREQ((const char *)device, "cdrom")) - disk->device = QEMUD_DISK_CDROM; - else if (STREQ((const char *)device, "floppy")) - disk->device = QEMUD_DISK_FLOPPY; - else { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("Invalid device type: %s"), device); - goto error; - } - - if (!bus) { - if (disk->device == QEMUD_DISK_FLOPPY) { - disk->bus = QEMUD_DISK_BUS_FDC; - } else { - if (STRPREFIX((const char *)target, "hd")) - disk->bus = QEMUD_DISK_BUS_IDE; - else if (STRPREFIX((const char *)target, "sd")) - disk->bus = QEMUD_DISK_BUS_SCSI; - else if (STRPREFIX((const char *)target, "vd")) - disk->bus = QEMUD_DISK_BUS_VIRTIO; - else if (STRPREFIX((const char *)target, "xvd")) - disk->bus = QEMUD_DISK_BUS_XEN; - else - disk->bus = QEMUD_DISK_BUS_IDE; - } - } else if (STREQ((const char *)bus, "ide")) - disk->bus = QEMUD_DISK_BUS_IDE; - else if (STREQ((const char *)bus, "fdc")) - disk->bus = QEMUD_DISK_BUS_FDC; - else if (STREQ((const char *)bus, "scsi")) - disk->bus = QEMUD_DISK_BUS_SCSI; - else if (STREQ((const char *)bus, "virtio")) - disk->bus = QEMUD_DISK_BUS_VIRTIO; - else if (STREQ((const char *)bus, "xen")) - disk->bus = QEMUD_DISK_BUS_XEN; - else { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("Invalid bus type: %s"), bus); - goto error; - } - - if (disk->device == QEMUD_DISK_FLOPPY && - disk->bus != QEMUD_DISK_BUS_FDC) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("Invalid bus type '%s' for floppy disk"), bus); - goto error; - } - - xmlFree(device); - xmlFree(target); - xmlFree(source); - xmlFree(bus); - - return 0; - - error: - xmlFree(bus); - xmlFree(type); - xmlFree(target); - xmlFree(source); - xmlFree(device); - return -1; -} - -static void qemudRandomMAC(struct qemud_vm_net_def *net) { - net->mac[0] = 0x52; - net->mac[1] = 0x54; - net->mac[2] = 0x00; - net->mac[3] = 1 + (int)(256*(rand()/(RAND_MAX+1.0))); - net->mac[4] = 1 + (int)(256*(rand()/(RAND_MAX+1.0))); - net->mac[5] = 1 + (int)(256*(rand()/(RAND_MAX+1.0))); -} - - -/* Parse the XML definition for a network interface - * @param net pre-allocated & zero'd net record - * @param node XML nodeset to parse for net definition - * @return 0 on success, -1 on failure - */ -static int qemudParseInterfaceXML(virConnectPtr conn, - struct qemud_vm_net_def *net, - xmlNodePtr node) { - xmlNodePtr cur; - xmlChar *macaddr = NULL; - xmlChar *type = NULL; - xmlChar *network = NULL; - xmlChar *bridge = NULL; - xmlChar *ifname = NULL; - xmlChar *script = NULL; - xmlChar *address = NULL; - xmlChar *port = NULL; - xmlChar *model = NULL; - - net->type = QEMUD_NET_USER; - - type = xmlGetProp(node, BAD_CAST "type"); - if (type != NULL) { - if (xmlStrEqual(type, BAD_CAST "user")) - net->type = QEMUD_NET_USER; - else if (xmlStrEqual(type, BAD_CAST "ethernet")) - net->type = QEMUD_NET_ETHERNET; - else if (xmlStrEqual(type, BAD_CAST "server")) - net->type = QEMUD_NET_SERVER; - else if (xmlStrEqual(type, BAD_CAST "client")) - net->type = QEMUD_NET_CLIENT; - else if (xmlStrEqual(type, BAD_CAST "mcast")) - net->type = QEMUD_NET_MCAST; - else if (xmlStrEqual(type, BAD_CAST "network")) - net->type = QEMUD_NET_NETWORK; - else if (xmlStrEqual(type, BAD_CAST "bridge")) - net->type = QEMUD_NET_BRIDGE; - else - net->type = QEMUD_NET_USER; - xmlFree(type); - type = NULL; - } - - cur = node->children; - while (cur != NULL) { - if (cur->type == XML_ELEMENT_NODE) { - if ((macaddr == NULL) && - (xmlStrEqual(cur->name, BAD_CAST "mac"))) { - macaddr = xmlGetProp(cur, BAD_CAST "address"); - } else if ((network == NULL) && - (net->type == QEMUD_NET_NETWORK) && - (xmlStrEqual(cur->name, BAD_CAST "source"))) { - network = xmlGetProp(cur, BAD_CAST "network"); - } else if ((network == NULL) && - (net->type == QEMUD_NET_BRIDGE) && - (xmlStrEqual(cur->name, BAD_CAST "source"))) { - bridge = xmlGetProp(cur, BAD_CAST "bridge"); - } else if ((network == NULL) && - ((net->type == QEMUD_NET_SERVER) || - (net->type == QEMUD_NET_CLIENT) || - (net->type == QEMUD_NET_MCAST)) && - (xmlStrEqual(cur->name, BAD_CAST "source"))) { - address = xmlGetProp(cur, BAD_CAST "address"); - port = xmlGetProp(cur, BAD_CAST "port"); - } else if ((ifname == NULL) && - ((net->type == QEMUD_NET_NETWORK) || - (net->type == QEMUD_NET_ETHERNET) || - (net->type == QEMUD_NET_BRIDGE)) && - xmlStrEqual(cur->name, BAD_CAST "target")) { - ifname = xmlGetProp(cur, BAD_CAST "dev"); - if (STRPREFIX((const char*)ifname, "vnet")) { - /* An auto-generated target name, blank it out */ - xmlFree(ifname); - ifname = NULL; - } - } else if ((script == NULL) && - (net->type == QEMUD_NET_ETHERNET) && - xmlStrEqual(cur->name, BAD_CAST "script")) { - script = xmlGetProp(cur, BAD_CAST "path"); - } else if (xmlStrEqual (cur->name, BAD_CAST "model")) { - model = xmlGetProp (cur, BAD_CAST "type"); - } - } - cur = cur->next; - } - - if (macaddr) { - unsigned int mac[6]; - sscanf((const char *)macaddr, "%02x:%02x:%02x:%02x:%02x:%02x", - (unsigned int*)&mac[0], - (unsigned int*)&mac[1], - (unsigned int*)&mac[2], - (unsigned int*)&mac[3], - (unsigned int*)&mac[4], - (unsigned int*)&mac[5]); - net->mac[0] = mac[0]; - net->mac[1] = mac[1]; - net->mac[2] = mac[2]; - net->mac[3] = mac[3]; - net->mac[4] = mac[4]; - net->mac[5] = mac[5]; - - xmlFree(macaddr); - macaddr = NULL; - } else { - qemudRandomMAC(net); - } - - if (net->type == QEMUD_NET_NETWORK) { - int len; - - if (network == NULL) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("No <source> 'network' attribute specified with <interface type='network'/>")); - goto error; - } else if ((len = xmlStrlen(network)) >= (QEMUD_MAX_NAME_LEN-1)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("Network name '%s' too long"), network); - goto error; - } else { - strncpy(net->dst.network.name, (char *)network, len); - net->dst.network.name[len] = '\0'; - } - - if (network) { - xmlFree(network); - network = NULL; - } - - if (ifname != NULL) { - if ((len = xmlStrlen(ifname)) >= (BR_IFNAME_MAXLEN-1)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("TAP interface name '%s' is too long"), - ifname); - goto error; - } else { - strncpy(net->dst.network.ifname, (char *)ifname, len); - net->dst.network.ifname[len] = '\0'; - } - xmlFree(ifname); - ifname = NULL; - } - } else if (net->type == QEMUD_NET_ETHERNET) { - int len; - - if (script != NULL) { - if ((len = xmlStrlen(script)) >= (PATH_MAX-1)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("TAP script path '%s' is too long"), script); - goto error; - } else { - strncpy(net->dst.ethernet.script, (char *)script, len); - net->dst.ethernet.script[len] = '\0'; - } - xmlFree(script); - script = NULL; - } - if (ifname != NULL) { - if ((len = xmlStrlen(ifname)) >= (BR_IFNAME_MAXLEN-1)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("TAP interface name '%s' is too long"), - ifname); - goto error; - } else { - strncpy(net->dst.ethernet.ifname, (char *)ifname, len); - net->dst.ethernet.ifname[len] = '\0'; - } - xmlFree(ifname); - } - } else if (net->type == QEMUD_NET_BRIDGE) { - int len; - - if (bridge == NULL) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("No <source> 'dev' attribute specified with <interface type='bridge'/>")); - goto error; - } else if ((len = xmlStrlen(bridge)) >= (BR_IFNAME_MAXLEN-1)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("TAP bridge path '%s' is too long"), bridge); - goto error; - } else { - strncpy(net->dst.bridge.brname, (char *)bridge, len); - net->dst.bridge.brname[len] = '\0'; - } - - xmlFree(bridge); - bridge = NULL; - - if (ifname != NULL) { - if ((len = xmlStrlen(ifname)) >= (BR_IFNAME_MAXLEN-1)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("TAP interface name '%s' is too long"), ifname); - goto error; - } else { - strncpy(net->dst.bridge.ifname, (char *)ifname, len); - net->dst.bridge.ifname[len] = '\0'; - } - xmlFree(ifname); - } - } else if (net->type == QEMUD_NET_CLIENT || - net->type == QEMUD_NET_SERVER || - net->type == QEMUD_NET_MCAST) { - int len = 0; - char *ret; - - if (port == NULL) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("No <source> 'port' attribute specified with socket interface")); - goto error; - } - if (!(net->dst.socket.port = strtol((char*)port, &ret, 10)) && - ret == (char*)port) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("Cannot parse <source> 'port' attribute with socket interface")); - goto error; - } - xmlFree(port); - port = NULL; - - if (address == NULL) { - if (net->type == QEMUD_NET_CLIENT || - net->type == QEMUD_NET_MCAST) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("No <source> 'address' attribute specified with socket interface")); - goto error; - } - } else if ((len = xmlStrlen(address)) >= (BR_INET_ADDR_MAXLEN)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("IP address '%s' is too long"), address); - goto error; - } - if (address == NULL) { - net->dst.socket.address[0] = '\0'; - } else { - strncpy(net->dst.socket.address, (char*)address,len); - net->dst.socket.address[len] = '\0'; - } - xmlFree(address); - } - - /* NIC model (see -net nic,model=?). We only check that it looks - * reasonable, not that it is a supported NIC type. FWIW kvm - * supports these types as of April 2008: - * i82551 i82557b i82559er ne2k_pci pcnet rtl8139 e1000 virtio - */ - if (model != NULL) { - int i, len; - - len = xmlStrlen (model); - if (len >= QEMUD_MODEL_MAX_LEN) { - qemudReportError (conn, NULL, NULL, VIR_ERR_INVALID_ARG, - _("Model name '%s' is too long"), model); - goto error; - } - for (i = 0; i < len; ++i) { - int char_ok = c_isalnum(model[i]) || model[i] == '_'; - if (!char_ok) { - qemudReportError (conn, NULL, NULL, VIR_ERR_INVALID_ARG, "%s", - _("Model name contains invalid characters")); - goto error; - } - } - strncpy (net->model, (const char*) model, len); - net->model[len] = '\0'; - - xmlFree (model); - model = NULL; - } else - net->model[0] = '\0'; - - return 0; - - error: - xmlFree(network); - xmlFree(address); - xmlFree(port); - xmlFree(ifname); - xmlFree(script); - xmlFree(bridge); - xmlFree(model); - return -1; -} - - -/* Parse the XML definition for a character device - * @param net pre-allocated & zero'd net record - * @param node XML nodeset to parse for net definition - * @return 0 on success, -1 on failure - * - * The XML we're dealing with looks like - * - * <serial type="pty"> - * <source path="/dev/pts/3"/> - * <target port="1"/> - * </serial> - * - * <serial type="dev"> - * <source path="/dev/ttyS0"/> - * <target port="1"/> - * </serial> - * - * <serial type="tcp"> - * <source mode="connect" host="0.0.0.0" service="2445"/> - * <target port="1"/> - * </serial> - * - * <serial type="tcp"> - * <source mode="bind" host="0.0.0.0" service="2445"/> - * <target port="1"/> - * </serial> - * - * <serial type="udp"> - * <source mode="bind" host="0.0.0.0" service="2445"/> - * <source mode="connect" host="0.0.0.0" service="2445"/> - * <target port="1"/> - * </serial> - * - * <serial type="unix"> - * <source mode="bind" path="/tmp/foo"/> - * <target port="1"/> - * </serial> - * - */ -static int qemudParseCharXML(virConnectPtr conn, - struct qemud_vm_chr_def *chr, - int portNum, - xmlNodePtr node) { - xmlNodePtr cur; - xmlChar *type = NULL; - xmlChar *bindHost = NULL; - xmlChar *bindService = NULL; - xmlChar *connectHost = NULL; - xmlChar *connectService = NULL; - xmlChar *path = NULL; - xmlChar *mode = NULL; - xmlChar *protocol = NULL; - int ret = -1; - - chr->srcType = QEMUD_CHR_SRC_TYPE_PTY; - type = xmlGetProp(node, BAD_CAST "type"); - if (type != NULL) { - if (xmlStrEqual(type, BAD_CAST "null")) - chr->srcType = QEMUD_CHR_SRC_TYPE_NULL; - else if (xmlStrEqual(type, BAD_CAST "vc")) - chr->srcType = QEMUD_CHR_SRC_TYPE_VC; - else if (xmlStrEqual(type, BAD_CAST "pty")) - chr->srcType = QEMUD_CHR_SRC_TYPE_PTY; - else if (xmlStrEqual(type, BAD_CAST "dev")) - chr->srcType = QEMUD_CHR_SRC_TYPE_DEV; - else if (xmlStrEqual(type, BAD_CAST "file")) - chr->srcType = QEMUD_CHR_SRC_TYPE_FILE; - else if (xmlStrEqual(type, BAD_CAST "pipe")) - chr->srcType = QEMUD_CHR_SRC_TYPE_PIPE; - else if (xmlStrEqual(type, BAD_CAST "stdio")) - chr->srcType = QEMUD_CHR_SRC_TYPE_STDIO; - else if (xmlStrEqual(type, BAD_CAST "udp")) - chr->srcType = QEMUD_CHR_SRC_TYPE_UDP; - else if (xmlStrEqual(type, BAD_CAST "tcp")) - chr->srcType = QEMUD_CHR_SRC_TYPE_TCP; - else if (xmlStrEqual(type, BAD_CAST "unix")) - chr->srcType = QEMUD_CHR_SRC_TYPE_UNIX; - else - chr->srcType = QEMUD_CHR_SRC_TYPE_NULL; - } - - cur = node->children; - while (cur != NULL) { - if (cur->type == XML_ELEMENT_NODE) { - if (xmlStrEqual(cur->name, BAD_CAST "source")) { - if (mode == NULL) - mode = xmlGetProp(cur, BAD_CAST "mode"); - - switch (chr->srcType) { - case QEMUD_CHR_SRC_TYPE_PTY: - case QEMUD_CHR_SRC_TYPE_DEV: - case QEMUD_CHR_SRC_TYPE_FILE: - case QEMUD_CHR_SRC_TYPE_PIPE: - case QEMUD_CHR_SRC_TYPE_UNIX: - if (path == NULL) - path = xmlGetProp(cur, BAD_CAST "path"); - - break; - - case QEMUD_CHR_SRC_TYPE_UDP: - case QEMUD_CHR_SRC_TYPE_TCP: - if (mode == NULL || - STREQ((const char *)mode, "connect")) { - - if (connectHost == NULL) - connectHost = xmlGetProp(cur, BAD_CAST "host"); - if (connectService == NULL) - connectService = xmlGetProp(cur, BAD_CAST "service"); - } else { - if (bindHost == NULL) - bindHost = xmlGetProp(cur, BAD_CAST "host"); - if (bindService == NULL) - bindService = xmlGetProp(cur, BAD_CAST "service"); - } - - if (chr->srcType == QEMUD_CHR_SRC_TYPE_UDP) { - xmlFree(mode); - mode = NULL; - } - } - } else if (xmlStrEqual(cur->name, BAD_CAST "protocol")) { - if (protocol == NULL) - protocol = xmlGetProp(cur, BAD_CAST "type"); - } - } - cur = cur->next; - } - - - chr->dstPort = portNum; - - switch (chr->srcType) { - case QEMUD_CHR_SRC_TYPE_NULL: - /* Nada */ - break; - - case QEMUD_CHR_SRC_TYPE_VC: - break; - - case QEMUD_CHR_SRC_TYPE_PTY: - /* @path attribute is an output only property - pty is auto-allocted */ - break; - - case QEMUD_CHR_SRC_TYPE_DEV: - case QEMUD_CHR_SRC_TYPE_FILE: - case QEMUD_CHR_SRC_TYPE_PIPE: - if (path == NULL) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("Missing source path attribute for char device")); - goto cleanup; - } - - strncpy(chr->srcData.file.path, (const char *)path, - sizeof(chr->srcData.file.path)); - NUL_TERMINATE(chr->srcData.file.path); - break; - - case QEMUD_CHR_SRC_TYPE_STDIO: - /* Nada */ - break; - - case QEMUD_CHR_SRC_TYPE_TCP: - if (mode == NULL || - STREQ((const char *)mode, "connect")) { - if (connectHost == NULL) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("Missing source host attribute for char device")); - goto cleanup; - } - if (connectService == NULL) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("Missing source service attribute for char device")); - goto cleanup; - } - - strncpy(chr->srcData.tcp.host, (const char *)connectHost, - sizeof(chr->srcData.tcp.host)); - NUL_TERMINATE(chr->srcData.tcp.host); - strncpy(chr->srcData.tcp.service, (const char *)connectService, - sizeof(chr->srcData.tcp.service)); - NUL_TERMINATE(chr->srcData.tcp.service); - - chr->srcData.tcp.listen = 0; - } else { - if (bindHost == NULL) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("Missing source host attribute for char device")); - goto cleanup; - } - if (bindService == NULL) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("Missing source service attribute for char device")); - goto cleanup; - } - - strncpy(chr->srcData.tcp.host, (const char *)bindHost, - sizeof(chr->srcData.tcp.host)); - NUL_TERMINATE(chr->srcData.tcp.host); - strncpy(chr->srcData.tcp.service, (const char *)bindService, - sizeof(chr->srcData.tcp.service)); - NUL_TERMINATE(chr->srcData.tcp.service); - - chr->srcData.tcp.listen = 1; - } - if (protocol != NULL && - STREQ((const char *)protocol, "telnet")) - chr->srcData.tcp.protocol = QEMUD_CHR_SRC_TCP_PROTOCOL_TELNET; - else - chr->srcData.tcp.protocol = QEMUD_CHR_SRC_TCP_PROTOCOL_RAW; - break; - - case QEMUD_CHR_SRC_TYPE_UDP: - if (connectService == NULL) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("Missing source service attribute for char device")); - goto cleanup; - } - - if (connectHost != NULL) { - strncpy(chr->srcData.udp.connectHost, (const char *)connectHost, - sizeof(chr->srcData.udp.connectHost)); - NUL_TERMINATE(chr->srcData.udp.connectHost); - } - strncpy(chr->srcData.udp.connectService, (const char *)connectService, - sizeof(chr->srcData.udp.connectService)); - NUL_TERMINATE(chr->srcData.udp.connectService); - - if (bindHost != NULL) { - strncpy(chr->srcData.udp.bindHost, (const char *)bindHost, - sizeof(chr->srcData.udp.bindHost)); - NUL_TERMINATE(chr->srcData.udp.bindHost); - } - if (bindService != NULL) { - strncpy(chr->srcData.udp.bindService, (const char *)bindService, - sizeof(chr->srcData.udp.bindService)); - NUL_TERMINATE(chr->srcData.udp.bindService); - } - break; - - case QEMUD_CHR_SRC_TYPE_UNIX: - if (path == NULL) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("Missing source path attribute for char device")); - goto cleanup; - } - - if (mode != NULL && - STRNEQ((const char *)mode, "connect")) - chr->srcData.nix.listen = 1; - else - chr->srcData.nix.listen = 0; - - strncpy(chr->srcData.nix.path, (const char *)path, - sizeof(chr->srcData.nix.path)); - NUL_TERMINATE(chr->srcData.nix.path); - break; - } - - ret = 0; - -cleanup: - xmlFree(mode); - xmlFree(protocol); - xmlFree(type); - xmlFree(bindHost); - xmlFree(bindService); - xmlFree(connectHost); - xmlFree(connectService); - xmlFree(path); - - return ret; -} - - -static int qemudParseCharXMLDevices(virConnectPtr conn, - xmlXPathContextPtr ctxt, - const char *xpath, - unsigned int *ndevs, - struct qemud_vm_chr_def **devs) -{ - xmlXPathObjectPtr obj; - int i, ret = -1; - - obj = xmlXPathEval(BAD_CAST xpath, ctxt); - if ((obj != NULL) && (obj->type == XPATH_NODESET) && - (obj->nodesetval != NULL) && (obj->nodesetval->nodeNr >= 0)) { - struct qemud_vm_chr_def *prev = *devs; - if (ndevs == NULL && - obj->nodesetval->nodeNr > 1) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("too many character devices")); - goto cleanup; - } - - for (i = 0; i < obj->nodesetval->nodeNr; i++) { - struct qemud_vm_chr_def *chr; - if (VIR_ALLOC(chr) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, - "%s", - _("failed to allocate space for char device")); - goto cleanup; - } - - if (qemudParseCharXML(conn, chr, i, obj->nodesetval->nodeTab[i]) < 0) { - VIR_FREE(chr); - goto cleanup; - } - if (ndevs) - (*ndevs)++; - chr->next = NULL; - if (i == 0) { - *devs = chr; - } else { - prev->next = chr; - } - prev = chr; - } - } - - ret = 0; - -cleanup: - xmlXPathFreeObject(obj); - return ret; -} - - -/* Parse the XML definition for a network interface */ -static int qemudParseInputXML(virConnectPtr conn, - const struct qemud_vm_def *vm, - struct qemud_vm_input_def *input, - xmlNodePtr node) { - xmlChar *type = NULL; - xmlChar *bus = NULL; - - type = xmlGetProp(node, BAD_CAST "type"); - bus = xmlGetProp(node, BAD_CAST "bus"); - - if (!type) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("missing input device type")); - goto error; - } - - if (STREQ((const char *)type, "mouse")) { - input->type = QEMU_INPUT_TYPE_MOUSE; - } else if (STREQ((const char *)type, "tablet")) { - input->type = QEMU_INPUT_TYPE_TABLET; - } else { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("unsupported input device type %s"), - (const char*)type); - goto error; - } - - if (bus) { - if (STREQ(vm->os.type, "hvm")) { - if (STREQ((const char*)bus, "ps2")) { /* Only allow mouse */ - if (input->type != QEMU_INPUT_TYPE_MOUSE) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("ps2 bus does not support %s input device"), - (const char*)type); - goto error; - } - input->bus = QEMU_INPUT_BUS_PS2; - } else if (STREQ((const char *)bus, "usb")) { /* Allow mouse & tablet */ - input->bus = QEMU_INPUT_BUS_USB; - } else { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("unsupported input bus %s"), (const char*)bus); - goto error; - } - } else { - if (STREQ((const char *)bus, "xen")) { /* Allow mouse only */ - input->bus = QEMU_INPUT_BUS_XEN; - if (input->type != QEMU_INPUT_TYPE_MOUSE) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("xen bus does not support %s input device"), - (const char*)type); - goto error; - } - } else { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("unsupported input bus %s"), (const char*)bus); - goto error; - } - } - } else { - if (STREQ(vm->os.type, "hvm")) { - if (input->type == QEMU_INPUT_TYPE_MOUSE) - input->bus = QEMU_INPUT_BUS_PS2; - else - input->bus = QEMU_INPUT_BUS_USB; - } else { - input->bus = QEMU_INPUT_BUS_XEN; - } - } - - xmlFree(type); - xmlFree(bus); - - return 0; - - error: - xmlFree(type); - xmlFree(bus); - - return -1; -} - -static int qemudDiskCompare(const void *aptr, const void *bptr) { - struct qemud_vm_disk_def *a = (struct qemud_vm_disk_def *) aptr; - struct qemud_vm_disk_def *b = (struct qemud_vm_disk_def *) bptr; - if (a->bus == b->bus) - return virDiskNameToIndex(a->dst) - virDiskNameToIndex(b->dst); - else - return a->bus - b->bus; -} - -static const char *qemudBusIdToName(int busId, int qemuIF) { - const char *busnames[] = { "ide", - (qemuIF ? "floppy" : "fdc"), - "scsi", - "virtio", - "xen"}; - verify_true(ARRAY_CARDINALITY(busnames) == QEMUD_DISK_BUS_LAST); - - return busnames[busId]; -} - -/* Sound device helper functions */ -static int qemudSoundModelFromString(const char *model) { - if (STREQ(model, "sb16")) { - return QEMU_SOUND_SB16; - } else if (STREQ(model, "es1370")) { - return QEMU_SOUND_ES1370; - } else if (STREQ(model, "pcspk")) { - return QEMU_SOUND_PCSPK; - } - - return -1; -} - -static const char *qemudSoundModelToString(const int model) { - - if (model == QEMU_SOUND_SB16) { - return "sb16"; - } else if (model == QEMU_SOUND_ES1370) { - return "es1370"; - } else if (model == QEMU_SOUND_PCSPK) { - return "pcspk"; - } - - return NULL; -} - - -static int qemudParseSoundXML(virConnectPtr conn, - struct qemud_vm_sound_def *sound, - const xmlNodePtr node) { - - int err = -1; - xmlChar *model = NULL; - model = xmlGetProp(node, BAD_CAST "model"); - - if (!model) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("missing sound model")); - goto error; - } - if ((sound->model = qemudSoundModelFromString((char *) model)) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("invalid sound model '%s'"), (char *) model); - goto error; - } - - err = 0; - error: - xmlFree(model); - return err; -} - -/* - * Parses a libvirt XML definition of a guest, and populates the - * the qemud_vm struct with matching data about the guests config - */ -static struct qemud_vm_def *qemudParseXML(virConnectPtr conn, - struct qemud_driver *driver, - xmlDocPtr xml) { - xmlNodePtr root = NULL; - xmlChar *prop = NULL; - xmlXPathContextPtr ctxt = NULL; - xmlXPathObjectPtr obj = NULL; - char *conv = NULL; - int i; - struct qemud_vm_def *def; - - if (VIR_ALLOC(def) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, - "%s", _("failed to allocate space for xmlXPathContext")); - return NULL; - } - - /* Prepare parser / xpath context */ - root = xmlDocGetRootElement(xml); - if ((root == NULL) || (!xmlStrEqual(root->name, BAD_CAST "domain"))) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("incorrect root element")); - goto error; - } - - ctxt = xmlXPathNewContext(xml); - if (ctxt == NULL) { - qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, - "%s", _("failed to allocate space for xmlXPathContext")); - goto error; - } - - - /* Find out what type of QEMU virtualization to use */ - if (!(prop = xmlGetProp(root, BAD_CAST "type"))) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("missing domain type attribute")); - goto error; - } - - if (STREQ((char *)prop, "qemu")) - def->virtType = QEMUD_VIRT_QEMU; - else if (STREQ((char *)prop, "kqemu")) - def->virtType = QEMUD_VIRT_KQEMU; - else if (STREQ((char *)prop, "kvm")) - def->virtType = QEMUD_VIRT_KVM; - else { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("invalid domain type attribute")); - goto error; - } - VIR_FREE(prop); - - - /* Extract domain name */ - obj = xmlXPathEval(BAD_CAST "string(/domain/name[1])", ctxt); - if ((obj == NULL) || (obj->type != XPATH_STRING) || - (obj->stringval == NULL) || (obj->stringval[0] == 0)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_NO_NAME, NULL); - goto error; - } - if (strlen((const char *)obj->stringval) >= (QEMUD_MAX_NAME_LEN-1)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("domain name length too long")); - goto error; - } - strcpy(def->name, (const char *)obj->stringval); - xmlXPathFreeObject(obj); - - - /* Extract domain uuid */ - obj = xmlXPathEval(BAD_CAST "string(/domain/uuid[1])", ctxt); - if ((obj == NULL) || (obj->type != XPATH_STRING) || - (obj->stringval == NULL) || (obj->stringval[0] == 0)) { - int err; - if ((err = virUUIDGenerate(def->uuid))) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("Failed to generate UUID: %s"), strerror(err)); - goto error; - } - } else if (virUUIDParse((const char *)obj->stringval, def->uuid) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("malformed uuid element")); - goto error; - } - xmlXPathFreeObject(obj); - - - /* Extract domain memory */ - obj = xmlXPathEval(BAD_CAST "string(/domain/memory[1])", ctxt); - if ((obj == NULL) || (obj->type != XPATH_STRING) || - (obj->stringval == NULL) || (obj->stringval[0] == 0)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("missing memory element")); - goto error; - } else { - conv = NULL; - def->maxmem = strtoll((const char*)obj->stringval, &conv, 10); - if (conv == (const char*)obj->stringval) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("malformed memory information")); - goto error; - } - } - xmlXPathFreeObject(obj); - - - /* Extract domain memory */ - obj = xmlXPathEval(BAD_CAST "string(/domain/currentMemory[1])", ctxt); - if ((obj == NULL) || (obj->type != XPATH_STRING) || - (obj->stringval == NULL) || (obj->stringval[0] == 0)) { - def->memory = def->maxmem; - } else { - conv = NULL; - def->memory = strtoll((const char*)obj->stringval, &conv, 10); - if (def->memory > def->maxmem) - def->memory = def->maxmem; - if (conv == (const char*)obj->stringval) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("malformed memory information")); - goto error; - } - } - xmlXPathFreeObject(obj); - - /* Extract domain vcpu info */ - obj = xmlXPathEval(BAD_CAST "string(/domain/vcpu[1])", ctxt); - if ((obj == NULL) || (obj->type != XPATH_STRING) || - (obj->stringval == NULL) || (obj->stringval[0] == 0)) { - def->vcpus = 1; - } else { - conv = NULL; - def->vcpus = strtoll((const char*)obj->stringval, &conv, 10); - if (conv == (const char*)obj->stringval) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("malformed vcpu information")); - goto error; - } - } - xmlXPathFreeObject(obj); - - /* Extract domain vcpu info */ - obj = xmlXPathEval(BAD_CAST "string(/domain/vcpu[1]/@cpuset)", ctxt); - if ((obj == NULL) || (obj->type != XPATH_STRING) || - (obj->stringval == NULL) || (obj->stringval[0] == 0)) { - /* Allow use on all CPUS */ - memset(def->cpumask, 1, QEMUD_CPUMASK_LEN); - } else { - char *set = (char *)obj->stringval; - memset(def->cpumask, 0, QEMUD_CPUMASK_LEN); - if (virParseCpuSet(conn, (const char **)&set, - 0, def->cpumask, - QEMUD_CPUMASK_LEN) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("malformed vcpu mask information")); - goto error; - } - } - xmlXPathFreeObject(obj); - - /* See if ACPI feature is requested */ - obj = xmlXPathEval(BAD_CAST "/domain/features/acpi", ctxt); - if ((obj != NULL) && (obj->type == XPATH_NODESET) && - (obj->nodesetval != NULL) && (obj->nodesetval->nodeNr == 1)) { - def->features |= QEMUD_FEATURE_ACPI; - } - xmlXPathFreeObject(obj); - - - /* See if we disable reboots */ - obj = xmlXPathEval(BAD_CAST "string(/domain/on_reboot)", ctxt); - if ((obj == NULL) || (obj->type != XPATH_STRING) || - (obj->stringval == NULL) || (obj->stringval[0] == 0)) { - def->noReboot = 0; - } else { - if (STREQ((char*)obj->stringval, "destroy")) - def->noReboot = 1; - else - def->noReboot = 0; - } - xmlXPathFreeObject(obj); - - /* See if we set clock to localtime */ - obj = xmlXPathEval(BAD_CAST "string(/domain/clock/@offset)", ctxt); - if ((obj == NULL) || (obj->type != XPATH_STRING) || - (obj->stringval == NULL) || (obj->stringval[0] == 0)) { - def->localtime = 0; - } else { - if (STREQ((char*)obj->stringval, "localtime")) - def->localtime = 1; - else - def->localtime = 0; - } - xmlXPathFreeObject(obj); - - - /* Extract bootloader */ - obj = xmlXPathEval(BAD_CAST "string(/domain/bootloader)", ctxt); - if ((obj != NULL) && (obj->type == XPATH_STRING) && - (obj->stringval != NULL) && (obj->stringval[0] != 0)) { - strncpy(def->os.bootloader, (const char*)obj->stringval, sizeof(def->os.bootloader)); - NUL_TERMINATE(def->os.bootloader); - - /* Set a default OS type, since <type> is optional with bootloader */ - strcpy(def->os.type, "xen"); - } - xmlXPathFreeObject(obj); - - /* Extract OS type info */ - obj = xmlXPathEval(BAD_CAST "string(/domain/os/type[1])", ctxt); - if ((obj == NULL) || (obj->type != XPATH_STRING) || - (obj->stringval == NULL) || (obj->stringval[0] == 0)) { - if (!def->os.type[0]) { - qemudReportError(conn, NULL, NULL, VIR_ERR_OS_TYPE, - "%s", _("no OS type")); - goto error; - } - } else { - strcpy(def->os.type, (const char *)obj->stringval); - } - xmlXPathFreeObject(obj); - obj = NULL; - - if (!virCapabilitiesSupportsGuestOSType(driver->caps, def->os.type)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_OS_TYPE, - "%s", def->os.type); - goto error; - } - - obj = xmlXPathEval(BAD_CAST "string(/domain/os/type[1]/@arch)", ctxt); - if ((obj == NULL) || (obj->type != XPATH_STRING) || - (obj->stringval == NULL) || (obj->stringval[0] == 0)) { - const char *defaultArch = virCapabilitiesDefaultGuestArch(driver->caps, def->os.type); - if (defaultArch == NULL) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("unsupported architecture")); - goto error; - } - if (strlen(defaultArch) >= (QEMUD_OS_TYPE_MAX_LEN-1)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("architecture type too long")); - goto error; - } - strcpy(def->os.arch, defaultArch); - } else { - if (strlen((const char *)obj->stringval) >= (QEMUD_OS_TYPE_MAX_LEN-1)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("architecture type too long")); - goto error; - } - strcpy(def->os.arch, (const char *)obj->stringval); - } - xmlXPathFreeObject(obj); - - obj = xmlXPathEval(BAD_CAST "string(/domain/os/type[1]/@machine)", ctxt); - if ((obj == NULL) || (obj->type != XPATH_STRING) || - (obj->stringval == NULL) || (obj->stringval[0] == 0)) { - const char *defaultMachine = virCapabilitiesDefaultGuestMachine(driver->caps, - def->os.type, - def->os.arch); - if (defaultMachine == NULL) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("unsupported architecture")); - goto error; - } - if (strlen(defaultMachine) >= (QEMUD_OS_MACHINE_MAX_LEN-1)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("machine type too long")); - goto error; - } - strcpy(def->os.machine, defaultMachine); - } else { - if (strlen((const char *)obj->stringval) >= (QEMUD_OS_MACHINE_MAX_LEN-1)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("architecture type too long")); - goto error; - } - strcpy(def->os.machine, (const char *)obj->stringval); - } - xmlXPathFreeObject(obj); - - - if (!def->os.bootloader[0]) { - obj = xmlXPathEval(BAD_CAST "string(/domain/os/kernel[1])", ctxt); - if ((obj != NULL) && (obj->type == XPATH_STRING) && - (obj->stringval != NULL) && (obj->stringval[0] != 0)) { - if (strlen((const char *)obj->stringval) >= (PATH_MAX-1)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("kernel path too long")); - goto error; - } - strcpy(def->os.kernel, (const char *)obj->stringval); - } - xmlXPathFreeObject(obj); - - - obj = xmlXPathEval(BAD_CAST "string(/domain/os/initrd[1])", ctxt); - if ((obj != NULL) && (obj->type == XPATH_STRING) && - (obj->stringval != NULL) && (obj->stringval[0] != 0)) { - if (strlen((const char *)obj->stringval) >= (PATH_MAX-1)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("initrd path too long")); - goto error; - } - strcpy(def->os.initrd, (const char *)obj->stringval); - } - xmlXPathFreeObject(obj); - - - obj = xmlXPathEval(BAD_CAST "string(/domain/os/cmdline[1])", ctxt); - if ((obj != NULL) && (obj->type == XPATH_STRING) && - (obj->stringval != NULL) && (obj->stringval[0] != 0)) { - if (strlen((const char *)obj->stringval) >= (PATH_MAX-1)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("cmdline arguments too long")); - goto error; - } - strcpy(def->os.cmdline, (const char *)obj->stringval); - } - xmlXPathFreeObject(obj); - - - /* analysis of the disk devices */ - obj = xmlXPathEval(BAD_CAST "/domain/os/boot", ctxt); - if ((obj != NULL) && (obj->type == XPATH_NODESET) && - (obj->nodesetval != NULL) && (obj->nodesetval->nodeNr >= 0)) { - for (i = 0; i < obj->nodesetval->nodeNr && i < QEMUD_MAX_BOOT_DEVS ; i++) { - if (!(prop = xmlGetProp(obj->nodesetval->nodeTab[i], BAD_CAST "dev"))) - continue; - if (STREQ((char *)prop, "hd")) { - def->os.bootDevs[def->os.nBootDevs++] = QEMUD_BOOT_DISK; - } else if (STREQ((char *)prop, "fd")) { - def->os.bootDevs[def->os.nBootDevs++] = QEMUD_BOOT_FLOPPY; - } else if (STREQ((char *)prop, "cdrom")) { - def->os.bootDevs[def->os.nBootDevs++] = QEMUD_BOOT_CDROM; - } else if (STREQ((char *)prop, "network")) { - def->os.bootDevs[def->os.nBootDevs++] = QEMUD_BOOT_NET; - } else { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("unknown boot device \'%s\'"), (char*)prop); - goto error; - } - xmlFree(prop); - prop = NULL; - } - } - xmlXPathFreeObject(obj); - if (def->os.nBootDevs == 0) { - def->os.nBootDevs = 1; - def->os.bootDevs[0] = QEMUD_BOOT_DISK; - } - } - - obj = xmlXPathEval(BAD_CAST "string(/domain/devices/emulator[1])", ctxt); - if ((obj == NULL) || (obj->type != XPATH_STRING) || - (obj->stringval == NULL) || (obj->stringval[0] == 0)) { - const char *type = qemudVirtTypeToString(def->virtType); - if (!type) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("unknown virt type")); - goto error; - } - const char *emulator = virCapabilitiesDefaultGuestEmulator(driver->caps, - def->os.type, - def->os.arch, - type); - if (!emulator) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("unsupported guest type")); - goto error; - } - strcpy(def->os.binary, emulator); - } else { - if (strlen((const char *)obj->stringval) >= (PATH_MAX-1)) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("emulator path too long")); - goto error; - } - strcpy(def->os.binary, (const char *)obj->stringval); - } - xmlXPathFreeObject(obj); - - obj = xmlXPathEval(BAD_CAST "/domain/devices/graphics", ctxt); - if ((obj == NULL) || (obj->type != XPATH_NODESET) || - (obj->nodesetval == NULL) || (obj->nodesetval->nodeNr == 0)) { - def->graphicsType = QEMUD_GRAPHICS_NONE; - } else if ((prop = xmlGetProp(obj->nodesetval->nodeTab[0], BAD_CAST "type"))) { - if (STREQ((char *)prop, "vnc")) { - xmlChar *vncport, *vnclisten; - def->graphicsType = QEMUD_GRAPHICS_VNC; - vncport = xmlGetProp(obj->nodesetval->nodeTab[0], BAD_CAST "port"); - if (vncport) { - conv = NULL; - def->vncPort = strtoll((const char*)vncport, &conv, 10); - } else { - def->vncPort = -1; - } - vnclisten = xmlGetProp(obj->nodesetval->nodeTab[0], BAD_CAST "listen"); - if (vnclisten && *vnclisten) - strncpy(def->vncListen, (char *)vnclisten, BR_INET_ADDR_MAXLEN-1); - else - strcpy(def->vncListen, driver->vncListen); - def->vncListen[BR_INET_ADDR_MAXLEN-1] = '\0'; - def->keymap = (char *) xmlGetProp(obj->nodesetval->nodeTab[0], BAD_CAST "keymap"); - xmlFree(vncport); - xmlFree(vnclisten); - } else if (STREQ((char *)prop, "sdl")) { - def->graphicsType = QEMUD_GRAPHICS_SDL; - } else { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("Unsupported graphics type %s"), prop); - goto error; - } - xmlFree(prop); - prop = NULL; - } - xmlXPathFreeObject(obj); - - /* analysis of the disk devices */ - obj = xmlXPathEval(BAD_CAST "/domain/devices/disk", ctxt); - if ((obj != NULL) && (obj->type == XPATH_NODESET) && - (obj->nodesetval != NULL) && (obj->nodesetval->nodeNr >= 0)) { - for (i = 0; i < obj->nodesetval->nodeNr; i++) { - struct qemud_vm_disk_def *disk; - if (VIR_ALLOC(disk) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, - "%s", _("failed to allocate space for disk string")); - goto error; - } - if (qemudParseDiskXML(conn, disk, obj->nodesetval->nodeTab[i]) < 0) { - VIR_FREE(disk); - goto error; - } - def->ndisks++; - if (i == 0) { - disk->next = NULL; - def->disks = disk; - } else { - struct qemud_vm_disk_def *ptr = def->disks; - while (ptr) { - if (!ptr->next || qemudDiskCompare(disk, ptr->next) < 0) { - disk->next = ptr->next; - ptr->next = disk; - break; - } - ptr = ptr->next; - } - } - } - } - xmlXPathFreeObject(obj); - obj = NULL; - - /* analysis of the character devices */ - if (qemudParseCharXMLDevices(conn, ctxt, - "/domain/devices/parallel", - &def->nparallels, - &def->parallels) < 0) - goto error; - if (qemudParseCharXMLDevices(conn, ctxt, - "/domain/devices/serial", - &def->nserials, - &def->serials) < 0) - goto error; - - /* - * If no serial devices were listed, then look for console - * devices which is the legacy syntax for the same thing - */ - if (def->nserials == 0) { - obj = xmlXPathEval(BAD_CAST "/domain/devices/console", ctxt); - if ((obj != NULL) && (obj->type == XPATH_NODESET) && - (obj->nodesetval != NULL) && (obj->nodesetval->nodeNr == 1)) { - struct qemud_vm_chr_def *chr; - if (VIR_ALLOC(chr) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, - "%s", - _("failed to allocate space for char device")); - goto error; - } - - if (qemudParseCharXML(conn, chr, 0, obj->nodesetval->nodeTab[0]) < 0) { - VIR_FREE(chr); - goto error; - } - def->nserials = 1; - def->serials = chr; - } - xmlXPathFreeObject(obj); - } - - - /* analysis of the network devices */ - obj = xmlXPathEval(BAD_CAST "/domain/devices/interface", ctxt); - if ((obj != NULL) && (obj->type == XPATH_NODESET) && - (obj->nodesetval != NULL) && (obj->nodesetval->nodeNr >= 0)) { - struct qemud_vm_net_def *prev = NULL; - for (i = 0; i < obj->nodesetval->nodeNr; i++) { - struct qemud_vm_net_def *net; - if (VIR_ALLOC(net) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, - "%s", _("failed to allocate space for net string")); - goto error; - } - if (qemudParseInterfaceXML(conn, net, obj->nodesetval->nodeTab[i]) < 0) { - VIR_FREE(net); - goto error; - } - def->nnets++; - net->next = NULL; - if (i == 0) { - def->nets = net; - } else { - prev->next = net; - } - prev = net; - } - } - xmlXPathFreeObject(obj); - - /* analysis of the input devices */ - obj = xmlXPathEval(BAD_CAST "/domain/devices/input", ctxt); - if ((obj != NULL) && (obj->type == XPATH_NODESET) && - (obj->nodesetval != NULL) && (obj->nodesetval->nodeNr >= 0)) { - struct qemud_vm_input_def *prev = NULL; - for (i = 0; i < obj->nodesetval->nodeNr; i++) { - struct qemud_vm_input_def *input; - if (VIR_ALLOC(input) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, - "%s", _("failed to allocate space for input string")); - goto error; - } - if (qemudParseInputXML(conn, def, input, obj->nodesetval->nodeTab[i]) < 0) { - VIR_FREE(input); - goto error; - } - /* Mouse + PS/2 is implicit with graphics, so don't store it */ - if (input->bus == QEMU_INPUT_BUS_PS2 && - input->type == QEMU_INPUT_TYPE_MOUSE) { - VIR_FREE(input); - continue; - } - def->ninputs++; - input->next = NULL; - if (def->inputs == NULL) { - def->inputs = input; - } else { - prev->next = input; - } - prev = input; - } - } - xmlXPathFreeObject(obj); - - /* Parse sound driver xml */ - obj = xmlXPathEval(BAD_CAST "/domain/devices/sound", ctxt); - if ((obj != NULL) && (obj->type == XPATH_NODESET) && - (obj->nodesetval != NULL) && (obj->nodesetval->nodeNr >= 0)) { - struct qemud_vm_sound_def *prev = NULL; - for (i = 0; i < obj->nodesetval->nodeNr; i++) { - - struct qemud_vm_sound_def *sound; - struct qemud_vm_sound_def *check = def->sounds; - int collision = 0; - if (VIR_ALLOC(sound) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, - "%s", _("failed to allocate space for sound dev")); - goto error; - } - if (qemudParseSoundXML(conn, sound, - obj->nodesetval->nodeTab[i]) < 0) { - VIR_FREE(sound); - goto error; - } - - // Check that model type isn't already present in sound dev list - while(check) { - if (check->model == sound->model) { - collision = 1; - break; - } - check = check->next; - } - if (collision) { - VIR_FREE(sound); - continue; - } - - def->nsounds++; - sound->next = NULL; - if (def->sounds == NULL) { - def->sounds = sound; - } else { - prev->next = sound; - } - prev = sound; - } - } - xmlXPathFreeObject(obj); - obj = NULL; - - /* If graphics are enabled, there's an implicit PS2 mouse */ - if (def->graphicsType != QEMUD_GRAPHICS_NONE) { - int hasPS2mouse = 0; - struct qemud_vm_input_def *input = def->inputs; - while (input) { - if (input->type == QEMU_INPUT_TYPE_MOUSE && - input->bus == QEMU_INPUT_BUS_PS2) - hasPS2mouse = 1; - input = input->next; - } - - if (!hasPS2mouse) { - if (VIR_ALLOC(input) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, - "%s", _("failed to allocate space for input string")); - goto error; - } - input->type = QEMU_INPUT_TYPE_MOUSE; - input->bus = QEMU_INPUT_BUS_PS2; - input->next = def->inputs; - def->inputs = input; - def->ninputs++; - } - } - - xmlXPathFreeContext(ctxt); - - return def; - - error: - VIR_FREE(prop); - xmlXPathFreeObject(obj); - xmlXPathFreeContext(ctxt); - qemudFreeVMDef(def); - return NULL; -} - static char * qemudNetworkIfaceConnect(virConnectPtr conn, struct qemud_driver *driver, - struct qemud_vm *vm, - struct qemud_vm_net_def *net, + int **tapfds, + int *ntapfds, + virDomainNetDefPtr net, int vlan) { virNetworkObjPtr network = NULL; @@ -2236,38 +553,37 @@ int err; int tapfd = -1; - if (net->type == QEMUD_NET_NETWORK) { - if (!(network = virNetworkFindByName(driver->networks, net->dst.network.name))) { + if (net->type == VIR_DOMAIN_NET_TYPE_NETWORK) { + if (!(network = virNetworkFindByName(driver->networks, net->data.network.name))) { qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("Network '%s' not found"), - net->dst.network.name); + net->data.network.name); goto error; } else if (network->def->bridge == NULL) { qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("Network '%s' not active"), - net->dst.network.name); + net->data.network.name); goto error; } brname = network->def->bridge; - if (net->dst.network.ifname[0] == '\0' || - STRPREFIX(net->dst.network.ifname, "vnet") || - strchr(net->dst.network.ifname, '%')) { - strcpy(net->dst.network.ifname, "vnet%d"); - } - ifname = net->dst.network.ifname; - } else if (net->type == QEMUD_NET_BRIDGE) { - brname = net->dst.bridge.brname; - if (net->dst.bridge.ifname[0] == '\0' || - STRPREFIX(net->dst.bridge.ifname, "vnet") || - strchr(net->dst.bridge.ifname, '%')) { - strcpy(net->dst.bridge.ifname, "vnet%d"); - } - ifname = net->dst.bridge.ifname; + } else if (net->type == VIR_DOMAIN_NET_TYPE_BRIDGE) { + brname = net->data.bridge.brname; } else { qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("Network type %d is not supported"), net->type); goto error; } + + if (!net->ifname || + STRPREFIX(net->ifname, "vnet") || + strchr(net->ifname, '%')) { + VIR_FREE(net->ifname); + if (!(net->ifname = strdup("vnet%d"))) { + qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL); + goto error; + } + } + ifname = net->ifname; if (!driver->brctl && (err = brInit(&driver->brctl))) { qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, @@ -2291,11 +607,10 @@ if (!(retval = strdup(tapfdstr))) goto no_memory; - if (VIR_REALLOC_N(vm->tapfds, vm->ntapfds+2) < 0) + if (VIR_REALLOC_N(*tapfds, (*ntapfds)+1) < 0) goto no_memory; - vm->tapfds[vm->ntapfds++] = tapfd; - vm->tapfds[vm->ntapfds] = -1; + (*tapfds)[(*ntapfds)++] = tapfd; return retval; @@ -2309,71 +624,71 @@ return NULL; } -static int qemudBuildCommandLineChrDevStr(struct qemud_vm_chr_def *dev, +static int qemudBuildCommandLineChrDevStr(virDomainChrDefPtr dev, char *buf, int buflen) { - switch (dev->srcType) { - case QEMUD_CHR_SRC_TYPE_NULL: + switch (dev->type) { + case VIR_DOMAIN_CHR_TYPE_NULL: strncpy(buf, "null", buflen); buf[buflen-1] = '\0'; break; - case QEMUD_CHR_SRC_TYPE_VC: + case VIR_DOMAIN_CHR_TYPE_VC: strncpy(buf, "vc", buflen); buf[buflen-1] = '\0'; break; - case QEMUD_CHR_SRC_TYPE_PTY: + case VIR_DOMAIN_CHR_TYPE_PTY: strncpy(buf, "pty", buflen); buf[buflen-1] = '\0'; break; - case QEMUD_CHR_SRC_TYPE_DEV: + case VIR_DOMAIN_CHR_TYPE_DEV: if (snprintf(buf, buflen, "%s", - dev->srcData.file.path) >= buflen) + dev->data.file.path) >= buflen) return -1; break; - case QEMUD_CHR_SRC_TYPE_FILE: + case VIR_DOMAIN_CHR_TYPE_FILE: if (snprintf(buf, buflen, "file:%s", - dev->srcData.file.path) >= buflen) + dev->data.file.path) >= buflen) return -1; break; - case QEMUD_CHR_SRC_TYPE_PIPE: + case VIR_DOMAIN_CHR_TYPE_PIPE: if (snprintf(buf, buflen, "pipe:%s", - dev->srcData.file.path) >= buflen) + dev->data.file.path) >= buflen) return -1; break; - case QEMUD_CHR_SRC_TYPE_STDIO: + case VIR_DOMAIN_CHR_TYPE_STDIO: strncpy(buf, "stdio", buflen); buf[buflen-1] = '\0'; break; - case QEMUD_CHR_SRC_TYPE_UDP: + case VIR_DOMAIN_CHR_TYPE_UDP: if (snprintf(buf, buflen, "udp:%s:%s@%s:%s", - dev->srcData.udp.connectHost, - dev->srcData.udp.connectService, - dev->srcData.udp.bindHost, - dev->srcData.udp.bindService) >= buflen) + dev->data.udp.connectHost, + dev->data.udp.connectService, + dev->data.udp.bindHost, + dev->data.udp.bindService) >= buflen) return -1; break; - case QEMUD_CHR_SRC_TYPE_TCP: + case VIR_DOMAIN_CHR_TYPE_TCP: if (snprintf(buf, buflen, "%s:%s:%s%s", - dev->srcData.tcp.protocol == QEMUD_CHR_SRC_TCP_PROTOCOL_TELNET ? "telnet" : "tcp", - dev->srcData.tcp.host, - dev->srcData.tcp.service, - dev->srcData.tcp.listen ? ",listen" : "") >= buflen) + dev->data.tcp.protocol == VIR_DOMAIN_CHR_TCP_PROTOCOL_TELNET ? "telnet" : "tcp", + dev->data.tcp.host, + dev->data.tcp.service, + dev->data.tcp.listen ? ",listen" : "") >= buflen) return -1; break; - case QEMUD_CHR_SRC_TYPE_UNIX: + case VIR_DOMAIN_CHR_TYPE_UNIX: if (snprintf(buf, buflen, "unix:%s%s", - dev->srcData.nix.path, - dev->srcData.nix.listen ? ",listen" : "") >= buflen) + dev->data.nix.path, + dev->data.nix.listen ? ",listen" : "") >= buflen) return -1; break; } @@ -2387,29 +702,26 @@ */ int qemudBuildCommandLine(virConnectPtr conn, struct qemud_driver *driver, - struct qemud_vm *vm, - char ***retargv) { + virDomainObjPtr vm, + int qemuCmdFlags, + char ***retargv, + int **tapfds, + int *ntapfds, + const char *migrateFrom) { int i; char memory[50]; char vcpus[50]; - char boot[QEMUD_MAX_BOOT_DEVS+1]; - struct qemud_vm_disk_def *disk = vm->def->disks; - struct qemud_vm_net_def *net = vm->def->nets; - struct qemud_vm_input_def *input = vm->def->inputs; - struct qemud_vm_sound_def *sound = vm->def->sounds; - struct qemud_vm_chr_def *serial = vm->def->serials; - struct qemud_vm_chr_def *parallel = vm->def->parallels; + char boot[VIR_DOMAIN_BOOT_LAST]; + virDomainDiskDefPtr disk = vm->def->disks; + virDomainNetDefPtr net = vm->def->nets; + virDomainInputDefPtr input = vm->def->inputs; + virDomainSoundDefPtr sound = vm->def->sounds; + virDomainChrDefPtr serial = vm->def->serials; + virDomainChrDefPtr parallel = vm->def->parallels; struct utsname ut; int disableKQEMU = 0; int qargc = 0, qarga = 0; char **qargv = NULL; - - if (vm->qemuVersion == 0) { - if (qemudExtractVersionInfo(vm->def->os.binary, - &(vm->qemuVersion), - &(vm->qemuCmdFlags)) < 0) - return -1; - } uname(&ut); @@ -2425,9 +737,9 @@ * 2. Guest is 'qemu' * 3. The qemu binary has the -no-kqemu flag */ - if ((vm->qemuCmdFlags & QEMUD_CMD_FLAG_KQEMU) && + if ((qemuCmdFlags & QEMUD_CMD_FLAG_KQEMU) && STREQ(ut.machine, vm->def->os.arch) && - vm->def->virtType == QEMUD_VIRT_QEMU) + vm->def->virtType == VIR_DOMAIN_VIRT_QEMU) disableKQEMU = 1; #define ADD_ARG_SPACE \ @@ -2453,10 +765,10 @@ } while (0) snprintf(memory, sizeof(memory), "%lu", vm->def->memory/1024); - snprintf(vcpus, sizeof(vcpus), "%d", vm->def->vcpus); + snprintf(vcpus, sizeof(vcpus), "%lu", vm->def->vcpus); - ADD_ARG_LIT(vm->def->os.binary); + ADD_ARG_LIT(vm->def->emulator); ADD_ARG_LIT("-S"); ADD_ARG_LIT("-M"); ADD_ARG_LIT(vm->def->os.machine); @@ -2467,7 +779,7 @@ ADD_ARG_LIT("-smp"); ADD_ARG_LIT(vcpus); - if (vm->qemuCmdFlags & QEMUD_CMD_FLAG_NAME) { + if (qemuCmdFlags & QEMUD_CMD_FLAG_NAME) { ADD_ARG_LIT("-name"); ADD_ARG_LIT(vm->def->name); } @@ -2478,7 +790,7 @@ * if you ask for nographic. So we have to make sure we override * these defaults ourselves... */ - if (vm->def->graphicsType == QEMUD_GRAPHICS_NONE) + if (!vm->def->graphics) ADD_ARG_LIT("-nographic"); ADD_ARG_LIT("-monitor"); @@ -2487,26 +799,26 @@ if (vm->def->localtime) ADD_ARG_LIT("-localtime"); - if ((vm->qemuCmdFlags & QEMUD_CMD_FLAG_NO_REBOOT) && - vm->def->noReboot) + if ((qemuCmdFlags & QEMUD_CMD_FLAG_NO_REBOOT) && + vm->def->onReboot != VIR_DOMAIN_LIFECYCLE_RESTART) ADD_ARG_LIT("-no-reboot"); - if (!(vm->def->features & QEMUD_FEATURE_ACPI)) + if (!(vm->def->features & (1 << VIR_DOMAIN_FEATURE_ACPI))) ADD_ARG_LIT("-no-acpi"); - if (!vm->def->os.bootloader[0]) { + if (!vm->def->os.bootloader) { for (i = 0 ; i < vm->def->os.nBootDevs ; i++) { switch (vm->def->os.bootDevs[i]) { - case QEMUD_BOOT_CDROM: + case VIR_DOMAIN_BOOT_CDROM: boot[i] = 'd'; break; - case QEMUD_BOOT_FLOPPY: + case VIR_DOMAIN_BOOT_FLOPPY: boot[i] = 'a'; break; - case QEMUD_BOOT_DISK: + case VIR_DOMAIN_BOOT_DISK: boot[i] = 'c'; break; - case QEMUD_BOOT_NET: + case VIR_DOMAIN_BOOT_NET: boot[i] = 'n'; break; default: @@ -2518,15 +830,15 @@ ADD_ARG_LIT("-boot"); ADD_ARG_LIT(boot); - if (vm->def->os.kernel[0]) { + if (vm->def->os.kernel) { ADD_ARG_LIT("-kernel"); ADD_ARG_LIT(vm->def->os.kernel); } - if (vm->def->os.initrd[0]) { + if (vm->def->os.initrd) { ADD_ARG_LIT("-initrd"); ADD_ARG_LIT(vm->def->os.initrd); } - if (vm->def->os.cmdline[0]) { + if (vm->def->os.cmdline) { ADD_ARG_LIT("-append"); ADD_ARG_LIT(vm->def->os.cmdline); } @@ -2536,20 +848,20 @@ } /* If QEMU supports -drive param instead of old -hda, -hdb, -cdrom .. */ - if (vm->qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE) { + if (qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE) { int bootCD = 0, bootFloppy = 0, bootDisk = 0; /* If QEMU supports boot=on for -drive param... */ - if (vm->qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE_BOOT) { + if (qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE_BOOT) { for (i = 0 ; i < vm->def->os.nBootDevs ; i++) { switch (vm->def->os.bootDevs[i]) { - case QEMUD_BOOT_CDROM: + case VIR_DOMAIN_BOOT_CDROM: bootCD = 1; break; - case QEMUD_BOOT_FLOPPY: + case VIR_DOMAIN_BOOT_FLOPPY: bootFloppy = 1; break; - case QEMUD_BOOT_DISK: + case VIR_DOMAIN_BOOT_DISK: bootDisk = 1; break; } @@ -2561,6 +873,7 @@ const char *media = NULL; int bootable = 0; int idx = virDiskNameToIndex(disk->dst); + const char *bus = virDomainDiskQEMUBusTypeToString(disk->bus); if (idx < 0) { qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, @@ -2568,26 +881,26 @@ goto error; } - if (disk->device == QEMUD_DISK_CDROM) + if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) media = "media=cdrom,"; switch (disk->device) { - case QEMUD_DISK_CDROM: + case VIR_DOMAIN_DISK_DEVICE_CDROM: bootable = bootCD; bootCD = 0; break; - case QEMUD_DISK_FLOPPY: + case VIR_DOMAIN_DISK_DEVICE_FLOPPY: bootable = bootFloppy; bootFloppy = 0; break; - case QEMUD_DISK_DISK: + case VIR_DOMAIN_DISK_DEVICE_DISK: bootable = bootDisk; bootDisk = 0; break; } snprintf(opt, PATH_MAX, "file=%s,if=%s,%sindex=%d%s", - disk->src, qemudBusIdToName(disk->bus, 1), + disk->src, bus, media ? media : "", idx, bootable ? ",boot=on" : ""); @@ -2602,8 +915,8 @@ char file[PATH_MAX]; if (STREQ(disk->dst, "hdc") && - disk->device == QEMUD_DISK_CDROM) { - if (disk->src[0]) { + disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) { + if (disk->src) { snprintf(dev, NAME_MAX, "-%s", "cdrom"); } else { disk = disk->next; @@ -2643,7 +956,8 @@ net->mac[2], net->mac[3], net->mac[4], net->mac[5], vlan, - (net->model[0] ? ",model=" : ""), net->model) >= sizeof(nic)) + (net->model ? ",model=" : ""), + (net->model ? net->model : "")) >= sizeof(nic)) goto error; ADD_ARG_LIT("-net"); @@ -2651,22 +965,24 @@ ADD_ARG_LIT("-net"); switch (net->type) { - case QEMUD_NET_NETWORK: - case QEMUD_NET_BRIDGE: + case VIR_DOMAIN_NET_TYPE_NETWORK: + case VIR_DOMAIN_NET_TYPE_BRIDGE: { - char *tap = qemudNetworkIfaceConnect(conn, driver, vm, net, vlan); + char *tap = qemudNetworkIfaceConnect(conn, driver, + tapfds, ntapfds, + net, vlan); if (tap == NULL) goto error; ADD_ARG(tap); break; } - case QEMUD_NET_ETHERNET: + case VIR_DOMAIN_NET_TYPE_ETHERNET: { char arg[PATH_MAX]; if (snprintf(arg, PATH_MAX-1, "tap,ifname=%s,script=%s,vlan=%d", - net->dst.ethernet.ifname, - net->dst.ethernet.script, + net->ifname, + net->data.ethernet.script, vlan) >= (PATH_MAX-1)) goto error; @@ -2674,27 +990,27 @@ } break; - case QEMUD_NET_CLIENT: - case QEMUD_NET_SERVER: - case QEMUD_NET_MCAST: + case VIR_DOMAIN_NET_TYPE_CLIENT: + case VIR_DOMAIN_NET_TYPE_SERVER: + case VIR_DOMAIN_NET_TYPE_MCAST: { char arg[PATH_MAX]; const char *mode = NULL; switch (net->type) { - case QEMUD_NET_CLIENT: + case VIR_DOMAIN_NET_TYPE_CLIENT: mode = "connect"; break; - case QEMUD_NET_SERVER: + case VIR_DOMAIN_NET_TYPE_SERVER: mode = "listen"; break; - case QEMUD_NET_MCAST: + case VIR_DOMAIN_NET_TYPE_MCAST: mode = "mcast"; break; } if (snprintf(arg, PATH_MAX-1, "socket,%s=%s:%d,vlan=%d", mode, - net->dst.socket.address, - net->dst.socket.port, + net->data.socket.address, + net->data.socket.port, vlan) >= (PATH_MAX-1)) goto error; @@ -2702,7 +1018,7 @@ } break; - case QEMUD_NET_USER: + case VIR_DOMAIN_NET_TYPE_USER: default: { char arg[PATH_MAX]; @@ -2754,19 +1070,20 @@ ADD_ARG_LIT("-usb"); while (input) { - if (input->bus == QEMU_INPUT_BUS_USB) { + if (input->bus == VIR_DOMAIN_INPUT_BUS_USB) { ADD_ARG_LIT("-usbdevice"); - ADD_ARG_LIT(input->type == QEMU_INPUT_TYPE_MOUSE ? "mouse" : "tablet"); + ADD_ARG_LIT(input->type == VIR_DOMAIN_INPUT_TYPE_MOUSE ? "mouse" : "tablet"); } input = input->next; } - if (vm->def->graphicsType == QEMUD_GRAPHICS_VNC) { + if (vm->def->graphics && + vm->def->graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC) { char vncdisplay[PATH_MAX]; int ret; - if (vm->qemuCmdFlags & QEMUD_CMD_FLAG_VNC_COLON) { + if (qemuCmdFlags & QEMUD_CMD_FLAG_VNC_COLON) { char options[PATH_MAX] = ""; if (driver->vncTLS) { strcat(options, ",tls"); @@ -2780,25 +1097,24 @@ options[sizeof(options)-1] = '\0'; } ret = snprintf(vncdisplay, sizeof(vncdisplay), "%s:%d%s", - vm->def->vncListen, - vm->def->vncActivePort - 5900, + vm->def->graphics->data.vnc.listenAddr, + vm->def->graphics->data.vnc.port - 5900, options); } else { ret = snprintf(vncdisplay, sizeof(vncdisplay), "%d", - vm->def->vncActivePort - 5900); + vm->def->graphics->data.vnc.port - 5900); } if (ret < 0 || ret >= (int)sizeof(vncdisplay)) goto error; ADD_ARG_LIT("-vnc"); ADD_ARG_LIT(vncdisplay); - if (vm->def->keymap) { + if (vm->def->graphics->data.vnc.keymap) { ADD_ARG_LIT("-k"); - ADD_ARG_LIT(vm->def->keymap); + ADD_ARG_LIT(vm->def->graphics->data.vnc.keymap); } - } else if (vm->def->graphicsType == QEMUD_GRAPHICS_NONE) { - /* Nada - we added -nographic earlier in this function */ - } else { + } else if (vm->def->graphics && + vm->def->graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_SDL) { /* SDL is the default. no args needed */ } @@ -2810,7 +1126,7 @@ goto no_memory; while(sound && size > 0) { - const char *model = qemudSoundModelToString(sound->model); + const char *model = virDomainSoundModelTypeToString(sound->model); if (!model) { VIR_FREE(modstr); qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, @@ -2827,9 +1143,9 @@ ADD_ARG(modstr); } - if (vm->migrateFrom[0]) { + if (migrateFrom) { ADD_ARG_LIT("-incoming"); - ADD_ARG_LIT(vm->migrateFrom); + ADD_ARG_LIT(migrateFrom); } ADD_ARG(NULL); @@ -2841,12 +1157,12 @@ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, "%s", _("failed to allocate space for argv string")); error: - if (vm->tapfds) { - for (i = 0; vm->tapfds[i] != -1; i++) - close(vm->tapfds[i]); - VIR_FREE(vm->tapfds); - vm->tapfds = NULL; - vm->ntapfds = 0; + if (tapfds && + *tapfds) { + for (i = 0; ntapfds; i++) + close((*tapfds)[i]); + VIR_FREE(*tapfds); + *ntapfds = 0; } if (qargv) { for (i = 0 ; i < qargc ; i++) @@ -2861,755 +1177,4 @@ } -/* Save a guest's config data into a persistent file */ -static int qemudSaveConfig(virConnectPtr conn, - struct qemud_driver *driver, - struct qemud_vm *vm, - struct qemud_vm_def *def) { - char *xml; - int fd = -1, ret = -1; - int towrite; - - if (!(xml = qemudGenerateXML(conn, driver, vm, def, 0))) - return -1; - - if ((fd = open(vm->configFile, - O_WRONLY | O_CREAT | O_TRUNC, - S_IRUSR | S_IWUSR )) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("cannot create config file %s: %s"), - vm->configFile, strerror(errno)); - goto cleanup; - } - - towrite = strlen(xml); - if (safewrite(fd, xml, towrite) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("cannot write config file %s: %s"), - vm->configFile, strerror(errno)); - goto cleanup; - } - - if (close(fd) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("cannot save config file %s: %s"), - vm->configFile, strerror(errno)); - goto cleanup; - } - - ret = 0; - - cleanup: - if (fd != -1) - close(fd); - - VIR_FREE(xml); - - return ret; -} - -struct qemud_vm_device_def * -qemudParseVMDeviceDef(virConnectPtr conn, - const struct qemud_vm_def *def, - const char *xmlStr) -{ - xmlDocPtr xml; - xmlNodePtr node; - struct qemud_vm_device_def *dev; - - if (VIR_ALLOC(dev) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL); - return NULL; - } - - if (!(xml = xmlReadDoc(BAD_CAST xmlStr, "device.xml", NULL, - XML_PARSE_NOENT | XML_PARSE_NONET | - XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) { - qemudReportError(conn, NULL, NULL, VIR_ERR_XML_ERROR, NULL); - goto error; - } - - node = xmlDocGetRootElement(xml); - if (node == NULL) { - qemudReportError(conn, NULL, NULL, VIR_ERR_XML_ERROR, - "%s", _("missing root element")); - goto error; - } - if (xmlStrEqual(node->name, BAD_CAST "disk")) { - dev->type = QEMUD_DEVICE_DISK; - qemudParseDiskXML(conn, &(dev->data.disk), node); - } else if (xmlStrEqual(node->name, BAD_CAST "interface")) { - dev->type = QEMUD_DEVICE_NET; - qemudParseInterfaceXML(conn, &(dev->data.net), node); - } else if (xmlStrEqual(node->name, BAD_CAST "input")) { - dev->type = QEMUD_DEVICE_DISK; - qemudParseInputXML(conn, def, &(dev->data.input), node); - } else if (xmlStrEqual(node->name, BAD_CAST "sound")) { - dev->type = QEMUD_DEVICE_SOUND; - qemudParseSoundXML(conn, &(dev->data.sound), node); - } else { - qemudReportError(conn, NULL, NULL, VIR_ERR_XML_ERROR, - "%s", _("unknown device type")); - goto error; - } - - xmlFreeDoc(xml); - - return dev; - - error: - if (xml) xmlFreeDoc(xml); - VIR_FREE(dev); - return NULL; -} - -struct qemud_vm_def * -qemudParseVMDef(virConnectPtr conn, - struct qemud_driver *driver, - const char *xmlStr, - const char *displayName) { - xmlDocPtr xml; - struct qemud_vm_def *def = NULL; - - if (!(xml = xmlReadDoc(BAD_CAST xmlStr, displayName ? displayName : "domain.xml", NULL, - XML_PARSE_NOENT | XML_PARSE_NONET | - XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) { - qemudReportError(conn, NULL, NULL, VIR_ERR_XML_ERROR, NULL); - return NULL; - } - - def = qemudParseXML(conn, driver, xml); - - xmlFreeDoc(xml); - - return def; -} - -struct qemud_vm * -qemudAssignVMDef(virConnectPtr conn, - struct qemud_driver *driver, - struct qemud_vm_def *def) -{ - struct qemud_vm *vm = NULL; - - if ((vm = qemudFindVMByName(driver, def->name))) { - if (!qemudIsActiveVM(vm)) { - qemudFreeVMDef(vm->def); - vm->def = def; - } else { - if (vm->newDef) - qemudFreeVMDef(vm->newDef); - vm->newDef = def; - } - /* Reset version, because the emulator path might have changed */ - vm->qemuVersion = 0; - vm->qemuCmdFlags = 0; - return vm; - } - - if (VIR_ALLOC(vm) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, - "%s", _("failed to allocate space for vm string")); - return NULL; - } - - vm->stdin = -1; - vm->stdout = -1; - vm->stderr = -1; - vm->monitor = -1; - vm->pid = -1; - vm->id = -1; - vm->state = VIR_DOMAIN_SHUTOFF; - vm->def = def; - vm->next = driver->vms; - - driver->vms = vm; - driver->ninactivevms++; - - return vm; -} - -void -qemudRemoveInactiveVM(struct qemud_driver *driver, - struct qemud_vm *vm) -{ - struct qemud_vm *prev = NULL, *curr; - - curr = driver->vms; - while (curr != vm) { - prev = curr; - curr = curr->next; - } - - if (curr) { - if (prev) - prev->next = curr->next; - else - driver->vms = curr->next; - - driver->ninactivevms--; - } - - qemudFreeVM(vm); -} - -int -qemudSaveVMDef(virConnectPtr conn, - struct qemud_driver *driver, - struct qemud_vm *vm, - struct qemud_vm_def *def) { - if (vm->configFile[0] == '\0') { - int err; - - if ((err = virFileMakePath(driver->configDir))) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("cannot create config directory %s: %s"), - driver->configDir, strerror(err)); - return -1; - } - - if (virFileBuildPath(driver->configDir, def->name, ".xml", - vm->configFile, PATH_MAX) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("cannot construct config file path")); - return -1; - } - - if (virFileBuildPath(driver->autostartDir, def->name, ".xml", - vm->autostartLink, PATH_MAX) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("cannot construct autostart link path")); - vm->configFile[0] = '\0'; - return -1; - } - } - - return qemudSaveConfig(conn, driver, vm, def); -} - - -static struct qemud_vm * -qemudLoadConfig(struct qemud_driver *driver, - const char *file, - const char *path, - const char *xml, - const char *autostartLink) { - struct qemud_vm_def *def; - struct qemud_vm *vm; - - if (!(def = qemudParseVMDef(NULL, driver, xml, file))) { - virErrorPtr err = virGetLastError(); - qemudLog(QEMUD_WARN, _("Error parsing QEMU guest config '%s' : %s"), - path, (err ? err->message : - _("BUG: unknown error - please report it\n"))); - return NULL; - } - - if (!virFileMatchesNameSuffix(file, def->name, ".xml")) { - qemudLog(QEMUD_WARN, - _("QEMU guest config filename '%s'" - " does not match guest name '%s'"), - path, def->name); - qemudFreeVMDef(def); - return NULL; - } - - if (!(vm = qemudAssignVMDef(NULL, driver, def))) { - qemudLog(QEMUD_WARN, - _("Failed to load QEMU guest config '%s': out of memory"), - path); - qemudFreeVMDef(def); - return NULL; - } - - strncpy(vm->configFile, path, PATH_MAX); - vm->configFile[PATH_MAX-1] = '\0'; - - strncpy(vm->autostartLink, autostartLink, PATH_MAX); - vm->autostartLink[PATH_MAX-1] = '\0'; - - vm->autostart = virFileLinkPointsTo(vm->autostartLink, vm->configFile); - - return vm; -} - -static -int qemudScanConfigDir(struct qemud_driver *driver, - const char *configDir, - const char *autostartDir) { - DIR *dir; - struct dirent *entry; - - if (!(dir = opendir(configDir))) { - if (errno == ENOENT) - return 0; - qemudLog(QEMUD_ERR, _("Failed to open dir '%s': %s"), - configDir, strerror(errno)); - return -1; - } - - while ((entry = readdir(dir))) { - char *xml; - char path[PATH_MAX]; - char autostartLink[PATH_MAX]; - - if (entry->d_name[0] == '.') - continue; - - if (!virFileHasSuffix(entry->d_name, ".xml")) - continue; - - if (virFileBuildPath(configDir, entry->d_name, NULL, path, PATH_MAX) < 0) { - qemudLog(QEMUD_WARN, _("Config filename '%s/%s' is too long"), - configDir, entry->d_name); - continue; - } - - if (virFileBuildPath(autostartDir, entry->d_name, NULL, - autostartLink, PATH_MAX) < 0) { - qemudLog(QEMUD_WARN, _("Autostart link path '%s/%s' is too long"), - autostartDir, entry->d_name); - continue; - } - - if (virFileReadAll(path, QEMUD_MAX_XML_LEN, &xml) < 0) - continue; - - qemudLoadConfig(driver, entry->d_name, path, xml, autostartLink); - - VIR_FREE(xml); - } - - closedir(dir); - - return 0; -} - -/* Scan for all guest and network config files */ -int qemudScanConfigs(struct qemud_driver *driver) { - if (qemudScanConfigDir(driver, driver->configDir, driver->autostartDir) < 0) - return -1; - - return 0; -} - -static int qemudGenerateXMLChar(virBufferPtr buf, - const struct qemud_vm_chr_def *dev, - const char *type) -{ - const char *const types[] = { - "null", - "vc", - "pty", - "dev", - "file", - "pipe", - "stdio", - "udp", - "tcp", - "unix" - }; - verify_true(ARRAY_CARDINALITY(types) == QEMUD_CHR_SRC_TYPE_LAST); - - /* Compat with legacy <console tty='/dev/pts/5'/> syntax */ - if (STREQ(type, "console") && - dev->srcType == QEMUD_CHR_SRC_TYPE_PTY && - dev->srcData.file.path[0] != '\0') { - virBufferVSprintf(buf, " <%s type='%s' tty='%s'>\n", - type, types[dev->srcType], - dev->srcData.file.path); - } else { - virBufferVSprintf(buf, " <%s type='%s'>\n", - type, types[dev->srcType]); - } - - switch (dev->srcType) { - case QEMUD_CHR_SRC_TYPE_NULL: - case QEMUD_CHR_SRC_TYPE_VC: - case QEMUD_CHR_SRC_TYPE_STDIO: - /* nada */ - break; - - case QEMUD_CHR_SRC_TYPE_PTY: - case QEMUD_CHR_SRC_TYPE_DEV: - case QEMUD_CHR_SRC_TYPE_FILE: - case QEMUD_CHR_SRC_TYPE_PIPE: - if (dev->srcType != QEMUD_CHR_SRC_TYPE_PTY || - dev->srcData.file.path[0]) { - virBufferVSprintf(buf, " <source path='%s'/>\n", - dev->srcData.file.path); - } - break; - - case QEMUD_CHR_SRC_TYPE_UDP: - if (dev->srcData.udp.bindService[0] != '\0' && - dev->srcData.udp.bindHost[0] != '\0') { - virBufferVSprintf(buf, " <source mode='bind' host='%s' service='%s'/>\n", - dev->srcData.udp.bindHost, - dev->srcData.udp.bindService); - } else if (dev->srcData.udp.bindHost[0] !='\0') { - virBufferVSprintf(buf, " <source mode='bind' host='%s'/>\n", - dev->srcData.udp.bindHost); - } else if (dev->srcData.udp.bindService[0] != '\0') { - virBufferVSprintf(buf, " <source mode='bind' service='%s'/>\n", - dev->srcData.udp.bindService); - } - - if (dev->srcData.udp.connectService[0] != '\0' && - dev->srcData.udp.connectHost[0] != '\0') { - virBufferVSprintf(buf, " <source mode='connect' host='%s' service='%s'/>\n", - dev->srcData.udp.connectHost, - dev->srcData.udp.connectService); - } else if (dev->srcData.udp.connectHost[0] != '\0') { - virBufferVSprintf(buf, " <source mode='connect' host='%s'/>\n", - dev->srcData.udp.connectHost); - } else if (dev->srcData.udp.connectService[0] != '\0') { - virBufferVSprintf(buf, " <source mode='connect' service='%s'/>\n", - dev->srcData.udp.connectService); - } - break; - - case QEMUD_CHR_SRC_TYPE_TCP: - virBufferVSprintf(buf, " <source mode='%s' host='%s' service='%s'/>\n", - dev->srcData.tcp.listen ? "bind" : "connect", - dev->srcData.tcp.host, - dev->srcData.tcp.service); - virBufferVSprintf(buf, " <protocol type='%s'/>\n", - dev->srcData.tcp.protocol == QEMUD_CHR_SRC_TCP_PROTOCOL_TELNET - ? "telnet" : "raw"); - break; - - case QEMUD_CHR_SRC_TYPE_UNIX: - virBufferVSprintf(buf, " <source mode='%s' path='%s'/>\n", - dev->srcData.nix.listen ? "bind" : "connect", - dev->srcData.nix.path); - break; - } - - virBufferVSprintf(buf, " <target port='%d'/>\n", - dev->dstPort); - - virBufferVSprintf(buf, " </%s>\n", - type); - - return 0; -} - - -/* Generate an XML document describing the guest's configuration */ -char *qemudGenerateXML(virConnectPtr conn, - struct qemud_driver *driver ATTRIBUTE_UNUSED, - struct qemud_vm *vm, - struct qemud_vm_def *def, - int live) { - virBuffer buf = VIR_BUFFER_INITIALIZER; - unsigned char *uuid; - char uuidstr[VIR_UUID_STRING_BUFLEN]; - const struct qemud_vm_disk_def *disk; - const struct qemud_vm_net_def *net; - const struct qemud_vm_input_def *input; - const struct qemud_vm_sound_def *sound; - const struct qemud_vm_chr_def *chr; - const char *type = NULL, *tmp; - int n, allones = 1; - - if (!(type = qemudVirtTypeToString(def->virtType))) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("unexpected domain type %d"), def->virtType); - goto cleanup; - } - - if (qemudIsActiveVM(vm) && live) - virBufferVSprintf(&buf, "<domain type='%s' id='%d'>\n", type, vm->id); - else - virBufferVSprintf(&buf, "<domain type='%s'>\n", type); - - virBufferVSprintf(&buf, " <name>%s</name>\n", def->name); - - uuid = def->uuid; - virUUIDFormat(uuid, uuidstr); - virBufferVSprintf(&buf, " <uuid>%s</uuid>\n", uuidstr); - - virBufferVSprintf(&buf, " <memory>%lu</memory>\n", def->maxmem); - virBufferVSprintf(&buf, " <currentMemory>%lu</currentMemory>\n", def->memory); - - for (n = 0 ; n < QEMUD_CPUMASK_LEN ; n++) - if (def->cpumask[n] != 1) - allones = 0; - - if (allones) { - virBufferVSprintf(&buf, " <vcpu>%d</vcpu>\n", def->vcpus); - } else { - char *cpumask = NULL; - if ((cpumask = virSaveCpuSet(conn, def->cpumask, QEMUD_CPUMASK_LEN)) == NULL) { - qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, - "%s", _("allocating cpu mask")); - goto cleanup; - } - virBufferVSprintf(&buf, " <vcpu cpuset='%s'>%d</vcpu>\n", cpumask, def->vcpus); - VIR_FREE(cpumask); - } - - if (def->os.bootloader[0]) - virBufferVSprintf(&buf, " <bootloader>%s</bootloader>\n", def->os.bootloader); - virBufferAddLit(&buf, " <os>\n"); - - if (def->virtType == QEMUD_VIRT_QEMU) - virBufferVSprintf(&buf, " <type arch='%s' machine='%s'>%s</type>\n", - def->os.arch, def->os.machine, def->os.type); - else - virBufferVSprintf(&buf, " <type>%s</type>\n", def->os.type); - - if (!def->os.bootloader[0]) { - if (def->os.kernel[0]) - virBufferVSprintf(&buf, " <kernel>%s</kernel>\n", def->os.kernel); - if (def->os.initrd[0]) - virBufferVSprintf(&buf, " <initrd>%s</initrd>\n", def->os.initrd); - if (def->os.cmdline[0]) - virBufferVSprintf(&buf, " <cmdline>%s</cmdline>\n", def->os.cmdline); - - for (n = 0 ; n < def->os.nBootDevs ; n++) { - const char *boottype = "hd"; - switch (def->os.bootDevs[n]) { - case QEMUD_BOOT_FLOPPY: - boottype = "fd"; - break; - case QEMUD_BOOT_DISK: - boottype = "hd"; - break; - case QEMUD_BOOT_CDROM: - boottype = "cdrom"; - break; - case QEMUD_BOOT_NET: - boottype = "network"; - break; - } - virBufferVSprintf(&buf, " <boot dev='%s'/>\n", boottype); - } - } - - virBufferAddLit(&buf, " </os>\n"); - - if (def->features & QEMUD_FEATURE_ACPI) { - virBufferAddLit(&buf, " <features>\n"); - virBufferAddLit(&buf, " <acpi/>\n"); - virBufferAddLit(&buf, " </features>\n"); - } - - virBufferVSprintf(&buf, " <clock offset='%s'/>\n", def->localtime ? "localtime" : "utc"); - - virBufferAddLit(&buf, " <on_poweroff>destroy</on_poweroff>\n"); - if (def->noReboot) - virBufferAddLit(&buf, " <on_reboot>destroy</on_reboot>\n"); - else - virBufferAddLit(&buf, " <on_reboot>restart</on_reboot>\n"); - - virBufferAddLit(&buf, " <on_crash>destroy</on_crash>\n"); - virBufferAddLit(&buf, " <devices>\n"); - - virBufferVSprintf(&buf, " <emulator>%s</emulator>\n", def->os.binary); - - disk = def->disks; - while (disk) { - const char *types[] = { - "block", - "file", - }; - const char *typeAttrs[] = { - "dev", - "file", - }; - const char *devices[] = { - "disk", - "cdrom", - "floppy", - }; - virBufferVSprintf(&buf, " <disk type='%s' device='%s'>\n", - types[disk->type], devices[disk->device]); - - if (disk->src[0]) - virBufferVSprintf(&buf, " <source %s='%s'/>\n", - typeAttrs[disk->type], disk->src); - - virBufferVSprintf(&buf, " <target dev='%s' bus='%s'/>\n", - disk->dst, qemudBusIdToName(disk->bus, 0)); - - if (disk->readonly) - virBufferAddLit(&buf, " <readonly/>\n"); - - virBufferAddLit(&buf, " </disk>\n"); - - disk = disk->next; - } - - net = def->nets; - while (net) { - const char *types[] = { - "user", - "ethernet", - "server", - "client", - "mcast", - "network", - "bridge", - }; - virBufferVSprintf(&buf, " <interface type='%s'>\n", - types[net->type]); - - virBufferVSprintf(&buf, " <mac address='%02x:%02x:%02x:%02x:%02x:%02x'/>\n", - net->mac[0], net->mac[1], net->mac[2], - net->mac[3], net->mac[4], net->mac[5]); - - switch (net->type) { - case QEMUD_NET_NETWORK: - virBufferVSprintf(&buf, " <source network='%s'/>\n", net->dst.network.name); - - if (net->dst.network.ifname[0] != '\0') - virBufferVSprintf(&buf, " <target dev='%s'/>\n", net->dst.network.ifname); - break; - - case QEMUD_NET_ETHERNET: - if (net->dst.ethernet.ifname[0] != '\0') - virBufferVSprintf(&buf, " <target dev='%s'/>\n", net->dst.ethernet.ifname); - if (net->dst.ethernet.script[0] != '\0') - virBufferVSprintf(&buf, " <script path='%s'/>\n", net->dst.ethernet.script); - break; - - case QEMUD_NET_BRIDGE: - virBufferVSprintf(&buf, " <source bridge='%s'/>\n", net->dst.bridge.brname); - if (net->dst.bridge.ifname[0] != '\0') - virBufferVSprintf(&buf, " <target dev='%s'/>\n", net->dst.bridge.ifname); - break; - - case QEMUD_NET_SERVER: - case QEMUD_NET_CLIENT: - case QEMUD_NET_MCAST: - if (net->dst.socket.address[0] != '\0') - virBufferVSprintf(&buf, " <source address='%s' port='%d'/>\n", - net->dst.socket.address, net->dst.socket.port); - else - virBufferVSprintf(&buf, " <source port='%d'/>\n", - net->dst.socket.port); - } - - if (net->model && net->model[0] != '\0') { - virBufferVSprintf(&buf, " <model type='%s'/>\n", - net->model); - } - - virBufferAddLit(&buf, " </interface>\n"); - - net = net->next; - } - - chr = def->serials; - while (chr) { - if (qemudGenerateXMLChar(&buf, chr, "serial") < 0) - goto no_memory; - - chr = chr->next; - } - - chr = def->parallels; - while (chr) { - if (qemudGenerateXMLChar(&buf, chr, "parallel") < 0) - goto no_memory; - - chr = chr->next; - } - - /* First serial device is the primary console */ - if (def->nserials > 0 && - qemudGenerateXMLChar(&buf, def->serials, "console") < 0) - goto no_memory; - - input = def->inputs; - while (input) { - if (input->bus == QEMU_INPUT_BUS_USB) - virBufferVSprintf(&buf, " <input type='%s' bus='usb'/>\n", - input->type == QEMU_INPUT_TYPE_MOUSE ? "mouse" : "tablet"); - input = input->next; - } - /* If graphics is enable, add implicit mouse */ - if (def->graphicsType != QEMUD_GRAPHICS_NONE) - virBufferVSprintf(&buf, " <input type='mouse' bus='%s'/>\n", - STREQ(def->os.type, "hvm") ? "ps2" : "xen"); - - switch (def->graphicsType) { - case QEMUD_GRAPHICS_VNC: - virBufferAddLit(&buf, " <graphics type='vnc'"); - - if (def->vncPort) - virBufferVSprintf(&buf, " port='%d'", - qemudIsActiveVM(vm) && live ? def->vncActivePort : def->vncPort); - - if (def->vncListen[0]) - virBufferVSprintf(&buf, " listen='%s'", - def->vncListen); - - if (def->keymap) - virBufferVSprintf(&buf, " keymap='%s'", - def->keymap); - - virBufferAddLit(&buf, "/>\n"); - break; - - case QEMUD_GRAPHICS_SDL: - virBufferAddLit(&buf, " <graphics type='sdl'/>\n"); - break; - - case QEMUD_GRAPHICS_NONE: - default: - break; - } - - sound = def->sounds; - while(sound) { - const char *model = qemudSoundModelToString(sound->model); - if (!model) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - "%s", _("invalid sound model")); - goto cleanup; - } - virBufferVSprintf(&buf, " <sound model='%s'/>\n", model); - sound = sound->next; - } - - virBufferAddLit(&buf, " </devices>\n"); - virBufferAddLit(&buf, "</domain>\n"); - - if (virBufferError(&buf)) - goto no_memory; - - return virBufferContentAndReset(&buf); - - no_memory: - qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, - "%s", _("failed to generate XML: out of memory")); - cleanup: - tmp = virBufferContentAndReset(&buf); - VIR_FREE(tmp); - return NULL; -} - - -int qemudDeleteConfig(virConnectPtr conn, - struct qemud_driver *driver ATTRIBUTE_UNUSED, - const char *configFile, - const char *name) { - if (!configFile[0]) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("no config file for %s"), name); - return -1; - } - - if (unlink(configFile) < 0) { - qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, - _("cannot remove config for %s"), name); - return -1; - } - - return 0; -} - #endif /* WITH_QEMU */ diff -r 8b6e9b6cbaa5 src/qemu_conf.h --- a/src/qemu_conf.h Tue Jul 08 15:26:54 2008 +0100 +++ b/src/qemu_conf.h Tue Jul 08 15:29:16 2008 +0100 @@ -29,217 +29,15 @@ #ifdef WITH_QEMU #include "internal.h" +#include "iptables.h" #include "bridge.h" -#include "iptables.h" #include "capabilities.h" #include "network_conf.h" -#include <netinet/in.h> -#include <sched.h> +#include "domain_conf.h" #define qemudDebug(fmt, ...) do {} while(0) -/* Different types of QEMU acceleration possible */ -enum qemud_vm_virt_type { - QEMUD_VIRT_QEMU, - QEMUD_VIRT_KQEMU, - QEMUD_VIRT_KVM, -}; - -/* Two types of disk backends */ -enum qemud_vm_disk_type { - QEMUD_DISK_BLOCK, - QEMUD_DISK_FILE -}; - -/* Three types of disk frontend */ -enum qemud_vm_disk_device { - QEMUD_DISK_DISK, - QEMUD_DISK_CDROM, - QEMUD_DISK_FLOPPY, -}; - -enum qemud_vm_disk_bus { - QEMUD_DISK_BUS_IDE, - QEMUD_DISK_BUS_FDC, - QEMUD_DISK_BUS_SCSI, - QEMUD_DISK_BUS_VIRTIO, - QEMUD_DISK_BUS_XEN, - - QEMUD_DISK_BUS_LAST -}; - -/* Stores the virtual disk configuration */ -struct qemud_vm_disk_def { - int type; - int device; - int bus; - char src[PATH_MAX]; - char dst[NAME_MAX]; - int readonly; - - struct qemud_vm_disk_def *next; -}; - -#define QEMUD_MAC_ADDRESS_LEN 6 -#define QEMUD_MODEL_MAX_LEN 10 -#define QEMUD_OS_TYPE_MAX_LEN 10 -#define QEMUD_OS_ARCH_MAX_LEN 10 -#define QEMUD_OS_MACHINE_MAX_LEN 10 - -/* 5 different types of networking config */ -enum qemud_vm_net_type { - QEMUD_NET_USER, - QEMUD_NET_ETHERNET, - QEMUD_NET_SERVER, - QEMUD_NET_CLIENT, - QEMUD_NET_MCAST, - QEMUD_NET_NETWORK, - QEMUD_NET_BRIDGE, -}; - -#define QEMUD_MAX_NAME_LEN 50 -#define QEMUD_MAX_XML_LEN 4096 -#define QEMUD_MAX_ERROR_LEN 1024 #define QEMUD_CPUMASK_LEN CPU_SETSIZE - -/* Stores the virtual network interface configuration */ -struct qemud_vm_net_def { - int type; - unsigned char mac[QEMUD_MAC_ADDRESS_LEN]; - char model[QEMUD_MODEL_MAX_LEN]; - union { - struct { - char ifname[BR_IFNAME_MAXLEN]; - char script[PATH_MAX]; - } ethernet; - struct { - char address[BR_INET_ADDR_MAXLEN]; - int port; - } socket; /* any of NET_CLIENT or NET_SERVER or NET_MCAST */ - struct { - char name[QEMUD_MAX_NAME_LEN]; - char ifname[BR_IFNAME_MAXLEN]; - } network; - struct { - char brname[BR_IFNAME_MAXLEN]; - char ifname[BR_IFNAME_MAXLEN]; - } bridge; - } dst; - - struct qemud_vm_net_def *next; -}; - -enum qemu_vm_chr_dst_type { - QEMUD_CHR_SRC_TYPE_NULL, - QEMUD_CHR_SRC_TYPE_VC, - QEMUD_CHR_SRC_TYPE_PTY, - QEMUD_CHR_SRC_TYPE_DEV, - QEMUD_CHR_SRC_TYPE_FILE, - QEMUD_CHR_SRC_TYPE_PIPE, - QEMUD_CHR_SRC_TYPE_STDIO, - QEMUD_CHR_SRC_TYPE_UDP, - QEMUD_CHR_SRC_TYPE_TCP, - QEMUD_CHR_SRC_TYPE_UNIX, - - QEMUD_CHR_SRC_TYPE_LAST, -}; - -enum { - QEMUD_CHR_SRC_TCP_PROTOCOL_RAW, - QEMUD_CHR_SRC_TCP_PROTOCOL_TELNET, -}; - -struct qemud_vm_chr_def { - int dstPort; - - int srcType; - union { - struct { - char path[PATH_MAX]; - } file; /* pty, file, pipe, or device */ - struct { - char host[BR_INET_ADDR_MAXLEN]; - char service[BR_INET_ADDR_MAXLEN]; - int listen; - int protocol; - } tcp; - struct { - char bindHost[BR_INET_ADDR_MAXLEN]; - char bindService[BR_INET_ADDR_MAXLEN]; - char connectHost[BR_INET_ADDR_MAXLEN]; - char connectService[BR_INET_ADDR_MAXLEN]; - } udp; - struct { - char path[PATH_MAX]; - int listen; - } nix; - } srcData; - - struct qemud_vm_chr_def *next; -}; - -enum qemu_vm_input_type { - QEMU_INPUT_TYPE_MOUSE, - QEMU_INPUT_TYPE_TABLET, -}; - -enum qemu_vm_input_bus { - QEMU_INPUT_BUS_PS2, - QEMU_INPUT_BUS_USB, - QEMU_INPUT_BUS_XEN, -}; - -struct qemud_vm_input_def { - int type; - int bus; - struct qemud_vm_input_def *next; -}; - -enum qemu_vm_sound_model { - QEMU_SOUND_NONE = 0, - QEMU_SOUND_SB16, - QEMU_SOUND_ES1370, - QEMU_SOUND_PCSPK, -}; - -struct qemud_vm_sound_def { - int model; - struct qemud_vm_sound_def *next; -}; - -/* Flags for the 'type' field in next struct */ -enum qemud_vm_device_type { - QEMUD_DEVICE_DISK, - QEMUD_DEVICE_NET, - QEMUD_DEVICE_INPUT, - QEMUD_DEVICE_SOUND, -}; - -struct qemud_vm_device_def { - int type; - union { - struct qemud_vm_disk_def disk; - struct qemud_vm_net_def net; - struct qemud_vm_input_def input; - struct qemud_vm_sound_def sound; - } data; -}; - -#define QEMUD_MAX_BOOT_DEVS 4 - -/* 3 possible boot devices */ -enum qemud_vm_boot_order { - QEMUD_BOOT_FLOPPY, - QEMUD_BOOT_CDROM, - QEMUD_BOOT_DISK, - QEMUD_BOOT_NET, -}; -/* 3 possible graphics console modes */ -enum qemud_vm_graphics_type { - QEMUD_GRAPHICS_NONE, - QEMUD_GRAPHICS_SDL, - QEMUD_GRAPHICS_VNC, -}; /* Internal flags to keep track of qemu command line capabilities */ enum qemud_cmd_flags { @@ -251,107 +49,12 @@ QEMUD_CMD_FLAG_NAME = (1 << 5), }; - -enum qemud_vm_features { - QEMUD_FEATURE_ACPI = 1, -}; - -/* Operating system configuration data & machine / arch */ -struct qemud_vm_os_def { - char type[QEMUD_OS_TYPE_MAX_LEN]; - char arch[QEMUD_OS_ARCH_MAX_LEN]; - char machine[QEMUD_OS_MACHINE_MAX_LEN]; - int nBootDevs; - int bootDevs[QEMUD_MAX_BOOT_DEVS]; - char kernel[PATH_MAX]; - char initrd[PATH_MAX]; - char cmdline[PATH_MAX]; - char binary[PATH_MAX]; - char bootloader[PATH_MAX]; -}; - -/* Guest VM main configuration */ -struct qemud_vm_def { - int virtType; - unsigned char uuid[VIR_UUID_BUFLEN]; - char name[QEMUD_MAX_NAME_LEN]; - - unsigned long memory; - unsigned long maxmem; - int vcpus; - char cpumask[QEMUD_CPUMASK_LEN]; - - int noReboot; - - struct qemud_vm_os_def os; - - int localtime; - int features; - int graphicsType; - int vncPort; - int vncActivePort; - char vncListen[BR_INET_ADDR_MAXLEN]; - char *keymap; - - unsigned int ndisks; - struct qemud_vm_disk_def *disks; - - unsigned int nnets; - struct qemud_vm_net_def *nets; - - unsigned int ninputs; - struct qemud_vm_input_def *inputs; - - unsigned int nsounds; - struct qemud_vm_sound_def *sounds; - - unsigned int nserials; - struct qemud_vm_chr_def *serials; - - unsigned int nparallels; - struct qemud_vm_chr_def *parallels; -}; - -/* Guest VM runtime state */ -struct qemud_vm { - int stdin; - int stdout; - int stderr; - int monitor; - int logfile; - int pid; - int id; - int state; - - int *tapfds; - int ntapfds; - - int nvcpupids; - int *vcpupids; - - int qemuVersion; - int qemuCmdFlags; /* values from enum qemud_cmd_flags */ - - char configFile[PATH_MAX]; - char autostartLink[PATH_MAX]; - char migrateFrom[PATH_MAX]; - - struct qemud_vm_def *def; /* The current definition */ - struct qemud_vm_def *newDef; /* New definition to activate at shutdown */ - - unsigned int autostart : 1; - - struct qemud_vm *next; -}; - /* Main driver state */ struct qemud_driver { int qemuVersion; - int nactivevms; - int ninactivevms; - struct qemud_vm *vms; int nextvmid; + virDomainObjPtr domains; virNetworkObjPtr networks; brControl *brctl; @@ -360,21 +63,15 @@ char *autostartDir; char *networkConfigDir; char *networkAutostartDir; - char logDir[PATH_MAX]; + char *logDir; unsigned int vncTLS : 1; unsigned int vncTLSx509verify : 1; char *vncTLSx509certdir; - char vncListen[BR_INET_ADDR_MAXLEN]; + char *vncListen; virCapsPtr caps; }; - -static inline int -qemudIsActiveVM(const struct qemud_vm *vm) -{ - return vm->id != -1; -} void qemudReportError(virConnectPtr conn, virDomainPtr dom, @@ -386,57 +83,22 @@ int qemudLoadDriverConfig(struct qemud_driver *driver, const char *filename); -struct qemud_vm *qemudFindVMByID(const struct qemud_driver *driver, - int id); -struct qemud_vm *qemudFindVMByUUID(const struct qemud_driver *driver, - const unsigned char *uuid); -struct qemud_vm *qemudFindVMByName(const struct qemud_driver *driver, - const char *name); - virCapsPtr qemudCapsInit (void); int qemudExtractVersion (virConnectPtr conn, struct qemud_driver *driver); +int qemudExtractVersionInfo (const char *qemu, + int *version, + int *flags); + int qemudBuildCommandLine (virConnectPtr conn, struct qemud_driver *driver, - struct qemud_vm *vm, - char ***argv); - -int qemudScanConfigs (struct qemud_driver *driver); -int qemudDeleteConfig (virConnectPtr conn, - struct qemud_driver *driver, - const char *configFile, - const char *name); - -void qemudFreeVMDef (struct qemud_vm_def *vm); -void qemudFreeVM (struct qemud_vm *vm); - -struct qemud_vm * - qemudAssignVMDef (virConnectPtr conn, - struct qemud_driver *driver, - struct qemud_vm_def *def); -void qemudRemoveInactiveVM (struct qemud_driver *driver, - struct qemud_vm *vm); - -struct qemud_vm_device_def * - qemudParseVMDeviceDef (virConnectPtr conn, - const struct qemud_vm_def *def, - const char *xmlStr); - -struct qemud_vm_def * - qemudParseVMDef (virConnectPtr conn, - struct qemud_driver *driver, - const char *xmlStr, - const char *displayName); -int qemudSaveVMDef (virConnectPtr conn, - struct qemud_driver *driver, - struct qemud_vm *vm, - struct qemud_vm_def *def); -char * qemudGenerateXML (virConnectPtr conn, - struct qemud_driver *driver, - struct qemud_vm *vm, - struct qemud_vm_def *def, - int live); + virDomainObjPtr dom, + int qemuCmdFlags, + char ***argv, + int **tapfds, + int *ntapfds, + const char *migrateFrom); const char *qemudVirtTypeToString (int type); diff -r 8b6e9b6cbaa5 src/qemu_driver.c --- a/src/qemu_driver.c Tue Jul 08 15:26:54 2008 +0100 +++ b/src/qemu_driver.c Tue Jul 08 15:29:16 2008 +0100 @@ -44,7 +44,6 @@ #include <pwd.h> #include <stdio.h> #include <sys/wait.h> -#include <libxml/uri.h> #if HAVE_NUMACTL #include <numa.h> @@ -54,13 +53,12 @@ #include <sched.h> #endif -#include "internal.h" +#include "qemu_driver.h" +#include "qemu_conf.h" #include "c-ctype.h" #include "event.h" #include "buf.h" #include "util.h" -#include "qemu_driver.h" -#include "qemu_conf.h" #include "nodeinfo.h" #include "stats_linux.h" #include "capabilities.h" @@ -112,11 +110,12 @@ static void qemudDispatchVMEvent(int fd, int events, void *opaque); static int qemudStartVMDaemon(virConnectPtr conn, struct qemud_driver *driver, - struct qemud_vm *vm); + virDomainObjPtr vm, + const char *migrateFrom); static void qemudShutdownVMDaemon(virConnectPtr conn, struct qemud_driver *driver, - struct qemud_vm *vm); + virDomainObjPtr vm); static int qemudStartNetworkDaemon(virConnectPtr conn, struct qemud_driver *driver, @@ -128,7 +127,7 @@ static int qemudDomainGetMaxVcpus(virDomainPtr dom); static int qemudMonitorCommand (const struct qemud_driver *driver, - const struct qemud_vm *vm, + const virDomainObjPtr vm, const char *cmd, char **reply); @@ -138,7 +137,7 @@ static void qemudAutostartConfigs(struct qemud_driver *driver) { virNetworkObjPtr network; - struct qemud_vm *vm; + virDomainObjPtr vm; network = driver->networks; while (network != NULL) { @@ -155,13 +154,13 @@ network = next; } - vm = driver->vms; + vm = driver->domains; while (vm != NULL) { - struct qemud_vm *next = vm->next; + virDomainObjPtr next = vm->next; if (vm->autostart && - !qemudIsActiveVM(vm) && - qemudStartVMDaemon(NULL, driver, vm) < 0) { + !virDomainIsActive(vm) && + qemudStartVMDaemon(NULL, driver, vm, NULL) < 0) { virErrorPtr err = virGetLastError(); qemudLog(QEMUD_ERR, _("Failed to autostart VM '%s': %s"), vm->def->name, err->message); @@ -191,8 +190,9 @@ qemu_driver->nextvmid = 1; if (!uid) { - if (snprintf(qemu_driver->logDir, PATH_MAX, "%s/log/libvirt/qemu", LOCAL_STATE_DIR) >= PATH_MAX) - goto snprintf_error; + if (asprintf(&qemu_driver->logDir, + "%s/log/libvirt/qemu", LOCAL_STATE_DIR) == -1) + goto out_of_memory; if ((base = strdup (SYSCONF_DIR "/libvirt")) == NULL) goto out_of_memory; @@ -203,8 +203,9 @@ goto out_of_memory; } - if (snprintf(qemu_driver->logDir, PATH_MAX, "%s/.libvirt/qemu/log", pw->pw_dir) >= PATH_MAX) - goto snprintf_error; + if (asprintf(&qemu_driver->logDir, + "%s/.libvirt/qemu/log", pw->pw_dir) == -1) + goto out_of_memory; if (asprintf (&base, "%s/.libvirt", pw->pw_dir) == -1) { qemudLog (QEMUD_ERR, @@ -243,7 +244,11 @@ return -1; } - if (qemudScanConfigs(qemu_driver) < 0) { + if (virDomainLoadAllConfigs(NULL, + qemu_driver->caps, + &qemu_driver->domains, + qemu_driver->configDir, + qemu_driver->autostartDir) < 0) { qemudShutdown(); return -1; } @@ -257,11 +262,6 @@ qemudAutostartConfigs(qemu_driver); return 0; - - snprintf_error: - qemudLog(QEMUD_ERR, - "%s", _("Resulting path to long for buffer in qemudInitPaths()")); - return -1; out_of_memory: qemudLog (QEMUD_ERR, @@ -279,7 +279,12 @@ */ static int qemudReload(void) { - qemudScanConfigs(qemu_driver); + virDomainLoadAllConfigs(NULL, + qemu_driver->caps, + &qemu_driver->domains, + qemu_driver->configDir, + qemu_driver->autostartDir); + virNetworkLoadAllConfigs(NULL, &qemu_driver->networks, qemu_driver->networkConfigDir, @@ -306,15 +311,19 @@ */ static int qemudActive(void) { + virDomainObjPtr dom = qemu_driver->domains; virNetworkObjPtr net = qemu_driver->networks; + while (dom) { + if (virDomainIsActive(dom)) + return 1; + dom = dom->next; + } + while (net) { - if (net->active) + if (virNetworkIsActive(net)) return 1; net = net->next; } - - if (qemu_driver->nactivevms) - return 1; /* Otherwise we're happy to deal with a shutdown */ return 0; @@ -327,7 +336,7 @@ */ static int qemudShutdown(void) { - struct qemud_vm *vm; + virDomainObjPtr vm; virNetworkObjPtr network; if (!qemu_driver) @@ -336,26 +345,25 @@ virCapabilitiesFree(qemu_driver->caps); /* shutdown active VMs */ - vm = qemu_driver->vms; + vm = qemu_driver->domains; while (vm) { - struct qemud_vm *next = vm->next; - if (qemudIsActiveVM(vm)) + virDomainObjPtr next = vm->next; + if (virDomainIsActive(vm)) qemudShutdownVMDaemon(NULL, qemu_driver, vm); - if (!vm->configFile[0]) - qemudRemoveInactiveVM(qemu_driver, vm); + if (!vm->configFile) + virDomainRemoveInactive(&qemu_driver->domains, + vm); vm = next; } /* free inactive VMs */ - vm = qemu_driver->vms; + vm = qemu_driver->domains; while (vm) { - struct qemud_vm *next = vm->next; - qemudFreeVM(vm); + virDomainObjPtr next = vm->next; + virDomainObjFree(vm); vm = next; } - qemu_driver->vms = NULL; - qemu_driver->nactivevms = 0; - qemu_driver->ninactivevms = 0; + qemu_driver->domains = NULL; /* shutdown active networks */ network = qemu_driver->networks; @@ -375,6 +383,7 @@ } qemu_driver->networks = NULL; + VIR_FREE(qemu_driver->logDir); VIR_FREE(qemu_driver->configDir); VIR_FREE(qemu_driver->autostartDir); VIR_FREE(qemu_driver->networkConfigDir); @@ -395,14 +404,14 @@ /* Return -1 for error, 1 to continue reading and 0 for success */ typedef int qemudHandlerMonitorOutput(virConnectPtr conn, struct qemud_driver *driver, - struct qemud_vm *vm, + virDomainObjPtr vm, const char *output, int fd); static int qemudReadMonitorOutput(virConnectPtr conn, struct qemud_driver *driver, - struct qemud_vm *vm, + virDomainObjPtr vm, int fd, char *buf, int buflen, @@ -475,7 +484,7 @@ static int qemudCheckMonitorPrompt(virConnectPtr conn ATTRIBUTE_UNUSED, struct qemud_driver *driver ATTRIBUTE_UNUSED, - struct qemud_vm *vm, + virDomainObjPtr vm, const char *output, int fd) { @@ -489,7 +498,7 @@ static int qemudOpenMonitor(virConnectPtr conn, struct qemud_driver *driver, - struct qemud_vm *vm, + virDomainObjPtr vm, const char *monitor) { int monfd; char buf[1024]; @@ -566,13 +575,13 @@ static int qemudFindCharDevicePTYs(virConnectPtr conn, struct qemud_driver *driver, - struct qemud_vm *vm, + virDomainObjPtr vm, const char *output, int fd ATTRIBUTE_UNUSED) { char monitor[PATH_MAX]; size_t offset = 0; - struct qemud_vm_chr_def *chr; + virDomainChrDefPtr chr; /* The order in which QEMU prints out the PTY paths is the order in which it procsses its monitor, serial @@ -586,10 +595,10 @@ /* then the serial devices */ chr = vm->def->serials; while (chr) { - if (chr->srcType == QEMUD_CHR_SRC_TYPE_PTY) { + if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) { if (qemudExtractMonitorPath(output, &offset, - chr->srcData.file.path, - sizeof(chr->srcData.file.path)) < 0) + chr->data.file.path, + sizeof(chr->data.file.path)) < 0) return 1; /* keep reading */ } chr = chr->next; @@ -598,10 +607,10 @@ /* and finally the parallel devices */ chr = vm->def->parallels; while (chr) { - if (chr->srcType == QEMUD_CHR_SRC_TYPE_PTY) { + if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) { if (qemudExtractMonitorPath(output, &offset, - chr->srcData.file.path, - sizeof(chr->srcData.file.path)) < 0) + chr->data.file.path, + sizeof(chr->data.file.path)) < 0) return 1; /* keep reading */ } chr = chr->next; @@ -613,7 +622,7 @@ static int qemudWaitForMonitor(virConnectPtr conn, struct qemud_driver *driver, - struct qemud_vm *vm) { + virDomainObjPtr vm) { char buf[1024]; /* Plenty of space to get startup greeting */ int ret = qemudReadMonitorOutput(conn, driver, vm, vm->stderr, @@ -634,14 +643,14 @@ static int qemudDetectVcpuPIDs(virConnectPtr conn, struct qemud_driver *driver, - struct qemud_vm *vm) { + virDomainObjPtr vm) { char *qemucpus = NULL; char *line; int lastVcpu = -1; /* Only KVM has seperate threads for CPUs, others just use main QEMU process for CPU */ - if (vm->def->virtType != QEMUD_VIRT_KVM) + if (vm->def->virtType != VIR_DOMAIN_VIRT_KVM) vm->nvcpupids = 1; else vm->nvcpupids = vm->def->vcpus; @@ -652,7 +661,7 @@ return -1; } - if (vm->def->virtType != QEMUD_VIRT_KVM) { + if (vm->def->virtType != VIR_DOMAIN_VIRT_KVM) { vm->vcpupids[0] = vm->pid; return 0; } @@ -734,7 +743,7 @@ static int qemudInitCpus(virConnectPtr conn, struct qemud_driver *driver, - struct qemud_vm *vm) { + virDomainObjPtr vm) { char *info = NULL; #if HAVE_SCHED_GETAFFINITY cpu_set_t mask; @@ -815,28 +824,33 @@ static int qemudStartVMDaemon(virConnectPtr conn, struct qemud_driver *driver, - struct qemud_vm *vm) { + virDomainObjPtr vm, + const char *migrateFrom) { char **argv = NULL, **tmp; int i, ret; char logfile[PATH_MAX]; struct stat sb; + int *tapfds = NULL; + int ntapfds = 0; + int qemuCmdFlags; - if (qemudIsActiveVM(vm)) { + if (virDomainIsActive(vm)) { qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, "%s", _("VM is already active")); return -1; } - if (vm->def->vncPort < 0) { + if (vm->def->graphics && + vm->def->graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC && + vm->def->graphics->data.vnc.autoport) { int port = qemudNextFreeVNCPort(driver); if (port < 0) { qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, "%s", _("Unable to find an unused VNC port")); return -1; } - vm->def->vncActivePort = port; - } else - vm->def->vncActivePort = vm->def->vncPort; + vm->def->graphics->data.vnc.port = port; + } if ((strlen(driver->logDir) + /* path */ 1 + /* Separator */ @@ -880,16 +894,26 @@ * Technically we could catch the exec() failure, but that's * in a sub-process so its hard to feed back a useful error */ - if (stat(vm->def->os.binary, &sb) < 0) { + if (stat(vm->def->emulator, &sb) < 0) { qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("Cannot find QEMU binary %s: %s"), - vm->def->os.binary, + vm->def->emulator, strerror(errno)); return -1; } + if (qemudExtractVersionInfo(vm->def->emulator, + NULL, + &qemuCmdFlags) < 0) { + qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, + _("Cannot determine QEMU argv syntax %s"), + vm->def->emulator); + return -1; + } - if (qemudBuildCommandLine(conn, driver, vm, &argv) < 0) { + if (qemudBuildCommandLine(conn, driver, vm, + qemuCmdFlags, &argv, + &tapfds, &ntapfds, migrateFrom) < 0) { close(vm->logfile); vm->logfile = -1; return -1; @@ -912,24 +936,19 @@ ret = virExecNonBlock(conn, argv, &vm->pid, vm->stdin, &vm->stdout, &vm->stderr); if (ret == 0) { - vm->id = driver->nextvmid++; - vm->state = vm->migrateFrom[0] ? VIR_DOMAIN_PAUSED : VIR_DOMAIN_RUNNING; - - driver->ninactivevms--; - driver->nactivevms++; + vm->def->id = driver->nextvmid++; + vm->state = migrateFrom ? VIR_DOMAIN_PAUSED : VIR_DOMAIN_RUNNING; } for (i = 0 ; argv[i] ; i++) VIR_FREE(argv[i]); VIR_FREE(argv); - if (vm->tapfds) { - for (i = 0; vm->tapfds[i] != -1; i++) { - close(vm->tapfds[i]); - vm->tapfds[i] = -1; + if (tapfds) { + for (i = 0 ; i < ntapfds ; i++) { + close(tapfds[i]); } - VIR_FREE(vm->tapfds); - vm->ntapfds = 0; + VIR_FREE(tapfds); } if (ret == 0) { @@ -953,7 +972,7 @@ } static int qemudVMData(struct qemud_driver *driver ATTRIBUTE_UNUSED, - struct qemud_vm *vm, int fd) { + virDomainObjPtr vm, int fd) { char buf[4096]; if (vm->pid < 0) return 0; @@ -982,8 +1001,8 @@ static void qemudShutdownVMDaemon(virConnectPtr conn ATTRIBUTE_UNUSED, - struct qemud_driver *driver, struct qemud_vm *vm) { - if (!qemudIsActiveVM(vm)) + struct qemud_driver *driver, virDomainObjPtr vm) { + if (!virDomainIsActive(vm)) return; qemudLog(QEMUD_INFO, _("Shutting down VM '%s'"), vm->def->name); @@ -1017,35 +1036,35 @@ } vm->pid = -1; - vm->id = -1; + vm->def->id = -1; vm->state = VIR_DOMAIN_SHUTOFF; VIR_FREE(vm->vcpupids); vm->nvcpupids = 0; if (vm->newDef) { - qemudFreeVMDef(vm->def); + virDomainDefFree(vm->def); vm->def = vm->newDef; + vm->def->id = -1; vm->newDef = NULL; } - - driver->nactivevms--; - driver->ninactivevms++; } -static int qemudDispatchVMLog(struct qemud_driver *driver, struct qemud_vm *vm, int fd) { +static int qemudDispatchVMLog(struct qemud_driver *driver, virDomainObjPtr vm, int fd) { if (qemudVMData(driver, vm, fd) < 0) { qemudShutdownVMDaemon(NULL, driver, vm); - if (!vm->configFile[0]) - qemudRemoveInactiveVM(driver, vm); + if (!vm->configFile) + virDomainRemoveInactive(&driver->domains, + vm); } return 0; } -static int qemudDispatchVMFailure(struct qemud_driver *driver, struct qemud_vm *vm, +static int qemudDispatchVMFailure(struct qemud_driver *driver, virDomainObjPtr vm, int fd ATTRIBUTE_UNUSED) { qemudShutdownVMDaemon(NULL, driver, vm); - if (!vm->configFile[0]) - qemudRemoveInactiveVM(driver, vm); + if (!vm->configFile) + virDomainRemoveInactive(&driver->domains, + vm); return 0; } @@ -1575,10 +1594,10 @@ static void qemudDispatchVMEvent(int fd, int events, void *opaque) { struct qemud_driver *driver = (struct qemud_driver *)opaque; - struct qemud_vm *vm = driver->vms; + virDomainObjPtr vm = driver->domains; while (vm) { - if (qemudIsActiveVM(vm) && + if (virDomainIsActive(vm) && (vm->stdout == fd || vm->stderr == fd)) break; @@ -1597,7 +1616,7 @@ static int qemudMonitorCommand (const struct qemud_driver *driver ATTRIBUTE_UNUSED, - const struct qemud_vm *vm, + const virDomainObjPtr vm, const char *cmd, char **reply) { int size = 0; @@ -1867,9 +1886,9 @@ static virDomainPtr qemudDomainLookupByID(virConnectPtr conn, - int id) { + int id) { struct qemud_driver *driver = (struct qemud_driver *)conn->privateData; - struct qemud_vm *vm = qemudFindVMByID(driver, id); + virDomainObjPtr vm = virDomainFindByID(driver->domains, id); virDomainPtr dom; if (!vm) { @@ -1878,13 +1897,13 @@ } dom = virGetDomain(conn, vm->def->name, vm->def->uuid); - if (dom) dom->id = vm->id; + if (dom) dom->id = vm->def->id; return dom; } static virDomainPtr qemudDomainLookupByUUID(virConnectPtr conn, - const unsigned char *uuid) { + const unsigned char *uuid) { struct qemud_driver *driver = (struct qemud_driver *)conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID(driver, uuid); + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, uuid); virDomainPtr dom; if (!vm) { @@ -1893,13 +1912,13 @@ } dom = virGetDomain(conn, vm->def->name, vm->def->uuid); - if (dom) dom->id = vm->id; + if (dom) dom->id = vm->def->id; return dom; } static virDomainPtr qemudDomainLookupByName(virConnectPtr conn, - const char *name) { + const char *name) { struct qemud_driver *driver = (struct qemud_driver *)conn->privateData; - struct qemud_vm *vm = qemudFindVMByName(driver, name); + virDomainObjPtr vm = virDomainFindByName(driver->domains, name); virDomainPtr dom; if (!vm) { @@ -1908,7 +1927,7 @@ } dom = virGetDomain(conn, vm->def->name, vm->def->uuid); - if (dom) dom->id = vm->id; + if (dom) dom->id = vm->def->id; return dom; } @@ -1945,11 +1964,11 @@ static int qemudListDomains(virConnectPtr conn, int *ids, int nids) { struct qemud_driver *driver = (struct qemud_driver *)conn->privateData; - struct qemud_vm *vm = driver->vms; + virDomainObjPtr vm = driver->domains; int got = 0; while (vm && got < nids) { - if (qemudIsActiveVM(vm)) { - ids[got] = vm->id; + if (virDomainIsActive(vm)) { + ids[got] = vm->def->id; got++; } vm = vm->next; @@ -1958,30 +1977,40 @@ } static int qemudNumDomains(virConnectPtr conn) { struct qemud_driver *driver = (struct qemud_driver *)conn->privateData; - return driver->nactivevms; + int n = 0; + virDomainObjPtr dom = driver->domains; + while (dom) { + if (virDomainIsActive(dom)) + n++; + dom = dom->next; + } + return n; } static virDomainPtr qemudDomainCreate(virConnectPtr conn, const char *xml, unsigned int flags ATTRIBUTE_UNUSED) { - struct qemud_vm_def *def; - struct qemud_vm *vm; + virDomainDefPtr def; + virDomainObjPtr vm; virDomainPtr dom; struct qemud_driver *driver = (struct qemud_driver *)conn->privateData; - if (!(def = qemudParseVMDef(conn, driver, xml, NULL))) + if (!(def = virDomainDefParseString(conn, driver->caps, xml))) return NULL; - if (!(vm = qemudAssignVMDef(conn, driver, def))) { - qemudFreeVMDef(def); + if (!(vm = virDomainAssignDef(conn, + &driver->domains, + def))) { + virDomainDefFree(def); return NULL; } - if (qemudStartVMDaemon(conn, driver, vm) < 0) { - qemudRemoveInactiveVM(driver, vm); + if (qemudStartVMDaemon(conn, driver, vm, NULL) < 0) { + virDomainRemoveInactive(&driver->domains, + vm); return NULL; } dom = virGetDomain(conn, vm->def->name, vm->def->uuid); - if (dom) dom->id = vm->id; + if (dom) dom->id = vm->def->id; return dom; } @@ -1989,12 +2018,12 @@ static int qemudDomainSuspend(virDomainPtr dom) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; char *info; - struct qemud_vm *vm = qemudFindVMByID(driver, dom->id); + virDomainObjPtr vm = virDomainFindByID(driver->domains, dom->id); if (!vm) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, _("no domain with matching id %d"), dom->id); return -1; } - if (!qemudIsActiveVM(vm)) { + if (!virDomainIsActive(vm)) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "%s", _("domain is not running")); return -1; @@ -2017,13 +2046,13 @@ static int qemudDomainResume(virDomainPtr dom) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; char *info; - struct qemud_vm *vm = qemudFindVMByID(driver, dom->id); + virDomainObjPtr vm = virDomainFindByID(driver->domains, dom->id); if (!vm) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, _("no domain with matching id %d"), dom->id); return -1; } - if (!qemudIsActiveVM(vm)) { + if (!virDomainIsActive(vm)) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "%s", _("domain is not running")); return -1; @@ -2044,7 +2073,7 @@ static int qemudDomainShutdown(virDomainPtr dom) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByID(driver, dom->id); + virDomainObjPtr vm = virDomainFindByID(driver->domains, dom->id); char* info; if (!vm) { @@ -2065,7 +2094,7 @@ static int qemudDomainDestroy(virDomainPtr dom) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByID(driver, dom->id); + virDomainObjPtr vm = virDomainFindByID(driver->domains, dom->id); if (!vm) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, @@ -2074,8 +2103,9 @@ } qemudShutdownVMDaemon(dom->conn, driver, vm); - if (!vm->configFile[0]) - qemudRemoveInactiveVM(driver, vm); + if (!vm->configFile) + virDomainRemoveInactive(&driver->domains, + vm); return 0; } @@ -2083,7 +2113,7 @@ static char *qemudDomainGetOSType(virDomainPtr dom) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid); + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid); char *type; if (!vm) { @@ -2103,7 +2133,7 @@ /* Returns max memory in kb, 0 if error */ static unsigned long qemudDomainGetMaxMemory(virDomainPtr dom) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid); + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid); if (!vm) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, @@ -2116,7 +2146,7 @@ static int qemudDomainSetMaxMemory(virDomainPtr dom, unsigned long newmax) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid); + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid); if (!vm) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, @@ -2136,7 +2166,7 @@ static int qemudDomainSetMemory(virDomainPtr dom, unsigned long newmem) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid); + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid); if (!vm) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, @@ -2144,7 +2174,7 @@ return -1; } - if (qemudIsActiveVM(vm)) { + if (virDomainIsActive(vm)) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT, "%s", _("cannot set memory of an active domain")); return -1; @@ -2161,9 +2191,9 @@ } static int qemudDomainGetInfo(virDomainPtr dom, - virDomainInfoPtr info) { + virDomainInfoPtr info) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid); + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid); if (!vm) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, "%s", _("no domain with matching uuid")); @@ -2172,7 +2202,7 @@ info->state = vm->state; - if (!qemudIsActiveVM(vm)) { + if (!virDomainIsActive(vm)) { info->cpuTime = 0; } else { if (qemudGetProcessInfo(&(info->cpuTime), vm->pid) < 0) { @@ -2284,7 +2314,7 @@ static int qemudDomainSave(virDomainPtr dom, const char *path) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByID(driver, dom->id); + virDomainObjPtr vm = virDomainFindByID(driver->domains, dom->id); char *command, *info; int fd; char *safe_path; @@ -2301,7 +2331,7 @@ return -1; } - if (!qemudIsActiveVM(vm)) { + if (!virDomainIsActive(vm)) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "%s", _("domain is not running")); return -1; @@ -2318,7 +2348,7 @@ } /* Get XML for the domain */ - xml = qemudGenerateXML(dom->conn, driver, vm, vm->def, 0); + xml = virDomainDefFormat(dom->conn, vm->def, VIR_DOMAIN_XML_SECURE); if (!xml) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "%s", _("failed to get domain xml")); @@ -2382,8 +2412,9 @@ /* Shut it down */ qemudShutdownVMDaemon(dom->conn, driver, vm); - if (!vm->configFile[0]) - qemudRemoveInactiveVM(driver, vm); + if (!vm->configFile) + virDomainRemoveInactive(&driver->domains, + vm); return 0; } @@ -2391,7 +2422,7 @@ static int qemudDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus) { const struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid); + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid); int max; if (!vm) { @@ -2400,7 +2431,7 @@ return -1; } - if (qemudIsActiveVM(vm)) { + if (virDomainIsActive(vm)) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT, "%s", _("cannot change vcpu count of an active domain")); return -1; @@ -2431,12 +2462,12 @@ unsigned char *cpumap, int maplen) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid); + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid); cpu_set_t mask; int i, maxcpu; virNodeInfo nodeinfo; - if (!qemudIsActiveVM(vm)) { + if (!virDomainIsActive(vm)) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG, "%s",_("cannot pin vcpus on an inactive domain")); return -1; @@ -2484,11 +2515,11 @@ unsigned char *cpumaps, int maplen) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid); + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid); virNodeInfo nodeinfo; int i, v, maxcpu; - if (!qemudIsActiveVM(vm)) { + if (!virDomainIsActive(vm)) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG, "%s",_("cannot pin vcpus on an inactive domain")); return -1; @@ -2549,7 +2580,7 @@ static int qemudDomainGetMaxVcpus(virDomainPtr dom) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid); + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid); const char *type; int ret; @@ -2559,7 +2590,7 @@ return -1; } - if (!(type = qemudVirtTypeToString(vm->def->virtType))) { + if (!(type = virDomainVirtTypeToString(vm->def->virtType))) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR, _("unknown virt type in domain definition '%d'"), vm->def->virtType); @@ -2577,8 +2608,8 @@ static int qemudDomainRestore(virConnectPtr conn, const char *path) { struct qemud_driver *driver = (struct qemud_driver *)conn->privateData; - struct qemud_vm_def *def; - struct qemud_vm *vm; + virDomainDefPtr def; + virDomainObjPtr vm; int fd; int ret; char *xml; @@ -2629,7 +2660,7 @@ } /* Create a domain from this XML */ - if (!(def = qemudParseVMDef(conn, driver, xml, NULL))) { + if (!(def = virDomainDefParseString(conn, driver->caps, xml))) { qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED, "%s", _("failed to parse XML")); close(fd); @@ -2639,35 +2670,37 @@ VIR_FREE(xml); /* Ensure the name and UUID don't already exist in an active VM */ - vm = qemudFindVMByUUID(driver, def->uuid); - if (!vm) vm = qemudFindVMByName(driver, def->name); - if (vm && qemudIsActiveVM(vm)) { + vm = virDomainFindByUUID(driver->domains, def->uuid); + if (!vm) + vm = virDomainFindByName(driver->domains, def->name); + if (vm && virDomainIsActive(vm)) { qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED, _("domain is already active as '%s'"), vm->def->name); close(fd); return -1; } - if (!(vm = qemudAssignVMDef(conn, driver, def))) { + if (!(vm = virDomainAssignDef(conn, + &driver->domains, + def))) { qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED, "%s", _("failed to assign new VM")); - qemudFreeVMDef(def); + virDomainDefFree(def); close(fd); return -1; } /* Set the migration source and start it up. */ - snprintf(vm->migrateFrom, sizeof(vm->migrateFrom), "stdio"); vm->stdin = fd; - ret = qemudStartVMDaemon(conn, driver, vm); + ret = qemudStartVMDaemon(conn, driver, vm, "stdio"); close(fd); - vm->migrateFrom[0] = '\0'; vm->stdin = -1; if (ret < 0) { qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED, "%s", _("failed to start VM")); - if (!vm->configFile[0]) - qemudRemoveInactiveVM(driver, vm); + if (!vm->configFile) + virDomainRemoveInactive(&driver->domains, + vm); return -1; } @@ -2688,26 +2721,29 @@ static char *qemudDomainDumpXML(virDomainPtr dom, - int flags ATTRIBUTE_UNUSED) { + int flags ATTRIBUTE_UNUSED) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid); + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid); if (!vm) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, "%s", _("no domain with matching uuid")); return NULL; } - return qemudGenerateXML(dom->conn, driver, vm, vm->def, 1); + return virDomainDefFormat(dom->conn, + (flags & VIR_DOMAIN_XML_INACTIVE) && vm->newDef ? + vm->newDef : vm->def, + flags); } static int qemudListDefinedDomains(virConnectPtr conn, char **const names, int nnames) { struct qemud_driver *driver = (struct qemud_driver *)conn->privateData; - struct qemud_vm *vm = driver->vms; + virDomainObjPtr vm = driver->domains; int got = 0, i; while (vm && got < nnames) { - if (!qemudIsActiveVM(vm)) { + if (!virDomainIsActive(vm)) { if (!(names[got] = strdup(vm->def->name))) { qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, "%s", _("failed to allocate space for VM name string")); @@ -2728,13 +2764,20 @@ static int qemudNumDefinedDomains(virConnectPtr conn) { struct qemud_driver *driver = (struct qemud_driver *)conn->privateData; - return driver->ninactivevms; + int n = 0; + virDomainObjPtr dom = driver->domains; + while (dom) { + if (!virDomainIsActive(dom)) + n++; + dom = dom->next; + } + return 0; } static int qemudDomainStart(virDomainPtr dom) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid); + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid); if (!vm) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, @@ -2742,37 +2785,43 @@ return -1; } - return qemudStartVMDaemon(dom->conn, driver, vm); + return qemudStartVMDaemon(dom->conn, driver, vm, NULL); } static virDomainPtr qemudDomainDefine(virConnectPtr conn, const char *xml) { struct qemud_driver *driver = (struct qemud_driver *)conn->privateData; - struct qemud_vm_def *def; - struct qemud_vm *vm; + virDomainDefPtr def; + virDomainObjPtr vm; virDomainPtr dom; - if (!(def = qemudParseVMDef(conn, driver, xml, NULL))) + if (!(def = virDomainDefParseString(conn, driver->caps, xml))) return NULL; - if (!(vm = qemudAssignVMDef(conn, driver, def))) { - qemudFreeVMDef(def); + if (!(vm = virDomainAssignDef(conn, + &driver->domains, + def))) { + virDomainDefFree(def); return NULL; } - if (qemudSaveVMDef(conn, driver, vm, def) < 0) { - qemudRemoveInactiveVM(driver, vm); + if (virDomainSaveConfig(conn, + driver->configDir, + driver->autostartDir, + vm) < 0) { + virDomainRemoveInactive(&driver->domains, + vm); return NULL; } dom = virGetDomain(conn, vm->def->name, vm->def->uuid); - if (dom) dom->id = vm->id; + if (dom) dom->id = vm->def->id; return dom; } static int qemudDomainUndefine(virDomainPtr dom) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid); + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid); if (!vm) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, @@ -2780,35 +2829,29 @@ return -1; } - if (qemudIsActiveVM(vm)) { + if (virDomainIsActive(vm)) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR, "%s", _("cannot delete active domain")); return -1; } - if (qemudDeleteConfig(dom->conn, driver, vm->configFile, vm->def->name) < 0) + if (virDomainDeleteConfig(dom->conn, vm) < 0) return -1; - if (unlink(vm->autostartLink) < 0 && errno != ENOENT && errno != ENOTDIR) - qemudLog(QEMUD_WARN, _("Failed to delete autostart link '%s': %s"), - vm->autostartLink, strerror(errno)); - - vm->configFile[0] = '\0'; - vm->autostartLink[0] = '\0'; - - qemudRemoveInactiveVM(driver, vm); + virDomainRemoveInactive(&driver->domains, + vm); return 0; } static int qemudDomainChangeCDROM(virDomainPtr dom, - struct qemud_vm *vm, - struct qemud_vm_disk_def *olddisk, - struct qemud_vm_disk_def *newdisk) { + virDomainObjPtr vm, + virDomainDiskDefPtr olddisk, + virDomainDiskDefPtr newdisk) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; char *cmd, *reply, *safe_path; - if (newdisk->src[0]) { + if (newdisk->src) { safe_path = qemudEscapeMonitorArg(newdisk->src); if (!safe_path) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, @@ -2848,9 +2891,9 @@ static int qemudDomainAttachDevice(virDomainPtr dom, const char *xml) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid); - struct qemud_vm_device_def *dev; - struct qemud_vm_disk_def *disk; + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid); + virDomainDeviceDefPtr dev; + virDomainDiskDefPtr disk; if (!vm) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, @@ -2858,18 +2901,19 @@ return -1; } - if (!qemudIsActiveVM(vm)) { + if (!virDomainIsActive(vm)) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR, "%s", _("cannot attach device on inactive domain")); return -1; } - dev = qemudParseVMDeviceDef(dom->conn, vm->def, xml); + dev = virDomainDeviceDefParse(dom->conn, vm->def, xml); if (dev == NULL) { return -1; } - if (dev->type != QEMUD_DEVICE_DISK || dev->data.disk.device != QEMUD_DISK_CDROM) { + if (dev->type != VIR_DOMAIN_DEVICE_DISK || + dev->data.disk->device != VIR_DOMAIN_DISK_DEVICE_CDROM) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT, "%s", _("only CDROM disk devices can be attached")); VIR_FREE(dev); @@ -2878,8 +2922,8 @@ disk = vm->def->disks; while (disk) { - if (disk->device == QEMUD_DISK_CDROM && - STREQ(disk->dst, dev->data.disk.dst)) + if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM && + STREQ(disk->dst, dev->data.disk->dst)) break; disk = disk->next; } @@ -2891,7 +2935,7 @@ return -1; } - if (qemudDomainChangeCDROM(dom, vm, disk, &dev->data.disk) < 0) { + if (qemudDomainChangeCDROM(dom, vm, disk, dev->data.disk) < 0) { VIR_FREE(dev); return -1; } @@ -2903,7 +2947,7 @@ static int qemudDomainGetAutostart(virDomainPtr dom, int *autostart) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid); + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid); if (!vm) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, @@ -2919,7 +2963,7 @@ static int qemudDomainSetAutostart(virDomainPtr dom, int autostart) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid); + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid); if (!vm) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, @@ -2977,14 +3021,14 @@ const char *p, *eol; char qemu_dev_name[32]; size_t len; - const struct qemud_vm *vm = qemudFindVMByID(driver, dom->id); + const virDomainObjPtr vm = virDomainFindByID(driver->domains, dom->id); if (!vm) { qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, _("no domain with matching id %d"), dom->id); return -1; } - if (!qemudIsActiveVM (vm)) { + if (!virDomainIsActive (vm)) { qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "%s", _("domain is not running")); return -1; @@ -3111,8 +3155,8 @@ { #ifdef __linux__ struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByID (driver, dom->id); - struct qemud_vm_net_def *net; + virDomainObjPtr vm = virDomainFindByID(driver->domains, dom->id); + virDomainNetDefPtr net; if (!vm) { qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, @@ -3120,7 +3164,7 @@ return -1; } - if (!qemudIsActiveVM(vm)) { + if (!virDomainIsActive(vm)) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "%s", _("domain is not running")); return -1; @@ -3134,20 +3178,8 @@ /* Check the path is one of the domain's network interfaces. */ for (net = vm->def->nets; net; net = net->next) { - switch (net->type) { - case QEMUD_NET_NETWORK: - if (STREQ (net->dst.network.ifname, path)) - goto ok; - break; - case QEMUD_NET_ETHERNET: - if (STREQ (net->dst.ethernet.ifname, path)) - goto ok; - break; - case QEMUD_NET_BRIDGE: - if (STREQ (net->dst.bridge.ifname, path)) - goto ok; - break; - } + if (STREQ (net->ifname, path)) + goto ok; } qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG, @@ -3171,8 +3203,8 @@ unsigned int flags ATTRIBUTE_UNUSED) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByUUID (driver, dom->uuid); - int i; + virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid); + virDomainDiskDefPtr disk; int fd, ret = -1; if (!vm) { @@ -3188,8 +3220,9 @@ } /* Check the path belongs to this domain. */ - for (i = 0; i < vm->def->ndisks; ++i) { - if (STREQ (vm->def->disks[i].src, path)) goto found; + for (disk = vm->def->disks ; disk != NULL ; disk = disk->next) { + if (disk->src != NULL && + STREQ (disk->src, path)) goto found; } qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG, _("invalid path")); @@ -3228,7 +3261,7 @@ unsigned int flags) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; - struct qemud_vm *vm = qemudFindVMByID (driver, dom->id); + virDomainObjPtr vm = virDomainFindByID(driver->domains, dom->id); char cmd[256], *info; char tmp[] = TEMPDIR "/qemu.mem.XXXXXX"; int fd = -1, ret = -1; @@ -3245,7 +3278,7 @@ return -1; } - if (!qemudIsActiveVM(vm)) { + if (!virDomainIsActive(vm)) { qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "%s", _("domain is not running")); return -1; @@ -3401,7 +3434,7 @@ } static virNetworkPtr qemudNetworkCreate(virConnectPtr conn, const char *xml) { - struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData; + struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData; virNetworkDefPtr def; virNetworkObjPtr network; virNetworkPtr net; diff -r 8b6e9b6cbaa5 tests/qemuxml2argvdata/qemuxml2argv-bootloader.xml --- a/tests/qemuxml2argvdata/qemuxml2argv-bootloader.xml Tue Jul 08 15:26:54 2008 +0100 +++ b/tests/qemuxml2argvdata/qemuxml2argv-bootloader.xml Tue Jul 08 15:29:16 2008 +0100 @@ -6,7 +6,7 @@ <vcpu>1</vcpu> <bootloader>/usr/bin/pygrub</bootloader> <os> - <type>xen</type> + <type arch='x86_64' machine='xenner'>xen</type> </os> <clock offset='utc'/> <on_poweroff>destroy</on_poweroff> diff -r 8b6e9b6cbaa5 tests/qemuxml2argvdata/qemuxml2argv-graphics-vnc.xml --- a/tests/qemuxml2argvdata/qemuxml2argv-graphics-vnc.xml Tue Jul 08 15:26:54 2008 +0100 +++ b/tests/qemuxml2argvdata/qemuxml2argv-graphics-vnc.xml Tue Jul 08 15:29:16 2008 +0100 @@ -19,6 +19,6 @@ <target dev='hda' bus='ide'/> </disk> <input type='mouse' bus='ps2'/> - <graphics type='vnc' port='5903' listen='127.0.0.1'/> + <graphics type='vnc' port='5903' autoport='no' listen='127.0.0.1'/> </devices> </domain> diff -r 8b6e9b6cbaa5 tests/qemuxml2argvdata/qemuxml2argv-input-xen.args --- a/tests/qemuxml2argvdata/qemuxml2argv-input-xen.args Tue Jul 08 15:26:54 2008 +0100 +++ b/tests/qemuxml2argvdata/qemuxml2argv-input-xen.args Tue Jul 08 15:29:16 2008 +0100 @@ -1,1 +1,1 @@ -/usr/bin/xenner -S -M xenner -m 214 -smp 1 -monitor pty -no-acpi -boot c -hda /dev/HostVG/QEMUGuest1 -net none -serial none -parallel none -usb -vnc :-5901 \ No newline at end of file +/usr/bin/xenner -S -M xenner -m 214 -smp 1 -monitor pty -no-acpi -boot c -hda /dev/HostVG/QEMUGuest1 -net none -serial none -parallel none -usb -vnc 127.0.0.1:3 \ No newline at end of file diff -r 8b6e9b6cbaa5 tests/qemuxml2argvdata/qemuxml2argv-input-xen.xml --- a/tests/qemuxml2argvdata/qemuxml2argv-input-xen.xml Tue Jul 08 15:26:54 2008 +0100 +++ b/tests/qemuxml2argvdata/qemuxml2argv-input-xen.xml Tue Jul 08 15:29:16 2008 +0100 @@ -5,7 +5,7 @@ <currentMemory>219200</currentMemory> <vcpu>1</vcpu> <os> - <type>xen</type> + <type arch='x86_64' machine='xenner'>xen</type> <boot dev='hd'/> </os> <clock offset='utc'/> @@ -19,6 +19,6 @@ <target dev='hda' bus='ide'/> </disk> <input type='mouse' bus='xen'/> - <graphics type='vnc' port='-1'/> + <graphics type='vnc' port='5903' autoport='no' listen='127.0.0.1'/> </devices> </domain> diff -r 8b6e9b6cbaa5 tests/qemuxml2argvdata/qemuxml2argv-sound.xml --- a/tests/qemuxml2argvdata/qemuxml2argv-sound.xml Tue Jul 08 15:26:54 2008 +0100 +++ b/tests/qemuxml2argvdata/qemuxml2argv-sound.xml Tue Jul 08 15:29:16 2008 +0100 @@ -16,15 +16,10 @@ <emulator>/usr/bin/qemu</emulator> <disk type='block' device='disk'> <source dev='/dev/HostVG/QEMUGuest1'/> - <target dev='hda'/> + <target dev='hda' bus='ide'/> </disk> <sound model='pcspk'/> - <sound model='pcspk'/> <sound model='es1370'/> - <sound model='pcspk'/> - <sound model='sb16'/> - <sound model='es1370'/> - <sound model='pcspk'/> <sound model='sb16'/> </devices> </domain> diff -r 8b6e9b6cbaa5 tests/qemuxml2argvtest.c --- a/tests/qemuxml2argvtest.c Tue Jul 08 15:26:54 2008 +0100 +++ b/tests/qemuxml2argvtest.c Tue Jul 08 15:29:16 2008 +0100 @@ -23,39 +23,33 @@ #define MAX_FILE 4096 static int testCompareXMLToArgvFiles(const char *xml, const char *cmd, int extraFlags) { - char xmlData[MAX_FILE]; char argvData[MAX_FILE]; - char *xmlPtr = &(xmlData[0]); char *expectargv = &(argvData[0]); char *actualargv = NULL; char **argv = NULL; char **tmp = NULL; - int ret = -1, len; - struct qemud_vm_def *vmdef = NULL; - struct qemud_vm vm; - - if (virtTestLoadFile(xml, &xmlPtr, MAX_FILE) < 0) - goto fail; + int ret = -1, len, flags; + virDomainDefPtr vmdef = NULL; + virDomainObj vm; if (virtTestLoadFile(cmd, &expectargv, MAX_FILE) < 0) goto fail; - if (!(vmdef = qemudParseVMDef(NULL, &driver, xmlData, "test"))) + if (!(vmdef = virDomainDefParseFile(NULL, driver.caps, xml))) goto fail; memset(&vm, 0, sizeof vm); vm.def = vmdef; + vm.def->id = -1; vm.pid = -1; - vm.id = -1; - vm.qemuVersion = 0 * 1000 * 100 + (8 * 1000) + 1; - vm.qemuCmdFlags = QEMUD_CMD_FLAG_VNC_COLON | - QEMUD_CMD_FLAG_NO_REBOOT; - vm.qemuCmdFlags |= extraFlags; - vm.migrateFrom[0] = '\0'; - vmdef->vncActivePort = vmdef->vncPort; + flags = QEMUD_CMD_FLAG_VNC_COLON | + QEMUD_CMD_FLAG_NO_REBOOT | + extraFlags; - if (qemudBuildCommandLine(NULL, &driver, &vm, &argv) < 0) + if (qemudBuildCommandLine(NULL, &driver, + &vm, flags, &argv, + NULL, NULL, NULL) < 0) goto fail; tmp = argv; @@ -92,8 +86,7 @@ } free(argv); } - if (vmdef) - qemudFreeVMDef(vmdef); + virDomainDefFree(vmdef); return ret; } diff -r 8b6e9b6cbaa5 tests/qemuxml2xmltest.c --- a/tests/qemuxml2xmltest.c Tue Jul 08 15:26:54 2008 +0100 +++ b/tests/qemuxml2xmltest.c Tue Jul 08 15:29:16 2008 +0100 @@ -27,25 +27,15 @@ char *xmlPtr = &(xmlData[0]); char *actual = NULL; int ret = -1; - struct qemud_vm_def *vmdef = NULL; - struct qemud_vm vm; + virDomainDefPtr vmdef = NULL; if (virtTestLoadFile(xml, &xmlPtr, MAX_FILE) < 0) goto fail; - if (!(vmdef = qemudParseVMDef(NULL, &driver, xmlData, "test"))) + if (!(vmdef = virDomainDefParseString(NULL, driver.caps, xmlData))) goto fail; - vm.def = vmdef; - vm.pid = -1; - vm.id = -1; - vm.qemuVersion = 0 * 1000 * 100 + (8 * 1000) + 1; - vm.qemuCmdFlags = QEMUD_CMD_FLAG_VNC_COLON | - QEMUD_CMD_FLAG_NO_REBOOT; - - vmdef->vncActivePort = vmdef->vncPort; - - if (!(actual = qemudGenerateXML(NULL, &driver, &vm, vmdef, 0))) + if (!(actual = virDomainDefFormat(NULL, vmdef, 0))) goto fail; if (STRNEQ(xmlData, actual)) { @@ -57,8 +47,7 @@ fail: free(actual); - if (vmdef) - qemudFreeVMDef(vmdef); + virDomainDefFree(vmdef); return ret; } @@ -115,6 +104,7 @@ DO_TEST("misc-no-reboot"); DO_TEST("net-user"); DO_TEST("net-virtio"); + DO_TEST("sound"); DO_TEST("serial-vc"); DO_TEST("serial-pty"); -- |: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :| |: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|

On Tue, Jul 08, 2008 at 05:38:41PM +0100, Daniel P. Berrange wrote: okay Hum we really ought to use the new macros here and raise the error, no ? [...] Hum, the logic in virDomainDefFormat() seems rather different, I hope this won't lead to too many regressions. [...] so you raise the memory issue here, i guess that's fine too. okay, the same logic is actually carried that way, fine. [...] checking that the call returned 6 could be a good idea. [...] hum, VIR_STRDUP macro and a hook into VIR_ALLOC would be good, at least it would allow to regression tests on out of memory situations in that part which is checked as part of make check. But that can be done separately of course. Hum, I guess the automatic addition of <clock offset='utc'/> , <input type='mouse' bus='xen'/> and <graphics type='vnc' port='-1' autoport='yes'/> aren't a problem, i.e. not changing the default behaviour, but it seems we are loosing the <script path='vif-bridge'/> information on the way out, and that looks significant, right ? pygrub probanly means a linux boot right, but lost script again. [...] We create currentMemory from memory value or I'm mistaken ? [...] hum hard to decript, but here it seems we lost the value of the sound emulation, going from 'idontexit,es1370,all' to 'all' this looks fishy Same thing soundhw went from 'sb16,es1370,idontexist,es1370more' to 'sb16,es1370', it's a bit weird Okidoc, so it looks basically okay to me except the loss of the network bridging script and the strange thing happening to sound hardware descriptions. Maybe the simplest is to commit and fix the 2 issues after with a second patch because rereviewing the whole is while just a few lines need fixing sounds inefficient :-) Excellent thing that we have all those regression tests on the SXP<->XML data !!! thanks ! Daniel -- Red Hat Virtualization group http://redhat.com/virtualization/ Daniel Veillard | virtualization library http://libvirt.org/ veillard(a)redhat.com | libxml GNOME XML XSLT toolkit http://xmlsoft.org/ http://veillard.com/ | Rpmfind RPM search engine http://rpmfind.net/