Signed-off-by: Cristian Klein <cristiklein(a)gmail.com&gt; --- include/libvirt/libvirt-domain.h | 5 +++ src/driver-hypervisor.h | 5 +++ src/libvirt-domain.c | 92 ++++++++++++++++++++++++++++++++++++++++ src/libvirt_public.syms | 1 + src/remote/remote_driver.c | 1 + src/remote/remote_protocol.x | 12 +++++- src/remote_protocol-structs | 5 +++ 7 files changed, 120 insertions(+), 1 deletion(-) diff --git a/include/libvirt/libvirt-domain.h b/include/libvirt/libvirt-domain.h index ae2c49c..090d97a 100644 --- a/include/libvirt/libvirt-domain.h +++ b/include/libvirt/libvirt-domain.h @@ -634,6 +634,8 @@ typedef enum { VIR_MIGRATE_ABORT_ON_ERROR = (1 << 12), /* abort migration on I/O errors happened during migration */ VIR_MIGRATE_AUTO_CONVERGE = (1 << 13), /* force convergence */ VIR_MIGRATE_RDMA_PIN_ALL = (1 << 14), /* RDMA memory pinning */ + VIR_MIGRATE_ENABLE_POSTCOPY = (1 << 15), /* enable (but do not start) post-copy */ + VIR_MIGRATE_POSTCOPY_AFTER_PRECOPY = (1 << 16), /* start post-copy after the first pass of pre-copy */ } virDomainMigrateFlags; @@ -773,6 +775,9 @@ int virDomainMigrateGetMaxSpeed(virDomainPtr domain, unsigned long *bandwidth, unsigned int flags); +int virDomainMigrateStartPostCopy (virDomainPtr domain, + unsigned int flags); + char * virConnectGetDomainCapabilities(virConnectPtr conn, const char *emulatorbin, const char *arch, diff --git a/src/driver-hypervisor.h b/src/driver-hypervisor.h index 9f26b13..a642dea 100644 --- a/src/driver-hypervisor.h +++ b/src/driver-hypervisor.h @@ -613,6 +613,10 @@ typedef int const char *dom_xml); typedef int +(*virDrvDomainMigrateStartPostCopy)(virDomainPtr domain, + unsigned int flags); + +typedef int (*virDrvConnectIsEncrypted)(virConnectPtr conn); typedef int @@ -1396,6 +1400,7 @@ struct _virHypervisorDriver { virDrvConnectGetAllDomainStats connectGetAllDomainStats; virDrvNodeAllocPages nodeAllocPages; virDrvDomainGetFSInfo domainGetFSInfo; + virDrvDomainMigrateStartPostCopy domainMigrateStartPostCopy; }; diff --git a/src/libvirt-domain.c b/src/libvirt-domain.c index 2b0defc..f29af21 100644 --- a/src/libvirt-domain.c +++ b/src/libvirt-domain.c @@ -3500,6 +3500,9 @@ virDomainMigrateDirect(virDomainPtr domain, * automatically when supported). * VIR_MIGRATE_UNSAFE Force migration even if it is considered unsafe. * VIR_MIGRATE_OFFLINE Migrate offline + * VIR_MIGRATE_ENABLE_POSTCOPY Enable (but do not start) post-copy + * VIR_MIGRATE_POSTCOPY_AFTER_PRECOPY Start post-copy after the first pass + * of pre-copy * * VIR_MIGRATE_TUNNELLED requires that VIR_MIGRATE_PEER2PEER be set. * Applications using the VIR_MIGRATE_PEER2PEER flag will probably @@ -3536,6 +3539,17 @@ virDomainMigrateDirect(virDomainPtr domain, * not support this feature and will return an error if bandwidth * is not 0. * + * If you want to do post-copy migration, you have two choices: + * either use the low-level mechanism provided by libvirt, or its + * default policy. To use the low-level mechanism, you must first enable + * post-copy migration using the VIR_MIGRATE_ENABLE_POSTCOPY flag. Once + * migration is active, from a separate thread, you may start post-copy + * by calling virDomainMigrateStartPostCopy. + * + * The default post-copy policy implemented in libvirt is to start + * post-copy after the first pass of pre-copy. To enable this behaviour + * start migration with the VIR_MIGRATE_POSTCOPY_AFTER_PRECOPY flag. + * * To see which features are supported by the current hypervisor, * see virConnectGetCapabilities, /capabilities/host/migration_features. * @@ -3716,6 +3730,8 @@ virDomainMigrate(virDomainPtr domain, * automatically when supported). * VIR_MIGRATE_UNSAFE Force migration even if it is considered unsafe. * VIR_MIGRATE_OFFLINE Migrate offline + * VIR_MIGRATE_ENABLE_POSTCOPY Enable (but do not start) post-copy + * VIR_MIGRATE_POSTCOPY_AFTER_PRECOPY Start post-copy after the first pass of pre-copy * * VIR_MIGRATE_TUNNELLED requires that VIR_MIGRATE_PEER2PEER be set. * Applications using the VIR_MIGRATE_PEER2PEER flag will probably @@ -3752,6 +3768,17 @@ virDomainMigrate(virDomainPtr domain, * not support this feature and will return an error if bandwidth * is not 0. * + * If you want to do post-copy migration, you have two choices: + * either use the low-level mechanism provided by libvirt, or its + * default policy. To use the low-level mechanism, you must first enable + * post-copy migration using the VIR_MIGRATE_ENABLE_POSTCOPY flag. Once + * migration is active, from a separate thread, you may start post-copy + * by calling virDomainMigrateStartPostCopy. + * + * The default post-copy policy implemented in libvirt is to start + * post-copy after the first pass of pre-copy. To enable this behaviour + * start migration with the VIR_MIGRATE_POSTCOPY_AFTER_PRECOPY flag. + * * To see which features are supported by the current hypervisor, * see virConnectGetCapabilities, /capabilities/host/migration_features. * @@ -4147,6 +4174,8 @@ virDomainMigrate3(virDomainPtr domain, * automatically when supported). * VIR_MIGRATE_UNSAFE Force migration even if it is considered unsafe. * VIR_MIGRATE_OFFLINE Migrate offline + * VIR_MIGRATE_ENABLE_POSTCOPY Enable (but do not start) post-copy + * VIR_MIGRATE_POSTCOPY_AFTER_PRECOPY Start post-copy after the first pass of pre-copy * * The operation of this API hinges on the VIR_MIGRATE_PEER2PEER flag. * If the VIR_MIGRATE_PEER2PEER flag is NOT set, the duri parameter @@ -4179,6 +4208,17 @@ virDomainMigrate3(virDomainPtr domain, * not support this feature and will return an error if bandwidth * is not 0. * + * If you want to do post-copy migration, you have two choices: + * either use the low-level mechanism provided by libvirt, or its + * default policy. To use the low-level mechanism, you must first enable + * post-copy migration using the VIR_MIGRATE_ENABLE_POSTCOPY flag. Once + * migration is active, from a separate thread, you may start post-copy + * by calling virDomainMigrateStartPostCopy. + * + * The default post-copy policy implemented in libvirt is to start + * post-copy after the first pass of pre-copy. To enable this behaviour + * start migration with the VIR_MIGRATE_POSTCOPY_AFTER_PRECOPY flag. + * * To see which features are supported by the current hypervisor, * see virConnectGetCapabilities, /capabilities/host/migration_features. * @@ -4292,6 +4332,8 @@ virDomainMigrateToURI(virDomainPtr domain, * automatically when supported). * VIR_MIGRATE_UNSAFE Force migration even if it is considered unsafe. * VIR_MIGRATE_OFFLINE Migrate offline + * VIR_MIGRATE_ENABLE_POSTCOPY Enable (but do not start) post-copy + * VIR_MIGRATE_POSTCOPY_AFTER_PRECOPY Start post-copy after the first pass of pre-copy * * The operation of this API hinges on the VIR_MIGRATE_PEER2PEER flag. * @@ -4334,6 +4376,17 @@ virDomainMigrateToURI(virDomainPtr domain, * not support this feature and will return an error if bandwidth * is not 0. * + * If you want to do post-copy migration, you have two choices: + * either use the low-level mechanism provided by libvirt, or its + * default policy. To use the low-level mechanism, you must first enable + * post-copy migration using the VIR_MIGRATE_ENABLE_POSTCOPY flag. Once + * migration is active, from a separate thread, you may start post-copy + * by calling virDomainMigrateStartPostCopy. + * + * The default post-copy policy implemented in libvirt is to start + * post-copy after the first pass of pre-copy. To enable this behaviour + * start migration with the VIR_MIGRATE_POSTCOPY_AFTER_PRECOPY flag. + * * To see which features are supported by the current hypervisor, * see virConnectGetCapabilities, /capabilities/host/migration_features. * @@ -8932,6 +8985,45 @@ virDomainMigrateGetMaxSpeed(virDomainPtr domain, /** + * virDomainMigrateStartPostCopy: + * @domain: a domain object + * @flags: extra flags; not used yet, so callers should always pass 0 + * + * Starts post-copy migration. This function has to be called while + * migration (initially pre-copy) is in progress. The migration operation + * must be called with the VIR_MIGRATE_ENABLE_POSTCOPY flag. + * + * Returns 0 in case of success, -1 otherwise. + */ +int +virDomainMigrateStartPostCopy(virDomainPtr domain, + unsigned int flags) +{ + virConnectPtr conn; + + VIR_DOMAIN_DEBUG(domain); + + virResetLastError(); + + virCheckDomainReturn(domain, -1); + conn = domain->conn; + + virCheckReadOnlyGoto(conn->flags, error); + + if (conn->driver->domainMigrateStartPostCopy) { + if (conn->driver->domainMigrateStartPostCopy(domain, flags) < 0) + goto error; + return 0; + } + + virReportUnsupportedError(); + error: + virDispatchError(conn); + return -1; +} + + +/** * virConnectDomainEventRegisterAny: * @conn: pointer to the connection * @dom: pointer to the domain diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms index e4c2df1..790f2f3 100644 --- a/src/libvirt_public.syms +++ b/src/libvirt_public.syms @@ -688,6 +688,7 @@ LIBVIRT_1.2.11 { global: virDomainFSInfoFree; virDomainGetFSInfo; + virDomainMigrateStartPostCopy; } LIBVIRT_1.2.9; # .... define new API here using predicted next version number .... diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index 22f0c88..001010f 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -8295,6 +8295,7 @@ static virHypervisorDriver hypervisor_driver = { .connectGetAllDomainStats = remoteConnectGetAllDomainStats, /* 1.2.8 */ .nodeAllocPages = remoteNodeAllocPages, /* 1.2.9 */ .domainGetFSInfo = remoteDomainGetFSInfo, /* 1.2.11 */ + .domainMigrateStartPostCopy = remoteDomainMigrateStartPostCopy, /* 1.2.11 */ }; static virNetworkDriver network_driver = { diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index cbd3ec7..4b13a8e 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -3143,6 +3143,10 @@ struct remote_domain_get_fsinfo_ret { unsigned int ret; }; +struct remote_domain_migrate_start_post_copy_args { + remote_nonnull_domain dom; + unsigned int flags; +}; /*----- Protocol. -----*/ /* Define the program number, protocol version and procedure numbers here. */ @@ -5550,5 +5554,11 @@ enum remote_procedure { * @generate: none * @acl: domain:fs_freeze */ - REMOTE_PROC_DOMAIN_GET_FSINFO = 349 + REMOTE_PROC_DOMAIN_GET_FSINFO = 349, + + /** + * @generate: both + * @acl: domain:migrate + */ + REMOTE_PROC_DOMAIN_MIGRATE_START_POST_COPY = 350 }; diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs index 2907fd5..c23d7c7 100644 --- a/src/remote_protocol-structs +++ b/src/remote_protocol-structs @@ -2605,6 +2605,10 @@ struct remote_domain_get_fsinfo_ret { } info; u_int ret; }; +struct remote_domain_migrate_start_post_copy_args { + remote_nonnull_domain dom; + u_int flags; +}; enum remote_procedure { REMOTE_PROC_CONNECT_OPEN = 1, REMOTE_PROC_CONNECT_CLOSE = 2, @@ -2955,4 +2959,5 @@ enum remote_procedure { REMOTE_PROC_NODE_ALLOC_PAGES = 347, REMOTE_PROC_DOMAIN_EVENT_CALLBACK_AGENT_LIFECYCLE = 348, REMOTE_PROC_DOMAIN_GET_FSINFO = 349, + REMOTE_PROC_DOMAIN_MIGRATE_START_POST_COPY = 350, }; -- 1.9.1

Signed-off-by: Cristian Klein <cristiklein(a)gmail.com&gt; --- src/qemu/qemu_migration.c | 82 +++++++++++++++++++++++++++++++++++++++++++++++ src/qemu/qemu_migration.h | 3 +- 2 files changed, 84 insertions(+), 1 deletion(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index a1b1458..ede938b 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -1803,6 +1803,67 @@ qemuMigrationSetOffline(virQEMUDriverPtr driver, static int +qemuMigrationTestPostCopy(virQEMUDriverPtr driver, + virDomainObjPtr vm, + qemuDomainAsyncJob job) +{ + qemuDomainObjPrivatePtr priv = vm->privateData; + int ret; + + if (qemuDomainObjEnterMonitorAsync(driver, vm, job) < 0) + return -1; + + ret = qemuMonitorGetMigrationCapability( + priv->mon, + QEMU_MONITOR_MIGRATION_CAPS_POSTCOPY); + + qemuDomainObjExitMonitor(driver, vm); + return ret; +} + + +static int +qemuMigrationSetPostCopy(virQEMUDriverPtr driver, + virDomainObjPtr vm, + qemuDomainAsyncJob job) +{ + qemuDomainObjPrivatePtr priv = vm->privateData; + int ret; + + if (job != QEMU_ASYNC_JOB_MIGRATION_OUT) { + virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("Set post-copy only makes sense for outgoing migration")); + } + + if (qemuDomainObjEnterMonitorAsync(driver, vm, job) < 0) + return -1; + + ret = qemuMonitorGetMigrationCapability( + priv->mon, + QEMU_MONITOR_MIGRATION_CAPS_POSTCOPY); + + if (ret < 0) { + goto cleanup; + } else if (ret == 0) { + virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("Post-copy migration is not supported by " + "source QEMU binary")); + ret = -1; + goto cleanup; + } + + ret = qemuMonitorSetMigrationCapability( + priv->mon, + QEMU_MONITOR_MIGRATION_CAPS_POSTCOPY, + true); + + cleanup: + qemuDomainObjExitMonitor(driver, vm); + return ret; +} + + +static int qemuMigrationSetCompression(virQEMUDriverPtr driver, virDomainObjPtr vm, bool state, @@ -2752,6 +2813,15 @@ qemuMigrationPrepareAny(virQEMUDriverPtr driver, dataFD[1] = -1; /* 'st' owns the FD now & will close it */ } + if (flags & VIR_MIGRATE_ENABLE_POSTCOPY && + qemuMigrationTestPostCopy(driver, vm, + QEMU_ASYNC_JOB_MIGRATION_IN) < 0) { + virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("Post-copy migration is not supported by " + "target QEMU binary")); + goto stop; + } + if (qemuMigrationSetCompression(driver, vm, flags & VIR_MIGRATE_COMPRESSED, QEMU_ASYNC_JOB_MIGRATION_IN) < 0) @@ -3602,6 +3672,18 @@ qemuMigrationRun(virQEMUDriverPtr driver, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) goto cleanup; + if (flags & VIR_MIGRATE_ENABLE_POSTCOPY) { + if (!(flags & VIR_MIGRATE_LIVE)) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("Enabling post-copy only makes sense with " + "live migration")); + goto cleanup; + } + if (qemuMigrationSetPostCopy(driver, vm, + QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) + goto cleanup; + } + if (qemuDomainObjEnterMonitorAsync(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) goto cleanup; diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h index e7a90c3..5d60238 100644 --- a/src/qemu/qemu_migration.h +++ b/src/qemu/qemu_migration.h @@ -41,7 +41,8 @@ VIR_MIGRATE_COMPRESSED | \ VIR_MIGRATE_ABORT_ON_ERROR | \ VIR_MIGRATE_AUTO_CONVERGE | \ - VIR_MIGRATE_RDMA_PIN_ALL) + VIR_MIGRATE_RDMA_PIN_ALL | \ + VIR_MIGRATE_ENABLE_POSTCOPY) /* All supported migration parameters and their types. */ # define QEMU_MIGRATION_PARAMETERS \ -- 1.9.1

Signed-off-by: Cristian Klein <cristiklein(a)gmail.com&gt; --- src/qemu/qemu_driver.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 06803b4..fc7de23 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -12356,6 +12356,55 @@ qemuDomainGetJobStats(virDomainPtr dom, } +static int qemuDomainMigrateStartPostCopy(virDomainPtr dom, + unsigned int flags) +{ + virQEMUDriverPtr driver = dom->conn->privateData; + virDomainObjPtr vm; + int ret = -1; + qemuDomainObjPrivatePtr priv; + + virCheckFlags(0, -1); + + if (!(vm = qemuDomObjFromDomain(dom))) + goto cleanup; + + if (virDomainMigrateStartPostCopyEnsureACL(dom->conn, vm->def) < 0) + goto cleanup; + + if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MIGRATION_OP) < 0) + goto cleanup; + + if (!virDomainObjIsActive(vm)) { + virReportError(VIR_ERR_OPERATION_INVALID, + "%s", _("domain is not running")); + goto endjob; + } + + priv = vm->privateData; + + if (priv->job.asyncJob != QEMU_ASYNC_JOB_MIGRATION_OUT) { + virReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("post-copy can only be started " + "while migration is in progress")); + goto endjob; + } + + VIR_DEBUG("Starting post-copy"); + qemuDomainObjEnterMonitor(driver, vm); + ret = qemuMonitorMigrateStartPostCopy(priv->mon); + qemuDomainObjExitMonitor(driver, vm); + + endjob: + if (!qemuDomainObjEndJob(driver, vm)) + vm = NULL; + + cleanup: + if (vm) + virObjectUnlock(vm); + return ret; +} + static int qemuDomainAbortJob(virDomainPtr dom) { virQEMUDriverPtr driver = dom->conn->privateData; @@ -19088,6 +19137,7 @@ static virHypervisorDriver qemuDriver = { .connectGetAllDomainStats = qemuConnectGetAllDomainStats, /* 1.2.8 */ .nodeAllocPages = qemuNodeAllocPages, /* 1.2.9 */ .domainGetFSInfo = qemuDomainGetFSInfo, /* 1.2.11 */ + .domainMigrateStartPostCopy = qemuDomainMigrateStartPostCopy, /* 1.2.11 */ }; -- 1.9.1

Signed-off-by: Cristian Klein <cristiklein(a)gmail.com&gt; --- tools/virsh-domain.c | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++-- tools/virsh.pod | 5 +++++ 2 files changed, 63 insertions(+), 2 deletions(-) diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c index 1753f6e..52e91d9 100644 --- a/tools/virsh-domain.c +++ b/tools/virsh-domain.c @@ -9439,6 +9439,10 @@ static const vshCmdOptDef opts_migrate[] = { .type = VSH_OT_BOOL, .help = N_("enable (but do not start) post-copy migration; to start post-copy use migrate-start-postcopy") }, + {.name = "postcopy-after", + .type = VSH_OT_INT, + .help = N_("switch to post-copy migration if live migration exceeds timeout (in seconds)") + }, {.name = "xml", .type = VSH_OT_STRING, .help = N_("filename containing updated XML for the target") @@ -9522,6 +9526,8 @@ doMigrate(void *opaque) if (vshCommandOptBool(cmd, "enable-postcopy")) flags |= VIR_MIGRATE_ENABLE_POSTCOPY; + if (vshCommandOptBool(cmd, "postcopy-after")) /* actually an int */ + flags |= VIR_MIGRATE_ENABLE_POSTCOPY; if (vshCommandOptBool(cmd, "live")) flags |= VIR_MIGRATE_LIVE; if (vshCommandOptBool(cmd, "p2p")) @@ -9612,6 +9618,20 @@ vshMigrationTimeout(vshControl *ctl, virDomainSuspend(dom); } +static void +vshMigrationPostCopyAfter(vshControl *ctl, + virDomainPtr dom, + void *opaque ATTRIBUTE_UNUSED) +{ + vshDebug(ctl, VSH_ERR_DEBUG, "starting post-copy\n"); + int rv = virDomainMigrateStartPostCopy(dom, 0); + if (rv < 0) { + vshError(ctl, "%s", _("start post-copy command failed")); + } else { + vshDebug(ctl, VSH_ERR_INFO, "switched to post-copy\n"); + } +} + static bool cmdMigrate(vshControl *ctl, const vshCmd *cmd) { @@ -9621,8 +9641,10 @@ cmdMigrate(vshControl *ctl, const vshCmd *cmd) bool verbose = false; bool functionReturn = false; int timeout = 0; + int postCopyAfter = 0; bool live_flag = false; vshCtrlData data = { .dconn = NULL }; + int rv; if (!(dom = vshCommandOptDomain(ctl, cmd, NULL))) return false; @@ -9640,6 +9662,35 @@ cmdMigrate(vshControl *ctl, const vshCmd *cmd) goto cleanup; } + rv = vshCommandOptInt(cmd, "postcopy-after", &postCopyAfter); + if (rv < 0 || (rv > 0 && postCopyAfter < 0)) { + vshError(ctl, "%s", _("invalid postcopy-after parameter")); + goto cleanup; + } + if (rv > 0) { + /* Ensure that we can multiply by 1000 without overflowing. */ + if (postCopyAfter > INT_MAX / 1000) { + vshError(ctl, "%s", _("post-copy after parameter is too large")); + goto cleanup; + } + postCopyAfter *= 1000; + /* 0 is a special value inside virsh, which means no timeout, so + * use 1ms instead for "start post-copy immediately" + */ + if (postCopyAfter == 0) + postCopyAfter = 1; + } + + if (postCopyAfter > 0 && !live_flag) { + vshError(ctl, "%s", + _("migrate: Unexpected postcopy-after for offline migration")); + goto cleanup; + } else if (postCopyAfter > 0 && timeout > 0) { + vshError(ctl, "%s", + _("migrate: --postcopy-after is incompatible with --timeout")); + goto cleanup; + } + if (pipe(p) < 0) goto cleanup; @@ -9669,8 +9720,13 @@ cmdMigrate(vshControl *ctl, const vshCmd *cmd) doMigrate, &data) < 0) goto cleanup; - functionReturn = vshWatchJob(ctl, dom, verbose, p[0], timeout, - vshMigrationTimeout, NULL, _("Migration")); + if (postCopyAfter != 0) { + functionReturn = vshWatchJob(ctl, dom, verbose, p[0], postCopyAfter, + vshMigrationPostCopyAfter, NULL, _("Migration")); + } else { + functionReturn = vshWatchJob(ctl, dom, verbose, p[0], timeout, + vshMigrationTimeout, NULL, _("Migration")); + } virThreadJoin(&workerThread); diff --git a/tools/virsh.pod b/tools/virsh.pod index 18c6a23..a4c5d34 100644 --- a/tools/virsh.pod +++ b/tools/virsh.pod @@ -1429,6 +1429,7 @@ to the I<uri> namespace is displayed instead of being modified. I<domain> I<desturi> [I<migrateuri>] [I<graphicsuri>] [I<listen-address>] [I<dname>] [I<--timeout> B<seconds>] [I<--xml> B<file>] [I<--enable-postcopy>] +[I<--postcopy-after> B<seconds>] Migrate domain to another host. Add I<--live> for live migration; <--p2p> for peer-2-peer migration; I<--direct> for direct migration; or I<--tunnelled> @@ -1481,6 +1482,10 @@ actually start post-copy, i.e., migration is started in pre-copy mode. Once migration started, the user may switch to post-copy using the B<migrate-start-postcopy> command sent from another virsh instance. +I<--postcopy-after> switches to post-copy migration when pre-copy migration +exceeds that many seconds. Zero means start post-copy as soon as possible. +It can only be used with I<--live>. + Running migration can be canceled by interrupting virsh (usually using C<Ctrl-C>) or by B<domjobabort> command sent from another virsh instance. -- 1.9.1

