External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-02-01 17:35:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fri Feb 23 08:41:34 IST 2007 Mark McLoughlin <markmc@redhat.com>

Browse Source 
* qemud/conf.[ch]: significantly re-factor qemudLoadConfigXML()
        so that "parse the XML", "assign the def to a VM" and
        "save the XML" operations are in separate functions.
        Add qemudRemoveInactiveVM() and qemudRemoveInactiveNetwork().
        Report errors when loading config files at startup. Check
        that a domain/network's name matches the config filename.

        * qemud/driver.c: update the Create() and Define() functions
        to explicitly parse/assign/save. Also, fix bug where if
        Create() failed, we would free the VM without removing it
        from the inactive list.

        * qemud/qemud.c: use qemudRemoveInactiveVM/Network()
This commit is contained in:
Mark McLoughlin 2007-02-23 08:48:02 +00:00
parent 593d20d400
commit d954480892
5 changed files with 420 additions and 241 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
ChangeLog
View File

@ -1,3 +1,19 @@
Fri Feb 23 08:41:34 IST 2007 Mark McLoughlin <markmc@redhat.com>
* qemud/conf.[ch]: significantly re-factor qemudLoadConfigXML()
so that "parse the XML", "assign the def to a VM" and
"save the XML" operations are in separate functions.
Add qemudRemoveInactiveVM() and qemudRemoveInactiveNetwork().
Report errors when loading config files at startup. Check
that a domain/network's name matches the config filename.
* qemud/driver.c: update the Create() and Define() functions
to explicitly parse/assign/save. Also, fix bug where if
Create() failed, we would free the VM without removing it
from the inactive list.
* qemud/qemud.c: use qemudRemoveInactiveVM/Network()
Fri Feb 23 08:40:52 IST 2007 Mark McLoughlin <markmc@redhat.com>
* qemud/driver.[ch], qemud/dispatch.c: fix the fact that

435
qemud/conf.c
View File

