Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 1 | /* |
| 2 | * Test code for VMState |
| 3 | * |
| 4 | * Copyright (c) 2013 Red Hat Inc. |
| 5 | * |
| 6 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
| 7 | * of this software and associated documentation files (the "Software"), to deal |
| 8 | * in the Software without restriction, including without limitation the rights |
| 9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| 10 | * copies of the Software, and to permit persons to whom the Software is |
| 11 | * furnished to do so, subject to the following conditions: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice shall be included in |
| 14 | * all copies or substantial portions of the Software. |
| 15 | * |
| 16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| 22 | * THE SOFTWARE. |
| 23 | */ |
| 24 | |
Peter Maydell | 681c28a | 2016-02-08 18:08:51 +0000 | [diff] [blame] | 25 | #include "qemu/osdep.h" |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 26 | |
| 27 | #include "qemu-common.h" |
| 28 | #include "migration/migration.h" |
| 29 | #include "migration/vmstate.h" |
Daniel P. Berrange | 10817bf | 2015-09-01 14:48:02 +0100 | [diff] [blame] | 30 | #include "qemu/coroutine.h" |
Daniel P. Berrange | 8925839 | 2016-04-27 11:05:08 +0100 | [diff] [blame] | 31 | #include "io/channel-file.h" |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 32 | |
Stefan Weil | 748bfb4 | 2014-07-07 21:03:38 +0200 | [diff] [blame] | 33 | static char temp_file[] = "/tmp/vmst.test.XXXXXX"; |
| 34 | static int temp_fd; |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 35 | |
Dr. David Alan Gilbert | 9935bac | 2014-10-10 12:39:05 +0100 | [diff] [blame] | 36 | |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 37 | /* Duplicate temp_fd and seek to the beginning of the file */ |
Juan Quintela | c6f6646 | 2014-04-05 18:34:36 +0200 | [diff] [blame] | 38 | static QEMUFile *open_test_file(bool write) |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 39 | { |
| 40 | int fd = dup(temp_fd); |
Daniel P. Berrange | 8925839 | 2016-04-27 11:05:08 +0100 | [diff] [blame] | 41 | QIOChannel *ioc; |
Marc-André Lureau | 4ae3c0e | 2016-07-07 20:48:06 +0200 | [diff] [blame] | 42 | QEMUFile *f; |
| 43 | |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 44 | lseek(fd, 0, SEEK_SET); |
Juan Quintela | c6f6646 | 2014-04-05 18:34:36 +0200 | [diff] [blame] | 45 | if (write) { |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 46 | g_assert_cmpint(ftruncate(fd, 0), ==, 0); |
| 47 | } |
Daniel P. Berrange | 8925839 | 2016-04-27 11:05:08 +0100 | [diff] [blame] | 48 | ioc = QIO_CHANNEL(qio_channel_file_new_fd(fd)); |
| 49 | if (write) { |
Marc-André Lureau | 4ae3c0e | 2016-07-07 20:48:06 +0200 | [diff] [blame] | 50 | f = qemu_fopen_channel_output(ioc); |
Daniel P. Berrange | 8925839 | 2016-04-27 11:05:08 +0100 | [diff] [blame] | 51 | } else { |
Marc-André Lureau | 4ae3c0e | 2016-07-07 20:48:06 +0200 | [diff] [blame] | 52 | f = qemu_fopen_channel_input(ioc); |
Daniel P. Berrange | 8925839 | 2016-04-27 11:05:08 +0100 | [diff] [blame] | 53 | } |
Marc-André Lureau | 4ae3c0e | 2016-07-07 20:48:06 +0200 | [diff] [blame] | 54 | object_unref(OBJECT(ioc)); |
| 55 | return f; |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 56 | } |
| 57 | |
Juan Quintela | 4ea7df4 | 2014-04-05 20:12:51 +0200 | [diff] [blame] | 58 | #define SUCCESS(val) \ |
| 59 | g_assert_cmpint((val), ==, 0) |
| 60 | |
| 61 | #define FAILURE(val) \ |
| 62 | g_assert_cmpint((val), !=, 0) |
| 63 | |
| 64 | static void save_vmstate(const VMStateDescription *desc, void *obj) |
| 65 | { |
| 66 | QEMUFile *f = open_test_file(true); |
| 67 | |
| 68 | /* Save file with vmstate */ |
Alexander Graf | 8118f09 | 2015-01-22 15:01:39 +0100 | [diff] [blame] | 69 | vmstate_save_state(f, desc, obj, NULL); |
Juan Quintela | 4ea7df4 | 2014-04-05 20:12:51 +0200 | [diff] [blame] | 70 | qemu_put_byte(f, QEMU_VM_EOF); |
| 71 | g_assert(!qemu_file_get_error(f)); |
| 72 | qemu_fclose(f); |
| 73 | } |
| 74 | |
Halil Pasic | 6d57b4c | 2016-10-21 16:37:38 +0200 | [diff] [blame] | 75 | static void save_buffer(const uint8_t *buf, size_t buf_size) |
| 76 | { |
| 77 | QEMUFile *fsave = open_test_file(true); |
| 78 | qemu_put_buffer(fsave, buf, buf_size); |
| 79 | qemu_fclose(fsave); |
| 80 | } |
| 81 | |
Dr. David Alan Gilbert | 5c379d9 | 2017-02-03 16:06:50 +0000 | [diff] [blame] | 82 | static void compare_vmstate(const uint8_t *wire, size_t size) |
Juan Quintela | 4ea7df4 | 2014-04-05 20:12:51 +0200 | [diff] [blame] | 83 | { |
| 84 | QEMUFile *f = open_test_file(false); |
| 85 | uint8_t result[size]; |
| 86 | |
| 87 | /* read back as binary */ |
| 88 | |
| 89 | g_assert_cmpint(qemu_get_buffer(f, result, sizeof(result)), ==, |
| 90 | sizeof(result)); |
| 91 | g_assert(!qemu_file_get_error(f)); |
| 92 | |
| 93 | /* Compare that what is on the file is the same that what we |
| 94 | expected to be there */ |
| 95 | SUCCESS(memcmp(result, wire, sizeof(result))); |
| 96 | |
| 97 | /* Must reach EOF */ |
| 98 | qemu_get_byte(f); |
| 99 | g_assert_cmpint(qemu_file_get_error(f), ==, -EIO); |
| 100 | |
| 101 | qemu_fclose(f); |
| 102 | } |
| 103 | |
| 104 | static int load_vmstate_one(const VMStateDescription *desc, void *obj, |
Dr. David Alan Gilbert | 5c379d9 | 2017-02-03 16:06:50 +0000 | [diff] [blame] | 105 | int version, const uint8_t *wire, size_t size) |
Juan Quintela | 4ea7df4 | 2014-04-05 20:12:51 +0200 | [diff] [blame] | 106 | { |
| 107 | QEMUFile *f; |
| 108 | int ret; |
| 109 | |
| 110 | f = open_test_file(true); |
| 111 | qemu_put_buffer(f, wire, size); |
| 112 | qemu_fclose(f); |
| 113 | |
| 114 | f = open_test_file(false); |
| 115 | ret = vmstate_load_state(f, desc, obj, version); |
| 116 | if (ret) { |
| 117 | g_assert(qemu_file_get_error(f)); |
| 118 | } else{ |
| 119 | g_assert(!qemu_file_get_error(f)); |
| 120 | } |
| 121 | qemu_fclose(f); |
| 122 | return ret; |
| 123 | } |
| 124 | |
| 125 | |
| 126 | static int load_vmstate(const VMStateDescription *desc, |
| 127 | void *obj, void *obj_clone, |
| 128 | void (*obj_copy)(void *, void*), |
Dr. David Alan Gilbert | 5c379d9 | 2017-02-03 16:06:50 +0000 | [diff] [blame] | 129 | int version, const uint8_t *wire, size_t size) |
Juan Quintela | 4ea7df4 | 2014-04-05 20:12:51 +0200 | [diff] [blame] | 130 | { |
| 131 | /* We test with zero size */ |
| 132 | obj_copy(obj_clone, obj); |
| 133 | FAILURE(load_vmstate_one(desc, obj, version, wire, 0)); |
| 134 | |
| 135 | /* Stream ends with QEMU_EOF, so we need at least 3 bytes to be |
| 136 | * able to test in the middle */ |
| 137 | |
| 138 | if (size > 3) { |
| 139 | |
| 140 | /* We test with size - 2. We can't test size - 1 due to EOF tricks */ |
| 141 | obj_copy(obj, obj_clone); |
| 142 | FAILURE(load_vmstate_one(desc, obj, version, wire, size - 2)); |
| 143 | |
| 144 | /* Test with size/2, first half of real state */ |
| 145 | obj_copy(obj, obj_clone); |
| 146 | FAILURE(load_vmstate_one(desc, obj, version, wire, size/2)); |
| 147 | |
| 148 | /* Test with size/2, second half of real state */ |
| 149 | obj_copy(obj, obj_clone); |
| 150 | FAILURE(load_vmstate_one(desc, obj, version, wire + (size/2), size/2)); |
| 151 | |
| 152 | } |
| 153 | obj_copy(obj, obj_clone); |
| 154 | return load_vmstate_one(desc, obj, version, wire, size); |
| 155 | } |
| 156 | |
| 157 | /* Test struct that we are going to use for our tests */ |
| 158 | |
| 159 | typedef struct TestSimple { |
| 160 | bool b_1, b_2; |
| 161 | uint8_t u8_1; |
| 162 | uint16_t u16_1; |
| 163 | uint32_t u32_1; |
| 164 | uint64_t u64_1; |
| 165 | int8_t i8_1, i8_2; |
| 166 | int16_t i16_1, i16_2; |
| 167 | int32_t i32_1, i32_2; |
| 168 | int64_t i64_1, i64_2; |
| 169 | } TestSimple; |
| 170 | |
| 171 | /* Object instantiation, we are going to use it in more than one test */ |
| 172 | |
| 173 | TestSimple obj_simple = { |
| 174 | .b_1 = true, |
| 175 | .b_2 = false, |
| 176 | .u8_1 = 130, |
| 177 | .u16_1 = 512, |
| 178 | .u32_1 = 70000, |
| 179 | .u64_1 = 12121212, |
| 180 | .i8_1 = 65, |
| 181 | .i8_2 = -65, |
| 182 | .i16_1 = 512, |
| 183 | .i16_2 = -512, |
| 184 | .i32_1 = 70000, |
| 185 | .i32_2 = -70000, |
| 186 | .i64_1 = 12121212, |
| 187 | .i64_2 = -12121212, |
| 188 | }; |
| 189 | |
| 190 | /* Description of the values. If you add a primitive type |
| 191 | you are expected to add a test here */ |
| 192 | |
| 193 | static const VMStateDescription vmstate_simple_primitive = { |
| 194 | .name = "simple/primitive", |
| 195 | .version_id = 1, |
| 196 | .minimum_version_id = 1, |
| 197 | .fields = (VMStateField[]) { |
| 198 | VMSTATE_BOOL(b_1, TestSimple), |
| 199 | VMSTATE_BOOL(b_2, TestSimple), |
| 200 | VMSTATE_UINT8(u8_1, TestSimple), |
| 201 | VMSTATE_UINT16(u16_1, TestSimple), |
| 202 | VMSTATE_UINT32(u32_1, TestSimple), |
| 203 | VMSTATE_UINT64(u64_1, TestSimple), |
| 204 | VMSTATE_INT8(i8_1, TestSimple), |
| 205 | VMSTATE_INT8(i8_2, TestSimple), |
| 206 | VMSTATE_INT16(i16_1, TestSimple), |
| 207 | VMSTATE_INT16(i16_2, TestSimple), |
| 208 | VMSTATE_INT32(i32_1, TestSimple), |
| 209 | VMSTATE_INT32(i32_2, TestSimple), |
| 210 | VMSTATE_INT64(i64_1, TestSimple), |
| 211 | VMSTATE_INT64(i64_2, TestSimple), |
| 212 | VMSTATE_END_OF_LIST() |
| 213 | } |
| 214 | }; |
| 215 | |
| 216 | /* It describes what goes through the wire. Our tests are basically: |
| 217 | |
| 218 | * save test |
| 219 | - save a struct a vmstate to a file |
| 220 | - read that file back (binary read, no vmstate) |
| 221 | - compare it with what we expect to be on the wire |
| 222 | * load test |
| 223 | - save to the file what we expect to be on the wire |
| 224 | - read struct back with vmstate in a different |
| 225 | - compare back with the original struct |
| 226 | */ |
| 227 | |
| 228 | uint8_t wire_simple_primitive[] = { |
| 229 | /* b_1 */ 0x01, |
| 230 | /* b_2 */ 0x00, |
| 231 | /* u8_1 */ 0x82, |
| 232 | /* u16_1 */ 0x02, 0x00, |
| 233 | /* u32_1 */ 0x00, 0x01, 0x11, 0x70, |
| 234 | /* u64_1 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0xf4, 0x7c, |
| 235 | /* i8_1 */ 0x41, |
| 236 | /* i8_2 */ 0xbf, |
| 237 | /* i16_1 */ 0x02, 0x00, |
| 238 | /* i16_2 */ 0xfe, 0x0, |
| 239 | /* i32_1 */ 0x00, 0x01, 0x11, 0x70, |
| 240 | /* i32_2 */ 0xff, 0xfe, 0xee, 0x90, |
| 241 | /* i64_1 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0xf4, 0x7c, |
| 242 | /* i64_2 */ 0xff, 0xff, 0xff, 0xff, 0xff, 0x47, 0x0b, 0x84, |
| 243 | QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */ |
| 244 | }; |
| 245 | |
| 246 | static void obj_simple_copy(void *target, void *source) |
| 247 | { |
| 248 | memcpy(target, source, sizeof(TestSimple)); |
| 249 | } |
| 250 | |
| 251 | static void test_simple_primitive(void) |
| 252 | { |
| 253 | TestSimple obj, obj_clone; |
| 254 | |
| 255 | memset(&obj, 0, sizeof(obj)); |
| 256 | save_vmstate(&vmstate_simple_primitive, &obj_simple); |
| 257 | |
| 258 | compare_vmstate(wire_simple_primitive, sizeof(wire_simple_primitive)); |
| 259 | |
| 260 | SUCCESS(load_vmstate(&vmstate_simple_primitive, &obj, &obj_clone, |
| 261 | obj_simple_copy, 1, wire_simple_primitive, |
| 262 | sizeof(wire_simple_primitive))); |
| 263 | |
| 264 | #define FIELD_EQUAL(name) g_assert_cmpint(obj.name, ==, obj_simple.name) |
| 265 | |
| 266 | FIELD_EQUAL(b_1); |
| 267 | FIELD_EQUAL(b_2); |
| 268 | FIELD_EQUAL(u8_1); |
| 269 | FIELD_EQUAL(u16_1); |
| 270 | FIELD_EQUAL(u32_1); |
| 271 | FIELD_EQUAL(u64_1); |
| 272 | FIELD_EQUAL(i8_1); |
| 273 | FIELD_EQUAL(i8_2); |
| 274 | FIELD_EQUAL(i16_1); |
| 275 | FIELD_EQUAL(i16_2); |
| 276 | FIELD_EQUAL(i32_1); |
| 277 | FIELD_EQUAL(i32_2); |
| 278 | FIELD_EQUAL(i64_1); |
| 279 | FIELD_EQUAL(i64_2); |
| 280 | } |
Juan Quintela | 4ea7df4 | 2014-04-05 20:12:51 +0200 | [diff] [blame] | 281 | |
| 282 | typedef struct TestStruct { |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 283 | uint32_t a, b, c, e; |
| 284 | uint64_t d, f; |
| 285 | bool skip_c_e; |
| 286 | } TestStruct; |
| 287 | |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 288 | static const VMStateDescription vmstate_versioned = { |
Juan Quintela | 4ea7df4 | 2014-04-05 20:12:51 +0200 | [diff] [blame] | 289 | .name = "test/versioned", |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 290 | .version_id = 2, |
| 291 | .minimum_version_id = 1, |
Juan Quintela | 35d0845 | 2014-04-16 16:01:33 +0200 | [diff] [blame] | 292 | .fields = (VMStateField[]) { |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 293 | VMSTATE_UINT32(a, TestStruct), |
| 294 | VMSTATE_UINT32_V(b, TestStruct, 2), /* Versioned field in the middle, so |
| 295 | * we catch bugs more easily. |
| 296 | */ |
| 297 | VMSTATE_UINT32(c, TestStruct), |
| 298 | VMSTATE_UINT64(d, TestStruct), |
| 299 | VMSTATE_UINT32_V(e, TestStruct, 2), |
| 300 | VMSTATE_UINT64_V(f, TestStruct, 2), |
| 301 | VMSTATE_END_OF_LIST() |
| 302 | } |
| 303 | }; |
| 304 | |
| 305 | static void test_load_v1(void) |
| 306 | { |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 307 | uint8_t buf[] = { |
| 308 | 0, 0, 0, 10, /* a */ |
| 309 | 0, 0, 0, 30, /* c */ |
| 310 | 0, 0, 0, 0, 0, 0, 0, 40, /* d */ |
| 311 | QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */ |
| 312 | }; |
Halil Pasic | 6d57b4c | 2016-10-21 16:37:38 +0200 | [diff] [blame] | 313 | save_buffer(buf, sizeof(buf)); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 314 | |
Juan Quintela | c6f6646 | 2014-04-05 18:34:36 +0200 | [diff] [blame] | 315 | QEMUFile *loading = open_test_file(false); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 316 | TestStruct obj = { .b = 200, .e = 500, .f = 600 }; |
| 317 | vmstate_load_state(loading, &vmstate_versioned, &obj, 1); |
| 318 | g_assert(!qemu_file_get_error(loading)); |
| 319 | g_assert_cmpint(obj.a, ==, 10); |
| 320 | g_assert_cmpint(obj.b, ==, 200); |
| 321 | g_assert_cmpint(obj.c, ==, 30); |
| 322 | g_assert_cmpint(obj.d, ==, 40); |
| 323 | g_assert_cmpint(obj.e, ==, 500); |
| 324 | g_assert_cmpint(obj.f, ==, 600); |
| 325 | qemu_fclose(loading); |
| 326 | } |
| 327 | |
| 328 | static void test_load_v2(void) |
| 329 | { |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 330 | uint8_t buf[] = { |
| 331 | 0, 0, 0, 10, /* a */ |
| 332 | 0, 0, 0, 20, /* b */ |
| 333 | 0, 0, 0, 30, /* c */ |
| 334 | 0, 0, 0, 0, 0, 0, 0, 40, /* d */ |
| 335 | 0, 0, 0, 50, /* e */ |
| 336 | 0, 0, 0, 0, 0, 0, 0, 60, /* f */ |
| 337 | QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */ |
| 338 | }; |
Halil Pasic | 6d57b4c | 2016-10-21 16:37:38 +0200 | [diff] [blame] | 339 | save_buffer(buf, sizeof(buf)); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 340 | |
Juan Quintela | c6f6646 | 2014-04-05 18:34:36 +0200 | [diff] [blame] | 341 | QEMUFile *loading = open_test_file(false); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 342 | TestStruct obj; |
| 343 | vmstate_load_state(loading, &vmstate_versioned, &obj, 2); |
| 344 | g_assert_cmpint(obj.a, ==, 10); |
| 345 | g_assert_cmpint(obj.b, ==, 20); |
| 346 | g_assert_cmpint(obj.c, ==, 30); |
| 347 | g_assert_cmpint(obj.d, ==, 40); |
| 348 | g_assert_cmpint(obj.e, ==, 50); |
| 349 | g_assert_cmpint(obj.f, ==, 60); |
| 350 | qemu_fclose(loading); |
| 351 | } |
| 352 | |
| 353 | static bool test_skip(void *opaque, int version_id) |
| 354 | { |
| 355 | TestStruct *t = (TestStruct *)opaque; |
| 356 | return !t->skip_c_e; |
| 357 | } |
| 358 | |
| 359 | static const VMStateDescription vmstate_skipping = { |
Juan Quintela | 4ea7df4 | 2014-04-05 20:12:51 +0200 | [diff] [blame] | 360 | .name = "test/skip", |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 361 | .version_id = 2, |
| 362 | .minimum_version_id = 1, |
Juan Quintela | 35d0845 | 2014-04-16 16:01:33 +0200 | [diff] [blame] | 363 | .fields = (VMStateField[]) { |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 364 | VMSTATE_UINT32(a, TestStruct), |
| 365 | VMSTATE_UINT32(b, TestStruct), |
| 366 | VMSTATE_UINT32_TEST(c, TestStruct, test_skip), |
| 367 | VMSTATE_UINT64(d, TestStruct), |
| 368 | VMSTATE_UINT32_TEST(e, TestStruct, test_skip), |
| 369 | VMSTATE_UINT64_V(f, TestStruct, 2), |
| 370 | VMSTATE_END_OF_LIST() |
| 371 | } |
| 372 | }; |
| 373 | |
| 374 | |
| 375 | static void test_save_noskip(void) |
| 376 | { |
Daniel P. Berrange | a8ec443 | 2016-04-27 11:04:53 +0100 | [diff] [blame] | 377 | QEMUFile *fsave = open_test_file(true); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 378 | TestStruct obj = { .a = 1, .b = 2, .c = 3, .d = 4, .e = 5, .f = 6, |
| 379 | .skip_c_e = false }; |
Alexander Graf | 8118f09 | 2015-01-22 15:01:39 +0100 | [diff] [blame] | 380 | vmstate_save_state(fsave, &vmstate_skipping, &obj, NULL); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 381 | g_assert(!qemu_file_get_error(fsave)); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 382 | |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 383 | uint8_t expected[] = { |
| 384 | 0, 0, 0, 1, /* a */ |
| 385 | 0, 0, 0, 2, /* b */ |
| 386 | 0, 0, 0, 3, /* c */ |
| 387 | 0, 0, 0, 0, 0, 0, 0, 4, /* d */ |
| 388 | 0, 0, 0, 5, /* e */ |
| 389 | 0, 0, 0, 0, 0, 0, 0, 6, /* f */ |
| 390 | }; |
Daniel P. Berrange | a8ec443 | 2016-04-27 11:04:53 +0100 | [diff] [blame] | 391 | |
Dr. David Alan Gilbert | 9935bac | 2014-10-10 12:39:05 +0100 | [diff] [blame] | 392 | qemu_fclose(fsave); |
Daniel P. Berrange | a8ec443 | 2016-04-27 11:04:53 +0100 | [diff] [blame] | 393 | compare_vmstate(expected, sizeof(expected)); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 394 | } |
| 395 | |
| 396 | static void test_save_skip(void) |
| 397 | { |
Daniel P. Berrange | a8ec443 | 2016-04-27 11:04:53 +0100 | [diff] [blame] | 398 | QEMUFile *fsave = open_test_file(true); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 399 | TestStruct obj = { .a = 1, .b = 2, .c = 3, .d = 4, .e = 5, .f = 6, |
| 400 | .skip_c_e = true }; |
Alexander Graf | 8118f09 | 2015-01-22 15:01:39 +0100 | [diff] [blame] | 401 | vmstate_save_state(fsave, &vmstate_skipping, &obj, NULL); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 402 | g_assert(!qemu_file_get_error(fsave)); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 403 | |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 404 | uint8_t expected[] = { |
| 405 | 0, 0, 0, 1, /* a */ |
| 406 | 0, 0, 0, 2, /* b */ |
| 407 | 0, 0, 0, 0, 0, 0, 0, 4, /* d */ |
| 408 | 0, 0, 0, 0, 0, 0, 0, 6, /* f */ |
| 409 | }; |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 410 | |
Dr. David Alan Gilbert | 9935bac | 2014-10-10 12:39:05 +0100 | [diff] [blame] | 411 | qemu_fclose(fsave); |
Daniel P. Berrange | a8ec443 | 2016-04-27 11:04:53 +0100 | [diff] [blame] | 412 | compare_vmstate(expected, sizeof(expected)); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 413 | } |
| 414 | |
| 415 | static void test_load_noskip(void) |
| 416 | { |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 417 | uint8_t buf[] = { |
| 418 | 0, 0, 0, 10, /* a */ |
| 419 | 0, 0, 0, 20, /* b */ |
| 420 | 0, 0, 0, 30, /* c */ |
| 421 | 0, 0, 0, 0, 0, 0, 0, 40, /* d */ |
| 422 | 0, 0, 0, 50, /* e */ |
| 423 | 0, 0, 0, 0, 0, 0, 0, 60, /* f */ |
| 424 | QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */ |
| 425 | }; |
Halil Pasic | 6d57b4c | 2016-10-21 16:37:38 +0200 | [diff] [blame] | 426 | save_buffer(buf, sizeof(buf)); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 427 | |
Daniel P. Berrange | a8ec443 | 2016-04-27 11:04:53 +0100 | [diff] [blame] | 428 | QEMUFile *loading = open_test_file(false); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 429 | TestStruct obj = { .skip_c_e = false }; |
| 430 | vmstate_load_state(loading, &vmstate_skipping, &obj, 2); |
| 431 | g_assert(!qemu_file_get_error(loading)); |
| 432 | g_assert_cmpint(obj.a, ==, 10); |
| 433 | g_assert_cmpint(obj.b, ==, 20); |
| 434 | g_assert_cmpint(obj.c, ==, 30); |
| 435 | g_assert_cmpint(obj.d, ==, 40); |
| 436 | g_assert_cmpint(obj.e, ==, 50); |
| 437 | g_assert_cmpint(obj.f, ==, 60); |
| 438 | qemu_fclose(loading); |
| 439 | } |
| 440 | |
| 441 | static void test_load_skip(void) |
| 442 | { |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 443 | uint8_t buf[] = { |
| 444 | 0, 0, 0, 10, /* a */ |
| 445 | 0, 0, 0, 20, /* b */ |
| 446 | 0, 0, 0, 0, 0, 0, 0, 40, /* d */ |
| 447 | 0, 0, 0, 0, 0, 0, 0, 60, /* f */ |
| 448 | QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */ |
| 449 | }; |
Halil Pasic | 6d57b4c | 2016-10-21 16:37:38 +0200 | [diff] [blame] | 450 | save_buffer(buf, sizeof(buf)); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 451 | |
Daniel P. Berrange | a8ec443 | 2016-04-27 11:04:53 +0100 | [diff] [blame] | 452 | QEMUFile *loading = open_test_file(false); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 453 | TestStruct obj = { .skip_c_e = true, .c = 300, .e = 500 }; |
| 454 | vmstate_load_state(loading, &vmstate_skipping, &obj, 2); |
| 455 | g_assert(!qemu_file_get_error(loading)); |
| 456 | g_assert_cmpint(obj.a, ==, 10); |
| 457 | g_assert_cmpint(obj.b, ==, 20); |
| 458 | g_assert_cmpint(obj.c, ==, 300); |
| 459 | g_assert_cmpint(obj.d, ==, 40); |
| 460 | g_assert_cmpint(obj.e, ==, 500); |
| 461 | g_assert_cmpint(obj.f, ==, 60); |
| 462 | qemu_fclose(loading); |
| 463 | } |
| 464 | |
Halil Pasic | 8cc49f0 | 2016-10-21 16:37:39 +0200 | [diff] [blame] | 465 | typedef struct { |
| 466 | int32_t i; |
| 467 | } TestStructTriv; |
| 468 | |
| 469 | const VMStateDescription vmsd_tst = { |
| 470 | .name = "test/tst", |
| 471 | .version_id = 1, |
| 472 | .minimum_version_id = 1, |
| 473 | .fields = (VMStateField[]) { |
| 474 | VMSTATE_INT32(i, TestStructTriv), |
| 475 | VMSTATE_END_OF_LIST() |
| 476 | } |
| 477 | }; |
| 478 | |
| 479 | #define AR_SIZE 4 |
| 480 | |
| 481 | typedef struct { |
| 482 | TestStructTriv *ar[AR_SIZE]; |
| 483 | } TestArrayOfPtrToStuct; |
| 484 | |
| 485 | const VMStateDescription vmsd_arps = { |
| 486 | .name = "test/arps", |
| 487 | .version_id = 1, |
| 488 | .minimum_version_id = 1, |
| 489 | .fields = (VMStateField[]) { |
| 490 | VMSTATE_ARRAY_OF_POINTER_TO_STRUCT(ar, TestArrayOfPtrToStuct, |
| 491 | AR_SIZE, 0, vmsd_tst, TestStructTriv), |
| 492 | VMSTATE_END_OF_LIST() |
| 493 | } |
| 494 | }; |
| 495 | static void test_arr_ptr_str_no0_save(void) |
| 496 | { |
| 497 | TestStructTriv ar[AR_SIZE] = {{.i = 0}, {.i = 1}, {.i = 2}, {.i = 3} }; |
| 498 | TestArrayOfPtrToStuct sample = {.ar = {&ar[0], &ar[1], &ar[2], &ar[3]} }; |
| 499 | uint8_t wire_sample[] = { |
| 500 | 0x00, 0x00, 0x00, 0x00, |
| 501 | 0x00, 0x00, 0x00, 0x01, |
| 502 | 0x00, 0x00, 0x00, 0x02, |
| 503 | 0x00, 0x00, 0x00, 0x03, |
| 504 | QEMU_VM_EOF |
| 505 | }; |
| 506 | |
| 507 | save_vmstate(&vmsd_arps, &sample); |
| 508 | compare_vmstate(wire_sample, sizeof(wire_sample)); |
| 509 | } |
| 510 | |
| 511 | static void test_arr_ptr_str_no0_load(void) |
| 512 | { |
| 513 | TestStructTriv ar_gt[AR_SIZE] = {{.i = 0}, {.i = 1}, {.i = 2}, {.i = 3} }; |
| 514 | TestStructTriv ar[AR_SIZE] = {}; |
| 515 | TestArrayOfPtrToStuct obj = {.ar = {&ar[0], &ar[1], &ar[2], &ar[3]} }; |
| 516 | int idx; |
| 517 | uint8_t wire_sample[] = { |
| 518 | 0x00, 0x00, 0x00, 0x00, |
| 519 | 0x00, 0x00, 0x00, 0x01, |
| 520 | 0x00, 0x00, 0x00, 0x02, |
| 521 | 0x00, 0x00, 0x00, 0x03, |
| 522 | QEMU_VM_EOF |
| 523 | }; |
| 524 | |
| 525 | save_buffer(wire_sample, sizeof(wire_sample)); |
| 526 | SUCCESS(load_vmstate_one(&vmsd_arps, &obj, 1, |
| 527 | wire_sample, sizeof(wire_sample))); |
| 528 | for (idx = 0; idx < AR_SIZE; ++idx) { |
| 529 | /* compare the target array ar with the ground truth array ar_gt */ |
| 530 | g_assert_cmpint(ar_gt[idx].i, ==, ar[idx].i); |
| 531 | } |
| 532 | } |
| 533 | |
Jianjun Duan | 7e99f22 | 2017-01-19 11:00:52 -0800 | [diff] [blame] | 534 | /* test QTAILQ migration */ |
| 535 | typedef struct TestQtailqElement TestQtailqElement; |
| 536 | |
| 537 | struct TestQtailqElement { |
| 538 | bool b; |
| 539 | uint8_t u8; |
| 540 | QTAILQ_ENTRY(TestQtailqElement) next; |
| 541 | }; |
| 542 | |
| 543 | typedef struct TestQtailq { |
| 544 | int16_t i16; |
| 545 | QTAILQ_HEAD(TestQtailqHead, TestQtailqElement) q; |
| 546 | int32_t i32; |
| 547 | } TestQtailq; |
| 548 | |
| 549 | static const VMStateDescription vmstate_q_element = { |
| 550 | .name = "test/queue-element", |
| 551 | .version_id = 1, |
| 552 | .minimum_version_id = 1, |
| 553 | .fields = (VMStateField[]) { |
| 554 | VMSTATE_BOOL(b, TestQtailqElement), |
| 555 | VMSTATE_UINT8(u8, TestQtailqElement), |
| 556 | VMSTATE_END_OF_LIST() |
| 557 | }, |
| 558 | }; |
| 559 | |
| 560 | static const VMStateDescription vmstate_q = { |
| 561 | .name = "test/queue", |
| 562 | .version_id = 1, |
| 563 | .minimum_version_id = 1, |
| 564 | .fields = (VMStateField[]) { |
| 565 | VMSTATE_INT16(i16, TestQtailq), |
| 566 | VMSTATE_QTAILQ_V(q, TestQtailq, 1, vmstate_q_element, TestQtailqElement, |
| 567 | next), |
| 568 | VMSTATE_INT32(i32, TestQtailq), |
| 569 | VMSTATE_END_OF_LIST() |
| 570 | } |
| 571 | }; |
| 572 | |
| 573 | uint8_t wire_q[] = { |
| 574 | /* i16 */ 0xfe, 0x0, |
| 575 | /* start of element 0 of q */ 0x01, |
| 576 | /* .b */ 0x01, |
| 577 | /* .u8 */ 0x82, |
| 578 | /* start of element 1 of q */ 0x01, |
| 579 | /* b */ 0x00, |
| 580 | /* u8 */ 0x41, |
| 581 | /* end of q */ 0x00, |
| 582 | /* i32 */ 0x00, 0x01, 0x11, 0x70, |
| 583 | QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */ |
| 584 | }; |
| 585 | |
| 586 | static void test_save_q(void) |
| 587 | { |
| 588 | TestQtailq obj_q = { |
| 589 | .i16 = -512, |
| 590 | .i32 = 70000, |
| 591 | }; |
| 592 | |
| 593 | TestQtailqElement obj_qe1 = { |
| 594 | .b = true, |
| 595 | .u8 = 130, |
| 596 | }; |
| 597 | |
| 598 | TestQtailqElement obj_qe2 = { |
| 599 | .b = false, |
| 600 | .u8 = 65, |
| 601 | }; |
| 602 | |
| 603 | QTAILQ_INIT(&obj_q.q); |
| 604 | QTAILQ_INSERT_TAIL(&obj_q.q, &obj_qe1, next); |
| 605 | QTAILQ_INSERT_TAIL(&obj_q.q, &obj_qe2, next); |
| 606 | |
| 607 | save_vmstate(&vmstate_q, &obj_q); |
| 608 | compare_vmstate(wire_q, sizeof(wire_q)); |
| 609 | } |
| 610 | |
| 611 | static void test_load_q(void) |
| 612 | { |
| 613 | TestQtailq obj_q = { |
| 614 | .i16 = -512, |
| 615 | .i32 = 70000, |
| 616 | }; |
| 617 | |
| 618 | TestQtailqElement obj_qe1 = { |
| 619 | .b = true, |
| 620 | .u8 = 130, |
| 621 | }; |
| 622 | |
| 623 | TestQtailqElement obj_qe2 = { |
| 624 | .b = false, |
| 625 | .u8 = 65, |
| 626 | }; |
| 627 | |
| 628 | QTAILQ_INIT(&obj_q.q); |
| 629 | QTAILQ_INSERT_TAIL(&obj_q.q, &obj_qe1, next); |
| 630 | QTAILQ_INSERT_TAIL(&obj_q.q, &obj_qe2, next); |
| 631 | |
| 632 | QEMUFile *fsave = open_test_file(true); |
| 633 | |
| 634 | qemu_put_buffer(fsave, wire_q, sizeof(wire_q)); |
| 635 | g_assert(!qemu_file_get_error(fsave)); |
| 636 | qemu_fclose(fsave); |
| 637 | |
| 638 | QEMUFile *fload = open_test_file(false); |
| 639 | TestQtailq tgt; |
| 640 | |
| 641 | QTAILQ_INIT(&tgt.q); |
| 642 | vmstate_load_state(fload, &vmstate_q, &tgt, 1); |
| 643 | char eof = qemu_get_byte(fload); |
| 644 | g_assert(!qemu_file_get_error(fload)); |
| 645 | g_assert_cmpint(tgt.i16, ==, obj_q.i16); |
| 646 | g_assert_cmpint(tgt.i32, ==, obj_q.i32); |
| 647 | g_assert_cmpint(eof, ==, QEMU_VM_EOF); |
| 648 | |
| 649 | TestQtailqElement *qele_from = QTAILQ_FIRST(&obj_q.q); |
| 650 | TestQtailqElement *qlast_from = QTAILQ_LAST(&obj_q.q, TestQtailqHead); |
| 651 | TestQtailqElement *qele_to = QTAILQ_FIRST(&tgt.q); |
| 652 | TestQtailqElement *qlast_to = QTAILQ_LAST(&tgt.q, TestQtailqHead); |
| 653 | |
| 654 | while (1) { |
| 655 | g_assert_cmpint(qele_to->b, ==, qele_from->b); |
| 656 | g_assert_cmpint(qele_to->u8, ==, qele_from->u8); |
| 657 | if ((qele_from == qlast_from) || (qele_to == qlast_to)) { |
| 658 | break; |
| 659 | } |
| 660 | qele_from = QTAILQ_NEXT(qele_from, next); |
| 661 | qele_to = QTAILQ_NEXT(qele_to, next); |
| 662 | } |
| 663 | |
| 664 | g_assert_cmpint((uintptr_t) qele_from, ==, (uintptr_t) qlast_from); |
| 665 | g_assert_cmpint((uintptr_t) qele_to, ==, (uintptr_t) qlast_to); |
| 666 | |
| 667 | /* clean up */ |
| 668 | TestQtailqElement *qele; |
| 669 | while (!QTAILQ_EMPTY(&tgt.q)) { |
| 670 | qele = QTAILQ_LAST(&tgt.q, TestQtailqHead); |
| 671 | QTAILQ_REMOVE(&tgt.q, qele, next); |
| 672 | free(qele); |
| 673 | qele = NULL; |
| 674 | } |
| 675 | qemu_fclose(fload); |
| 676 | } |
| 677 | |
Dr. David Alan Gilbert | 5c379d9 | 2017-02-03 16:06:50 +0000 | [diff] [blame] | 678 | typedef struct TmpTestStruct { |
| 679 | TestStruct *parent; |
| 680 | int64_t diff; |
| 681 | } TmpTestStruct; |
| 682 | |
| 683 | static void tmp_child_pre_save(void *opaque) |
| 684 | { |
| 685 | struct TmpTestStruct *tts = opaque; |
| 686 | |
| 687 | tts->diff = tts->parent->b - tts->parent->a; |
| 688 | } |
| 689 | |
| 690 | static int tmp_child_post_load(void *opaque, int version_id) |
| 691 | { |
| 692 | struct TmpTestStruct *tts = opaque; |
| 693 | |
| 694 | tts->parent->b = tts->parent->a + tts->diff; |
| 695 | |
| 696 | return 0; |
| 697 | } |
| 698 | |
| 699 | static const VMStateDescription vmstate_tmp_back_to_parent = { |
| 700 | .name = "test/tmp_child_parent", |
| 701 | .fields = (VMStateField[]) { |
| 702 | VMSTATE_UINT64(f, TestStruct), |
| 703 | VMSTATE_END_OF_LIST() |
| 704 | } |
| 705 | }; |
| 706 | |
| 707 | static const VMStateDescription vmstate_tmp_child = { |
| 708 | .name = "test/tmp_child", |
| 709 | .pre_save = tmp_child_pre_save, |
| 710 | .post_load = tmp_child_post_load, |
| 711 | .fields = (VMStateField[]) { |
| 712 | VMSTATE_INT64(diff, TmpTestStruct), |
| 713 | VMSTATE_STRUCT_POINTER(parent, TmpTestStruct, |
| 714 | vmstate_tmp_back_to_parent, TestStruct), |
| 715 | VMSTATE_END_OF_LIST() |
| 716 | } |
| 717 | }; |
| 718 | |
| 719 | static const VMStateDescription vmstate_with_tmp = { |
| 720 | .name = "test/with_tmp", |
| 721 | .version_id = 1, |
| 722 | .fields = (VMStateField[]) { |
| 723 | VMSTATE_UINT32(a, TestStruct), |
| 724 | VMSTATE_UINT64(d, TestStruct), |
| 725 | VMSTATE_WITH_TMP(TestStruct, TmpTestStruct, vmstate_tmp_child), |
| 726 | VMSTATE_END_OF_LIST() |
| 727 | } |
| 728 | }; |
| 729 | |
| 730 | static void obj_tmp_copy(void *target, void *source) |
| 731 | { |
| 732 | memcpy(target, source, sizeof(TestStruct)); |
| 733 | } |
| 734 | |
| 735 | static void test_tmp_struct(void) |
| 736 | { |
| 737 | TestStruct obj, obj_clone; |
| 738 | |
| 739 | uint8_t const wire_with_tmp[] = { |
| 740 | /* u32 a */ 0x00, 0x00, 0x00, 0x02, |
| 741 | /* u64 d */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, |
| 742 | /* diff */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, |
| 743 | /* u64 f */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, |
| 744 | QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */ |
| 745 | }; |
| 746 | |
| 747 | memset(&obj, 0, sizeof(obj)); |
| 748 | obj.a = 2; |
| 749 | obj.b = 4; |
| 750 | obj.d = 1; |
| 751 | obj.f = 8; |
| 752 | save_vmstate(&vmstate_with_tmp, &obj); |
| 753 | |
| 754 | compare_vmstate(wire_with_tmp, sizeof(wire_with_tmp)); |
| 755 | |
| 756 | memset(&obj, 0, sizeof(obj)); |
| 757 | SUCCESS(load_vmstate(&vmstate_with_tmp, &obj, &obj_clone, |
| 758 | obj_tmp_copy, 1, wire_with_tmp, |
| 759 | sizeof(wire_with_tmp))); |
| 760 | g_assert_cmpint(obj.a, ==, 2); /* From top level vmsd */ |
| 761 | g_assert_cmpint(obj.b, ==, 4); /* from the post_load */ |
| 762 | g_assert_cmpint(obj.d, ==, 1); /* From top level vmsd */ |
| 763 | g_assert_cmpint(obj.f, ==, 8); /* From the child->parent */ |
| 764 | } |
| 765 | |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 766 | int main(int argc, char **argv) |
| 767 | { |
| 768 | temp_fd = mkstemp(temp_file); |
| 769 | |
Daniel P. Berrange | 8925839 | 2016-04-27 11:05:08 +0100 | [diff] [blame] | 770 | module_call_init(MODULE_INIT_QOM); |
| 771 | |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 772 | g_test_init(&argc, &argv, NULL); |
Juan Quintela | 4ea7df4 | 2014-04-05 20:12:51 +0200 | [diff] [blame] | 773 | g_test_add_func("/vmstate/simple/primitive", test_simple_primitive); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 774 | g_test_add_func("/vmstate/versioned/load/v1", test_load_v1); |
| 775 | g_test_add_func("/vmstate/versioned/load/v2", test_load_v2); |
| 776 | g_test_add_func("/vmstate/field_exists/load/noskip", test_load_noskip); |
| 777 | g_test_add_func("/vmstate/field_exists/load/skip", test_load_skip); |
| 778 | g_test_add_func("/vmstate/field_exists/save/noskip", test_save_noskip); |
| 779 | g_test_add_func("/vmstate/field_exists/save/skip", test_save_skip); |
Halil Pasic | 8cc49f0 | 2016-10-21 16:37:39 +0200 | [diff] [blame] | 780 | g_test_add_func("/vmstate/array/ptr/str/no0/save", |
| 781 | test_arr_ptr_str_no0_save); |
| 782 | g_test_add_func("/vmstate/array/ptr/str/no0/load", |
| 783 | test_arr_ptr_str_no0_load); |
Jianjun Duan | 7e99f22 | 2017-01-19 11:00:52 -0800 | [diff] [blame] | 784 | g_test_add_func("/vmstate/qtailq/save/saveq", test_save_q); |
| 785 | g_test_add_func("/vmstate/qtailq/load/loadq", test_load_q); |
Dr. David Alan Gilbert | 5c379d9 | 2017-02-03 16:06:50 +0000 | [diff] [blame] | 786 | g_test_add_func("/vmstate/tmp_struct", test_tmp_struct); |
Eduardo Habkost | 2668b4b | 2013-11-28 12:01:18 -0200 | [diff] [blame] | 787 | g_test_run(); |
| 788 | |
| 789 | close(temp_fd); |
| 790 | unlink(temp_file); |
| 791 | |
| 792 | return 0; |
| 793 | } |