From nobody Wed May 14 13:08:32 2025 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) client-ip=209.132.183.28; envelope-from=libvir-list-bounces@redhat.com; helo=mx1.redhat.com; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com Return-Path: Received: from mx1.redhat.com (mx1.redhat.com [209.132.183.28]) by mx.zohomail.com with SMTPS id 152285309068336.21566082004108; Wed, 4 Apr 2018 07:44:50 -0700 (PDT) Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 77946356DF; Wed, 4 Apr 2018 14:44:48 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 3D62789E60; Wed, 4 Apr 2018 14:44:48 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 08A5E65D25; Wed, 4 Apr 2018 14:44:48 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.rdu2.redhat.com [10.11.54.4]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id w34Eg88W020422 for ; Wed, 4 Apr 2018 10:42:08 -0400 Received: by smtp.corp.redhat.com (Postfix) id 4874B2024CA2; Wed, 4 Apr 2018 14:42:08 +0000 (UTC) Received: from virval.usersys.redhat.com (unknown [10.43.2.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id C73E12024CA4 for ; Wed, 4 Apr 2018 14:42:07 +0000 (UTC) Received: by virval.usersys.redhat.com (Postfix, from userid 500) id 2F518104526; Wed, 4 Apr 2018 16:42:02 +0200 (CEST) From: Jiri Denemark To: libvir-list@redhat.com Date: Wed, 4 Apr 2018 16:41:43 +0200 Message-Id: In-Reply-To: References: In-Reply-To: References: Mail-Followup-To: libvir-list@redhat.com X-Scanned-By: MIMEDefang 2.78 on 10.11.54.4 X-loop: libvir-list@redhat.com Subject: [libvirt] [PATCH 54/68] qemu: Refactor qemuMigrationParams X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.30]); Wed, 04 Apr 2018 14:44:49 +0000 (UTC) X-ZohoMail: RSF_0 Z_629925259 SPT_0 Content-Type: text/plain; charset="utf-8" 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 --- src/qemu/qemu_migration_params.c | 469 ++++++++++++++++++++----------- src/qemu/qemu_migration_params.h | 20 ++ 2 files changed, 327 insertions(+), 162 deletions(-) diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_par= ams.c index 9f091ec693..50f69ee571 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -38,46 +38,29 @@ VIR_LOG_INIT("qemu.qemu_migration_params"); =20 #define QEMU_MIGRATION_TLS_ALIAS_BASE "libvirt_migrate" =20 -typedef struct _qemuMonitorMigrationParams qemuMonitorMigrationParams; -typedef qemuMonitorMigrationParams *qemuMonitorMigrationParamsPtr; -struct _qemuMonitorMigrationParams { - bool compressLevel_set; - int compressLevel; +typedef enum { + QEMU_MIGRATION_PARAM_TYPE_INT, + QEMU_MIGRATION_PARAM_TYPE_ULL, + QEMU_MIGRATION_PARAM_TYPE_BOOL, + QEMU_MIGRATION_PARAM_TYPE_STRING, +} qemuMigrationParamType; =20 - bool compressThreads_set; - int compressThreads; - - bool decompressThreads_set; - int decompressThreads; - - bool cpuThrottleInitial_set; - int cpuThrottleInitial; - - bool cpuThrottleIncrement_set; - int cpuThrottleIncrement; - - /* Value is either NULL, "", or some string. NULL indicates no support; - * whereas, some string value indicates we can support setting/clearin= g */ - 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; +typedef struct _qemuMigrationParamValue qemuMigrationParamValue; +typedef qemuMigrationParamValue *qemuMigrationParamValuePtr; +struct _qemuMigrationParamValue { + bool set; + union { + int i; /* exempt from syntax-check */ + unsigned long long ull; + bool b; + char *s; + } value; }; =20 struct _qemuMigrationParams { unsigned long long compMethods; /* bit-wise OR of qemuMigrationCompres= sMethod */ virBitmapPtr caps; - qemuMonitorMigrationParams params; + qemuMigrationParamValue params[QEMU_MIGRATION_PARAM_LAST]; }; =20 typedef enum { @@ -92,6 +75,19 @@ VIR_ENUM_IMPL(qemuMigrationCompressMethod, QEMU_MIGRATIO= N_COMPRESS_LAST, "mt", ); =20 +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"); =20 typedef struct _qemuMigrationParamsAlwaysOnItem qemuMigrationParamsAlwaysO= nItem; struct _qemuMigrationParamsAlwaysOnItem { @@ -128,6 +124,21 @@ static const qemuMigrationParamsFlagMapItem qemuMigrat= ionParamsFlagMap[] =3D { QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION}, }; =20 +static const qemuMigrationParamType qemuMigrationParamTypes[] =3D { + [QEMU_MIGRATION_PARAM_COMPRESS_LEVEL] =3D QEMU_MIGRATION_PARAM_TYPE_IN= T, + [QEMU_MIGRATION_PARAM_COMPRESS_THREADS] =3D QEMU_MIGRATION_PARAM_TYPE_= INT, + [QEMU_MIGRATION_PARAM_DECOMPRESS_THREADS] =3D QEMU_MIGRATION_PARAM_TYP= E_INT, + [QEMU_MIGRATION_PARAM_THROTTLE_INITIAL] =3D QEMU_MIGRATION_PARAM_TYPE_= INT, + [QEMU_MIGRATION_PARAM_THROTTLE_INCREMENT] =3D QEMU_MIGRATION_PARAM_TYP= E_INT, + [QEMU_MIGRATION_PARAM_TLS_CREDS] =3D QEMU_MIGRATION_PARAM_TYPE_STRING, + [QEMU_MIGRATION_PARAM_TLS_HOSTNAME] =3D QEMU_MIGRATION_PARAM_TYPE_STRI= NG, + [QEMU_MIGRATION_PARAM_MAX_BANDWIDTH] =3D QEMU_MIGRATION_PARAM_TYPE_ULL, + [QEMU_MIGRATION_PARAM_DOWNTIME_LIMIT] =3D QEMU_MIGRATION_PARAM_TYPE_UL= L, + [QEMU_MIGRATION_PARAM_BLOCK_INCREMENTAL] =3D QEMU_MIGRATION_PARAM_TYPE= _BOOL, + [QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE] =3D QEMU_MIGRATION_PARAM_TYPE= _ULL, +}; +verify(ARRAY_CARDINALITY(qemuMigrationParamTypes) =3D=3D QEMU_MIGRATION_PA= RAM_LAST); + =20 static qemuMigrationParamsPtr qemuMigrationParamsNew(void) @@ -152,26 +163,120 @@ qemuMigrationParamsNew(void) void qemuMigrationParamsFree(qemuMigrationParamsPtr migParams) { + size_t i; + if (!migParams) return; =20 + for (i =3D 0; i < QEMU_MIGRATION_PARAM_LAST; i++) { + if (qemuMigrationParamTypes[i] =3D=3D QEMU_MIGRATION_PARAM_TYPE_ST= RING) + VIR_FREE(migParams->params[i].value.s); + } + virBitmapFree(migParams->caps); - VIR_FREE(migParams->params.tlsCreds); - VIR_FREE(migParams->params.tlsHostname); VIR_FREE(migParams); } =20 =20 -#define GET(API, PARAM, VAR) \ - do { \ - int rc; \ - if ((rc =3D API(params, nparams, VIR_MIGRATE_PARAM_ ## PARAM, \ - &migParams->params.VAR)) < 0) \ - goto error; \ - \ - if (rc =3D=3D 1) \ - migParams->params.VAR ## _set =3D true; \ - } while (0) +static int +qemuMigrationParamsCheckType(qemuMigrationParam param, + qemuMigrationParamType type) +{ + if (qemuMigrationParamTypes[param] !=3D type) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Type mismatch for '%s' migration parameter"), + qemuMigrationParamTypeToString(param)); + return -1; + } + + 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 =3D virTypedParamsGetInt(params, nparams, name, + &migParams->params[param].value.i)) < 0) + return -1; + + migParams->params[param].set =3D !!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 =3D virTypedParamsGetULLong(params, nparams, name, + &migParams->params[param].value.ull)= ) < 0) + return -1; + + migParams->params[param].set =3D !!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); +} =20 =20 static int @@ -221,23 +326,40 @@ qemuMigrationParamsSetCompression(virTypedParameterPt= r params, ignore_value(virBitmapSetBit(migParams->caps, cap)); } =20 - if (params) { - GET(virTypedParamsGetInt, COMPRESSION_MT_LEVEL, compressLevel); - GET(virTypedParamsGetInt, COMPRESSION_MT_THREADS, compressThreads); - GET(virTypedParamsGetInt, COMPRESSION_MT_DTHREADS, decompressThrea= ds); - GET(virTypedParamsGetULLong, COMPRESSION_XBZRLE_CACHE, xbzrleCache= Size); - } + if (qemuMigrationParamsGetTPInt(migParams, + QEMU_MIGRATION_PARAM_COMPRESS_LEVEL, + params, nparams, + VIR_MIGRATE_PARAM_COMPRESSION_MT_LEVEL= ) < 0) + goto error; =20 - if ((migParams->params.compressLevel_set || - migParams->params.compressThreads_set || - migParams->params.decompressThreads_set) && + if (qemuMigrationParamsGetTPInt(migParams, + QEMU_MIGRATION_PARAM_COMPRESS_THREADS, + params, nparams, + VIR_MIGRATE_PARAM_COMPRESSION_MT_THREA= DS) < 0) + goto error; + + if (qemuMigrationParamsGetTPInt(migParams, + QEMU_MIGRATION_PARAM_DECOMPRESS_THREAD= S, + params, nparams, + VIR_MIGRATE_PARAM_COMPRESSION_MT_DTHRE= ADS) < 0) + goto error; + + if (qemuMigrationParamsGetTPULL(migParams, + QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE, + params, nparams, + VIR_MIGRATE_PARAM_COMPRESSION_XBZRLE_C= ACHE) < 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))) { virReportError(VIR_ERR_INVALID_ARG, "%s", _("Turn multithread compression on to tune it")); goto error; } =20 - if (migParams->params.xbzrleCacheSize_set && + if (migParams->params[QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE].set && !(migParams->compMethods & (1ULL << QEMU_MIGRATION_COMPRESS_XBZRLE= ))) { virReportError(VIR_ERR_INVALID_ARG, "%s", _("Turn xbzrle compression on to tune it")); @@ -277,15 +399,22 @@ qemuMigrationParamsFromFlags(virTypedParameterPtr par= ams, } } =20 - if (params) { - if (party =3D=3D QEMU_MIGRATION_SOURCE) { - GET(virTypedParamsGetInt, AUTO_CONVERGE_INITIAL, cpuThrottleIn= itial); - GET(virTypedParamsGetInt, AUTO_CONVERGE_INCREMENT, cpuThrottle= Increment); - } + if (party =3D=3D QEMU_MIGRATION_SOURCE) { + if (qemuMigrationParamsGetTPInt(migParams, + QEMU_MIGRATION_PARAM_THROTTLE_INIT= IAL, + params, nparams, + VIR_MIGRATE_PARAM_AUTO_CONVERGE_IN= ITIAL) < 0) + goto error; + + if (qemuMigrationParamsGetTPInt(migParams, + QEMU_MIGRATION_PARAM_THROTTLE_INCR= EMENT, + params, nparams, + VIR_MIGRATE_PARAM_AUTO_CONVERGE_IN= CREMENT) < 0) + goto error; } =20 - if ((migParams->params.cpuThrottleInitial_set || - migParams->params.cpuThrottleIncrement_set) && + if ((migParams->params[QEMU_MIGRATION_PARAM_THROTTLE_INITIAL].set || + migParams->params[QEMU_MIGRATION_PARAM_THROTTLE_INCREMENT].set) && !(flags & VIR_MIGRATE_AUTO_CONVERGE)) { virReportError(VIR_ERR_INVALID_ARG, "%s", _("Turn auto convergence on to tune it")); @@ -302,8 +431,6 @@ qemuMigrationParamsFromFlags(virTypedParameterPtr param= s, return NULL; } =20 -#undef GET - =20 int qemuMigrationParamsDump(qemuMigrationParamsPtr migParams, @@ -315,7 +442,7 @@ qemuMigrationParamsDump(qemuMigrationParamsPtr migParam= s, size_t i; =20 if (migParams->compMethods =3D=3D 1ULL << QEMU_MIGRATION_COMPRESS_XBZR= LE && - !migParams->params.xbzrleCacheSize_set) { + !migParams->params[QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE].set) { *flags |=3D VIR_MIGRATE_COMPRESSED; return 0; } @@ -328,20 +455,29 @@ qemuMigrationParamsDump(qemuMigrationParamsPtr migPar= ams, return -1; } =20 -#define SET(API, PARAM, VAR) \ - do { \ - if (migParams->params.VAR ## _set && \ - API(params, nparams, maxparams, VIR_MIGRATE_PARAM_ ## PARAM, \ - migParams->params.VAR) < 0) \ - return -1; \ - } while (0) + if (qemuMigrationParamsSetTPInt(migParams, + QEMU_MIGRATION_PARAM_COMPRESS_LEVEL, + params, nparams, maxparams, + VIR_MIGRATE_PARAM_COMPRESSION_MT_LEVEL= ) < 0) + return -1; =20 - SET(virTypedParamsAddInt, COMPRESSION_MT_LEVEL, compressLevel); - SET(virTypedParamsAddInt, COMPRESSION_MT_THREADS, compressThreads); - SET(virTypedParamsAddInt, COMPRESSION_MT_DTHREADS, decompressThreads); - SET(virTypedParamsAddULLong, COMPRESSION_XBZRLE_CACHE, xbzrleCacheSize= ); + if (qemuMigrationParamsSetTPInt(migParams, + QEMU_MIGRATION_PARAM_COMPRESS_THREADS, + params, nparams, maxparams, + VIR_MIGRATE_PARAM_COMPRESSION_MT_THREA= DS) < 0) + return -1; =20 -#undef SET + if (qemuMigrationParamsSetTPInt(migParams, + QEMU_MIGRATION_PARAM_DECOMPRESS_THREAD= S, + params, nparams, maxparams, + VIR_MIGRATE_PARAM_COMPRESSION_MT_DTHRE= ADS) < 0) + return -1; + + if (qemuMigrationParamsSetTPULL(migParams, + QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE, + params, nparams, maxparams, + VIR_MIGRATE_PARAM_COMPRESSION_XBZRLE_C= ACHE) < 0) + return -1; =20 return 0; } @@ -350,7 +486,11 @@ qemuMigrationParamsDump(qemuMigrationParamsPtr migPara= ms, static qemuMigrationParamsPtr qemuMigrationParamsFromJSON(virJSONValuePtr params) { - qemuMigrationParamsPtr migParams =3D NULL; + qemuMigrationParamsPtr migParams; + qemuMigrationParamValuePtr pv; + const char *name; + const char *str; + size_t i; =20 if (!(migParams =3D qemuMigrationParamsNew())) return NULL; @@ -358,47 +498,35 @@ qemuMigrationParamsFromJSON(virJSONValuePtr params) if (!params) return migParams; =20 -#define PARSE_SET(API, VAR, FIELD) \ - do { \ - if (API(params, FIELD, &migParams->params.VAR) =3D=3D 0) \ - migParams->params.VAR ## _set =3D true; \ - } while (0) + for (i =3D 0; i < QEMU_MIGRATION_PARAM_LAST; i++) { + name =3D qemuMigrationParamTypeList[i]; + pv =3D &migParams->params[i]; =20 -#define PARSE_INT(VAR, FIELD) \ - PARSE_SET(virJSONValueObjectGetNumberInt, VAR, FIELD) + switch (qemuMigrationParamTypes[i]) { + case QEMU_MIGRATION_PARAM_TYPE_INT: + if (virJSONValueObjectGetNumberInt(params, name, &pv->value.i)= =3D=3D 0) + pv->set =3D true; + break; =20 -#define PARSE_ULONG(VAR, FIELD) \ - PARSE_SET(virJSONValueObjectGetNumberUlong, VAR, FIELD) + case QEMU_MIGRATION_PARAM_TYPE_ULL: + if (virJSONValueObjectGetNumberUlong(params, name, &pv->value.= ull) =3D=3D 0) + pv->set =3D true; + break; =20 -#define PARSE_BOOL(VAR, FIELD) \ - PARSE_SET(virJSONValueObjectGetBoolean, VAR, FIELD) + case QEMU_MIGRATION_PARAM_TYPE_BOOL: + if (virJSONValueObjectGetBoolean(params, name, &pv->value.b) = =3D=3D 0) + pv->set =3D true; + break; =20 -#define PARSE_STR(VAR, FIELD) \ - do { \ - const char *str; \ - if ((str =3D virJSONValueObjectGetString(params, FIELD))) { \ - if (VIR_STRDUP(migParams->params.VAR, str) < 0) \ - goto error; \ - } \ - } 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 + case QEMU_MIGRATION_PARAM_TYPE_STRING: + if ((str =3D virJSONValueObjectGetString(params, name))) { + if (VIR_STRDUP(pv->value.s, str) < 0) + goto error; + pv->set =3D true; + } + break; + } + } =20 return migParams; =20 @@ -412,48 +540,43 @@ static virJSONValuePtr qemuMigrationParamsToJSON(qemuMigrationParamsPtr migParams) { virJSONValuePtr params =3D NULL; + qemuMigrationParamValuePtr pv; + const char *name; + size_t i; + int rc; =20 if (!(params =3D virJSONValueNewObject())) return NULL; =20 -#define APPEND(VALID, API, VAR, FIELD) \ - do { \ - if (VALID && API(params, FIELD, migParams->params.VAR) < 0) \ - goto error; \ - } while (0) + for (i =3D 0; i < QEMU_MIGRATION_PARAM_LAST; i++) { + name =3D qemuMigrationParamTypeList[i]; + pv =3D &migParams->params[i]; =20 -#define APPEND_INT(VAR, FIELD) \ - APPEND(migParams->params.VAR ## _set, \ - virJSONValueObjectAppendNumberInt, VAR, FIELD) + if (!pv->set) + continue; =20 -#define APPEND_STR(VAR, FIELD) \ - APPEND(migParams->params.VAR, \ - virJSONValueObjectAppendString, VAR, FIELD) + rc =3D 0; + switch (qemuMigrationParamTypes[i]) { + case QEMU_MIGRATION_PARAM_TYPE_INT: + rc =3D virJSONValueObjectAppendNumberInt(params, name, pv->val= ue.i); + break; =20 -#define APPEND_ULONG(VAR, FIELD) \ - APPEND(migParams->params.VAR ## _set, \ - virJSONValueObjectAppendNumberUlong, VAR, FIELD) + case QEMU_MIGRATION_PARAM_TYPE_ULL: + rc =3D virJSONValueObjectAppendNumberUlong(params, name, pv->v= alue.ull); + break; =20 -#define APPEND_BOOL(VAR, FIELD) \ - APPEND(migParams->params.VAR ## _set, \ - virJSONValueObjectAppendBoolean, VAR, FIELD) + case QEMU_MIGRATION_PARAM_TYPE_BOOL: + rc =3D virJSONValueObjectAppendBoolean(params, name, pv->value= .b); + break; =20 - APPEND_INT(compressLevel, "compress-level"); - APPEND_INT(compressThreads, "compress-threads"); - APPEND_INT(decompressThreads, "decompress-threads"); - 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"); + case QEMU_MIGRATION_PARAM_TYPE_STRING: + rc =3D virJSONValueObjectAppendString(params, name, pv->value.= s); + break; + } =20 -#undef APPEND -#undef APPEND_INT -#undef APPEND_STR -#undef APPEND_ULONG + if (rc < 0) + goto error; + } =20 return params; =20 @@ -483,6 +606,7 @@ qemuMigrationParamsApply(virQEMUDriverPtr driver, qemuDomainObjPrivatePtr priv =3D vm->privateData; bool xbzrleCacheSize_old =3D false; virJSONValuePtr params =3D NULL; + qemuMigrationParam xbzrle =3D QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE; int ret =3D -1; =20 if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) @@ -496,14 +620,14 @@ qemuMigrationParamsApply(virQEMUDriverPtr driver, * we need to set it via migrate-set-cache-size and tell * qemuMonitorSetMigrationParams to ignore this parameter. */ - if (migParams->params.xbzrleCacheSize_set && + if (migParams->params[xbzrle].set && (!priv->job.migParams || - !priv->job.migParams->params.xbzrleCacheSize_set)) { + !priv->job.migParams->params[xbzrle].set)) { if (qemuMonitorSetMigrationCacheSize(priv->mon, - migParams->params.xbzrleCache= Size) < 0) + migParams->params[xbzrle].val= ue.ull) < 0) goto cleanup; xbzrleCacheSize_old =3D true; - migParams->params.xbzrleCacheSize_set =3D false; + migParams->params[xbzrle].set =3D false; } =20 if (!(params =3D qemuMigrationParamsToJSON(migParams))) @@ -522,7 +646,7 @@ qemuMigrationParamsApply(virQEMUDriverPtr driver, ret =3D -1; =20 if (xbzrleCacheSize_old) - migParams->params.xbzrleCacheSize_set =3D true; + migParams->params[xbzrle].set =3D true; =20 virJSONValueFree(params); =20 @@ -568,7 +692,7 @@ qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver, goto error; } =20 - if ((!priv->job.migParams->params.tlsCreds)) { + if (!priv->job.migParams->params[QEMU_MIGRATION_PARAM_TLS_CREDS].set) { virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", _("TLS migration is not supported with this " "QEMU binary")); @@ -599,8 +723,12 @@ qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver, *tlsAlias, &tlsProps) < 0) goto error; =20 - if (VIR_STRDUP(migParams->params.tlsCreds, *tlsAlias) < 0 || - VIR_STRDUP(migParams->params.tlsHostname, hostname ? hostname : ""= ) < 0) + if (qemuMigrationParamsSetString(migParams, + QEMU_MIGRATION_PARAM_TLS_CREDS, + *tlsAlias) < 0 || + qemuMigrationParamsSetString(migParams, + QEMU_MIGRATION_PARAM_TLS_HOSTNAME, + hostname ? hostname : "") < 0) goto error; =20 ret =3D 0; @@ -632,11 +760,13 @@ qemuMigrationParamsDisableTLS(virDomainObjPtr vm, { qemuDomainObjPrivatePtr priv =3D vm->privateData; =20 - if (!priv->job.migParams->params.tlsCreds) + if (!priv->job.migParams->params[QEMU_MIGRATION_PARAM_TLS_CREDS].set) return 0; =20 - if (VIR_STRDUP(migParams->params.tlsCreds, "") < 0 || - VIR_STRDUP(migParams->params.tlsHostname, "") < 0) + if (qemuMigrationParamsSetString(migParams, + QEMU_MIGRATION_PARAM_TLS_CREDS, "") <= 0 || + qemuMigrationParamsSetString(migParams, + QEMU_MIGRATION_PARAM_TLS_HOSTNAME, ""= ) < 0) return -1; =20 return 0; @@ -661,7 +791,7 @@ qemuMigrationParamsResetTLS(virQEMUDriverPtr driver, char *secAlias =3D NULL; =20 /* 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; =20 /* NB: If either or both fail to allocate memory we can still proceed @@ -710,6 +840,21 @@ qemuMigrationParamsFetch(virQEMUDriverPtr driver, } =20 =20 +int +qemuMigrationParamsSetString(qemuMigrationParamsPtr migParams, + qemuMigrationParam param, + const char *value) +{ + if (qemuMigrationParamsCheckType(param, QEMU_MIGRATION_PARAM_TYPE_STRI= NG) < 0) + return -1; + + if (VIR_STRDUP(migParams->params[param].value.s, value) < 0) + return -1; + + return 0; +} + + /** * Returns 0 on success, * 1 if the parameter is not supported by QEMU. @@ -718,10 +863,10 @@ int qemuMigrationParamsGetDowntimeLimit(qemuMigrationParamsPtr migParams, unsigned long long *value) { - if (!migParams->params.downtimeLimit_set) + if (!migParams->params[QEMU_MIGRATION_PARAM_DOWNTIME_LIMIT].set) return 1; =20 - *value =3D migParams->params.downtimeLimit; + *value =3D migParams->params[QEMU_MIGRATION_PARAM_DOWNTIME_LIMIT].valu= e.ull; return 0; } =20 diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_par= ams.h index 9fcd9825c8..c354c35d29 100644 --- a/src/qemu/qemu_migration_params.h +++ b/src/qemu/qemu_migration_params.h @@ -27,6 +27,21 @@ # include "qemu_monitor.h" # include "qemu_conf.h" =20 +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; =20 typedef struct _qemuMigrationParams qemuMigrationParams; typedef qemuMigrationParams *qemuMigrationParamsPtr; @@ -79,6 +94,11 @@ qemuMigrationParamsFetch(virQEMUDriverPtr driver, int asyncJob, qemuMigrationParamsPtr *migParams); =20 +int +qemuMigrationParamsSetString(qemuMigrationParamsPtr migParams, + qemuMigrationParam param, + const char *value); + int qemuMigrationParamsGetDowntimeLimit(qemuMigrationParamsPtr migParams, unsigned long long *value); --=20 2.17.0 -- libvir-list mailing list libvir-list@redhat.com https://www.redhat.com/mailman/listinfo/libvir-list