--- src/libvirt_private.syms | 4 ++ src/util/cgroup.c | 81 ++++++++++++++++++++++++++++++++++++++++++++-- src/util/cgroup.h | 6 +++ 3 files changed, 88 insertions(+), 3 deletions(-) diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index afde173..9b9b6ce 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -71,6 +71,8 @@ virCgroupForVcpu; virCgroupFree; virCgroupGetBlkioWeight; virCgroupGetCpuShares; +virCgroupGetCpuCfsPeriod; +virCgroupGetCpuCfsQuota; virCgroupGetCpuacctUsage; virCgroupGetFreezerState; virCgroupGetMemoryHardLimit; @@ -85,6 +87,8 @@ virCgroupPathOfController; virCgroupRemove; virCgroupSetBlkioWeight; virCgroupSetCpuShares; +virCgroupSetCpuCfsPeriod; +virCgroupSetCpuCfsQuota; virCgroupSetFreezerState; virCgroupSetMemory; virCgroupSetMemoryHardLimit; diff --git a/src/util/cgroup.c b/src/util/cgroup.c index ae7567d..2d1378b 100644 --- a/src/util/cgroup.c +++ b/src/util/cgroup.c @@ -398,8 +398,6 @@ static int virCgroupSetValueI64(virCgroupPtr group, return rc; } -#if 0 -/* This is included for completeness, but not yet used */ static int virCgroupGetValueI64(virCgroupPtr group, int controller, const char *key, @@ -419,7 +417,6 @@ out: return rc; } -#endif static int virCgroupGetValueU64(virCgroupPtr group, int controller, @@ -1384,6 +1381,84 @@ int virCgroupGetCpuShares(virCgroupPtr group, unsigned long long *shares) "cpu.shares", shares); } +/** + * virCgroupSetCpuCfsPeriod: + * + * @group: The cgroup to change cpu.cfs_period_us for + * @cfs_period: The bandwidth period in usecs + * + * Returns: 0 on success + */ +int virCgroupSetCpuCfsPeriod(virCgroupPtr group, unsigned long long cfs_period) +{ + /* The cfs_period shoule be greater or equal than 1ms, and less or equal + * than 1s. + */ + if (cfs_period < 1000 || cfs_period > 1000000) + return -EINVAL; + + return virCgroupSetValueU64(group, + VIR_CGROUP_CONTROLLER_CPU, + "cpu.cfs_period_us", cfs_period); +} + +/** + * virCgroupGetCpuCfsPeriod: + * + * @group: The cgroup to get cpu.cfs_period_us for + * @cfs_period: Pointer to the returned bandwidth period in usecs + * + * Returns: 0 on success + */ +int virCgroupGetCpuCfsPeriod(virCgroupPtr group, unsigned long long *cfs_period) +{ + return virCgroupGetValueU64(group, + VIR_CGROUP_CONTROLLER_CPU, + "cpu.cfs_period_us", cfs_period); +} + +/** + * virCgroupSetCpuCfsQuota: + * + * @group: The cgroup to change cpu.cfs_quota_us for + * @cfs_quota: the cpu bandwidth (in usecs) that this tg will be allowed to + * consume over period + * + * Returns: 0 on success + */ +int virCgroupSetCpuCfsQuota(virCgroupPtr group, long long cfs_quota) +{ + if (cfs_quota >= 0) { + /* The cfs_quota shoule be greater or equal than 1ms */ + if (cfs_quota < 1000) + return -EINVAL; + + /* check overflow */ + if (cfs_quota > (unsigned long long)~0ULL / 1000) + return -EINVAL; + } + + return virCgroupSetValueI64(group, + VIR_CGROUP_CONTROLLER_CPU, + "cpu.cfs_quota_us", cfs_quota); +} + +/** + * virCgroupGetCpuCfsQuota: + * + * @group: The cgroup to get cpu.cfs_quota_us for + * @cfs_quota: Pointer to the returned cpu bandwidth (in usecs) that this tg + * will be allowed to consume over period + * + * Returns: 0 on success + */ +int virCgroupGetCpuCfsQuota(virCgroupPtr group, long long *cfs_quota) +{ + return virCgroupGetValueI64(group, + VIR_CGROUP_CONTROLLER_CPU, + "cpu.cfs_quota_us", cfs_quota); +} + int virCgroupGetCpuacctUsage(virCgroupPtr group, unsigned long long *usage) { return virCgroupGetValueU64(group, diff --git a/src/util/cgroup.h b/src/util/cgroup.h index 1d04418..d190bb3 100644 --- a/src/util/cgroup.h +++ b/src/util/cgroup.h @@ -104,6 +104,12 @@ int virCgroupDenyDevicePath(virCgroupPtr group, int virCgroupSetCpuShares(virCgroupPtr group, unsigned long long shares); int virCgroupGetCpuShares(virCgroupPtr group, unsigned long long *shares); +int virCgroupSetCpuCfsPeriod(virCgroupPtr group, unsigned long long cfs_period); +int virCgroupGetCpuCfsPeriod(virCgroupPtr group, unsigned long long *cfs_period); + +int virCgroupSetCpuCfsQuota(virCgroupPtr group, long long cfs_quota); +int virCgroupGetCpuCfsQuota(virCgroupPtr group, long long *cfs_quota); + int virCgroupGetCpuacctUsage(virCgroupPtr group, unsigned long long *usage); int virCgroupSetFreezerState(virCgroupPtr group, const char *state); -- 1.7.1

