The "cmd" argument in cmdList is now used. Unmark it as unused. --- tools/virsh-domain-monitor.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/virsh-domain-monitor.c b/tools/virsh-domain-monitor.c index 5ed89d1..936fa8e 100644 --- a/tools/virsh-domain-monitor.c +++ b/tools/virsh-domain-monitor.c @@ -1689,7 +1689,7 @@ static const vshCmdOptDef opts_list[] = { if (vshCommandOptBool(cmd, NAME)) \ flags |= (FLAG) static bool -cmdList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED) +cmdList(vshControl *ctl, const vshCmd *cmd) { bool managed = vshCommandOptBool(cmd, "managed-save"); bool optTitle = vshCommandOptBool(cmd, "title"); -- 1.8.2.1

The qemu monitor provides more information about vCPUs of a guest than we needed currently. This patch upgrades the extraction function to easily extract new data about the vCPUs and fixes code to cope with the new structure. The information extracted here will be later used for mapping of vCPUs of a guest. This patch also refactors the function used to parse data from the text monitor. --- src/qemu/qemu_driver.c | 31 ++++++++------- src/qemu/qemu_monitor.c | 9 +++-- src/qemu/qemu_monitor.h | 11 +++++- src/qemu/qemu_monitor_json.c | 47 +++++++++++++--------- src/qemu/qemu_monitor_json.h | 2 +- src/qemu/qemu_monitor_text.c | 92 +++++++++++++++++++++++++------------------- src/qemu/qemu_monitor_text.h | 2 +- src/qemu/qemu_process.c | 63 ++++++++++++++++++++---------- 8 files changed, 159 insertions(+), 98 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 4a4f8d3..0041d8f 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -3522,8 +3522,8 @@ static int qemuDomainHotplugVcpus(virQEMUDriverPtr driver, int ret = -1; int oldvcpus = vm->def->vcpus; int vcpus = oldvcpus; - pid_t *cpupids = NULL; - int ncpupids; + qemuMonitorCPUInfoPtr cpuinfo = NULL; + int ncpuinfo; virCgroupPtr cgroup_vcpu = NULL; qemuDomainObjEnterMonitor(driver, vm); @@ -3564,13 +3564,13 @@ static int qemuDomainHotplugVcpus(virQEMUDriverPtr driver, * or don't have the "info cpus" command (and they don't support multiple * CPUs anyways), so errors in the re-detection will not be treated * fatal */ - if ((ncpupids = qemuMonitorGetCPUInfo(priv->mon, &cpupids)) <= 0) { + if ((ncpuinfo = qemuMonitorGetCPUInfo(priv->mon, &cpuinfo)) <= 0) { virResetLastError(); goto cleanup; } /* check if hotplug has failed */ - if (vcpus < oldvcpus && ncpupids == oldvcpus) { + if (vcpus < oldvcpus && ncpuinfo == oldvcpus) { virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", _("qemu didn't unplug the vCPUs properly")); vcpus = oldvcpus; @@ -3578,11 +3578,11 @@ static int qemuDomainHotplugVcpus(virQEMUDriverPtr driver, goto cleanup; } - if (ncpupids != vcpus) { + if (ncpuinfo != vcpus) { virReportError(VIR_ERR_INTERNAL_ERROR, _("got wrong number of vCPU pids from QEMU monitor. " "got %d, wanted %d"), - ncpupids, vcpus); + ncpuinfo, vcpus); ret = -1; goto cleanup; } @@ -3602,11 +3602,11 @@ static int qemuDomainHotplugVcpus(virQEMUDriverPtr driver, } /* Add vcpu thread to the cgroup */ - rv = virCgroupAddTask(cgroup_vcpu, cpupids[i]); + rv = virCgroupAddTask(cgroup_vcpu, cpuinfo[i].thread_id); if (rv < 0) { virReportSystemError(-rv, _("unable to add vcpu %d task %d to cgroup"), - i, cpupids[i]); + i, cpuinfo[i].thread_id); virCgroupRemove(cgroup_vcpu); goto cleanup; } @@ -3646,7 +3646,7 @@ static int qemuDomainHotplugVcpus(virQEMUDriverPtr driver, goto cleanup; } } else { - if (virProcessSetAffinity(cpupids[i], + if (virProcessSetAffinity(cpuinfo[i].thread_id, vcpupin->cpumask) < 0) { virReportError(VIR_ERR_SYSTEM_ERROR, _("failed to set cpu affinity for vcpu %d"), @@ -3687,15 +3687,18 @@ static int qemuDomainHotplugVcpus(virQEMUDriverPtr driver, } } - priv->nvcpupids = ncpupids; - VIR_FREE(priv->vcpupids); - priv->vcpupids = cpupids; - cpupids = NULL; + if (VIR_REALLOC_N(priv->vcpupids, ncpuinfo) < 0) { + virReportOOMError(); + goto cleanup; + } + + /* copy the thread id's */ + for (i = 0; i < ncpuinfo; i++) + priv->vcpupids[i] = cpuinfo[i].thread_id; cleanup: qemuDomainObjExitMonitor(driver, vm); vm->def->vcpus = vcpus; - VIR_FREE(cpupids); virDomainAuditVcpu(vm, oldvcpus, nvcpus, "update", rc == 1); if (cgroup_vcpu) virCgroupFree(&cgroup_vcpu); diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c index af85c29..783af2e 100644 --- a/src/qemu/qemu_monitor.c +++ b/src/qemu/qemu_monitor.c @@ -1281,8 +1281,9 @@ int qemuMonitorSystemReset(qemuMonitorPtr mon) } -int qemuMonitorGetCPUInfo(qemuMonitorPtr mon, - int **pids) +int +qemuMonitorGetCPUInfo(qemuMonitorPtr mon, + qemuMonitorCPUInfoPtr *info) { int ret; VIR_DEBUG("mon=%p", mon); @@ -1294,9 +1295,9 @@ int qemuMonitorGetCPUInfo(qemuMonitorPtr mon, } if (mon->json) - ret = qemuMonitorJSONGetCPUInfo(mon, pids); + ret = qemuMonitorJSONGetCPUInfo(mon, info); else - ret = qemuMonitorTextGetCPUInfo(mon, pids); + ret = qemuMonitorTextGetCPUInfo(mon, info); return ret; } diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h index 3d9afa3..c51fee3 100644 --- a/src/qemu/qemu_monitor.h +++ b/src/qemu/qemu_monitor.h @@ -252,8 +252,17 @@ int qemuMonitorGetStatus(qemuMonitorPtr mon, int qemuMonitorSystemReset(qemuMonitorPtr mon); int qemuMonitorSystemPowerdown(qemuMonitorPtr mon); +typedef struct _qemuMonitorCPUInfo qemuMonitorCPUInfo; +typedef qemuMonitorCPUInfo *qemuMonitorCPUInfoPtr; +struct _qemuMonitorCPUInfo { + unsigned int id; + bool active; + pid_t thread_id; +}; + int qemuMonitorGetCPUInfo(qemuMonitorPtr mon, - int **pids); + qemuMonitorCPUInfoPtr *info); + int qemuMonitorGetVirtType(qemuMonitorPtr mon, int *virtType); int qemuMonitorGetBalloonInfo(qemuMonitorPtr mon, diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c index 26bf09b..4a69fec 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -1164,17 +1164,17 @@ int qemuMonitorJSONSystemReset(qemuMonitorPtr mon) /* - * [ { "CPU": 0, "current": true, "halted": false, "pc": 3227107138 }, - * { "CPU": 1, "current": false, "halted": true, "pc": 7108165 } ] + * [ { "CPU": 0, "current": true, "halted": false, "pc": 3227107138, "thread_id": 1234}, + * { "CPU": 1, "current": false, "halted": true, "pc": 7108165, "thread_id": 5678 } ] */ static int qemuMonitorJSONExtractCPUInfo(virJSONValuePtr reply, - int **pids) + qemuMonitorCPUInfoPtr *info) { virJSONValuePtr data; int ret = -1; int i; - int *threads = NULL; + qemuMonitorCPUInfoPtr cpus = NULL; int ncpus; if (!(data = virJSONValueObjectGet(reply, "return"))) { @@ -1195,49 +1195,60 @@ qemuMonitorJSONExtractCPUInfo(virJSONValuePtr reply, goto cleanup; } - if (VIR_REALLOC_N(threads, ncpus) < 0) { + if (VIR_ALLOC_N(cpus, ncpus) < 0) { virReportOOMError(); goto cleanup; } for (i = 0; i < ncpus; i++) { virJSONValuePtr entry = virJSONValueArrayGet(data, i); - int thread; + bool halted; + if (!entry) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("character device information was missing array element")); + _("cpu information was missing array element")); goto cleanup; } - if (virJSONValueObjectGetNumberInt(entry, "thread_id", &thread) < 0) { - /* Only qemu-kvm tree includs thread_id, so treat this as - non-fatal, simply returning no data */ - ret = 0; + if (virJSONValueObjectGetNumberUint(entry, "CPU", &cpus[i].id) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("CPU id missing in cpu information")); goto cleanup; } - threads[i] = thread; + if (virJSONValueObjectGetNumberInt(entry, "thread_id", + &cpus[i].thread_id) < 0) { + /* Some versions of qemu don't provide this information */ + cpus[i].thread_id = 0; + } + + if (virJSONValueObjectGetBoolean(entry, "halted", &halted) < 0) { + /* Not that important that we should fail */ + halted = false; + } + + cpus[i].active = !halted; } - *pids = threads; - threads = NULL; + *info = cpus; + cpus = NULL; ret = ncpus; cleanup: - VIR_FREE(threads); + VIR_FREE(cpus); return ret; } int qemuMonitorJSONGetCPUInfo(qemuMonitorPtr mon, - int **pids) + qemuMonitorCPUInfoPtr *info) { int ret; virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("query-cpus", NULL); virJSONValuePtr reply = NULL; - *pids = NULL; + *info = NULL; if (!cmd) return -1; @@ -1248,7 +1259,7 @@ int qemuMonitorJSONGetCPUInfo(qemuMonitorPtr mon, ret = qemuMonitorJSONCheckError(cmd, reply); if (ret == 0) - ret = qemuMonitorJSONExtractCPUInfo(reply, pids); + ret = qemuMonitorJSONExtractCPUInfo(reply, info); virJSONValueFree(cmd); virJSONValueFree(reply); diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h index d79b86b..ac077b1 100644 --- a/src/qemu/qemu_monitor_json.h +++ b/src/qemu/qemu_monitor_json.h @@ -53,7 +53,7 @@ int qemuMonitorJSONSystemPowerdown(qemuMonitorPtr mon); int qemuMonitorJSONSystemReset(qemuMonitorPtr mon); int qemuMonitorJSONGetCPUInfo(qemuMonitorPtr mon, - int **pids); + qemuMonitorCPUInfoPtr *info); int qemuMonitorJSONGetVirtType(qemuMonitorPtr mon, int *virtType); int qemuMonitorJSONGetBalloonInfo(qemuMonitorPtr mon, diff --git a/src/qemu/qemu_monitor_text.c b/src/qemu/qemu_monitor_text.c index aa4145e..a967ae6 100644 --- a/src/qemu/qemu_monitor_text.c +++ b/src/qemu/qemu_monitor_text.c @@ -501,13 +501,16 @@ int qemuMonitorTextSystemReset(qemuMonitorPtr mon) { } -int qemuMonitorTextGetCPUInfo(qemuMonitorPtr mon, - int **pids) +int +qemuMonitorTextGetCPUInfo(qemuMonitorPtr mon, + qemuMonitorCPUInfoPtr *info) { char *qemucpus = NULL; - char *line; - pid_t *cpupids = NULL; - size_t ncpupids = 0; + char **cpulines = NULL; + char **cpuline; + qemuMonitorCPUInfoPtr cpus = NULL; + size_t ncpus = 0; + int ret = -1; if (qemuMonitorHMPCommand(mon, "info cpus", &qemucpus) < 0) return -1; @@ -516,52 +519,63 @@ int qemuMonitorTextGetCPUInfo(qemuMonitorPtr mon, * This is the gross format we're about to parse :-{ * * (qemu) info cpus - * * CPU #0: pc=0x00000000000f0c4a thread_id=30019 - * CPU #1: pc=0x00000000fffffff0 thread_id=30020 - * CPU #2: pc=0x00000000fffffff0 thread_id=30021 + * * CPU #0: pc=0xffffffff8103b90b (halted) thread_id=874519 + * CPU #1: pc=0xffffffff8102e191 (halted) thread_id=874520 + * CPU #2: pc=0xffffffff812c12ae thread_id=874521 + * CPU #3: pc=0xffffffff810521cf thread_id=874522 * */ - line = qemucpus; - do { - char *offset = NULL; - char *end = NULL; + if (!(cpulines = virStringSplit(qemucpus, "\n", 0))) + goto cleanup; + + cpuline = cpulines; + + while (*cpuline++) { + char *offset; + char *end; + int id; int tid = 0; + bool halted = false; - /* Extract host Thread ID */ - if ((offset = strstr(line, "thread_id=")) == NULL) - goto error; + /* Extract vCPU id */ + if (!(offset = strchr(*cpuline, '#')) || + virStrToLong_i(offset + 1, &end, 10, &id) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("failed to extract vCPU id")); + goto cleanup; + } - if (virStrToLong_i(offset + strlen("thread_id="), &end, 10, &tid) < 0) - goto error; - if (end == NULL || !c_isspace(*end)) - goto error; + /* extract cpu state */ + if (strstr(*cpuline, "(halted)")) + halted = true; - if (VIR_REALLOC_N(cpupids, ncpupids+1) < 0) - goto error; + /* Extract host Thread ID, some versions of qemu may lack this info */ + if ((offset = strstr(*cpuline, "thread_id="))) { + if (virStrToLong_i(offset + strlen("thread_id="), &end, 10, &tid) < 0) + tid = 0; + } - VIR_DEBUG("tid=%d", tid); - cpupids[ncpupids++] = tid; + ncpus++; - /* Skip to next data line */ - line = strchr(offset, '\r'); - if (line == NULL) - line = strchr(offset, '\n'); - } while (line != NULL); + if (VIR_REALLOC_N(cpus, ncpus) < 0) { + virReportOOMError(); + goto cleanup; + } - /* Validate we got data for all VCPUs we expected */ - VIR_FREE(qemucpus); - *pids = cpupids; - return ncpupids; + cpus[ncpus].id = id; + cpus[ncpus].thread_id = tid; + cpus[ncpus].active = !halted; + } -error: + *info = cpus; + ret = ncpus; + +cleanup: VIR_FREE(qemucpus); - VIR_FREE(cpupids); + VIR_FREE(cpus); + virStringFreeList(cpulines); - /* Returning 0 to indicate non-fatal failure, since - * older QEMU does not have VCPU<->PID mapping and - * we don't want to fail on that - */ - return 0; + return ret; } diff --git a/src/qemu/qemu_monitor_text.h b/src/qemu/qemu_monitor_text.h index 5218a8b..08f4280 100644 --- a/src/qemu/qemu_monitor_text.h +++ b/src/qemu/qemu_monitor_text.h @@ -50,7 +50,7 @@ int qemuMonitorTextSystemPowerdown(qemuMonitorPtr mon); int qemuMonitorTextSystemReset(qemuMonitorPtr mon); int qemuMonitorTextGetCPUInfo(qemuMonitorPtr mon, - int **pids); + qemuMonitorCPUInfoPtr *info); int qemuMonitorTextGetVirtType(qemuMonitorPtr mon, int *virtType); int qemuMonitorTextGetBalloonInfo(qemuMonitorPtr mon, diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index d4fd4fb..8de14c3 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -1755,40 +1755,63 @@ static int qemuProcessDetectVcpuPIDs(virQEMUDriverPtr driver, virDomainObjPtr vm) { - pid_t *cpupids = NULL; - int ncpupids; qemuDomainObjPrivatePtr priv = vm->privateData; + qemuMonitorCPUInfoPtr info = NULL; + int ninfo; + int i; + int ret = -1; - qemuDomainObjEnterMonitor(driver, vm); /* failure to get the VCPU<-> PID mapping or to execute the query * command will not be treated fatal as some versions of qemu don't * support this command */ - if ((ncpupids = qemuMonitorGetCPUInfo(priv->mon, &cpupids)) <= 0) { - qemuDomainObjExitMonitor(driver, vm); - virResetLastError(); + qemuDomainObjEnterMonitor(driver, vm); + ninfo = qemuMonitorGetCPUInfo(priv->mon, &info); + qemuDomainObjExitMonitor(driver, vm); - priv->nvcpupids = 1; - if (VIR_ALLOC_N(priv->vcpupids, priv->nvcpupids) < 0) { - virReportOOMError(); - return -1; - } - priv->vcpupids[0] = vm->pid; - return 0; + if (ninfo < 0) + goto fallback; + + if (VIR_ALLOC_N(priv->vcpupids, ninfo) < 0) { + virReportOOMError(); + goto cleanup; } - qemuDomainObjExitMonitor(driver, vm); - if (ncpupids != vm->def->vcpus) { + for (i = 0; i < ninfo; i++) { + /* some versions of qemu don't expose thread IDs. Fall back gracefully */ + if (info[i].thread_id == 0) + goto fallback; + + priv->vcpupids[i] = info[i].thread_id; + } + + if (ninfo != vm->def->vcpus) { virReportError(VIR_ERR_INTERNAL_ERROR, _("got wrong number of vCPU pids from QEMU monitor. " "got %d, wanted %d"), - ncpupids, vm->def->vcpus); - VIR_FREE(cpupids); - return -1; + ninfo, vm->def->vcpus); + VIR_FREE(priv->vcpupids); + goto cleanup; } - priv->nvcpupids = ncpupids; - priv->vcpupids = cpupids; + priv->nvcpupids = ninfo; + ret = 0; + +cleanup: + VIR_FREE(info); + return ret; + +fallback: + VIR_FREE(info); + VIR_FREE(priv->vcpupids); + virResetLastError(); + priv->nvcpupids = 1; + if (VIR_ALLOC_N(priv->vcpupids, priv->nvcpupids) < 0) { + virReportOOMError(); + return -1; + } + priv->vcpupids[0] = vm->pid; return 0; + } -- 1.8.2.1

QEMU recently added support for cpu hotplug upstream that will support plugging arbitrary cpus. Additionally guest-agent-based cpu state modification from the guest point of view was added recently. This API will help monitoring the state of vCPUs using the two apporoaches as a support infrastructure for the modification APIs. --- daemon/remote.c | 54 ++++++++++++++++++++++++++++++ include/libvirt/libvirt.h.in | 21 ++++++++++++ python/generator.py | 1 + python/libvirt-override-api.xml | 7 ++++ python/libvirt-override.c | 66 ++++++++++++++++++++++++++++++++++++ src/driver.h | 6 ++++ src/libvirt.c | 74 +++++++++++++++++++++++++++++++++++++++++ src/libvirt_public.syms | 6 ++++ src/remote/remote_driver.c | 47 ++++++++++++++++++++++++++ src/remote/remote_protocol.x | 18 +++++++++- src/remote_protocol-structs | 13 ++++++++ 11 files changed, 312 insertions(+), 1 deletion(-) diff --git a/daemon/remote.c b/daemon/remote.c index 0e253bf..bb0640a 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -4583,6 +4583,60 @@ cleanup: return rv; } + +static int +remoteDispatchDomainGetVcpuMap(virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client ATTRIBUTE_UNUSED, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr, + remote_domain_get_vcpu_map_args *args, + remote_domain_get_vcpu_map_ret *ret) +{ + unsigned char *cpumap = NULL; + unsigned int flags; + int cpunum; + int rv = -1; + virDomainPtr dom = NULL; + struct daemonClientPrivate *priv = + virNetServerClientGetPrivateData(client); + + if (!priv->conn) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + if (!(dom = get_nonnull_domain(priv->conn, args->dom))) + goto cleanup; + + flags = args->flags; + + cpunum = virDomainGetVCPUMap(dom, + args->need_map ? &cpumap : NULL, + flags); + if (cpunum < 0) + goto cleanup; + + /* 'serialize' return cpumap */ + if (args->need_map) { + ret->cpumap.cpumap_len = VIR_CPU_MAPLEN(cpunum); + ret->cpumap.cpumap_val = (char *) cpumap; + cpumap = NULL; + } + + ret->ret = cpunum; + + rv = 0; + +cleanup: + if (rv < 0) + virNetMessageSaveError(rerr); + if (dom) + virDomainFree(dom); + VIR_FREE(cpumap); + return rv; +} + + static int lxcDispatchDomainOpenNamespace(virNetServerPtr server ATTRIBUTE_UNUSED, virNetServerClientPtr client ATTRIBUTE_UNUSED, diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index 1804c93..46d499c 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -4858,6 +4858,27 @@ int virNWFilterGetUUIDString (virNWFilterPtr nwfilter, char *buf); char * virNWFilterGetXMLDesc (virNWFilterPtr nwfilter, unsigned int flags); + +/** + * virDomainGetVCPUMapFlags + * + * Since 1.0.6 + */ +typedef enum { + VIR_DOMAIN_VCPU_MAP_HYPERVISOR = (1 << 0), /* request data from hypervisor */ + VIR_DOMAIN_VCPU_MAP_AGENT = (1 << 1), /* request data from guest agent */ + + VIR_DOMAIN_VCPU_MAP_POSSIBLE = (1 << 2), /* map all possible vcpus */ + VIR_DOMAIN_VCPU_MAP_ONLINE = (1 << 3), /* map all online vcpus */ + VIR_DOMAIN_VCPU_MAP_OFFLINE = (1 << 4), /* map all offline vcpus */ + VIR_DOMAIN_VCPU_MAP_OFFLINABLE = (1 << 5), /* map all vcpus that can be offlined */ + VIR_DOMAIN_VCPU_MAP_ACTIVE = (1 << 6), /* map cpus that are in use by the guest */ +} virDomainGetVCPUMapFlags; + +int virDomainGetVCPUMap(virDomainPtr dom, + unsigned char **cpumap, + unsigned int flags); + /** * virDomainConsoleFlags * diff --git a/python/generator.py b/python/generator.py index 8c380bb..4884c29 100755 --- a/python/generator.py +++ b/python/generator.py @@ -458,6 +458,7 @@ skip_impl = ( 'virNodeGetMemoryParameters', 'virNodeSetMemoryParameters', 'virNodeGetCPUMap', + 'virDomainGetVCPUMap', ) lxc_skip_impl = ( diff --git a/python/libvirt-override-api.xml b/python/libvirt-override-api.xml index 155ab36..7725800 100644 --- a/python/libvirt-override-api.xml +++ b/python/libvirt-override-api.xml @@ -584,5 +584,12 @@ <arg name='conn' type='virConnectPtr' info='pointer to the hypervisor connection'/> <arg name='flags' type='int' info='unused, pass 0'/> </function> + <function name='virDomainGetVCPUMap' file='python'> + <info>Get node CPU information</info> + <return type='char *' info='(cpunum, cpumap) on success, None on error'/> + <arg name='dom' type='virDomainPtr' info='pointer to the domain'/> + <arg name='flags' type='unsigned int' info='an OR&apos;ed set of virDomainGetVCPUMapFlags'/> + </function> + </symbols> </api> diff --git a/python/libvirt-override.c b/python/libvirt-override.c index 6ed2624..016b192 100644 --- a/python/libvirt-override.c +++ b/python/libvirt-override.c @@ -6759,6 +6759,71 @@ error: } +static PyObject * +libvirt_virDomainGetVCPUMap(PyObject *self ATTRIBUTE_UNUSED, + PyObject *args) +{ + virDomainPtr domain; + PyObject *pyobj_domain; + PyObject *ret = NULL; + PyObject *pycpumap = NULL; + PyObject *pyused = NULL; + PyObject *pycpunum = NULL; + PyObject *pyonline = NULL; + int i_retval; + unsigned char *cpumap = NULL; + unsigned int flags; + int i; + + if (!PyArg_ParseTuple(args, (char *)"Oi:virDomainGetVCPUMap", + &pyobj_domain, &flags)) + return NULL; + + domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain); + + LIBVIRT_BEGIN_ALLOW_THREADS; + i_retval = virDomainGetVCPUMap(domain, &cpumap, flags); + LIBVIRT_END_ALLOW_THREADS; + + if (i_retval < 0) + return VIR_PY_NONE; + + if (!(ret = PyTuple_New(2))) + goto error; + + /* 0: number of CPUs */ + if ((pycpunum = PyLong_FromLong(i_retval)) == NULL || + PyTuple_SetItem(ret, 0, pycpunum) < 0) + goto error; + + /* 1: CPU map */ + if ((pycpumap = PyList_New(i_retval)) == NULL) + goto error; + + for (i = 0; i < i_retval; i++) { + if ((pyused = PyBool_FromLong(VIR_CPU_USED(cpumap, i))) == NULL) + goto error; + if (PyList_SetItem(pycpumap, i, pyused) < 0) + goto error; + } + + if (PyTuple_SetItem(ret, 1, pycpumap) < 0) + goto error; + +cleanup: + VIR_FREE(cpumap); + return ret; +error: + Py_XDECREF(ret); + Py_XDECREF(pycpumap); + Py_XDECREF(pyused); + Py_XDECREF(pycpunum); + Py_XDECREF(pyonline); + ret = NULL; + goto cleanup; +} + + /************************************************************************ * * * The registration stuff * @@ -6882,6 +6947,7 @@ static PyMethodDef libvirtMethods[] = { {(char *) "virNodeGetMemoryParameters", libvirt_virNodeGetMemoryParameters, METH_VARARGS, NULL}, {(char *) "virNodeSetMemoryParameters", libvirt_virNodeSetMemoryParameters, METH_VARARGS, NULL}, {(char *) "virNodeGetCPUMap", libvirt_virNodeGetCPUMap, METH_VARARGS, NULL}, + {(char *) "virDomainGetVCPUMap", libvirt_virDomainGetVCPUMap, METH_VARARGS, NULL}, {NULL, NULL, 0, NULL} }; diff --git a/src/driver.h b/src/driver.h index e998adf..0caa2d6 100644 --- a/src/driver.h +++ b/src/driver.h @@ -1047,6 +1047,11 @@ typedef int int **fdlist, unsigned int flags); +typedef int +(*virDrvDomainGetVCPUMap)(virDomainPtr dom, + unsigned char **cpumap, + unsigned int flags); + typedef struct _virDriver virDriver; typedef virDriver *virDriverPtr; @@ -1248,6 +1253,7 @@ struct _virDriver { virDrvDomainFSTrim domainFSTrim; virDrvDomainSendProcessSignal domainSendProcessSignal; virDrvDomainLxcOpenNamespace domainLxcOpenNamespace; + virDrvDomainGetVCPUMap domainGetVCPUMap; }; diff --git a/src/libvirt.c b/src/libvirt.c index b129611..3f51e83 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -9499,6 +9499,80 @@ error: return -1; } + +/** + * virDomainGetVCPUMap: + * @domain: pointer to domain object + * @cpumap: pointer to a pointer where the returned cpumap will be stored + * @flags: bitwise-OR of virDomainGetVCPUMapFlags + * + * Request a map of virtual processors of a domain. Use @flags to control + * the data contained in the map. + * + * If @flags is 0 this function behaves as if flags + * VIR_DOMAIN_VCPU_MAP_HYPERVISOR and VIR_DOMAIN_VCPU_MAP_POSSIBLE were + * specified. + * + * When @flags contains VIR_DOMAIN_VCPU_MAP_AGENT the guest agent is used + * to query the requested data from the point of view of the guest. + * + * Returns the length of @cpumap or -1 in case of error. + */ +int +virDomainGetVCPUMap(virDomainPtr domain, + unsigned char **cpumap, + unsigned int flags) +{ + virConnectPtr conn; + + VIR_DOMAIN_DEBUG(domain); + + virResetLastError(); + + if (!VIR_IS_CONNECTED_DOMAIN(domain)) { + virLibDomainError(VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + virDispatchError(NULL); + return -1; + } + + conn = domain->conn; + + if ((flags & (VIR_DOMAIN_VCPU_MAP_HYPERVISOR | + VIR_DOMAIN_VCPU_MAP_AGENT)) == 0) + flags |= VIR_DOMAIN_VCPU_MAP_HYPERVISOR; + + if ((flags & (VIR_DOMAIN_VCPU_MAP_POSSIBLE | + VIR_DOMAIN_VCPU_MAP_ONLINE | + VIR_DOMAIN_VCPU_MAP_OFFLINE | + VIR_DOMAIN_VCPU_MAP_OFFLINABLE)) == 0) + flags |= VIR_DOMAIN_VCPU_MAP_ONLINE; + + if (flags & VIR_DOMAIN_VCPU_MAP_HYPERVISOR && + flags & VIR_DOMAIN_VCPU_MAP_AGENT) { + virReportInvalidArg(flags, + _("flags VIR_DOMAIN_VCPU_MAP_HYPERVISOR and " + "VIR_DOMAIN_VCPU_MAP_AGENT in %s " + "are mutually exclusive"), + __FUNCTION__); + goto error; + } + + if (conn->driver->domainGetVCPUMap) { + int ret; + ret = conn->driver->domainGetVCPUMap(domain, cpumap, flags); + if (ret < 0) + goto error; + return ret; + } + + virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__); + +error: + virDispatchError(domain->conn); + return -1; + +} + /** * virDomainGetSecurityLabel: * @domain: a domain object diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms index 4ee2d27..04465be 100644 --- a/src/libvirt_public.syms +++ b/src/libvirt_public.syms @@ -621,4 +621,10 @@ LIBVIRT_1.0.6 { virGetLastErrorMessage; } LIBVIRT_1.0.5; +LIBVIRT_1.0.7 { + global: + virDomainGetVCPUMap; +} LIBVIRT_1.0.6; + + # .... define new API here using predicted next version number .... diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index 2cda559..99fa3c1 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -5951,6 +5951,52 @@ done: static int +remoteDomainGetVCPUMap(virDomainPtr dom, + unsigned char **cpumap, + unsigned int flags) +{ + int rv = -1; + remote_domain_get_vcpu_map_args args; + remote_domain_get_vcpu_map_ret ret; + struct private_data *priv = dom->conn->privateData; + + remoteDriverLock(priv); + + args.need_map = !!cpumap; + args.flags = flags; + make_nonnull_domain(&args.dom, dom); + + memset(&ret, 0, sizeof(ret)); + if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_VCPU_MAP, + (xdrproc_t) xdr_remote_domain_get_vcpu_map_args, + (char *) &args, + (xdrproc_t) xdr_remote_domain_get_vcpu_map_ret, + (char *) &ret) == -1) + goto done; + + if (ret.ret < 0) + goto cleanup; + + if (cpumap) { + if (VIR_ALLOC_N(*cpumap, ret.cpumap.cpumap_len) < 0) { + virReportOOMError(); + goto cleanup; + } + memcpy(*cpumap, ret.cpumap.cpumap_val, ret.cpumap.cpumap_len); + } + + rv = ret.ret; + +cleanup: + xdr_free((xdrproc_t) xdr_remote_domain_get_vcpu_map_ret, (char *) &ret); +done: + remoteDriverUnlock(priv); + return rv; +} + + + +static int remoteDomainLxcOpenNamespace(virDomainPtr domain, int **fdlist, unsigned int flags) @@ -6348,6 +6394,7 @@ static virDriver remote_driver = { .nodeGetCPUMap = remoteNodeGetCPUMap, /* 1.0.0 */ .domainFSTrim = remoteDomainFSTrim, /* 1.0.1 */ .domainLxcOpenNamespace = remoteDomainLxcOpenNamespace, /* 1.0.2 */ + .domainGetVCPUMap = remoteDomainGetVCPUMap, /* 1.0.7 */ }; static virNetworkDriver network_driver = { diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index 1ebbce7..7db6be3 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -2737,6 +2737,17 @@ struct remote_node_get_cpu_map_ret { int ret; }; +struct remote_domain_get_vcpu_map_args { + remote_nonnull_domain dom; + int need_map; + unsigned int flags; +}; + +struct remote_domain_get_vcpu_map_ret { + opaque cpumap<REMOTE_CPUMAP_MAX>; + int ret; +}; + struct remote_domain_fstrim_args { remote_nonnull_domain dom; remote_string mountPoint; @@ -4434,6 +4445,11 @@ enum remote_procedure { /** * @generate: server */ - REMOTE_PROC_NODE_DEVICE_DETACH_FLAGS = 301 + REMOTE_PROC_NODE_DEVICE_DETACH_FLAGS = 301, + + /** + * @generate: none + */ + REMOTE_PROC_DOMAIN_GET_VCPU_MAP = 302 }; diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs index ea38ea2..e1ceabd 100644 --- a/src/remote_protocol-structs +++ b/src/remote_protocol-structs @@ -2186,6 +2186,18 @@ struct remote_node_get_cpu_map_ret { u_int online; int ret; }; +struct remote_domain_get_vcpu_map_args { + remote_nonnull_domain dom; + int need_map; + u_int flags; +}; +struct remote_domain_get_vcpu_map_ret { + struct { + u_int cpumap_len; + char * cpumap_val; + } cpumap; + int ret; +}; struct remote_domain_fstrim_args { remote_nonnull_domain dom; remote_string mountPoint; @@ -2494,4 +2506,5 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_MIGRATE_GET_COMPRESSION_CACHE = 299, REMOTE_PROC_DOMAIN_MIGRATE_SET_COMPRESSION_CACHE = 300, REMOTE_PROC_NODE_DEVICE_DETACH_FLAGS = 301, + REMOTE_PROC_DOMAIN_GET_VCPU_MAP = 302, }; -- 1.8.2.1

Use the agent cpu state code and the upgraded hypervisor vcpu state retrieval code to implement virDomainGetVCPUMap() api. --- src/qemu/qemu_driver.c | 179 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 179 insertions(+) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 0041d8f..70acdbb 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -15052,6 +15052,184 @@ qemuNodeSuspendForDuration(virConnectPtr conn ATTRIBUTE_UNUSED, return nodeSuspendForDuration(target, duration, flags); } +#define MATCH(FLAG) (flags & (FLAG)) +static int +qemuDomainGetVCPUMap(virDomainPtr dom, + unsigned char **cpumap, + unsigned int flags) +{ + virQEMUDriverPtr driver = dom->conn->privateData; + virDomainObjPtr vm; + qemuDomainObjPrivatePtr priv; + + qemuAgentCPUInfoPtr agentinfo = NULL; + qemuMonitorCPUInfoPtr vcpuinfo = NULL; + int ninfo = -1; + + virBitmapPtr cpus = NULL; + int i; + int ret = -1; + int dummy; + + virCheckFlags(VIR_DOMAIN_VCPU_MAP_HYPERVISOR | + VIR_DOMAIN_VCPU_MAP_AGENT | + VIR_DOMAIN_VCPU_MAP_POSSIBLE | + VIR_DOMAIN_VCPU_MAP_ONLINE | + VIR_DOMAIN_VCPU_MAP_OFFLINE | + VIR_DOMAIN_VCPU_MAP_OFFLINABLE | + VIR_DOMAIN_VCPU_MAP_ACTIVE, -1); + + + if (!(vm = qemuDomObjFromDomain(dom))) + return -1; + + priv = vm->privateData; + + /* request data from the guest */ + if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_QUERY) < 0) + goto cleanup; + + if (!virDomainObjIsActive(vm)) { + virReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("domain is not running")); + goto endjob; + } + + + if (MATCH(VIR_DOMAIN_VCPU_MAP_AGENT)) { + if (!priv->agent) { + virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", + _("guest agent is not configured")); + goto endjob; + } + qemuDomainObjEnterAgent(vm); + ninfo = qemuAgentGetVCPUs(priv->agent, &agentinfo); + qemuDomainObjExitAgent(vm); + } else { + qemuDomainObjEnterMonitor(driver, vm); + ninfo = qemuMonitorGetCPUInfo(priv->mon, &vcpuinfo); + qemuDomainObjExitMonitor(driver, vm); + } + +endjob: + if (qemuDomainObjEndJob(driver, vm) == 0) + vm = NULL; + + if (ninfo < 0) + goto cleanup; + + + if (MATCH(VIR_DOMAIN_VCPU_MAP_AGENT)) { + unsigned int maxcpu = 0; + + if (MATCH(VIR_DOMAIN_VCPU_MAP_ACTIVE)) { + virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", + _("qemu guest agent doesn't report active vCPUs ")); + goto cleanup; + } + + /* count cpus */ + for (i = 0; i < ninfo; i++) { + if (agentinfo[i].id > maxcpu) + maxcpu = agentinfo[i].id; + } + + /* allocate the returned array, vCPUs are indexed from 0 */ + if (!(cpus = virBitmapNew(maxcpu + 1))) { + virReportOOMError(); + goto cleanup; + } + + /* VIR_DOMAIN_VCPU_MAP_POSSIBLE */ + for (i = 0; i < ninfo; i++) + ignore_value(virBitmapSetBit(cpus, agentinfo[i].id)); + + if (MATCH(VIR_DOMAIN_VCPU_MAP_ONLINE)) { + for (i = 0; i < ninfo; i++) { + if (!agentinfo[i].online) + ignore_value(virBitmapClearBit(cpus, agentinfo[i].id)); + } + } + + if (MATCH(VIR_DOMAIN_VCPU_MAP_OFFLINE)) { + for (i = 0; i < ninfo; i++) { + if (agentinfo[i].online) + ignore_value(virBitmapClearBit(cpus, agentinfo[i].id)); + } + } + + if (MATCH(VIR_DOMAIN_VCPU_MAP_OFFLINABLE)) { + for (i = 0; i < ninfo; i++) { + if (!agentinfo[i].offlinable) + ignore_value(virBitmapClearBit(cpus, agentinfo[i].id)); + } + } + } else { + if (MATCH(VIR_DOMAIN_VCPU_MAP_OFFLINABLE)) { + virReportError(VIR_ERR_INVALID_ARG, "%s", + _("qemu driver doesn't support reporting of " + "offlinable vCPUs of the hypervisor")); + goto cleanup; + } + + /* hypervisor cpu stats */ + if (!(cpus = virBitmapNew(vm->def->maxvcpus))) { + virReportOOMError(); + goto cleanup; + } + + /* map active cpus */ + if (MATCH(VIR_DOMAIN_VCPU_MAP_ACTIVE)) { + /* offline vcpus can't be active */ + if (MATCH(VIR_DOMAIN_VCPU_MAP_OFFLINE)) + goto done; + + for (i = 0; i < ninfo; i++) { + if (vcpuinfo[i].active) + ignore_value(virBitmapSetBit(cpus, vcpuinfo[i].id)); + } + + goto done; + } + + /* for native hotplug, all configured vCPUs are possible for hotplug */ + if (MATCH(VIR_DOMAIN_VCPU_MAP_POSSIBLE)) { + virBitmapSetAll(cpus); + goto done; + } + + if (MATCH(VIR_DOMAIN_VCPU_MAP_OFFLINE)) { + /* online and offline together produce an empty map */ + if (MATCH(VIR_DOMAIN_VCPU_MAP_ONLINE)) + goto done; + + /* set all bit's so we can subtract online cpus from it later */ + virBitmapSetAll(cpus); + } + + for (i = 0; i < ninfo; i++) { + if (MATCH(VIR_DOMAIN_VCPU_MAP_ONLINE)) + ignore_value(virBitmapSetBit(cpus, vcpuinfo[i].id)); + else + ignore_value(virBitmapClearBit(cpus, vcpuinfo[i].id)); + } + } + +done: + if (cpumap && virBitmapToData(cpus, cpumap, &dummy) < 0) + goto cleanup; + + ret = virBitmapSize(cpus); + +cleanup: + if (vm) + virObjectUnlock(vm); + virBitmapFree(cpus); + VIR_FREE(vcpuinfo); + VIR_FREE(agentinfo); + return ret; +} +#undef MATCH static virDriver qemuDriver = { .no = VIR_DRV_QEMU, @@ -15232,6 +15410,7 @@ static virDriver qemuDriver = { .nodeGetCPUMap = qemuNodeGetCPUMap, /* 1.0.0 */ .domainFSTrim = qemuDomainFSTrim, /* 1.0.1 */ .domainOpenChannel = qemuDomainOpenChannel, /* 1.0.2 */ + .domainGetVCPUMap = qemuDomainGetVCPUMap, /* 1.0.7 */ }; -- 1.8.2.1

This patch introduces API virDomainSetGuestVcpus that will be used to work with vCPU state from the point of view of the guest using the guest agent. --- include/libvirt/libvirt.h.in | 4 ++++ src/driver.h | 8 +++++++ src/libvirt.c | 55 ++++++++++++++++++++++++++++++++++++++++++++ src/libvirt_public.syms | 1 + src/remote/remote_driver.c | 1 + src/remote/remote_protocol.x | 15 +++++++++++- src/remote_protocol-structs | 7 ++++++ 7 files changed, 90 insertions(+), 1 deletion(-) diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index 46d499c..c4c8224 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -2127,6 +2127,10 @@ int virDomainSetVcpus (virDomainPtr domain, int virDomainSetVcpusFlags (virDomainPtr domain, unsigned int nvcpus, unsigned int flags); +int virDomainSetGuestVcpu (virDomainPtr domain, + unsigned int id, + unsigned int online, + unsigned int flags); int virDomainGetVcpusFlags (virDomainPtr domain, unsigned int flags); diff --git a/src/driver.h b/src/driver.h index 0caa2d6..eca5f1d 100644 --- a/src/driver.h +++ b/src/driver.h @@ -1052,6 +1052,13 @@ typedef int unsigned char **cpumap, unsigned int flags); +typedef int +(*virDrvDomainSetGuestVcpu)(virDomainPtr dom, + unsigned int id, + unsigned int online, + unsigned int flags); + + typedef struct _virDriver virDriver; typedef virDriver *virDriverPtr; @@ -1254,6 +1261,7 @@ struct _virDriver { virDrvDomainSendProcessSignal domainSendProcessSignal; virDrvDomainLxcOpenNamespace domainLxcOpenNamespace; virDrvDomainGetVCPUMap domainGetVCPUMap; + virDrvDomainSetGuestVcpu domainSetGuestVcpu; }; diff --git a/src/libvirt.c b/src/libvirt.c index 3f51e83..9c3bbe6 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -8947,6 +8947,61 @@ error: return -1; } + +/** + * virDomainSetGuestVcpu: + * @domain: pointer to domain object, or NULL for Domain0 + * @id: vcpu ID in the guest + * @online: desired state of the vcpu + * @flags: currently unused, callers should pass 0 + * + * Dynamically change the state of a virtual CPUs used by the domain by + * using the guest agent. The vCPU id used is from the point of view of + * the guest. + * + * Returns 0 in case of success, -1 in case of failure. + */ + +int +virDomainSetGuestVcpu(virDomainPtr domain, + unsigned int id, + unsigned int online, + unsigned int flags) +{ + virConnectPtr conn; + + VIR_DOMAIN_DEBUG(domain, "id=%u, online=%u, flags=%x", id, online, flags); + + virResetLastError(); + + if (!VIR_IS_CONNECTED_DOMAIN(domain)) { + virLibDomainError(VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + virDispatchError(NULL); + return -1; + } + if (domain->conn->flags & VIR_CONNECT_RO) { + virLibDomainError(VIR_ERR_OPERATION_DENIED, __FUNCTION__); + goto error; + } + + conn = domain->conn; + + if (conn->driver->domainSetGuestVcpu) { + int ret; + ret = conn->driver->domainSetGuestVcpu(domain, id, online, flags); + if (ret < 0) + goto error; + return ret; + } + + virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__); + +error: + virDispatchError(domain->conn); + return -1; +} + + /** * virDomainGetVcpusFlags: * @domain: pointer to domain object, or NULL for Domain0 diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms index 04465be..bbb7c77 100644 --- a/src/libvirt_public.syms +++ b/src/libvirt_public.syms @@ -624,6 +624,7 @@ LIBVIRT_1.0.6 { LIBVIRT_1.0.7 { global: virDomainGetVCPUMap; + virDomainSetGuestVcpu; } LIBVIRT_1.0.6; diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index 99fa3c1..4dca3eb 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -6395,6 +6395,7 @@ static virDriver remote_driver = { .domainFSTrim = remoteDomainFSTrim, /* 1.0.1 */ .domainLxcOpenNamespace = remoteDomainLxcOpenNamespace, /* 1.0.2 */ .domainGetVCPUMap = remoteDomainGetVCPUMap, /* 1.0.7 */ + .domainSetGuestVcpu = remoteDomainSetGuestVcpu, /* 1.0.7 */ }; static virNetworkDriver network_driver = { diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index 7db6be3..bcc578f 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -2748,6 +2748,13 @@ struct remote_domain_get_vcpu_map_ret { int ret; }; +struct remote_domain_set_guest_vcpu_args { + remote_nonnull_domain dom; + unsigned int id; + unsigned int online; + unsigned int flags; +}; + struct remote_domain_fstrim_args { remote_nonnull_domain dom; remote_string mountPoint; @@ -4450,6 +4457,12 @@ enum remote_procedure { /** * @generate: none */ - REMOTE_PROC_DOMAIN_GET_VCPU_MAP = 302 + REMOTE_PROC_DOMAIN_GET_VCPU_MAP = 302, + + /** + * @generate: both + */ + REMOTE_PROC_DOMAIN_SET_GUEST_VCPU = 303 + }; diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs index e1ceabd..0ded7d8 100644 --- a/src/remote_protocol-structs +++ b/src/remote_protocol-structs @@ -2198,6 +2198,12 @@ struct remote_domain_get_vcpu_map_ret { } cpumap; int ret; }; +struct remote_domain_set_guest_vcpu_args { + remote_nonnull_domain dom; + u_int id; + u_int online; + u_int flags; +}; struct remote_domain_fstrim_args { remote_nonnull_domain dom; remote_string mountPoint; @@ -2507,4 +2513,5 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_MIGRATE_SET_COMPRESSION_CACHE = 300, REMOTE_PROC_NODE_DEVICE_DETACH_FLAGS = 301, REMOTE_PROC_DOMAIN_GET_VCPU_MAP = 302, + REMOTE_PROC_DOMAIN_SET_GUEST_VCPU = 303, }; -- 1.8.2.1

Use the helper added earlier to implement this new API. --- src/qemu/qemu_driver.c | 65 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 70acdbb..809807f 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -15231,6 +15231,70 @@ cleanup: } #undef MATCH + +static int +qemuDomainSetGuestVcpu(virDomainPtr dom, + unsigned int id, + unsigned int online, + unsigned int flags) +{ + virQEMUDriverPtr driver = dom->conn->privateData; + virDomainObjPtr vm; + qemuDomainObjPrivatePtr priv; + int ret = -1; + + qemuAgentCPUInfo agentinfo = { .id = id, + .online = !!online }; + + virCheckFlags(0, -1); + + if (!(vm = qemuDomObjFromDomain(dom))) + return -1; + + priv = vm->privateData; + + /* request data from the guest */ + if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0) + goto cleanup; + + if (!virDomainObjIsActive(vm)) { + virReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("domain is not running")); + goto endjob; + } + + if (!priv->agent) { + virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", + _("guest agent is not configured")); + goto endjob; + } + + qemuDomainObjEnterAgent(vm); + ret = qemuAgentSetVCPUs(priv->agent, &agentinfo, 1); + qemuDomainObjExitAgent(vm); + +endjob: + if (qemuDomainObjEndJob(driver, vm) == 0) + vm = NULL; + + if (ret < 0) + goto cleanup; + + if (ret != 0) { + virReportError(VIR_ERR_OPERATION_FAILED, + _("failed to set state of vCPU '%u'"), id); + goto cleanup; + } + + ret = 0; + +cleanup: + if (vm) + virObjectUnlock(vm); + return ret; +} + + static virDriver qemuDriver = { .no = VIR_DRV_QEMU, .name = QEMU_DRIVER_NAME, @@ -15411,6 +15475,7 @@ static virDriver qemuDriver = { .domainFSTrim = qemuDomainFSTrim, /* 1.0.1 */ .domainOpenChannel = qemuDomainOpenChannel, /* 1.0.2 */ .domainGetVCPUMap = qemuDomainGetVCPUMap, /* 1.0.7 */ + .domainSetGuestVcpu = qemuDomainSetGuestVcpu, /* 1.0.7 */ }; -- 1.8.2.1