/* * 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"); } /* Open a read-only qemu-file from an existing memory block */ static QEMUFile *open_mem_file_read(const void *data, size_t len) { /* The qsb gets freed by qemu_fclose */ QEMUSizedBuffer *qsb = qsb_create(data, len); g_assert(qsb); return qemu_bufopen("r", qsb); } /* * 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); 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); 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); 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 */ }; QEMUFile *loading = open_mem_file_read(buf, sizeof(buf)); 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); } 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 */ }; QEMUFile *loading = open_mem_file_read(buf, sizeof(buf)); 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); } 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; }