--- Notes: v2: - already ACKed src/qemu/qemu_capabilities.c | 2 ++ src/qemu/qemu_capabilities.h | 1 + tests/qemucapabilitiesdata/caps_2.7.0.x86_64.xml | 1 + 3 files changed, 4 insertions(+) diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c index 8efb8fb..88d2c6e 100644 --- a/src/qemu/qemu_capabilities.c +++ b/src/qemu/qemu_capabilities.c @@ -341,6 +341,7 @@ VIR_ENUM_IMPL(virQEMUCaps, QEMU_CAPS_LAST, "intel-iommu", "smm", "virtio-pci-disable-legacy", + "query-hotpluggable-cpus", ); @@ -1462,6 +1463,7 @@ struct virQEMUCapsStringFlags virQEMUCapsCommands[] = { { "change-backing-file", QEMU_CAPS_CHANGE_BACKING_FILE }, { "rtc-reset-reinjection", QEMU_CAPS_RTC_RESET_REINJECTION }, { "migrate-incoming", QEMU_CAPS_INCOMING_DEFER }, + { "query-hotpluggable-cpus", QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS }, }; struct virQEMUCapsStringFlags virQEMUCapsMigration[] = { diff --git a/src/qemu/qemu_capabilities.h b/src/qemu/qemu_capabilities.h index 776a0f3..365394d 100644 --- a/src/qemu/qemu_capabilities.h +++ b/src/qemu/qemu_capabilities.h @@ -374,6 +374,7 @@ typedef enum { QEMU_CAPS_DEVICE_INTEL_IOMMU, /* -device intel-iommu */ QEMU_CAPS_MACHINE_SMM_OPT, /* -machine xxx,smm=on/off/auto */ QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY, /* virtio-*pci.disable-legacy */ + QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS, /* qmp command query-hotpluggable-cpus */ QEMU_CAPS_LAST /* this must always be the last item */ } virQEMUCapsFlags; diff --git a/tests/qemucapabilitiesdata/caps_2.7.0.x86_64.xml b/tests/qemucapabilitiesdata/caps_2.7.0.x86_64.xml index ccb190b..daae569 100644 --- a/tests/qemucapabilitiesdata/caps_2.7.0.x86_64.xml +++ b/tests/qemucapabilitiesdata/caps_2.7.0.x86_64.xml @@ -193,6 +193,7 @@ <flag name='intel-iommu'/> <flag name='smm'/> <flag name='virtio-pci-disable-legacy'/> + <flag name='query-hotpluggable-cpus'/> <version>2006091</version> <kvmVersion>0</kvmVersion> <package> (v2.7.0-rc1-52-g42e0d60)</package> -- 2.8.2

QEMU reports whether 'query-hotpluggable-cpus' is supported for a given machine type. Extract and cache the information using the capability cache. When copying the capabilities for a new start of qemu, mask out the presence of QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS if the machine type doesn't support hotpluggable cpus. --- Notes: v2: - improved commit message - already ACKed src/qemu/qemu_capabilities.c | 29 ++++++++++++- src/qemu/qemu_capabilities.h | 2 + src/qemu/qemu_monitor.h | 1 + src/qemu/qemu_monitor_json.c | 3 ++ tests/qemucapabilitiesdata/caps_2.7.0.x86_64.xml | 54 ++++++++++++------------ 5 files changed, 61 insertions(+), 28 deletions(-) diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c index 88d2c6e..2ca7803 100644 --- a/src/qemu/qemu_capabilities.c +++ b/src/qemu/qemu_capabilities.c @@ -349,6 +349,7 @@ struct virQEMUCapsMachineType { char *name; char *alias; unsigned int maxCpus; + bool hotplugCpus; }; /* * Update the XML parser/formatter when adding more @@ -550,6 +551,7 @@ virQEMUCapsParseMachineTypesStr(const char *output, } /* When parsing from command line we don't have information about maxCpus */ qemuCaps->machineTypes[qemuCaps->nmachineTypes-1].maxCpus = 0; + qemuCaps->machineTypes[qemuCaps->nmachineTypes-1].hotplugCpus = false; } while ((p = next)); @@ -2105,6 +2107,7 @@ virQEMUCapsPtr virQEMUCapsNewCopy(virQEMUCapsPtr qemuCaps) VIR_STRDUP(ret->machineTypes[i].alias, qemuCaps->machineTypes[i].alias) < 0) goto error; ret->machineTypes[i].maxCpus = qemuCaps->machineTypes[i].maxCpus; + ret->machineTypes[i].hotplugCpus = qemuCaps->machineTypes[i].hotplugCpus; } if (VIR_ALLOC_N(ret->gicCapabilities, qemuCaps->ngicCapabilities) < 0) @@ -2414,6 +2417,20 @@ int virQEMUCapsGetMachineMaxCpus(virQEMUCapsPtr qemuCaps, } +bool virQEMUCapsGetMachineHotplugCpus(virQEMUCapsPtr qemuCaps, + const char *name) +{ + size_t i; + + for (i = 0; i < qemuCaps->nmachineTypes; i++) { + if (STREQ_NULLABLE(qemuCaps->machineTypes[i].name, name)) + return qemuCaps->machineTypes[i].hotplugCpus; + } + + return false; +} + + /** * virQEMUCapsSetGICCapabilities: * @qemuCaps: QEMU capabilities @@ -2572,6 +2589,7 @@ virQEMUCapsProbeQMPMachineTypes(virQEMUCapsPtr qemuCaps, goto cleanup; mach->maxCpus = machines[i]->maxCpus; + mach->hotplugCpus = machines[i]->hotplugCpus; if (machines[i]->isDefault) defIdx = qemuCaps->nmachineTypes - 1; @@ -2830,7 +2848,7 @@ int virQEMUCapsProbeQMP(virQEMUCapsPtr qemuCaps, * ... * <cpu name="pentium3"/> * ... - * <machine name="pc-1.0" alias="pc" maxCpus="4"/> + * <machine name="pc-1.0" alias="pc" hotplugCpus='yes' maxCpus="4"/> * ... * </qemuCaps> */ @@ -2991,6 +3009,11 @@ virQEMUCapsLoadCache(virQEMUCapsPtr qemuCaps, const char *filename, goto cleanup; } VIR_FREE(str); + + str = virXMLPropString(nodes[i], "hotplugCpus"); + if (STREQ_NULLABLE(str, "yes")) + qemuCaps->machineTypes[i].hotplugCpus = true; + VIR_FREE(str); } } VIR_FREE(nodes); @@ -3124,6 +3147,8 @@ virQEMUCapsFormatCache(virQEMUCapsPtr qemuCaps, if (qemuCaps->machineTypes[i].alias) virBufferEscapeString(&buf, " alias='%s'", qemuCaps->machineTypes[i].alias); + if (qemuCaps->machineTypes[i].hotplugCpus) + virBufferAddLit(&buf, " hotplugCpus='yes'"); virBufferAsprintf(&buf, " maxCpus='%u'/>\n", qemuCaps->machineTypes[i].maxCpus); } @@ -3912,6 +3937,8 @@ virQEMUCapsFilterByMachineType(virQEMUCapsPtr qemuCaps, virQEMUCapsClear(qemuCaps, filter->flags[j]); } + if (!virQEMUCapsGetMachineHotplugCpus(qemuCaps, machineType)) + virQEMUCapsClear(qemuCaps, QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS); } diff --git a/src/qemu/qemu_capabilities.h b/src/qemu/qemu_capabilities.h index 365394d..a74d39f 100644 --- a/src/qemu/qemu_capabilities.h +++ b/src/qemu/qemu_capabilities.h @@ -428,6 +428,8 @@ const char *virQEMUCapsGetCanonicalMachine(virQEMUCapsPtr qemuCaps, const char *name); int virQEMUCapsGetMachineMaxCpus(virQEMUCapsPtr qemuCaps, const char *name); +bool virQEMUCapsGetMachineHotplugCpus(virQEMUCapsPtr qemuCaps, + const char *name); int virQEMUCapsGetMachineTypesCaps(virQEMUCapsPtr qemuCaps, size_t *nmachines, virCapsGuestMachinePtr **machines); diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h index 826991f..417091c 100644 --- a/src/qemu/qemu_monitor.h +++ b/src/qemu/qemu_monitor.h @@ -854,6 +854,7 @@ struct _qemuMonitorMachineInfo { bool isDefault; char *alias; unsigned int maxCpus; + bool hotplugCpus; }; int qemuMonitorGetMachines(qemuMonitorPtr mon, diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c index 4f4fb4f..ab5423e 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -4840,6 +4840,9 @@ int qemuMonitorJSONGetMachines(qemuMonitorPtr mon, _("query-machines reply has malformed 'cpu-max' data")); goto cleanup; } + + ignore_value(virJSONValueObjectGetBoolean(child, "hotpluggable-cpus", + &info->hotplugCpus)); } ret = n; diff --git a/tests/qemucapabilitiesdata/caps_2.7.0.x86_64.xml b/tests/qemucapabilitiesdata/caps_2.7.0.x86_64.xml index daae569..7a54040 100644 --- a/tests/qemucapabilitiesdata/caps_2.7.0.x86_64.xml +++ b/tests/qemucapabilitiesdata/caps_2.7.0.x86_64.xml @@ -227,31 +227,31 @@ <cpu name='core2duo'/> <cpu name='phenom'/> <cpu name='qemu64'/> - <machine name='pc-i440fx-2.7' alias='pc' maxCpus='255'/> - <machine name='pc-0.12' maxCpus='255'/> - <machine name='pc-i440fx-2.4' maxCpus='255'/> - <machine name='pc-1.3' maxCpus='255'/> - <machine name='pc-q35-2.7' alias='q35' maxCpus='255'/> - <machine name='pc-q35-2.6' maxCpus='255'/> - <machine name='pc-i440fx-1.7' maxCpus='255'/> - <machine name='pc-i440fx-1.6' maxCpus='255'/> - <machine name='pc-0.11' maxCpus='255'/> - <machine name='pc-i440fx-2.3' maxCpus='255'/> - <machine name='pc-0.10' maxCpus='255'/> - <machine name='pc-1.2' maxCpus='255'/> - <machine name='pc-i440fx-2.2' maxCpus='255'/> - <machine name='isapc' maxCpus='1'/> - <machine name='pc-q35-2.5' maxCpus='255'/> - <machine name='pc-0.15' maxCpus='255'/> - <machine name='pc-i440fx-1.5' maxCpus='255'/> - <machine name='pc-0.14' maxCpus='255'/> - <machine name='pc-i440fx-2.6' maxCpus='255'/> - <machine name='pc-i440fx-1.4' maxCpus='255'/> - <machine name='pc-i440fx-2.5' maxCpus='255'/> - <machine name='pc-1.1' maxCpus='255'/> - <machine name='pc-i440fx-2.1' maxCpus='255'/> - <machine name='pc-1.0' maxCpus='255'/> - <machine name='pc-i440fx-2.0' maxCpus='255'/> - <machine name='pc-q35-2.4' maxCpus='255'/> - <machine name='pc-0.13' maxCpus='255'/> + <machine name='pc-i440fx-2.7' alias='pc' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-0.12' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-i440fx-2.4' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-1.3' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-q35-2.7' alias='q35' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-q35-2.6' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-i440fx-1.7' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-i440fx-1.6' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-0.11' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-i440fx-2.3' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-0.10' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-1.2' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-i440fx-2.2' hotplugCpus='yes' maxCpus='255'/> + <machine name='isapc' hotplugCpus='yes' maxCpus='1'/> + <machine name='pc-q35-2.5' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-0.15' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-i440fx-1.5' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-0.14' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-i440fx-2.6' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-i440fx-1.4' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-i440fx-2.5' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-1.1' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-i440fx-2.1' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-1.0' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-i440fx-2.0' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-q35-2.4' hotplugCpus='yes' maxCpus='255'/> + <machine name='pc-0.13' hotplugCpus='yes' maxCpus='255'/> </qemuCaps> -- 2.8.2