@ -1140,22 +1140,14 @@ int qemudBuildCommandLine(struct qemud_server *server,
/* Save a guest's config data into a persistent file */
static int qemudSaveConfig(struct qemud_server *server,
struct qemud_vm *vm) {
struct qemud_vm *vm,
struct qemud_vm_def *def) {
char *xml;
int fd = -1, ret = -1;
int towrite;
int err;
if (!(xml = qemudGenerateXML(server, vm, 0))) {
if (!(xml = qemudGenerateXML(server, vm, def, 0)))
return -1;
}
if ((err = qemudEnsureDir(server->configDir))) {
qemudReportError(server, VIR_ERR_INTERNAL_ERROR,
"cannot create config directory %s: %s",
server->configDir, strerror(err));
goto cleanup;
}
if ((fd = open(vm->configFile,
O_WRONLY | O_CREAT | O_TRUNC,
@ -1192,31 +1184,33 @@ static int qemudSaveConfig(struct qemud_server *server,
return ret;
}
/* Create a qemud_vm instance, populating it based on the data
* in a libvirt XML document describing the guest */
struct qemud_vm *qemudLoadConfigXML(struct qemud_server *server,
const char *file,
const char *doc,
int save) {
struct qemud_vm_def *def = NULL;
struct qemud_vm *vm = NULL;
struct qemud_vm_def *
qemudParseVMDef(struct qemud_server *server,
const char *xmlStr,
const char *displayName) {
xmlDocPtr xml;
int newVM = 0;
struct qemud_vm_def *def = NULL;
if (!(xml = xmlReadDoc(BAD_CAST doc, file ? file : "domain.xml", NULL,
if (!(xml = xmlReadDoc(BAD_CAST xmlStr, displayName ? displayName : "domain.xml", NULL,
XML_PARSE_NOENT | XML_PARSE_NONET |
XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) {
qemudReportError(server, VIR_ERR_XML_ERROR, NULL);
return NULL;
}
if (!(def = qemudParseXML(server, xml))) {
xmlFreeDoc(xml);
return NULL;
}
def = qemudParseXML(server, xml);
xmlFreeDoc(xml);
return def;
}
struct qemud_vm *
qemudAssignVMDef(struct qemud_server *server,
struct qemud_vm_def *def)
{
struct qemud_vm *vm = NULL;
if ((vm = qemudFindVMByName(server, def->name))) {
if (!qemudIsActiveVM(vm)) {
qemudFreeVMDef(vm->def);
@ -1226,63 +1220,87 @@ struct qemud_vm *qemudLoadConfigXML(struct qemud_server *server,
qemudFreeVMDef(vm->newDef);
vm->newDef = def;
}
} else {
if (!(vm = calloc(1, sizeof(struct qemud_vm)))) {
qemudReportError(server, VIR_ERR_NO_MEMORY, "vm");
qemudFreeVMDef(def);
return NULL;
}
vm->stdout = -1;
vm->stderr = -1;
vm->monitor = -1;
vm->pid = -1;
vm->id = -1;
vm->def = def;
newVM = 1;
return vm;
}
if (file) {
strncpy(vm->configFile, file, PATH_MAX);
vm->configFile[PATH_MAX-1] = '\0';
} else {
if (save) {
if (qemudMakeConfigPath(server->configDir, vm->def->name, ".xml", vm->configFile, PATH_MAX) < 0) {
qemudReportError(server, VIR_ERR_INTERNAL_ERROR,
"cannot construct config file path");
if (newVM)
qemudFreeVM(vm);
return NULL;
}
if (qemudSaveConfig(server, vm) < 0) {
if (newVM)
qemudFreeVM(vm);
return NULL;
}
} else {
vm->configFile[0] = '\0';
}
if (!(vm = calloc(1, sizeof(struct qemud_vm)))) {
qemudReportError(server, VIR_ERR_NO_MEMORY, "vm");
return NULL;
}
if (newVM) {
vm->next = server->vms;
server->vms = vm;
server->ninactivevms++;
}
vm->stdout = -1;
vm->stderr = -1;
vm->monitor = -1;
vm->pid = -1;
vm->id = -1;
vm->def = def;
vm->next = server->vms;
server->vms = vm;
server->ninactivevms++;
return vm;
}
void
qemudRemoveInactiveVM(struct qemud_server *server,
struct qemud_vm *vm)
{
struct qemud_vm *prev = NULL, *curr;
curr = server->vms;
while (curr != vm) {
prev = curr;
curr = curr->next;
}
if (curr) {
if (prev)
prev->next = curr->next;
else
server->vms = curr->next;
server->ninactivevms--;
}
qemudFreeVM(vm);
}
int
qemudSaveVMDef(struct qemud_server *server,
struct qemud_vm *vm,
struct qemud_vm_def *def) {
if (vm->configFile[0] == '\0') {
int err;
if ((err = qemudEnsureDir(server->configDir))) {
qemudReportError(server, VIR_ERR_INTERNAL_ERROR,
"cannot create config directory %s: %s",
server->configDir, strerror(err));
return -1;
}
if (qemudMakeConfigPath(server->configDir, def->name, ".xml",
vm->configFile, PATH_MAX) < 0) {
qemudReportError(server, VIR_ERR_INTERNAL_ERROR,
"cannot construct config file path");
return -1;
}
}
return qemudSaveConfig(server, vm, def);
}
static int qemudSaveNetworkConfig(struct qemud_server *server,
struct qemud_network *network) {
struct qemud_network *network,
struct qemud_network_def *def) {
char *xml;
int fd, ret = -1;
int towrite;
int err;
if (!(xml = qemudGenerateNetworkXML(server, network, 0))) {
if (!(xml = qemudGenerateNetworkXML(server, network, def))) {
return -1;
}
@ -1550,28 +1568,32 @@ static struct qemud_network_def *qemudParseNetworkXML(struct qemud_server *serve
return NULL;
}
struct qemud_network *qemudLoadNetworkConfigXML(struct qemud_server *server,
const char *file,
const char *doc,
int save) {
struct qemud_network_def *def = NULL;
struct qemud_network *network = NULL;
struct qemud_network_def *
qemudParseNetworkDef(struct qemud_server *server,
const char *xmlStr,
const char *displayName) {
xmlDocPtr xml;
int newNetwork = 0;
struct qemud_network_def *def;
if (!(xml = xmlReadDoc(BAD_CAST doc, file ? file : "network.xml", NULL,
if (!(xml = xmlReadDoc(BAD_CAST xmlStr, displayName ? displayName : "network.xml", NULL,
XML_PARSE_NOENT | XML_PARSE_NONET |
XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) {
qemudReportError(server, VIR_ERR_XML_ERROR, NULL);
return NULL;
}
if (!(def = qemudParseNetworkXML(server, xml))) {
xmlFreeDoc(xml);
return NULL;
}
def = qemudParseNetworkXML(server, xml);
xmlFreeDoc(xml);
return def;
}
struct qemud_network *
qemudAssignNetworkDef(struct qemud_server *server,
struct qemud_network_def *def) {
struct qemud_network *network;
if ((network = qemudFindNetworkByName(server, def->name))) {
if (!qemudIsActiveNetwork(network)) {
qemudFreeNetworkDef(network->def);
@ -1581,87 +1603,202 @@ struct qemud_network *qemudLoadNetworkConfigXML(struct qemud_server *server,
qemudFreeNetworkDef(network->newDef);
network->newDef = def;
}
} else {
if (!(network = calloc(1, sizeof(struct qemud_network)))) {
qemudReportError(server, VIR_ERR_NO_MEMORY, "network");
return NULL;
}
network->def = def;
newNetwork = 1;
return network;
}
if (file) {
strncpy(network->configFile, file, PATH_MAX);
network->configFile[PATH_MAX-1] = '\0';
} else {
if (save) {
if (qemudMakeConfigPath(server->networkConfigDir, network->def->name, ".xml", network->configFile, PATH_MAX) < 0) {
qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "cannot construct config file path");
if (newNetwork)
qemudFreeNetwork(network);
return NULL;
}
if (qemudSaveNetworkConfig(server, network) < 0) {
if (newNetwork)
qemudFreeNetwork(network);
return NULL;
}
} else {
network->configFile[0] = '\0';
}
if (!(network = calloc(1, sizeof(struct qemud_network)))) {
qemudReportError(server, VIR_ERR_NO_MEMORY, "network");
return NULL;
}
if (newNetwork) {
network->next = server->networks;
server->networks = network;
server->ninactivenetworks++;
}
network->def = def;
network->next = server->networks;
server->networks = network;
server->ninactivenetworks++;
return network;
}
void
qemudRemoveInactiveNetwork(struct qemud_server *server,
struct qemud_network *network)
{
struct qemud_network *prev = NULL, *curr;
/* Load a guest from its persistent config file */
static void qemudLoadConfig(struct qemud_server *server,
const char *file,
int isGuest) {
curr = server->networks;
while (curr != network) {
prev = curr;
curr = curr->next;
}
if (curr) {
if (prev)
prev->next = curr->next;
else
server->networks = curr->next;
server->ninactivenetworks--;
}
qemudFreeNetwork(network);
}
int
qemudSaveNetworkDef(struct qemud_server *server,
struct qemud_network *network,
struct qemud_network_def *def) {
if (network->configFile[0] == '\0') {
int err;
if ((err = qemudEnsureDir(server->networkConfigDir))) {
qemudReportError(server, VIR_ERR_INTERNAL_ERROR,
"cannot create config directory %s: %s",
server->networkConfigDir, strerror(err));
return -1;
}
if (qemudMakeConfigPath(server->networkConfigDir, def->name, ".xml",
network->configFile, PATH_MAX) < 0) {
qemudReportError(server, VIR_ERR_INTERNAL_ERROR,
"cannot construct config file path");
return -1;
}
}
return qemudSaveNetworkConfig(server, network, def);
}
static int
qemudReadFile(const char *path,
char *buf,
int maxlen) {
FILE *fh;
struct stat st;
char xml[QEMUD_MAX_XML_LEN];
int ret;
int ret = 0;
if (!(fh = fopen(file, "r"))) {
qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "cannot open config file %s", file);
return;
if (!(fh = fopen(path, "r"))) {
qemudLog(QEMUD_WARN, "Failed to open file '%s': %s",
path, strerror(errno));
goto error;
}
if (fstat(fileno(fh), &st) < 0) {
qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "cannot stat config file %s", file);
goto cleanup;
qemudLog(QEMUD_WARN, "Failed to stat file '%s': %s",
path, strerror(errno));
goto error;
}
if (st.st_size >= QEMUD_MAX_XML_LEN) {
qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "config too large in file %s", file);
goto cleanup;
if (S_ISDIR(st.st_mode)) {
qemudDebug("Ignoring directory '%s' - clearly not a config file", path);
goto error;
}
if ((ret = fread(xml, st.st_size, 1, fh)) != 1) {
qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "cannot read config file %s", file);
goto cleanup;
if (st.st_size >= maxlen) {
qemudLog(QEMUD_WARN, "File '%s' is too large", path);
goto error;
}
xml[st.st_size] = '\0';
if (isGuest) {
qemudLoadConfigXML(server, file, xml, 1);
} else {
qemudLoadNetworkConfigXML(server, file, xml, 1);
if ((ret = fread(buf, st.st_size, 1, fh)) != 1) {
qemudLog(QEMUD_WARN, "Failed to read config file '%s': %s",
path, strerror(errno));
goto error;
}
cleanup:
fclose(fh);
buf[st.st_size] = '\0';
ret = 1;
error:
if (fh)
fclose(fh);
return ret;
}
static int
compareFileToNameSuffix(const char *file,
const char *name,
const char *suffix) {
int filelen = strlen(file);
int namelen = strlen(name);
int suffixlen = strlen(suffix);
if (filelen == (namelen + suffixlen) &&
!strncmp(file, name, namelen) &&
!strncmp(file + namelen, suffix, suffixlen))
return 1;
else
return 0;
}
static struct qemud_vm *
qemudLoadConfig(struct qemud_server *server,
const char *file,
const char *path,
const char *xml) {
struct qemud_vm_def *def;
struct qemud_vm *vm;
if (!(def = qemudParseVMDef(server, xml, file))) {
qemudLog(QEMUD_WARN, "Error parsing QEMU guest config '%s' : %s",
path, server->errorMessage);
return NULL;
}
if (!compareFileToNameSuffix(file, def->name, ".xml")) {
qemudLog(QEMUD_WARN, "QEMU guest config filename '%s' does not match guest name '%s'",
path, def->name);
qemudFreeVMDef(def);
return NULL;
}
if (!(vm = qemudAssignVMDef(server, def))) {
qemudLog(QEMUD_WARN, "Failed to load QEMU guest config '%s': out of memory", path);
qemudFreeVMDef(def);
return NULL;
}
strncpy(vm->configFile, path, PATH_MAX);
vm->configFile[PATH_MAX-1] = '\0';
return vm;
}
static struct qemud_network *
qemudLoadNetworkConfig(struct qemud_server *server,
const char *file,
const char *path,
const char *xml) {
struct qemud_network_def *def;
struct qemud_network *network;
if (!(def = qemudParseNetworkDef(server, xml, file))) {
qemudLog(QEMUD_WARN, "Error parsing network config '%s' : %s",
path, server->errorMessage);
return NULL;
}
if (!compareFileToNameSuffix(file, def->name, ".xml")) {
qemudLog(QEMUD_WARN, "Network config filename '%s' does not match network name '%s'",
path, def->name);
qemudFreeNetworkDef(def);
return NULL;
}
if (!(network = qemudAssignNetworkDef(server, def))) {
qemudLog(QEMUD_WARN, "Failed to load network config '%s': out of memory", path);
qemudFreeNetworkDef(def);
return NULL;
}
strncpy(network->configFile, path, PATH_MAX);
network->configFile[PATH_MAX-1] = '\0';
return network;
}
static
int qemudScanConfigDir(struct qemud_server *server,
@ -1679,14 +1816,25 @@ int qemudScanConfigDir(struct qemud_server *server,
}
while ((entry = readdir(dir))) {
char file[PATH_MAX];
char xml[QEMUD_MAX_XML_LEN];
char path[PATH_MAX];
if (entry->d_name[0] == '.')
continue;
if (qemudMakeConfigPath(configDir, entry->d_name, NULL, file, PATH_MAX) < 0)
if (qemudMakeConfigPath(configDir, entry->d_name, NULL, path, PATH_MAX) < 0) {
qemudLog(QEMUD_WARN, "Config filename '%s/%s' is too long",
configDir, entry->d_name);
continue;
}
if (!qemudReadFile(path, xml, QEMUD_MAX_XML_LEN))
continue;
qemudLoadConfig(server, file, isGuest);
if (isGuest)
qemudLoadConfig(server, entry->d_name, path, xml);
else
qemudLoadNetworkConfig(server, entry->d_name, path, xml);
}
closedir(dir);
@ -1751,8 +1899,10 @@ int qemudBufferPrintf(struct qemudBuffer *buf,
}
/* Generate an XML document describing the guest's configuration */
char *qemudGenerateXML(struct qemud_server *server, struct qemud_vm *vm, int live) {
struct qemud_vm_def *def = live ? vm->def : (vm->newDef ? vm->newDef : vm->def);
char *qemudGenerateXML(struct qemud_server *server,
struct qemud_vm *vm,
struct qemud_vm_def *def,
int live) {
struct qemudBuffer buf;
unsigned char *uuid;
struct qemud_vm_disk_def *disk;
@ -1986,9 +2136,8 @@ char *qemudGenerateXML(struct qemud_server *server, struct qemud_vm *vm, int liv
char *qemudGenerateNetworkXML(struct qemud_server *server,
struct qemud_network *network,
int live) {
struct qemud_network_def *def = live ? network->def : (network->newDef ? network->newDef : network->def);
struct qemud_network *network ATTRIBUTE_UNUSED,
struct qemud_network_def *def) {
struct qemudBuffer buf;
unsigned char *uuid;

70
qemud/conf.h
View File

@ -26,33 +26,55 @@
#include "internal.h"
int qemudBuildCommandLine(struct qemud_server *server,
struct qemud_vm *vm,
char ***argv);
int qemudBuildCommandLine (struct qemud_server *server,
struct qemud_vm *vm,
char ***argv);
int qemudScanConfigs(struct qemud_server *server);
int qemudDeleteConfig(struct qemud_server *server,
const char *configFile,
const char *name);
int qemudScanConfigs (struct qemud_server *server);
int qemudDeleteConfig (struct qemud_server *server,
const char *configFile,
const char *name);
void qemudFreeVMDef(struct qemud_vm_def *vm);
void qemudFreeVM(struct qemud_vm *vm);
struct qemud_vm *qemudLoadConfigXML(struct qemud_server *server,
const char *file,
const char *doc,
int persist);
char *qemudGenerateXML(struct qemud_server *server,
struct qemud_vm *vm, int live);
void qemudFreeVMDef (struct qemud_vm_def *vm);
void qemudFreeVM (struct qemud_vm *vm);
void qemudFreeNetworkDef(struct qemud_network_def *def);
void qemudFreeNetwork(struct qemud_network *network);
struct qemud_network *qemudLoadNetworkConfigXML(struct qemud_server *server,
const char *file,
const char *doc,
int persist);
char *qemudGenerateNetworkXML(struct qemud_server *server,
struct qemud_network *network,
int live);
struct qemud_vm *
qemudAssignVMDef (struct qemud_server *server,
struct qemud_vm_def *def);
void qemudRemoveInactiveVM (struct qemud_server *server,
struct qemud_vm *vm);
struct qemud_vm_def *
qemudParseVMDef (struct qemud_server *server,
const char *xmlStr,
const char *displayName);
int qemudSaveVMDef (struct qemud_server *server,
struct qemud_vm *vm,
struct qemud_vm_def *def);
char * qemudGenerateXML (struct qemud_server *server,
struct qemud_vm *vm,
struct qemud_vm_def *def,
int live);
void qemudFreeNetworkDef (struct qemud_network_def *def);
void qemudFreeNetwork (struct qemud_network *network);
struct qemud_network *
qemudAssignNetworkDef (struct qemud_server *server,
struct qemud_network_def *def);
void qemudRemoveInactiveNetwork (struct qemud_server *server,
struct qemud_network *network);
struct qemud_network_def *
qemudParseNetworkDef (struct qemud_server *server,
const char *xmlStr,
const char *displayName);
int qemudSaveNetworkDef (struct qemud_server *server,
struct qemud_network *network,
struct qemud_network_def *def);
char * qemudGenerateNetworkXML (struct qemud_server *server,
struct qemud_network *network,
struct qemud_network_def *def);
#endif

95
qemud/driver.c
View File

@ -279,14 +279,20 @@ int qemudNumDomains(struct qemud_server *server) {
return server->nactivevms;
}
struct qemud_vm *qemudDomainCreate(struct qemud_server *server, const char *xml) {
struct qemud_vm_def *def;
struct qemud_vm *vm;
if (!(vm = qemudLoadConfigXML(server, NULL, xml, 0))) {
if (!(def = qemudParseVMDef(server, xml, NULL)))
return NULL;
if (!(vm = qemudAssignVMDef(server, def))) {
qemudFreeVMDef(def);
return NULL;
}
if (qemudStartVMDaemon(server, vm) < 0) {
qemudFreeVM(vm);
qemudRemoveInactiveVM(server, vm);
return NULL;
}
@ -416,7 +422,7 @@ int qemudDomainDumpXML(struct qemud_server *server, const unsigned char *uuid, c
return -1;
}
vmxml = qemudGenerateXML(server, vm, 1);
vmxml = qemudGenerateXML(server, vm, vm->def, 1);
if (!vmxml)
return -1;
@ -461,12 +467,27 @@ struct qemud_vm *qemudDomainStart(struct qemud_server *server, const unsigned ch
struct qemud_vm *qemudDomainDefine(struct qemud_server *server, const char *xml) {
return qemudLoadConfigXML(server, NULL, xml, 1);
struct qemud_vm_def *def;
struct qemud_vm *vm;
if (!(def = qemudParseVMDef(server, xml, NULL)))
return NULL;
if (!(vm = qemudAssignVMDef(server, def))) {
qemudFreeVMDef(def);
return NULL;
}
if (qemudSaveVMDef(server, vm, def) < 0) {
qemudRemoveInactiveVM(server, vm);
return NULL;
}
return vm;
}
int qemudDomainUndefine(struct qemud_server *server, const unsigned char *uuid) {
struct qemud_vm *vm = qemudFindVMByUUID(server, uuid);
struct qemud_vm *prev = NULL, *curr = server->vms;
if (!vm) {
qemudReportError(server, VIR_ERR_INVALID_DOMAIN, "no domain with matching uuid");
@ -483,22 +504,7 @@ int qemudDomainUndefine(struct qemud_server *server, const unsigned char *uuid)
vm->configFile[0] = '\0';
while (curr) {
if (curr == vm) {
if (prev) {
prev->next = curr->next;
} else {
server->vms = curr->next;
}
server->ninactivevms--;
break;
}
prev = curr;
curr = curr->next;
}
qemudFreeVM(vm);
qemudRemoveInactiveVM(server, vm);
return 0;
}
@ -566,14 +572,19 @@ int qemudListDefinedNetworks(struct qemud_server *server, char *const*names, int
}
struct qemud_network *qemudNetworkCreate(struct qemud_server *server, const char *xml) {
struct qemud_network_def *def;
struct qemud_network *network;
if (!(network = qemudLoadNetworkConfigXML(server, NULL, xml, 0))) {
if (!(def = qemudParseNetworkDef(server, xml, NULL)))
return NULL;
if (!(network = qemudAssignNetworkDef(server, def))) {
qemudFreeNetworkDef(def);
return NULL;
}
if (qemudStartNetworkDaemon(server, network) < 0) {
qemudFreeNetwork(network);
qemudRemoveInactiveNetwork(server, network);
return NULL;
}
@ -581,12 +592,27 @@ struct qemud_network *qemudNetworkCreate(struct qemud_server *server, const char
}
struct qemud_network *qemudNetworkDefine(struct qemud_server *server, const char *xml) {
return qemudLoadNetworkConfigXML(server, NULL, xml, 1);
struct qemud_network_def *def;
struct qemud_network *network;
if (!(def = qemudParseNetworkDef(server, xml, NULL)))
return NULL;
if (!(network = qemudAssignNetworkDef(server, def))) {
qemudFreeNetworkDef(def);
return NULL;
}
if (qemudSaveNetworkDef(server, network, def) < 0) {
qemudRemoveInactiveNetwork(server, network);
return NULL;
}
return network;
}
int qemudNetworkUndefine(struct qemud_server *server, const unsigned char *uuid) {
struct qemud_network *network = qemudFindNetworkByUUID(server, uuid);
struct qemud_network *prev = NULL, *curr = server->networks;
if (!network) {
qemudReportError(server, VIR_ERR_INVALID_DOMAIN, "no network with matching uuid");
@ -598,22 +624,7 @@ int qemudNetworkUndefine(struct qemud_server *server, const unsigned char *uuid)
network->configFile[0] = '\0';
while (curr) {
if (curr == network) {
if (prev) {
prev->next = curr->next;
} else {
server->networks = curr->next;
}
server->ninactivenetworks--;
break;
}
prev = curr;
curr = curr->next;
}
qemudFreeNetwork(network);
qemudRemoveInactiveNetwork(server, network);
return 0;
}
@ -650,7 +661,7 @@ int qemudNetworkDumpXML(struct qemud_server *server, const unsigned char *uuid,
return -1;
}
networkxml = qemudGenerateNetworkXML(server, network, 1);
networkxml = qemudGenerateNetworkXML(server, network, network->def);
if (!networkxml)
return -1;

45
qemud/qemud.c
View File

@ -1255,8 +1255,7 @@ static int qemudDispatchPoll(struct qemud_server *server, struct pollfd *fds) {
struct qemud_socket *sock = server->sockets;
struct qemud_client *client = server->clients;
struct qemud_vm *vm;
struct qemud_vm *tmp;
struct qemud_network *network, *prevnet;
struct qemud_network *network;
int ret = 0;
int fd = 0;
@ -1336,42 +1335,24 @@ static int qemudDispatchPoll(struct qemud_server *server, struct pollfd *fds) {
/* Cleanup any VMs which shutdown & dont have an associated
config file */
vm = server->vms;
tmp = NULL;
while (vm) {
if (!qemudIsActiveVM(vm) && !vm->configFile[0]) {
struct qemud_vm *next = vm->next;
if (tmp) {
tmp->next = next;
} else {
server->vms = next;
}
qemudFreeVM(vm);
server->ninactivevms--;
vm = next;
} else {
tmp = vm;
vm = vm->next;
}
struct qemud_vm *next = vm->next;
if (!qemudIsActiveVM(vm) && !vm->configFile[0])
qemudRemoveInactiveVM(server, vm);
vm = next;
}
/* Cleanup any networks too */
network = server->networks;
prevnet = NULL;
while (network) {
if (!qemudIsActiveNetwork(network) && !network->configFile[0]) {
struct qemud_network *next = network->next;
if (prevnet) {
prevnet->next = next;
} else {
server->networks = next;
}
qemudFreeNetwork(network);
server->ninactivenetworks--;
network = next;
} else {
prevnet = network;
network = network->next;
}
struct qemud_network *next = network->next;
if (!qemudIsActiveNetwork(network) && !network->configFile[0])
qemudRemoveInactiveNetwork(server, network);
network = next;
}
return ret;