API agreed on in https://www.redhat.com/archives/libvir-list/2010-September/msg00456.html v2: update enum names for consistency with virDomainDeviceModifyFlags. * include/libvirt/libvirt.h.in (virDomainVcpuFlags) (virDomainSetVcpusFlags, virDomainGetVcpusFlags): New declarations. * src/libvirt_public.syms: Export new symbols. --- include/libvirt/libvirt.h.in | 15 +++++++++++++++ src/libvirt_public.syms | 2 ++ 2 files changed, 17 insertions(+), 0 deletions(-) diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index 2eba61e..d0cc4c0 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -915,8 +915,23 @@ struct _virVcpuInfo { }; 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 */ + VIR_DOMAIN_VCPU_LIVE = (1 << 0), /* Affect active domain */ + VIR_DOMAIN_VCPU_CONFIG = (1 << 1), /* Affect next boot */ + + /* Additional flags to be bit-wise OR'd in */ + VIR_DOMAIN_VCPU_MAXIMUM = (1 << 2), /* Max rather than current count */ +} virDomainVcpuFlags; + int virDomainSetVcpus (virDomainPtr domain, unsigned int nvcpus); +int virDomainSetVcpusFlags (virDomainPtr domain, + unsigned int nvcpus, + unsigned int flags); +int virDomainGetVcpusFlags (virDomainPtr domain, + unsigned int flags); int virDomainPinVcpu (virDomainPtr domain, unsigned int vcpu, diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms index fceb516..a8091b1 100644 --- a/src/libvirt_public.syms +++ b/src/libvirt_public.syms @@ -409,6 +409,8 @@ LIBVIRT_0.8.5 { global: virDomainSetMemoryParameters; virDomainGetMemoryParameters; + virDomainGetVcpusFlags; + virDomainSetVcpusFlags; } LIBVIRT_0.8.2; # .... define new API here using predicted next version number .... -- 1.7.2.3

v2 changes: Add doc references to old API. Update to new flag names. Factor driver-independent checks to happen up front. * src/libvirt.c (virDomainSetVcpusFlags, virDomainGetVcpusFlags): New functions. (virDomainSetVcpus, virDomainGetMaxVcpus): Refer to new API. --- src/libvirt.c | 140 ++++++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 files changed, 134 insertions(+), 6 deletions(-) diff --git a/src/libvirt.c b/src/libvirt.c index 2868460..c9f93c6 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -5178,7 +5178,9 @@ error: * This function requires privileged access to the hypervisor. * * This command only changes the runtime configuration of the domain, - * so can only be called on an active domain. + * so can only be called on an active domain. It is hypervisor-dependent + * whether it also affects persistent configuration; for more control, + * use virDomainSetVcpusFlags(). * * Returns 0 in case of success, -1 in case of failure. */ @@ -5223,13 +5225,139 @@ error: } /** + * virDomainSetVcpusFlags: + * @domain: pointer to domain object, or NULL for Domain0 + * @nvcpus: the new number of virtual CPUs for this domain, must be at least 1 + * @flags: an OR'ed set of virDomainVcpuFlags + * + * Dynamically change the number of virtual CPUs used by the domain. + * Note that this call may fail if the underlying virtualization hypervisor + * does not support it or if growing the number is arbitrary limited. + * This function requires privileged access to the hypervisor. + * + * @flags must include VIR_DOMAIN_VCPU_LIVE to affect a running + * domain (which may fail if domain is not active), or + * VIR_DOMAIN_VCPU_CONFIG to affect the next boot via the XML + * description of the domain. Both flags may be set. + * + * If @flags includes VIR_DOMAIN_VCPU_MAXIMUM, then + * VIR_DOMAIN_VCPU_LIVE must be clear, and only the maximum virtual + * CPU limit is altered; generally, this value must be less than or + * equal to virConnectGetMaxVcpus(). Otherwise, this call affects the + * current virtual CPU limit, which must be less than or equal to the + * maximum limit. + * + * Returns 0 in case of success, -1 in case of failure. + */ + +int +virDomainSetVcpusFlags(virDomainPtr domain, unsigned int nvcpus, + unsigned int flags) +{ + virConnectPtr conn; + DEBUG("domain=%p, nvcpus=%u, flags=%u", domain, nvcpus, flags); + + virResetLastError(); + + if (!VIR_IS_CONNECTED_DOMAIN(domain)) { + virLibDomainError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + virDispatchError(NULL); + return (-1); + } + if (domain->conn->flags & VIR_CONNECT_RO) { + virLibDomainError(domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__); + goto error; + } + + /* Perform some argument validation common to all implementations. */ + if (nvcpus < 1 || (unsigned short) nvcpus != nvcpus || + (flags & (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_CONFIG)) == 0) { + virLibDomainError(domain, VIR_ERR_INVALID_ARG, __FUNCTION__); + goto error; + } + conn = domain->conn; + + if (conn->driver->domainSetVcpusFlags) { + int ret; + ret = conn->driver->domainSetVcpusFlags (domain, nvcpus, flags); + if (ret < 0) + goto error; + return ret; + } + + virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__); + +error: + virDispatchError(domain->conn); + return -1; +} + +/** + * virDomainGetVcpusFlags: + * @domain: pointer to domain object, or NULL for Domain0 + * @flags: an OR'ed set of virDomainVcpuFlags + * + * Query the number of virtual CPUs used by the domain. Note that + * this call may fail if the underlying virtualization hypervisor does + * not support it. This function requires privileged access to the + * hypervisor. + * + * @flags must include either VIR_DOMAIN_VCPU_ACTIVE to query a + * running domain (which will fail if domain is not active), or + * VIR_DOMAIN_VCPU_PERSISTENT to query the XML description of the + * domain. It is an error to set both 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. + */ + +int +virDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags) +{ + virConnectPtr conn; + DEBUG("domain=%p, flags=%u", domain, flags); + + virResetLastError(); + + if (!VIR_IS_CONNECTED_DOMAIN(domain)) { + virLibDomainError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + virDispatchError(NULL); + return (-1); + } + + /* Exactly one of these two flags should be set. */ + if (!(flags & VIR_DOMAIN_VCPU_LIVE) == !(flags & VIR_DOMAIN_VCPU_CONFIG)) { + virLibDomainError(domain, VIR_ERR_INVALID_ARG, __FUNCTION__); + goto error; + } + conn = domain->conn; + + if (conn->driver->domainGetVcpusFlags) { + int ret; + ret = conn->driver->domainGetVcpusFlags (domain, flags); + if (ret < 0) + goto error; + return ret; + } + + virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__); + +error: + virDispatchError(domain->conn); + return -1; +} + +/** * virDomainPinVcpu: * @domain: pointer to domain object, or NULL for Domain0 * @vcpu: virtual CPU number * @cpumap: pointer to a bit map of real CPUs (in 8-bit bytes) (IN) - * Each bit set to 1 means that corresponding CPU is usable. - * Bytes are stored in little-endian order: CPU0-7, 8-15... - * In each byte, lowest CPU number is least significant bit. + * Each bit set to 1 means that corresponding CPU is usable. + * Bytes are stored in little-endian order: CPU0-7, 8-15... + * In each byte, lowest CPU number is least significant bit. * @maplen: number of bytes in cpumap, from 1 up to size of CPU map in * underlying virtualization system (Xen...). * If maplen < size, missing bytes are set to zero. @@ -5357,9 +5485,9 @@ error: * * Provides the maximum number of virtual CPUs supported for * the guest VM. If the guest is inactive, this is basically - * the same as virConnectGetMaxVcpus. If the guest is running + * the same as virConnectGetMaxVcpus(). If the guest is running * this will reflect the maximum number of virtual CPUs the - * guest was booted with. + * guest was booted with. For more details, see virDomainGetVcpusFlags(). * * Returns the maximum of virtual CPU or -1 in case of error. */ -- 1.7.2.3

