9:23 a.m.
This series adds a new VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY typed
parameter for virDomainMigrate3 and virDomainMigrateToURI3 for setting
maximum post-copy migration bandwidth.
In case the initial VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY value turns out
to be suboptimal a new VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY flag for
virDomainMigrateSetMaxSpeed and virDomainMigrateGetMaxSpeed may be used
to set/get the maximum post-copy migration bandwidth while migration is
already running.
Jiri Denemark (8):
qemu: Use C99 initializers for qemuMigrationParamsTPMap
qemu: Add optional unit to qemuMigrationParamsTPMapItem
qemu: Rework qemuDomainMigrateSetMaxSpeed
qemu: Make migration params usable outside migration
Public API for post-copy migration bandwidth
qemu: Implement VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY
qemu: Implement VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY flag
virsh: Add support for setting post-copy migration bandwidth
include/libvirt/libvirt-domain.h | 15 ++++
src/libvirt-domain.c | 11 ++-
src/qemu/qemu_driver.c | 118 +++++++++++++++++++++++-------
src/qemu/qemu_migration.h | 1 +
src/qemu/qemu_migration_params.c | 122 +++++++++++++++++++++++--------
src/qemu/qemu_migration_params.h | 10 +++
tools/virsh-domain.c | 33 ++++++++-
tools/virsh.pod | 15 +++-
8 files changed, 260 insertions(+), 65 deletions(-)
--
2.20.1
9:23 a.m.
New subject: [libvirt] [PATCH 1/8] qemu: Use C99 initializers for qemuMigrationParamsTPMap
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
src/qemu/qemu_migration_params.c | 36 ++++++++++++++++----------------
1 file changed, 18 insertions(+), 18 deletions(-)
diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c
index e112e790c2..658e785059 100644
--- a/src/qemu/qemu_migration_params.c
+++ b/src/qemu/qemu_migration_params.c
@@ -154,29 +154,29 @@ static const qemuMigrationParamsFlagMapItem
qemuMigrationParamsFlagMap[] = {
/* Translation from VIR_MIGRATE_PARAM_* typed parameters to
* qemuMigrationParams. */
static const qemuMigrationParamsTPMapItem qemuMigrationParamsTPMap[] = {
- {VIR_MIGRATE_PARAM_AUTO_CONVERGE_INITIAL,
- QEMU_MIGRATION_PARAM_THROTTLE_INITIAL,
- QEMU_MIGRATION_SOURCE},
+ {.typedParam = VIR_MIGRATE_PARAM_AUTO_CONVERGE_INITIAL,
+ .param = QEMU_MIGRATION_PARAM_THROTTLE_INITIAL,
+ .party = QEMU_MIGRATION_SOURCE},
- {VIR_MIGRATE_PARAM_AUTO_CONVERGE_INCREMENT,
- QEMU_MIGRATION_PARAM_THROTTLE_INCREMENT,
- QEMU_MIGRATION_SOURCE},
+ {.typedParam = VIR_MIGRATE_PARAM_AUTO_CONVERGE_INCREMENT,
+ .param = QEMU_MIGRATION_PARAM_THROTTLE_INCREMENT,
+ .party = QEMU_MIGRATION_SOURCE},
- {VIR_MIGRATE_PARAM_COMPRESSION_MT_LEVEL,
- QEMU_MIGRATION_PARAM_COMPRESS_LEVEL,
- QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION},
+ {.typedParam = VIR_MIGRATE_PARAM_COMPRESSION_MT_LEVEL,
+ .param = QEMU_MIGRATION_PARAM_COMPRESS_LEVEL,
+ .party = QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION},
- {VIR_MIGRATE_PARAM_COMPRESSION_MT_THREADS,
- QEMU_MIGRATION_PARAM_COMPRESS_THREADS,
- QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION},
+ {.typedParam = VIR_MIGRATE_PARAM_COMPRESSION_MT_THREADS,
+ .param = QEMU_MIGRATION_PARAM_COMPRESS_THREADS,
+ .party = QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION},
- {VIR_MIGRATE_PARAM_COMPRESSION_MT_DTHREADS,
- QEMU_MIGRATION_PARAM_DECOMPRESS_THREADS,
- QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION},
+ {.typedParam = VIR_MIGRATE_PARAM_COMPRESSION_MT_DTHREADS,
+ .param = QEMU_MIGRATION_PARAM_DECOMPRESS_THREADS,
+ .party = QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION},
- {VIR_MIGRATE_PARAM_COMPRESSION_XBZRLE_CACHE,
- QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE,
- QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION},
+ {.typedParam = VIR_MIGRATE_PARAM_COMPRESSION_XBZRLE_CACHE,
+ .param = QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE,
+ .party = QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION},
};
static const qemuMigrationParamType qemuMigrationParamTypes[] = {
--
2.20.1
7:47 a.m.
New subject: [libvirt] [PATCH 1/8] qemu: Use C99 initializers for qemuMigrationParamsTPMap
On Tue, Feb 05, 2019 at 04:23:04PM +0100, Jiri Denemark wrote:
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
src/qemu/qemu_migration_params.c | 36 ++++++++++++++++----------------
1 file changed, 18 insertions(+), 18 deletions(-)
Reviewed-by: Ján Tomko <jtomko(a)redhat.com>
Jano
9:23 a.m.
New subject: [libvirt] [PATCH 2/8] qemu: Add optional unit to qemuMigrationParamsTPMapItem
Some migration parameters supported by libvirt may use units that differ
from the units used by QEMU for the corresponding parameters. For
example, libvirt defines migration bandwidth in MiB/s while QEMU expects
B/s. Let's add a unit field to qemuMigrationParamsTPMapItem for
automatic conversion when translating between libvirt's migration typed
parameters and QEMU's migration paramteres.
This patch is a preparation for future parameters as the existing
VIR_MIGRATE_PARAM_BANDWIDTH parameter is set using "migrate_set_speed"
QMP command rather than "migrate-set-parameters" for backward
compatibility.
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
src/qemu/qemu_migration_params.c | 63 ++++++++++++++++++++++++++------
1 file changed, 51 insertions(+), 12 deletions(-)
diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c
index 658e785059..c36bed5744 100644
--- a/src/qemu/qemu_migration_params.c
+++ b/src/qemu/qemu_migration_params.c
@@ -120,6 +120,7 @@ struct _qemuMigrationParamsFlagMapItem {
typedef struct _qemuMigrationParamsTPMapItem qemuMigrationParamsTPMapItem;
struct _qemuMigrationParamsTPMapItem {
const char *typedParam;
+ unsigned int unit;
qemuMigrationParam param;
int party; /* bit-wise OR of qemuMigrationParty */
};
@@ -273,7 +274,8 @@ qemuMigrationParamsGetTPInt(qemuMigrationParamsPtr migParams,
qemuMigrationParam param,
virTypedParameterPtr params,
int nparams,
- const char *name)
+ const char *name,
+ unsigned int unit)
{
int rc;
@@ -287,6 +289,17 @@ qemuMigrationParamsGetTPInt(qemuMigrationParamsPtr migParams,
&migParams->params[param].value.i)) < 0)
return -1;
+ if (unit > 0) {
+ unsigned int max = UINT_MAX / unit;
+ if (migParams->params[param].value.i > max) {
+ virReportError(VIR_ERR_OVERFLOW,
+ _("%s migration parameter must be less than %u"),
+ name, max + 1);
+ return -1;
+ }
+ migParams->params[param].value.i *= unit;
+ }
+
migParams->params[param].set = !!rc;
return 0;
}
@@ -298,16 +311,22 @@ qemuMigrationParamsSetTPInt(qemuMigrationParamsPtr migParams,
virTypedParameterPtr *params,
int *nparams,
int *maxparams,
- const char *name)
+ const char *name,
+ unsigned int unit)
{
+ int value;
+
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);
+ value = migParams->params[param].value.i;
+ if (unit > 0)
+ value /= unit;
+
+ return virTypedParamsAddInt(params, nparams, maxparams, name, value);
}
@@ -316,7 +335,8 @@ qemuMigrationParamsGetTPULL(qemuMigrationParamsPtr migParams,
qemuMigrationParam param,
virTypedParameterPtr params,
int nparams,
- const char *name)
+ const char *name,
+ unsigned int unit)
{
int rc;
@@ -330,6 +350,17 @@ qemuMigrationParamsGetTPULL(qemuMigrationParamsPtr migParams,
&migParams->params[param].value.ull)) <
0)
return -1;
+ if (unit > 0) {
+ unsigned long long max = ULLONG_MAX / unit;
+ if (migParams->params[param].value.ull > max) {
+ virReportError(VIR_ERR_OVERFLOW,
+ _("%s migration parameter must be less than %llu"),
+ name, max + 1);
+ return -1;
+ }
+ migParams->params[param].value.ull *= unit;
+ }
+
migParams->params[param].set = !!rc;
return 0;
}
@@ -341,16 +372,22 @@ qemuMigrationParamsSetTPULL(qemuMigrationParamsPtr migParams,
virTypedParameterPtr *params,
int *nparams,
int *maxparams,
- const char *name)
+ const char *name,
+ unsigned int unit)
{
+ unsigned long long value;
+
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);
+ value = migParams->params[param].value.ull;
+ if (unit > 0)
+ value /= unit;
+
+ return virTypedParamsAddULLong(params, nparams, maxparams, name, value);
}
@@ -465,13 +502,15 @@ qemuMigrationParamsFromFlags(virTypedParameterPtr params,
switch (qemuMigrationParamTypes[item->param]) {
case QEMU_MIGRATION_PARAM_TYPE_INT:
if (qemuMigrationParamsGetTPInt(migParams, item->param, params,
- nparams, item->typedParam) < 0)
+ nparams, item->typedParam,
+ item->unit) < 0)
goto error;
break;
case QEMU_MIGRATION_PARAM_TYPE_ULL:
if (qemuMigrationParamsGetTPULL(migParams, item->param, params,
- nparams, item->typedParam) < 0)
+ nparams, item->typedParam,
+ item->unit) < 0)
goto error;
break;
@@ -533,14 +572,14 @@ qemuMigrationParamsDump(qemuMigrationParamsPtr migParams,
case QEMU_MIGRATION_PARAM_TYPE_INT:
if (qemuMigrationParamsSetTPInt(migParams, item->param,
params, nparams, maxparams,
- item->typedParam) < 0)
+ item->typedParam, item->unit) < 0)
return -1;
break;
case QEMU_MIGRATION_PARAM_TYPE_ULL:
if (qemuMigrationParamsSetTPULL(migParams, item->param,
params, nparams, maxparams,
- item->typedParam) < 0)
+ item->typedParam, item->unit) < 0)
return -1;
break;
--
2.20.1
7:50 a.m.
New subject: [libvirt] [PATCH 2/8] qemu: Add optional unit to qemuMigrationParamsTPMapItem
On Tue, Feb 05, 2019 at 04:23:05PM +0100, Jiri Denemark wrote:
Some migration parameters supported by libvirt may use units that
differ
from the units used by QEMU for the corresponding parameters. For
example, libvirt defines migration bandwidth in MiB/s while QEMU expects
B/s. Let's add a unit field to qemuMigrationParamsTPMapItem for
automatic conversion when translating between libvirt's migration typed
parameters and QEMU's migration paramteres.
This patch is a preparation for future parameters as the existing
VIR_MIGRATE_PARAM_BANDWIDTH parameter is set using "migrate_set_speed"
QMP command rather than "migrate-set-parameters" for backward
compatibility.
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
src/qemu/qemu_migration_params.c | 63 ++++++++++++++++++++++++++------
1 file changed, 51 insertions(+), 12 deletions(-)
diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c
index 658e785059..c36bed5744 100644
--- a/src/qemu/qemu_migration_params.c
+++ b/src/qemu/qemu_migration_params.c
@@ -120,6 +120,7 @@ struct _qemuMigrationParamsFlagMapItem {
typedef struct _qemuMigrationParamsTPMapItem qemuMigrationParamsTPMapItem;
struct _qemuMigrationParamsTPMapItem {
const char *typedParam;
+ unsigned int unit;
qemuMigrationParam param;
int party; /* bit-wise OR of qemuMigrationParty */
};
@@ -273,7 +274,8 @@ qemuMigrationParamsGetTPInt(qemuMigrationParamsPtr migParams,
qemuMigrationParam param,
virTypedParameterPtr params,
int nparams,
- const char *name)
+ const char *name,
+ unsigned int unit)
{
int rc;
@@ -287,6 +289,17 @@ qemuMigrationParamsGetTPInt(qemuMigrationParamsPtr migParams,
&migParams->params[param].value.i)) < 0)
return -1;
+ if (unit > 0) {
+ unsigned int max = UINT_MAX / unit;
+ if (migParams->params[param].value.i > max) {
+ virReportError(VIR_ERR_OVERFLOW,
+ _("%s migration parameter must be less than %u"),
Sounds better in my head as:
migration parameter '%s' must be...
(which should also be easier to translate with the parameter name
quoted)
+ name, max + 1);
+ return -1;
+ }
+ migParams->params[param].value.i *= unit;
+ }
+
migParams->params[param].set = !!rc;
return 0;
}
@@ -298,16 +311,22 @@ qemuMigrationParamsSetTPInt(qemuMigrationParamsPtr migParams,
virTypedParameterPtr *params,
int *nparams,
int *maxparams,
- const char *name)
+ const char *name,
+ unsigned int unit)
{
+ int value;
+
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);
+ value = migParams->params[param].value.i;
+ if (unit > 0)
+ value /= unit;
+
+ return virTypedParamsAddInt(params, nparams, maxparams, name, value);
}
@@ -316,7 +335,8 @@ qemuMigrationParamsGetTPULL(qemuMigrationParamsPtr migParams,
qemuMigrationParam param,
virTypedParameterPtr params,
int nparams,
- const char *name)
+ const char *name,
+ unsigned int unit)
{
int rc;
@@ -330,6 +350,17 @@ qemuMigrationParamsGetTPULL(qemuMigrationParamsPtr migParams,
&migParams->params[param].value.ull)) <
0)
return -1;
+ if (unit > 0) {
+ unsigned long long max = ULLONG_MAX / unit;
+ if (migParams->params[param].value.ull > max) {
+ virReportError(VIR_ERR_OVERFLOW,
+ _("%s migration parameter must be less than %llu"),
+ name, max + 1);
Same here.
+ return -1;
+ }
+ migParams->params[param].value.ull *= unit;
+ }
+
migParams->params[param].set = !!rc;
return 0;
}
Reviewed-by: Ján Tomko <jtomko(a)redhat.com>
Jano
9:23 a.m.
New subject: [libvirt] [PATCH 3/8] qemu: Rework qemuDomainMigrateSetMaxSpeed
Let's make the code flow easier to follow and get rid of the ugly endjob
label inside if branch.
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
src/qemu/qemu_driver.c | 41 ++++++++++++++++++++++-------------------
1 file changed, 22 insertions(+), 19 deletions(-)
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 427c1d02a8..93ec1dacf4 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -14275,6 +14275,7 @@ qemuDomainMigrateSetMaxSpeed(virDomainPtr dom,
virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
qemuDomainObjPrivatePtr priv;
+ int rc;
int ret = -1;
virCheckFlags(0, -1);
@@ -14294,29 +14295,31 @@ qemuDomainMigrateSetMaxSpeed(virDomainPtr dom,
goto cleanup;
}
- if (virDomainObjIsActive(vm)) {
- if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MIGRATION_OP) < 0)
- goto cleanup;
-
- if (virDomainObjCheckActive(vm) < 0)
- goto endjob;
-
- VIR_DEBUG("Setting migration bandwidth to %luMbs", bandwidth);
- qemuDomainObjEnterMonitor(driver, vm);
- ret = qemuMonitorSetMigrationSpeed(priv->mon, bandwidth);
- if (qemuDomainObjExitMonitor(driver, vm) < 0)
- ret = -1;
-
- if (ret == 0)
- priv->migMaxBandwidth = bandwidth;
-
- endjob:
- qemuDomainObjEndJob(driver, vm);
- } else {
+ if (!virDomainObjIsActive(vm)) {
priv->migMaxBandwidth = bandwidth;
ret = 0;
+ goto cleanup;
}
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MIGRATION_OP) < 0)
+ goto cleanup;
+
+ if (virDomainObjCheckActive(vm) < 0)
+ goto endjob;
+
+ VIR_DEBUG("Setting migration bandwidth to %luMbs", bandwidth);
+ qemuDomainObjEnterMonitor(driver, vm);
+ rc = qemuMonitorSetMigrationSpeed(priv->mon, bandwidth);
+ if (qemuDomainObjExitMonitor(driver, vm) < 0 || rc < 0)
+ goto endjob;
+
+ priv->migMaxBandwidth = bandwidth;
+
+ ret = 0;
+
+ endjob:
+ qemuDomainObjEndJob(driver, vm);
+
cleanup:
virDomainObjEndAPI(&vm);
return ret;
--
2.20.1
7:50 a.m.
New subject: [libvirt] [PATCH 3/8] qemu: Rework qemuDomainMigrateSetMaxSpeed
On Tue, Feb 05, 2019 at 04:23:06PM +0100, Jiri Denemark wrote:
Let's make the code flow easier to follow and get rid of the ugly
endjob
label inside if branch.
Thank you.
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
src/qemu/qemu_driver.c | 41 ++++++++++++++++++++++-------------------
1 file changed, 22 insertions(+), 19 deletions(-)
Reviewed-by: Ján Tomko <jtomko(a)redhat.com>
Jano
9:23 a.m.
New subject: [libvirt] [PATCH 4/8] qemu: Make migration params usable outside migration
So far migration parameters were changed only at the beginning of
migration mostly via an automatic translation from flags and typed
parameters. We need to export a few more functions to support APIs which
may set migration parameters while migration is already running.
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
src/qemu/qemu_migration_params.c | 16 +++++++++++++++-
src/qemu/qemu_migration_params.h | 9 +++++++++
2 files changed, 24 insertions(+), 1 deletion(-)
diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c
index c36bed5744..117ae0e998 100644
--- a/src/qemu/qemu_migration_params.c
+++ b/src/qemu/qemu_migration_params.c
@@ -216,7 +216,7 @@ qemuMigrationParamsGetAlwaysOnCaps(qemuMigrationParty party)
}
-static qemuMigrationParamsPtr
+qemuMigrationParamsPtr
qemuMigrationParamsNew(void)
{
qemuMigrationParamsPtr params;
@@ -1039,6 +1039,20 @@ qemuMigrationParamsFetch(virQEMUDriverPtr driver,
}
+int
+qemuMigrationParamsSetULL(qemuMigrationParamsPtr migParams,
+ qemuMigrationParam param,
+ unsigned long long value)
+{
+ if (qemuMigrationParamsCheckType(param, QEMU_MIGRATION_PARAM_TYPE_ULL) < 0)
+ return -1;
+
+ migParams->params[param].value.ull = value;
+ migParams->params[param].set = true;
+ return 0;
+}
+
+
/**
* Returns -1 on error,
* 0 on success,
diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h
index 709b818dcf..db0745ec28 100644
--- a/src/qemu/qemu_migration_params.h
+++ b/src/qemu/qemu_migration_params.h
@@ -84,8 +84,12 @@ qemuMigrationParamsDump(qemuMigrationParamsPtr migParams,
int *maxparams,
unsigned long *flags);
+qemuMigrationParamsPtr
+qemuMigrationParamsNew(void);
+
void
qemuMigrationParamsFree(qemuMigrationParamsPtr migParams);
+VIR_DEFINE_AUTOPTR_FUNC(qemuMigrationParams, qemuMigrationParamsFree)
int
qemuMigrationParamsApply(virQEMUDriverPtr driver,
@@ -112,6 +116,11 @@ qemuMigrationParamsFetch(virQEMUDriverPtr driver,
int asyncJob,
qemuMigrationParamsPtr *migParams);
+int
+qemuMigrationParamsSetULL(qemuMigrationParamsPtr migParams,
+ qemuMigrationParam param,
+ unsigned long long value);
+
int
qemuMigrationParamsGetULL(qemuMigrationParamsPtr migParams,
qemuMigrationParam param,
--
2.20.1
7:50 a.m.
New subject: [libvirt] [PATCH 4/8] qemu: Make migration params usable outside migration
On Tue, Feb 05, 2019 at 04:23:07PM +0100, Jiri Denemark wrote:
So far migration parameters were changed only at the beginning of
migration mostly via an automatic translation from flags and typed
parameters. We need to export a few more functions to support APIs which
may set migration parameters while migration is already running.
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
src/qemu/qemu_migration_params.c | 16 +++++++++++++++-
src/qemu/qemu_migration_params.h | 9 +++++++++
2 files changed, 24 insertions(+), 1 deletion(-)
Reviewed-by: Ján Tomko <jtomko(a)redhat.com>
Jano
9:23 a.m.
New subject: [libvirt] [PATCH 5/8] Public API for post-copy migration bandwidth
This patch adds a new VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY typed
parameter for virDomainMigrate3 and virDomainMigrateToURI3 for setting
maximum post-copy migration bandwidth.
In case the initial VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY value turns out
to be suboptimal a new VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY flag for
virDomainMigrateSetMaxSpeed and virDomainMigrateGetMaxSpeed may be used
to set/get the maximum post-copy migration bandwidth while migration is
already running.
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
include/libvirt/libvirt-domain.h | 15 +++++++++++++++
src/libvirt-domain.c | 11 ++++++++---
2 files changed, 23 insertions(+), 3 deletions(-)
diff --git a/include/libvirt/libvirt-domain.h b/include/libvirt/libvirt-domain.h
index 0388911ded..d99f9b690b 100644
--- a/include/libvirt/libvirt-domain.h
+++ b/include/libvirt/libvirt-domain.h
@@ -903,6 +903,15 @@ typedef enum {
*/
# define VIR_MIGRATE_PARAM_BANDWIDTH "bandwidth"
+/**
+ * VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY:
+ *
+ * virDomainMigrate* params field: the maximum bandwidth (in MiB/s) that will
+ * be used for post-copy phase of a migration as VIR_TYPED_PARAM_ULLONG. If set
+ * to 0 or omitted, post-copy migration speed will not be limited.
+ */
+# define VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY "bandwidth.postcopy"
+
/**
* VIR_MIGRATE_PARAM_GRAPHICS_URI:
*
@@ -1062,6 +1071,12 @@ int virDomainMigrateSetCompressionCache(virDomainPtr domain,
unsigned long long cacheSize,
unsigned int flags);
+/* Domain migration speed flags. */
+typedef enum {
+ /* Set or get maximum speed of postcopy migration. */
+ VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY = (1 << 0),
+} virDomainMigrateMaxSpeedFlags;
+
int virDomainMigrateSetMaxSpeed(virDomainPtr domain,
unsigned long bandwidth,
unsigned int flags);
diff --git a/src/libvirt-domain.c b/src/libvirt-domain.c
index 58b4863c8f..7b87b3716a 100644
--- a/src/libvirt-domain.c
+++ b/src/libvirt-domain.c
@@ -9036,11 +9036,13 @@ virDomainMigrateSetCompressionCache(virDomainPtr domain,
* virDomainMigrateSetMaxSpeed:
* @domain: a domain object
* @bandwidth: migration bandwidth limit in MiB/s
- * @flags: extra flags; not used yet, so callers should always pass 0
+ * @flags: bitwise-OR of virDomainMigrateMaxSpeedFlags
*
* The maximum bandwidth (in MiB/s) that will be used to do migration
* can be specified with the bandwidth parameter. Not all hypervisors
- * will support a bandwidth cap
+ * will support a bandwidth cap. When VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY
+ * is set in @flags, this API sets the maximum bandwidth for the postcopy
+ * phase of the migration.
*
* Returns 0 in case of success, -1 otherwise.
*/
@@ -9077,10 +9079,13 @@ virDomainMigrateSetMaxSpeed(virDomainPtr domain,
* virDomainMigrateGetMaxSpeed:
* @domain: a domain object
* @bandwidth: return value of current migration bandwidth limit in MiB/s
- * @flags: extra flags; not used yet, so callers should always pass 0
+ * @flags: bitwise-OR of virDomainMigrateMaxSpeedFlags
*
* Get the current maximum bandwidth (in MiB/s) that will be used if the
* domain is migrated. Not all hypervisors will support a bandwidth limit.
+ * When VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY is set in @flags, this API
+ * gets the current maximum bandwidth for the postcopy phase of the
+ * migration.
*
* Returns 0 in case of success, -1 otherwise.
*/
--
2.20.1
7:54 a.m.
New subject: [libvirt] [PATCH 5/8] Public API for post-copy migration bandwidth
On Tue, Feb 05, 2019 at 04:23:08PM +0100, Jiri Denemark wrote:
This patch adds a new VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY typed
parameter for virDomainMigrate3 and virDomainMigrateToURI3 for setting
maximum post-copy migration bandwidth.
In case the initial VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY value turns out
to be suboptimal a new VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY flag for
virDomainMigrateSetMaxSpeed and virDomainMigrateGetMaxSpeed may be used
to set/get the maximum post-copy migration bandwidth while migration is
already running.
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
include/libvirt/libvirt-domain.h | 15 +++++++++++++++
src/libvirt-domain.c | 11 ++++++++---
2 files changed, 23 insertions(+), 3 deletions(-)
diff --git a/include/libvirt/libvirt-domain.h b/include/libvirt/libvirt-domain.h
index 0388911ded..d99f9b690b 100644
--- a/include/libvirt/libvirt-domain.h
+++ b/include/libvirt/libvirt-domain.h
@@ -903,6 +903,15 @@ typedef enum {
*/
# define VIR_MIGRATE_PARAM_BANDWIDTH "bandwidth"
+/**
+ * VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY:
+ *
+ * virDomainMigrate* params field: the maximum bandwidth (in MiB/s) that will
I guess granularity < 1 MiB/s is not worth the trouble of creating an
inconsistent API, is it?
+ * be used for post-copy phase of a migration as
VIR_TYPED_PARAM_ULLONG. If set
+ * to 0 or omitted, post-copy migration speed will not be limited.
+ */
+# define VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY "bandwidth.postcopy"
+
/**
* VIR_MIGRATE_PARAM_GRAPHICS_URI:
*
@@ -1062,6 +1071,12 @@ int virDomainMigrateSetCompressionCache(virDomainPtr domain,
unsigned long long cacheSize,
unsigned int flags);
+/* Domain migration speed flags. */
+typedef enum {
+ /* Set or get maximum speed of postcopy migration. */
post-copy is the spelling used for human-readable strings
+ VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY = (1 << 0),
+} virDomainMigrateMaxSpeedFlags;
+
int virDomainMigrateSetMaxSpeed(virDomainPtr domain,
unsigned long bandwidth,
unsigned int flags);
diff --git a/src/libvirt-domain.c b/src/libvirt-domain.c
index 58b4863c8f..7b87b3716a 100644
--- a/src/libvirt-domain.c
+++ b/src/libvirt-domain.c
@@ -9036,11 +9036,13 @@ virDomainMigrateSetCompressionCache(virDomainPtr domain,
* virDomainMigrateSetMaxSpeed:
* @domain: a domain object
* @bandwidth: migration bandwidth limit in MiB/s
- * @flags: extra flags; not used yet, so callers should always pass 0
+ * @flags: bitwise-OR of virDomainMigrateMaxSpeedFlags
*
* The maximum bandwidth (in MiB/s) that will be used to do migration
* can be specified with the bandwidth parameter. Not all hypervisors
- * will support a bandwidth cap
+ * will support a bandwidth cap. When VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY
+ * is set in @flags, this API sets the maximum bandwidth for the postcopy
post-copy
+ * phase of the migration.
*
* Returns 0 in case of success, -1 otherwise.
*/
@@ -9077,10 +9079,13 @@ virDomainMigrateSetMaxSpeed(virDomainPtr domain,
* virDomainMigrateGetMaxSpeed:
* @domain: a domain object
* @bandwidth: return value of current migration bandwidth limit in MiB/s
- * @flags: extra flags; not used yet, so callers should always pass 0
+ * @flags: bitwise-OR of virDomainMigrateMaxSpeedFlags
*
* Get the current maximum bandwidth (in MiB/s) that will be used if the
* domain is migrated. Not all hypervisors will support a bandwidth limit.
+ * When VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY is set in @flags, this API
+ * gets the current maximum bandwidth for the postcopy phase of the
post-copy
+ * migration.
*
Reviewed-by: Ján Tomko <jtomko(a)redhat.com>
Jano
9:23 a.m.
New subject: [libvirt] [PATCH 6/8] qemu: Implement VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY
This typed parameter for virDomainMigrate3 and virDomainMigrateToURI3
APIs may be used for setting maximum post-copy migration bandwidth.
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
src/qemu/qemu_migration.h | 1 +
src/qemu/qemu_migration_params.c | 7 +++++++
src/qemu/qemu_migration_params.h | 1 +
3 files changed, 9 insertions(+)
diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h
index 976a723d21..ca73d3e467 100644
--- a/src/qemu/qemu_migration.h
+++ b/src/qemu/qemu_migration.h
@@ -79,6 +79,7 @@
VIR_MIGRATE_PARAM_PERSIST_XML, VIR_TYPED_PARAM_STRING, \
VIR_MIGRATE_PARAM_AUTO_CONVERGE_INITIAL, VIR_TYPED_PARAM_INT, \
VIR_MIGRATE_PARAM_AUTO_CONVERGE_INCREMENT, VIR_TYPED_PARAM_INT, \
+ VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY, VIR_TYPED_PARAM_ULLONG, \
NULL
diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c
index 117ae0e998..67070b9d08 100644
--- a/src/qemu/qemu_migration_params.c
+++ b/src/qemu/qemu_migration_params.c
@@ -102,6 +102,7 @@ VIR_ENUM_IMPL(qemuMigrationParam, QEMU_MIGRATION_PARAM_LAST,
"downtime-limit",
"block-incremental",
"xbzrle-cache-size",
+ "max-postcopy-bandwidth",
);
typedef struct _qemuMigrationParamsAlwaysOnItem qemuMigrationParamsAlwaysOnItem;
@@ -178,6 +179,11 @@ static const qemuMigrationParamsTPMapItem qemuMigrationParamsTPMap[]
= {
{.typedParam = VIR_MIGRATE_PARAM_COMPRESSION_XBZRLE_CACHE,
.param = QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE,
.party = QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION},
+
+ {.typedParam = VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY,
+ .unit = 1024 * 1024, /* MB/s */
+ .param = QEMU_MIGRATION_PARAM_MAX_POSTCOPY_BANDWIDTH,
+ .party = QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION},
};
static const qemuMigrationParamType qemuMigrationParamTypes[] = {
@@ -192,6 +198,7 @@ static const qemuMigrationParamType qemuMigrationParamTypes[] = {
[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,
+ [QEMU_MIGRATION_PARAM_MAX_POSTCOPY_BANDWIDTH] = QEMU_MIGRATION_PARAM_TYPE_ULL,
};
verify(ARRAY_CARDINALITY(qemuMigrationParamTypes) == QEMU_MIGRATION_PARAM_LAST);
diff --git a/src/qemu/qemu_migration_params.h b/src/qemu/qemu_migration_params.h
index db0745ec28..2460684a00 100644
--- a/src/qemu/qemu_migration_params.h
+++ b/src/qemu/qemu_migration_params.h
@@ -55,6 +55,7 @@ typedef enum {
QEMU_MIGRATION_PARAM_DOWNTIME_LIMIT,
QEMU_MIGRATION_PARAM_BLOCK_INCREMENTAL,
QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE,
+ QEMU_MIGRATION_PARAM_MAX_POSTCOPY_BANDWIDTH,
QEMU_MIGRATION_PARAM_LAST
} qemuMigrationParam;
--
2.20.1
7:55 a.m.
New subject: [libvirt] [PATCH 6/8] qemu: Implement VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY
On Tue, Feb 05, 2019 at 04:23:09PM +0100, Jiri Denemark wrote:
This typed parameter for virDomainMigrate3 and virDomainMigrateToURI3
APIs may be used for setting maximum post-copy migration bandwidth.
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
src/qemu/qemu_migration.h | 1 +
src/qemu/qemu_migration_params.c | 7 +++++++
src/qemu/qemu_migration_params.h | 1 +
3 files changed, 9 insertions(+)
diff --git a/src/qemu/qemu_migration_params.c
b/src/qemu/qemu_migration_params.c
index 117ae0e998..67070b9d08 100644
--- a/src/qemu/qemu_migration_params.c
+++ b/src/qemu/qemu_migration_params.c
@@ -178,6 +179,11 @@ static const qemuMigrationParamsTPMapItem qemuMigrationParamsTPMap[]
= {
{.typedParam = VIR_MIGRATE_PARAM_COMPRESSION_XBZRLE_CACHE,
.param = QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE,
.party = QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION},
+
+ {.typedParam = VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY,
+ .unit = 1024 * 1024, /* MB/s */
MiB/s
+ .param = QEMU_MIGRATION_PARAM_MAX_POSTCOPY_BANDWIDTH,
+ .party = QEMU_MIGRATION_SOURCE | QEMU_MIGRATION_DESTINATION},
};
static const qemuMigrationParamType qemuMigrationParamTypes[] = {
Reviewed-by: Ján Tomko <jtomko(a)redhat.com>
Jano
9:23 a.m.
New subject: [libvirt] [PATCH 7/8] qemu: Implement VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY flag
This flag tells virDomainMigrateSetMaxSpeed and
virDomainMigrateGetMaxSpeed APIs to work on post-copy migration
bandwidth.
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
src/qemu/qemu_driver.c | 91 ++++++++++++++++++++++++++++++++++++------
1 file changed, 78 insertions(+), 13 deletions(-)
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 93ec1dacf4..06a0560a35 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -14275,10 +14275,12 @@ qemuDomainMigrateSetMaxSpeed(virDomainPtr dom,
virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
qemuDomainObjPrivatePtr priv;
- int rc;
+ bool postcopy = !!(flags & VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY);
+ VIR_AUTOPTR(qemuMigrationParams) migParams = NULL;
+ unsigned long long max;
int ret = -1;
- virCheckFlags(0, -1);
+ virCheckFlags(VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY, -1);
if (!(vm = qemuDomObjFromDomain(dom)))
goto cleanup;
@@ -14288,14 +14290,18 @@ qemuDomainMigrateSetMaxSpeed(virDomainPtr dom,
if (virDomainMigrateSetMaxSpeedEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (bandwidth > QEMU_DOMAIN_MIG_BANDWIDTH_MAX) {
+ if (postcopy)
+ max = ULLONG_MAX / 1024 / 1024;
+ else
+ max = QEMU_DOMAIN_MIG_BANDWIDTH_MAX;
+
+ if (bandwidth > max) {
virReportError(VIR_ERR_OVERFLOW,
- _("bandwidth must be less than %llu"),
- QEMU_DOMAIN_MIG_BANDWIDTH_MAX + 1ULL);
+ _("bandwidth must be less than %llu"), max + 1);
goto cleanup;
}
- if (!virDomainObjIsActive(vm)) {
+ if (!postcopy && !virDomainObjIsActive(vm)) {
priv->migMaxBandwidth = bandwidth;
ret = 0;
goto cleanup;
@@ -14308,12 +14314,29 @@ qemuDomainMigrateSetMaxSpeed(virDomainPtr dom,
goto endjob;
VIR_DEBUG("Setting migration bandwidth to %luMbs", bandwidth);
- qemuDomainObjEnterMonitor(driver, vm);
- rc = qemuMonitorSetMigrationSpeed(priv->mon, bandwidth);
- if (qemuDomainObjExitMonitor(driver, vm) < 0 || rc < 0)
- goto endjob;
- priv->migMaxBandwidth = bandwidth;
+ if (postcopy) {
+ if (!(migParams = qemuMigrationParamsNew()))
+ goto endjob;
+
+ if (qemuMigrationParamsSetULL(migParams,
+ QEMU_MIGRATION_PARAM_MAX_POSTCOPY_BANDWIDTH,
+ bandwidth * 1024 * 1024) < 0)
+ goto endjob;
+
+ if (qemuMigrationParamsApply(driver, vm, QEMU_ASYNC_JOB_NONE,
+ migParams) < 0)
+ goto endjob;
+ } else {
+ int rc;
+
+ qemuDomainObjEnterMonitor(driver, vm);
+ rc = qemuMonitorSetMigrationSpeed(priv->mon, bandwidth);
+ if (qemuDomainObjExitMonitor(driver, vm) < 0 || rc < 0)
+ goto endjob;
+
+ priv->migMaxBandwidth = bandwidth;
+ }
ret = 0;
@@ -14330,11 +14353,13 @@ qemuDomainMigrateGetMaxSpeed(virDomainPtr dom,
unsigned long *bandwidth,
unsigned int flags)
{
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
qemuDomainObjPrivatePtr priv;
+ bool postcopy = !!(flags & VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY);
int ret = -1;
- virCheckFlags(0, -1);
+ virCheckFlags(VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY, -1);
if (!(vm = qemuDomObjFromDomain(dom)))
goto cleanup;
@@ -14344,7 +14369,47 @@ qemuDomainMigrateGetMaxSpeed(virDomainPtr dom,
if (virDomainMigrateGetMaxSpeedEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- *bandwidth = priv->migMaxBandwidth;
+ if (postcopy) {
+ VIR_AUTOPTR(qemuMigrationParams) migParams = NULL;
+ unsigned long long bw;
+ int rc = -1;
+
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_QUERY) < 0)
+ goto cleanup;
+
+ if (virDomainObjCheckActive(vm) == 0 &&
+ qemuMigrationParamsFetch(driver, vm, QEMU_ASYNC_JOB_NONE,
+ &migParams) == 0) {
+ rc = qemuMigrationParamsGetULL(migParams,
+ QEMU_MIGRATION_PARAM_MAX_POSTCOPY_BANDWIDTH,
+ &bw);
+
+ /* QEMU reports B/s while we use MiB/s */
+ bw /= 1024 * 1024;
+ }
+
+ qemuDomainObjEndJob(driver, vm);
+
+ if (rc < 0) {
+ goto cleanup;
+ } else if (rc == 1) {
+ virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+ _("querying maximum post-copy migration speed is "
+ "not supported by QEMU binary"));
+ goto cleanup;
+ } if (bw > ULONG_MAX) {
+ virReportError(VIR_ERR_OVERFLOW,
+ _("bandwidth %llu is greater than %lu which is the
"
+ "maximum value supported by this API"),
+ bw, ULONG_MAX);
+ goto cleanup;
+ }
+
+ *bandwidth = bw;
+ } else {
+ *bandwidth = priv->migMaxBandwidth;
+ }
+
ret = 0;
cleanup:
--
2.20.1
8:06 a.m.
New subject: [libvirt] [PATCH 7/8] qemu: Implement VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY flag
On Tue, Feb 05, 2019 at 04:23:10PM +0100, Jiri Denemark wrote:
This flag tells virDomainMigrateSetMaxSpeed and
virDomainMigrateGetMaxSpeed APIs to work on post-copy migration
bandwidth.
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
src/qemu/qemu_driver.c | 91 ++++++++++++++++++++++++++++++++++++------
1 file changed, 78 insertions(+), 13 deletions(-)
@@ -14344,7 +14369,47 @@ qemuDomainMigrateGetMaxSpeed(virDomainPtr
dom,
if (virDomainMigrateGetMaxSpeedEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- *bandwidth = priv->migMaxBandwidth;
+ if (postcopy) {
This whole branch looks like a good candidate for a helper function.
+ VIR_AUTOPTR(qemuMigrationParams) migParams = NULL;
+ unsigned long long bw;
+ int rc = -1;
+
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_QUERY) < 0)
+ goto cleanup;
+
+ if (virDomainObjCheckActive(vm) == 0 &&
+ qemuMigrationParamsFetch(driver, vm, QEMU_ASYNC_JOB_NONE,
+ &migParams) == 0) {
+ rc = qemuMigrationParamsGetULL(migParams,
+ QEMU_MIGRATION_PARAM_MAX_POSTCOPY_BANDWIDTH,
+ &bw);
+
+ /* QEMU reports B/s while we use MiB/s */
+ bw /= 1024 * 1024;
+ }
You coould put an 'endjob' label here.
+
+ qemuDomainObjEndJob(driver, vm);
+
+ if (rc < 0) {
+ goto cleanup;
+ } else if (rc == 1) {
No need for 'else' after goto.
+ virReportError(VIR_ERR_OPERATION_INVALID,
"%s",
+ _("querying maximum post-copy migration speed is "
+ "not supported by QEMU binary"));
+ goto cleanup;
+ } if (bw > ULONG_MAX) {
Missing newline.
Reviewed-by: Ján Tomko <jtomko(a)redhat.com>
Jano
9:11 a.m.
New subject: [libvirt] [PATCH v2 7/8] qemu: Implement VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY flag
This flag tells virDomainMigrateSetMaxSpeed and
virDomainMigrateGetMaxSpeed APIs to work on post-copy migration
bandwidth.
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
Notes:
Version 2:
- if (postcopy) branch from qemuDomainMigrateGetMaxSpeed separated
into a helper function
src/qemu/qemu_driver.c | 110 ++++++++++++++++++++++++++++++++++++-----
1 file changed, 97 insertions(+), 13 deletions(-)
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 0c0ed4fab9..7106f6d553 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -14275,10 +14275,12 @@ qemuDomainMigrateSetMaxSpeed(virDomainPtr dom,
virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
qemuDomainObjPrivatePtr priv;
- int rc;
+ bool postcopy = !!(flags & VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY);
+ VIR_AUTOPTR(qemuMigrationParams) migParams = NULL;
+ unsigned long long max;
int ret = -1;
- virCheckFlags(0, -1);
+ virCheckFlags(VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY, -1);
if (!(vm = qemuDomObjFromDomain(dom)))
goto cleanup;
@@ -14288,14 +14290,18 @@ qemuDomainMigrateSetMaxSpeed(virDomainPtr dom,
if (virDomainMigrateSetMaxSpeedEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (bandwidth > QEMU_DOMAIN_MIG_BANDWIDTH_MAX) {
+ if (postcopy)
+ max = ULLONG_MAX / 1024 / 1024;
+ else
+ max = QEMU_DOMAIN_MIG_BANDWIDTH_MAX;
+
+ if (bandwidth > max) {
virReportError(VIR_ERR_OVERFLOW,
- _("bandwidth must be less than %llu"),
- QEMU_DOMAIN_MIG_BANDWIDTH_MAX + 1ULL);
+ _("bandwidth must be less than %llu"), max + 1);
goto cleanup;
}
- if (!virDomainObjIsActive(vm)) {
+ if (!postcopy && !virDomainObjIsActive(vm)) {
priv->migMaxBandwidth = bandwidth;
ret = 0;
goto cleanup;
@@ -14308,12 +14314,29 @@ qemuDomainMigrateSetMaxSpeed(virDomainPtr dom,
goto endjob;
VIR_DEBUG("Setting migration bandwidth to %luMbs", bandwidth);
- qemuDomainObjEnterMonitor(driver, vm);
- rc = qemuMonitorSetMigrationSpeed(priv->mon, bandwidth);
- if (qemuDomainObjExitMonitor(driver, vm) < 0 || rc < 0)
- goto endjob;
- priv->migMaxBandwidth = bandwidth;
+ if (postcopy) {
+ if (!(migParams = qemuMigrationParamsNew()))
+ goto endjob;
+
+ if (qemuMigrationParamsSetULL(migParams,
+ QEMU_MIGRATION_PARAM_MAX_POSTCOPY_BANDWIDTH,
+ bandwidth * 1024 * 1024) < 0)
+ goto endjob;
+
+ if (qemuMigrationParamsApply(driver, vm, QEMU_ASYNC_JOB_NONE,
+ migParams) < 0)
+ goto endjob;
+ } else {
+ int rc;
+
+ qemuDomainObjEnterMonitor(driver, vm);
+ rc = qemuMonitorSetMigrationSpeed(priv->mon, bandwidth);
+ if (qemuDomainObjExitMonitor(driver, vm) < 0 || rc < 0)
+ goto endjob;
+
+ priv->migMaxBandwidth = bandwidth;
+ }
ret = 0;
@@ -14325,16 +14348,71 @@ qemuDomainMigrateSetMaxSpeed(virDomainPtr dom,
return ret;
}
+
+static int
+qemuDomainMigrationGetPostcopyBandwidth(virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ unsigned long *bandwidth)
+{
+ VIR_AUTOPTR(qemuMigrationParams) migParams = NULL;
+ unsigned long long bw;
+ int rc;
+ int ret = -1;
+
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_QUERY) < 0)
+ return -1;
+
+ if (virDomainObjCheckActive(vm) < 0)
+ goto cleanup;
+
+ if (qemuMigrationParamsFetch(driver, vm, QEMU_ASYNC_JOB_NONE,
+ &migParams) < 0)
+ goto cleanup;
+
+ if ((rc = qemuMigrationParamsGetULL(migParams,
+ QEMU_MIGRATION_PARAM_MAX_POSTCOPY_BANDWIDTH,
+ &bw)) < 0)
+ goto cleanup;
+
+ if (rc == 1) {
+ virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+ _("querying maximum post-copy migration speed is "
+ "not supported by QEMU binary"));
+ goto cleanup;
+ }
+
+ /* QEMU reports B/s while we use MiB/s */
+ bw /= 1024 * 1024;
+
+ if (bw > ULONG_MAX) {
+ virReportError(VIR_ERR_OVERFLOW,
+ _("bandwidth %llu is greater than %lu which is the "
+ "maximum value supported by this API"),
+ bw, ULONG_MAX);
+ goto cleanup;
+ }
+
+ *bandwidth = bw;
+ ret = 0;
+
+ cleanup:
+ qemuDomainObjEndJob(driver, vm);
+ return ret;
+}
+
+
static int
qemuDomainMigrateGetMaxSpeed(virDomainPtr dom,
unsigned long *bandwidth,
unsigned int flags)
{
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
qemuDomainObjPrivatePtr priv;
+ bool postcopy = !!(flags & VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY);
int ret = -1;
- virCheckFlags(0, -1);
+ virCheckFlags(VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY, -1);
if (!(vm = qemuDomObjFromDomain(dom)))
goto cleanup;
@@ -14344,7 +14422,13 @@ qemuDomainMigrateGetMaxSpeed(virDomainPtr dom,
if (virDomainMigrateGetMaxSpeedEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- *bandwidth = priv->migMaxBandwidth;
+ if (postcopy) {
+ if (qemuDomainMigrationGetPostcopyBandwidth(driver, vm, bandwidth) < 0)
+ goto cleanup;
+ } else {
+ *bandwidth = priv->migMaxBandwidth;
+ }
+
ret = 0;
cleanup:
--
2.20.1
9:19 a.m.
New subject: [libvirt] [PATCH v2 7/8] qemu: Implement VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY flag
On Thu, Feb 07, 2019 at 04:11:46PM +0100, Jiri Denemark wrote:
This flag tells virDomainMigrateSetMaxSpeed and
virDomainMigrateGetMaxSpeed APIs to work on post-copy migration
bandwidth.
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
Notes:
Version 2:
- if (postcopy) branch from qemuDomainMigrateGetMaxSpeed separated
into a helper function
src/qemu/qemu_driver.c | 110 ++++++++++++++++++++++++++++++++++++-----
1 file changed, 97 insertions(+), 13 deletions(-)
Reviewed-by: Ján Tomko <jtomko(a)redhat.com>
Jano
6:45 a.m.
New subject: [libvirt] [PATCH v2 7/8] qemu: Implement VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY flag
On 2/7/19 10:11 AM, Jiri Denemark wrote:
This flag tells virDomainMigrateSetMaxSpeed and
virDomainMigrateGetMaxSpeed APIs to work on post-copy migration
bandwidth.
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
Notes:
Version 2:
- if (postcopy) branch from qemuDomainMigrateGetMaxSpeed separated
into a helper function
[...]
+
+static int
+qemuDomainMigrationGetPostcopyBandwidth(virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ unsigned long *bandwidth)
+{
+ VIR_AUTOPTR(qemuMigrationParams) migParams = NULL;
+ unsigned long long bw;
+ int rc;
+ int ret = -1;
+
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_QUERY) < 0)
+ return -1;
+
+ if (virDomainObjCheckActive(vm) < 0)
+ goto cleanup;
+
+ if (qemuMigrationParamsFetch(driver, vm, QEMU_ASYNC_JOB_NONE,
+ &migParams) < 0)
+ goto cleanup;
+
+ if ((rc = qemuMigrationParamsGetULL(migParams,
+ QEMU_MIGRATION_PARAM_MAX_POSTCOPY_BANDWIDTH,
+ &bw)) < 0)
+ goto cleanup;
+
+ if (rc == 1) {
+ virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+ _("querying maximum post-copy migration speed is "
+ "not supported by QEMU binary"));
+ goto cleanup;
+ }
+
+ /* QEMU reports B/s while we use MiB/s */
+ bw /= 1024 * 1024;
+
+ if (bw > ULONG_MAX) {
FWIW: Coverity generates a complaint here:
1) Event result_independent_of_operands: "bw > 18446744073709551615ULL
/* 9223372036854775807L * 2UL + 1UL */" is always false regardless of
the values of its operands. This occurs as the logical operand of "if".
John
+ virReportError(VIR_ERR_OVERFLOW,
+ _("bandwidth %llu is greater than %lu which is the "
+ "maximum value supported by this API"),
+ bw, ULONG_MAX);
+ goto cleanup;
+ }
+
+ *bandwidth = bw;
+ ret = 0;
+
+ cleanup:
+ qemuDomainObjEndJob(driver, vm);
+ return ret;
+}
+
+
[...]
9:23 a.m.
New subject: [libvirt] [PATCH 8/8] virsh: Add support for setting post-copy migration bandwidth
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
tools/virsh-domain.c | 33 +++++++++++++++++++++++++++++++--
tools/virsh.pod | 15 +++++++++++----
2 files changed, 42 insertions(+), 6 deletions(-)
diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c
index 275ac0c318..db0d5d4dcc 100644
--- a/tools/virsh-domain.c
+++ b/tools/virsh-domain.c
@@ -10557,6 +10557,10 @@ static const vshCmdOptDef opts_migrate[] = {
.type = VSH_OT_BOOL,
.help = N_("use TLS for migration")
},
+ {.name = "postcopy-bandwidth",
+ .type = VSH_OT_INT,
+ .help = N_("post-copy migration bandwidth limit in MiB/s")
+ },
{.name = NULL}
};
@@ -10753,6 +10757,15 @@ doMigrate(void *opaque)
goto save_error;
}
+ if ((rv = vshCommandOptULongLong(ctl, cmd, "postcopy-bandwidth",
&ullOpt)) < 0) {
+ goto out;
+ } else if (rv > 0) {
+ if (virTypedParamsAddULLong(¶ms, &nparams, &maxparams,
+ VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY,
+ ullOpt) < 0)
+ goto save_error;
+ }
+
if (vshCommandOptBool(cmd, "live"))
flags |= VIR_MIGRATE_LIVE;
if (vshCommandOptBool(cmd, "p2p"))
@@ -11150,6 +11163,10 @@ static const vshCmdOptDef opts_migrate_setspeed[] = {
.flags = VSH_OFLAG_REQ,
.help = N_("migration bandwidth limit in MiB/s")
},
+ {.name = "postcopy",
+ .type = VSH_OT_BOOL,
+ .help = N_("set postcopy migration bandwidth")
+ },
{.name = NULL}
};
@@ -11158,6 +11175,7 @@ cmdMigrateSetMaxSpeed(vshControl *ctl, const vshCmd *cmd)
{
virDomainPtr dom = NULL;
unsigned long bandwidth = 0;
+ unsigned int flags = 0;
bool ret = false;
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
@@ -11166,7 +11184,10 @@ cmdMigrateSetMaxSpeed(vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptULWrap(ctl, cmd, "bandwidth", &bandwidth) < 0)
goto done;
- if (virDomainMigrateSetMaxSpeed(dom, bandwidth, 0) < 0)
+ if (vshCommandOptBool(cmd, "postcopy"))
+ flags |= VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY;
+
+ if (virDomainMigrateSetMaxSpeed(dom, bandwidth, flags) < 0)
goto done;
ret = true;
@@ -11191,6 +11212,10 @@ static const vshCmdInfo info_migrate_getspeed[] = {
static const vshCmdOptDef opts_migrate_getspeed[] = {
VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_ACTIVE),
+ {.name = "postcopy",
+ .type = VSH_OT_BOOL,
+ .help = N_("get postcopy migration bandwidth")
+ },
{.name = NULL}
};
@@ -11199,12 +11224,16 @@ cmdMigrateGetMaxSpeed(vshControl *ctl, const vshCmd *cmd)
{
virDomainPtr dom = NULL;
unsigned long bandwidth;
+ unsigned int flags = 0;
bool ret = false;
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
return false;
- if (virDomainMigrateGetMaxSpeed(dom, &bandwidth, 0) < 0)
+ if (vshCommandOptBool(cmd, "postcopy"))
+ flags |= VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY;
+
+ if (virDomainMigrateGetMaxSpeed(dom, &bandwidth, flags) < 0)
goto done;
vshPrint(ctl, "%lu\n", bandwidth);
diff --git a/tools/virsh.pod b/tools/virsh.pod
index 59a5900162..67edb57b14 100644
--- a/tools/virsh.pod
+++ b/tools/virsh.pod
@@ -1903,6 +1903,7 @@ I<domain> I<desturi> [I<migrateuri>]
[I<graphicsuri>] [I<listen-address>] [I<dna
[I<--comp-mt-level>] [I<--comp-mt-threads>] [I<--comp-mt-dthreads>]
[I<--comp-xbzrle-cache>] [I<--auto-converge>]
[I<auto-converge-initial>]
[I<auto-converge-increment>] [I<--persistent-xml> B<file>]
[I<--tls>]
+[I<--postcopy-bandwidth> B<bandwidth>]
Migrate domain to another host. Add I<--live> for live migration; <--p2p>
for peer-2-peer migration; I<--direct> for direct migration; or
I<--tunnelled>
@@ -1933,6 +1934,8 @@ Once migration is running, the user may switch to post-copy using
the
B<migrate-postcopy> command sent from another virsh instance or use
I<--postcopy-after-precopy> along with I<--postcopy> to let libvirt
automatically switch to post-copy after the first pass of pre-copy is finished.
+The maximum bandwidth consumed during the post-copy phase may be limited using
+I<--postcopy-bandwidth>.
I<--auto-converge> forces convergence during live migration. The initial
guest CPU throttling rate can be set with I<auto-converge-initial>. If the
@@ -2098,17 +2101,21 @@ is supposed to be used while the domain is being live-migrated as
a reaction
to migration progress and increasing number of compression cache misses
obtained from domjobinfo.
-=item B<migrate-setspeed> I<domain> I<bandwidth>
+=item B<migrate-setspeed> I<domain> I<bandwidth> [I<--postcopy>]
Set the maximum migration bandwidth (in MiB/s) for a domain which is being
migrated to another host. I<bandwidth> is interpreted as an unsigned long
long value. Specifying a negative value results in an essentially unlimited
value being provided to the hypervisor. The hypervisor can choose whether to
-reject the value or convert it to the maximum value allowed.
+reject the value or convert it to the maximum value allowed. If the
+I<--postcopy> option is specified, the command will set the maximum bandwidth
+allowed during a post-copy migration phase.
-=item B<migrate-getspeed> I<domain>
+=item B<migrate-getspeed> I<domain> [I<--postcopy>]
-Get the maximum migration bandwidth (in MiB/s) for a domain.
+Get the maximum migration bandwidth (in MiB/s) for a domain. If the
+I<--postcopy> option is specified, the command will get the maximum bandwidth
+allowed during a post-copy migration phase.
=item B<migrate-postcopy> I<domain>
--
2.20.1
8:12 a.m.
New subject: [libvirt] [PATCH 8/8] virsh: Add support for setting post-copy migration bandwidth
On Tue, Feb 05, 2019 at 04:23:11PM +0100, Jiri Denemark wrote:
Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com>
---
tools/virsh-domain.c | 33 +++++++++++++++++++++++++++++++--
tools/virsh.pod | 15 +++++++++++----
2 files changed, 42 insertions(+), 6 deletions(-)
diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c
index 275ac0c318..db0d5d4dcc 100644
--- a/tools/virsh-domain.c
+++ b/tools/virsh-domain.c
@@ -11150,6 +11163,10 @@ static const vshCmdOptDef opts_migrate_setspeed[] = {
.flags = VSH_OFLAG_REQ,
.help = N_("migration bandwidth limit in MiB/s")
},
+ {.name = "postcopy",
+ .type = VSH_OT_BOOL,
+ .help = N_("set postcopy migration bandwidth")
post-copy
+ },
{.name = NULL}
};
@@ -11191,6 +11212,10 @@ static const vshCmdInfo info_migrate_getspeed[] = {
static const vshCmdOptDef opts_migrate_getspeed[] = {
VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_ACTIVE),
+ {.name = "postcopy",
+ .type = VSH_OT_BOOL,
+ .help = N_("get postcopy migration bandwidth")
post-copy
+ },
{.name = NULL}
};
Reviewed-by: Ján Tomko <jtomko(a)redhat.com>
Jano
2113
days inactive
2117
days old
19 comments
3 participants
participants (3)
-
Jiri Denemark -
John Ferlan -
Ján Tomko