QEMU 2.9.0 will introduce polling feature for AioContext that instead of blocking syscalls polls for events without blocking. This means that polling can be in most cases faster but it also increases CPU utilization. To address this issue QEMU implements self-tuning algorithm that modifies the current polling time to adapt to different workloads and it can also fallback to blocking syscalls. For each IOThread this all is controlled by three parameters, poll-max-ns, poll-grow and poll-shrink. If parameter poll-max-ns is set to 0 it disables the polling, if it is omitted the default behavior is used and any value more than 0 enables polling. Parameters poll-grow and poll-shrink configure how the self-tuning algorithm will adapt the current polling time. If they are omitted or set to 0 default values will be used. Signed-off-by: Pavel Hrdina <phrdina(a)redhat.com&gt; --- docs/formatdomain.html.in | 19 ++- docs/schemas/domaincommon.rng | 24 +++ src/conf/domain_conf.c | 169 ++++++++++++++++++++- src/conf/domain_conf.h | 8 + src/libvirt_private.syms | 1 + .../generic-iothreads-no-polling.xml | 22 +++ .../generic-iothreads-polling-disabled.xml | 24 +++ .../generic-iothreads-polling-enabled-fail.xml | 24 +++ .../generic-iothreads-polling-enabled.xml | 24 +++ tests/genericxml2xmltest.c | 6 + tests/testutils.c | 3 +- 11 files changed, 318 insertions(+), 6 deletions(-) create mode 100644 tests/genericxml2xmlindata/generic-iothreads-no-polling.xml create mode 100644 tests/genericxml2xmlindata/generic-iothreads-polling-disabled.xml create mode 100644 tests/genericxml2xmlindata/generic-iothreads-polling-enabled-fail.xml create mode 100644 tests/genericxml2xmlindata/generic-iothreads-polling-enabled.xml diff --git a/docs/formatdomain.html.in b/docs/formatdomain.html.in index b69bd4c44c..f01a11cf93 100644 --- a/docs/formatdomain.html.in +++ b/docs/formatdomain.html.in @@ -611,6 +611,7 @@ ... &lt;iothreadids&gt; &lt;iothread id="2"/&gt; + &lt;polling enabled='yes' max_ns="4000" grow="2" shrink="4"/&gt; &lt;iothread id="4"/&gt; &lt;iothread id="6"/&gt; &lt;iothread id="8"/&gt; @@ -645,7 +646,23 @@ defined for the domain, then the <code>iothreads</code> value will be adjusted accordingly. <span class="since">Since 1.2.15</span> - </dd> + </dd> + <dt><code>polling</code></dt> + <dd> + The optional <code>polling</code> element provides the capability to + enable/disable and configure polling mechanism for iothreads. Attribute + <code>max_ns</code> specifies the maximum time in <code>ns</code> + between each poll requests and is mandatory if polling is explicitly + enabled. Attributes <code>grow</code> and <code>shrink</code> specifies + time in <code>ns</code> that is used to configure how the polling + algorithm will adapt current polling time to different workloads. + If any of <code>max_ns</code>, <code>grow</code> and <code>shrink</code> + is set to <code>0</code>, it is the same as not providing it at all. + If this element is omitted the default behavior and values are set by + hypervisor. Possible values for <code>enabled</code> are + <code>yes</code> and <code>no</code>. Available only for QEMU driver. + <span class="since">Since 3.1.0</span> + </dd> </dl> <h3><a name="elementsCPUTuning">CPU Tuning</a></h3> diff --git a/docs/schemas/domaincommon.rng b/docs/schemas/domaincommon.rng index c5f101325e..11aecbaa6e 100644 --- a/docs/schemas/domaincommon.rng +++ b/docs/schemas/domaincommon.rng @@ -661,6 +661,30 @@ <attribute name="id"> <ref name="unsignedInt"/> </attribute> + <optional> + <element name="polling"> + <optional> + <attribute name="enabled"> + <ref name="virYesNo"/> + </attribute> + </optional> + <optional> + <attribute name="max_ns"> + <ref name="unsignedInt"/> + </attribute> + </optional> + <optional> + <attribute name="grow"> + <ref name="unsignedInt"/> + </attribute> + </optional> + <optional> + <attribute name="shrink"> + <ref name="unsignedInt"/> + </attribute> + </optional> + </element> + </optional> </element> </zeroOrMore> </element> diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index 79bdbdf50c..4b552a9175 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -1228,6 +1228,30 @@ virDomainDeviceDefCheckUnsupportedMemoryDevice(virDomainDeviceDefPtr dev) } +/** + * virDomainDefCheckUnsupportedIOThreadPolling: + * @def: domain definition + * + * Returns -1 if the domain definition would configure IOThread polling + * and reports an error, otherwise returns 0. + */ +static int +virDomainDefCheckUnsupportedIOThreadPolling(virDomainDefPtr def) +{ + size_t i; + + for (i = 0; i < def->niothreadids; i++) { + if (def->iothreadids[i]->poll_enabled != VIR_TRISTATE_BOOL_ABSENT) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("IOThread polling is not supported by this driver")); + return -1; + } + } + + return 0; +} + + bool virDomainObjTaint(virDomainObjPtr obj, virDomainTaintFlags taint) { @@ -4467,6 +4491,10 @@ virDomainDefPostParseCheckFeatures(virDomainDefPtr def, return -1; } + if (UNSUPPORTED(VIR_DOMAIN_DEF_FEATURE_IOTHREAD_POLLING) && + virDomainDefCheckUnsupportedIOThreadPolling(def) < 0) + return -1; + return 0; } @@ -4585,6 +4613,60 @@ virDomainVcpuDefPostParse(virDomainDefPtr def) } +int +virDomainIOThreadDefPostParse(virDomainIOThreadIDDefPtr iothread) +{ + if ((iothread->poll_grow > 0 || iothread->poll_shrink > 0) && + iothread->poll_max_ns == 0) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, + _("polling grow or shrink is set for iothread id " + "'%u' but max_ns is not set"), + iothread->iothread_id); + return -1; + } + + switch (iothread->poll_enabled) { + case VIR_TRISTATE_BOOL_ABSENT: + if (iothread->poll_max_ns > 0) + iothread->poll_enabled = VIR_TRISTATE_BOOL_YES; + break; + + case VIR_TRISTATE_BOOL_NO: + iothread->poll_max_ns = 0; + iothread->poll_grow = 0; + iothread->poll_shrink = 0; + break; + + case VIR_TRISTATE_BOOL_YES: + if (iothread->poll_max_ns == 0) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, + _("polling is enabled for iothread id '%u' but " + "max_ns is not set"), iothread->iothread_id); + return -1; + } + break; + + case VIR_TRISTATE_BOOL_LAST: + break; + } + + return 0; +} + + +static int +virDomainDefPostParseIOThreads(virDomainDefPtr def) +{ + size_t i; + + for (i = 0; i < def->niothreadids; i++) + if (virDomainIOThreadDefPostParse(def->iothreadids[i]) < 0) + return -1; + + return 0; +} + + static int virDomainDefPostParseInternal(virDomainDefPtr def, struct virDomainDefPostParseDeviceIteratorData *data) @@ -4599,6 +4681,9 @@ virDomainDefPostParseInternal(virDomainDefPtr def, if (virDomainVcpuDefPostParse(def) < 0) return -1; + if (virDomainDefPostParseIOThreads(def) < 0) + return -1; + if (virDomainDefPostParseMemory(def, data->parseFlags) < 0) return -1; @@ -15574,7 +15659,9 @@ virDomainIdmapDefParseXML(xmlXPathContextPtr ctxt, * * <iothreads>4</iothreads> * <iothreadids> - * <iothread id='1'/> + * <iothread id='1'> + * <polling enabled='yes' max_ns='4000' grow='2' shrink='4'/> + * </iothread> * <iothread id='3'/> * <iothread id='5'/> * <iothread id='7'/> @@ -15587,6 +15674,7 @@ virDomainIOThreadIDDefParseXML(xmlNodePtr node, virDomainIOThreadIDDefPtr iothrid; xmlNodePtr oldnode = ctxt->node; char *tmp = NULL; + int npoll = 0; if (VIR_ALLOC(iothrid) < 0) return NULL; @@ -15604,6 +15692,58 @@ virDomainIOThreadIDDefParseXML(xmlNodePtr node, _("invalid iothread 'id' value '%s'"), tmp); goto error; } + VIR_FREE(tmp); + + if ((npoll = virXPathNodeSet("./polling", ctxt, NULL)) < 0) + goto error; + + if (npoll > 1) { + virReportError(VIR_ERR_XML_ERROR, "%s", + _("only one polling element is allowed for each " + "<iothread> element")); + goto error; + } + + if (npoll > 0) { + if ((tmp = virXPathString("string(./polling/@enabled)", ctxt))) { + int enabled = virTristateBoolTypeFromString(tmp); + if (enabled < 0) { + virReportError(VIR_ERR_XML_ERROR, + _("invalid polling 'enabled' value '%s'"), tmp); + goto error; + } + iothrid->poll_enabled = enabled; + } else { + virReportError(VIR_ERR_XML_ERROR, "%s", + _("missing 'enabled' attribute in <polling> element")); + goto error; + } + VIR_FREE(tmp); + + if ((tmp = virXPathString("string(./polling/@max_ns)", ctxt)) && + virStrToLong_uip(tmp, NULL, 10, &iothrid->poll_max_ns) < 0) { + virReportError(VIR_ERR_XML_ERROR, + _("invalid polling 'max_ns' value '%s'"), tmp); + goto error; + } + VIR_FREE(tmp); + + if ((tmp = virXPathString("string(./polling/@grow)", ctxt)) && + virStrToLong_uip(tmp, NULL, 10, &iothrid->poll_grow) < 0) { + virReportError(VIR_ERR_XML_ERROR, + _("invalid polling 'grow' value '%s'"), tmp); + goto error; + } + VIR_FREE(tmp); + + if ((tmp = virXPathString("string(./polling/@shrink)", ctxt)) && + virStrToLong_uip(tmp, NULL, 10, &iothrid->poll_shrink) < 0) { + virReportError(VIR_ERR_XML_ERROR, + _("invalid polling 'shrink' value '%s'"), tmp); + goto error; + } + VIR_FREE(tmp); + } cleanup: VIR_FREE(tmp); @@ -23713,7 +23853,8 @@ virDomainDefIothreadShouldFormat(virDomainDefPtr def) size_t i; for (i = 0; i < def->niothreadids; i++) { - if (!def->iothreadids[i]->autofill) + if (!def->iothreadids[i]->autofill || + def->iothreadids[i]->poll_enabled != VIR_TRISTATE_BOOL_ABSENT) return true; } @@ -23918,8 +24059,28 @@ virDomainDefFormatInternal(virDomainDefPtr def, virBufferAddLit(buf, "<iothreadids>\n"); virBufferAdjustIndent(buf, 2); for (i = 0; i < def->niothreadids; i++) { - virBufferAsprintf(buf, "<iothread id='%u'/>\n", - def->iothreadids[i]->iothread_id); + virDomainIOThreadIDDefPtr iothread = def->iothreadids[i]; + virBufferAsprintf(buf, "<iothread id='%u'", iothread->iothread_id); + if (iothread->poll_enabled != VIR_TRISTATE_BOOL_ABSENT) { + virBufferAddLit(buf, ">\n"); + virBufferAdjustIndent(buf, 2); + virBufferAsprintf(buf, "<polling enabled='%s'", + virTristateBoolTypeToString(iothread->poll_enabled)); + if (iothread->poll_max_ns) + virBufferAsprintf(buf, " max_ns='%u'", + iothread->poll_max_ns); + if (iothread->poll_grow) + virBufferAsprintf(buf, " grow='%u'", + iothread->poll_grow); + if (iothread->poll_shrink) + virBufferAsprintf(buf, " shrink='%u'", + iothread->poll_shrink); + virBufferAddLit(buf, "/>\n"); + virBufferAdjustIndent(buf, -2); + virBufferAddLit(buf, "</iothread>\n"); + } else { + virBufferAddLit(buf, "/>\n"); + } } virBufferAdjustIndent(buf, -2); virBufferAddLit(buf, "</iothreadids>\n"); diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h index 1e53cc3280..8ac1d8a409 100644 --- a/src/conf/domain_conf.h +++ b/src/conf/domain_conf.h @@ -2074,11 +2074,18 @@ struct _virDomainIOThreadIDDef { int thread_id; virBitmapPtr cpumask; + virTristateBool poll_enabled; + unsigned int poll_max_ns; + unsigned int poll_grow; + unsigned int poll_shrink; + virDomainThreadSchedParam sched; }; void virDomainIOThreadIDDefFree(virDomainIOThreadIDDefPtr def); +int virDomainIOThreadDefPostParse(virDomainIOThreadIDDefPtr iothread); + typedef struct _virDomainCputune virDomainCputune; typedef virDomainCputune *virDomainCputunePtr; @@ -2410,6 +2417,7 @@ typedef enum { VIR_DOMAIN_DEF_FEATURE_OFFLINE_VCPUPIN = (1 << 2), VIR_DOMAIN_DEF_FEATURE_NAME_SLASH = (1 << 3), VIR_DOMAIN_DEF_FEATURE_INDIVIDUAL_VCPUS = (1 << 4), + VIR_DOMAIN_DEF_FEATURE_IOTHREAD_POLLING = (1 << 5), } virDomainDefFeatures; diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index e6ccd697d2..97aee9c0e3 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -371,6 +371,7 @@ virDomainHypervTypeToString; virDomainInputDefFree; virDomainIOMMUModelTypeFromString; virDomainIOMMUModelTypeToString; +virDomainIOThreadDefPostParse; virDomainIOThreadIDAdd; virDomainIOThreadIDDefFree; virDomainIOThreadIDDel; diff --git a/tests/genericxml2xmlindata/generic-iothreads-no-polling.xml b/tests/genericxml2xmlindata/generic-iothreads-no-polling.xml new file mode 100644 index 0000000000..b7e5a11c06 --- /dev/null +++ b/tests/genericxml2xmlindata/generic-iothreads-no-polling.xml @@ -0,0 +1,22 @@ +<domain type='qemu'> + <name>foo</name> + <uuid>c7a5fdbd-edaf-9455-926a-d65c16db1809</uuid> + <memory unit='KiB'>219136</memory> + <currentMemory unit='KiB'>219136</currentMemory> + <vcpu placement='static'>1</vcpu> + <iothreads>2</iothreads> + <iothreadids> + <iothread id='1'/> + <iothread id='2'/> + </iothreadids> + <os> + <type arch='x86_64' 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/genericxml2xmlindata/generic-iothreads-polling-disabled.xml b/tests/genericxml2xmlindata/generic-iothreads-polling-disabled.xml new file mode 100644 index 0000000000..0352a80900 --- /dev/null +++ b/tests/genericxml2xmlindata/generic-iothreads-polling-disabled.xml @@ -0,0 +1,24 @@ +<domain type='qemu'> + <name>foo</name> + <uuid>c7a5fdbd-edaf-9455-926a-d65c16db1809</uuid> + <memory unit='KiB'>219136</memory> + <currentMemory unit='KiB'>219136</currentMemory> + <vcpu placement='static'>1</vcpu> + <iothreads>2</iothreads> + <iothreadids> + <iothread id='1'> + <polling enabled='no'/> + </iothread> + <iothread id='2'/> + </iothreadids> + <os> + <type arch='x86_64' 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/genericxml2xmlindata/generic-iothreads-polling-enabled-fail.xml b/tests/genericxml2xmlindata/generic-iothreads-polling-enabled-fail.xml new file mode 100644 index 0000000000..6f77922e7a --- /dev/null +++ b/tests/genericxml2xmlindata/generic-iothreads-polling-enabled-fail.xml @@ -0,0 +1,24 @@ +<domain type='qemu'> + <name>foo</name> + <uuid>c7a5fdbd-edaf-9455-926a-d65c16db1809</uuid> + <memory unit='KiB'>219136</memory> + <currentMemory unit='KiB'>219136</currentMemory> + <vcpu placement='static'>1</vcpu> + <iothreads>2</iothreads> + <iothreadids> + <iothread id='1'> + <polling enabled='yes'/> + </iothread> + <iothread id='2'/> + </iothreadids> + <os> + <type arch='x86_64' 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/genericxml2xmlindata/generic-iothreads-polling-enabled.xml b/tests/genericxml2xmlindata/generic-iothreads-polling-enabled.xml new file mode 100644 index 0000000000..ef9161f367 --- /dev/null +++ b/tests/genericxml2xmlindata/generic-iothreads-polling-enabled.xml @@ -0,0 +1,24 @@ +<domain type='qemu'> + <name>foo</name> + <uuid>c7a5fdbd-edaf-9455-926a-d65c16db1809</uuid> + <memory unit='KiB'>219136</memory> + <currentMemory unit='KiB'>219136</currentMemory> + <vcpu placement='static'>1</vcpu> + <iothreads>2</iothreads> + <iothreadids> + <iothread id='1'> + <polling enabled='yes' max_ns='4000' grow='50'/> + </iothread> + <iothread id='2'/> + </iothreadids> + <os> + <type arch='x86_64' 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 488190270f..c3a9586eab 100644 --- a/tests/genericxml2xmltest.c +++ b/tests/genericxml2xmltest.c @@ -100,6 +100,12 @@ mymain(void) DO_TEST("vcpus-individual"); + DO_TEST("iothreads-no-polling"); + DO_TEST("iothreads-polling-enabled"); + DO_TEST("iothreads-polling-disabled"); + DO_TEST_FULL("iothreads-polling-enabled-fail", 0, false, + TEST_COMPARE_DOM_XML2XML_RESULT_FAIL_PARSE); + virObjectUnref(caps); virObjectUnref(xmlopt); diff --git a/tests/testutils.c b/tests/testutils.c index a596a83a96..93a12bcc76 100644 --- a/tests/testutils.c +++ b/tests/testutils.c @@ -1101,7 +1101,8 @@ virCapsPtr virTestGenericCapsInit(void) } static virDomainDefParserConfig virTestGenericDomainDefParserConfig = { - .features = VIR_DOMAIN_DEF_FEATURE_INDIVIDUAL_VCPUS, + .features = VIR_DOMAIN_DEF_FEATURE_INDIVIDUAL_VCPUS | + VIR_DOMAIN_DEF_FEATURE_IOTHREAD_POLLING, }; static virDomainXMLPrivateDataCallbacks virTestGenericPrivateDataCallbacks; -- 2.11.1

This basically copies and extend the existing virDomainAddIOThread API by adding support for parameters. This allows you to add a new iothread into a domain and also sets polling parameters along with the new iothread. Signed-off-by: Pavel Hrdina <phrdina(a)redhat.com&gt; --- include/libvirt/libvirt-domain.h | 39 +++++++++++++++++++++ src/driver-hypervisor.h | 8 +++++ src/libvirt-domain.c | 75 ++++++++++++++++++++++++++++++++++++++++ src/libvirt_public.syms | 5 +++ src/remote/remote_driver.c | 1 + src/remote/remote_protocol.x | 20 ++++++++++- src/remote_protocol-structs | 10 ++++++ 7 files changed, 157 insertions(+), 1 deletion(-) diff --git a/include/libvirt/libvirt-domain.h b/include/libvirt/libvirt-domain.h index e303140a23..5ce974292e 100644 --- a/include/libvirt/libvirt-domain.h +++ b/include/libvirt/libvirt-domain.h @@ -1855,6 +1855,40 @@ int virDomainGetEmulatorPinInfo (virDomainPtr domain, int maplen, unsigned int flags); +/* IOThread parameters */ + +/** + * VIR_DOMAIN_IOTHREAD_POLL_ENABLED: + * + * Whether polling should be enabled or not. If omitted the default is set + * by hypervisor. + */ +# define VIR_DOMAIN_IOTHREAD_POLL_ENABLED "poll_enabled" + +/** + * VIR_DOMAIN_IOTHREAD_POLL_MAX_NS: + * + * The maximal polling time that can be used by polling algorithm in ns. + * If omitted the default is 0. + */ +# define VIR_DOMAIN_IOTHREAD_POLL_MAX_NS "poll_max_ns" + +/** + * VIR_DOMAIN_IOTHREAD_POLL_GROW: + * + * This tells the polling algorithm how many ns it should grow current + * polling time if it's not optimal anymore. If omitted the default is 0. + */ +# define VIR_DOMAIN_IOTHREAD_POLL_GROW "poll_grow" + +/** + * VIR_DOMAIN_IOTHREAD_POLL_SHRINK: + * + * This tells the polling algorithm how many ns it should shrink current + * polling time if it's not optimal anymore. If omitted the default is 0. + */ +# define VIR_DOMAIN_IOTHREAD_POLL_SHRINK "poll_shrink" + /** * virIOThreadInfo: * @@ -1882,6 +1916,11 @@ int virDomainPinIOThread(virDomainPtr domain, int virDomainAddIOThread(virDomainPtr domain, unsigned int iothread_id, unsigned int flags); +int virDomainAddIOThreadParams(virDomainPtr domain, + unsigned int iothread_id, + virTypedParameterPtr params, + int nparams, + unsigned int flags); int virDomainDelIOThread(virDomainPtr domain, unsigned int iothread_id, unsigned int flags); diff --git a/src/driver-hypervisor.h b/src/driver-hypervisor.h index 51af73200b..9c7ce83cd3 100644 --- a/src/driver-hypervisor.h +++ b/src/driver-hypervisor.h @@ -399,6 +399,13 @@ typedef int unsigned int flags); typedef int +(*virDrvDomainAddIOThreadParams)(virDomainPtr domain, + unsigned int iothread_id, + virTypedParameterPtr params, + int nparams, + unsigned int flags); + +typedef int (*virDrvDomainDelIOThread)(virDomainPtr domain, unsigned int iothread_id, unsigned int flags); @@ -1334,6 +1341,7 @@ struct _virHypervisorDriver { virDrvDomainGetIOThreadInfo domainGetIOThreadInfo; virDrvDomainPinIOThread domainPinIOThread; virDrvDomainAddIOThread domainAddIOThread; + virDrvDomainAddIOThreadParams domainAddIOThreadParams; virDrvDomainDelIOThread domainDelIOThread; virDrvDomainGetSecurityLabel domainGetSecurityLabel; virDrvDomainGetSecurityLabelList domainGetSecurityLabelList; diff --git a/src/libvirt-domain.c b/src/libvirt-domain.c index 5b3e842058..691c72dedd 100644 --- a/src/libvirt-domain.c +++ b/src/libvirt-domain.c @@ -7751,6 +7751,81 @@ virDomainAddIOThread(virDomainPtr domain, /** + * virDomainAddIOThreadParams: + * @domain: a domain object + * @iothread_id: the specific IOThread ID value to add + * @params: pointer to IOThread parameter objects + * @nparams: number of IOThread parameters + * @flags: bitwise-OR of virDomainModificationImpact and virTypedParameterFlags + * + * Dynamically add an IOThread to the domain. It is left up to the + * underlying virtual hypervisor to determine the valid range for an + * @iothread_id and determining whether the @iothread_id already exists. + * + * The combination of parameters has some limitation: + * + * - If VIR_DOMAIN_IOTHREAD_POLL_ENABLED is set to true, + * VIR_DOMAIN_IOTHREAD_POLL_MAX_NS must be set as well. + * + * - If VIR_DOMAIN_IOTHREAD_POLL_MAX_NS is set to value > 0, + * VIR_DOMAIN_IOTHREAD_POLL_ENABLED is set to true. + * + * - If one of VIR_DOMAIN_IOTHREAD_POLL_GROW or VIR_DOMAIN_IOTHREAD_POLL_SHRINK + * is set to value > 0, VIR_DOMAIN_IOTHREAD_POLL_MAX_NS must be set as well. + * + * See VIR_DOMAIN_IOTHREAD_* for detailed description of accepted IOThread + * parameters. + * + * Note that this call can fail if the underlying virtualization hypervisor + * does not support it or if growing the number of iothreads is arbitrarily + * limited. This function requires privileged access to the hypervisor. + * + * Returns 0 in case of success, -1 in case of failure. + */ +int +virDomainAddIOThreadParams(virDomainPtr domain, + unsigned int iothread_id, + virTypedParameterPtr params, + int nparams, + unsigned int flags) +{ + virConnectPtr conn; + + VIR_DOMAIN_DEBUG(domain, "iothread_id=%u, params=%p, nparams=%d, flags=%x", + iothread_id, params, nparams, flags); + VIR_TYPED_PARAMS_DEBUG(params, nparams); + + virResetLastError(); + + virCheckDomainReturn(domain, -1); + conn = domain->conn; + + virCheckReadOnlyGoto(conn->flags, error); + virCheckNonNegativeArgGoto(nparams, error); + if (nparams) + virCheckNonNullArgGoto(params, error); + + if (virTypedParameterValidateSet(conn, params, nparams) < 0) + goto error; + + if (conn->driver->domainAddIOThreadParams) { + int ret; + ret = conn->driver->domainAddIOThreadParams(domain, iothread_id, + params, nparams, flags); + if (ret < 0) + goto error; + return ret; + } + + virReportUnsupportedError(); + + error: + virDispatchError(domain->conn); + return -1; +} + + +/** * virDomainDelIOThread: * @domain: a domain object * @iothread_id: the specific IOThread ID value to delete diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms index 62885ac415..edf72d23aa 100644 --- a/src/libvirt_public.syms +++ b/src/libvirt_public.syms @@ -753,4 +753,9 @@ LIBVIRT_3.0.0 { virConnectSecretEventDeregisterAny; } LIBVIRT_2.2.0; +LIBVIRT_3.1.0 { + global: + virDomainAddIOThreadParams; +} LIBVIRT_3.0.0; + # .... define new API here using predicted next version number .... diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index a3f7d9b0ba..f9e246b8bc 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -8246,6 +8246,7 @@ static virHypervisorDriver hypervisor_driver = { .domainGetIOThreadInfo = remoteDomainGetIOThreadInfo, /* 1.2.14 */ .domainPinIOThread = remoteDomainPinIOThread, /* 1.2.14 */ .domainAddIOThread = remoteDomainAddIOThread, /* 1.2.15 */ + .domainAddIOThreadParams = remoteDomainAddIOThreadParams, /* 3.1.0 */ .domainDelIOThread = remoteDomainDelIOThread, /* 1.2.15 */ .domainGetSecurityLabel = remoteDomainGetSecurityLabel, /* 0.6.1 */ .domainGetSecurityLabelList = remoteDomainGetSecurityLabelList, /* 0.10.0 */ diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index cd0a14cc69..146c38b3f4 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -253,6 +253,9 @@ const REMOTE_DOMAIN_IP_ADDR_MAX = 2048; /* Upper limit on number of guest vcpu information entries */ const REMOTE_DOMAIN_GUEST_VCPU_PARAMS_MAX = 64; +/* Upper limit on number of IOThread information entries */ +const REMOTE_DOMAIN_IOTHREAD_PARAMS_MAX = 64; + /* UUID. VIR_UUID_BUFLEN definition comes from libvirt.h */ typedef opaque remote_uuid[VIR_UUID_BUFLEN]; @@ -1227,6 +1230,13 @@ struct remote_domain_add_iothread_args { unsigned int flags; }; +struct remote_domain_add_iothread_params_args { + remote_nonnull_domain dom; + unsigned int iothread_id; + remote_typed_param params<REMOTE_DOMAIN_IOTHREAD_PARAMS_MAX>; + unsigned int flags; +}; + struct remote_domain_del_iothread_args { remote_nonnull_domain dom; unsigned int iothread_id; @@ -6018,6 +6028,14 @@ enum remote_procedure { * @generate: both * @acl: none */ - REMOTE_PROC_SECRET_EVENT_VALUE_CHANGED = 383 + REMOTE_PROC_SECRET_EVENT_VALUE_CHANGED = 383, + + /** + * @generate: both + * @acl: domain:write + * @acl: domain:save:!VIR_DOMAIN_AFFECT_CONFIG|VIR_DOMAIN_AFFECT_LIVE + * @acl: domain:save:VIR_DOMAIN_AFFECT_CONFIG + */ + REMOTE_PROC_DOMAIN_ADD_IOTHREAD_PARAMS = 384 }; diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs index 0360600cfb..2e3245322f 100644 --- a/src/remote_protocol-structs +++ b/src/remote_protocol-structs @@ -857,6 +857,15 @@ struct remote_domain_add_iothread_args { u_int iothread_id; u_int flags; }; +struct remote_domain_add_iothread_params_args { + remote_nonnull_domain dom; + u_int iothread_id; + struct { + u_int params_len; + remote_typed_param * params_val; + } params; + u_int flags; +}; struct remote_domain_del_iothread_args { remote_nonnull_domain dom; u_int iothread_id; @@ -3210,4 +3219,5 @@ enum remote_procedure { REMOTE_PROC_CONNECT_SECRET_EVENT_DEREGISTER_ANY = 381, REMOTE_PROC_SECRET_EVENT_LIFECYCLE = 382, REMOTE_PROC_SECRET_EVENT_VALUE_CHANGED = 383, + REMOTE_PROC_DOMAIN_ADD_IOTHREAD_PARAMS = 384, }; -- 2.11.1

Signed-off-by: Pavel Hrdina <phrdina(a)redhat.com&gt; --- tools/virsh-domain.c | 65 ++++++++++++++++++++++++++++++++++++++++++++++++++-- tools/virsh.pod | 10 ++++++++ 2 files changed, 73 insertions(+), 2 deletions(-) diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c index 023ec8a8b3..dddb336a57 100644 --- a/tools/virsh-domain.c +++ b/tools/virsh-domain.c @@ -7191,6 +7191,24 @@ static const vshCmdOptDef opts_iothreadadd[] = { .flags = VSH_OFLAG_REQ, .help = N_("iothread for the new IOThread") }, + {.name = "poll-disabled", + .type = VSH_OT_BOOL, + .help = N_("disable polling for the new IOThread") + }, + {.name = "poll-max-ns", + .type = VSH_OT_INT, + .help = N_("set max polling time in ns for the new IOThread") + }, + {.name = "poll-grow", + .type = VSH_OT_INT, + .help = N_("set how much ns should be used to grow current polling " + "time for the new IOThread") + }, + {.name = "poll-shrink", + .type = VSH_OT_INT, + .help = N_("set how much ns should be used to shrink current polling " + "time for the new IOThread") + }, VIRSH_COMMON_OPT_DOMAIN_CONFIG, VIRSH_COMMON_OPT_DOMAIN_LIVE, VIRSH_COMMON_OPT_DOMAIN_CURRENT, @@ -7206,10 +7224,21 @@ cmdIOThreadAdd(vshControl *ctl, const vshCmd *cmd) bool config = vshCommandOptBool(cmd, "config"); bool live = vshCommandOptBool(cmd, "live"); bool current = vshCommandOptBool(cmd, "current"); + bool poll_disabled = vshCommandOptBool(cmd, "poll-disabled"); unsigned int flags = VIR_DOMAIN_AFFECT_CURRENT; + virTypedParameterPtr params = NULL; + int nparams = 0; + int maxparams = 0; + unsigned int poll_val; + int rc; VSH_EXCLUSIVE_OPTIONS_VAR(current, live); VSH_EXCLUSIVE_OPTIONS_VAR(current, config); + VSH_EXCLUSIVE_OPTIONS("poll-disabled", "poll-max-ns"); + VSH_EXCLUSIVE_OPTIONS("poll-disabled", "poll-grow"); + VSH_EXCLUSIVE_OPTIONS("poll-disabled", "poll-shrink"); + VSH_REQUIRE_OPTION("poll-grow", "poll-max-ns"); + VSH_REQUIRE_OPTION("poll-shrink", "poll-max-ns"); if (config) flags |= VIR_DOMAIN_AFFECT_CONFIG; @@ -7226,14 +7255,46 @@ cmdIOThreadAdd(vshControl *ctl, const vshCmd *cmd) goto cleanup; } - if (virDomainAddIOThread(dom, iothread_id, flags) < 0) - goto cleanup; + if (poll_disabled) { + if (virTypedParamsAddBoolean(&params, &nparams, &maxparams, + VIR_DOMAIN_IOTHREAD_POLL_ENABLED, 0) < 0) + goto save_error; + } else { +#define VSH_IOTHREAD_SET_PARAMS(opt, param) \ + poll_val = 0; \ + if ((rc = vshCommandOptUInt(ctl, cmd, opt, &poll_val)) < 0) \ + goto cleanup; \ + if (rc > 0 && \ + virTypedParamsAddUInt(&params, &nparams, &maxparams, \ + param, poll_val) < 0) \ + goto save_error; + + VSH_IOTHREAD_SET_PARAMS("poll-max-ns", VIR_DOMAIN_IOTHREAD_POLL_MAX_NS) + VSH_IOTHREAD_SET_PARAMS("poll-grow", VIR_DOMAIN_IOTHREAD_POLL_GROW) + VSH_IOTHREAD_SET_PARAMS("poll-shrink", VIR_DOMAIN_IOTHREAD_POLL_SHRINK) + +#undef VSH_IOTHREAD_SET_PARAMS + } + + if (nparams) { + if (virDomainAddIOThreadParams(dom, iothread_id, + params, nparams, flags) < 0) + goto cleanup; + } else { + if (virDomainAddIOThread(dom, iothread_id, flags) < 0) + goto cleanup; + } ret = true; cleanup: + virTypedParamsFree(params, nparams); virDomainFree(dom); return ret; + + save_error: + vshSaveLibvirtError(); + goto cleanup; } /* diff --git a/tools/virsh.pod b/tools/virsh.pod index 90f4b5a1f7..12fa650f03 100644 --- a/tools/virsh.pod +++ b/tools/virsh.pod @@ -1520,12 +1520,22 @@ B<Note>: The expression is sequentially evaluated, so "0-15,^8" is identical to "9-14,0-7,15" but not identical to "^8,0-15". =item B<iothreadadd> I<domain> I<iothread_id> +[[I<--poll-disable>] | [I<--poll-max-ns> B<ns>] [I<--poll-grow> B<ns>] +[I<--poll-shring> B<ns>]] [[I<--config>] [I<--live>] | [I<--current>]] Add a new IOThread to the domain using the specified I<iothread_id>. If the I<iothread_id> already exists, the command will fail. The I<iothread_id> must be greater than zero. +It is possible to configure polling for the new added IOThread using +I<--poll-*> options. If no polling option is not specified hypervisor +will use its default configuration. To disable polling use I<--poll-disable>. +To enable polling you need to at least provide I<--poll-max-ns> which sets +the maximum polling time that can be used by polling algorithm. +I<--poll-grow> and I<--poll-shring> is used to configure how the polling +algorithm will adapt the current polling time to different workloads. + If I<--live> is specified, affect a running guest. If the guest is not running an error is returned. If I<--config> is specified, affect the next boot of a persistent guest. -- 2.11.1

Signed-off-by: Pavel Hrdina <phrdina(a)redhat.com&gt; --- Patch [1] that is still waiting to be pushed into QEMU is required for this feature. [1] <http://lists.nongnu.org/archive/html/qemu-devel/2017-02/msg02192.html> src/qemu/qemu_capabilities.c | 2 ++ src/qemu/qemu_capabilities.h | 1 + tests/qemucapabilitiesdata/caps_2.9.0.x86_64.replies | 12 ++++++++++++ tests/qemucapabilitiesdata/caps_2.9.0.x86_64.xml | 1 + 4 files changed, 16 insertions(+) diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c index e851eec7a7..982893a6c8 100644 --- a/src/qemu/qemu_capabilities.c +++ b/src/qemu/qemu_capabilities.c @@ -358,6 +358,7 @@ VIR_ENUM_IMPL(virQEMUCaps, QEMU_CAPS_LAST, "query-cpu-model-expansion", /* 245 */ "virtio-net.host_mtu", "spice-rendernode", + "iothread.poll-max-ns", ); @@ -1734,6 +1735,7 @@ static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsUSBNECXHCI[] = { static struct virQEMUCapsStringFlags virQEMUCapsQMPSchemaQueries[] = { { "blockdev-add/arg-type/options/+gluster/debug-level", QEMU_CAPS_GLUSTER_DEBUG_LEVEL}, { "blockdev-add/arg-type/+gluster/debug", QEMU_CAPS_GLUSTER_DEBUG_LEVEL}, + { "query-iothreads/ret-type/poll-max-ns", QEMU_CAPS_IOTHREAD_POLLING}, }; struct virQEMUCapsObjectTypeProps { diff --git a/src/qemu/qemu_capabilities.h b/src/qemu/qemu_capabilities.h index 0f998c473f..bdaccde307 100644 --- a/src/qemu/qemu_capabilities.h +++ b/src/qemu/qemu_capabilities.h @@ -394,6 +394,7 @@ typedef enum { QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION, /* qmp query-cpu-model-expansion */ QEMU_CAPS_VIRTIO_NET_HOST_MTU, /* virtio-net-*.host_mtu */ QEMU_CAPS_SPICE_RENDERNODE, /* -spice rendernode */ + QEMU_CAPS_IOTHREAD_POLLING, /* -object iothread.poll-max-ns */ QEMU_CAPS_LAST /* this must always be the last item */ } virQEMUCapsFlags; diff --git a/tests/qemucapabilitiesdata/caps_2.9.0.x86_64.replies b/tests/qemucapabilitiesdata/caps_2.9.0.x86_64.replies index fe9fe7d5b7..5ee2c61e4f 100644 --- a/tests/qemucapabilitiesdata/caps_2.9.0.x86_64.replies +++ b/tests/qemucapabilitiesdata/caps_2.9.0.x86_64.replies @@ -9211,6 +9211,18 @@ { "name": "thread-id", "type": "int" + }, + { + "name": "poll-max-ns", + "type": "int" + }, + { + "name": "poll-grow", + "type": "int" + }, + { + "name": "poll-shrink", + "type": "int" } ], "meta-type": "object" diff --git a/tests/qemucapabilitiesdata/caps_2.9.0.x86_64.xml b/tests/qemucapabilitiesdata/caps_2.9.0.x86_64.xml index dcdc0e6213..7089429866 100644 --- a/tests/qemucapabilitiesdata/caps_2.9.0.x86_64.xml +++ b/tests/qemucapabilitiesdata/caps_2.9.0.x86_64.xml @@ -202,6 +202,7 @@ <flag name='vhost-scsi'/> <flag name='drive-iotune-group'/> <flag name='virtio-net.host_mtu'/> + <flag name='iothread.poll-max-ns'/> <version>2008050</version> <kvmVersion>0</kvmVersion> <package> (v2.8.0-1321-gad584d3)</package> -- 2.11.1

Signed-off-by: Pavel Hrdina <phrdina(a)redhat.com&gt; --- src/qemu/qemu_driver.c | 6 +++--- src/qemu/qemu_monitor.c | 6 ++++-- src/qemu/qemu_monitor.h | 6 +++++- src/qemu/qemu_monitor_json.c | 19 ++++++++++++++++++- src/qemu/qemu_monitor_json.h | 3 ++- src/qemu/qemu_process.c | 2 +- tests/qemumonitorjsontest.c | 2 +- 7 files changed, 34 insertions(+), 10 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index da9f10e65e..ff610a7692 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -5284,7 +5284,7 @@ qemuDomainGetIOThreadsLive(virQEMUDriverPtr driver, } qemuDomainObjEnterMonitor(driver, vm); - niothreads = qemuMonitorGetIOThreads(priv->mon, &iothreads); + niothreads = qemuMonitorGetIOThreads(priv->mon, &iothreads, false); if (qemuDomainObjExitMonitor(driver, vm) < 0) goto endjob; if (niothreads < 0) @@ -5599,7 +5599,7 @@ qemuDomainHotplugAddIOThread(virQEMUDriverPtr driver, * and add the thread_id to the vm->def->iothreadids list. */ if ((new_niothreads = qemuMonitorGetIOThreads(priv->mon, - &new_iothreads)) < 0) + &new_iothreads, false)) < 0) goto exit_monitor; if (qemuDomainObjExitMonitor(driver, vm) < 0) @@ -5681,7 +5681,7 @@ qemuDomainHotplugDelIOThread(virQEMUDriverPtr driver, goto exit_monitor; if ((new_niothreads = qemuMonitorGetIOThreads(priv->mon, - &new_iothreads)) < 0) + &new_iothreads, false)) < 0) goto exit_monitor; if (qemuDomainObjExitMonitor(driver, vm) < 0) diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c index b15207a693..7633e6fc07 100644 --- a/src/qemu/qemu_monitor.c +++ b/src/qemu/qemu_monitor.c @@ -4025,6 +4025,7 @@ qemuMonitorRTCResetReinjection(qemuMonitorPtr mon) * qemuMonitorGetIOThreads: * @mon: Pointer to the monitor * @iothreads: Location to return array of IOThreadInfo data + * @supportPolling: Whether require polling data in QEMU reply * * Issue query-iothreads command. * Retrieve the list of iothreads defined/running for the machine @@ -4034,7 +4035,8 @@ qemuMonitorRTCResetReinjection(qemuMonitorPtr mon) */ int qemuMonitorGetIOThreads(qemuMonitorPtr mon, - qemuMonitorIOThreadInfoPtr **iothreads) + qemuMonitorIOThreadInfoPtr **iothreads, + bool supportPolling) { VIR_DEBUG("iothreads=%p", iothreads); @@ -4047,7 +4049,7 @@ qemuMonitorGetIOThreads(qemuMonitorPtr mon, return 0; } - return qemuMonitorJSONGetIOThreads(mon, iothreads); + return qemuMonitorJSONGetIOThreads(mon, iothreads, supportPolling); } diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h index 8811d85017..eeae18e5b0 100644 --- a/src/qemu/qemu_monitor.h +++ b/src/qemu/qemu_monitor.h @@ -1005,9 +1005,13 @@ typedef qemuMonitorIOThreadInfo *qemuMonitorIOThreadInfoPtr; struct _qemuMonitorIOThreadInfo { unsigned int iothread_id; int thread_id; + int poll_max_ns; + int poll_grow; + int poll_shrink; }; int qemuMonitorGetIOThreads(qemuMonitorPtr mon, - qemuMonitorIOThreadInfoPtr **iothreads); + qemuMonitorIOThreadInfoPtr **iothreads, + bool supportPolling); typedef struct _qemuMonitorMemoryDeviceInfo qemuMonitorMemoryDeviceInfo; typedef qemuMonitorMemoryDeviceInfo *qemuMonitorMemoryDeviceInfoPtr; diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c index 1d281af48e..ab73f7aaf6 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -6738,7 +6738,8 @@ qemuMonitorJSONRTCResetReinjection(qemuMonitorPtr mon) */ int qemuMonitorJSONGetIOThreads(qemuMonitorPtr mon, - qemuMonitorIOThreadInfoPtr **iothreads) + qemuMonitorIOThreadInfoPtr **iothreads, + bool supportPolling) { int ret = -1; virJSONValuePtr cmd; @@ -6804,6 +6805,22 @@ qemuMonitorJSONGetIOThreads(qemuMonitorPtr mon, "'thread-id' data")); goto cleanup; } + +#define VIR_IOTHREAD_GET_POLL_DATA(prop, store) \ + if (supportPolling && \ + virJSONValueObjectGetNumberInt(child, prop, &store) < 0) { \ + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", \ + _("query-iothreads reply has malformed " \ + "'" prop "' data")); \ + goto cleanup; \ + } + + VIR_IOTHREAD_GET_POLL_DATA("poll-max-ns", info->poll_max_ns) + VIR_IOTHREAD_GET_POLL_DATA("poll-grow", info->poll_grow) + VIR_IOTHREAD_GET_POLL_DATA("poll-shrink", info->poll_shrink) + +#undef VIR_IOTHREAD_GET_DATA + } ret = n; diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h index 79688c82f7..0f557a2991 100644 --- a/src/qemu/qemu_monitor_json.h +++ b/src/qemu/qemu_monitor_json.h @@ -480,7 +480,8 @@ int qemuMonitorJSONGetGuestCPU(qemuMonitorPtr mon, int qemuMonitorJSONRTCResetReinjection(qemuMonitorPtr mon); int qemuMonitorJSONGetIOThreads(qemuMonitorPtr mon, - qemuMonitorIOThreadInfoPtr **iothreads) + qemuMonitorIOThreadInfoPtr **iothreads, + bool supportPolling) ATTRIBUTE_NONNULL(2); int qemuMonitorJSONGetMemoryDeviceInfo(qemuMonitorPtr mon, diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index 522f49d8b7..9eb4dfd5fa 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -2104,7 +2104,7 @@ qemuProcessDetectIOThreadPIDs(virQEMUDriverPtr driver, /* Get the list of IOThreads from qemu */ if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) goto cleanup; - niothreads = qemuMonitorGetIOThreads(priv->mon, &iothreads); + niothreads = qemuMonitorGetIOThreads(priv->mon, &iothreads, false); if (qemuDomainObjExitMonitor(driver, vm) < 0) goto cleanup; if (niothreads < 0) diff --git a/tests/qemumonitorjsontest.c b/tests/qemumonitorjsontest.c index 5b2d6bb343..c9c1f2cada 100644 --- a/tests/qemumonitorjsontest.c +++ b/tests/qemumonitorjsontest.c @@ -2488,7 +2488,7 @@ testQemuMonitorJSONGetIOThreads(const void *data) goto cleanup; if ((ninfo = qemuMonitorGetIOThreads(qemuMonitorTestGetMonitor(test), - &info)) < 0) + &info, false)) < 0) goto cleanup; if (ninfo != 2) { -- 2.11.1