Note - this wrapping is completely mechanical; the old API will function identically, since the new API validates that the exact same flags are provided by the old API. On a per-driver basis, it may make sense to have the old API pass a different set of flags, but that should be done in the per-driver patch that implements the full range of flag support in the new API. v2: update flag names * src/esx/esx_driver.c (esxDomainSetVcpus, escDomainGetMaxVpcus): Move guts... (esxDomainSetVcpusFlags, esxDomainGetVcpusFlags): ...to new functions. (esxDriver): Trivially support the new API. * src/openvz/openvz_driver.c (openvzDomainSetVcpus) (openvzDomainSetVcpusFlags, openvzDomainGetMaxVcpus) (openvzDomainGetVcpusFlags, openvzDriver): Likewise. * src/phyp/phyp_driver.c (phypDomainSetCPU) (phypDomainSetVcpusFlags, phypGetLparCPUMAX) (phypDomainGetVcpusFlags, phypDriver): Likewise. * src/qemu/qemu_driver.c (qemudDomainSetVcpus) (qemudDomainSetVcpusFlags, qemudDomainGetMaxVcpus) (qemudDomainGetVcpusFlags, qemuDriver): Likewise. * src/test/test_driver.c (testSetVcpus, testDomainSetVcpusFlags) (testDomainGetMaxVcpus, testDomainGetVcpusFlags, testDriver): Likewise. * src/vbox/vbox_tmpl.c (vboxDomainSetVcpus) (vboxDomainSetVcpusFlags, virDomainGetMaxVcpus) (virDomainGetVcpusFlags, virDriver): Likewise. * src/xen/xen_driver.c (xenUnifiedDomainSetVcpus) (xenUnifiedDomainSetVcpusFlags, xenUnifiedDomainGetMaxVcpus) (xenUnifiedDomainGetVcpusFlags, xenUnifiedDriver): Likewise. * src/xenapi/xenapi_driver.c (xenapiDomainSetVcpus) (xenapiDomainSetVcpusFlags, xenapiDomainGetMaxVcpus) (xenapiDomainGetVcpusFlags, xenapiDriver): Likewise. (xenapiError): New helper macro. --- src/esx/esx_driver.c | 32 +++++++++++++++++++--- src/openvz/openvz_driver.c | 34 +++++++++++++++++++++--- src/phyp/phyp_driver.c | 32 ++++++++++++++++++++--- src/qemu/qemu_driver.c | 38 +++++++++++++++++++++++++--- src/test/test_driver.c | 36 ++++++++++++++++++++++--- src/vbox/vbox_tmpl.c | 36 +++++++++++++++++++++++--- src/xen/xen_driver.c | 34 ++++++++++++++++++++++--- src/xenapi/xenapi_driver.c | 60 ++++++++++++++++++++++++++++++++++++++------ 8 files changed, 263 insertions(+), 39 deletions(-) diff --git a/src/esx/esx_driver.c b/src/esx/esx_driver.c index 1b5545a..465da45 100644 --- a/src/esx/esx_driver.c +++ b/src/esx/esx_driver.c @@ -2382,7 +2382,8 @@ esxDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info) static int -esxDomainSetVcpus(virDomainPtr domain, unsigned int nvcpus) +esxDomainSetVcpusFlags(virDomainPtr domain, unsigned int nvcpus, + unsigned int flags) { int result = -1; esxPrivate *priv = domain->conn->privateData; @@ -2392,6 +2393,11 @@ esxDomainSetVcpus(virDomainPtr domain, unsigned int nvcpus) esxVI_ManagedObjectReference *task = NULL; esxVI_TaskInfoState taskInfoState; + if (flags != VIR_DOMAIN_VCPU_LIVE) { + ESX_ERROR(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags); + return -1; + } + if (nvcpus < 1) { ESX_ERROR(VIR_ERR_INVALID_ARG, "%s", _("Requested number of virtual CPUs must at least be 1")); @@ -2451,15 +2457,26 @@ esxDomainSetVcpus(virDomainPtr domain, unsigned int nvcpus) } +static int +esxDomainSetVcpus(virDomainPtr domain, unsigned int nvcpus) +{ + return esxDomainSetVcpusFlags(domain, nvcpus, VIR_DOMAIN_VCPU_LIVE); +} + static int -esxDomainGetMaxVcpus(virDomainPtr domain) +esxDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags) { esxPrivate *priv = domain->conn->privateData; esxVI_String *propertyNameList = NULL; esxVI_ObjectContent *hostSystem = NULL; esxVI_DynamicProperty *dynamicProperty = NULL; + if (flags != (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) { + ESX_ERROR(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags); + return -1; + } + if (priv->maxVcpus > 0) { return priv->maxVcpus; } @@ -2505,7 +2522,12 @@ esxDomainGetMaxVcpus(virDomainPtr domain) return priv->maxVcpus; } - +static int +esxDomainGetMaxVcpus(virDomainPtr domain) +{ + return esxDomainGetVcpusFlags(domain, (VIR_DOMAIN_VCPU_LIVE | + VIR_DOMAIN_VCPU_MAXIMUM)); +} static char * esxDomainDumpXML(virDomainPtr domain, int flags) @@ -4150,8 +4172,8 @@ static virDriver esxDriver = { NULL, /* domainRestore */ NULL, /* domainCoreDump */ esxDomainSetVcpus, /* domainSetVcpus */ - NULL, /* domainSetVcpusFlags */ - NULL, /* domainGetVcpusFlags */ + esxDomainSetVcpusFlags, /* domainSetVcpusFlags */ + esxDomainGetVcpusFlags, /* domainGetVcpusFlags */ NULL, /* domainPinVcpu */ NULL, /* domainGetVcpus */ esxDomainGetMaxVcpus, /* domainGetMaxVcpus */ diff --git a/src/openvz/openvz_driver.c b/src/openvz/openvz_driver.c index 9d19aeb..0f3cfdf 100644 --- a/src/openvz/openvz_driver.c +++ b/src/openvz/openvz_driver.c @@ -67,7 +67,6 @@ static int openvzGetProcessInfo(unsigned long long *cpuTime, int vpsid); static int openvzGetMaxVCPUs(virConnectPtr conn, const char *type); static int openvzDomainGetMaxVcpus(virDomainPtr dom); -static int openvzDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus); static int openvzDomainSetVcpusInternal(virDomainObjPtr vm, unsigned int nvcpus); static int openvzDomainSetMemoryInternal(virDomainObjPtr vm, @@ -1211,11 +1210,24 @@ static int openvzGetMaxVCPUs(virConnectPtr conn ATTRIBUTE_UNUSED, return -1; } +static int +openvzDomainGetVcpusFlags(virDomainPtr dom ATTRIBUTE_UNUSED, + unsigned int flags) +{ + if (flags != (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) { + openvzError(VIR_ERR_INVALID_ARG, _("unsupported flags (0x%x)"), flags); + return -1; + } -static int openvzDomainGetMaxVcpus(virDomainPtr dom ATTRIBUTE_UNUSED) { return openvzGetMaxVCPUs(NULL, "openvz"); } +static int openvzDomainGetMaxVcpus(virDomainPtr dom) +{ + return openvzDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_LIVE | + VIR_DOMAIN_VCPU_MAXIMUM)); +} + static int openvzDomainSetVcpusInternal(virDomainObjPtr vm, unsigned int nvcpus) { @@ -1241,12 +1253,18 @@ static int openvzDomainSetVcpusInternal(virDomainObjPtr vm, return 0; } -static int openvzDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus) +static int openvzDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus, + unsigned int flags) { virDomainObjPtr vm; struct openvz_driver *driver = dom->conn->privateData; int ret = -1; + if (flags != VIR_DOMAIN_VCPU_LIVE) { + openvzError(VIR_ERR_INVALID_ARG, _("unsupported flags (0x%x)"), flags); + return -1; + } + openvzDriverLock(driver); vm = virDomainFindByUUID(&driver->domains, dom->uuid); openvzDriverUnlock(driver); @@ -1272,6 +1290,12 @@ cleanup: return ret; } +static int +openvzDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus) +{ + return openvzDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_VCPU_LIVE); +} + static virDrvOpenStatus openvzOpen(virConnectPtr conn, virConnectAuthPtr auth ATTRIBUTE_UNUSED, int flags ATTRIBUTE_UNUSED) @@ -1590,8 +1614,8 @@ static virDriver openvzDriver = { NULL, /* domainRestore */ NULL, /* domainCoreDump */ openvzDomainSetVcpus, /* domainSetVcpus */ - NULL, /* domainSetVcpusFlags */ - NULL, /* domainGetVcpusFlags */ + openvzDomainSetVcpusFlags, /* domainSetVcpusFlags */ + openvzDomainGetVcpusFlags, /* domainGetVcpusFlags */ NULL, /* domainPinVcpu */ NULL, /* domainGetVcpus */ openvzDomainGetMaxVcpus, /* domainGetMaxVcpus */ diff --git a/src/phyp/phyp_driver.c b/src/phyp/phyp_driver.c index 6e0a5e9..e284ae0 100644 --- a/src/phyp/phyp_driver.c +++ b/src/phyp/phyp_driver.c @@ -1497,15 +1497,27 @@ phypGetLparCPU(virConnectPtr conn, const char *managed_system, int lpar_id) } static int -phypGetLparCPUMAX(virDomainPtr dom) +phypDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags) { phyp_driverPtr phyp_driver = dom->conn->privateData; char *managed_system = phyp_driver->managed_system; + if (flags != (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) { + PHYP_ERROR(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags); + return -1; + } + return phypGetLparCPUGeneric(dom->conn, managed_system, dom->id, 1); } static int +phypGetLparCPUMAX(virDomainPtr dom) +{ + return phypDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_LIVE | + VIR_DOMAIN_VCPU_MAXIMUM)); +} + +static int phypGetRemoteSlot(virConnectPtr conn, const char *managed_system, const char *lpar_name) { @@ -3831,7 +3843,8 @@ phypConnectGetCapabilities(virConnectPtr conn) } static int -phypDomainSetCPU(virDomainPtr dom, unsigned int nvcpus) +phypDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus, + unsigned int flags) { ConnectionData *connection_data = dom->conn->networkPrivateData; phyp_driverPtr phyp_driver = dom->conn->privateData; @@ -3846,6 +3859,11 @@ phypDomainSetCPU(virDomainPtr dom, unsigned int nvcpus) unsigned int amount = 0; virBuffer buf = VIR_BUFFER_INITIALIZER; + if (flags != VIR_DOMAIN_VCPU_LIVE) { + PHYP_ERROR(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags); + return -1; + } + if ((ncpus = phypGetLparCPU(dom->conn, managed_system, dom->id)) == 0) return 0; @@ -3891,6 +3909,12 @@ phypDomainSetCPU(virDomainPtr dom, unsigned int nvcpus) } +static int +phypDomainSetCPU(virDomainPtr dom, unsigned int nvcpus) +{ + return phypDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_VCPU_LIVE); +} + static virDrvOpenStatus phypVIOSDriverOpen(virConnectPtr conn, virConnectAuthPtr auth ATTRIBUTE_UNUSED, @@ -3941,8 +3965,8 @@ static virDriver phypDriver = { NULL, /* domainRestore */ NULL, /* domainCoreDump */ phypDomainSetCPU, /* domainSetVcpus */ - NULL, /* domainSetVcpusFlags */ - NULL, /* domainGetVcpusFlags */ + phypDomainSetVcpusFlags, /* domainSetVcpusFlags */ + phypDomainGetVcpusFlags, /* domainGetVcpusFlags */ NULL, /* domainPinVcpu */ NULL, /* domainGetVcpus */ phypGetLparCPUMAX, /* domainGetMaxVcpus */ diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 0078973..ba39f2a 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -5933,13 +5933,22 @@ unsupported: } -static int qemudDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus) { +static int +qemudDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus, + unsigned int flags) +{ struct qemud_driver *driver = dom->conn->privateData; virDomainObjPtr vm; const char * type; int max; int ret = -1; + if (flags != VIR_DOMAIN_VCPU_LIVE) { + qemuReportError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), + flags); + return -1; + } + qemuDriverLock(driver); vm = virDomainFindByUUID(&driver->domains, dom->uuid); qemuDriverUnlock(driver); @@ -5993,6 +6002,12 @@ cleanup: return ret; } +static int +qemudDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus) +{ + return qemudDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_VCPU_LIVE); +} + static int qemudDomainPinVcpu(virDomainPtr dom, @@ -6149,12 +6164,20 @@ cleanup: } -static int qemudDomainGetMaxVcpus(virDomainPtr dom) { +static int +qemudDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags) +{ struct qemud_driver *driver = dom->conn->privateData; virDomainObjPtr vm; const char *type; int ret = -1; + if (flags != (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) { + qemuReportError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), + flags); + return -1; + } + qemuDriverLock(driver); vm = virDomainFindByUUID(&driver->domains, dom->uuid); qemuDriverUnlock(driver); @@ -6182,6 +6205,13 @@ cleanup: return ret; } +static int +qemudDomainGetMaxVcpus(virDomainPtr dom) +{ + return qemudDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_LIVE | + VIR_DOMAIN_VCPU_MAXIMUM)); +} + static int qemudDomainGetSecurityLabel(virDomainPtr dom, virSecurityLabelPtr seclabel) { struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData; @@ -12902,8 +12932,8 @@ static virDriver qemuDriver = { qemudDomainRestore, /* domainRestore */ qemudDomainCoreDump, /* domainCoreDump */ qemudDomainSetVcpus, /* domainSetVcpus */ - NULL, /* domainSetVcpusFlags */ - NULL, /* domainGetVcpusFlags */ + qemudDomainSetVcpusFlags, /* domainSetVcpusFlags */ + qemudDomainGetVcpusFlags, /* domainGetVcpusFlags */ qemudDomainPinVcpu, /* domainPinVcpu */ qemudDomainGetVcpus, /* domainGetVcpus */ qemudDomainGetMaxVcpus, /* domainGetMaxVcpus */ diff --git a/src/test/test_driver.c b/src/test/test_driver.c index 6a00558..b70c80d 100644 --- a/src/test/test_driver.c +++ b/src/test/test_driver.c @@ -2029,17 +2029,37 @@ cleanup: return ret; } -static int testDomainGetMaxVcpus(virDomainPtr domain) +static int +testDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags) { + if (flags != (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) { + testError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags); + return -1; + } + return testGetMaxVCPUs(domain->conn, "test"); } -static int testSetVcpus(virDomainPtr domain, - unsigned int nrCpus) { +static int +testDomainGetMaxVcpus(virDomainPtr domain) +{ + return testDomainGetVcpusFlags(domain, (VIR_DOMAIN_VCPU_LIVE | + VIR_DOMAIN_VCPU_MAXIMUM)); +} + +static int +testDomainSetVcpusFlags(virDomainPtr domain, unsigned int nrCpus, + unsigned int flags) +{ testConnPtr privconn = domain->conn->privateData; virDomainObjPtr privdom = NULL; int ret = -1, maxvcpus; + if (flags != VIR_DOMAIN_VCPU_LIVE) { + testError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags); + return -1; + } + /* Do this first before locking */ maxvcpus = testDomainGetMaxVcpus(domain); if (maxvcpus < 0) @@ -2082,6 +2102,12 @@ cleanup: return ret; } +static int +testSetVcpus(virDomainPtr domain, unsigned int nrCpus) +{ + return testDomainSetVcpusFlags(domain, nrCpus, VIR_DOMAIN_VCPU_LIVE); +} + static int testDomainGetVcpus(virDomainPtr domain, virVcpuInfoPtr info, int maxinfo, @@ -5260,8 +5286,8 @@ static virDriver testDriver = { testDomainRestore, /* domainRestore */ testDomainCoreDump, /* domainCoreDump */ testSetVcpus, /* domainSetVcpus */ - NULL, /* domainSetVcpusFlags */ - NULL, /* domainGetVcpusFlags */ + testDomainSetVcpusFlags, /* domainSetVcpusFlags */ + testDomainGetVcpusFlags, /* domainGetVcpusFlags */ testDomainPinVcpu, /* domainPinVcpu */ testDomainGetVcpus, /* domainGetVcpus */ testDomainGetMaxVcpus, /* domainGetMaxVcpus */ diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index cb9193a..0cbe8b3 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -1839,13 +1839,21 @@ cleanup: return ret; } -static int vboxDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus) { +static int +vboxDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus, + unsigned int flags) +{ VBOX_OBJECT_CHECK(dom->conn, int, -1); IMachine *machine = NULL; vboxIID *iid = NULL; PRUint32 CPUCount = nvcpus; nsresult rc; + if (flags != VIR_DOMAIN_VCPU_LIVE) { + vboxError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags); + return -1; + } + #if VBOX_API_VERSION == 2002 if (VIR_ALLOC(iid) < 0) { virReportOOMError(); @@ -1887,11 +1895,24 @@ cleanup: return ret; } -static int vboxDomainGetMaxVcpus(virDomainPtr dom) { +static int +vboxDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus) +{ + return vboxDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_VCPU_LIVE); +} + +static int +vboxDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags) +{ VBOX_OBJECT_CHECK(dom->conn, int, -1); ISystemProperties *systemProperties = NULL; PRUint32 maxCPUCount = 0; + if (flags != (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) { + vboxError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags); + return -1; + } + /* Currently every domain supports the same number of max cpus * as that supported by vbox and thus take it directly from * the systemproperties. @@ -1909,6 +1930,13 @@ static int vboxDomainGetMaxVcpus(virDomainPtr dom) { return ret; } +static int +vboxDomainGetMaxVcpus(virDomainPtr dom) +{ + return vboxDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_LIVE | + VIR_DOMAIN_VCPU_MAXIMUM)); +} + static char *vboxDomainDumpXML(virDomainPtr dom, int flags) { VBOX_OBJECT_CHECK(dom->conn, char *, NULL); virDomainDefPtr def = NULL; @@ -8267,8 +8295,8 @@ virDriver NAME(Driver) = { NULL, /* domainRestore */ NULL, /* domainCoreDump */ vboxDomainSetVcpus, /* domainSetVcpus */ - NULL, /* domainSetVcpusFlags */ - NULL, /* domainGetVcpusFlags */ + vboxDomainSetVcpusFlags, /* domainSetVcpusFlags */ + vboxDomainGetVcpusFlags, /* domainGetVcpusFlags */ NULL, /* domainPinVcpu */ NULL, /* domainGetVcpus */ vboxDomainGetMaxVcpus, /* domainGetMaxVcpus */ diff --git a/src/xen/xen_driver.c b/src/xen/xen_driver.c index 7d67ced..d6c9c57 100644 --- a/src/xen/xen_driver.c +++ b/src/xen/xen_driver.c @@ -1069,11 +1069,18 @@ xenUnifiedDomainCoreDump (virDomainPtr dom, const char *to, int flags) } static int -xenUnifiedDomainSetVcpus (virDomainPtr dom, unsigned int nvcpus) +xenUnifiedDomainSetVcpusFlags (virDomainPtr dom, unsigned int nvcpus, + unsigned int flags) { GET_PRIVATE(dom->conn); int i; + if (flags != VIR_DOMAIN_VCPU_LIVE) { + xenUnifiedError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), + flags); + return -1; + } + /* Try non-hypervisor methods first, then hypervisor direct method * as a last resort. */ @@ -1093,6 +1100,12 @@ xenUnifiedDomainSetVcpus (virDomainPtr dom, unsigned int nvcpus) } static int +xenUnifiedDomainSetVcpus (virDomainPtr dom, unsigned int nvcpus) +{ + return xenUnifiedDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_VCPU_LIVE); +} + +static int xenUnifiedDomainPinVcpu (virDomainPtr dom, unsigned int vcpu, unsigned char *cpumap, int maplen) { @@ -1126,11 +1139,17 @@ xenUnifiedDomainGetVcpus (virDomainPtr dom, } static int -xenUnifiedDomainGetMaxVcpus (virDomainPtr dom) +xenUnifiedDomainGetVcpusFlags (virDomainPtr dom, unsigned int flags) { GET_PRIVATE(dom->conn); int i, ret; + if (flags != (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) { + xenUnifiedError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), + flags); + return -1; + } + for (i = 0; i < XEN_UNIFIED_NR_DRIVERS; ++i) if (priv->opened[i] && drivers[i]->domainGetMaxVcpus) { ret = drivers[i]->domainGetMaxVcpus (dom); @@ -1140,6 +1159,13 @@ xenUnifiedDomainGetMaxVcpus (virDomainPtr dom) return -1; } +static int +xenUnifiedDomainGetMaxVcpus (virDomainPtr dom) +{ + return xenUnifiedDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_LIVE | + VIR_DOMAIN_VCPU_MAXIMUM)); +} + static char * xenUnifiedDomainDumpXML (virDomainPtr dom, int flags) { @@ -1951,8 +1977,8 @@ static virDriver xenUnifiedDriver = { xenUnifiedDomainRestore, /* domainRestore */ xenUnifiedDomainCoreDump, /* domainCoreDump */ xenUnifiedDomainSetVcpus, /* domainSetVcpus */ - NULL, /* domainSetVcpusFlags */ - NULL, /* domainGetVcpusFlags */ + xenUnifiedDomainSetVcpusFlags, /* domainSetVcpusFlags */ + xenUnifiedDomainGetVcpusFlags, /* domainGetVcpusFlags */ xenUnifiedDomainPinVcpu, /* domainPinVcpu */ xenUnifiedDomainGetVcpus, /* domainGetVcpus */ xenUnifiedDomainGetMaxVcpus, /* domainGetMaxVcpus */ diff --git a/src/xenapi/xenapi_driver.c b/src/xenapi/xenapi_driver.c index 753169c..7d4ab8d 100644 --- a/src/xenapi/xenapi_driver.c +++ b/src/xenapi/xenapi_driver.c @@ -40,6 +40,11 @@ #include "xenapi_driver_private.h" #include "xenapi_utils.h" +#define VIR_FROM_THIS VIR_FROM_XENAPI + +#define xenapiError(code, ...) \ + virReportErrorHelper(NULL, VIR_FROM_THIS, code, __FILE__, \ + __FUNCTION__, __LINE__, __VA_ARGS__) /* * getCapsObject @@ -987,19 +992,26 @@ xenapiDomainGetInfo (virDomainPtr dom, virDomainInfoPtr info) /* - * xenapiDomainSetVcpus + * xenapiDomainSetVcpusFlags * * Sets the VCPUs on the domain * Return 0 on success or -1 in case of error */ static int -xenapiDomainSetVcpus (virDomainPtr dom, unsigned int nvcpus) +xenapiDomainSetVcpusFlags (virDomainPtr dom, unsigned int nvcpus, + unsigned int flags) { - /* vm.set_vcpus_max */ xen_vm vm; xen_vm_set *vms; xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session; + + if (flags != VIR_DOMAIN_VCPU_LIVE) { + xenapiError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), + flags); + return -1; + } + if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) { if (vms->size != 1) { xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, @@ -1019,6 +1031,18 @@ xenapiDomainSetVcpus (virDomainPtr dom, unsigned int nvcpus) } /* + * xenapiDomainSetVcpus + * + * Sets the VCPUs on the domain + * Return 0 on success or -1 in case of error + */ +static int +xenapiDomainSetVcpus (virDomainPtr dom, unsigned int nvcpus) +{ + return xenapiDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_VCPU_LIVE); +} + +/* * xenapiDomainPinVcpu * * Dynamically change the real CPUs which can be allocated to a virtual CPU @@ -1140,19 +1164,26 @@ xenapiDomainGetVcpus (virDomainPtr dom, } /* - * xenapiDomainGetMaxVcpus + * xenapiDomainGetVcpusFlags * * - * Returns maximum number of Vcpus on success or -1 in case of error + * Returns Vcpus count on success or -1 in case of error */ static int -xenapiDomainGetMaxVcpus (virDomainPtr dom) +xenapiDomainGetVcpusFlags (virDomainPtr dom, unsigned int flags) { xen_vm vm; xen_vm_set *vms; int64_t maxvcpu = 0; enum xen_vm_power_state state; xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session; + + if (flags != (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) { + xenapiError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), + flags); + return -1; + } + if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) { if (vms->size != 1) { xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, @@ -1176,6 +1207,19 @@ xenapiDomainGetMaxVcpus (virDomainPtr dom) } /* + * xenapiDomainGetMaxVcpus + * + * + * Returns maximum number of Vcpus on success or -1 in case of error + */ +static int +xenapiDomainGetMaxVcpus (virDomainPtr dom) +{ + return xenapiDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_LIVE | + VIR_DOMAIN_VCPU_MAXIMUM)); +} + +/* * xenapiDomainDumpXML * * @@ -1754,8 +1798,8 @@ static virDriver xenapiDriver = { NULL, /* domainRestore */ NULL, /* domainCoreDump */ xenapiDomainSetVcpus, /* domainSetVcpus */ - NULL, /* domainSetVcpusFlags */ - NULL, /* domainGetVcpusFlags */ + xenapiDomainSetVcpusFlags, /* domainSetVcpusFlags */ + xenapiDomainGetVcpusFlags, /* domainGetVcpusFlags */ xenapiDomainPinVcpu, /* domainPinVcpu */ xenapiDomainGetVcpus, /* domainGetVcpus */ xenapiDomainGetMaxVcpus, /* domainGetMaxVcpus */ -- 1.7.2.3

