When unsupported parameter is passed to virTypedParamsValidate, VIR_ERR_ARGUMENT_UNSUPPORTED should be returned rather than VIR_ERR_INVALID_ARG, which is more appropriate for supported parameters used incorrectly. --- src/util/virtypedparam.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/util/virtypedparam.c b/src/util/virtypedparam.c index 8b2211f..eef9e30 100644 --- a/src/util/virtypedparam.c +++ b/src/util/virtypedparam.c @@ -87,7 +87,7 @@ virTypedParamsValidate(virTypedParameterPtr params, int nparams, ...) name = va_arg(ap, const char *); } if (!name) { - virReportError(VIR_ERR_INVALID_ARG, + virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, _("parameter '%s' not supported"), params[i].field); goto cleanup; -- 1.8.2.1

--- src/libvirt_private.syms | 1 + src/util/virtypedparam.c | 58 ++++++++++++++++++++++++++++++++++++++++++++++++ src/util/virtypedparam.h | 5 +++++ 3 files changed, 64 insertions(+) diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index ae9f356..4e01073 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -1900,6 +1900,7 @@ virTPMCreateCancelPath; virTypedParameterAssign; virTypedParameterAssignFromStr; virTypedParamsCheck; +virTypedParamsReplaceString; virTypedParamsValidate; diff --git a/src/util/virtypedparam.c b/src/util/virtypedparam.c index 825148b..760bb05 100644 --- a/src/util/virtypedparam.c +++ b/src/util/virtypedparam.c @@ -285,6 +285,64 @@ cleanup: } +/** + * virTypedParamsReplaceString: + * @params: pointer to the array of typed parameters + * @nparams: number of parameters in the @params array + * @name: name of the parameter to set + * @value: the value to store into the parameter + * + * Sets new value @value to parameter called @name with char * type. If the + * parameter does not exist yet in @params, it is automatically created and + * @naprams is incremented by one. Otherwise current value of the parameter + * is freed on success. The function creates its own copy of @value string, + * which needs to be freed using virTypedParamsFree or virTypedParamsClear. + * + * Returns 0 on success, -1 on error. + */ +int +virTypedParamsReplaceString(virTypedParameterPtr *params, + int *nparams, + const char *name, + const char *value) +{ + char *str = NULL; + char *old = NULL; + size_t n = *nparams; + virTypedParameterPtr param; + + virResetLastError(); + + param = virTypedParamsGet(*params, n, name); + if (param) { + old = param->value.s; + } else if (VIR_EXPAND_N(*params, n, 1) < 0) { + virReportOOMError(); + goto error; + } else { + param = *params + n - 1; + } + + if (VIR_STRDUP(str, value) < 0) + goto error; + + if (virTypedParameterAssign(param, name, + VIR_TYPED_PARAM_STRING, str) < 0) { + param->value.s = old; + VIR_FREE(str); + goto error; + } + VIR_FREE(old); + + *nparams = n; + return 0; + +error: + virDispatchError(NULL); + return -1; +} + + /* The following APIs are public and their signature may never change. */ /** diff --git a/src/util/virtypedparam.h b/src/util/virtypedparam.h index b0f8522..6eb61c4 100644 --- a/src/util/virtypedparam.h +++ b/src/util/virtypedparam.h @@ -44,4 +44,9 @@ int virTypedParameterAssignFromStr(virTypedParameterPtr param, const char *val) ATTRIBUTE_RETURN_CHECK; +int virTypedParamsReplaceString(virTypedParameterPtr *params, + int *nparams, + const char *name, + const char *value); + #endif /* __VIR_TYPED_PARAM_H */ -- 1.8.2.1

All APIs that take typed parameters are only using params address in their entry point debug messages. With the new VIR_TYPED_PARAMS_DEBUG macro, all functions can easily log all individual typed parameters passed to them. --- docs/apibuild.py | 1 + src/libvirt_private.syms | 3 +++ src/util/virtypedparam.c | 41 ++++++++++++++++++++++++++++++++++++++++- src/util/virtypedparam.h | 18 ++++++++++++++++++ 4 files changed, 62 insertions(+), 1 deletion(-) diff --git a/docs/apibuild.py b/docs/apibuild.py index c816197..e0996bf 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", + "virTypedParameterToString": "internal function in virtypedparam.c", "virTypedParamsCheck": "internal function in virtypedparam.c", } diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 4e01073..0e0c3bc 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -1899,6 +1899,9 @@ virTPMCreateCancelPath; # util/virtypedparam.h virTypedParameterAssign; virTypedParameterAssignFromStr; +virTypedParameterToString; +virTypedParameterTypeFromString; +virTypedParameterTypeToString; virTypedParamsCheck; virTypedParamsReplaceString; virTypedParamsValidate; diff --git a/src/util/virtypedparam.c b/src/util/virtypedparam.c index 760bb05..8b18a5a 100644 --- a/src/util/virtypedparam.c +++ b/src/util/virtypedparam.c @@ -31,7 +31,6 @@ #define VIR_FROM_THIS VIR_FROM_NONE -VIR_ENUM_DECL(virTypedParameter) VIR_ENUM_IMPL(virTypedParameter, VIR_TYPED_PARAM_LAST, "unknown", "int", @@ -135,6 +134,46 @@ virTypedParamsCheck(virTypedParameterPtr params, return true; } +char * +virTypedParameterToString(virTypedParameterPtr param) +{ + char *value; + int ret = -1; + + switch (param->type) { + case VIR_TYPED_PARAM_INT: + ret = virAsprintf(&value, "%d", param->value.i); + break; + case VIR_TYPED_PARAM_UINT: + ret = virAsprintf(&value, "%u", param->value.ui); + break; + case VIR_TYPED_PARAM_LLONG: + ret = virAsprintf(&value, "%lld", param->value.l); + break; + case VIR_TYPED_PARAM_ULLONG: + ret = virAsprintf(&value, "%llu", param->value.ul); + break; + case VIR_TYPED_PARAM_DOUBLE: + ret = virAsprintf(&value, "%g", param->value.d); + break; + case VIR_TYPED_PARAM_BOOLEAN: + ret = virAsprintf(&value, "%d", param->value.b); + break; + case VIR_TYPED_PARAM_STRING: + ret = VIR_STRDUP(value, param->value.s); + break; + default: + virReportError(VIR_ERR_INTERNAL_ERROR, + _("unexpected type %d for field %s"), + param->type, param->field); + } + + if (ret < 0) + return NULL; + else + return value; +} + /* 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 6eb61c4..ca062c0 100644 --- a/src/util/virtypedparam.h +++ b/src/util/virtypedparam.h @@ -24,6 +24,7 @@ # define __VIR_TYPED_PARAM_H_ # include "internal.h" +# include "virutil.h" int virTypedParamsValidate(virTypedParameterPtr params, int nparams, /* const char *name, int type ... */ ...) @@ -49,4 +50,21 @@ int virTypedParamsReplaceString(virTypedParameterPtr *params, const char *name, const char *value); +char *virTypedParameterToString(virTypedParameterPtr param); + +VIR_ENUM_DECL(virTypedParameter) + +# define VIR_TYPED_PARAMS_DEBUG(params, nparams) \ + do { \ + int _i; \ + for (_i = 0; _i < (nparams); _i++) { \ + char *_value = virTypedParameterToString((params) + _i); \ + VIR_DEBUG("params[\"%s\"]=(%s)%s", \ + (params)[_i].field, \ + virTypedParameterTypeToString((params)[_i].type), \ + NULLSTR(_value)); \ + VIR_FREE(_value); \ + } \ + } while (0) + #endif /* __VIR_TYPED_PARAM_H */ -- 1.8.2.1

--- src/libvirt.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/libvirt.c b/src/libvirt.c index db120b7..a6efaf8 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -65,6 +65,7 @@ #include "virthread.h" #include "virstring.h" #include "virutil.h" +#include "virtypedparam.h" #ifdef WITH_TEST # include "test/test_driver.h" @@ -3839,6 +3840,7 @@ virDomainSetMemoryParameters(virDomainPtr domain, VIR_DOMAIN_DEBUG(domain, "params=%p, nparams=%d, flags=%x", params, nparams, flags); + VIR_TYPED_PARAMS_DEBUG(params, nparams); virResetLastError(); @@ -3981,6 +3983,7 @@ virDomainSetNumaParameters(virDomainPtr domain, VIR_DOMAIN_DEBUG(domain, "params=%p, nparams=%d, flags=%x", params, nparams, flags); + VIR_TYPED_PARAMS_DEBUG(params, nparams); virResetLastError(); @@ -4108,6 +4111,7 @@ virDomainSetBlkioParameters(virDomainPtr domain, VIR_DOMAIN_DEBUG(domain, "params=%p, nparams=%d, flags=%x", params, nparams, flags); + VIR_TYPED_PARAMS_DEBUG(params, nparams); virResetLastError(); @@ -6988,6 +6992,7 @@ virNodeSetMemoryParameters(virConnectPtr conn, { VIR_DEBUG("conn=%p, params=%p, nparams=%d, flags=%x", conn, params, nparams, flags); + VIR_TYPED_PARAMS_DEBUG(params, nparams); virResetLastError(); @@ -7228,6 +7233,7 @@ virDomainSetSchedulerParameters(virDomainPtr domain, virConnectPtr conn; VIR_DOMAIN_DEBUG(domain, "params=%p, nparams=%d", params, nparams); + VIR_TYPED_PARAMS_DEBUG(params, nparams); virResetLastError(); @@ -7292,6 +7298,7 @@ virDomainSetSchedulerParametersFlags(virDomainPtr domain, VIR_DOMAIN_DEBUG(domain, "params=%p, nparams=%d, flags=%x", params, nparams, flags); + VIR_TYPED_PARAMS_DEBUG(params, nparams); virResetLastError(); @@ -7574,6 +7581,7 @@ virDomainSetInterfaceParameters(virDomainPtr domain, VIR_DOMAIN_DEBUG(domain, "device=%s, params=%p, nparams=%d, flags=%x", device, params, nparams, flags); + VIR_TYPED_PARAMS_DEBUG(params, nparams); virResetLastError(); @@ -20415,6 +20423,7 @@ int virDomainSetBlockIoTune(virDomainPtr dom, VIR_DOMAIN_DEBUG(dom, "disk=%s, params=%p, nparams=%d, flags=%x", disk, params, nparams, flags); + VIR_TYPED_PARAMS_DEBUG(params, nparams); virResetLastError(); -- 1.8.2.1

