NuKVM/libvirt
3
0
Fork 0
mirror of https://github.com/libvirt/libvirt.git synced 2025-02-25 18:55:26 -06:00
Code Issues Packages Projects Releases Wiki Activity

qemu: Refactor qemuMigrationParams

Browse Source 
Adding support for new migration parameter requires a lot of places to
be changed (most likely by copy&paste engineering): new variables to
store the parameter value and the associated *_set bool, JSON formatter
and parser, XML formatter and parser (to be added soon), and the actual
code to set the parameter. It's pretty easy to forget about some of the
places which need to be updated and end up with incorrect support. The
goal of this patch is to let most of the places do their job without any
modifications when new parameters are added.

To achieve the goal, a new qemuMigrationParam enum is introduced and all
parameters are stored in an array indexed by the items of this enum.
This will also allow us to automatically set the migration parameters
which directly correspond to libvirt's typed parameters accepted by
virDomainMigrate* APIs.

Signed-off-by: Jiri Denemark <jdenemar@redhat.com>
Reviewed-by: Ján Tomko <jtomko@redhat.com>
This commit is contained in:
Jiri Denemark 2018-03-28 18:25:58 +02:00
parent b57c98509b
commit d384a88b30
2 changed files with 328 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

470
src/qemu/qemu_migration_params.c
View File