Add support for retrieving information regarding hotpluggable cpu units supported by qemu. Data returned by the command carries information needed to figure out the granularity of hotplug, the necessary cpu type name and the topology information. Note that qemu doesn't specify any particular order of the entries thus it's necessary sort them by socket_id, core_id and thread_id to the order libvirt expects. --- Notes: v2: - fixed alias string in comment - already ACKed src/qemu/qemu_monitor.h | 16 ++++ src/qemu/qemu_monitor_json.c | 170 +++++++++++++++++++++++++++++++++++++++++++ src/qemu/qemu_monitor_json.h | 5 ++ 3 files changed, 191 insertions(+) diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h index 576b2af..58f8327 100644 --- a/src/qemu/qemu_monitor.h +++ b/src/qemu/qemu_monitor.h @@ -398,6 +398,22 @@ void qemuMonitorQueryCpusFree(struct qemuMonitorQueryCpusEntry *entries, size_t nentries); +struct qemuMonitorQueryHotpluggableCpusEntry { + char *type; /* name of the cpu to use with device_add */ + unsigned int vcpus; /* count of virtual cpus in the guest this entry adds */ + char *qom_path; /* full device qom path only present for online cpus */ + char *alias; /* device alias, may be NULL for non-hotpluggable entities */ + + /* topology information -1 if qemu didn't report given parameter */ + int node_id; + int socket_id; + int core_id; + int thread_id; +}; +void qemuMonitorQueryHotpluggableCpusFree(struct qemuMonitorQueryHotpluggableCpusEntry *entries, + size_t nentries); + + struct _qemuMonitorCPUInfo { pid_t tid; }; diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c index 9e0ea87..3d0a120 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -7070,3 +7070,173 @@ qemuMonitorJSONGetRTCTime(qemuMonitorPtr mon, virJSONValueFree(reply); return ret; } + + +void +qemuMonitorQueryHotpluggableCpusFree(struct qemuMonitorQueryHotpluggableCpusEntry *entries, + size_t nentries) +{ + struct qemuMonitorQueryHotpluggableCpusEntry *entry; + size_t i; + + if (!entries) + return; + + for (i = 0; i < nentries; i++) { + entry = entries + i; + + VIR_FREE(entry->type); + VIR_FREE(entry->qom_path); + VIR_FREE(entry->alias); + } + + VIR_FREE(entries); +} + + +/** + * [{ + * "props": { + * "core-id": 0, + * "thread-id": 0, + * "socket-id": 0 + * }, + * "vcpus-count": 1, + * "qom-path": "/machine/unattached/device[0]", + * "type": "qemu64-x86_64-cpu" + * }, + * {...} + * ] + */ +static int +qemuMonitorJSONProcessHotpluggableCpusReply(virJSONValuePtr vcpu, + struct qemuMonitorQueryHotpluggableCpusEntry *entry) +{ + virJSONValuePtr props; + const char *tmp; + + if (!(tmp = virJSONValueObjectGetString(vcpu, "type"))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("query-hotpluggable-cpus didn't return device type")); + return -1; + } + + if (VIR_STRDUP(entry->type, tmp) < 0) + return -1; + + if (virJSONValueObjectGetNumberUint(vcpu, "vcpus-count", &entry->vcpus) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("query-hotpluggable-cpus didn't return vcpus-count")); + return -1; + } + + if (!(props = virJSONValueObjectGetObject(vcpu, "props"))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("query-hotpluggable-cpus didn't return device props")); + return -1; + } + + entry->node_id = -1; + entry->socket_id = -1; + entry->core_id = -1; + entry->thread_id = -1; + + ignore_value(virJSONValueObjectGetNumberInt(props, "node-id", &entry->node_id)); + ignore_value(virJSONValueObjectGetNumberInt(props, "socket-id", &entry->socket_id)); + ignore_value(virJSONValueObjectGetNumberInt(props, "core-id", &entry->core_id)); + ignore_value(virJSONValueObjectGetNumberInt(props, "thread-id", &entry->thread_id)); + + if (entry->node_id == -1 && entry->socket_id == -1 && + entry->core_id == -1 && entry->thread_id == -1) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("query-hotpluggable-cpus entry doesn't report " + "topology information")); + return -1; + } + + /* qom path is not present unless the vCPU is online */ + if ((tmp = virJSONValueObjectGetString(vcpu, "qom-path"))) { + if (VIR_STRDUP(entry->qom_path, tmp) < 0) + return -1; + + /* alias is the part after last slash having a "vcpu" prefix */ + if ((tmp = strrchr(tmp, '/')) && STRPREFIX(tmp + 1, "vcpu")) { + if (VIR_STRDUP(entry->alias, tmp + 1) < 0) + return -1; + } + } + + return 0; +} + + +static int +qemuMonitorQueryHotpluggableCpusEntrySort(const void *p1, + const void *p2) +{ + const struct qemuMonitorQueryHotpluggableCpusEntry *a = p1; + const struct qemuMonitorQueryHotpluggableCpusEntry *b = p2; + + if (a->socket_id != b->socket_id) + return a->socket_id - b->socket_id; + + if (a->core_id != b->core_id) + return a->core_id - b->core_id; + + return a->thread_id - b->thread_id; +} + + +int +qemuMonitorJSONGetHotpluggableCPUs(qemuMonitorPtr mon, + struct qemuMonitorQueryHotpluggableCpusEntry **entries, + size_t *nentries) +{ + struct qemuMonitorQueryHotpluggableCpusEntry *info = NULL; + ssize_t ninfo = 0; + int ret = -1; + size_t i; + virJSONValuePtr data; + virJSONValuePtr cmd; + virJSONValuePtr reply = NULL; + virJSONValuePtr vcpu; + + if (!(cmd = qemuMonitorJSONMakeCommand("query-hotpluggable-cpus", NULL))) + return -1; + + if (qemuMonitorJSONCommand(mon, cmd, &reply) < 0) + goto cleanup; + + if (qemuMonitorJSONCheckError(cmd, reply) < 0) + goto cleanup; + + data = virJSONValueObjectGet(reply, "return"); + + if ((ninfo = virJSONValueArraySize(data)) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("query-hotpluggable-cpus reply is not an array")); + goto cleanup; + } + + if (VIR_ALLOC_N(info, ninfo) < 0) + goto cleanup; + + for (i = 0; i < ninfo; i++) { + vcpu = virJSONValueArrayGet(data, i); + + if (qemuMonitorJSONProcessHotpluggableCpusReply(vcpu, info + i) < 0) + goto cleanup; + } + + qsort(info, ninfo, sizeof(*info), qemuMonitorQueryHotpluggableCpusEntrySort); + + VIR_STEAL_PTR(*entries, info); + *nentries = ninfo; + ret = 0; + + cleanup: + qemuMonitorQueryHotpluggableCpusFree(info, ninfo); + virJSONValueFree(cmd); + virJSONValueFree(reply); + return ret; +} diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h index 90fe697..0eab96f 100644 --- a/src/qemu/qemu_monitor_json.h +++ b/src/qemu/qemu_monitor_json.h @@ -494,4 +494,9 @@ int qemuMonitorJSONMigrateStartPostCopy(qemuMonitorPtr mon) int qemuMonitorJSONGetRTCTime(qemuMonitorPtr mon, struct tm *tm) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); + +int qemuMonitorJSONGetHotpluggableCPUs(qemuMonitorPtr mon, + struct qemuMonitorQueryHotpluggableCpusEntry **entries, + size_t *nentries) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3); #endif /* QEMU_MONITOR_JSON_H */ -- 2.8.2

For hotplug purposes it's necessary to retrieve data using query-hotpluggable-cpus while the old query-cpus API report thread IDs and order of hotplug. This patch adds code that merges the data using a rather non-trivial algorithm and fills the data to the qemuMonitorCPUInfo structure for adding to appropriate place in the domain definition. --- Notes: v2: - fixed loop in the fallback info populator function - fixed debug message src/qemu/qemu_domain.c | 2 +- src/qemu/qemu_monitor.c | 197 ++++++++++++++++++++++++++++++++++++++++++++++-- src/qemu/qemu_monitor.h | 23 +++++- 3 files changed, 212 insertions(+), 10 deletions(-) diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c index c56dc75..45ded03 100644 --- a/src/qemu/qemu_domain.c +++ b/src/qemu/qemu_domain.c @@ -5804,7 +5804,7 @@ qemuDomainRefreshVcpuInfo(virQEMUDriverPtr driver, if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) return -1; - rc = qemuMonitorGetCPUInfo(qemuDomainGetMonitor(vm), &info, maxvcpus); + rc = qemuMonitorGetCPUInfo(qemuDomainGetMonitor(vm), &info, maxvcpus, false); if (qemuDomainObjExitMonitor(driver, vm) < 0) goto cleanup; diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c index f87f431..451786b 100644 --- a/src/qemu/qemu_monitor.c +++ b/src/qemu/qemu_monitor.c @@ -1656,13 +1656,36 @@ qemuMonitorSystemReset(qemuMonitorPtr mon) } +static void +qemuMonitorCPUInfoClear(qemuMonitorCPUInfoPtr cpus, + size_t ncpus) +{ + size_t i; + + for (i = 0; i < ncpus; i++) { + cpus[i].id = 0; + cpus[i].socket_id = -1; + cpus[i].core_id = -1; + cpus[i].thread_id = -1; + cpus[i].vcpus = 0; + cpus[i].tid = 0; + + VIR_FREE(cpus[i].qom_path); + VIR_FREE(cpus[i].alias); + VIR_FREE(cpus[i].type); + } +} + + void qemuMonitorCPUInfoFree(qemuMonitorCPUInfoPtr cpus, - size_t ncpus ATTRIBUTE_UNUSED) + size_t ncpus) { if (!cpus) return; + qemuMonitorCPUInfoClear(cpus, ncpus); + VIR_FREE(cpus); } @@ -1683,10 +1706,148 @@ qemuMonitorQueryCpusFree(struct qemuMonitorQueryCpusEntry *entries, /** + * Legacy approach doesn't allow out of order cpus, thus no complex matching + * algorithm is necessary */ +static void +qemuMonitorGetCPUInfoLegacy(struct qemuMonitorQueryCpusEntry *cpuentries, + size_t ncpuentries, + qemuMonitorCPUInfoPtr vcpus, + size_t maxvcpus) +{ + size_t i; + + for (i = 0; i < maxvcpus; i++) { + if (i < ncpuentries) + vcpus[i].tid = cpuentries[i].tid; + + /* for legacy hotplug to work we need to fake the vcpu count added by + * enabling a given vcpu */ + vcpus[i].vcpus = 1; + } +} + + +/** + * qemuMonitorGetCPUInfoHotplug: + * + * This function stitches together data retrieved via query-hotpluggable-cpus + * which returns entities on the hotpluggable level (which may describe more + * than one guest logical vcpu) with the output of query-cpus, having an entry + * per enabled guest logical vcpu. + * + * query-hotpluggable-cpus conveys following information: + * - topology information and number of logical vcpus this entry creates + * - device type name of the entry that needs to be used when hotplugging + * - qom path in qemu which can be used to map the entry against query-cpus + * + * query-cpus conveys following information: + * - thread id of a given guest logical vcpu + * - order in which the vcpus were inserted + * - qom path to allow mapping the two together + * + * The libvirt's internal structure has an entry for each possible (even + * disabled) guest vcpu. The purpose is to map the data together so that we are + * certain of the thread id mapping and the information required for vcpu + * hotplug. + * + * This function returns 0 on success and -1 on error, but does not report + * libvirt errors so that fallback approach can be used. + */ +static int +qemuMonitorGetCPUInfoHotplug(struct qemuMonitorQueryHotpluggableCpusEntry *hotplugvcpus, + size_t nhotplugvcpus, + struct qemuMonitorQueryCpusEntry *cpuentries, + size_t ncpuentries, + qemuMonitorCPUInfoPtr vcpus, + size_t maxvcpus) +{ + int order = 1; + size_t totalvcpus = 0; + size_t i; + size_t j; + + /* ensure that the total vcpu count reported by query-hotpluggable-cpus equals + * to the libvirt maximum cpu count */ + for (i = 0; i < nhotplugvcpus; i++) + totalvcpus += hotplugvcpus[i].vcpus; + + if (totalvcpus != maxvcpus) { + VIR_DEBUG("expected '%zu' total vcpus got '%zu'", maxvcpus, totalvcpus); + return -1; + } + + /* Note the order in which the hotpluggable entities are inserted by + * matching them to the query-cpus entries */ + for (i = 0; i < ncpuentries; i++) { + for (j = 0; j < nhotplugvcpus; j++) { + if (!cpuentries[i].qom_path || + !hotplugvcpus[j].qom_path || + !STRPREFIX(cpuentries[i].qom_path, hotplugvcpus[j].qom_path)) + continue; + + /* add ordering info for hotpluggable entries */ + if (hotplugvcpus[j].enable_id == 0) + hotplugvcpus[j].enable_id = order++; + + break; + } + } + + /* transfer appropriate data from the hotpluggable list to corresponding + * entries. the entries returned by qemu may in fact describe multiple + * logical vcpus in the guest */ + j = 0; + for (i = 0; i < nhotplugvcpus; i++) { + vcpus[j].socket_id = hotplugvcpus[i].socket_id; + vcpus[j].core_id = hotplugvcpus[i].core_id; + vcpus[j].thread_id = hotplugvcpus[i].thread_id; + vcpus[j].vcpus = hotplugvcpus[i].vcpus; + VIR_STEAL_PTR(vcpus[j].qom_path, hotplugvcpus[i].qom_path); + VIR_STEAL_PTR(vcpus[j].alias, hotplugvcpus[i].alias); + VIR_STEAL_PTR(vcpus[j].type, hotplugvcpus[i].type); + vcpus[j].id = hotplugvcpus[i].enable_id; + + /* skip over vcpu entries covered by this hotpluggable entry */ + j += hotplugvcpus[i].vcpus; + } + + /* match entries from query cpus to the output array taking into account + * multi-vcpu objects */ + for (j = 0; j < ncpuentries; j++) { + /* find the correct entry or beginning of group of entries */ + for (i = 0; i < maxvcpus; i++) { + if (cpuentries[j].qom_path && vcpus[i].qom_path && + STRPREFIX(cpuentries[j].qom_path, vcpus[i].qom_path)) + break; + } + + if (i == maxvcpus) { + VIR_DEBUG("too many query-cpus entries for a given " + "query-hotpluggable-cpus entry"); + return -1; + } + + if (vcpus[i].vcpus != 1) { + /* find a possibly empty vcpu thread for core granularity systems */ + for (; i < maxvcpus; i++) { + if (vcpus[i].tid == 0) + break; + } + } + + vcpus[i].tid = cpuentries[j].tid; + } + + return 0; +} + + +/** * qemuMonitorGetCPUInfo: * @mon: monitor * @cpus: pointer filled by array of qemuMonitorCPUInfo structures * @maxvcpus: total possible number of vcpus + * @hotplug: query data relevant for hotplug support * * Detects VCPU information. If qemu doesn't support or fails reporting * information this function will return success as other parts of libvirt @@ -1698,20 +1859,32 @@ qemuMonitorQueryCpusFree(struct qemuMonitorQueryCpusEntry *entries, int qemuMonitorGetCPUInfo(qemuMonitorPtr mon, qemuMonitorCPUInfoPtr *vcpus, - size_t maxvcpus) + size_t maxvcpus, + bool hotplug) { - qemuMonitorCPUInfoPtr info = NULL; + struct qemuMonitorQueryHotpluggableCpusEntry *hotplugcpus = NULL; + size_t nhotplugcpus = 0; struct qemuMonitorQueryCpusEntry *cpuentries = NULL; size_t ncpuentries = 0; - size_t i; int ret = -1; int rc; + qemuMonitorCPUInfoPtr info = NULL; - QEMU_CHECK_MONITOR(mon); + if (hotplug) + QEMU_CHECK_MONITOR_JSON(mon); + else + QEMU_CHECK_MONITOR(mon); if (VIR_ALLOC_N(info, maxvcpus) < 0) return -1; + /* initialize a few non-zero defaults */ + qemuMonitorCPUInfoClear(info, maxvcpus); + + if (hotplug && + (qemuMonitorJSONGetHotpluggableCPUs(mon, &hotplugcpus, &nhotplugcpus)) < 0) + goto cleanup; + if (mon->json) rc = qemuMonitorJSONQueryCPUs(mon, &cpuentries, &ncpuentries); else @@ -1726,15 +1899,23 @@ qemuMonitorGetCPUInfo(qemuMonitorPtr mon, goto cleanup; } - for (i = 0; i < ncpuentries; i++) - info[i].tid = cpuentries[i].tid; + if (!hotplugcpus || + qemuMonitorGetCPUInfoHotplug(hotplugcpus, nhotplugcpus, + cpuentries, ncpuentries, + info, maxvcpus) < 0) { + /* Fallback to the legacy algorithm. Hotplug paths will make sure that + * the apropriate data is present */ + qemuMonitorCPUInfoClear(info, maxvcpus); + qemuMonitorGetCPUInfoLegacy(cpuentries, ncpuentries, info, maxvcpus); + } VIR_STEAL_PTR(*vcpus, info); ret = 0; cleanup: - qemuMonitorCPUInfoFree(info, maxvcpus); + qemuMonitorQueryHotpluggableCpusFree(hotplugcpus, nhotplugcpus); qemuMonitorQueryCpusFree(cpuentries, ncpuentries); + qemuMonitorCPUInfoFree(info, maxvcpus); return ret; } diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h index 58f8327..b838725 100644 --- a/src/qemu/qemu_monitor.h +++ b/src/qemu/qemu_monitor.h @@ -409,6 +409,9 @@ struct qemuMonitorQueryHotpluggableCpusEntry { int socket_id; int core_id; int thread_id; + + /* internal data */ + int enable_id; }; void qemuMonitorQueryHotpluggableCpusFree(struct qemuMonitorQueryHotpluggableCpusEntry *entries, size_t nentries); @@ -416,6 +419,23 @@ void qemuMonitorQueryHotpluggableCpusFree(struct qemuMonitorQueryHotpluggableCpu struct _qemuMonitorCPUInfo { pid_t tid; + int id; /* order of enabling of the given cpu */ + + /* topology info for hotplug purposes. Hotplug of given vcpu impossible if + * all entries are -1 */ + int socket_id; + int core_id; + int thread_id; + unsigned int vcpus; /* number of vcpus added if given entry is hotplugged */ + + /* name of the qemu type to add in case of hotplug */ + char *type; + + /* alias of an hotpluggable entry. Entries with alias can be hot-unplugged */ + char *alias; + + /* internal for use in the matching code */ + char *qom_path; }; typedef struct _qemuMonitorCPUInfo qemuMonitorCPUInfo; typedef qemuMonitorCPUInfo *qemuMonitorCPUInfoPtr; @@ -424,7 +444,8 @@ void qemuMonitorCPUInfoFree(qemuMonitorCPUInfoPtr list, size_t nitems); int qemuMonitorGetCPUInfo(qemuMonitorPtr mon, qemuMonitorCPUInfoPtr *vcpus, - size_t maxvcpus); + size_t maxvcpus, + bool hotplug); int qemuMonitorGetVirtType(qemuMonitorPtr mon, virDomainVirtType *virtType); -- 2.8.2

