With this element users will control how SPICE server behaves upon migration. For now, there's just one attribute 'seamless' turning seamless migration on/off/default. --- docs/formatdomain.html.in | 10 ++++++++++ docs/schemas/domaincommon.rng | 11 +++++++++++ src/conf/domain_conf.c | 31 ++++++++++++++++++++++++++++++- src/conf/domain_conf.h | 10 ++++++++++ src/libvirt_private.syms | 2 ++ 5 files changed, 63 insertions(+), 1 deletions(-) diff --git a/docs/formatdomain.html.in b/docs/formatdomain.html.in index c05f3df..8b87055 100644 --- a/docs/formatdomain.html.in +++ b/docs/formatdomain.html.in @@ -3216,6 +3216,7 @@ qemu-kvm -net nic,model=? /dev/null <streaming mode='filter'/> <clipboard copypaste='no'/> <mouse mode='client'/> + <migration seamless='on'/> </graphics></pre> <p> Spice supports variable compression settings for audio, @@ -3255,6 +3256,15 @@ qemu-kvm -net nic,model=? /dev/null <span class="since">since 0.9.11</span>. If no mode is specified, the qemu default will be used (client mode). </p> + <p> + SPICE migration behaviour can be controlled via + <code>migration</code> element (<span class="since">since + 0.9.11</span>). Notably, <code>seamless</code> + attribute turns on or off seamless migration. Accepted + values are <code>on</code> or <code>off</code>. If you + don't specify anything libvirt turns on this feature for + old enough qemu. + </p> </dd> <dt><code>"rdp"</code></dt> <dd> diff --git a/docs/schemas/domaincommon.rng b/docs/schemas/domaincommon.rng index d70f0c2..09e31eb 100644 --- a/docs/schemas/domaincommon.rng +++ b/docs/schemas/domaincommon.rng @@ -2061,6 +2061,17 @@ <empty/> </element> </optional> + <optional> + <element name="migration"> + <attribute name="seamless"> + <choice> + <value>on</value> + <value>off</value> + </choice> + </attribute> + <empty/> + </element> + </optional> </interleave> </group> <group> diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index 75756c4..35a3ee8 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -500,6 +500,11 @@ VIR_ENUM_IMPL(virDomainGraphicsSpiceClipboardCopypaste, "default", "yes", "no"); +VIR_ENUM_IMPL(virDomainGraphicsSpiceMigrationSeamless, + VIR_DOMAIN_GRAPHICS_SPICE_MIGRATION_SEAMLESS_LAST, + "default", + "on", + "off"); VIR_ENUM_IMPL(virDomainHostdevMode, VIR_DOMAIN_HOSTDEV_MODE_LAST, "subsystem", @@ -6652,6 +6657,27 @@ virDomainGraphicsDefParseXML(xmlNodePtr node, VIR_FREE(mode); def->data.spice.mousemode = modeVal; + } else if (xmlStrEqual(cur->name, BAD_CAST "migration")) { + char *seamless = virXMLPropString(cur, "seamless"); + int seamlessVal; + + if (!seamless) { + virReportError(VIR_ERR_XML_ERROR, "%s", + _("spice migration missing seamless")); + goto error; + } + + seamlessVal = virDomainGraphicsSpiceMigrationSeamlessTypeFromString(seamless); + if (seamlessVal <= 0) { + virReportError(VIR_ERR_XML_ERROR, + _("unknown seamless migration value '%s'"), + seamless); + VIR_FREE(seamless); + goto error; + } + VIR_FREE(seamless); + + def->data.spice.seamless = seamlessVal; } } cur = cur->next; @@ -13249,7 +13275,7 @@ virDomainGraphicsDefFormat(virBufferPtr buf, if (!children && (def->data.spice.image || def->data.spice.jpeg || def->data.spice.zlib || def->data.spice.playback || def->data.spice.streaming || def->data.spice.copypaste || - def->data.spice.mousemode)) { + def->data.spice.mousemode || def->data.spice.seamless)) { virBufferAddLit(buf, ">\n"); children = 1; } @@ -13274,6 +13300,9 @@ virDomainGraphicsDefFormat(virBufferPtr buf, if (def->data.spice.copypaste) virBufferAsprintf(buf, " <clipboard copypaste='%s'/>\n", virDomainGraphicsSpiceClipboardCopypasteTypeToString(def->data.spice.copypaste)); + if (def->data.spice.seamless) + virBufferAsprintf(buf, " <migration seamless='%s'/>\n", + virDomainGraphicsSpiceMigrationSeamlessTypeToString(def->data.spice.seamless)); } if (children) { diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h index b6fb0db..8e61378 100644 --- a/src/conf/domain_conf.h +++ b/src/conf/domain_conf.h @@ -1213,6 +1213,14 @@ enum virDomainGraphicsSpiceClipboardCopypaste { VIR_DOMAIN_GRAPHICS_SPICE_CLIPBOARD_COPYPASTE_LAST }; +enum virDomainGraphicsSpiceMigrationSeamless { + VIR_DOMAIN_GRAPHICS_SPICE_MIGRATION_SEAMLESS_DEFAULT = 0, + VIR_DOMAIN_GRAPHICS_SPICE_MIGRATION_SEAMLESS_ON, + VIR_DOMAIN_GRAPHICS_SPICE_MIGRATION_SEAMLESS_OFF, + + VIR_DOMAIN_GRAPHICS_SPICE_MIGRATION_SEAMLESS_LAST +}; + enum virDomainGraphicsListenType { VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_NONE = 0, VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS, @@ -1280,6 +1288,7 @@ struct _virDomainGraphicsDef { int playback; int streaming; int copypaste; + int seamless; } spice; } data; /* nListens, listens, and *port are only useful if type is vnc, @@ -2198,6 +2207,7 @@ VIR_ENUM_DECL(virDomainGraphicsSpicePlaybackCompression) VIR_ENUM_DECL(virDomainGraphicsSpiceStreamingMode) VIR_ENUM_DECL(virDomainGraphicsSpiceClipboardCopypaste) VIR_ENUM_DECL(virDomainGraphicsSpiceMouseMode) +VIR_ENUM_DECL(virDomainGraphicsSpiceMigrationSeamless) VIR_ENUM_DECL(virDomainNumatuneMemMode) VIR_ENUM_DECL(virDomainNumatuneMemPlacementMode) /* from libvirt.h */ diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 064e2a6..b2ff153 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -377,6 +377,8 @@ virDomainGraphicsSpiceImageCompressionTypeFromString; virDomainGraphicsSpiceImageCompressionTypeToString; virDomainGraphicsSpiceJpegCompressionTypeFromString; virDomainGraphicsSpiceJpegCompressionTypeToString; +virDomainGraphicsSpiceMigrationSeamlessTypeFromString; +virDomainGraphicsSpiceMigrationSeamlessTypeToString; virDomainGraphicsSpiceMouseModeTypeFromString; virDomainGraphicsSpiceMouseModeTypeToString; virDomainGraphicsSpicePlaybackCompressionTypeFromString; -- 1.7.8.6

This requires adding "seamless-migration='on|off'" to the qemu command line. It is turned on by default (if not running on ancient qemu that doesn't support this). --- src/qemu/qemu_capabilities.c | 3 +++ src/qemu/qemu_capabilities.h | 1 + src/qemu/qemu_command.c | 14 ++++++++++++++ 3 files changed, 18 insertions(+), 0 deletions(-) diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c index af3b0b2..7514f04 100644 --- a/src/qemu/qemu_capabilities.c +++ b/src/qemu/qemu_capabilities.c @@ -177,6 +177,7 @@ VIR_ENUM_IMPL(qemuCaps, QEMU_CAPS_LAST, "disable-s4", /* 105 */ "usb-redir.filter", + "seamless-migration", ); struct _qemuCaps { @@ -1140,6 +1141,8 @@ qemuCapsComputeCmdFlags(const char *help, } if (strstr(help, "-spice")) qemuCapsSet(caps, QEMU_CAPS_SPICE); + if (strstr(help, "seamless-migration=")) + qemuCapsSet(caps, QEMU_CAPS_SEAMLESS_MIGRATION); if (strstr(help, "boot=on")) qemuCapsSet(caps, QEMU_CAPS_DRIVE_BOOT); if (strstr(help, "serial=s")) diff --git a/src/qemu/qemu_capabilities.h b/src/qemu/qemu_capabilities.h index bbb07c9..d33cdd1 100644 --- a/src/qemu/qemu_capabilities.h +++ b/src/qemu/qemu_capabilities.h @@ -142,6 +142,7 @@ enum qemuCapsFlags { QEMU_CAPS_DISABLE_S3 = 104, /* S3 BIOS Advertisement on/off */ QEMU_CAPS_DISABLE_S4 = 105, /* S4 BIOS Advertisement on/off */ QEMU_CAPS_USB_REDIR_FILTER = 106, /* usb-redir.filter */ + QEMU_CAPS_SEAMLESS_MIGRATION = 107, /* seamless-migration for SPICE */ QEMU_CAPS_LAST, /* this must always be the last item */ }; diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c index ec825bc..a9e54fb 100644 --- a/src/qemu/qemu_command.c +++ b/src/qemu/qemu_command.c @@ -6069,6 +6069,20 @@ qemuBuildCommandLine(virConnectPtr conn, if (def->graphics[0]->data.spice.copypaste == VIR_DOMAIN_GRAPHICS_SPICE_CLIPBOARD_COPYPASTE_NO) virBufferAddLit(&opt, ",disable-copy-paste"); + if (qemuCapsGet(caps, QEMU_CAPS_SEAMLESS_MIGRATION)) { + if (def->graphics[0]->data.spice.seamless == + VIR_DOMAIN_GRAPHICS_SPICE_MIGRATION_SEAMLESS_OFF) + virBufferAddLit(&opt, ",seamless-migration=off"); + else + virBufferAddLit(&opt, ",seamless-migration=on"); + } else if (def->graphics[0]->data.spice.seamless == + VIR_DOMAIN_GRAPHICS_SPICE_MIGRATION_SEAMLESS_ON) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("SPICE seamless migration is not " + "supported by this version of qemu")); + goto error; + } + virCommandAddArg(cmd, "-spice"); virCommandAddArgBuffer(cmd, &opt); if (def->graphics[0]->data.spice.keymap) -- 1.7.8.6

Recently, there have been some improvements made to qemu so it supports seamless migration or something very close to it. However, it requires libvirt interaction. Once qemu is migrated, the SPICE server needs to send its internal state to the destination. Once it's done, it fires SPICE_MIGRATE_COMPLETED event and this fact is advertised in 'query-spice' output as well. We must not kill qemu until SPICE server finishes the transfer. --- src/qemu/qemu_migration.c | 38 +++++++++++++++++++++++++++--- src/qemu/qemu_monitor.c | 22 +++++++++++++++++ src/qemu/qemu_monitor.h | 3 ++ src/qemu/qemu_monitor_json.c | 52 ++++++++++++++++++++++++++++++++++++++++++ src/qemu/qemu_monitor_json.h | 3 ++ 5 files changed, 114 insertions(+), 4 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 99fc8ce..19666e2 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -891,11 +891,13 @@ static int qemuMigrationUpdateJobStatus(struct qemud_driver *driver, virDomainObjPtr vm, const char *job, - enum qemuDomainAsyncJob asyncJob) + enum qemuDomainAsyncJob asyncJob, + bool wait_for_spice) { qemuDomainObjPrivatePtr priv = vm->privateData; int ret; int status; + bool spice_migrated = true; unsigned long long memProcessed; unsigned long long memRemaining; unsigned long long memTotal; @@ -910,6 +912,13 @@ qemuMigrationUpdateJobStatus(struct qemud_driver *driver, &memProcessed, &memRemaining, &memTotal); + + /* If qemu says migrated, check spice */ + if (wait_for_spice && (ret == 0) && + (status == QEMU_MONITOR_MIGRATION_STATUS_COMPLETED)) + ret = qemuMonitorGetSpiceMigrationStatus(priv->mon, + &spice_migrated); + qemuDomainObjExitMonitorWithDriver(driver, vm); if (ret < 0 || virTimeMillisNow(&priv->job.info.timeElapsed) < 0) { @@ -939,7 +948,8 @@ qemuMigrationUpdateJobStatus(struct qemud_driver *driver, break; case QEMU_MONITOR_MIGRATION_STATUS_COMPLETED: - priv->job.info.type = VIR_DOMAIN_JOB_COMPLETED; + if (spice_migrated) + priv->job.info.type = VIR_DOMAIN_JOB_COMPLETED; ret = 0; break; @@ -967,6 +977,15 @@ qemuMigrationWaitForCompletion(struct qemud_driver *driver, virDomainObjPtr vm, { qemuDomainObjPrivatePtr priv = vm->privateData; const char *job; + bool wait_for_spice; + + /* If guest uses SPICE and supports seamles_migration we have to hold up + * migration finish until SPICE server transfers its data */ + wait_for_spice = (vm->def->ngraphics == 1) && + (vm->def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE) && + qemuCapsGet(priv->caps, QEMU_CAPS_SEAMLESS_MIGRATION) && + (vm->def->graphics[0]->data.spice.seamless != + VIR_DOMAIN_GRAPHICS_SPICE_MIGRATION_SEAMLESS_OFF); switch (priv->job.asyncJob) { case QEMU_ASYNC_JOB_MIGRATION_OUT: @@ -988,7 +1007,8 @@ qemuMigrationWaitForCompletion(struct qemud_driver *driver, virDomainObjPtr vm, /* Poll every 50ms for progress & to allow cancellation */ struct timespec ts = { .tv_sec = 0, .tv_nsec = 50 * 1000 * 1000ull }; - if (qemuMigrationUpdateJobStatus(driver, vm, job, asyncJob) < 0) + if (qemuMigrationUpdateJobStatus(driver, vm, job, + asyncJob, wait_for_spice) < 0) goto cleanup; if (dconn && virConnectIsAlive(dconn) <= 0) { @@ -1840,6 +1860,7 @@ qemuMigrationRun(struct qemud_driver *driver, int fd = -1; unsigned long migrate_speed = resource ? resource : priv->migMaxBandwidth; virErrorPtr orig_err = NULL; + bool wait_for_spice; VIR_DEBUG("driver=%p, vm=%p, cookiein=%s, cookieinlen=%d, " "cookieout=%p, cookieoutlen=%p, flags=%lx, resource=%lu, " @@ -1848,6 +1869,14 @@ qemuMigrationRun(struct qemud_driver *driver, cookieout, cookieoutlen, flags, resource, spec, spec->destType, spec->fwdType); + /* If guest uses SPICE and supports seamless migration we have to hold up + * migration finish until SPICE server transfers its data */ + wait_for_spice = (vm->def->ngraphics == 1) && + (vm->def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE) && + qemuCapsGet(priv->caps, QEMU_CAPS_SEAMLESS_MIGRATION) && + (vm->def->graphics[0]->data.spice.seamless != + VIR_DOMAIN_GRAPHICS_SPICE_MIGRATION_SEAMLESS_OFF); + if (virLockManagerPluginUsesState(driver->lockManager) && !cookieout) { virReportError(VIR_ERR_INTERNAL_ERROR, @@ -1946,7 +1975,8 @@ qemuMigrationRun(struct qemud_driver *driver, * connection from qemu which may never be initiated. */ if (qemuMigrationUpdateJobStatus(driver, vm, _("migration job"), - QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) + QEMU_ASYNC_JOB_MIGRATION_OUT, + wait_for_spice) < 0) goto cancel; while ((fd = accept(spec->dest.unix_socket.sock, NULL, NULL)) < 0) { diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c index b43b15e..20bb333 100644 --- a/src/qemu/qemu_monitor.c +++ b/src/qemu/qemu_monitor.c @@ -1844,6 +1844,28 @@ int qemuMonitorGetMigrationStatus(qemuMonitorPtr mon, return ret; } +int qemuMonitorGetSpiceMigrationStatus(qemuMonitorPtr mon, + bool *spice_migrated) +{ + int ret; + VIR_DEBUG("mon=%p", mon); + + if (!mon) { + virReportError(VIR_ERR_INVALID_ARG, "%s", + _("monitor must not be NULL")); + return -1; + } + + if (mon->json) { + ret = qemuMonitorJSONGetSpiceMigrationStatus(mon, spice_migrated); + } else { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("JSON monitor is required")); + return -1; + } + + return ret; +} int qemuMonitorMigrateToFd(qemuMonitorPtr mon, unsigned int flags, diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h index f206d49..d3a0877 100644 --- a/src/qemu/qemu_monitor.h +++ b/src/qemu/qemu_monitor.h @@ -346,6 +346,9 @@ int qemuMonitorGetMigrationStatus(qemuMonitorPtr mon, unsigned long long *remaining, unsigned long long *total); +int qemuMonitorGetSpiceMigrationStatus(qemuMonitorPtr mon, + bool *spice_migrated); + typedef enum { QEMU_MONITOR_MIGRATE_BACKGROUND = 1 << 0, QEMU_MONITOR_MIGRATE_NON_SHARED_DISK = 1 << 1, /* migration with non-shared storage with full disk copy */ diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c index 8842817..63dbd25 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -2487,6 +2487,58 @@ int qemuMonitorJSONGetMigrationStatus(qemuMonitorPtr mon, } +static int +qemuMonitorJSONSpiceGetMigrationStatusReply(virJSONValuePtr reply, + bool *spice_migrated) +{ + virJSONValuePtr ret; + const char *migrated_str; + + if (!(ret = virJSONValueObjectGet(reply, "return"))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("query-spice reply was missing return data")); + return -1; + } + + if (!(migrated_str = virJSONValueObjectGetString(ret, "migrated"))) { + /* Deliberately don't report error here as we are + * probably dealing with older qemu which doesn't + * report this yet. Pretend spice is migrated. */ + *spice_migrated = true; + } else { + *spice_migrated = STREQ(migrated_str, "true"); + } + + return 0; +} + + +int qemuMonitorJSONGetSpiceMigrationStatus(qemuMonitorPtr mon, + bool *spice_migrated) +{ + int ret; + virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("query-spice", + NULL); + virJSONValuePtr reply = NULL; + + if (!cmd) + return -1; + + ret = qemuMonitorJSONCommand(mon, cmd, &reply); + + if (ret == 0) + ret = qemuMonitorJSONCheckError(cmd, reply); + + if (ret == 0) + ret = qemuMonitorJSONSpiceGetMigrationStatusReply(reply, + spice_migrated); + + virJSONValueFree(cmd); + virJSONValueFree(reply); + return ret; +} + + int qemuMonitorJSONMigrate(qemuMonitorPtr mon, unsigned int flags, const char *uri) diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h index f5d515f..88edb73 100644 --- a/src/qemu/qemu_monitor_json.h +++ b/src/qemu/qemu_monitor_json.h @@ -132,6 +132,9 @@ int qemuMonitorJSONGetMigrationStatus(qemuMonitorPtr mon, unsigned long long *remaining, unsigned long long *total); +int qemuMonitorJSONGetSpiceMigrationStatus(qemuMonitorPtr mon, + bool *spice_migrated); + int qemuMonitorJSONMigrate(qemuMonitorPtr mon, unsigned int flags, const char *uri); -- 1.7.8.6