Signed-off-by: Pavel Hrdina <phrdina(a)redhat.com&gt; --- src/conf/domain_conf.c | 4 +- src/conf/domain_conf.h | 2 +- src/qemu/qemu_driver.c | 182 +++++++++++++++++++++++++++++++++++++------------ 3 files changed, 140 insertions(+), 48 deletions(-) diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index 4b552a9175..64303a6790 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -20348,14 +20348,14 @@ virDomainIOThreadIDFind(const virDomainDef *def, virDomainIOThreadIDDefPtr virDomainIOThreadIDAdd(virDomainDefPtr def, - unsigned int iothread_id) + virDomainIOThreadIDDef iothread) { virDomainIOThreadIDDefPtr iothrid = NULL; if (VIR_ALLOC(iothrid) < 0) goto error; - iothrid->iothread_id = iothread_id; + *iothrid = iothread; if (VIR_APPEND_ELEMENT_COPY(def->iothreadids, def->niothreadids, iothrid) < 0) diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h index 8ac1d8a409..5f8c745d8a 100644 --- a/src/conf/domain_conf.h +++ b/src/conf/domain_conf.h @@ -2791,7 +2791,7 @@ int virDomainDefAddImplicitDevices(virDomainDefPtr def); virDomainIOThreadIDDefPtr virDomainIOThreadIDFind(const virDomainDef *def, unsigned int iothread_id); virDomainIOThreadIDDefPtr virDomainIOThreadIDAdd(virDomainDefPtr def, - unsigned int iothread_id); + virDomainIOThreadIDDef iothread); void virDomainIOThreadIDDel(virDomainDefPtr def, unsigned int iothread_id); unsigned int virDomainDefFormatConvertXMLFlags(unsigned int flags); diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 9e3691b575..96c8b2b8bc 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -5571,7 +5571,7 @@ qemuDomainPinIOThread(virDomainPtr dom, static int qemuDomainHotplugAddIOThread(virQEMUDriverPtr driver, virDomainObjPtr vm, - unsigned int iothread_id) + virDomainIOThreadIDDef iothread) { qemuDomainObjPrivatePtr priv = vm->privateData; char *alias = NULL; @@ -5583,14 +5583,18 @@ qemuDomainHotplugAddIOThread(virQEMUDriverPtr driver, int new_niothreads = 0; bool supportPolling = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_IOTHREAD_POLLING); qemuMonitorIOThreadInfoPtr *new_iothreads = NULL; - virDomainIOThreadIDDefPtr iothrid; + virDomainIOThreadIDDefPtr new_iothread = NULL; + virJSONValuePtr props = NULL; - if (virAsprintf(&alias, "iothread%u", iothread_id) < 0) + if (virAsprintf(&alias, "iothread%u", iothread.iothread_id) < 0) return -1; qemuDomainObjEnterMonitor(driver, vm); - rc = qemuMonitorAddObject(priv->mon, "iothread", alias, NULL); + if (qemuBuildIOThreadProps(&iothread, priv->qemuCaps, &props) < 0) + goto cleanup; + + rc = qemuMonitorAddObject(priv->mon, "iothread", alias, props); exp_niothreads++; if (rc < 0) goto exit_monitor; @@ -5620,23 +5624,23 @@ qemuDomainHotplugAddIOThread(virQEMUDriverPtr driver, * in the QEMU IOThread list, so we can add it to our iothreadids list */ for (idx = 0; idx < new_niothreads; idx++) { - if (new_iothreads[idx]->iothread_id == iothread_id) + if (new_iothreads[idx]->iothread_id == iothread.iothread_id) break; } if (idx == new_niothreads) { virReportError(VIR_ERR_INTERNAL_ERROR, _("cannot find new IOThread '%u' in QEMU monitor."), - iothread_id); + iothread.iothread_id); goto cleanup; } - if (!(iothrid = virDomainIOThreadIDAdd(vm->def, iothread_id))) + if (!(new_iothread = virDomainIOThreadIDAdd(vm->def, iothread))) goto cleanup; - qemuDomainIOThreadUpdate(iothrid, new_iothreads[idx], supportPolling); + qemuDomainIOThreadUpdate(new_iothread, new_iothreads[idx], supportPolling); - if (qemuProcessSetupIOThread(vm, iothrid) < 0) + if (qemuProcessSetupIOThread(vm, new_iothread) < 0) goto cleanup; ret = 0; @@ -5649,6 +5653,7 @@ qemuDomainHotplugAddIOThread(virQEMUDriverPtr driver, } virDomainAuditIOThread(vm, orig_niothreads, new_niothreads, "update", rc == 0); + virJSONValueFree(props); VIR_FREE(alias); return ret; @@ -5773,10 +5778,73 @@ qemuDomainDelIOThreadCheck(virDomainDefPtr def, return 0; } + +static int +qemuDomainIOThreadParseParams(virTypedParameterPtr params, + int nparams, + qemuDomainObjPrivatePtr priv, + virDomainIOThreadIDDefPtr iothread) +{ + int poll_enabled; + int rc; + + if (virTypedParamsValidate(params, nparams, + VIR_DOMAIN_IOTHREAD_POLL_ENABLED, + VIR_TYPED_PARAM_BOOLEAN, + VIR_DOMAIN_IOTHREAD_POLL_MAX_NS, + VIR_TYPED_PARAM_UINT, + VIR_DOMAIN_IOTHREAD_POLL_GROW, + VIR_TYPED_PARAM_UINT, + VIR_DOMAIN_IOTHREAD_POLL_SHRINK, + VIR_TYPED_PARAM_UINT, + NULL) < 0) + return -1; + + if ((rc = virTypedParamsGetBoolean(params, nparams, + VIR_DOMAIN_IOTHREAD_POLL_ENABLED, + &poll_enabled)) < 0) + return -1; + + if (rc > 0) { + if (poll_enabled) + iothread->poll_enabled = VIR_TRISTATE_BOOL_YES; + else + iothread->poll_enabled = VIR_TRISTATE_BOOL_NO; + } + + if (virTypedParamsGetUInt(params, nparams, + VIR_DOMAIN_IOTHREAD_POLL_MAX_NS, + &iothread->poll_max_ns) < 0) + return -1; + + if (virTypedParamsGetUInt(params, nparams, + VIR_DOMAIN_IOTHREAD_POLL_GROW, + &iothread->poll_grow) < 0) + return -1; + + if (virTypedParamsGetUInt(params, nparams, + VIR_DOMAIN_IOTHREAD_POLL_SHRINK, + &iothread->poll_shrink) < 0) + return -1; + + if (virDomainIOThreadDefPostParse(iothread) < 0) + return -1; + + if (iothread->poll_enabled != VIR_TRISTATE_BOOL_ABSENT && + !virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_IOTHREAD_POLLING)) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("IOThreads polling is not supported for this QEMU")); + return -1; + } + + return 0; +} + + static int qemuDomainChgIOThread(virQEMUDriverPtr driver, virDomainObjPtr vm, - unsigned int iothread_id, + virDomainIOThreadIDDef iothread, bool add, unsigned int flags) { @@ -5804,36 +5872,39 @@ qemuDomainChgIOThread(virQEMUDriverPtr driver, } if (add) { - if (qemuDomainAddIOThreadCheck(def, iothread_id) < 0) + if (qemuDomainAddIOThreadCheck(def, iothread.iothread_id) < 0) goto endjob; - if (qemuDomainHotplugAddIOThread(driver, vm, iothread_id) < 0) + if (qemuDomainHotplugAddIOThread(driver, vm, iothread) < 0) goto endjob; } else { - if (qemuDomainDelIOThreadCheck(def, iothread_id) < 0) + if (qemuDomainDelIOThreadCheck(def, iothread.iothread_id) < 0) goto endjob; - if (qemuDomainHotplugDelIOThread(driver, vm, iothread_id) < 0) + if (qemuDomainHotplugDelIOThread(driver, vm, + iothread.iothread_id) < 0) goto endjob; } - if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm, driver->caps) < 0) + if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm, + driver->caps) < 0) goto endjob; } if (persistentDef) { if (add) { - if (qemuDomainAddIOThreadCheck(persistentDef, iothread_id) < 0) + if (qemuDomainAddIOThreadCheck(persistentDef, + iothread.iothread_id) < 0) goto endjob; - if (!virDomainIOThreadIDAdd(persistentDef, iothread_id)) + if (!virDomainIOThreadIDAdd(persistentDef, iothread)) goto endjob; - } else { - if (qemuDomainDelIOThreadCheck(persistentDef, iothread_id) < 0) + if (qemuDomainDelIOThreadCheck(persistentDef, + iothread.iothread_id) < 0) goto endjob; - virDomainIOThreadIDDel(persistentDef, iothread_id); + virDomainIOThreadIDDel(persistentDef, iothread.iothread_id); } if (virDomainSaveConfig(cfg->configDir, driver->caps, @@ -5851,35 +5922,53 @@ qemuDomainChgIOThread(virQEMUDriverPtr driver, return ret; } + +static int +qemuDomainAddIOThreadParams(virDomainPtr dom, + unsigned int iothread_id, + virTypedParameterPtr params, + int nparams, + unsigned int flags) +{ + virQEMUDriverPtr driver = dom->conn->privateData; + virDomainObjPtr vm = NULL; + virDomainIOThreadIDDef iothread = {0}; + int ret = -1; + + virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | + VIR_DOMAIN_AFFECT_CONFIG, -1); + + if (iothread_id == 0) { + virReportError(VIR_ERR_INVALID_ARG, "%s", + _("invalid value of 0 for iothread_id")); + return -1; + } + iothread.iothread_id = iothread_id; + + if (!(vm = qemuDomObjFromDomain(dom))) + goto cleanup; + + if (qemuDomainIOThreadParseParams(params, nparams, vm->privateData, + &iothread) < 0) + goto cleanup; + + if (virDomainAddIOThreadParamsEnsureACL(dom->conn, vm->def, flags) < 0) + goto cleanup; + + ret = qemuDomainChgIOThread(driver, vm, iothread, true, flags); + + cleanup: + virDomainObjEndAPI(&vm); + return ret; +} + + static int qemuDomainAddIOThread(virDomainPtr dom, unsigned int iothread_id, unsigned int flags) { - virQEMUDriverPtr driver = dom->conn->privateData; - virDomainObjPtr vm = NULL; - int ret = -1; - - virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | - VIR_DOMAIN_AFFECT_CONFIG, -1); - - if (iothread_id == 0) { - virReportError(VIR_ERR_INVALID_ARG, "%s", - _("invalid value of 0 for iothread_id")); - return -1; - } - - if (!(vm = qemuDomObjFromDomain(dom))) - goto cleanup; - - if (virDomainAddIOThreadEnsureACL(dom->conn, vm->def, flags) < 0) - goto cleanup; - - ret = qemuDomainChgIOThread(driver, vm, iothread_id, true, flags); - - cleanup: - virDomainObjEndAPI(&vm); - return ret; + return qemuDomainAddIOThreadParams(dom, iothread_id, NULL, 0, flags); } @@ -5890,6 +5979,7 @@ qemuDomainDelIOThread(virDomainPtr dom, { virQEMUDriverPtr driver = dom->conn->privateData; virDomainObjPtr vm = NULL; + virDomainIOThreadIDDef iothread = {0}; int ret = -1; virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | @@ -5900,6 +5990,7 @@ qemuDomainDelIOThread(virDomainPtr dom, _("invalid value of 0 for iothread_id")); return -1; } + iothread.iothread_id = iothread_id; if (!(vm = qemuDomObjFromDomain(dom))) goto cleanup; @@ -5907,7 +5998,7 @@ qemuDomainDelIOThread(virDomainPtr dom, if (virDomainDelIOThreadEnsureACL(dom->conn, vm->def, flags) < 0) goto cleanup; - ret = qemuDomainChgIOThread(driver, vm, iothread_id, false, flags); + ret = qemuDomainChgIOThread(driver, vm, iothread, false, flags); cleanup: virDomainObjEndAPI(&vm); @@ -20274,6 +20365,7 @@ static virHypervisorDriver qemuHypervisorDriver = { .domainGetIOThreadInfo = qemuDomainGetIOThreadInfo, /* 1.2.14 */ .domainPinIOThread = qemuDomainPinIOThread, /* 1.2.14 */ .domainAddIOThread = qemuDomainAddIOThread, /* 1.2.15 */ + .domainAddIOThreadParams = qemuDomainAddIOThreadParams, /* 3.1.0 */ .domainDelIOThread = qemuDomainDelIOThread, /* 1.2.15 */ .domainGetSecurityLabel = qemuDomainGetSecurityLabel, /* 0.6.1 */ .domainGetSecurityLabelList = qemuDomainGetSecurityLabelList, /* 0.10.0 */ -- 2.11.1

Signed-off-by: Pavel Hrdina <phrdina(a)redhat.com&gt; --- docs/news.xml | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/docs/news.xml b/docs/news.xml index 8d53e07973..5544fefae9 100644 --- a/docs/news.xml +++ b/docs/news.xml @@ -80,6 +80,15 @@ devices, providing device type information. </description> </change> + <change> + <summary> + iothread: add support for polling mechanism + </summary> + <description> + Add a new &lt;polling&gt; element for iothreads that allows to + configure polling feature instead of blocking syscalls. + </description> + </change> </section> <section title="Improvements"> <change> -- 2.11.1