Power 8 platform's basic hotpluggable unit is a core rather than a thread for x86_64 family. This introduces most of the complexity of the matching code and thus needs to be tested. The test data contain data captured from in-order cpu hotplug and unplug operations. --- Notes: v2: - dropped test 3 as it was identical to test 1 - did not change alias in the data - already ACKed .../qemumonitorjson-cpuinfo-ppc64-basic-cpus.json | 77 +++++++ ...emumonitorjson-cpuinfo-ppc64-basic-hotplug.json | 27 +++ .../qemumonitorjson-cpuinfo-ppc64-basic.data | 40 ++++ ...mumonitorjson-cpuinfo-ppc64-hotplug-1-cpus.json | 149 ++++++++++++++ ...onitorjson-cpuinfo-ppc64-hotplug-1-hotplug.json | 28 +++ .../qemumonitorjson-cpuinfo-ppc64-hotplug-1.data | 51 +++++ ...mumonitorjson-cpuinfo-ppc64-hotplug-2-cpus.json | 221 +++++++++++++++++++++ ...onitorjson-cpuinfo-ppc64-hotplug-2-hotplug.json | 29 +++ .../qemumonitorjson-cpuinfo-ppc64-hotplug-2.data | 62 ++++++ tests/qemumonitorjsontest.c | 4 + 10 files changed, 688 insertions(+) create mode 100644 tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-basic-cpus.json create mode 100644 tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-basic-hotplug.json create mode 100644 tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-basic.data create mode 100644 tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-1-cpus.json create mode 100644 tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-1-hotplug.json create mode 100644 tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-1.data create mode 100644 tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-2-cpus.json create mode 100644 tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-2-hotplug.json create mode 100644 tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-2.data diff --git a/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-basic-cpus.json b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-basic-cpus.json new file mode 100644 index 0000000..27a3d8b --- /dev/null +++ b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-basic-cpus.json @@ -0,0 +1,77 @@ +{ + "return": [ + { + "arch": "ppc", + "current": true, + "CPU": 0, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[0]", + "halted": false, + "thread_id": 21925 + }, + { + "arch": "ppc", + "current": false, + "CPU": 1, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[1]", + "halted": false, + "thread_id": 21926 + }, + { + "arch": "ppc", + "current": false, + "CPU": 2, + "nip": -4611686018422360608, + "qom_path": "/machine/unattached/device[1]/thread[2]", + "halted": false, + "thread_id": 21927 + }, + { + "arch": "ppc", + "current": false, + "CPU": 3, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[3]", + "halted": false, + "thread_id": 21928 + }, + { + "arch": "ppc", + "current": false, + "CPU": 4, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[4]", + "halted": false, + "thread_id": 21930 + }, + { + "arch": "ppc", + "current": false, + "CPU": 5, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[5]", + "halted": false, + "thread_id": 21931 + }, + { + "arch": "ppc", + "current": false, + "CPU": 6, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[6]", + "halted": false, + "thread_id": 21932 + }, + { + "arch": "ppc", + "current": false, + "CPU": 7, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[7]", + "halted": false, + "thread_id": 21933 + } + ], + "id": "libvirt-12" +} diff --git a/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-basic-hotplug.json b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-basic-hotplug.json new file mode 100644 index 0000000..513317b --- /dev/null +++ b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-basic-hotplug.json @@ -0,0 +1,27 @@ +{ + "return": [ + { + "props": { + "core-id": 16 + }, + "vcpus-count": 8, + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 8 + }, + "vcpus-count": 8, + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 0 + }, + "vcpus-count": 8, + "qom-path": "/machine/unattached/device[1]", + "type": "host-spapr-cpu-core" + } + ], + "id": "libvirt-11" +} diff --git a/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-basic.data b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-basic.data new file mode 100644 index 0000000..9fc8148 --- /dev/null +++ b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-basic.data @@ -0,0 +1,40 @@ +[vcpu libvirt-id='0'] + thread-id='21925' + qemu-id='1' + type='host-spapr-cpu-core' + qom_path='/machine/unattached/device[1]' + topology: core='0' vcpus='8' +[vcpu libvirt-id='1'] + thread-id='21926' +[vcpu libvirt-id='2'] + thread-id='21927' +[vcpu libvirt-id='3'] + thread-id='21928' +[vcpu libvirt-id='4'] + thread-id='21930' +[vcpu libvirt-id='5'] + thread-id='21931' +[vcpu libvirt-id='6'] + thread-id='21932' +[vcpu libvirt-id='7'] + thread-id='21933' +[vcpu libvirt-id='8'] + type='host-spapr-cpu-core' + topology: core='8' vcpus='8' +[vcpu libvirt-id='9'] +[vcpu libvirt-id='10'] +[vcpu libvirt-id='11'] +[vcpu libvirt-id='12'] +[vcpu libvirt-id='13'] +[vcpu libvirt-id='14'] +[vcpu libvirt-id='15'] +[vcpu libvirt-id='16'] + type='host-spapr-cpu-core' + topology: core='16' vcpus='8' +[vcpu libvirt-id='17'] +[vcpu libvirt-id='18'] +[vcpu libvirt-id='19'] +[vcpu libvirt-id='20'] +[vcpu libvirt-id='21'] +[vcpu libvirt-id='22'] +[vcpu libvirt-id='23'] diff --git a/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-1-cpus.json b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-1-cpus.json new file mode 100644 index 0000000..7771cbc --- /dev/null +++ b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-1-cpus.json @@ -0,0 +1,149 @@ +{ + "return": [ + { + "arch": "ppc", + "current": true, + "CPU": 0, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[0]", + "halted": false, + "thread_id": 21925 + }, + { + "arch": "ppc", + "current": false, + "CPU": 1, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[1]", + "halted": false, + "thread_id": 21926 + }, + { + "arch": "ppc", + "current": false, + "CPU": 2, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[2]", + "halted": false, + "thread_id": 21927 + }, + { + "arch": "ppc", + "current": false, + "CPU": 3, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[3]", + "halted": false, + "thread_id": 21928 + }, + { + "arch": "ppc", + "current": false, + "CPU": 4, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[4]", + "halted": false, + "thread_id": 21930 + }, + { + "arch": "ppc", + "current": false, + "CPU": 5, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[5]", + "halted": false, + "thread_id": 21931 + }, + { + "arch": "ppc", + "current": false, + "CPU": 6, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[6]", + "halted": false, + "thread_id": 21932 + }, + { + "arch": "ppc", + "current": false, + "CPU": 7, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[7]", + "halted": false, + "thread_id": 21933 + }, + { + "arch": "ppc", + "current": false, + "CPU": 8, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu0/thread[0]", + "halted": false, + "thread_id": 22131 + }, + { + "arch": "ppc", + "current": false, + "CPU": 9, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu0/thread[1]", + "halted": false, + "thread_id": 22132 + }, + { + "arch": "ppc", + "current": false, + "CPU": 10, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu0/thread[2]", + "halted": false, + "thread_id": 22133 + }, + { + "arch": "ppc", + "current": false, + "CPU": 11, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu0/thread[3]", + "halted": false, + "thread_id": 22134 + }, + { + "arch": "ppc", + "current": false, + "CPU": 12, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu0/thread[4]", + "halted": false, + "thread_id": 22135 + }, + { + "arch": "ppc", + "current": false, + "CPU": 13, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu0/thread[5]", + "halted": false, + "thread_id": 22136 + }, + { + "arch": "ppc", + "current": false, + "CPU": 14, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu0/thread[6]", + "halted": false, + "thread_id": 22137 + }, + { + "arch": "ppc", + "current": false, + "CPU": 15, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu0/thread[7]", + "halted": false, + "thread_id": 22138 + } + ], + "id": "libvirt-14" +} diff --git a/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-1-hotplug.json b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-1-hotplug.json new file mode 100644 index 0000000..e7594c3 --- /dev/null +++ b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-1-hotplug.json @@ -0,0 +1,28 @@ +{ + "return": [ + { + "props": { + "core-id": 16 + }, + "vcpus-count": 8, + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 8 + }, + "vcpus-count": 8, + "qom-path": "/machine/peripheral/vcpu0", + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 0 + }, + "vcpus-count": 8, + "qom-path": "/machine/unattached/device[1]", + "type": "host-spapr-cpu-core" + } + ], + "id": "libvirt-15" +} diff --git a/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-1.data b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-1.data new file mode 100644 index 0000000..b0139b5 --- /dev/null +++ b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-1.data @@ -0,0 +1,51 @@ +[vcpu libvirt-id='0'] + thread-id='21925' + qemu-id='1' + type='host-spapr-cpu-core' + qom_path='/machine/unattached/device[1]' + topology: core='0' vcpus='8' +[vcpu libvirt-id='1'] + thread-id='21926' +[vcpu libvirt-id='2'] + thread-id='21927' +[vcpu libvirt-id='3'] + thread-id='21928' +[vcpu libvirt-id='4'] + thread-id='21930' +[vcpu libvirt-id='5'] + thread-id='21931' +[vcpu libvirt-id='6'] + thread-id='21932' +[vcpu libvirt-id='7'] + thread-id='21933' +[vcpu libvirt-id='8'] + thread-id='22131' + qemu-id='2' + type='host-spapr-cpu-core' + alias='vcpu0' + qom_path='/machine/peripheral/vcpu0' + topology: core='8' vcpus='8' +[vcpu libvirt-id='9'] + thread-id='22132' +[vcpu libvirt-id='10'] + thread-id='22133' +[vcpu libvirt-id='11'] + thread-id='22134' +[vcpu libvirt-id='12'] + thread-id='22135' +[vcpu libvirt-id='13'] + thread-id='22136' +[vcpu libvirt-id='14'] + thread-id='22137' +[vcpu libvirt-id='15'] + thread-id='22138' +[vcpu libvirt-id='16'] + type='host-spapr-cpu-core' + topology: core='16' vcpus='8' +[vcpu libvirt-id='17'] +[vcpu libvirt-id='18'] +[vcpu libvirt-id='19'] +[vcpu libvirt-id='20'] +[vcpu libvirt-id='21'] +[vcpu libvirt-id='22'] +[vcpu libvirt-id='23'] diff --git a/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-2-cpus.json b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-2-cpus.json new file mode 100644 index 0000000..b377b6a --- /dev/null +++ b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-2-cpus.json @@ -0,0 +1,221 @@ +{ + "return": [ + { + "arch": "ppc", + "current": true, + "CPU": 0, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[0]", + "halted": false, + "thread_id": 21925 + }, + { + "arch": "ppc", + "current": false, + "CPU": 1, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[1]", + "halted": false, + "thread_id": 21926 + }, + { + "arch": "ppc", + "current": false, + "CPU": 2, + "nip": -4611686018422360576, + "qom_path": "/machine/unattached/device[1]/thread[2]", + "halted": false, + "thread_id": 21927 + }, + { + "arch": "ppc", + "current": false, + "CPU": 3, + "nip": -4611686018422360596, + "qom_path": "/machine/unattached/device[1]/thread[3]", + "halted": false, + "thread_id": 21928 + }, + { + "arch": "ppc", + "current": false, + "CPU": 4, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[4]", + "halted": false, + "thread_id": 21930 + }, + { + "arch": "ppc", + "current": false, + "CPU": 5, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[5]", + "halted": false, + "thread_id": 21931 + }, + { + "arch": "ppc", + "current": false, + "CPU": 6, + "nip": -4611686018426772172, + "qom_path": "/machine/unattached/device[1]/thread[6]", + "halted": false, + "thread_id": 21932 + }, + { + "arch": "ppc", + "current": false, + "CPU": 7, + "nip": -4611686018422360596, + "qom_path": "/machine/unattached/device[1]/thread[7]", + "halted": false, + "thread_id": 21933 + }, + { + "arch": "ppc", + "current": false, + "CPU": 8, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu0/thread[0]", + "halted": false, + "thread_id": 22131 + }, + { + "arch": "ppc", + "current": false, + "CPU": 9, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu0/thread[1]", + "halted": false, + "thread_id": 22132 + }, + { + "arch": "ppc", + "current": false, + "CPU": 10, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu0/thread[2]", + "halted": false, + "thread_id": 22133 + }, + { + "arch": "ppc", + "current": false, + "CPU": 11, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu0/thread[3]", + "halted": false, + "thread_id": 22134 + }, + { + "arch": "ppc", + "current": false, + "CPU": 12, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu0/thread[4]", + "halted": false, + "thread_id": 22135 + }, + { + "arch": "ppc", + "current": false, + "CPU": 13, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu0/thread[5]", + "halted": false, + "thread_id": 22136 + }, + { + "arch": "ppc", + "current": false, + "CPU": 14, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu0/thread[6]", + "halted": false, + "thread_id": 22137 + }, + { + "arch": "ppc", + "current": false, + "CPU": 15, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu0/thread[7]", + "halted": false, + "thread_id": 22138 + }, + { + "arch": "ppc", + "current": false, + "CPU": 16, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu1/thread[0]", + "halted": false, + "thread_id": 22223 + }, + { + "arch": "ppc", + "current": false, + "CPU": 17, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu1/thread[1]", + "halted": false, + "thread_id": 22224 + }, + { + "arch": "ppc", + "current": false, + "CPU": 18, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu1/thread[2]", + "halted": false, + "thread_id": 22225 + }, + { + "arch": "ppc", + "current": false, + "CPU": 19, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu1/thread[3]", + "halted": false, + "thread_id": 22226 + }, + { + "arch": "ppc", + "current": false, + "CPU": 20, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu1/thread[4]", + "halted": false, + "thread_id": 22227 + }, + { + "arch": "ppc", + "current": false, + "CPU": 21, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu1/thread[5]", + "halted": false, + "thread_id": 22228 + }, + { + "arch": "ppc", + "current": false, + "CPU": 22, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu1/thread[6]", + "halted": false, + "thread_id": 22229 + }, + { + "arch": "ppc", + "current": false, + "CPU": 23, + "nip": -4611686018426772172, + "qom_path": "/machine/peripheral/vcpu1/thread[7]", + "halted": false, + "thread_id": 22230 + } + ], + "id": "libvirt-17" +} diff --git a/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-2-hotplug.json b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-2-hotplug.json new file mode 100644 index 0000000..7027531 --- /dev/null +++ b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-2-hotplug.json @@ -0,0 +1,29 @@ +{ + "return": [ + { + "props": { + "core-id": 16 + }, + "vcpus-count": 8, + "qom-path": "/machine/peripheral/vcpu1", + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 8 + }, + "vcpus-count": 8, + "qom-path": "/machine/peripheral/vcpu0", + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 0 + }, + "vcpus-count": 8, + "qom-path": "/machine/unattached/device[1]", + "type": "host-spapr-cpu-core" + } + ], + "id": "libvirt-18" +} diff --git a/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-2.data b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-2.data new file mode 100644 index 0000000..ea4b099 --- /dev/null +++ b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-hotplug-2.data @@ -0,0 +1,62 @@ +[vcpu libvirt-id='0'] + thread-id='21925' + qemu-id='1' + type='host-spapr-cpu-core' + qom_path='/machine/unattached/device[1]' + topology: core='0' vcpus='8' +[vcpu libvirt-id='1'] + thread-id='21926' +[vcpu libvirt-id='2'] + thread-id='21927' +[vcpu libvirt-id='3'] + thread-id='21928' +[vcpu libvirt-id='4'] + thread-id='21930' +[vcpu libvirt-id='5'] + thread-id='21931' +[vcpu libvirt-id='6'] + thread-id='21932' +[vcpu libvirt-id='7'] + thread-id='21933' +[vcpu libvirt-id='8'] + thread-id='22131' + qemu-id='2' + type='host-spapr-cpu-core' + alias='vcpu0' + qom_path='/machine/peripheral/vcpu0' + topology: core='8' vcpus='8' +[vcpu libvirt-id='9'] + thread-id='22132' +[vcpu libvirt-id='10'] + thread-id='22133' +[vcpu libvirt-id='11'] + thread-id='22134' +[vcpu libvirt-id='12'] + thread-id='22135' +[vcpu libvirt-id='13'] + thread-id='22136' +[vcpu libvirt-id='14'] + thread-id='22137' +[vcpu libvirt-id='15'] + thread-id='22138' +[vcpu libvirt-id='16'] + thread-id='22223' + qemu-id='3' + type='host-spapr-cpu-core' + alias='vcpu1' + qom_path='/machine/peripheral/vcpu1' + topology: core='16' vcpus='8' +[vcpu libvirt-id='17'] + thread-id='22224' +[vcpu libvirt-id='18'] + thread-id='22225' +[vcpu libvirt-id='19'] + thread-id='22226' +[vcpu libvirt-id='20'] + thread-id='22227' +[vcpu libvirt-id='21'] + thread-id='22228' +[vcpu libvirt-id='22'] + thread-id='22229' +[vcpu libvirt-id='23'] + thread-id='22230' diff --git a/tests/qemumonitorjsontest.c b/tests/qemumonitorjsontest.c index 6132f5d..e3ee74b 100644 --- a/tests/qemumonitorjsontest.c +++ b/tests/qemumonitorjsontest.c @@ -2586,6 +2586,10 @@ mymain(void) DO_TEST_CPU_INFO("x86-basic-pluggable", 8); + DO_TEST_CPU_INFO("ppc64-basic", 24); + DO_TEST_CPU_INFO("ppc64-hotplug-1", 24); + DO_TEST_CPU_INFO("ppc64-hotplug-2", 24); + qemuTestDriverFree(&driver); return (ret == 0) ? EXIT_SUCCESS : EXIT_FAILURE; -- 2.8.2

