External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-02-08 12:41:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

qemu: Refactor qemuDomainSetMemoryParameters

Browse Source 
The new TypedParam helper APIs allow to simplify this function
significantly.

This patch integrates the fix in 75e5bec97b3045e4f926248d5c742f8a50d0f9
by correctly ordering the setting functions instead of reordering the
parameters.
This commit is contained in:
Peter Krempa 2013-02-18 16:13:04 +01:00
parent 65bb1b9795
commit 19c6ad9ac7
1 changed files with 60 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

160
src/qemu/qemu_driver.c
View File

@ -7217,15 +7217,15 @@ qemuDomainSetMemoryParameters(virDomainPtr dom,
unsigned int flags) unsigned int flags)
{ {
virQEMUDriverPtr driver = dom->conn->privateData; virQEMUDriverPtr driver = dom->conn->privateData;
int i;
virDomainDefPtr persistentDef = NULL; virDomainDefPtr persistentDef = NULL;
virCgroupPtr group = NULL; virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL; virDomainObjPtr vm = NULL;
virTypedParameterPtr hard_limit = NULL; unsigned long long swap_hard_limit;
virTypedParameterPtr swap_hard_limit = NULL; unsigned long long memory_hard_limit;
int hard_limit_index = 0; unsigned long long memory_soft_limit;
int swap_hard_limit_index = 0; bool set_swap_hard_limit = false;
unsigned long long val = 0; bool set_memory_hard_limit = false;
bool set_memory_soft_limit = false;
virQEMUDriverConfigPtr cfg = NULL; virQEMUDriverConfigPtr cfg = NULL;
int ret = -1; int ret = -1;
int rc; int rc;
@ -7244,13 +7244,9 @@ qemuDomainSetMemoryParameters(virDomainPtr dom,
NULL) < 0) NULL) < 0)
return -1; return -1;
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (vm == NULL) { if (!(vm = qemuDomObjFromDomain(dom)))
virReportError(VIR_ERR_INTERNAL_ERROR, return -1;
_("No such domain %s"), dom->uuid);
goto cleanup;
}
cfg = virQEMUDriverGetConfig(driver); cfg = virQEMUDriverGetConfig(driver);
@ -7275,110 +7271,74 @@ qemuDomainSetMemoryParameters(virDomainPtr dom,
} }
} }
for (i = 0; i < nparams; i++) { #define VIR_GET_LIMIT_PARAMETER(PARAM, VALUE) \
if (STREQ(params[i].field, VIR_DOMAIN_MEMORY_HARD_LIMIT)) { if ((rc = virTypedParamsGetULLong(params, nparams, PARAM, &VALUE) < 0)) \
hard_limit = &params[i]; goto cleanup; \
hard_limit_index = i; \
} else if (STREQ(params[i].field, VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT)) { if (rc == 1) \
swap_hard_limit = &params[i]; set_ ## VALUE = true;
swap_hard_limit_index = i;
} VIR_GET_LIMIT_PARAMETER(VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT, swap_hard_limit)
} VIR_GET_LIMIT_PARAMETER(VIR_DOMAIN_MEMORY_HARD_LIMIT, memory_hard_limit)
VIR_GET_LIMIT_PARAMETER(VIR_DOMAIN_MEMORY_SOFT_LIMIT, memory_soft_limit)
#undef VIR_GET_LIMIT_PARAMETER
/* It will fail if hard limit greater than swap hard limit anyway */ /* It will fail if hard limit greater than swap hard limit anyway */
if (swap_hard_limit && if (set_swap_hard_limit && set_memory_hard_limit &&
hard_limit && memory_hard_limit > swap_hard_limit) {
(hard_limit->value.ul > swap_hard_limit->value.ul)) {
virReportError(VIR_ERR_INVALID_ARG, "%s", virReportError(VIR_ERR_INVALID_ARG, "%s",
_("hard limit must be lower than swap hard limit")); _("memory hard_limit tunable value must be lower than "
"swap_hard_limit"));
goto cleanup; goto cleanup;
} }
if (flags & VIR_DOMAIN_AFFECT_LIVE) { if (set_swap_hard_limit) {
/* Get current swap hard limit */ if (flags & VIR_DOMAIN_AFFECT_LIVE &&
rc = virCgroupGetMemSwapHardLimit(group, &val); (rc = virCgroupSetMemSwapHardLimit(group, swap_hard_limit)) < 0) {
if (rc != 0) {
virReportSystemError(-rc, "%s", virReportSystemError(-rc, "%s",
_("unable to get swap hard limit")); _("unable to set memory swap_hard_limit tunable"));
goto cleanup; goto cleanup;
} }
/* Swap hard_limit and swap_hard_limit to ensure the setting if (flags & VIR_DOMAIN_AFFECT_CONFIG)
* could succeed if both of them are provided. persistentDef->mem.swap_hard_limit = swap_hard_limit;
*/
if (swap_hard_limit && hard_limit) {
virTypedParameter param;
if (swap_hard_limit->value.ul > val) {
if (hard_limit_index < swap_hard_limit_index) {
param = params[hard_limit_index];
params[hard_limit_index] = params[swap_hard_limit_index];
params[swap_hard_limit_index] = param;
}
} else {
if (hard_limit_index > swap_hard_limit_index) {
param = params[hard_limit_index];
params[hard_limit_index] = params[swap_hard_limit_index];
params[swap_hard_limit_index] = param;
}
}
}
} }
if (set_memory_hard_limit) {
if (flags & VIR_DOMAIN_AFFECT_LIVE &&
(rc = virCgroupSetMemoryHardLimit(group, memory_hard_limit)) < 0) {
virReportSystemError(-rc, "%s",
_("unable to set memory hard_limit tunable"));
goto cleanup;
}
if (flags & VIR_DOMAIN_AFFECT_CONFIG)
persistentDef->mem.hard_limit = memory_hard_limit;
}
if (set_memory_soft_limit) {
if (flags & VIR_DOMAIN_AFFECT_LIVE &&
(rc = virCgroupSetMemorySoftLimit(group, memory_soft_limit)) < 0) {
virReportSystemError(-rc, "%s",
_("unable to set memory soft_limit tunable"));
goto cleanup;
}
if (flags & VIR_DOMAIN_AFFECT_CONFIG)
persistentDef->mem.soft_limit = memory_soft_limit;
}
if (flags & VIR_DOMAIN_AFFECT_CONFIG &&
virDomainSaveConfig(cfg->configDir, persistentDef) < 0)
goto cleanup;
ret = 0; ret = 0;
for (i = 0; i < nparams; i++) {
virTypedParameterPtr param = &params[i];
if (STREQ(param->field, VIR_DOMAIN_MEMORY_HARD_LIMIT)) {
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
rc = virCgroupSetMemoryHardLimit(group, param->value.ul);
if (rc != 0) {
virReportSystemError(-rc, "%s",
_("unable to set memory hard_limit tunable"));
ret = -1;
}
}
if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
persistentDef->mem.hard_limit = param->value.ul;
}
} else if (STREQ(param->field, VIR_DOMAIN_MEMORY_SOFT_LIMIT)) {
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
rc = virCgroupSetMemorySoftLimit(group, param->value.ul);
if (rc != 0) {
virReportSystemError(-rc, "%s",
_("unable to set memory soft_limit tunable"));
ret = -1;
}
}
if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
persistentDef->mem.soft_limit = param->value.ul;
}
} else if (STREQ(param->field, VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT)) {
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
rc = virCgroupSetMemSwapHardLimit(group, param->value.ul);
if (rc != 0) {
virReportSystemError(-rc, "%s",
_("unable to set swap_hard_limit tunable"));
ret = -1;
}
}
if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
persistentDef->mem.swap_hard_limit = param->value.ul;
}
}
}
if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
if (virDomainSaveConfig(cfg->configDir, persistentDef) < 0)
ret = -1;
}
cleanup: cleanup:
virCgroupFree(&group); virCgroupFree(&group);
if (vm) virObjectUnlock(vm);
virObjectUnlock(vm);
virObjectUnref(caps); virObjectUnref(caps);
virObjectUnref(cfg); virObjectUnref(cfg);
return ret; return ret;