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 25 #include "qemu/osdep.h" 26 27 #include "qemu-common.h" 28 #include "../migration/migration.h" 29 #include "migration/vmstate.h" 30 #include "migration/qemu-file-types.h" 31 #include "../migration/qemu-file.h" 32 #include "../migration/qemu-file-channel.h" 33 #include "../migration/savevm.h" 34 #include "qemu/coroutine.h" 35 #include "io/channel-file.h" 36 37 static char temp_file[] = "/tmp/vmst.test.XXXXXX"; 38 static int temp_fd; 39 40 41 /* Duplicate temp_fd and seek to the beginning of the file */ 42 static QEMUFile *open_test_file(bool write) 43 { 44 int fd = dup(temp_fd); 45 QIOChannel *ioc; 46 QEMUFile *f; 47 48 lseek(fd, 0, SEEK_SET); 49 if (write) { 50 g_assert_cmpint(ftruncate(fd, 0), ==, 0); 51 } 52 ioc = QIO_CHANNEL(qio_channel_file_new_fd(fd)); 53 if (write) { 54 f = qemu_fopen_channel_output(ioc); 55 } else { 56 f = qemu_fopen_channel_input(ioc); 57 } 58 object_unref(OBJECT(ioc)); 59 return f; 60 } 61 62 #define SUCCESS(val) \ 63 g_assert_cmpint((val), ==, 0) 64 65 #define FAILURE(val) \ 66 g_assert_cmpint((val), !=, 0) 67 68 static void save_vmstate(const VMStateDescription *desc, void *obj) 69 { 70 QEMUFile *f = open_test_file(true); 71 72 /* Save file with vmstate */ 73 int ret = vmstate_save_state(f, desc, obj, NULL); 74 g_assert(!ret); 75 qemu_put_byte(f, QEMU_VM_EOF); 76 g_assert(!qemu_file_get_error(f)); 77 qemu_fclose(f); 78 } 79 80 static void save_buffer(const uint8_t *buf, size_t buf_size) 81 { 82 QEMUFile *fsave = open_test_file(true); 83 qemu_put_buffer(fsave, buf, buf_size); 84 qemu_fclose(fsave); 85 } 86 87 static void compare_vmstate(const uint8_t *wire, size_t size) 88 { 89 QEMUFile *f = open_test_file(false); 90 uint8_t result[size]; 91 92 /* read back as binary */ 93 94 g_assert_cmpint(qemu_get_buffer(f, result, sizeof(result)), ==, 95 sizeof(result)); 96 g_assert(!qemu_file_get_error(f)); 97 98 /* Compare that what is on the file is the same that what we 99 expected to be there */ 100 SUCCESS(memcmp(result, wire, sizeof(result))); 101 102 /* Must reach EOF */ 103 qemu_get_byte(f); 104 g_assert_cmpint(qemu_file_get_error(f), ==, -EIO); 105 106 qemu_fclose(f); 107 } 108 109 static int load_vmstate_one(const VMStateDescription *desc, void *obj, 110 int version, const uint8_t *wire, size_t size) 111 { 112 QEMUFile *f; 113 int ret; 114 115 f = open_test_file(true); 116 qemu_put_buffer(f, wire, size); 117 qemu_fclose(f); 118 119 f = open_test_file(false); 120 ret = vmstate_load_state(f, desc, obj, version); 121 if (ret) { 122 g_assert(qemu_file_get_error(f)); 123 } else{ 124 g_assert(!qemu_file_get_error(f)); 125 } 126 qemu_fclose(f); 127 return ret; 128 } 129 130 131 static int load_vmstate(const VMStateDescription *desc, 132 void *obj, void *obj_clone, 133 void (*obj_copy)(void *, void*), 134 int version, const uint8_t *wire, size_t size) 135 { 136 /* We test with zero size */ 137 obj_copy(obj_clone, obj); 138 FAILURE(load_vmstate_one(desc, obj, version, wire, 0)); 139 140 /* Stream ends with QEMU_EOF, so we need at least 3 bytes to be 141 * able to test in the middle */ 142 143 if (size > 3) { 144 145 /* We test with size - 2. We can't test size - 1 due to EOF tricks */ 146 obj_copy(obj, obj_clone); 147 FAILURE(load_vmstate_one(desc, obj, version, wire, size - 2)); 148 149 /* Test with size/2, first half of real state */ 150 obj_copy(obj, obj_clone); 151 FAILURE(load_vmstate_one(desc, obj, version, wire, size/2)); 152 153 /* Test with size/2, second half of real state */ 154 obj_copy(obj, obj_clone); 155 FAILURE(load_vmstate_one(desc, obj, version, wire + (size/2), size/2)); 156 157 } 158 obj_copy(obj, obj_clone); 159 return load_vmstate_one(desc, obj, version, wire, size); 160 } 161 162 /* Test struct that we are going to use for our tests */ 163 164 typedef struct TestSimple { 165 bool b_1, b_2; 166 uint8_t u8_1; 167 uint16_t u16_1; 168 uint32_t u32_1; 169 uint64_t u64_1; 170 int8_t i8_1, i8_2; 171 int16_t i16_1, i16_2; 172 int32_t i32_1, i32_2; 173 int64_t i64_1, i64_2; 174 } TestSimple; 175 176 /* Object instantiation, we are going to use it in more than one test */ 177 178 TestSimple obj_simple = { 179 .b_1 = true, 180 .b_2 = false, 181 .u8_1 = 130, 182 .u16_1 = 512, 183 .u32_1 = 70000, 184 .u64_1 = 12121212, 185 .i8_1 = 65, 186 .i8_2 = -65, 187 .i16_1 = 512, 188 .i16_2 = -512, 189 .i32_1 = 70000, 190 .i32_2 = -70000, 191 .i64_1 = 12121212, 192 .i64_2 = -12121212, 193 }; 194 195 /* Description of the values. If you add a primitive type 196 you are expected to add a test here */ 197 198 static const VMStateDescription vmstate_simple_primitive = { 199 .name = "simple/primitive", 200 .version_id = 1, 201 .minimum_version_id = 1, 202 .fields = (VMStateField[]) { 203 VMSTATE_BOOL(b_1, TestSimple), 204 VMSTATE_BOOL(b_2, TestSimple), 205 VMSTATE_UINT8(u8_1, TestSimple), 206 VMSTATE_UINT16(u16_1, TestSimple), 207 VMSTATE_UINT32(u32_1, TestSimple), 208 VMSTATE_UINT64(u64_1, TestSimple), 209 VMSTATE_INT8(i8_1, TestSimple), 210 VMSTATE_INT8(i8_2, TestSimple), 211 VMSTATE_INT16(i16_1, TestSimple), 212 VMSTATE_INT16(i16_2, TestSimple), 213 VMSTATE_INT32(i32_1, TestSimple), 214 VMSTATE_INT32(i32_2, TestSimple), 215 VMSTATE_INT64(i64_1, TestSimple), 216 VMSTATE_INT64(i64_2, TestSimple), 217 VMSTATE_END_OF_LIST() 218 } 219 }; 220 221 /* It describes what goes through the wire. Our tests are basically: 222 223 * save test 224 - save a struct a vmstate to a file 225 - read that file back (binary read, no vmstate) 226 - compare it with what we expect to be on the wire 227 * load test 228 - save to the file what we expect to be on the wire 229 - read struct back with vmstate in a different 230 - compare back with the original struct 231 */ 232 233 uint8_t wire_simple_primitive[] = { 234 /* b_1 */ 0x01, 235 /* b_2 */ 0x00, 236 /* u8_1 */ 0x82, 237 /* u16_1 */ 0x02, 0x00, 238 /* u32_1 */ 0x00, 0x01, 0x11, 0x70, 239 /* u64_1 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0xf4, 0x7c, 240 /* i8_1 */ 0x41, 241 /* i8_2 */ 0xbf, 242 /* i16_1 */ 0x02, 0x00, 243 /* i16_2 */ 0xfe, 0x0, 244 /* i32_1 */ 0x00, 0x01, 0x11, 0x70, 245 /* i32_2 */ 0xff, 0xfe, 0xee, 0x90, 246 /* i64_1 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0xf4, 0x7c, 247 /* i64_2 */ 0xff, 0xff, 0xff, 0xff, 0xff, 0x47, 0x0b, 0x84, 248 QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */ 249 }; 250 251 static void obj_simple_copy(void *target, void *source) 252 { 253 memcpy(target, source, sizeof(TestSimple)); 254 } 255 256 static void test_simple_primitive(void) 257 { 258 TestSimple obj, obj_clone; 259 260 memset(&obj, 0, sizeof(obj)); 261 save_vmstate(&vmstate_simple_primitive, &obj_simple); 262 263 compare_vmstate(wire_simple_primitive, sizeof(wire_simple_primitive)); 264 265 SUCCESS(load_vmstate(&vmstate_simple_primitive, &obj, &obj_clone, 266 obj_simple_copy, 1, wire_simple_primitive, 267 sizeof(wire_simple_primitive))); 268 269 #define FIELD_EQUAL(name) g_assert_cmpint(obj.name, ==, obj_simple.name) 270 271 FIELD_EQUAL(b_1); 272 FIELD_EQUAL(b_2); 273 FIELD_EQUAL(u8_1); 274 FIELD_EQUAL(u16_1); 275 FIELD_EQUAL(u32_1); 276 FIELD_EQUAL(u64_1); 277 FIELD_EQUAL(i8_1); 278 FIELD_EQUAL(i8_2); 279 FIELD_EQUAL(i16_1); 280 FIELD_EQUAL(i16_2); 281 FIELD_EQUAL(i32_1); 282 FIELD_EQUAL(i32_2); 283 FIELD_EQUAL(i64_1); 284 FIELD_EQUAL(i64_2); 285 } 286 287 typedef struct TestStruct { 288 uint32_t a, b, c, e; 289 uint64_t d, f; 290 bool skip_c_e; 291 } TestStruct; 292 293 static const VMStateDescription vmstate_versioned = { 294 .name = "test/versioned", 295 .version_id = 2, 296 .minimum_version_id = 1, 297 .fields = (VMStateField[]) { 298 VMSTATE_UINT32(a, TestStruct), 299 VMSTATE_UINT32_V(b, TestStruct, 2), /* Versioned field in the middle, so 300 * we catch bugs more easily. 301 */ 302 VMSTATE_UINT32(c, TestStruct), 303 VMSTATE_UINT64(d, TestStruct), 304 VMSTATE_UINT32_V(e, TestStruct, 2), 305 VMSTATE_UINT64_V(f, TestStruct, 2), 306 VMSTATE_END_OF_LIST() 307 } 308 }; 309 310 static void test_load_v1(void) 311 { 312 uint8_t buf[] = { 313 0, 0, 0, 10, /* a */ 314 0, 0, 0, 30, /* c */ 315 0, 0, 0, 0, 0, 0, 0, 40, /* d */ 316 QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */ 317 }; 318 save_buffer(buf, sizeof(buf)); 319 320 QEMUFile *loading = open_test_file(false); 321 TestStruct obj = { .b = 200, .e = 500, .f = 600 }; 322 vmstate_load_state(loading, &vmstate_versioned, &obj, 1); 323 g_assert(!qemu_file_get_error(loading)); 324 g_assert_cmpint(obj.a, ==, 10); 325 g_assert_cmpint(obj.b, ==, 200); 326 g_assert_cmpint(obj.c, ==, 30); 327 g_assert_cmpint(obj.d, ==, 40); 328 g_assert_cmpint(obj.e, ==, 500); 329 g_assert_cmpint(obj.f, ==, 600); 330 qemu_fclose(loading); 331 } 332 333 static void test_load_v2(void) 334 { 335 uint8_t buf[] = { 336 0, 0, 0, 10, /* a */ 337 0, 0, 0, 20, /* b */ 338 0, 0, 0, 30, /* c */ 339 0, 0, 0, 0, 0, 0, 0, 40, /* d */ 340 0, 0, 0, 50, /* e */ 341 0, 0, 0, 0, 0, 0, 0, 60, /* f */ 342 QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */ 343 }; 344 save_buffer(buf, sizeof(buf)); 345 346 QEMUFile *loading = open_test_file(false); 347 TestStruct obj; 348 vmstate_load_state(loading, &vmstate_versioned, &obj, 2); 349 g_assert_cmpint(obj.a, ==, 10); 350 g_assert_cmpint(obj.b, ==, 20); 351 g_assert_cmpint(obj.c, ==, 30); 352 g_assert_cmpint(obj.d, ==, 40); 353 g_assert_cmpint(obj.e, ==, 50); 354 g_assert_cmpint(obj.f, ==, 60); 355 qemu_fclose(loading); 356 } 357 358 static bool test_skip(void *opaque, int version_id) 359 { 360 TestStruct *t = (TestStruct *)opaque; 361 return !t->skip_c_e; 362 } 363 364 static const VMStateDescription vmstate_skipping = { 365 .name = "test/skip", 366 .version_id = 2, 367 .minimum_version_id = 1, 368 .fields = (VMStateField[]) { 369 VMSTATE_UINT32(a, TestStruct), 370 VMSTATE_UINT32(b, TestStruct), 371 VMSTATE_UINT32_TEST(c, TestStruct, test_skip), 372 VMSTATE_UINT64(d, TestStruct), 373 VMSTATE_UINT32_TEST(e, TestStruct, test_skip), 374 VMSTATE_UINT64_V(f, TestStruct, 2), 375 VMSTATE_END_OF_LIST() 376 } 377 }; 378 379 380 static void test_save_noskip(void) 381 { 382 QEMUFile *fsave = open_test_file(true); 383 TestStruct obj = { .a = 1, .b = 2, .c = 3, .d = 4, .e = 5, .f = 6, 384 .skip_c_e = false }; 385 int ret = vmstate_save_state(fsave, &vmstate_skipping, &obj, NULL); 386 g_assert(!ret); 387 g_assert(!qemu_file_get_error(fsave)); 388 389 uint8_t expected[] = { 390 0, 0, 0, 1, /* a */ 391 0, 0, 0, 2, /* b */ 392 0, 0, 0, 3, /* c */ 393 0, 0, 0, 0, 0, 0, 0, 4, /* d */ 394 0, 0, 0, 5, /* e */ 395 0, 0, 0, 0, 0, 0, 0, 6, /* f */ 396 }; 397 398 qemu_fclose(fsave); 399 compare_vmstate(expected, sizeof(expected)); 400 } 401 402 static void test_save_skip(void) 403 { 404 QEMUFile *fsave = open_test_file(true); 405 TestStruct obj = { .a = 1, .b = 2, .c = 3, .d = 4, .e = 5, .f = 6, 406 .skip_c_e = true }; 407 int ret = vmstate_save_state(fsave, &vmstate_skipping, &obj, NULL); 408 g_assert(!ret); 409 g_assert(!qemu_file_get_error(fsave)); 410 411 uint8_t expected[] = { 412 0, 0, 0, 1, /* a */ 413 0, 0, 0, 2, /* b */ 414 0, 0, 0, 0, 0, 0, 0, 4, /* d */ 415 0, 0, 0, 0, 0, 0, 0, 6, /* f */ 416 }; 417 418 qemu_fclose(fsave); 419 compare_vmstate(expected, sizeof(expected)); 420 } 421 422 static void test_load_noskip(void) 423 { 424 uint8_t buf[] = { 425 0, 0, 0, 10, /* a */ 426 0, 0, 0, 20, /* b */ 427 0, 0, 0, 30, /* c */ 428 0, 0, 0, 0, 0, 0, 0, 40, /* d */ 429 0, 0, 0, 50, /* e */ 430 0, 0, 0, 0, 0, 0, 0, 60, /* f */ 431 QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */ 432 }; 433 save_buffer(buf, sizeof(buf)); 434 435 QEMUFile *loading = open_test_file(false); 436 TestStruct obj = { .skip_c_e = false }; 437 vmstate_load_state(loading, &vmstate_skipping, &obj, 2); 438 g_assert(!qemu_file_get_error(loading)); 439 g_assert_cmpint(obj.a, ==, 10); 440 g_assert_cmpint(obj.b, ==, 20); 441 g_assert_cmpint(obj.c, ==, 30); 442 g_assert_cmpint(obj.d, ==, 40); 443 g_assert_cmpint(obj.e, ==, 50); 444 g_assert_cmpint(obj.f, ==, 60); 445 qemu_fclose(loading); 446 } 447 448 static void test_load_skip(void) 449 { 450 uint8_t buf[] = { 451 0, 0, 0, 10, /* a */ 452 0, 0, 0, 20, /* b */ 453 0, 0, 0, 0, 0, 0, 0, 40, /* d */ 454 0, 0, 0, 0, 0, 0, 0, 60, /* f */ 455 QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */ 456 }; 457 save_buffer(buf, sizeof(buf)); 458 459 QEMUFile *loading = open_test_file(false); 460 TestStruct obj = { .skip_c_e = true, .c = 300, .e = 500 }; 461 vmstate_load_state(loading, &vmstate_skipping, &obj, 2); 462 g_assert(!qemu_file_get_error(loading)); 463 g_assert_cmpint(obj.a, ==, 10); 464 g_assert_cmpint(obj.b, ==, 20); 465 g_assert_cmpint(obj.c, ==, 300); 466 g_assert_cmpint(obj.d, ==, 40); 467 g_assert_cmpint(obj.e, ==, 500); 468 g_assert_cmpint(obj.f, ==, 60); 469 qemu_fclose(loading); 470 } 471 472 typedef struct { 473 int32_t i; 474 } TestStructTriv; 475 476 const VMStateDescription vmsd_tst = { 477 .name = "test/tst", 478 .version_id = 1, 479 .minimum_version_id = 1, 480 .fields = (VMStateField[]) { 481 VMSTATE_INT32(i, TestStructTriv), 482 VMSTATE_END_OF_LIST() 483 } 484 }; 485 486 /* test array migration */ 487 488 #define AR_SIZE 4 489 490 typedef struct { 491 TestStructTriv *ar[AR_SIZE]; 492 } TestArrayOfPtrToStuct; 493 494 const VMStateDescription vmsd_arps = { 495 .name = "test/arps", 496 .version_id = 1, 497 .minimum_version_id = 1, 498 .fields = (VMStateField[]) { 499 VMSTATE_ARRAY_OF_POINTER_TO_STRUCT(ar, TestArrayOfPtrToStuct, 500 AR_SIZE, 0, vmsd_tst, TestStructTriv), 501 VMSTATE_END_OF_LIST() 502 } 503 }; 504 505 static uint8_t wire_arr_ptr_no0[] = { 506 0x00, 0x00, 0x00, 0x00, 507 0x00, 0x00, 0x00, 0x01, 508 0x00, 0x00, 0x00, 0x02, 509 0x00, 0x00, 0x00, 0x03, 510 QEMU_VM_EOF 511 }; 512 513 static void test_arr_ptr_str_no0_save(void) 514 { 515 TestStructTriv ar[AR_SIZE] = {{.i = 0}, {.i = 1}, {.i = 2}, {.i = 3} }; 516 TestArrayOfPtrToStuct sample = {.ar = {&ar[0], &ar[1], &ar[2], &ar[3]} }; 517 518 save_vmstate(&vmsd_arps, &sample); 519 compare_vmstate(wire_arr_ptr_no0, sizeof(wire_arr_ptr_no0)); 520 } 521 522 static void test_arr_ptr_str_no0_load(void) 523 { 524 TestStructTriv ar_gt[AR_SIZE] = {{.i = 0}, {.i = 1}, {.i = 2}, {.i = 3} }; 525 TestStructTriv ar[AR_SIZE] = {}; 526 TestArrayOfPtrToStuct obj = {.ar = {&ar[0], &ar[1], &ar[2], &ar[3]} }; 527 int idx; 528 529 save_buffer(wire_arr_ptr_no0, sizeof(wire_arr_ptr_no0)); 530 SUCCESS(load_vmstate_one(&vmsd_arps, &obj, 1, 531 wire_arr_ptr_no0, sizeof(wire_arr_ptr_no0))); 532 for (idx = 0; idx < AR_SIZE; ++idx) { 533 /* compare the target array ar with the ground truth array ar_gt */ 534 g_assert_cmpint(ar_gt[idx].i, ==, ar[idx].i); 535 } 536 } 537 538 static uint8_t wire_arr_ptr_0[] = { 539 0x00, 0x00, 0x00, 0x00, 540 VMS_NULLPTR_MARKER, 541 0x00, 0x00, 0x00, 0x02, 542 0x00, 0x00, 0x00, 0x03, 543 QEMU_VM_EOF 544 }; 545 546 static void test_arr_ptr_str_0_save(void) 547 { 548 TestStructTriv ar[AR_SIZE] = {{.i = 0}, {.i = 1}, {.i = 2}, {.i = 3} }; 549 TestArrayOfPtrToStuct sample = {.ar = {&ar[0], NULL, &ar[2], &ar[3]} }; 550 551 save_vmstate(&vmsd_arps, &sample); 552 compare_vmstate(wire_arr_ptr_0, sizeof(wire_arr_ptr_0)); 553 } 554 555 static void test_arr_ptr_str_0_load(void) 556 { 557 TestStructTriv ar_gt[AR_SIZE] = {{.i = 0}, {.i = 0}, {.i = 2}, {.i = 3} }; 558 TestStructTriv ar[AR_SIZE] = {}; 559 TestArrayOfPtrToStuct obj = {.ar = {&ar[0], NULL, &ar[2], &ar[3]} }; 560 int idx; 561 562 save_buffer(wire_arr_ptr_0, sizeof(wire_arr_ptr_0)); 563 SUCCESS(load_vmstate_one(&vmsd_arps, &obj, 1, 564 wire_arr_ptr_0, sizeof(wire_arr_ptr_0))); 565 for (idx = 0; idx < AR_SIZE; ++idx) { 566 /* compare the target array ar with the ground truth array ar_gt */ 567 g_assert_cmpint(ar_gt[idx].i, ==, ar[idx].i); 568 } 569 for (idx = 0; idx < AR_SIZE; ++idx) { 570 if (idx == 1) { 571 g_assert_cmpint((uintptr_t)(obj.ar[idx]), ==, 0); 572 } else { 573 g_assert_cmpint((uintptr_t)(obj.ar[idx]), !=, 0); 574 } 575 } 576 } 577 578 typedef struct TestArrayOfPtrToInt { 579 int32_t *ar[AR_SIZE]; 580 } TestArrayOfPtrToInt; 581 582 const VMStateDescription vmsd_arpp = { 583 .name = "test/arps", 584 .version_id = 1, 585 .minimum_version_id = 1, 586 .fields = (VMStateField[]) { 587 VMSTATE_ARRAY_OF_POINTER(ar, TestArrayOfPtrToInt, 588 AR_SIZE, 0, vmstate_info_int32, int32_t*), 589 VMSTATE_END_OF_LIST() 590 } 591 }; 592 593 static void test_arr_ptr_prim_0_save(void) 594 { 595 int32_t ar[AR_SIZE] = {0 , 1, 2, 3}; 596 TestArrayOfPtrToInt sample = {.ar = {&ar[0], NULL, &ar[2], &ar[3]} }; 597 598 save_vmstate(&vmsd_arpp, &sample); 599 compare_vmstate(wire_arr_ptr_0, sizeof(wire_arr_ptr_0)); 600 } 601 602 static void test_arr_ptr_prim_0_load(void) 603 { 604 int32_t ar_gt[AR_SIZE] = {0, 1, 2, 3}; 605 int32_t ar[AR_SIZE] = {3 , 42, 1, 0}; 606 TestArrayOfPtrToInt obj = {.ar = {&ar[0], NULL, &ar[2], &ar[3]} }; 607 int idx; 608 609 save_buffer(wire_arr_ptr_0, sizeof(wire_arr_ptr_0)); 610 SUCCESS(load_vmstate_one(&vmsd_arpp, &obj, 1, 611 wire_arr_ptr_0, sizeof(wire_arr_ptr_0))); 612 for (idx = 0; idx < AR_SIZE; ++idx) { 613 /* compare the target array ar with the ground truth array ar_gt */ 614 if (idx == 1) { 615 g_assert_cmpint(42, ==, ar[idx]); 616 } else { 617 g_assert_cmpint(ar_gt[idx], ==, ar[idx]); 618 } 619 } 620 } 621 622 /* test QTAILQ migration */ 623 typedef struct TestQtailqElement TestQtailqElement; 624 625 struct TestQtailqElement { 626 bool b; 627 uint8_t u8; 628 QTAILQ_ENTRY(TestQtailqElement) next; 629 }; 630 631 typedef struct TestQtailq { 632 int16_t i16; 633 QTAILQ_HEAD(TestQtailqHead, TestQtailqElement) q; 634 int32_t i32; 635 } TestQtailq; 636 637 static const VMStateDescription vmstate_q_element = { 638 .name = "test/queue-element", 639 .version_id = 1, 640 .minimum_version_id = 1, 641 .fields = (VMStateField[]) { 642 VMSTATE_BOOL(b, TestQtailqElement), 643 VMSTATE_UINT8(u8, TestQtailqElement), 644 VMSTATE_END_OF_LIST() 645 }, 646 }; 647 648 static const VMStateDescription vmstate_q = { 649 .name = "test/queue", 650 .version_id = 1, 651 .minimum_version_id = 1, 652 .fields = (VMStateField[]) { 653 VMSTATE_INT16(i16, TestQtailq), 654 VMSTATE_QTAILQ_V(q, TestQtailq, 1, vmstate_q_element, TestQtailqElement, 655 next), 656 VMSTATE_INT32(i32, TestQtailq), 657 VMSTATE_END_OF_LIST() 658 } 659 }; 660 661 uint8_t wire_q[] = { 662 /* i16 */ 0xfe, 0x0, 663 /* start of element 0 of q */ 0x01, 664 /* .b */ 0x01, 665 /* .u8 */ 0x82, 666 /* start of element 1 of q */ 0x01, 667 /* b */ 0x00, 668 /* u8 */ 0x41, 669 /* end of q */ 0x00, 670 /* i32 */ 0x00, 0x01, 0x11, 0x70, 671 QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */ 672 }; 673 674 static void test_save_q(void) 675 { 676 TestQtailq obj_q = { 677 .i16 = -512, 678 .i32 = 70000, 679 }; 680 681 TestQtailqElement obj_qe1 = { 682 .b = true, 683 .u8 = 130, 684 }; 685 686 TestQtailqElement obj_qe2 = { 687 .b = false, 688 .u8 = 65, 689 }; 690 691 QTAILQ_INIT(&obj_q.q); 692 QTAILQ_INSERT_TAIL(&obj_q.q, &obj_qe1, next); 693 QTAILQ_INSERT_TAIL(&obj_q.q, &obj_qe2, next); 694 695 save_vmstate(&vmstate_q, &obj_q); 696 compare_vmstate(wire_q, sizeof(wire_q)); 697 } 698 699 static void test_load_q(void) 700 { 701 TestQtailq obj_q = { 702 .i16 = -512, 703 .i32 = 70000, 704 }; 705 706 TestQtailqElement obj_qe1 = { 707 .b = true, 708 .u8 = 130, 709 }; 710 711 TestQtailqElement obj_qe2 = { 712 .b = false, 713 .u8 = 65, 714 }; 715 716 QTAILQ_INIT(&obj_q.q); 717 QTAILQ_INSERT_TAIL(&obj_q.q, &obj_qe1, next); 718 QTAILQ_INSERT_TAIL(&obj_q.q, &obj_qe2, next); 719 720 QEMUFile *fsave = open_test_file(true); 721 722 qemu_put_buffer(fsave, wire_q, sizeof(wire_q)); 723 g_assert(!qemu_file_get_error(fsave)); 724 qemu_fclose(fsave); 725 726 QEMUFile *fload = open_test_file(false); 727 TestQtailq tgt; 728 729 QTAILQ_INIT(&tgt.q); 730 vmstate_load_state(fload, &vmstate_q, &tgt, 1); 731 char eof = qemu_get_byte(fload); 732 g_assert(!qemu_file_get_error(fload)); 733 g_assert_cmpint(tgt.i16, ==, obj_q.i16); 734 g_assert_cmpint(tgt.i32, ==, obj_q.i32); 735 g_assert_cmpint(eof, ==, QEMU_VM_EOF); 736 737 TestQtailqElement *qele_from = QTAILQ_FIRST(&obj_q.q); 738 TestQtailqElement *qlast_from = QTAILQ_LAST(&obj_q.q, TestQtailqHead); 739 TestQtailqElement *qele_to = QTAILQ_FIRST(&tgt.q); 740 TestQtailqElement *qlast_to = QTAILQ_LAST(&tgt.q, TestQtailqHead); 741 742 while (1) { 743 g_assert_cmpint(qele_to->b, ==, qele_from->b); 744 g_assert_cmpint(qele_to->u8, ==, qele_from->u8); 745 if ((qele_from == qlast_from) || (qele_to == qlast_to)) { 746 break; 747 } 748 qele_from = QTAILQ_NEXT(qele_from, next); 749 qele_to = QTAILQ_NEXT(qele_to, next); 750 } 751 752 g_assert_cmpint((uintptr_t) qele_from, ==, (uintptr_t) qlast_from); 753 g_assert_cmpint((uintptr_t) qele_to, ==, (uintptr_t) qlast_to); 754 755 /* clean up */ 756 TestQtailqElement *qele; 757 while (!QTAILQ_EMPTY(&tgt.q)) { 758 qele = QTAILQ_LAST(&tgt.q, TestQtailqHead); 759 QTAILQ_REMOVE(&tgt.q, qele, next); 760 free(qele); 761 qele = NULL; 762 } 763 qemu_fclose(fload); 764 } 765 766 typedef struct TmpTestStruct { 767 TestStruct *parent; 768 int64_t diff; 769 } TmpTestStruct; 770 771 static int tmp_child_pre_save(void *opaque) 772 { 773 struct TmpTestStruct *tts = opaque; 774 775 tts->diff = tts->parent->b - tts->parent->a; 776 777 return 0; 778 } 779 780 static int tmp_child_post_load(void *opaque, int version_id) 781 { 782 struct TmpTestStruct *tts = opaque; 783 784 tts->parent->b = tts->parent->a + tts->diff; 785 786 return 0; 787 } 788 789 static const VMStateDescription vmstate_tmp_back_to_parent = { 790 .name = "test/tmp_child_parent", 791 .fields = (VMStateField[]) { 792 VMSTATE_UINT64(f, TestStruct), 793 VMSTATE_END_OF_LIST() 794 } 795 }; 796 797 static const VMStateDescription vmstate_tmp_child = { 798 .name = "test/tmp_child", 799 .pre_save = tmp_child_pre_save, 800 .post_load = tmp_child_post_load, 801 .fields = (VMStateField[]) { 802 VMSTATE_INT64(diff, TmpTestStruct), 803 VMSTATE_STRUCT_POINTER(parent, TmpTestStruct, 804 vmstate_tmp_back_to_parent, TestStruct), 805 VMSTATE_END_OF_LIST() 806 } 807 }; 808 809 static const VMStateDescription vmstate_with_tmp = { 810 .name = "test/with_tmp", 811 .version_id = 1, 812 .fields = (VMStateField[]) { 813 VMSTATE_UINT32(a, TestStruct), 814 VMSTATE_UINT64(d, TestStruct), 815 VMSTATE_WITH_TMP(TestStruct, TmpTestStruct, vmstate_tmp_child), 816 VMSTATE_END_OF_LIST() 817 } 818 }; 819 820 static void obj_tmp_copy(void *target, void *source) 821 { 822 memcpy(target, source, sizeof(TestStruct)); 823 } 824 825 static void test_tmp_struct(void) 826 { 827 TestStruct obj, obj_clone; 828 829 uint8_t const wire_with_tmp[] = { 830 /* u32 a */ 0x00, 0x00, 0x00, 0x02, 831 /* u64 d */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 832 /* diff */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 833 /* u64 f */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 834 QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */ 835 }; 836 837 memset(&obj, 0, sizeof(obj)); 838 obj.a = 2; 839 obj.b = 4; 840 obj.d = 1; 841 obj.f = 8; 842 save_vmstate(&vmstate_with_tmp, &obj); 843 844 compare_vmstate(wire_with_tmp, sizeof(wire_with_tmp)); 845 846 memset(&obj, 0, sizeof(obj)); 847 SUCCESS(load_vmstate(&vmstate_with_tmp, &obj, &obj_clone, 848 obj_tmp_copy, 1, wire_with_tmp, 849 sizeof(wire_with_tmp))); 850 g_assert_cmpint(obj.a, ==, 2); /* From top level vmsd */ 851 g_assert_cmpint(obj.b, ==, 4); /* from the post_load */ 852 g_assert_cmpint(obj.d, ==, 1); /* From top level vmsd */ 853 g_assert_cmpint(obj.f, ==, 8); /* From the child->parent */ 854 } 855 856 int main(int argc, char **argv) 857 { 858 temp_fd = mkstemp(temp_file); 859 860 module_call_init(MODULE_INIT_QOM); 861 862 setenv("QTEST_SILENT_ERRORS", "1", 1); 863 864 g_test_init(&argc, &argv, NULL); 865 g_test_add_func("/vmstate/simple/primitive", test_simple_primitive); 866 g_test_add_func("/vmstate/versioned/load/v1", test_load_v1); 867 g_test_add_func("/vmstate/versioned/load/v2", test_load_v2); 868 g_test_add_func("/vmstate/field_exists/load/noskip", test_load_noskip); 869 g_test_add_func("/vmstate/field_exists/load/skip", test_load_skip); 870 g_test_add_func("/vmstate/field_exists/save/noskip", test_save_noskip); 871 g_test_add_func("/vmstate/field_exists/save/skip", test_save_skip); 872 g_test_add_func("/vmstate/array/ptr/str/no0/save", 873 test_arr_ptr_str_no0_save); 874 g_test_add_func("/vmstate/array/ptr/str/no0/load", 875 test_arr_ptr_str_no0_load); 876 g_test_add_func("/vmstate/array/ptr/str/0/save", test_arr_ptr_str_0_save); 877 g_test_add_func("/vmstate/array/ptr/str/0/load", 878 test_arr_ptr_str_0_load); 879 g_test_add_func("/vmstate/array/ptr/prim/0/save", 880 test_arr_ptr_prim_0_save); 881 g_test_add_func("/vmstate/array/ptr/prim/0/load", 882 test_arr_ptr_prim_0_load); 883 g_test_add_func("/vmstate/qtailq/save/saveq", test_save_q); 884 g_test_add_func("/vmstate/qtailq/load/loadq", test_load_q); 885 g_test_add_func("/vmstate/tmp_struct", test_tmp_struct); 886 g_test_run(); 887 888 close(temp_fd); 889 unlink(temp_file); 890 891 return 0; 892 } 893