The reported data is unusual so add it to the test suite. --- Notes: v2: - already ACKed ...umonitorjson-cpuinfo-ppc64-no-threads-cpus.json | 77 +++++++++++++ ...nitorjson-cpuinfo-ppc64-no-threads-hotplug.json | 125 +++++++++++++++++++++ .../qemumonitorjson-cpuinfo-ppc64-no-threads.data | 72 ++++++++++++ tests/qemumonitorjsontest.c | 1 + 4 files changed, 275 insertions(+) create mode 100644 tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-no-threads-cpus.json create mode 100644 tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-no-threads-hotplug.json create mode 100644 tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-no-threads.data diff --git a/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-no-threads-cpus.json b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-no-threads-cpus.json new file mode 100644 index 0000000..31a3905 --- /dev/null +++ b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-no-threads-cpus.json @@ -0,0 +1,77 @@ +{ + "return": [ + { + "arch": "ppc", + "current": true, + "CPU": 0, + "nip": -4611686018426772876, + "qom_path": "/machine/unattached/device[1]/thread[0]", + "halted": false, + "thread_id": 35232 + }, + { + "arch": "ppc", + "current": false, + "CPU": 1, + "nip": -4611686018426772876, + "qom_path": "/machine/unattached/device[2]/thread[0]", + "halted": false, + "thread_id": 35233 + }, + { + "arch": "ppc", + "current": false, + "CPU": 2, + "nip": -4611686018426772876, + "qom_path": "/machine/unattached/device[3]/thread[0]", + "halted": false, + "thread_id": 35234 + }, + { + "arch": "ppc", + "current": false, + "CPU": 3, + "nip": -4611686018426772876, + "qom_path": "/machine/unattached/device[4]/thread[0]", + "halted": false, + "thread_id": 35235 + }, + { + "arch": "ppc", + "current": false, + "CPU": 4, + "nip": -4611686018426772876, + "qom_path": "/machine/unattached/device[5]/thread[0]", + "halted": false, + "thread_id": 35236 + }, + { + "arch": "ppc", + "current": false, + "CPU": 5, + "nip": -4611686018426772876, + "qom_path": "/machine/unattached/device[6]/thread[0]", + "halted": false, + "thread_id": 35237 + }, + { + "arch": "ppc", + "current": false, + "CPU": 6, + "nip": -4611686018426772876, + "qom_path": "/machine/unattached/device[7]/thread[0]", + "halted": false, + "thread_id": 35238 + }, + { + "arch": "ppc", + "current": false, + "CPU": 7, + "nip": -4611686018426772876, + "qom_path": "/machine/unattached/device[8]/thread[0]", + "halted": false, + "thread_id": 35239 + } + ], + "id": "libvirt-11" +} diff --git a/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-no-threads-hotplug.json b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-no-threads-hotplug.json new file mode 100644 index 0000000..30785a9 --- /dev/null +++ b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-no-threads-hotplug.json @@ -0,0 +1,125 @@ +{ + "return": [ + { + "props": { + "core-id": 120 + }, + "vcpus-count": 1, + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 112 + }, + "vcpus-count": 1, + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 104 + }, + "vcpus-count": 1, + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 96 + }, + "vcpus-count": 1, + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 88 + }, + "vcpus-count": 1, + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 80 + }, + "vcpus-count": 1, + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 72 + }, + "vcpus-count": 1, + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 64 + }, + "vcpus-count": 1, + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 56 + }, + "vcpus-count": 1, + "qom-path": "/machine/unattached/device[8]", + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 48 + }, + "vcpus-count": 1, + "qom-path": "/machine/unattached/device[7]", + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 40 + }, + "vcpus-count": 1, + "qom-path": "/machine/unattached/device[6]", + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 32 + }, + "vcpus-count": 1, + "qom-path": "/machine/unattached/device[5]", + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 24 + }, + "vcpus-count": 1, + "qom-path": "/machine/unattached/device[4]", + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 16 + }, + "vcpus-count": 1, + "qom-path": "/machine/unattached/device[3]", + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 8 + }, + "vcpus-count": 1, + "qom-path": "/machine/unattached/device[2]", + "type": "host-spapr-cpu-core" + }, + { + "props": { + "core-id": 0 + }, + "vcpus-count": 1, + "qom-path": "/machine/unattached/device[1]", + "type": "host-spapr-cpu-core" + } + ], + "id": "libvirt-12" +} diff --git a/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-no-threads.data b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-no-threads.data new file mode 100644 index 0000000..d7ab77b --- /dev/null +++ b/tests/qemumonitorjsondata/qemumonitorjson-cpuinfo-ppc64-no-threads.data @@ -0,0 +1,72 @@ +[vcpu libvirt-id='0'] + thread-id='35232' + qemu-id='1' + type='host-spapr-cpu-core' + qom_path='/machine/unattached/device[1]' + topology: core='0' vcpus='1' +[vcpu libvirt-id='1'] + thread-id='35233' + qemu-id='2' + type='host-spapr-cpu-core' + qom_path='/machine/unattached/device[2]' + topology: core='8' vcpus='1' +[vcpu libvirt-id='2'] + thread-id='35234' + qemu-id='3' + type='host-spapr-cpu-core' + qom_path='/machine/unattached/device[3]' + topology: core='16' vcpus='1' +[vcpu libvirt-id='3'] + thread-id='35235' + qemu-id='4' + type='host-spapr-cpu-core' + qom_path='/machine/unattached/device[4]' + topology: core='24' vcpus='1' +[vcpu libvirt-id='4'] + thread-id='35236' + qemu-id='5' + type='host-spapr-cpu-core' + qom_path='/machine/unattached/device[5]' + topology: core='32' vcpus='1' +[vcpu libvirt-id='5'] + thread-id='35237' + qemu-id='6' + type='host-spapr-cpu-core' + qom_path='/machine/unattached/device[6]' + topology: core='40' vcpus='1' +[vcpu libvirt-id='6'] + thread-id='35238' + qemu-id='7' + type='host-spapr-cpu-core' + qom_path='/machine/unattached/device[7]' + topology: core='48' vcpus='1' +[vcpu libvirt-id='7'] + thread-id='35239' + qemu-id='8' + type='host-spapr-cpu-core' + qom_path='/machine/unattached/device[8]' + topology: core='56' vcpus='1' +[vcpu libvirt-id='8'] + type='host-spapr-cpu-core' + topology: core='64' vcpus='1' +[vcpu libvirt-id='9'] + type='host-spapr-cpu-core' + topology: core='72' vcpus='1' +[vcpu libvirt-id='10'] + type='host-spapr-cpu-core' + topology: core='80' vcpus='1' +[vcpu libvirt-id='11'] + type='host-spapr-cpu-core' + topology: core='88' vcpus='1' +[vcpu libvirt-id='12'] + type='host-spapr-cpu-core' + topology: core='96' vcpus='1' +[vcpu libvirt-id='13'] + type='host-spapr-cpu-core' + topology: core='104' vcpus='1' +[vcpu libvirt-id='14'] + type='host-spapr-cpu-core' + topology: core='112' vcpus='1' +[vcpu libvirt-id='15'] + type='host-spapr-cpu-core' + topology: core='120' vcpus='1' diff --git a/tests/qemumonitorjsontest.c b/tests/qemumonitorjsontest.c index 388e43f..b8ec07b 100644 --- a/tests/qemumonitorjsontest.c +++ b/tests/qemumonitorjsontest.c @@ -2590,6 +2590,7 @@ mymain(void) DO_TEST_CPU_INFO("ppc64-hotplug-1", 24); DO_TEST_CPU_INFO("ppc64-hotplug-2", 24); DO_TEST_CPU_INFO("ppc64-hotplug-4", 24); + DO_TEST_CPU_INFO("ppc64-no-threads", 16); qemuTestDriverFree(&driver); -- 2.8.2