To be used by new migration APIs with extensible set of parameters. --- include/libvirt/libvirt.h.in | 56 ++++++++++++++++++++++++++++++++++++++++++++ src/libvirt_internal.h | 5 ++++ 2 files changed, 61 insertions(+) diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index acf3218..35bffea 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -1191,6 +1191,62 @@ typedef enum { VIR_MIGRATE_ABORT_ON_ERROR = (1 << 12), /* abort migration on I/O errors happened during migration */ } virDomainMigrateFlags; + +/** + * VIR_MIGRATE_PARAM_URI: + * + * virDomainMigrate* params field: URI to use for initiating domain migration + * as VIR_TYPED_PARAM_STRING. It takes a hypervisor specific format. The + * uri_transports element of the hypervisor capabilities XML includes details + * of the supported URI schemes. When omitted libvirt will auto-generate + * suitable default URI. It is typically only necessary to specify this URI if + * the destination host has multiple interfaces and a specific interface is + * required to transmit migration data. + * + * This filed may not be used when VIR_MIGRATE_TUNNELLED flag is set. + */ +#define VIR_MIGRATE_PARAM_URI "migrate_uri" + +/** + * VIR_MIGRATE_PARAM_DEST_NAME: + * + * virDomainMigrate* params field: the name to be used for the domain on the + * destination host as VIR_TYPED_PARAM_STRING. Omitting this parameter keeps + * the domain name the same. This field is only allowed to be used with + * hypervisors that support domain renaming during migration. + */ +#define VIR_MIGRATE_PARAM_DEST_NAME "destination_name" + +/** + * VIR_MIGRATE_PARAM_DEST_XML: + * + * virDomainMigrate* params field: the new configuration to be used for the + * domain on the destination host as VIR_TYPED_PARAM_STRING. The configuration + * must include an identical set of virtual devices, to ensure a stable guest + * ABI across migration. Only parameters related to host side configuration + * can be changed in the XML. Hypervisors which support this will validate + * this and refuse to allow migration if the provided XML would cause a change + * in the guest ABI. This field cannot be used to rename the domain during + * migration (use VIR_MIGRATE_PARAM_DEST_NAME field for that purpose). Domain + * name in the destination XML must match the original domain name. + * + * Omitting this parameter keeps the original domain configuration. Using this + * field with hypervisors that do not support changing domain configuration + * during migration will result in a failure. + */ +#define VIR_MIGRATE_PARAM_DEST_XML "destination_xml" + +/** + * VIR_MIGRATE_PARAM_BANDWIDTH: + * + * virDomainMigrate* params field: the maximum bandwidth (in MiB/s) that will + * be used for migration as VIR_TYPED_PARAM_ULLONG. If set to 0 or omitted, + * libvirt will choose a suitable default. Some hypervisors do not support this + * feature and will return an error if this field is used and is not 0. + */ +#define VIR_MIGRATE_PARAM_BANDWIDTH "bandwidth" + + /* Domain migration. */ virDomainPtr virDomainMigrate (virDomainPtr domain, virConnectPtr dconn, unsigned long flags, const char *dname, diff --git a/src/libvirt_internal.h b/src/libvirt_internal.h index 29f2043..434d795 100644 --- a/src/libvirt_internal.h +++ b/src/libvirt_internal.h @@ -110,6 +110,11 @@ enum { * Support for offline migration. */ VIR_DRV_FEATURE_MIGRATION_OFFLINE = 12, + + /* + * Support for migration parameters. + */ + VIR_DRV_FEATURE_MIGRATION_PARAMS = 13, }; -- 1.8.2.1

