11:18 a.m.
The next two patches port the QEMU driver over to the new APIs. This is
a fairly straightforward exercise since the new APIs are derived from
the currenty QEMU driver impl. Aside from a mass deletion of code the rest
is mostly just renaming function calls / objects. The test suite passes
and I can start VMs, so this is reasonably ready to commit (depends on
the earlier patches of course)
Daniel
--
|: 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 :|
11:23 a.m.
New subject: [libvirt] PATCH: 1/2: port QEMU driver to new network APIs
This patch ports the networking part of the QEMU driver to the new network
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
Really this networking code doesn't belong in the QEMU driver at all. We
really ought to move it out into a network_driver.c file as its nothing
todo with QEMU at all. Its just here from historical days when it had to
run inside the libvirt_qemud daemon.
bridge.c | 63 ++----
bridge.h | 4
qemu_conf.c | 547 ++++------------------------------------------------------
qemu_conf.h | 94 ---------
qemu_driver.c | 368 ++++++++++++++++++++-------------------
5 files changed, 265 insertions(+), 811 deletions(-)
Regards,
Daniel
diff -r 5c483067f7a0 src/bridge.c
--- a/src/bridge.c Sun Jun 22 17:56:04 2008 -0400
+++ b/src/bridge.c Sun Jun 22 17:58:48 2008 -0400
@@ -116,60 +116,41 @@
/**
* brAddBridge:
* @ctl: bridge control pointer
- * @nameOrFmt: the bridge name (or name template)
- * @name: pointer to @maxlen bytes to store the bridge name
- * @maxlen: size of @name array
+ * @name: the bridge name
*
- * This function register a new bridge, @nameOrFmt can be either
- * a fixed name or a name template with '%d' for dynamic name allocation.
- * in either case the final name for the bridge will be stored in @name.
+ * This function register a new bridge
*
* Returns 0 in case of success or an errno code in case of failure.
*/
#ifdef SIOCBRADDBR
int
brAddBridge(brControl *ctl,
- const char *nameOrFmt,
- char *name,
- int maxlen)
+ char **name)
{
- int id, subst;
-
- if (!ctl || !ctl->fd || !nameOrFmt || !name)
+ if (!ctl || !ctl->fd || !name)
return EINVAL;
- if (maxlen >= BR_IFNAME_MAXLEN)
- maxlen = BR_IFNAME_MAXLEN;
+ if (*name) {
+ if (ioctl(ctl->fd, SIOCBRADDBR, *name) == 0)
+ return 0;
+ } else {
+ int id = 0;
+ do {
+ char try[50];
- subst = id = 0;
+ snprintf(try, sizeof(try), "virbr%d", id);
- if (strstr(nameOrFmt, "%d"))
- subst = 1;
+ if (ioctl(ctl->fd, SIOCBRADDBR, try) == 0) {
+ if (!(*name = strdup(try))) {
+ ioctl(ctl->fd, SIOCBRDELBR, name);
+ return ENOMEM;
+ }
+ return 0;
+ }
- do {
- char try[BR_IFNAME_MAXLEN];
- int len;
-
- if (subst) {
- len = snprintf(try, maxlen, nameOrFmt, id);
- if (len >= maxlen)
- return EADDRINUSE;
- } else {
- len = strlen(nameOrFmt);
- if (len >= maxlen - 1)
- return EINVAL;
-
- strncpy(try, nameOrFmt, len);
- try[len] = '\0';
- }
-
- if (ioctl(ctl->fd, SIOCBRADDBR, try) == 0) {
- strncpy(name, try, maxlen);
- return 0;
- }
-
- id++;
- } while (subst && id <= MAX_BRIDGE_ID);
+ id++;
+ } while (id < MAX_BRIDGE_ID);
+ }
return errno;
}
diff -r 5c483067f7a0 src/bridge.h
--- a/src/bridge.h Sun Jun 22 17:56:04 2008 -0400
+++ b/src/bridge.h Sun Jun 22 17:58:48 2008 -0400
@@ -47,9 +47,7 @@
void brShutdown (brControl *ctl);
int brAddBridge (brControl *ctl,
- const char *nameOrFmt,
- char *name,
- int maxlen);
+ char **name);
int brDeleteBridge (brControl *ctl,
const char *name);
diff -r 5c483067f7a0 src/qemu_conf.c
--- a/src/qemu_conf.c Sun Jun 22 17:56:04 2008 -0400
+++ b/src/qemu_conf.c Sun Jun 22 17:58:48 2008 -0400
@@ -175,32 +175,6 @@
if (STREQ(vm->def->name, name))
return vm;
vm = vm->next;
- }
-
- return NULL;
-}
-
-struct qemud_network *qemudFindNetworkByUUID(const struct qemud_driver *driver,
- const unsigned char *uuid) {
- struct qemud_network *network = driver->networks;
-
- while (network) {
- if (!memcmp(network->def->uuid, uuid, VIR_UUID_BUFLEN))
- return network;
- network = network->next;
- }
-
- return NULL;
-}
-
-struct qemud_network *qemudFindNetworkByName(const struct qemud_driver *driver,
- const char *name) {
- struct qemud_network *network = driver->networks;
-
- while (network) {
- if (STREQ(network->def->name, name))
- return network;
- network = network->next;
}
return NULL;
@@ -2254,7 +2228,7 @@
struct qemud_vm_net_def *net,
int vlan)
{
- struct qemud_network *network = NULL;
+ virNetworkObjPtr network = NULL;
char *brname;
char *ifname;
char tapfdstr[4+3+32+7];
@@ -2263,18 +2237,18 @@
int tapfd = -1;
if (net->type == QEMUD_NET_NETWORK) {
- if (!(network = qemudFindNetworkByName(driver, net->dst.network.name))) {
+ if (!(network = virNetworkFindByName(driver->networks,
net->dst.network.name))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("Network '%s' not found"),
net->dst.network.name);
goto error;
- } else if (network->bridge[0] == '\0') {
+ } else if (network->def->bridge == NULL) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("Network '%s' not active"),
net->dst.network.name);
goto error;
}
- brname = network->bridge;
+ brname = network->def->bridge;
if (net->dst.network.ifname[0] == '\0' ||
STRPREFIX(net->dst.network.ifname, "vnet") ||
strchr(net->dst.network.ifname, '%')) {
@@ -3115,14 +3089,15 @@
static int qemudSaveNetworkConfig(virConnectPtr conn,
struct qemud_driver *driver,
- struct qemud_network *network,
- struct qemud_network_def *def) {
+ virNetworkObjPtr network,
+ int active) {
char *xml;
int fd, ret = -1;
int towrite;
int err;
- if (!(xml = qemudGenerateNetworkXML(conn, driver, network, def))) {
+ if (!(xml = virNetworkDefFormat(conn, !active && network->newDef ?
+ network->newDef : network->def))) {
return -1;
}
@@ -3166,384 +3141,14 @@
return ret;
}
-void qemudFreeNetworkDef(struct qemud_network_def *def) {
- struct qemud_dhcp_range_def *range = def->ranges;
- while (range) {
- struct qemud_dhcp_range_def *next = range->next;
- VIR_FREE(range);
- range = next;
- }
- VIR_FREE(def);
-}
-
-void qemudFreeNetwork(struct qemud_network *network) {
- qemudFreeNetworkDef(network->def);
- if (network->newDef)
- qemudFreeNetworkDef(network->newDef);
- VIR_FREE(network);
-}
-
-static int qemudParseBridgeXML(struct qemud_driver *driver ATTRIBUTE_UNUSED,
- struct qemud_network_def *def,
- xmlNodePtr node) {
- xmlChar *name, *stp, *delay;
-
- name = xmlGetProp(node, BAD_CAST "name");
- if (name != NULL) {
- strncpy(def->bridge, (const char *)name, IF_NAMESIZE-1);
- def->bridge[IF_NAMESIZE-1] = '\0';
- xmlFree(name);
- name = NULL;
- }
-
- stp = xmlGetProp(node, BAD_CAST "stp");
- if (stp != NULL) {
- if (xmlStrEqual(stp, BAD_CAST "off")) {
- def->disableSTP = 1;
- }
- xmlFree(stp);
- stp = NULL;
- }
-
- delay = xmlGetProp(node, BAD_CAST "delay");
- if (delay != NULL) {
- def->forwardDelay = strtol((const char *)delay, NULL, 10);
- xmlFree(delay);
- delay = NULL;
- }
-
- return 1;
-}
-
-static int qemudParseDhcpRangesXML(virConnectPtr conn,
- struct qemud_driver *driver ATTRIBUTE_UNUSED,
- struct qemud_network_def *def,
- xmlNodePtr node) {
-
- xmlNodePtr cur;
-
- cur = node->children;
- while (cur != NULL) {
- struct qemud_dhcp_range_def *range;
- xmlChar *start, *end;
-
- if (cur->type != XML_ELEMENT_NODE ||
- !xmlStrEqual(cur->name, BAD_CAST "range")) {
- cur = cur->next;
- continue;
- }
-
- if (VIR_ALLOC(range) < 0) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for range
string"));
- return 0;
- }
-
- start = xmlGetProp(cur, BAD_CAST "start");
- end = xmlGetProp(cur, BAD_CAST "end");
-
- if (start && start[0] && end && end[0]) {
- strncpy(range->start, (const char *)start, BR_INET_ADDR_MAXLEN-1);
- range->start[BR_INET_ADDR_MAXLEN-1] = '\0';
-
- strncpy(range->end, (const char *)end, BR_INET_ADDR_MAXLEN-1);
- range->end[BR_INET_ADDR_MAXLEN-1] = '\0';
-
- range->next = def->ranges;
- def->ranges = range;
- def->nranges++;
- } else {
- VIR_FREE(range);
- }
-
- xmlFree(start);
- xmlFree(end);
-
- cur = cur->next;
- }
-
- return 1;
-}
-
-static int qemudParseInetXML(virConnectPtr conn,
- struct qemud_driver *driver ATTRIBUTE_UNUSED,
- struct qemud_network_def *def,
- xmlNodePtr node) {
- xmlChar *address, *netmask;
- xmlNodePtr cur;
-
- address = xmlGetProp(node, BAD_CAST "address");
- if (address != NULL) {
- strncpy(def->ipAddress, (const char *)address, BR_INET_ADDR_MAXLEN-1);
- def->ipAddress[BR_INET_ADDR_MAXLEN-1] = '\0';
- xmlFree(address);
- address = NULL;
- }
-
- netmask = xmlGetProp(node, BAD_CAST "netmask");
- if (netmask != NULL) {
- strncpy(def->netmask, (const char *)netmask, BR_INET_ADDR_MAXLEN-1);
- def->netmask[BR_INET_ADDR_MAXLEN-1] = '\0';
- xmlFree(netmask);
- netmask = NULL;
- }
-
- if (def->ipAddress[0] && def->netmask[0]) {
- struct in_addr inaddress, innetmask;
- char *netaddr;
-
- inet_aton((const char*)def->ipAddress, &inaddress);
- inet_aton((const char*)def->netmask, &innetmask);
-
- inaddress.s_addr &= innetmask.s_addr;
-
- netaddr = inet_ntoa(inaddress);
-
- snprintf(def->network,sizeof(def->network)-1,
- "%s/%s", netaddr, (const char *)def->netmask);
- }
-
- cur = node->children;
- while (cur != NULL) {
- if (cur->type == XML_ELEMENT_NODE &&
- xmlStrEqual(cur->name, BAD_CAST "dhcp") &&
- !qemudParseDhcpRangesXML(conn, driver, def, cur))
- return 0;
- cur = cur->next;
- }
-
- return 1;
-}
-
-
-static struct qemud_network_def *qemudParseNetworkXML(virConnectPtr conn,
- struct qemud_driver *driver,
- xmlDocPtr xml) {
- xmlNodePtr root = NULL;
- xmlXPathContextPtr ctxt = NULL;
- xmlXPathObjectPtr obj = NULL, tmp = NULL;
- struct qemud_network_def *def;
-
- if (VIR_ALLOC(def) < 0) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for network_def
string"));
- return NULL;
- }
-
- /* Prepare parser / xpath context */
- root = xmlDocGetRootElement(xml);
- if ((root == NULL) || (!xmlStrEqual(root->name, BAD_CAST "network"))) {
- 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
string"));
- goto error;
- }
-
-
- /* Extract network name */
- obj = xmlXPathEval(BAD_CAST "string(/network/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", _("network name length too long"));
- goto error;
- }
- strcpy(def->name, (const char *)obj->stringval);
- xmlXPathFreeObject(obj);
-
-
- /* Extract network uuid */
- obj = xmlXPathEval(BAD_CAST "string(/network/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);
-
- /* Parse bridge information */
- obj = xmlXPathEval(BAD_CAST "/network/bridge[1]", ctxt);
- if ((obj != NULL) && (obj->type == XPATH_NODESET) &&
- (obj->nodesetval != NULL) && (obj->nodesetval->nodeNr > 0))
{
- if (!qemudParseBridgeXML(driver, def, obj->nodesetval->nodeTab[0])) {
- goto error;
- }
- }
- xmlXPathFreeObject(obj);
-
- /* Parse IP information */
- obj = xmlXPathEval(BAD_CAST "/network/ip[1]", ctxt);
- if ((obj != NULL) && (obj->type == XPATH_NODESET) &&
- (obj->nodesetval != NULL) && (obj->nodesetval->nodeNr > 0))
{
- if (!qemudParseInetXML(conn, driver, def, obj->nodesetval->nodeTab[0])) {
- goto error;
- }
- }
- xmlXPathFreeObject(obj);
-
- /* IPv4 forwarding setup */
- obj = xmlXPathEval(BAD_CAST "count(/network/forward) > 0", ctxt);
- if ((obj != NULL) && (obj->type == XPATH_BOOLEAN) &&
- obj->boolval) {
- if (!def->ipAddress[0] ||
- !def->netmask[0]) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
- "%s", _("Forwarding requested, but no IPv4
address/netmask provided"));
- goto error;
- }
-
- def->forward = 1;
-
- tmp = xmlXPathEval(BAD_CAST "string(/network/forward[1]/@mode)",
ctxt);
- if ((tmp != NULL) && (tmp->type == XPATH_STRING) &&
- (tmp->stringval != NULL) && (xmlStrEqual(tmp->stringval,
BAD_CAST "route"))) {
- def->forwardMode = QEMUD_NET_FORWARD_ROUTE;
- } else {
- def->forwardMode = QEMUD_NET_FORWARD_NAT;
- }
- xmlXPathFreeObject(tmp);
- tmp = NULL;
-
- tmp = xmlXPathEval(BAD_CAST "string(/network/forward[1]/@dev)", ctxt);
- if ((tmp != NULL) && (tmp->type == XPATH_STRING) &&
- (tmp->stringval != NULL) && (tmp->stringval[0] != 0)) {
- int len;
- if ((len = xmlStrlen(tmp->stringval)) >= (BR_IFNAME_MAXLEN-1)) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
- _("forward device name '%s' is too
long"),
- (char*)tmp->stringval);
- goto error;
- }
- strcpy(def->forwardDev, (char*)tmp->stringval);
- } else {
- def->forwardDev[0] = '\0';
- }
- xmlXPathFreeObject(tmp);
- tmp = NULL;
- } else {
- def->forward = 0;
- }
- xmlXPathFreeObject(obj);
-
- xmlXPathFreeContext(ctxt);
-
- return def;
-
- error:
- /* XXX free all the stuff in the qemud_network struct, or leave it upto
- the caller ? */
- xmlXPathFreeObject(obj);
- xmlXPathFreeObject(tmp);
- xmlXPathFreeContext(ctxt);
- qemudFreeNetworkDef(def);
- return NULL;
-}
-
-struct qemud_network_def *
-qemudParseNetworkDef(virConnectPtr conn,
- struct qemud_driver *driver,
- const char *xmlStr,
- const char *displayName) {
- xmlDocPtr xml;
- struct qemud_network_def *def;
-
- if (!(xml = xmlReadDoc(BAD_CAST xmlStr, displayName ? displayName :
"network.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 = qemudParseNetworkXML(conn, driver, xml);
-
- xmlFreeDoc(xml);
-
- return def;
-}
-
-struct qemud_network *
-qemudAssignNetworkDef(virConnectPtr conn,
- struct qemud_driver *driver,
- struct qemud_network_def *def) {
- struct qemud_network *network;
-
- if ((network = qemudFindNetworkByName(driver, def->name))) {
- if (!qemudIsActiveNetwork(network)) {
- qemudFreeNetworkDef(network->def);
- network->def = def;
- } else {
- if (network->newDef)
- qemudFreeNetworkDef(network->newDef);
- network->newDef = def;
- }
-
- return network;
- }
-
- if (VIR_ALLOC(network) < 0) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for network
string"));
- return NULL;
- }
-
- network->def = def;
- network->next = driver->networks;
-
- driver->networks = network;
- driver->ninactivenetworks++;
-
- return network;
-}
-
-void
-qemudRemoveInactiveNetwork(struct qemud_driver *driver,
- struct qemud_network *network)
-{
- struct qemud_network *prev = NULL, *curr;
-
- curr = driver->networks;
- while (curr != network) {
- prev = curr;
- curr = curr->next;
- }
-
- if (curr) {
- if (prev)
- prev->next = curr->next;
- else
- driver->networks = curr->next;
-
- driver->ninactivenetworks--;
- }
-
- qemudFreeNetwork(network);
-}
int
qemudSaveNetworkDef(virConnectPtr conn,
struct qemud_driver *driver,
- struct qemud_network *network,
- struct qemud_network_def *def) {
-
- if (network->configFile[0] == '\0') {
+ virNetworkObjPtr network,
+ int active) {
+ if (network->configFile == NULL) {
+ char buf[PATH_MAX];
int err;
if ((err = virFileMakePath(driver->networkConfigDir))) {
@@ -3553,23 +3158,31 @@
return -1;
}
- if (virFileBuildPath(driver->networkConfigDir, def->name,
".xml",
- network->configFile, PATH_MAX) < 0) {
+ if (virFileBuildPath(driver->networkConfigDir, network->def->name,
".xml",
+ buf, sizeof(buf)) < 0) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot construct config file
path"));
return -1;
}
+ if (!(network->configFile = strdup(buf))) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ return -1;
+ }
- if (virFileBuildPath(driver->networkAutostartDir, def->name,
".xml",
- network->autostartLink, PATH_MAX) < 0) {
+ if (virFileBuildPath(driver->networkAutostartDir, network->def->name,
".xml",
+ buf, sizeof(buf)) < 0) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot construct autostart link
path"));
- network->configFile[0] = '\0';
+ return -1;
+ }
+ if (!(network->autostartLink = strdup(buf))) {
+ VIR_FREE(network->configFile);
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
return -1;
}
}
- return qemudSaveNetworkConfig(conn, driver, network, def);
+ return qemudSaveNetworkConfig(conn, driver, network, active);
}
@@ -3618,16 +3231,16 @@
return vm;
}
-static struct qemud_network *
+static virNetworkObjPtr
qemudLoadNetworkConfig(struct qemud_driver *driver,
const char *file,
const char *path,
const char *xml,
const char *autostartLink) {
- struct qemud_network_def *def;
- struct qemud_network *network;
+ virNetworkDefPtr def;
+ virNetworkObjPtr network;
- if (!(def = qemudParseNetworkDef(NULL, driver, xml, file))) {
+ if (!(def = virNetworkDefParse(NULL, xml, file))) {
virErrorPtr err = virGetLastError();
qemudLog(QEMUD_WARN, _("Error parsing network config '%s' :
%s"),
path, err->message);
@@ -3639,22 +3252,29 @@
_("Network config filename '%s'"
" does not match network name '%s'"),
path, def->name);
- qemudFreeNetworkDef(def);
+ virNetworkDefFree(def);
return NULL;
}
- if (!(network = qemudAssignNetworkDef(NULL, driver, def))) {
+ if (!(network = virNetworkAssignDef(NULL,
+ &driver->networks,
+ def))) {
qemudLog(QEMUD_WARN,
_("Failed to load network config '%s': out of
memory"), path);
- qemudFreeNetworkDef(def);
+ virNetworkDefFree(def);
return NULL;
}
- strncpy(network->configFile, path, PATH_MAX);
- network->configFile[PATH_MAX-1] = '\0';
-
- strncpy(network->autostartLink, autostartLink, PATH_MAX);
- network->autostartLink[PATH_MAX-1] = '\0';
+ network->configFile = strdup(path);
+ network->autostartLink = strdup(autostartLink);
+ if (network->configFile == NULL ||
+ network->autostartLink == NULL) {
+ qemudLog(QEMUD_WARN,
+ _("Failed to save config file path"));
+ virNetworkRemoveInactive(&driver->networks,
+ network);
+ return NULL;
+ }
network->autostart = virFileLinkPointsTo(network->autostartLink,
network->configFile);
@@ -4128,83 +3748,6 @@
}
-char *qemudGenerateNetworkXML(virConnectPtr conn,
- struct qemud_driver *driver ATTRIBUTE_UNUSED,
- struct qemud_network *network,
- struct qemud_network_def *def) {
- virBuffer buf = VIR_BUFFER_INITIALIZER;
- unsigned char *uuid;
- char *tmp;
- char uuidstr[VIR_UUID_STRING_BUFLEN];
-
- virBufferAddLit(&buf, "<network>\n");
-
- virBufferVSprintf(&buf, " <name>%s</name>\n",
def->name);
-
- uuid = def->uuid;
- virUUIDFormat(uuid, uuidstr);
- virBufferVSprintf(&buf, " <uuid>%s</uuid>\n", uuidstr);
-
- if (def->forward) {
- if (def->forwardDev[0]) {
- virBufferVSprintf(&buf, " <forward dev='%s'
mode='%s'/>\n",
- def->forwardDev, (def->forwardMode ==
QEMUD_NET_FORWARD_ROUTE ? "route" : "nat"));
- } else {
- virBufferVSprintf(&buf, " <forward
mode='%s'/>\n", (def->forwardMode == QEMUD_NET_FORWARD_ROUTE ?
"route" : "nat"));
- }
- }
-
- virBufferAddLit(&buf, " <bridge");
- if (qemudIsActiveNetwork(network)) {
- virBufferVSprintf(&buf, " name='%s'", network->bridge);
- } else if (def->bridge[0]) {
- virBufferVSprintf(&buf, " name='%s'", def->bridge);
- }
- virBufferVSprintf(&buf, " stp='%s' forwardDelay='%d'
/>\n",
- def->disableSTP ? "off" : "on",
- def->forwardDelay);
-
- if (def->ipAddress[0] || def->netmask[0]) {
- virBufferAddLit(&buf, " <ip");
-
- if (def->ipAddress[0])
- virBufferVSprintf(&buf, " address='%s'",
def->ipAddress);
-
- if (def->netmask[0])
- virBufferVSprintf(&buf, " netmask='%s'",
def->netmask);
-
- virBufferAddLit(&buf, ">\n");
-
- if (def->ranges) {
- struct qemud_dhcp_range_def *range = def->ranges;
- virBufferAddLit(&buf, " <dhcp>\n");
- while (range) {
- virBufferVSprintf(&buf, " <range start='%s'
end='%s' />\n",
- range->start, range->end);
- range = range->next;
- }
- virBufferAddLit(&buf, " </dhcp>\n");
- }
-
- virBufferAddLit(&buf, " </ip>\n");
- }
-
- virBufferAddLit(&buf, "</network>\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"));
- tmp = virBufferContentAndReset(&buf);
- VIR_FREE(tmp);
- return NULL;
-}
-
-
int qemudDeleteConfig(virConnectPtr conn,
struct qemud_driver *driver ATTRIBUTE_UNUSED,
const char *configFile,
diff -r 5c483067f7a0 src/qemu_conf.h
--- a/src/qemu_conf.h Sun Jun 22 17:56:04 2008 -0400
+++ b/src/qemu_conf.h Sun Jun 22 17:58:48 2008 -0400
@@ -32,6 +32,7 @@
#include "bridge.h"
#include "iptables.h"
#include "capabilities.h"
+#include "network_conf.h"
#include <netinet/in.h>
#include <sched.h>
@@ -94,12 +95,6 @@
QEMUD_NET_MCAST,
QEMUD_NET_NETWORK,
QEMUD_NET_BRIDGE,
-};
-
-/* 2 possible types of forwarding */
-enum qemud_vm_net_forward_type {
- QEMUD_NET_FORWARD_NAT,
- QEMUD_NET_FORWARD_ROUTE,
};
#define QEMUD_MAX_NAME_LEN 50
@@ -349,53 +344,6 @@
struct qemud_vm *next;
};
-/* Store start and end addresses of a dhcp range */
-struct qemud_dhcp_range_def {
- char start[BR_INET_ADDR_MAXLEN];
- char end[BR_INET_ADDR_MAXLEN];
-
- struct qemud_dhcp_range_def *next;
-};
-
-/* Virtual Network main configuration */
-struct qemud_network_def {
- unsigned char uuid[VIR_UUID_BUFLEN];
- char name[QEMUD_MAX_NAME_LEN];
-
- char bridge[BR_IFNAME_MAXLEN];
- int disableSTP;
- int forwardDelay;
-
- int forward;
- int forwardMode; /* From qemud_vm_net_forward_type */
- char forwardDev[BR_IFNAME_MAXLEN];
-
- char ipAddress[BR_INET_ADDR_MAXLEN];
- char netmask[BR_INET_ADDR_MAXLEN];
- char network[BR_INET_ADDR_MAXLEN+BR_INET_ADDR_MAXLEN+1];
-
- int nranges;
- struct qemud_dhcp_range_def *ranges;
-};
-
-/* Virtual Network runtime state */
-struct qemud_network {
- char configFile[PATH_MAX];
- char autostartLink[PATH_MAX];
-
- struct qemud_network_def *def; /* The current definition */
- struct qemud_network_def *newDef; /* New definition to activate at shutdown */
-
- char bridge[BR_IFNAME_MAXLEN];
- int dnsmasqPid;
-
- unsigned int active : 1;
- unsigned int autostart : 1;
-
- struct qemud_network *next;
-};
-
-
/* Main driver state */
struct qemud_driver {
int qemuVersion;
@@ -403,9 +351,9 @@
int ninactivevms;
struct qemud_vm *vms;
int nextvmid;
- int nactivenetworks;
- int ninactivenetworks;
- struct qemud_network *networks;
+
+ virNetworkObjPtr networks;
+
brControl *brctl;
iptablesContext *iptables;
char *configDir;
@@ -428,12 +376,6 @@
return vm->id != -1;
}
-static inline int
-qemudIsActiveNetwork(const struct qemud_network *network)
-{
- return network->active;
-}
-
void qemudReportError(virConnectPtr conn,
virDomainPtr dom,
virNetworkPtr net,
@@ -450,11 +392,6 @@
const unsigned char *uuid);
struct qemud_vm *qemudFindVMByName(const struct qemud_driver *driver,
const char *name);
-
-struct qemud_network *qemudFindNetworkByUUID(const struct qemud_driver *driver,
- const unsigned char *uuid);
-struct qemud_network *qemudFindNetworkByName(const struct qemud_driver *driver,
- const char *name);
virCapsPtr qemudCapsInit (void);
@@ -501,29 +438,10 @@
struct qemud_vm_def *def,
int live);
-void qemudFreeNetworkDef (struct qemud_network_def *def);
-void qemudFreeNetwork (struct qemud_network *network);
-
-struct qemud_network *
- qemudAssignNetworkDef (virConnectPtr conn,
- struct qemud_driver *driver,
- struct qemud_network_def *def);
-void qemudRemoveInactiveNetwork (struct qemud_driver *driver,
- struct qemud_network *network);
-
-struct qemud_network_def *
- qemudParseNetworkDef (virConnectPtr conn,
- struct qemud_driver *driver,
- const char *xmlStr,
- const char *displayName);
int qemudSaveNetworkDef (virConnectPtr conn,
struct qemud_driver *driver,
- struct qemud_network *network,
- struct qemud_network_def *def);
-char * qemudGenerateNetworkXML (virConnectPtr conn,
- struct qemud_driver *driver,
- struct qemud_network *network,
- struct qemud_network_def *def);
+ virNetworkObjPtr network,
+ int active);
const char *qemudVirtTypeToString (int type);
diff -r 5c483067f7a0 src/qemu_driver.c
--- a/src/qemu_driver.c Sun Jun 22 17:56:04 2008 -0400
+++ b/src/qemu_driver.c Sun Jun 22 17:58:48 2008 -0400
@@ -118,11 +118,11 @@
static int qemudStartNetworkDaemon(virConnectPtr conn,
struct qemud_driver *driver,
- struct qemud_network *network);
+ virNetworkObjPtr network);
static int qemudShutdownNetworkDaemon(virConnectPtr conn,
struct qemud_driver *driver,
- struct qemud_network *network);
+ virNetworkObjPtr network);
static int qemudDomainGetMaxVcpus(virDomainPtr dom);
static int qemudMonitorCommand (const struct qemud_driver *driver,
@@ -135,15 +135,15 @@
static
void qemudAutostartConfigs(struct qemud_driver *driver) {
- struct qemud_network *network;
+ virNetworkObjPtr network;
struct qemud_vm *vm;
network = driver->networks;
while (network != NULL) {
- struct qemud_network *next = network->next;
+ virNetworkObjPtr next = network->next;
if (network->autostart &&
- !qemudIsActiveNetwork(network) &&
+ !virNetworkIsActive(network) &&
qemudStartNetworkDaemon(NULL, driver, network) < 0) {
virErrorPtr err = virGetLastError();
qemudLog(QEMUD_ERR, _("Failed to autostart network '%s':
%s"),
@@ -292,11 +292,14 @@
*/
static int
qemudActive(void) {
- /* If we've any active networks or guests, then we
- * mark this driver as active
- */
- if (qemu_driver->nactivenetworks &&
- qemu_driver->nactivevms)
+ virNetworkObjPtr net = qemu_driver->networks;
+ while (net) {
+ if (net->active)
+ return 1;
+ net = net->next;
+ }
+
+ if (qemu_driver->nactivevms)
return 1;
/* Otherwise we're happy to deal with a shutdown */
@@ -311,7 +314,7 @@
static int
qemudShutdown(void) {
struct qemud_vm *vm;
- struct qemud_network *network;
+ virNetworkObjPtr network;
if (!qemu_driver)
return -1;
@@ -343,8 +346,8 @@
/* shutdown active networks */
network = qemu_driver->networks;
while (network) {
- struct qemud_network *next = network->next;
- if (qemudIsActiveNetwork(network))
+ virNetworkObjPtr next = network->next;
+ if (virNetworkIsActive(network))
qemudShutdownNetworkDaemon(NULL, qemu_driver, network);
network = next;
}
@@ -352,13 +355,11 @@
/* free inactive networks */
network = qemu_driver->networks;
while (network) {
- struct qemud_network *next = network->next;
- qemudFreeNetwork(network);
+ virNetworkObjPtr next = network->next;
+ virNetworkObjFree(network);
network = next;
}
qemu_driver->networks = NULL;
- qemu_driver->nactivenetworks = 0;
- qemu_driver->ninactivenetworks = 0;
VIR_FREE(qemu_driver->configDir);
VIR_FREE(qemu_driver->autostartDir);
@@ -1035,11 +1036,10 @@
static int
qemudBuildDnsmasqArgv(virConnectPtr conn,
- struct qemud_network *network,
+ virNetworkObjPtr network,
char ***argv) {
- int i, len;
+ int i, len, r;
char buf[PATH_MAX];
- struct qemud_dhcp_range_def *range;
len =
1 + /* dnsmasq */
@@ -1105,15 +1105,13 @@
LOCAL_STATE_DIR, network->def->name);
APPEND_ARG(*argv, i++, buf);
- range = network->def->ranges;
- while (range) {
+ for (r = 0 ; r < network->def->nranges ; r++) {
snprintf(buf, sizeof(buf), "%s,%s",
- range->start, range->end);
+ network->def->ranges[r].start,
+ network->def->ranges[r].end);
APPEND_ARG(*argv, i++, "--dhcp-range");
APPEND_ARG(*argv, i++, buf);
-
- range = range->next;
}
#undef APPEND_ARG
@@ -1134,12 +1132,12 @@
static int
dhcpStartDhcpDaemon(virConnectPtr conn,
- struct qemud_network *network)
+ virNetworkObjPtr network)
{
char **argv;
int ret, i;
- if (network->def->ipAddress[0] == '\0') {
+ if (network->def->ipAddress == NULL) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot start dhcp daemon without IP
address for server"));
return -1;
@@ -1161,27 +1159,27 @@
static int
qemudAddMasqueradingIptablesRules(virConnectPtr conn,
struct qemud_driver *driver,
- struct qemud_network *network) {
+ virNetworkObjPtr network) {
int err;
/* allow forwarding packets from the bridge interface */
if ((err = iptablesAddForwardAllowOut(driver->iptables,
network->def->network,
- network->bridge,
+ network->def->bridge,
network->def->forwardDev))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("failed to add iptables rule to allow forwarding from
'%s' : %s\n"),
- network->bridge, strerror(err));
+ network->def->bridge, strerror(err));
goto masqerr1;
}
/* allow forwarding packets to the bridge interface if they are part of an existing
connection */
if ((err = iptablesAddForwardAllowRelatedIn(driver->iptables,
network->def->network,
- network->bridge,
+ network->def->bridge,
network->def->forwardDev))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("failed to add iptables rule to allow forwarding to
'%s' : %s\n"),
- network->bridge, strerror(err));
+ network->def->bridge, strerror(err));
goto masqerr2;
}
@@ -1200,12 +1198,12 @@
masqerr3:
iptablesRemoveForwardAllowRelatedIn(driver->iptables,
network->def->network,
- network->bridge,
+ network->def->bridge,
network->def->forwardDev);
masqerr2:
iptablesRemoveForwardAllowOut(driver->iptables,
network->def->network,
- network->bridge,
+ network->def->bridge,
network->def->forwardDev);
masqerr1:
return 0;
@@ -1214,27 +1212,27 @@
static int
qemudAddRoutingIptablesRules(virConnectPtr conn,
struct qemud_driver *driver,
- struct qemud_network *network) {
+ virNetworkObjPtr network) {
int err;
/* allow routing packets from the bridge interface */
if ((err = iptablesAddForwardAllowOut(driver->iptables,
network->def->network,
- network->bridge,
+ network->def->bridge,
network->def->forwardDev))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("failed to add iptables rule to allow routing from
'%s' : %s\n"),
- network->bridge, strerror(err));
+ network->def->bridge, strerror(err));
goto routeerr1;
}
/* allow routing packets to the bridge interface */
if ((err = iptablesAddForwardAllowIn(driver->iptables,
network->def->network,
- network->bridge,
+ network->def->bridge,
network->def->forwardDev))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("failed to add iptables rule to allow routing to
'%s' : %s\n"),
- network->bridge, strerror(err));
+ network->def->bridge, strerror(err));
goto routeerr2;
}
@@ -1244,7 +1242,7 @@
routeerr2:
iptablesRemoveForwardAllowOut(driver->iptables,
network->def->network,
- network->bridge,
+ network->def->bridge,
network->def->forwardDev);
routeerr1:
return 0;
@@ -1253,7 +1251,7 @@
static int
qemudAddIptablesRules(virConnectPtr conn,
struct qemud_driver *driver,
- struct qemud_network *network) {
+ virNetworkObjPtr network) {
int err;
if (!driver->iptables && !(driver->iptables = iptablesContextNew())) {
@@ -1264,71 +1262,69 @@
/* allow DHCP requests through to dnsmasq */
- if ((err = iptablesAddTcpInput(driver->iptables, network->bridge, 67))) {
+ if ((err = iptablesAddTcpInput(driver->iptables, network->def->bridge, 67)))
{
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("failed to add iptables rule to allow DHCP requests from
'%s' : %s"),
- network->bridge, strerror(err));
+ network->def->bridge, strerror(err));
goto err1;
}
- if ((err = iptablesAddUdpInput(driver->iptables, network->bridge, 67))) {
+ if ((err = iptablesAddUdpInput(driver->iptables, network->def->bridge, 67)))
{
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("failed to add iptables rule to allow DHCP requests from
'%s' : %s"),
- network->bridge, strerror(err));
+ network->def->bridge, strerror(err));
goto err2;
}
/* allow DNS requests through to dnsmasq */
- if ((err = iptablesAddTcpInput(driver->iptables, network->bridge, 53))) {
+ if ((err = iptablesAddTcpInput(driver->iptables, network->def->bridge, 53)))
{
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("failed to add iptables rule to allow DNS requests from
'%s' : %s"),
- network->bridge, strerror(err));
+ network->def->bridge, strerror(err));
goto err3;
}
- if ((err = iptablesAddUdpInput(driver->iptables, network->bridge, 53))) {
+ if ((err = iptablesAddUdpInput(driver->iptables, network->def->bridge, 53)))
{
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("failed to add iptables rule to allow DNS requests from
'%s' : %s"),
- network->bridge, strerror(err));
+ network->def->bridge, strerror(err));
goto err4;
}
/* Catch all rules to block forwarding to/from bridges */
- if ((err = iptablesAddForwardRejectOut(driver->iptables, network->bridge))) {
+ if ((err = iptablesAddForwardRejectOut(driver->iptables,
network->def->bridge))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("failed to add iptables rule to block outbound traffic
from '%s' : %s"),
- network->bridge, strerror(err));
+ network->def->bridge, strerror(err));
goto err5;
}
- if ((err = iptablesAddForwardRejectIn(driver->iptables, network->bridge))) {
+ if ((err = iptablesAddForwardRejectIn(driver->iptables,
network->def->bridge))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("failed to add iptables rule to block inbound traffic to
'%s' : %s"),
- network->bridge, strerror(err));
+ network->def->bridge, strerror(err));
goto err6;
}
/* Allow traffic between guests on the same bridge */
- if ((err = iptablesAddForwardAllowCross(driver->iptables, network->bridge))) {
+ if ((err = iptablesAddForwardAllowCross(driver->iptables,
network->def->bridge))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("failed to add iptables rule to allow cross bridge
traffic on '%s' : %s"),
- network->bridge, strerror(err));
+ network->def->bridge, strerror(err));
goto err7;
}
- if (network->def->forward) {
- /* If masquerading is enabled, set up the rules*/
- if (network->def->forwardMode == QEMUD_NET_FORWARD_NAT &&
- !qemudAddMasqueradingIptablesRules(conn, driver, network))
- goto err8;
- /* else if routing is enabled, set up the rules*/
- else if (network->def->forwardMode == QEMUD_NET_FORWARD_ROUTE &&
- !qemudAddRoutingIptablesRules(conn, driver, network))
- goto err8;
- }
+ /* If masquerading is enabled, set up the rules*/
+ if (network->def->forwardType == VIR_NETWORK_FORWARD_NAT &&
+ !qemudAddMasqueradingIptablesRules(conn, driver, network))
+ goto err8;
+ /* else if routing is enabled, set up the rules*/
+ else if (network->def->forwardType == VIR_NETWORK_FORWARD_ROUTE &&
+ !qemudAddRoutingIptablesRules(conn, driver, network))
+ goto err8;
iptablesSaveRules(driver->iptables);
@@ -1336,56 +1332,56 @@
err8:
iptablesRemoveForwardAllowCross(driver->iptables,
- network->bridge);
+ network->def->bridge);
err7:
iptablesRemoveForwardRejectIn(driver->iptables,
- network->bridge);
+ network->def->bridge);
err6:
iptablesRemoveForwardRejectOut(driver->iptables,
- network->bridge);
+ network->def->bridge);
err5:
- iptablesRemoveUdpInput(driver->iptables, network->bridge, 53);
+ iptablesRemoveUdpInput(driver->iptables, network->def->bridge, 53);
err4:
- iptablesRemoveTcpInput(driver->iptables, network->bridge, 53);
+ iptablesRemoveTcpInput(driver->iptables, network->def->bridge, 53);
err3:
- iptablesRemoveUdpInput(driver->iptables, network->bridge, 67);
+ iptablesRemoveUdpInput(driver->iptables, network->def->bridge, 67);
err2:
- iptablesRemoveTcpInput(driver->iptables, network->bridge, 67);
+ iptablesRemoveTcpInput(driver->iptables, network->def->bridge, 67);
err1:
return 0;
}
static void
qemudRemoveIptablesRules(struct qemud_driver *driver,
- struct qemud_network *network) {
- if (network->def->forward) {
+ virNetworkObjPtr network) {
+ if (network->def->forwardType != VIR_NETWORK_FORWARD_NONE) {
iptablesRemoveForwardMasquerade(driver->iptables,
network->def->network,
network->def->forwardDev);
- if (network->def->forwardMode == QEMUD_NET_FORWARD_NAT)
+ if (network->def->forwardType == VIR_NETWORK_FORWARD_NAT)
iptablesRemoveForwardAllowRelatedIn(driver->iptables,
network->def->network,
- network->bridge,
+ network->def->bridge,
network->def->forwardDev);
- else if (network->def->forwardMode == QEMUD_NET_FORWARD_ROUTE)
+ else if (network->def->forwardType == VIR_NETWORK_FORWARD_ROUTE)
iptablesRemoveForwardAllowIn(driver->iptables,
network->def->network,
- network->bridge,
+ network->def->bridge,
network->def->forwardDev);
iptablesRemoveForwardAllowOut(driver->iptables,
network->def->network,
- network->bridge,
+ network->def->bridge,
network->def->forwardDev);
}
- iptablesRemoveForwardAllowCross(driver->iptables, network->bridge);
- iptablesRemoveForwardRejectIn(driver->iptables, network->bridge);
- iptablesRemoveForwardRejectOut(driver->iptables, network->bridge);
- iptablesRemoveUdpInput(driver->iptables, network->bridge, 53);
- iptablesRemoveTcpInput(driver->iptables, network->bridge, 53);
- iptablesRemoveUdpInput(driver->iptables, network->bridge, 67);
- iptablesRemoveTcpInput(driver->iptables, network->bridge, 67);
+ iptablesRemoveForwardAllowCross(driver->iptables, network->def->bridge);
+ iptablesRemoveForwardRejectIn(driver->iptables, network->def->bridge);
+ iptablesRemoveForwardRejectOut(driver->iptables, network->def->bridge);
+ iptablesRemoveUdpInput(driver->iptables, network->def->bridge, 53);
+ iptablesRemoveTcpInput(driver->iptables, network->def->bridge, 53);
+ iptablesRemoveUdpInput(driver->iptables, network->def->bridge, 67);
+ iptablesRemoveTcpInput(driver->iptables, network->def->bridge, 67);
iptablesSaveRules(driver->iptables);
}
@@ -1411,11 +1407,10 @@
static int qemudStartNetworkDaemon(virConnectPtr conn,
struct qemud_driver *driver,
- struct qemud_network *network) {
- const char *name;
+ virNetworkObjPtr network) {
int err;
- if (qemudIsActiveNetwork(network)) {
+ if (virNetworkIsActive(network)) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
"%s", _("network is already active"));
return -1;
@@ -1427,77 +1422,68 @@
return -1;
}
- if (network->def->bridge[0] == '\0' ||
- strchr(network->def->bridge, '%')) {
- name = "vnet%d";
- } else {
- name = network->def->bridge;
- }
-
- if ((err = brAddBridge(driver->brctl, name, network->bridge,
sizeof(network->bridge)))) {
+ if ((err = brAddBridge(driver->brctl, &network->def->bridge))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
- _("cannot create bridge '%s' : %s"), name,
strerror(err));
+ _("cannot create bridge '%s' : %s"),
+ network->def->bridge, strerror(err));
return -1;
}
- if (network->def->forwardDelay &&
- (err = brSetForwardDelay(driver->brctl, network->bridge,
network->def->forwardDelay))) {
+ if (network->def->delay &&
+ (err = brSetForwardDelay(driver->brctl, network->def->bridge,
network->def->delay))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
- _("failed to set bridge forward delay to %d"),
- network->def->forwardDelay);
+ _("failed to set bridge forward delay to %ld"),
+ network->def->delay);
goto err_delbr;
}
- if ((err = brSetEnableSTP(driver->brctl, network->bridge,
network->def->disableSTP ? 0 : 1))) {
+ if ((err = brSetEnableSTP(driver->brctl, network->def->bridge,
network->def->stp ? 1 : 0))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("failed to set bridge STP to %s"),
- network->def->disableSTP ? "off" :
"on");
+ network->def->stp ? "on" : "off");
goto err_delbr;
}
- if (network->def->ipAddress[0] &&
- (err = brSetInetAddress(driver->brctl, network->bridge,
network->def->ipAddress))) {
+ if (network->def->ipAddress &&
+ (err = brSetInetAddress(driver->brctl, network->def->bridge,
network->def->ipAddress))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("cannot set IP address on bridge '%s' to
'%s' : %s"),
- network->bridge, network->def->ipAddress,
strerror(err));
+ network->def->bridge, network->def->ipAddress,
strerror(err));
goto err_delbr;
}
- if (network->def->netmask[0] &&
- (err = brSetInetNetmask(driver->brctl, network->bridge,
network->def->netmask))) {
+ if (network->def->netmask &&
+ (err = brSetInetNetmask(driver->brctl, network->def->bridge,
network->def->netmask))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("cannot set netmask on bridge '%s' to
'%s' : %s"),
- network->bridge, network->def->netmask,
strerror(err));
+ network->def->bridge, network->def->netmask,
strerror(err));
goto err_delbr;
}
- if (network->def->ipAddress[0] &&
- (err = brSetInterfaceUp(driver->brctl, network->bridge, 1))) {
+ if (network->def->ipAddress &&
+ (err = brSetInterfaceUp(driver->brctl, network->def->bridge, 1))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("failed to bring the bridge '%s' up : %s"),
- network->bridge, strerror(err));
+ network->def->bridge, strerror(err));
goto err_delbr;
}
if (!qemudAddIptablesRules(conn, driver, network))
goto err_delbr1;
- if (network->def->forward &&
+ if (network->def->forwardType != VIR_NETWORK_FORWARD_NONE &&
!qemudEnableIpForwarding()) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("failed to enable IP forwarding : %s"),
strerror(err));
goto err_delbr2;
}
- if (network->def->ranges &&
+ if (network->def->nranges &&
dhcpStartDhcpDaemon(conn, network) < 0)
goto err_delbr2;
network->active = 1;
-
- driver->ninactivenetworks--;
- driver->nactivenetworks++;
return 0;
@@ -1505,16 +1491,16 @@
qemudRemoveIptablesRules(driver, network);
err_delbr1:
- if (network->def->ipAddress[0] &&
- (err = brSetInterfaceUp(driver->brctl, network->bridge, 0))) {
+ if (network->def->ipAddress &&
+ (err = brSetInterfaceUp(driver->brctl, network->def->bridge, 0))) {
qemudLog(QEMUD_WARN, _("Failed to bring down bridge '%s' :
%s"),
- network->bridge, strerror(err));
+ network->def->bridge, strerror(err));
}
err_delbr:
- if ((err = brDeleteBridge(driver->brctl, network->bridge))) {
+ if ((err = brDeleteBridge(driver->brctl, network->def->bridge))) {
qemudLog(QEMUD_WARN, _("Failed to delete bridge '%s' : %s"),
- network->bridge, strerror(err));
+ network->def->bridge, strerror(err));
}
return -1;
@@ -1523,12 +1509,12 @@
static int qemudShutdownNetworkDaemon(virConnectPtr conn ATTRIBUTE_UNUSED,
struct qemud_driver *driver,
- struct qemud_network *network) {
+ virNetworkObjPtr network) {
int err;
qemudLog(QEMUD_INFO, _("Shutting down network '%s'"),
network->def->name);
- if (!qemudIsActiveNetwork(network))
+ if (!virNetworkIsActive(network))
return 0;
if (network->dnsmasqPid > 0)
@@ -1536,15 +1522,15 @@
qemudRemoveIptablesRules(driver, network);
- if (network->def->ipAddress[0] &&
- (err = brSetInterfaceUp(driver->brctl, network->bridge, 0))) {
+ if (network->def->ipAddress &&
+ (err = brSetInterfaceUp(driver->brctl, network->def->bridge, 0))) {
qemudLog(QEMUD_WARN, _("Failed to bring down bridge '%s' :
%s"),
- network->bridge, strerror(err));
+ network->def->bridge, strerror(err));
}
- if ((err = brDeleteBridge(driver->brctl, network->bridge))) {
+ if ((err = brDeleteBridge(driver->brctl, network->def->bridge))) {
qemudLog(QEMUD_WARN, _("Failed to delete bridge '%s' : %s"),
- network->bridge, strerror(err));
+ network->def->bridge, strerror(err));
}
if (network->dnsmasqPid > 0 &&
@@ -1555,21 +1541,18 @@
"%s", _("Got unexpected pid for dnsmasq"));
}
- network->bridge[0] = '\0';
network->dnsmasqPid = -1;
network->active = 0;
if (network->newDef) {
- qemudFreeNetworkDef(network->def);
+ virNetworkDefFree(network->def);
network->def = network->newDef;
network->newDef = NULL;
}
- driver->nactivenetworks--;
- driver->ninactivenetworks++;
-
- if (!network->configFile[0])
- qemudRemoveInactiveNetwork(driver, network);
+ if (!network->configFile)
+ virNetworkRemoveInactive(&driver->networks,
+ network);
return 0;
}
@@ -3286,9 +3269,9 @@
}
static virNetworkPtr qemudNetworkLookupByUUID(virConnectPtr conn ATTRIBUTE_UNUSED,
- const unsigned char *uuid) {
+ const unsigned char *uuid) {
struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
- struct qemud_network *network = qemudFindNetworkByUUID(driver, uuid);
+ virNetworkObjPtr network = virNetworkFindByUUID(driver->networks, uuid);
virNetworkPtr net;
if (!network) {
@@ -3301,9 +3284,9 @@
return net;
}
static virNetworkPtr qemudNetworkLookupByName(virConnectPtr conn ATTRIBUTE_UNUSED,
- const char *name) {
+ const char *name) {
struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
- struct qemud_network *network = qemudFindNetworkByName(driver, name);
+ virNetworkObjPtr network = virNetworkFindByName(driver->networks, name);
virNetworkPtr net;
if (!network) {
@@ -3333,16 +3316,23 @@
}
static int qemudNumNetworks(virConnectPtr conn) {
+ int nactive = 0;
struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
- return driver->nactivenetworks;
+ virNetworkObjPtr net = driver->networks;
+ while (net) {
+ if (virNetworkIsActive(net))
+ nactive++;
+ net = net->next;
+ }
+ return nactive;
}
static int qemudListNetworks(virConnectPtr conn, char **const names, int nnames) {
struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
- struct qemud_network *network = driver->networks;
+ virNetworkObjPtr network = driver->networks;
int got = 0, i;
while (network && got < nnames) {
- if (qemudIsActiveNetwork(network)) {
+ if (virNetworkIsActive(network)) {
if (!(names[got] = strdup(network->def->name))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
"%s", _("failed to allocate space for VM name
string"));
@@ -3361,16 +3351,24 @@
}
static int qemudNumDefinedNetworks(virConnectPtr conn) {
+ int ninactive = 0;
struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
- return driver->ninactivenetworks;
+ virNetworkObjPtr net = driver->networks;
+ while (net) {
+ if (!virNetworkIsActive(net))
+ ninactive++;
+ net = net->next;
+ }
+ return ninactive;
}
static int qemudListDefinedNetworks(virConnectPtr conn, char **const names, int nnames)
{
struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
- struct qemud_network *network = driver->networks;
+ virNetworkObjPtr network = driver->networks;
int got = 0, i;
while (network && got < nnames) {
- if (!qemudIsActiveNetwork(network)) {
+ if (!virNetworkIsActive
+(network)) {
if (!(names[got] = strdup(network->def->name))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
"%s", _("failed to allocate space for VM name
string"));
@@ -3390,20 +3388,23 @@
static virNetworkPtr qemudNetworkCreate(virConnectPtr conn, const char *xml) {
struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
- struct qemud_network_def *def;
- struct qemud_network *network;
+ virNetworkDefPtr def;
+ virNetworkObjPtr network;
virNetworkPtr net;
- if (!(def = qemudParseNetworkDef(conn, driver, xml, NULL)))
+ if (!(def = virNetworkDefParse(conn, xml, NULL)))
return NULL;
- if (!(network = qemudAssignNetworkDef(conn, driver, def))) {
- qemudFreeNetworkDef(def);
+ if (!(network = virNetworkAssignDef(conn,
+ &driver->networks,
+ def))) {
+ virNetworkDefFree(def);
return NULL;
}
if (qemudStartNetworkDaemon(conn, driver, network) < 0) {
- qemudRemoveInactiveNetwork(driver, network);
+ virNetworkRemoveInactive(&driver->networks,
+ network);
return NULL;
}
@@ -3413,30 +3414,31 @@
static virNetworkPtr qemudNetworkDefine(virConnectPtr conn, const char *xml) {
struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
- struct qemud_network_def *def;
- struct qemud_network *network;
- virNetworkPtr net;
+ virNetworkDefPtr def;
+ virNetworkObjPtr network;
- if (!(def = qemudParseNetworkDef(conn, driver, xml, NULL)))
+ if (!(def = virNetworkDefParse(conn, xml, NULL)))
return NULL;
- if (!(network = qemudAssignNetworkDef(conn, driver, def))) {
- qemudFreeNetworkDef(def);
+ if (!(network = virNetworkAssignDef(conn,
+ &driver->networks,
+ def))) {
+ virNetworkDefFree(def);
return NULL;
}
- if (qemudSaveNetworkDef(conn, driver, network, def) < 0) {
- qemudRemoveInactiveNetwork(driver, network);
+ if (qemudSaveNetworkDef(conn, driver, network, 1) < 0) {
+ virNetworkRemoveInactive(&driver->networks,
+ network);
return NULL;
}
- net = virGetNetwork(conn, network->def->name, network->def->uuid);
- return net;
+ return virGetNetwork(conn, network->def->name, network->def->uuid);
}
static int qemudNetworkUndefine(virNetworkPtr net) {
struct qemud_driver *driver = (struct qemud_driver
*)net->conn->networkPrivateData;
- struct qemud_network *network = qemudFindNetworkByUUID(driver, net->uuid);
+ virNetworkObjPtr network = virNetworkFindByUUID(driver->networks, net->uuid);
if (!network) {
qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_DOMAIN,
@@ -3444,24 +3446,36 @@
return -1;
}
+ if (virNetworkIsActive(network)) {
+ qemudReportError(net->conn, NULL, net, VIR_ERR_INTERNAL_ERROR,
+ "%s", _("network is still active"));
+ return -1;
+ }
+
+ if (!network->configFile) {
+ qemudReportError(net->conn, NULL, net, VIR_ERR_INTERNAL_ERROR,
+ "%s", _("network has no config file"));
+ return -1;
+ }
+
if (qemudDeleteConfig(net->conn, driver, network->configFile,
network->def->name) < 0)
return -1;
- if (unlink(network->autostartLink) < 0 && errno != ENOENT &&
errno != ENOTDIR)
+ if (network->autostartLink &&
+ unlink(network->autostartLink) < 0 &&
+ errno != ENOENT && errno != ENOTDIR)
qemudLog(QEMUD_WARN, _("Failed to delete autostart link '%s':
%s"),
network->autostartLink, strerror(errno));
- network->configFile[0] = '\0';
- network->autostartLink[0] = '\0';
-
- qemudRemoveInactiveNetwork(driver, network);
+ virNetworkRemoveInactive(&driver->networks,
+ network);
return 0;
}
static int qemudNetworkStart(virNetworkPtr net) {
struct qemud_driver *driver = (struct qemud_driver
*)net->conn->networkPrivateData;
- struct qemud_network *network = qemudFindNetworkByUUID(driver, net->uuid);
+ virNetworkObjPtr network = virNetworkFindByUUID(driver->networks, net->uuid);
if (!network) {
qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK,
@@ -3474,7 +3488,7 @@
static int qemudNetworkDestroy(virNetworkPtr net) {
struct qemud_driver *driver = (struct qemud_driver
*)net->conn->networkPrivateData;
- struct qemud_network *network = qemudFindNetworkByUUID(driver, net->uuid);
+ virNetworkObjPtr network = virNetworkFindByUUID(driver->networks, net->uuid);
int ret;
if (!network) {
@@ -3490,7 +3504,7 @@
static char *qemudNetworkDumpXML(virNetworkPtr net, int flags ATTRIBUTE_UNUSED) {
struct qemud_driver *driver = (struct qemud_driver
*)net->conn->networkPrivateData;
- struct qemud_network *network = qemudFindNetworkByUUID(driver, net->uuid);
+ virNetworkObjPtr network = virNetworkFindByUUID(driver->networks, net->uuid);
if (!network) {
qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK,
@@ -3498,12 +3512,12 @@
return NULL;
}
- return qemudGenerateNetworkXML(net->conn, driver, network, network->def);
+ return virNetworkDefFormat(net->conn, network->def);
}
static char *qemudNetworkGetBridgeName(virNetworkPtr net) {
struct qemud_driver *driver = (struct qemud_driver
*)net->conn->networkPrivateData;
- struct qemud_network *network = qemudFindNetworkByUUID(driver, net->uuid);
+ virNetworkObjPtr network = virNetworkFindByUUID(driver->networks, net->uuid);
char *bridge;
if (!network) {
qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK,
@@ -3511,7 +3525,7 @@
return NULL;
}
- bridge = strdup(network->bridge);
+ bridge = strdup(network->def->bridge);
if (!bridge) {
qemudReportError(net->conn, NULL, net, VIR_ERR_NO_MEMORY,
"%s", _("failed to allocate space for network bridge
string"));
@@ -3523,7 +3537,7 @@
static int qemudNetworkGetAutostart(virNetworkPtr net,
int *autostart) {
struct qemud_driver *driver = (struct qemud_driver
*)net->conn->networkPrivateData;
- struct qemud_network *network = qemudFindNetworkByUUID(driver, net->uuid);
+ virNetworkObjPtr network = virNetworkFindByUUID(driver->networks, net->uuid);
if (!network) {
qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK,
@@ -3539,7 +3553,7 @@
static int qemudNetworkSetAutostart(virNetworkPtr net,
int autostart) {
struct qemud_driver *driver = (struct qemud_driver
*)net->conn->networkPrivateData;
- struct qemud_network *network = qemudFindNetworkByUUID(driver, net->uuid);
+ virNetworkObjPtr network = virNetworkFindByUUID(driver->networks, net->uuid);
if (!network) {
qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK,
--
|: 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 :|
11:28 a.m.
New subject: [libvirt] PATCH: 2/2: port QEMU driver to new domain APIs
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).
src/qemu_conf.c | 2552 +------------------
src/qemu_conf.h | 366 --
src/qemu_driver.c | 443 +--
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 | 26
tests/qemuxml2xmltest.c | 20
10 files changed, 486 insertions(+), 2938 deletions(-)
Regards,
Daniel
diff -r 286320a1cbc8 src/qemu_conf.c
--- a/src/qemu_conf.c Sun Jun 22 18:04:01 2008 -0400
+++ b/src/qemu_conf.c Sun Jun 22 18:08:24 2008 -0400
@@ -57,6 +57,15 @@
#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)
void qemudReportError(virConnectPtr conn,
@@ -64,12 +73,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 +95,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 +146,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 +403,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 +466,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 +543,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,7 +560,7 @@
int err;
int tapfd = -1;
- if (net->type == QEMUD_NET_NETWORK) {
+ if (net->type == VIR_DOMAIN_NET_TYPE_NETWORK) {
if (!(network = virNetworkFindByName(driver->networks,
net->dst.network.name))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("Network '%s' not found"),
@@ -2249,15 +573,15 @@
goto error;
}
brname = network->def->bridge;
- if (net->dst.network.ifname[0] == '\0' ||
+ if (!net->dst.network.ifname ||
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) {
+ } else if (net->type == VIR_DOMAIN_NET_TYPE_BRIDGE) {
brname = net->dst.bridge.brname;
- if (net->dst.bridge.ifname[0] == '\0' ||
+ if (!net->dst.bridge.ifname ||
STRPREFIX(net->dst.bridge.ifname, "vnet") ||
strchr(net->dst.bridge.ifname, '%')) {
strcpy(net->dst.bridge.ifname, "vnet%d");
@@ -2291,11 +615,10 @@
if (!(retval = strdup(tapfdstr)))
goto no_memory;
- if (VIR_ALLOC_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 +632,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 +710,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 +745,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 +773,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 +787,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 +798,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 +807,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 +838,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 +856,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 +881,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 +889,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 +923,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 +964,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,17 +973,19 @@
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",
@@ -2674,20 +998,20 @@
}
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;
}
@@ -2702,7 +1026,7 @@
}
break;
- case QEMUD_NET_USER:
+ case VIR_DOMAIN_NET_TYPE_USER:
default:
{
char arg[PATH_MAX];
@@ -2754,19 +1078,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 +1105,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 +1134,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 +1151,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 +1165,11 @@
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) {
+ for (i = 0; ntapfds; i++)
+ close((*tapfds)[i]);
+ VIR_FREE(*tapfds);
+ *ntapfds = 0;
}
if (qargv) {
for (i = 0 ; i < qargc ; i++)
@@ -2863,14 +1186,16 @@
/* 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) {
+ struct qemud_driver *driver ATTRIBUTE_UNUSED,
+ virDomainObjPtr vm,
+ int active) {
char *xml;
int fd = -1, ret = -1;
int towrite;
- if (!(xml = qemudGenerateXML(conn, driver, vm, def, 0)))
+ if (!(xml = virDomainDefFormat(conn,
+ !active && vm->newDef ? vm->newDef :
vm->def,
+ 1)))
return -1;
if ((fd = open(vm->configFile,
@@ -2908,6 +1233,7 @@
return ret;
}
+#if 0
struct qemud_vm_device_def *
qemudParseVMDeviceDef(virConnectPtr conn,
const struct qemud_vm_def *def,
@@ -2963,102 +1289,16 @@
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;
+#endif
- 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') {
+qemudSaveDomainDef(virConnectPtr conn,
+ struct qemud_driver *driver,
+ virDomainObjPtr domain,
+ int active) {
+ if (!domain->configFile) {
+ char buf[PATH_MAX];
int err;
if ((err = virFileMakePath(driver->configDir))) {
@@ -3068,23 +1308,31 @@
return -1;
}
- if (virFileBuildPath(driver->configDir, def->name, ".xml",
- vm->configFile, PATH_MAX) < 0) {
+ if (virFileBuildPath(driver->configDir, domain->def->name,
".xml",
+ buf, sizeof(buf)) < 0) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot construct config file
path"));
return -1;
}
+ if (!(domain->configFile = strdup(buf))) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ return -1;
+ }
- if (virFileBuildPath(driver->autostartDir, def->name, ".xml",
- vm->autostartLink, PATH_MAX) < 0) {
+ if (virFileBuildPath(driver->autostartDir, domain->def->name,
".xml",
+ buf, sizeof(buf)) < 0) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot construct autostart link
path"));
- vm->configFile[0] = '\0';
+ return -1;
+ }
+ if (!(domain->autostartLink = strdup(buf))) {
+ VIR_FREE(domain->configFile);
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
return -1;
}
}
- return qemudSaveConfig(conn, driver, vm, def);
+ return qemudSaveConfig(conn, driver, domain, active);
}
static int qemudSaveNetworkConfig(virConnectPtr conn,
@@ -3186,16 +1434,16 @@
}
-static struct qemud_vm *
+static virDomainObjPtr
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;
+ virDomainDefPtr def;
+ virDomainObjPtr vm;
- if (!(def = qemudParseVMDef(NULL, driver, xml, file))) {
+ if (!(def = virDomainDefParse(NULL, driver->caps, xml, file))) {
virErrorPtr err = virGetLastError();
qemudLog(QEMUD_WARN, _("Error parsing QEMU guest config '%s' :
%s"),
path, (err ? err->message :
@@ -3208,23 +1456,30 @@
_("QEMU guest config filename '%s'"
" does not match guest name '%s'"),
path, def->name);
- qemudFreeVMDef(def);
+ virDomainDefFree(def);
return NULL;
}
- if (!(vm = qemudAssignVMDef(NULL, driver, def))) {
+ if (!(vm = virDomainAssignDef(NULL,
+ &driver->domains,
+ def))) {
qemudLog(QEMUD_WARN,
_("Failed to load QEMU guest config '%s': out of
memory"),
path);
- qemudFreeVMDef(def);
+ virDomainDefFree(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';
+ if (!(vm->configFile = strdup(path))) {
+ virDomainRemoveInactive(&driver->domains,
+ vm);
+ return NULL;
+ }
+ if (!(vm->autostartLink = strdup(autostartLink))) {
+ virDomainRemoveInactive(&driver->domains,
+ vm);
+ return NULL;
+ }
vm->autostart = virFileLinkPointsTo(vm->autostartLink, vm->configFile);
@@ -3321,7 +1576,7 @@
continue;
}
- if (virFileReadAll(path, QEMUD_MAX_XML_LEN, &xml) < 0)
+ if (virFileReadAll(path,16000, &xml) < 0)
continue;
if (isGuest)
@@ -3348,411 +1603,12 @@
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]) {
+ if (!configFile) {
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
_("no config file for %s"), name);
return -1;
diff -r 286320a1cbc8 src/qemu_conf.h
--- a/src/qemu_conf.h Sun Jun 22 18:04:01 2008 -0400
+++ b/src/qemu_conf.h Sun Jun 22 18:08:24 2008 -0400
@@ -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,21 +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);
+ virDomainObjPtr dom,
+ int qemuCmdFlags,
+ char ***argv,
+ int **tapfds,
+ int *ntapfds,
+ const char *migrateFrom);
int qemudScanConfigs (struct qemud_driver *driver);
int qemudDeleteConfig (virConnectPtr conn,
@@ -408,43 +106,15 @@
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,
+int qemudSaveDomainDef (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 domain,
+ int active);
int qemudSaveNetworkDef (virConnectPtr conn,
struct qemud_driver *driver,
virNetworkObjPtr network,
int active);
-const char *qemudVirtTypeToString (int type);
-
#endif /* WITH_QEMU */
#endif /* __QEMUD_CONF_H */
diff -r 286320a1cbc8 src/qemu_driver.c
--- a/src/qemu_driver.c Sun Jun 22 18:04:01 2008 -0400
+++ b/src/qemu_driver.c Sun Jun 22 18:08:24 2008 -0400
@@ -110,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,
@@ -126,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);
@@ -136,7 +137,7 @@
static
void qemudAutostartConfigs(struct qemud_driver *driver) {
virNetworkObjPtr network;
- struct qemud_vm *vm;
+ virDomainObjPtr vm;
network = driver->networks;
while (network != NULL) {
@@ -153,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);
@@ -188,8 +189,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;
@@ -200,8 +202,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,
@@ -248,11 +251,6 @@
return 0;
- snprintf_error:
- qemudLog(QEMUD_ERR,
- "%s", _("Resulting path to long for buffer in
qemudInitPaths()"));
- return -1;
-
out_of_memory:
qemudLog (QEMUD_ERR,
"%s", _("qemudStartup: out of memory"));
@@ -292,15 +290,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;
@@ -313,7 +315,7 @@
*/
static int
qemudShutdown(void) {
- struct qemud_vm *vm;
+ virDomainObjPtr vm;
virNetworkObjPtr network;
if (!qemu_driver)
@@ -322,26 +324,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;
@@ -361,6 +362,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);
@@ -380,14 +382,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,
@@ -460,7 +462,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)
{
@@ -474,7 +476,7 @@
static int qemudOpenMonitor(virConnectPtr conn,
struct qemud_driver *driver,
- struct qemud_vm *vm,
+ virDomainObjPtr vm,
const char *monitor) {
int monfd;
char buf[1024];
@@ -551,13 +553,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
@@ -571,10 +573,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;
@@ -583,10 +585,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;
@@ -598,7 +600,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,
@@ -619,14 +621,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;
@@ -637,7 +639,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;
}
@@ -719,7 +721,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;
@@ -800,28 +802,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 */
@@ -865,16 +872,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;
@@ -897,24 +914,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) {
@@ -938,7 +950,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;
@@ -967,8 +979,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);
@@ -1002,35 +1014,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;
}
@@ -1560,10 +1572,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;
@@ -1582,7 +1594,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;
@@ -1852,9 +1864,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) {
@@ -1863,13 +1875,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) {
@@ -1878,13 +1890,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) {
@@ -1893,7 +1905,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;
}
@@ -1930,11 +1942,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;
@@ -1943,30 +1955,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 = virDomainDefParse(conn, driver->caps, xml, NULL)))
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;
}
@@ -1974,12 +1996,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;
@@ -2002,13 +2024,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;
@@ -2029,7 +2051,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) {
@@ -2050,7 +2072,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,
@@ -2059,8 +2081,9 @@
}
qemudShutdownVMDaemon(dom->conn, driver, vm);
- if (!vm->configFile[0])
- qemudRemoveInactiveVM(driver, vm);
+ if (!vm->configFile)
+ virDomainRemoveInactive(&driver->domains,
+ vm);
return 0;
}
@@ -2068,7 +2091,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) {
@@ -2088,7 +2111,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,
@@ -2101,7 +2124,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,
@@ -2121,7 +2144,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,
@@ -2129,7 +2152,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;
@@ -2146,9 +2169,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"));
@@ -2157,7 +2180,7 @@
info->state = vm->state;
- if (!qemudIsActiveVM(vm)) {
+ if (!virDomainIsActive(vm)) {
info->cpuTime = 0;
} else {
if (qemudGetProcessInfo(&(info->cpuTime), vm->pid) < 0) {
@@ -2269,7 +2292,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;
@@ -2286,7 +2309,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;
@@ -2303,7 +2326,7 @@
}
/* Get XML for the domain */
- xml = qemudGenerateXML(dom->conn, driver, vm, vm->def, 0);
+ xml = virDomainDefFormat(dom->conn, vm->def, 1);
if (!xml) {
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
"%s", _("failed to get domain xml"));
@@ -2367,8 +2390,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;
}
@@ -2376,7 +2400,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) {
@@ -2385,7 +2409,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;
@@ -2416,12 +2440,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;
@@ -2469,11 +2493,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;
@@ -2534,7 +2558,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;
@@ -2544,7 +2568,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);
@@ -2562,8 +2586,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;
@@ -2614,7 +2638,7 @@
}
/* Create a domain from this XML */
- if (!(def = qemudParseVMDef(conn, driver, xml, NULL))) {
+ if (!(def = virDomainDefParse(conn, driver->caps, xml, NULL))) {
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
"%s", _("failed to parse XML"));
close(fd);
@@ -2624,35 +2648,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;
}
@@ -2673,26 +2699,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 & VIR_DOMAIN_XML_SECURE) ? 1 : 0);
}
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"));
@@ -2713,13 +2742,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,
@@ -2727,37 +2763,40 @@
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 = virDomainDefParse(conn, driver->caps, xml, NULL)))
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 (qemudSaveDomainDef(conn, driver, vm, 1) < 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,
@@ -2765,7 +2804,7 @@
return -1;
}
- if (qemudIsActiveVM(vm)) {
+ if (virDomainIsActive(vm)) {
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot delete active domain"));
return -1;
@@ -2778,22 +2817,20 @@
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,
@@ -2833,9 +2870,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,
@@ -2843,18 +2880,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);
@@ -2863,8 +2901,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;
}
@@ -2876,7 +2914,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;
}
@@ -2888,7 +2926,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,
@@ -2904,7 +2942,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,
@@ -2962,14 +3000,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;
@@ -3096,8 +3134,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,
@@ -3105,7 +3143,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;
@@ -3120,15 +3158,15 @@
/* 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:
+ case VIR_DOMAIN_NET_TYPE_NETWORK:
if (STREQ (net->dst.network.ifname, path))
goto ok;
break;
- case QEMUD_NET_ETHERNET:
+ case VIR_DOMAIN_NET_TYPE_ETHERNET:
if (STREQ (net->dst.ethernet.ifname, path))
goto ok;
break;
- case QEMUD_NET_BRIDGE:
+ case VIR_DOMAIN_NET_TYPE_BRIDGE:
if (STREQ (net->dst.bridge.ifname, path))
goto ok;
break;
@@ -3156,8 +3194,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) {
@@ -3173,8 +3211,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"));
@@ -3213,7 +3252,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;
@@ -3230,7 +3269,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;
@@ -3387,7 +3426,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 286320a1cbc8 tests/qemuxml2argvdata/qemuxml2argv-bootloader.xml
--- a/tests/qemuxml2argvdata/qemuxml2argv-bootloader.xml Sun Jun 22 18:04:01 2008 -0400
+++ b/tests/qemuxml2argvdata/qemuxml2argv-bootloader.xml Sun Jun 22 18:08:24 2008 -0400
@@ -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 286320a1cbc8 tests/qemuxml2argvdata/qemuxml2argv-graphics-vnc.xml
--- a/tests/qemuxml2argvdata/qemuxml2argv-graphics-vnc.xml Sun Jun 22 18:04:01 2008 -0400
+++ b/tests/qemuxml2argvdata/qemuxml2argv-graphics-vnc.xml Sun Jun 22 18:08:24 2008 -0400
@@ -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 286320a1cbc8 tests/qemuxml2argvdata/qemuxml2argv-input-xen.args
--- a/tests/qemuxml2argvdata/qemuxml2argv-input-xen.args Sun Jun 22 18:04:01 2008 -0400
+++ b/tests/qemuxml2argvdata/qemuxml2argv-input-xen.args Sun Jun 22 18:08:24 2008 -0400
@@ -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 286320a1cbc8 tests/qemuxml2argvdata/qemuxml2argv-input-xen.xml
--- a/tests/qemuxml2argvdata/qemuxml2argv-input-xen.xml Sun Jun 22 18:04:01 2008 -0400
+++ b/tests/qemuxml2argvdata/qemuxml2argv-input-xen.xml Sun Jun 22 18:08:24 2008 -0400
@@ -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 286320a1cbc8 tests/qemuxml2argvdata/qemuxml2argv-sound.xml
--- a/tests/qemuxml2argvdata/qemuxml2argv-sound.xml Sun Jun 22 18:04:01 2008 -0400
+++ b/tests/qemuxml2argvdata/qemuxml2argv-sound.xml Sun Jun 22 18:08:24 2008 -0400
@@ -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 286320a1cbc8 tests/qemuxml2argvtest.c
--- a/tests/qemuxml2argvtest.c Sun Jun 22 18:04:01 2008 -0400
+++ b/tests/qemuxml2argvtest.c Sun Jun 22 18:08:24 2008 -0400
@@ -30,9 +30,9 @@
char *actualargv = NULL;
char **argv = NULL;
char **tmp = NULL;
- int ret = -1, len;
- struct qemud_vm_def *vmdef = NULL;
- struct qemud_vm vm;
+ int ret = -1, len, flags;
+ virDomainDefPtr vmdef = NULL;
+ virDomainObj vm;
if (virtTestLoadFile(xml, &xmlPtr, MAX_FILE) < 0)
goto fail;
@@ -40,22 +40,21 @@
if (virtTestLoadFile(cmd, &expectargv, MAX_FILE) < 0)
goto fail;
- if (!(vmdef = qemudParseVMDef(NULL, &driver, xmlData, "test")))
+ if (!(vmdef = virDomainDefParse(NULL, driver.caps, xmlData, "test")))
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 +91,7 @@
}
free(argv);
}
- if (vmdef)
- qemudFreeVMDef(vmdef);
+ virDomainDefFree(vmdef);
return ret;
}
diff -r 286320a1cbc8 tests/qemuxml2xmltest.c
--- a/tests/qemuxml2xmltest.c Sun Jun 22 18:04:01 2008 -0400
+++ b/tests/qemuxml2xmltest.c Sun Jun 22 18:08:24 2008 -0400
@@ -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 = virDomainDefParse(NULL, driver.caps, xmlData, "test")))
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 :|
6029
days inactive
6029
days old
2 comments
1 participants
participants (1)
-
Daniel P. Berrange