Similarly to devices the guest may allow unplug of the VCPU if libvirt is down. To avoid problems, refresh the vcpu state on reconnect. Don't mess with the vcpu state otherwise. --- Notes: v2: already ACKed src/qemu/qemu_domain.c | 9 ++++++++- src/qemu/qemu_domain.h | 3 ++- src/qemu/qemu_driver.c | 4 ++-- src/qemu/qemu_process.c | 7 +++++-- 4 files changed, 17 insertions(+), 6 deletions(-) diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c index f0ae84e..d4f472b 100644 --- a/src/qemu/qemu_domain.c +++ b/src/qemu/qemu_domain.c @@ -5764,16 +5764,20 @@ qemuDomainSupportsNewVcpuHotplug(virDomainObjPtr vm) * @driver: qemu driver data * @vm: domain object * @asyncJob: current asynchronous job type + * @state: refresh vcpu state * * Updates vCPU information private data of @vm. Due to historical reasons this * function returns success even if some data were not reported by qemu. * + * If @state is true, the vcpu state is refreshed as reported by the monitor. + * * Returns 0 on success and -1 on fatal error. */ int qemuDomainRefreshVcpuInfo(virQEMUDriverPtr driver, virDomainObjPtr vm, - int asyncJob) + int asyncJob, + bool state) { virDomainVcpuDefPtr vcpu; qemuDomainVcpuPrivatePtr vcpupriv; @@ -5841,6 +5845,9 @@ qemuDomainRefreshVcpuInfo(virQEMUDriverPtr driver, VIR_FREE(vcpupriv->alias); VIR_STEAL_PTR(vcpupriv->alias, info[i].alias); vcpupriv->enable_id = info[i].id; + + if (hotplug && state) + vcpu->online = !!info[i].qom_path; } ret = 0; diff --git a/src/qemu/qemu_domain.h b/src/qemu/qemu_domain.h index c95acdf..b4b3dae 100644 --- a/src/qemu/qemu_domain.h +++ b/src/qemu/qemu_domain.h @@ -660,7 +660,8 @@ pid_t qemuDomainGetVcpuPid(virDomainObjPtr vm, unsigned int vcpuid); int qemuDomainValidateVcpuInfo(virDomainObjPtr vm); int qemuDomainRefreshVcpuInfo(virQEMUDriverPtr driver, virDomainObjPtr vm, - int asyncJob); + int asyncJob, + bool state); bool qemuDomainSupportsNicdev(virDomainDefPtr def, virDomainNetDefPtr net); diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index a0ac2ef..8ff95f6 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -4640,7 +4640,7 @@ qemuDomainHotplugAddVcpu(virQEMUDriverPtr driver, vcpuinfo->online = true; - if (qemuDomainRefreshVcpuInfo(driver, vm, QEMU_ASYNC_JOB_NONE) < 0) + if (qemuDomainRefreshVcpuInfo(driver, vm, QEMU_ASYNC_JOB_NONE, false) < 0) goto cleanup; if (qemuDomainValidateVcpuInfo(vm) < 0) @@ -4689,7 +4689,7 @@ qemuDomainHotplugDelVcpu(virQEMUDriverPtr driver, goto cleanup; } - if (qemuDomainRefreshVcpuInfo(driver, vm, QEMU_ASYNC_JOB_NONE) < 0) + if (qemuDomainRefreshVcpuInfo(driver, vm, QEMU_ASYNC_JOB_NONE, false) < 0) goto cleanup; if (qemuDomainValidateVcpuInfo(vm) < 0) { diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index 907da30..3cf9d8c 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -3354,6 +3354,9 @@ qemuProcessReconnect(void *opaque) ignore_value(virSecurityManagerCheckAllLabel(driver->securityManager, obj->def)); + if (qemuDomainRefreshVcpuInfo(driver, obj, QEMU_ASYNC_JOB_NONE, true) < 0) + goto error; + if (virSecurityManagerReserveLabel(driver->securityManager, obj->def, obj->pid) < 0) goto error; @@ -5234,7 +5237,7 @@ qemuProcessLaunch(virConnectPtr conn, goto cleanup; VIR_DEBUG("Refreshing VCPU info"); - if (qemuDomainRefreshVcpuInfo(driver, vm, asyncJob) < 0) + if (qemuDomainRefreshVcpuInfo(driver, vm, asyncJob, false) < 0) goto cleanup; if (qemuDomainValidateVcpuInfo(vm) < 0) @@ -6029,7 +6032,7 @@ int qemuProcessAttach(virConnectPtr conn ATTRIBUTE_UNUSED, } VIR_DEBUG("Detecting VCPU PIDs"); - if (qemuDomainRefreshVcpuInfo(driver, vm, QEMU_ASYNC_JOB_NONE) < 0) + if (qemuDomainRefreshVcpuInfo(driver, vm, QEMU_ASYNC_JOB_NONE, false) < 0) goto error; if (qemuDomainValidateVcpuInfo(vm) < 0) -- 2.8.2

