External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-08-26 18:41:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge all return paths from LXC driver APIs

Browse Source
This commit is contained in:
Daniel P. Berrange 2008-12-04 21:11:41 +00:00
parent bc898df2c7
commit 5305c55849
2 changed files with 158 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ChangeLog
View File

@ -1,3 +1,7 @@
Thu Dec 4 21:10:41 GMT 2008 Daniel P. Berrange <berrange@redhat.com>
* src/lxc_driver.c: Merge all return paths from driver APIs
Thu Dec 4 21:09:41 GMT 2008 Daniel P. Berrange <berrange@redhat.com> Thu Dec 4 21:09:41 GMT 2008 Daniel P. Berrange <berrange@redhat.com>
QEMU domain events thread safety QEMU domain events thread safety

278
src/lxc_driver.c
View File

@ -103,65 +103,68 @@ static int lxcClose(virConnectPtr conn)
static virDomainPtr lxcDomainLookupByID(virConnectPtr conn, static virDomainPtr lxcDomainLookupByID(virConnectPtr conn,
int id) int id)
{ {
lxc_driver_t *driver = (lxc_driver_t *)conn->privateData; lxc_driver_t *driver = conn->privateData;
virDomainObjPtr vm = virDomainFindByID(&driver->domains, id); virDomainObjPtr vm;
virDomainPtr dom; virDomainPtr dom = NULL;
vm = virDomainFindByID(&driver->domains, id);
if (!vm) { if (!vm) {
lxcError(conn, NULL, VIR_ERR_NO_DOMAIN, NULL); lxcError(conn, NULL, VIR_ERR_NO_DOMAIN, NULL);
return NULL; goto cleanup;
} }
dom = virGetDomain(conn, vm->def->name, vm->def->uuid); dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom) { if (dom)
dom->id = vm->def->id; dom->id = vm->def->id;
}
cleanup:
return dom; return dom;
} }
static virDomainPtr lxcDomainLookupByUUID(virConnectPtr conn, static virDomainPtr lxcDomainLookupByUUID(virConnectPtr conn,
const unsigned char *uuid) const unsigned char *uuid)
{ {
lxc_driver_t *driver = (lxc_driver_t *)conn->privateData; lxc_driver_t *driver = conn->privateData;
virDomainObjPtr vm = virDomainFindByUUID(&driver->domains, uuid); virDomainObjPtr vm;
virDomainPtr dom; virDomainPtr dom = NULL;
vm = virDomainFindByUUID(&driver->domains, uuid);
if (!vm) { if (!vm) {
lxcError(conn, NULL, VIR_ERR_NO_DOMAIN, NULL); lxcError(conn, NULL, VIR_ERR_NO_DOMAIN, NULL);
return NULL; goto cleanup;
} }
dom = virGetDomain(conn, vm->def->name, vm->def->uuid); dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom) { if (dom)
dom->id = vm->def->id; dom->id = vm->def->id;
}
cleanup:
return dom; return dom;
} }
static virDomainPtr lxcDomainLookupByName(virConnectPtr conn, static virDomainPtr lxcDomainLookupByName(virConnectPtr conn,
const char *name) const char *name)
{ {
lxc_driver_t *driver = (lxc_driver_t *)conn->privateData; lxc_driver_t *driver = conn->privateData;
virDomainObjPtr vm = virDomainFindByName(&driver->domains, name); virDomainObjPtr vm;
virDomainPtr dom; virDomainPtr dom = NULL;
vm = virDomainFindByName(&driver->domains, name);
if (!vm) { if (!vm) {
lxcError(conn, NULL, VIR_ERR_NO_DOMAIN, NULL); lxcError(conn, NULL, VIR_ERR_NO_DOMAIN, NULL);
return NULL; goto cleanup;
} }
dom = virGetDomain(conn, vm->def->name, vm->def->uuid); dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom) { if (dom)
dom->id = vm->def->id; dom->id = vm->def->id;
}
cleanup:
return dom; return dom;
} }
static int lxcListDomains(virConnectPtr conn, int *ids, int nids) { static int lxcListDomains(virConnectPtr conn, int *ids, int nids) {
lxc_driver_t *driver = (lxc_driver_t *)conn->privateData; lxc_driver_t *driver = conn->privateData;
int got = 0, i; int got = 0, i;
for (i = 0 ; i < driver->domains.count && got < nids ; i++) for (i = 0 ; i < driver->domains.count && got < nids ; i++)
@ -170,8 +173,9 @@ static int lxcListDomains(virConnectPtr conn, int *ids, int nids) {
return got; return got;
} }
static int lxcNumDomains(virConnectPtr conn) { static int lxcNumDomains(virConnectPtr conn) {
lxc_driver_t *driver = (lxc_driver_t *)conn->privateData; lxc_driver_t *driver = conn->privateData;
int n = 0, i; int n = 0, i;
for (i = 0 ; i < driver->domains.count ; i++) for (i = 0 ; i < driver->domains.count ; i++)
@ -183,7 +187,7 @@ static int lxcNumDomains(virConnectPtr conn) {
static int lxcListDefinedDomains(virConnectPtr conn, static int lxcListDefinedDomains(virConnectPtr conn,
char **const names, int nnames) { char **const names, int nnames) {
lxc_driver_t *driver = (lxc_driver_t *)conn->privateData; lxc_driver_t *driver = conn->privateData;
int got = 0, i; int got = 0, i;
for (i = 0 ; i < driver->domains.count && got < nnames ; i++) { for (i = 0 ; i < driver->domains.count && got < nnames ; i++) {
@ -206,7 +210,7 @@ static int lxcListDefinedDomains(virConnectPtr conn,
static int lxcNumDefinedDomains(virConnectPtr conn) { static int lxcNumDefinedDomains(virConnectPtr conn) {
lxc_driver_t *driver = (lxc_driver_t *)conn->privateData; lxc_driver_t *driver = conn->privateData;
int n = 0, i; int n = 0, i;
for (i = 0 ; i < driver->domains.count ; i++) for (i = 0 ; i < driver->domains.count ; i++)
@ -220,86 +224,91 @@ static int lxcNumDefinedDomains(virConnectPtr conn) {
static virDomainPtr lxcDomainDefine(virConnectPtr conn, const char *xml) static virDomainPtr lxcDomainDefine(virConnectPtr conn, const char *xml)
{ {
lxc_driver_t *driver = (lxc_driver_t *)conn->privateData; lxc_driver_t *driver = conn->privateData;
virDomainDefPtr def; virDomainDefPtr def = NULL;
virDomainObjPtr vm; virDomainObjPtr vm;
virDomainPtr dom; virDomainPtr dom = NULL;
if (!(def = virDomainDefParseString(conn, driver->caps, xml))) if (!(def = virDomainDefParseString(conn, driver->caps, xml)))
return NULL; goto cleanup;
if ((def->nets != NULL) && !(driver->have_netns)) { if ((def->nets != NULL) && !(driver->have_netns)) {
lxcError(conn, NULL, VIR_ERR_NO_SUPPORT, lxcError(conn, NULL, VIR_ERR_NO_SUPPORT,
"%s", _("System lacks NETNS support")); "%s", _("System lacks NETNS support"));
virDomainDefFree(def); goto cleanup;
return NULL;
} }
if (!(vm = virDomainAssignDef(conn, &driver->domains, def))) { if (!(vm = virDomainAssignDef(conn, &driver->domains, def)))
virDomainDefFree(def); goto cleanup;
return NULL; def = NULL;
}
vm->persistent = 1; vm->persistent = 1;
if (virDomainSaveConfig(conn, if (virDomainSaveConfig(conn,
driver->configDir, driver->configDir,
vm->newDef ? vm->newDef : vm->def) < 0) { vm->newDef ? vm->newDef : vm->def) < 0) {
virDomainRemoveInactive(&driver->domains, vm); virDomainRemoveInactive(&driver->domains, vm);
return NULL; goto cleanup;
} }
dom = virGetDomain(conn, vm->def->name, vm->def->uuid); dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom) { if (dom)
dom->id = vm->def->id; dom->id = vm->def->id;
}
cleanup:
virDomainDefFree(def);
return dom; return dom;
} }
static int lxcDomainUndefine(virDomainPtr dom) static int lxcDomainUndefine(virDomainPtr dom)
{ {
lxc_driver_t *driver = (lxc_driver_t *)dom->conn->privateData; lxc_driver_t *driver = dom->conn->privateData;
virDomainObjPtr vm = virDomainFindByUUID(&driver->domains, dom->uuid); virDomainObjPtr vm;
int ret = -1;
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
if (!vm) { if (!vm) {
lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN, lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN,
"%s", _("no domain with matching uuid")); "%s", _("no domain with matching uuid"));
return -1; goto cleanup;
} }
if (virDomainIsActive(vm)) { if (virDomainIsActive(vm)) {
lxcError(dom->conn, dom, VIR_ERR_INTERNAL_ERROR, lxcError(dom->conn, dom, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot delete active domain")); "%s", _("cannot delete active domain"));
return -1; goto cleanup;
} }
if (!vm->persistent) { if (!vm->persistent) {
lxcError(dom->conn, dom, VIR_ERR_INTERNAL_ERROR, lxcError(dom->conn, dom, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot undefine transient domain")); "%s", _("cannot undefine transient domain"));
return -1; goto cleanup;
} }
if (virDomainDeleteConfig(dom->conn, if (virDomainDeleteConfig(dom->conn,
driver->configDir, driver->configDir,
driver->autostartDir, driver->autostartDir,
vm) <0) vm) < 0)
return -1; goto cleanup;
virDomainRemoveInactive(&driver->domains, vm); virDomainRemoveInactive(&driver->domains, vm);
ret = 0;
return 0; cleanup:
return ret;
} }
static int lxcDomainGetInfo(virDomainPtr dom, static int lxcDomainGetInfo(virDomainPtr dom,
virDomainInfoPtr info) virDomainInfoPtr info)
{ {
lxc_driver_t *driver = (lxc_driver_t *)dom->conn->privateData; lxc_driver_t *driver = dom->conn->privateData;
virDomainObjPtr vm = virDomainFindByUUID(&driver->domains, dom->uuid); virDomainObjPtr vm;
int ret = -1;
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
if (!vm) { if (!vm) {
lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN, lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN,
"%s", _("no domain with matching uuid")); "%s", _("no domain with matching uuid"));
return -1; goto cleanup;
} }
info->state = vm->state; info->state = vm->state;
@ -313,40 +322,52 @@ static int lxcDomainGetInfo(virDomainPtr dom,
info->maxMem = vm->def->maxmem; info->maxMem = vm->def->maxmem;
info->memory = vm->def->memory; info->memory = vm->def->memory;
info->nrVirtCpu = 1; info->nrVirtCpu = 1;
ret = 0;
return 0; cleanup:
return ret;
} }
static char *lxcGetOSType(virDomainPtr dom) static char *lxcGetOSType(virDomainPtr dom)
{ {
lxc_driver_t *driver = (lxc_driver_t *)dom->conn->privateData; lxc_driver_t *driver = dom->conn->privateData;
virDomainObjPtr vm = virDomainFindByUUID(&driver->domains, dom->uuid); virDomainObjPtr vm;
char *ret = NULL;
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
if (!vm) { if (!vm) {
lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN, lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN,
"%s", _("no domain with matching uuid")); "%s", _("no domain with matching uuid"));
return NULL; goto cleanup;
} }
return strdup(vm->def->os.type); ret = strdup(vm->def->os.type);
cleanup:
return ret;
} }
static char *lxcDomainDumpXML(virDomainPtr dom, static char *lxcDomainDumpXML(virDomainPtr dom,
int flags) int flags)
{ {
lxc_driver_t *driver = (lxc_driver_t *)dom->conn->privateData; lxc_driver_t *driver = dom->conn->privateData;
virDomainObjPtr vm = virDomainFindByUUID(&driver->domains, dom->uuid); virDomainObjPtr vm;
char *ret = NULL;
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
if (!vm) { if (!vm) {
lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN, lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN,
"%s", _("no domain with matching uuid")); "%s", _("no domain with matching uuid"));
return NULL; goto cleanup;
} }
return virDomainDefFormat(dom->conn, ret = virDomainDefFormat(dom->conn,
(flags & VIR_DOMAIN_XML_INACTIVE) && (flags & VIR_DOMAIN_XML_INACTIVE) &&
vm->newDef ? vm->newDef : vm->def, vm->newDef ? vm->newDef : vm->def,
flags); flags);
cleanup:
return ret;
} }
@ -855,27 +876,27 @@ cleanup:
*/ */
static int lxcDomainStart(virDomainPtr dom) static int lxcDomainStart(virDomainPtr dom)
{ {
int rc = -1; lxc_driver_t *driver = dom->conn->privateData;
virConnectPtr conn = dom->conn; virDomainObjPtr vm;
lxc_driver_t *driver = (lxc_driver_t *)(conn->privateData); int ret = -1;
virDomainObjPtr vm = virDomainFindByName(&driver->domains, dom->name);
vm = virDomainFindByName(&driver->domains, dom->name);
if (!vm) { if (!vm) {
lxcError(conn, dom, VIR_ERR_INVALID_DOMAIN, lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN,
_("no domain named %s"), dom->name); _("no domain named %s"), dom->name);
goto cleanup; goto cleanup;
} }
if ((vm->def->nets != NULL) && !(driver->have_netns)) { if ((vm->def->nets != NULL) && !(driver->have_netns)) {
lxcError(conn, NULL, VIR_ERR_NO_SUPPORT, lxcError(dom->conn, NULL, VIR_ERR_NO_SUPPORT,
"%s", _("System lacks NETNS support")); "%s", _("System lacks NETNS support"));
goto cleanup; goto cleanup;
} }
rc = lxcVmStart(conn, driver, vm); ret = lxcVmStart(dom->conn, driver, vm);
cleanup: cleanup:
return rc; return ret;
} }
/** /**
@ -892,38 +913,36 @@ static virDomainPtr
lxcDomainCreateAndStart(virConnectPtr conn, lxcDomainCreateAndStart(virConnectPtr conn,
const char *xml, const char *xml,
unsigned int flags ATTRIBUTE_UNUSED) { unsigned int flags ATTRIBUTE_UNUSED) {
lxc_driver_t *driver = (lxc_driver_t *)conn->privateData; lxc_driver_t *driver = conn->privateData;
virDomainObjPtr vm; virDomainObjPtr vm;
virDomainDefPtr def; virDomainDefPtr def;
virDomainPtr dom = NULL; virDomainPtr dom = NULL;
if (!(def = virDomainDefParseString(conn, driver->caps, xml))) if (!(def = virDomainDefParseString(conn, driver->caps, xml)))
goto return_point; goto cleanup;
if ((def->nets != NULL) && !(driver->have_netns)) { if ((def->nets != NULL) && !(driver->have_netns)) {
virDomainDefFree(def);
lxcError(conn, NULL, VIR_ERR_NO_SUPPORT, lxcError(conn, NULL, VIR_ERR_NO_SUPPORT,
"%s", _("System lacks NETNS support")); "%s", _("System lacks NETNS support"));
goto return_point; goto cleanup;
} }
if (!(vm = virDomainAssignDef(conn, &driver->domains, def))) { if (!(vm = virDomainAssignDef(conn, &driver->domains, def)))
virDomainDefFree(def); goto cleanup;
goto return_point; def = NULL;
}
if (lxcVmStart(conn, driver, vm) < 0) { if (lxcVmStart(conn, driver, vm) < 0) {
virDomainRemoveInactive(&driver->domains, vm); virDomainRemoveInactive(&driver->domains, vm);
goto return_point; goto cleanup;
} }
dom = virGetDomain(conn, vm->def->name, vm->def->uuid); dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom) { if (dom)
dom->id = vm->def->id; dom->id = vm->def->id;
}
return_point: cleanup:
virDomainDefFree(def);
return dom; return dom;
} }
@ -937,16 +956,21 @@ return_point:
*/ */
static int lxcDomainShutdown(virDomainPtr dom) static int lxcDomainShutdown(virDomainPtr dom)
{ {
lxc_driver_t *driver = (lxc_driver_t*)dom->conn->privateData; lxc_driver_t *driver = dom->conn->privateData;
virDomainObjPtr vm = virDomainFindByID(&driver->domains, dom->id); virDomainObjPtr vm;
int ret = -1;
vm = virDomainFindByID(&driver->domains, dom->id);
if (!vm) { if (!vm) {
lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN, lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN,
_("no domain with id %d"), dom->id); _("no domain with id %d"), dom->id);
return -1; goto cleanup;
} }
return lxcVmTerminate(dom->conn, driver, vm, 0); ret = lxcVmTerminate(dom->conn, driver, vm, 0);
cleanup:
return ret;
} }
@ -960,16 +984,21 @@ static int lxcDomainShutdown(virDomainPtr dom)
*/ */
static int lxcDomainDestroy(virDomainPtr dom) static int lxcDomainDestroy(virDomainPtr dom)
{ {
lxc_driver_t *driver = (lxc_driver_t*)dom->conn->privateData; lxc_driver_t *driver = dom->conn->privateData;
virDomainObjPtr vm = virDomainFindByID(&driver->domains, dom->id); virDomainObjPtr vm;
int ret = -1;
vm = virDomainFindByID(&driver->domains, dom->id);
if (!vm) { if (!vm) {
lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN, lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN,
_("no domain with id %d"), dom->id); _("no domain with id %d"), dom->id);
return -1; goto cleanup;
} }
return lxcVmTerminate(dom->conn, driver, vm, SIGKILL); ret = lxcVmTerminate(dom->conn, driver, vm, SIGKILL);
cleanup:
return ret;
} }
static int lxcCheckNetNsSupport(void) static int lxcCheckNetNsSupport(void)
@ -1146,86 +1175,87 @@ static char *lxcGetSchedulerType(virDomainPtr domain ATTRIBUTE_UNUSED,
return strdup("posix"); return strdup("posix");
} }
static int lxcSetSchedulerParameters(virDomainPtr _domain, static int lxcSetSchedulerParameters(virDomainPtr domain,
virSchedParameterPtr params, virSchedParameterPtr params,
int nparams) int nparams)
{ {
int i; int i;
int rc; virCgroupPtr group = NULL;
virCgroupPtr group; virDomainObjPtr vm = NULL;
virDomainObjPtr domain; int ret = -1;
if (virCgroupHaveSupport() != 0) if (virCgroupHaveSupport() != 0)
return 0; goto cleanup;
domain = virDomainFindByUUID(&lxc_driver->domains, _domain->uuid); vm = virDomainFindByUUID(&lxc_driver->domains, domain->uuid);
if (domain == NULL) { if (vm == NULL) {
lxcError(NULL, _domain, VIR_ERR_INTERNAL_ERROR, lxcError(NULL, domain, VIR_ERR_INTERNAL_ERROR,
_("No such domain %s"), _domain->uuid); _("No such domain %s"), domain->uuid);
return -EINVAL; goto cleanup;
} }
rc = virCgroupForDomain(domain->def, "lxc", &group); if (virCgroupForDomain(vm->def, "lxc", &group) != 0)
if (rc != 0) goto cleanup;
return rc;
for (i = 0; i < nparams; i++) { for (i = 0; i < nparams; i++) {
virSchedParameterPtr param = &params[i]; virSchedParameterPtr param = &params[i];
if (STREQ(param->field, "cpu_shares")) { if (STREQ(param->field, "cpu_shares")) {
rc = virCgroupSetCpuShares(group, params[i].value.ui); if (virCgroupSetCpuShares(group, params[i].value.ui) != 0)
goto cleanup;
} else { } else {
lxcError(NULL, _domain, VIR_ERR_INVALID_ARG, lxcError(NULL, domain, VIR_ERR_INVALID_ARG,
_("Invalid parameter `%s'"), param->field); _("Invalid parameter `%s'"), param->field);
rc = -ENOENT; goto cleanup;
goto out;
} }
} }
ret = 0;
rc = 0; cleanup:
out:
virCgroupFree(&group); virCgroupFree(&group);
return rc; return ret;
} }
static int lxcGetSchedulerParameters(virDomainPtr _domain, static int lxcGetSchedulerParameters(virDomainPtr domain,
virSchedParameterPtr params, virSchedParameterPtr params,
int *nparams) int *nparams)
{ {
int rc = 0; virCgroupPtr group = NULL;
virCgroupPtr group; virDomainObjPtr vm = NULL;
virDomainObjPtr domain;
unsigned long val; unsigned long val;
int ret = -1;
if (virCgroupHaveSupport() != 0) if (virCgroupHaveSupport() != 0)
return 0; goto cleanup;
if ((*nparams) != 1) { if ((*nparams) != 1) {
lxcError(NULL, _domain, VIR_ERR_INVALID_ARG, lxcError(NULL, domain, VIR_ERR_INVALID_ARG,
"%s", _("Invalid parameter count")); "%s", _("Invalid parameter count"));
return -1; goto cleanup;
} }
domain = virDomainFindByUUID(&lxc_driver->domains, _domain->uuid); vm = virDomainFindByUUID(&lxc_driver->domains, domain->uuid);
if (domain == NULL) { if (vm == NULL) {
lxcError(NULL, _domain, VIR_ERR_INTERNAL_ERROR, lxcError(NULL, domain, VIR_ERR_INTERNAL_ERROR,
_("No such domain %s"), _domain->uuid); _("No such domain %s"), domain->uuid);
return -ENOENT; goto cleanup;
} }
rc = virCgroupForDomain(domain->def, "lxc", &group); if (virCgroupForDomain(vm->def, "lxc", &group) != 0)
if (rc != 0) goto cleanup;
return rc;
rc = virCgroupGetCpuShares(group, &val); if (virCgroupGetCpuShares(group, &val) != 0)
goto cleanup;
params[0].value.ul = val; params[0].value.ul = val;
strncpy(params[0].field, "cpu_shares", sizeof(params[0].field)); strncpy(params[0].field, "cpu_shares", sizeof(params[0].field));
params[0].type = VIR_DOMAIN_SCHED_FIELD_ULLONG; params[0].type = VIR_DOMAIN_SCHED_FIELD_ULLONG;
virCgroupFree(&group); ret = 0;
return rc; cleanup:
virCgroupFree(&group);
return ret;
} }
/* Function Tables */ /* Function Tables */