migration: Test the new "file:" migration
cover migration: Test the new "file:" migration
Based-on:
[PATCH V3 0/2] migration file URI
https://lore.kernel.org/r/[email protected]
Since v1:
- added the force-emit-setup-event property
- added verification that the skipped region is empty
CI run: https://gitlab.com/farosas/qemu/-/pipelines/914915941
v1:
https://lore.kernel.org/r/[email protected]
Here's the test for the file: migration.
I hit an issue with the setting of migration status. If we call query-migrate too soon after migrate-incoming, the query returns an empty response because we're not setting the MIGRATION_STATUS_SETUP in the incoming path. We just send the event, but never actually change state.
Aside from the fix, there's some tidying up to avoid duplicating too much code in the tests.
Thanks
CI run: https://gitlab.com/farosas/qemu/-/pipelines/912226554
Fabiano Rosas (6):
migration: Set migration status early in incoming side tests/qtest: migration: Expose migrate_set_capability tests/qtest: migration: Add migrate_incoming_qmp helper tests/qtest: migration: Use migrate_incoming_qmp where appropriate tests/qtest: migration: Add support for negative testing of
qmp_migrate
tests/qtest: migration-test: Add tests for file-based migration
migration/migration.c | 17 +++- migration/migration.h | 11 +++ migration/options.c | 13 +++ migration/options.h | 1 + tests/qtest/libqtest.c | 33 +++++++ tests/qtest/libqtest.h | 28 ++++++ tests/qtest/meson.build | 1 + tests/qtest/migration-helpers.c | 61 +++++++++++++ tests/qtest/migration-helpers.h | 11 +++ tests/qtest/migration-test.c | 144 +++++++++++++++++++++++++----- tests/qtest/virtio-net-failover.c | 77 ++-------------- 11 files changed, 304 insertions(+), 93 deletions(-)
Signature · 1 line
2.35.3
PATCH 1/6 migration: Set migration status early in incoming side
We are sending a migration event of MIGRATION_STATUS_SETUP at qemu_start_incoming_migration but never actually setting the state.
This creates a window between qmp_migrate_incoming and process_incoming_migration_co where the migration status is still MIGRATION_STATUS_NONE. Calling query-migrate during this time will return an empty response even though the incoming migration command has already been issued.
Commit 7cf1fe6d68 ("migration: Add migration events on target side") has added support to the 'events' capability to the incoming part of migration, but chose to send the SETUP event without setting the state. I'm assuming this was a mistake.
To avoid introducing a change in behavior, we need to keep sending the SETUP event, even if the 'events' capability is not set. Add the force-emit-setup-event migration property to enable it.
--- migration/migration.c | 17 +++++++++++++++-- migration/migration.h | 11 +++++++++++ migration/options.c | 13 +++++++++++++ migration/options.h | 1 + 4 files changed, 40 insertions(+), 2 deletions(-)
migration/migration.c +15 -2
@@ -424,13 +424,26 @@ void migrate_add_address(SocketAddress *address)static void qemu_start_incoming_migration (const char *uri,Error **errp) {const char *p =NULL ; +MigrationIncomingState *mis =migration_incoming_get_current ();/* URI is not suitable for migration? */ if (!migration_channels_and_uri_compatible (uri, errp)) {return ; } -qapi_event_send_migration (MIGRATION_STATUS_SETUP ); +migrate_set_state (&mis->state,MIGRATION_STATUS_NONE , +MIGRATION_STATUS_SETUP ); +/* +* QMP clients should have set the 'events' migration capability +* if they want to receive this event, in which case the +* migrate_set_state() call above will have already sent the +* event. We still need to send the event for compatibility even +* if migration events are disabled. +*/ +if (migrate_emit_setup_event ()) { +qapi_event_send_migration (MIGRATION_STATUS_SETUP ); + } +if (strstart (uri,"tcp:" , &p) ||strstart (uri,"unix:" ,NULL ) ||strstart (uri,"vsock:" ,NULL )) {
@@ -524,7 +537,7 @@ process_incoming_migration_co(void *opaque) mis->largest_page_size =qemu_ram_pagesize_largest ();postcopy_state_set (POSTCOPY_INCOMING_NONE ); -migrate_set_state (&mis->state,MIGRATION_STATUS_NONE , +migrate_set_state (&mis->state,MIGRATION_STATUS_SETUP ,MIGRATION_STATUS_ACTIVE ); mis->loadvm_co =qemu_coroutine_self ();
migration/migration.h +11 -0
@@ -433,6 +433,17 @@ struct MigrationState {*/ uint8_t clear_bitmap_shift; +/* +* Always emit the incoming migration's SETUP event, even when the +* 'events' capability is not enabled. +* +* QMP clients that wish to receive migration events should always +* enable the 'events' capability. This property is for +* compatibility with clients that rely on the older QEMU behavior +* of unconditionally emitting the SETUP event. +*/ +bool force_emit_setup_event; +/* * This save hostname when out-going migration starts */
migration/options.c +13 -0
@@ -95,6 +95,8 @@ Property migration_properties[] = { clear_bitmap_shift, CLEAR_BITMAP_SHIFT_DEFAULT),DEFINE_PROP_BOOL ("x-preempt-pre-7-2" , MigrationState, preempt_pre_7_2, false), +DEFINE_PROP_BOOL ("force-emit-setup-event" , MigrationState, + force_emit_setup_event, true),/* Migration parameters */ DEFINE_PROP_UINT8("x-compress-level", MigrationState,
@@ -338,6 +340,17 @@ bool migrate_zero_copy_send(void)/* pseudo capabilities */ +bool migrate_emit_setup_event (void ) +{ +MigrationState *s =migrate_get_current (); + +/* +* If migration events are enabled the setup event will have +* already been sent. +*/ +return !migrate_events () && s->force_emit_setup_event; +} +bool migrate_multifd_flush_after_each_section (void ) {MigrationState *s =migrate_get_current ();
migration/options.h +1 -0
@@ -52,6 +52,7 @@ bool migrate_zero_copy_send(void);* check, but they are not a capability. */ +bool migrate_emit_setup_event (void );bool migrate_multifd_flush_after_each_section (void );bool migrate_postcopy (void );bool migrate_tls (void );
Signature · 1 line
2.35.3
Re: [PATCH 1/6] migration: Set migration status early in incoming side
Quoted 9 lines · Fabiano Rosas
We are sending a migration event of
MIGRATION_STATUS_SETUPatqemu_start_incoming_migrationbut never actually setting the state.This creates a window between
qmp_migrate_incomingandprocess_incoming_migration_cowhere the migration status is stillMIGRATION_STATUS_NONE. Calling query-migrate during this time will return an empty response even though the incoming migration command has already been issued.
Quoted 8 lines
Commit
7cf1fe6d68("migration: Add migration events on target side") has added support to the 'events' capability to the incoming part of migration, but chose to send the SETUP event without setting the state. I'm assuming this was a mistake.To avoid introducing a change in behavior, we need to keep sending the SETUP event, even if the 'events' capability is not set. Add the force-emit-setup-event migration property to enable it.
This is so unfortunate... since qemu 2.4.....
Does it mean that when cap-events is set we can send duplicated events?
The fix makes sense to me in general, butt I'm curious whether we can fix it without having a compat bit doing the wrong thing, even if having the risk of breaking someone, with the hope that the only thing he/she needs to do is to enable the cap-events if didn't. I'd consider that if e.g. as long as libvirt is fine. Does anyone know how libvirt handles this?
The worst case is if there's major breakage we can apply a patch adding the compat bit and copy stable, which should cover all the recent releases. And if no report after a few releases, probably mean we're fine anyway.
It's just feel so unfortunate migration needs to carry over so much legacy issues along the way. So hope to avoid it if any possiblility.
Quoted 118 lines
Signed-off-by Fabiano Rosas <[email protected]>--- migration/migration.c | 17 +++++++++++++++-- migration/migration.h | 11 +++++++++++ migration/options.c | 13 +++++++++++++ migration/options.h | 1 + 4 files changed, 40 insertions(+), 2 deletions(-)migration/migration.c +15
-2@@ -424,13 +424,26 @@ void migrate_add_address(SocketAddress *address)static void qemu_start_incoming_migration (const char *uri,Error **errp) {const char *p =NULL ; +MigrationIncomingState *mis =migration_incoming_get_current ();/* URI is not suitable for migration? */ if (!migration_channels_and_uri_compatible (uri, errp)) {return ; } -qapi_event_send_migration (MIGRATION_STATUS_SETUP ); +migrate_set_state (&mis->state,MIGRATION_STATUS_NONE , +MIGRATION_STATUS_SETUP ); +/* +* QMP clients should have set the 'events' migration capability +* if they want to receive this event, in which case the +* migrate_set_state() call above will have already sent the +* event. We still need to send the event for compatibility even +* if migration events are disabled. +*/ +if (migrate_emit_setup_event ()) { +qapi_event_send_migration (MIGRATION_STATUS_SETUP ); + } +if (strstart (uri,"tcp:" , &p) ||strstart (uri,"unix:" ,NULL ) ||strstart (uri,"vsock:" ,NULL )) {@@ -524,7 +537,7 @@ process_incoming_migration_co(void *opaque) mis->largest_page_size =qemu_ram_pagesize_largest ();postcopy_state_set (POSTCOPY_INCOMING_NONE ); -migrate_set_state (&mis->state,MIGRATION_STATUS_NONE , +migrate_set_state (&mis->state,MIGRATION_STATUS_SETUP ,MIGRATION_STATUS_ACTIVE ); mis->loadvm_co =qemu_coroutine_self ();migration/migration.h +11
-0@@ -433,6 +433,17 @@ struct MigrationState {*/ uint8_t clear_bitmap_shift; +/* +* Always emit the incoming migration's SETUP event, even when the +* 'events' capability is not enabled. +* +* QMP clients that wish to receive migration events should always +* enable the 'events' capability. This property is for +* compatibility with clients that rely on the older QEMU behavior +* of unconditionally emitting the SETUP event. +*/ +bool force_emit_setup_event; +/* * This save hostname when out-going migration starts */ migration/options.c +13
-0@@ -95,6 +95,8 @@ Property migration_properties[] = { clear_bitmap_shift, CLEAR_BITMAP_SHIFT_DEFAULT),DEFINE_PROP_BOOL ("x-preempt-pre-7-2" , MigrationState, preempt_pre_7_2, false), +DEFINE_PROP_BOOL ("force-emit-setup-event" , MigrationState, + force_emit_setup_event, true),/* Migration parameters */ DEFINE_PROP_UINT8("x-compress-level", MigrationState,@@ -338,6 +340,17 @@ bool migrate_zero_copy_send(void)/* pseudo capabilities */ +bool migrate_emit_setup_event (void ) +{ +MigrationState *s =migrate_get_current (); + +/* +* If migration events are enabled the setup event will have +* already been sent. +*/ +return !migrate_events () && s->force_emit_setup_event; +} +bool migrate_multifd_flush_after_each_section (void ) {MigrationState *s =migrate_get_current ();migration/options.h +1
-0@@ -52,6 +52,7 @@ bool migrate_zero_copy_send(void);* check, but they are not a capability. */ +bool migrate_emit_setup_event (void );bool migrate_multifd_flush_after_each_section (void );bool migrate_postcopy (void );bool migrate_tls (void );Signature · 1 line
2.35.3
Signature · 1 line
Peter Xu
Re: [PATCH 1/6] migration: Set migration status early in incoming side
Quoted 15 lines · Peter Xu
Quoted 14 lines · Fabiano Rosas
We are sending a migration event of
MIGRATION_STATUS_SETUPatqemu_start_incoming_migrationbut never actually setting the state.This creates a window between
qmp_migrate_incomingandprocess_incoming_migration_cowhere the migration status is stillMIGRATION_STATUS_NONE. Calling query-migrate during this time will return an empty response even though the incoming migration command has already been issued.Commit
7cf1fe6d68("migration: Add migration events on target side") has added support to the 'events' capability to the incoming part of migration, but chose to send the SETUP event without setting the state. I'm assuming this was a mistake.
Quoted 8 lines
Quoted 3 lines
To avoid introducing a change in behavior, we need to keep sending the SETUP event, even if the 'events' capability is not set. Add the force-emit-setup-event migration property to enable it.
This is so unfortunate... since qemu 2.4.....
Does it mean that when cap-events is set we can send duplicated events?
Not with current code because this event was the only one sent directly without setting the state first, so migrate_generate_event() never runs.
And not with this patch because I'm not sending the event if migrate_events() is true because it will already be sent by migrate_generate_event().
Quoted 6 lines
The fix makes sense to me in general, butt I'm curious whether we can fix it without having a compat bit doing the wrong thing, even if having the risk of breaking someone, with the hope that the only thing he/she needs to do is to enable the cap-events if didn't. I'd consider that if e.g. as long as libvirt is fine. Does anyone know how libvirt handles this?
I agree that it would be cleaner for us to just break compatibility and hope for the best. Any process waiting for the event would hang, but simply enabling the capability would fix it.
I see libvirt knows about the 'events' capability but I couldn't determine if it is enabled by default. I'll have to take a deeper look.
PATCH 2/6 tests/qtest: migration: Expose migrate_set_capability
In reply to Fabiano RosasThe following patch will make use of this function from within migrate-helpers.c, so move it there.
--- tests/qtest/migration-helpers.c | 11 +++++++++++ tests/qtest/migration-helpers.h | 3 +++ tests/qtest/migration-test.c | 11 ----------- 3 files changed, 14 insertions(+), 11 deletions(-)
tests/qtest/migration-helpers.c +11 -0
@@ -70,6 +70,17 @@ void migrate_qmp(QTestState *who, const char *uri, const char *fmt, ...) "{ 'execute': 'migrate', 'arguments': %p}", args); } +void migrate_set_capability (QTestState *who,const char *capability, +bool value) +{ +qtest_qmp_assert_success (who, +"{ 'execute': 'migrate-set-capabilities'," +"'arguments': { " +"'capabilities': [ { " +"'capability': %s, 'state': %i } ] } }" , + capability, value); +} +/* * Note: caller is responsible to free the returned object via * qobject_unref() after use
tests/qtest/migration-helpers.h +3 -0
@@ -23,6 +23,9 @@ bool migrate_watch_for_resume(QTestState *who, const char *name, G_GNUC_PRINTF(3, 4)void migrate_qmp (QTestState *who,const char *uri,const char *fmt, ...); +void migrate_set_capability (QTestState *who,const char *capability, +bool value); +QDict *migrate_query (QTestState *who);QDict *migrate_query_not_failed (QTestState *who);
tests/qtest/migration-test.c +0 -11
@@ -472,17 +472,6 @@ static void migrate_cancel(QTestState *who)qtest_qmp_assert_success (who,"{ 'execute': 'migrate_cancel' }" ); } -static void migrate_set_capability (QTestState *who,const char *capability, -bool value) -{ -qtest_qmp_assert_success (who, -"{ 'execute': 'migrate-set-capabilities'," -"'arguments': { " -"'capabilities': [ { " -"'capability': %s, 'state': %i } ] } }" , - capability, value); -} -static void migrate_postcopy_start (QTestState *from,QTestState *to) {qtest_qmp_assert_success (from,"{ 'execute': 'migrate-start-postcopy' }" );
Signature · 1 line
2.35.3
Re: [PATCH 2/6] tests/qtest: migration: Expose migrate_set_capability
Quoted 10 lines · Fabiano Rosas
The following patch will make use of this function from within
migrate-helpers.c, so move it there.Signed-off-by Fabiano Rosas <[email protected]>Reviewed-by Juan Quintela <[email protected]>--- tests/qtest/migration-helpers.c | 11 +++++++++++ tests/qtest/migration-helpers.h | 3 +++ tests/qtest/migration-test.c | 11 ----------- 3 files changed, 14 insertions(+), 11 deletions(-)
PATCH 3/6 tests/qtest: migration: Add migrate_incoming_qmp helper
In reply to Fabiano Rosasfile-based migration requires the target to initiate its migration after the source has finished writing out the data in the file. Currently there's no easy way to initiate 'migrate-incoming', allow this by introducing migrate_incoming_qmp helper, similarly to migrate_qmp.
Also make sure migration events are enabled and wait for the incoming migration to start before returning. This avoid a race when querying the migration status too soon after issuing the command.
--- tests/qtest/migration-helpers.c | 28 ++++++++++++++++++++++++++++ tests/qtest/migration-helpers.h | 4 ++++ 2 files changed, 32 insertions(+)
tests/qtest/migration-helpers.c +28 -0
@@ -81,6 +81,34 @@ void migrate_set_capability(QTestState *who, const char *capability, capability, value); } +void migrate_incoming_qmp (QTestState *to,const char *uri,const char *fmt, ...) +{ +va_list ap; +QDict *args, *rsp, *data; + +va_start (ap, fmt); + args =qdict_from_vjsonf_nofail (fmt, ap); +va_end (ap); + +g_assert (!qdict_haskey (args,"uri" )); +qdict_put_str (args,"uri" , uri); + +migrate_set_capability (to,"events" , true); + + rsp =qtest_qmp (to,"{ 'execute': 'migrate-incoming', 'arguments': %p}" , + args); +g_assert (qdict_haskey (rsp,"return" )); + + rsp =qtest_qmp_eventwait_ref (to,"MIGRATION" ); +g_assert (qdict_haskey (rsp,"data" )); + + data =qdict_get_qdict (rsp,"data" ); +g_assert (qdict_haskey (data,"status" )); + g_assert_cmpstr(qdict_get_str(data, "status"), ==, "setup"); + +qobject_unref (rsp); +} +/* * Note: caller is responsible to free the returned object via * qobject_unref() after use
tests/qtest/migration-helpers.h +4 -0
@@ -23,6 +23,10 @@ bool migrate_watch_for_resume(QTestState *who, const char *name, G_GNUC_PRINTF(3, 4)void migrate_qmp (QTestState *who,const char *uri,const char *fmt, ...); +G_GNUC_PRINTF(3, 4) +void migrate_incoming_qmp (QTestState *who,const char *uri, +const char *fmt, ...); +void migrate_set_capability (QTestState *who,const char *capability,bool value);
Signature · 1 line
2.35.3
Re: [PATCH 3/6] tests/qtest: migration: Add migrate_incoming_qmp helper
Quoted 30 lines · Fabiano Rosas
file-based migration requires the target to initiate its migration after the source has finished writing out the data in the file. Currently there's no easy way to initiate 'migrate-incoming', allow this by introducing
migrate_incoming_qmphelper, similarly tomigrate_qmp.Also make sure migration events are enabled and wait for the incoming migration to start before returning. This avoid a race when querying the migration status too soon after issuing the command.
Signed-off-by Fabiano Rosas <[email protected]>--- tests/qtest/migration-helpers.c | 28 ++++++++++++++++++++++++++++ tests/qtest/migration-helpers.h | 4 ++++ 2 files changed, 32 insertions(+)tests/qtest/migration-helpers.c +7
-0@@ -81,6 +81,34 @@ void migrate_set_capability(QTestState *who, const char *capability, capability, value); } +void migrate_incoming_qmp (QTestState *to,const char *uri,const char *fmt, ...) +{ +va_list ap; +QDict *args, *rsp, *data; + +va_start (ap, fmt); + args =qdict_from_vjsonf_nofail (fmt, ap);
tests/qtest/migration-helpers.c void migrate_set_capability(QTestState *who, const char *capability, · line 100
Quoted 10 lines
tests/qtest/migration-helpers.c +10
-0+va_end (ap); + +g_assert (!qdict_haskey (args,"uri" )); +qdict_put_str (args,"uri" , uri); + +migrate_set_capability (to,"events" , true); + + rsp =qtest_qmp (to,"{ 'execute': 'migrate-incoming', 'arguments': %p}" , + args); +g_assert (qdict_haskey (rsp,"return" ));
rsp leaked?
Quoted 32 lines
tests/qtest/migration-helpers.c +11
-0+ + rsp =qtest_qmp_eventwait_ref (to,"MIGRATION" ); +g_assert (qdict_haskey (rsp,"data" )); + + data =qdict_get_qdict (rsp,"data" ); +g_assert (qdict_haskey (data,"status" )); + g_assert_cmpstr(qdict_get_str(data, "status"), ==, "setup"); + +qobject_unref (rsp); +} +/* * Note: caller is responsible to free the returned object via * qobject_unref() after use tests/qtest/migration-helpers.h +4
-0@@ -23,6 +23,10 @@ bool migrate_watch_for_resume(QTestState *who, const char *name, G_GNUC_PRINTF(3, 4)void migrate_qmp (QTestState *who,const char *uri,const char *fmt, ...); +G_GNUC_PRINTF(3, 4) +void migrate_incoming_qmp (QTestState *who,const char *uri, +const char *fmt, ...); +void migrate_set_capability (QTestState *who,const char *capability,bool value);Signature · 1 line
2.35.3
Signature · 1 line
Peter Xu
Re: [PATCH 3/6] tests/qtest: migration: Add migrate_incoming_qmp helper
Quoted 35 lines · Peter Xu
Quoted 34 lines · Fabiano Rosas
file-based migration requires the target to initiate its migration after the source has finished writing out the data in the file. Currently there's no easy way to initiate 'migrate-incoming', allow this by introducing
migrate_incoming_qmphelper, similarly tomigrate_qmp.Also make sure migration events are enabled and wait for the incoming migration to start before returning. This avoid a race when querying the migration status too soon after issuing the command.
Signed-off-by Fabiano Rosas <[email protected]>--- tests/qtest/migration-helpers.c | 28 ++++++++++++++++++++++++++++ tests/qtest/migration-helpers.h | 4 ++++ 2 files changed, 32 insertions(+)tests/qtest/migration-helpers.c +11
-0@@ -81,6 +81,34 @@ void migrate_set_capability(QTestState *who, const char *capability, capability, value); } +void migrate_incoming_qmp (QTestState *to,const char *uri,const char *fmt, ...) +{ +va_list ap; +QDict *args, *rsp, *data; + +va_start (ap, fmt); + args =qdict_from_vjsonf_nofail (fmt, ap); +va_end (ap); + +g_assert (!qdict_haskey (args,"uri" )); +qdict_put_str (args,"uri" , uri);
Quoted 9 lines
tests/qtest/migration-helpers.c void migrate_set_capability(QTestState *who, const char *capability, · line 100
Quoted 6 lines
tests/qtest/migration-helpers.c +6
-0+ +migrate_set_capability (to,"events" , true); + + rsp =qtest_qmp (to,"{ 'execute': 'migrate-incoming', 'arguments': %p}" , + args); +g_assert (qdict_haskey (rsp,"return" ));rsp leaked?
Good catch. I'll fix it.
PATCH 4/6 tests/qtest: migration: Use migrate_incoming_qmp where appropriate
In reply to Fabiano RosasUse the new migrate_incoming_qmp helper in the places that currently open-code calling migrate-incoming.
--- tests/qtest/meson.build | 1 + tests/qtest/migration-test.c | 12 ++--- tests/qtest/virtio-net-failover.c | 77 ++++--------------------------- 3 files changed, 14 insertions(+), 76 deletions(-)
tests/qtest/meson.build +1 -0
@@ -313,6 +313,7 @@ qtests = { 'tpm-tis-i2c-test': [io, tpmemu_files, 'qtest_aspeed.c'], 'tpm-tis-device-swtpm-test': [io, tpmemu_files, 'tpm-tis-util.c'], 'tpm-tis-device-test': [io, tpmemu_files, 'tpm-tis-util.c'], + 'virtio-net-failover': files('migration-helpers.c'), 'vmgenid-test': files('boot-sector.c', 'acpi-utils.c'), 'netdev-socket': files('netdev-socket.c', '../unit/socket-helpers.c'), }
tests/qtest/migration-test.c +4 -8
@@ -1819,8 +1819,7 @@ static void *test_migrate_fd_start_hook(QTestState *from,close (pair[0 ]);/* Start incoming migration from the 1st socket */ -qtest_qmp_assert_success (to,"{ 'execute': 'migrate-incoming'," -" 'arguments': { 'uri': 'fd:fd-mig' }}" ); +migrate_incoming_qmp (to,"fd:fd-mig" ,"{}" );/* Send the 2nd socket to the target */ qtest_qmp_fds_assert_success(from, &pair[1], 1,
@@ -2042,8 +2041,7 @@ test_migrate_precopy_tcp_multifd_start_common(QTestState *from,migrate_set_capability (to,"multifd" , true);/* Start incoming migration from the 1st socket */ -qtest_qmp_assert_success (to,"{ 'execute': 'migrate-incoming'," -" 'arguments': { 'uri': 'tcp:127.0.0.1:0' }}" ); +migrate_incoming_qmp (to,"tcp:127.0.0.1:0" ,"{}" );return NULL ; }
@@ -2295,8 +2293,7 @@ static void test_multifd_tcp_cancel(void)migrate_set_capability (to,"multifd" , true);/* Start incoming migration from the 1st socket */ -qtest_qmp_assert_success (to,"{ 'execute': 'migrate-incoming'," -" 'arguments': { 'uri': 'tcp:127.0.0.1:0' }}" ); +migrate_incoming_qmp (to,"tcp:127.0.0.1:0" ,"{}" );/* Wait for the first serial output from the source */ wait_for_serial ("src_serial" );
@@ -2326,8 +2323,7 @@ static void test_multifd_tcp_cancel(void)migrate_set_capability (to2,"multifd" , true);/* Start incoming migration from the 1st socket */ -qtest_qmp_assert_success (to2,"{ 'execute': 'migrate-incoming'," -" 'arguments': { 'uri': 'tcp:127.0.0.1:0' }}" ); +migrate_incoming_qmp (to2,"tcp:127.0.0.1:0" ,"{}" );g_free (uri); uri =migrate_get_socket_address (to2,"socket-address" );
tests/qtest/virtio-net-failover.c +9 -68
134 lines not on this page · raw message
Signature · 1 line
2.35.3
PATCH 5/6 tests/qtest: migration: Add support for negative testing of qmp_migrate
In reply to Fabiano RosasThere is currently no way to write a test for errors that happened in qmp_migrate before the migration has started.
Add a version of qmp_migrate that ensures an error happens and tests the error message. To make use of it a test needs to declare:
MigrateCommon args = {
.result = MIG_TEST_QMP_ERROR,
.error_str = "error message"
}
--- tests/qtest/libqtest.c | 33 +++++++++++++++++++++++++++++++++ tests/qtest/libqtest.h | 28 ++++++++++++++++++++++++++++ tests/qtest/migration-helpers.c | 22 ++++++++++++++++++++++ tests/qtest/migration-helpers.h | 4 ++++ tests/qtest/migration-test.c | 17 +++++++++++++---- 5 files changed, 100 insertions(+), 4 deletions(-)
tests/qtest/libqtest.c +33 -0
@@ -1243,6 +1243,28 @@ void qtest_memset(QTestState *s, uint64_t addr, uint8_t pattern, size_t size)qtest_rsp (s); } +QDict *qtest_vqmp_assert_failure_ref (QTestState *qts, +const char *fmt,va_list args) +{ +QDict *response; +QDict *ret; + + response =qtest_vqmp (qts, fmt, args); + +g_assert (response); +if (!qdict_haskey (response,"error" )) { +g_autoptr (GString) s =qobject_to_json_pretty (QOBJECT (response), true); +g_test_message ("%s" , s->str); + } +g_assert (qdict_haskey (response,"error" )); +g_assert (!qdict_haskey (response,"return" )); + ret =qdict_get_qdict (response,"error" ); +qobject_ref (ret); +qobject_unref (response); + +return ret; +} +QDict *qtest_vqmp_assert_success_ref (QTestState *qts,const char *fmt,va_list args) {
@@ -1305,6 +1327,17 @@ void qtest_vqmp_fds_assert_success(QTestState *qts, int *fds, size_t nfds, }#endif /* !_WIN32 */ +QDict *qtest_qmp_assert_failure_ref (QTestState *qts,const char *fmt, ...) +{ +QDict *response; +va_list ap; + +va_start (ap, fmt); + response =qtest_vqmp_assert_failure_ref (qts, fmt, ap); +va_end (ap); +return response; +} +QDict *qtest_qmp_assert_success_ref (QTestState *qts,const char *fmt, ...) {QDict *response;
tests/qtest/libqtest.h +28 -0
@@ -799,6 +799,34 @@ void qtest_vqmp_fds_assert_success(QTestState *qts, int *fds, size_t nfds,G_GNUC_PRINTF (4 ,0 );#endif /* !_WIN32 */ +/** +* qtest_qmp_assert_failure_ref: +* @qts: QTestState instance to operate on +* @fmt: QMP message to send to qemu, formatted like +* qobject_from_jsonf_nofail(). See parse_interpolation() for what's +* supported after '%'. +* +* Sends a QMP message to QEMU, asserts that an 'error' key is present in +* the response, and returns the response. +*/ +QDict *qtest_qmp_assert_failure_ref (QTestState *qts,const char *fmt, ...) +G_GNUC_PRINTF (2 ,3 ); + +/** +* qtest_vqmp_assert_failure_ref: +* @qts: QTestState instance to operate on +* @fmt: QMP message to send to qemu, formatted like +* qobject_from_jsonf_nofail(). See parse_interpolation() for what's +* supported after '%'. +* @args: variable arguments for @fmt +* +* Sends a QMP message to QEMU, asserts that an 'error' key is present in +* the response, and returns the response. +*/ +QDict *qtest_vqmp_assert_failure_ref (QTestState *qts, +const char *fmt,va_list args) +G_GNUC_PRINTF (2 ,0 ); +/** * qtest_qmp_assert_success_ref: * @qts: QTestState instance to operate on
tests/qtest/migration-helpers.c +22 -0
@@ -49,6 +49,28 @@ bool migrate_watch_for_resume(QTestState *who, const char *name,return false; } +void migrate_qmp_with_error (QTestState *who,const char *uri, +const char *error_str,const char *fmt, ...) +{ +va_list ap; +QDict *args, *err; + +va_start (ap, fmt); + args =qdict_from_vjsonf_nofail (fmt, ap); +va_end (ap); + +g_assert (!qdict_haskey (args,"uri" )); +qdict_put_str (args,"uri" , uri); + + err =qtest_qmp_assert_failure_ref ( + who,"{ 'execute': 'migrate', 'arguments': %p}" , args); + +g_assert (qdict_haskey (err,"desc" )); + g_assert_cmpstr(qdict_get_str(err, "desc"), ==, error_str); + +qobject_unref (err); +} +/* * Send QMP command "migrate". * Arguments are built from @fmt... (formatted like
tests/qtest/migration-helpers.h +4 -0
@@ -27,6 +27,10 @@ G_GNUC_PRINTF(3, 4)void migrate_incoming_qmp (QTestState *who,const char *uri,const char *fmt, ...); +G_GNUC_PRINTF(4, 5) +void migrate_qmp_with_error (QTestState *who,const char *uri, +const char *error_str,const char *fmt, ...); +void migrate_set_capability (QTestState *who,const char *capability,bool value);
tests/qtest/migration-test.c +13 -4
@@ -564,6 +564,8 @@ typedef struct {MIG_TEST_FAIL ,/* This test should fail, dest qemu should fail with abnormal status */ MIG_TEST_FAIL_DEST_QUIT_ERR , +/* The QMP command for this migration should fail with an error */ +MIG_TEST_QMP_ERROR , } result;/* Optional: set number of migration passes to wait for, if live==true */
@@ -582,6 +584,7 @@ typedef struct {/* Postcopy specific fields */ void *postcopy_data;bool postcopy_preempt; +gchar *error_str; } MigrateCommon; static int test_migrate_start(QTestState **from, QTestState **to,
@@ -1379,6 +1382,7 @@ static void test_precopy_common(MigrateCommon *args) {QTestState *from, *to;void *data_hook =NULL ; + g_autofree char *connect_uri = NULL;if (test_migrate_start (&from, &to, args->listen_uri, &args->start)) {return ;
@@ -1419,13 +1423,17 @@ static void test_precopy_common(MigrateCommon *args) }if (!args->connect_uri) { - g_autofree char *local_connect_uri = -migrate_get_socket_address (to,"socket-address" ); -migrate_qmp (from, local_connect_uri,"{}" ); + connect_uri =migrate_get_socket_address (to,"socket-address" ); }else { -migrate_qmp (from, args->connect_uri,"{}" ); + connect_uri =g_strdup (args->connect_uri); } +if (args->result ==MIG_TEST_QMP_ERROR ) { +migrate_qmp_with_error (from, connect_uri, args->error_str,"{}" ); + goto finish; + } + +migrate_qmp (from, connect_uri,"{}" );if (args->result !=MIG_TEST_SUCCEED ) {bool allow_active = args->result ==MIG_TEST_FAIL ;
@@ -1474,6 +1482,7 @@ static void test_precopy_common(MigrateCommon *args)wait_for_serial ("dest_serial" ); } +finish:if (args->finish_hook) { args->finish_hook (from, to, data_hook); }
Signature · 1 line
2.35.3
PATCH 6/6 tests/qtest: migration-test: Add tests for file-based migration
In reply to Fabiano RosasAdd basic tests for file-based migration.
--- tests/qtest/migration-test.c | 104 +++++++++++++++++++++++++++++++++++ 1 file changed, 104 insertions(+)
tests/qtest/migration-test.c +104 -0
@@ -52,6 +52,10 @@ static bool got_dst_resume;*/ #define DIRTYLIMIT_TOLERANCE_RANGE 25/* MB/s */ +#define QEMU_VM_FILE_MAGIC 0x5145564d +#define FILE_TEST_FILENAME "migfile" +#define FILE_TEST_OFFSET 0x1000 +#if defined(__linux__)#include <sys/syscall.h> #include <sys/vfs.h>
@@ -763,6 +767,7 @@ static void test_migrate_end(QTestState *from, QTestState *to, bool test_dest)cleanup ("migsocket" );cleanup ("src_serial" );cleanup ("dest_serial" ); +cleanup (FILE_TEST_FILENAME ); }#ifdef CONFIG_GNUTLS
@@ -1460,11 +1465,28 @@ static void test_precopy_common(MigrateCommon *args)*/ wait_for_migration_complete (from); +/* +* For file based migration the target must begin its +* migration after the source has finished. +*/ +if (strstr (connect_uri,"file:" )) { +migrate_incoming_qmp (to, connect_uri,"{}" ); + } +if (!got_src_stop) {qtest_qmp_eventwait (from,"STOP" ); } }else {wait_for_migration_complete (from); + +/* +* For file based migration the target must begin its +* migration after the source has finished. +*/ +if (strstr (connect_uri,"file:" )) { +migrate_incoming_qmp (to, connect_uri,"{}" ); + } +/* * Must wait for dst to finish reading all incoming * data on the socket before issuing 'cont' otherwise
@@ -1682,6 +1704,78 @@ static void test_precopy_unix_compress_nowait(void)test_precopy_common (&args); } +static void test_precopy_file (void ) +{ + g_autofree char *uri = g_strdup_printf("file:%s/%s", tmpfs, +FILE_TEST_FILENAME ); +MigrateCommon args = { + .connect_uri = uri, + .listen_uri ="defer" , + }; + +test_precopy_common (&args); +} + +#if defined(__linux__) +static void file_offset_finish_hook (QTestState *from,QTestState *to,void *opaque) +{ + g_autofree char *path = g_strdup_printf("%s/%s", tmpfs, FILE_TEST_FILENAME); +size_t size =FILE_TEST_OFFSET +sizeof (QEMU_VM_FILE_MAGIC ); +uintptr_t *addr, *p; +int fd; + + fd =open (path,O_RDONLY ); +g_assert (fd !=-1 ); + addr =mmap (NULL , size,PROT_READ ,MAP_PRIVATE , fd,0 ); +g_assert (addr !=MAP_FAILED ); + +/* +* Ensure the skipped offset contains zeros and the migration +* stream starts at the right place. +*/ + p = addr; +while (p < addr +FILE_TEST_OFFSET /sizeof (uintptr_t )) { +g_assert (*p ==0 ); + p++; + } + g_assert_cmpint(cpu_to_be32(*p), ==, QEMU_VM_FILE_MAGIC); + +munmap (addr, size); +close (fd); +} + +static void test_precopy_file_offset (void ) +{ + g_autofree char *uri = g_strdup_printf("file:%s/%s,offset=%d", tmpfs, +FILE_TEST_FILENAME , +FILE_TEST_OFFSET ); +MigrateCommon args = { + .connect_uri = uri, + .listen_uri ="defer" , + .finish_hook = file_offset_finish_hook, + }; + +test_precopy_common (&args); +} +#endif + +static void test_precopy_file_offset_bad (void ) +{ +/* using a value not supported by qemu_strtosz() */ + g_autofree char *uri = g_strdup_printf("file:%s/migfile,offset=0x20M", + tmpfs); +MigrateCommon args = { + .connect_uri = uri, + .listen_uri ="defer" , + .error_str =g_strdup ( +"file URI has bad offset 0x20M: Unknown error -22" ), + .result =MIG_TEST_QMP_ERROR , + }; + +test_precopy_common (&args); +g_free (args.error_str); +} +static void test_precopy_tcp_plain (void ) {MigrateCommon args = {
@@ -2704,6 +2798,16 @@ int main(int argc, char **argv)qtest_add_func ("/migration/precopy/unix/compress/nowait" , test_precopy_unix_compress_nowait); } + +qtest_add_func ("/migration/precopy/file" , + test_precopy_file); +#if defined(__linux__) +qtest_add_func ("/migration/precopy/file/offset" , + test_precopy_file_offset); +#endif +qtest_add_func ("/migration/precopy/file/offset/bad" , + test_precopy_file_offset_bad); +#ifdef CONFIG_GNUTLS qtest_add_func ("/migration/precopy/unix/tls/psk" , test_precopy_unix_tls_psk);
Signature · 1 line
2.35.3
Re: [PATCH 6/6] tests/qtest: migration-test: Add tests for file-based migration
Quoted 76 lines · Fabiano Rosas
Add basic tests for file-based migration.
Signed-off-by Fabiano Rosas <[email protected]>--- tests/qtest/migration-test.c | 104 +++++++++++++++++++++++++++++++++++ 1 file changed, 104 insertions(+)tests/qtest/migration-test.c +35
-0@@ -52,6 +52,10 @@ static bool got_dst_resume;*/ #define DIRTYLIMIT_TOLERANCE_RANGE 25/* MB/s */ +#define QEMU_VM_FILE_MAGIC 0x5145564d +#define FILE_TEST_FILENAME "migfile" +#define FILE_TEST_OFFSET 0x1000 +#if defined(__linux__)#include <sys/syscall.h> #include <sys/vfs.h> @@ -763,6 +767,7 @@ static void test_migrate_end(QTestState *from, QTestState *to, bool test_dest)cleanup ("migsocket" );cleanup ("src_serial" );cleanup ("dest_serial" ); +cleanup (FILE_TEST_FILENAME ); }#ifdef CONFIG_GNUTLS @@ -1460,11 +1465,28 @@ static void test_precopy_common(MigrateCommon *args)*/ wait_for_migration_complete (from); +/* +* For file based migration the target must begin its +* migration after the source has finished. +*/ +if (strstr (connect_uri,"file:" )) { +migrate_incoming_qmp (to, connect_uri,"{}" ); + } +if (!got_src_stop) {qtest_qmp_eventwait (from,"STOP" ); } }else {wait_for_migration_complete (from); + +/* +* For file based migration the target must begin its +* migration after the source has finished. +*/ +if (strstr (connect_uri,"file:" )) { +migrate_incoming_qmp (to, connect_uri,"{}" ); + } +/* * Must wait for dst to finish reading all incoming * data on the socket before issuing 'cont' otherwise @@ -1682,6 +1704,78 @@ static void test_precopy_unix_compress_nowait(void)test_precopy_common (&args); } +static void test_precopy_file (void ) +{ + g_autofree char *uri = g_strdup_printf("file:%s/%s", tmpfs, +FILE_TEST_FILENAME ); +MigrateCommon args = { + .connect_uri = uri, + .listen_uri ="defer" , + }; + +test_precopy_common (&args); +} + +#if defined(__linux__)
tests/qtest/migration-test.c static void test_precopy_unix_compress_nowait(void) · line 1729
Quoted 10 lines
tests/qtest/migration-test.c +10
-0+static void file_offset_finish_hook (QTestState *from,QTestState *to,void *opaque) +{ + g_autofree char *path = g_strdup_printf("%s/%s", tmpfs, FILE_TEST_FILENAME); +size_t size =FILE_TEST_OFFSET +sizeof (QEMU_VM_FILE_MAGIC ); +uintptr_t *addr, *p; +int fd; + + fd =open (path,O_RDONLY ); +g_assert (fd !=-1 ); + addr =mmap (NULL , size,PROT_READ ,MAP_PRIVATE , fd,0 );
Not something that matters a lot, but RO mapping a file with private is a bit weird. Maybe just use MAP_SHARED?
Quoted 12 lines
tests/qtest/migration-test.c +12
-0+g_assert (addr !=MAP_FAILED ); + +/* +* Ensure the skipped offset contains zeros and the migration +* stream starts at the right place. +*/ + p = addr; +while (p < addr +FILE_TEST_OFFSET /sizeof (uintptr_t )) { +g_assert (*p ==0 ); + p++; + } + g_assert_cmpint(cpu_to_be32(*p), ==, QEMU_VM_FILE_MAGIC);
tests/qtest/migration-test.c static void test_precopy_unix_compress_nowait(void) · line 1751
Quoted 10 lines
tests/qtest/migration-test.c +10
-0+ +munmap (addr, size); +close (fd); +} + +static void test_precopy_file_offset (void ) +{ + g_autofree char *uri = g_strdup_printf("file:%s/%s,offset=%d", tmpfs, +FILE_TEST_FILENAME , +FILE_TEST_OFFSET );
Is it intended to also only run this test with linux? IIUC it should also work for others. Maybe only file_offset_finish_hook() is optional? Or am i wrong?
Quoted 10 lines
tests/qtest/migration-test.c +10
-0+MigrateCommon args = { + .connect_uri = uri, + .listen_uri ="defer" , + .finish_hook = file_offset_finish_hook, + }; + + test_precopy_common(&args); +} +#endif +
tests/qtest/migration-test.c static void test_precopy_unix_compress_nowait(void) · line 1771
Quoted 10 lines
tests/qtest/migration-test.c +10
-0+static void test_precopy_file_offset_bad (void ) +{ +/* using a value not supported by qemu_strtosz() */ + g_autofree char *uri = g_strdup_printf("file:%s/migfile,offset=0x20M", + tmpfs); +MigrateCommon args = { + .connect_uri = uri, + .listen_uri ="defer" , + .error_str =g_strdup ( +"file URI has bad offset 0x20M: Unknown error -22" ),
"Unknown error" may imply that in Steve's patch the errno is inverted..
Shall we not rely on the string in the test? It might be too strict, I worry, because error strings should be defined for human readers, and we may not want some e.g. grammar / trivial change to break a test.
Quoted 30 lines
tests/qtest/migration-test.c +17
-0+ .result = MIG_TEST_QMP_ERROR, + }; + +test_precopy_common (&args); +g_free (args.error_str); +} +static void test_precopy_tcp_plain (void ) {MigrateCommon args = {@@ -2704,6 +2798,16 @@ int main(int argc, char **argv)qtest_add_func ("/migration/precopy/unix/compress/nowait" , test_precopy_unix_compress_nowait); } + +qtest_add_func ("/migration/precopy/file" , + test_precopy_file); +#if defined(__linux__) +qtest_add_func ("/migration/precopy/file/offset" , + test_precopy_file_offset); +#endif +qtest_add_func ("/migration/precopy/file/offset/bad" , + test_precopy_file_offset_bad); +#ifdef CONFIG_GNUTLS qtest_add_func ("/migration/precopy/unix/tls/psk" , test_precopy_unix_tls_psk);Signature · 1 line
2.35.3
Signature · 1 line
Peter Xu
Re: [PATCH 6/6] tests/qtest: migration-test: Add tests for file-based migration
Quoted 82 lines · Peter Xu
Quoted 81 lines · Fabiano Rosas
Add basic tests for file-based migration.
Signed-off-by Fabiano Rosas <[email protected]>--- tests/qtest/migration-test.c | 104 +++++++++++++++++++++++++++++++++++ 1 file changed, 104 insertions(+)tests/qtest/migration-test.c +40
-0@@ -52,6 +52,10 @@ static bool got_dst_resume;*/ #define DIRTYLIMIT_TOLERANCE_RANGE 25/* MB/s */ +#define QEMU_VM_FILE_MAGIC 0x5145564d +#define FILE_TEST_FILENAME "migfile" +#define FILE_TEST_OFFSET 0x1000 +#if defined(__linux__)#include <sys/syscall.h> #include <sys/vfs.h> @@ -763,6 +767,7 @@ static void test_migrate_end(QTestState *from, QTestState *to, bool test_dest)cleanup ("migsocket" );cleanup ("src_serial" );cleanup ("dest_serial" ); +cleanup (FILE_TEST_FILENAME ); }#ifdef CONFIG_GNUTLS @@ -1460,11 +1465,28 @@ static void test_precopy_common(MigrateCommon *args)*/ wait_for_migration_complete (from); +/* +* For file based migration the target must begin its +* migration after the source has finished. +*/ +if (strstr (connect_uri,"file:" )) { +migrate_incoming_qmp (to, connect_uri,"{}" ); + } +if (!got_src_stop) {qtest_qmp_eventwait (from,"STOP" ); } }else {wait_for_migration_complete (from); + +/* +* For file based migration the target must begin its +* migration after the source has finished. +*/ +if (strstr (connect_uri,"file:" )) { +migrate_incoming_qmp (to, connect_uri,"{}" ); + } +/* * Must wait for dst to finish reading all incoming * data on the socket before issuing 'cont' otherwise @@ -1682,6 +1704,78 @@ static void test_precopy_unix_compress_nowait(void)test_precopy_common (&args); } +static void test_precopy_file (void ) +{ + g_autofree char *uri = g_strdup_printf("file:%s/%s", tmpfs, +FILE_TEST_FILENAME ); +MigrateCommon args = { + .connect_uri = uri, + .listen_uri ="defer" , + }; + +test_precopy_common (&args); +} + +#if defined(__linux__) +static void file_offset_finish_hook (QTestState *from,QTestState *to,void *opaque) +{ + g_autofree char *path = g_strdup_printf("%s/%s", tmpfs, FILE_TEST_FILENAME); +size_t size =FILE_TEST_OFFSET +sizeof (QEMU_VM_FILE_MAGIC ); +uintptr_t *addr, *p;
Quoted 9 lines
tests/qtest/migration-test.c static void test_precopy_unix_compress_nowait(void) · line 1729
Quoted 5 lines
tests/qtest/migration-test.c +5
-0+int fd; + + fd =open (path,O_RDONLY ); +g_assert (fd !=-1 ); + addr =mmap (NULL , size,PROT_READ ,MAP_PRIVATE , fd,0 );Not something that matters a lot, but RO mapping a file with private is a bit weird. Maybe just use
MAP_SHARED?
Yep
Quoted 18 lines
Quoted 18 lines
tests/qtest/migration-test.c +18
-0+g_assert (addr !=MAP_FAILED ); + +/* +* Ensure the skipped offset contains zeros and the migration +* stream starts at the right place. +*/ + p = addr; +while (p < addr +FILE_TEST_OFFSET /sizeof (uintptr_t )) { +g_assert (*p ==0 ); + p++; + } + g_assert_cmpint(cpu_to_be32(*p), ==, QEMU_VM_FILE_MAGIC); + +munmap (addr, size); +close (fd); +} + +static void test_precopy_file_offset (void )
Quoted 9 lines
tests/qtest/migration-test.c static void test_precopy_unix_compress_nowait(void) · line 1751
Quoted 4 lines
tests/qtest/migration-test.c +4
-0+{ + g_autofree char *uri = g_strdup_printf("file:%s/%s,offset=%d", tmpfs, +FILE_TEST_FILENAME , +FILE_TEST_OFFSET );Is it intended to also only run this test with linux? IIUC it should also work for others. Maybe only
file_offset_finish_hook()is optional? Or am i wrong?
Yes, only the hook is linux-specific. I'll change it.
Quoted 23 lines
Quoted 10 lines
tests/qtest/migration-test.c +10
-0+MigrateCommon args = { + .connect_uri = uri, + .listen_uri ="defer" , + .finish_hook = file_offset_finish_hook, + }; + + test_precopy_common(&args); +} +#endif +tests/qtest/migration-test.c static void test_precopy_unix_compress_nowait(void) · line 1771
Quoted 10 lines
tests/qtest/migration-test.c +10
-0+static void test_precopy_file_offset_bad (void ) +{ +/* using a value not supported by qemu_strtosz() */ + g_autofree char *uri = g_strdup_printf("file:%s/migfile,offset=0x20M", + tmpfs); +MigrateCommon args = { + .connect_uri = uri, + .listen_uri ="defer" , + .error_str =g_strdup ( +"file URI has bad offset 0x20M: Unknown error -22" ),"Unknown error" may imply that in Steve's patch the errno is inverted..
Quoted 4 lines
Shall we not rely on the string in the test? It might be too strict, I worry, because error strings should be defined for human readers, and we may not want some e.g. grammar / trivial change to break a test.
Well, you just caught an issue with the errno by looking at the string, so maybe testing it is a good thing?
I'd expect anyone changing the string to run the test and catch the mismatch before sending a patch anyway.
I don't have a strong opinion about it, though. I can remove the error_str.
Re: [PATCH 6/6] tests/qtest: migration-test: Add tests for file-based migration
Quoted 154 lines · Fabiano Rosas
Quoted 82 lines · Peter Xu
Quoted 81 lines · Fabiano Rosas
Add basic tests for file-based migration.
Signed-off-by Fabiano Rosas <[email protected]>--- tests/qtest/migration-test.c | 104 +++++++++++++++++++++++++++++++++++ 1 file changed, 104 insertions(+)tests/qtest/migration-test.c +40
-0@@ -52,6 +52,10 @@ static bool got_dst_resume;*/ #define DIRTYLIMIT_TOLERANCE_RANGE 25/* MB/s */ +#define QEMU_VM_FILE_MAGIC 0x5145564d +#define FILE_TEST_FILENAME "migfile" +#define FILE_TEST_OFFSET 0x1000 +#if defined(__linux__)#include <sys/syscall.h> #include <sys/vfs.h> @@ -763,6 +767,7 @@ static void test_migrate_end(QTestState *from, QTestState *to, bool test_dest)cleanup ("migsocket" );cleanup ("src_serial" );cleanup ("dest_serial" ); +cleanup (FILE_TEST_FILENAME ); }#ifdef CONFIG_GNUTLS @@ -1460,11 +1465,28 @@ static void test_precopy_common(MigrateCommon *args)*/ wait_for_migration_complete (from); +/* +* For file based migration the target must begin its +* migration after the source has finished. +*/ +if (strstr (connect_uri,"file:" )) { +migrate_incoming_qmp (to, connect_uri,"{}" ); + } +if (!got_src_stop) {qtest_qmp_eventwait (from,"STOP" ); } }else {wait_for_migration_complete (from); + +/* +* For file based migration the target must begin its +* migration after the source has finished. +*/ +if (strstr (connect_uri,"file:" )) { +migrate_incoming_qmp (to, connect_uri,"{}" ); + } +/* * Must wait for dst to finish reading all incoming * data on the socket before issuing 'cont' otherwise @@ -1682,6 +1704,78 @@ static void test_precopy_unix_compress_nowait(void)test_precopy_common (&args); } +static void test_precopy_file (void ) +{ + g_autofree char *uri = g_strdup_printf("file:%s/%s", tmpfs, +FILE_TEST_FILENAME ); +MigrateCommon args = { + .connect_uri = uri, + .listen_uri ="defer" , + }; + +test_precopy_common (&args); +} + +#if defined(__linux__) +static void file_offset_finish_hook (QTestState *from,QTestState *to,void *opaque) +{ + g_autofree char *path = g_strdup_printf("%s/%s", tmpfs, FILE_TEST_FILENAME); +size_t size =FILE_TEST_OFFSET +sizeof (QEMU_VM_FILE_MAGIC ); +uintptr_t *addr, *p;Quoted 9 lines
tests/qtest/migration-test.c static void test_precopy_unix_compress_nowait(void) · line 1729
Quoted 5 lines
tests/qtest/migration-test.c +5
-0+int fd; + + fd =open (path,O_RDONLY ); +g_assert (fd !=-1 ); + addr =mmap (NULL , size,PROT_READ ,MAP_PRIVATE , fd,0 );Not something that matters a lot, but RO mapping a file with private is a bit weird. Maybe just use
MAP_SHARED?Yep
Quoted 18 lines
Quoted 18 lines
tests/qtest/migration-test.c +18
-0+g_assert (addr !=MAP_FAILED ); + +/* +* Ensure the skipped offset contains zeros and the migration +* stream starts at the right place. +*/ + p = addr; +while (p < addr +FILE_TEST_OFFSET /sizeof (uintptr_t )) { +g_assert (*p ==0 ); + p++; + } + g_assert_cmpint(cpu_to_be32(*p), ==, QEMU_VM_FILE_MAGIC); + +munmap (addr, size); +close (fd); +} + +static void test_precopy_file_offset (void )Quoted 9 lines
tests/qtest/migration-test.c static void test_precopy_unix_compress_nowait(void) · line 1751
Quoted 4 lines
tests/qtest/migration-test.c +4
-0+{ + g_autofree char *uri = g_strdup_printf("file:%s/%s,offset=%d", tmpfs, +FILE_TEST_FILENAME , +FILE_TEST_OFFSET );Is it intended to also only run this test with linux? IIUC it should also work for others. Maybe only
file_offset_finish_hook()is optional? Or am i wrong?Yes, only the hook is linux-specific. I'll change it.
Quoted 23 lines
Quoted 10 lines
tests/qtest/migration-test.c +10
-0+MigrateCommon args = { + .connect_uri = uri, + .listen_uri ="defer" , + .finish_hook = file_offset_finish_hook, + }; + + test_precopy_common(&args); +} +#endif +tests/qtest/migration-test.c static void test_precopy_unix_compress_nowait(void) · line 1771
Quoted 10 lines
tests/qtest/migration-test.c +10
-0+static void test_precopy_file_offset_bad (void ) +{ +/* using a value not supported by qemu_strtosz() */ + g_autofree char *uri = g_strdup_printf("file:%s/migfile,offset=0x20M", + tmpfs); +MigrateCommon args = { + .connect_uri = uri, + .listen_uri ="defer" , + .error_str =g_strdup ( +"file URI has bad offset 0x20M: Unknown error -22" ),"Unknown error" may imply that in Steve's patch the errno is inverted..
Quoted 4 lines
Shall we not rely on the string in the test? It might be too strict, I worry, because error strings should be defined for human readers, and we may not want some e.g. grammar / trivial change to break a test.
Quoted 8 lines
Well, you just caught an issue with the errno by looking at the string, so maybe testing it is a good thing?
I'd expect anyone changing the string to run the test and catch the mismatch before sending a patch anyway.
I don't have a strong opinion about it, though. I can remove the
error_str.
FWIW, I fixed the errno, so it should say
file URI has bad offset 0x20M: EINVAL
- Steve
Re: [PATCH 6/6] tests/qtest: migration-test: Add tests for file-based migration
In reply to Fabiano RosasQuoted 18 lines · Fabiano Rosas
Quoted 13 lines
tests/qtest/migration-test.c static void test_precopy_unix_compress_nowait(void) · line 1771
Quoted 10 lines
tests/qtest/migration-test.c +10
-0+static void test_precopy_file_offset_bad (void ) +{ +/* using a value not supported by qemu_strtosz() */ + g_autofree char *uri = g_strdup_printf("file:%s/migfile,offset=0x20M", + tmpfs); +MigrateCommon args = { + .connect_uri = uri, + .listen_uri ="defer" , + .error_str =g_strdup ( +"file URI has bad offset 0x20M: Unknown error -22" ),"Unknown error" may imply that in Steve's patch the errno is inverted..
Quoted 4 lines
Shall we not rely on the string in the test? It might be too strict, I worry, because error strings should be defined for human readers, and we may not want some e.g. grammar / trivial change to break a test.
Quoted 8 lines
Well, you just caught an issue with the errno by looking at the string, so maybe testing it is a good thing?
I'd expect anyone changing the string to run the test and catch the mismatch before sending a patch anyway.
I don't have a strong opinion about it, though. I can remove the
error_str.
I can give a few other examples outside "grammar error" (which in this case we can guarantee there's no grammar issue..): we can always try to append something to an error, when error_setg_errno() got refactored, or even someone just thinks better to make the 1st letter capitalized ("f" -> "F").
It's just too fragile to me..
Thanks,
Signature · 1 line
Peter Xu