Signed-off-by: Cristian Klein <cristiklein(a)gmail.com&gt; --- src/qemu/qemu_driver.c | 2 ++ src/qemu/qemu_migration.c | 49 +++++++++++++++++++++++++++++++++++++++++++---- src/qemu/qemu_migration.h | 3 ++- 3 files changed, 49 insertions(+), 5 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index fc7de23..53347ea 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -11348,6 +11348,8 @@ qemuDomainMigratePrepare2(virConnectPtr dconn, virCheckFlags(QEMU_MIGRATION_FLAGS, -1); + if (flags & VIR_MIGRATE_POSTCOPY_AFTER_PRECOPY) + flags |= VIR_MIGRATE_ENABLE_POSTCOPY; if (flags & VIR_MIGRATE_ENABLE_POSTCOPY) { /* post-copy migration does not work with Sequence v2 */ virReportError(VIR_ERR_INTERNAL_ERROR, "%s", diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 137ddfa..e5412c5 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -2112,7 +2112,8 @@ qemuMigrationWaitForCompletion(virQEMUDriverPtr driver, qemuDomainAsyncJob asyncJob, virConnectPtr dconn, bool abort_on_error, - bool exit_on_postcopy_active) + bool exit_on_postcopy_active, + bool trigger_postcopy) { qemuDomainObjPrivatePtr priv = vm->privateData; qemuDomainJobInfoPtr jobInfo = priv->job.current; @@ -2144,6 +2145,34 @@ qemuMigrationWaitForCompletion(virQEMUDriverPtr driver, if (qemuMigrationUpdateJobStatus(driver, vm, job, asyncJob) == -1) break; + /* automatically switch to post-copy if the user requested so */ + if (trigger_postcopy && + jobInfo->status.status == QEMU_MONITOR_MIGRATION_STATUS_ACTIVE && + jobInfo->status.ram_dirty_sync_count > 0) { + int rv; + + /* Clear variable to prevent sending this command to qemu twice */ + trigger_postcopy = false; + + if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) { + /* Migration might have finished before we got to + * trigger post-copy */ + break; + } + rv = qemuMonitorMigrateStartPostCopy(priv->mon); + qemuDomainObjExitMonitor(driver, vm); + + if (rv < 0) { + virReportError(VIR_ERR_OPERATION_FAILED, + _("%s: %s"), job, + _("Switching to post-copy failed")); + if (abort_on_error) + break; + } else { + VIR_DEBUG("Switched to post-copy"); + } + } + /* cancel migration if disk I/O error is emitted while migrating */ if (abort_on_error && virDomainObjGetState(vm, &pauseReason) == VIR_DOMAIN_PAUSED && @@ -2822,6 +2851,8 @@ qemuMigrationPrepareAny(virQEMUDriverPtr driver, dataFD[1] = -1; /* 'st' owns the FD now & will close it */ } + if (flags & VIR_MIGRATE_POSTCOPY_AFTER_PRECOPY) + flags |= VIR_MIGRATE_ENABLE_POSTCOPY; if (flags & VIR_MIGRATE_ENABLE_POSTCOPY && qemuMigrationTestPostCopy(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN) < 0) { @@ -3200,13 +3231,17 @@ qemuMigrationConfirmPhase(virQEMUDriverPtr driver, virCheckFlags(QEMU_MIGRATION_FLAGS, -1); /* Wait for post-copy to complete */ + if (flags & VIR_MIGRATE_POSTCOPY_AFTER_PRECOPY) + flags |= VIR_MIGRATE_ENABLE_POSTCOPY; if (flags & VIR_MIGRATE_ENABLE_POSTCOPY) { bool abort_on_error = !!(flags & VIR_MIGRATE_ABORT_ON_ERROR); bool exit_on_postcopy_active = false; + bool trigger_postcopy = false; rv = qemuMigrationWaitForCompletion(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT, conn, abort_on_error, - exit_on_postcopy_active); + exit_on_postcopy_active, + trigger_postcopy); if (rv < 0) goto cleanup; } @@ -3693,6 +3728,8 @@ qemuMigrationRun(virQEMUDriverPtr driver, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) goto cleanup; + if (flags & VIR_MIGRATE_POSTCOPY_AFTER_PRECOPY) + flags |= VIR_MIGRATE_ENABLE_POSTCOPY; if (flags & VIR_MIGRATE_ENABLE_POSTCOPY) { if (!(flags & VIR_MIGRATE_LIVE)) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", @@ -3809,10 +3846,12 @@ qemuMigrationRun(virQEMUDriverPtr driver, { bool exit_on_postcopy_active = true; + bool trigger_postcopy = (flags & VIR_MIGRATE_POSTCOPY_AFTER_PRECOPY); rc = qemuMigrationWaitForCompletion(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT, dconn, abort_on_error, - exit_on_postcopy_active); + exit_on_postcopy_active, + trigger_postcopy); } if (rc == -2) @@ -5280,9 +5319,11 @@ qemuMigrationToFile(virQEMUDriverPtr driver, virDomainObjPtr vm, { bool abort_on_error = false; bool exit_on_postcopy_active = true; + bool trigger_postcopy = false; rc = qemuMigrationWaitForCompletion(driver, vm, asyncJob, NULL, abort_on_error, - exit_on_postcopy_active); + exit_on_postcopy_active, + trigger_postcopy); } if (rc < 0) { diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h index 5d60238..8cec9b8 100644 --- a/src/qemu/qemu_migration.h +++ b/src/qemu/qemu_migration.h @@ -42,7 +42,8 @@ VIR_MIGRATE_ABORT_ON_ERROR | \ VIR_MIGRATE_AUTO_CONVERGE | \ VIR_MIGRATE_RDMA_PIN_ALL | \ - VIR_MIGRATE_ENABLE_POSTCOPY) + VIR_MIGRATE_ENABLE_POSTCOPY | \ + VIR_MIGRATE_POSTCOPY_AFTER_PRECOPY) /* All supported migration parameters and their types. */ # define QEMU_MIGRATION_PARAMETERS \ -- 1.9.1

This reverts commit 46a811db0731cedaea0153fc223faa6096cee5b5. It causes random problems in OpenStack, which displays the following error: """ error : virNWFilterObjAssignDef:3075 : operation failed: filter 'nova-no-nd-reflection' already exists with uuid ef783c9f-ae1c-4242-8cd5-9cef5ec4fa7a """ Special thanks to Vojtech Cima for investigating. Signed-off-by: Cristian Klein <cristiklein(a)gmail.com&gt; --- src/conf/nwfilter_conf.c | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/src/conf/nwfilter_conf.c b/src/conf/nwfilter_conf.c index 074d745..7abeff8 100644 --- a/src/conf/nwfilter_conf.c +++ b/src/conf/nwfilter_conf.c @@ -3065,17 +3065,6 @@ virNWFilterObjAssignDef(virNWFilterObjListPtr nwfilters, return NULL; } virNWFilterObjUnlock(nwfilter); - } else { - nwfilter = virNWFilterObjFindByName(nwfilters, def->name); - if (nwfilter) { - char uuidstr[VIR_UUID_STRING_BUFLEN]; - virUUIDFormat(nwfilter->def->uuid, uuidstr); - virReportError(VIR_ERR_OPERATION_FAILED, - _("filter '%s' already exists with uuid %s"), - def->name, uuidstr); - virNWFilterObjUnlock(nwfilter); - return NULL; - } } if (virNWFilterDefLoopDetect(nwfilters, def) < 0) { -- 1.9.1

On 2014-12-02 17:03, Jiri Denemark wrote: I just observed that later versions of OpenStack fixed this. Sorry for the noise. For future references: https://review.openstack.org/#/c/122721/ https://review.openstack.org/#/c/122721/1/nova/virt/libvirt/firewall.py Cristian