@ -39,46 +39,29 @@ VIR_LOG_INIT("qemu.qemu_migration_params");
#define QEMU_MIGRATION_TLS_ALIAS_BASE "libvirt_migrate" #define QEMU_MIGRATION_TLS_ALIAS_BASE "libvirt_migrate"
typedef struct _qemuMonitorMigrationParams qemuMonitorMigrationParams; typedef enum {
typedef qemuMonitorMigrationParams *qemuMonitorMigrationParamsPtr; QEMU_MIGRATION_PARAM_TYPE_INT,
struct _qemuMonitorMigrationParams { QEMU_MIGRATION_PARAM_TYPE_ULL,
bool compressLevel_set; QEMU_MIGRATION_PARAM_TYPE_BOOL,
int compressLevel; QEMU_MIGRATION_PARAM_TYPE_STRING,
} qemuMigrationParamType;
bool compressThreads_set; typedef struct _qemuMigrationParamValue qemuMigrationParamValue;
int compressThreads; typedef qemuMigrationParamValue *qemuMigrationParamValuePtr;
struct _qemuMigrationParamValue {
bool decompressThreads_set; bool set;
int decompressThreads; union {
int i; /* exempt from syntax-check */
bool cpuThrottleInitial_set; unsigned long long ull;
int cpuThrottleInitial; bool b;
char *s;
bool cpuThrottleIncrement_set; } value;
int cpuThrottleIncrement;
/* Value is either NULL, "", or some string. NULL indicates no support;
* whereas, some string value indicates we can support setting/clearing */
char *tlsCreds;
char *tlsHostname;
bool maxBandwidth_set;
unsigned long long maxBandwidth;
bool downtimeLimit_set;
unsigned long long downtimeLimit;
bool blockIncremental_set;
bool blockIncremental;
bool xbzrleCacheSize_set;
unsigned long long xbzrleCacheSize;
}; };
struct _qemuMigrationParams { struct _qemuMigrationParams {
unsigned long long compMethods; /* bit-wise OR of qemuMigrationCompressMethod */ unsigned long long compMethods; /* bit-wise OR of qemuMigrationCompressMethod */
virBitmapPtr caps; virBitmapPtr caps;
qemuMonitorMigrationParams params; qemuMigrationParamValue params[QEMU_MIGRATION_PARAM_LAST];
}; };
typedef enum { typedef enum {
@ -93,6 +76,20 @@ VIR_ENUM_IMPL(qemuMigrationCompressMethod, QEMU_MIGRATION_COMPRESS_LAST,
"mt", "mt",
); );
VIR_ENUM_DECL(qemuMigrationParam)
VIR_ENUM_IMPL(qemuMigrationParam, QEMU_MIGRATION_PARAM_LAST,
"compress-level",
"compress-threads",
"decompress-threads",
"cpu-throttle-initial",
"cpu-throttle-increment",
"tls-creds",
"tls-hostname",
"max-bandwidth",
"downtime-limit",
"block-incremental",
"xbzrle-cache-size",
);
typedef struct _qemuMigrationParamsAlwaysOnItem qemuMigrationParamsAlwaysOnItem; typedef struct _qemuMigrationParamsAlwaysOnItem qemuMigrationParamsAlwaysOnItem;
struct _qemuMigrationParamsAlwaysOnItem { struct _qemuMigrationParamsAlwaysOnItem {
@ -129,6 +126,21 @@ static const qemuMigrationParamsFlagMapItem qemuMigrationParamsFlagMap[] = {
QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION}, QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION},
}; };
static const qemuMigrationParamType qemuMigrationParamTypes[] = {
[QEMU_MIGRATION_PARAM_COMPRESS_LEVEL] = QEMU_MIGRATION_PARAM_TYPE_INT,
[QEMU_MIGRATION_PARAM_COMPRESS_THREADS] = QEMU_MIGRATION_PARAM_TYPE_INT,
[QEMU_MIGRATION_PARAM_DECOMPRESS_THREADS] = QEMU_MIGRATION_PARAM_TYPE_INT,
[QEMU_MIGRATION_PARAM_THROTTLE_INITIAL] = QEMU_MIGRATION_PARAM_TYPE_INT,
[QEMU_MIGRATION_PARAM_THROTTLE_INCREMENT] = QEMU_MIGRATION_PARAM_TYPE_INT,
[QEMU_MIGRATION_PARAM_TLS_CREDS] = QEMU_MIGRATION_PARAM_TYPE_STRING,
[QEMU_MIGRATION_PARAM_TLS_HOSTNAME] = QEMU_MIGRATION_PARAM_TYPE_STRING,
[QEMU_MIGRATION_PARAM_MAX_BANDWIDTH] = QEMU_MIGRATION_PARAM_TYPE_ULL,
[QEMU_MIGRATION_PARAM_DOWNTIME_LIMIT] = QEMU_MIGRATION_PARAM_TYPE_ULL,
[QEMU_MIGRATION_PARAM_BLOCK_INCREMENTAL] = QEMU_MIGRATION_PARAM_TYPE_BOOL,
[QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE] = QEMU_MIGRATION_PARAM_TYPE_ULL,
};
verify(ARRAY_CARDINALITY(qemuMigrationParamTypes) == QEMU_MIGRATION_PARAM_LAST);
static qemuMigrationParamsPtr static qemuMigrationParamsPtr
qemuMigrationParamsNew(void) qemuMigrationParamsNew(void)
@ -153,26 +165,120 @@ qemuMigrationParamsNew(void)
void void
qemuMigrationParamsFree(qemuMigrationParamsPtr migParams) qemuMigrationParamsFree(qemuMigrationParamsPtr migParams)
{ {
size_t i;
if (!migParams) if (!migParams)
return; return;
for (i = 0; i < QEMU_MIGRATION_PARAM_LAST; i++) {
if (qemuMigrationParamTypes[i] == QEMU_MIGRATION_PARAM_TYPE_STRING)
VIR_FREE(migParams->params[i].value.s);
}
virBitmapFree(migParams->caps); virBitmapFree(migParams->caps);
VIR_FREE(migParams->params.tlsCreds);
VIR_FREE(migParams->params.tlsHostname);
VIR_FREE(migParams); VIR_FREE(migParams);
} }
#define GET(API, PARAM, VAR) \ static int
do { \ qemuMigrationParamsCheckType(qemuMigrationParam param,
int rc; \ qemuMigrationParamType type)
if ((rc = API(params, nparams, VIR_MIGRATE_PARAM_ ## PARAM, \ {
&migParams->params.VAR)) < 0) \ if (qemuMigrationParamTypes[param] != type) {
goto error; \ virReportError(VIR_ERR_INTERNAL_ERROR,
\ _("Type mismatch for '%s' migration parameter"),
if (rc == 1) \ qemuMigrationParamTypeToString(param));
migParams->params.VAR ## _set = true; \ return -1;
} while (0) }
return 0;
}
static int
qemuMigrationParamsGetTPInt(qemuMigrationParamsPtr migParams,
qemuMigrationParam param,
virTypedParameterPtr params,
int nparams,
const char *name)
{
int rc;
if (qemuMigrationParamsCheckType(param, QEMU_MIGRATION_PARAM_TYPE_INT) < 0)
return -1;
if (!params)
return 0;
if ((rc = virTypedParamsGetInt(params, nparams, name,
&migParams->params[param].value.i)) < 0)
return -1;
migParams->params[param].set = !!rc;
return 0;
}
static int
qemuMigrationParamsSetTPInt(qemuMigrationParamsPtr migParams,
qemuMigrationParam param,
virTypedParameterPtr *params,
int *nparams,
int *maxparams,
const char *name)
{
if (qemuMigrationParamsCheckType(param, QEMU_MIGRATION_PARAM_TYPE_INT) < 0)
return -1;
if (!migParams->params[param].set)
return 0;
return virTypedParamsAddInt(params, nparams, maxparams, name,
migParams->params[param].value.i);
}
static int
qemuMigrationParamsGetTPULL(qemuMigrationParamsPtr migParams,
qemuMigrationParam param,
virTypedParameterPtr params,
int nparams,
const char *name)
{
int rc;
if (qemuMigrationParamsCheckType(param, QEMU_MIGRATION_PARAM_TYPE_ULL) < 0)
return -1;
if (!params)
return 0;
if ((rc = virTypedParamsGetULLong(params, nparams, name,
&migParams->params[param].value.ull)) < 0)
return -1;
migParams->params[param].set = !!rc;
return 0;
}
static int
qemuMigrationParamsSetTPULL(qemuMigrationParamsPtr migParams,
qemuMigrationParam param,
virTypedParameterPtr *params,
int *nparams,
int *maxparams,
const char *name)
{
if (qemuMigrationParamsCheckType(param, QEMU_MIGRATION_PARAM_TYPE_ULL) < 0)
return -1;
if (!migParams->params[param].set)
return 0;
return virTypedParamsAddULLong(params, nparams, maxparams, name,
migParams->params[param].value.ull);
}
static int static int
@ -222,23 +328,40 @@ qemuMigrationParamsSetCompression(virTypedParameterPtr params,
ignore_value(virBitmapSetBit(migParams->caps, cap)); ignore_value(virBitmapSetBit(migParams->caps, cap));
} }
if (params) { if (qemuMigrationParamsGetTPInt(migParams,
GET(virTypedParamsGetInt, COMPRESSION_MT_LEVEL, compressLevel); QEMU_MIGRATION_PARAM_COMPRESS_LEVEL,
GET(virTypedParamsGetInt, COMPRESSION_MT_THREADS, compressThreads); params, nparams,
GET(virTypedParamsGetInt, COMPRESSION_MT_DTHREADS, decompressThreads); VIR_MIGRATE_PARAM_COMPRESSION_MT_LEVEL) < 0)
GET(virTypedParamsGetULLong, COMPRESSION_XBZRLE_CACHE, xbzrleCacheSize); goto error;
}
if ((migParams->params.compressLevel_set || if (qemuMigrationParamsGetTPInt(migParams,
migParams->params.compressThreads_set || QEMU_MIGRATION_PARAM_COMPRESS_THREADS,
migParams->params.decompressThreads_set) && params, nparams,
VIR_MIGRATE_PARAM_COMPRESSION_MT_THREADS) < 0)
goto error;
if (qemuMigrationParamsGetTPInt(migParams,
QEMU_MIGRATION_PARAM_DECOMPRESS_THREADS,
params, nparams,
VIR_MIGRATE_PARAM_COMPRESSION_MT_DTHREADS) < 0)
goto error;
if (qemuMigrationParamsGetTPULL(migParams,
QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE,
params, nparams,
VIR_MIGRATE_PARAM_COMPRESSION_XBZRLE_CACHE) < 0)
goto error;
if ((migParams->params[QEMU_MIGRATION_PARAM_COMPRESS_LEVEL].set ||
migParams->params[QEMU_MIGRATION_PARAM_COMPRESS_THREADS].set ||
migParams->params[QEMU_MIGRATION_PARAM_DECOMPRESS_THREADS].set) &&
!(migParams->compMethods & (1ULL << QEMU_MIGRATION_COMPRESS_MT))) { !(migParams->compMethods & (1ULL << QEMU_MIGRATION_COMPRESS_MT))) {
virReportError(VIR_ERR_INVALID_ARG, "%s", virReportError(VIR_ERR_INVALID_ARG, "%s",
_("Turn multithread compression on to tune it")); _("Turn multithread compression on to tune it"));
goto error; goto error;
} }
if (migParams->params.xbzrleCacheSize_set && if (migParams->params[QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE].set &&
!(migParams->compMethods & (1ULL << QEMU_MIGRATION_COMPRESS_XBZRLE))) { !(migParams->compMethods & (1ULL << QEMU_MIGRATION_COMPRESS_XBZRLE))) {
virReportError(VIR_ERR_INVALID_ARG, "%s", virReportError(VIR_ERR_INVALID_ARG, "%s",
_("Turn xbzrle compression on to tune it")); _("Turn xbzrle compression on to tune it"));
@ -281,15 +404,22 @@ qemuMigrationParamsFromFlags(virTypedParameterPtr params,
} }
} }
if (params) { if (party == QEMU_MIGRATION_SOURCE) {
if (party == QEMU_MIGRATION_SOURCE) { if (qemuMigrationParamsGetTPInt(migParams,
GET(virTypedParamsGetInt, AUTO_CONVERGE_INITIAL, cpuThrottleInitial); QEMU_MIGRATION_PARAM_THROTTLE_INITIAL,
GET(virTypedParamsGetInt, AUTO_CONVERGE_INCREMENT, cpuThrottleIncrement); params, nparams,
} VIR_MIGRATE_PARAM_AUTO_CONVERGE_INITIAL) < 0)
goto error;
if (qemuMigrationParamsGetTPInt(migParams,
QEMU_MIGRATION_PARAM_THROTTLE_INCREMENT,
params, nparams,
VIR_MIGRATE_PARAM_AUTO_CONVERGE_INCREMENT) < 0)
goto error;
} }
if ((migParams->params.cpuThrottleInitial_set || if ((migParams->params[QEMU_MIGRATION_PARAM_THROTTLE_INITIAL].set ||
migParams->params.cpuThrottleIncrement_set) && migParams->params[QEMU_MIGRATION_PARAM_THROTTLE_INCREMENT].set) &&
!(flags & VIR_MIGRATE_AUTO_CONVERGE)) { !(flags & VIR_MIGRATE_AUTO_CONVERGE)) {
virReportError(VIR_ERR_INVALID_ARG, "%s", virReportError(VIR_ERR_INVALID_ARG, "%s",
_("Turn auto convergence on to tune it")); _("Turn auto convergence on to tune it"));
@ -306,8 +436,6 @@ qemuMigrationParamsFromFlags(virTypedParameterPtr params,
return NULL; return NULL;
} }
#undef GET
int int
qemuMigrationParamsDump(qemuMigrationParamsPtr migParams, qemuMigrationParamsDump(qemuMigrationParamsPtr migParams,
@ -319,7 +447,7 @@ qemuMigrationParamsDump(qemuMigrationParamsPtr migParams,
size_t i; size_t i;
if (migParams->compMethods == 1ULL << QEMU_MIGRATION_COMPRESS_XBZRLE && if (migParams->compMethods == 1ULL << QEMU_MIGRATION_COMPRESS_XBZRLE &&
!migParams->params.xbzrleCacheSize_set) { !migParams->params[QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE].set) {
*flags |= VIR_MIGRATE_COMPRESSED; *flags |= VIR_MIGRATE_COMPRESSED;
return 0; return 0;
} }
@ -332,20 +460,29 @@ qemuMigrationParamsDump(qemuMigrationParamsPtr migParams,
return -1; return -1;
} }
#define SET(API, PARAM, VAR) \ if (qemuMigrationParamsSetTPInt(migParams,
do { \ QEMU_MIGRATION_PARAM_COMPRESS_LEVEL,
if (migParams->params.VAR ## _set && \ params, nparams, maxparams,
API(params, nparams, maxparams, VIR_MIGRATE_PARAM_ ## PARAM, \ VIR_MIGRATE_PARAM_COMPRESSION_MT_LEVEL) < 0)
migParams->params.VAR) < 0) \ return -1;
return -1; \
} while (0)
SET(virTypedParamsAddInt, COMPRESSION_MT_LEVEL, compressLevel); if (qemuMigrationParamsSetTPInt(migParams,
SET(virTypedParamsAddInt, COMPRESSION_MT_THREADS, compressThreads); QEMU_MIGRATION_PARAM_COMPRESS_THREADS,
SET(virTypedParamsAddInt, COMPRESSION_MT_DTHREADS, decompressThreads); params, nparams, maxparams,
SET(virTypedParamsAddULLong, COMPRESSION_XBZRLE_CACHE, xbzrleCacheSize); VIR_MIGRATE_PARAM_COMPRESSION_MT_THREADS) < 0)
return -1;
#undef SET if (qemuMigrationParamsSetTPInt(migParams,
QEMU_MIGRATION_PARAM_DECOMPRESS_THREADS,
params, nparams, maxparams,
VIR_MIGRATE_PARAM_COMPRESSION_MT_DTHREADS) < 0)
return -1;
if (qemuMigrationParamsSetTPULL(migParams,
QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE,
params, nparams, maxparams,
VIR_MIGRATE_PARAM_COMPRESSION_XBZRLE_CACHE) < 0)
return -1;
return 0; return 0;
} }
@ -354,7 +491,11 @@ qemuMigrationParamsDump(qemuMigrationParamsPtr migParams,
qemuMigrationParamsPtr qemuMigrationParamsPtr
qemuMigrationParamsFromJSON(virJSONValuePtr params) qemuMigrationParamsFromJSON(virJSONValuePtr params)
{ {
qemuMigrationParamsPtr migParams = NULL; qemuMigrationParamsPtr migParams;
qemuMigrationParamValuePtr pv;
const char *name;
const char *str;
size_t i;
if (!(migParams = qemuMigrationParamsNew())) if (!(migParams = qemuMigrationParamsNew()))
return NULL; return NULL;
@ -362,47 +503,35 @@ qemuMigrationParamsFromJSON(virJSONValuePtr params)
if (!params) if (!params)
return migParams; return migParams;
#define PARSE_SET(API, VAR, FIELD) \ for (i = 0; i < QEMU_MIGRATION_PARAM_LAST; i++) {
do { \ name = qemuMigrationParamTypeToString(i);
if (API(params, FIELD, &migParams->params.VAR) == 0) \ pv = &migParams->params[i];
migParams->params.VAR ## _set = true; \
} while (0)
#define PARSE_INT(VAR, FIELD) \ switch (qemuMigrationParamTypes[i]) {
PARSE_SET(virJSONValueObjectGetNumberInt, VAR, FIELD) case QEMU_MIGRATION_PARAM_TYPE_INT:
if (virJSONValueObjectGetNumberInt(params, name, &pv->value.i) == 0)
pv->set = true;
break;
#define PARSE_ULONG(VAR, FIELD) \ case QEMU_MIGRATION_PARAM_TYPE_ULL:
PARSE_SET(virJSONValueObjectGetNumberUlong, VAR, FIELD) if (virJSONValueObjectGetNumberUlong(params, name, &pv->value.ull) == 0)
pv->set = true;
break;
#define PARSE_BOOL(VAR, FIELD) \ case QEMU_MIGRATION_PARAM_TYPE_BOOL:
PARSE_SET(virJSONValueObjectGetBoolean, VAR, FIELD) if (virJSONValueObjectGetBoolean(params, name, &pv->value.b) == 0)
pv->set = true;
break;
#define PARSE_STR(VAR, FIELD) \ case QEMU_MIGRATION_PARAM_TYPE_STRING:
do { \ if ((str = virJSONValueObjectGetString(params, name))) {
const char *str; \ if (VIR_STRDUP(pv->value.s, str) < 0)
if ((str = virJSONValueObjectGetString(params, FIELD))) { \ goto error;
if (VIR_STRDUP(migParams->params.VAR, str) < 0) \ pv->set = true;
goto error; \ }
} \ break;
} while (0) }
}
PARSE_INT(compressLevel, "compress-level");
PARSE_INT(compressThreads, "compress-threads");
PARSE_INT(decompressThreads, "decompress-threads");
PARSE_INT(cpuThrottleInitial, "cpu-throttle-initial");
PARSE_INT(cpuThrottleIncrement, "cpu-throttle-increment");
PARSE_STR(tlsCreds, "tls-creds");
PARSE_STR(tlsHostname, "tls-hostname");
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
#undef PARSE_ULONG
#undef PARSE_BOOL
#undef PARSE_STR
return migParams; return migParams;
@ -416,48 +545,43 @@ virJSONValuePtr
qemuMigrationParamsToJSON(qemuMigrationParamsPtr migParams) qemuMigrationParamsToJSON(qemuMigrationParamsPtr migParams)
{ {
virJSONValuePtr params = NULL; virJSONValuePtr params = NULL;
qemuMigrationParamValuePtr pv;
const char *name;
size_t i;
int rc;
if (!(params = virJSONValueNewObject())) if (!(params = virJSONValueNewObject()))
return NULL; return NULL;
#define APPEND(VALID, API, VAR, FIELD) \ for (i = 0; i < QEMU_MIGRATION_PARAM_LAST; i++) {
do { \ name = qemuMigrationParamTypeToString(i);
if (VALID && API(params, FIELD, migParams->params.VAR) < 0) \ pv = &migParams->params[i];
goto error; \
} while (0)
#define APPEND_INT(VAR, FIELD) \ if (!pv->set)
APPEND(migParams->params.VAR ## _set, \ continue;
virJSONValueObjectAppendNumberInt, VAR, FIELD)
#define APPEND_STR(VAR, FIELD) \ rc = 0;
APPEND(migParams->params.VAR, \ switch (qemuMigrationParamTypes[i]) {
virJSONValueObjectAppendString, VAR, FIELD) case QEMU_MIGRATION_PARAM_TYPE_INT:
rc = virJSONValueObjectAppendNumberInt(params, name, pv->value.i);
break;
#define APPEND_ULONG(VAR, FIELD) \ case QEMU_MIGRATION_PARAM_TYPE_ULL:
APPEND(migParams->params.VAR ## _set, \ rc = virJSONValueObjectAppendNumberUlong(params, name, pv->value.ull);
virJSONValueObjectAppendNumberUlong, VAR, FIELD) break;
#define APPEND_BOOL(VAR, FIELD) \ case QEMU_MIGRATION_PARAM_TYPE_BOOL:
APPEND(migParams->params.VAR ## _set, \ rc = virJSONValueObjectAppendBoolean(params, name, pv->value.b);
virJSONValueObjectAppendBoolean, VAR, FIELD) break;
APPEND_INT(compressLevel, "compress-level"); case QEMU_MIGRATION_PARAM_TYPE_STRING:
APPEND_INT(compressThreads, "compress-threads"); rc = virJSONValueObjectAppendString(params, name, pv->value.s);
APPEND_INT(decompressThreads, "decompress-threads"); break;
APPEND_INT(cpuThrottleInitial, "cpu-throttle-initial"); }
APPEND_INT(cpuThrottleIncrement, "cpu-throttle-increment");
APPEND_STR(tlsCreds, "tls-creds");
APPEND_STR(tlsHostname, "tls-hostname");
APPEND_ULONG(maxBandwidth, "max-bandwidth");
APPEND_ULONG(downtimeLimit, "downtime-limit");
APPEND_BOOL(blockIncremental, "block-incremental");
APPEND_ULONG(xbzrleCacheSize, "xbzrle-cache-size");
#undef APPEND if (rc < 0)
#undef APPEND_INT goto error;
#undef APPEND_STR }
#undef APPEND_ULONG
return params; return params;
@ -487,6 +611,7 @@ qemuMigrationParamsApply(virQEMUDriverPtr driver,
qemuDomainObjPrivatePtr priv = vm->privateData; qemuDomainObjPrivatePtr priv = vm->privateData;
bool xbzrleCacheSize_old = false; bool xbzrleCacheSize_old = false;
virJSONValuePtr params = NULL; virJSONValuePtr params = NULL;
qemuMigrationParam xbzrle = QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE;
int ret = -1; int ret = -1;
int rc; int rc;
@ -501,14 +626,14 @@ qemuMigrationParamsApply(virQEMUDriverPtr driver,
* we need to set it via migrate-set-cache-size and tell * we need to set it via migrate-set-cache-size and tell
* qemuMonitorSetMigrationParams to ignore this parameter. * qemuMonitorSetMigrationParams to ignore this parameter.
*/ */
if (migParams->params.xbzrleCacheSize_set && if (migParams->params[xbzrle].set &&
(!priv->job.migParams || (!priv->job.migParams ||
!priv->job.migParams->params.xbzrleCacheSize_set)) { !priv->job.migParams->params[xbzrle].set)) {
if (qemuMonitorSetMigrationCacheSize(priv->mon, if (qemuMonitorSetMigrationCacheSize(priv->mon,
migParams->params.xbzrleCacheSize) < 0) migParams->params[xbzrle].value.ull) < 0)
goto cleanup; goto cleanup;
xbzrleCacheSize_old = true; xbzrleCacheSize_old = true;
migParams->params.xbzrleCacheSize_set = false; migParams->params[xbzrle].set = false;
} }
if (!(params = qemuMigrationParamsToJSON(migParams))) if (!(params = qemuMigrationParamsToJSON(migParams)))
@ -528,7 +653,7 @@ qemuMigrationParamsApply(virQEMUDriverPtr driver,
ret = -1; ret = -1;
if (xbzrleCacheSize_old) if (xbzrleCacheSize_old)
migParams->params.xbzrleCacheSize_set = true; migParams->params[xbzrle].set = true;
virJSONValueFree(params); virJSONValueFree(params);
@ -574,7 +699,7 @@ qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver,
goto error; goto error;
} }
if ((!priv->job.migParams->params.tlsCreds)) { if (!priv->job.migParams->params[QEMU_MIGRATION_PARAM_TLS_CREDS].set) {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
_("TLS migration is not supported with this " _("TLS migration is not supported with this "
"QEMU binary")); "QEMU binary"));
@ -605,8 +730,12 @@ qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver,
*tlsAlias, &tlsProps) < 0) *tlsAlias, &tlsProps) < 0)
goto error; goto error;
if (VIR_STRDUP(migParams->params.tlsCreds, *tlsAlias) < 0 || if (qemuMigrationParamsSetString(migParams,
VIR_STRDUP(migParams->params.tlsHostname, hostname ? hostname : "") < 0) QEMU_MIGRATION_PARAM_TLS_CREDS,
*tlsAlias) < 0 ||
qemuMigrationParamsSetString(migParams,
QEMU_MIGRATION_PARAM_TLS_HOSTNAME,
hostname ? hostname : "") < 0)
goto error; goto error;
ret = 0; ret = 0;
@ -638,11 +767,13 @@ qemuMigrationParamsDisableTLS(virDomainObjPtr vm,
{ {
qemuDomainObjPrivatePtr priv = vm->privateData; qemuDomainObjPrivatePtr priv = vm->privateData;
if (!priv->job.migParams->params.tlsCreds) if (!priv->job.migParams->params[QEMU_MIGRATION_PARAM_TLS_CREDS].set)
return 0; return 0;
if (VIR_STRDUP(migParams->params.tlsCreds, "") < 0 || if (qemuMigrationParamsSetString(migParams,
VIR_STRDUP(migParams->params.tlsHostname, "") < 0) QEMU_MIGRATION_PARAM_TLS_CREDS, "") < 0 ||
qemuMigrationParamsSetString(migParams,
QEMU_MIGRATION_PARAM_TLS_HOSTNAME, "") < 0)
return -1; return -1;
return 0; return 0;
@ -667,7 +798,7 @@ qemuMigrationParamsResetTLS(virQEMUDriverPtr driver,
char *secAlias = NULL; char *secAlias = NULL;
/* If QEMU does not support TLS migration we didn't set the aliases. */ /* If QEMU does not support TLS migration we didn't set the aliases. */
if (!origParams->params.tlsCreds) if (!origParams->params[QEMU_MIGRATION_PARAM_TLS_CREDS].set)
return; return;
/* NB: If either or both fail to allocate memory we can still proceed /* NB: If either or both fail to allocate memory we can still proceed
@ -716,6 +847,21 @@ qemuMigrationParamsFetch(virQEMUDriverPtr driver,
} }
int
qemuMigrationParamsSetString(qemuMigrationParamsPtr migParams,
qemuMigrationParam param,
const char *value)
{
if (qemuMigrationParamsCheckType(param, QEMU_MIGRATION_PARAM_TYPE_STRING) < 0)
return -1;
if (VIR_STRDUP(migParams->params[param].value.s, value) < 0)
return -1;
return 0;
}
/** /**
* Returns 0 on success, * Returns 0 on success,
* 1 if the parameter is not supported by QEMU. * 1 if the parameter is not supported by QEMU.
@ -724,10 +870,10 @@ int
qemuMigrationParamsGetDowntimeLimit(qemuMigrationParamsPtr migParams, qemuMigrationParamsGetDowntimeLimit(qemuMigrationParamsPtr migParams,
unsigned long long *value) unsigned long long *value)
{ {
if (!migParams->params.downtimeLimit_set) if (!migParams->params[QEMU_MIGRATION_PARAM_DOWNTIME_LIMIT].set)
return 1; return 1;
*value = migParams->params.downtimeLimit; *value = migParams->params[QEMU_MIGRATION_PARAM_DOWNTIME_LIMIT].value.ull;
return 0; return 0;
} }

20
src/qemu/qemu_migration_params.h
View File

@ -27,6 +27,21 @@
# include "qemu_monitor.h" # include "qemu_monitor.h"
# include "qemu_conf.h" # include "qemu_conf.h"
typedef enum {
QEMU_MIGRATION_PARAM_COMPRESS_LEVEL,
QEMU_MIGRATION_PARAM_COMPRESS_THREADS,
QEMU_MIGRATION_PARAM_DECOMPRESS_THREADS,
QEMU_MIGRATION_PARAM_THROTTLE_INITIAL,
QEMU_MIGRATION_PARAM_THROTTLE_INCREMENT,
QEMU_MIGRATION_PARAM_TLS_CREDS,
QEMU_MIGRATION_PARAM_TLS_HOSTNAME,
QEMU_MIGRATION_PARAM_MAX_BANDWIDTH,
QEMU_MIGRATION_PARAM_DOWNTIME_LIMIT,
QEMU_MIGRATION_PARAM_BLOCK_INCREMENTAL,
QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE,
QEMU_MIGRATION_PARAM_LAST
} qemuMigrationParam;
typedef struct _qemuMigrationParams qemuMigrationParams; typedef struct _qemuMigrationParams qemuMigrationParams;
typedef qemuMigrationParams *qemuMigrationParamsPtr; typedef qemuMigrationParams *qemuMigrationParamsPtr;
@ -79,6 +94,11 @@ qemuMigrationParamsFetch(virQEMUDriverPtr driver,
int asyncJob, int asyncJob,
qemuMigrationParamsPtr *migParams); qemuMigrationParamsPtr *migParams);
int
qemuMigrationParamsSetString(qemuMigrationParamsPtr migParams,
qemuMigrationParam param,
const char *value);
int int
qemuMigrationParamsGetDowntimeLimit(qemuMigrationParamsPtr migParams, qemuMigrationParamsGetDowntimeLimit(qemuMigrationParamsPtr migParams,
unsigned long long *value); unsigned long long *value);