--- docs/apibuild.py | 2 +- src/esx/esx_driver.c | 24 ++++----- src/libvirt_private.syms | 2 +- src/libxl/libxl_driver.c | 12 ++--- src/lxc/lxc_driver.c | 40 +++++++-------- src/nodeinfo.c | 16 +++--- src/openvz/openvz_driver.c | 16 +++--- src/qemu/qemu_driver.c | 120 ++++++++++++++++++++++----------------------- src/test/test_driver.c | 8 +-- src/util/virtypedparam.c | 2 +- src/util/virtypedparam.h | 4 +- src/xen/xen_hypervisor.c | 12 ++--- 12 files changed, 129 insertions(+), 129 deletions(-) diff --git a/docs/apibuild.py b/docs/apibuild.py index d17b593..686a234 100755 --- a/docs/apibuild.py +++ b/docs/apibuild.py @@ -64,7 +64,7 @@ ignored_functions = { "virDomainMigrateConfirm3": "private function for migration", "virDomainMigratePrepareTunnel3": "private function for tunnelled migration", "DllMain": "specific function for Win32", - "virTypedParameterArrayValidate": "internal function in virtypedparam.c", + "virTypedParamsValidate": "internal function in virtypedparam.c", "virTypedParameterAssign": "internal function in virtypedparam.c", "virTypedParameterAssignFromStr": "internal function in virtypedparam.c", } diff --git a/src/esx/esx_driver.c b/src/esx/esx_driver.c index d5e9c2c..a5df810 100644 --- a/src/esx/esx_driver.c +++ b/src/esx/esx_driver.c @@ -3710,14 +3710,14 @@ esxDomainSetSchedulerParametersFlags(virDomainPtr domain, int i; virCheckFlags(0, -1); - if (virTypedParameterArrayValidate(params, nparams, - VIR_DOMAIN_SCHEDULER_RESERVATION, - VIR_TYPED_PARAM_LLONG, - VIR_DOMAIN_SCHEDULER_LIMIT, - VIR_TYPED_PARAM_LLONG, - VIR_DOMAIN_SCHEDULER_SHARES, - VIR_TYPED_PARAM_INT, - NULL) < 0) + if (virTypedParamsValidate(params, nparams, + VIR_DOMAIN_SCHEDULER_RESERVATION, + VIR_TYPED_PARAM_LLONG, + VIR_DOMAIN_SCHEDULER_LIMIT, + VIR_TYPED_PARAM_LLONG, + VIR_DOMAIN_SCHEDULER_SHARES, + VIR_TYPED_PARAM_INT, + NULL) < 0) return -1; if (esxVI_EnsureSession(priv->primary) < 0) { @@ -4874,10 +4874,10 @@ esxDomainSetMemoryParameters(virDomainPtr domain, virTypedParameterPtr params, int i; virCheckFlags(0, -1); - if (virTypedParameterArrayValidate(params, nparams, - VIR_DOMAIN_MEMORY_MIN_GUARANTEE, - VIR_TYPED_PARAM_ULLONG, - NULL) < 0) + if (virTypedParamsValidate(params, nparams, + VIR_DOMAIN_MEMORY_MIN_GUARANTEE, + VIR_TYPED_PARAM_ULLONG, + NULL) < 0) return -1; if (esxVI_EnsureSession(priv->primary) < 0) { diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index b449293..f61fe55 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -1897,9 +1897,9 @@ virTPMCreateCancelPath; # util/virtypedparam.h -virTypedParameterArrayValidate; virTypedParameterAssign; virTypedParameterAssignFromStr; +virTypedParamsValidate; # util/viruri.h diff --git a/src/libxl/libxl_driver.c b/src/libxl/libxl_driver.c index 9a7cb20..481a8b1 100644 --- a/src/libxl/libxl_driver.c +++ b/src/libxl/libxl_driver.c @@ -4172,12 +4172,12 @@ libxlDomainSetSchedulerParametersFlags(virDomainPtr dom, int ret = -1; virCheckFlags(0, -1); - if (virTypedParameterArrayValidate(params, nparams, - VIR_DOMAIN_SCHEDULER_WEIGHT, - VIR_TYPED_PARAM_UINT, - VIR_DOMAIN_SCHEDULER_CAP, - VIR_TYPED_PARAM_UINT, - NULL) < 0) + if (virTypedParamsValidate(params, nparams, + VIR_DOMAIN_SCHEDULER_WEIGHT, + VIR_TYPED_PARAM_UINT, + VIR_DOMAIN_SCHEDULER_CAP, + VIR_TYPED_PARAM_UINT, + NULL) < 0) return -1; libxlDriverLock(driver); diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c index 3d6baf5..218715b 100644 --- a/src/lxc/lxc_driver.c +++ b/src/lxc/lxc_driver.c @@ -752,14 +752,14 @@ lxcDomainSetMemoryParameters(virDomainPtr dom, virLXCDomainObjPrivatePtr priv; virCheckFlags(0, -1); - if (virTypedParameterArrayValidate(params, nparams, - VIR_DOMAIN_MEMORY_HARD_LIMIT, - VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_MEMORY_SOFT_LIMIT, - VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT, - VIR_TYPED_PARAM_ULLONG, - NULL) < 0) + if (virTypedParamsValidate(params, nparams, + VIR_DOMAIN_MEMORY_HARD_LIMIT, + VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_MEMORY_SOFT_LIMIT, + VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT, + VIR_TYPED_PARAM_ULLONG, + NULL) < 0) return -1; lxcDriverLock(driver); @@ -1732,14 +1732,14 @@ lxcDomainSetSchedulerParametersFlags(virDomainPtr dom, virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG, -1); - if (virTypedParameterArrayValidate(params, nparams, - VIR_DOMAIN_SCHEDULER_CPU_SHARES, - VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_SCHEDULER_VCPU_PERIOD, - VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_SCHEDULER_VCPU_QUOTA, - VIR_TYPED_PARAM_LLONG, - NULL) < 0) + if (virTypedParamsValidate(params, nparams, + VIR_DOMAIN_SCHEDULER_CPU_SHARES, + VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_SCHEDULER_VCPU_PERIOD, + VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_SCHEDULER_VCPU_QUOTA, + VIR_TYPED_PARAM_LLONG, + NULL) < 0) return -1; lxcDriverLock(driver); @@ -1979,10 +1979,10 @@ lxcDomainSetBlkioParameters(virDomainPtr dom, virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG, -1); - if (virTypedParameterArrayValidate(params, nparams, - VIR_DOMAIN_BLKIO_WEIGHT, - VIR_TYPED_PARAM_UINT, - NULL) < 0) + if (virTypedParamsValidate(params, nparams, + VIR_DOMAIN_BLKIO_WEIGHT, + VIR_TYPED_PARAM_UINT, + NULL) < 0) return -1; lxcDriverLock(driver); diff --git a/src/nodeinfo.c b/src/nodeinfo.c index d8375ab..a50f892 100644 --- a/src/nodeinfo.c +++ b/src/nodeinfo.c @@ -1196,14 +1196,14 @@ nodeSetMemoryParameters(virTypedParameterPtr params ATTRIBUTE_UNUSED, int i; int rc; - if (virTypedParameterArrayValidate(params, nparams, - VIR_NODE_MEMORY_SHARED_PAGES_TO_SCAN, - VIR_TYPED_PARAM_UINT, - VIR_NODE_MEMORY_SHARED_SLEEP_MILLISECS, - VIR_TYPED_PARAM_UINT, - VIR_NODE_MEMORY_SHARED_MERGE_ACROSS_NODES, - VIR_TYPED_PARAM_UINT, - NULL) < 0) + if (virTypedParamsValidate(params, nparams, + VIR_NODE_MEMORY_SHARED_PAGES_TO_SCAN, + VIR_TYPED_PARAM_UINT, + VIR_NODE_MEMORY_SHARED_SLEEP_MILLISECS, + VIR_TYPED_PARAM_UINT, + VIR_NODE_MEMORY_SHARED_MERGE_ACROSS_NODES, + VIR_TYPED_PARAM_UINT, + NULL) < 0) return -1; if (!nodeMemoryParametersIsAllSupported(params, nparams)) diff --git a/src/openvz/openvz_driver.c b/src/openvz/openvz_driver.c index d8abe9c..d04e3ba 100644 --- a/src/openvz/openvz_driver.c +++ b/src/openvz/openvz_driver.c @@ -1871,14 +1871,14 @@ openvzDomainSetMemoryParameters(virDomainPtr domain, goto cleanup; virCheckFlags(0, -1); - if (virTypedParameterArrayValidate(params, nparams, - VIR_DOMAIN_MEMORY_HARD_LIMIT, - VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_MEMORY_SOFT_LIMIT, - VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_MEMORY_MIN_GUARANTEE, - VIR_TYPED_PARAM_ULLONG, - NULL) < 0) + if (virTypedParamsValidate(params, nparams, + VIR_DOMAIN_MEMORY_HARD_LIMIT, + VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_MEMORY_SOFT_LIMIT, + VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_MEMORY_MIN_GUARANTEE, + VIR_TYPED_PARAM_ULLONG, + NULL) < 0) return -1; for (i = 0; i < nparams; i++) { diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 9b738e0..a682e36 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -7231,12 +7231,12 @@ qemuDomainSetBlkioParameters(virDomainPtr dom, virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG, -1); - if (virTypedParameterArrayValidate(params, nparams, - VIR_DOMAIN_BLKIO_WEIGHT, - VIR_TYPED_PARAM_UINT, - VIR_DOMAIN_BLKIO_DEVICE_WEIGHT, - VIR_TYPED_PARAM_STRING, - NULL) < 0) + if (virTypedParamsValidate(params, nparams, + VIR_DOMAIN_BLKIO_WEIGHT, + VIR_TYPED_PARAM_UINT, + VIR_DOMAIN_BLKIO_DEVICE_WEIGHT, + VIR_TYPED_PARAM_STRING, + NULL) < 0) return -1; if (!(vm = qemuDomObjFromDomain(dom))) @@ -7558,14 +7558,14 @@ qemuDomainSetMemoryParameters(virDomainPtr dom, virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG, -1); - if (virTypedParameterArrayValidate(params, nparams, - VIR_DOMAIN_MEMORY_HARD_LIMIT, - VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_MEMORY_SOFT_LIMIT, - VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT, - VIR_TYPED_PARAM_ULLONG, - NULL) < 0) + if (virTypedParamsValidate(params, nparams, + VIR_DOMAIN_MEMORY_HARD_LIMIT, + VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_MEMORY_SOFT_LIMIT, + VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT, + VIR_TYPED_PARAM_ULLONG, + NULL) < 0) return -1; @@ -7836,12 +7836,12 @@ qemuDomainSetNumaParameters(virDomainPtr dom, virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG, -1); - if (virTypedParameterArrayValidate(params, nparams, - VIR_DOMAIN_NUMA_MODE, - VIR_TYPED_PARAM_INT, - VIR_DOMAIN_NUMA_NODESET, - VIR_TYPED_PARAM_STRING, - NULL) < 0) + if (virTypedParamsValidate(params, nparams, + VIR_DOMAIN_NUMA_MODE, + VIR_TYPED_PARAM_INT, + VIR_DOMAIN_NUMA_NODESET, + VIR_TYPED_PARAM_STRING, + NULL) < 0) return -1; if (!(vm = qemuDomObjFromDomain(dom))) @@ -8170,18 +8170,18 @@ qemuDomainSetSchedulerParametersFlags(virDomainPtr dom, virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG, -1); - if (virTypedParameterArrayValidate(params, nparams, - VIR_DOMAIN_SCHEDULER_CPU_SHARES, - VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_SCHEDULER_VCPU_PERIOD, - VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_SCHEDULER_VCPU_QUOTA, - VIR_TYPED_PARAM_LLONG, - VIR_DOMAIN_SCHEDULER_EMULATOR_PERIOD, - VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_SCHEDULER_EMULATOR_QUOTA, - VIR_TYPED_PARAM_LLONG, - NULL) < 0) + if (virTypedParamsValidate(params, nparams, + VIR_DOMAIN_SCHEDULER_CPU_SHARES, + VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_SCHEDULER_VCPU_PERIOD, + VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_SCHEDULER_VCPU_QUOTA, + VIR_TYPED_PARAM_LLONG, + VIR_DOMAIN_SCHEDULER_EMULATOR_PERIOD, + VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_SCHEDULER_EMULATOR_QUOTA, + VIR_TYPED_PARAM_LLONG, + NULL) < 0) return -1; if (!(vm = qemuDomObjFromDomain(dom))) @@ -8964,20 +8964,20 @@ qemuDomainSetInterfaceParameters(virDomainPtr dom, virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG, -1); - if (virTypedParameterArrayValidate(params, nparams, - VIR_DOMAIN_BANDWIDTH_IN_AVERAGE, - VIR_TYPED_PARAM_UINT, - VIR_DOMAIN_BANDWIDTH_IN_PEAK, - VIR_TYPED_PARAM_UINT, - VIR_DOMAIN_BANDWIDTH_IN_BURST, - VIR_TYPED_PARAM_UINT, - VIR_DOMAIN_BANDWIDTH_OUT_AVERAGE, - VIR_TYPED_PARAM_UINT, - VIR_DOMAIN_BANDWIDTH_OUT_PEAK, - VIR_TYPED_PARAM_UINT, - VIR_DOMAIN_BANDWIDTH_OUT_BURST, - VIR_TYPED_PARAM_UINT, - NULL) < 0) + if (virTypedParamsValidate(params, nparams, + VIR_DOMAIN_BANDWIDTH_IN_AVERAGE, + VIR_TYPED_PARAM_UINT, + VIR_DOMAIN_BANDWIDTH_IN_PEAK, + VIR_TYPED_PARAM_UINT, + VIR_DOMAIN_BANDWIDTH_IN_BURST, + VIR_TYPED_PARAM_UINT, + VIR_DOMAIN_BANDWIDTH_OUT_AVERAGE, + VIR_TYPED_PARAM_UINT, + VIR_DOMAIN_BANDWIDTH_OUT_PEAK, + VIR_TYPED_PARAM_UINT, + VIR_DOMAIN_BANDWIDTH_OUT_BURST, + VIR_TYPED_PARAM_UINT, + NULL) < 0) return -1; if (!(vm = qemuDomObjFromDomain(dom))) @@ -14050,20 +14050,20 @@ qemuDomainSetBlockIoTune(virDomainPtr dom, virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG, -1); - if (virTypedParameterArrayValidate(params, nparams, - VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_BYTES_SEC, - VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_BLOCK_IOTUNE_READ_BYTES_SEC, - VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_BLOCK_IOTUNE_WRITE_BYTES_SEC, - VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_IOPS_SEC, - VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_BLOCK_IOTUNE_READ_IOPS_SEC, - VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_BLOCK_IOTUNE_WRITE_IOPS_SEC, - VIR_TYPED_PARAM_ULLONG, - NULL) < 0) + if (virTypedParamsValidate(params, nparams, + VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_BYTES_SEC, + VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_BLOCK_IOTUNE_READ_BYTES_SEC, + VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_BLOCK_IOTUNE_WRITE_BYTES_SEC, + VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_IOPS_SEC, + VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_BLOCK_IOTUNE_READ_IOPS_SEC, + VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_BLOCK_IOTUNE_WRITE_IOPS_SEC, + VIR_TYPED_PARAM_ULLONG, + NULL) < 0) return -1; memset(&info, 0, sizeof(info)); diff --git a/src/test/test_driver.c b/src/test/test_driver.c index f1cdd92..30c2194 100644 --- a/src/test/test_driver.c +++ b/src/test/test_driver.c @@ -2784,10 +2784,10 @@ testDomainSetSchedulerParametersFlags(virDomainPtr domain, int ret = -1, i; virCheckFlags(0, -1); - if (virTypedParameterArrayValidate(params, nparams, - VIR_DOMAIN_SCHEDULER_WEIGHT, - VIR_TYPED_PARAM_UINT, - NULL) < 0) + if (virTypedParamsValidate(params, nparams, + VIR_DOMAIN_SCHEDULER_WEIGHT, + VIR_TYPED_PARAM_UINT, + NULL) < 0) return -1; testDriverLock(privconn); diff --git a/src/util/virtypedparam.c b/src/util/virtypedparam.c index bf374a6..8b2211f 100644 --- a/src/util/virtypedparam.c +++ b/src/util/virtypedparam.c @@ -48,7 +48,7 @@ VIR_ENUM_IMPL(virTypedParameter, VIR_TYPED_PARAM_LAST, * parameters. Return 0 on success, -1 on failure with error message * already issued. */ int -virTypedParameterArrayValidate(virTypedParameterPtr params, int nparams, ...) +virTypedParamsValidate(virTypedParameterPtr params, int nparams, ...) { va_list ap; int ret = -1; diff --git a/src/util/virtypedparam.h b/src/util/virtypedparam.h index c777a55..8f6bd1b 100644 --- a/src/util/virtypedparam.h +++ b/src/util/virtypedparam.h @@ -25,8 +25,8 @@ # include "internal.h" -int virTypedParameterArrayValidate(virTypedParameterPtr params, int nparams, - /* const char *name, int type ... */ ...) +int virTypedParamsValidate(virTypedParameterPtr params, int nparams, + /* const char *name, int type ... */ ...) ATTRIBUTE_SENTINEL ATTRIBUTE_RETURN_CHECK; int virTypedParameterAssign(virTypedParameterPtr param, const char *name, diff --git a/src/xen/xen_hypervisor.c b/src/xen/xen_hypervisor.c index cfc8139..9d9c3ee 100644 --- a/src/xen/xen_hypervisor.c +++ b/src/xen/xen_hypervisor.c @@ -1277,12 +1277,12 @@ xenHypervisorSetSchedulerParameters(virConnectPtr conn, return 0; } - if (virTypedParameterArrayValidate(params, nparams, - VIR_DOMAIN_SCHEDULER_WEIGHT, - VIR_TYPED_PARAM_UINT, - VIR_DOMAIN_SCHEDULER_CAP, - VIR_TYPED_PARAM_UINT, - NULL) < 0) + if (virTypedParamsValidate(params, nparams, + VIR_DOMAIN_SCHEDULER_WEIGHT, + VIR_TYPED_PARAM_UINT, + VIR_DOMAIN_SCHEDULER_CAP, + VIR_TYPED_PARAM_UINT, + NULL) < 0) return -1; /* -- 1.8.2.1

This API is useful for checking whether only a specific subset of supported typed parameters were passed. --- docs/apibuild.py | 1 + src/libvirt_private.syms | 1 + src/util/virtypedparam.c | 26 ++++++++++++++++++++++++++ src/util/virtypedparam.h | 5 +++++ 4 files changed, 33 insertions(+) diff --git a/docs/apibuild.py b/docs/apibuild.py index 686a234..c816197 100755 --- a/docs/apibuild.py +++ b/docs/apibuild.py @@ -67,6 +67,7 @@ ignored_functions = { "virTypedParamsValidate": "internal function in virtypedparam.c", "virTypedParameterAssign": "internal function in virtypedparam.c", "virTypedParameterAssignFromStr": "internal function in virtypedparam.c", + "virTypedParamsCheck": "internal function in virtypedparam.c", } ignored_macros = { diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index f61fe55..ae9f356 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -1899,6 +1899,7 @@ virTPMCreateCancelPath; # util/virtypedparam.h virTypedParameterAssign; virTypedParameterAssignFromStr; +virTypedParamsCheck; virTypedParamsValidate; diff --git a/src/util/virtypedparam.c b/src/util/virtypedparam.c index eef9e30..825148b 100644 --- a/src/util/virtypedparam.c +++ b/src/util/virtypedparam.c @@ -109,6 +109,32 @@ cleanup: } +/* Check if params contains only specified parameter names. Return true if + * only specified names are present in params, false if params contains any + * unspecified parameter name. */ +bool +virTypedParamsCheck(virTypedParameterPtr params, + int nparams, + const char **names, + int nnames) +{ + int i, j; + + for (i = 0; i < nparams; i++) { + bool found = false; + for (j = 0; j < nnames; j++) { + if (STREQ(params[i].field, names[j])) { + found = true; + break; + } + } + if (!found) + return false; + } + + return true; +} + /* Assign name, type, and the appropriately typed arg to param; in the * case of a string, the caller is assumed to have malloc'd a string, * or can pass NULL to have this function malloc an empty string. diff --git a/src/util/virtypedparam.h b/src/util/virtypedparam.h index 8f6bd1b..b0f8522 100644 --- a/src/util/virtypedparam.h +++ b/src/util/virtypedparam.h @@ -29,6 +29,11 @@ int virTypedParamsValidate(virTypedParameterPtr params, int nparams, /* const char *name, int type ... */ ...) ATTRIBUTE_SENTINEL ATTRIBUTE_RETURN_CHECK; +bool virTypedParamsCheck(virTypedParameterPtr params, + int nparams, + const char **names, + int nnames); + int virTypedParameterAssign(virTypedParameterPtr param, const char *name, int type, /* TYPE arg */ ...) ATTRIBUTE_RETURN_CHECK; -- 1.8.2.1

--- docs/apibuild.py | 1 + src/libvirt_private.syms | 1 + src/util/virtypedparam.c | 34 ++++++++++++++++++++++++++++++++++ src/util/virtypedparam.h | 4 ++++ 4 files changed, 40 insertions(+) diff --git a/docs/apibuild.py b/docs/apibuild.py index e0996bf..aca2370 100755 --- a/docs/apibuild.py +++ b/docs/apibuild.py @@ -69,6 +69,7 @@ ignored_functions = { "virTypedParameterAssignFromStr": "internal function in virtypedparam.c", "virTypedParameterToString": "internal function in virtypedparam.c", "virTypedParamsCheck": "internal function in virtypedparam.c", + "virTypedParamsCopy": "internal function in virtypedparam.c", } ignored_macros = { diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 0e0c3bc..fa1041c 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -1903,6 +1903,7 @@ virTypedParameterToString; virTypedParameterTypeFromString; virTypedParameterTypeToString; virTypedParamsCheck; +virTypedParamsCopy; virTypedParamsReplaceString; virTypedParamsValidate; diff --git a/src/util/virtypedparam.c b/src/util/virtypedparam.c index 8b18a5a..cf0fde5 100644 --- a/src/util/virtypedparam.c +++ b/src/util/virtypedparam.c @@ -382,6 +382,40 @@ error: } +int +virTypedParamsCopy(virTypedParameterPtr *dst, + virTypedParameterPtr src, + int nparams) +{ + int i; + + *dst = NULL; + if (!src || nparams <= 0) + return 0; + + if (VIR_ALLOC_N(*dst, nparams) < 0) { + virReportOOMError(); + return -1; + } + + for (i = 0; i < nparams; i++) { + ignore_value(virStrcpyStatic((*dst)[i].field, src[i].field)); + (*dst)[i].type = src[i].type; + if (src[i].type == VIR_TYPED_PARAM_STRING) { + if (VIR_STRDUP((*dst)[i].value.s, src[i].value.s) < 0) { + virTypedParamsFree(*dst, i - 1); + *dst = NULL; + return -1; + } + } else { + (*dst)[i].value = src[i].value; + } + } + + return 0; +} + + /* The following APIs are public and their signature may never change. */ /** diff --git a/src/util/virtypedparam.h b/src/util/virtypedparam.h index ca062c0..728cae3 100644 --- a/src/util/virtypedparam.h +++ b/src/util/virtypedparam.h @@ -50,6 +50,10 @@ int virTypedParamsReplaceString(virTypedParameterPtr *params, const char *name, const char *value); +int virTypedParamsCopy(virTypedParameterPtr *dst, + virTypedParameterPtr src, + int nparams); + char *virTypedParameterToString(virTypedParameterPtr param); VIR_ENUM_DECL(virTypedParameter) -- 1.8.2.1

--- src/qemu/qemu_driver.c | 350 +++++++++++++++++++++++++++++++++++++++------- src/qemu/qemu_migration.c | 162 +++++++++++++++------ src/qemu/qemu_migration.h | 9 ++ 3 files changed, 431 insertions(+), 90 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index a682e36..c040287 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -1086,6 +1086,7 @@ qemuConnectSupportsFeature(virConnectPtr conn ATTRIBUTE_UNUSED, int feature) case VIR_DRV_FEATURE_TYPED_PARAM_STRING: case VIR_DRV_FEATURE_XML_MIGRATABLE: case VIR_DRV_FEATURE_MIGRATION_OFFLINE: + case VIR_DRV_FEATURE_MIGRATION_PARAMS: return 1; default: return 0; @@ -9887,21 +9888,18 @@ cleanup: *******************************************************************/ static char * -qemuDomainMigrateBegin3(virDomainPtr domain, - const char *xmlin, - char **cookieout, - int *cookieoutlen, - unsigned long flags, - const char *dname, - unsigned long resource ATTRIBUTE_UNUSED) +qemuDomainMigrateBegin3Internal(virDomainPtr domain, + const char *xmlin, + const char *dname, + char **cookieout, + int *cookieoutlen, + unsigned long flags) { virQEMUDriverPtr driver = domain->conn->privateData; virDomainObjPtr vm; char *xml = NULL; enum qemuDomainAsyncJob asyncJob; - virCheckFlags(QEMU_MIGRATION_FLAGS, NULL); - if (!(vm = qemuDomObjFromDomain(domain))) return NULL; @@ -9969,26 +9967,66 @@ endjob: goto cleanup; } +static char * +qemuDomainMigrateBegin3(virDomainPtr domain, + const char *xmlin, + char **cookieout, + int *cookieoutlen, + unsigned long flags, + const char *dname, + unsigned long resource ATTRIBUTE_UNUSED) +{ + virCheckFlags(QEMU_MIGRATION_FLAGS, NULL); + + return qemuDomainMigrateBegin3Internal(domain, xmlin, dname, + cookieout, cookieoutlen, flags); +} + +static char * +qemuDomainMigrateBegin3Params(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + char **cookieout, + int *cookieoutlen, + unsigned int flags) +{ + const char *xmlin = NULL; + const char *dname = NULL; + + virCheckFlags(QEMU_MIGRATION_FLAGS, NULL); + if (virTypedParamsValidate(params, nparams, QEMU_MIGRATION_PARAMETERS) < 0) + return NULL; + + if (virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_DEST_XML, + &xmlin) < 0 || + virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_DEST_NAME, + &dname) < 0) + return NULL; + + return qemuDomainMigrateBegin3Internal(domain, xmlin, dname, + cookieout, cookieoutlen, flags); +} + + static int -qemuDomainMigratePrepare3(virConnectPtr dconn, - const char *cookiein, - int cookieinlen, - char **cookieout, - int *cookieoutlen, - const char *uri_in, - char **uri_out, - unsigned long flags, - const char *dname, - unsigned long resource ATTRIBUTE_UNUSED, - const char *dom_xml) +qemuDomainMigratePrepare3Internal(virConnectPtr dconn, + const char *dom_xml, + const char *dname, + const char *uri_in, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + char **uri_out, + unsigned long flags) { virQEMUDriverPtr driver = dconn->privateData; virCapsPtr caps = NULL; virDomainDefPtr def = NULL; int ret = -1; - virCheckFlags(QEMU_MIGRATION_FLAGS, -1); - *uri_out = NULL; if (flags & VIR_MIGRATE_TUNNELLED) { @@ -10032,26 +10070,78 @@ cleanup: return ret; } +static int +qemuDomainMigratePrepare3(virConnectPtr dconn, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + const char *uri_in, + char **uri_out, + unsigned long flags, + const char *dname, + unsigned long resource ATTRIBUTE_UNUSED, + const char *dom_xml) +{ + virCheckFlags(QEMU_MIGRATION_FLAGS, -1); + + return qemuDomainMigratePrepare3Internal(dconn, dom_xml, dname, uri_in, + cookiein, cookieinlen, cookieout, + cookieoutlen, uri_out, flags); +} static int -qemuDomainMigratePrepareTunnel3(virConnectPtr dconn, - virStreamPtr st, +qemuDomainMigratePrepare3Params(virConnectPtr dconn, + virTypedParameterPtr params, + int nparams, const char *cookiein, int cookieinlen, char **cookieout, int *cookieoutlen, - unsigned long flags, - const char *dname, - unsigned long resource ATTRIBUTE_UNUSED, - const char *dom_xml) + char **uri_out, + unsigned int flags) +{ + const char *dom_xml = NULL; + const char *dname = NULL; + const char *uri_in = NULL; + + virCheckFlags(QEMU_MIGRATION_FLAGS, -1); + if (virTypedParamsValidate(params, nparams, QEMU_MIGRATION_PARAMETERS) < 0) + return -1; + + if (virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_DEST_XML, + &dom_xml) < 0 || + virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_DEST_NAME, + &dname) < 0 || + virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_URI, + &uri_in) < 0) + return -1; + + return qemuDomainMigratePrepare3Internal(dconn, dom_xml, dname, uri_in, + cookiein, cookieinlen, cookieout, + cookieoutlen, uri_out, flags); +} + + +static int +qemuDomainMigratePrepareTunnel3Internal(virConnectPtr dconn, + virStreamPtr st, + const char *dom_xml, + const char *dname, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned long flags) { virQEMUDriverPtr driver = dconn->privateData; virCapsPtr caps = NULL; virDomainDefPtr def = NULL; int ret = -1; - virCheckFlags(QEMU_MIGRATION_FLAGS, -1); - if (!dom_xml) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("no domain XML passed")); @@ -10093,6 +10183,58 @@ cleanup: return ret; } +static int +qemuDomainMigratePrepareTunnel3(virConnectPtr dconn, + virStreamPtr st, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned long flags, + const char *dname, + unsigned long resource ATTRIBUTE_UNUSED, + const char *dom_xml) +{ + virCheckFlags(QEMU_MIGRATION_FLAGS, -1); + + return qemuDomainMigratePrepareTunnel3Internal(dconn, st, dom_xml, dname, + cookiein, cookieinlen, + cookieout, cookieoutlen, + flags); +} + +static int +qemuDomainMigratePrepareTunnel3Params(virConnectPtr dconn, + virStreamPtr st, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned int flags) +{ + const char *dom_xml = NULL; + const char *dname = NULL; + + virCheckFlags(QEMU_MIGRATION_FLAGS, -1); + if (virTypedParamsValidate(params, nparams, QEMU_MIGRATION_PARAMETERS) < 0) + return -1; + + if (virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_DEST_XML, + &dom_xml) < 0 || + virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_DEST_NAME, + &dname) < 0) + return -1; + + return qemuDomainMigratePrepareTunnel3Internal(dconn, st, dom_xml, dname, + cookiein, cookieinlen, + cookieout, cookieoutlen, + flags); +} + static int qemuDomainMigratePerform3(virDomainPtr dom, @@ -10121,6 +10263,51 @@ qemuDomainMigratePerform3(virDomainPtr dom, flags, dname, resource, true); } +static int +qemuDomainMigratePerform3Params(virDomainPtr dom, + const char *dconnuri, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned int flags) +{ + virQEMUDriverPtr driver = dom->conn->privateData; + virDomainObjPtr vm; + const char *dom_xml = NULL; + const char *dname = NULL; + const char *uri = NULL; + unsigned long long bandwidth = 0; + + virCheckFlags(QEMU_MIGRATION_FLAGS, -1); + if (virTypedParamsValidate(params, nparams, QEMU_MIGRATION_PARAMETERS) < 0) + return -1; + + if (virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_DEST_XML, + &dom_xml) < 0 || + virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_DEST_NAME, + &dname) < 0 || + virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_URI, + &uri) < 0 || + virTypedParamsGetULLong(params, nparams, + VIR_MIGRATE_PARAM_BANDWIDTH, + &bandwidth) < 0) + return -1; + + if (!(vm = qemuDomObjFromDomain(dom))) + return -1; + + return qemuMigrationPerform(driver, dom->conn, vm, dom_xml, + dconnuri, uri, cookiein, cookieinlen, + cookieout, cookieoutlen, + flags, dname, bandwidth, true); +} + static virDomainPtr qemuDomainMigrateFinish3(virConnectPtr dconn, @@ -10136,32 +10323,66 @@ qemuDomainMigrateFinish3(virConnectPtr dconn, { virQEMUDriverPtr driver = dconn->privateData; virDomainObjPtr vm; - virDomainPtr dom = NULL; virCheckFlags(QEMU_MIGRATION_FLAGS, NULL); - vm = virDomainObjListFindByName(driver->domains, dname); - if (!vm) { + if (!(vm = virDomainObjListFindByName(driver->domains, dname))) { virReportError(VIR_ERR_NO_DOMAIN, _("no domain with matching name '%s'"), dname); - goto cleanup; + return NULL; } - dom = qemuMigrationFinish(driver, dconn, vm, - cookiein, cookieinlen, - cookieout, cookieoutlen, - flags, cancelled, true); + return qemuMigrationFinish(driver, dconn, vm, + cookiein, cookieinlen, + cookieout, cookieoutlen, + flags, cancelled, true); +} -cleanup: - return dom; +static virDomainPtr +qemuDomainMigrateFinish3Params(virConnectPtr dconn, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned int flags, + int cancelled) +{ + virQEMUDriverPtr driver = dconn->privateData; + virDomainObjPtr vm; + const char *dname = NULL; + + virCheckFlags(QEMU_MIGRATION_FLAGS, NULL); + if (virTypedParamsValidate(params, nparams, QEMU_MIGRATION_PARAMETERS) < 0) + return NULL; + + if (virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_DEST_NAME, + &dname) < 0) + return NULL; + + if (!dname || + !(vm = virDomainObjListFindByName(driver->domains, dname))) { + virReportError(VIR_ERR_NO_DOMAIN, + _("no domain with matching name '%s'"), + NULLSTR(dname)); + return NULL; + } + + return qemuMigrationFinish(driver, dconn, vm, + cookiein, cookieinlen, + cookieout, cookieoutlen, + flags, cancelled, true); } + static int -qemuDomainMigrateConfirm3(virDomainPtr domain, - const char *cookiein, - int cookieinlen, - unsigned long flags, - int cancelled) +qemuDomainMigrateConfirm3Internal(virDomainPtr domain, + const char *cookiein, + int cookieinlen, + unsigned long flags, + int cancelled) { virQEMUDriverPtr driver = domain->conn->privateData; virDomainObjPtr vm; @@ -10169,8 +10390,6 @@ qemuDomainMigrateConfirm3(virDomainPtr domain, enum qemuMigrationJobPhase phase; virQEMUDriverConfigPtr cfg = NULL; - virCheckFlags(QEMU_MIGRATION_FLAGS, -1); - if (!(vm = qemuDomObjFromDomain(domain))) return -1; @@ -10209,6 +10428,37 @@ cleanup: return ret; } +static int +qemuDomainMigrateConfirm3(virDomainPtr domain, + const char *cookiein, + int cookieinlen, + unsigned long flags, + int cancelled) +{ + virCheckFlags(QEMU_MIGRATION_FLAGS, -1); + + return qemuDomainMigrateConfirm3Internal(domain, cookiein, cookieinlen, + flags, cancelled); +} + +static int +qemuDomainMigrateConfirm3Params(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + unsigned int flags, + int cancelled) +{ + virCheckFlags(QEMU_MIGRATION_FLAGS, -1); + + if (virTypedParamsValidate(params, nparams, QEMU_MIGRATION_PARAMETERS) < 0) + return -1; + + return qemuDomainMigrateConfirm3Internal(domain, cookiein, cookieinlen, + flags, cancelled); +} + static int qemuNodeDeviceGetPciInfo(virNodeDevicePtr dev, @@ -15378,6 +15628,12 @@ static virDriver qemuDriver = { .nodeGetCPUMap = qemuNodeGetCPUMap, /* 1.0.0 */ .domainFSTrim = qemuDomainFSTrim, /* 1.0.1 */ .domainOpenChannel = qemuDomainOpenChannel, /* 1.0.2 */ + .domainMigrateBegin3Params = qemuDomainMigrateBegin3Params, /* 1.0.7 */ + .domainMigratePrepare3Params = qemuDomainMigratePrepare3Params, /* 1.0.7 */ + .domainMigratePrepareTunnel3Params = qemuDomainMigratePrepareTunnel3Params, /* 1.0.7 */ + .domainMigratePerform3Params = qemuDomainMigratePerform3Params, /* 1.0.7 */ + .domainMigrateFinish3Params = qemuDomainMigrateFinish3Params, /* 1.0.7 */ + .domainMigrateConfirm3Params = qemuDomainMigrateConfirm3Params, /* 1.0.7 */ }; diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 8de38fe..6243d75 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -55,6 +55,7 @@ #include "viruri.h" #include "virhook.h" #include "virstring.h" +#include "virtypedparam.h" #define VIR_FROM_THIS VIR_FROM_QEMU @@ -3306,16 +3307,18 @@ cleanup: * from libvirt.c, but running in source libvirtd context, * instead of client app context & also adding in tunnel * handling */ -static int doPeer2PeerMigrate3(virQEMUDriverPtr driver, - virConnectPtr sconn, - virConnectPtr dconn, - virDomainObjPtr vm, - const char *xmlin, - const char *dconnuri, - const char *uri, - unsigned long flags, - const char *dname, - unsigned long resource) +static int +doPeer2PeerMigrate3(virQEMUDriverPtr driver, + virConnectPtr sconn, + virConnectPtr dconn, + const char *dconnuri, + virDomainObjPtr vm, + const char *xmlin, + const char *dname, + const char *uri, + unsigned long long bandwidth, + bool useParams, + unsigned long flags) { virDomainPtr ddomain = NULL; char *uri_out = NULL; @@ -3326,15 +3329,18 @@ static int doPeer2PeerMigrate3(virQEMUDriverPtr driver, int cookieoutlen = 0; int ret = -1; virErrorPtr orig_err = NULL; - bool cancelled; + bool cancelled = true; virStreamPtr st = NULL; unsigned int destflags = flags & ~VIR_MIGRATE_ABORT_ON_ERROR; - VIR_DEBUG("driver=%p, sconn=%p, dconn=%p, vm=%p, xmlin=%s, " - "dconnuri=%s, uri=%s, flags=%lx, dname=%s, resource=%lu", - driver, sconn, dconn, vm, NULLSTR(xmlin), - NULLSTR(dconnuri), NULLSTR(uri), flags, - NULLSTR(dname), resource); + virTypedParameterPtr params = NULL; + int nparams = 0; + int maxparams = 0; + + VIR_DEBUG("driver=%p, sconn=%p, dconn=%p, dconnuri=%s, vm=%p, xmlin=%s, " + "dname=%s, uri=%s, bandwidth=%llu, useParams=%d, flags=%lx", + driver, sconn, dconn, NULLSTR(dconnuri), vm, NULLSTR(xmlin), + NULLSTR(dname), NULLSTR(uri), bandwidth, useParams, flags); /* Unlike the virDomainMigrateVersion3 counterpart, we don't need * to worry about auto-setting the VIR_MIGRATE_CHANGE_PROTECTION @@ -3346,6 +3352,28 @@ static int doPeer2PeerMigrate3(virQEMUDriverPtr driver, if (!dom_xml) goto cleanup; + if (useParams) { + if (virTypedParamsAddString(¶ms, &nparams, &maxparams, + VIR_MIGRATE_PARAM_DEST_XML, dom_xml) < 0) + goto cleanup; + + if (dname && + virTypedParamsAddString(¶ms, &nparams, &maxparams, + VIR_MIGRATE_PARAM_DEST_NAME, dname) < 0) + goto cleanup; + + if (uri && + virTypedParamsAddString(¶ms, &nparams, &maxparams, + VIR_MIGRATE_PARAM_URI, uri) < 0) + goto cleanup; + + if (bandwidth && + virTypedParamsAddULLong(¶ms, &nparams, &maxparams, + VIR_MIGRATE_PARAM_BANDWIDTH, + bandwidth) < 0) + goto cleanup; + } + if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) flags |= VIR_MIGRATE_PAUSED; @@ -3359,16 +3387,27 @@ static int doPeer2PeerMigrate3(virQEMUDriverPtr driver, goto cleanup; qemuDomainObjEnterRemote(vm); - ret = dconn->driver->domainMigratePrepareTunnel3 - (dconn, st, cookiein, cookieinlen, - &cookieout, &cookieoutlen, - destflags, dname, resource, dom_xml); + if (useParams) { + ret = dconn->driver->domainMigratePrepareTunnel3Params + (dconn, st, params, nparams, cookiein, cookieinlen, + &cookieout, &cookieoutlen, destflags); + } else { + ret = dconn->driver->domainMigratePrepareTunnel3 + (dconn, st, cookiein, cookieinlen, &cookieout, &cookieoutlen, + destflags, dname, bandwidth, dom_xml); + } qemuDomainObjExitRemote(vm); } else { qemuDomainObjEnterRemote(vm); - ret = dconn->driver->domainMigratePrepare3 - (dconn, cookiein, cookieinlen, &cookieout, &cookieoutlen, - uri, &uri_out, destflags, dname, resource, dom_xml); + if (useParams) { + ret = dconn->driver->domainMigratePrepare3Params + (dconn, params, nparams, cookiein, cookieinlen, + &cookieout, &cookieoutlen, &uri_out, destflags); + } else { + ret = dconn->driver->domainMigratePrepare3 + (dconn, cookiein, cookieinlen, &cookieout, &cookieoutlen, + uri, &uri_out, destflags, dname, bandwidth, dom_xml); + } qemuDomainObjExitRemote(vm); } VIR_FREE(dom_xml); @@ -3383,11 +3422,15 @@ static int doPeer2PeerMigrate3(virQEMUDriverPtr driver, goto finish; } - if (!(flags & VIR_MIGRATE_TUNNELLED) && - (uri_out == NULL)) { + if (uri_out) { + uri = uri_out; + if (useParams && + virTypedParamsReplaceString(¶ms, &nparams, + VIR_MIGRATE_PARAM_URI, uri_out) < 0) + goto finish; + } else if (!uri && !(flags & VIR_MIGRATE_TUNNELLED)) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("domainMigratePrepare3 did not set uri")); - cancelled = true; goto finish; } @@ -3396,23 +3439,24 @@ static int doPeer2PeerMigrate3(virQEMUDriverPtr driver, * running, but in paused state until the destination can * confirm migration completion. */ - VIR_DEBUG("Perform3 %p uri=%s uri_out=%s", sconn, uri, uri_out); + VIR_DEBUG("Perform3 %p uri=%s", sconn, NULLSTR(uri)); qemuMigrationJobSetPhase(driver, vm, QEMU_MIGRATION_PHASE_PERFORM3); VIR_FREE(cookiein); cookiein = cookieout; cookieinlen = cookieoutlen; cookieout = NULL; cookieoutlen = 0; - if (flags & VIR_MIGRATE_TUNNELLED) + if (flags & VIR_MIGRATE_TUNNELLED) { ret = doTunnelMigrate(driver, vm, st, cookiein, cookieinlen, &cookieout, &cookieoutlen, - flags, resource, dconn); - else - ret = doNativeMigrate(driver, vm, uri_out, + flags, bandwidth, dconn); + } else { + ret = doNativeMigrate(driver, vm, uri, cookiein, cookieinlen, &cookieout, &cookieoutlen, - flags, resource, dconn); + flags, bandwidth, dconn); + } /* Perform failed. Make sure Finish doesn't overwrite the error */ if (ret < 0) { @@ -3440,12 +3484,29 @@ finish: cookieinlen = cookieoutlen; cookieout = NULL; cookieoutlen = 0; - dname = dname ? dname : vm->def->name; - qemuDomainObjEnterRemote(vm); - ddomain = dconn->driver->domainMigrateFinish3 - (dconn, dname, cookiein, cookieinlen, &cookieout, &cookieoutlen, - dconnuri, uri_out ? uri_out : uri, destflags, cancelled); - qemuDomainObjExitRemote(vm); + + if (useParams) { + if (virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_DEST_NAME, NULL) <= 0 && + virTypedParamsReplaceString(¶ms, &nparams, + VIR_MIGRATE_PARAM_DEST_NAME, + vm->def->name) < 0) { + ddomain = NULL; + } else { + qemuDomainObjEnterRemote(vm); + ddomain = dconn->driver->domainMigrateFinish3Params + (dconn, params, nparams, cookiein, cookieinlen, + &cookieout, &cookieoutlen, destflags, cancelled); + qemuDomainObjExitRemote(vm); + } + } else { + dname = dname ? dname : vm->def->name; + qemuDomainObjEnterRemote(vm); + ddomain = dconn->driver->domainMigrateFinish3 + (dconn, dname, cookiein, cookieinlen, &cookieout, &cookieoutlen, + dconnuri, uri, destflags, cancelled); + qemuDomainObjExitRemote(vm); + } /* If ddomain is NULL, then we were unable to start * the guest on the target, and must restart on the @@ -3501,7 +3562,7 @@ finish: VIR_FREE(uri_out); VIR_FREE(cookiein); VIR_FREE(cookieout); - + virTypedParamsFree(params, nparams); return ret; } @@ -3523,6 +3584,7 @@ static int doPeer2PeerMigrate(virQEMUDriverPtr driver, virErrorPtr orig_err = NULL; bool offline = false; virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver); + bool useParams; VIR_DEBUG("driver=%p, sconn=%p, vm=%p, xmlin=%s, dconnuri=%s, " "uri=%s, flags=%lx, dname=%s, resource=%lu", @@ -3557,6 +3619,8 @@ static int doPeer2PeerMigrate(virQEMUDriverPtr driver, */ *v3proto = VIR_DRV_SUPPORTS_FEATURE(dconn->driver, dconn, VIR_DRV_FEATURE_MIGRATION_V3); + useParams = VIR_DRV_SUPPORTS_FEATURE(dconn->driver, dconn, + VIR_DRV_FEATURE_MIGRATION_PARAMS); if (flags & VIR_MIGRATE_OFFLINE) offline = VIR_DRV_SUPPORTS_FEATURE(dconn->driver, dconn, VIR_DRV_FEATURE_MIGRATION_OFFLINE); @@ -3568,6 +3632,17 @@ static int doPeer2PeerMigrate(virQEMUDriverPtr driver, goto cleanup; } + /* Only xmlin, dname, uri, and bandwidth parameters can be used with + * old-style APIs. */ +#if 0 + if (!useParams && /* any new parameter */) { + virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("Migration APIs with extensible parameters are not " + "supported but extended parameters were passed")); + goto cleanup; + } +#endif + if (flags & VIR_MIGRATE_OFFLINE && !offline) { virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", _("offline migration is not supported by " @@ -3589,12 +3664,13 @@ static int doPeer2PeerMigrate(virQEMUDriverPtr driver, * Therefore it is safe to clear the bit here. */ flags &= ~VIR_MIGRATE_CHANGE_PROTECTION; - if (*v3proto) - ret = doPeer2PeerMigrate3(driver, sconn, dconn, vm, xmlin, - dconnuri, uri, flags, dname, resource); - else + if (*v3proto) { + ret = doPeer2PeerMigrate3(driver, sconn, dconn, dconnuri, vm, xmlin, + dname, uri, resource, useParams, flags); + } else { ret = doPeer2PeerMigrate2(driver, sconn, dconn, vm, dconnuri, flags, dname, resource); + } cleanup: orig_err = virSaveLastError(); diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h index 5b21ca2..e44cf3b 100644 --- a/src/qemu/qemu_migration.h +++ b/src/qemu/qemu_migration.h @@ -41,6 +41,15 @@ VIR_MIGRATE_COMPRESSED | \ VIR_MIGRATE_ABORT_ON_ERROR) +/* All supported migration parameters and their types. */ +# define QEMU_MIGRATION_PARAMETERS \ + VIR_MIGRATE_PARAM_URI, VIR_TYPED_PARAM_STRING, \ + VIR_MIGRATE_PARAM_DEST_NAME, VIR_TYPED_PARAM_STRING, \ + VIR_MIGRATE_PARAM_DEST_XML, VIR_TYPED_PARAM_STRING, \ + VIR_MIGRATE_PARAM_BANDWIDTH, VIR_TYPED_PARAM_ULLONG, \ + NULL + + enum qemuMigrationJobPhase { QEMU_MIGRATION_PHASE_NONE = 0, QEMU_MIGRATION_PHASE_PERFORM2, -- 1.8.2.1

--- src/qemu/qemu_driver.c | 99 +++++++---------------------------------------- src/qemu/qemu_migration.c | 98 +++++++++++++++++++++++++++++++++++++++++----- src/qemu/qemu_migration.h | 1 + 3 files changed, 105 insertions(+), 93 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index c040287..14397f5 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -9888,86 +9888,6 @@ cleanup: *******************************************************************/ static char * -qemuDomainMigrateBegin3Internal(virDomainPtr domain, - const char *xmlin, - const char *dname, - char **cookieout, - int *cookieoutlen, - unsigned long flags) -{ - virQEMUDriverPtr driver = domain->conn->privateData; - virDomainObjPtr vm; - char *xml = NULL; - enum qemuDomainAsyncJob asyncJob; - - if (!(vm = qemuDomObjFromDomain(domain))) - return NULL; - - if ((flags & VIR_MIGRATE_CHANGE_PROTECTION)) { - if (qemuMigrationJobStart(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) - goto cleanup; - asyncJob = QEMU_ASYNC_JOB_MIGRATION_OUT; - } else { - if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0) - goto cleanup; - asyncJob = QEMU_ASYNC_JOB_NONE; - } - - if (!virDomainObjIsActive(vm) && !(flags & VIR_MIGRATE_OFFLINE)) { - virReportError(VIR_ERR_OPERATION_INVALID, - "%s", _("domain is not running")); - goto endjob; - } - - /* Check if there is any ejected media. - * We don't want to require them on the destination. - */ - if (!(flags & VIR_MIGRATE_OFFLINE) && - qemuDomainCheckEjectableMedia(driver, vm, asyncJob) < 0) - goto endjob; - - if (!(xml = qemuMigrationBegin(driver, vm, xmlin, dname, - cookieout, cookieoutlen, - flags))) - goto endjob; - - if ((flags & VIR_MIGRATE_CHANGE_PROTECTION)) { - /* We keep the job active across API calls until the confirm() call. - * This prevents any other APIs being invoked while migration is taking - * place. - */ - if (virQEMUCloseCallbacksSet(driver->closeCallbacks, vm, domain->conn, - qemuMigrationCleanup) < 0) - goto endjob; - if (qemuMigrationJobContinue(vm) == 0) { - vm = NULL; - virReportError(VIR_ERR_OPERATION_FAILED, - "%s", _("domain disappeared")); - VIR_FREE(xml); - if (cookieout) - VIR_FREE(*cookieout); - } - } else { - goto endjob; - } - -cleanup: - if (vm) - virObjectUnlock(vm); - return xml; - -endjob: - if ((flags & VIR_MIGRATE_CHANGE_PROTECTION)) { - if (qemuMigrationJobFinish(driver, vm) == 0) - vm = NULL; - } else { - if (qemuDomainObjEndJob(driver, vm) == 0) - vm = NULL; - } - goto cleanup; -} - -static char * qemuDomainMigrateBegin3(virDomainPtr domain, const char *xmlin, char **cookieout, @@ -9976,10 +9896,16 @@ qemuDomainMigrateBegin3(virDomainPtr domain, const char *dname, unsigned long resource ATTRIBUTE_UNUSED) { + virDomainObjPtr vm; + virCheckFlags(QEMU_MIGRATION_FLAGS, NULL); - return qemuDomainMigrateBegin3Internal(domain, xmlin, dname, - cookieout, cookieoutlen, flags); + if (!(vm = qemuDomObjFromDomain(domain))) + return NULL; + + return qemuMigrationBegin(domain->conn->privateData, + domain->conn, vm, xmlin, dname, + cookieout, cookieoutlen, flags); } static char * @@ -9992,6 +9918,7 @@ qemuDomainMigrateBegin3Params(virDomainPtr domain, { const char *xmlin = NULL; const char *dname = NULL; + virDomainObjPtr vm; virCheckFlags(QEMU_MIGRATION_FLAGS, NULL); if (virTypedParamsValidate(params, nparams, QEMU_MIGRATION_PARAMETERS) < 0) @@ -10005,8 +9932,12 @@ qemuDomainMigrateBegin3Params(virDomainPtr domain, &dname) < 0) return NULL; - return qemuDomainMigrateBegin3Internal(domain, xmlin, dname, - cookieout, cookieoutlen, flags); + if (!(vm = qemuDomObjFromDomain(domain))) + return NULL; + + return qemuMigrationBegin(domain->conn->privateData, + domain->conn, vm, xmlin, dname, + cookieout, cookieoutlen, flags); } diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 6243d75..c0b721a 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -39,6 +39,7 @@ #include "qemu_capabilities.h" #include "qemu_command.h" #include "qemu_cgroup.h" +#include "qemu_hotplug.h" #include "domain_audit.h" #include "virlog.h" @@ -1924,14 +1925,16 @@ cleanup: return vm; } + /* The caller is supposed to lock the vm and start a migration job. */ -char *qemuMigrationBegin(virQEMUDriverPtr driver, - virDomainObjPtr vm, - const char *xmlin, - const char *dname, - char **cookieout, - int *cookieoutlen, - unsigned long flags) +static char * +qemuMigrationBeginPhase(virQEMUDriverPtr driver, + virDomainObjPtr vm, + const char *xmlin, + const char *dname, + char **cookieout, + int *cookieoutlen, + unsigned long flags) { char *rv = NULL; qemuMigrationCookiePtr mig = NULL; @@ -2025,6 +2028,83 @@ cleanup: return rv; } +char * +qemuMigrationBegin(virQEMUDriverPtr driver, + virConnectPtr conn, + virDomainObjPtr vm, + const char *xmlin, + const char *dname, + char **cookieout, + int *cookieoutlen, + unsigned long flags) +{ + char *xml = NULL; + enum qemuDomainAsyncJob asyncJob; + + if ((flags & VIR_MIGRATE_CHANGE_PROTECTION)) { + if (qemuMigrationJobStart(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) + goto cleanup; + asyncJob = QEMU_ASYNC_JOB_MIGRATION_OUT; + } else { + if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0) + goto cleanup; + asyncJob = QEMU_ASYNC_JOB_NONE; + } + + if (!virDomainObjIsActive(vm) && !(flags & VIR_MIGRATE_OFFLINE)) { + virReportError(VIR_ERR_OPERATION_INVALID, + "%s", _("domain is not running")); + goto endjob; + } + + /* Check if there is any ejected media. + * We don't want to require them on the destination. + */ + if (!(flags & VIR_MIGRATE_OFFLINE) && + qemuDomainCheckEjectableMedia(driver, vm, asyncJob) < 0) + goto endjob; + + if (!(xml = qemuMigrationBeginPhase(driver, vm, xmlin, dname, + cookieout, cookieoutlen, + flags))) + goto endjob; + + if ((flags & VIR_MIGRATE_CHANGE_PROTECTION)) { + /* We keep the job active across API calls until the confirm() call. + * This prevents any other APIs being invoked while migration is taking + * place. + */ + if (virQEMUCloseCallbacksSet(driver->closeCallbacks, vm, conn, + qemuMigrationCleanup) < 0) + goto endjob; + if (qemuMigrationJobContinue(vm) == 0) { + vm = NULL; + virReportError(VIR_ERR_OPERATION_FAILED, + "%s", _("domain disappeared")); + VIR_FREE(xml); + if (cookieout) + VIR_FREE(*cookieout); + } + } else { + goto endjob; + } + +cleanup: + if (vm) + virObjectUnlock(vm); + return xml; + +endjob: + if ((flags & VIR_MIGRATE_CHANGE_PROTECTION)) { + if (qemuMigrationJobFinish(driver, vm) == 0) + vm = NULL; + } else { + if (qemuDomainObjEndJob(driver, vm) == 0) + vm = NULL; + } + goto cleanup; +} + /* Prepare is the first step, and it runs on the destination host. */ @@ -3347,8 +3427,8 @@ doPeer2PeerMigrate3(virQEMUDriverPtr driver, * bit here, because we are already running inside the context of * a single job. */ - dom_xml = qemuMigrationBegin(driver, vm, xmlin, dname, - &cookieout, &cookieoutlen, flags); + dom_xml = qemuMigrationBeginPhase(driver, vm, xmlin, dname, + &cookieout, &cookieoutlen, flags); if (!dom_xml) goto cleanup; diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h index e44cf3b..ef7307e 100644 --- a/src/qemu/qemu_migration.h +++ b/src/qemu/qemu_migration.h @@ -94,6 +94,7 @@ virDomainObjPtr qemuMigrationCleanup(virQEMUDriverPtr driver, virConnectPtr conn); char *qemuMigrationBegin(virQEMUDriverPtr driver, + virConnectPtr conn, virDomainObjPtr vm, const char *xmlin, const char *dname, -- 1.8.2.1

--- src/qemu/qemu_driver.c | 69 +++----------- src/qemu/qemu_migration.c | 225 ++++++++++++++++++++++++++++------------------ src/qemu/qemu_migration.h | 2 +- 3 files changed, 152 insertions(+), 144 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 80ec379..29210a5 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -10164,67 +10164,21 @@ qemuDomainMigrateFinish3Params(virConnectPtr dconn, static int -qemuDomainMigrateConfirm3Internal(virDomainPtr domain, - const char *cookiein, - int cookieinlen, - unsigned long flags, - int cancelled) -{ - virQEMUDriverPtr driver = domain->conn->privateData; - virDomainObjPtr vm; - int ret = -1; - enum qemuMigrationJobPhase phase; - virQEMUDriverConfigPtr cfg = NULL; - - if (!(vm = qemuDomObjFromDomain(domain))) - return -1; - - cfg = virQEMUDriverGetConfig(driver); - - if (!qemuMigrationJobIsActive(vm, QEMU_ASYNC_JOB_MIGRATION_OUT)) - goto cleanup; - - if (cancelled) - phase = QEMU_MIGRATION_PHASE_CONFIRM3_CANCELLED; - else - phase = QEMU_MIGRATION_PHASE_CONFIRM3; - - qemuMigrationJobStartPhase(driver, vm, phase); - virQEMUCloseCallbacksUnset(driver->closeCallbacks, vm, - qemuMigrationCleanup); - - ret = qemuMigrationConfirm(driver, domain->conn, vm, - cookiein, cookieinlen, - flags, cancelled); - - if (qemuMigrationJobFinish(driver, vm) == 0) { - vm = NULL; - } else if (!virDomainObjIsActive(vm) && - (!vm->persistent || (flags & VIR_MIGRATE_UNDEFINE_SOURCE))) { - if (flags & VIR_MIGRATE_UNDEFINE_SOURCE) - virDomainDeleteConfig(cfg->configDir, cfg->autostartDir, vm); - qemuDomainRemoveInactive(driver, vm); - vm = NULL; - } - -cleanup: - if (vm) - virObjectUnlock(vm); - virObjectUnref(cfg); - return ret; -} - -static int qemuDomainMigrateConfirm3(virDomainPtr domain, const char *cookiein, int cookieinlen, unsigned long flags, int cancelled) { + virDomainObjPtr vm; + virCheckFlags(QEMU_MIGRATION_FLAGS, -1); - return qemuDomainMigrateConfirm3Internal(domain, cookiein, cookieinlen, - flags, cancelled); + if (!(vm = qemuDomObjFromDomain(domain))) + return -1; + + return qemuMigrationConfirm(domain->conn->privateData, domain->conn, + vm, cookiein, cookieinlen, flags, cancelled); } static int @@ -10236,13 +10190,18 @@ qemuDomainMigrateConfirm3Params(virDomainPtr domain, unsigned int flags, int cancelled) { + virDomainObjPtr vm; + virCheckFlags(QEMU_MIGRATION_FLAGS, -1); if (virTypedParamsValidate(params, nparams, QEMU_MIGRATION_PARAMETERS) < 0) return -1; - return qemuDomainMigrateConfirm3Internal(domain, cookiein, cookieinlen, - flags, cancelled); + if (!(vm = qemuDomObjFromDomain(domain))) + return -1; + + return qemuMigrationConfirm(domain->conn->privateData, domain->conn, + vm, cookiein, cookieinlen, flags, cancelled); } diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 7559625..a63af70 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2647,6 +2647,140 @@ cleanup: } +static int +qemuMigrationConfirmPhase(virQEMUDriverPtr driver, + virConnectPtr conn, + virDomainObjPtr vm, + const char *cookiein, + int cookieinlen, + unsigned int flags, + int retcode) +{ + qemuMigrationCookiePtr mig; + virDomainEventPtr event = NULL; + int rv = -1; + virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver); + + VIR_DEBUG("driver=%p, conn=%p, vm=%p, cookiein=%s, cookieinlen=%d, " + "flags=%x, retcode=%d", + driver, conn, vm, NULLSTR(cookiein), cookieinlen, + flags, retcode); + + virCheckFlags(QEMU_MIGRATION_FLAGS, -1); + + qemuMigrationJobSetPhase(driver, vm, + retcode == 0 + ? QEMU_MIGRATION_PHASE_CONFIRM3 + : QEMU_MIGRATION_PHASE_CONFIRM3_CANCELLED); + + if (!(mig = qemuMigrationEatCookie(driver, vm, cookiein, cookieinlen, 0))) + goto cleanup; + + if (flags & VIR_MIGRATE_OFFLINE) + goto done; + + /* Did the migration go as planned? If yes, kill off the + * domain object, but if no, resume CPUs + */ + if (retcode == 0) { + /* If guest uses SPICE and supports seamless migration we have to hold + * up domain shutdown until SPICE server transfers its data */ + qemuMigrationWaitForSpice(driver, vm); + + qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_MIGRATED, + VIR_QEMU_PROCESS_STOP_MIGRATED); + virDomainAuditStop(vm, "migrated"); + + event = virDomainEventNewFromObj(vm, + VIR_DOMAIN_EVENT_STOPPED, + VIR_DOMAIN_EVENT_STOPPED_MIGRATED); + } else { + + /* cancel any outstanding NBD jobs */ + qemuMigrationCancelDriveMirror(mig, driver, vm); + + /* run 'cont' on the destination, which allows migration on qemu + * >= 0.10.6 to work properly. This isn't strictly necessary on + * older qemu's, but it also doesn't hurt anything there + */ + if (qemuProcessStartCPUs(driver, vm, conn, + VIR_DOMAIN_RUNNING_MIGRATED, + QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) { + if (virGetLastError() == NULL) + virReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("resume operation failed")); + goto cleanup; + } + + event = virDomainEventNewFromObj(vm, + VIR_DOMAIN_EVENT_RESUMED, + VIR_DOMAIN_EVENT_RESUMED_MIGRATED); + if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0) { + VIR_WARN("Failed to save status on vm %s", vm->def->name); + goto cleanup; + } + } + +done: + qemuMigrationCookieFree(mig); + rv = 0; + +cleanup: + if (event) + qemuDomainEventQueue(driver, event); + virObjectUnref(cfg); + return rv; +} + +int +qemuMigrationConfirm(virQEMUDriverPtr driver, + virConnectPtr conn, + virDomainObjPtr vm, + const char *cookiein, + int cookieinlen, + unsigned int flags, + int cancelled) +{ + int ret = -1; + enum qemuMigrationJobPhase phase; + virQEMUDriverConfigPtr cfg = NULL; + + cfg = virQEMUDriverGetConfig(driver); + + if (!qemuMigrationJobIsActive(vm, QEMU_ASYNC_JOB_MIGRATION_OUT)) + goto cleanup; + + if (cancelled) + phase = QEMU_MIGRATION_PHASE_CONFIRM3_CANCELLED; + else + phase = QEMU_MIGRATION_PHASE_CONFIRM3; + + qemuMigrationJobStartPhase(driver, vm, phase); + virQEMUCloseCallbacksUnset(driver->closeCallbacks, vm, + qemuMigrationCleanup); + + ret = qemuMigrationConfirmPhase(driver, conn, vm, + cookiein, cookieinlen, + flags, cancelled); + + if (qemuMigrationJobFinish(driver, vm) == 0) { + vm = NULL; + } else if (!virDomainObjIsActive(vm) && + (!vm->persistent || (flags & VIR_MIGRATE_UNDEFINE_SOURCE))) { + if (flags & VIR_MIGRATE_UNDEFINE_SOURCE) + virDomainDeleteConfig(cfg->configDir, cfg->autostartDir, vm); + qemuDomainRemoveInactive(driver, vm); + vm = NULL; + } + +cleanup: + if (vm) + virObjectUnlock(vm); + virObjectUnref(cfg); + return ret; +} + + enum qemuMigrationDestinationType { MIGRATION_DEST_HOST, MIGRATION_DEST_CONNECT_HOST, @@ -3680,9 +3814,9 @@ finish: cookieinlen = cookieoutlen; cookieout = NULL; cookieoutlen = 0; - ret = qemuMigrationConfirm(driver, sconn, vm, - cookiein, cookieinlen, - flags, cancelled); + ret = qemuMigrationConfirmPhase(driver, sconn, vm, + cookiein, cookieinlen, + flags, cancelled); /* If Confirm3 returns -1, there's nothing more we can * do, but fortunately worst case is that there is a * domain left in 'paused' state on source. @@ -4365,91 +4499,6 @@ cleanup: } -int qemuMigrationConfirm(virQEMUDriverPtr driver, - virConnectPtr conn, - virDomainObjPtr vm, - const char *cookiein, - int cookieinlen, - unsigned int flags, - int retcode) -{ - qemuMigrationCookiePtr mig; - virDomainEventPtr event = NULL; - int rv = -1; - virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver); - - VIR_DEBUG("driver=%p, conn=%p, vm=%p, cookiein=%s, cookieinlen=%d, " - "flags=%x, retcode=%d", - driver, conn, vm, NULLSTR(cookiein), cookieinlen, - flags, retcode); - - virCheckFlags(QEMU_MIGRATION_FLAGS, -1); - - qemuMigrationJobSetPhase(driver, vm, - retcode == 0 - ? QEMU_MIGRATION_PHASE_CONFIRM3 - : QEMU_MIGRATION_PHASE_CONFIRM3_CANCELLED); - - if (!(mig = qemuMigrationEatCookie(driver, vm, cookiein, cookieinlen, 0))) - goto cleanup; - - if (flags & VIR_MIGRATE_OFFLINE) - goto done; - - /* Did the migration go as planned? If yes, kill off the - * domain object, but if no, resume CPUs - */ - if (retcode == 0) { - /* If guest uses SPICE and supports seamless migration we have to hold - * up domain shutdown until SPICE server transfers its data */ - qemuMigrationWaitForSpice(driver, vm); - - qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_MIGRATED, - VIR_QEMU_PROCESS_STOP_MIGRATED); - virDomainAuditStop(vm, "migrated"); - - event = virDomainEventNewFromObj(vm, - VIR_DOMAIN_EVENT_STOPPED, - VIR_DOMAIN_EVENT_STOPPED_MIGRATED); - } else { - - /* cancel any outstanding NBD jobs */ - qemuMigrationCancelDriveMirror(mig, driver, vm); - - /* run 'cont' on the destination, which allows migration on qemu - * >= 0.10.6 to work properly. This isn't strictly necessary on - * older qemu's, but it also doesn't hurt anything there - */ - if (qemuProcessStartCPUs(driver, vm, conn, - VIR_DOMAIN_RUNNING_MIGRATED, - QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) { - if (virGetLastError() == NULL) - virReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("resume operation failed")); - goto cleanup; - } - - event = virDomainEventNewFromObj(vm, - VIR_DOMAIN_EVENT_RESUMED, - VIR_DOMAIN_EVENT_RESUMED_MIGRATED); - if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0) { - VIR_WARN("Failed to save status on vm %s", vm->def->name); - goto cleanup; - } - } - -done: - qemuMigrationCookieFree(mig); - rv = 0; - -cleanup: - if (event) - qemuDomainEventQueue(driver, event); - virObjectUnref(cfg); - return rv; -} - - /* Helper function called while vm is active. */ int qemuMigrationToFile(virQEMUDriverPtr driver, virDomainObjPtr vm, diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h index 2e03b78..65663e9 100644 --- a/src/qemu/qemu_migration.h +++ b/src/qemu/qemu_migration.h @@ -146,7 +146,7 @@ int qemuMigrationConfirm(virQEMUDriverPtr driver, const char *cookiein, int cookieinlen, unsigned int flags, - int retcode); + int cancelled); bool qemuMigrationIsAllowed(virQEMUDriverPtr driver, virDomainObjPtr vm, virDomainDefPtr def, bool remote, -- 1.8.2.1

--- src/libvirt.c | 108 ++++++++++++++++++++++++++++++---------------------------- 1 file changed, 56 insertions(+), 52 deletions(-) diff --git a/src/libvirt.c b/src/libvirt.c index 12387ef..7c60600 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -5070,73 +5070,69 @@ virDomainMigrateVersion3(virDomainPtr domain, * only talks to the source libvirtd instance. The source libvirtd * then opens its own connection to the destination and co-ordinates * migration itself. + * + * If useParams is true, params and nparams contain migration parameters and + * we know it's safe to call the API which supports extensible parameters. + * Otherwise, we have to use xmlin, dname, uri, and bandwidth and pass them + * to the old-style APIs. */ static int -virDomainMigratePeer2Peer(virDomainPtr domain, - const char *xmlin, - unsigned long flags, - const char *dname, - const char *dconnuri, - const char *uri, - unsigned long bandwidth) +virDomainMigratePeer2PeerFull(virDomainPtr domain, + const char *dconnuri, + const char *xmlin, + const char *dname, + const char *uri, + unsigned long long bandwidth, + virTypedParameterPtr params, + int nparams, + bool useParams, + unsigned int flags) { virURIPtr tempuri = NULL; - VIR_DOMAIN_DEBUG(domain, "xmlin=%s, flags=%lx, dname=%s, " - "dconnuri=%s, uri=%s, bandwidth=%lu", - NULLSTR(xmlin), flags, NULLSTR(dname), - NULLSTR(dconnuri), NULLSTR(uri), bandwidth); - if (!domain->conn->driver->domainMigratePerform) { - virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__); - virDispatchError(domain->conn); - return -1; - } + VIR_DOMAIN_DEBUG(domain, + "dconnuri=%s, xmlin=%s, dname=%s, uri=%s, bandwidth=%llu " + "params=%p, nparams=%d, useParams=%d, flags=%x", + dconnuri, NULLSTR(xmlin), NULLSTR(dname), NULLSTR(uri), + bandwidth, params, nparams, useParams, flags); + VIR_TYPED_PARAMS_DEBUG(params, nparams); - if (!(tempuri = virURIParse(dconnuri))) { - virDispatchError(domain->conn); + if ((useParams && !domain->conn->driver->domainMigratePerform3Params) || + (!useParams && + !domain->conn->driver->domainMigratePerform && + !domain->conn->driver->domainMigratePerform3)) { + virLibConnError(VIR_ERR_INTERNAL_ERROR, __FUNCTION__); return -1; } - if (!tempuri->server) { - virReportInvalidArg(dconnuri, - _("unable to parse server from dconnuri in %s"), - __FUNCTION__); - virDispatchError(domain->conn); - virURIFree(tempuri); + if (!(tempuri = virURIParse(dconnuri))) return -1; - } - if (STRPREFIX(tempuri->server, "localhost")) { + if (!tempuri->server || STRPREFIX(tempuri->server, "localhost")) { virReportInvalidArg(dconnuri, _("unable to parse server from dconnuri in %s"), __FUNCTION__); - virDispatchError(domain->conn); virURIFree(tempuri); return -1; } virURIFree(tempuri); - /* Perform the migration. The driver isn't supposed to return - * until the migration is complete. - */ - if (VIR_DRV_SUPPORTS_FEATURE(domain->conn->driver, domain->conn, - VIR_DRV_FEATURE_MIGRATION_V3)) { + if (useParams) { + VIR_DEBUG("Using migration protocol 3 with extensible parameters"); + return domain->conn->driver->domainMigratePerform3Params + (domain, dconnuri, params, nparams, + NULL, 0, NULL, NULL, flags); + } else if (VIR_DRV_SUPPORTS_FEATURE(domain->conn->driver, domain->conn, + VIR_DRV_FEATURE_MIGRATION_V3)) { VIR_DEBUG("Using migration protocol 3"); - return domain->conn->driver->domainMigratePerform3(domain, - xmlin, - NULL, /* cookiein */ - 0, /* cookieinlen */ - NULL, /* cookieoutlen */ - NULL, /* cookieoutlen */ - dconnuri, - uri, - flags, - dname, - bandwidth); + return domain->conn->driver->domainMigratePerform3 + (domain, xmlin, NULL, 0, NULL, NULL, dconnuri, + uri, flags, dname, bandwidth); } else { VIR_DEBUG("Using migration protocol 2"); if (xmlin) { - virLibConnError(VIR_ERR_INTERNAL_ERROR, "%s", - _("Unable to change target guest XML during migration")); + virLibConnError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("Unable to change target guest XML " + "during migration")); return -1; } if (uri) { @@ -5144,16 +5140,24 @@ virDomainMigratePeer2Peer(virDomainPtr domain, _("Unable to override peer2peer migration URI")); return -1; } - return domain->conn->driver->domainMigratePerform(domain, - NULL, /* cookie */ - 0, /* cookielen */ - dconnuri, - flags, - dname, - bandwidth); + return domain->conn->driver->domainMigratePerform + (domain, NULL, 0, dconnuri, flags, dname, bandwidth); } } +static int +virDomainMigratePeer2Peer(virDomainPtr domain, + const char *xmlin, + unsigned long flags, + const char *dname, + const char *dconnuri, + const char *uri, + unsigned long bandwidth) +{ + return virDomainMigratePeer2PeerFull(domain, dconnuri, xmlin, dname, uri, + bandwidth, NULL, 0, false, flags); +} + /* * In normal migration, the libvirt client co-ordinates communication -- 1.8.2.1

This patch introduces two new APIs virDomainMigrate3 and virDomainMigrateToURI3 that may be used in place of their older variants. These new APIs take optional migration parameters (such as bandwidth, domain XML, ...) in an array of virTypedParameters, which makes adding new parameters easier as there's no need to introduce new APIs whenever a new migration parameter needs to be added. Both APIs are backward compatible and will automatically use older migration calls in case the new calls are not supported as long as the typed parameters array does not contain any parameter which was not supported by the older calls. --- include/libvirt/libvirt.h.in | 10 ++ python/generator.py | 2 + src/libvirt.c | 376 +++++++++++++++++++++++++++++++++++++++++++ src/libvirt_public.syms | 6 + 4 files changed, 394 insertions(+) diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index 35bffea..5f3a006 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -1255,6 +1255,11 @@ virDomainPtr virDomainMigrate2(virDomainPtr domain, virConnectPtr dconn, const char *dxml, unsigned long flags, const char *dname, const char *uri, unsigned long bandwidth); +virDomainPtr virDomainMigrate3(virDomainPtr domain, + virConnectPtr dconn, + virTypedParameterPtr params, + unsigned int nparams, + unsigned int flags); int virDomainMigrateToURI (virDomainPtr domain, const char *duri, unsigned long flags, const char *dname, @@ -1267,6 +1272,11 @@ int virDomainMigrateToURI2(virDomainPtr domain, unsigned long flags, const char *dname, unsigned long bandwidth); +int virDomainMigrateToURI3(virDomainPtr domain, + const char *dconnuri, + virTypedParameterPtr params, + unsigned int nparams, + unsigned int flags); int virDomainMigrateSetMaxDowntime (virDomainPtr domain, unsigned long long downtime, diff --git a/python/generator.py b/python/generator.py index 8c380bb..da642eb 100755 --- a/python/generator.py +++ b/python/generator.py @@ -458,6 +458,8 @@ skip_impl = ( 'virNodeGetMemoryParameters', 'virNodeSetMemoryParameters', 'virNodeGetCPUMap', + 'virDomainMigrate3', + 'virDomainMigrateToURI3', ) lxc_skip_impl = ( diff --git a/src/libvirt.c b/src/libvirt.c index 7c60600..fdb9fa1 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -5061,6 +5061,17 @@ virDomainMigrateVersion3(virDomainPtr domain, bandwidth, NULL, 0, false, flags); } +static virDomainPtr +virDomainMigrateVersion3Params(virDomainPtr domain, + virConnectPtr dconn, + virTypedParameterPtr params, + int nparams, + unsigned int flags) +{ + return virDomainMigrateVersion3Full(domain, dconn, NULL, NULL, NULL, 0, + params, nparams, true, flags); +} + /* * In normal migration, the libvirt client co-ordinates communication @@ -5158,6 +5169,17 @@ virDomainMigratePeer2Peer(virDomainPtr domain, bandwidth, NULL, 0, false, flags); } +static int +virDomainMigratePeer2PeerParams(virDomainPtr domain, + const char *dconnuri, + virTypedParameterPtr params, + int nparams, + unsigned int flags) +{ + return virDomainMigratePeer2PeerFull(domain, dconnuri, NULL, NULL, NULL, 0, + params, nparams, true, flags); +} + /* * In normal migration, the libvirt client co-ordinates communication @@ -5700,6 +5722,208 @@ error: /** + * virDomainMigrate3: + * @domain: a domain object + * @dconn: destination host (a connection object) + * @params: (optional) migration parameters + * @nparams: (optional) number of migration parameters in @params + * @flags: bitwise-OR of virDomainMigrateFlags + * + * Migrate the domain object from its current host to the destination host + * given by dconn (a connection to the destination host). + * + * See virDomainMigrateFlags documentation for description of individual flags. + * + * VIR_MIGRATE_TUNNELLED and VIR_MIGRATE_PEER2PEER are not supported by this + * API, use virDomainMigrateToURI3 instead. + * + * If you want to copy non-shared storage within migration you + * can use either VIR_MIGRATE_NON_SHARED_DISK or + * VIR_MIGRATE_NON_SHARED_INC as they are mutually exclusive. + * + * There are many limitations on migration imposed by the underlying + * technology - for example it may not be possible to migrate between + * different processors even with the same architecture, or between + * different types of hypervisor. + * + * Returns the new domain object if the migration was successful, + * or NULL in case of error. Note that the new domain object + * exists in the scope of the destination connection (dconn). + */ +virDomainPtr +virDomainMigrate3(virDomainPtr domain, + virConnectPtr dconn, + virTypedParameterPtr params, + unsigned int nparams, + unsigned int flags) +{ + virDomainPtr ddomain = NULL; + const char *compatParams[] = { VIR_MIGRATE_PARAM_URI, + VIR_MIGRATE_PARAM_DEST_NAME, + VIR_MIGRATE_PARAM_DEST_XML, + VIR_MIGRATE_PARAM_BANDWIDTH }; + const char *uri = NULL; + const char *dname = NULL; + const char *dxml = NULL; + unsigned long long bandwidth = 0; + + VIR_DOMAIN_DEBUG(domain, "dconn=%p, params=%p, nparms=%u flags=%x", + dconn, params, nparams, flags); + VIR_TYPED_PARAMS_DEBUG(params, nparams); + + virResetLastError(); + + /* First checkout the source */ + if (!VIR_IS_CONNECTED_DOMAIN(domain)) { + virLibDomainError(VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + virDispatchError(NULL); + return NULL; + } + if (domain->conn->flags & VIR_CONNECT_RO) { + virLibDomainError(VIR_ERR_OPERATION_DENIED, __FUNCTION__); + goto error; + } + + /* Now checkout the destination */ + if (!VIR_IS_CONNECT(dconn)) { + virLibConnError(VIR_ERR_INVALID_CONN, __FUNCTION__); + goto error; + } + if (dconn->flags & VIR_CONNECT_RO) { + /* NB, deliberately report error against source object, not dest */ + virLibDomainError(VIR_ERR_OPERATION_DENIED, __FUNCTION__); + goto error; + } + + if (flags & VIR_MIGRATE_NON_SHARED_DISK && + flags & VIR_MIGRATE_NON_SHARED_INC) { + virReportInvalidArg(flags, + _("flags 'shared disk' and 'shared incremental' " + "in %s are mutually exclusive"), + __FUNCTION__); + goto error; + } + if (flags & (VIR_MIGRATE_PEER2PEER | VIR_MIGRATE_TUNNELLED)) { + virReportInvalidArg(flags, "%s", + _("use virDomainMigrateToURI3 for peer-to-peer " + "migration")); + goto error; + } + + if (flags & VIR_MIGRATE_OFFLINE) { + if (!VIR_DRV_SUPPORTS_FEATURE(domain->conn->driver, domain->conn, + VIR_DRV_FEATURE_MIGRATION_OFFLINE)) { + virLibConnError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("offline migration is not supported by " + "the source host")); + goto error; + } + if (!VIR_DRV_SUPPORTS_FEATURE(dconn->driver, dconn, + VIR_DRV_FEATURE_MIGRATION_OFFLINE)) { + virLibConnError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("offline migration is not supported by " + "the destination host")); + goto error; + } + } + + /* Change protection requires support only on source side, and + * is only needed in v3 migration, which automatically re-adds + * the flag for just the source side. We mask it out to allow + * migration from newer source to an older destination that + * rejects the flag. */ + if (flags & VIR_MIGRATE_CHANGE_PROTECTION && + !VIR_DRV_SUPPORTS_FEATURE(domain->conn->driver, domain->conn, + VIR_DRV_FEATURE_MIGRATE_CHANGE_PROTECTION)) { + virLibConnError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("cannot enforce change protection")); + goto error; + } + flags &= ~VIR_MIGRATE_CHANGE_PROTECTION; + + /* Prefer extensible API but fall back to older migration APIs if params + * only contains parameters which were supported by the older API. */ + if (VIR_DRV_SUPPORTS_FEATURE(domain->conn->driver, domain->conn, + VIR_DRV_FEATURE_MIGRATION_PARAMS) && + VIR_DRV_SUPPORTS_FEATURE(dconn->driver, dconn, + VIR_DRV_FEATURE_MIGRATION_PARAMS)) { + VIR_DEBUG("Using migration protocol 3 with extensible parameters"); + ddomain = virDomainMigrateVersion3Params(domain, dconn, params, + nparams, flags); + goto done; + } + + if (!virTypedParamsCheck(params, nparams, compatParams, + ARRAY_CARDINALITY(compatParams))) { + virLibConnError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("Migration APIs with extensible parameters are not " + "supported but extended parameters were passed")); + goto error; + } + + if (virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_URI, &uri) < 0 || + virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_DEST_NAME, &dname) < 0 || + virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_DEST_XML, &dxml) < 0 || + virTypedParamsGetULLong(params, nparams, + VIR_MIGRATE_PARAM_BANDWIDTH, &bandwidth) < 0) { + goto error; + } + + if (VIR_DRV_SUPPORTS_FEATURE(domain->conn->driver, domain->conn, + VIR_DRV_FEATURE_MIGRATION_V3) && + VIR_DRV_SUPPORTS_FEATURE(dconn->driver, dconn, + VIR_DRV_FEATURE_MIGRATION_V3)) { + VIR_DEBUG("Using migration protocol 3"); + ddomain = virDomainMigrateVersion3(domain, dconn, dxml, flags, + dname, uri, bandwidth); + } else if (VIR_DRV_SUPPORTS_FEATURE(domain->conn->driver, domain->conn, + VIR_DRV_FEATURE_MIGRATION_V2) && + VIR_DRV_SUPPORTS_FEATURE(dconn->driver, dconn, + VIR_DRV_FEATURE_MIGRATION_V2)) { + VIR_DEBUG("Using migration protocol 2"); + if (dxml) { + virLibConnError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("Unable to change target guest XML during " + "migration")); + goto error; + } + ddomain = virDomainMigrateVersion2(domain, dconn, flags, + dname, uri, bandwidth); + } else if (VIR_DRV_SUPPORTS_FEATURE(domain->conn->driver, domain->conn, + VIR_DRV_FEATURE_MIGRATION_V1) && + VIR_DRV_SUPPORTS_FEATURE(dconn->driver, dconn, + VIR_DRV_FEATURE_MIGRATION_V1)) { + VIR_DEBUG("Using migration protocol 1"); + if (dxml) { + virLibConnError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("Unable to change target guest XML during " + "migration")); + goto error; + } + ddomain = virDomainMigrateVersion1(domain, dconn, flags, + dname, uri, bandwidth); + } else { + /* This driver does not support any migration method */ + virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__); + goto error; + } + +done: + if (ddomain == NULL) + goto error; + + return ddomain; + +error: + virDispatchError(domain->conn); + return NULL; +} + + +/** * virDomainMigrateToURI: * @domain: a domain object * @duri: mandatory URI for the destination host @@ -6004,6 +6228,158 @@ error: } +/** + * virDomainMigrateToURI3: + * @domain: a domain object + * @dconnuri: (optional) URI for target libvirtd if @flags includes VIR_MIGRATE_PEER2PEER + * @params: (optional) migration parameters + * @nparams: (optional) number of migration parameters in @params + * @flags: bitwise-OR of virDomainMigrateFlags + * + * Migrate the domain object from its current host to the destination host + * given by URI. + * + * See virDomainMigrateFlags documentation for description of individual flags. + * + * The operation of this API hinges on the VIR_MIGRATE_PEER2PEER flag. + * + * If the VIR_MIGRATE_PEER2PEER flag is set, the @dconnuri parameter must be a + * valid libvirt connection URI, by which the source libvirt daemon can connect + * to the destination libvirt. + * + * If the VIR_MIGRATE_PEER2PEER flag is NOT set, then @dconnuri must be NULL + * and VIR_MIGRATE_PARAM_URI migration parameter must be filled in with + * hypervisor specific URI used to initiate the migration. This is called + * "direct" migration. + * + * VIR_MIGRATE_TUNNELLED requires that VIR_MIGRATE_PEER2PEER be set. + * + * If you want to copy non-shared storage within migration you + * can use either VIR_MIGRATE_NON_SHARED_DISK or + * VIR_MIGRATE_NON_SHARED_INC as they are mutually exclusive. + * + * There are many limitations on migration imposed by the underlying + * technology - for example it may not be possible to migrate between + * different processors even with the same architecture, or between + * different types of hypervisor. + * + * Returns 0 if the migration succeeded, -1 upon error. + */ +int +virDomainMigrateToURI3(virDomainPtr domain, + const char *dconnuri, + virTypedParameterPtr params, + unsigned int nparams, + unsigned int flags) +{ + bool compat; + const char *compatParams[] = { VIR_MIGRATE_PARAM_URI, + VIR_MIGRATE_PARAM_DEST_NAME, + VIR_MIGRATE_PARAM_DEST_XML, + VIR_MIGRATE_PARAM_BANDWIDTH }; + const char *uri = NULL; + const char *dname = NULL; + const char *dxml = NULL; + unsigned long long bandwidth = 0; + + VIR_DOMAIN_DEBUG(domain, "dconnuri=%s, params=%p, nparms=%u flags=%x", + NULLSTR(dconnuri), params, nparams, flags); + VIR_TYPED_PARAMS_DEBUG(params, nparams); + + virResetLastError(); + + /* First checkout the source */ + if (!VIR_IS_CONNECTED_DOMAIN(domain)) { + virLibDomainError(VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + virDispatchError(NULL); + return -1; + } + if (domain->conn->flags & VIR_CONNECT_RO) { + virLibDomainError(VIR_ERR_OPERATION_DENIED, __FUNCTION__); + goto error; + } + + if (flags & VIR_MIGRATE_NON_SHARED_DISK && + flags & VIR_MIGRATE_NON_SHARED_INC) { + virReportInvalidArg(flags, + _("flags 'shared disk' and 'shared incremental' " + "in %s are mutually exclusive"), + __FUNCTION__); + goto error; + } + + compat = virTypedParamsCheck(params, nparams, compatParams, + ARRAY_CARDINALITY(compatParams)); + + if (virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_URI, &uri) < 0 || + virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_DEST_NAME, &dname) < 0 || + virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_DEST_XML, &dxml) < 0 || + virTypedParamsGetULLong(params, nparams, + VIR_MIGRATE_PARAM_BANDWIDTH, &bandwidth) < 0) { + goto error; + } + + if (flags & VIR_MIGRATE_PEER2PEER) { + if (!VIR_DRV_SUPPORTS_FEATURE(domain->conn->driver, domain->conn, + VIR_DRV_FEATURE_MIGRATION_P2P)) { + virLibConnError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", + _("Peer-to-peer migration is not supported by " + "the connection driver")); + goto error; + } + + if (VIR_DRV_SUPPORTS_FEATURE(domain->conn->driver, domain->conn, + VIR_DRV_FEATURE_MIGRATION_PARAMS)) { + VIR_DEBUG("Using peer2peer migration with extensible parameters"); + if (virDomainMigratePeer2PeerParams(domain, dconnuri, params, + nparams, flags) < 0) + goto error; + } else if (compat) { + VIR_DEBUG("Using peer2peer migration"); + if (virDomainMigratePeer2Peer(domain, dxml, flags, dname, + dconnuri, uri, bandwidth) < 0) + goto error; + } else { + virLibConnError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("Peer-to-peer migration with extensible " + "parameters is not supported but extended " + "parameters were passed")); + goto error; + } + } else { + if (!VIR_DRV_SUPPORTS_FEATURE(domain->conn->driver, domain->conn, + VIR_DRV_FEATURE_MIGRATION_DIRECT)) { + /* Cannot do a migration with only the perform step */ + virLibConnError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", + _("Direct migration is not supported by the" + " connection driver")); + goto error; + } + + if (!compat) { + virLibConnError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("Direct migration does not support extensible " + "parameters")); + goto error; + } + + VIR_DEBUG("Using direct migration"); + if (virDomainMigrateDirect(domain, dxml, flags, + dname, uri, bandwidth) < 0) + goto error; + } + + return 0; + +error: + virDispatchError(domain->conn); + return -1; +} + + /* * Not for public use. This function is part of the internal * implementation of migration in the remote case. diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms index 4ee2d27..d47218a 100644 --- a/src/libvirt_public.syms +++ b/src/libvirt_public.syms @@ -621,4 +621,10 @@ LIBVIRT_1.0.6 { virGetLastErrorMessage; } LIBVIRT_1.0.5; +LIBVIRT_1.0.7 { + global: + virDomainMigrate3; + virDomainMigrateToURI3; +} LIBVIRT_1.0.6; + # .... define new API here using predicted next version number .... -- 1.8.2.1

The patch implements wrappers for virDomainMigrate3 and virDomainMigrateToURI3. --- python/libvirt-override-api.xml | 18 ++++ python/libvirt-override.c | 218 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 236 insertions(+) diff --git a/python/libvirt-override-api.xml b/python/libvirt-override-api.xml index 155ab36..9a88215 100644 --- a/python/libvirt-override-api.xml +++ b/python/libvirt-override-api.xml @@ -527,6 +527,24 @@ <arg name='flags' type='unsigned int' info='flags, currently unused, pass 0.'/> <return type='unsigned long' info='current max migration speed, or None in case of error'/> </function> + <function name='virDomainMigrate3' file='python'> + <info>Migrate the domain object from its current host to the destination host + given by dconn (a connection to the destination host).</info> + <arg name='domain' type='virDomainPtr' info='a domain object'/> + <arg name='dconn' type='virConnectPtr' info='pointer to the destination host connection'/> + <arg name='params' type='char *' info='dictionary with migration parameters'/> + <arg name='flags' type='unsigned int' info='an OR'ed set of virDomainMigrateFlags'/> + <return type='virDomainPtr' info='a new domain object or NULL in case of failure'/> + </function> + <function name='virDomainMigrateToURI3' file='python'> + <info>Migrate the domain object from its current host to the destination host + given by URI.</info> + <arg name='domain' type='virDomainPtr' info='a domain object'/> + <arg name='dconnuri' type='virConnectPtr' info='URI for target libvirtd if @flags includes VIR_MIGRATE_PEER2PEER'/> + <arg name='params' type='char *' info='dictionary with migration parameters'/> + <arg name='flags' type='unsigned int' info='an OR'ed set of virDomainMigrateFlags'/> + <return type='int' info='0 in case of success, -1 in case of failure.'/> + </function> <function name='virDomainSetBlockIoTune' file='python'> <info>Change the I/O tunables for a block device</info> <arg name='dom' type='virDomainPtr' info='pointer to the domain'/> diff --git a/python/libvirt-override.c b/python/libvirt-override.c index b6462c2..5c5586d 100644 --- a/python/libvirt-override.c +++ b/python/libvirt-override.c @@ -258,6 +258,160 @@ cleanup: return NULL; } + +typedef struct { + const char *name; + int type; +} virPyTypedParamsHint; +typedef virPyTypedParamsHint *virPyTypedParamsHintPtr; + +/* Automatically convert dict into type parameters based on types reported + * by python. All integer types are converted into LLONG (in case of a negative + * value) or ULLONG (in case of a positive value). If you need different + * handling, use @hints to explicitly specify what types should be used for + * specific parameters. + */ +static int +ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) +virPyDictToTypedParams(PyObject *dict, + virTypedParameterPtr *ret_params, + int *ret_nparams, + virPyTypedParamsHintPtr hints, + int nhints) +{ + PyObject *key; + PyObject *value; +#if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION <= 4 + int pos = 0; +#else + Py_ssize_t pos = 0; +#endif + virTypedParameterPtr params = NULL; + int i; + int n = 0; + int max = 0; + int ret = -1; + + *ret_params = NULL; + *ret_nparams = 0; + + if (PyDict_Size(dict) < 0) + return -1; + + while (PyDict_Next(dict, &pos, &key, &value)) { + char *keystr; + int type = -1; + + if (!(keystr = PyString_AsString(key))) + goto cleanup; + + for (i = 0; i < nhints; i++) { + if (STREQ(hints[i].name, keystr)) { + type = hints[i].type; + break; + } + } + + if (type == -1) { + if (PyString_Check(value)) { + type = VIR_TYPED_PARAM_STRING; + } else if (PyBool_Check(value)) { + type = VIR_TYPED_PARAM_BOOLEAN; + } else if (PyLong_Check(value)) { + unsigned long long ull = PyLong_AsUnsignedLongLong(value); + if (ull == (unsigned long long) -1 && PyErr_Occurred()) + type = VIR_TYPED_PARAM_LLONG; + else + type = VIR_TYPED_PARAM_ULLONG; + } else if (PyInt_Check(value)) { + if (PyInt_AS_LONG(value) < 0) + type = VIR_TYPED_PARAM_LLONG; + else + type = VIR_TYPED_PARAM_ULLONG; + } else if (PyFloat_Check(value)) { + type = VIR_TYPED_PARAM_DOUBLE; + } + } + + if (type == -1) { + PyErr_Format(PyExc_TypeError, + "Unknown type of \"%s\" field", keystr); + goto cleanup; + } + + switch ((virTypedParameterType) type) { + case VIR_TYPED_PARAM_INT: + { + int val; + if (libvirt_intUnwrap(value, &val) < 0 || + virTypedParamsAddInt(¶ms, &n, &max, keystr, val) < 0) + goto cleanup; + break; + } + case VIR_TYPED_PARAM_UINT: + { + unsigned int val; + if (libvirt_uintUnwrap(value, &val) < 0 || + virTypedParamsAddUInt(¶ms, &n, &max, keystr, val) < 0) + goto cleanup; + break; + } + case VIR_TYPED_PARAM_LLONG: + { + long long val; + if (libvirt_longlongUnwrap(value, &val) < 0 || + virTypedParamsAddLLong(¶ms, &n, &max, keystr, val) < 0) + goto cleanup; + break; + } + case VIR_TYPED_PARAM_ULLONG: + { + unsigned long long val; + if (libvirt_ulonglongUnwrap(value, &val) < 0 || + virTypedParamsAddULLong(¶ms, &n, &max, keystr, val) < 0) + goto cleanup; + break; + } + case VIR_TYPED_PARAM_DOUBLE: + { + double val; + if (libvirt_doubleUnwrap(value, &val) < 0 || + virTypedParamsAddDouble(¶ms, &n, &max, keystr, val) < 0) + goto cleanup; + break; + } + case VIR_TYPED_PARAM_BOOLEAN: + { + bool val; + if (libvirt_boolUnwrap(value, &val) < 0 || + virTypedParamsAddBoolean(¶ms, &n, &max, keystr, val) < 0) + goto cleanup; + break; + } + case VIR_TYPED_PARAM_STRING: + { + char *val = PyString_AsString(value); + if (!val || + virTypedParamsAddString(¶ms, &n, &max, keystr, val) < 0) + goto cleanup; + break; + } + case VIR_TYPED_PARAM_LAST: + break; /* unreachable */ + } + } + + *ret_params = params; + *ret_nparams = n; + params = NULL; + ret = 0; + +cleanup: + virTypedParamsFree(params, n); + return ret; +} + + /* * Utility function to retrieve the number of node CPUs present. * It first tries virGetNodeCPUMap, which will return the @@ -6495,6 +6649,68 @@ libvirt_virDomainMigrateGetMaxSpeed(PyObject *self ATTRIBUTE_UNUSED, PyObject *a } static PyObject * +libvirt_virDomainMigrate3(PyObject *self ATTRIBUTE_UNUSED, + PyObject *args) +{ + PyObject *pyobj_domain; + virDomainPtr domain; + PyObject *pyobj_dconn; + virConnectPtr dconn; + PyObject *dict; + unsigned int flags; + virTypedParameterPtr params; + int nparams; + virDomainPtr ddom = NULL; + + if (!PyArg_ParseTuple(args, (char *) "OOOi:virDomainMigrate3", + &pyobj_domain, &pyobj_dconn, &dict, &flags)) + return NULL; + + domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain); + dconn = (virConnectPtr) PyvirConnect_Get(pyobj_dconn); + + if (virPyDictToTypedParams(dict, ¶ms, &nparams, NULL, 0) < 0) + return NULL; + + LIBVIRT_BEGIN_ALLOW_THREADS; + ddom = virDomainMigrate3(domain, dconn, params, nparams, flags); + LIBVIRT_END_ALLOW_THREADS; + + virTypedParamsFree(params, nparams); + return libvirt_virDomainPtrWrap(ddom); +} + +static PyObject * +libvirt_virDomainMigrateToURI3(PyObject *self ATTRIBUTE_UNUSED, + PyObject *args) +{ + PyObject *pyobj_domain; + virDomainPtr domain; + char *dconnuri; + PyObject *dict; + unsigned int flags; + virTypedParameterPtr params; + int nparams; + int ret = -1; + + if (!PyArg_ParseTuple(args, (char *) "OzOi:virDomainMigrate3", + &pyobj_domain, &dconnuri, &dict, &flags)) + return NULL; + + domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain); + + if (virPyDictToTypedParams(dict, ¶ms, &nparams, NULL, 0) < 0) + return NULL; + + LIBVIRT_BEGIN_ALLOW_THREADS; + ret = virDomainMigrateToURI3(domain, dconnuri, params, nparams, flags); + LIBVIRT_END_ALLOW_THREADS; + + virTypedParamsFree(params, nparams); + return libvirt_intWrap(ret); +} + +static PyObject * libvirt_virDomainBlockPeek(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) { PyObject *py_retval = NULL; @@ -6876,6 +7092,8 @@ static PyMethodDef libvirtMethods[] = { {(char *) "virDomainSendKey", libvirt_virDomainSendKey, METH_VARARGS, NULL}, {(char *) "virDomainMigrateGetCompressionCache", libvirt_virDomainMigrateGetCompressionCache, METH_VARARGS, NULL}, {(char *) "virDomainMigrateGetMaxSpeed", libvirt_virDomainMigrateGetMaxSpeed, METH_VARARGS, NULL}, + {(char *) "virDomainMigrate3", libvirt_virDomainMigrate3, METH_VARARGS, NULL}, + {(char *) "virDomainMigrateToURI3", libvirt_virDomainMigrateToURI3, METH_VARARGS, NULL}, {(char *) "virDomainBlockPeek", libvirt_virDomainBlockPeek, METH_VARARGS, NULL}, {(char *) "virDomainMemoryPeek", libvirt_virDomainMemoryPeek, METH_VARARGS, NULL}, {(char *) "virDomainGetDiskErrors", libvirt_virDomainGetDiskErrors, METH_VARARGS, NULL}, -- 1.8.2.1

--- src/qemu/qemu_driver.c | 14 ++-- src/qemu/qemu_migration.c | 185 ++++++++++++++++++++++++++++++++-------------- src/qemu/qemu_migration.h | 2 + 3 files changed, 139 insertions(+), 62 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 29210a5..f7824b6 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -9778,7 +9778,7 @@ qemuDomainMigratePerform(virDomainPtr dom, * Consume any cookie we were able to decode though */ ret = qemuMigrationPerform(driver, dom->conn, vm, - NULL, dconnuri, uri, cookie, cookielen, + NULL, dconnuri, uri, NULL, cookie, cookielen, NULL, NULL, /* No output cookies in v2 */ flags, dname, resource, false); @@ -10044,7 +10044,7 @@ qemuDomainMigratePerform3(virDomainPtr dom, return -1; return qemuMigrationPerform(driver, dom->conn, vm, xmlin, - dconnuri, uri, cookiein, cookieinlen, + dconnuri, uri, NULL, cookiein, cookieinlen, cookieout, cookieoutlen, flags, dname, resource, true); } @@ -10065,6 +10065,7 @@ qemuDomainMigratePerform3Params(virDomainPtr dom, const char *dom_xml = NULL; const char *dname = NULL; const char *uri = NULL; + const char *graphicsuri = NULL; unsigned long long bandwidth = 0; virCheckFlags(QEMU_MIGRATION_FLAGS, -1); @@ -10082,15 +10083,18 @@ qemuDomainMigratePerform3Params(virDomainPtr dom, &uri) < 0 || virTypedParamsGetULLong(params, nparams, VIR_MIGRATE_PARAM_BANDWIDTH, - &bandwidth) < 0) + &bandwidth) < 0 || + virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_GRAPHICS_URI, + &graphicsuri) < 0) return -1; if (!(vm = qemuDomObjFromDomain(dom))) return -1; return qemuMigrationPerform(driver, dom->conn, vm, dom_xml, - dconnuri, uri, cookiein, cookieinlen, - cookieout, cookieoutlen, + dconnuri, uri, graphicsuri, + cookiein, cookieinlen, cookieout, cookieoutlen, flags, dname, bandwidth, true); } diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index a63af70..ce27c92 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -1785,44 +1785,87 @@ cancel: static int qemuDomainMigrateGraphicsRelocate(virQEMUDriverPtr driver, virDomainObjPtr vm, - qemuMigrationCookiePtr cookie) + qemuMigrationCookiePtr cookie, + const char *graphicsuri) { qemuDomainObjPrivatePtr priv = vm->privateData; - int ret; - char *listenAddress; + int ret = -1; + const char *listenAddress = NULL; virSocketAddr addr; + virURIPtr uri = NULL; + int type = -1; + int port = -1; + int tlsPort = -1; + const char *tlsSubject = NULL; - if (!cookie) + if (!cookie || (!cookie->graphics && !graphicsuri)) return 0; - if (!cookie->graphics) - return 0; + if (graphicsuri && !(uri = virURIParse(graphicsuri))) + goto cleanup; + + if (cookie->graphics) { + type = cookie->graphics->type; + + listenAddress = cookie->graphics->listen; + + if (!listenAddress || + (virSocketAddrParse(&addr, listenAddress, AF_UNSPEC) > 0 && + virSocketAddrIsWildcard(&addr))) + listenAddress = cookie->remoteHostname; + + port = cookie->graphics->port; + tlsPort = cookie->graphics->tlsPort; + tlsSubject = cookie->graphics->tlsSubject; + } + + if (uri) { + int i; + + if ((type = virDomainGraphicsTypeFromString(uri->scheme)) < 0) { + virReportError(VIR_ERR_INVALID_ARG, + _("unknown graphics type %s"), uri->scheme); + goto cleanup; + } + + if (uri->server) + listenAddress = uri->server; + if (uri->port > 0) + port = uri->port; + + for (i = 0; i < uri->paramsCount; i++) { + virURIParamPtr param = uri->params + i; + + if (STRCASEEQ(param->name, "tlsPort")) { + if (virStrToLong_i(param->value, NULL, 10, &tlsPort) < 0) { + virReportError(VIR_ERR_INVALID_ARG, + _("invalid tlsPort number: %s"), + param->value); + goto cleanup; + } + } else if (STRCASEEQ(param->name, "tlsSubject")) { + tlsSubject = param->value; + } + } + } /* QEMU doesn't support VNC relocation yet, so * skip it to avoid generating an error */ - if (cookie->graphics->type != VIR_DOMAIN_GRAPHICS_TYPE_SPICE) - return 0; - - listenAddress = cookie->graphics->listen; - - if (!listenAddress || - (virSocketAddrParse(&addr, listenAddress, AF_UNSPEC) > 0 && - virSocketAddrIsWildcard(&addr))) - listenAddress = cookie->remoteHostname; + if (type != VIR_DOMAIN_GRAPHICS_TYPE_SPICE) { + ret = 0; + goto cleanup; + } - ret = qemuDomainObjEnterMonitorAsync(driver, vm, - QEMU_ASYNC_JOB_MIGRATION_OUT); - if (ret == 0) { - ret = qemuMonitorGraphicsRelocate(priv->mon, - cookie->graphics->type, - listenAddress, - cookie->graphics->port, - cookie->graphics->tlsPort, - cookie->graphics->tlsSubject); + if (qemuDomainObjEnterMonitorAsync(driver, vm, + QEMU_ASYNC_JOB_MIGRATION_OUT) == 0) { + ret = qemuMonitorGraphicsRelocate(priv->mon, type, listenAddress, + port, tlsPort, tlsSubject); qemuDomainObjExitMonitor(driver, vm); } +cleanup: + virURIFree(uri); return ret; } @@ -3068,7 +3111,8 @@ qemuMigrationRun(virQEMUDriverPtr driver, unsigned long flags, unsigned long resource, qemuMigrationSpecPtr spec, - virConnectPtr dconn) + virConnectPtr dconn, + const char *graphicsuri) { int ret = -1; unsigned int migrate_flags = QEMU_MONITOR_MIGRATE_BACKGROUND; @@ -3083,10 +3127,11 @@ qemuMigrationRun(virQEMUDriverPtr driver, VIR_DEBUG("driver=%p, vm=%p, cookiein=%s, cookieinlen=%d, " "cookieout=%p, cookieoutlen=%p, flags=%lx, resource=%lu, " - "spec=%p (dest=%d, fwd=%d)", + "spec=%p (dest=%d, fwd=%d), dconn=%p, graphicsuri=%s", driver, vm, NULLSTR(cookiein), cookieinlen, cookieout, cookieoutlen, flags, resource, - spec, spec->destType, spec->fwdType); + spec, spec->destType, spec->fwdType, dconn, + NULLSTR(graphicsuri)); if (flags & VIR_MIGRATE_NON_SHARED_DISK) { migrate_flags |= QEMU_MONITOR_MIGRATE_NON_SHARED_DISK; @@ -3112,7 +3157,7 @@ qemuMigrationRun(virQEMUDriverPtr driver, if (!mig) goto cleanup; - if (qemuDomainMigrateGraphicsRelocate(driver, vm, mig) < 0) + if (qemuDomainMigrateGraphicsRelocate(driver, vm, mig, graphicsuri) < 0) VIR_WARN("unable to provide data for graphics client relocation"); /* this will update migrate_flags on success */ @@ -3306,7 +3351,8 @@ static int doNativeMigrate(virQEMUDriverPtr driver, int *cookieoutlen, unsigned long flags, unsigned long resource, - virConnectPtr dconn) + virConnectPtr dconn, + const char *graphicsuri) { qemuDomainObjPrivatePtr priv = vm->privateData; virURIPtr uribits = NULL; @@ -3314,9 +3360,11 @@ static int doNativeMigrate(virQEMUDriverPtr driver, qemuMigrationSpec spec; VIR_DEBUG("driver=%p, vm=%p, uri=%s, cookiein=%s, cookieinlen=%d, " - "cookieout=%p, cookieoutlen=%p, flags=%lx, resource=%lu", + "cookieout=%p, cookieoutlen=%p, flags=%lx, resource=%lu, " + "graphicsuri=%s", driver, vm, uri, NULLSTR(cookiein), cookieinlen, - cookieout, cookieoutlen, flags, resource); + cookieout, cookieoutlen, flags, resource, + NULLSTR(graphicsuri)); if (STRPREFIX(uri, "tcp:") && !STRPREFIX(uri, "tcp://")) { char *tmp; @@ -3342,7 +3390,8 @@ static int doNativeMigrate(virQEMUDriverPtr driver, spec.fwdType = MIGRATION_FWD_DIRECT; ret = qemuMigrationRun(driver, vm, cookiein, cookieinlen, cookieout, - cookieoutlen, flags, resource, &spec, dconn); + cookieoutlen, flags, resource, &spec, dconn, + graphicsuri); if (spec.destType == MIGRATION_DEST_FD) VIR_FORCE_CLOSE(spec.dest.fd.qemu); @@ -3362,7 +3411,8 @@ static int doTunnelMigrate(virQEMUDriverPtr driver, int *cookieoutlen, unsigned long flags, unsigned long resource, - virConnectPtr dconn) + virConnectPtr dconn, + const char *graphicsuri) { qemuDomainObjPrivatePtr priv = vm->privateData; virNetSocketPtr sock = NULL; @@ -3371,9 +3421,11 @@ static int doTunnelMigrate(virQEMUDriverPtr driver, virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver); VIR_DEBUG("driver=%p, vm=%p, st=%p, cookiein=%s, cookieinlen=%d, " - "cookieout=%p, cookieoutlen=%p, flags=%lx, resource=%lu", + "cookieout=%p, cookieoutlen=%p, flags=%lx, resource=%lu, " + "graphicsuri=%s", driver, vm, st, NULLSTR(cookiein), cookieinlen, - cookieout, cookieoutlen, flags, resource); + cookieout, cookieoutlen, flags, resource, + NULLSTR(graphicsuri)); if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD) && !virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX) && @@ -3427,7 +3479,8 @@ static int doTunnelMigrate(virQEMUDriverPtr driver, } ret = qemuMigrationRun(driver, vm, cookiein, cookieinlen, cookieout, - cookieoutlen, flags, resource, &spec, dconn); + cookieoutlen, flags, resource, &spec, dconn, + graphicsuri); cleanup: if (spec.destType == MIGRATION_DEST_FD) { @@ -3533,12 +3586,12 @@ static int doPeer2PeerMigrate2(virQEMUDriverPtr driver, if (flags & VIR_MIGRATE_TUNNELLED) ret = doTunnelMigrate(driver, vm, st, NULL, 0, NULL, NULL, - flags, resource, dconn); + flags, resource, dconn, NULL); else ret = doNativeMigrate(driver, vm, uri_out, cookie, cookielen, NULL, NULL, /* No out cookie with v2 migration */ - flags, resource, dconn); + flags, resource, dconn, NULL); /* Perform failed. Make sure Finish doesn't overwrite the error */ if (ret < 0) @@ -3596,6 +3649,7 @@ doPeer2PeerMigrate3(virQEMUDriverPtr driver, const char *xmlin, const char *dname, const char *uri, + const char *graphicsuri, unsigned long long bandwidth, bool useParams, unsigned long flags) @@ -3618,9 +3672,11 @@ doPeer2PeerMigrate3(virQEMUDriverPtr driver, int maxparams = 0; VIR_DEBUG("driver=%p, sconn=%p, dconn=%p, dconnuri=%s, vm=%p, xmlin=%s, " - "dname=%s, uri=%s, bandwidth=%llu, useParams=%d, flags=%lx", + "dname=%s, uri=%s, graphicsuri=%s, bandwidth=%llu, " + "useParams=%d, flags=%lx", driver, sconn, dconn, NULLSTR(dconnuri), vm, NULLSTR(xmlin), - NULLSTR(dname), NULLSTR(uri), bandwidth, useParams, flags); + NULLSTR(dname), NULLSTR(uri), NULLSTR(graphicsuri), bandwidth, + useParams, flags); /* Unlike the virDomainMigrateVersion3 counterpart, we don't need * to worry about auto-setting the VIR_MIGRATE_CHANGE_PROTECTION @@ -3652,6 +3708,12 @@ doPeer2PeerMigrate3(virQEMUDriverPtr driver, VIR_MIGRATE_PARAM_BANDWIDTH, bandwidth) < 0) goto cleanup; + + if (graphicsuri && + virTypedParamsAddString(¶ms, &nparams, &maxparams, + VIR_MIGRATE_PARAM_GRAPHICS_URI, + graphicsuri) < 0) + goto cleanup; } if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) @@ -3730,12 +3792,12 @@ doPeer2PeerMigrate3(virQEMUDriverPtr driver, ret = doTunnelMigrate(driver, vm, st, cookiein, cookieinlen, &cookieout, &cookieoutlen, - flags, bandwidth, dconn); + flags, bandwidth, dconn, graphicsuri); } else { ret = doNativeMigrate(driver, vm, uri, cookiein, cookieinlen, &cookieout, &cookieoutlen, - flags, bandwidth, dconn); + flags, bandwidth, dconn, graphicsuri); } /* Perform failed. Make sure Finish doesn't overwrite the error */ @@ -3853,6 +3915,7 @@ static int doPeer2PeerMigrate(virQEMUDriverPtr driver, const char *xmlin, const char *dconnuri, const char *uri, + const char *graphicsuri, unsigned long flags, const char *dname, unsigned long resource, @@ -3867,9 +3930,10 @@ static int doPeer2PeerMigrate(virQEMUDriverPtr driver, bool useParams; VIR_DEBUG("driver=%p, sconn=%p, vm=%p, xmlin=%s, dconnuri=%s, " - "uri=%s, flags=%lx, dname=%s, resource=%lu", + "uri=%s, graphicsuri=%s, flags=%lx, dname=%s, resource=%lu", driver, sconn, vm, NULLSTR(xmlin), NULLSTR(dconnuri), - NULLSTR(uri), flags, NULLSTR(dname), resource); + NULLSTR(uri), NULLSTR(graphicsuri), flags, NULLSTR(dname), + resource); /* the order of operations is important here; we make sure the * destination side is completely setup before we touch the source @@ -3946,7 +4010,8 @@ static int doPeer2PeerMigrate(virQEMUDriverPtr driver, if (*v3proto) { ret = doPeer2PeerMigrate3(driver, sconn, dconn, dconnuri, vm, xmlin, - dname, uri, resource, useParams, flags); + dname, uri, graphicsuri, resource, + useParams, flags); } else { ret = doPeer2PeerMigrate2(driver, sconn, dconn, vm, dconnuri, flags, dname, resource); @@ -3978,6 +4043,7 @@ qemuMigrationPerformJob(virQEMUDriverPtr driver, const char *xmlin, const char *dconnuri, const char *uri, + const char *graphicsuri, const char *cookiein, int cookieinlen, char **cookieout, @@ -4013,13 +4079,13 @@ qemuMigrationPerformJob(virQEMUDriverPtr driver, if ((flags & (VIR_MIGRATE_TUNNELLED | VIR_MIGRATE_PEER2PEER))) { ret = doPeer2PeerMigrate(driver, conn, vm, xmlin, - dconnuri, uri, flags, dname, + dconnuri, uri, graphicsuri, flags, dname, resource, &v3proto); } else { qemuMigrationJobSetPhase(driver, vm, QEMU_MIGRATION_PHASE_PERFORM2); ret = doNativeMigrate(driver, vm, uri, cookiein, cookieinlen, cookieout, cookieoutlen, - flags, resource, NULL); + flags, resource, NULL, NULL); } if (ret < 0) goto endjob; @@ -4093,6 +4159,7 @@ qemuMigrationPerformPhase(virQEMUDriverPtr driver, virConnectPtr conn, virDomainObjPtr vm, const char *uri, + const char *graphicsuri, const char *cookiein, int cookieinlen, char **cookieout, @@ -4120,7 +4187,7 @@ qemuMigrationPerformPhase(virQEMUDriverPtr driver, resume = virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING; ret = doNativeMigrate(driver, vm, uri, cookiein, cookieinlen, cookieout, cookieoutlen, - flags, resource, NULL); + flags, resource, NULL, graphicsuri); if (ret < 0 && resume && virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) { @@ -4177,6 +4244,7 @@ qemuMigrationPerform(virQEMUDriverPtr driver, const char *xmlin, const char *dconnuri, const char *uri, + const char *graphicsuri, const char *cookiein, int cookieinlen, char **cookieout, @@ -4187,12 +4255,13 @@ qemuMigrationPerform(virQEMUDriverPtr driver, bool v3proto) { VIR_DEBUG("driver=%p, conn=%p, vm=%p, xmlin=%s, dconnuri=%s, " - "uri=%s, cookiein=%s, cookieinlen=%d, cookieout=%p, " - "cookieoutlen=%p, flags=%lx, dname=%s, resource=%lu, v3proto=%d", + "uri=%s, graphicsuri=%s, " + "cookiein=%s, cookieinlen=%d, cookieout=%p, cookieoutlen=%p, " + "flags=%lx, dname=%s, resource=%lu, v3proto=%d", driver, conn, vm, NULLSTR(xmlin), NULLSTR(dconnuri), - NULLSTR(uri), NULLSTR(cookiein), cookieinlen, - cookieout, cookieoutlen, flags, NULLSTR(dname), - resource, v3proto); + NULLSTR(uri), NULLSTR(graphicsuri), + NULLSTR(cookiein), cookieinlen, cookieout, cookieoutlen, + flags, NULLSTR(dname), resource, v3proto); if ((flags & (VIR_MIGRATE_TUNNELLED | VIR_MIGRATE_PEER2PEER))) { if (cookieinlen) { @@ -4202,9 +4271,9 @@ qemuMigrationPerform(virQEMUDriverPtr driver, } return qemuMigrationPerformJob(driver, conn, vm, xmlin, dconnuri, uri, - cookiein, cookieinlen, cookieout, - cookieoutlen, flags, dname, resource, - v3proto); + graphicsuri, cookiein, cookieinlen, + cookieout, cookieoutlen, + flags, dname, resource, v3proto); } else { if (dconnuri) { virReportError(VIR_ERR_INTERNAL_ERROR, @@ -4214,12 +4283,14 @@ qemuMigrationPerform(virQEMUDriverPtr driver, if (v3proto) { return qemuMigrationPerformPhase(driver, conn, vm, uri, + graphicsuri, cookiein, cookieinlen, cookieout, cookieoutlen, flags, resource); } else { return qemuMigrationPerformJob(driver, conn, vm, xmlin, dconnuri, - uri, cookiein, cookieinlen, + uri, graphicsuri, + cookiein, cookieinlen, cookieout, cookieoutlen, flags, dname, resource, v3proto); } diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h index 65663e9..a67a3fe 100644 --- a/src/qemu/qemu_migration.h +++ b/src/qemu/qemu_migration.h @@ -47,6 +47,7 @@ VIR_MIGRATE_PARAM_DEST_NAME, VIR_TYPED_PARAM_STRING, \ VIR_MIGRATE_PARAM_DEST_XML, VIR_TYPED_PARAM_STRING, \ VIR_MIGRATE_PARAM_BANDWIDTH, VIR_TYPED_PARAM_ULLONG, \ + VIR_MIGRATE_PARAM_GRAPHICS_URI, VIR_TYPED_PARAM_STRING, \ NULL @@ -120,6 +121,7 @@ int qemuMigrationPerform(virQEMUDriverPtr driver, const char *xmlin, const char *dconnuri, const char *uri, + const char *graphicsuri, const char *cookiein, int cookieinlen, char **cookieout, -- 1.8.2.1