This patch implements extensible variants of all internal migration APIs used for v3 migration. --- daemon/remote.c | 331 ++++++++++++++++++++++++++++++++++++++++++- docs/apibuild.py | 6 + docs/hvsupport.pl | 7 + src/driver.h | 67 +++++++++ src/libvirt.c | 324 ++++++++++++++++++++++++++++++++++++++++++ src/libvirt_internal.h | 54 +++++++ src/libvirt_private.syms | 6 + src/remote/remote_protocol.x | 96 ++++++++++++- src/remote_protocol-structs | 107 ++++++++++++++ 9 files changed, 996 insertions(+), 2 deletions(-) diff --git a/daemon/remote.c b/daemon/remote.c index 47267c2..ba11379 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -885,7 +885,7 @@ remoteDeserializeTypedParameters(remote_typed_param *args_params_val, virTypedParameterPtr params = NULL; /* Check the length of the returned list carefully. */ - if (args_params_len > limit) { + if (limit && args_params_len > limit) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("nparams too large")); goto cleanup; } @@ -4677,6 +4677,335 @@ cleanup: return rv; } +static int +remoteDispatchDomainMigrateBegin3Params( + virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client ATTRIBUTE_UNUSED, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr, + remote_domain_migrate_begin3_params_args *args, + remote_domain_migrate_begin3_params_ret *ret) +{ + char *xml = NULL; + virDomainPtr dom = NULL; + virTypedParameterPtr params = NULL; + int nparams = 0; + char *cookieout = NULL; + int cookieoutlen = 0; + int rv = -1; + struct daemonClientPrivate *priv = + virNetServerClientGetPrivateData(client); + + if (!priv->conn) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + if (!(dom = get_nonnull_domain(priv->conn, args->dom))) + goto cleanup; + + if (!(params = remoteDeserializeTypedParameters(args->params.params_val, + args->params.params_len, + 0, &nparams))) + goto cleanup; + + if (!(xml = virDomainMigrateBegin3Params(dom, params, nparams, + &cookieout, &cookieoutlen, + args->flags))) + goto cleanup; + + ret->cookie_out.cookie_out_len = cookieoutlen; + ret->cookie_out.cookie_out_val = cookieout; + ret->xml = xml; + + rv = 0; + +cleanup: + virTypedParamsFree(params, nparams); + if (rv < 0) + virNetMessageSaveError(rerr); + if (dom) + virDomainFree(dom); + return rv; +} + +static int +remoteDispatchDomainMigratePrepare3Params( + virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client ATTRIBUTE_UNUSED, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr, + remote_domain_migrate_prepare3_params_args *args, + remote_domain_migrate_prepare3_params_ret *ret) +{ + virTypedParameterPtr params = NULL; + int nparams = 0; + char *cookieout = NULL; + int cookieoutlen = 0; + char **uri_out; + int rv = -1; + struct daemonClientPrivate *priv = + virNetServerClientGetPrivateData(client); + + if (!priv->conn) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + if (!(params = remoteDeserializeTypedParameters(args->params.params_val, + args->params.params_len, + 0, &nparams))) + goto cleanup; + + /* Wacky world of XDR ... */ + if (VIR_ALLOC(uri_out) < 0) { + virReportOOMError(); + goto cleanup; + } + + if (virDomainMigratePrepare3Params(priv->conn, params, nparams, + args->cookie_in.cookie_in_val, + args->cookie_in.cookie_in_len, + &cookieout, &cookieoutlen, + uri_out, args->flags) < 0) + goto cleanup; + + ret->cookie_out.cookie_out_len = cookieoutlen; + ret->cookie_out.cookie_out_val = cookieout; + ret->uri_out = !*uri_out ? NULL : uri_out; + + rv = 0; + +cleanup: + virTypedParamsFree(params, nparams); + if (rv < 0) { + virNetMessageSaveError(rerr); + VIR_FREE(uri_out); + } + return rv; +} + +static int +remoteDispatchDomainMigratePrepareTunnel3Params( + virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr, + remote_domain_migrate_prepare_tunnel3_params_args *args, + remote_domain_migrate_prepare_tunnel3_params_ret *ret) +{ + virTypedParameterPtr params = NULL; + int nparams = 0; + char *cookieout = NULL; + int cookieoutlen = 0; + int rv = -1; + struct daemonClientPrivate *priv = + virNetServerClientGetPrivateData(client); + virStreamPtr st = NULL; + daemonClientStreamPtr stream = NULL; + + if (!priv->conn) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + if (!(params = remoteDeserializeTypedParameters(args->params.params_val, + args->params.params_len, + 0, &nparams))) + goto cleanup; + + if (!(st = virStreamNew(priv->conn, VIR_STREAM_NONBLOCK)) || + !(stream = daemonCreateClientStream(client, st, remoteProgram, + &msg->header))) + goto cleanup; + + if (virDomainMigratePrepareTunnel3Params(priv->conn, st, params, nparams, + args->cookie_in.cookie_in_val, + args->cookie_in.cookie_in_len, + &cookieout, &cookieoutlen, + args->flags) < 0) + goto cleanup; + + if (daemonAddClientStream(client, stream, false) < 0) + goto cleanup; + + ret->cookie_out.cookie_out_val = cookieout; + ret->cookie_out.cookie_out_len = cookieoutlen; + rv = 0; + +cleanup: + virTypedParamsFree(params, nparams); + if (rv < 0) { + virNetMessageSaveError(rerr); + VIR_FREE(cookieout); + if (stream) { + virStreamAbort(st); + daemonFreeClientStream(client, stream); + } else { + virStreamFree(st); + } + } + return rv; +} + + +static int +remoteDispatchDomainMigratePerform3Params( + virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client ATTRIBUTE_UNUSED, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr, + remote_domain_migrate_perform3_params_args *args, + remote_domain_migrate_perform3_params_ret *ret) +{ + virTypedParameterPtr params = NULL; + int nparams = 0; + virDomainPtr dom = NULL; + char *cookieout = NULL; + int cookieoutlen = 0; + char *dconnuri; + int rv = -1; + struct daemonClientPrivate *priv = + virNetServerClientGetPrivateData(client); + + if (!priv->conn) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + if (!(dom = get_nonnull_domain(priv->conn, args->dom))) + goto cleanup; + + if (!(params = remoteDeserializeTypedParameters(args->params.params_val, + args->params.params_len, + 0, &nparams))) + goto cleanup; + + dconnuri = args->dconnuri == NULL ? NULL : *args->dconnuri; + + if (virDomainMigratePerform3Params(dom, dconnuri, params, nparams, + args->cookie_in.cookie_in_val, + args->cookie_in.cookie_in_len, + &cookieout, &cookieoutlen, + args->flags) < 0) + goto cleanup; + + ret->cookie_out.cookie_out_len = cookieoutlen; + ret->cookie_out.cookie_out_val = cookieout; + + rv = 0; + +cleanup: + virTypedParamsFree(params, nparams); + if (rv < 0) + virNetMessageSaveError(rerr); + if (dom) + virDomainFree(dom); + return rv; +} + + +static int +remoteDispatchDomainMigrateFinish3Params( + virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client ATTRIBUTE_UNUSED, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr, + remote_domain_migrate_finish3_params_args *args, + remote_domain_migrate_finish3_params_ret *ret) +{ + virTypedParameterPtr params = NULL; + int nparams = 0; + virDomainPtr dom = NULL; + char *cookieout = NULL; + int cookieoutlen = 0; + int rv = -1; + struct daemonClientPrivate *priv = + virNetServerClientGetPrivateData(client); + + if (!priv->conn) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + if (!(params = remoteDeserializeTypedParameters(args->params.params_val, + args->params.params_len, + 0, &nparams))) + goto cleanup; + + dom = virDomainMigrateFinish3Params(priv->conn, params, nparams, + args->cookie_in.cookie_in_val, + args->cookie_in.cookie_in_len, + &cookieout, &cookieoutlen, + args->flags, args->cancelled); + if (!dom) + goto cleanup; + + make_nonnull_domain(&ret->dom, dom); + + ret->cookie_out.cookie_out_len = cookieoutlen; + ret->cookie_out.cookie_out_val = cookieout; + + rv = 0; + +cleanup: + virTypedParamsFree(params, nparams); + if (rv < 0) { + virNetMessageSaveError(rerr); + VIR_FREE(cookieout); + } + if (dom) + virDomainFree(dom); + return rv; +} + + +static int +remoteDispatchDomainMigrateConfirm3Params( + virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client ATTRIBUTE_UNUSED, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr, + remote_domain_migrate_confirm3_params_args *args) +{ + virTypedParameterPtr params = NULL; + int nparams = 0; + virDomainPtr dom = NULL; + int rv = -1; + struct daemonClientPrivate *priv = + virNetServerClientGetPrivateData(client); + + if (!priv->conn) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + if (!(dom = get_nonnull_domain(priv->conn, args->dom))) + goto cleanup; + + if (!(params = remoteDeserializeTypedParameters(args->params.params_val, + args->params.params_len, + 0, &nparams))) + goto cleanup; + + if (virDomainMigrateConfirm3Params(dom, params, nparams, + args->cookie_in.cookie_in_val, + args->cookie_in.cookie_in_len, + args->flags, args->cancelled) < 0) + goto cleanup; + + rv = 0; + +cleanup: + virTypedParamsFree(params, nparams); + if (rv < 0) + virNetMessageSaveError(rerr); + if (dom) + virDomainFree(dom); + return rv; +} + + /*----- Helpers. -----*/ /* get_nonnull_domain and get_nonnull_network turn an on-wire diff --git a/docs/apibuild.py b/docs/apibuild.py index aca2370..e65c559 100755 --- a/docs/apibuild.py +++ b/docs/apibuild.py @@ -70,6 +70,12 @@ ignored_functions = { "virTypedParameterToString": "internal function in virtypedparam.c", "virTypedParamsCheck": "internal function in virtypedparam.c", "virTypedParamsCopy": "internal function in virtypedparam.c", + "virDomainMigrateBegin3Params": "private function for migration", + "virDomainMigrateFinish3Params": "private function for migration", + "virDomainMigratePerform3Params": "private function for migration", + "virDomainMigratePrepare3Params": "private function for migration", + "virDomainMigrateConfirm3Params": "private function for migration", + "virDomainMigratePrepareTunnel3Params": "private function for tunnelled migration", } ignored_macros = { diff --git a/docs/hvsupport.pl b/docs/hvsupport.pl index e31441e..c774ada 100755 --- a/docs/hvsupport.pl +++ b/docs/hvsupport.pl @@ -169,6 +169,13 @@ $apis{virDomainMigratePerform3} = "0.9.2"; $apis{virDomainMigrateFinish3} = "0.9.2"; $apis{virDomainMigrateConfirm3} = "0.9.2"; +$apis{virDomainMigrateBegin3Params} = "1.0.7"; +$apis{virDomainMigratePrepare3Params} = "1.0.7"; +$apis{virDomainMigratePrepareTunnel3Params} = "1.0.7"; +$apis{virDomainMigratePerform3Params} = "1.0.7"; +$apis{virDomainMigrateFinish3Params} = "1.0.7"; +$apis{virDomainMigrateConfirm3Params} = "1.0.7"; + # Now we want to get the mapping between public APIs diff --git a/src/driver.h b/src/driver.h index ec5fc53..31851cb 100644 --- a/src/driver.h +++ b/src/driver.h @@ -1045,6 +1045,67 @@ typedef int int **fdlist, unsigned int flags); +typedef char * +(*virDrvDomainMigrateBegin3Params)(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + char **cookieout, + int *cookieoutlen, + unsigned int flags); + +typedef int +(*virDrvDomainMigratePrepare3Params)(virConnectPtr dconn, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + char **uri_out, + unsigned int flags); + +typedef int +(*virDrvDomainMigratePrepareTunnel3Params)(virConnectPtr dconn, + virStreamPtr st, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned int flags); + +typedef int +(*virDrvDomainMigratePerform3Params)(virDomainPtr dom, + const char *dconnuri, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned int flags); + +typedef virDomainPtr +(*virDrvDomainMigrateFinish3Params)(virConnectPtr dconn, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned int flags, + int cancelled); + +typedef int +(*virDrvDomainMigrateConfirm3Params)(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + unsigned int flags, + int cancelled); + typedef struct _virDriver virDriver; typedef virDriver *virDriverPtr; @@ -1246,6 +1307,12 @@ struct _virDriver { virDrvDomainFSTrim domainFSTrim; virDrvDomainSendProcessSignal domainSendProcessSignal; virDrvDomainLxcOpenNamespace domainLxcOpenNamespace; + virDrvDomainMigrateBegin3Params domainMigrateBegin3Params; + virDrvDomainMigratePrepare3Params domainMigratePrepare3Params; + virDrvDomainMigratePrepareTunnel3Params domainMigratePrepareTunnel3Params; + virDrvDomainMigratePerform3Params domainMigratePerform3Params; + virDrvDomainMigrateFinish3Params domainMigrateFinish3Params; + virDrvDomainMigrateConfirm3Params domainMigrateConfirm3Params; }; diff --git a/src/libvirt.c b/src/libvirt.c index a6efaf8..d6ded5e 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -6542,6 +6542,330 @@ error: } +/* + * Not for public use. This function is part of the internal + * implementation of migration in the remote case. + */ +char * +virDomainMigrateBegin3Params(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + char **cookieout, + int *cookieoutlen, + unsigned int flags) +{ + virConnectPtr conn; + + VIR_DOMAIN_DEBUG(domain, "params=%p, nparams=%d, " + "cookieout=%p, cookieoutlen=%p, flags=%x", + params, nparams, cookieout, cookieoutlen, flags); + VIR_TYPED_PARAMS_DEBUG(params, nparams); + + virResetLastError(); + + if (!VIR_IS_CONNECTED_DOMAIN(domain)) { + virLibDomainError(VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + virDispatchError(NULL); + return NULL; + } + conn = domain->conn; + + if (domain->conn->flags & VIR_CONNECT_RO) { + virLibDomainError(VIR_ERR_OPERATION_DENIED, __FUNCTION__); + goto error; + } + + if (conn->driver->domainMigrateBegin3Params) { + char *xml; + xml = conn->driver->domainMigrateBegin3Params(domain, params, nparams, + cookieout, cookieoutlen, + flags); + VIR_DEBUG("xml %s", NULLSTR(xml)); + if (!xml) + goto error; + return xml; + } + + virLibDomainError(VIR_ERR_NO_SUPPORT, __FUNCTION__); + +error: + virDispatchError(domain->conn); + return NULL; +} + + +/* + * Not for public use. This function is part of the internal + * implementation of migration in the remote case. + */ +int +virDomainMigratePrepare3Params(virConnectPtr dconn, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + char **uri_out, + unsigned int flags) +{ + VIR_DEBUG("dconn=%p, params=%p, nparams=%d, cookiein=%p, cookieinlen=%d, " + "cookieout=%p, cookieoutlen=%p, uri_out=%p, flags=%x", + dconn, params, nparams, cookiein, cookieinlen, + cookieout, cookieoutlen, uri_out, flags); + VIR_TYPED_PARAMS_DEBUG(params, nparams); + + virResetLastError(); + + if (!VIR_IS_CONNECT(dconn)) { + virLibConnError(VIR_ERR_INVALID_CONN, __FUNCTION__); + virDispatchError(NULL); + return -1; + } + + if (dconn->flags & VIR_CONNECT_RO) { + virLibConnError(VIR_ERR_OPERATION_DENIED, __FUNCTION__); + goto error; + } + + if (dconn->driver->domainMigratePrepare3Params) { + int ret; + ret = dconn->driver->domainMigratePrepare3Params(dconn, params, nparams, + cookiein, cookieinlen, + cookieout, cookieoutlen, + uri_out, flags); + if (ret < 0) + goto error; + return ret; + } + + virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__); + +error: + virDispatchError(dconn); + return -1; +} + + +/* + * Not for public use. This function is part of the internal + * implementation of migration in the remote case. + */ +int +virDomainMigratePrepareTunnel3Params(virConnectPtr conn, + virStreamPtr st, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned int flags) + +{ + VIR_DEBUG("conn=%p, stream=%p, params=%p, nparams=%d, cookiein=%p, " + "cookieinlen=%d, cookieout=%p, cookieoutlen=%p, flags=%x", + conn, st, params, nparams, cookiein, cookieinlen, + cookieout, cookieoutlen, flags); + VIR_TYPED_PARAMS_DEBUG(params, nparams); + + virResetLastError(); + + if (!VIR_IS_CONNECT(conn)) { + virLibConnError(VIR_ERR_INVALID_CONN, __FUNCTION__); + virDispatchError(NULL); + return -1; + } + + if (conn->flags & VIR_CONNECT_RO) { + virLibConnError(VIR_ERR_OPERATION_DENIED, __FUNCTION__); + goto error; + } + + if (conn != st->conn) { + virReportInvalidArg(conn, + _("conn in %s must match stream connection"), + __FUNCTION__); + goto error; + } + + if (conn->driver->domainMigratePrepareTunnel3Params) { + int rv; + rv = conn->driver->domainMigratePrepareTunnel3Params( + conn, st, params, nparams, cookiein, cookieinlen, + cookieout, cookieoutlen, flags); + if (rv < 0) + goto error; + return rv; + } + + virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__); + +error: + virDispatchError(conn); + return -1; +} + + +/* + * Not for public use. This function is part of the internal + * implementation of migration in the remote case. + */ +int +virDomainMigratePerform3Params(virDomainPtr domain, + const char *dconnuri, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned int flags) +{ + virConnectPtr conn; + + VIR_DOMAIN_DEBUG(domain, "dconnuri=%s, params=%p, nparams=%d, cookiein=%p, " + "cookieinlen=%d, cookieout=%p, cookieoutlen=%p, flags=%x", + NULLSTR(dconnuri), params, nparams, cookiein, + cookieinlen, cookieout, cookieoutlen, flags); + VIR_TYPED_PARAMS_DEBUG(params, nparams); + + virResetLastError(); + + if (!VIR_IS_CONNECTED_DOMAIN(domain)) { + virLibDomainError(VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + virDispatchError(NULL); + return -1; + } + conn = domain->conn; + + if (domain->conn->flags & VIR_CONNECT_RO) { + virLibDomainError(VIR_ERR_OPERATION_DENIED, __FUNCTION__); + goto error; + } + + if (conn->driver->domainMigratePerform3Params) { + int ret; + ret = conn->driver->domainMigratePerform3Params( + domain, dconnuri, params, nparams, cookiein, cookieinlen, + cookieout, cookieoutlen, flags); + if (ret < 0) + goto error; + return ret; + } + + virLibDomainError(VIR_ERR_NO_SUPPORT, __FUNCTION__); + +error: + virDispatchError(domain->conn); + return -1; +} + + +/* + * Not for public use. This function is part of the internal + * implementation of migration in the remote case. + */ +virDomainPtr +virDomainMigrateFinish3Params(virConnectPtr dconn, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned int flags, + int cancelled) +{ + VIR_DEBUG("dconn=%p, params=%p, nparams=%d, cookiein=%p, cookieinlen=%d, " + "cookieout=%p, cookieoutlen=%p, flags=%x, cancelled=%d", + dconn, params, nparams, cookiein, cookieinlen, cookieout, + cookieoutlen, flags, cancelled); + VIR_TYPED_PARAMS_DEBUG(params, nparams); + + virResetLastError(); + + if (!VIR_IS_CONNECT(dconn)) { + virLibConnError(VIR_ERR_INVALID_CONN, __FUNCTION__); + virDispatchError(NULL); + return NULL; + } + + if (dconn->flags & VIR_CONNECT_RO) { + virLibConnError(VIR_ERR_OPERATION_DENIED, __FUNCTION__); + goto error; + } + + if (dconn->driver->domainMigrateFinish3Params) { + virDomainPtr ret; + ret = dconn->driver->domainMigrateFinish3Params( + dconn, params, nparams, cookiein, cookieinlen, + cookieout, cookieoutlen, flags, cancelled); + if (!ret) + goto error; + return ret; + } + + virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__); + +error: + virDispatchError(dconn); + return NULL; +} + + +/* + * Not for public use. This function is part of the internal + * implementation of migration in the remote case. + */ +int +virDomainMigrateConfirm3Params(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + unsigned int flags, + int cancelled) +{ + virConnectPtr conn; + + VIR_DOMAIN_DEBUG(domain, "params=%p, nparams=%d, cookiein=%p, " + "cookieinlen=%d, flags=%x, cancelled=%d", + params, nparams, cookiein, cookieinlen, flags, cancelled); + VIR_TYPED_PARAMS_DEBUG(params, nparams); + + virResetLastError(); + + if (!VIR_IS_CONNECTED_DOMAIN(domain)) { + virLibDomainError(VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + virDispatchError(NULL); + return -1; + } + conn = domain->conn; + + if (domain->conn->flags & VIR_CONNECT_RO) { + virLibDomainError(VIR_ERR_OPERATION_DENIED, __FUNCTION__); + goto error; + } + + if (conn->driver->domainMigrateConfirm3Params) { + int ret; + ret = conn->driver->domainMigrateConfirm3Params( + domain, params, nparams, + cookiein, cookieinlen, flags, cancelled); + if (ret < 0) + goto error; + return ret; + } + + virLibDomainError(VIR_ERR_NO_SUPPORT, __FUNCTION__); + +error: + virDispatchError(domain->conn); + return -1; +} + + /** * virNodeGetInfo: * @conn: pointer to the hypervisor connection diff --git a/src/libvirt_internal.h b/src/libvirt_internal.h index 434d795..115d8d1 100644 --- a/src/libvirt_internal.h +++ b/src/libvirt_internal.h @@ -226,4 +226,58 @@ int virDomainMigrateConfirm3(virDomainPtr domain, unsigned long flags, int restart); /* Restart the src VM */ +char *virDomainMigrateBegin3Params(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + char **cookieout, + int *cookieoutlen, + unsigned int flags); + +int virDomainMigratePrepare3Params(virConnectPtr dconn, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + char **uri_out, + unsigned int flags); + +int virDomainMigratePrepareTunnel3Params(virConnectPtr conn, + virStreamPtr st, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned int flags); + +int virDomainMigratePerform3Params(virDomainPtr domain, + const char *dconnuri, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned int flags); + +virDomainPtr virDomainMigrateFinish3Params(virConnectPtr dconn, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned int flags, + int cancelled); + +int virDomainMigrateConfirm3Params(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + unsigned int flags, + int cancelled); #endif diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index fa1041c..bb5f91e 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -709,17 +709,23 @@ virFDStreamSetIOHelper; # libvirt_internal.h virConnectSupportsFeature; virDomainMigrateBegin3; +virDomainMigrateBegin3Params; virDomainMigrateConfirm3; +virDomainMigrateConfirm3Params; virDomainMigrateFinish; virDomainMigrateFinish2; virDomainMigrateFinish3; +virDomainMigrateFinish3Params; virDomainMigratePerform; virDomainMigratePerform3; +virDomainMigratePerform3Params; virDomainMigratePrepare; virDomainMigratePrepare2; virDomainMigratePrepare3; +virDomainMigratePrepare3Params; virDomainMigratePrepareTunnel; virDomainMigratePrepareTunnel3; +virDomainMigratePrepareTunnel3Params; virRegisterDriver; virRegisterInterfaceDriver; virRegisterNetworkDriver; diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index 9723377..b506f99 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -2744,6 +2744,70 @@ struct remote_domain_fstrim_args { unsigned int flags; }; +struct remote_domain_migrate_begin3_params_args { + remote_nonnull_domain dom; + remote_typed_param params<>; + unsigned int flags; +}; + +struct remote_domain_migrate_begin3_params_ret { + opaque cookie_out<REMOTE_MIGRATE_COOKIE_MAX>; + remote_nonnull_string xml; +}; + +struct remote_domain_migrate_prepare3_params_args { + remote_typed_param params<>; + opaque cookie_in<REMOTE_MIGRATE_COOKIE_MAX>; + unsigned int flags; +}; + +struct remote_domain_migrate_prepare3_params_ret { + opaque cookie_out<REMOTE_MIGRATE_COOKIE_MAX>; + remote_string uri_out; +}; + +struct remote_domain_migrate_prepare_tunnel3_params_args { + remote_typed_param params<>; + opaque cookie_in<REMOTE_MIGRATE_COOKIE_MAX>; + unsigned int flags; +}; + +struct remote_domain_migrate_prepare_tunnel3_params_ret { + opaque cookie_out<REMOTE_MIGRATE_COOKIE_MAX>; +}; + +struct remote_domain_migrate_perform3_params_args { + remote_nonnull_domain dom; + remote_string dconnuri; + remote_typed_param params<>; + opaque cookie_in<REMOTE_MIGRATE_COOKIE_MAX>; + unsigned int flags; +}; + +struct remote_domain_migrate_perform3_params_ret { + opaque cookie_out<REMOTE_MIGRATE_COOKIE_MAX>; +}; + +struct remote_domain_migrate_finish3_params_args { + remote_typed_param params<>; + opaque cookie_in<REMOTE_MIGRATE_COOKIE_MAX>; + unsigned int flags; + int cancelled; +}; + +struct remote_domain_migrate_finish3_params_ret { + remote_nonnull_domain dom; + opaque cookie_out<REMOTE_MIGRATE_COOKIE_MAX>; +}; + +struct remote_domain_migrate_confirm3_params_args { + remote_nonnull_domain dom; + remote_typed_param params<>; + opaque cookie_in<REMOTE_MIGRATE_COOKIE_MAX>; + unsigned int flags; + int cancelled; +}; + /*----- Protocol. -----*/ /* Define the program number, protocol version and procedure numbers here. */ @@ -4434,6 +4498,36 @@ enum remote_procedure { /** * @generate: server */ - REMOTE_PROC_NODE_DEVICE_DETACH_FLAGS = 301 + REMOTE_PROC_NODE_DEVICE_DETACH_FLAGS = 301, + + /** + * @generate: none + */ + REMOTE_PROC_DOMAIN_MIGRATE_BEGIN3_PARAMS = 302, + + /** + * @generate: none + */ + REMOTE_PROC_DOMAIN_MIGRATE_PREPARE3_PARAMS = 303, + + /** + * @generate: none + */ + REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL3_PARAMS = 304, + + /** + * @generate: none + */ + REMOTE_PROC_DOMAIN_MIGRATE_PERFORM3_PARAMS = 305, + + /** + * @generate: none + */ + REMOTE_PROC_DOMAIN_MIGRATE_FINISH3_PARAMS = 306, + + /** + * @generate: none + */ + REMOTE_PROC_DOMAIN_MIGRATE_CONFIRM3_PARAMS = 307 }; diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs index ea38ea2..e38d24a 100644 --- a/src/remote_protocol-structs +++ b/src/remote_protocol-structs @@ -2192,6 +2192,107 @@ struct remote_domain_fstrim_args { uint64_t minimum; u_int flags; }; +struct remote_domain_migrate_begin3_params_args { + remote_nonnull_domain dom; + struct { + u_int params_len; + remote_typed_param * params_val; + } params; + u_int flags; +}; +struct remote_domain_migrate_begin3_params_ret { + struct { + u_int cookie_out_len; + char * cookie_out_val; + } cookie_out; + remote_nonnull_string xml; +}; +struct remote_domain_migrate_prepare3_params_args { + struct { + u_int params_len; + remote_typed_param * params_val; + } params; + struct { + u_int cookie_in_len; + char * cookie_in_val; + } cookie_in; + u_int flags; +}; +struct remote_domain_migrate_prepare3_params_ret { + struct { + u_int cookie_out_len; + char * cookie_out_val; + } cookie_out; + remote_string uri_out; +}; +struct remote_domain_migrate_prepare_tunnel3_params_args { + struct { + u_int params_len; + remote_typed_param * params_val; + } params; + struct { + u_int cookie_in_len; + char * cookie_in_val; + } cookie_in; + u_int flags; +}; +struct remote_domain_migrate_prepare_tunnel3_params_ret { + struct { + u_int cookie_out_len; + char * cookie_out_val; + } cookie_out; +}; +struct remote_domain_migrate_perform3_params_args { + remote_nonnull_domain dom; + remote_string dconnuri; + struct { + u_int params_len; + remote_typed_param * params_val; + } params; + struct { + u_int cookie_in_len; + char * cookie_in_val; + } cookie_in; + u_int flags; +}; +struct remote_domain_migrate_perform3_params_ret { + struct { + u_int cookie_out_len; + char * cookie_out_val; + } cookie_out; +}; +struct remote_domain_migrate_finish3_params_args { + struct { + u_int params_len; + remote_typed_param * params_val; + } params; + struct { + u_int cookie_in_len; + char * cookie_in_val; + } cookie_in; + u_int flags; + int cancelled; +}; +struct remote_domain_migrate_finish3_params_ret { + remote_nonnull_domain dom; + struct { + u_int cookie_out_len; + char * cookie_out_val; + } cookie_out; +}; +struct remote_domain_migrate_confirm3_params_args { + remote_nonnull_domain dom; + struct { + u_int params_len; + remote_typed_param * params_val; + } params; + struct { + u_int cookie_in_len; + char * cookie_in_val; + } cookie_in; + u_int flags; + int cancelled; +}; enum remote_procedure { REMOTE_PROC_CONNECT_OPEN = 1, REMOTE_PROC_CONNECT_CLOSE = 2, @@ -2494,4 +2595,10 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_MIGRATE_GET_COMPRESSION_CACHE = 299, REMOTE_PROC_DOMAIN_MIGRATE_SET_COMPRESSION_CACHE = 300, REMOTE_PROC_NODE_DEVICE_DETACH_FLAGS = 301, + REMOTE_PROC_DOMAIN_MIGRATE_BEGIN3_PARAMS = 302, + REMOTE_PROC_DOMAIN_MIGRATE_PREPARE3_PARAMS = 303, + REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL3_PARAMS = 304, + REMOTE_PROC_DOMAIN_MIGRATE_PERFORM3_PARAMS = 305, + REMOTE_PROC_DOMAIN_MIGRATE_FINISH3_PARAMS = 306, + REMOTE_PROC_DOMAIN_MIGRATE_CONFIRM3_PARAMS = 307, }; -- 1.8.2.1

--- src/remote/remote_driver.c | 398 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 398 insertions(+) diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index 87c61f4..4b3a514 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -6042,6 +6042,398 @@ done: } +static char * +remoteDomainMigrateBegin3Params(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + char **cookieout, + int *cookieoutlen, + unsigned int flags) +{ + char *rv = NULL; + remote_domain_migrate_begin3_params_args args; + remote_domain_migrate_begin3_params_ret ret; + struct private_data *priv = domain->conn->privateData; + + remoteDriverLock(priv); + + memset(&args, 0, sizeof(args)); + memset(&ret, 0, sizeof(ret)); + + make_nonnull_domain(&args.dom, domain); + args.flags = flags; + + if (remoteSerializeTypedParameters(params, nparams, + &args.params.params_val, + &args.params.params_len) < 0) { + xdr_free((xdrproc_t) xdr_remote_domain_migrate_begin3_params_args, + (char *) &args); + goto cleanup; + } + + if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_BEGIN3_PARAMS, + (xdrproc_t) xdr_remote_domain_migrate_begin3_params_args, + (char *) &args, + (xdrproc_t) xdr_remote_domain_migrate_begin3_params_ret, + (char *) &ret) == -1) + goto cleanup; + + if (ret.cookie_out.cookie_out_len > 0) { + if (!cookieout || !cookieoutlen) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("caller ignores cookieout or cookieoutlen")); + goto error; + } + *cookieout = ret.cookie_out.cookie_out_val; /* Caller frees. */ + *cookieoutlen = ret.cookie_out.cookie_out_len; + } + + rv = ret.xml; /* caller frees */ + +cleanup: + remoteFreeTypedParameters(args.params.params_val, args.params.params_len); + remoteDriverUnlock(priv); + return rv; + +error: + VIR_FREE(ret.cookie_out.cookie_out_val); + goto cleanup; +} + + +static int +remoteDomainMigratePrepare3Params(virConnectPtr dconn, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + char **uri_out, + unsigned int flags) +{ + int rv = -1; + remote_domain_migrate_prepare3_params_args args; + remote_domain_migrate_prepare3_params_ret ret; + struct private_data *priv = dconn->privateData; + + remoteDriverLock(priv); + + memset(&args, 0, sizeof(args)); + memset(&ret, 0, sizeof(ret)); + + if (remoteSerializeTypedParameters(params, nparams, + &args.params.params_val, + &args.params.params_len) < 0) { + xdr_free((xdrproc_t) xdr_remote_domain_migrate_prepare3_params_args, + (char *) &args); + goto cleanup; + } + + args.cookie_in.cookie_in_val = (char *)cookiein; + args.cookie_in.cookie_in_len = cookieinlen; + args.flags = flags; + + if (call(dconn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_PREPARE3_PARAMS, + (xdrproc_t) xdr_remote_domain_migrate_prepare3_params_args, + (char *) &args, + (xdrproc_t) xdr_remote_domain_migrate_prepare3_params_ret, + (char *) &ret) == -1) + goto cleanup; + + if (ret.cookie_out.cookie_out_len > 0) { + if (!cookieout || !cookieoutlen) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("caller ignores cookieout or cookieoutlen")); + goto error; + } + *cookieout = ret.cookie_out.cookie_out_val; /* Caller frees. */ + *cookieoutlen = ret.cookie_out.cookie_out_len; + } + if (ret.uri_out) { + if (!uri_out) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("caller ignores uri_out")); + goto error; + } + *uri_out = *ret.uri_out; /* Caller frees. */ + } + + rv = 0; + +cleanup: + remoteFreeTypedParameters(args.params.params_val, args.params.params_len); + VIR_FREE(ret.uri_out); + remoteDriverUnlock(priv); + return rv; + +error: + VIR_FREE(ret.cookie_out.cookie_out_val); + if (ret.uri_out) + VIR_FREE(*ret.uri_out); + goto cleanup; +} + + +static int +remoteDomainMigratePrepareTunnel3Params(virConnectPtr dconn, + virStreamPtr st, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned int flags) +{ + struct private_data *priv = dconn->privateData; + int rv = -1; + remote_domain_migrate_prepare_tunnel3_params_args args; + remote_domain_migrate_prepare_tunnel3_params_ret ret; + virNetClientStreamPtr netst; + + remoteDriverLock(priv); + + memset(&args, 0, sizeof(args)); + memset(&ret, 0, sizeof(ret)); + + args.cookie_in.cookie_in_val = (char *)cookiein; + args.cookie_in.cookie_in_len = cookieinlen; + args.flags = flags; + + if (remoteSerializeTypedParameters(params, nparams, + &args.params.params_val, + &args.params.params_len) < 0) { + xdr_free((xdrproc_t) xdr_remote_domain_migrate_prepare_tunnel3_params_args, + (char *) &args); + goto cleanup; + } + + if (!(netst = virNetClientStreamNew(priv->remoteProgram, + REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL3_PARAMS, + priv->counter))) + goto cleanup; + + if (virNetClientAddStream(priv->client, netst) < 0) { + virObjectUnref(netst); + goto cleanup; + } + + st->driver = &remoteStreamDrv; + st->privateData = netst; + + if (call(dconn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL3_PARAMS, + (xdrproc_t) xdr_remote_domain_migrate_prepare_tunnel3_params_args, + (char *) &args, + (xdrproc_t) xdr_remote_domain_migrate_prepare_tunnel3_params_ret, + (char *) &ret) == -1) { + virNetClientRemoveStream(priv->client, netst); + virObjectUnref(netst); + goto cleanup; + } + + if (ret.cookie_out.cookie_out_len > 0) { + if (!cookieout || !cookieoutlen) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("caller ignores cookieout or cookieoutlen")); + goto error; + } + *cookieout = ret.cookie_out.cookie_out_val; /* Caller frees. */ + *cookieoutlen = ret.cookie_out.cookie_out_len; + } + + rv = 0; + +cleanup: + remoteFreeTypedParameters(args.params.params_val, args.params.params_len); + remoteDriverUnlock(priv); + return rv; + +error: + VIR_FREE(ret.cookie_out.cookie_out_val); + goto cleanup; +} + + +static int +remoteDomainMigratePerform3Params(virDomainPtr dom, + const char *dconnuri, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned int flags) +{ + int rv = -1; + remote_domain_migrate_perform3_params_args args; + remote_domain_migrate_perform3_params_ret ret; + struct private_data *priv = dom->conn->privateData; + + remoteDriverLock(priv); + + memset(&args, 0, sizeof(args)); + memset(&ret, 0, sizeof(ret)); + + make_nonnull_domain(&args.dom, dom); + args.dconnuri = dconnuri == NULL ? NULL : (char **) &dconnuri; + args.cookie_in.cookie_in_val = (char *)cookiein; + args.cookie_in.cookie_in_len = cookieinlen; + args.flags = flags; + + if (remoteSerializeTypedParameters(params, nparams, + &args.params.params_val, + &args.params.params_len) < 0) { + xdr_free((xdrproc_t) xdr_remote_domain_migrate_perform3_params_args, + (char *) &args); + goto cleanup; + } + + if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_PERFORM3_PARAMS, + (xdrproc_t) xdr_remote_domain_migrate_perform3_params_args, + (char *) &args, + (xdrproc_t) xdr_remote_domain_migrate_perform3_params_ret, + (char *) &ret) == -1) + goto cleanup; + + if (ret.cookie_out.cookie_out_len > 0) { + if (!cookieout || !cookieoutlen) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("caller ignores cookieout or cookieoutlen")); + goto error; + } + *cookieout = ret.cookie_out.cookie_out_val; /* Caller frees. */ + *cookieoutlen = ret.cookie_out.cookie_out_len; + } + + rv = 0; + +cleanup: + remoteFreeTypedParameters(args.params.params_val, args.params.params_len); + remoteDriverUnlock(priv); + return rv; + +error: + VIR_FREE(ret.cookie_out.cookie_out_val); + goto cleanup; +} + + +static virDomainPtr +remoteDomainMigrateFinish3Params(virConnectPtr dconn, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + unsigned int flags, + int cancelled) +{ + remote_domain_migrate_finish3_params_args args; + remote_domain_migrate_finish3_params_ret ret; + struct private_data *priv = dconn->privateData; + virDomainPtr rv = NULL; + + remoteDriverLock(priv); + + memset(&args, 0, sizeof(args)); + memset(&ret, 0, sizeof(ret)); + + args.cookie_in.cookie_in_val = (char *)cookiein; + args.cookie_in.cookie_in_len = cookieinlen; + args.flags = flags; + args.cancelled = cancelled; + + if (remoteSerializeTypedParameters(params, nparams, + &args.params.params_val, + &args.params.params_len) < 0) { + xdr_free((xdrproc_t) xdr_remote_domain_migrate_finish3_params_args, + (char *) &args); + goto cleanup; + } + + if (call(dconn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_FINISH3_PARAMS, + (xdrproc_t) xdr_remote_domain_migrate_finish3_params_args, + (char *) &args, + (xdrproc_t) xdr_remote_domain_migrate_finish3_params_ret, + (char *) &ret) == -1) + goto cleanup; + + rv = get_nonnull_domain(dconn, ret.dom); + + if (ret.cookie_out.cookie_out_len > 0) { + if (!cookieout || !cookieoutlen) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("caller ignores cookieout or cookieoutlen")); + goto error; + } + *cookieout = ret.cookie_out.cookie_out_val; /* Caller frees. */ + *cookieoutlen = ret.cookie_out.cookie_out_len; + ret.cookie_out.cookie_out_val = NULL; + ret.cookie_out.cookie_out_len = 0; + } + + xdr_free((xdrproc_t) &xdr_remote_domain_migrate_finish3_params_ret, + (char *) &ret); + +cleanup: + remoteFreeTypedParameters(args.params.params_val, args.params.params_len); + remoteDriverUnlock(priv); + return rv; + +error: + VIR_FREE(ret.cookie_out.cookie_out_val); + goto cleanup; +} + + +static int +remoteDomainMigrateConfirm3Params(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + const char *cookiein, + int cookieinlen, + unsigned int flags, + int cancelled) +{ + int rv = -1; + remote_domain_migrate_confirm3_params_args args; + struct private_data *priv = domain->conn->privateData; + + remoteDriverLock(priv); + + memset(&args, 0, sizeof(args)); + + make_nonnull_domain(&args.dom, domain); + args.cookie_in.cookie_in_len = cookieinlen; + args.cookie_in.cookie_in_val = (char *) cookiein; + args.flags = flags; + args.cancelled = cancelled; + + if (remoteSerializeTypedParameters(params, nparams, + &args.params.params_val, + &args.params.params_len) < 0) { + xdr_free((xdrproc_t) xdr_remote_domain_migrate_confirm3_params_args, + (char *) &args); + goto cleanup; + } + + if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_CONFIRM3_PARAMS, + (xdrproc_t) xdr_remote_domain_migrate_confirm3_params_args, + (char *) &args, (xdrproc_t) xdr_void, (char *) NULL) == -1) + goto cleanup; + + rv = 0; + +cleanup: + remoteFreeTypedParameters(args.params.params_val, args.params.params_len); + remoteDriverUnlock(priv); + return rv; +} + + static void remoteDomainEventQueue(struct private_data *priv, virDomainEventPtr event) { @@ -6367,6 +6759,12 @@ static virDriver remote_driver = { .nodeGetCPUMap = remoteNodeGetCPUMap, /* 1.0.0 */ .domainFSTrim = remoteDomainFSTrim, /* 1.0.1 */ .domainLxcOpenNamespace = remoteDomainLxcOpenNamespace, /* 1.0.2 */ + .domainMigrateBegin3Params = remoteDomainMigrateBegin3Params, /* 1.0.7 */ + .domainMigratePrepare3Params = remoteDomainMigratePrepare3Params, /* 1.0.7 */ + .domainMigratePrepareTunnel3Params = remoteDomainMigratePrepareTunnel3Params, /* 1.0.7 */ + .domainMigratePerform3Params = remoteDomainMigratePerform3Params, /* 1.0.7 */ + .domainMigrateFinish3Params = remoteDomainMigrateFinish3Params, /* 1.0.7 */ + .domainMigrateConfirm3Params = remoteDomainMigrateConfirm3Params, /* 1.0.7 */ }; static virNetworkDriver network_driver = { -- 1.8.2.1

On Tue, Jun 18, 2013 at 04:05:53PM +0200, Jiri Denemark wrote: This change isn't going to fly with the access control check requirements. We mandate that the conversion from virDomainPtr to virDomainDefPtr must always happen in the method that is registered in the driver table. ie you must call qemuDomObjFromDomain() directly from qemuDomainMigrateBegin3 and qemuDomainMigrateBegin3Params and then pass the 'def' into qemuDomainMigrateBegin3Internal Likewise for all the other methods you change in a similar way here. The test suite for the access control code will fail with your patch as it is. Daniel -- |: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|

--- src/qemu/qemu_driver.c | 277 +++++++++++----------------------------------- src/qemu/qemu_migration.c | 70 +++++++++++- src/qemu/qemu_migration.h | 31 ++---- 3 files changed, 145 insertions(+), 233 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 14397f5..80ec379 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -9670,57 +9670,28 @@ qemuDomainMigratePrepareTunnel(virConnectPtr dconn, const char *dom_xml) { 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")); - goto cleanup; - } if (!(flags & VIR_MIGRATE_TUNNELLED)) { - virReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("PrepareTunnel called but no TUNNELLED flag set")); - goto cleanup; - } - if (st == NULL) { - virReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("tunnelled migration requested but NULL stream passed")); - goto cleanup; + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("PrepareTunnel called but no TUNNELLED flag set")); + return -1; } if (virLockManagerPluginUsesState(driver->lockManager)) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Cannot use migrate v2 protocol with lock manager %s"), virLockManagerPluginGetName(driver->lockManager)); - goto cleanup; - } - - if (!(caps = virQEMUDriverGetCapabilities(driver, false))) - goto cleanup; - - if (!(def = virDomainDefParseString(dom_xml, caps, driver->xmlopt, - QEMU_EXPECTED_VIRT_TYPES, - VIR_DOMAIN_XML_INACTIVE))) - goto cleanup; - - if (dname) { - VIR_FREE(def->name); - if (VIR_STRDUP(def->name, dname) < 0) - goto cleanup; + return -1; } - ret = qemuMigrationPrepareTunnel(driver, dconn, - NULL, 0, NULL, NULL, /* No cookies in v2 */ - st, &def, flags); - -cleanup: - virDomainDefFree(def); - virObjectUnref(caps); - return ret; + /* Do not use cookies in v2 protocol, since the cookie + * length was not sufficiently large, causing failures + * migrating between old & new libvirtd + */ + return qemuMigrationPrepare(dconn, dom_xml, dname, NULL, st, + NULL, 0, NULL, NULL, NULL, flags); } /* Prepare is the first step, and it runs on the destination host. @@ -9739,63 +9710,32 @@ qemuDomainMigratePrepare2(virConnectPtr dconn, const char *dom_xml) { virQEMUDriverPtr driver = dconn->privateData; - virCapsPtr caps = NULL; - virDomainDefPtr def = NULL; - int ret = -1; virCheckFlags(QEMU_MIGRATION_FLAGS, -1); - *uri_out = NULL; - - if (virLockManagerPluginUsesState(driver->lockManager)) { - virReportError(VIR_ERR_INTERNAL_ERROR, - _("Cannot use migrate v2 protocol with lock manager %s"), - virLockManagerPluginGetName(driver->lockManager)); - goto cleanup; - } - if (flags & VIR_MIGRATE_TUNNELLED) { /* this is a logical error; we never should have gotten here with * VIR_MIGRATE_TUNNELLED set */ - virReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("Tunnelled migration requested but invalid RPC method called")); - goto cleanup; + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("Tunnelled migration requested but invalid RPC " + "method called")); + return -1; } - if (!dom_xml) { + if (virLockManagerPluginUsesState(driver->lockManager)) { virReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("no domain XML passed")); - goto cleanup; - } - - if (!(caps = virQEMUDriverGetCapabilities(driver, false))) - goto cleanup; - - if (!(def = virDomainDefParseString(dom_xml, caps, driver->xmlopt, - QEMU_EXPECTED_VIRT_TYPES, - VIR_DOMAIN_XML_INACTIVE))) - goto cleanup; - - if (dname) { - VIR_FREE(def->name); - if (VIR_STRDUP(def->name, dname) < 0) - goto cleanup; + _("Cannot use migrate v2 protocol with lock manager %s"), + virLockManagerPluginGetName(driver->lockManager)); + return -1; } /* Do not use cookies in v2 protocol, since the cookie * length was not sufficiently large, causing failures * migrating between old & new libvirtd */ - ret = qemuMigrationPrepareDirect(driver, dconn, - NULL, 0, NULL, NULL, /* No cookies */ - uri_in, uri_out, - &def, flags); - -cleanup: - virDomainDefFree(def); - virObjectUnref(caps); - return ret; + return qemuMigrationPrepare(dconn, dom_xml, dname, uri_in, NULL, + NULL, 0, NULL, NULL, uri_out, flags); } @@ -9942,66 +9882,6 @@ qemuDomainMigrateBegin3Params(virDomainPtr domain, static int -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; - - *uri_out = NULL; - - if (flags & VIR_MIGRATE_TUNNELLED) { - /* this is a logical error; we never should have gotten here with - * VIR_MIGRATE_TUNNELLED set - */ - virReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("Tunnelled migration requested but invalid RPC method called")); - goto cleanup; - } - - if (!dom_xml) { - virReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("no domain XML passed")); - goto cleanup; - } - - if (!(caps = virQEMUDriverGetCapabilities(driver, false))) - goto cleanup; - - if (!(def = virDomainDefParseString(dom_xml, caps, driver->xmlopt, - QEMU_EXPECTED_VIRT_TYPES, - VIR_DOMAIN_XML_INACTIVE))) - goto cleanup; - - if (dname) { - VIR_FREE(def->name); - if (VIR_STRDUP(def->name, dname) < 0) - goto cleanup; - } - - ret = qemuMigrationPrepareDirect(driver, dconn, - cookiein, cookieinlen, - cookieout, cookieoutlen, - uri_in, uri_out, - &def, flags); - -cleanup: - virDomainDefFree(def); - virObjectUnref(caps); - return ret; -} - -static int qemuDomainMigratePrepare3(virConnectPtr dconn, const char *cookiein, int cookieinlen, @@ -10016,9 +9896,19 @@ qemuDomainMigratePrepare3(virConnectPtr dconn, { virCheckFlags(QEMU_MIGRATION_FLAGS, -1); - return qemuDomainMigratePrepare3Internal(dconn, dom_xml, dname, uri_in, - cookiein, cookieinlen, cookieout, - cookieoutlen, uri_out, flags); + if (flags & VIR_MIGRATE_TUNNELLED) { + /* this is a logical error; we never should have gotten here with + * VIR_MIGRATE_TUNNELLED set + */ + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("Tunnelled migration requested but invalid RPC " + "method called")); + return -1; + } + + return qemuMigrationPrepare(dconn, dom_xml, dname, uri_in, NULL, + cookiein, cookieinlen, cookieout, + cookieoutlen, uri_out, flags); } static int @@ -10037,6 +9927,17 @@ qemuDomainMigratePrepare3Params(virConnectPtr dconn, const char *uri_in = NULL; virCheckFlags(QEMU_MIGRATION_FLAGS, -1); + + if (flags & VIR_MIGRATE_TUNNELLED) { + /* this is a logical error; we never should have gotten here with + * VIR_MIGRATE_TUNNELLED set + */ + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("Tunnelled migration requested but invalid RPC " + "method called")); + return -1; + } + if (virTypedParamsValidate(params, nparams, QEMU_MIGRATION_PARAMETERS) < 0) return -1; @@ -10051,70 +9952,13 @@ qemuDomainMigratePrepare3Params(virConnectPtr dconn, &uri_in) < 0) return -1; - return qemuDomainMigratePrepare3Internal(dconn, dom_xml, dname, uri_in, - cookiein, cookieinlen, cookieout, - cookieoutlen, uri_out, flags); + return qemuMigrationPrepare(dconn, dom_xml, dname, uri_in, NULL, + 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; - - if (!dom_xml) { - virReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("no domain XML passed")); - goto cleanup; - } - if (!(flags & VIR_MIGRATE_TUNNELLED)) { - virReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("PrepareTunnel called but no TUNNELLED flag set")); - goto cleanup; - } - if (st == NULL) { - virReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("tunnelled migration requested but NULL stream passed")); - goto cleanup; - } - - if (!(caps = virQEMUDriverGetCapabilities(driver, false))) - goto cleanup; - - if (!(def = virDomainDefParseString(dom_xml, caps, driver->xmlopt, - QEMU_EXPECTED_VIRT_TYPES, - VIR_DOMAIN_XML_INACTIVE))) - goto cleanup; - - if (dname) { - VIR_FREE(def->name); - if (VIR_STRDUP(def->name, dname) < 0) - goto cleanup; - } - - ret = qemuMigrationPrepareTunnel(driver, dconn, - cookiein, cookieinlen, - cookieout, cookieoutlen, - st, &def, flags); - -cleanup: - virDomainDefFree(def); - virObjectUnref(caps); - return ret; -} - -static int qemuDomainMigratePrepareTunnel3(virConnectPtr dconn, virStreamPtr st, const char *cookiein, @@ -10128,10 +9972,15 @@ qemuDomainMigratePrepareTunnel3(virConnectPtr dconn, { virCheckFlags(QEMU_MIGRATION_FLAGS, -1); - return qemuDomainMigratePrepareTunnel3Internal(dconn, st, dom_xml, dname, - cookiein, cookieinlen, - cookieout, cookieoutlen, - flags); + if (!(flags & VIR_MIGRATE_TUNNELLED)) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("PrepareTunnel called but no TUNNELLED flag set")); + return -1; + } + + return qemuMigrationPrepare(dconn, dom_xml, dname, NULL, st, + cookiein, cookieinlen, cookieout, + cookieoutlen, NULL, flags); } static int @@ -10149,6 +9998,13 @@ qemuDomainMigratePrepareTunnel3Params(virConnectPtr dconn, const char *dname = NULL; virCheckFlags(QEMU_MIGRATION_FLAGS, -1); + + if (!(flags & VIR_MIGRATE_TUNNELLED)) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("PrepareTunnel called but no TUNNELLED flag set")); + return -1; + } + if (virTypedParamsValidate(params, nparams, QEMU_MIGRATION_PARAMETERS) < 0) return -1; @@ -10160,10 +10016,9 @@ qemuDomainMigratePrepareTunnel3Params(virConnectPtr dconn, &dname) < 0) return -1; - return qemuDomainMigratePrepareTunnel3Internal(dconn, st, dom_xml, dname, - cookiein, cookieinlen, - cookieout, cookieoutlen, - flags); + return qemuMigrationPrepare(dconn, dom_xml, dname, NULL, st, + cookiein, cookieinlen, cookieout, + cookieoutlen, NULL, flags); } diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index c0b721a..7559625 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2424,7 +2424,7 @@ endjob: * This version starts an empty VM listening on a localhost TCP port, and * sets up the corresponding virStream to handle the incoming data. */ -int +static int qemuMigrationPrepareTunnel(virQEMUDriverPtr driver, virConnectPtr dconn, const char *cookiein, @@ -2450,7 +2450,7 @@ qemuMigrationPrepareTunnel(virQEMUDriverPtr driver, } -int +static int qemuMigrationPrepareDirect(virQEMUDriverPtr driver, virConnectPtr dconn, const char *cookiein, @@ -2477,6 +2477,8 @@ qemuMigrationPrepareDirect(virQEMUDriverPtr driver, cookieout, cookieoutlen, NULLSTR(uri_in), uri_out, *def, flags); + *uri_out = NULL; + /* The URI passed in may be NULL or a string "tcp://somehostname:port". * * If the URI passed in is NULL then we allocate a port number @@ -2580,6 +2582,70 @@ cleanup: return ret; } +int +qemuMigrationPrepare(virConnectPtr dconn, + const char *dom_xml, + const char *dname, + const char *uri_in, + virStreamPtr st, + 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; + + if ((flags & VIR_MIGRATE_TUNNELLED) && !st) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("tunnelled migration requested but NULL stream " + "passed")); + goto cleanup; + } + + if (!dom_xml) { + virReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("no domain XML passed")); + goto cleanup; + } + + if (!(caps = virQEMUDriverGetCapabilities(driver, false))) + goto cleanup; + + if (!(def = virDomainDefParseString(dom_xml, caps, driver->xmlopt, + QEMU_EXPECTED_VIRT_TYPES, + VIR_DOMAIN_XML_INACTIVE))) + goto cleanup; + + if (dname) { + VIR_FREE(def->name); + if (VIR_STRDUP(def->name, dname) < 0) + goto cleanup; + } + + if (flags & VIR_MIGRATE_TUNNELLED) { + ret = qemuMigrationPrepareTunnel(driver, dconn, + cookiein, cookieinlen, + cookieout, cookieoutlen, + st, &def, flags); + } else { + ret = qemuMigrationPrepareDirect(driver, dconn, + cookiein, cookieinlen, + cookieout, cookieoutlen, + uri_in, uri_out, + &def, flags); + } + +cleanup: + virDomainDefFree(def); + virObjectUnref(caps); + return ret; +} + enum qemuMigrationDestinationType { MIGRATION_DEST_HOST, diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h index ef7307e..2e03b78 100644 --- a/src/qemu/qemu_migration.h +++ b/src/qemu/qemu_migration.h @@ -102,26 +102,17 @@ char *qemuMigrationBegin(virQEMUDriverPtr driver, int *cookieoutlen, unsigned long flags); -int qemuMigrationPrepareTunnel(virQEMUDriverPtr driver, - virConnectPtr dconn, - const char *cookiein, - int cookieinlen, - char **cookieout, - int *cookieoutlen, - virStreamPtr st, - virDomainDefPtr *def, - unsigned long flags); - -int qemuMigrationPrepareDirect(virQEMUDriverPtr driver, - virConnectPtr dconn, - const char *cookiein, - int cookieinlen, - char **cookieout, - int *cookieoutlen, - const char *uri_in, - char **uri_out, - virDomainDefPtr *def, - unsigned long flags); +int qemuMigrationPrepare(virConnectPtr dconn, + const char *dom_xml, + const char *dname, + const char *uri_in, + virStreamPtr st, + const char *cookiein, + int cookieinlen, + char **cookieout, + int *cookieoutlen, + char **uri_out, + unsigned long flags); int qemuMigrationPerform(virQEMUDriverPtr driver, virConnectPtr conn, -- 1.8.2.1

--- src/libvirt.c | 177 +++++++++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 133 insertions(+), 44 deletions(-) diff --git a/src/libvirt.c b/src/libvirt.c index d6ded5e..12387ef 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -4776,15 +4776,22 @@ finish: * Src: Confirm * - Kill off VM if success, resume if failed * + * 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 virDomainPtr -virDomainMigrateVersion3(virDomainPtr domain, - virConnectPtr dconn, - const char *xmlin, - unsigned long flags, - const char *dname, - const char *uri, - unsigned long bandwidth) +virDomainMigrateVersion3Full(virDomainPtr domain, + virConnectPtr dconn, + const char *xmlin, + const char *dname, + const char *uri, + unsigned long long bandwidth, + virTypedParameterPtr params, + int nparams, + bool useParams, + unsigned int flags) { virDomainPtr ddomain = NULL; char *uri_out = NULL; @@ -4800,47 +4807,82 @@ virDomainMigrateVersion3(virDomainPtr domain, unsigned long protection = 0; bool notify_source = true; unsigned int destflags = flags & ~VIR_MIGRATE_ABORT_ON_ERROR; + int state; + virTypedParameterPtr tmp; - VIR_DOMAIN_DEBUG(domain, "dconn=%p xmlin=%s, flags=%lx, " - "dname=%s, uri=%s, bandwidth=%lu", - dconn, NULLSTR(xmlin), flags, - NULLSTR(dname), NULLSTR(uri), bandwidth); + VIR_DOMAIN_DEBUG(domain, + "dconn=%p, xmlin=%s, dname=%s, uri=%s, bandwidth=%llu, " + "params=%p, nparams=%d, useParams=%d, flags=%x", + dconn, NULLSTR(xmlin), NULLSTR(dname), NULLSTR(uri), + bandwidth, params, nparams, useParams, flags); + VIR_TYPED_PARAMS_DEBUG(params, nparams); - if (!domain->conn->driver->domainMigrateBegin3 || - !domain->conn->driver->domainMigratePerform3 || - !domain->conn->driver->domainMigrateConfirm3 || - !dconn->driver->domainMigratePrepare3 || - !dconn->driver->domainMigrateFinish3) { + if ((!useParams && + (!domain->conn->driver->domainMigrateBegin3 || + !domain->conn->driver->domainMigratePerform3 || + !domain->conn->driver->domainMigrateConfirm3 || + !dconn->driver->domainMigratePrepare3 || + !dconn->driver->domainMigrateFinish3)) || + (useParams && + (!domain->conn->driver->domainMigrateBegin3Params || + !domain->conn->driver->domainMigratePerform3Params || + !domain->conn->driver->domainMigrateConfirm3Params || + !dconn->driver->domainMigratePrepare3Params || + !dconn->driver->domainMigrateFinish3Params))) { virLibConnError(VIR_ERR_INTERNAL_ERROR, __FUNCTION__); - virDispatchError(domain->conn); return NULL; } + if (virTypedParamsCopy(&tmp, params, nparams) < 0) + return NULL; + params = tmp; + if (VIR_DRV_SUPPORTS_FEATURE(domain->conn->driver, domain->conn, VIR_DRV_FEATURE_MIGRATE_CHANGE_PROTECTION)) protection = VIR_MIGRATE_CHANGE_PROTECTION; VIR_DEBUG("Begin3 %p", domain->conn); - dom_xml = domain->conn->driver->domainMigrateBegin3 - (domain, xmlin, &cookieout, &cookieoutlen, - flags | protection, dname, bandwidth); + if (useParams) { + dom_xml = domain->conn->driver->domainMigrateBegin3Params + (domain, params, nparams, &cookieout, &cookieoutlen, + flags | protection); + } else { + dom_xml = domain->conn->driver->domainMigrateBegin3 + (domain, xmlin, &cookieout, &cookieoutlen, + flags | protection, dname, bandwidth); + } if (!dom_xml) goto done; - ret = virDomainGetInfo(domain, &info); - if (ret == 0 && info.state == VIR_DOMAIN_PAUSED) { - flags |= VIR_MIGRATE_PAUSED; + if (useParams) { + /* If source is new enough to support extensible migration parameters, + * it's certainly new enough to support virDomainGetState. */ + ret = virDomainGetState(domain, &state, NULL, 0); + } else { + ret = virDomainGetInfo(domain, &info); + state = info.state; } + if (ret == 0 && state == VIR_DOMAIN_PAUSED) + flags |= VIR_MIGRATE_PAUSED; - VIR_DEBUG("Prepare3 %p flags=%lx", dconn, flags); + VIR_DEBUG("Prepare3 %p flags=%x", dconn, flags); cookiein = cookieout; cookieinlen = cookieoutlen; cookieout = NULL; cookieoutlen = 0; - ret = dconn->driver->domainMigratePrepare3 - (dconn, cookiein, cookieinlen, &cookieout, &cookieoutlen, - uri, &uri_out, destflags, dname, bandwidth, dom_xml); - VIR_FREE(dom_xml); + if (useParams) { + if (virTypedParamsReplaceString(&params, &nparams, + VIR_MIGRATE_PARAM_DEST_XML, + dom_xml) < 0) + goto done; + 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); + } if (ret == -1) { if (protection) { /* Begin already started a migration job so we need to cancel it by @@ -4853,14 +4895,20 @@ virDomainMigrateVersion3(virDomainPtr domain, } } - if (uri == NULL && uri_out == NULL) { + /* Did domainMigratePrepare3 change URI? */ + if (uri_out) { + uri = uri_out; + if (useParams && + virTypedParamsReplaceString(&params, &nparams, + VIR_MIGRATE_PARAM_URI, + uri_out) < 0) + goto finish; + } else if (!uri && + virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_URI, &uri) <= 0) { virLibConnError(VIR_ERR_INTERNAL_ERROR, "%s", _("domainMigratePrepare3 did not set uri")); - virDispatchError(domain->conn); - goto finish; } - if (uri_out) - uri = uri_out; /* Did domainMigratePrepare3 change URI? */ if (flags & VIR_MIGRATE_OFFLINE) { VIR_DEBUG("Offline migration, skipping Perform phase"); @@ -4882,10 +4930,16 @@ virDomainMigrateVersion3(virDomainPtr domain, cookieout = NULL; cookieoutlen = 0; /* dconnuri not relevant in non-P2P modes, so left NULL here */ - ret = domain->conn->driver->domainMigratePerform3 - (domain, NULL, cookiein, cookieinlen, - &cookieout, &cookieoutlen, NULL, - uri, flags | protection, dname, bandwidth); + if (useParams) { + ret = domain->conn->driver->domainMigratePerform3Params + (domain, NULL, params, nparams, cookiein, cookieinlen, + &cookieout, &cookieoutlen, flags | protection); + } else { + ret = domain->conn->driver->domainMigratePerform3 + (domain, NULL, cookiein, cookieinlen, + &cookieout, &cookieoutlen, NULL, + uri, flags | protection, dname, bandwidth); + } /* Perform failed. Make sure Finish doesn't overwrite the error */ if (ret < 0) { @@ -4914,10 +4968,24 @@ finish: cookieinlen = cookieoutlen; cookieout = NULL; cookieoutlen = 0; - dname = dname ? dname : domain->name; - ddomain = dconn->driver->domainMigrateFinish3 - (dconn, dname, cookiein, cookieinlen, &cookieout, &cookieoutlen, - NULL, uri, destflags, cancelled); + if (useParams) { + if (virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_DEST_NAME, NULL) <= 0 && + virTypedParamsReplaceString(&params, &nparams, + VIR_MIGRATE_PARAM_DEST_NAME, + domain->name) < 0) { + domain = NULL; + } else { + ddomain = dconn->driver->domainMigrateFinish3Params + (dconn, params, nparams, cookiein, cookieinlen, + &cookieout, &cookieoutlen, destflags, cancelled); + } + } else { + dname = dname ? dname : domain->name; + ddomain = dconn->driver->domainMigrateFinish3 + (dconn, dname, cookiein, cookieinlen, &cookieout, &cookieoutlen, + NULL, uri, destflags, cancelled); + } /* If ddomain is NULL, then we were unable to start * the guest on the target, and must restart on the @@ -4948,9 +5016,15 @@ confirm: cookieinlen = cookieoutlen; cookieout = NULL; cookieoutlen = 0; - ret = domain->conn->driver->domainMigrateConfirm3 - (domain, cookiein, cookieinlen, - flags | protection, cancelled); + if (useParams) { + ret = domain->conn->driver->domainMigrateConfirm3Params + (domain, params, nparams, cookiein, cookieinlen, + flags | protection, cancelled); + } else { + ret = domain->conn->driver->domainMigrateConfirm3 + (domain, cookiein, cookieinlen, + flags | protection, 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. @@ -4966,12 +5040,27 @@ confirm: virSetError(orig_err); virFreeError(orig_err); } + VIR_FREE(dom_xml); VIR_FREE(uri_out); VIR_FREE(cookiein); VIR_FREE(cookieout); + virTypedParamsFree(params, nparams); return ddomain; } +static virDomainPtr +virDomainMigrateVersion3(virDomainPtr domain, + virConnectPtr dconn, + const char *xmlin, + unsigned long flags, + const char *dname, + const char *uri, + unsigned long bandwidth) +{ + return virDomainMigrateVersion3Full(domain, dconn, xmlin, dname, uri, + bandwidth, NULL, 0, false, flags); +} + /* * In normal migration, the libvirt client co-ordinates communication -- 1.8.2.1

On Tue, Jun 25, 2013 at 06:56:35 -0400, John Ferlan wrote: Oops, that's a nasty typo. Fixed by the following patch which I pushed as trivial: diff --git a/src/libvirt.c b/src/libvirt.c index 2dc96a9..bc1694a 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -4979,7 +4979,7 @@ finish: virTypedParamsReplaceString(&params, &nparams, VIR_MIGRATE_PARAM_DEST_NAME, domain->name) < 0) { - domain = NULL; + ddomain = NULL; } else { ddomain = dconn->driver->domainMigrateFinish3Params (dconn, params, nparams, cookiein, cookieinlen,

--- tools/virsh-domain.c | 77 ++++++++++++++++++++++++++++++++++++---------------- 1 file changed, 54 insertions(+), 23 deletions(-) diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c index 7f9b9e3..2226b5c 100644 --- a/tools/virsh-domain.c +++ b/tools/virsh-domain.c @@ -8345,15 +8345,15 @@ doMigrate(void *opaque) char ret = '1'; virDomainPtr dom = NULL; const char *desturi = NULL; - const char *migrateuri = NULL; - const char *dname = NULL; + const char *opt = NULL; unsigned int flags = 0; vshCtrlData *data = opaque; vshControl *ctl = data->ctl; const vshCmd *cmd = data->cmd; - const char *xmlfile = NULL; - char *xml = NULL; sigset_t sigmask, oldsigmask; + virTypedParameterPtr params = NULL; + int nparams = 0; + int maxparams = 0; sigemptyset(&sigmask); sigaddset(&sigmask, SIGINT); @@ -8363,11 +8363,40 @@ doMigrate(void *opaque) if (!(dom = vshCommandOptDomain(ctl, cmd, NULL))) goto out; - if (vshCommandOptStringReq(ctl, cmd, "desturi", &desturi) < 0 || - vshCommandOptStringReq(ctl, cmd, "migrateuri", &migrateuri) < 0 || - vshCommandOptStringReq(ctl, cmd, "dname", &dname) < 0 || - vshCommandOptStringReq(ctl, cmd, "xml", &xmlfile) < 0) + if (vshCommandOptStringReq(ctl, cmd, "desturi", &desturi) < 0) + goto out; + + if (vshCommandOptStringReq(ctl, cmd, "migrateuri", &opt) < 0) + goto out; + else if (opt && + virTypedParamsAddString(&params, &nparams, &maxparams, + VIR_MIGRATE_PARAM_URI, opt) < 0) + goto save_error; + + if (vshCommandOptStringReq(ctl, cmd, "dname", &opt) < 0) goto out; + else if (opt && + virTypedParamsAddString(&params, &nparams, &maxparams, + VIR_MIGRATE_PARAM_DEST_NAME, opt) < 0) + goto save_error; + + if (vshCommandOptStringReq(ctl, cmd, "xml", &opt) < 0) { + goto out; + } else if (opt) { + char *xml; + + if (virFileReadAll(opt, 1024 * 1024, &xml) < 0) { + vshError(ctl, _("cannot read file '%s'"), opt); + goto save_error; + } + + if (virTypedParamsAddString(&params, &nparams, &maxparams, + VIR_MIGRATE_PARAM_DEST_XML, xml) < 0) { + VIR_FREE(xml); + goto save_error; + } + VIR_FREE(xml); + } if (vshCommandOptBool(cmd, "live")) flags |= VIR_MIGRATE_LIVE; @@ -8406,23 +8435,19 @@ doMigrate(void *opaque) if (vshCommandOptBool(cmd, "abort-on-error")) flags |= VIR_MIGRATE_ABORT_ON_ERROR; - if (xmlfile && - virFileReadAll(xmlfile, 8192, &xml) < 0) { - vshError(ctl, _("file '%s' doesn't exist"), xmlfile); - goto out; - } - if ((flags & VIR_MIGRATE_PEER2PEER) || vshCommandOptBool(cmd, "direct")) { /* migrateuri doesn't make sense for tunnelled migration */ - if (flags & VIR_MIGRATE_TUNNELLED && migrateuri != NULL) { - vshError(ctl, "%s", _("migrate: Unexpected migrateuri for peer2peer/direct migration")); + if (flags & VIR_MIGRATE_TUNNELLED && + virTypedParamsGetString(params, nparams, + VIR_MIGRATE_PARAM_URI, NULL) == 1) { + vshError(ctl, "%s", _("migrate: Unexpected migrateuri for " + "peer2peer/direct migration")); goto out; } - if (virDomainMigrateToURI2(dom, desturi, migrateuri, - xml, flags, dname, 0) == 0) + if (virDomainMigrateToURI3(dom, desturi, params, nparams, flags) == 0) ret = '0'; } else { /* For traditional live migration, connect to the destination host directly. */ @@ -8430,10 +8455,10 @@ doMigrate(void *opaque) virDomainPtr ddom = NULL; dconn = virConnectOpenAuth(desturi, virConnectAuthPtrDefault, 0); - if (!dconn) goto out; + if (!dconn) + goto out; - ddom = virDomainMigrate2(dom, dconn, xml, flags, dname, migrateuri, 0); - if (ddom) { + if ((ddom = virDomainMigrate3(dom, dconn, params, nparams, flags))) { virDomainFree(ddom); ret = '0'; } @@ -8443,9 +8468,15 @@ doMigrate(void *opaque) out: pthread_sigmask(SIG_SETMASK, &oldsigmask, NULL); out_sig: - if (dom) virDomainFree(dom); - VIR_FREE(xml); + virTypedParamsFree(params, nparams); + if (dom) + virDomainFree(dom); ignore_value(safewrite(data->writefd, &ret, sizeof(ret))); + return; + +save_error: + vshSaveLibvirtError(); + goto out; } static void -- 1.8.2.1

The parameter specifies connection parameters to use for migrating client's connection to domain's graphical console. --- include/libvirt/libvirt.h.in | 21 +++++++++++++++++++++ tools/virsh-domain.c | 11 +++++++++++ tools/virsh.pod | 18 +++++++++++++++++- 3 files changed, 49 insertions(+), 1 deletion(-) diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index 5f3a006..a25c7d2 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -1246,6 +1246,27 @@ typedef enum { */ #define VIR_MIGRATE_PARAM_BANDWIDTH "bandwidth" +/** + * VIR_MIGRATE_PARAM_GRAPHICS_URI: + * + * virDomainMigrate* params field: URI to use for migrating client's connection + * to domain's graphical console as VIR_TYPED_PARAM_STRING. If specified, the + * client will be asked to automatically reconnect using these parameters + * instead of the automatically computed ones. This can be useful if, e.g., the + * client does not have a direct access to the network virtualization hosts are + * connected to and needs to connect through a proxy. The URI is formed as + * follows: + * + * protocol://hostname[:port]/[?parameters] + * + * where protocol is either "spice" or "vnc" and parameters is a list of + * protocol specific parameters separated by '&'. Currently recognized + * parameters are "tlsPort" and "tlsSubject". For example, + * + * spice://target.host.com:1234/?tlsPort=4567 + */ +#define VIR_MIGRATE_PARAM_GRAPHICS_URI "graphics_uri" + /* Domain migration. */ virDomainPtr virDomainMigrate (virDomainPtr domain, virConnectPtr dconn, diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c index 2226b5c..873f123 100644 --- a/tools/virsh-domain.c +++ b/tools/virsh-domain.c @@ -8324,6 +8324,10 @@ static const vshCmdOptDef opts_migrate[] = { .type = VSH_OT_DATA, .help = N_("migration URI, usually can be omitted") }, + {.name = "graphicsuri", + .type = VSH_OT_DATA, + .help = N_("graphics URI to be used for seamless graphics migration") + }, {.name = "dname", .type = VSH_OT_DATA, .help = N_("rename to new name during migration (if supported)") @@ -8373,6 +8377,13 @@ doMigrate(void *opaque) VIR_MIGRATE_PARAM_URI, opt) < 0) goto save_error; + if (vshCommandOptStringReq(ctl, cmd, "graphicsuri", &opt) < 0) + goto out; + else if (opt && + virTypedParamsAddString(&params, &nparams, &maxparams, + VIR_MIGRATE_PARAM_GRAPHICS_URI, opt) < 0) + goto save_error; + if (vshCommandOptStringReq(ctl, cmd, "dname", &opt) < 0) goto out; else if (opt && diff --git a/tools/virsh.pod b/tools/virsh.pod index f4746cc..94fe897 100644 --- a/tools/virsh.pod +++ b/tools/virsh.pod @@ -1044,7 +1044,7 @@ stats. [I<--persistent>] [I<--undefinesource>] [I<--suspend>] [I<--copy-storage-all>] [I<--copy-storage-inc>] [I<--change-protection>] [I<--unsafe>] [I<--verbose>] [I<--compressed>] [I<--abort-on-error>] -I<domain> I<desturi> [I<migrateuri>] [I<dname>] +I<domain> I<desturi> [I<migrateuri>] [I<graphicsuri>] [I<dname>] [I<--timeout> B<seconds>] [I<--xml> B<file>] Migrate domain to another host. Add I<--live> for live migration; <--p2p> @@ -1136,6 +1136,22 @@ order to comply with local firewall policies. =back +Optional I<graphicsuri> overrides connection parameters used for automatically +reconnecting a graphical clients at the end of migration. If omitted, libvirt +will compute the parameters based on target host IP address. In case the +client does not have a direct access to the network virtualization hosts are +connected to and needs to connect through a proxy, I<graphicsuri> may be used +to specify the address the client should connect to. The URI is formed as +follows: + + protocol://hostname[:port]/[?parameters] + +where protocol is either "spice" or "vnc" and parameters is a list of protocol +specific parameters separated by '&'. Currently recognized parameters are +"tlsPort" and "tlsSubject". For example, + + spice://target.host.com:1234/?tlsPort=4567 + =item B<migrate-setmaxdowntime> I<domain> I<downtime> Set maximum tolerable downtime for a domain which is being live-migrated to -- 1.8.2.1