--- src/conf/domain_conf.c | 272 ++++++++++++++++++++++- src/conf/domain_conf.h | 25 ++ src/libvirt_private.syms | 4 + src/qemu/qemu_cgroup.c | 131 +++++++++++ src/qemu/qemu_cgroup.h | 2 + src/qemu/qemu_process.c | 4 + tests/qemuxml2argvdata/qemuxml2argv-cputune.xml | 2 + 7 files changed, 438 insertions(+), 2 deletions(-) diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index 60e0318..0a1f973 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -997,6 +997,21 @@ virDomainVcpuPinDefFree(virDomainVcpuPinDefPtr *def, VIR_FREE(def); } +static void +virDomainVcpuBWDefFree(virDomainVcpuBWDefPtr *def, + int nvcpubw) +{ + int i; + + if (!def || !nvcpubw) + return; + + for(i = 0; i < nvcpubw; i++) + VIR_FREE(def[i]); + + VIR_FREE(def); +} + void virDomainDefFree(virDomainDefPtr def) { unsigned int i; @@ -1089,6 +1104,9 @@ void virDomainDefFree(virDomainDefPtr def) virCPUDefFree(def->cpu); + virDomainVcpuBWDefFree(def->cputune.vcpubw, + def->cputune.nvcpubw); + virDomainVcpuPinDefFree(def->cputune.vcpupin, def->cputune.nvcpupin); VIR_FREE(def->numatune.memory.nodemask); @@ -5715,6 +5733,62 @@ error: goto cleanup; } +/* Parse the XML definition for a vcpubandwidth */ +static virDomainVcpuBWDefPtr +virDomainVcpuBWDefParseXML(const xmlNodePtr node, + xmlXPathContextPtr ctxt, + int maxvcpus) +{ + virDomainVcpuBWDefPtr def; + xmlNodePtr oldnode = ctxt->node; + unsigned int vcpuid; + unsigned long long period; + long long quota; + int ret; + + if (VIR_ALLOC(def) < 0) { + virReportOOMError(); + return NULL; + } + + ctxt->node = node; + + ret = virXPathUInt("string(./@vcpu)", ctxt, &vcpuid); + if (ret == -2) { + virDomainReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("vcpu id must be an unsigned integer")); + goto error; + } else if (ret == -1) { + virDomainReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("can't parse vcpupin node")); + goto error; + } + + if (vcpuid >= maxvcpus) { + virDomainReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("vcpu id must be less than maxvcpus")); + goto error; + } + + if (virXPathULongLong("string(./@period)", ctxt, &period) < 0) + period = 0; + + if (virXPathLongLong("string(./@quota)", ctxt, &quota) < 0) + quota = 0; + + def->vcpuid = vcpuid; + def->period = period; + def->quota = quota; + +cleanup: + ctxt->node = oldnode; + return def; + +error: + VIR_FREE(def); + goto cleanup; +} + static virDomainDefPtr virDomainDefParseXML(virCapsPtr caps, xmlDocPtr xml, @@ -5881,6 +5955,49 @@ static virDomainDefPtr virDomainDefParseXML(virCapsPtr caps, &def->cputune.shares) < 0) def->cputune.shares = 0; + if ((n = virXPathNodeSet("./cputune/bandwidth", ctxt, &nodes)) < 0) + goto error; + + if (n > def->maxvcpus) { + virDomainReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("bandwith nodes must be less than" + " maxvcpus")); + goto error; + } + + if (n && VIR_ALLOC_N(def->cputune.vcpubw, n) < 0) + goto no_memory; + + for (i = 0; i < n; i++) { + virDomainVcpuBWDefPtr vcpubw = NULL; + vcpubw = virDomainVcpuBWDefParseXML(nodes[i], ctxt, def->maxvcpus); + + if (!vcpubw) + goto error; + + if (virDomainVcpuBWIsDuplicate(def->cputune.vcpubw, + def->cputune.nvcpubw, + vcpubw->vcpuid)) { + virDomainReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("duplicate vcpubandwidth for same" + " vcpu")); + VIR_FREE(vcpubw); + goto error; + } + + if (vcpubw->period || vcpubw->quota) + def->cputune.vcpubw[def->cputune.nvcpubw++] = vcpubw; + else + VIR_FREE(vcpubw); + } + if (def->cputune.nvcpubw) + ignore_value(VIR_REALLOC_N(def->cputune.vcpubw, + def->cputune.nvcpubw)); + else + VIR_FREE(def->cputune.vcpubw); + + VIR_FREE(nodes); + if ((n = virXPathNodeSet("./cputune/vcpupin", ctxt, &nodes)) < 0) { goto error; } @@ -8274,6 +8391,144 @@ virDomainVcpuPinDel(virDomainDefPtr def, int vcpu) return 0; } +/* Check if vcpupin with same vcpuid already exists. + * Return 1 if exists, 0 if not. */ +int +virDomainVcpuBWIsDuplicate(virDomainVcpuBWDefPtr *def, + int nvcpubw, + int vcpu) +{ + int i; + + if (!def || !nvcpubw) + return 0; + + for (i = 0; i < nvcpubw; i++) { + if (def[i]->vcpuid == vcpu) + return 1; + } + + return 0; +} + +virDomainVcpuBWDefPtr +virDomainVcpuBWFindByVcpu(virDomainVcpuBWDefPtr *def, + int nvcpubw, + int vcpu) +{ + int i; + + if (!def || !nvcpubw) + return NULL; + + for (i = 0; i < nvcpubw; i++) { + if (def[i]->vcpuid == vcpu) + return def[i]; + } + + return NULL; +} + +int +virDomainVcpuBWAdd(virDomainDefPtr def, + unsigned long long period, + long long quota, + int vcpu) +{ + virDomainVcpuBWDefPtr *vcpubw_list = NULL; + virDomainVcpuBWDefPtr vcpubw = NULL; + + /* No vcpubw exists yet. */ + if (!def->cputune.nvcpubw) { + if (period == 0 && quota == 0) + return 0; + + if (VIR_ALLOC(vcpubw) < 0) + goto no_memory; + + if (VIR_ALLOC(vcpubw_list) < 0) + goto no_memory; + + vcpubw->vcpuid = vcpu; + vcpubw->period = period; + vcpubw->quota = quota; + vcpubw_list[def->cputune.nvcpubw++] = vcpubw; + + def->cputune.vcpubw = vcpubw_list; + } else { + int nvcpubw = def->cputune.nvcpubw; + vcpubw_list = def->cputune.vcpubw; + if (virDomainVcpuBWIsDuplicate(vcpubw_list, nvcpubw, vcpu)) { + vcpubw = virDomainVcpuBWFindByVcpu(vcpubw_list, nvcpubw, vcpu); + if (period == 0 && quota == 0) { + return virDomainVcpuBWDel(def, vcpu); + } else { + vcpubw->vcpuid = vcpu; + vcpubw->period = period; + vcpubw->quota = quota; + } + } else { + if (period == 0 && quota == 0) + return 0; + + if (VIR_ALLOC(vcpubw) < 0) + goto no_memory; + + if (VIR_REALLOC_N(vcpubw_list, nvcpubw + 1) < 0) + goto no_memory; + + vcpubw->vcpuid = vcpu; + vcpubw->period = period; + vcpubw->quota = quota; + vcpubw_list[def->cputune.nvcpubw++] = vcpubw; + } + } + + return 0; + +no_memory: + virReportOOMError(); + VIR_FREE(vcpubw); + return -1; +} + +int +virDomainVcpuBWDel(virDomainDefPtr def, int vcpu) +{ + int n; + bool deleted = false; + virDomainVcpuBWDefPtr *vcpubw_list = def->cputune.vcpubw; + + /* No vcpubw exists yet */ + if (!def->cputune.nvcpubw) + return 0; + + for (n = 0; n < def->cputune.nvcpubw; n++) { + if (vcpubw_list[n]->vcpuid == vcpu) { + VIR_FREE(vcpubw_list[n]); + memmove(&vcpubw_list[n], &vcpubw_list[n+1], + (def->cputune.nvcpubw - n - 1) * + sizeof(virDomainVcpuBWDefPtr)); + deleted = true; + break; + } + } + + if (!deleted) + return 0; + + if (--def->cputune.nvcpubw == 0) { + VIR_FREE(def->cputune.vcpubw); + } else { + if (VIR_REALLOC_N(def->cputune.vcpubw, + def->cputune.nvcpubw) < 0) { + /* ignore, harmless */ + } + } + + return 0; +} + static int virDomainLifecycleDefFormat(virBufferPtr buf, int type, @@ -9553,12 +9808,24 @@ char *virDomainDefFormat(virDomainDefPtr def, virBufferAsprintf(&buf, " current='%u'", def->vcpus); virBufferAsprintf(&buf, ">%u</vcpu>\n", def->maxvcpus); - if (def->cputune.shares || def->cputune.vcpupin) + if (def->cputune.shares || def->cputune.vcpupin || + def->cputune.vcpubw) virBufferAddLit(&buf, " <cputune>\n"); if (def->cputune.shares) virBufferAsprintf(&buf, " <shares>%lu</shares>\n", def->cputune.shares); + if (def->cputune.vcpubw) { + int i; + for (i = 0; i < def->cputune.nvcpubw; i++) { + virBufferAsprintf(&buf, " <bandwidth vcpu='%u' ", + def->cputune.vcpubw[i]->vcpuid); + virBufferAsprintf(&buf, "period='%llu' ", + def->cputune.vcpubw[i]->period); + virBufferAsprintf(&buf, "quota='%lld'/>\n", + def->cputune.vcpubw[i]->quota); + } + } if (def->cputune.vcpupin) { int i; for (i = 0; i < def->cputune.nvcpupin; i++) { @@ -9580,7 +9847,8 @@ char *virDomainDefFormat(virDomainDefPtr def, } } - if (def->cputune.shares || def->cputune.vcpupin) + if (def->cputune.shares || def->cputune.vcpupin || + def->cputune.vcpubw) virBufferAddLit(&buf, " </cputune>\n"); if (def->numatune.memory.nodemask) diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h index e81977c..a2929b5 100644 --- a/src/conf/domain_conf.h +++ b/src/conf/domain_conf.h @@ -1108,6 +1108,14 @@ struct _virDomainVcpuPinDef { char *cpumask; }; +typedef struct _virDomainVcpuBWDef virDomainVcpuBWDef; +typedef virDomainVcpuBWDef *virDomainVcpuBWDefPtr; +struct _virDomainVcpuBWDef { + int vcpuid; + unsigned long long period; + long long quota; +}; + int virDomainVcpuPinIsDuplicate(virDomainVcpuPinDefPtr *def, int nvcpupin, int vcpu); @@ -1116,6 +1124,14 @@ virDomainVcpuPinDefPtr virDomainVcpuPinFindByVcpu(virDomainVcpuPinDefPtr *def, int nvcpupin, int vcpu); +int virDomainVcpuBWIsDuplicate(virDomainVcpuBWDefPtr *def, + int nvcpubw, + int vcpu); + +virDomainVcpuBWDefPtr virDomainVcpuBWFindByVcpu(virDomainVcpuBWDefPtr *def, + int nvcpubw, + int vcpu); + enum virDomainNumatuneMemMode { VIR_DOMAIN_NUMATUNE_MEM_STRICT, VIR_DOMAIN_NUMATUNE_MEM_PREFERRED, @@ -1170,6 +1186,8 @@ struct _virDomainDef { struct { unsigned long shares; + int nvcpubw; + virDomainVcpuBWDefPtr *vcpubw; int nvcpupin; virDomainVcpuPinDefPtr *vcpupin; } cputune; @@ -1413,6 +1431,13 @@ int virDomainVcpuPinAdd(virDomainDefPtr def, int virDomainVcpuPinDel(virDomainDefPtr def, int vcpu); +int virDomainVcpuBWAdd(virDomainDefPtr def, + unsigned long long period, + long long quota, + int vcpu); + +int virDomainVcpuBWDel(virDomainDefPtr def, int vcpu); + int virDomainDiskIndexByName(virDomainDefPtr def, const char *name); int virDomainDiskInsert(virDomainDefPtr def, virDomainDiskDefPtr disk); diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 9b9b6ce..aad0c3a 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -371,6 +371,10 @@ virDomainTimerTickpolicyTypeFromString; virDomainTimerTickpolicyTypeToString; virDomainTimerTrackTypeFromString; virDomainTimerTrackTypeToString; +virDomainVcpuBWAdd; +virDomainVcpuBWDel; +virDomainVcpuBWFindByVcpu; +virDomainVcpuBWIsDuplicate; virDomainVcpuPinAdd; virDomainVcpuPinDel; virDomainVcpuPinFindByVcpu; diff --git a/src/qemu/qemu_cgroup.c b/src/qemu/qemu_cgroup.c index 1298924..201c0b8 100644 --- a/src/qemu/qemu_cgroup.c +++ b/src/qemu/qemu_cgroup.c @@ -24,6 +24,7 @@ #include <config.h> #include "qemu_cgroup.h" +#include "qemu_domain.h" #include "cgroup.h" #include "logging.h" #include "memory.h" @@ -376,6 +377,136 @@ cleanup: return -1; } +int qemuSetupCgroupVcpuBW(virCgroupPtr cgroup, virDomainVcpuBWDefPtr vcpubw) +{ + int rc; + unsigned long long old_period; + + if (!vcpubw) + return 0; + + if (vcpubw->period == 0 && vcpubw->quota == 0) + return 0; + + if (vcpubw->period) { + /* get old period, and we can rollback if set quota failed */ + rc = virCgroupGetCpuCfsPeriod(cgroup, &old_period); + if (rc < 0) { + virReportSystemError(-rc, + _("%s"), "Unable to get cpu bandwidth period"); + return -1; + } + + rc = virCgroupSetCpuCfsPeriod(cgroup, vcpubw->period); + if (rc < 0) { + virReportSystemError(-rc, + _("%s"), "Unable to set cpu bandwidth period"); + return -1; + } + } + + if (vcpubw->quota) { + rc = virCgroupSetCpuCfsQuota(cgroup, vcpubw->quota); + if (rc < 0) { + virReportSystemError(-rc, + _("%s"), "Unable to set cpu bandwidth quota"); + goto cleanup; + } + } + + return 0; + +cleanup: + if (vcpubw->period) { + rc = virCgroupSetCpuCfsPeriod(cgroup, old_period); + if (rc < 0) + virReportSystemError(-rc, + _("%s"), + "Unable to rollback cpu bandwidth period"); + } + + return -1; +} + +int qemuSetupCgroupForVcpu(struct qemud_driver *driver, virDomainObjPtr vm) +{ + virCgroupPtr cgroup = NULL; + virCgroupPtr cgroup_vcpu = NULL; + qemuDomainObjPrivatePtr priv = vm->privateData; + int rc; + unsigned int i; + virDomainVcpuBWDefPtr *vcpubw_list = vm->def->cputune.vcpubw; + virDomainVcpuBWDefPtr vcpubw = NULL; + int nvcpubw = vm->def->cputune.nvcpubw; + + if (driver->cgroup == NULL) + return 0; /* Not supported, so claim success */ + + rc = virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0); + if (rc != 0) { + virReportSystemError(-rc, + _("Unable to find cgroup for %s"), + vm->def->name); + goto cleanup; + } + + if (priv->nvcpupids == 0 || priv->vcpupids[0] == vm->pid) { + /* If we does not know VCPU<->PID mapping or all vcpu runs in the same + * thread, we can not control each vcpu. So just use the last config. + */ + if (vcpubw_list) { + if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) { + if (qemuSetupCgroupVcpuBW(cgroup, vcpubw_list[nvcpubw - 1]) < 0) + goto cleanup; + } + } + return 0; + } + + for (i = 0; i < priv->nvcpupids; i++) { + rc = virCgroupForVcpu(cgroup, i, &cgroup_vcpu, 1); + if (rc < 0) { + virReportSystemError(-rc, + _("Unable to create vcpu cgroup for %s(vcpu:" + " %d)"), + vm->def->name, i); + goto cleanup; + } + + /* move the thread for vcpu to sub dir */ + rc = virCgroupAddTask(cgroup_vcpu, priv->vcpupids[i]); + if (rc < 0) { + virReportSystemError(-rc, + _("unable to add vcpu %d task %d to cgroup"), + i, priv->vcpupids[i]); + goto cleanup; + } + + if (vcpubw_list) { + if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) { + vcpubw = virDomainVcpuBWFindByVcpu(vcpubw_list, nvcpubw, i); + if (qemuSetupCgroupVcpuBW(cgroup, vcpubw) < 0) + goto cleanup; + } + } + + virCgroupFree(&cgroup_vcpu); + } + + virCgroupFree(&cgroup_vcpu); + virCgroupFree(&cgroup); + return 0; + +cleanup: + virCgroupFree(&cgroup_vcpu); + if (cgroup) { + virCgroupRemove(cgroup); + virCgroupFree(&cgroup); + } + + return -1; +} + int qemuRemoveCgroup(struct qemud_driver *driver, virDomainObjPtr vm, diff --git a/src/qemu/qemu_cgroup.h b/src/qemu/qemu_cgroup.h index e8abfb4..f0a5cee 100644 --- a/src/qemu/qemu_cgroup.h +++ b/src/qemu/qemu_cgroup.h @@ -49,6 +49,8 @@ int qemuSetupHostUsbDeviceCgroup(usbDevice *dev, void *opaque); int qemuSetupCgroup(struct qemud_driver *driver, virDomainObjPtr vm); +int qemuSetupCgroupVcpuBW(virCgroupPtr cgroup, virDomainVcpuBWDefPtr vcpubw); +int qemuSetupCgroupForVcpu(struct qemud_driver *driver, virDomainObjPtr vm); int qemuRemoveCgroup(struct qemud_driver *driver, virDomainObjPtr vm, int quiet); diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index 88a31a3..ce3a4bb 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -2677,6 +2677,10 @@ int qemuProcessStart(virConnectPtr conn, if (qemuProcessDetectVcpuPIDs(driver, vm) < 0) goto cleanup; + VIR_DEBUG("Setting cgroup for each VCPU(if required)"); + if (qemuSetupCgroupForVcpu(driver, vm) < 0) + goto cleanup; + VIR_DEBUG("Setting VCPU affinities"); if (qemuProcessSetVcpuAffinites(conn, vm) < 0) goto cleanup; diff --git a/tests/qemuxml2argvdata/qemuxml2argv-cputune.xml b/tests/qemuxml2argvdata/qemuxml2argv-cputune.xml index 0afbadb..0a67e40 100644 --- a/tests/qemuxml2argvdata/qemuxml2argv-cputune.xml +++ b/tests/qemuxml2argvdata/qemuxml2argv-cputune.xml @@ -6,6 +6,8 @@ <vcpu>2</vcpu> <cputune> <shares>2048</shares> + <bandwidth vcpu='0' period='1000000' quota='-1'/> + <bandwidth vcpu='1' period='1000' quota='1000'/> <vcpupin vcpu='0' cpuset='0'/> <vcpupin vcpu='1' cpuset='1'/> </cputune> -- 1.7.1

We need this feature in the following patch. --- include/libvirt/libvirt.h.in | 3 ++- src/libvirt.c | 12 ++++++------ src/qemu/qemu_driver.c | 18 ++++++++++-------- 3 files changed, 18 insertions(+), 15 deletions(-) diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index 8e20f75..14d6a88 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -1234,8 +1234,9 @@ typedef virVcpuInfo *virVcpuInfoPtr; /* Flags for controlling virtual CPU hot-plugging. */ typedef enum { - /* Must choose at least one of these two bits; SetVcpus can choose both; + /* Must choose at least one of these three bits; SetVcpus can choose both; see virDomainModificationImpact for details. */ + VIR_DOMAIN_VCPU_CURRENT = VIR_DOMAIN_AFFECT_CURRENT, VIR_DOMAIN_VCPU_LIVE = VIR_DOMAIN_AFFECT_LIVE, VIR_DOMAIN_VCPU_CONFIG = VIR_DOMAIN_AFFECT_CONFIG, diff --git a/src/libvirt.c b/src/libvirt.c index e00c64f..9857e3b 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -6923,13 +6923,18 @@ error: * @flags must include either VIR_DOMAIN_AFFECT_LIVE to query a * running domain (which will fail if domain is not active), or * VIR_DOMAIN_AFFECT_CONFIG to query the XML description of the - * domain. It is an error to set both flags. + * domain, or VIR_DOMAIN_AFFECT_CURRENT to query a running domain + * (if domain is active) or query the XML description of the domain + * (if domain is not active). + * It is an error to set two of these three flags. * * If @flags includes VIR_DOMAIN_VCPU_MAXIMUM, then the maximum * virtual CPU limit is queried. Otherwise, this call queries the * current virtual CPU limit. * * Returns 0 in case of success, -1 in case of failure. + * + * NB. Not all hypervisor support VIR_DOMAIN_AFFECT_CURRENT. */ int @@ -6947,11 +6952,6 @@ virDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags) return -1; } - /* Exactly one of these two flags should be set. */ - if (!(flags & VIR_DOMAIN_AFFECT_LIVE) == !(flags & VIR_DOMAIN_AFFECT_CONFIG)) { - virLibDomainError(VIR_ERR_INVALID_ARG, __FUNCTION__); - goto error; - } conn = domain->conn; if (conn->driver->domainGetVcpusFlags) { diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 8b65c26..9ddbc0f 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -3374,18 +3374,12 @@ qemudDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags) virDomainObjPtr vm; virDomainDefPtr def; int ret = -1; + bool isActive; virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG | VIR_DOMAIN_VCPU_MAXIMUM, -1); - /* Exactly one of LIVE or CONFIG must be set. */ - if (!(flags & VIR_DOMAIN_AFFECT_LIVE) == !(flags & VIR_DOMAIN_AFFECT_CONFIG)) { - qemuReportError(VIR_ERR_INVALID_ARG, - _("invalid flag combination: (0x%x)"), flags); - return -1; - } - qemuDriverLock(driver); vm = virDomainFindByUUID(&driver->domains, dom->uuid); qemuDriverUnlock(driver); @@ -3398,8 +3392,16 @@ qemudDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags) goto cleanup; } + isActive = virDomainObjIsActive(vm); + if ((flags & ~VIR_DOMAIN_VCPU_MAXIMUM) == VIR_DOMAIN_AFFECT_CURRENT) { + if (isActive) + flags |= VIR_DOMAIN_AFFECT_LIVE; + else + flags |= VIR_DOMAIN_AFFECT_CONFIG; + } + if (flags & VIR_DOMAIN_AFFECT_LIVE) { - if (!virDomainObjIsActive(vm)) { + if (!isActive) { qemuReportError(VIR_ERR_OPERATION_INVALID, "%s", _("domain not active")); goto cleanup; -- 1.7.1

At 06/30/2011 11:13 AM, Wen Congyang Write: another typo error: s/params/vcpubw/ s/nparams/nvcpubw/

--- daemon/remote.c | 132 ++++++++++++++++++++++++++++++++++++++++++ src/remote/remote_driver.c | 64 ++++++++++++++++++++ src/remote/remote_protocol.x | 32 ++++++++++- src/rpc/gendispatch.pl | 30 ++++++++++ 4 files changed, 257 insertions(+), 1 deletions(-) diff --git a/daemon/remote.c b/daemon/remote.c index 9e6cf77..c83a8fa 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -100,6 +100,17 @@ remoteDeserializeTypedParameters(remote_typed_param *args_params_val, u_int args_params_len, int limit, int *nparams); +static int +remoteSerializeVcpuBandwidth(virDomainVcpuBWDefPtr vcpubw, + int nvcpubw, + remote_vcpu_bandwidth **args_vcpubw_val, + u_int *args_vcpubw_len); +static virDomainVcpuBWDefPtr +remoteDeserializeVcpuBandwidth(remote_vcpu_bandwidth *ret_vcpubw_val, + u_int ret_vcpubw_len, + int limit, + int *nvcpubw); + #include "remote_dispatch.h" #include "qemu_dispatch.h" @@ -2857,6 +2868,127 @@ cleanup: } +/* Helper to serialize vcpu bandwidth. */ +static int remoteSerializeVcpuBandwidth(virDomainVcpuBWDefPtr vcpubw, + int nvcpubw, + remote_vcpu_bandwidth **ret_vcpubw_val, + u_int *ret_vcpubw_len) +{ + int i; + int rv = -1; + remote_vcpu_bandwidth *val; + + if (VIR_ALLOC_N(val, nvcpubw) < 0) { + virReportOOMError(); + goto cleanup; + } + + for (i = 0; i < nvcpubw; i++) { + val[i].vcpuid = vcpubw[i].vcpuid; + val[i].period = vcpubw[i].period; + val[i].quota = vcpubw[i].quota; + } + + *ret_vcpubw_val = val; + *ret_vcpubw_len = nvcpubw; + val = NULL; + rv = 0; + +cleanup: + VIR_FREE(val); + return rv; +} + + +/* Helper to deserialize vcpu bandwidth. */ +static virDomainVcpuBWDefPtr +remoteDeserializeVcpuBandwidth(remote_vcpu_bandwidth *args_vcpubw_val, + u_int args_vcpubw_len, + int limit, + int *nvcpubw) +{ + int i; + virDomainVcpuBWDefPtr vcpubw = NULL; + + /* Check the length of the returned list carefully. */ + if (args_vcpubw_len > limit) { + virNetError(VIR_ERR_INTERNAL_ERROR, "%s", + _("returned number of vcpubw exceeds limit")); + goto cleanup; + } + if (VIR_ALLOC_N(vcpubw, args_vcpubw_len) < 0) { + virReportOOMError(); + goto cleanup; + } + + /* Deserialise the result. */ + for (i = 0; i < args_vcpubw_len; i++) { + vcpubw[i].vcpuid = args_vcpubw_val[i].vcpuid; + vcpubw[i].period = args_vcpubw_val[i].period; + vcpubw[i].quota = args_vcpubw_val[i].quota; + } + + *nvcpubw = args_vcpubw_len; + +cleanup: + return vcpubw; +} + + +static int +remoteDispatchDomainGetVcpuBW(virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client ATTRIBUTE_UNUSED, + virNetMessageHeaderPtr hdr ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr, + remote_domain_get_vcpu_b_w_args *args, + remote_domain_get_vcpu_b_w_ret *ret) +{ + virDomainPtr dom = NULL; + virDomainVcpuBWDefPtr vcpubw = NULL; + int nvcpubw = args->nvcpubw_list; + int rv = -1; + struct daemonClientPrivate *priv = + virNetServerClientGetPrivateData(client); + + if (!priv->conn) { + virNetError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + if (nvcpubw > REMOTE_DOMAIN_VCPU_MAX) { + virNetError(VIR_ERR_INTERNAL_ERROR, "%s", _("nvcpubw too large")); + goto cleanup; + } + if (VIR_ALLOC_N(vcpubw, nvcpubw) < 0) + goto no_memory; + + if (!(dom = get_nonnull_domain(priv->conn, args->dom))) + goto cleanup; + + if (virDomainGetVcpuBW(dom, vcpubw, &nvcpubw, args->flags) < 0) + goto cleanup; + + if (remoteSerializeVcpuBandwidth(vcpubw, nvcpubw, + &ret->vcpubw_list.vcpubw_list_val, + &ret->vcpubw_list.vcpubw_list_len) < 0) + goto cleanup; + + rv = 0; + +cleanup: + if (rv < 0) + virNetMessageSaveError(rerr); + if (dom) + virDomainFree(dom); + VIR_FREE(vcpubw); + return rv; + +no_memory: + virReportOOMError(); + goto cleanup; +} + + /*----- Helpers. -----*/ /* get_nonnull_domain and get_nonnull_network turn an on-wire diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index 0e68bc5..fe3a4ab 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -1317,6 +1317,68 @@ cleanup: return rv; } +/* Helper to serialize vcpu bandwidth. */ +static int remoteSerializeVcpuBandwidth(virDomainVcpuBWDefPtr vcpubw, + int nvcpubw, + remote_vcpu_bandwidth **args_vcpubw_val, + u_int *args_vcpubw_len) +{ + int i; + int rv = -1; + remote_vcpu_bandwidth *val; + + if (VIR_ALLOC_N(val, nvcpubw) < 0) { + virReportOOMError(); + goto cleanup; + } + + for (i = 0; i < nvcpubw; i++) { + val[i].vcpuid = vcpubw[i].vcpuid; + val[i].period = vcpubw[i].period; + val[i].quota = vcpubw[i].quota; + } + + *args_vcpubw_val = val; + *args_vcpubw_len = nvcpubw; + val = NULL; + rv = 0; + +cleanup: + VIR_FREE(val); + return rv; +} + +/* Helper to deserialize vcpu bandwidth. */ +static int remoteDeserializeVcpuBandwidth(remote_vcpu_bandwidth *ret_vcpubw_val, + u_int ret_vcpubw_len, + int limit, + virDomainVcpuBWDefPtr vcpubw, + int *nvcpubw) +{ + int i; + int rv = -1; + + /* Check the length of the returned list carefully. */ + if (ret_vcpubw_len > limit || ret_vcpubw_len > *nvcpubw) { + remoteError(VIR_ERR_RPC, "%s", + _("returned number of vcpubw exceeds limit")); + goto cleanup; + } + + /* Deserialise the result. */ + for (i = 0; i < ret_vcpubw_len; i++) { + vcpubw[i].vcpuid = ret_vcpubw_val[i].vcpuid; + vcpubw[i].period = ret_vcpubw_val[i].period; + vcpubw[i].quota = ret_vcpubw_val[i].quota; + } + + rv = 0; + *nvcpubw = ret_vcpubw_len; + +cleanup: + return rv; +} + static int remoteDomainGetMemoryParameters (virDomainPtr domain, virTypedParameterPtr params, int *nparams, @@ -4234,6 +4296,8 @@ static virDriver remote_driver = { .domainMigrateFinish3 = remoteDomainMigrateFinish3, /* 0.9.2 */ .domainMigrateConfirm3 = remoteDomainMigrateConfirm3, /* 0.9.2 */ .domainSendKey = remoteDomainSendKey, /* 0.9.3 */ + .domainGetVcpuBW = remoteDomainGetVcpuBW, /* 0.9.4 */ + .domainSetVcpuBW = remoteDomainSetVcpuBW, /* 0.9.4 */ }; static virNetworkDriver network_driver = { diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index 7c3539c..3771ed1 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -193,6 +193,11 @@ const REMOTE_CPU_BASELINE_MAX = 256; */ const REMOTE_DOMAIN_SEND_KEY_MAX = 16; +/* + * Max number of vcpu + */ +const REMOTE_DOMAIN_VCPU_MAX = 4096; + /* UUID. VIR_UUID_BUFLEN definition comes from libvirt.h */ typedef opaque remote_uuid[VIR_UUID_BUFLEN]; @@ -331,6 +336,12 @@ struct remote_node_get_memory_stats { unsigned hyper value; }; +struct remote_vcpu_bandwidth { + int vcpuid; + uint64_t period; + int64_t quota; +}; + /*----- Calls. -----*/ /* For each call we may have a 'remote_CALL_args' and 'remote_CALL_ret' @@ -2115,6 +2126,22 @@ struct remote_domain_get_control_info_ret { /* insert@1 */ unsigned hyper stateTime; }; +struct remote_domain_get_vcpu_b_w_args { + remote_nonnull_domain dom; + int nvcpubw_list; /* call-by-reference */ + unsigned int flags; +}; + +struct remote_domain_get_vcpu_b_w_ret { + remote_vcpu_bandwidth vcpubw_list<REMOTE_DOMAIN_VCPU_MAX>; /* insert@1 */ +}; + +struct remote_domain_set_vcpu_b_w_args { + remote_nonnull_domain dom; + remote_vcpu_bandwidth vcpubw_list<REMOTE_DOMAIN_VCPU_MAX>; + unsigned int flags; +}; + /*----- Protocol. -----*/ /* Define the program number, protocol version and procedure numbers here. */ @@ -2383,7 +2410,10 @@ enum remote_procedure { REMOTE_PROC_NODE_GET_CPU_STATS = 227, /* skipgen skipgen */ REMOTE_PROC_NODE_GET_MEMORY_STATS = 228, /* skipgen skipgen */ REMOTE_PROC_DOMAIN_GET_CONTROL_INFO = 229, /* autogen autogen */ - REMOTE_PROC_DOMAIN_GET_VCPU_PIN_INFO = 230 /* skipgen skipgen */ + REMOTE_PROC_DOMAIN_GET_VCPU_PIN_INFO = 230, /* skipgen skipgen */ + + REMOTE_PROC_DOMAIN_GET_VCPU_B_W = 231, /* skipgen autogen */ + REMOTE_PROC_DOMAIN_SET_VCPU_B_W = 232 /* autogen autogen */ /* * Notice how the entries are grouped in sets of 10 ? diff --git a/src/rpc/gendispatch.pl b/src/rpc/gendispatch.pl index 027560c..7ea1c52 100755 --- a/src/rpc/gendispatch.pl +++ b/src/rpc/gendispatch.pl @@ -423,6 +423,17 @@ elsif ($opt_b) { " &n$1)) == NULL)\n" . " goto cleanup;\n"); push(@free_list, " VIR_FREE(params);"); + } elsif ($args_member =~ m/^remote_vcpu_bandwidth (\S+)<(\S+)>;/) { + push(@vars_list, "virDomainVcpuBWDefPtr $1 = NULL"); + push(@vars_list, "int n$1"); + push(@args_list, "$1"); + push(@args_list, "n$1"); + push(@getters_list, " if (($1 = remoteDeserializeVcpuBandwidth(args->$1.$1_val,\n" . + " args->$1.$1_len,\n" . + " $2,\n" . + " &n$1)) == NULL)\n" . + " goto cleanup;\n"); + push(@free_list, " VIR_FREE(vcpubw_list);"); } elsif ($args_member =~ m/<\S+>;/ or $args_member =~ m/\[\S+\];/) { # just make all other array types fail die "unhandled type for argument value: $args_member"; @@ -1099,6 +1110,13 @@ elsif ($opt_k) { " xdr_free((xdrproc_t)xdr_$call->{args}, (char *)&args);\n" . " goto done;\n" . " }"); + } elsif ($args_member =~ m/^remote_vcpu_bandwidth (\S+)<(\S+)>;/) { + push(@args_list, "virDomainVcpuBWDefPtr $1"); + push(@args_list, "int n$1"); + push(@setters_list2, "if (remoteSerializeVcpuBandwidth($1, n$1, &args.$1.$1_val, &args.$1.$1_len) < 0) {\n" . + " xdr_free((xdrproc_t)xdr_$call->{args}, (char *)&args);\n" . + " goto done;\n" . + " }"); } elsif ($args_member =~ m/^((?:unsigned )?int) (\S+);\s*\/\*\s*call-by-reference\s*\*\//) { my $type_name = "$1 *"; my $arg_name = $2; @@ -1264,6 +1282,18 @@ elsif ($opt_k) { } elsif ($ret_member =~ m/^remote_typed_param (\S+)<\S+>;/) { # error out on unannotated arrays die "remote_typed_param array without insert@<offset> annotation: $ret_member"; + } elsif ($ret_member =~ m/^remote_vcpu_bandwidth (\S+)<(\S+)>;\s*\/\*\s*insert@(\d+)\s*\*\//) { + splice(@args_list, int($3), 0, ("virDomainVcpuBWDefPtr $1")); + push(@ret_list2, "if (remoteDeserializeVcpuBandwidth(ret.$1.$1_val,\n" . + " ret.$1.$1_len,\n" . + " $2,\n" . + " $1,\n" . + " n$1) < 0)\n" . + " goto cleanup;\n"); + $single_ret_cleanup = 1; + } elsif ($ret_member =~ m/^remote_vcpu_bandwidth (\S+)<\S+>;/) { + # error out on unannotated arrays + die "remote_vcpu_bandwidth array without insert@<offset> annotation: $ret_member"; } elsif ($ret_member =~ m/^int (\S+);/) { my $arg_name = $1; -- 1.7.1

On Thu, 30 Jun 2011 11:19:14 +0800 Wen Congyang <wency(a)cn.fujitsu.com&gt; wrote: I try the following: # virsh domstate VM shut off # virsh vcpu-bandwidth VM --config vcpu: period quota ---------------------------------- 0: 100000 50000 1: 100000 50000 2: 100000 50000 3: 100000 50000 # virsh start VM Domain VM started # virsh vcpu-bandwidth VM --live vcpu: period quota ---------------------------------- 0: 100000 -1 1: 100000 -1 2: 100000 -1 3: 100000 -1 This behavior doesn't make sense to me. Is this what you intend? Or, do I make a mistake? Is the following case OK? VCPU#4-7 are not present. <vcpu current='4'>8</vcpu> This check should be done before querying? -- Taku Izumi <izumi.taku(a)jp.fujitsu.com&gt;

--- docs/formatdomain.html.in | 19 +++++++++++++++++++ 1 files changed, 19 insertions(+), 0 deletions(-) diff --git a/docs/formatdomain.html.in b/docs/formatdomain.html.in index 3a64983..7e1e5f0 100644 --- a/docs/formatdomain.html.in +++ b/docs/formatdomain.html.in @@ -294,6 +294,8 @@ &lt;vcpupin vcpu="2" cpuset="2,3"/&gt; &lt;vcpupin vcpu="3" cpuset="0,4"/&gt; &lt;shares&gt;2048&lt;/shares&gt; + &lt;period&gt;1000000000&lt;/period&gt; + &lt;quota&gt;-1&lt;/quota&gt; &lt;/cputune&gt; &lt;numatune&gt; &lt;memory mode="strict" nodeset="1-4,^3"/&gt; @@ -385,6 +387,23 @@ 2048 will get twice as much CPU time as a VM configured with value 1024. <span class="since">Since 0.9.0</span> </dd> + <dt><code>period</code></dt> + <dd> + The optional <code>period</code> element specifies the enforcement + interval(unit: microseconds). Within <code>period</code>, the domain + will not be allowed to consume more than <code>quota</code> worth of + runtime. The value should be in range [1000, 1000000]. + <span class="since">Since 0.9.4</span> + </dd> + <dt><code>quota</code></dt> + <dd> + The optional <code>quota</code> element specifies the maximum allowed + bandwidth(unit: microseconds). A domain with <code>quota</code> as any + negative value indicates that the domain has infinite bandwidth, which + means that it is not bandwidth controlled. The value should be in range + [1000, 18446744073709551] or less than 0. + <span class="since">Since 0.9.4</span> + </dd> <dt><code>numatune</code></dt> <dd> The optional <code>numatune</code> element provides details of -- 1.7.1