v2: update option names to match enum name change; tweak grammar in text; add maxvcpus command * tools/virsh.c (cmdSetvcpus): Add new flags. Let invalid commands through to driver, to ease testing of hypervisor argument validation. (cmdMaxvcpus, cmdVcpucount): New commands. (commands): Add new commands. * tools/virsh.pod (setvcpus, vcpucount, maxvcpus): Document new behavior. --- tools/virsh.c | 247 ++++++++++++++++++++++++++++++++++++++++++++++++++----- tools/virsh.pod | 38 ++++++++- 2 files changed, 262 insertions(+), 23 deletions(-) diff --git a/tools/virsh.c b/tools/virsh.c index 89c2e1e..496853e 100644 --- a/tools/virsh.c +++ b/tools/virsh.c @@ -2280,10 +2280,216 @@ cmdFreecell(vshControl *ctl, const vshCmd *cmd) } /* + * "maxvcpus" command + */ +static const vshCmdInfo info_maxvcpus[] = { + {"help", N_("connection vcpu maximum")}, + {"desc", N_("Show maximum number of virtual CPUs for guests on this connection.")}, + {NULL, NULL} +}; + +static const vshCmdOptDef opts_maxvcpus[] = { + {"type", VSH_OT_STRING, 0, N_("domain type")}, + {NULL, 0, 0, NULL} +}; + +static int +cmdMaxvcpus(vshControl *ctl, const vshCmd *cmd) +{ + char *type; + int vcpus; + + type = vshCommandOptString(cmd, "type", NULL); + + if (!vshConnectionUsability(ctl, ctl->conn)) + return FALSE; + + vcpus = virConnectGetMaxVcpus(ctl->conn, type); + if (vcpus < 0) + return FALSE; + vshPrint(ctl, "%d\n", vcpus); + + return TRUE; +} + +/* + * "vcpucount" command + */ +static const vshCmdInfo info_vcpucount[] = { + {"help", N_("domain vcpu counts")}, + {"desc", N_("Returns the number of virtual CPUs used by the domain.")}, + {NULL, NULL} +}; + +static const vshCmdOptDef opts_vcpucount[] = { + {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")}, + {"maximum", VSH_OT_BOOL, 0, N_("get maximum cap on vcpus")}, + {"current", VSH_OT_BOOL, 0, N_("get current vcpu usage")}, + {"config", VSH_OT_BOOL, 0, N_("get value to be used on next boot")}, + {"live", VSH_OT_BOOL, 0, N_("get value from running domain")}, + {NULL, 0, 0, NULL} +}; + +static int +cmdVcpucount(vshControl *ctl, const vshCmd *cmd) +{ + virDomainPtr dom; + int ret = TRUE; + int maximum = vshCommandOptBool(cmd, "maximum"); + int current = vshCommandOptBool(cmd, "current"); + int config = vshCommandOptBool(cmd, "config"); + int live = vshCommandOptBool(cmd, "live"); + bool all = maximum + current + config + live == 0; + int count; + + if (maximum && current) { + vshError(ctl, "%s", + _("--maximum and --current cannot both be specified")); + return FALSE; + } + if (config && live) { + vshError(ctl, "%s", + _("--config and --live cannot both be specified")); + return FALSE; + } + /* We want one of each pair of mutually exclusive options; that + * is, use of flags requires exactly two options. */ + if (maximum + current + config + live == 1) { + vshError(ctl, + _("when using --%s, either --%s or --%s must be specified"), + (maximum ? "maximum" : current ? "current" + : config ? "config" : "live"), + maximum + current ? "config" : "maximum", + maximum + current ? "live" : "current"); + return FALSE; + } + + if (!vshConnectionUsability(ctl, ctl->conn)) + return FALSE; + + if (!(dom = vshCommandOptDomain(ctl, cmd, NULL))) + return FALSE; + + /* In all cases, try the new API first; if it fails because we are + * talking to an older client, try a fallback API before giving + * up. */ + if (all || (maximum && config)) { + count = virDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_MAXIMUM | + VIR_DOMAIN_VCPU_CONFIG)); + if (count < 0 && (last_error->code == VIR_ERR_NO_SUPPORT + || last_error->code == VIR_ERR_INVALID_ARG)) { + char *tmp; + char *xml = virDomainGetXMLDesc(dom, VIR_DOMAIN_XML_INACTIVE); + if (xml && (tmp = strstr(xml, "<vcpu"))) { + tmp = strchr(tmp, '>'); + if (!tmp || virStrToLong_i(tmp + 1, &tmp, 10, &count) < 0) + count = -1; + } + VIR_FREE(xml); + } + + if (count < 0) { + virshReportError(ctl); + ret = FALSE; + } else if (all) { + vshPrint(ctl, "%-12s %-12s %3d\n", _("maximum"), _("config"), + count); + } else { + vshPrint(ctl, "%d\n", count); + } + virFreeError(last_error); + last_error = NULL; + } + + if (all || (maximum && live)) { + count = virDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_MAXIMUM | + VIR_DOMAIN_VCPU_LIVE)); + if (count < 0 && (last_error->code == VIR_ERR_NO_SUPPORT + || last_error->code == VIR_ERR_INVALID_ARG)) { + count = virDomainGetMaxVcpus(dom); + } + + if (count < 0) { + virshReportError(ctl); + ret = FALSE; + } else if (all) { + vshPrint(ctl, "%-12s %-12s %3d\n", _("maximum"), _("live"), + count); + } else { + vshPrint(ctl, "%d\n", count); + } + virFreeError(last_error); + last_error = NULL; + } + + if (all || (current && config)) { + count = virDomainGetVcpusFlags(dom, VIR_DOMAIN_VCPU_CONFIG); + if (count < 0 && (last_error->code == VIR_ERR_NO_SUPPORT + || last_error->code == VIR_ERR_INVALID_ARG)) { + char *tmp, *end; + char *xml = virDomainGetXMLDesc(dom, VIR_DOMAIN_XML_INACTIVE); + if (xml && (tmp = strstr(xml, "<vcpu"))) { + end = strchr(tmp, '>'); + if (end) { + *end = '\0'; + tmp = strstr(tmp, "current="); + if (!tmp) + tmp = end + 1; + else { + tmp += strlen("current="); + tmp += *tmp == '\'' || *tmp == '"'; + } + } + if (!tmp || virStrToLong_i(tmp, &tmp, 10, &count) < 0) + count = -1; + } + VIR_FREE(xml); + } + + if (count < 0) { + virshReportError(ctl); + ret = FALSE; + } else if (all) { + vshPrint(ctl, "%-12s %-12s %3d\n", _("current"), _("config"), + count); + } else { + vshPrint(ctl, "%d\n", count); + } + virFreeError(last_error); + last_error = NULL; + } + + if (all || (current && live)) { + count = virDomainGetVcpusFlags(dom, VIR_DOMAIN_VCPU_LIVE); + if (count < 0 && (last_error->code == VIR_ERR_NO_SUPPORT + || last_error->code == VIR_ERR_INVALID_ARG)) { + virDomainInfo info; + if (virDomainGetInfo(dom, &info) == 0) + count = info.nrVirtCpu; + } + + if (count < 0) { + virshReportError(ctl); + ret = FALSE; + } else if (all) { + vshPrint(ctl, "%-12s %-12s %3d\n", _("current"), _("live"), + count); + } else { + vshPrint(ctl, "%d\n", count); + } + virFreeError(last_error); + last_error = NULL; + } + + virDomainFree(dom); + return ret; +} + +/* * "vcpuinfo" command */ static const vshCmdInfo info_vcpuinfo[] = { - {"help", N_("domain vcpu information")}, + {"help", N_("detailed domain vcpu information")}, {"desc", N_("Returns basic information about the domain virtual CPUs.")}, {NULL, NULL} }; @@ -2513,6 +2719,9 @@ static const vshCmdInfo info_setvcpus[] = { static const vshCmdOptDef opts_setvcpus[] = { {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")}, {"count", VSH_OT_DATA, VSH_OFLAG_REQ, N_("number of virtual CPUs")}, + {"maximum", VSH_OT_BOOL, 0, N_("set maximum limit on next boot")}, + {"config", VSH_OT_BOOL, 0, N_("affect next boot")}, + {"live", VSH_OT_BOOL, 0, N_("affect running domain")}, {NULL, 0, 0, NULL} }; @@ -2521,8 +2730,13 @@ cmdSetvcpus(vshControl *ctl, const vshCmd *cmd) { virDomainPtr dom; int count; - int maxcpu; int ret = TRUE; + int maximum = vshCommandOptBool(cmd, "maximum"); + int config = vshCommandOptBool(cmd, "config"); + int live = vshCommandOptBool(cmd, "live"); + int flags = ((maximum ? VIR_DOMAIN_VCPU_MAXIMUM : 0) | + (config ? VIR_DOMAIN_VCPU_CONFIG : 0) | + (live ? VIR_DOMAIN_VCPU_LIVE : 0)); if (!vshConnectionUsability(ctl, ctl->conn)) return FALSE; @@ -2531,26 +2745,15 @@ cmdSetvcpus(vshControl *ctl, const vshCmd *cmd) return FALSE; count = vshCommandOptInt(cmd, "count", &count); - if (count <= 0) { - vshError(ctl, "%s", _("Invalid number of virtual CPUs.")); - virDomainFree(dom); - return FALSE; - } - - maxcpu = virDomainGetMaxVcpus(dom); - if (maxcpu <= 0) { - virDomainFree(dom); - return FALSE; - } - - if (count > maxcpu) { - vshError(ctl, "%s", _("Too many virtual CPUs.")); - virDomainFree(dom); - return FALSE; - } - if (virDomainSetVcpus(dom, count) != 0) { - ret = FALSE; + if (!flags) { + if (virDomainSetVcpus(dom, count) != 0) { + ret = FALSE; + } + } else { + if (virDomainSetVcpusFlags(dom, count, flags) < 0) { + ret = FALSE; + } } virDomainFree(dom); @@ -9553,6 +9756,7 @@ static const vshCmdDef commands[] = { {"freecell", cmdFreecell, opts_freecell, info_freecell}, {"hostname", cmdHostname, NULL, info_hostname}, {"list", cmdList, opts_list, info_list}, + {"maxvcpus", cmdMaxvcpus, opts_maxvcpus, info_maxvcpus}, {"migrate", cmdMigrate, opts_migrate, info_migrate}, {"migrate-setmaxdowntime", cmdMigrateSetMaxDowntime, opts_migrate_setmaxdowntime, info_migrate_setmaxdowntime}, @@ -9659,6 +9863,7 @@ static const vshCmdDef commands[] = { {"vol-name", cmdVolName, opts_vol_name, info_vol_name}, {"vol-key", cmdVolKey, opts_vol_key, info_vol_key}, + {"vcpucount", cmdVcpucount, opts_vcpucount, info_vcpucount}, {"vcpuinfo", cmdVcpuinfo, opts_vcpuinfo, info_vcpuinfo}, {"vcpupin", cmdVcpupin, opts_vcpupin, info_vcpupin}, {"version", cmdVersion, NULL, info_version}, diff --git a/tools/virsh.pod b/tools/virsh.pod index f65f6d4..9634b21 100644 --- a/tools/virsh.pod +++ b/tools/virsh.pod @@ -436,7 +436,14 @@ Remove the managed save file for a domain if it exists. The next time the domain is started it will not restore to its previous state but instead will do a full boot. -=item B<migrate> optional I<--live> I<--suspend> I<domain-id> I<desturi> I<migrateuri> +=item B<maxvcpus> optional I<type> + +Provide the maximum number of virtual CPUs supported for a guest VM on +this connection. If provided, the I<type> parameter must be a valid +type attribute for the <domain> element of XML. + +=item B<migrate> optional I<--live> I<--suspend> I<domain-id> I<desturi> +I<migrateuri> Migrate domain to another host. Add --live for live migration; --suspend leaves the domain paused on the destination host. The I<desturi> is the @@ -506,7 +513,8 @@ Change the maximum memory allocation limit in the guest domain. This should not change the current memory use. The memory limit is specified in kilobytes. -=item B<setvcpus> I<domain-id> I<count> +=item B<setvcpus> I<domain-id> I<count> optional I<--maximum> I<--config> +I<--live> Change the number of virtual CPUs active in the guest domain. Note that I<count> may be limited by host, hypervisor or limit coming from the @@ -515,6 +523,17 @@ original description of domain. For Xen, you can only adjust the virtual CPUs of a running domain if the domain is paravirtualized. +If I<--config> is specified, the change will only affect the next +boot of a domain. If I<--live> is specified, the domain must be +running, and the change takes place immediately. Both flags may be +specified, if supported by the hypervisor. If neither flag is given, +then I<--live> is implied and it is up to the hypervisor whether +I<--config> is also implied. + +If I<--maximum> is specified, then you must use I<--config> and +avoid I<--live>; this flag controls the maximum limit of vcpus that +can be hot-plugged the next time the domain is booted. + =item B<shutdown> I<domain-id> Gracefully shuts down a domain. This coordinates with the domain OS @@ -553,6 +572,21 @@ is not available the processes will provide an exit code of 1. Undefine the configuration for an inactive domain. Since it's not running the domain name or UUID must be used as the I<domain-id>. +=item B<vcpucount> I<domain-id> optional I<--maximum> I<--current> +I<--config> I<--live> + +Print information about the virtual cpu counts of the given +I<domain-id>. If no flags are specified, all possible counts are +listed in a table; otherwise, the output is limited to just the +numeric value requested. + +I<--maximum> requests information on the maximum cap of vcpus that a +domain can add via B<setvcpus>, while I<--current> shows the current +usage; these two flags cannot both be specified. I<--config> +requests information regarding the next time the domain will be +booted, while I<--live> requires a running domain and lists current +values; these two flags cannot both be specified. + =item B<vcpuinfo> I<domain-id> Returns basic information about the domain virtual CPUs, like the number of -- 1.7.2.3

v2: avoid C++ comment style * src/qemu/qemu_conf.c (qemuParseCommandLineSmp): Distinguish between vcpus and maxvcpus, for new enough qemu. * tests/qemuargv2xmltest.c (mymain): Add new test. * tests/qemuxml2argvtest.c (mymain): Likewise. * tests/qemuxml2xmltest.c (mymain): Likewise. * tests/qemuxml2argvdata/qemuxml2argv-smp.args: New file. --- src/qemu/qemu_conf.c | 13 +++++++++---- tests/qemuargv2xmltest.c | 2 ++ tests/qemuxml2argvdata/qemuxml2argv-smp.args | 1 + tests/qemuxml2argvtest.c | 2 ++ tests/qemuxml2xmltest.c | 2 ++ 5 files changed, 16 insertions(+), 4 deletions(-) create mode 100644 tests/qemuxml2argvdata/qemuxml2argv-smp.args diff --git a/src/qemu/qemu_conf.c b/src/qemu/qemu_conf.c index d06025b..e2ac59f 100644 --- a/src/qemu/qemu_conf.c +++ b/src/qemu/qemu_conf.c @@ -3707,6 +3707,8 @@ qemuBuildSmpArgStr(const virDomainDefPtr def, virBufferVSprintf(&buf, "%u", def->vcpus); if ((qemuCmdFlags & QEMUD_CMD_FLAG_SMP_TOPOLOGY)) { + if (def->vcpus != def->maxvcpus) + virBufferVSprintf(&buf, ",maxcpus=%u", def->maxvcpus); /* sockets, cores, and threads are either all zero * or all non-zero, thus checking one of them is enough */ if (def->cpu && def->cpu->sockets) { @@ -3719,12 +3721,12 @@ qemuBuildSmpArgStr(const virDomainDefPtr def, virBufferVSprintf(&buf, ",cores=%u", 1); virBufferVSprintf(&buf, ",threads=%u", 1); } - } - if (def->vcpus != def->maxvcpus) { + } else if (def->vcpus != def->maxvcpus) { virBufferFreeAndReset(&buf); + /* FIXME - consider hot-unplugging cpus after boot for older qemu */ qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", _("setting current vcpu count less than maximum is " - "not supported yet")); + "not supported with this QEMU binary")); return NULL; } @@ -6146,6 +6148,7 @@ qemuParseCommandLineSmp(virDomainDefPtr dom, unsigned int sockets = 0; unsigned int cores = 0; unsigned int threads = 0; + unsigned int maxcpus = 0; int i; int nkws; char **kws; @@ -6173,12 +6176,14 @@ qemuParseCommandLineSmp(virDomainDefPtr dom, cores = n; else if (STREQ(kws[i], "threads")) threads = n; + else if (STREQ(kws[i], "maxcpus")) + maxcpus = n; else goto syntax; } } - dom->maxvcpus = dom->vcpus; + dom->maxvcpus = maxcpus ? maxcpus : dom->vcpus; if (sockets && cores && threads) { virCPUDefPtr cpu; diff --git a/tests/qemuargv2xmltest.c b/tests/qemuargv2xmltest.c index 4f9ec84..d941b0b 100644 --- a/tests/qemuargv2xmltest.c +++ b/tests/qemuargv2xmltest.c @@ -221,6 +221,8 @@ mymain(int argc, char **argv) DO_TEST("hostdev-pci-address"); + DO_TEST("smp"); + DO_TEST_FULL("restore-v1", 0, "stdio"); DO_TEST_FULL("restore-v2", 0, "stdio"); DO_TEST_FULL("restore-v2", 0, "exec:cat"); diff --git a/tests/qemuxml2argvdata/qemuxml2argv-smp.args b/tests/qemuxml2argvdata/qemuxml2argv-smp.args new file mode 100644 index 0000000..3ec8f15 --- /dev/null +++ b/tests/qemuxml2argvdata/qemuxml2argv-smp.args @@ -0,0 +1 @@ +LC_ALL=C PATH=/bin HOME=/home/test USER=test LOGNAME=test /usr/bin/qemu -S -M pc -m 214 -smp 1,maxcpus=2,sockets=2,cores=1,threads=1 -nographic -monitor unix:/tmp/test-monitor,server,nowait -no-acpi -boot c -hda /dev/HostVG/QEMUGuest1 -net none -serial none -parallel none -usb diff --git a/tests/qemuxml2argvtest.c b/tests/qemuxml2argvtest.c index 92d5b18..551d6c4 100644 --- a/tests/qemuxml2argvtest.c +++ b/tests/qemuxml2argvtest.c @@ -385,6 +385,8 @@ mymain(int argc, char **argv) DO_TEST("qemu-ns", 0); + DO_TEST("smp", QEMUD_CMD_FLAG_SMP_TOPOLOGY); + free(driver.stateDir); virCapabilitiesFree(driver.caps); diff --git a/tests/qemuxml2xmltest.c b/tests/qemuxml2xmltest.c index a33d435..cdc4390 100644 --- a/tests/qemuxml2xmltest.c +++ b/tests/qemuxml2xmltest.c @@ -180,6 +180,8 @@ mymain(int argc, char **argv) DO_TEST("encrypted-disk"); DO_TEST("memtune"); + DO_TEST("smp"); + /* These tests generate different XML */ DO_TEST_DIFFERENT("balloon-device-auto"); DO_TEST_DIFFERENT("channel-virtio-auto"); -- 1.7.2.3

This patch series focuses on xendConfigVersion 2 (xm_internal) and 3 (xend_internal), but leaves out changes for xenapi drivers. See this link for more details about vcpu_avail for xm usage. http://lists.xensource.com/archives/html/xen-devel/2009-11/msg01061.html This relies on the fact that def->maxvcpus can be at most 32 with xen. v2: new patch * src/xen/xend_internal.c (xenDaemonParseSxpr) (sexpr_to_xend_domain_info, xenDaemonFormatSxpr): Use vcpu_avail when current vcpus is less than maximum. * src/xen/xm_internal.c (xenXMDomainConfigParse) (xenXMDomainConfigFormat): Likewise. * tests/xml2sexprdata/xml2sexpr-pv-vcpus.sexpr: New file. * tests/sexpr2xmldata/sexpr2xml-pv-vcpus.sexpr: Likewise. * tests/sexpr2xmldata/sexpr2xml-pv-vcpus.xml: Likewise. * tests/xmconfigdata/test-paravirt-vcpu.cfg: Likewise. * tests/xmconfigdata/test-paravirt-vcpu.xml: Likewise. * tests/xml2sexprtest.c (mymain): New test. * tests/sexpr2xmltest.c (mymain): Likewise. * tests/xmconfigtest.c (mymain): Likewise. --- src/xen/xend_internal.c | 19 +++++++++++++-- src/xen/xm_internal.c | 10 ++++++- tests/sexpr2xmldata/sexpr2xml-pv-vcpus.sexpr | 1 + tests/sexpr2xmldata/sexpr2xml-pv-vcpus.xml | 27 +++++++++++++++++++++ tests/sexpr2xmltest.c | 1 + tests/xmconfigdata/test-paravirt-vcpu.cfg | 17 +++++++++++++ tests/xmconfigdata/test-paravirt-vcpu.xml | 32 ++++++++++++++++++++++++++ tests/xmconfigtest.c | 1 + tests/xml2sexprdata/xml2sexpr-pv-vcpus.sexpr | 1 + tests/xml2sexprtest.c | 1 + 10 files changed, 105 insertions(+), 5 deletions(-) create mode 100644 tests/sexpr2xmldata/sexpr2xml-pv-vcpus.sexpr create mode 100644 tests/sexpr2xmldata/sexpr2xml-pv-vcpus.xml create mode 100644 tests/xmconfigdata/test-paravirt-vcpu.cfg create mode 100644 tests/xmconfigdata/test-paravirt-vcpu.xml create mode 100644 tests/xml2sexprdata/xml2sexpr-pv-vcpus.sexpr diff --git a/src/xen/xend_internal.c b/src/xen/xend_internal.c index 456b477..dfc6415 100644 --- a/src/xen/xend_internal.c +++ b/src/xen/xend_internal.c @@ -44,6 +44,7 @@ #include "xen_hypervisor.h" #include "xs_internal.h" /* To extract VNC port & Serial console TTY */ #include "memory.h" +#include "count-one-bits.h" /* required for cpumap_t */ #include <xen/dom0_ops.h> @@ -2191,7 +2192,9 @@ xenDaemonParseSxpr(virConnectPtr conn, } def->maxvcpus = sexpr_int(root, "domain/vcpus"); - def->vcpus = def->maxvcpus; + def->vcpus = count_one_bits(sexpr_int(root, "domain/vcpu_avail")); + if (!def->vcpus || def->maxvcpus < def->vcpus) + def->vcpus = def->maxvcpus; tmp = sexpr_node(root, "domain/on_poweroff"); if (tmp != NULL) { @@ -2433,7 +2436,7 @@ sexpr_to_xend_domain_info(virDomainPtr domain, const struct sexpr *root, virDomainInfoPtr info) { const char *flags; - + int vcpus; if ((root == NULL) || (info == NULL)) return (-1); @@ -2464,7 +2467,11 @@ sexpr_to_xend_domain_info(virDomainPtr domain, const struct sexpr *root, info->state = VIR_DOMAIN_NOSTATE; } info->cpuTime = sexpr_float(root, "domain/cpu_time") * 1000000000; - info->nrVirtCpu = sexpr_int(root, "domain/vcpus"); + vcpus = sexpr_int(root, "domain/vcpus"); + info->nrVirtCpu = count_one_bits(sexpr_int(root, "domain/vcpu_avail")); + if (!info->nrVirtCpu || vcpus < info->nrVirtCpu) + info->nrVirtCpu = vcpus; + return (0); } @@ -5668,6 +5675,9 @@ xenDaemonFormatSxpr(virConnectPtr conn, virBufferVSprintf(&buf, "(memory %lu)(maxmem %lu)", def->mem.cur_balloon/1024, def->mem.max_balloon/1024); virBufferVSprintf(&buf, "(vcpus %u)", def->maxvcpus); + /* Computing the vcpu_avail bitmask works because MAX_VIRT_CPUS is 32. */ + if (def->vcpus < def->maxvcpus) + virBufferVSprintf(&buf, "(vcpu_avail %u)", (1U << def->vcpus) - 1); if (def->cpumask) { char *ranges = virDomainCpuSetFormat(def->cpumask, def->cpumasklen); @@ -5763,6 +5773,9 @@ xenDaemonFormatSxpr(virConnectPtr conn, virBufferVSprintf(&buf, "(kernel '%s')", def->os.loader); virBufferVSprintf(&buf, "(vcpus %u)", def->maxvcpus); + if (def->vcpus < def->maxvcpus) + virBufferVSprintf(&buf, "(vcpu_avail %u)", + (1U << def->vcpus) - 1); for (i = 0 ; i < def->os.nBootDevs ; i++) { switch (def->os.bootDevs[i]) { diff --git a/src/xen/xm_internal.c b/src/xen/xm_internal.c index bf20a64..f7121ab 100644 --- a/src/xen/xm_internal.c +++ b/src/xen/xm_internal.c @@ -46,6 +46,7 @@ #include "util.h" #include "memory.h" #include "logging.h" +#include "count-one-bits.h" #define VIR_FROM_THIS VIR_FROM_XENXM @@ -772,10 +773,12 @@ xenXMDomainConfigParse(virConnectPtr conn, virConfPtr conf) { def->mem.max_balloon *= 1024; if (xenXMConfigGetULong(conf, "vcpus", &count, 1) < 0 || - (unsigned short) count != count) + MAX_VIRT_CPUS < count) goto cleanup; def->maxvcpus = count; - def->vcpus = def->maxvcpus; + if (xenXMConfigGetULong(conf, "vcpu_avail", &count, -1) < 0) + goto cleanup; + def->vcpus = MIN(count_one_bits(count), def->maxvcpus); if (xenXMConfigGetString(conf, "cpus", &str, NULL) < 0) goto cleanup; @@ -2246,6 +2249,9 @@ virConfPtr xenXMDomainConfigFormat(virConnectPtr conn, if (xenXMConfigSetInt(conf, "vcpus", def->maxvcpus) < 0) goto no_memory; + if (def->vcpus < def->maxvcpus && + xenXMConfigSetInt(conf, "vcpu_avail", (1U << def->vcpus) - 1) < 0) + goto no_memory; if ((def->cpumask != NULL) && ((cpus = virDomainCpuSetFormat(def->cpumask, diff --git a/tests/sexpr2xmldata/sexpr2xml-pv-vcpus.sexpr b/tests/sexpr2xmldata/sexpr2xml-pv-vcpus.sexpr new file mode 100644 index 0000000..2be6822 --- /dev/null +++ b/tests/sexpr2xmldata/sexpr2xml-pv-vcpus.sexpr @@ -0,0 +1 @@ +(domain (domid 6)(name 'pvtest')(memory 420)(maxmem 420)(vcpus 4)(vcpu_avail 3)(uuid '596a5d2171f48fb2e068e2386a5c413e')(on_poweroff 'destroy')(on_reboot 'destroy')(on_crash 'destroy')(image (linux (kernel '/var/lib/xen/vmlinuz.2Dn2YT')(ramdisk '/var/lib/xen/initrd.img.0u-Vhq')(args ' method=http://download.fedora.devel.redhat.com/pub/fedora/linux/core/test... ')))(device (vbd (dev 'xvda')(uname 'file:/root/some.img')(mode 'w')))) diff --git a/tests/sexpr2xmldata/sexpr2xml-pv-vcpus.xml b/tests/sexpr2xmldata/sexpr2xml-pv-vcpus.xml new file mode 100644 index 0000000..0d6bf11 --- /dev/null +++ b/tests/sexpr2xmldata/sexpr2xml-pv-vcpus.xml @@ -0,0 +1,27 @@ +<domain type='xen' id='6'> + <name>pvtest</name> + <uuid>596a5d21-71f4-8fb2-e068-e2386a5c413e</uuid> + <memory>430080</memory> + <currentMemory>430080</currentMemory> + <vcpu current='2'>4</vcpu> + <os> + <type>linux</type> + <kernel>/var/lib/xen/vmlinuz.2Dn2YT</kernel> + <initrd>/var/lib/xen/initrd.img.0u-Vhq</initrd> + <cmdline> method=http://download.fedora.devel.redhat.com/pub/fedora/linux/core/test... </cmdline> + </os> + <clock offset='utc'/> + <on_poweroff>destroy</on_poweroff> + <on_reboot>destroy</on_reboot> + <on_crash>destroy</on_crash> + <devices> + <disk type='file' device='disk'> + <driver name='file'/> + <source file='/root/some.img'/> + <target dev='xvda' bus='xen'/> + </disk> + <console type='pty'> + <target type='xen' port='0'/> + </console> + </devices> +</domain> diff --git a/tests/sexpr2xmltest.c b/tests/sexpr2xmltest.c index d62b44f..f100dd8 100644 --- a/tests/sexpr2xmltest.c +++ b/tests/sexpr2xmltest.c @@ -132,6 +132,7 @@ mymain(int argc, char **argv) DO_TEST("pv-vfb-type-crash", "pv-vfb-type-crash", 3); DO_TEST("fv-autoport", "fv-autoport", 3); DO_TEST("pv-bootloader", "pv-bootloader", 1); + DO_TEST("pv-vcpus", "pv-vcpus", 1); DO_TEST("disk-file", "disk-file", 2); DO_TEST("disk-block", "disk-block", 2); diff --git a/tests/xmconfigdata/test-paravirt-vcpu.cfg b/tests/xmconfigdata/test-paravirt-vcpu.cfg new file mode 100644 index 0000000..24c78f4 --- /dev/null +++ b/tests/xmconfigdata/test-paravirt-vcpu.cfg @@ -0,0 +1,17 @@ +name = "XenGuest1" +uuid = "c7a5fdb0-cdaf-9455-926a-d65c16db1809" +maxmem = 579 +memory = 394 +vcpus = 4 +vcpu_avail = 3 +bootloader = "/usr/bin/pygrub" +on_poweroff = "destroy" +on_reboot = "restart" +on_crash = "restart" +sdl = 0 +vnc = 1 +vncunused = 1 +vnclisten = "127.0.0.1" +vncpasswd = "123poi" +disk = [ "phy:/dev/HostVG/XenGuest1,xvda,w" ] +vif = [ "mac=00:16:3e:66:94:9c,bridge=br0,script=vif-bridge" ] diff --git a/tests/xmconfigdata/test-paravirt-vcpu.xml b/tests/xmconfigdata/test-paravirt-vcpu.xml new file mode 100644 index 0000000..0be9456 --- /dev/null +++ b/tests/xmconfigdata/test-paravirt-vcpu.xml @@ -0,0 +1,32 @@ +<domain type='xen'> + <name>XenGuest1</name> + <uuid>c7a5fdb0-cdaf-9455-926a-d65c16db1809</uuid> + <memory>592896</memory> + <currentMemory>403456</currentMemory> + <vcpu current='2'>4</vcpu> + <bootloader>/usr/bin/pygrub</bootloader> + <os> + <type arch='i686' machine='xenpv'>linux</type> + </os> + <clock offset='utc'/> + <on_poweroff>destroy</on_poweroff> + <on_reboot>restart</on_reboot> + <on_crash>restart</on_crash> + <devices> + <disk type='block' device='disk'> + <driver name='phy'/> + <source dev='/dev/HostVG/XenGuest1'/> + <target dev='xvda' bus='xen'/> + </disk> + <interface type='bridge'> + <mac address='00:16:3e:66:94:9c'/> + <source bridge='br0'/> + <script path='vif-bridge'/> + </interface> + <console type='pty'> + <target type='xen' port='0'/> + </console> + <input type='mouse' bus='xen'/> + <graphics type='vnc' port='-1' autoport='yes' listen='127.0.0.1' passwd='123poi'/> + </devices> +</domain> diff --git a/tests/xmconfigtest.c b/tests/xmconfigtest.c index 221b322..ea00747 100644 --- a/tests/xmconfigtest.c +++ b/tests/xmconfigtest.c @@ -210,6 +210,7 @@ mymain(int argc, char **argv) DO_TEST("paravirt-new-pvfb-vncdisplay", 3); DO_TEST("paravirt-net-e1000", 3); DO_TEST("paravirt-net-vifname", 3); + DO_TEST("paravirt-vcpu", 2); DO_TEST("fullvirt-old-cdrom", 1); DO_TEST("fullvirt-new-cdrom", 2); DO_TEST("fullvirt-utc", 2); diff --git a/tests/xml2sexprdata/xml2sexpr-pv-vcpus.sexpr b/tests/xml2sexprdata/xml2sexpr-pv-vcpus.sexpr new file mode 100644 index 0000000..e886545 --- /dev/null +++ b/tests/xml2sexprdata/xml2sexpr-pv-vcpus.sexpr @@ -0,0 +1 @@ +(vm (name 'pvtest')(memory 420)(maxmem 420)(vcpus 4)(vcpu_avail 3)(uuid '596a5d21-71f4-8fb2-e068-e2386a5c413e')(on_poweroff 'destroy')(on_reboot 'destroy')(on_crash 'destroy')(image (linux (kernel '/var/lib/xen/vmlinuz.2Dn2YT')(ramdisk '/var/lib/xen/initrd.img.0u-Vhq')(args ' method=http://download.fedora.devel.redhat.com/pub/fedora/linux/core/test... ')))(device (vbd (dev 'xvda')(uname 'file:/root/some.img')(mode 'w')))) \ No newline at end of file diff --git a/tests/xml2sexprtest.c b/tests/xml2sexprtest.c index 77cf760..9cf8d39 100644 --- a/tests/xml2sexprtest.c +++ b/tests/xml2sexprtest.c @@ -118,6 +118,7 @@ mymain(int argc, char **argv) DO_TEST("pv-vfb-new", "pv-vfb-new", "pvtest", 3); DO_TEST("pv-vfb-new-auto", "pv-vfb-new-auto", "pvtest", 3); DO_TEST("pv-bootloader", "pv-bootloader", "pvtest", 1); + DO_TEST("pv-vcpus", "pv-vcpus", "pvtest", 1); DO_TEST("disk-file", "disk-file", "pvtest", 2); DO_TEST("disk-block", "disk-block", "pvtest", 2); -- 1.7.2.3

* src/xen/xen_driver.h (xenUnifiedDriver): Remove now-unused domainGetMAxVcpus. * src/xen/proxy_internal.c (xenProxyDriver): Likewise. * src/xen/xen_hypervisor.c (xenHypervisorDriver): Likewise. * src/xen/xen_inotify.c (xenInotifyDriver): Likewise. * src/xen/xend_internal.c (xenDaemonDriver): Likewise. * src/xen/xm_internal.c (xenXMDriver): Likewise. * src/xen/xs_internal.c (xenStoreDriver): Likewise. --- src/xen/proxy_internal.c | 1 - src/xen/xen_driver.h | 3 +-- src/xen/xen_hypervisor.c | 1 - src/xen/xen_inotify.c | 1 - src/xen/xend_internal.c | 1 - src/xen/xm_internal.c | 1 - src/xen/xs_internal.c | 1 - 7 files changed, 1 insertions(+), 8 deletions(-) diff --git a/src/xen/proxy_internal.c b/src/xen/proxy_internal.c index 335dfc4..3e122f4 100644 --- a/src/xen/proxy_internal.c +++ b/src/xen/proxy_internal.c @@ -70,7 +70,6 @@ struct xenUnifiedDriver xenProxyDriver = { NULL, /* domainSetVcpus */ NULL, /* domainPinVcpu */ NULL, /* domainGetVcpus */ - NULL, /* domainGetMaxVcpus */ NULL, /* listDefinedDomains */ NULL, /* numOfDefinedDomains */ NULL, /* domainCreate */ diff --git a/src/xen/xen_driver.h b/src/xen/xen_driver.h index 3e7c1d0..bb68f6a 100644 --- a/src/xen/xen_driver.h +++ b/src/xen/xen_driver.h @@ -1,7 +1,7 @@ /* * xen_unified.c: Unified Xen driver. * - * Copyright (C) 2007 Red Hat, Inc. + * Copyright (C) 2007, 2010 Red Hat, Inc. * * See COPYING.LIB for the License of this software * @@ -87,7 +87,6 @@ struct xenUnifiedDriver { virDrvDomainSetVcpus domainSetVcpus; virDrvDomainPinVcpu domainPinVcpu; virDrvDomainGetVcpus domainGetVcpus; - virDrvDomainGetMaxVcpus domainGetMaxVcpus; virDrvListDefinedDomains listDefinedDomains; virDrvNumOfDefinedDomains numOfDefinedDomains; virDrvDomainCreate domainCreate; diff --git a/src/xen/xen_hypervisor.c b/src/xen/xen_hypervisor.c index 6246513..32f3683 100644 --- a/src/xen/xen_hypervisor.c +++ b/src/xen/xen_hypervisor.c @@ -787,7 +787,6 @@ struct xenUnifiedDriver xenHypervisorDriver = { xenHypervisorSetVcpus, /* domainSetVcpus */ xenHypervisorPinVcpu, /* domainPinVcpu */ xenHypervisorGetVcpus, /* domainGetVcpus */ - xenHypervisorGetVcpuMax, /* domainGetMaxVcpus */ NULL, /* listDefinedDomains */ NULL, /* numOfDefinedDomains */ NULL, /* domainCreate */ diff --git a/src/xen/xen_inotify.c b/src/xen/xen_inotify.c index d24b20f..9b95d67 100644 --- a/src/xen/xen_inotify.c +++ b/src/xen/xen_inotify.c @@ -74,7 +74,6 @@ struct xenUnifiedDriver xenInotifyDriver = { NULL, /* domainSetVcpus */ NULL, /* domainPinVcpu */ NULL, /* domainGetVcpus */ - NULL, /* domainGetMaxVcpus */ NULL, /* listDefinedDomains */ NULL, /* numOfDefinedDomains */ NULL, /* domainCreate */ diff --git a/src/xen/xend_internal.c b/src/xen/xend_internal.c index 3642296..e887e9d 100644 --- a/src/xen/xend_internal.c +++ b/src/xen/xend_internal.c @@ -5140,7 +5140,6 @@ struct xenUnifiedDriver xenDaemonDriver = { xenDaemonDomainSetVcpus, /* domainSetVcpus */ xenDaemonDomainPinVcpu, /* domainPinVcpu */ xenDaemonDomainGetVcpus, /* domainGetVcpus */ - NULL, /* domainGetMaxVcpus */ xenDaemonListDefinedDomains, /* listDefinedDomains */ xenDaemonNumOfDefinedDomains,/* numOfDefinedDomains */ xenDaemonDomainCreate, /* domainCreate */ diff --git a/src/xen/xm_internal.c b/src/xen/xm_internal.c index 4ea4245..9194c0d 100644 --- a/src/xen/xm_internal.c +++ b/src/xen/xm_internal.c @@ -106,7 +106,6 @@ struct xenUnifiedDriver xenXMDriver = { xenXMDomainSetVcpus, /* domainSetVcpus */ xenXMDomainPinVcpu, /* domainPinVcpu */ NULL, /* domainGetVcpus */ - NULL, /* domainGetMaxVcpus */ xenXMListDefinedDomains, /* listDefinedDomains */ xenXMNumOfDefinedDomains, /* numOfDefinedDomains */ xenXMDomainCreate, /* domainCreate */ diff --git a/src/xen/xs_internal.c b/src/xen/xs_internal.c index 9296f25..434904c 100644 --- a/src/xen/xs_internal.c +++ b/src/xen/xs_internal.c @@ -70,7 +70,6 @@ struct xenUnifiedDriver xenStoreDriver = { NULL, /* domainSetVcpus */ NULL, /* domainPinVcpu */ NULL, /* domainGetVcpus */ - NULL, /* domainGetMaxVcpus */ NULL, /* listDefinedDomains */ NULL, /* numOfDefinedDomains */ NULL, /* domainCreate */ -- 1.7.2.3

Tested with RHEL 5.6 (xendConfigVersion 2, where xend_internal controls live domains and xm_internal controls inactive domains). Hopefully this works with xendConfigVersion 3 (where xend_internal controls everything). v2: new patch * src/xen/xen_driver.c (xenUnifiedDomainSetVcpusFlags): Support more flags. (xenUnifiedGetMaxVcpus): Export. * src/xen/xm_internal.h (xenXMDomainSetVcpusFlags): New prototype. * src/xen/xend_internal.h (xenDaemonDomainSetVcpusFlags): Likewise. * src/xen/xen_driver.h (xenUnifiedGetMaxVcpus): Likewise. * src/xen/xm_internal.c (xenXMDomainSetVcpusFlags): New function. * src/xen/xend_internal.c (xenDaemonDomainSetVcpusFlags): Likewise. --- With this patch in place, I should be done with my vcpu API addition. src/xen/xen_driver.c | 60 ++++++++++++++++++++++++--------- src/xen/xen_driver.h | 1 + src/xen/xend_internal.c | 76 +++++++++++++++++++++++++++++++++++++++++++ src/xen/xend_internal.h | 3 ++ src/xen/xm_internal.c | 83 +++++++++++++++++++++++++++++++++++++++++++++++ src/xen/xm_internal.h | 2 + 6 files changed, 208 insertions(+), 17 deletions(-) diff --git a/src/xen/xen_driver.c b/src/xen/xen_driver.c index fe2ff86..66e8518 100644 --- a/src/xen/xen_driver.c +++ b/src/xen/xen_driver.c @@ -508,7 +508,7 @@ xenUnifiedIsSecure(virConnectPtr conn) return ret; } -static int +int xenUnifiedGetMaxVcpus (virConnectPtr conn, const char *type) { GET_PRIVATE(conn); @@ -1073,36 +1073,62 @@ xenUnifiedDomainSetVcpusFlags (virDomainPtr dom, unsigned int nvcpus, unsigned int flags) { GET_PRIVATE(dom->conn); - int i; + int ret; + + virCheckFlags(VIR_DOMAIN_VCPU_LIVE | + VIR_DOMAIN_VCPU_CONFIG | + VIR_DOMAIN_VCPU_MAXIMUM, -1); - if (flags != VIR_DOMAIN_VCPU_LIVE) { - xenUnifiedError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), - flags); + /* At least one of LIVE or CONFIG must be set. MAXIMUM cannot be + * mixed with LIVE. */ + if ((flags & (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_CONFIG)) == 0 || + (flags & (VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_VCPU_LIVE)) == + (VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_VCPU_LIVE)) { + xenUnifiedError(VIR_ERR_INVALID_ARG, + _("invalid flag combination: (0x%x)"), flags); + return -1; + } + if (!nvcpus || (unsigned short) nvcpus != nvcpus) { + xenUnifiedError(VIR_ERR_INVALID_ARG, + _("argument out of range: %d"), nvcpus); return -1; } /* Try non-hypervisor methods first, then hypervisor direct method * as a last resort. */ - for (i = 0; i < XEN_UNIFIED_NR_DRIVERS; ++i) - if (i != XEN_UNIFIED_HYPERVISOR_OFFSET && - priv->opened[i] && - drivers[i]->domainSetVcpus && - drivers[i]->domainSetVcpus (dom, nvcpus) == 0) - return 0; - - if (priv->opened[XEN_UNIFIED_HYPERVISOR_OFFSET] && - drivers[XEN_UNIFIED_HYPERVISOR_OFFSET]->domainSetVcpus && - drivers[XEN_UNIFIED_HYPERVISOR_OFFSET]->domainSetVcpus (dom, nvcpus) == 0) - return 0; + if (priv->opened[XEN_UNIFIED_XEND_OFFSET]) { + ret = xenDaemonDomainSetVcpusFlags(dom, nvcpus, flags); + if (ret != -2) + return ret; + } + if (priv->opened[XEN_UNIFIED_XM_OFFSET]) { + ret = xenXMDomainSetVcpusFlags(dom, nvcpus, flags); + if (ret != -2) + return ret; + } + if (flags == VIR_DOMAIN_VCPU_LIVE) + return xenHypervisorSetVcpus(dom, nvcpus); + xenUnifiedError(VIR_ERR_NO_SUPPORT, __FUNCTION__); return -1; } static int xenUnifiedDomainSetVcpus (virDomainPtr dom, unsigned int nvcpus) { - return xenUnifiedDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_VCPU_LIVE); + unsigned int flags = VIR_DOMAIN_VCPU_LIVE; + xenUnifiedPrivatePtr priv; + + /* Per the documented API, it is hypervisor-dependent whether this + * affects just _LIVE or _LIVE|_CONFIG; in xen's case, that + * depends on xendConfigVersion. */ + if (dom) { + priv = dom->conn->privateData; + if (priv->xendConfigVersion >= 3) + flags |= VIR_DOMAIN_VCPU_CONFIG; + } + return xenUnifiedDomainSetVcpusFlags(dom, nvcpus, flags); } static int diff --git a/src/xen/xen_driver.h b/src/xen/xen_driver.h index bb68f6a..e67faba 100644 --- a/src/xen/xen_driver.h +++ b/src/xen/xen_driver.h @@ -219,6 +219,7 @@ int xenUnifiedRemoveDomainInfo(xenUnifiedDomainInfoListPtr info, void xenUnifiedDomainEventDispatch (xenUnifiedPrivatePtr priv, virDomainEventPtr event); unsigned long xenUnifiedVersion(void); +int xenUnifiedGetMaxVcpus(virConnectPtr conn, const char *type); # ifndef PROXY void xenUnifiedLock(xenUnifiedPrivatePtr priv); diff --git a/src/xen/xend_internal.c b/src/xen/xend_internal.c index e887e9d..ed90459 100644 --- a/src/xen/xend_internal.c +++ b/src/xen/xend_internal.c @@ -3535,6 +3535,82 @@ xenDaemonLookupByID(virConnectPtr conn, int id) { } /** + * xenDaemonDomainSetVcpusFlags: + * @domain: pointer to domain object + * @nvcpus: the new number of virtual CPUs for this domain + * @flags: bitwise-ORd from virDomainVcpuFlags + * + * Change virtual CPUs allocation of domain according to flags. + * + * Returns 0 on success, -1 if an error message was issued, and -2 if + * the unified driver should keep trying. + */ +int +xenDaemonDomainSetVcpusFlags(virDomainPtr domain, unsigned int vcpus, + unsigned int flags) +{ + char buf[VIR_UUID_BUFLEN]; + xenUnifiedPrivatePtr priv; + int max; + + if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL) + || (vcpus < 1)) { + virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__); + return (-1); + } + + priv = (xenUnifiedPrivatePtr) domain->conn->privateData; + + if ((domain->id < 0 && priv->xendConfigVersion < 3) || + (flags & VIR_DOMAIN_VCPU_MAXIMUM)) + return -2; + + /* With xendConfigVersion 2, only _LIVE is supported. With + * xendConfigVersion 3, only _LIVE|_CONFIG is supported for + * running domains, or _CONFIG for inactive domains. */ + if (priv->xendConfigVersion < 3) { + if (flags & VIR_DOMAIN_VCPU_CONFIG) { + virXendError(VIR_ERR_OPERATION_INVALID, "%s", + _("Xend version does not support modifying " + "persistent config")); + return -1; + } + } else if (domain->id < 0) { + if (flags & VIR_DOMAIN_VCPU_LIVE) { + virXendError(VIR_ERR_OPERATION_INVALID, "%s", + _("domain not running")); + return -1; + } + } else { + if ((flags & (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_CONFIG)) != + (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_CONFIG)) { + virXendError(VIR_ERR_OPERATION_INVALID, "%s", + _("Xend only supports modifying both live and " + "persistent config")); + } + } + + /* Unfortunately, xend_op does not validate whether this exceeds + * the maximum. */ + flags |= VIR_DOMAIN_VCPU_MAXIMUM; + if ((max = xenDaemonDomainGetVcpusFlags(domain, flags)) < 0) { + virXendError(VIR_ERR_OPERATION_INVALID, "%s", + _("could not determin max vcpus for the domain")); + return -1; + } + if (vcpus > max) { + virXendError(VIR_ERR_INVALID_ARG, + _("requested vcpus is greater than max allowable" + " vcpus for the domain: %d > %d"), vcpus, max); + return -1; + } + + snprintf(buf, sizeof(buf), "%d", vcpus); + return xend_op(domain->conn, domain->name, "op", "set_vcpus", "vcpus", + buf, NULL); +} + +/** * xenDaemonDomainSetVcpus: * @domain: pointer to domain object * @nvcpus: the new number of virtual CPUs for this domain diff --git a/src/xen/xend_internal.h b/src/xen/xend_internal.h index 923cebd..53f5d2c 100644 --- a/src/xen/xend_internal.h +++ b/src/xen/xend_internal.h @@ -151,6 +151,9 @@ int xenDaemonDomainUndefine(virDomainPtr domain); int xenDaemonDomainSetVcpus (virDomainPtr domain, unsigned int vcpus); +int xenDaemonDomainSetVcpusFlags (virDomainPtr domain, + unsigned int vcpus, + unsigned int flags); int xenDaemonDomainPinVcpu (virDomainPtr domain, unsigned int vcpu, unsigned char *cpumap, diff --git a/src/xen/xm_internal.c b/src/xen/xm_internal.c index 9194c0d..663802b 100644 --- a/src/xen/xm_internal.c +++ b/src/xen/xm_internal.c @@ -1669,6 +1669,89 @@ cleanup: return ret; } +/* + * xenXMDomainSetVcpusFlags: + * @domain: pointer to domain object + * @nvcpus: number of vcpus + * @flags: bitwise-ORd from virDomainVcpuFlags + * + * Change virtual CPUs allocation of domain according to flags. + * + * Returns 0 on success, -1 if an error message was issued, and -2 if + * the unified driver should keep trying. + */ +int +xenXMDomainSetVcpusFlags(virDomainPtr domain, unsigned int vcpus, + unsigned int flags) +{ + xenUnifiedPrivatePtr priv; + const char *filename; + xenXMConfCachePtr entry; + int ret = -1; + int max; + + if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) { + xenXMError(VIR_ERR_INVALID_ARG, __FUNCTION__); + return -1; + } + if (domain->conn->flags & VIR_CONNECT_RO) { + xenXMError(VIR_ERR_OPERATION_DENIED, __FUNCTION__); + return -1; + } + if (domain->id != -1) + return -2; + if (flags & VIR_DOMAIN_VCPU_LIVE) { + xenXMError(VIR_ERR_OPERATION_INVALID, "%s", + _("domain is not running")); + return -1; + } + + priv = domain->conn->privateData; + xenUnifiedLock(priv); + + if (!(filename = virHashLookup(priv->nameConfigMap, domain->name))) + goto cleanup; + + if (!(entry = virHashLookup(priv->configCache, filename))) + goto cleanup; + + /* Hypervisor maximum. */ + if ((max = xenUnifiedGetMaxVcpus(domain->conn, NULL)) < 0) { + xenXMError(VIR_ERR_INTERNAL_ERROR, "%s", + _("could not determin max vcpus for the domain")); + goto cleanup; + } + /* Can't specify a current larger than stored maximum; but + * reducing maximum can silently reduce current. */ + if (!(flags & VIR_DOMAIN_VCPU_MAXIMUM)) + max = entry->def->maxvcpus; + if (vcpus > max) { + xenXMError(VIR_ERR_INVALID_ARG, + _("requested vcpus is greater than max allowable" + " vcpus for the domain: %d > %d"), vcpus, max); + goto cleanup; + } + + if (flags & VIR_DOMAIN_VCPU_MAXIMUM) { + entry->def->maxvcpus = vcpus; + if (entry->def->vcpus > vcpus) + entry->def->vcpus = vcpus; + } else { + entry->def->vcpus = vcpus; + } + + /* If this fails, should we try to undo our changes to the + * in-memory representation of the config file. I say not! + */ + if (xenXMConfigSaveFile(domain->conn, entry->filename, entry->def) < 0) + goto cleanup; + ret = 0; + +cleanup: + xenUnifiedUnlock(priv); + return ret; +} + /** * xenXMDomainGetVcpusFlags: * @domain: pointer to domain object diff --git a/src/xen/xm_internal.h b/src/xen/xm_internal.h index 3295fbd..a46e1a2 100644 --- a/src/xen/xm_internal.h +++ b/src/xen/xm_internal.h @@ -45,6 +45,8 @@ int xenXMDomainSetMemory(virDomainPtr domain, unsigned long memory); int xenXMDomainSetMaxMemory(virDomainPtr domain, unsigned long memory); unsigned long xenXMDomainGetMaxMemory(virDomainPtr domain); int xenXMDomainSetVcpus(virDomainPtr domain, unsigned int vcpus); +int xenXMDomainSetVcpusFlags(virDomainPtr domain, unsigned int vcpus, + unsigned int flags); int xenXMDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags); int xenXMDomainPinVcpu(virDomainPtr domain, unsigned int vcpu, unsigned char *cpumap, int maplen); -- 1.7.2.3