Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; Reviewed-by: Ján Tomko <jtomko(a)redhat.com&gt; --- src/qemu/qemu_driver.c | 4 ++-- src/qemu/qemu_migration.c | 10 +++++----- src/qemu/qemu_migration.h | 4 ++-- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 5c31dfdd58..cc431ae045 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -13615,7 +13615,7 @@ qemuDomainMigrateGetCompressionCache(virDomainPtr dom, priv = vm->privateData; - if (!qemuMigrationAnyCapsGet(vm, QEMU_MONITOR_MIGRATION_CAPS_XBZRLE)) { + if (!qemuMigrationCapsGet(vm, QEMU_MONITOR_MIGRATION_CAPS_XBZRLE)) { virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", _("Compressed migration is not supported by " "QEMU binary")); @@ -13666,7 +13666,7 @@ qemuDomainMigrateSetCompressionCache(virDomainPtr dom, priv = vm->privateData; - if (!qemuMigrationAnyCapsGet(vm, QEMU_MONITOR_MIGRATION_CAPS_XBZRLE)) { + if (!qemuMigrationCapsGet(vm, QEMU_MONITOR_MIGRATION_CAPS_XBZRLE)) { virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", _("Compressed migration is not supported by " "QEMU binary")); diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 256b994bd9..3890a29d7e 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -1335,7 +1335,7 @@ qemuMigrationOptionSet(virQEMUDriverPtr driver, qemuDomainObjPrivatePtr priv = vm->privateData; int ret; - if (!qemuMigrationAnyCapsGet(vm, capability)) { + if (!qemuMigrationCapsGet(vm, capability)) { if (!state) { /* Unsupported but we want it off anyway */ return 0; @@ -3869,7 +3869,7 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) goto error; - if (qemuMigrationAnyCapsGet(vm, QEMU_MONITOR_MIGRATION_CAPS_PAUSE_BEFORE_SWITCHOVER) && + if (qemuMigrationCapsGet(vm, QEMU_MONITOR_MIGRATION_CAPS_PAUSE_BEFORE_SWITCHOVER) && qemuMigrationOptionSet(driver, vm, QEMU_MONITOR_MIGRATION_CAPS_PAUSE_BEFORE_SWITCHOVER, true, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) @@ -6095,7 +6095,7 @@ qemuMigrationParamsReset(virQEMUDriverPtr driver, goto cleanup; for (cap = 0; cap < QEMU_MONITOR_MIGRATION_CAPS_LAST; cap++) { - if (qemuMigrationAnyCapsGet(vm, cap) && + if (qemuMigrationCapsGet(vm, cap) && qemuMigrationOptionSet(driver, vm, cap, false, job) < 0) goto cleanup; } @@ -6160,8 +6160,8 @@ qemuMigrationSrcFetchMirrorStats(virQEMUDriverPtr driver, bool -qemuMigrationAnyCapsGet(virDomainObjPtr vm, - qemuMonitorMigrationCaps cap) +qemuMigrationCapsGet(virDomainObjPtr vm, + qemuMonitorMigrationCaps cap) { qemuDomainObjPrivatePtr priv = vm->privateData; bool enabled = false; diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h index a075aec124..af96854a73 100644 --- a/src/qemu/qemu_migration.h +++ b/src/qemu/qemu_migration.h @@ -309,7 +309,7 @@ qemuMigrationSrcFetchMirrorStats(virQEMUDriverPtr driver, qemuDomainJobInfoPtr jobInfo); bool -qemuMigrationAnyCapsGet(virDomainObjPtr vm, - qemuMonitorMigrationCaps cap); +qemuMigrationCapsGet(virDomainObjPtr vm, + qemuMonitorMigrationCaps cap); #endif /* __QEMU_MIGRATION_H__ */ -- 2.17.0

In the end, this will allow us to have most of the logic around migration parameters and capabilities done in one place. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- po/POTFILES.in | 1 + src/qemu/Makefile.inc.am | 2 + src/qemu/qemu_driver.c | 1 + src/qemu/qemu_migration.c | 421 +--------------------------- src/qemu/qemu_migration.h | 24 +- src/qemu/qemu_migration_params.c | 454 +++++++++++++++++++++++++++++++ src/qemu/qemu_migration_params.h | 82 ++++++ src/qemu/qemu_process.c | 1 + 8 files changed, 550 insertions(+), 436 deletions(-) create mode 100644 src/qemu/qemu_migration_params.c create mode 100644 src/qemu/qemu_migration_params.h diff --git a/po/POTFILES.in b/po/POTFILES.in index 0dcd1cab28..be2874487c 100644 --- a/po/POTFILES.in +++ b/po/POTFILES.in @@ -136,6 +136,7 @@ src/qemu/qemu_hotplug.c src/qemu/qemu_interface.c src/qemu/qemu_migration.c src/qemu/qemu_migration_cookie.c +src/qemu/qemu_migration_params.c src/qemu/qemu_monitor.c src/qemu/qemu_monitor_json.c src/qemu/qemu_monitor_text.c diff --git a/src/qemu/Makefile.inc.am b/src/qemu/Makefile.inc.am index 8ef290a6c1..25706ba4bc 100644 --- a/src/qemu/Makefile.inc.am +++ b/src/qemu/Makefile.inc.am @@ -33,6 +33,8 @@ QEMU_DRIVER_SOURCES = \ qemu/qemu_migration.h \ qemu/qemu_migration_cookie.c \ qemu/qemu_migration_cookie.h \ + qemu/qemu_migration_params.c \ + qemu/qemu_migration_params.h \ qemu/qemu_monitor.c \ qemu/qemu_monitor.h \ qemu/qemu_monitor_text.c \ diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index f7ad211077..519bd767c1 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -57,6 +57,7 @@ #include "qemu_monitor.h" #include "qemu_process.h" #include "qemu_migration.h" +#include "qemu_migration_params.h" #include "qemu_blockjob.h" #include "qemu_security.h" diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index a0071cc089..34eb3eb9e5 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -29,6 +29,7 @@ #include "qemu_migration.h" #include "qemu_migration_cookie.h" +#include "qemu_migration_params.h" #include "qemu_monitor.h" #include "qemu_domain.h" #include "qemu_process.h" @@ -81,8 +82,6 @@ VIR_ENUM_IMPL(qemuMigrationCompressMethod, QEMU_MIGRATION_COMPRESS_LAST, "mt", ); -#define QEMU_MIGRATION_TLS_ALIAS_BASE "libvirt_migrate" - static int qemuMigrationJobStart(virQEMUDriverPtr driver, virDomainObjPtr vm, @@ -115,156 +114,6 @@ qemuMigrationJobFinish(virQEMUDriverPtr driver, virDomainObjPtr obj) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); -/* qemuMigrationParamsCheckTLSCreds - * @driver: pointer to qemu driver - * @vm: domain object - * @asyncJob: migration job to join - * - * Query the migration parameters looking for the 'tls-creds' parameter. - * If found, then we can support setting or clearing the parameters and thus - * can support TLS for migration. - * - * Returns 0 if we were able to successfully fetch the params and - * additionally if the tls-creds parameter exists, saves it in the - * private domain structure. Returns -1 on failure. - */ -static int -qemuMigrationParamsCheckTLSCreds(virQEMUDriverPtr driver, - virDomainObjPtr vm, - qemuDomainAsyncJob asyncJob) -{ - int ret = -1; - qemuDomainObjPrivatePtr priv = vm->privateData; - qemuMonitorMigrationParams migParams = { 0 }; - - if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) - return -1; - - if (qemuMonitorGetMigrationParams(priv->mon, &migParams) < 0) - goto cleanup; - - /* NB: Could steal NULL pointer too! Let caller decide what to do. */ - VIR_STEAL_PTR(priv->migTLSAlias, migParams.tlsCreds); - - ret = 0; - - cleanup: - if (qemuDomainObjExitMonitor(driver, vm) < 0) - ret = -1; - - qemuMigrationParamsClear(&migParams); - - return ret; -} - - -/* qemuMigrationParamsCheckSetupTLS - * @driver: pointer to qemu driver - * @vm: domain object - * @cfg: configuration pointer - * @asyncJob: migration job to join - * - * Check if TLS is possible and set up the environment. Assumes the caller - * desires to use TLS (e.g. caller found VIR_MIGRATE_TLS flag). - * - * Ensure the qemu.conf has been properly configured to add an entry for - * "migrate_tls_x509_cert_dir". Also check if the "tls-creds" parameter - * was present from a query of migration parameters - * - * Returns 0 on success, -1 on error/failure - */ -static int -qemuMigrationParamsCheckSetupTLS(virQEMUDriverPtr driver, - virQEMUDriverConfigPtr cfg, - virDomainObjPtr vm, - qemuDomainAsyncJob asyncJob) -{ - qemuDomainObjPrivatePtr priv = vm->privateData; - - if (!cfg->migrateTLSx509certdir) { - virReportError(VIR_ERR_OPERATION_INVALID, "%s", - _("host migration TLS directory not configured")); - return -1; - } - - if (qemuMigrationParamsCheckTLSCreds(driver, vm, asyncJob) < 0) - return -1; - - if (!priv->migTLSAlias) { - virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", - _("TLS migration is not supported with this " - "QEMU binary")); - return -1; - } - - /* If there's a secret, then grab/store it now using the connection */ - if (cfg->migrateTLSx509secretUUID && - !(priv->migSecinfo = - qemuDomainSecretInfoTLSNew(priv, QEMU_MIGRATION_TLS_ALIAS_BASE, - cfg->migrateTLSx509secretUUID))) - return -1; - - return 0; -} - - -/* qemuMigrationParamsAddTLSObjects - * @driver: pointer to qemu driver - * @vm: domain object - * @cfg: configuration pointer - * @tlsListen: server or client - * @asyncJob: Migration job to join - * @tlsAlias: alias to be generated for TLS object - * @secAlias: alias to be generated for a secinfo object - * @migParams: migration parameters to set - * - * Create the TLS objects for the migration and set the migParams value - * - * Returns 0 on success, -1 on failure - */ -static int -qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, - virDomainObjPtr vm, - virQEMUDriverConfigPtr cfg, - bool tlsListen, - qemuDomainAsyncJob asyncJob, - char **tlsAlias, - char **secAlias, - qemuMonitorMigrationParamsPtr migParams) -{ - qemuDomainObjPrivatePtr priv = vm->privateData; - virJSONValuePtr tlsProps = NULL; - virJSONValuePtr secProps = NULL; - - if (qemuDomainGetTLSObjects(priv->qemuCaps, priv->migSecinfo, - cfg->migrateTLSx509certdir, tlsListen, - cfg->migrateTLSx509verify, - QEMU_MIGRATION_TLS_ALIAS_BASE, - &tlsProps, tlsAlias, &secProps, secAlias) < 0) - goto error; - - /* Ensure the domain doesn't already have the TLS objects defined... - * This should prevent any issues just in case some cleanup wasn't - * properly completed (both src and dst use the same alias) or - * some other error path between now and perform . */ - qemuDomainDelTLSObjects(driver, vm, asyncJob, *secAlias, *tlsAlias); - - if (qemuDomainAddTLSObjects(driver, vm, asyncJob, *secAlias, &secProps, - *tlsAlias, &tlsProps) < 0) - goto error; - - if (VIR_STRDUP(migParams->tlsCreds, *tlsAlias) < 0) - goto error; - - return 0; - - error: - virJSONValueFree(tlsProps); - virJSONValueFree(secProps); - return -1; -} - - static void qemuMigrationSrcStoreDomainState(virDomainObjPtr vm) { @@ -1325,7 +1174,7 @@ qemuMigrationAnyPostcopyFailed(virQEMUDriverPtr driver, } -static int +int qemuMigrationOptionSet(virQEMUDriverPtr driver, virDomainObjPtr vm, qemuMonitorMigrationCaps capability, @@ -2363,238 +2212,6 @@ qemuMigrationDstPrepare(virDomainObjPtr vm, return inc; } -static int -qemuMigrationParamsSetCompression(virQEMUDriverPtr driver, - virDomainObjPtr vm, - qemuDomainAsyncJob job, - qemuMigrationCompressionPtr compression, - qemuMonitorMigrationParamsPtr migParams) -{ - int ret = -1; - qemuDomainObjPrivatePtr priv = vm->privateData; - - if (qemuMigrationOptionSet(driver, vm, - QEMU_MONITOR_MIGRATION_CAPS_XBZRLE, - compression->methods & - (1ULL << QEMU_MIGRATION_COMPRESS_XBZRLE), - job) < 0) - return -1; - - if (qemuMigrationOptionSet(driver, vm, - QEMU_MONITOR_MIGRATION_CAPS_COMPRESS, - compression->methods & - (1ULL << QEMU_MIGRATION_COMPRESS_MT), - job) < 0) - return -1; - - if (qemuDomainObjEnterMonitorAsync(driver, vm, job) < 0) - return -1; - - migParams->compressLevel_set = compression->level_set; - migParams->compressLevel = compression->level; - - migParams->compressThreads_set = compression->threads_set; - migParams->compressThreads = compression->threads; - - migParams->decompressThreads_set = compression->dthreads_set; - migParams->decompressThreads = compression->dthreads; - - if (compression->xbzrle_cache_set && - qemuMonitorSetMigrationCacheSize(priv->mon, - compression->xbzrle_cache) < 0) - goto cleanup; - - ret = 0; - - cleanup: - if (qemuDomainObjExitMonitor(driver, vm) < 0) - ret = -1; - - return ret; -} - - -void -qemuMigrationParamsClear(qemuMonitorMigrationParamsPtr migParams) -{ - if (!migParams) - return; - - VIR_FREE(migParams->tlsCreds); - VIR_FREE(migParams->tlsHostname); -} - - -void -qemuMigrationParamsFree(qemuMonitorMigrationParamsPtr *migParams) -{ - if (!*migParams) - return; - - qemuMigrationParamsClear(*migParams); - VIR_FREE(*migParams); -} - - -/* qemuMigrationParamsSetEmptyTLS - * @driver: pointer to qemu driver - * @vm: domain object - * @asyncJob: migration job to join - * @migParams: Pointer to a migration parameters block - * - * If we support setting the tls-creds, then set both tls-creds and - * tls-hostname to the empty string ("") which indicates to not use - * TLS on this migration. - * - * Returns 0 on success, -1 on failure - */ -static int -qemuMigrationParamsSetEmptyTLS(virQEMUDriverPtr driver, - virDomainObjPtr vm, - qemuDomainAsyncJob asyncJob, - qemuMonitorMigrationParamsPtr migParams) -{ - qemuDomainObjPrivatePtr priv = vm->privateData; - - if (qemuMigrationParamsCheckTLSCreds(driver, vm, asyncJob) < 0) - return -1; - - if (!priv->migTLSAlias) - return 0; - - if (VIR_STRDUP(migParams->tlsCreds, "") < 0 || - VIR_STRDUP(migParams->tlsHostname, "") < 0) - return -1; - - return 0; -} - - -qemuMonitorMigrationParamsPtr -qemuMigrationParamsFromFlags(virTypedParameterPtr params, - int nparams, - unsigned long flags) -{ - qemuMonitorMigrationParamsPtr migParams; - - if (VIR_ALLOC(migParams) < 0) - return NULL; - - if (!params) - return migParams; - -#define GET(PARAM, VAR) \ - do { \ - int rc; \ - if ((rc = virTypedParamsGetInt(params, nparams, \ - VIR_MIGRATE_PARAM_ ## PARAM, \ - &migParams->VAR)) < 0) \ - goto error; \ - \ - if (rc == 1) \ - migParams->VAR ## _set = true; \ - } while (0) - - GET(AUTO_CONVERGE_INITIAL, cpuThrottleInitial); - GET(AUTO_CONVERGE_INCREMENT, cpuThrottleIncrement); - -#undef GET - - if ((migParams->cpuThrottleInitial_set || - migParams->cpuThrottleIncrement_set) && - !(flags & VIR_MIGRATE_AUTO_CONVERGE)) { - virReportError(VIR_ERR_INVALID_ARG, "%s", - _("Turn auto convergence on to tune it")); - goto error; - } - - return migParams; - - error: - qemuMigrationParamsFree(&migParams); - return NULL; -} - - -static int -qemuMigrationParamsSet(virQEMUDriverPtr driver, - virDomainObjPtr vm, - qemuDomainAsyncJob job, - qemuMonitorMigrationParamsPtr migParams) -{ - qemuDomainObjPrivatePtr priv = vm->privateData; - int ret = -1; - - if (qemuDomainObjEnterMonitorAsync(driver, vm, job) < 0) - return -1; - - if (qemuMonitorSetMigrationParams(priv->mon, migParams) < 0) - goto cleanup; - - ret = 0; - - cleanup: - if (qemuDomainObjExitMonitor(driver, vm) < 0) - ret = -1; - - return ret; -} - - -/* qemuMigrationParamsResetTLS - * @driver: pointer to qemu driver - * @vm: domain object - * @asyncJob: migration job to join - * - * Deconstruct all the setup possibly done for TLS - delete the TLS and - * security objects, free the secinfo, and reset the migration params to "". - * - * Returns 0 on success, -1 on failure - */ -static int -qemuMigrationParamsResetTLS(virQEMUDriverPtr driver, - virDomainObjPtr vm, - qemuDomainAsyncJob asyncJob) -{ - qemuDomainObjPrivatePtr priv = vm->privateData; - char *tlsAlias = NULL; - char *secAlias = NULL; - qemuMonitorMigrationParams migParams = { 0 }; - int ret = -1; - - if (qemuMigrationParamsCheckTLSCreds(driver, vm, asyncJob) < 0) - return -1; - - /* If the tls-creds doesn't exist or if they're set to "" then there's - * nothing to do since we never set anything up */ - if (!priv->migTLSAlias || !*priv->migTLSAlias) - return 0; - - /* NB: If either or both fail to allocate memory we can still proceed - * since the next time we migrate another deletion attempt will be - * made after successfully generating the aliases. */ - tlsAlias = qemuAliasTLSObjFromSrcAlias(QEMU_MIGRATION_TLS_ALIAS_BASE); - secAlias = qemuDomainGetSecretAESAlias(QEMU_MIGRATION_TLS_ALIAS_BASE, false); - - qemuDomainDelTLSObjects(driver, vm, asyncJob, secAlias, tlsAlias); - qemuDomainSecretInfoFree(&priv->migSecinfo); - - if (VIR_STRDUP(migParams.tlsCreds, "") < 0 || - VIR_STRDUP(migParams.tlsHostname, "") < 0 || - qemuMigrationParamsSet(driver, vm, asyncJob, &migParams) < 0) - goto cleanup; - - ret = 0; - - cleanup: - VIR_FREE(tlsAlias); - VIR_FREE(secAlias); - qemuMigrationParamsClear(&migParams); - - return ret; -} - - static int qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, virConnectPtr dconn, @@ -6074,40 +5691,6 @@ qemuMigrationAnyCompressionDump(qemuMigrationCompressionPtr compression, } -/* - * qemuMigrationParamsReset: - * - * Reset all migration parameters so that the next job which internally uses - * migration (save, managedsave, snapshots, dump) will not try to use them. - */ -void -qemuMigrationParamsReset(virQEMUDriverPtr driver, - virDomainObjPtr vm, - qemuDomainAsyncJob job) -{ - qemuMonitorMigrationCaps cap; - virErrorPtr err = virSaveLastError(); - - if (!virDomainObjIsActive(vm)) - goto cleanup; - - if (qemuMigrationParamsResetTLS(driver, vm, job) < 0) - goto cleanup; - - for (cap = 0; cap < QEMU_MONITOR_MIGRATION_CAPS_LAST; cap++) { - if (qemuMigrationCapsGet(vm, cap) && - qemuMigrationOptionSet(driver, vm, cap, false, job) < 0) - goto cleanup; - } - - cleanup: - if (err) { - virSetError(err); - virFreeError(err); - } -} - - int qemuMigrationSrcFetchMirrorStats(virQEMUDriverPtr driver, virDomainObjPtr vm, diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h index 3424404dc4..adf788c909 100644 --- a/src/qemu/qemu_migration.h +++ b/src/qemu/qemu_migration.h @@ -34,7 +34,6 @@ * * Exceptions: * - * - qemuMigrationParamsXXX - runs on source or dest host * - qemuMigrationOptionXXX - runs on source or dest host * - qemuMigrationJobXXX - runs on source or dest host */ @@ -136,17 +135,6 @@ qemuMigrationAnyCompressionDump(qemuMigrationCompressionPtr compression, int *maxparams, unsigned long *flags); -void -qemuMigrationParamsClear(qemuMonitorMigrationParamsPtr migParams); - -void -qemuMigrationParamsFree(qemuMonitorMigrationParamsPtr *migParams); - -qemuMonitorMigrationParamsPtr -qemuMigrationParamsFromFlags(virTypedParameterPtr params, - int nparams, - unsigned long flags); - int qemuMigrationSrcSetOffline(virQEMUDriverPtr driver, virDomainObjPtr vm); @@ -297,11 +285,6 @@ void qemuMigrationAnyPostcopyFailed(virQEMUDriverPtr driver, virDomainObjPtr vm); -void -qemuMigrationParamsReset(virQEMUDriverPtr driver, - virDomainObjPtr vm, - qemuDomainAsyncJob job); - int qemuMigrationSrcFetchMirrorStats(virQEMUDriverPtr driver, virDomainObjPtr vm, @@ -312,4 +295,11 @@ bool qemuMigrationCapsGet(virDomainObjPtr vm, qemuMonitorMigrationCaps cap); +int +qemuMigrationOptionSet(virQEMUDriverPtr driver, + virDomainObjPtr vm, + qemuMonitorMigrationCaps capability, + bool state, + qemuDomainAsyncJob job); + #endif /* __QEMU_MIGRATION_H__ */ diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c new file mode 100644 index 0000000000..72ecafd057 --- /dev/null +++ b/src/qemu/qemu_migration_params.c @@ -0,0 +1,454 @@ +/* + * qemu_migration_params.c: QEMU migration parameters handling + * + * Copyright (C) 2006-2018 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * <http://www.gnu.org/licenses/>;. + * + */ + +#include <config.h> + +#include "virlog.h" +#include "virerror.h" +#include "viralloc.h" +#include "virstring.h" + +#include "qemu_alias.h" +#include "qemu_hotplug.h" +#include "qemu_migration.h" +#include "qemu_migration_params.h" + +#define VIR_FROM_THIS VIR_FROM_QEMU + +VIR_LOG_INIT("qemu.qemu_migration_params"); + +#define QEMU_MIGRATION_TLS_ALIAS_BASE "libvirt_migrate" + + +void +qemuMigrationParamsClear(qemuMonitorMigrationParamsPtr migParams) +{ + if (!migParams) + return; + + VIR_FREE(migParams->tlsCreds); + VIR_FREE(migParams->tlsHostname); +} + + +void +qemuMigrationParamsFree(qemuMonitorMigrationParamsPtr *migParams) +{ + if (!*migParams) + return; + + qemuMigrationParamsClear(*migParams); + VIR_FREE(*migParams); +} + + +qemuMonitorMigrationParamsPtr +qemuMigrationParamsFromFlags(virTypedParameterPtr params, + int nparams, + unsigned long flags) +{ + qemuMonitorMigrationParamsPtr migParams; + + if (VIR_ALLOC(migParams) < 0) + return NULL; + + if (!params) + return migParams; + +#define GET(PARAM, VAR) \ + do { \ + int rc; \ + if ((rc = virTypedParamsGetInt(params, nparams, \ + VIR_MIGRATE_PARAM_ ## PARAM, \ + &migParams->VAR)) < 0) \ + goto error; \ + \ + if (rc == 1) \ + migParams->VAR ## _set = true; \ + } while (0) + + GET(AUTO_CONVERGE_INITIAL, cpuThrottleInitial); + GET(AUTO_CONVERGE_INCREMENT, cpuThrottleIncrement); + +#undef GET + + if ((migParams->cpuThrottleInitial_set || + migParams->cpuThrottleIncrement_set) && + !(flags & VIR_MIGRATE_AUTO_CONVERGE)) { + virReportError(VIR_ERR_INVALID_ARG, "%s", + _("Turn auto convergence on to tune it")); + goto error; + } + + return migParams; + + error: + qemuMigrationParamsFree(&migParams); + return NULL; +} + + +int +qemuMigrationParamsSet(virQEMUDriverPtr driver, + virDomainObjPtr vm, + int asyncJob, + qemuMonitorMigrationParamsPtr migParams) +{ + qemuDomainObjPrivatePtr priv = vm->privateData; + int ret = -1; + + if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) + return -1; + + if (qemuMonitorSetMigrationParams(priv->mon, migParams) < 0) + goto cleanup; + + ret = 0; + + cleanup: + if (qemuDomainObjExitMonitor(driver, vm) < 0) + ret = -1; + + return ret; +} + + +/* qemuMigrationParamsCheckTLSCreds + * @driver: pointer to qemu driver + * @vm: domain object + * @asyncJob: migration job to join + * + * Query the migration parameters looking for the 'tls-creds' parameter. + * If found, then we can support setting or clearing the parameters and thus + * can support TLS for migration. + * + * Returns 0 if we were able to successfully fetch the params and + * additionally if the tls-creds parameter exists, saves it in the + * private domain structure. Returns -1 on failure. + */ +static int +qemuMigrationParamsCheckTLSCreds(virQEMUDriverPtr driver, + virDomainObjPtr vm, + int asyncJob) +{ + int ret = -1; + qemuDomainObjPrivatePtr priv = vm->privateData; + qemuMonitorMigrationParams migParams = { 0 }; + + if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) + return -1; + + if (qemuMonitorGetMigrationParams(priv->mon, &migParams) < 0) + goto cleanup; + + /* NB: Could steal NULL pointer too! Let caller decide what to do. */ + VIR_STEAL_PTR(priv->migTLSAlias, migParams.tlsCreds); + + ret = 0; + + cleanup: + if (qemuDomainObjExitMonitor(driver, vm) < 0) + ret = -1; + + qemuMigrationParamsClear(&migParams); + + return ret; +} + + +/* qemuMigrationParamsCheckSetupTLS + * @driver: pointer to qemu driver + * @vm: domain object + * @cfg: configuration pointer + * @asyncJob: migration job to join + * + * Check if TLS is possible and set up the environment. Assumes the caller + * desires to use TLS (e.g. caller found VIR_MIGRATE_TLS flag). + * + * Ensure the qemu.conf has been properly configured to add an entry for + * "migrate_tls_x509_cert_dir". Also check if the "tls-creds" parameter + * was present from a query of migration parameters + * + * Returns 0 on success, -1 on error/failure + */ +int +qemuMigrationParamsCheckSetupTLS(virQEMUDriverPtr driver, + virQEMUDriverConfigPtr cfg, + virDomainObjPtr vm, + int asyncJob) +{ + qemuDomainObjPrivatePtr priv = vm->privateData; + + if (!cfg->migrateTLSx509certdir) { + virReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("host migration TLS directory not configured")); + return -1; + } + + if (qemuMigrationParamsCheckTLSCreds(driver, vm, asyncJob) < 0) + return -1; + + if (!priv->migTLSAlias) { + virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", + _("TLS migration is not supported with this " + "QEMU binary")); + return -1; + } + + /* If there's a secret, then grab/store it now using the connection */ + if (cfg->migrateTLSx509secretUUID && + !(priv->migSecinfo = + qemuDomainSecretInfoTLSNew(priv, QEMU_MIGRATION_TLS_ALIAS_BASE, + cfg->migrateTLSx509secretUUID))) + return -1; + + return 0; +} + + +/* qemuMigrationParamsAddTLSObjects + * @driver: pointer to qemu driver + * @vm: domain object + * @cfg: configuration pointer + * @tlsListen: server or client + * @asyncJob: Migration job to join + * @tlsAlias: alias to be generated for TLS object + * @secAlias: alias to be generated for a secinfo object + * @migParams: migration parameters to set + * + * Create the TLS objects for the migration and set the migParams value + * + * Returns 0 on success, -1 on failure + */ +int +qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, + virDomainObjPtr vm, + virQEMUDriverConfigPtr cfg, + bool tlsListen, + int asyncJob, + char **tlsAlias, + char **secAlias, + qemuMonitorMigrationParamsPtr migParams) +{ + qemuDomainObjPrivatePtr priv = vm->privateData; + virJSONValuePtr tlsProps = NULL; + virJSONValuePtr secProps = NULL; + + if (qemuDomainGetTLSObjects(priv->qemuCaps, priv->migSecinfo, + cfg->migrateTLSx509certdir, tlsListen, + cfg->migrateTLSx509verify, + QEMU_MIGRATION_TLS_ALIAS_BASE, + &tlsProps, tlsAlias, &secProps, secAlias) < 0) + goto error; + + /* Ensure the domain doesn't already have the TLS objects defined... + * This should prevent any issues just in case some cleanup wasn't + * properly completed (both src and dst use the same alias) or + * some other error path between now and perform . */ + qemuDomainDelTLSObjects(driver, vm, asyncJob, *secAlias, *tlsAlias); + + if (qemuDomainAddTLSObjects(driver, vm, asyncJob, *secAlias, &secProps, + *tlsAlias, &tlsProps) < 0) + goto error; + + if (VIR_STRDUP(migParams->tlsCreds, *tlsAlias) < 0) + goto error; + + return 0; + + error: + virJSONValueFree(tlsProps); + virJSONValueFree(secProps); + return -1; +} + + +/* qemuMigrationParamsSetEmptyTLS + * @driver: pointer to qemu driver + * @vm: domain object + * @asyncJob: migration job to join + * @migParams: Pointer to a migration parameters block + * + * If we support setting the tls-creds, then set both tls-creds and + * tls-hostname to the empty string ("") which indicates to not use + * TLS on this migration. + * + * Returns 0 on success, -1 on failure + */ +int +qemuMigrationParamsSetEmptyTLS(virQEMUDriverPtr driver, + virDomainObjPtr vm, + int asyncJob, + qemuMonitorMigrationParamsPtr migParams) +{ + qemuDomainObjPrivatePtr priv = vm->privateData; + + if (qemuMigrationParamsCheckTLSCreds(driver, vm, asyncJob) < 0) + return -1; + + if (!priv->migTLSAlias) + return 0; + + if (VIR_STRDUP(migParams->tlsCreds, "") < 0 || + VIR_STRDUP(migParams->tlsHostname, "") < 0) + return -1; + + return 0; +} + + +int +qemuMigrationParamsSetCompression(virQEMUDriverPtr driver, + virDomainObjPtr vm, + int asyncJob, + qemuMigrationCompressionPtr compression, + qemuMonitorMigrationParamsPtr migParams) +{ + int ret = -1; + qemuDomainObjPrivatePtr priv = vm->privateData; + + if (qemuMigrationOptionSet(driver, vm, + QEMU_MONITOR_MIGRATION_CAPS_XBZRLE, + compression->methods & + (1ULL << QEMU_MIGRATION_COMPRESS_XBZRLE), + asyncJob) < 0) + return -1; + + if (qemuMigrationOptionSet(driver, vm, + QEMU_MONITOR_MIGRATION_CAPS_COMPRESS, + compression->methods & + (1ULL << QEMU_MIGRATION_COMPRESS_MT), + asyncJob) < 0) + return -1; + + if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) + return -1; + + migParams->compressLevel_set = compression->level_set; + migParams->compressLevel = compression->level; + + migParams->compressThreads_set = compression->threads_set; + migParams->compressThreads = compression->threads; + + migParams->decompressThreads_set = compression->dthreads_set; + migParams->decompressThreads = compression->dthreads; + + if (compression->xbzrle_cache_set && + qemuMonitorSetMigrationCacheSize(priv->mon, + compression->xbzrle_cache) < 0) + goto cleanup; + + ret = 0; + + cleanup: + if (qemuDomainObjExitMonitor(driver, vm) < 0) + ret = -1; + + return ret; +} + + +/* qemuMigrationParamsResetTLS + * @driver: pointer to qemu driver + * @vm: domain object + * @asyncJob: migration job to join + * + * Deconstruct all the setup possibly done for TLS - delete the TLS and + * security objects, free the secinfo, and reset the migration params to "". + * + * Returns 0 on success, -1 on failure + */ +static int +qemuMigrationParamsResetTLS(virQEMUDriverPtr driver, + virDomainObjPtr vm, + int asyncJob) +{ + qemuDomainObjPrivatePtr priv = vm->privateData; + char *tlsAlias = NULL; + char *secAlias = NULL; + qemuMonitorMigrationParams migParams = { 0 }; + int ret = -1; + + if (qemuMigrationParamsCheckTLSCreds(driver, vm, asyncJob) < 0) + return -1; + + /* If the tls-creds doesn't exist or if they're set to "" then there's + * nothing to do since we never set anything up */ + if (!priv->migTLSAlias || !*priv->migTLSAlias) + return 0; + + /* NB: If either or both fail to allocate memory we can still proceed + * since the next time we migrate another deletion attempt will be + * made after successfully generating the aliases. */ + tlsAlias = qemuAliasTLSObjFromSrcAlias(QEMU_MIGRATION_TLS_ALIAS_BASE); + secAlias = qemuDomainGetSecretAESAlias(QEMU_MIGRATION_TLS_ALIAS_BASE, false); + + qemuDomainDelTLSObjects(driver, vm, asyncJob, secAlias, tlsAlias); + qemuDomainSecretInfoFree(&priv->migSecinfo); + + if (VIR_STRDUP(migParams.tlsCreds, "") < 0 || + VIR_STRDUP(migParams.tlsHostname, "") < 0 || + qemuMigrationParamsSet(driver, vm, asyncJob, &migParams) < 0) + goto cleanup; + + ret = 0; + + cleanup: + VIR_FREE(tlsAlias); + VIR_FREE(secAlias); + qemuMigrationParamsClear(&migParams); + + return ret; +} + + +/* + * qemuMigrationParamsReset: + * + * Reset all migration parameters so that the next job which internally uses + * migration (save, managedsave, snapshots, dump) will not try to use them. + */ +void +qemuMigrationParamsReset(virQEMUDriverPtr driver, + virDomainObjPtr vm, + int asyncJob) +{ + qemuMonitorMigrationCaps cap; + virErrorPtr err = virSaveLastError(); + + if (!virDomainObjIsActive(vm)) + goto cleanup; + + if (qemuMigrationParamsResetTLS(driver, vm, asyncJob) < 0) + goto cleanup; + + for (cap = 0; cap < QEMU_MONITOR_MIGRATION_CAPS_LAST; cap++) { + if (qemuMigrationCapsGet(vm, cap) && + qemuMigrationOptionSet(driver, vm, cap, false, asyncJob) < 0) + goto cleanup; + } + + cleanup: + if (err) { + virSetError(err); + virFreeError(err); + } +} diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h new file mode 100644 index 0000000000..33b3c27e51 --- /dev/null +++ b/src/qemu/qemu_migration_params.h @@ -0,0 +1,82 @@ +/* + * qemu_migration_params.h: QEMU migration parameters handling + * + * Copyright (C) 2006-2018 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * <http://www.gnu.org/licenses/>;. + * + */ + +#ifndef __QEMU_MIGRATION_PARAMS_H__ +# define __QEMU_MIGRATION_PARAMS_H__ + +# include "internal.h" + +# include "qemu_monitor.h" +# include "qemu_conf.h" + + +qemuMonitorMigrationParamsPtr +qemuMigrationParamsFromFlags(virTypedParameterPtr params, + int nparams, + unsigned long flags); + +void +qemuMigrationParamsClear(qemuMonitorMigrationParamsPtr migParams); + +void +qemuMigrationParamsFree(qemuMonitorMigrationParamsPtr *migParams); + +int +qemuMigrationParamsSet(virQEMUDriverPtr driver, + virDomainObjPtr vm, + int asyncJob, + qemuMonitorMigrationParamsPtr migParams); + +int +qemuMigrationParamsCheckSetupTLS(virQEMUDriverPtr driver, + virQEMUDriverConfigPtr cfg, + virDomainObjPtr vm, + int asyncJob); + +int +qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, + virDomainObjPtr vm, + virQEMUDriverConfigPtr cfg, + bool tlsListen, + int asyncJob, + char **tlsAlias, + char **secAlias, + qemuMonitorMigrationParamsPtr migParams); + +int +qemuMigrationParamsSetEmptyTLS(virQEMUDriverPtr driver, + virDomainObjPtr vm, + int asyncJob, + qemuMonitorMigrationParamsPtr migParams); + +int +qemuMigrationParamsSetCompression(virQEMUDriverPtr driver, + virDomainObjPtr vm, + int asyncJob, + qemuMigrationCompressionPtr compression, + qemuMonitorMigrationParamsPtr migParams); + +void +qemuMigrationParamsReset(virQEMUDriverPtr driver, + virDomainObjPtr vm, + int asyncJob); + +#endif /* __QEMU_MIGRATION_PARAMS_H__ */ diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index f02114c693..7d678046c8 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -45,6 +45,7 @@ #include "qemu_hostdev.h" #include "qemu_hotplug.h" #include "qemu_migration.h" +#include "qemu_migration_params.h" #include "qemu_interface.h" #include "qemu_security.h" -- 2.17.0

Since the function is tightly connected to migration, it was renamed as qemuMigrationCapsCheck and moved to qemu_migration_params.c. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_domain.c | 72 -------------------------------- src/qemu/qemu_domain.h | 4 -- src/qemu/qemu_migration_params.c | 72 ++++++++++++++++++++++++++++++++ src/qemu/qemu_migration_params.h | 5 +++ src/qemu/qemu_process.c | 2 +- 5 files changed, 78 insertions(+), 77 deletions(-) diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c index 100304fd05..84476de11b 100644 --- a/src/qemu/qemu_domain.c +++ b/src/qemu/qemu_domain.c @@ -11798,78 +11798,6 @@ qemuDomainCheckCCWS390AddressSupport(const virDomainDef *def, } -int -qemuDomainCheckMigrationCapabilities(virQEMUDriverPtr driver, - virDomainObjPtr vm, - qemuDomainAsyncJob asyncJob) -{ - qemuDomainObjPrivatePtr priv = vm->privateData; - char **caps = NULL; - char **capStr; - int ret = -1; - int rc; - - if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) - return -1; - - rc = qemuMonitorGetMigrationCapabilities(priv->mon, &caps); - - if (qemuDomainObjExitMonitor(driver, vm) < 0 || rc < 0) - goto cleanup; - - if (!caps) { - ret = 0; - goto cleanup; - } - - priv->migrationCaps = virBitmapNew(QEMU_MONITOR_MIGRATION_CAPS_LAST); - if (!priv->migrationCaps) - goto cleanup; - - for (capStr = caps; *capStr; capStr++) { - int cap = qemuMonitorMigrationCapsTypeFromString(*capStr); - - if (cap < 0) { - VIR_DEBUG("Unknown migration capability: '%s'", *capStr); - } else { - ignore_value(virBitmapSetBit(priv->migrationCaps, cap)); - VIR_DEBUG("Found migration capability: '%s'", *capStr); - } - } - - if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATION_EVENT)) { - if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) - goto cleanup; - - rc = qemuMonitorSetMigrationCapability(priv->mon, - QEMU_MONITOR_MIGRATION_CAPS_EVENTS, - true); - - if (qemuDomainObjExitMonitor(driver, vm) < 0) - goto cleanup; - - if (rc < 0) { - virResetLastError(); - VIR_DEBUG("Cannot enable migration events; clearing capability"); - virQEMUCapsClear(priv->qemuCaps, QEMU_CAPS_MIGRATION_EVENT); - } - } - - /* Migration events capability must always be enabled, clearing it from - * migration capabilities bitmap makes sure it won't be touched anywhere - * else. - */ - ignore_value(virBitmapClearBit(priv->migrationCaps, - QEMU_MONITOR_MIGRATION_CAPS_EVENTS)); - - ret = 0; - - cleanup: - virStringListFree(caps); - return ret; -} - - /** * qemuDomainPrepareDiskSourceChain: * diff --git a/src/qemu/qemu_domain.h b/src/qemu/qemu_domain.h index 21e12f6594..415b2ca093 100644 --- a/src/qemu/qemu_domain.h +++ b/src/qemu/qemu_domain.h @@ -988,10 +988,6 @@ bool qemuDomainCheckCCWS390AddressSupport(const virDomainDef *def, const char *devicename); int -qemuDomainCheckMigrationCapabilities(virQEMUDriverPtr driver, - virDomainObjPtr vm, - qemuDomainAsyncJob asyncJob); -int qemuDomainPrepareDiskSourceChain(virDomainDiskDefPtr disk, virStorageSourcePtr src, virQEMUDriverConfigPtr cfg, diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 72ecafd057..461df876db 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -452,3 +452,75 @@ qemuMigrationParamsReset(virQEMUDriverPtr driver, virFreeError(err); } } + + +int +qemuMigrationCapsCheck(virQEMUDriverPtr driver, + virDomainObjPtr vm, + int asyncJob) +{ + qemuDomainObjPrivatePtr priv = vm->privateData; + char **caps = NULL; + char **capStr; + int ret = -1; + int rc; + + if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) + return -1; + + rc = qemuMonitorGetMigrationCapabilities(priv->mon, &caps); + + if (qemuDomainObjExitMonitor(driver, vm) < 0 || rc < 0) + goto cleanup; + + if (!caps) { + ret = 0; + goto cleanup; + } + + priv->migrationCaps = virBitmapNew(QEMU_MONITOR_MIGRATION_CAPS_LAST); + if (!priv->migrationCaps) + goto cleanup; + + for (capStr = caps; *capStr; capStr++) { + int cap = qemuMonitorMigrationCapsTypeFromString(*capStr); + + if (cap < 0) { + VIR_DEBUG("Unknown migration capability: '%s'", *capStr); + } else { + ignore_value(virBitmapSetBit(priv->migrationCaps, cap)); + VIR_DEBUG("Found migration capability: '%s'", *capStr); + } + } + + if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATION_EVENT)) { + if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) + goto cleanup; + + rc = qemuMonitorSetMigrationCapability(priv->mon, + QEMU_MONITOR_MIGRATION_CAPS_EVENTS, + true); + + if (qemuDomainObjExitMonitor(driver, vm) < 0) + goto cleanup; + + if (rc < 0) { + virResetLastError(); + VIR_DEBUG("Cannot enable migration events; clearing capability"); + virQEMUCapsClear(priv->qemuCaps, QEMU_CAPS_MIGRATION_EVENT); + } + } + + /* Migration events capability must always be enabled, clearing it from + * migration capabilities bitmap makes sure it won't be touched anywhere + * else. + */ + ignore_value(virBitmapClearBit(priv->migrationCaps, + QEMU_MONITOR_MIGRATION_CAPS_EVENTS)); + + ret = 0; + + cleanup: + virStringListFree(caps); + return ret; +} diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index 33b3c27e51..a006357825 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -79,4 +79,9 @@ qemuMigrationParamsReset(virQEMUDriverPtr driver, virDomainObjPtr vm, int asyncJob); +int +qemuMigrationCapsCheck(virQEMUDriverPtr driver, + virDomainObjPtr vm, + int asyncJob); + #endif /* __QEMU_MIGRATION_PARAMS_H__ */ diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index 7d678046c8..11276dace9 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -1840,7 +1840,7 @@ qemuConnectMonitor(virQEMUDriverPtr driver, virDomainObjPtr vm, int asyncJob, if (qemuProcessInitMonitor(driver, vm, asyncJob) < 0) return -1; - if (qemuDomainCheckMigrationCapabilities(driver, vm, asyncJob) < 0) + if (qemuMigrationCapsCheck(driver, vm, asyncJob) < 0) return -1; return 0; -- 2.17.0

The function is connected with the code which handles migration parameters and capabilities, let's move it to qemu_migration_params.c. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 14 -------------- src/qemu/qemu_migration.h | 4 ---- src/qemu/qemu_migration_params.c | 14 ++++++++++++++ src/qemu/qemu_migration_params.h | 4 ++++ 4 files changed, 18 insertions(+), 18 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 34eb3eb9e5..57903c7b17 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -5740,17 +5740,3 @@ qemuMigrationSrcFetchMirrorStats(virQEMUDriverPtr driver, virHashFree(blockinfo); return 0; } - - -bool -qemuMigrationCapsGet(virDomainObjPtr vm, - qemuMonitorMigrationCaps cap) -{ - qemuDomainObjPrivatePtr priv = vm->privateData; - bool enabled = false; - - if (priv->migrationCaps) - ignore_value(virBitmapGetBit(priv->migrationCaps, cap, &enabled)); - - return enabled; -} diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h index adf788c909..3f33d3013d 100644 --- a/src/qemu/qemu_migration.h +++ b/src/qemu/qemu_migration.h @@ -291,10 +291,6 @@ qemuMigrationSrcFetchMirrorStats(virQEMUDriverPtr driver, qemuDomainAsyncJob asyncJob, qemuDomainJobInfoPtr jobInfo); -bool -qemuMigrationCapsGet(virDomainObjPtr vm, - qemuMonitorMigrationCaps cap); - int qemuMigrationOptionSet(virQEMUDriverPtr driver, virDomainObjPtr vm, diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 461df876db..f78e9ad875 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -524,3 +524,17 @@ qemuMigrationCapsCheck(virQEMUDriverPtr driver, virStringListFree(caps); return ret; } + + +bool +qemuMigrationCapsGet(virDomainObjPtr vm, + qemuMonitorMigrationCaps cap) +{ + qemuDomainObjPrivatePtr priv = vm->privateData; + bool enabled = false; + + if (priv->migrationCaps) + ignore_value(virBitmapGetBit(priv->migrationCaps, cap, &enabled)); + + return enabled; +} diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index a006357825..0a68bc0e39 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -84,4 +84,8 @@ qemuMigrationCapsCheck(virQEMUDriverPtr driver, virDomainObjPtr vm, int asyncJob); +bool +qemuMigrationCapsGet(virDomainObjPtr vm, + qemuMonitorMigrationCaps cap); + #endif /* __QEMU_MIGRATION_PARAMS_H__ */ -- 2.17.0

Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration_params.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index f78e9ad875..36a9fd3509 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -299,17 +299,17 @@ qemuMigrationParamsSetEmptyTLS(virQEMUDriverPtr driver, int asyncJob, qemuMonitorMigrationParamsPtr migParams) { - qemuDomainObjPrivatePtr priv = vm->privateData; + qemuDomainObjPrivatePtr priv = vm->privateData; - if (qemuMigrationParamsCheckTLSCreds(driver, vm, asyncJob) < 0) - return -1; + if (qemuMigrationParamsCheckTLSCreds(driver, vm, asyncJob) < 0) + return -1; - if (!priv->migTLSAlias) - return 0; + if (!priv->migTLSAlias) + return 0; - if (VIR_STRDUP(migParams->tlsCreds, "") < 0 || - VIR_STRDUP(migParams->tlsHostname, "") < 0) - return -1; + if (VIR_STRDUP(migParams->tlsCreds, "") < 0 || + VIR_STRDUP(migParams->tlsHostname, "") < 0) + return -1; return 0; } -- 2.17.0

Our *Free functions usually do not take a double pointer and the caller has to make sure it doesn't use the stale pointer after the *Free function returns. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_driver.c | 2 +- src/qemu/qemu_migration_params.c | 10 +++++----- src/qemu/qemu_migration_params.h | 2 +- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 519bd767c1..bf6c0d0826 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -12781,7 +12781,7 @@ qemuDomainMigratePerform3Params(virDomainPtr dom, flags, dname, bandwidth, true); cleanup: VIR_FREE(compression); - qemuMigrationParamsFree(&migParams); + qemuMigrationParamsFree(migParams); VIR_FREE(migrate_disks); return ret; } diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 36a9fd3509..784b1b9254 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -50,13 +50,13 @@ qemuMigrationParamsClear(qemuMonitorMigrationParamsPtr migParams) void -qemuMigrationParamsFree(qemuMonitorMigrationParamsPtr *migParams) +qemuMigrationParamsFree(qemuMonitorMigrationParamsPtr migParams) { - if (!*migParams) + if (!migParams) return; - qemuMigrationParamsClear(*migParams); - VIR_FREE(*migParams); + qemuMigrationParamsClear(migParams); + VIR_FREE(migParams); } @@ -101,7 +101,7 @@ qemuMigrationParamsFromFlags(virTypedParameterPtr params, return migParams; error: - qemuMigrationParamsFree(&migParams); + qemuMigrationParamsFree(migParams); return NULL; } diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index 0a68bc0e39..1f28d8d606 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -37,7 +37,7 @@ void qemuMigrationParamsClear(qemuMonitorMigrationParamsPtr migParams); void -qemuMigrationParamsFree(qemuMonitorMigrationParamsPtr *migParams); +qemuMigrationParamsFree(qemuMonitorMigrationParamsPtr migParams); int qemuMigrationParamsSet(virQEMUDriverPtr driver, -- 2.17.0

It will get a bit more complicated soon and storing it on a stack with {0} initializer will no longer work. We need a proper constructor. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_driver.c | 20 +++++++++++------ src/qemu/qemu_migration.c | 28 ++++++++++++++--------- src/qemu/qemu_migration_params.c | 38 +++++++++++++++++++++++--------- src/qemu/qemu_migration_params.h | 3 +++ 4 files changed, 61 insertions(+), 28 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index bf6c0d0826..c157ff9bb0 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -12241,7 +12241,7 @@ qemuDomainMigratePerform(virDomainPtr dom, int ret = -1; const char *dconnuri = NULL; qemuMigrationCompressionPtr compression = NULL; - qemuMonitorMigrationParams migParams = { 0 }; + qemuMonitorMigrationParamsPtr migParams = NULL; virCheckFlags(QEMU_MIGRATION_FLAGS, -1); @@ -12252,6 +12252,9 @@ qemuDomainMigratePerform(virDomainPtr dom, goto cleanup; } + if (!(migParams = qemuMigrationParamsNew())) + goto cleanup; + if (!(compression = qemuMigrationAnyCompressionParse(NULL, 0, flags))) goto cleanup; @@ -12276,12 +12279,12 @@ qemuDomainMigratePerform(virDomainPtr dom, */ ret = qemuMigrationSrcPerform(driver, dom->conn, vm, NULL, NULL, dconnuri, uri, NULL, NULL, 0, NULL, 0, - compression, &migParams, cookie, cookielen, + compression, migParams, cookie, cookielen, NULL, NULL, /* No output cookies in v2 */ flags, dname, resource, false); cleanup: - qemuMigrationParamsClear(&migParams); + qemuMigrationParamsFree(migParams); VIR_FREE(compression); return ret; } @@ -12666,13 +12669,16 @@ qemuDomainMigratePerform3(virDomainPtr dom, virQEMUDriverPtr driver = dom->conn->privateData; virDomainObjPtr vm; qemuMigrationCompressionPtr compression = NULL; - qemuMonitorMigrationParams migParams = { 0 }; + qemuMonitorMigrationParamsPtr migParams = NULL; int ret = -1; virCheckFlags(QEMU_MIGRATION_FLAGS, -1); + if (!(migParams = qemuMigrationParamsNew())) + goto cleanup; + if (!(compression = qemuMigrationAnyCompressionParse(NULL, 0, flags))) - return -1; + goto cleanup; if (!(vm = qemuDomObjFromDomain(dom))) goto cleanup; @@ -12684,13 +12690,13 @@ qemuDomainMigratePerform3(virDomainPtr dom, ret = qemuMigrationSrcPerform(driver, dom->conn, vm, xmlin, NULL, dconnuri, uri, NULL, NULL, 0, NULL, 0, - compression, &migParams, + compression, migParams, cookiein, cookieinlen, cookieout, cookieoutlen, flags, dname, resource, true); cleanup: - qemuMigrationParamsClear(&migParams); + qemuMigrationParamsFree(migParams); VIR_FREE(compression); return ret; } diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 57903c7b17..a0061c8c83 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2251,7 +2251,7 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, int rv; char *tlsAlias = NULL; char *secAlias = NULL; - qemuMonitorMigrationParams migParams = { 0 }; + qemuMonitorMigrationParamsPtr migParams = NULL; virNWFilterReadLockFilterUpdates(); @@ -2301,6 +2301,9 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, if (!qemuMigrationSrcIsAllowedHostdev(*def)) goto cleanup; + if (!(migParams = qemuMigrationParamsNew())) + goto cleanup; + /* Let migration hook filter domain XML */ if (virHookPresent(VIR_HOOK_DRIVER_QEMU)) { char *xml; @@ -2445,7 +2448,7 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, } if (qemuMigrationParamsSetCompression(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN, - compression, &migParams) < 0) + compression, migParams) < 0) goto stopjob; /* Migrations using TLS need to add the "tls-creds-x509" object and @@ -2458,17 +2461,17 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, if (qemuMigrationParamsAddTLSObjects(driver, vm, cfg, true, QEMU_ASYNC_JOB_MIGRATION_IN, - &tlsAlias, &secAlias, &migParams) < 0) + &tlsAlias, &secAlias, migParams) < 0) goto stopjob; /* Force reset of 'tls-hostname', it's a source only parameter */ - if (VIR_STRDUP(migParams.tlsHostname, "") < 0) + if (VIR_STRDUP(migParams->tlsHostname, "") < 0) goto stopjob; } else { if (qemuMigrationParamsSetEmptyTLS(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN, - &migParams) < 0) + migParams) < 0) goto stopjob; } @@ -2489,7 +2492,7 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, goto stopjob; if (qemuMigrationParamsSet(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN, - &migParams) < 0) + migParams) < 0) goto stopjob; if (mig->nbd && @@ -2577,7 +2580,7 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, virDomainObjRemoveTransientDef(vm); qemuDomainRemoveInactiveJob(driver, vm); } - qemuMigrationParamsClear(&migParams); + qemuMigrationParamsFree(migParams); virDomainObjEndAPI(&vm); qemuDomainEventQueue(driver, event); qemuMigrationCookieFree(mig); @@ -3881,7 +3884,7 @@ qemuMigrationSrcPerformPeer2Peer2(virQEMUDriverPtr driver, virStreamPtr st = NULL; unsigned long destflags; qemuMigrationCompressionPtr compression = NULL; - qemuMonitorMigrationParams migParams = { 0 }; + qemuMonitorMigrationParamsPtr migParams = NULL; VIR_DEBUG("driver=%p, sconn=%p, dconn=%p, vm=%p, dconnuri=%s, " "flags=0x%lx, dname=%s, resource=%lu", @@ -3903,6 +3906,9 @@ qemuMigrationSrcPerformPeer2Peer2(virQEMUDriverPtr driver, destflags = flags & ~(VIR_MIGRATE_ABORT_ON_ERROR | VIR_MIGRATE_AUTO_CONVERGE); + if (!(migParams = qemuMigrationParamsNew())) + goto cleanup; + if (!(compression = qemuMigrationAnyCompressionParse(NULL, 0, flags))) goto cleanup; @@ -3958,13 +3964,13 @@ qemuMigrationSrcPerformPeer2Peer2(virQEMUDriverPtr driver, ret = qemuMigrationSrcPerformTunnel(driver, vm, st, NULL, NULL, 0, NULL, NULL, flags, resource, dconn, - NULL, 0, NULL, compression, &migParams); + NULL, 0, NULL, compression, migParams); else ret = qemuMigrationSrcPerformNative(driver, vm, NULL, uri_out, cookie, cookielen, NULL, NULL, /* No out cookie with v2 migration */ flags, resource, dconn, NULL, 0, NULL, - compression, &migParams); + compression, migParams); /* Perform failed. Make sure Finish doesn't overwrite the error */ if (ret < 0) @@ -4004,7 +4010,7 @@ qemuMigrationSrcPerformPeer2Peer2(virQEMUDriverPtr driver, virSetError(orig_err); virFreeError(orig_err); } - qemuMigrationParamsClear(&migParams); + qemuMigrationParamsFree(migParams); VIR_FREE(uri_out); VIR_FREE(cookie); VIR_FREE(compression); diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 784b1b9254..95ceed4e14 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -38,6 +38,18 @@ VIR_LOG_INIT("qemu.qemu_migration_params"); #define QEMU_MIGRATION_TLS_ALIAS_BASE "libvirt_migrate" +qemuMonitorMigrationParamsPtr +qemuMigrationParamsNew(void) +{ + qemuMonitorMigrationParamsPtr params; + + if (VIR_ALLOC(params) < 0) + return NULL; + + return params; +} + + void qemuMigrationParamsClear(qemuMonitorMigrationParamsPtr migParams) { @@ -67,7 +79,7 @@ qemuMigrationParamsFromFlags(virTypedParameterPtr params, { qemuMonitorMigrationParamsPtr migParams; - if (VIR_ALLOC(migParams) < 0) + if (!(migParams = qemuMigrationParamsNew())) return NULL; if (!params) @@ -151,16 +163,19 @@ qemuMigrationParamsCheckTLSCreds(virQEMUDriverPtr driver, { int ret = -1; qemuDomainObjPrivatePtr priv = vm->privateData; - qemuMonitorMigrationParams migParams = { 0 }; + qemuMonitorMigrationParamsPtr migParams = NULL; if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) return -1; - if (qemuMonitorGetMigrationParams(priv->mon, &migParams) < 0) + if (!(migParams = qemuMigrationParamsNew())) + goto cleanup; + + if (qemuMonitorGetMigrationParams(priv->mon, migParams) < 0) goto cleanup; /* NB: Could steal NULL pointer too! Let caller decide what to do. */ - VIR_STEAL_PTR(priv->migTLSAlias, migParams.tlsCreds); + VIR_STEAL_PTR(priv->migTLSAlias, migParams->tlsCreds); ret = 0; @@ -168,7 +183,7 @@ qemuMigrationParamsCheckTLSCreds(virQEMUDriverPtr driver, if (qemuDomainObjExitMonitor(driver, vm) < 0) ret = -1; - qemuMigrationParamsClear(&migParams); + qemuMigrationParamsFree(migParams); return ret; } @@ -384,7 +399,7 @@ qemuMigrationParamsResetTLS(virQEMUDriverPtr driver, qemuDomainObjPrivatePtr priv = vm->privateData; char *tlsAlias = NULL; char *secAlias = NULL; - qemuMonitorMigrationParams migParams = { 0 }; + qemuMonitorMigrationParamsPtr migParams = NULL; int ret = -1; if (qemuMigrationParamsCheckTLSCreds(driver, vm, asyncJob) < 0) @@ -395,6 +410,9 @@ qemuMigrationParamsResetTLS(virQEMUDriverPtr driver, if (!priv->migTLSAlias || !*priv->migTLSAlias) return 0; + if (!(migParams = qemuMigrationParamsNew())) + goto cleanup; + /* NB: If either or both fail to allocate memory we can still proceed * since the next time we migrate another deletion attempt will be * made after successfully generating the aliases. */ @@ -404,9 +422,9 @@ qemuMigrationParamsResetTLS(virQEMUDriverPtr driver, qemuDomainDelTLSObjects(driver, vm, asyncJob, secAlias, tlsAlias); qemuDomainSecretInfoFree(&priv->migSecinfo); - if (VIR_STRDUP(migParams.tlsCreds, "") < 0 || - VIR_STRDUP(migParams.tlsHostname, "") < 0 || - qemuMigrationParamsSet(driver, vm, asyncJob, &migParams) < 0) + if (VIR_STRDUP(migParams->tlsCreds, "") < 0 || + VIR_STRDUP(migParams->tlsHostname, "") < 0 || + qemuMigrationParamsSet(driver, vm, asyncJob, migParams) < 0) goto cleanup; ret = 0; @@ -414,7 +432,7 @@ qemuMigrationParamsResetTLS(virQEMUDriverPtr driver, cleanup: VIR_FREE(tlsAlias); VIR_FREE(secAlias); - qemuMigrationParamsClear(&migParams); + qemuMigrationParamsFree(migParams); return ret; } diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index 1f28d8d606..cbc63b9cbf 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -28,6 +28,9 @@ # include "qemu_conf.h" +qemuMonitorMigrationParamsPtr +qemuMigrationParamsNew(void); + qemuMonitorMigrationParamsPtr qemuMigrationParamsFromFlags(virTypedParameterPtr params, int nparams, -- 2.17.0

It's no longer used since we do not store the struct on a stack anymore. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration_params.c | 12 +----------- src/qemu/qemu_migration_params.h | 3 --- 2 files changed, 1 insertion(+), 14 deletions(-) diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 95ceed4e14..c315810728 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -51,23 +51,13 @@ qemuMigrationParamsNew(void) void -qemuMigrationParamsClear(qemuMonitorMigrationParamsPtr migParams) +qemuMigrationParamsFree(qemuMonitorMigrationParamsPtr migParams) { if (!migParams) return; VIR_FREE(migParams->tlsCreds); VIR_FREE(migParams->tlsHostname); -} - - -void -qemuMigrationParamsFree(qemuMonitorMigrationParamsPtr migParams) -{ - if (!migParams) - return; - - qemuMigrationParamsClear(migParams); VIR_FREE(migParams); } diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index cbc63b9cbf..f11315cb9d 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -36,9 +36,6 @@ qemuMigrationParamsFromFlags(virTypedParameterPtr params, int nparams, unsigned long flags); -void -qemuMigrationParamsClear(qemuMonitorMigrationParamsPtr migParams); - void qemuMigrationParamsFree(qemuMonitorMigrationParamsPtr migParams); -- 2.17.0

It provides just another view on some migration parameters so let's move it close to them. The end goal is to merge compression parameters with the rest of migration parameters since it doesn't make any sense to handle them differently. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.h | 20 +------------------- src/qemu/qemu_migration_params.h | 19 +++++++++++++++++++ 2 files changed, 20 insertions(+), 19 deletions(-) diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h index 3f33d3013d..4e7b33445b 100644 --- a/src/qemu/qemu_migration.h +++ b/src/qemu/qemu_migration.h @@ -24,6 +24,7 @@ # include "qemu_conf.h" # include "qemu_domain.h" +# include "qemu_migration_params.h" /* * General function naming conventions: @@ -38,9 +39,6 @@ * - qemuMigrationJobXXX - runs on source or dest host */ -typedef struct _qemuMigrationCompression qemuMigrationCompression; -typedef qemuMigrationCompression *qemuMigrationCompressionPtr; - /* All supported qemu migration flags. */ # define QEMU_MIGRATION_FLAGS \ (VIR_MIGRATE_LIVE | \ @@ -108,22 +106,6 @@ typedef enum { } qemuMigrationCompressMethod; VIR_ENUM_DECL(qemuMigrationCompressMethod) -struct _qemuMigrationCompression { - unsigned long long methods; - - bool level_set; - int level; - - bool threads_set; - int threads; - - bool dthreads_set; - int dthreads; - - bool xbzrle_cache_set; - unsigned long long xbzrle_cache; -}; - qemuMigrationCompressionPtr qemuMigrationAnyCompressionParse(virTypedParameterPtr params, int nparams, diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index f11315cb9d..bb38d34cd6 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -28,6 +28,25 @@ # include "qemu_conf.h" +typedef struct _qemuMigrationCompression qemuMigrationCompression; +typedef qemuMigrationCompression *qemuMigrationCompressionPtr; +struct _qemuMigrationCompression { + unsigned long long methods; + + bool level_set; + int level; + + bool threads_set; + int threads; + + bool dthreads_set; + int dthreads; + + bool xbzrle_cache_set; + unsigned long long xbzrle_cache; +}; + + qemuMonitorMigrationParamsPtr qemuMigrationParamsNew(void); -- 2.17.0

Currently migration parameters are stored in a structure which mimics the QEMU migration parameters handled by query-migrate-parameters and migrate-set-parameters. The new structure will become a libvirt's abstraction on top of QEMU migration parameters, capabilities, and related stuff. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_driver.c | 6 ++-- src/qemu/qemu_migration.c | 26 +++++++------- src/qemu/qemu_migration.h | 2 +- src/qemu/qemu_migration_params.c | 62 ++++++++++++++++---------------- src/qemu/qemu_migration_params.h | 21 +++++++---- 5 files changed, 62 insertions(+), 55 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index c157ff9bb0..6e6fc130c5 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -12241,7 +12241,7 @@ qemuDomainMigratePerform(virDomainPtr dom, int ret = -1; const char *dconnuri = NULL; qemuMigrationCompressionPtr compression = NULL; - qemuMonitorMigrationParamsPtr migParams = NULL; + qemuMigrationParamsPtr migParams = NULL; virCheckFlags(QEMU_MIGRATION_FLAGS, -1); @@ -12669,7 +12669,7 @@ qemuDomainMigratePerform3(virDomainPtr dom, virQEMUDriverPtr driver = dom->conn->privateData; virDomainObjPtr vm; qemuMigrationCompressionPtr compression = NULL; - qemuMonitorMigrationParamsPtr migParams = NULL; + qemuMigrationParamsPtr migParams = NULL; int ret = -1; virCheckFlags(QEMU_MIGRATION_FLAGS, -1); @@ -12725,7 +12725,7 @@ qemuDomainMigratePerform3Params(virDomainPtr dom, unsigned long long bandwidth = 0; int nbdPort = 0; qemuMigrationCompressionPtr compression = NULL; - qemuMonitorMigrationParamsPtr migParams = NULL; + qemuMigrationParamsPtr migParams = NULL; int ret = -1; virCheckFlags(QEMU_MIGRATION_FLAGS, -1); diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index a0061c8c83..055d8a674a 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2251,7 +2251,7 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, int rv; char *tlsAlias = NULL; char *secAlias = NULL; - qemuMonitorMigrationParamsPtr migParams = NULL; + qemuMigrationParamsPtr migParams = NULL; virNWFilterReadLockFilterUpdates(); @@ -2465,7 +2465,7 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, goto stopjob; /* Force reset of 'tls-hostname', it's a source only parameter */ - if (VIR_STRDUP(migParams->tlsHostname, "") < 0) + if (VIR_STRDUP(migParams->params.tlsHostname, "") < 0) goto stopjob; } else { @@ -3337,7 +3337,7 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, size_t nmigrate_disks, const char **migrate_disks, qemuMigrationCompressionPtr compression, - qemuMonitorMigrationParamsPtr migParams) + qemuMigrationParamsPtr migParams) { int ret = -1; unsigned int migrate_flags = QEMU_MONITOR_MIGRATE_BACKGROUND; @@ -3426,11 +3426,11 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, * connect directly to the destination. */ if (spec->destType == MIGRATION_DEST_CONNECT_HOST || spec->destType == MIGRATION_DEST_FD) { - if (VIR_STRDUP(migParams->tlsHostname, spec->dest.host.name) < 0) + if (VIR_STRDUP(migParams->params.tlsHostname, spec->dest.host.name) < 0) goto error; } else { /* Be sure there's nothing from a previous migration */ - if (VIR_STRDUP(migParams->tlsHostname, "") < 0) + if (VIR_STRDUP(migParams->params.tlsHostname, "") < 0) goto error; } } else { @@ -3733,7 +3733,7 @@ qemuMigrationSrcPerformNative(virQEMUDriverPtr driver, size_t nmigrate_disks, const char **migrate_disks, qemuMigrationCompressionPtr compression, - qemuMonitorMigrationParamsPtr migParams) + qemuMigrationParamsPtr migParams) { qemuDomainObjPrivatePtr priv = vm->privateData; virURIPtr uribits = NULL; @@ -3812,7 +3812,7 @@ qemuMigrationSrcPerformTunnel(virQEMUDriverPtr driver, size_t nmigrate_disks, const char **migrate_disks, qemuMigrationCompressionPtr compression, - qemuMonitorMigrationParamsPtr migParams) + qemuMigrationParamsPtr migParams) { int ret = -1; qemuMigrationSpec spec; @@ -3884,7 +3884,7 @@ qemuMigrationSrcPerformPeer2Peer2(virQEMUDriverPtr driver, virStreamPtr st = NULL; unsigned long destflags; qemuMigrationCompressionPtr compression = NULL; - qemuMonitorMigrationParamsPtr migParams = NULL; + qemuMigrationParamsPtr migParams = NULL; VIR_DEBUG("driver=%p, sconn=%p, dconn=%p, vm=%p, dconnuri=%s, " "flags=0x%lx, dname=%s, resource=%lu", @@ -4039,7 +4039,7 @@ qemuMigrationSrcPerformPeer2Peer3(virQEMUDriverPtr driver, const char **migrate_disks, int nbdPort, qemuMigrationCompressionPtr compression, - qemuMonitorMigrationParamsPtr migParams, + qemuMigrationParamsPtr migParams, unsigned long long bandwidth, bool useParams, unsigned long flags) @@ -4398,7 +4398,7 @@ qemuMigrationSrcPerformPeer2Peer(virQEMUDriverPtr driver, const char **migrate_disks, int nbdPort, qemuMigrationCompressionPtr compression, - qemuMonitorMigrationParamsPtr migParams, + qemuMigrationParamsPtr migParams, unsigned long flags, const char *dname, unsigned long resource, @@ -4563,7 +4563,7 @@ qemuMigrationSrcPerformJob(virQEMUDriverPtr driver, const char **migrate_disks, int nbdPort, qemuMigrationCompressionPtr compression, - qemuMonitorMigrationParamsPtr migParams, + qemuMigrationParamsPtr migParams, const char *cookiein, int cookieinlen, char **cookieout, @@ -4676,7 +4676,7 @@ qemuMigrationSrcPerformPhase(virQEMUDriverPtr driver, size_t nmigrate_disks, const char **migrate_disks, qemuMigrationCompressionPtr compression, - qemuMonitorMigrationParamsPtr migParams, + qemuMigrationParamsPtr migParams, const char *cookiein, int cookieinlen, char **cookieout, @@ -4750,7 +4750,7 @@ qemuMigrationSrcPerform(virQEMUDriverPtr driver, const char **migrate_disks, int nbdPort, qemuMigrationCompressionPtr compression, - qemuMonitorMigrationParamsPtr migParams, + qemuMigrationParamsPtr migParams, const char *cookiein, int cookieinlen, char **cookieout, diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h index 4e7b33445b..e59296fd63 100644 --- a/src/qemu/qemu_migration.h +++ b/src/qemu/qemu_migration.h @@ -182,7 +182,7 @@ qemuMigrationSrcPerform(virQEMUDriverPtr driver, const char **migrate_disks, int nbdPort, qemuMigrationCompressionPtr compression, - qemuMonitorMigrationParamsPtr migParams, + qemuMigrationParamsPtr migParams, const char *cookiein, int cookieinlen, char **cookieout, diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index c315810728..3a1816c2b9 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -38,10 +38,10 @@ VIR_LOG_INIT("qemu.qemu_migration_params"); #define QEMU_MIGRATION_TLS_ALIAS_BASE "libvirt_migrate" -qemuMonitorMigrationParamsPtr +qemuMigrationParamsPtr qemuMigrationParamsNew(void) { - qemuMonitorMigrationParamsPtr params; + qemuMigrationParamsPtr params; if (VIR_ALLOC(params) < 0) return NULL; @@ -51,23 +51,23 @@ qemuMigrationParamsNew(void) void -qemuMigrationParamsFree(qemuMonitorMigrationParamsPtr migParams) +qemuMigrationParamsFree(qemuMigrationParamsPtr migParams) { if (!migParams) return; - VIR_FREE(migParams->tlsCreds); - VIR_FREE(migParams->tlsHostname); + VIR_FREE(migParams->params.tlsCreds); + VIR_FREE(migParams->params.tlsHostname); VIR_FREE(migParams); } -qemuMonitorMigrationParamsPtr +qemuMigrationParamsPtr qemuMigrationParamsFromFlags(virTypedParameterPtr params, int nparams, unsigned long flags) { - qemuMonitorMigrationParamsPtr migParams; + qemuMigrationParamsPtr migParams; if (!(migParams = qemuMigrationParamsNew())) return NULL; @@ -80,11 +80,11 @@ qemuMigrationParamsFromFlags(virTypedParameterPtr params, int rc; \ if ((rc = virTypedParamsGetInt(params, nparams, \ VIR_MIGRATE_PARAM_ ## PARAM, \ - &migParams->VAR)) < 0) \ + &migParams->params.VAR)) < 0) \ goto error; \ \ if (rc == 1) \ - migParams->VAR ## _set = true; \ + migParams->params.VAR ## _set = true; \ } while (0) GET(AUTO_CONVERGE_INITIAL, cpuThrottleInitial); @@ -92,8 +92,8 @@ qemuMigrationParamsFromFlags(virTypedParameterPtr params, #undef GET - if ((migParams->cpuThrottleInitial_set || - migParams->cpuThrottleIncrement_set) && + if ((migParams->params.cpuThrottleInitial_set || + migParams->params.cpuThrottleIncrement_set) && !(flags & VIR_MIGRATE_AUTO_CONVERGE)) { virReportError(VIR_ERR_INVALID_ARG, "%s", _("Turn auto convergence on to tune it")); @@ -112,7 +112,7 @@ int qemuMigrationParamsSet(virQEMUDriverPtr driver, virDomainObjPtr vm, int asyncJob, - qemuMonitorMigrationParamsPtr migParams) + qemuMigrationParamsPtr migParams) { qemuDomainObjPrivatePtr priv = vm->privateData; int ret = -1; @@ -120,7 +120,7 @@ qemuMigrationParamsSet(virQEMUDriverPtr driver, if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) return -1; - if (qemuMonitorSetMigrationParams(priv->mon, migParams) < 0) + if (qemuMonitorSetMigrationParams(priv->mon, &migParams->params) < 0) goto cleanup; ret = 0; @@ -153,7 +153,7 @@ qemuMigrationParamsCheckTLSCreds(virQEMUDriverPtr driver, { int ret = -1; qemuDomainObjPrivatePtr priv = vm->privateData; - qemuMonitorMigrationParamsPtr migParams = NULL; + qemuMigrationParamsPtr migParams = NULL; if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) return -1; @@ -161,11 +161,11 @@ qemuMigrationParamsCheckTLSCreds(virQEMUDriverPtr driver, if (!(migParams = qemuMigrationParamsNew())) goto cleanup; - if (qemuMonitorGetMigrationParams(priv->mon, migParams) < 0) + if (qemuMonitorGetMigrationParams(priv->mon, &migParams->params) < 0) goto cleanup; /* NB: Could steal NULL pointer too! Let caller decide what to do. */ - VIR_STEAL_PTR(priv->migTLSAlias, migParams->tlsCreds); + VIR_STEAL_PTR(priv->migTLSAlias, migParams->params.tlsCreds); ret = 0; @@ -251,7 +251,7 @@ qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, int asyncJob, char **tlsAlias, char **secAlias, - qemuMonitorMigrationParamsPtr migParams) + qemuMigrationParamsPtr migParams) { qemuDomainObjPrivatePtr priv = vm->privateData; virJSONValuePtr tlsProps = NULL; @@ -274,7 +274,7 @@ qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, *tlsAlias, &tlsProps) < 0) goto error; - if (VIR_STRDUP(migParams->tlsCreds, *tlsAlias) < 0) + if (VIR_STRDUP(migParams->params.tlsCreds, *tlsAlias) < 0) goto error; return 0; @@ -302,7 +302,7 @@ int qemuMigrationParamsSetEmptyTLS(virQEMUDriverPtr driver, virDomainObjPtr vm, int asyncJob, - qemuMonitorMigrationParamsPtr migParams) + qemuMigrationParamsPtr migParams) { qemuDomainObjPrivatePtr priv = vm->privateData; @@ -312,8 +312,8 @@ qemuMigrationParamsSetEmptyTLS(virQEMUDriverPtr driver, if (!priv->migTLSAlias) return 0; - if (VIR_STRDUP(migParams->tlsCreds, "") < 0 || - VIR_STRDUP(migParams->tlsHostname, "") < 0) + if (VIR_STRDUP(migParams->params.tlsCreds, "") < 0 || + VIR_STRDUP(migParams->params.tlsHostname, "") < 0) return -1; return 0; @@ -325,7 +325,7 @@ qemuMigrationParamsSetCompression(virQEMUDriverPtr driver, virDomainObjPtr vm, int asyncJob, qemuMigrationCompressionPtr compression, - qemuMonitorMigrationParamsPtr migParams) + qemuMigrationParamsPtr migParams) { int ret = -1; qemuDomainObjPrivatePtr priv = vm->privateData; @@ -347,14 +347,14 @@ qemuMigrationParamsSetCompression(virQEMUDriverPtr driver, if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) return -1; - migParams->compressLevel_set = compression->level_set; - migParams->compressLevel = compression->level; + migParams->params.compressLevel_set = compression->level_set; + migParams->params.compressLevel = compression->level; - migParams->compressThreads_set = compression->threads_set; - migParams->compressThreads = compression->threads; + migParams->params.compressThreads_set = compression->threads_set; + migParams->params.compressThreads = compression->threads; - migParams->decompressThreads_set = compression->dthreads_set; - migParams->decompressThreads = compression->dthreads; + migParams->params.decompressThreads_set = compression->dthreads_set; + migParams->params.decompressThreads = compression->dthreads; if (compression->xbzrle_cache_set && qemuMonitorSetMigrationCacheSize(priv->mon, @@ -389,7 +389,7 @@ qemuMigrationParamsResetTLS(virQEMUDriverPtr driver, qemuDomainObjPrivatePtr priv = vm->privateData; char *tlsAlias = NULL; char *secAlias = NULL; - qemuMonitorMigrationParamsPtr migParams = NULL; + qemuMigrationParamsPtr migParams = NULL; int ret = -1; if (qemuMigrationParamsCheckTLSCreds(driver, vm, asyncJob) < 0) @@ -412,8 +412,8 @@ qemuMigrationParamsResetTLS(virQEMUDriverPtr driver, qemuDomainDelTLSObjects(driver, vm, asyncJob, secAlias, tlsAlias); qemuDomainSecretInfoFree(&priv->migSecinfo); - if (VIR_STRDUP(migParams->tlsCreds, "") < 0 || - VIR_STRDUP(migParams->tlsHostname, "") < 0 || + if (VIR_STRDUP(migParams->params.tlsCreds, "") < 0 || + VIR_STRDUP(migParams->params.tlsHostname, "") < 0 || qemuMigrationParamsSet(driver, vm, asyncJob, migParams) < 0) goto cleanup; diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index bb38d34cd6..57b7dd6666 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -47,22 +47,29 @@ struct _qemuMigrationCompression { }; -qemuMonitorMigrationParamsPtr +typedef struct _qemuMigrationParams qemuMigrationParams; +typedef qemuMigrationParams *qemuMigrationParamsPtr; +struct _qemuMigrationParams { + qemuMonitorMigrationParams params; +}; + + +qemuMigrationParamsPtr qemuMigrationParamsNew(void); -qemuMonitorMigrationParamsPtr +qemuMigrationParamsPtr qemuMigrationParamsFromFlags(virTypedParameterPtr params, int nparams, unsigned long flags); void -qemuMigrationParamsFree(qemuMonitorMigrationParamsPtr migParams); +qemuMigrationParamsFree(qemuMigrationParamsPtr migParams); int qemuMigrationParamsSet(virQEMUDriverPtr driver, virDomainObjPtr vm, int asyncJob, - qemuMonitorMigrationParamsPtr migParams); + qemuMigrationParamsPtr migParams); int qemuMigrationParamsCheckSetupTLS(virQEMUDriverPtr driver, @@ -78,20 +85,20 @@ qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, int asyncJob, char **tlsAlias, char **secAlias, - qemuMonitorMigrationParamsPtr migParams); + qemuMigrationParamsPtr migParams); int qemuMigrationParamsSetEmptyTLS(virQEMUDriverPtr driver, virDomainObjPtr vm, int asyncJob, - qemuMonitorMigrationParamsPtr migParams); + qemuMigrationParamsPtr migParams); int qemuMigrationParamsSetCompression(virQEMUDriverPtr driver, virDomainObjPtr vm, int asyncJob, qemuMigrationCompressionPtr compression, - qemuMonitorMigrationParamsPtr migParams); + qemuMigrationParamsPtr migParams); void qemuMigrationParamsReset(virQEMUDriverPtr driver, -- 2.17.0

When connection to the client which controls a non-p2p migration gets closed between Perform and Confirm phase, we don't know whether the domain was successfully migrated or not. Thus, we have to leave the domain paused and just cleanup the migration job and reset migration parameters. Previously we didn't reset the parameters and future save or snapshot operations would see wrong environment (and could fail because of it) in case the domain stayed running on the source host. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 055d8a674a..b7ef535b5d 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -1834,6 +1834,7 @@ qemuMigrationSrcCleanup(virDomainObjPtr vm, VIR_WARN("Migration of domain %s finished but we don't know if the" " domain was successfully started on destination or not", vm->def->name); + qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT); /* clear the job and let higher levels decide what to do */ qemuDomainObjDiscardAsyncJob(driver, vm); break; -- 2.17.0

Any job which touches migration parameters will first store their original values (i.e., QEMU defaults) to qemuDomainJobObj to make it easier to reset them back once the job finishes. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_domain.c | 3 +++ src/qemu/qemu_domain.h | 3 +++ src/qemu/qemu_migration.c | 9 ++++++++ src/qemu/qemu_migration_params.c | 38 ++++++++++++++++++++++++++++++++ src/qemu/qemu_migration_params.h | 5 +++++ 5 files changed, 58 insertions(+) diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c index 84476de11b..78f5dc360c 100644 --- a/src/qemu/qemu_domain.c +++ b/src/qemu/qemu_domain.c @@ -336,6 +336,8 @@ qemuDomainObjResetAsyncJob(qemuDomainObjPrivatePtr priv) job->dumpCompleted = false; VIR_FREE(job->error); VIR_FREE(job->current); + qemuMigrationParamsFree(job->migParams); + job->migParams = NULL; } void @@ -350,6 +352,7 @@ qemuDomainObjRestoreJob(virDomainObjPtr obj, job->asyncJob = priv->job.asyncJob; job->asyncOwner = priv->job.asyncOwner; job->phase = priv->job.phase; + VIR_STEAL_PTR(job->migParams, priv->job.migParams); qemuDomainObjResetJob(priv); qemuDomainObjResetAsyncJob(priv); diff --git a/src/qemu/qemu_domain.h b/src/qemu/qemu_domain.h index 415b2ca093..1828b64284 100644 --- a/src/qemu/qemu_domain.h +++ b/src/qemu/qemu_domain.h @@ -34,6 +34,7 @@ # include "qemu_agent.h" # include "qemu_conf.h" # include "qemu_capabilities.h" +# include "qemu_migration_params.h" # include "virmdev.h" # include "virchrdev.h" # include "virobject.h" @@ -177,6 +178,8 @@ struct qemuDomainJobObj { bool postcopyEnabled; /* post-copy migration was enabled */ char *error; /* job event completion error */ bool dumpCompleted; /* dump completed */ + + qemuMigrationParamsPtr migParams; }; typedef void (*qemuDomainCleanupCallback)(virQEMUDriverPtr driver, diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index b7ef535b5d..96ca5593cf 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2448,6 +2448,9 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, dataFD[1] = -1; /* 'st' owns the FD now & will close it */ } + if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN) < 0) + goto stopjob; + if (qemuMigrationParamsSetCompression(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN, compression, migParams) < 0) goto stopjob; @@ -4597,6 +4600,9 @@ qemuMigrationSrcPerformJob(virQEMUDriverPtr driver, qemuMigrationSrcStoreDomainState(vm); + if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) + goto endjob; + if ((flags & (VIR_MIGRATE_TUNNELLED | VIR_MIGRATE_PEER2PEER))) { ret = qemuMigrationSrcPerformPeer2Peer(driver, conn, vm, xmlin, persist_xml, dconnuri, uri, graphicsuri, listenAddress, @@ -4700,6 +4706,9 @@ qemuMigrationSrcPerformPhase(virQEMUDriverPtr driver, virCloseCallbacksUnset(driver->closeCallbacks, vm, qemuMigrationSrcCleanup); + if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) + goto endjob; + ret = qemuMigrationSrcPerformNative(driver, vm, persist_xml, uri, cookiein, cookieinlen, cookieout, cookieoutlen, flags, resource, NULL, graphicsuri, diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 3a1816c2b9..465132fd9c 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -428,6 +428,44 @@ qemuMigrationParamsResetTLS(virQEMUDriverPtr driver, } +/** + * qemuMigrationParamsCheck: + * + * Check supported migration parameters and keep their original values in + * qemuDomainJobObj so that we can properly reset them at the end of migration. + */ +int +qemuMigrationParamsCheck(virQEMUDriverPtr driver, + virDomainObjPtr vm, + int asyncJob) +{ + qemuDomainObjPrivatePtr priv = vm->privateData; + qemuMigrationParamsPtr origParams = NULL; + int ret = -1; + + if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) + return -1; + + if (!(origParams = qemuMigrationParamsNew())) + goto cleanup; + + if (qemuMonitorGetMigrationParams(priv->mon, &origParams->params) < 0) + goto cleanup; + + ret = 0; + + cleanup: + if (qemuDomainObjExitMonitor(driver, vm) < 0) + ret = -1; + + if (ret == 0) + VIR_STEAL_PTR(priv->job.migParams, origParams); + qemuMigrationParamsFree(origParams); + + return ret; +} + + /* * qemuMigrationParamsReset: * diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index 57b7dd6666..c283a81b51 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -100,6 +100,11 @@ qemuMigrationParamsSetCompression(virQEMUDriverPtr driver, qemuMigrationCompressionPtr compression, qemuMigrationParamsPtr migParams); +int +qemuMigrationParamsCheck(virQEMUDriverPtr driver, + virDomainObjPtr vm, + int asyncJob); + void qemuMigrationParamsReset(virQEMUDriverPtr driver, virDomainObjPtr vm, -- 2.17.0

Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_domain.c | 6 +++--- src/qemu/qemu_domain.h | 8 +++++--- src/qemu/qemu_process.c | 4 ++-- 3 files changed, 10 insertions(+), 8 deletions(-) diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c index 78f5dc360c..e997c14aad 100644 --- a/src/qemu/qemu_domain.c +++ b/src/qemu/qemu_domain.c @@ -309,7 +309,7 @@ qemuDomainObjInitJob(qemuDomainObjPrivatePtr priv) static void qemuDomainObjResetJob(qemuDomainObjPrivatePtr priv) { - struct qemuDomainJobObj *job = &priv->job; + qemuDomainJobObjPtr job = &priv->job; job->active = QEMU_JOB_NONE; job->owner = 0; @@ -320,7 +320,7 @@ qemuDomainObjResetJob(qemuDomainObjPrivatePtr priv) static void qemuDomainObjResetAsyncJob(qemuDomainObjPrivatePtr priv) { - struct qemuDomainJobObj *job = &priv->job; + qemuDomainJobObjPtr job = &priv->job; job->asyncJob = QEMU_ASYNC_JOB_NONE; job->asyncOwner = 0; @@ -342,7 +342,7 @@ qemuDomainObjResetAsyncJob(qemuDomainObjPrivatePtr priv) void qemuDomainObjRestoreJob(virDomainObjPtr obj, - struct qemuDomainJobObj *job) + qemuDomainJobObjPtr job) { qemuDomainObjPrivatePtr priv = obj->privateData; diff --git a/src/qemu/qemu_domain.h b/src/qemu/qemu_domain.h index 1828b64284..2c474ae4a4 100644 --- a/src/qemu/qemu_domain.h +++ b/src/qemu/qemu_domain.h @@ -154,7 +154,9 @@ struct _qemuDomainJobInfo { qemuDomainMirrorStats mirrorStats; }; -struct qemuDomainJobObj { +typedef struct _qemuDomainJobObj qemuDomainJobObj; +typedef qemuDomainJobObj *qemuDomainJobObjPtr; +struct _qemuDomainJobObj { virCond cond; /* Use to coordinate jobs */ qemuDomainJob active; /* Currently running job */ unsigned long long owner; /* Thread id which set current job */ @@ -254,7 +256,7 @@ typedef qemuDomainObjPrivate *qemuDomainObjPrivatePtr; struct _qemuDomainObjPrivate { virQEMUDriverPtr driver; - struct qemuDomainJobObj job; + qemuDomainJobObj job; virBitmapPtr namespaces; @@ -513,7 +515,7 @@ void qemuDomainObjSetJobPhase(virQEMUDriverPtr driver, void qemuDomainObjSetAsyncJobMask(virDomainObjPtr obj, unsigned long long allowedJobs); void qemuDomainObjRestoreJob(virDomainObjPtr obj, - struct qemuDomainJobObj *job); + qemuDomainJobObjPtr job); void qemuDomainObjDiscardAsyncJob(virQEMUDriverPtr driver, virDomainObjPtr obj); void qemuDomainObjReleaseAsyncJob(virDomainObjPtr obj); diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index 11276dace9..dd97cd7e7d 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -3186,7 +3186,7 @@ qemuProcessRecoverMigrationOut(virQEMUDriverPtr driver, static int qemuProcessRecoverJob(virQEMUDriverPtr driver, virDomainObjPtr vm, - const struct qemuDomainJobObj *job, + const qemuDomainJobObj *job, unsigned int *stopFlags) { qemuDomainObjPrivatePtr priv = vm->privateData; @@ -7262,7 +7262,7 @@ qemuProcessReconnect(void *opaque) virQEMUDriverPtr driver = data->driver; virDomainObjPtr obj = data->obj; qemuDomainObjPrivatePtr priv; - struct qemuDomainJobObj oldjob; + qemuDomainJobObj oldjob; int state; int reason; virQEMUDriverConfigPtr cfg; -- 2.17.0

Currently, only job->phase is passed and both APIs will need to look at more details about the job. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_process.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index dd97cd7e7d..fd81933f2e 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -3034,7 +3034,7 @@ qemuProcessUpdateState(virQEMUDriverPtr driver, virDomainObjPtr vm) static int qemuProcessRecoverMigrationIn(virQEMUDriverPtr driver, virDomainObjPtr vm, - qemuMigrationJobPhase phase, + const qemuDomainJobObj *job, virDomainState state, int reason) { @@ -3043,7 +3043,7 @@ qemuProcessRecoverMigrationIn(virQEMUDriverPtr driver, (state == VIR_DOMAIN_RUNNING && reason == VIR_DOMAIN_RUNNING_POSTCOPY); - switch (phase) { + switch ((qemuMigrationJobPhase) job->phase) { case QEMU_MIGRATION_PHASE_NONE: case QEMU_MIGRATION_PHASE_PERFORM2: case QEMU_MIGRATION_PHASE_BEGIN3: @@ -3092,7 +3092,7 @@ qemuProcessRecoverMigrationIn(virQEMUDriverPtr driver, static int qemuProcessRecoverMigrationOut(virQEMUDriverPtr driver, virDomainObjPtr vm, - qemuMigrationJobPhase phase, + const qemuDomainJobObj *job, virDomainState state, int reason, unsigned int *stopFlags) @@ -3102,7 +3102,7 @@ qemuProcessRecoverMigrationOut(virQEMUDriverPtr driver, reason == VIR_DOMAIN_PAUSED_POSTCOPY_FAILED); bool resume = false; - switch (phase) { + switch ((qemuMigrationJobPhase) job->phase) { case QEMU_MIGRATION_PHASE_NONE: case QEMU_MIGRATION_PHASE_PREPARE: case QEMU_MIGRATION_PHASE_FINISH2: @@ -3197,13 +3197,13 @@ qemuProcessRecoverJob(virQEMUDriverPtr driver, switch (job->asyncJob) { case QEMU_ASYNC_JOB_MIGRATION_OUT: - if (qemuProcessRecoverMigrationOut(driver, vm, job->phase, + if (qemuProcessRecoverMigrationOut(driver, vm, job, state, reason, stopFlags) < 0) return -1; break; case QEMU_ASYNC_JOB_MIGRATION_IN: - if (qemuProcessRecoverMigrationIn(driver, vm, job->phase, + if (qemuProcessRecoverMigrationIn(driver, vm, job, state, reason) < 0) return -1; break; -- 2.17.0

Restore the original values of all migration parameters we store in qemuDomainJobObj instead of explicitly resting only a limited set of them. The result is not strictly equivalent to the previous code wrt reseting TLS state because the previous code would only reset it if we changed it before while the new code will reset it always if QEMU supports TLS migration. This is not a problem for the parameters themselves, but it can cause spurious errors about missing TLS objects being logged at the end of non-TLS migration. This issue will be fixed ~50 patches later. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 20 +++++++++---- src/qemu/qemu_migration_params.c | 48 +++++++++++--------------------- src/qemu/qemu_migration_params.h | 3 +- src/qemu/qemu_process.c | 4 +-- 4 files changed, 34 insertions(+), 41 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 96ca5593cf..72fcae77f4 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -1834,7 +1834,8 @@ qemuMigrationSrcCleanup(virDomainObjPtr vm, VIR_WARN("Migration of domain %s finished but we don't know if the" " domain was successfully started on destination or not", vm->def->name); - qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT); + qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT, + priv->job.migParams); /* clear the job and let higher levels decide what to do */ qemuDomainObjDiscardAsyncJob(driver, vm); break; @@ -2593,7 +2594,8 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, return ret; stopjob: - qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN); + qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN, + priv->job.migParams); if (stopProcess) { unsigned int stopFlags = VIR_QEMU_PROCESS_STOP_MIGRATED; @@ -2969,7 +2971,8 @@ qemuMigrationSrcConfirmPhase(virQEMUDriverPtr driver, qemuDomainEventQueue(driver, event); } - qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT); + qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT, + priv->job.migParams); if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm, driver->caps) < 0) VIR_WARN("Failed to save status on vm %s", vm->def->name); @@ -4581,6 +4584,7 @@ qemuMigrationSrcPerformJob(virQEMUDriverPtr driver, int ret = -1; virErrorPtr orig_err = NULL; virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver); + qemuDomainObjPrivatePtr priv = vm->privateData; if (qemuMigrationJobStart(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) goto cleanup; @@ -4641,7 +4645,8 @@ qemuMigrationSrcPerformJob(virQEMUDriverPtr driver, * here */ if (!v3proto && ret < 0) - qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT); + qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT, + priv->job.migParams); if (qemuMigrationSrcRestoreDomainState(driver, vm)) { event = virDomainEventLifecycleNewFromObj(vm, @@ -4691,6 +4696,7 @@ qemuMigrationSrcPerformPhase(virQEMUDriverPtr driver, unsigned long flags, unsigned long resource) { + qemuDomainObjPrivatePtr priv = vm->privateData; virObjectEventPtr event = NULL; int ret = -1; @@ -4731,7 +4737,8 @@ qemuMigrationSrcPerformPhase(virQEMUDriverPtr driver, endjob: if (ret < 0) { - qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT); + qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT, + priv->job.migParams); qemuMigrationJobFinish(driver, vm); } else { qemuMigrationJobContinue(vm); @@ -5187,7 +5194,8 @@ qemuMigrationDstFinish(virQEMUDriverPtr driver, VIR_FREE(priv->job.completed); } - qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN); + qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN, + priv->job.migParams); qemuMigrationJobFinish(driver, vm); if (!virDomainObjIsActive(vm)) diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 465132fd9c..72836ba9fa 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -378,30 +378,19 @@ qemuMigrationParamsSetCompression(virQEMUDriverPtr driver, * * Deconstruct all the setup possibly done for TLS - delete the TLS and * security objects, free the secinfo, and reset the migration params to "". - * - * Returns 0 on success, -1 on failure */ -static int +static void qemuMigrationParamsResetTLS(virQEMUDriverPtr driver, virDomainObjPtr vm, - int asyncJob) + int asyncJob, + qemuMigrationParamsPtr origParams) { - qemuDomainObjPrivatePtr priv = vm->privateData; char *tlsAlias = NULL; char *secAlias = NULL; - qemuMigrationParamsPtr migParams = NULL; - int ret = -1; - if (qemuMigrationParamsCheckTLSCreds(driver, vm, asyncJob) < 0) - return -1; - - /* If the tls-creds doesn't exist or if they're set to "" then there's - * nothing to do since we never set anything up */ - if (!priv->migTLSAlias || !*priv->migTLSAlias) - return 0; - - if (!(migParams = qemuMigrationParamsNew())) - goto cleanup; + /* If QEMU does not support TLS migration we didn't set the aliases. */ + if (!origParams->params.tlsCreds) + return; /* NB: If either or both fail to allocate memory we can still proceed * since the next time we migrate another deletion attempt will be @@ -410,21 +399,10 @@ qemuMigrationParamsResetTLS(virQEMUDriverPtr driver, secAlias = qemuDomainGetSecretAESAlias(QEMU_MIGRATION_TLS_ALIAS_BASE, false); qemuDomainDelTLSObjects(driver, vm, asyncJob, secAlias, tlsAlias); - qemuDomainSecretInfoFree(&priv->migSecinfo); + qemuDomainSecretInfoFree(&QEMU_DOMAIN_PRIVATE(vm)->migSecinfo); - if (VIR_STRDUP(migParams->params.tlsCreds, "") < 0 || - VIR_STRDUP(migParams->params.tlsHostname, "") < 0 || - qemuMigrationParamsSet(driver, vm, asyncJob, migParams) < 0) - goto cleanup; - - ret = 0; - - cleanup: VIR_FREE(tlsAlias); VIR_FREE(secAlias); - qemuMigrationParamsFree(migParams); - - return ret; } @@ -475,16 +453,22 @@ qemuMigrationParamsCheck(virQEMUDriverPtr driver, void qemuMigrationParamsReset(virQEMUDriverPtr driver, virDomainObjPtr vm, - int asyncJob) + int asyncJob, + qemuMigrationParamsPtr origParams) { qemuMonitorMigrationCaps cap; virErrorPtr err = virSaveLastError(); + VIR_DEBUG("Resetting migration parameters %p", origParams); + if (!virDomainObjIsActive(vm)) goto cleanup; - if (qemuMigrationParamsResetTLS(driver, vm, asyncJob) < 0) - goto cleanup; + if (origParams) { + if (qemuMigrationParamsSet(driver, vm, asyncJob, origParams) < 0) + goto cleanup; + qemuMigrationParamsResetTLS(driver, vm, asyncJob, origParams); + } for (cap = 0; cap < QEMU_MONITOR_MIGRATION_CAPS_LAST; cap++) { if (qemuMigrationCapsGet(vm, cap) && diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index c283a81b51..b7649128f8 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -108,7 +108,8 @@ qemuMigrationParamsCheck(virQEMUDriverPtr driver, void qemuMigrationParamsReset(virQEMUDriverPtr driver, virDomainObjPtr vm, - int asyncJob); + int asyncJob, + qemuMigrationParamsPtr origParams); int qemuMigrationCapsCheck(virQEMUDriverPtr driver, diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index fd81933f2e..6aa4f4ed71 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -3085,7 +3085,7 @@ qemuProcessRecoverMigrationIn(virQEMUDriverPtr driver, break; } - qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_NONE); + qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_NONE, job->migParams); return 0; } @@ -3179,7 +3179,7 @@ qemuProcessRecoverMigrationOut(virQEMUDriverPtr driver, } } - qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_NONE); + qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_NONE, job->migParams); return 0; } -- 2.17.0

The code can be merged directly in qemuMigrationParamsAddTLSObjects. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 15 ------- src/qemu/qemu_migration_params.c | 73 ++++++++++---------------------- src/qemu/qemu_migration_params.h | 6 --- 3 files changed, 23 insertions(+), 71 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 72fcae77f4..633f0120bb 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2042,7 +2042,6 @@ qemuMigrationSrcBegin(virConnectPtr conn, unsigned long flags) { virQEMUDriverPtr driver = conn->privateData; - virQEMUDriverConfigPtr cfg = NULL; char *xml = NULL; qemuDomainAsyncJob asyncJob; @@ -2076,12 +2075,6 @@ qemuMigrationSrcBegin(virConnectPtr conn, nmigrate_disks, migrate_disks, flags))) goto endjob; - if (flags & VIR_MIGRATE_TLS) { - cfg = virQEMUDriverGetConfig(driver); - if (qemuMigrationParamsCheckSetupTLS(driver, cfg, vm, asyncJob) < 0) - goto endjob; - } - if ((flags & VIR_MIGRATE_CHANGE_PROTECTION)) { /* We keep the job active across API calls until the confirm() call. * This prevents any other APIs being invoked while migration is taking @@ -2098,7 +2091,6 @@ qemuMigrationSrcBegin(virConnectPtr conn, } cleanup: - virObjectUnref(cfg); virDomainObjEndAPI(&vm); return xml; @@ -2460,10 +2452,6 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, * set the migration TLS parameters */ if (flags & VIR_MIGRATE_TLS) { cfg = virQEMUDriverGetConfig(driver); - if (qemuMigrationParamsCheckSetupTLS(driver, cfg, vm, - QEMU_ASYNC_JOB_MIGRATION_IN) < 0) - goto stopjob; - if (qemuMigrationParamsAddTLSObjects(driver, vm, cfg, true, QEMU_ASYNC_JOB_MIGRATION_IN, &tlsAlias, &secAlias, migParams) < 0) @@ -3421,9 +3409,6 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, if (flags & VIR_MIGRATE_TLS) { cfg = virQEMUDriverGetConfig(driver); - - /* Begin/CheckSetupTLS already set up migTLSAlias, the following - * assumes that and adds the TLS objects to the domain. */ if (qemuMigrationParamsAddTLSObjects(driver, vm, cfg, false, QEMU_ASYNC_JOB_MIGRATION_OUT, &tlsAlias, &secAlias, migParams) < 0) diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 72836ba9fa..d3a4a6d896 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -179,56 +179,6 @@ qemuMigrationParamsCheckTLSCreds(virQEMUDriverPtr driver, } -/* qemuMigrationParamsCheckSetupTLS - * @driver: pointer to qemu driver - * @vm: domain object - * @cfg: configuration pointer - * @asyncJob: migration job to join - * - * Check if TLS is possible and set up the environment. Assumes the caller - * desires to use TLS (e.g. caller found VIR_MIGRATE_TLS flag). - * - * Ensure the qemu.conf has been properly configured to add an entry for - * "migrate_tls_x509_cert_dir". Also check if the "tls-creds" parameter - * was present from a query of migration parameters - * - * Returns 0 on success, -1 on error/failure - */ -int -qemuMigrationParamsCheckSetupTLS(virQEMUDriverPtr driver, - virQEMUDriverConfigPtr cfg, - virDomainObjPtr vm, - int asyncJob) -{ - qemuDomainObjPrivatePtr priv = vm->privateData; - - if (!cfg->migrateTLSx509certdir) { - virReportError(VIR_ERR_OPERATION_INVALID, "%s", - _("host migration TLS directory not configured")); - return -1; - } - - if (qemuMigrationParamsCheckTLSCreds(driver, vm, asyncJob) < 0) - return -1; - - if (!priv->migTLSAlias) { - virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", - _("TLS migration is not supported with this " - "QEMU binary")); - return -1; - } - - /* If there's a secret, then grab/store it now using the connection */ - if (cfg->migrateTLSx509secretUUID && - !(priv->migSecinfo = - qemuDomainSecretInfoTLSNew(priv, QEMU_MIGRATION_TLS_ALIAS_BASE, - cfg->migrateTLSx509secretUUID))) - return -1; - - return 0; -} - - /* qemuMigrationParamsAddTLSObjects * @driver: pointer to qemu driver * @vm: domain object @@ -257,6 +207,29 @@ qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, virJSONValuePtr tlsProps = NULL; virJSONValuePtr secProps = NULL; + if (!cfg->migrateTLSx509certdir) { + virReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("host migration TLS directory not configured")); + goto error; + } + + if (qemuMigrationParamsCheckTLSCreds(driver, vm, asyncJob) < 0) + goto error; + + if (!priv->migTLSAlias) { + virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", + _("TLS migration is not supported with this " + "QEMU binary")); + goto error; + } + + /* If there's a secret, then grab/store it now using the connection */ + if (cfg->migrateTLSx509secretUUID && + !(priv->migSecinfo = + qemuDomainSecretInfoTLSNew(priv, QEMU_MIGRATION_TLS_ALIAS_BASE, + cfg->migrateTLSx509secretUUID))) + goto error; + if (qemuDomainGetTLSObjects(priv->qemuCaps, priv->migSecinfo, cfg->migrateTLSx509certdir, tlsListen, cfg->migrateTLSx509verify, diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index b7649128f8..a65a2fde2a 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -71,12 +71,6 @@ qemuMigrationParamsSet(virQEMUDriverPtr driver, int asyncJob, qemuMigrationParamsPtr migParams); -int -qemuMigrationParamsCheckSetupTLS(virQEMUDriverPtr driver, - virQEMUDriverConfigPtr cfg, - virDomainObjPtr vm, - int asyncJob); - int qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, virDomainObjPtr vm, -- 2.17.0

The function checks whether QEMU supports TLS migration and stores the original value of tls-creds parameter to priv->migTLSAlias. This is no longer needed because we already have the original value stored in priv->migParams. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_domain.c | 2 -- src/qemu/qemu_domain.h | 4 --- src/qemu/qemu_migration.c | 8 ++--- src/qemu/qemu_migration_params.c | 62 ++------------------------------ src/qemu/qemu_migration_params.h | 4 +-- 5 files changed, 6 insertions(+), 74 deletions(-) diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c index e997c14aad..03ad8d35c0 100644 --- a/src/qemu/qemu_domain.c +++ b/src/qemu/qemu_domain.c @@ -1905,8 +1905,6 @@ qemuDomainObjPrivateDataClear(qemuDomainObjPrivatePtr priv) virDomainUSBAddressSetFree(priv->usbaddrs); priv->usbaddrs = NULL; - /* clean up migration data */ - VIR_FREE(priv->migTLSAlias); virCPUDefFree(priv->origCPU); priv->origCPU = NULL; diff --git a/src/qemu/qemu_domain.h b/src/qemu/qemu_domain.h index 2c474ae4a4..2bb3e0a788 100644 --- a/src/qemu/qemu_domain.h +++ b/src/qemu/qemu_domain.h @@ -330,10 +330,6 @@ struct _qemuDomainObjPrivate { /* private XML). */ qemuDomainSecretInfoPtr migSecinfo; - /* Used when fetching/storing the current 'tls-creds' migration setting */ - /* (not to be saved in our private XML). */ - char *migTLSAlias; - /* CPU def used to start the domain when it differs from the one actually * provided by QEMU. */ virCPUDefPtr origCPU; diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 633f0120bb..e6239576ef 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2462,9 +2462,7 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, goto stopjob; } else { - if (qemuMigrationParamsSetEmptyTLS(driver, vm, - QEMU_ASYNC_JOB_MIGRATION_IN, - migParams) < 0) + if (qemuMigrationParamsSetEmptyTLS(vm, migParams) < 0) goto stopjob; } @@ -3426,9 +3424,7 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, goto error; } } else { - if (qemuMigrationParamsSetEmptyTLS(driver, vm, - QEMU_ASYNC_JOB_MIGRATION_OUT, - migParams) < 0) + if (qemuMigrationParamsSetEmptyTLS(vm, migParams) < 0) goto error; } diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index d3a4a6d896..451d799efb 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -133,52 +133,6 @@ qemuMigrationParamsSet(virQEMUDriverPtr driver, } -/* qemuMigrationParamsCheckTLSCreds - * @driver: pointer to qemu driver - * @vm: domain object - * @asyncJob: migration job to join - * - * Query the migration parameters looking for the 'tls-creds' parameter. - * If found, then we can support setting or clearing the parameters and thus - * can support TLS for migration. - * - * Returns 0 if we were able to successfully fetch the params and - * additionally if the tls-creds parameter exists, saves it in the - * private domain structure. Returns -1 on failure. - */ -static int -qemuMigrationParamsCheckTLSCreds(virQEMUDriverPtr driver, - virDomainObjPtr vm, - int asyncJob) -{ - int ret = -1; - qemuDomainObjPrivatePtr priv = vm->privateData; - qemuMigrationParamsPtr migParams = NULL; - - if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) - return -1; - - if (!(migParams = qemuMigrationParamsNew())) - goto cleanup; - - if (qemuMonitorGetMigrationParams(priv->mon, &migParams->params) < 0) - goto cleanup; - - /* NB: Could steal NULL pointer too! Let caller decide what to do. */ - VIR_STEAL_PTR(priv->migTLSAlias, migParams->params.tlsCreds); - - ret = 0; - - cleanup: - if (qemuDomainObjExitMonitor(driver, vm) < 0) - ret = -1; - - qemuMigrationParamsFree(migParams); - - return ret; -} - - /* qemuMigrationParamsAddTLSObjects * @driver: pointer to qemu driver * @vm: domain object @@ -213,10 +167,7 @@ qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, goto error; } - if (qemuMigrationParamsCheckTLSCreds(driver, vm, asyncJob) < 0) - goto error; - - if (!priv->migTLSAlias) { + if ((!priv->job.migParams->params.tlsCreds)) { virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", _("TLS migration is not supported with this " "QEMU binary")); @@ -260,9 +211,7 @@ qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, /* qemuMigrationParamsSetEmptyTLS - * @driver: pointer to qemu driver * @vm: domain object - * @asyncJob: migration job to join * @migParams: Pointer to a migration parameters block * * If we support setting the tls-creds, then set both tls-creds and @@ -272,17 +221,12 @@ qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, * Returns 0 on success, -1 on failure */ int -qemuMigrationParamsSetEmptyTLS(virQEMUDriverPtr driver, - virDomainObjPtr vm, - int asyncJob, +qemuMigrationParamsSetEmptyTLS(virDomainObjPtr vm, qemuMigrationParamsPtr migParams) { qemuDomainObjPrivatePtr priv = vm->privateData; - if (qemuMigrationParamsCheckTLSCreds(driver, vm, asyncJob) < 0) - return -1; - - if (!priv->migTLSAlias) + if (!priv->job.migParams->params.tlsCreds) return 0; if (VIR_STRDUP(migParams->params.tlsCreds, "") < 0 || diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index a65a2fde2a..c6cc2aaff6 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -82,9 +82,7 @@ qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, qemuMigrationParamsPtr migParams); int -qemuMigrationParamsSetEmptyTLS(virQEMUDriverPtr driver, - virDomainObjPtr vm, - int asyncJob, +qemuMigrationParamsSetEmptyTLS(virDomainObjPtr vm, qemuMigrationParamsPtr migParams); int -- 2.17.0

The new name is qemuMigrationParamsDisableTLS. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 4 ++-- src/qemu/qemu_migration_params.c | 6 +++--- src/qemu/qemu_migration_params.h | 4 ++-- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index e6239576ef..efc5734b1a 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2462,7 +2462,7 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, goto stopjob; } else { - if (qemuMigrationParamsSetEmptyTLS(vm, migParams) < 0) + if (qemuMigrationParamsDisableTLS(vm, migParams) < 0) goto stopjob; } @@ -3424,7 +3424,7 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, goto error; } } else { - if (qemuMigrationParamsSetEmptyTLS(vm, migParams) < 0) + if (qemuMigrationParamsDisableTLS(vm, migParams) < 0) goto error; } diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 451d799efb..1f3549a7b4 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -210,7 +210,7 @@ qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, } -/* qemuMigrationParamsSetEmptyTLS +/* qemuMigrationParamsDisableTLS * @vm: domain object * @migParams: Pointer to a migration parameters block * @@ -221,8 +221,8 @@ qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, * Returns 0 on success, -1 on failure */ int -qemuMigrationParamsSetEmptyTLS(virDomainObjPtr vm, - qemuMigrationParamsPtr migParams) +qemuMigrationParamsDisableTLS(virDomainObjPtr vm, + qemuMigrationParamsPtr migParams) { qemuDomainObjPrivatePtr priv = vm->privateData; diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index c6cc2aaff6..4eefe409df 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -82,8 +82,8 @@ qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, qemuMigrationParamsPtr migParams); int -qemuMigrationParamsSetEmptyTLS(virDomainObjPtr vm, - qemuMigrationParamsPtr migParams); +qemuMigrationParamsDisableTLS(virDomainObjPtr vm, + qemuMigrationParamsPtr migParams); int qemuMigrationParamsSetCompression(virQEMUDriverPtr driver, -- 2.17.0

The new name is qemuMigrationParamsEnableTLS. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 12 ++++++------ src/qemu/qemu_migration_params.c | 18 +++++++++--------- src/qemu/qemu_migration_params.h | 16 ++++++++-------- 3 files changed, 23 insertions(+), 23 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index efc5734b1a..9a9a881f9b 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2452,9 +2452,9 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, * set the migration TLS parameters */ if (flags & VIR_MIGRATE_TLS) { cfg = virQEMUDriverGetConfig(driver); - if (qemuMigrationParamsAddTLSObjects(driver, vm, cfg, true, - QEMU_ASYNC_JOB_MIGRATION_IN, - &tlsAlias, &secAlias, migParams) < 0) + if (qemuMigrationParamsEnableTLS(driver, vm, cfg, true, + QEMU_ASYNC_JOB_MIGRATION_IN, + &tlsAlias, &secAlias, migParams) < 0) goto stopjob; /* Force reset of 'tls-hostname', it's a source only parameter */ @@ -3407,9 +3407,9 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, if (flags & VIR_MIGRATE_TLS) { cfg = virQEMUDriverGetConfig(driver); - if (qemuMigrationParamsAddTLSObjects(driver, vm, cfg, false, - QEMU_ASYNC_JOB_MIGRATION_OUT, - &tlsAlias, &secAlias, migParams) < 0) + if (qemuMigrationParamsEnableTLS(driver, vm, cfg, false, + QEMU_ASYNC_JOB_MIGRATION_OUT, + &tlsAlias, &secAlias, migParams) < 0) goto error; /* We need to add tls-hostname whenever QEMU itself does not diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 1f3549a7b4..bb3bbc30f3 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -133,7 +133,7 @@ qemuMigrationParamsSet(virQEMUDriverPtr driver, } -/* qemuMigrationParamsAddTLSObjects +/* qemuMigrationParamsEnableTLS * @driver: pointer to qemu driver * @vm: domain object * @cfg: configuration pointer @@ -148,14 +148,14 @@ qemuMigrationParamsSet(virQEMUDriverPtr driver, * Returns 0 on success, -1 on failure */ int -qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, - virDomainObjPtr vm, - virQEMUDriverConfigPtr cfg, - bool tlsListen, - int asyncJob, - char **tlsAlias, - char **secAlias, - qemuMigrationParamsPtr migParams) +qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver, + virDomainObjPtr vm, + virQEMUDriverConfigPtr cfg, + bool tlsListen, + int asyncJob, + char **tlsAlias, + char **secAlias, + qemuMigrationParamsPtr migParams) { qemuDomainObjPrivatePtr priv = vm->privateData; virJSONValuePtr tlsProps = NULL; diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index 4eefe409df..6f3fb67949 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -72,14 +72,14 @@ qemuMigrationParamsSet(virQEMUDriverPtr driver, qemuMigrationParamsPtr migParams); int -qemuMigrationParamsAddTLSObjects(virQEMUDriverPtr driver, - virDomainObjPtr vm, - virQEMUDriverConfigPtr cfg, - bool tlsListen, - int asyncJob, - char **tlsAlias, - char **secAlias, - qemuMigrationParamsPtr migParams); +qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver, + virDomainObjPtr vm, + virQEMUDriverConfigPtr cfg, + bool tlsListen, + int asyncJob, + char **tlsAlias, + char **secAlias, + qemuMigrationParamsPtr migParams); int qemuMigrationParamsDisableTLS(virDomainObjPtr vm, -- 2.17.0

Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 31 ++++++++++++------------------- src/qemu/qemu_migration_params.c | 9 +++++++-- src/qemu/qemu_migration_params.h | 1 + 3 files changed, 20 insertions(+), 21 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 9a9a881f9b..c2cd937743 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2454,13 +2454,9 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, cfg = virQEMUDriverGetConfig(driver); if (qemuMigrationParamsEnableTLS(driver, vm, cfg, true, QEMU_ASYNC_JOB_MIGRATION_IN, - &tlsAlias, &secAlias, migParams) < 0) + &tlsAlias, &secAlias, NULL, + migParams) < 0) goto stopjob; - - /* Force reset of 'tls-hostname', it's a source only parameter */ - if (VIR_STRDUP(migParams->params.tlsHostname, "") < 0) - goto stopjob; - } else { if (qemuMigrationParamsDisableTLS(vm, migParams) < 0) goto stopjob; @@ -3406,23 +3402,20 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, VIR_WARN("unable to provide data for graphics client relocation"); if (flags & VIR_MIGRATE_TLS) { - cfg = virQEMUDriverGetConfig(driver); - if (qemuMigrationParamsEnableTLS(driver, vm, cfg, false, - QEMU_ASYNC_JOB_MIGRATION_OUT, - &tlsAlias, &secAlias, migParams) < 0) - goto error; + const char *hostname = NULL; /* We need to add tls-hostname whenever QEMU itself does not * connect directly to the destination. */ if (spec->destType == MIGRATION_DEST_CONNECT_HOST || - spec->destType == MIGRATION_DEST_FD) { - if (VIR_STRDUP(migParams->params.tlsHostname, spec->dest.host.name) < 0) - goto error; - } else { - /* Be sure there's nothing from a previous migration */ - if (VIR_STRDUP(migParams->params.tlsHostname, "") < 0) - goto error; - } + spec->destType == MIGRATION_DEST_FD) + hostname = spec->dest.host.name; + + cfg = virQEMUDriverGetConfig(driver); + if (qemuMigrationParamsEnableTLS(driver, vm, cfg, false, + QEMU_ASYNC_JOB_MIGRATION_OUT, + &tlsAlias, &secAlias, hostname, + migParams) < 0) + goto error; } else { if (qemuMigrationParamsDisableTLS(vm, migParams) < 0) goto error; diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index bb3bbc30f3..476687aae2 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -141,9 +141,12 @@ qemuMigrationParamsSet(virQEMUDriverPtr driver, * @asyncJob: Migration job to join * @tlsAlias: alias to be generated for TLS object * @secAlias: alias to be generated for a secinfo object + * @hostname: hostname of the migration destination * @migParams: migration parameters to set * - * Create the TLS objects for the migration and set the migParams value + * Create the TLS objects for the migration and set the migParams value. + * If QEMU itself does not connect to the destination @hostname must be + * provided for certificate verification. * * Returns 0 on success, -1 on failure */ @@ -155,6 +158,7 @@ qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver, int asyncJob, char **tlsAlias, char **secAlias, + const char *hostname, qemuMigrationParamsPtr migParams) { qemuDomainObjPrivatePtr priv = vm->privateData; @@ -198,7 +202,8 @@ qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver, *tlsAlias, &tlsProps) < 0) goto error; - if (VIR_STRDUP(migParams->params.tlsCreds, *tlsAlias) < 0) + if (VIR_STRDUP(migParams->params.tlsCreds, *tlsAlias) < 0 || + VIR_STRDUP(migParams->params.tlsHostname, hostname ? hostname : "") < 0) goto error; return 0; diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index 6f3fb67949..6535c3af47 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -79,6 +79,7 @@ qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver, int asyncJob, char **tlsAlias, char **secAlias, + const char *hostname, qemuMigrationParamsPtr migParams); int -- 2.17.0

There's no real reason for qemuMigrationParamsEnableTLS to require the callers to pass a valid virQEMUDriverConfigPtr, it can just call virQEMUDriverGetConfig. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 10 ++-------- src/qemu/qemu_migration_params.c | 12 ++++++++---- src/qemu/qemu_migration_params.h | 1 - 3 files changed, 10 insertions(+), 13 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index c2cd937743..54d9dfa025 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2228,7 +2228,6 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, { virDomainObjPtr vm = NULL; virObjectEventPtr event = NULL; - virQEMUDriverConfigPtr cfg = NULL; int ret = -1; int dataFD[2] = { -1, -1 }; qemuDomainObjPrivatePtr priv = NULL; @@ -2451,8 +2450,7 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, /* Migrations using TLS need to add the "tls-creds-x509" object and * set the migration TLS parameters */ if (flags & VIR_MIGRATE_TLS) { - cfg = virQEMUDriverGetConfig(driver); - if (qemuMigrationParamsEnableTLS(driver, vm, cfg, true, + if (qemuMigrationParamsEnableTLS(driver, vm, true, QEMU_ASYNC_JOB_MIGRATION_IN, &tlsAlias, &secAlias, NULL, migParams) < 0) @@ -2549,7 +2547,6 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, cleanup: VIR_FREE(tlsAlias); VIR_FREE(secAlias); - virObjectUnref(cfg); qemuProcessIncomingDefFree(incoming); VIR_FREE(xmlout); VIR_FORCE_CLOSE(dataFD[0]); @@ -3330,7 +3327,6 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, { int ret = -1; unsigned int migrate_flags = QEMU_MONITOR_MIGRATE_BACKGROUND; - virQEMUDriverConfigPtr cfg = NULL; qemuDomainObjPrivatePtr priv = vm->privateData; qemuMigrationCookiePtr mig = NULL; char *tlsAlias = NULL; @@ -3410,8 +3406,7 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, spec->destType == MIGRATION_DEST_FD) hostname = spec->dest.host.name; - cfg = virQEMUDriverGetConfig(driver); - if (qemuMigrationParamsEnableTLS(driver, vm, cfg, false, + if (qemuMigrationParamsEnableTLS(driver, vm, false, QEMU_ASYNC_JOB_MIGRATION_OUT, &tlsAlias, &secAlias, hostname, migParams) < 0) @@ -3649,7 +3644,6 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, cleanup: VIR_FREE(tlsAlias); VIR_FREE(secAlias); - virObjectUnref(cfg); VIR_FORCE_CLOSE(fd); virDomainDefFree(persistDef); qemuMigrationCookieFree(mig); diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 476687aae2..dd8cf68842 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -136,7 +136,6 @@ qemuMigrationParamsSet(virQEMUDriverPtr driver, /* qemuMigrationParamsEnableTLS * @driver: pointer to qemu driver * @vm: domain object - * @cfg: configuration pointer * @tlsListen: server or client * @asyncJob: Migration job to join * @tlsAlias: alias to be generated for TLS object @@ -153,7 +152,6 @@ qemuMigrationParamsSet(virQEMUDriverPtr driver, int qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver, virDomainObjPtr vm, - virQEMUDriverConfigPtr cfg, bool tlsListen, int asyncJob, char **tlsAlias, @@ -164,6 +162,8 @@ qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver, qemuDomainObjPrivatePtr priv = vm->privateData; virJSONValuePtr tlsProps = NULL; virJSONValuePtr secProps = NULL; + virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver); + int ret = -1; if (!cfg->migrateTLSx509certdir) { virReportError(VIR_ERR_OPERATION_INVALID, "%s", @@ -206,12 +206,16 @@ qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver, VIR_STRDUP(migParams->params.tlsHostname, hostname ? hostname : "") < 0) goto error; - return 0; + ret = 0; + + cleanup: + virObjectUnref(cfg); + return ret; error: virJSONValueFree(tlsProps); virJSONValueFree(secProps); - return -1; + goto cleanup; } diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index 6535c3af47..e8323dc9bb 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -74,7 +74,6 @@ qemuMigrationParamsSet(virQEMUDriverPtr driver, int qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver, virDomainObjPtr vm, - virQEMUDriverConfigPtr cfg, bool tlsListen, int asyncJob, char **tlsAlias, -- 2.17.0

The new name is qemuMigrationParamsApply and it will soon become the only API which will send all requested migration parameters and capabilities to QEMU. All other qemuMigrationParams* APIs will just operate on the qemuMigrationParams structure. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 8 ++++---- src/qemu/qemu_migration_params.c | 21 ++++++++++++++++----- src/qemu/qemu_migration_params.h | 8 ++++---- 3 files changed, 24 insertions(+), 13 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 54d9dfa025..602ccdfdd5 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2476,8 +2476,8 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, QEMU_ASYNC_JOB_MIGRATION_IN) < 0) goto stopjob; - if (qemuMigrationParamsSet(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN, - migParams) < 0) + if (qemuMigrationParamsApply(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN, + migParams) < 0) goto stopjob; if (mig->nbd && @@ -3471,8 +3471,8 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, true, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) goto error; - if (qemuMigrationParamsSet(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT, - migParams) < 0) + if (qemuMigrationParamsApply(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT, + migParams) < 0) goto error; if (qemuDomainObjEnterMonitorAsync(driver, vm, diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index dd8cf68842..92fe84d324 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -108,11 +108,22 @@ qemuMigrationParamsFromFlags(virTypedParameterPtr params, } +/** + * qemuMigrationParamsApply + * @driver: qemu driver + * @vm: domain object + * @asyncJob: migration job + * @migParams: migration parameters to send to QEMU + * + * Send all parameters stored in @migParams to QEMU. + * + * Returns 0 on success, -1 on failure. + */ int -qemuMigrationParamsSet(virQEMUDriverPtr driver, - virDomainObjPtr vm, - int asyncJob, - qemuMigrationParamsPtr migParams) +qemuMigrationParamsApply(virQEMUDriverPtr driver, + virDomainObjPtr vm, + int asyncJob, + qemuMigrationParamsPtr migParams) { qemuDomainObjPrivatePtr priv = vm->privateData; int ret = -1; @@ -391,7 +402,7 @@ qemuMigrationParamsReset(virQEMUDriverPtr driver, goto cleanup; if (origParams) { - if (qemuMigrationParamsSet(driver, vm, asyncJob, origParams) < 0) + if (qemuMigrationParamsApply(driver, vm, asyncJob, origParams) < 0) goto cleanup; qemuMigrationParamsResetTLS(driver, vm, asyncJob, origParams); } diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index e8323dc9bb..ce7f84fd66 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -66,10 +66,10 @@ void qemuMigrationParamsFree(qemuMigrationParamsPtr migParams); int -qemuMigrationParamsSet(virQEMUDriverPtr driver, - virDomainObjPtr vm, - int asyncJob, - qemuMigrationParamsPtr migParams); +qemuMigrationParamsApply(virQEMUDriverPtr driver, + virDomainObjPtr vm, + int asyncJob, + qemuMigrationParamsPtr migParams); int qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver, -- 2.17.0

All users of migration parameters are supposed to use APIs provided by qemu_migration_params.c without having to worry about the internals. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration_params.c | 5 +++++ src/qemu/qemu_migration_params.h | 3 --- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 92fe84d324..4ca49d942e 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -30,6 +30,7 @@ #include "qemu_hotplug.h" #include "qemu_migration.h" #include "qemu_migration_params.h" +#include "qemu_monitor.h" #define VIR_FROM_THIS VIR_FROM_QEMU @@ -37,6 +38,10 @@ VIR_LOG_INIT("qemu.qemu_migration_params"); #define QEMU_MIGRATION_TLS_ALIAS_BASE "libvirt_migrate" +struct _qemuMigrationParams { + qemuMonitorMigrationParams params; +}; + qemuMigrationParamsPtr qemuMigrationParamsNew(void) diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index ce7f84fd66..37e528f36c 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -49,9 +49,6 @@ struct _qemuMigrationCompression { typedef struct _qemuMigrationParams qemuMigrationParams; typedef qemuMigrationParams *qemuMigrationParamsPtr; -struct _qemuMigrationParams { - qemuMonitorMigrationParams params; -}; qemuMigrationParamsPtr -- 2.17.0

Our current monitor API forces the caller to call migrate-set-capabilities QMP command for each capability separately, which is quite suboptimal. Let's add a new API for setting all capabilities at once. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_monitor.c | 19 +++++++++++ src/qemu/qemu_monitor.h | 3 ++ src/qemu/qemu_monitor_json.c | 63 ++++++++++++++++++++++++++++++++++++ src/qemu/qemu_monitor_json.h | 3 ++ 4 files changed, 88 insertions(+) diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c index 7b647525b3..7ea72af788 100644 --- a/src/qemu/qemu_monitor.c +++ b/src/qemu/qemu_monitor.c @@ -3991,6 +3991,25 @@ qemuMonitorSetMigrationCapability(qemuMonitorPtr mon, } +int +qemuMonitorSetMigrationCapabilities(qemuMonitorPtr mon, + virBitmapPtr caps, + virBitmapPtr states) +{ + char *capsStr = virBitmapFormat(caps); + char *statesStr = virBitmapFormat(states); + + VIR_DEBUG("caps=%s, states=%s", NULLSTR(capsStr), NULLSTR(statesStr)); + + VIR_FREE(capsStr); + VIR_FREE(statesStr); + + QEMU_CHECK_MONITOR_JSON(mon); + + return qemuMonitorJSONSetMigrationCapabilities(mon, caps, states); +} + + /** * qemuMonitorGetGICCapabilities: * @mon: QEMU monitor diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h index d04148e568..870aae5cbd 100644 --- a/src/qemu/qemu_monitor.h +++ b/src/qemu/qemu_monitor.h @@ -763,6 +763,9 @@ int qemuMonitorGetMigrationCapabilities(qemuMonitorPtr mon, int qemuMonitorSetMigrationCapability(qemuMonitorPtr mon, qemuMonitorMigrationCaps capability, bool state); +int qemuMonitorSetMigrationCapabilities(qemuMonitorPtr mon, + virBitmapPtr caps, + virBitmapPtr states); int qemuMonitorGetGICCapabilities(qemuMonitorPtr mon, virGICCapability **capabilities); diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c index 57c2c4de0f..7ab73657a0 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -6251,6 +6251,69 @@ qemuMonitorJSONSetMigrationCapability(qemuMonitorPtr mon, } +int +qemuMonitorJSONSetMigrationCapabilities(qemuMonitorPtr mon, + virBitmapPtr caps, + virBitmapPtr states) +{ + int ret = -1; + qemuMonitorMigrationCaps bit; + virJSONValuePtr cmd = NULL; + virJSONValuePtr reply = NULL; + virJSONValuePtr cap = NULL; + virJSONValuePtr array; + + if (!(array = virJSONValueNewArray())) + goto cleanup; + + for (bit = 0; bit < QEMU_MONITOR_MIGRATION_CAPS_LAST; bit++) { + bool supported = false; + bool state = false; + + ignore_value(virBitmapGetBit(caps, bit, &supported)); + if (!supported) + continue; + + ignore_value(virBitmapGetBit(states, bit, &state)); + + if (!(cap = virJSONValueNewObject())) + goto cleanup; + + if (virJSONValueObjectAppendString(cap, "capability", + qemuMonitorMigrationCapsTypeToString(bit)) < 0) + goto cleanup; + + if (virJSONValueObjectAppendBoolean(cap, "state", state) < 0) + goto cleanup; + + if (virJSONValueArrayAppend(array, cap) < 0) + goto cleanup; + + cap = NULL; + } + + cmd = qemuMonitorJSONMakeCommand("migrate-set-capabilities", + "a:capabilities", &array, + NULL); + if (!cmd) + goto cleanup; + + if (qemuMonitorJSONCommand(mon, cmd, &reply) < 0) + goto cleanup; + + if (qemuMonitorJSONCheckError(cmd, reply) < 0) + goto cleanup; + + ret = 0; + cleanup: + virJSONValueFree(array); + virJSONValueFree(cap); + virJSONValueFree(cmd); + virJSONValueFree(reply); + return ret; +} + + /** * qemuMonitorJSONGetGICCapabilities: * @mon: QEMU JSON monitor diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h index 045df4919f..76e6738f44 100644 --- a/src/qemu/qemu_monitor_json.h +++ b/src/qemu/qemu_monitor_json.h @@ -148,6 +148,9 @@ int qemuMonitorJSONGetMigrationCapabilities(qemuMonitorPtr mon, int qemuMonitorJSONSetMigrationCapability(qemuMonitorPtr mon, qemuMonitorMigrationCaps capability, bool state); +int qemuMonitorJSONSetMigrationCapabilities(qemuMonitorPtr mon, + virBitmapPtr caps, + virBitmapPtr states); int qemuMonitorJSONGetGICCapabilities(qemuMonitorPtr mon, virGICCapability **capabilities); -- 2.17.0

Migration capabilities are closely related to migration parameters and it makes sense to keep them in a single data structure. Similarly to migration parameters the capabilities are all send to QEMU at once in qemuMigrationParamsApply, all other APIs operate on the qemuMigrationParams structure. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 100 ++++++------------------------- src/qemu/qemu_migration.h | 7 --- src/qemu/qemu_migration_params.c | 99 +++++++++++++++++++++++------- src/qemu/qemu_migration_params.h | 11 ++++ 4 files changed, 107 insertions(+), 110 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 602ccdfdd5..e01c2a209d 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -1174,66 +1174,6 @@ qemuMigrationAnyPostcopyFailed(virQEMUDriverPtr driver, } -int -qemuMigrationOptionSet(virQEMUDriverPtr driver, - virDomainObjPtr vm, - qemuMonitorMigrationCaps capability, - bool state, - qemuDomainAsyncJob job) -{ - qemuDomainObjPrivatePtr priv = vm->privateData; - int ret; - - if (!qemuMigrationCapsGet(vm, capability)) { - if (!state) { - /* Unsupported but we want it off anyway */ - return 0; - } - - if (job == QEMU_ASYNC_JOB_MIGRATION_IN) { - virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, - _("Migration option '%s' is not supported by " - "target QEMU binary"), - qemuMonitorMigrationCapsTypeToString(capability)); - } else { - virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, - _("Migration option '%s' is not supported by " - "source QEMU binary"), - qemuMonitorMigrationCapsTypeToString(capability)); - } - return -1; - } - - if (qemuDomainObjEnterMonitorAsync(driver, vm, job) < 0) - return -1; - - ret = qemuMonitorSetMigrationCapability(priv->mon, capability, state); - - if (qemuDomainObjExitMonitor(driver, vm) < 0) - ret = -1; - - return ret; -} - - -static int -qemuMigrationOptionSetPostCopy(virQEMUDriverPtr driver, - virDomainObjPtr vm, - bool state, - qemuDomainAsyncJob job) -{ - qemuDomainObjPrivatePtr priv = vm->privateData; - - if (qemuMigrationOptionSet(driver, vm, - QEMU_MONITOR_MIGRATION_CAPS_POSTCOPY, - state, job) < 0) - return -1; - - priv->job.postcopyEnabled = state; - return 0; -} - - static int qemuMigrationSrcWaitForSpice(virDomainObjPtr vm) { @@ -2465,15 +2405,14 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, goto stopjob; } - if (qemuMigrationOptionSet(driver, vm, - QEMU_MONITOR_MIGRATION_CAPS_RDMA_PIN_ALL, - flags & VIR_MIGRATE_RDMA_PIN_ALL, - QEMU_ASYNC_JOB_MIGRATION_IN) < 0) + if (qemuMigrationParamsSetCapability(vm, + QEMU_MONITOR_MIGRATION_CAPS_RDMA_PIN_ALL, + flags & VIR_MIGRATE_RDMA_PIN_ALL, + migParams) < 0) goto stopjob; - if (qemuMigrationOptionSetPostCopy(driver, vm, - flags & VIR_MIGRATE_POSTCOPY, - QEMU_ASYNC_JOB_MIGRATION_IN) < 0) + if (qemuMigrationParamsSetPostCopy(vm, flags & VIR_MIGRATE_POSTCOPY, + migParams) < 0) goto stopjob; if (qemuMigrationParamsApply(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN, @@ -3448,27 +3387,26 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, compression, migParams) < 0) goto error; - if (qemuMigrationOptionSet(driver, vm, - QEMU_MONITOR_MIGRATION_CAPS_AUTO_CONVERGE, - flags & VIR_MIGRATE_AUTO_CONVERGE, - QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) + if (qemuMigrationParamsSetCapability(vm, + QEMU_MONITOR_MIGRATION_CAPS_AUTO_CONVERGE, + flags & VIR_MIGRATE_AUTO_CONVERGE, + migParams) < 0) goto error; - if (qemuMigrationOptionSet(driver, vm, - QEMU_MONITOR_MIGRATION_CAPS_RDMA_PIN_ALL, - flags & VIR_MIGRATE_RDMA_PIN_ALL, - QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) + if (qemuMigrationParamsSetCapability(vm, + QEMU_MONITOR_MIGRATION_CAPS_RDMA_PIN_ALL, + flags & VIR_MIGRATE_RDMA_PIN_ALL, + migParams) < 0) goto error; - if (qemuMigrationOptionSetPostCopy(driver, vm, - flags & VIR_MIGRATE_POSTCOPY, - QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) + if (qemuMigrationParamsSetPostCopy(vm, flags & VIR_MIGRATE_POSTCOPY, + migParams) < 0) goto error; if (qemuMigrationCapsGet(vm, QEMU_MONITOR_MIGRATION_CAPS_PAUSE_BEFORE_SWITCHOVER) && - qemuMigrationOptionSet(driver, vm, - QEMU_MONITOR_MIGRATION_CAPS_PAUSE_BEFORE_SWITCHOVER, - true, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) + qemuMigrationParamsSetCapability(vm, + QEMU_MONITOR_MIGRATION_CAPS_PAUSE_BEFORE_SWITCHOVER, + true, migParams) < 0) goto error; if (qemuMigrationParamsApply(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT, diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h index e59296fd63..fc81eb5016 100644 --- a/src/qemu/qemu_migration.h +++ b/src/qemu/qemu_migration.h @@ -273,11 +273,4 @@ qemuMigrationSrcFetchMirrorStats(virQEMUDriverPtr driver, qemuDomainAsyncJob asyncJob, qemuDomainJobInfoPtr jobInfo); -int -qemuMigrationOptionSet(virQEMUDriverPtr driver, - virDomainObjPtr vm, - qemuMonitorMigrationCaps capability, - bool state, - qemuDomainAsyncJob job); - #endif /* __QEMU_MIGRATION_H__ */ diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 4ca49d942e..d934a93086 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -39,6 +39,7 @@ VIR_LOG_INIT("qemu.qemu_migration_params"); #define QEMU_MIGRATION_TLS_ALIAS_BASE "libvirt_migrate" struct _qemuMigrationParams { + virBitmapPtr caps; qemuMonitorMigrationParams params; }; @@ -51,7 +52,15 @@ qemuMigrationParamsNew(void) if (VIR_ALLOC(params) < 0) return NULL; + params->caps = virBitmapNew(QEMU_MONITOR_MIGRATION_CAPS_LAST); + if (!params->caps) + goto error; + return params; + + error: + qemuMigrationParamsFree(params); + return NULL; } @@ -61,6 +70,7 @@ qemuMigrationParamsFree(qemuMigrationParamsPtr migParams) if (!migParams) return; + virBitmapFree(migParams->caps); VIR_FREE(migParams->params.tlsCreds); VIR_FREE(migParams->params.tlsHostname); VIR_FREE(migParams); @@ -136,6 +146,10 @@ qemuMigrationParamsApply(virQEMUDriverPtr driver, if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) return -1; + if (qemuMonitorSetMigrationCapabilities(priv->mon, priv->migrationCaps, + migParams->caps) < 0) + goto cleanup; + if (qemuMonitorSetMigrationParams(priv->mon, &migParams->params) < 0) goto cleanup; @@ -149,6 +163,50 @@ qemuMigrationParamsApply(virQEMUDriverPtr driver, } +int +qemuMigrationParamsSetCapability(virDomainObjPtr vm, + qemuMonitorMigrationCaps capability, + bool state, + qemuMigrationParamsPtr migParams) +{ + if (!qemuMigrationCapsGet(vm, capability)) { + if (!state) { + /* Unsupported but we want it off anyway */ + return 0; + } + + virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, + _("Migration option '%s' is not supported by QEMU binary"), + qemuMonitorMigrationCapsTypeToString(capability)); + return -1; + } + + if (state) + ignore_value(virBitmapSetBit(migParams->caps, capability)); + else + ignore_value(virBitmapClearBit(migParams->caps, capability)); + + return 0; +} + + +int +qemuMigrationParamsSetPostCopy(virDomainObjPtr vm, + bool state, + qemuMigrationParamsPtr migParams) +{ + qemuDomainObjPrivatePtr priv = vm->privateData; + + if (qemuMigrationParamsSetCapability(vm, + QEMU_MONITOR_MIGRATION_CAPS_POSTCOPY, + state, migParams) < 0) + return -1; + + priv->job.postcopyEnabled = state; + return 0; +} + + /* qemuMigrationParamsEnableTLS * @driver: pointer to qemu driver * @vm: domain object @@ -272,18 +330,18 @@ qemuMigrationParamsSetCompression(virQEMUDriverPtr driver, int ret = -1; qemuDomainObjPrivatePtr priv = vm->privateData; - if (qemuMigrationOptionSet(driver, vm, - QEMU_MONITOR_MIGRATION_CAPS_XBZRLE, - compression->methods & - (1ULL << QEMU_MIGRATION_COMPRESS_XBZRLE), - asyncJob) < 0) + if (qemuMigrationParamsSetCapability(vm, + QEMU_MONITOR_MIGRATION_CAPS_XBZRLE, + compression->methods & + (1ULL << QEMU_MIGRATION_COMPRESS_XBZRLE), + migParams) < 0) return -1; - if (qemuMigrationOptionSet(driver, vm, - QEMU_MONITOR_MIGRATION_CAPS_COMPRESS, - compression->methods & - (1ULL << QEMU_MIGRATION_COMPRESS_MT), - asyncJob) < 0) + if (qemuMigrationParamsSetCapability(vm, + QEMU_MONITOR_MIGRATION_CAPS_COMPRESS, + compression->methods & + (1ULL << QEMU_MIGRATION_COMPRESS_MT), + migParams) < 0) return -1; if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) @@ -369,6 +427,11 @@ qemuMigrationParamsCheck(virQEMUDriverPtr driver, if (!(origParams = qemuMigrationParamsNew())) goto cleanup; + /* + * We want to disable all migration capabilities after migration, no need + * to ask QEMU for their current settings. + */ + if (qemuMonitorGetMigrationParams(priv->mon, &origParams->params) < 0) goto cleanup; @@ -398,25 +461,17 @@ qemuMigrationParamsReset(virQEMUDriverPtr driver, int asyncJob, qemuMigrationParamsPtr origParams) { - qemuMonitorMigrationCaps cap; virErrorPtr err = virSaveLastError(); VIR_DEBUG("Resetting migration parameters %p", origParams); - if (!virDomainObjIsActive(vm)) + if (!virDomainObjIsActive(vm) || !origParams) goto cleanup; - if (origParams) { - if (qemuMigrationParamsApply(driver, vm, asyncJob, origParams) < 0) - goto cleanup; - qemuMigrationParamsResetTLS(driver, vm, asyncJob, origParams); - } + if (qemuMigrationParamsApply(driver, vm, asyncJob, origParams) < 0) + goto cleanup; - for (cap = 0; cap < QEMU_MONITOR_MIGRATION_CAPS_LAST; cap++) { - if (qemuMigrationCapsGet(vm, cap) && - qemuMigrationOptionSet(driver, vm, cap, false, asyncJob) < 0) - goto cleanup; - } + qemuMigrationParamsResetTLS(driver, vm, asyncJob, origParams); cleanup: if (err) { diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index 37e528f36c..e341f73900 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -68,6 +68,17 @@ qemuMigrationParamsApply(virQEMUDriverPtr driver, int asyncJob, qemuMigrationParamsPtr migParams); +int +qemuMigrationParamsSetCapability(virDomainObjPtr vm, + qemuMonitorMigrationCaps capability, + bool state, + qemuMigrationParamsPtr migParams); + +int +qemuMigrationParamsSetPostCopy(virDomainObjPtr vm, + bool state, + qemuMigrationParamsPtr migParams); + int qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver, virDomainObjPtr vm, -- 2.17.0

Rework all remaining callers of qemuMonitorSetMigrationCapability to use the new qemuMonitorSetMigrationCapabilities API. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration_params.c | 11 ++++++++--- tests/qemumonitorjsontest.c | 16 +++++++++++----- 2 files changed, 19 insertions(+), 8 deletions(-) diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index d934a93086..53e105bec8 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -487,6 +487,7 @@ qemuMigrationCapsCheck(virQEMUDriverPtr driver, int asyncJob) { qemuDomainObjPrivatePtr priv = vm->privateData; + virBitmapPtr migEvent = NULL; char **caps = NULL; char **capStr; int ret = -1; @@ -521,12 +522,16 @@ qemuMigrationCapsCheck(virQEMUDriverPtr driver, } if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATION_EVENT)) { + migEvent = virBitmapNew(QEMU_MONITOR_MIGRATION_CAPS_LAST); + if (!migEvent) + goto cleanup; + + ignore_value(virBitmapSetBit(migEvent, QEMU_MONITOR_MIGRATION_CAPS_EVENTS)); + if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) goto cleanup; - rc = qemuMonitorSetMigrationCapability(priv->mon, - QEMU_MONITOR_MIGRATION_CAPS_EVENTS, - true); + rc = qemuMonitorSetMigrationCapabilities(priv->mon, migEvent, migEvent); if (qemuDomainObjExitMonitor(driver, vm) < 0) goto cleanup; diff --git a/tests/qemumonitorjsontest.c b/tests/qemumonitorjsontest.c index 0afdc80038..1cad383596 100644 --- a/tests/qemumonitorjsontest.c +++ b/tests/qemumonitorjsontest.c @@ -2229,13 +2229,14 @@ testQemuMonitorJSONqemuMonitorJSONGetTargetArch(const void *data) } static int -testQemuMonitorJSONqemuMonitorJSONGetMigrationCapability(const void *data) +testQemuMonitorJSONqemuMonitorJSONGetMigrationCapabilities(const void *data) { virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data; qemuMonitorTestPtr test = qemuMonitorTestNewSimple(true, xmlopt); int ret = -1; const char *cap; char **caps = NULL; + virBitmapPtr bitmap = NULL; const char *reply = "{" " \"return\": [" @@ -2266,15 +2267,20 @@ testQemuMonitorJSONqemuMonitorJSONGetMigrationCapability(const void *data) goto cleanup; } - if (qemuMonitorJSONSetMigrationCapability(qemuMonitorTestGetMonitor(test), - QEMU_MONITOR_MIGRATION_CAPS_XBZRLE, - true) < 0) + bitmap = virBitmapNew(QEMU_MONITOR_MIGRATION_CAPS_LAST); + if (!bitmap) + goto cleanup; + + ignore_value(virBitmapSetBit(bitmap, QEMU_MONITOR_MIGRATION_CAPS_XBZRLE)); + if (qemuMonitorJSONSetMigrationCapabilities(qemuMonitorTestGetMonitor(test), + bitmap, bitmap) < 0) goto cleanup; ret = 0; cleanup: qemuMonitorTestFree(test); virStringListFree(caps); + virBitmapFree(bitmap); return ret; } @@ -2999,7 +3005,7 @@ mymain(void) DO_TEST(qemuMonitorJSONGetChardevInfo); DO_TEST(qemuMonitorJSONSetBlockIoThrottle); DO_TEST(qemuMonitorJSONGetTargetArch); - DO_TEST(qemuMonitorJSONGetMigrationCapability); + DO_TEST(qemuMonitorJSONGetMigrationCapabilities); DO_TEST(qemuMonitorJSONQueryCPUs); DO_TEST(qemuMonitorJSONGetVirtType); DO_TEST(qemuMonitorJSONSendKey); -- 2.17.0

Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_monitor.c | 14 ---------- src/qemu/qemu_monitor.h | 3 -- src/qemu/qemu_monitor_json.c | 53 ------------------------------------ src/qemu/qemu_monitor_json.h | 3 -- 4 files changed, 73 deletions(-) diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c index 7ea72af788..09f21ba77d 100644 --- a/src/qemu/qemu_monitor.c +++ b/src/qemu/qemu_monitor.c @@ -3977,20 +3977,6 @@ qemuMonitorGetMigrationCapabilities(qemuMonitorPtr mon, } -int -qemuMonitorSetMigrationCapability(qemuMonitorPtr mon, - qemuMonitorMigrationCaps capability, - bool state) -{ - VIR_DEBUG("capability=%s, state=%d", - qemuMonitorMigrationCapsTypeToString(capability), state); - - QEMU_CHECK_MONITOR_JSON(mon); - - return qemuMonitorJSONSetMigrationCapability(mon, capability, state); -} - - int qemuMonitorSetMigrationCapabilities(qemuMonitorPtr mon, virBitmapPtr caps, diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h index 870aae5cbd..c95b3a2ef4 100644 --- a/src/qemu/qemu_monitor.h +++ b/src/qemu/qemu_monitor.h @@ -760,9 +760,6 @@ VIR_ENUM_DECL(qemuMonitorMigrationCaps); int qemuMonitorGetMigrationCapabilities(qemuMonitorPtr mon, char ***capabilities); -int qemuMonitorSetMigrationCapability(qemuMonitorPtr mon, - qemuMonitorMigrationCaps capability, - bool state); int qemuMonitorSetMigrationCapabilities(qemuMonitorPtr mon, virBitmapPtr caps, virBitmapPtr states); diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c index 7ab73657a0..c6cb71addf 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -6198,59 +6198,6 @@ qemuMonitorJSONGetMigrationCapabilities(qemuMonitorPtr mon, } -int -qemuMonitorJSONSetMigrationCapability(qemuMonitorPtr mon, - qemuMonitorMigrationCaps capability, - bool state) -{ - int ret = -1; - - virJSONValuePtr cmd = NULL; - virJSONValuePtr reply = NULL; - virJSONValuePtr cap = NULL; - virJSONValuePtr caps; - - if (!(caps = virJSONValueNewArray())) - goto cleanup; - - if (!(cap = virJSONValueNewObject())) - goto cleanup; - - if (virJSONValueObjectAppendString( - cap, "capability", - qemuMonitorMigrationCapsTypeToString(capability)) < 0) - goto cleanup; - - if (virJSONValueObjectAppendBoolean(cap, "state", state) < 0) - goto cleanup; - - if (virJSONValueArrayAppend(caps, cap) < 0) - goto cleanup; - - cap = NULL; - - cmd = qemuMonitorJSONMakeCommand("migrate-set-capabilities", - "a:capabilities", &caps, - NULL); - if (!cmd) - goto cleanup; - - if (qemuMonitorJSONCommand(mon, cmd, &reply) < 0) - goto cleanup; - - if (qemuMonitorJSONCheckError(cmd, reply) < 0) - goto cleanup; - - ret = 0; - cleanup: - virJSONValueFree(caps); - virJSONValueFree(cap); - virJSONValueFree(cmd); - virJSONValueFree(reply); - return ret; -} - - int qemuMonitorJSONSetMigrationCapabilities(qemuMonitorPtr mon, virBitmapPtr caps, diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h index 76e6738f44..a73e98815c 100644 --- a/src/qemu/qemu_monitor_json.h +++ b/src/qemu/qemu_monitor_json.h @@ -145,9 +145,6 @@ int qemuMonitorJSONGetMigrationStats(qemuMonitorPtr mon, int qemuMonitorJSONGetMigrationCapabilities(qemuMonitorPtr mon, char ***capabilities); -int qemuMonitorJSONSetMigrationCapability(qemuMonitorPtr mon, - qemuMonitorMigrationCaps capability, - bool state); int qemuMonitorJSONSetMigrationCapabilities(qemuMonitorPtr mon, virBitmapPtr caps, virBitmapPtr states); -- 2.17.0

Originally QEMU provided query-migrate-cache-size and migrate-set-cache-size QMP commands for querying/setting XBZRLE cache size. In version 2.11 QEMU added support for XBZRLE cache size to the general migration paramaters commands. This patch adds support for this parameter to libvirt to make sure it is properly restored to its original value after a failed or aborted migration. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_monitor.c | 5 +++-- src/qemu/qemu_monitor.h | 3 +++ src/qemu/qemu_monitor_json.c | 2 ++ tests/qemumonitorjsontest.c | 4 +++- 4 files changed, 11 insertions(+), 3 deletions(-) diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c index 09f21ba77d..18b54e2da8 100644 --- a/src/qemu/qemu_monitor.c +++ b/src/qemu/qemu_monitor.c @@ -2639,7 +2639,7 @@ qemuMonitorSetMigrationParams(qemuMonitorPtr mon, "decompressThreads=%d:%d cpuThrottleInitial=%d:%d " "cpuThrottleIncrement=%d:%d tlsCreds=%s tlsHostname=%s " "maxBandwidth=%d:%llu downtimeLimit=%d:%llu " - "blockIncremental=%d:%d", + "blockIncremental=%d:%d xbzrleCacheSize=%d:%llu", params->compressLevel_set, params->compressLevel, params->compressThreads_set, params->compressThreads, params->decompressThreads_set, params->decompressThreads, @@ -2648,7 +2648,8 @@ qemuMonitorSetMigrationParams(qemuMonitorPtr mon, NULLSTR(params->tlsCreds), NULLSTR(params->tlsHostname), params->maxBandwidth_set, params->maxBandwidth, params->downtimeLimit_set, params->downtimeLimit, - params->blockIncremental_set, params->blockIncremental); + params->blockIncremental_set, params->blockIncremental, + params->xbzrleCacheSize_set, params->xbzrleCacheSize); QEMU_CHECK_MONITOR_JSON(mon); diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h index c95b3a2ef4..2bb4dbc667 100644 --- a/src/qemu/qemu_monitor.h +++ b/src/qemu/qemu_monitor.h @@ -673,6 +673,9 @@ struct _qemuMonitorMigrationParams { bool blockIncremental_set; bool blockIncremental; + + bool xbzrleCacheSize_set; + unsigned long long xbzrleCacheSize; }; int qemuMonitorGetMigrationParams(qemuMonitorPtr mon, diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c index c6cb71addf..acc126629e 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -2833,6 +2833,7 @@ qemuMonitorJSONGetMigrationParams(qemuMonitorPtr mon, PARSE_ULONG(maxBandwidth, "max-bandwidth"); PARSE_ULONG(downtimeLimit, "downtime-limit"); PARSE_BOOL(blockIncremental, "block-incremental"); + PARSE_ULONG(xbzrleCacheSize, "xbzrle-cache-size"); #undef PARSE_SET #undef PARSE_INT @@ -2898,6 +2899,7 @@ qemuMonitorJSONSetMigrationParams(qemuMonitorPtr mon, APPEND_ULONG(maxBandwidth, "max-bandwidth"); APPEND_ULONG(downtimeLimit, "downtime-limit"); APPEND_BOOL(blockIncremental, "block-incremental"); + APPEND_ULONG(xbzrleCacheSize, "xbzrle-cache-size"); #undef APPEND #undef APPEND_INT diff --git a/tests/qemumonitorjsontest.c b/tests/qemumonitorjsontest.c index 1cad383596..8a5b0be64b 100644 --- a/tests/qemumonitorjsontest.c +++ b/tests/qemumonitorjsontest.c @@ -1810,7 +1810,8 @@ testQemuMonitorJSONqemuMonitorJSONGetMigrationParams(const void *data) " \"tls-hostname\": \"\"," " \"max-bandwidth\": 1234567890," " \"downtime-limit\": 500," - " \"block-incremental\": true" + " \"block-incremental\": true," + " \"xbzrle-cache-size\": 67108864" " }" "}") < 0) { goto cleanup; @@ -1867,6 +1868,7 @@ testQemuMonitorJSONqemuMonitorJSONGetMigrationParams(const void *data) CHECK_ULONG(maxBandwidth, "max-bandwidth", 1234567890ULL); CHECK_ULONG(downtimeLimit, "downtime-limit", 500ULL); CHECK_BOOL(blockIncremental, "block-incremental", true); + CHECK_ULONG(xbzrleCacheSize, "xbzrle-cache-size", 67108864ULL); #undef CHECK_NUM #undef CHECK_INT -- 2.17.0

Prefer xbzrle-cache-size migration parameter over the special migrate-set-cache-size QMP command. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 6 ++--- src/qemu/qemu_migration_params.c | 42 +++++++++++++++++--------------- src/qemu/qemu_migration_params.h | 4 +-- 3 files changed, 25 insertions(+), 27 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index e01c2a209d..476417c15d 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2383,8 +2383,7 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN) < 0) goto stopjob; - if (qemuMigrationParamsSetCompression(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN, - compression, migParams) < 0) + if (qemuMigrationParamsSetCompression(vm, compression, migParams) < 0) goto stopjob; /* Migrations using TLS need to add the "tls-creds-x509" object and @@ -3383,8 +3382,7 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, goto error; } - if (qemuMigrationParamsSetCompression(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT, - compression, migParams) < 0) + if (qemuMigrationParamsSetCompression(vm, compression, migParams) < 0) goto error; if (qemuMigrationParamsSetCapability(vm, diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 53e105bec8..faaaa29cc9 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -141,6 +141,7 @@ qemuMigrationParamsApply(virQEMUDriverPtr driver, qemuMigrationParamsPtr migParams) { qemuDomainObjPrivatePtr priv = vm->privateData; + bool xbzrleCacheSize_old = false; int ret = -1; if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) @@ -150,6 +151,20 @@ qemuMigrationParamsApply(virQEMUDriverPtr driver, migParams->caps) < 0) goto cleanup; + /* If QEMU is too old to support xbzrle-cache-size migration parameter, + * we need to set it via migrate-set-cache-size and tell + * qemuMonitorSetMigrationParams to ignore this parameter. + */ + if (migParams->params.xbzrleCacheSize_set && + (!priv->job.migParams || + !priv->job.migParams->params.xbzrleCacheSize_set)) { + if (qemuMonitorSetMigrationCacheSize(priv->mon, + migParams->params.xbzrleCacheSize) < 0) + goto cleanup; + xbzrleCacheSize_old = true; + migParams->params.xbzrleCacheSize_set = false; + } + if (qemuMonitorSetMigrationParams(priv->mon, &migParams->params) < 0) goto cleanup; @@ -159,6 +174,9 @@ qemuMigrationParamsApply(virQEMUDriverPtr driver, if (qemuDomainObjExitMonitor(driver, vm) < 0) ret = -1; + if (xbzrleCacheSize_old) + migParams->params.xbzrleCacheSize_set = true; + return ret; } @@ -321,15 +339,10 @@ qemuMigrationParamsDisableTLS(virDomainObjPtr vm, int -qemuMigrationParamsSetCompression(virQEMUDriverPtr driver, - virDomainObjPtr vm, - int asyncJob, +qemuMigrationParamsSetCompression(virDomainObjPtr vm, qemuMigrationCompressionPtr compression, qemuMigrationParamsPtr migParams) { - int ret = -1; - qemuDomainObjPrivatePtr priv = vm->privateData; - if (qemuMigrationParamsSetCapability(vm, QEMU_MONITOR_MIGRATION_CAPS_XBZRLE, compression->methods & @@ -344,9 +357,6 @@ qemuMigrationParamsSetCompression(virQEMUDriverPtr driver, migParams) < 0) return -1; - if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) - return -1; - migParams->params.compressLevel_set = compression->level_set; migParams->params.compressLevel = compression->level; @@ -356,18 +366,10 @@ qemuMigrationParamsSetCompression(virQEMUDriverPtr driver, migParams->params.decompressThreads_set = compression->dthreads_set; migParams->params.decompressThreads = compression->dthreads; - if (compression->xbzrle_cache_set && - qemuMonitorSetMigrationCacheSize(priv->mon, - compression->xbzrle_cache) < 0) - goto cleanup; + migParams->params.xbzrleCacheSize_set = compression->xbzrle_cache_set; + migParams->params.xbzrleCacheSize = compression->xbzrle_cache; - ret = 0; - - cleanup: - if (qemuDomainObjExitMonitor(driver, vm) < 0) - ret = -1; - - return ret; + return 0; } diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index e341f73900..4cb70f62a4 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -94,9 +94,7 @@ qemuMigrationParamsDisableTLS(virDomainObjPtr vm, qemuMigrationParamsPtr migParams); int -qemuMigrationParamsSetCompression(virQEMUDriverPtr driver, - virDomainObjPtr vm, - int asyncJob, +qemuMigrationParamsSetCompression(virDomainObjPtr vm, qemuMigrationCompressionPtr compression, qemuMigrationParamsPtr migParams); -- 2.17.0

We reached the point when qemuMigrationParamsApply is the only API which sends migration parameters and capabilities to QEMU. Thus all but the TLS parameters can be set before we ask QEMU for the current values of all parameters in qemuMigrationParamsCheck. Supported migration capabilities are queried as soon as libvirt connects to QEMU monitor so we can check them anytime. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 476417c15d..c97911039d 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2380,25 +2380,9 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, dataFD[1] = -1; /* 'st' owns the FD now & will close it */ } - if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN) < 0) - goto stopjob; - if (qemuMigrationParamsSetCompression(vm, compression, migParams) < 0) goto stopjob; - /* Migrations using TLS need to add the "tls-creds-x509" object and - * set the migration TLS parameters */ - if (flags & VIR_MIGRATE_TLS) { - if (qemuMigrationParamsEnableTLS(driver, vm, true, - QEMU_ASYNC_JOB_MIGRATION_IN, - &tlsAlias, &secAlias, NULL, - migParams) < 0) - goto stopjob; - } else { - if (qemuMigrationParamsDisableTLS(vm, migParams) < 0) - goto stopjob; - } - if (STREQ_NULLABLE(protocol, "rdma") && virProcessSetMaxMemLock(vm->pid, vm->def->mem.hard_limit << 10) < 0) { goto stopjob; @@ -2414,6 +2398,22 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, migParams) < 0) goto stopjob; + if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN) < 0) + goto stopjob; + + /* Migrations using TLS need to add the "tls-creds-x509" object and + * set the migration TLS parameters */ + if (flags & VIR_MIGRATE_TLS) { + if (qemuMigrationParamsEnableTLS(driver, vm, true, + QEMU_ASYNC_JOB_MIGRATION_IN, + &tlsAlias, &secAlias, NULL, + migParams) < 0) + goto stopjob; + } else { + if (qemuMigrationParamsDisableTLS(vm, migParams) < 0) + goto stopjob; + } + if (qemuMigrationParamsApply(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN, migParams) < 0) goto stopjob; -- 2.17.0

We reached the point when qemuMigrationParamsApply is the only API which sends migration parameters and capabilities to QEMU. Thus all but the TLS parameters can be set before we ask QEMU for the current values of all parameters in qemuMigrationParamsCheck. Supported migration capabilities are queried as soon as libvirt connects to QEMU monitor so we can check them anytime. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 67 +++++++++++++++++++-------------------- 1 file changed, 32 insertions(+), 35 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index c97911039d..3f443a756b 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -3335,6 +3335,34 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, if (qemuMigrationSrcGraphicsRelocate(driver, vm, mig, graphicsuri) < 0) VIR_WARN("unable to provide data for graphics client relocation"); + if (qemuMigrationParamsSetCompression(vm, compression, migParams) < 0) + goto error; + + if (qemuMigrationParamsSetCapability(vm, + QEMU_MONITOR_MIGRATION_CAPS_AUTO_CONVERGE, + flags & VIR_MIGRATE_AUTO_CONVERGE, + migParams) < 0) + goto error; + + if (qemuMigrationParamsSetCapability(vm, + QEMU_MONITOR_MIGRATION_CAPS_RDMA_PIN_ALL, + flags & VIR_MIGRATE_RDMA_PIN_ALL, + migParams) < 0) + goto error; + + if (qemuMigrationParamsSetPostCopy(vm, flags & VIR_MIGRATE_POSTCOPY, + migParams) < 0) + goto error; + + if (qemuMigrationCapsGet(vm, QEMU_MONITOR_MIGRATION_CAPS_PAUSE_BEFORE_SWITCHOVER) && + qemuMigrationParamsSetCapability(vm, + QEMU_MONITOR_MIGRATION_CAPS_PAUSE_BEFORE_SWITCHOVER, + true, migParams) < 0) + goto error; + + if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) + goto error; + if (flags & VIR_MIGRATE_TLS) { const char *hostname = NULL; @@ -3354,6 +3382,10 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, goto error; } + if (qemuMigrationParamsApply(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT, + migParams) < 0) + goto error; + if (migrate_flags & (QEMU_MONITOR_MIGRATE_NON_SHARED_DISK | QEMU_MONITOR_MIGRATE_NON_SHARED_INC)) { if (mig->nbd) { @@ -3382,35 +3414,6 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, goto error; } - if (qemuMigrationParamsSetCompression(vm, compression, migParams) < 0) - goto error; - - if (qemuMigrationParamsSetCapability(vm, - QEMU_MONITOR_MIGRATION_CAPS_AUTO_CONVERGE, - flags & VIR_MIGRATE_AUTO_CONVERGE, - migParams) < 0) - goto error; - - if (qemuMigrationParamsSetCapability(vm, - QEMU_MONITOR_MIGRATION_CAPS_RDMA_PIN_ALL, - flags & VIR_MIGRATE_RDMA_PIN_ALL, - migParams) < 0) - goto error; - - if (qemuMigrationParamsSetPostCopy(vm, flags & VIR_MIGRATE_POSTCOPY, - migParams) < 0) - goto error; - - if (qemuMigrationCapsGet(vm, QEMU_MONITOR_MIGRATION_CAPS_PAUSE_BEFORE_SWITCHOVER) && - qemuMigrationParamsSetCapability(vm, - QEMU_MONITOR_MIGRATION_CAPS_PAUSE_BEFORE_SWITCHOVER, - true, migParams) < 0) - goto error; - - if (qemuMigrationParamsApply(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT, - migParams) < 0) - goto error; - if (qemuDomainObjEnterMonitorAsync(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) goto error; @@ -4508,9 +4511,6 @@ qemuMigrationSrcPerformJob(virQEMUDriverPtr driver, qemuMigrationSrcStoreDomainState(vm); - if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) - goto endjob; - if ((flags & (VIR_MIGRATE_TUNNELLED | VIR_MIGRATE_PEER2PEER))) { ret = qemuMigrationSrcPerformPeer2Peer(driver, conn, vm, xmlin, persist_xml, dconnuri, uri, graphicsuri, listenAddress, @@ -4616,9 +4616,6 @@ qemuMigrationSrcPerformPhase(virQEMUDriverPtr driver, virCloseCallbacksUnset(driver->closeCallbacks, vm, qemuMigrationSrcCleanup); - if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) - goto endjob; - ret = qemuMigrationSrcPerformNative(driver, vm, persist_xml, uri, cookiein, cookieinlen, cookieout, cookieoutlen, flags, resource, NULL, graphicsuri, -- 2.17.0

Instead of checking each capability at the time we want to set it in qemuMigrationParamsSetCapability we can check all of them at once in qemuMigrationParamsCheck. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 6 ++++-- src/qemu/qemu_migration_params.c | 33 ++++++++++++++++++-------------- src/qemu/qemu_migration_params.h | 3 ++- 3 files changed, 25 insertions(+), 17 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 3f443a756b..eb544bbb77 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2398,7 +2398,8 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, migParams) < 0) goto stopjob; - if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN) < 0) + if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN, + migParams) < 0) goto stopjob; /* Migrations using TLS need to add the "tls-creds-x509" object and @@ -3360,7 +3361,8 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, true, migParams) < 0) goto error; - if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) + if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT, + migParams) < 0) goto error; if (flags & VIR_MIGRATE_TLS) { diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index faaaa29cc9..a7b5ce385e 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -182,23 +182,11 @@ qemuMigrationParamsApply(virQEMUDriverPtr driver, int -qemuMigrationParamsSetCapability(virDomainObjPtr vm, +qemuMigrationParamsSetCapability(virDomainObjPtr vm ATTRIBUTE_UNUSED, qemuMonitorMigrationCaps capability, bool state, qemuMigrationParamsPtr migParams) { - if (!qemuMigrationCapsGet(vm, capability)) { - if (!state) { - /* Unsupported but we want it off anyway */ - return 0; - } - - virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, - _("Migration option '%s' is not supported by QEMU binary"), - qemuMonitorMigrationCapsTypeToString(capability)); - return -1; - } - if (state) ignore_value(virBitmapSetBit(migParams->caps, capability)); else @@ -413,16 +401,33 @@ qemuMigrationParamsResetTLS(virQEMUDriverPtr driver, * * Check supported migration parameters and keep their original values in * qemuDomainJobObj so that we can properly reset them at the end of migration. + * Reports an error if any of the currently used capabilities in @migParams + * are unsupported by QEMU. */ int qemuMigrationParamsCheck(virQEMUDriverPtr driver, virDomainObjPtr vm, - int asyncJob) + int asyncJob, + qemuMigrationParamsPtr migParams) { qemuDomainObjPrivatePtr priv = vm->privateData; qemuMigrationParamsPtr origParams = NULL; + qemuMonitorMigrationCaps cap; int ret = -1; + for (cap = 0; cap < QEMU_MONITOR_MIGRATION_CAPS_LAST; cap++) { + bool state = false; + + ignore_value(virBitmapGetBit(migParams->caps, cap, &state)); + + if (state && !qemuMigrationCapsGet(vm, cap)) { + virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, + _("Migration option '%s' is not supported by QEMU binary"), + qemuMonitorMigrationCapsTypeToString(cap)); + return -1; + } + } + if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) return -1; diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index 4cb70f62a4..7ca667a507 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -101,7 +101,8 @@ qemuMigrationParamsSetCompression(virDomainObjPtr vm, int qemuMigrationParamsCheck(virQEMUDriverPtr driver, virDomainObjPtr vm, - int asyncJob); + int asyncJob, + qemuMigrationParamsPtr migParams); void qemuMigrationParamsReset(virQEMUDriverPtr driver, -- 2.17.0

Some migration parameters and capabilities are supposed to be set on both sides of migration while others should only be set on one side. For example, CPU throttling parameters make no sense on the destination and they can be used even if the destination is too old to support them. To make qemuMigrationParamsFromFlags more general and usable on both sides of migration, we need to tell it what side it's been called on. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_driver.c | 3 ++- src/qemu/qemu_migration_params.c | 9 ++++++--- src/qemu/qemu_migration_params.h | 8 +++++++- 3 files changed, 15 insertions(+), 5 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 6e6fc130c5..d8a641f77d 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -12765,7 +12765,8 @@ qemuDomainMigratePerform3Params(virDomainPtr dom, if (nmigrate_disks < 0) goto cleanup; - if (!(migParams = qemuMigrationParamsFromFlags(params, nparams, flags))) + if (!(migParams = qemuMigrationParamsFromFlags(params, nparams, flags, + QEMU_MIGRATION_SOURCE))) goto cleanup; if (!(compression = qemuMigrationAnyCompressionParse(params, nparams, flags))) diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index a7b5ce385e..b55abc2e36 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -80,7 +80,8 @@ qemuMigrationParamsFree(qemuMigrationParamsPtr migParams) qemuMigrationParamsPtr qemuMigrationParamsFromFlags(virTypedParameterPtr params, int nparams, - unsigned long flags) + unsigned long flags, + qemuMigrationParty party) { qemuMigrationParamsPtr migParams; @@ -102,8 +103,10 @@ qemuMigrationParamsFromFlags(virTypedParameterPtr params, migParams->params.VAR ## _set = true; \ } while (0) - GET(AUTO_CONVERGE_INITIAL, cpuThrottleInitial); - GET(AUTO_CONVERGE_INCREMENT, cpuThrottleIncrement); + if (party == QEMU_MIGRATION_SOURCE) { + GET(AUTO_CONVERGE_INITIAL, cpuThrottleInitial); + GET(AUTO_CONVERGE_INCREMENT, cpuThrottleIncrement); + } #undef GET diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index 7ca667a507..d66fdb7cde 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -50,6 +50,11 @@ struct _qemuMigrationCompression { typedef struct _qemuMigrationParams qemuMigrationParams; typedef qemuMigrationParams *qemuMigrationParamsPtr; +typedef enum { + QEMU_MIGRATION_SOURCE = (1 << 0), + QEMU_MIGRATION_DESTINATION = (1 << 1), +} qemuMigrationParty; + qemuMigrationParamsPtr qemuMigrationParamsNew(void); @@ -57,7 +62,8 @@ qemuMigrationParamsNew(void); qemuMigrationParamsPtr qemuMigrationParamsFromFlags(virTypedParameterPtr params, int nparams, - unsigned long flags); + unsigned long flags, + qemuMigrationParty party); void qemuMigrationParamsFree(qemuMigrationParamsPtr migParams); -- 2.17.0

Every migration entry point in qemu_driver is supposed to call qemuMigrationParamsFromFlags to transform flags and parameters into qemuMigrationParams structure and pass the result to qemuMigration* APIs. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_driver.c | 64 +++++++++++++++++++++++++++++++-------- src/qemu/qemu_migration.c | 23 ++++++-------- src/qemu/qemu_migration.h | 2 ++ 3 files changed, 62 insertions(+), 27 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index d8a641f77d..5271e01d92 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -12126,6 +12126,7 @@ qemuDomainMigratePrepareTunnel(virConnectPtr dconn, virQEMUDriverPtr driver = dconn->privateData; virDomainDefPtr def = NULL; char *origname = NULL; + qemuMigrationParamsPtr migParams = NULL; int ret = -1; virCheckFlags(QEMU_MIGRATION_FLAGS, -1); @@ -12136,6 +12137,10 @@ qemuDomainMigratePrepareTunnel(virConnectPtr dconn, goto cleanup; } + if (!(migParams = qemuMigrationParamsFromFlags(NULL, 0, flags, + QEMU_MIGRATION_DESTINATION))) + goto cleanup; + if (virLockManagerPluginUsesState(driver->lockManager)) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Cannot use migrate v2 protocol with lock manager %s"), @@ -12151,9 +12156,10 @@ qemuDomainMigratePrepareTunnel(virConnectPtr dconn, ret = qemuMigrationDstPrepareTunnel(driver, dconn, NULL, 0, NULL, NULL, /* No cookies in v2 */ - st, &def, origname, flags); + st, &def, origname, migParams, flags); cleanup: + qemuMigrationParamsFree(migParams); VIR_FREE(origname); virDomainDefFree(def); return ret; @@ -12178,6 +12184,7 @@ qemuDomainMigratePrepare2(virConnectPtr dconn, virDomainDefPtr def = NULL; char *origname = NULL; qemuMigrationCompressionPtr compression = NULL; + qemuMigrationParamsPtr migParams = NULL; int ret = -1; virCheckFlags(QEMU_MIGRATION_FLAGS, -1); @@ -12195,6 +12202,10 @@ qemuDomainMigratePrepare2(virConnectPtr dconn, if (!(compression = qemuMigrationAnyCompressionParse(NULL, 0, flags))) goto cleanup; + if (!(migParams = qemuMigrationParamsFromFlags(NULL, 0, flags, + QEMU_MIGRATION_DESTINATION))) + goto cleanup; + if (virLockManagerPluginUsesState(driver->lockManager)) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Cannot use migrate v2 protocol with lock manager %s"), @@ -12216,9 +12227,10 @@ qemuDomainMigratePrepare2(virConnectPtr dconn, NULL, 0, NULL, NULL, /* No cookies */ uri_in, uri_out, &def, origname, NULL, 0, NULL, 0, - compression, flags); + compression, migParams, flags); cleanup: + qemuMigrationParamsFree(migParams); VIR_FREE(compression); VIR_FREE(origname); virDomainDefFree(def); @@ -12252,10 +12264,11 @@ qemuDomainMigratePerform(virDomainPtr dom, goto cleanup; } - if (!(migParams = qemuMigrationParamsNew())) + if (!(compression = qemuMigrationAnyCompressionParse(NULL, 0, flags))) goto cleanup; - if (!(compression = qemuMigrationAnyCompressionParse(NULL, 0, flags))) + if (!(migParams = qemuMigrationParamsFromFlags(NULL, 0, flags, + QEMU_MIGRATION_SOURCE))) goto cleanup; if (!(vm = qemuDomObjFromDomain(dom))) @@ -12430,6 +12443,7 @@ qemuDomainMigratePrepare3(virConnectPtr dconn, virDomainDefPtr def = NULL; char *origname = NULL; qemuMigrationCompressionPtr compression = NULL; + qemuMigrationParamsPtr migParams = NULL; int ret = -1; virCheckFlags(QEMU_MIGRATION_FLAGS, -1); @@ -12447,6 +12461,10 @@ qemuDomainMigratePrepare3(virConnectPtr dconn, if (!(compression = qemuMigrationAnyCompressionParse(NULL, 0, flags))) goto cleanup; + if (!(migParams = qemuMigrationParamsFromFlags(NULL, 0, flags, + QEMU_MIGRATION_DESTINATION))) + goto cleanup; + if (!(def = qemuMigrationAnyPrepareDef(driver, dom_xml, dname, &origname))) goto cleanup; @@ -12458,9 +12476,10 @@ qemuDomainMigratePrepare3(virConnectPtr dconn, cookieout, cookieoutlen, uri_in, uri_out, &def, origname, NULL, 0, NULL, 0, - compression, flags); + compression, migParams, flags); cleanup: + qemuMigrationParamsFree(migParams); VIR_FREE(compression); VIR_FREE(origname); virDomainDefFree(def); @@ -12490,6 +12509,7 @@ qemuDomainMigratePrepare3Params(virConnectPtr dconn, const char **migrate_disks = NULL; char *origname = NULL; qemuMigrationCompressionPtr compression = NULL; + qemuMigrationParamsPtr migParams = NULL; int ret = -1; virCheckFlagsGoto(QEMU_MIGRATION_FLAGS, cleanup); @@ -12523,6 +12543,10 @@ qemuDomainMigratePrepare3Params(virConnectPtr dconn, if (!(compression = qemuMigrationAnyCompressionParse(params, nparams, flags))) goto cleanup; + if (!(migParams = qemuMigrationParamsFromFlags(params, nparams, flags, + QEMU_MIGRATION_DESTINATION))) + goto cleanup; + if (flags & VIR_MIGRATE_TUNNELLED) { /* this is a logical error; we never should have gotten here with * VIR_MIGRATE_TUNNELLED set @@ -12545,9 +12569,10 @@ qemuDomainMigratePrepare3Params(virConnectPtr dconn, uri_in, uri_out, &def, origname, listenAddress, nmigrate_disks, migrate_disks, nbdPort, - compression, flags); + compression, migParams, flags); cleanup: + qemuMigrationParamsFree(migParams); VIR_FREE(compression); VIR_FREE(migrate_disks); VIR_FREE(origname); @@ -12572,6 +12597,7 @@ qemuDomainMigratePrepareTunnel3(virConnectPtr dconn, virQEMUDriverPtr driver = dconn->privateData; virDomainDefPtr def = NULL; char *origname = NULL; + qemuMigrationParamsPtr migParams = NULL; int ret = -1; virCheckFlags(QEMU_MIGRATION_FLAGS, -1); @@ -12582,6 +12608,10 @@ qemuDomainMigratePrepareTunnel3(virConnectPtr dconn, goto cleanup; } + if (!(migParams = qemuMigrationParamsFromFlags(NULL, 0, flags, + QEMU_MIGRATION_DESTINATION))) + goto cleanup; + if (!(def = qemuMigrationAnyPrepareDef(driver, dom_xml, dname, &origname))) goto cleanup; @@ -12591,9 +12621,10 @@ qemuDomainMigratePrepareTunnel3(virConnectPtr dconn, ret = qemuMigrationDstPrepareTunnel(driver, dconn, cookiein, cookieinlen, cookieout, cookieoutlen, - st, &def, origname, flags); + st, &def, origname, migParams, flags); cleanup: + qemuMigrationParamsFree(migParams); VIR_FREE(origname); virDomainDefFree(def); return ret; @@ -12615,6 +12646,7 @@ qemuDomainMigratePrepareTunnel3Params(virConnectPtr dconn, const char *dom_xml = NULL; const char *dname = NULL; char *origname = NULL; + qemuMigrationParamsPtr migParams = NULL; int ret = -1; virCheckFlags(QEMU_MIGRATION_FLAGS, -1); @@ -12635,6 +12667,10 @@ qemuDomainMigratePrepareTunnel3Params(virConnectPtr dconn, goto cleanup; } + if (!(migParams = qemuMigrationParamsFromFlags(params, nparams, flags, + QEMU_MIGRATION_DESTINATION))) + goto cleanup; + if (!(def = qemuMigrationAnyPrepareDef(driver, dom_xml, dname, &origname))) goto cleanup; @@ -12644,9 +12680,10 @@ qemuDomainMigratePrepareTunnel3Params(virConnectPtr dconn, ret = qemuMigrationDstPrepareTunnel(driver, dconn, cookiein, cookieinlen, cookieout, cookieoutlen, - st, &def, origname, flags); + st, &def, origname, migParams, flags); cleanup: + qemuMigrationParamsFree(migParams); VIR_FREE(origname); virDomainDefFree(def); return ret; @@ -12674,10 +12711,11 @@ qemuDomainMigratePerform3(virDomainPtr dom, virCheckFlags(QEMU_MIGRATION_FLAGS, -1); - if (!(migParams = qemuMigrationParamsNew())) + if (!(compression = qemuMigrationAnyCompressionParse(NULL, 0, flags))) goto cleanup; - if (!(compression = qemuMigrationAnyCompressionParse(NULL, 0, flags))) + if (!(migParams = qemuMigrationParamsFromFlags(NULL, 0, flags, + QEMU_MIGRATION_SOURCE))) goto cleanup; if (!(vm = qemuDomObjFromDomain(dom))) @@ -12765,11 +12803,11 @@ qemuDomainMigratePerform3Params(virDomainPtr dom, if (nmigrate_disks < 0) goto cleanup; - if (!(migParams = qemuMigrationParamsFromFlags(params, nparams, flags, - QEMU_MIGRATION_SOURCE))) + if (!(compression = qemuMigrationAnyCompressionParse(params, nparams, flags))) goto cleanup; - if (!(compression = qemuMigrationAnyCompressionParse(params, nparams, flags))) + if (!(migParams = qemuMigrationParamsFromFlags(params, nparams, flags, + QEMU_MIGRATION_SOURCE))) goto cleanup; if (!(vm = qemuDomObjFromDomain(dom))) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index eb544bbb77..5614f0d43e 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2164,6 +2164,7 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, const char **migrate_disks, int nbdPort, qemuMigrationCompressionPtr compression, + qemuMigrationParamsPtr migParams, unsigned long flags) { virDomainObjPtr vm = NULL; @@ -2184,7 +2185,6 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, int rv; char *tlsAlias = NULL; char *secAlias = NULL; - qemuMigrationParamsPtr migParams = NULL; virNWFilterReadLockFilterUpdates(); @@ -2234,9 +2234,6 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, if (!qemuMigrationSrcIsAllowedHostdev(*def)) goto cleanup; - if (!(migParams = qemuMigrationParamsNew())) - goto cleanup; - /* Let migration hook filter domain XML */ if (virHookPresent(VIR_HOOK_DRIVER_QEMU)) { char *xml; @@ -2503,7 +2500,6 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, virDomainObjRemoveTransientDef(vm); qemuDomainRemoveInactiveJob(driver, vm); } - qemuMigrationParamsFree(migParams); virDomainObjEndAPI(&vm); qemuDomainEventQueue(driver, event); qemuMigrationCookieFree(mig); @@ -2543,6 +2539,7 @@ qemuMigrationDstPrepareTunnel(virQEMUDriverPtr driver, virStreamPtr st, virDomainDefPtr *def, const char *origname, + qemuMigrationParamsPtr migParams, unsigned long flags) { qemuMigrationCompressionPtr compression = NULL; @@ -2566,7 +2563,7 @@ qemuMigrationDstPrepareTunnel(virQEMUDriverPtr driver, ret = qemuMigrationDstPrepareAny(driver, dconn, cookiein, cookieinlen, cookieout, cookieoutlen, def, origname, st, NULL, 0, false, NULL, 0, NULL, 0, - compression, flags); + compression, migParams, flags); VIR_FREE(compression); return ret; } @@ -2611,6 +2608,7 @@ qemuMigrationDstPrepareDirect(virQEMUDriverPtr driver, const char **migrate_disks, int nbdPort, qemuMigrationCompressionPtr compression, + qemuMigrationParamsPtr migParams, unsigned long flags) { unsigned short port = 0; @@ -2734,7 +2732,7 @@ qemuMigrationDstPrepareDirect(virQEMUDriverPtr driver, NULL, uri ? uri->scheme : "tcp", port, autoPort, listenAddress, nmigrate_disks, migrate_disks, nbdPort, - compression, flags); + compression, migParams, flags); cleanup: virURIFree(uri); VIR_FREE(hostname); @@ -3788,7 +3786,8 @@ qemuMigrationSrcPerformPeer2Peer2(virQEMUDriverPtr driver, const char *dconnuri, unsigned long flags, const char *dname, - unsigned long resource) + unsigned long resource, + qemuMigrationParamsPtr migParams) { virDomainPtr ddomain = NULL; char *uri_out = NULL; @@ -3800,7 +3799,6 @@ qemuMigrationSrcPerformPeer2Peer2(virQEMUDriverPtr driver, virStreamPtr st = NULL; unsigned long destflags; qemuMigrationCompressionPtr compression = NULL; - qemuMigrationParamsPtr migParams = NULL; VIR_DEBUG("driver=%p, sconn=%p, dconn=%p, vm=%p, dconnuri=%s, " "flags=0x%lx, dname=%s, resource=%lu", @@ -3822,9 +3820,6 @@ qemuMigrationSrcPerformPeer2Peer2(virQEMUDriverPtr driver, destflags = flags & ~(VIR_MIGRATE_ABORT_ON_ERROR | VIR_MIGRATE_AUTO_CONVERGE); - if (!(migParams = qemuMigrationParamsNew())) - goto cleanup; - if (!(compression = qemuMigrationAnyCompressionParse(NULL, 0, flags))) goto cleanup; @@ -3926,7 +3921,6 @@ qemuMigrationSrcPerformPeer2Peer2(virQEMUDriverPtr driver, virSetError(orig_err); virFreeError(orig_err); } - qemuMigrationParamsFree(migParams); VIR_FREE(uri_out); VIR_FREE(cookie); VIR_FREE(compression); @@ -4442,7 +4436,8 @@ qemuMigrationSrcPerformPeer2Peer(virQEMUDriverPtr driver, useParams, flags); } else { ret = qemuMigrationSrcPerformPeer2Peer2(driver, sconn, dconn, vm, - dconnuri, flags, dname, resource); + dconnuri, flags, dname, resource, + migParams); } cleanup: diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h index fc81eb5016..2bf710a919 100644 --- a/src/qemu/qemu_migration.h +++ b/src/qemu/qemu_migration.h @@ -148,6 +148,7 @@ qemuMigrationDstPrepareTunnel(virQEMUDriverPtr driver, virStreamPtr st, virDomainDefPtr *def, const char *origname, + qemuMigrationParamsPtr migParams, unsigned long flags); int @@ -166,6 +167,7 @@ qemuMigrationDstPrepareDirect(virQEMUDriverPtr driver, const char **migrate_disks, int nbdPort, qemuMigrationCompressionPtr compression, + qemuMigrationParamsPtr migParams, unsigned long flags); int -- 2.17.0

It is no longer used outside qemu_migration_params.c. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration_params.c | 2 +- src/qemu/qemu_migration_params.h | 3 --- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index b55abc2e36..a0a00d0fc7 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -44,7 +44,7 @@ struct _qemuMigrationParams { }; -qemuMigrationParamsPtr +static qemuMigrationParamsPtr qemuMigrationParamsNew(void) { qemuMigrationParamsPtr params; diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index d66fdb7cde..4350b14d6d 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -56,9 +56,6 @@ typedef enum { } qemuMigrationParty; -qemuMigrationParamsPtr -qemuMigrationParamsNew(void); - qemuMigrationParamsPtr qemuMigrationParamsFromFlags(virTypedParameterPtr params, int nparams, -- 2.17.0

It's just a tiny wrapper around qemuMigrationParamsSetCapability and setting priv->job.postcopyEnabled is not something qemuMigrationParams code should be doing anyway so let the callers do it. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 16 ++++++++++++---- src/qemu/qemu_migration_params.c | 17 ----------------- src/qemu/qemu_migration_params.h | 5 ----- 3 files changed, 12 insertions(+), 26 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 5614f0d43e..400eb0710c 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2391,8 +2391,10 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, migParams) < 0) goto stopjob; - if (qemuMigrationParamsSetPostCopy(vm, flags & VIR_MIGRATE_POSTCOPY, - migParams) < 0) + if (qemuMigrationParamsSetCapability(vm, + QEMU_MONITOR_MIGRATION_CAPS_POSTCOPY, + flags & VIR_MIGRATE_POSTCOPY, + migParams) < 0) goto stopjob; if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN, @@ -2416,6 +2418,8 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, migParams) < 0) goto stopjob; + priv->job.postcopyEnabled = flags & VIR_MIGRATE_POSTCOPY; + if (mig->nbd && flags & (VIR_MIGRATE_NON_SHARED_DISK | VIR_MIGRATE_NON_SHARED_INC) && virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NBD_SERVER)) { @@ -3349,8 +3353,10 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, migParams) < 0) goto error; - if (qemuMigrationParamsSetPostCopy(vm, flags & VIR_MIGRATE_POSTCOPY, - migParams) < 0) + if (qemuMigrationParamsSetCapability(vm, + QEMU_MONITOR_MIGRATION_CAPS_POSTCOPY, + flags & VIR_MIGRATE_POSTCOPY, + migParams) < 0) goto error; if (qemuMigrationCapsGet(vm, QEMU_MONITOR_MIGRATION_CAPS_PAUSE_BEFORE_SWITCHOVER) && @@ -3386,6 +3392,8 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, migParams) < 0) goto error; + priv->job.postcopyEnabled = flags & VIR_MIGRATE_POSTCOPY; + if (migrate_flags & (QEMU_MONITOR_MIGRATE_NON_SHARED_DISK | QEMU_MONITOR_MIGRATE_NON_SHARED_INC)) { if (mig->nbd) { diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index a0a00d0fc7..bf95fb4f59 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -199,23 +199,6 @@ qemuMigrationParamsSetCapability(virDomainObjPtr vm ATTRIBUTE_UNUSED, } -int -qemuMigrationParamsSetPostCopy(virDomainObjPtr vm, - bool state, - qemuMigrationParamsPtr migParams) -{ - qemuDomainObjPrivatePtr priv = vm->privateData; - - if (qemuMigrationParamsSetCapability(vm, - QEMU_MONITOR_MIGRATION_CAPS_POSTCOPY, - state, migParams) < 0) - return -1; - - priv->job.postcopyEnabled = state; - return 0; -} - - /* qemuMigrationParamsEnableTLS * @driver: pointer to qemu driver * @vm: domain object diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index 4350b14d6d..fac901e35c 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -77,11 +77,6 @@ qemuMigrationParamsSetCapability(virDomainObjPtr vm, bool state, qemuMigrationParamsPtr migParams); -int -qemuMigrationParamsSetPostCopy(virDomainObjPtr vm, - bool state, - qemuMigrationParamsPtr migParams); - int qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver, virDomainObjPtr vm, -- 2.17.0

Some migration capabilities are always enabled if QEMU supports them. We can just drop the explicit code for them and let qemuMigrationParamsCheck automatically set such capabilities. QEMU_MONITOR_MIGRATION_CAPS_EVENTS would normally be one of the always on features, but it is the only feature we want to enable even for other jobs which internally use migration (such as save and snapshot). Hence this capability is set very early after libvirtd connects to QEMU monitor. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 6 ------ src/qemu/qemu_migration_params.c | 31 +++++++++++++++++++++++++++++++ 2 files changed, 31 insertions(+), 6 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 400eb0710c..0446003f47 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -3359,12 +3359,6 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, migParams) < 0) goto error; - if (qemuMigrationCapsGet(vm, QEMU_MONITOR_MIGRATION_CAPS_PAUSE_BEFORE_SWITCHOVER) && - qemuMigrationParamsSetCapability(vm, - QEMU_MONITOR_MIGRATION_CAPS_PAUSE_BEFORE_SWITCHOVER, - true, migParams) < 0) - goto error; - if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT, migParams) < 0) goto error; diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index bf95fb4f59..03056eed09 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -43,6 +43,19 @@ struct _qemuMigrationParams { qemuMonitorMigrationParams params; }; +typedef struct _qemuMigrationParamsAlwaysOnItem qemuMigrationParamsAlwaysOnItem; +struct _qemuMigrationParamsAlwaysOnItem { + qemuMonitorMigrationCaps cap; + int party; /* bit-wise OR of qemuMigrationParty */ +}; + +/* Migration capabilities which should always be enabled as long as they + * are supported by QEMU. */ +static const qemuMigrationParamsAlwaysOnItem qemuMigrationParamsAlwaysOn[] = { + {QEMU_MONITOR_MIGRATION_CAPS_PAUSE_BEFORE_SWITCHOVER, + QEMU_MIGRATION_SOURCE}, +}; + static qemuMigrationParamsPtr qemuMigrationParamsNew(void) @@ -399,8 +412,15 @@ qemuMigrationParamsCheck(virQEMUDriverPtr driver, qemuDomainObjPrivatePtr priv = vm->privateData; qemuMigrationParamsPtr origParams = NULL; qemuMonitorMigrationCaps cap; + qemuMigrationParty party; + size_t i; int ret = -1; + if (asyncJob == QEMU_ASYNC_JOB_MIGRATION_OUT) + party = QEMU_MIGRATION_SOURCE; + else + party = QEMU_MIGRATION_DESTINATION; + for (cap = 0; cap < QEMU_MONITOR_MIGRATION_CAPS_LAST; cap++) { bool state = false; @@ -414,6 +434,17 @@ qemuMigrationParamsCheck(virQEMUDriverPtr driver, } } + for (i = 0; i < ARRAY_CARDINALITY(qemuMigrationParamsAlwaysOn); i++) { + cap = qemuMigrationParamsAlwaysOn[i].cap; + + if (qemuMigrationParamsAlwaysOn[i].party & party && + qemuMigrationCapsGet(vm, cap)) { + VIR_DEBUG("Enabling migration capability '%s'", + qemuMonitorMigrationCapsTypeToString(cap)); + ignore_value(virBitmapSetBit(migParams->caps, cap)); + } + } + if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) return -1; -- 2.17.0

Most migration capabilities are directly connected with virDomainMigrateFlags so qemuMigrationParamsFromFlags can automatically enable them. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration.c | 30 --------------------- src/qemu/qemu_migration_params.c | 45 +++++++++++++++++++++++++++----- src/qemu/qemu_migration_params.h | 6 ----- 3 files changed, 39 insertions(+), 42 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 0446003f47..e1a29d9569 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2385,18 +2385,6 @@ qemuMigrationDstPrepareAny(virQEMUDriverPtr driver, goto stopjob; } - if (qemuMigrationParamsSetCapability(vm, - QEMU_MONITOR_MIGRATION_CAPS_RDMA_PIN_ALL, - flags & VIR_MIGRATE_RDMA_PIN_ALL, - migParams) < 0) - goto stopjob; - - if (qemuMigrationParamsSetCapability(vm, - QEMU_MONITOR_MIGRATION_CAPS_POSTCOPY, - flags & VIR_MIGRATE_POSTCOPY, - migParams) < 0) - goto stopjob; - if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN, migParams) < 0) goto stopjob; @@ -3341,24 +3329,6 @@ qemuMigrationSrcRun(virQEMUDriverPtr driver, if (qemuMigrationParamsSetCompression(vm, compression, migParams) < 0) goto error; - if (qemuMigrationParamsSetCapability(vm, - QEMU_MONITOR_MIGRATION_CAPS_AUTO_CONVERGE, - flags & VIR_MIGRATE_AUTO_CONVERGE, - migParams) < 0) - goto error; - - if (qemuMigrationParamsSetCapability(vm, - QEMU_MONITOR_MIGRATION_CAPS_RDMA_PIN_ALL, - flags & VIR_MIGRATE_RDMA_PIN_ALL, - migParams) < 0) - goto error; - - if (qemuMigrationParamsSetCapability(vm, - QEMU_MONITOR_MIGRATION_CAPS_POSTCOPY, - flags & VIR_MIGRATE_POSTCOPY, - migParams) < 0) - goto error; - if (qemuMigrationParamsCheck(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT, migParams) < 0) goto error; diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 03056eed09..369e560990 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -49,6 +49,13 @@ struct _qemuMigrationParamsAlwaysOnItem { int party; /* bit-wise OR of qemuMigrationParty */ }; +typedef struct _qemuMigrationParamsFlagMapItem qemuMigrationParamsFlagMapItem; +struct _qemuMigrationParamsFlagMapItem { + virDomainMigrateFlags flag; + qemuMonitorMigrationCaps cap; + int party; /* bit-wise OR of qemuMigrationParty */ +}; + /* Migration capabilities which should always be enabled as long as they * are supported by QEMU. */ static const qemuMigrationParamsAlwaysOnItem qemuMigrationParamsAlwaysOn[] = { @@ -56,6 +63,21 @@ static const qemuMigrationParamsAlwaysOnItem qemuMigrationParamsAlwaysOn[] = { QEMU_MIGRATION_SOURCE}, }; +/* Translation from virDomainMigrateFlags to qemuMonitorMigrationCaps. */ +static const qemuMigrationParamsFlagMapItem qemuMigrationParamsFlagMap[] = { + {VIR_MIGRATE_RDMA_PIN_ALL, + QEMU_MONITOR_MIGRATION_CAPS_RDMA_PIN_ALL, + QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION}, + + {VIR_MIGRATE_AUTO_CONVERGE, + QEMU_MONITOR_MIGRATION_CAPS_AUTO_CONVERGE, + QEMU_MIGRATION_SOURCE}, + + {VIR_MIGRATE_POSTCOPY, + QEMU_MONITOR_MIGRATION_CAPS_POSTCOPY, + QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION}, +}; + static qemuMigrationParamsPtr qemuMigrationParamsNew(void) @@ -97,12 +119,21 @@ qemuMigrationParamsFromFlags(virTypedParameterPtr params, qemuMigrationParty party) { qemuMigrationParamsPtr migParams; + size_t i; if (!(migParams = qemuMigrationParamsNew())) return NULL; - if (!params) - return migParams; + for (i = 0; i < ARRAY_CARDINALITY(qemuMigrationParamsFlagMap); i++) { + qemuMonitorMigrationCaps cap = qemuMigrationParamsFlagMap[i].cap; + + if (qemuMigrationParamsFlagMap[i].party & party && + flags & qemuMigrationParamsFlagMap[i].flag) { + VIR_DEBUG("Enabling migration capability '%s'", + qemuMonitorMigrationCapsTypeToString(cap)); + ignore_value(virBitmapSetBit(migParams->caps, cap)); + } + } #define GET(PARAM, VAR) \ do { \ @@ -116,9 +147,11 @@ qemuMigrationParamsFromFlags(virTypedParameterPtr params, migParams->params.VAR ## _set = true; \ } while (0) - if (party == QEMU_MIGRATION_SOURCE) { - GET(AUTO_CONVERGE_INITIAL, cpuThrottleInitial); - GET(AUTO_CONVERGE_INCREMENT, cpuThrottleIncrement); + if (params) { + if (party == QEMU_MIGRATION_SOURCE) { + GET(AUTO_CONVERGE_INITIAL, cpuThrottleInitial); + GET(AUTO_CONVERGE_INCREMENT, cpuThrottleIncrement); + } } #undef GET @@ -197,7 +230,7 @@ qemuMigrationParamsApply(virQEMUDriverPtr driver, } -int +static int qemuMigrationParamsSetCapability(virDomainObjPtr vm ATTRIBUTE_UNUSED, qemuMonitorMigrationCaps capability, bool state, diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h index fac901e35c..494ac104ad 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -71,12 +71,6 @@ qemuMigrationParamsApply(virQEMUDriverPtr driver, int asyncJob, qemuMigrationParamsPtr migParams); -int -qemuMigrationParamsSetCapability(virDomainObjPtr vm, - qemuMonitorMigrationCaps capability, - bool state, - qemuMigrationParamsPtr migParams); - int qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver, virDomainObjPtr vm, -- 2.17.0

Propagate the calls up the stack to the point where qemuMigrationParamsFromFlags is called. The end goal achieved in the following few patches is to merge compression parameters into the general migration parameters code. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_driver.c | 21 ++++++++++++++++++--- src/qemu/qemu_migration.c | 25 +++++++------------------ src/qemu/qemu_migration.h | 1 + 3 files changed, 26 insertions(+), 21 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 5271e01d92..85755257aa 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -12126,6 +12126,7 @@ qemuDomainMigratePrepareTunnel(virConnectPtr dconn, virQEMUDriverPtr driver = dconn->privateData; virDomainDefPtr def = NULL; char *origname = NULL; + qemuMigrationCompressionPtr compression = NULL; qemuMigrationParamsPtr migParams = NULL; int ret = -1; @@ -12137,6 +12138,9 @@ qemuDomainMigratePrepareTunnel(virConnectPtr dconn, goto cleanup; } + if (!(compression = qemuMigrationAnyCompressionParse(NULL, 0, flags))) + goto cleanup; + if (!(migParams = qemuMigrationParamsFromFlags(NULL, 0, flags, QEMU_MIGRATION_DESTINATION))) goto cleanup; @@ -12156,9 +12160,10 @@ qemuDomainMigratePrepareTunnel(virConnectPtr dconn, ret = qemuMigrationDstPrepareTunnel(driver, dconn, NULL, 0, NULL, NULL, /* No cookies in v2 */ - st, &def, origname, migParams, flags); + st, &def, origname, compression, migParams, flags); cleanup: + VIR_FREE(compression); qemuMigrationParamsFree(migParams); VIR_FREE(origname); virDomainDefFree(def); @@ -12597,6 +12602,7 @@ qemuDomainMigratePrepareTunnel3(virConnectPtr dconn, virQEMUDriverPtr driver = dconn->privateData; virDomainDefPtr def = NULL; char *origname = NULL; + qemuMigrationCompressionPtr compression = NULL; qemuMigrationParamsPtr migParams = NULL; int ret = -1; @@ -12608,6 +12614,9 @@ qemuDomainMigratePrepareTunnel3(virConnectPtr dconn, goto cleanup; } + if (!(compression = qemuMigrationAnyCompressionParse(NULL, 0, flags))) + goto cleanup; + if (!(migParams = qemuMigrationParamsFromFlags(NULL, 0, flags, QEMU_MIGRATION_DESTINATION))) goto cleanup; @@ -12621,9 +12630,10 @@ qemuDomainMigratePrepareTunnel3(virConnectPtr dconn, ret = qemuMigrationDstPrepareTunnel(driver, dconn, cookiein, cookieinlen, cookieout, cookieoutlen, - st, &def, origname, migParams, flags); + st, &def, origname, compression, migParams, flags); cleanup: + VIR_FREE(compression); qemuMigrationParamsFree(migParams); VIR_FREE(origname); virDomainDefFree(def); @@ -12646,6 +12656,7 @@ qemuDomainMigratePrepareTunnel3Params(virConnectPtr dconn, const char *dom_xml = NULL; const char *dname = NULL; char *origname = NULL; + qemuMigrationCompressionPtr compression = NULL; qemuMigrationParamsPtr migParams = NULL; int ret = -1; @@ -12667,6 +12678,9 @@ qemuDomainMigratePrepareTunnel3Params(virConnectPtr dconn, goto cleanup; } + if (!(compression = qemuMigrationAnyCompressionParse(NULL, 0, flags))) + goto cleanup; + if (!(migParams = qemuMigrationParamsFromFlags(params, nparams, flags, QEMU_MIGRATION_DESTINATION))) goto cleanup; @@ -12680,9 +12694,10 @@ qemuDomainMigratePrepareTunnel3Params(virConnectPtr dconn, ret = qemuMigrationDstPrepareTunnel(driver, dconn, cookiein, cookieinlen, cookieout, cookieoutlen, - st, &def, origname, migParams, flags); + st, &def, origname, compression, migParams, flags); cleanup: + VIR_FREE(compression); qemuMigrationParamsFree(migParams); VIR_FREE(origname); virDomainDefFree(def); diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index e1a29d9569..d4c5994f25 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2531,12 +2531,10 @@ qemuMigrationDstPrepareTunnel(virQEMUDriverPtr driver, virStreamPtr st, virDomainDefPtr *def, const char *origname, + qemuMigrationCompressionPtr compression, qemuMigrationParamsPtr migParams, unsigned long flags) { - qemuMigrationCompressionPtr compression = NULL; - int ret; - VIR_DEBUG("driver=%p, dconn=%p, cookiein=%s, cookieinlen=%d, " "cookieout=%p, cookieoutlen=%p, st=%p, def=%p, " "origname=%s, flags=0x%lx", @@ -2549,15 +2547,10 @@ qemuMigrationDstPrepareTunnel(virQEMUDriverPtr driver, return -1; } - if (!(compression = qemuMigrationAnyCompressionParse(NULL, 0, flags))) - return -1; - - ret = qemuMigrationDstPrepareAny(driver, dconn, cookiein, cookieinlen, - cookieout, cookieoutlen, def, origname, - st, NULL, 0, false, NULL, 0, NULL, 0, - compression, migParams, flags); - VIR_FREE(compression); - return ret; + return qemuMigrationDstPrepareAny(driver, dconn, cookiein, cookieinlen, + cookieout, cookieoutlen, def, origname, + st, NULL, 0, false, NULL, 0, NULL, 0, + compression, migParams, flags); } @@ -3759,6 +3752,7 @@ qemuMigrationSrcPerformPeer2Peer2(virQEMUDriverPtr driver, unsigned long flags, const char *dname, unsigned long resource, + qemuMigrationCompressionPtr compression, qemuMigrationParamsPtr migParams) { virDomainPtr ddomain = NULL; @@ -3770,7 +3764,6 @@ qemuMigrationSrcPerformPeer2Peer2(virQEMUDriverPtr driver, bool cancelled; virStreamPtr st = NULL; unsigned long destflags; - qemuMigrationCompressionPtr compression = NULL; VIR_DEBUG("driver=%p, sconn=%p, dconn=%p, vm=%p, dconnuri=%s, " "flags=0x%lx, dname=%s, resource=%lu", @@ -3792,9 +3785,6 @@ qemuMigrationSrcPerformPeer2Peer2(virQEMUDriverPtr driver, destflags = flags & ~(VIR_MIGRATE_ABORT_ON_ERROR | VIR_MIGRATE_AUTO_CONVERGE); - if (!(compression = qemuMigrationAnyCompressionParse(NULL, 0, flags))) - goto cleanup; - VIR_DEBUG("Prepare2 %p", dconn); if (flags & VIR_MIGRATE_TUNNELLED) { /* @@ -3895,7 +3885,6 @@ qemuMigrationSrcPerformPeer2Peer2(virQEMUDriverPtr driver, } VIR_FREE(uri_out); VIR_FREE(cookie); - VIR_FREE(compression); return ret; } @@ -4409,7 +4398,7 @@ qemuMigrationSrcPerformPeer2Peer(virQEMUDriverPtr driver, } else { ret = qemuMigrationSrcPerformPeer2Peer2(driver, sconn, dconn, vm, dconnuri, flags, dname, resource, - migParams); + compression, migParams); } cleanup: diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h index 2bf710a919..3cd456568a 100644 --- a/src/qemu/qemu_migration.h +++ b/src/qemu/qemu_migration.h @@ -148,6 +148,7 @@ qemuMigrationDstPrepareTunnel(virQEMUDriverPtr driver, virStreamPtr st, virDomainDefPtr *def, const char *origname, + qemuMigrationCompressionPtr compression, qemuMigrationParamsPtr migParams, unsigned long flags); -- 2.17.0

So far it's used only for CPU throttling parameters which are all ints, but we'll soon want to use it for more parameters with different types. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com&gt; --- src/qemu/qemu_migration_params.c | 31 +++++++++++++++---------------- 1 file changed, 15 insertions(+), 16 deletions(-) diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 369e560990..e0cbdb1a38 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -112,6 +112,17 @@ qemuMigrationParamsFree(qemuMigrationParamsPtr migParams) } +#define GET(API, PARAM, VAR) \ + do { \ + int rc; \ + if ((rc = API(params, nparams, VIR_MIGRATE_PARAM_ ## PARAM, \ + &migParams->params.VAR)) < 0) \ + goto error; \ + \ + if (rc == 1) \ + migParams->params.VAR ## _set = true; \ + } while (0) + qemuMigrationParamsPtr qemuMigrationParamsFromFlags(virTypedParameterPtr params, int nparams, @@ -135,27 +146,13 @@ qemuMigrationParamsFromFlags(virTypedParameterPtr params, } } -#define GET(PARAM, VAR) \ - do { \ - int rc; \ - if ((rc = virTypedParamsGetInt(params, nparams, \ - VIR_MIGRATE_PARAM_ ## PARAM, \ - &migParams->params.VAR)) < 0) \ - goto error; \ - \ - if (rc == 1) \ - migParams->params.VAR ## _set = true; \ - } while (0) - if (params) { if (party == QEMU_MIGRATION_SOURCE) { - GET(AUTO_CONVERGE_INITIAL, cpuThrottleInitial); - GET(AUTO_CONVERGE_INCREMENT, cpuThrottleIncrement); + GET(virTypedParamsGetInt, AUTO_CONVERGE_INITIAL, cpuThrottleInitial); + GET(virTypedParamsGetInt, AUTO_CONVERGE_INCREMENT, cpuThrottleIncrement); } } -#undef GET - if ((migParams->params.cpuThrottleInitial_set || migParams->params.cpuThrottleIncrement_set) && !(flags & VIR_MIGRATE_AUTO_CONVERGE)) { @@ -171,6 +168,8 @@ qemuMigrationParamsFromFlags(virTypedParameterPtr params, return NULL; } +#undef GET + /** * qemuMigrationParamsApply -- 2.17.0

On Fri, Apr 13, 2018 at 16:22:00 +0200, Ján Tomko wrote: The macro will go away completely later in this series anyway. Jirka