mirror of
https://gitlab.com/qemu-project/qemu
synced 2024-09-06 18:05:37 +00:00
![Alexander Graf](/assets/img/avatar_default.png)
One of the annoyances of the current migration format is the fact that it's not self-describing. In fact, it's not properly describing at all. Some code randomly scattered throughout QEMU elaborates roughly how to read and write a stream of bytes. We discussed an idea during KVM Forum 2013 to add a JSON description of the migration protocol itself to the migration stream. This patch adds a section after the VM_END migration end marker that contains description data on what the device sections of the stream are composed of. This approach is backwards compatible with any QEMU version reading the stream, because QEMU just stops reading after the VM_END marker and ignores any data following it. With an additional external program this allows us to decipher the contents of any migration stream and hopefully make migration bugs easier to track down. Signed-off-by: Alexander Graf <agraf@suse.de> Signed-off-by: Amit Shah <amit.shah@redhat.com> Signed-off-by: Juan Quintela <quintela@redhat.com>
504 lines
15 KiB
C
504 lines
15 KiB
C
/*
|
|
* Test code for VMState
|
|
*
|
|
* Copyright (c) 2013 Red Hat Inc.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
#include <glib.h>
|
|
|
|
#include "qemu-common.h"
|
|
#include "migration/migration.h"
|
|
#include "migration/vmstate.h"
|
|
#include "block/coroutine.h"
|
|
|
|
static char temp_file[] = "/tmp/vmst.test.XXXXXX";
|
|
static int temp_fd;
|
|
|
|
/* Fake yield_until_fd_readable() implementation so we don't have to pull the
|
|
* coroutine code as dependency.
|
|
*/
|
|
void yield_until_fd_readable(int fd)
|
|
{
|
|
fd_set fds;
|
|
FD_ZERO(&fds);
|
|
FD_SET(fd, &fds);
|
|
select(fd + 1, &fds, NULL, NULL, NULL);
|
|
}
|
|
|
|
/*
|
|
* Some tests use 'open_test_file' to work on a real fd, some use
|
|
* an in memory file (QEMUSizedBuffer+qemu_bufopen); we could pick one
|
|
* but this way we test both.
|
|
*/
|
|
|
|
/* Duplicate temp_fd and seek to the beginning of the file */
|
|
static QEMUFile *open_test_file(bool write)
|
|
{
|
|
int fd = dup(temp_fd);
|
|
lseek(fd, 0, SEEK_SET);
|
|
if (write) {
|
|
g_assert_cmpint(ftruncate(fd, 0), ==, 0);
|
|
}
|
|
return qemu_fdopen(fd, write ? "wb" : "rb");
|
|
}
|
|
|
|
/*
|
|
* Check that the contents of the memory-buffered file f match
|
|
* the given size/data.
|
|
*/
|
|
static void check_mem_file(QEMUFile *f, void *data, size_t size)
|
|
{
|
|
uint8_t *result = g_malloc(size);
|
|
const QEMUSizedBuffer *qsb = qemu_buf_get(f);
|
|
g_assert_cmpint(qsb_get_length(qsb), ==, size);
|
|
g_assert_cmpint(qsb_get_buffer(qsb, 0, size, result), ==, size);
|
|
g_assert_cmpint(memcmp(result, data, size), ==, 0);
|
|
g_free(result);
|
|
}
|
|
|
|
#define SUCCESS(val) \
|
|
g_assert_cmpint((val), ==, 0)
|
|
|
|
#define FAILURE(val) \
|
|
g_assert_cmpint((val), !=, 0)
|
|
|
|
static void save_vmstate(const VMStateDescription *desc, void *obj)
|
|
{
|
|
QEMUFile *f = open_test_file(true);
|
|
|
|
/* Save file with vmstate */
|
|
vmstate_save_state(f, desc, obj, NULL);
|
|
qemu_put_byte(f, QEMU_VM_EOF);
|
|
g_assert(!qemu_file_get_error(f));
|
|
qemu_fclose(f);
|
|
}
|
|
|
|
static void compare_vmstate(uint8_t *wire, size_t size)
|
|
{
|
|
QEMUFile *f = open_test_file(false);
|
|
uint8_t result[size];
|
|
|
|
/* read back as binary */
|
|
|
|
g_assert_cmpint(qemu_get_buffer(f, result, sizeof(result)), ==,
|
|
sizeof(result));
|
|
g_assert(!qemu_file_get_error(f));
|
|
|
|
/* Compare that what is on the file is the same that what we
|
|
expected to be there */
|
|
SUCCESS(memcmp(result, wire, sizeof(result)));
|
|
|
|
/* Must reach EOF */
|
|
qemu_get_byte(f);
|
|
g_assert_cmpint(qemu_file_get_error(f), ==, -EIO);
|
|
|
|
qemu_fclose(f);
|
|
}
|
|
|
|
static int load_vmstate_one(const VMStateDescription *desc, void *obj,
|
|
int version, uint8_t *wire, size_t size)
|
|
{
|
|
QEMUFile *f;
|
|
int ret;
|
|
|
|
f = open_test_file(true);
|
|
qemu_put_buffer(f, wire, size);
|
|
qemu_fclose(f);
|
|
|
|
f = open_test_file(false);
|
|
ret = vmstate_load_state(f, desc, obj, version);
|
|
if (ret) {
|
|
g_assert(qemu_file_get_error(f));
|
|
} else{
|
|
g_assert(!qemu_file_get_error(f));
|
|
}
|
|
qemu_fclose(f);
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int load_vmstate(const VMStateDescription *desc,
|
|
void *obj, void *obj_clone,
|
|
void (*obj_copy)(void *, void*),
|
|
int version, uint8_t *wire, size_t size)
|
|
{
|
|
/* We test with zero size */
|
|
obj_copy(obj_clone, obj);
|
|
FAILURE(load_vmstate_one(desc, obj, version, wire, 0));
|
|
|
|
/* Stream ends with QEMU_EOF, so we need at least 3 bytes to be
|
|
* able to test in the middle */
|
|
|
|
if (size > 3) {
|
|
|
|
/* We test with size - 2. We can't test size - 1 due to EOF tricks */
|
|
obj_copy(obj, obj_clone);
|
|
FAILURE(load_vmstate_one(desc, obj, version, wire, size - 2));
|
|
|
|
/* Test with size/2, first half of real state */
|
|
obj_copy(obj, obj_clone);
|
|
FAILURE(load_vmstate_one(desc, obj, version, wire, size/2));
|
|
|
|
/* Test with size/2, second half of real state */
|
|
obj_copy(obj, obj_clone);
|
|
FAILURE(load_vmstate_one(desc, obj, version, wire + (size/2), size/2));
|
|
|
|
}
|
|
obj_copy(obj, obj_clone);
|
|
return load_vmstate_one(desc, obj, version, wire, size);
|
|
}
|
|
|
|
/* Test struct that we are going to use for our tests */
|
|
|
|
typedef struct TestSimple {
|
|
bool b_1, b_2;
|
|
uint8_t u8_1;
|
|
uint16_t u16_1;
|
|
uint32_t u32_1;
|
|
uint64_t u64_1;
|
|
int8_t i8_1, i8_2;
|
|
int16_t i16_1, i16_2;
|
|
int32_t i32_1, i32_2;
|
|
int64_t i64_1, i64_2;
|
|
} TestSimple;
|
|
|
|
/* Object instantiation, we are going to use it in more than one test */
|
|
|
|
TestSimple obj_simple = {
|
|
.b_1 = true,
|
|
.b_2 = false,
|
|
.u8_1 = 130,
|
|
.u16_1 = 512,
|
|
.u32_1 = 70000,
|
|
.u64_1 = 12121212,
|
|
.i8_1 = 65,
|
|
.i8_2 = -65,
|
|
.i16_1 = 512,
|
|
.i16_2 = -512,
|
|
.i32_1 = 70000,
|
|
.i32_2 = -70000,
|
|
.i64_1 = 12121212,
|
|
.i64_2 = -12121212,
|
|
};
|
|
|
|
/* Description of the values. If you add a primitive type
|
|
you are expected to add a test here */
|
|
|
|
static const VMStateDescription vmstate_simple_primitive = {
|
|
.name = "simple/primitive",
|
|
.version_id = 1,
|
|
.minimum_version_id = 1,
|
|
.fields = (VMStateField[]) {
|
|
VMSTATE_BOOL(b_1, TestSimple),
|
|
VMSTATE_BOOL(b_2, TestSimple),
|
|
VMSTATE_UINT8(u8_1, TestSimple),
|
|
VMSTATE_UINT16(u16_1, TestSimple),
|
|
VMSTATE_UINT32(u32_1, TestSimple),
|
|
VMSTATE_UINT64(u64_1, TestSimple),
|
|
VMSTATE_INT8(i8_1, TestSimple),
|
|
VMSTATE_INT8(i8_2, TestSimple),
|
|
VMSTATE_INT16(i16_1, TestSimple),
|
|
VMSTATE_INT16(i16_2, TestSimple),
|
|
VMSTATE_INT32(i32_1, TestSimple),
|
|
VMSTATE_INT32(i32_2, TestSimple),
|
|
VMSTATE_INT64(i64_1, TestSimple),
|
|
VMSTATE_INT64(i64_2, TestSimple),
|
|
VMSTATE_END_OF_LIST()
|
|
}
|
|
};
|
|
|
|
/* It describes what goes through the wire. Our tests are basically:
|
|
|
|
* save test
|
|
- save a struct a vmstate to a file
|
|
- read that file back (binary read, no vmstate)
|
|
- compare it with what we expect to be on the wire
|
|
* load test
|
|
- save to the file what we expect to be on the wire
|
|
- read struct back with vmstate in a different
|
|
- compare back with the original struct
|
|
*/
|
|
|
|
uint8_t wire_simple_primitive[] = {
|
|
/* b_1 */ 0x01,
|
|
/* b_2 */ 0x00,
|
|
/* u8_1 */ 0x82,
|
|
/* u16_1 */ 0x02, 0x00,
|
|
/* u32_1 */ 0x00, 0x01, 0x11, 0x70,
|
|
/* u64_1 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0xf4, 0x7c,
|
|
/* i8_1 */ 0x41,
|
|
/* i8_2 */ 0xbf,
|
|
/* i16_1 */ 0x02, 0x00,
|
|
/* i16_2 */ 0xfe, 0x0,
|
|
/* i32_1 */ 0x00, 0x01, 0x11, 0x70,
|
|
/* i32_2 */ 0xff, 0xfe, 0xee, 0x90,
|
|
/* i64_1 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0xf4, 0x7c,
|
|
/* i64_2 */ 0xff, 0xff, 0xff, 0xff, 0xff, 0x47, 0x0b, 0x84,
|
|
QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */
|
|
};
|
|
|
|
static void obj_simple_copy(void *target, void *source)
|
|
{
|
|
memcpy(target, source, sizeof(TestSimple));
|
|
}
|
|
|
|
static void test_simple_primitive(void)
|
|
{
|
|
TestSimple obj, obj_clone;
|
|
|
|
memset(&obj, 0, sizeof(obj));
|
|
save_vmstate(&vmstate_simple_primitive, &obj_simple);
|
|
|
|
compare_vmstate(wire_simple_primitive, sizeof(wire_simple_primitive));
|
|
|
|
SUCCESS(load_vmstate(&vmstate_simple_primitive, &obj, &obj_clone,
|
|
obj_simple_copy, 1, wire_simple_primitive,
|
|
sizeof(wire_simple_primitive)));
|
|
|
|
#define FIELD_EQUAL(name) g_assert_cmpint(obj.name, ==, obj_simple.name)
|
|
|
|
FIELD_EQUAL(b_1);
|
|
FIELD_EQUAL(b_2);
|
|
FIELD_EQUAL(u8_1);
|
|
FIELD_EQUAL(u16_1);
|
|
FIELD_EQUAL(u32_1);
|
|
FIELD_EQUAL(u64_1);
|
|
FIELD_EQUAL(i8_1);
|
|
FIELD_EQUAL(i8_2);
|
|
FIELD_EQUAL(i16_1);
|
|
FIELD_EQUAL(i16_2);
|
|
FIELD_EQUAL(i32_1);
|
|
FIELD_EQUAL(i32_2);
|
|
FIELD_EQUAL(i64_1);
|
|
FIELD_EQUAL(i64_2);
|
|
}
|
|
#undef FIELD_EQUAL
|
|
|
|
typedef struct TestStruct {
|
|
uint32_t a, b, c, e;
|
|
uint64_t d, f;
|
|
bool skip_c_e;
|
|
} TestStruct;
|
|
|
|
static const VMStateDescription vmstate_versioned = {
|
|
.name = "test/versioned",
|
|
.version_id = 2,
|
|
.minimum_version_id = 1,
|
|
.fields = (VMStateField[]) {
|
|
VMSTATE_UINT32(a, TestStruct),
|
|
VMSTATE_UINT32_V(b, TestStruct, 2), /* Versioned field in the middle, so
|
|
* we catch bugs more easily.
|
|
*/
|
|
VMSTATE_UINT32(c, TestStruct),
|
|
VMSTATE_UINT64(d, TestStruct),
|
|
VMSTATE_UINT32_V(e, TestStruct, 2),
|
|
VMSTATE_UINT64_V(f, TestStruct, 2),
|
|
VMSTATE_END_OF_LIST()
|
|
}
|
|
};
|
|
|
|
static void test_load_v1(void)
|
|
{
|
|
QEMUFile *fsave = open_test_file(true);
|
|
uint8_t buf[] = {
|
|
0, 0, 0, 10, /* a */
|
|
0, 0, 0, 30, /* c */
|
|
0, 0, 0, 0, 0, 0, 0, 40, /* d */
|
|
QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */
|
|
};
|
|
qemu_put_buffer(fsave, buf, sizeof(buf));
|
|
qemu_fclose(fsave);
|
|
|
|
QEMUFile *loading = open_test_file(false);
|
|
TestStruct obj = { .b = 200, .e = 500, .f = 600 };
|
|
vmstate_load_state(loading, &vmstate_versioned, &obj, 1);
|
|
g_assert(!qemu_file_get_error(loading));
|
|
g_assert_cmpint(obj.a, ==, 10);
|
|
g_assert_cmpint(obj.b, ==, 200);
|
|
g_assert_cmpint(obj.c, ==, 30);
|
|
g_assert_cmpint(obj.d, ==, 40);
|
|
g_assert_cmpint(obj.e, ==, 500);
|
|
g_assert_cmpint(obj.f, ==, 600);
|
|
qemu_fclose(loading);
|
|
}
|
|
|
|
static void test_load_v2(void)
|
|
{
|
|
QEMUFile *fsave = open_test_file(true);
|
|
uint8_t buf[] = {
|
|
0, 0, 0, 10, /* a */
|
|
0, 0, 0, 20, /* b */
|
|
0, 0, 0, 30, /* c */
|
|
0, 0, 0, 0, 0, 0, 0, 40, /* d */
|
|
0, 0, 0, 50, /* e */
|
|
0, 0, 0, 0, 0, 0, 0, 60, /* f */
|
|
QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */
|
|
};
|
|
qemu_put_buffer(fsave, buf, sizeof(buf));
|
|
qemu_fclose(fsave);
|
|
|
|
QEMUFile *loading = open_test_file(false);
|
|
TestStruct obj;
|
|
vmstate_load_state(loading, &vmstate_versioned, &obj, 2);
|
|
g_assert_cmpint(obj.a, ==, 10);
|
|
g_assert_cmpint(obj.b, ==, 20);
|
|
g_assert_cmpint(obj.c, ==, 30);
|
|
g_assert_cmpint(obj.d, ==, 40);
|
|
g_assert_cmpint(obj.e, ==, 50);
|
|
g_assert_cmpint(obj.f, ==, 60);
|
|
qemu_fclose(loading);
|
|
}
|
|
|
|
static bool test_skip(void *opaque, int version_id)
|
|
{
|
|
TestStruct *t = (TestStruct *)opaque;
|
|
return !t->skip_c_e;
|
|
}
|
|
|
|
static const VMStateDescription vmstate_skipping = {
|
|
.name = "test/skip",
|
|
.version_id = 2,
|
|
.minimum_version_id = 1,
|
|
.fields = (VMStateField[]) {
|
|
VMSTATE_UINT32(a, TestStruct),
|
|
VMSTATE_UINT32(b, TestStruct),
|
|
VMSTATE_UINT32_TEST(c, TestStruct, test_skip),
|
|
VMSTATE_UINT64(d, TestStruct),
|
|
VMSTATE_UINT32_TEST(e, TestStruct, test_skip),
|
|
VMSTATE_UINT64_V(f, TestStruct, 2),
|
|
VMSTATE_END_OF_LIST()
|
|
}
|
|
};
|
|
|
|
|
|
static void test_save_noskip(void)
|
|
{
|
|
QEMUFile *fsave = qemu_bufopen("w", NULL);
|
|
TestStruct obj = { .a = 1, .b = 2, .c = 3, .d = 4, .e = 5, .f = 6,
|
|
.skip_c_e = false };
|
|
vmstate_save_state(fsave, &vmstate_skipping, &obj, NULL);
|
|
g_assert(!qemu_file_get_error(fsave));
|
|
|
|
uint8_t expected[] = {
|
|
0, 0, 0, 1, /* a */
|
|
0, 0, 0, 2, /* b */
|
|
0, 0, 0, 3, /* c */
|
|
0, 0, 0, 0, 0, 0, 0, 4, /* d */
|
|
0, 0, 0, 5, /* e */
|
|
0, 0, 0, 0, 0, 0, 0, 6, /* f */
|
|
};
|
|
check_mem_file(fsave, expected, sizeof(expected));
|
|
qemu_fclose(fsave);
|
|
}
|
|
|
|
static void test_save_skip(void)
|
|
{
|
|
QEMUFile *fsave = qemu_bufopen("w", NULL);
|
|
TestStruct obj = { .a = 1, .b = 2, .c = 3, .d = 4, .e = 5, .f = 6,
|
|
.skip_c_e = true };
|
|
vmstate_save_state(fsave, &vmstate_skipping, &obj, NULL);
|
|
g_assert(!qemu_file_get_error(fsave));
|
|
|
|
uint8_t expected[] = {
|
|
0, 0, 0, 1, /* a */
|
|
0, 0, 0, 2, /* b */
|
|
0, 0, 0, 0, 0, 0, 0, 4, /* d */
|
|
0, 0, 0, 0, 0, 0, 0, 6, /* f */
|
|
};
|
|
check_mem_file(fsave, expected, sizeof(expected));
|
|
|
|
qemu_fclose(fsave);
|
|
}
|
|
|
|
static void test_load_noskip(void)
|
|
{
|
|
uint8_t buf[] = {
|
|
0, 0, 0, 10, /* a */
|
|
0, 0, 0, 20, /* b */
|
|
0, 0, 0, 30, /* c */
|
|
0, 0, 0, 0, 0, 0, 0, 40, /* d */
|
|
0, 0, 0, 50, /* e */
|
|
0, 0, 0, 0, 0, 0, 0, 60, /* f */
|
|
QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */
|
|
};
|
|
|
|
QEMUSizedBuffer *qsb = qsb_create(buf, sizeof(buf));
|
|
g_assert(qsb);
|
|
QEMUFile *loading = qemu_bufopen("r", qsb);
|
|
TestStruct obj = { .skip_c_e = false };
|
|
vmstate_load_state(loading, &vmstate_skipping, &obj, 2);
|
|
g_assert(!qemu_file_get_error(loading));
|
|
g_assert_cmpint(obj.a, ==, 10);
|
|
g_assert_cmpint(obj.b, ==, 20);
|
|
g_assert_cmpint(obj.c, ==, 30);
|
|
g_assert_cmpint(obj.d, ==, 40);
|
|
g_assert_cmpint(obj.e, ==, 50);
|
|
g_assert_cmpint(obj.f, ==, 60);
|
|
qemu_fclose(loading);
|
|
qsb_free(qsb);
|
|
}
|
|
|
|
static void test_load_skip(void)
|
|
{
|
|
uint8_t buf[] = {
|
|
0, 0, 0, 10, /* a */
|
|
0, 0, 0, 20, /* b */
|
|
0, 0, 0, 0, 0, 0, 0, 40, /* d */
|
|
0, 0, 0, 0, 0, 0, 0, 60, /* f */
|
|
QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */
|
|
};
|
|
|
|
QEMUSizedBuffer *qsb = qsb_create(buf, sizeof(buf));
|
|
g_assert(qsb);
|
|
QEMUFile *loading = qemu_bufopen("r", qsb);
|
|
TestStruct obj = { .skip_c_e = true, .c = 300, .e = 500 };
|
|
vmstate_load_state(loading, &vmstate_skipping, &obj, 2);
|
|
g_assert(!qemu_file_get_error(loading));
|
|
g_assert_cmpint(obj.a, ==, 10);
|
|
g_assert_cmpint(obj.b, ==, 20);
|
|
g_assert_cmpint(obj.c, ==, 300);
|
|
g_assert_cmpint(obj.d, ==, 40);
|
|
g_assert_cmpint(obj.e, ==, 500);
|
|
g_assert_cmpint(obj.f, ==, 60);
|
|
qemu_fclose(loading);
|
|
qsb_free(qsb);
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
temp_fd = mkstemp(temp_file);
|
|
|
|
g_test_init(&argc, &argv, NULL);
|
|
g_test_add_func("/vmstate/simple/primitive", test_simple_primitive);
|
|
g_test_add_func("/vmstate/versioned/load/v1", test_load_v1);
|
|
g_test_add_func("/vmstate/versioned/load/v2", test_load_v2);
|
|
g_test_add_func("/vmstate/field_exists/load/noskip", test_load_noskip);
|
|
g_test_add_func("/vmstate/field_exists/load/skip", test_load_skip);
|
|
g_test_add_func("/vmstate/field_exists/save/noskip", test_save_noskip);
|
|
g_test_add_func("/vmstate/field_exists/save/skip", test_save_skip);
|
|
g_test_run();
|
|
|
|
close(temp_fd);
|
|
unlink(temp_file);
|
|
|
|
return 0;
|
|
}
|