Individual vCPU hotplug requires us to track the state of any vCPU. To allow this add the following XML: <domain> ... <vcpu current='1'>2</vcpu> <vcpus> <vcpu id='0' enabled='no' hotpluggable='yes'/> <vcpu id='1' enabled='yes' hotpluggable='no' order='1'/> </vcpus> ... The 'enabled' attribute allows to control the state of the vcpu. 'hotpluggable' controls whether given vcpu can be hotplugged and 'order' allows to specify the order to add the vcpus. --- Notes: v2: - added documentation - added tweak of hotplug state when reconnecting to a VM - discussed design requests in previous thread docs/formatdomain.html.in | 40 ++++++ docs/schemas/domaincommon.rng | 25 ++++ src/conf/domain_conf.c | 152 ++++++++++++++++++++- src/conf/domain_conf.h | 6 + src/qemu/qemu_domain.c | 11 +- .../generic-vcpus-individual.xml | 23 ++++ tests/genericxml2xmltest.c | 2 + tests/testutils.c | 4 +- 8 files changed, 259 insertions(+), 4 deletions(-) create mode 100644 tests/genericxml2xmlindata/generic-vcpus-individual.xml diff --git a/docs/formatdomain.html.in b/docs/formatdomain.html.in index bfbb0f2..062045b 100644 --- a/docs/formatdomain.html.in +++ b/docs/formatdomain.html.in @@ -489,6 +489,10 @@ <domain> ... <vcpu placement='static' cpuset="1-4,^3,6" current="1">2</vcpu> + <vcpus> + <vcpu id='0' enabled='yes' hotpluggable='no' order='1'/> + <vcpu id='1' enabled='no' hotpluggable='yes'/> + </vcpus> ... </domain> </pre> @@ -542,6 +546,42 @@ </dd> </dl> </dd> + <dt><code>vcpus</code></dt> + <dd> + The vcpus element allows to control state of individual vcpus. + + The <code>id</code> attribute specifies the vCPU id as used by libvirt + in other places such as vcpu pinning, scheduler information and NUMA + assignment. Note that the vcpu ID as seen in the guest may differ from + libvirt ID in certain cases. Valid IDs are from 0 to the maximum vcpu + count as set by the <code>vcpu</code> element minus 1. + + The <code>enabled</code> attribute allows to control the state of the + vcpu. Valid values are <code>yes</code> and <code>no</code>. + + <code>hotpluggable</code> controls whether given vcpu can be hotplugged + and hotunplugged in cases when the cpu is enabled at boot. Note that + all disabled vcpus must be hotpluggable. Valid values are + <code>yes</code> and <code>no</code>. + + <code>order</code> allows to specify the order to add the vcpus. For + hypervisors/platforms that require to insert multiple vcpus at once + the order may be be duplicated accross all vcpus that need to be + enabled at once. Specifying order is not necessary, vcpus are then + added in an arbitrary order. + + Note that hypervisors may create hotpluggable vcpus differently from + boot vcpus thus special initialization may be necessary. + + Hypervisors may require that vcpus enabled on boot which are not + hotpluggable are clustered at the beginning starting with ID 0. It may + be also required that vcpu 0 is always present and non-hotpluggable. + + Note that providing state for individual cpus may be necessary to enable + support of addressable vCPU hotplug and this feature may not be + supported by all hypervisors. + <span class="since">Since 2.2.0 (QEMU only)</span> + </dd> </dl> <h3><a name="elementsIOThreadsAllocation">IOThreads Allocation</a></h3> diff --git a/docs/schemas/domaincommon.rng b/docs/schemas/domaincommon.rng index 052f28c..5b3d652 100644 --- a/docs/schemas/domaincommon.rng +++ b/docs/schemas/domaincommon.rng @@ -583,6 +583,31 @@ </optional> <optional> + <element name="vcpus"> + <zeroOrMore> + <element name="vcpu"> + <attribute name="id"> + <ref name="unsignedInt"/> + </attribute> + <attribute name="enabled"> + <ref name="virYesNo"/> + </attribute> + <optional> + <attribute name="hotpluggable"> + <ref name="virYesNo"/> + </attribute> + </optional> + <optional> + <attribute name="order"> + <ref name="unsignedInt"/> + </attribute> + </optional> + </element> + </zeroOrMore> + </element> + </optional> + + <optional> <element name="iothreads"> <ref name="unsignedInt"/> </element> diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index 14d4f7d..df2e53f 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -4332,6 +4332,13 @@ virDomainDefPostParseCheckFeatures(virDomainDefPtr def, } } + if (UNSUPPORTED(VIR_DOMAIN_DEF_FEATURE_INDIVIDUAL_VCPUS) && + def->individualvcpus) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("individual CPU state configuration is not supported")); + return -1; + } + return 0; } @@ -4406,6 +4413,43 @@ virDomainDefPostParseDeviceIterator(virDomainDefPtr def, static int +virDomainVcpuDefPostParse(virDomainDefPtr def) +{ + virDomainVcpuDefPtr vcpu; + size_t maxvcpus = virDomainDefGetVcpusMax(def); + size_t i; + + for (i = 0; i < maxvcpus; i++) { + vcpu = virDomainDefGetVcpu(def, i); + + switch (vcpu->hotpluggable) { + case VIR_TRISTATE_BOOL_ABSENT: + if (vcpu->online) + vcpu->hotpluggable = VIR_TRISTATE_BOOL_NO; + else + vcpu->hotpluggable = VIR_TRISTATE_BOOL_YES; + break; + + case VIR_TRISTATE_BOOL_NO: + if (!vcpu->online) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, + _("vcpu '%zu' is both offline and not " + "hotpluggable"), i); + return -1; + } + break; + + case VIR_TRISTATE_BOOL_YES: + case VIR_TRISTATE_BOOL_LAST: + break; + } + } + + return 0; +} + + +static int virDomainDefPostParseInternal(virDomainDefPtr def, struct virDomainDefPostParseDeviceIteratorData *data) { @@ -4416,6 +4460,9 @@ virDomainDefPostParseInternal(virDomainDefPtr def, return -1; } + if (virDomainVcpuDefPostParse(def) < 0) + return -1; + if (virDomainDefPostParseMemory(def, data->parseFlags) < 0) return -1; @@ -15521,6 +15568,8 @@ virDomainVcpuParse(virDomainDefPtr def, virDomainXMLOptionPtr xmlopt) { int n; + xmlNodePtr *nodes = NULL; + size_t i; char *tmp = NULL; unsigned int maxvcpus; unsigned int vcpus; @@ -15549,8 +15598,6 @@ virDomainVcpuParse(virDomainDefPtr def, vcpus = maxvcpus; } - if (virDomainDefSetVcpus(def, vcpus) < 0) - goto cleanup; tmp = virXPathString("string(./vcpu[1]/@placement)", ctxt); if (tmp) { @@ -15582,9 +15629,80 @@ virDomainVcpuParse(virDomainDefPtr def, } } + if ((n = virXPathNodeSet("./vcpus/vcpu", ctxt, &nodes)) < 0) + goto cleanup; + + if (n) { + /* if individual vcpu states are provided take them as master */ + def->individualvcpus = true; + + for (i = 0; i < n; i++) { + virDomainVcpuDefPtr vcpu; + int state; + unsigned int id; + unsigned int order; + + if (!(tmp = virXMLPropString(nodes[i], "id")) || + virStrToLong_uip(tmp, NULL, 10, &id) < 0) { + virReportError(VIR_ERR_XML_ERROR, "%s", + _("missing or invalid vcpu id")); + goto cleanup; + } + + VIR_FREE(tmp); + + if (id >= def->maxvcpus) { + virReportError(VIR_ERR_XML_ERROR, + _("vcpu id '%u' is out of range of maximum " + "vcpu count"), id); + goto cleanup; + } + + vcpu = virDomainDefGetVcpu(def, id); + + if (!(tmp = virXMLPropString(nodes[i], "enabled"))) { + virReportError(VIR_ERR_XML_ERROR, "%s", + _("missing vcpu enabled state")); + goto cleanup; + } + + if ((state = virTristateBoolTypeFromString(tmp)) < 0) { + virReportError(VIR_ERR_XML_ERROR, + _("invalid vcpu 'enabled' value '%s'"), tmp); + goto cleanup; + } + VIR_FREE(tmp); + + vcpu->online = state == VIR_TRISTATE_BOOL_YES; + + if ((tmp = virXMLPropString(nodes[i], "hotpluggable"))) { + if ((vcpu->hotpluggable = virTristateBoolTypeFromString(tmp)) < 0) { + virReportError(VIR_ERR_XML_ERROR, + _("invalid vcpu 'hotpluggable' value '%s'"), tmp); + goto cleanup; + } + VIR_FREE(tmp); + } + + if ((tmp = virXMLPropString(nodes[i], "order"))) { + if (virStrToLong_uip(tmp, NULL, 10, &order) < 0) { + virReportError(VIR_ERR_XML_ERROR, "%s", + _("invalid vcpu order")); + goto cleanup; + } + vcpu->order = order; + VIR_FREE(tmp); + } + } + } else { + if (virDomainDefSetVcpus(def, vcpus) < 0) + goto cleanup; + } + ret = 0; cleanup: + VIR_FREE(nodes); VIR_FREE(tmp); return ret; @@ -18642,6 +18760,13 @@ virDomainDefVcpuCheckAbiStability(virDomainDefPtr src, "destination definitions"), i); return false; } + + if (svcpu->order != dvcpu->order) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, + _("vcpu enable order of vCPU '%zu' differs between " + "source and destination definitions"), i); + return false; + } } return true; @@ -22946,6 +23071,8 @@ static int virDomainCpuDefFormat(virBufferPtr buf, const virDomainDef *def) { + virDomainVcpuDefPtr vcpu; + size_t i; char *cpumask = NULL; int ret = -1; @@ -22962,6 +23089,27 @@ virDomainCpuDefFormat(virBufferPtr buf, virBufferAsprintf(buf, " current='%u'", virDomainDefGetVcpus(def)); virBufferAsprintf(buf, ">%u</vcpu>\n", virDomainDefGetVcpusMax(def)); + if (def->individualvcpus) { + virBufferAddLit(buf, "<vcpus>\n"); + virBufferAdjustIndent(buf, 2); + for (i = 0; i < def->maxvcpus; i++) { + vcpu = def->vcpus[i]; + + virBufferAsprintf(buf, "<vcpu id='%zu' enabled='%s'", + i, vcpu->online ? "yes" : "no"); + if (vcpu->hotpluggable) + virBufferAsprintf(buf, " hotpluggable='%s'", + virTristateBoolTypeToString(vcpu->hotpluggable)); + + if (vcpu->order != 0) + virBufferAsprintf(buf, " order='%d'", vcpu->order); + + virBufferAddLit(buf, "/>\n"); + } + virBufferAdjustIndent(buf, -2); + virBufferAddLit(buf, "</vcpus>\n"); + } + ret = 0; cleanup: diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h index 8b26724..b889125 100644 --- a/src/conf/domain_conf.h +++ b/src/conf/domain_conf.h @@ -2046,6 +2046,9 @@ typedef virDomainVcpuDef *virDomainVcpuDefPtr; struct _virDomainVcpuDef { bool online; + virTristateBool hotpluggable; + unsigned int order; + virBitmapPtr cpumask; virDomainThreadSchedParam sched; @@ -2142,6 +2145,8 @@ struct _virDomainDef { virDomainVcpuDefPtr *vcpus; size_t maxvcpus; + /* set if the vcpu definition was specified individually */ + bool individualvcpus; int placement_mode; virBitmapPtr cpumask; @@ -2344,6 +2349,7 @@ typedef enum { VIR_DOMAIN_DEF_FEATURE_MEMORY_HOTPLUG = (1 << 1), VIR_DOMAIN_DEF_FEATURE_OFFLINE_VCPUPIN = (1 << 2), VIR_DOMAIN_DEF_FEATURE_NAME_SLASH = (1 << 3), + VIR_DOMAIN_DEF_FEATURE_INDIVIDUAL_VCPUS = (1 << 4), } virDomainDefFeatures; diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c index d4f472b..5f4c642 100644 --- a/src/qemu/qemu_domain.c +++ b/src/qemu/qemu_domain.c @@ -5846,8 +5846,17 @@ qemuDomainRefreshVcpuInfo(virQEMUDriverPtr driver, VIR_STEAL_PTR(vcpupriv->alias, info[i].alias); vcpupriv->enable_id = info[i].id; - if (hotplug && state) + if (hotplug && state) { vcpu->online = !!info[i].qom_path; + + /* mark cpus that don't have an alias as non-hotpluggable */ + if (vcpu->online) { + if (vcpupriv->alias) + vcpu->hotpluggable = VIR_TRISTATE_BOOL_YES; + else + vcpu->hotpluggable = VIR_TRISTATE_BOOL_NO; + } + } } ret = 0; diff --git a/tests/genericxml2xmlindata/generic-vcpus-individual.xml b/tests/genericxml2xmlindata/generic-vcpus-individual.xml new file mode 100644 index 0000000..cbcf8fd --- /dev/null +++ b/tests/genericxml2xmlindata/generic-vcpus-individual.xml @@ -0,0 +1,23 @@ +<domain type='qemu'> + <name>foobar</name> + <uuid>c7a5fdbd-edaf-9455-926a-d65c16db1809</uuid> + <memory unit='KiB'>219136</memory> + <currentMemory unit='KiB'>219136</currentMemory> + <vcpu placement='static' current='2'>4</vcpu> + <vcpus> + <vcpu id='0' enabled='no' hotpluggable='yes' order='1'/> + <vcpu id='1' enabled='yes' hotpluggable='no'/> + <vcpu id='2' enabled='no' hotpluggable='yes' order='2'/> + <vcpu id='3' enabled='yes' hotpluggable='no'/> + </vcpus> + <os> + <type arch='i686' machine='pc'>hvm</type> + <boot dev='hd'/> + </os> + <clock offset='utc'/> + <on_poweroff>destroy</on_poweroff> + <on_reboot>restart</on_reboot> + <on_crash>destroy</on_crash> + <devices> + </devices> +</domain> diff --git a/tests/genericxml2xmltest.c b/tests/genericxml2xmltest.c index a487727..2ea2396 100644 --- a/tests/genericxml2xmltest.c +++ b/tests/genericxml2xmltest.c @@ -97,6 +97,8 @@ mymain(void) DO_TEST("perf"); + DO_TEST("vcpus-individual"); + virObjectUnref(caps); virObjectUnref(xmlopt); diff --git a/tests/testutils.c b/tests/testutils.c index 8af8707..8ea6ab8 100644 --- a/tests/testutils.c +++ b/tests/testutils.c @@ -1089,7 +1089,9 @@ virCapsPtr virTestGenericCapsInit(void) return NULL; } -static virDomainDefParserConfig virTestGenericDomainDefParserConfig; +static virDomainDefParserConfig virTestGenericDomainDefParserConfig = { + .features = VIR_DOMAIN_DEF_FEATURE_INDIVIDUAL_VCPUS, +}; static virDomainXMLPrivateDataCallbacks virTestGenericPrivateDataCallbacks; virDomainXMLOptionPtr virTestGenericDomainXMLConfInit(void) -- 2.8.2

For use on the monitor we need to format certain parts of the vcpu private definition into a JSON object. Add a helper. --- Notes: v2: - already ACKed src/qemu/qemu_command.c | 30 ++++++++++++++++++++++++++++++ src/qemu/qemu_command.h | 3 +++ 2 files changed, 33 insertions(+) diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c index a6dea6a..28e5a7e 100644 --- a/src/qemu/qemu_command.c +++ b/src/qemu/qemu_command.c @@ -9799,3 +9799,33 @@ qemuBuildChrDeviceStr(char **deviceStr, return ret; } + + +virJSONValuePtr +qemuBuildHotpluggableCPUProps(const virDomainVcpuDef *vcpu) +{ + qemuDomainVcpuPrivatePtr vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpu); + virJSONValuePtr ret = NULL; + + if (virJSONValueObjectCreate(&ret, "s:driver", vcpupriv->type, + "s:id", vcpupriv->alias, NULL) < 0) + goto error; + + if (vcpupriv->socket_id != -1 && + virJSONValueObjectAdd(ret, "i:socket-id", vcpupriv->socket_id, NULL) < 0) + goto error; + + if (vcpupriv->core_id != -1 && + virJSONValueObjectAdd(ret, "i:core-id", vcpupriv->core_id, NULL) < 0) + goto error; + + if (vcpupriv->thread_id != -1 && + virJSONValueObjectAdd(ret, "i:thread-id", vcpupriv->thread_id, NULL) < 0) + goto error; + + return ret; + + error: + virJSONValueFree(ret); + return NULL; +} diff --git a/src/qemu/qemu_command.h b/src/qemu/qemu_command.h index dcf9ba6..9b9ccb6 100644 --- a/src/qemu/qemu_command.h +++ b/src/qemu/qemu_command.h @@ -179,4 +179,7 @@ bool qemuCheckCCWS390AddressSupport(const virDomainDef *def, virQEMUCapsPtr qemuCaps, const char *devicename); +virJSONValuePtr qemuBuildHotpluggableCPUProps(const virDomainVcpuDef *vcpu) + ATTRIBUTE_NONNULL(1); + #endif /* __QEMU_COMMAND_H__*/ -- 2.8.2

Add support for using the new approach to hotplug vcpus using device_add during startup of qemu to allow sparse vcpu topologies. There are a few limitations imposed by qemu on the supported configuration: - vcpu0 needs to be always present and not hotpluggable - non-hotpluggable cpus need to be ordered at the beginning - order of the vcpus needs to be unique for every single hotpluggable entity Qemu also doesn't really allow to query the information necessary to start a VM with the vcpus directly on the commandline. Fortunately they can be hotplugged during startup. The new hotplug code uses the following approach: - non-hotpluggable vcpus are counted and put to the -smp option - qemu is started - qemu is queried for the necessary information - the configuration is checked - the hotpluggable vcpus are hotplugged - vcpus are started This patch adds a lot of checking code and enables the support to specify the individual vcpu element with qemu. --- src/qemu/qemu_command.c | 20 ++- src/qemu/qemu_domain.c | 76 ++++++++- src/qemu/qemu_process.c | 173 +++++++++++++++++++++ .../qemuxml2argv-cpu-hotplug-startup.args | 20 +++ .../qemuxml2argv-cpu-hotplug-startup.xml | 29 ++++ tests/qemuxml2argvtest.c | 2 + 6 files changed, 315 insertions(+), 5 deletions(-) create mode 100644 tests/qemuxml2argvdata/qemuxml2argv-cpu-hotplug-startup.args create mode 100644 tests/qemuxml2argvdata/qemuxml2argv-cpu-hotplug-startup.xml diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c index 28e5a7e..c1dc390 100644 --- a/src/qemu/qemu_command.c +++ b/src/qemu/qemu_command.c @@ -7082,17 +7082,29 @@ qemuBuildMachineCommandLine(virCommandPtr cmd, static int qemuBuildSmpCommandLine(virCommandPtr cmd, - const virDomainDef *def) + virDomainDefPtr def) { char *smp; virBuffer buf = VIR_BUFFER_INITIALIZER; + unsigned int maxvcpus = virDomainDefGetVcpusMax(def); + unsigned int nvcpus = 0; + virDomainVcpuDefPtr vcpu; + size_t i; + + /* count un-hotpluggable enabled vcpus. Hotpluggable ones will be added + * in a different way */ + for (i = 0; i < maxvcpus; i++) { + vcpu = virDomainDefGetVcpu(def, i); + if (vcpu->online && vcpu->hotpluggable == VIR_TRISTATE_BOOL_NO) + nvcpus++; + } virCommandAddArg(cmd, "-smp"); - virBufferAsprintf(&buf, "%u", virDomainDefGetVcpus(def)); + virBufferAsprintf(&buf, "%u", nvcpus); - if (virDomainDefHasVcpusOffline(def)) - virBufferAsprintf(&buf, ",maxcpus=%u", virDomainDefGetVcpusMax(def)); + if (nvcpus != maxvcpus) + virBufferAsprintf(&buf, ",maxcpus=%u", 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) { diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c index aa93498..1602824 100644 --- a/src/qemu/qemu_domain.c +++ b/src/qemu/qemu_domain.c @@ -2253,6 +2253,76 @@ qemuDomainRecheckInternalPaths(virDomainDefPtr def, static int +qemuDomainDefVcpusPostParse(virDomainDefPtr def) +{ + unsigned int maxvcpus = virDomainDefGetVcpusMax(def); + virDomainVcpuDefPtr vcpu; + virDomainVcpuDefPtr prevvcpu; + size_t i; + bool has_order = false; + + /* vcpu 0 needs to be present, first, and non-hotpluggable */ + vcpu = virDomainDefGetVcpu(def, 0); + if (!vcpu->online) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("vcpu 0 can't be offline")); + return -1; + } + if (vcpu->hotpluggable == VIR_TRISTATE_BOOL_YES) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("vcpu0 can't be hotpluggable")); + return -1; + } + if (vcpu->order != 0 && vcpu->order != 1) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("vcpu0 must be enabled first")); + return -1; + } + + if (vcpu->order != 0) + has_order = true; + + prevvcpu = vcpu; + + /* all online vcpus or no online vcpu need to have order set */ + for (i = 1; i < maxvcpus; i++) { + vcpu = virDomainDefGetVcpu(def, i); + + if (vcpu->online && + (vcpu->order != 0) != has_order) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("all vcpus must have either set or unset order")); + return -1; + } + + /* few conditions for non-hotpluggable (thus onine) vcpus */ + if (vcpu->hotpluggable == VIR_TRISTATE_BOOL_NO) { + /* they can be ordered only at the beinning */ + if (prevvcpu->hotpluggable == VIR_TRISTATE_BOOL_YES) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("online non-hotpluggable vcpus need to be at " + "the beginning")); + return -1; + } + + /* they need to be in order (qemu doesn't support any order yet). + * Also note that multiple vcpus may share order on some platforms */ + if (prevvcpu->order > vcpu->order) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("online non-hotpluggable vcpus must be ordered " + "in ascending order")); + return -1; + } + } + + prevvcpu = vcpu; + } + + return 0; +} + + +static int qemuDomainDefPostParse(virDomainDefPtr def, virCapsPtr caps, unsigned int parseFlags, @@ -2307,6 +2377,9 @@ qemuDomainDefPostParse(virDomainDefPtr def, if (virSecurityManagerVerify(driver->securityManager, def) < 0) goto cleanup; + if (qemuDomainDefVcpusPostParse(def) < 0) + goto cleanup; + ret = 0; cleanup: virObjectUnref(qemuCaps); @@ -2709,7 +2782,8 @@ virDomainDefParserConfig virQEMUDriverDomainDefParserConfig = { .deviceValidateCallback = qemuDomainDeviceDefValidate, .features = VIR_DOMAIN_DEF_FEATURE_MEMORY_HOTPLUG | - VIR_DOMAIN_DEF_FEATURE_OFFLINE_VCPUPIN + VIR_DOMAIN_DEF_FEATURE_OFFLINE_VCPUPIN | + VIR_DOMAIN_DEF_FEATURE_INDIVIDUAL_VCPUS, }; diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index f3915a5..c31d2ad 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -4760,6 +4760,167 @@ qemuProcessSetupIOThreads(virDomainObjPtr vm) } +static int +qemuProcessValidateHotpluggableVcpus(virDomainDefPtr def) +{ + virDomainVcpuDefPtr vcpu; + virDomainVcpuDefPtr subvcpu; + qemuDomainVcpuPrivatePtr vcpupriv; + unsigned int maxvcpus = virDomainDefGetVcpusMax(def); + size_t i = 0; + size_t j; + virBitmapPtr ordermap = NULL; + int ret = -1; + + if (!(ordermap = virBitmapNew(maxvcpus))) + goto cleanup; + + /* validate: + * - all hotpluggable entities to be hotplugged have the correct data + * - vcpus belonging to a hotpluggable entity share configuration + * - order of the hotpluggable entities is unique + */ + for (i = 0; i < maxvcpus; i++) { + vcpu = virDomainDefGetVcpu(def, i); + vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpu); + + /* skip over hotpluggable entities */ + if (vcpupriv->vcpus == 0) + continue; + + if (vcpu->order != 0) { + if (virBitmapIsBitSet(ordermap, vcpu->order - 1)) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, + _("duplicate vcpu order '%u'"), vcpu->order - 1); + goto cleanup; + } + + ignore_value(virBitmapSetBit(ordermap, vcpu->order - 1)); + } + + + for (j = i + 1; j < (i + vcpupriv->vcpus); j++) { + subvcpu = virDomainDefGetVcpu(def, j); + if (subvcpu->hotpluggable != vcpu->hotpluggable || + subvcpu->online != vcpu->online || + subvcpu->order != vcpu->order) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, + _("vcpus '%zu' and '%zu' are in the same hotplug " + "group but differ in configuration"), i, j); + goto cleanup; + } + } + + if (vcpu->online && vcpu->hotpluggable == VIR_TRISTATE_BOOL_YES) { + if ((vcpupriv->socket_id == -1 && vcpupriv->core_id == -1 && + vcpupriv->thread_id == -1) || + !vcpupriv->type) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, + _("vcpu '%zu' is missing hotplug data"), i); + goto cleanup; + } + } + } + + ret = 0; + cleanup: + virBitmapFree(ordermap); + return ret; +} + + +static int +qemuDomainHasHotpluggableStartupVcpus(virDomainDefPtr def) +{ + size_t maxvcpus = virDomainDefGetVcpusMax(def); + virDomainVcpuDefPtr vcpu; + size_t i; + + for (i = 0; i < maxvcpus; i++) { + vcpu = virDomainDefGetVcpu(def, i); + + if (vcpu->online && vcpu->hotpluggable == VIR_TRISTATE_BOOL_YES) + return true; + } + + return false; +} + + +static int +qemuProcessVcpusSortOrder(const void *a, + const void *b) +{ + const virDomainVcpuDef *vcpua = a; + const virDomainVcpuDef *vcpub = b; + + return vcpua->order - vcpub->order; +} + + +static int +qemuProcessSetupHotpluggableVcpus(virQEMUDriverPtr driver, + virDomainObjPtr vm, + qemuDomainAsyncJob asyncJob) +{ + unsigned int maxvcpus = virDomainDefGetVcpusMax(vm->def); + virDomainVcpuDefPtr vcpu; + qemuDomainVcpuPrivatePtr vcpupriv; + virJSONValuePtr vcpuprops = NULL; + size_t i; + int ret = -1; + int rc; + + virDomainVcpuDefPtr *bootHotplug = NULL; + size_t nbootHotplug = 0; + + for (i = 0; i < maxvcpus; i++) { + vcpu = virDomainDefGetVcpu(vm->def, i); + vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpu); + + if (vcpu->hotpluggable == VIR_TRISTATE_BOOL_YES && vcpu->online && + vcpupriv->vcpus != 0) { + if (virAsprintf(&vcpupriv->alias, "vcpu%zu", i) < 0) + goto cleanup; + + if (VIR_APPEND_ELEMENT(bootHotplug, nbootHotplug, vcpu) < 0) + goto cleanup; + } + } + + qsort(bootHotplug, nbootHotplug, sizeof(*bootHotplug), + qemuProcessVcpusSortOrder); + + for (i = 0; i < nbootHotplug; i++) { + vcpu = bootHotplug[i]; + + if (!(vcpuprops = qemuBuildHotpluggableCPUProps(vcpu))) + goto cleanup; + + if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) + goto cleanup; + + rc = qemuMonitorAddDeviceArgs(qemuDomainGetMonitor(vm), vcpuprops); + vcpuprops = NULL; + + if (qemuDomainObjExitMonitor(driver, vm) < 0) + goto cleanup; + + if (rc < 0) + goto cleanup; + + virJSONValueFree(vcpuprops); + } + + ret = 0; + + cleanup: + VIR_FREE(bootHotplug); + virJSONValueFree(vcpuprops); + return ret; +} + + /** * qemuProcessPrepareDomain * @@ -5236,6 +5397,18 @@ qemuProcessLaunch(virConnectPtr conn, if (qemuSetupCpusetMems(vm) < 0) goto cleanup; + VIR_DEBUG("setting up hotpluggable cpus"); + if (qemuDomainHasHotpluggableStartupVcpus(vm->def)) { + if (qemuDomainRefreshVcpuInfo(driver, vm, asyncJob, false) < 0) + goto cleanup; + + if (qemuProcessValidateHotpluggableVcpus(vm->def) < 0) + goto cleanup; + + if (qemuProcessSetupHotpluggableVcpus(driver, vm, asyncJob) < 0) + goto cleanup; + } + VIR_DEBUG("Refreshing VCPU info"); if (qemuDomainRefreshVcpuInfo(driver, vm, asyncJob, false) < 0) goto cleanup; diff --git a/tests/qemuxml2argvdata/qemuxml2argv-cpu-hotplug-startup.args b/tests/qemuxml2argvdata/qemuxml2argv-cpu-hotplug-startup.args new file mode 100644 index 0000000..035f250 --- /dev/null +++ b/tests/qemuxml2argvdata/qemuxml2argv-cpu-hotplug-startup.args @@ -0,0 +1,20 @@ +LC_ALL=C \ +PATH=/bin \ +HOME=/home/test \ +USER=test \ +LOGNAME=test \ +QEMU_AUDIO_DRV=none \ +/usr/bin/qemu \ +-name QEMUGuest1 \ +-S \ +-M pc \ +-m 214 \ +-smp 1,maxcpus=6,sockets=3,cores=2,threads=1 \ +-uuid c7a5fdbd-edaf-9455-926a-d65c16db1809 \ +-nographic \ +-nodefaults \ +-monitor unix:/tmp/lib/domain--1-QEMUGuest1/monitor.sock,server,nowait \ +-no-acpi \ +-boot n \ +-usb \ +-device virtio-balloon-pci,id=balloon0,bus=pci.0,addr=0x3 diff --git a/tests/qemuxml2argvdata/qemuxml2argv-cpu-hotplug-startup.xml b/tests/qemuxml2argvdata/qemuxml2argv-cpu-hotplug-startup.xml new file mode 100644 index 0000000..58718aa --- /dev/null +++ b/tests/qemuxml2argvdata/qemuxml2argv-cpu-hotplug-startup.xml @@ -0,0 +1,29 @@ +<domain type='qemu'> + <name>QEMUGuest1</name> + <uuid>c7a5fdbd-edaf-9455-926a-d65c16db1809</uuid> + <memory unit='KiB'>219100</memory> + <currentMemory unit='KiB'>219100</currentMemory> + <vcpu placement='static' current='3'>6</vcpu> + <vcpus> + <vcpu id='0' enabled='yes' hotpluggable='no' order='1'/> + <vcpu id='1' enabled='no' hotpluggable='yes'/> + <vcpu id='2' enabled='no' hotpluggable='yes'/> + <vcpu id='3' enabled='no' hotpluggable='yes'/> + <vcpu id='4' enabled='yes' hotpluggable='yes' order='2'/> + <vcpu id='5' enabled='yes' hotpluggable='yes' order='3'/> + </vcpus> + <os> + <type arch='x86_64' machine='pc'>hvm</type> + <boot dev='network'/> + </os> + <cpu> + <topology sockets="3" cores="2" threads="1"/> + </cpu> + <clock offset='utc'/> + <on_poweroff>destroy</on_poweroff> + <on_reboot>restart</on_reboot> + <on_crash>destroy</on_crash> + <devices> + <emulator>/usr/bin/qemu</emulator> + </devices> +</domain> diff --git a/tests/qemuxml2argvtest.c b/tests/qemuxml2argvtest.c index e8b8cb4..39abe72 100644 --- a/tests/qemuxml2argvtest.c +++ b/tests/qemuxml2argvtest.c @@ -2106,6 +2106,8 @@ mymain(void) DO_TEST("intel-iommu", QEMU_CAPS_DEVICE_PCI_BRIDGE, QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE, QEMU_CAPS_DEVICE_INTEL_IOMMU); + DO_TEST("cpu-hotplug-startup", QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS); + qemuTestDriverFree(&driver); return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE; -- 2.8.2

To allow unplugging the vcpus, hotplugging of vcpus on platforms which require to plug multiple logical vcpus at once or pluging them in in arbitrary order it's necessary to use the new device_add interface for vcpu hotplug. This patch adds support for the device_add interface using the old setvcpus API by implementing an algorihm to select the appropriate entities to plug in. --- src/qemu/qemu_driver.c | 155 +++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 138 insertions(+), 17 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index d083e46..2f88d23 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -4594,46 +4594,66 @@ qemuDomainHotplugAddVcpu(virQEMUDriverPtr driver, virDomainObjPtr vm, unsigned int vcpu) { - qemuDomainObjPrivatePtr priv = vm->privateData; + virJSONValuePtr vcpuprops = NULL; virDomainVcpuDefPtr vcpuinfo = virDomainDefGetVcpu(vm->def, vcpu); qemuDomainVcpuPrivatePtr vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpuinfo); + unsigned int nvcpus = vcpupriv->vcpus; + bool newhotplug = qemuDomainSupportsNewVcpuHotplug(vm); int ret = -1; int rc; int oldvcpus = virDomainDefGetVcpus(vm->def); + size_t i; - if (vcpuinfo->online) { - virReportError(VIR_ERR_INVALID_ARG, - _("vCPU '%u' is already online"), vcpu); - return -1; + if (newhotplug) { + if (virAsprintf(&vcpupriv->alias, "vcpu%u", vcpu) < 0) + goto cleanup; + + if (!(vcpuprops = qemuBuildHotpluggableCPUProps(vcpuinfo))) + goto cleanup; } qemuDomainObjEnterMonitor(driver, vm); - rc = qemuMonitorSetCPU(priv->mon, vcpu, true); + if (newhotplug) { + rc = qemuMonitorAddDeviceArgs(qemuDomainGetMonitor(vm), vcpuprops); + vcpuprops = NULL; + } else { + rc = qemuMonitorSetCPU(qemuDomainGetMonitor(vm), vcpu, true); + } if (qemuDomainObjExitMonitor(driver, vm) < 0) goto cleanup; - virDomainAuditVcpu(vm, oldvcpus, oldvcpus + 1, "update", rc == 0); + virDomainAuditVcpu(vm, oldvcpus, oldvcpus + nvcpus, "update", rc == 0); if (rc < 0) goto cleanup; - vcpuinfo->online = true; + /* start outputing of the new XML element to allow keeping unpluggability */ + if (newhotplug) + vm->def->individualvcpus = true; if (qemuDomainRefreshVcpuInfo(driver, vm, QEMU_ASYNC_JOB_NONE, false) < 0) goto cleanup; - if (qemuDomainValidateVcpuInfo(vm) < 0) - goto cleanup; + for (i = vcpu; i < vcpu + nvcpus; i++) { + vcpuinfo = virDomainDefGetVcpu(vm->def, i); + vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpuinfo); + + vcpuinfo->online = true; - if (vcpupriv->tid > 0 && - qemuProcessSetupVcpu(vm, vcpu) < 0) + if (vcpupriv->tid > 0 && + qemuProcessSetupVcpu(vm, i) < 0) + goto cleanup; + } + + if (qemuDomainValidateVcpuInfo(vm) < 0) goto cleanup; ret = 0; cleanup: + virJSONValueFree(vcpuprops); return ret; } @@ -4771,6 +4791,95 @@ qemuDomainSetVcpusMax(virQEMUDriverPtr driver, } +/** + * qemuDomainSelectHotplugVcpuEntities: + * + * @def: domain definition + * @nvcpus: target vcpu count + * @cpumap: vcpu entity IDs filled on success + * + * Tries to find which vcpu entities need to be enabled or disabled to reach + * @nvcpus. This function works in order of the legacy hotplug but is able to + * skip over entries that are added out of order. + */ +static virBitmapPtr +qemuDomainSelectHotplugVcpuEntities(virDomainDefPtr def, + unsigned int nvcpus) +{ + virBitmapPtr ret = NULL; + virDomainVcpuDefPtr vcpu; + qemuDomainVcpuPrivatePtr vcpupriv; + unsigned int maxvcpus = virDomainDefGetVcpusMax(def); + unsigned int curvcpus = virDomainDefGetVcpus(def); + ssize_t i; + + if (!(ret = virBitmapNew(maxvcpus))) + return NULL; + + if (nvcpus > curvcpus) { + for (i = 0; i < maxvcpus && curvcpus < nvcpus; i++) { + vcpu = virDomainDefGetVcpu(def, i); + vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpu); + + if (vcpu->online) + continue; + + if (vcpupriv->vcpus == 0) + continue; + + curvcpus += vcpupriv->vcpus; + + if (curvcpus > nvcpus) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("target vm vcpu granularity does not allow the " + "desired vcpu count")); + goto error; + } + + ignore_value(virBitmapSetBit(ret, i)); + } + } else { + for (i = maxvcpus - 1; i >= 0 && curvcpus > nvcpus; i--) { + vcpu = virDomainDefGetVcpu(def, i); + vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpu); + + if (!vcpu->online) + continue; + + if (vcpupriv->vcpus == 0) + continue; + + if (!vcpupriv->alias) + continue; + + curvcpus -= vcpupriv->vcpus; + + if (curvcpus < nvcpus) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("target vm vcpu granularity does not allow the " + "desired vcpu count")); + goto error; + } + + ignore_value(virBitmapSetBit(ret, i)); + } + } + + if (curvcpus != nvcpus) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("failed to find appropriate hotpluggable vcpus to " + "reach the desired target vcpu count")); + goto error; + } + + return ret; + + error: + virBitmapFree(ret); + return NULL; +} + + static int qemuDomainSetVcpusLive(virQEMUDriverPtr driver, virQEMUDriverConfigPtr cfg, @@ -4784,8 +4893,14 @@ qemuDomainSetVcpusLive(virQEMUDriverPtr driver, char *all_nodes_str = NULL; virBitmapPtr all_nodes = NULL; virErrorPtr err = NULL; + virBitmapPtr vcpumap = NULL; + ssize_t nextvcpu = -1; + int rc = 0; int ret = -1; + if (!(vcpumap = qemuDomainSelectHotplugVcpuEntities(vm->def, nvcpus))) + goto cleanup; + if (virNumaIsAvailable() && virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPUSET)) { if (virCgroupNewThread(priv->cgroup, VIR_CGROUP_THREAD_EMULATOR, 0, @@ -4804,20 +4919,25 @@ qemuDomainSetVcpusLive(virQEMUDriverPtr driver, } if (nvcpus > virDomainDefGetVcpus(vm->def)) { - for (i = virDomainDefGetVcpus(vm->def); i < nvcpus; i++) { - if (qemuDomainHotplugAddVcpu(driver, vm, i) < 0) - goto cleanup; + while ((nextvcpu = virBitmapNextSetBit(vcpumap, nextvcpu)) != -1) { + if ((rc = qemuDomainHotplugAddVcpu(driver, vm, nextvcpu)) < 0) + break; } } else { for (i = virDomainDefGetVcpus(vm->def) - 1; i >= nvcpus; i--) { - if (qemuDomainHotplugDelVcpu(driver, vm, i) < 0) - goto cleanup; + if ((rc = qemuDomainHotplugDelVcpu(driver, vm, i)) < 0) + break; } } + qemuDomainVcpuPersistOrder(vm->def); + if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm, driver->caps) < 0) goto cleanup; + if (rc < 0) + goto cleanup; + ret = 0; cleanup: @@ -4832,6 +4952,7 @@ qemuDomainSetVcpusLive(virQEMUDriverPtr driver, VIR_FREE(all_nodes_str); virBitmapFree(all_nodes); virCgroupFree(&cgroup_temp); + virBitmapFree(vcpumap); return ret; } -- 2.8.2

Add a overlay function that takes the alias directly rather than extracting it from a device info. --- src/qemu/qemu_hotplug.c | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/src/qemu/qemu_hotplug.c b/src/qemu/qemu_hotplug.c index 00e4a75..31ef22f 100644 --- a/src/qemu/qemu_hotplug.c +++ b/src/qemu/qemu_hotplug.c @@ -3529,8 +3529,8 @@ qemuDomainRemoveDevice(virQEMUDriverPtr driver, static void -qemuDomainMarkDeviceForRemoval(virDomainObjPtr vm, - virDomainDeviceInfoPtr info) +qemuDomainMarkDeviceAliasForRemoval(virDomainObjPtr vm, + const char *alias) { qemuDomainObjPrivatePtr priv = vm->privateData; @@ -3539,9 +3539,19 @@ qemuDomainMarkDeviceForRemoval(virDomainObjPtr vm, if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE_DEL_EVENT)) return; - priv->unplug.alias = info->alias; + priv->unplug.alias = alias; } + +static void +qemuDomainMarkDeviceForRemoval(virDomainObjPtr vm, + virDomainDeviceInfoPtr info) + +{ + qemuDomainMarkDeviceAliasForRemoval(vm, info->alias); +} + + static void qemuDomainResetDeviceRemoval(virDomainObjPtr vm) { -- 2.8.2