1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include "qemu/osdep.h"
26
27#include "../migration/migration.h"
28#include "migration/vmstate.h"
29#include "migration/qemu-file-types.h"
30#include "../migration/qemu-file.h"
31#include "../migration/qemu-file-channel.h"
32#include "../migration/savevm.h"
33#include "qemu/coroutine.h"
34#include "qemu/module.h"
35#include "io/channel-file.h"
36
37static char temp_file[] = "/tmp/vmst.test.XXXXXX";
38static int temp_fd;
39
40
41
42static 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
68static void save_vmstate(const VMStateDescription *desc, void *obj)
69{
70 QEMUFile *f = open_test_file(true);
71
72
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
80static 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
87static 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
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
99
100 SUCCESS(memcmp(result, wire, sizeof(result)));
101
102
103 qemu_get_byte(f);
104 g_assert_cmpint(qemu_file_get_error(f), ==, -EIO);
105
106 qemu_fclose(f);
107}
108
109static 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
131static 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
137 obj_copy(obj_clone, obj);
138 FAILURE(load_vmstate_one(desc, obj, version, wire, 0));
139
140
141
142
143 if (size > 3) {
144
145
146 obj_copy(obj, obj_clone);
147 FAILURE(load_vmstate_one(desc, obj, version, wire, size - 2));
148
149
150 obj_copy(obj, obj_clone);
151 FAILURE(load_vmstate_one(desc, obj, version, wire, size/2));
152
153
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
163
164typedef 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
177
178TestSimple 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
196
197
198static 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
222
223
224
225
226
227
228
229
230
231
232
233uint8_t wire_simple_primitive[] = {
234 0x01,
235 0x00,
236 0x82,
237 0x02, 0x00,
238 0x00, 0x01, 0x11, 0x70,
239 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0xf4, 0x7c,
240 0x41,
241 0xbf,
242 0x02, 0x00,
243 0xfe, 0x0,
244 0x00, 0x01, 0x11, 0x70,
245 0xff, 0xfe, 0xee, 0x90,
246 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0xf4, 0x7c,
247 0xff, 0xff, 0xff, 0xff, 0xff, 0x47, 0x0b, 0x84,
248 QEMU_VM_EOF,
249};
250
251static void obj_simple_copy(void *target, void *source)
252{
253 memcpy(target, source, sizeof(TestSimple));
254}
255
256static 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
287typedef struct TestSimpleArray {
288 uint16_t u16_1[3];
289} TestSimpleArray;
290
291
292
293TestSimpleArray obj_simple_arr = {
294 .u16_1 = { 0x42, 0x43, 0x44 },
295};
296
297
298
299
300static const VMStateDescription vmstate_simple_arr = {
301 .name = "simple/array",
302 .version_id = 1,
303 .minimum_version_id = 1,
304 .fields = (VMStateField[]) {
305 VMSTATE_UINT16_ARRAY(u16_1, TestSimpleArray, 3),
306 VMSTATE_END_OF_LIST()
307 }
308};
309
310uint8_t wire_simple_arr[] = {
311 0x00, 0x42,
312 0x00, 0x43,
313 0x00, 0x44,
314 QEMU_VM_EOF,
315};
316
317static void obj_simple_arr_copy(void *target, void *source)
318{
319 memcpy(target, source, sizeof(TestSimpleArray));
320}
321
322static void test_simple_array(void)
323{
324 TestSimpleArray obj, obj_clone;
325
326 memset(&obj, 0, sizeof(obj));
327 save_vmstate(&vmstate_simple_arr, &obj_simple_arr);
328
329 compare_vmstate(wire_simple_arr, sizeof(wire_simple_arr));
330
331 SUCCESS(load_vmstate(&vmstate_simple_arr, &obj, &obj_clone,
332 obj_simple_arr_copy, 1, wire_simple_arr,
333 sizeof(wire_simple_arr)));
334}
335
336typedef struct TestStruct {
337 uint32_t a, b, c, e;
338 uint64_t d, f;
339 bool skip_c_e;
340} TestStruct;
341
342static const VMStateDescription vmstate_versioned = {
343 .name = "test/versioned",
344 .version_id = 2,
345 .minimum_version_id = 1,
346 .fields = (VMStateField[]) {
347 VMSTATE_UINT32(a, TestStruct),
348 VMSTATE_UINT32_V(b, TestStruct, 2),
349
350
351 VMSTATE_UINT32(c, TestStruct),
352 VMSTATE_UINT64(d, TestStruct),
353 VMSTATE_UINT32_V(e, TestStruct, 2),
354 VMSTATE_UINT64_V(f, TestStruct, 2),
355 VMSTATE_END_OF_LIST()
356 }
357};
358
359static void test_load_v1(void)
360{
361 uint8_t buf[] = {
362 0, 0, 0, 10,
363 0, 0, 0, 30,
364 0, 0, 0, 0, 0, 0, 0, 40,
365 QEMU_VM_EOF,
366 };
367 save_buffer(buf, sizeof(buf));
368
369 QEMUFile *loading = open_test_file(false);
370 TestStruct obj = { .b = 200, .e = 500, .f = 600 };
371 vmstate_load_state(loading, &vmstate_versioned, &obj, 1);
372 g_assert(!qemu_file_get_error(loading));
373 g_assert_cmpint(obj.a, ==, 10);
374 g_assert_cmpint(obj.b, ==, 200);
375 g_assert_cmpint(obj.c, ==, 30);
376 g_assert_cmpint(obj.d, ==, 40);
377 g_assert_cmpint(obj.e, ==, 500);
378 g_assert_cmpint(obj.f, ==, 600);
379 qemu_fclose(loading);
380}
381
382static void test_load_v2(void)
383{
384 uint8_t buf[] = {
385 0, 0, 0, 10,
386 0, 0, 0, 20,
387 0, 0, 0, 30,
388 0, 0, 0, 0, 0, 0, 0, 40,
389 0, 0, 0, 50,
390 0, 0, 0, 0, 0, 0, 0, 60,
391 QEMU_VM_EOF,
392 };
393 save_buffer(buf, sizeof(buf));
394
395 QEMUFile *loading = open_test_file(false);
396 TestStruct obj;
397 vmstate_load_state(loading, &vmstate_versioned, &obj, 2);
398 g_assert_cmpint(obj.a, ==, 10);
399 g_assert_cmpint(obj.b, ==, 20);
400 g_assert_cmpint(obj.c, ==, 30);
401 g_assert_cmpint(obj.d, ==, 40);
402 g_assert_cmpint(obj.e, ==, 50);
403 g_assert_cmpint(obj.f, ==, 60);
404 qemu_fclose(loading);
405}
406
407static bool test_skip(void *opaque, int version_id)
408{
409 TestStruct *t = (TestStruct *)opaque;
410 return !t->skip_c_e;
411}
412
413static const VMStateDescription vmstate_skipping = {
414 .name = "test/skip",
415 .version_id = 2,
416 .minimum_version_id = 1,
417 .fields = (VMStateField[]) {
418 VMSTATE_UINT32(a, TestStruct),
419 VMSTATE_UINT32(b, TestStruct),
420 VMSTATE_UINT32_TEST(c, TestStruct, test_skip),
421 VMSTATE_UINT64(d, TestStruct),
422 VMSTATE_UINT32_TEST(e, TestStruct, test_skip),
423 VMSTATE_UINT64_V(f, TestStruct, 2),
424 VMSTATE_END_OF_LIST()
425 }
426};
427
428
429static void test_save_noskip(void)
430{
431 QEMUFile *fsave = open_test_file(true);
432 TestStruct obj = { .a = 1, .b = 2, .c = 3, .d = 4, .e = 5, .f = 6,
433 .skip_c_e = false };
434 int ret = vmstate_save_state(fsave, &vmstate_skipping, &obj, NULL);
435 g_assert(!ret);
436 g_assert(!qemu_file_get_error(fsave));
437
438 uint8_t expected[] = {
439 0, 0, 0, 1,
440 0, 0, 0, 2,
441 0, 0, 0, 3,
442 0, 0, 0, 0, 0, 0, 0, 4,
443 0, 0, 0, 5,
444 0, 0, 0, 0, 0, 0, 0, 6,
445 };
446
447 qemu_fclose(fsave);
448 compare_vmstate(expected, sizeof(expected));
449}
450
451static void test_save_skip(void)
452{
453 QEMUFile *fsave = open_test_file(true);
454 TestStruct obj = { .a = 1, .b = 2, .c = 3, .d = 4, .e = 5, .f = 6,
455 .skip_c_e = true };
456 int ret = vmstate_save_state(fsave, &vmstate_skipping, &obj, NULL);
457 g_assert(!ret);
458 g_assert(!qemu_file_get_error(fsave));
459
460 uint8_t expected[] = {
461 0, 0, 0, 1,
462 0, 0, 0, 2,
463 0, 0, 0, 0, 0, 0, 0, 4,
464 0, 0, 0, 0, 0, 0, 0, 6,
465 };
466
467 qemu_fclose(fsave);
468 compare_vmstate(expected, sizeof(expected));
469}
470
471static void test_load_noskip(void)
472{
473 uint8_t buf[] = {
474 0, 0, 0, 10,
475 0, 0, 0, 20,
476 0, 0, 0, 30,
477 0, 0, 0, 0, 0, 0, 0, 40,
478 0, 0, 0, 50,
479 0, 0, 0, 0, 0, 0, 0, 60,
480 QEMU_VM_EOF,
481 };
482 save_buffer(buf, sizeof(buf));
483
484 QEMUFile *loading = open_test_file(false);
485 TestStruct obj = { .skip_c_e = false };
486 vmstate_load_state(loading, &vmstate_skipping, &obj, 2);
487 g_assert(!qemu_file_get_error(loading));
488 g_assert_cmpint(obj.a, ==, 10);
489 g_assert_cmpint(obj.b, ==, 20);
490 g_assert_cmpint(obj.c, ==, 30);
491 g_assert_cmpint(obj.d, ==, 40);
492 g_assert_cmpint(obj.e, ==, 50);
493 g_assert_cmpint(obj.f, ==, 60);
494 qemu_fclose(loading);
495}
496
497static void test_load_skip(void)
498{
499 uint8_t buf[] = {
500 0, 0, 0, 10,
501 0, 0, 0, 20,
502 0, 0, 0, 0, 0, 0, 0, 40,
503 0, 0, 0, 0, 0, 0, 0, 60,
504 QEMU_VM_EOF,
505 };
506 save_buffer(buf, sizeof(buf));
507
508 QEMUFile *loading = open_test_file(false);
509 TestStruct obj = { .skip_c_e = true, .c = 300, .e = 500 };
510 vmstate_load_state(loading, &vmstate_skipping, &obj, 2);
511 g_assert(!qemu_file_get_error(loading));
512 g_assert_cmpint(obj.a, ==, 10);
513 g_assert_cmpint(obj.b, ==, 20);
514 g_assert_cmpint(obj.c, ==, 300);
515 g_assert_cmpint(obj.d, ==, 40);
516 g_assert_cmpint(obj.e, ==, 500);
517 g_assert_cmpint(obj.f, ==, 60);
518 qemu_fclose(loading);
519}
520
521typedef struct {
522 int32_t i;
523} TestStructTriv;
524
525const VMStateDescription vmsd_tst = {
526 .name = "test/tst",
527 .version_id = 1,
528 .minimum_version_id = 1,
529 .fields = (VMStateField[]) {
530 VMSTATE_INT32(i, TestStructTriv),
531 VMSTATE_END_OF_LIST()
532 }
533};
534
535
536
537#define AR_SIZE 4
538
539typedef struct {
540 TestStructTriv *ar[AR_SIZE];
541} TestArrayOfPtrToStuct;
542
543const VMStateDescription vmsd_arps = {
544 .name = "test/arps",
545 .version_id = 1,
546 .minimum_version_id = 1,
547 .fields = (VMStateField[]) {
548 VMSTATE_ARRAY_OF_POINTER_TO_STRUCT(ar, TestArrayOfPtrToStuct,
549 AR_SIZE, 0, vmsd_tst, TestStructTriv),
550 VMSTATE_END_OF_LIST()
551 }
552};
553
554static uint8_t wire_arr_ptr_no0[] = {
555 0x00, 0x00, 0x00, 0x00,
556 0x00, 0x00, 0x00, 0x01,
557 0x00, 0x00, 0x00, 0x02,
558 0x00, 0x00, 0x00, 0x03,
559 QEMU_VM_EOF
560};
561
562static void test_arr_ptr_str_no0_save(void)
563{
564 TestStructTriv ar[AR_SIZE] = {{.i = 0}, {.i = 1}, {.i = 2}, {.i = 3} };
565 TestArrayOfPtrToStuct sample = {.ar = {&ar[0], &ar[1], &ar[2], &ar[3]} };
566
567 save_vmstate(&vmsd_arps, &sample);
568 compare_vmstate(wire_arr_ptr_no0, sizeof(wire_arr_ptr_no0));
569}
570
571static void test_arr_ptr_str_no0_load(void)
572{
573 TestStructTriv ar_gt[AR_SIZE] = {{.i = 0}, {.i = 1}, {.i = 2}, {.i = 3} };
574 TestStructTriv ar[AR_SIZE] = {};
575 TestArrayOfPtrToStuct obj = {.ar = {&ar[0], &ar[1], &ar[2], &ar[3]} };
576 int idx;
577
578 save_buffer(wire_arr_ptr_no0, sizeof(wire_arr_ptr_no0));
579 SUCCESS(load_vmstate_one(&vmsd_arps, &obj, 1,
580 wire_arr_ptr_no0, sizeof(wire_arr_ptr_no0)));
581 for (idx = 0; idx < AR_SIZE; ++idx) {
582
583 g_assert_cmpint(ar_gt[idx].i, ==, ar[idx].i);
584 }
585}
586
587static uint8_t wire_arr_ptr_0[] = {
588 0x00, 0x00, 0x00, 0x00,
589 VMS_NULLPTR_MARKER,
590 0x00, 0x00, 0x00, 0x02,
591 0x00, 0x00, 0x00, 0x03,
592 QEMU_VM_EOF
593};
594
595static void test_arr_ptr_str_0_save(void)
596{
597 TestStructTriv ar[AR_SIZE] = {{.i = 0}, {.i = 1}, {.i = 2}, {.i = 3} };
598 TestArrayOfPtrToStuct sample = {.ar = {&ar[0], NULL, &ar[2], &ar[3]} };
599
600 save_vmstate(&vmsd_arps, &sample);
601 compare_vmstate(wire_arr_ptr_0, sizeof(wire_arr_ptr_0));
602}
603
604static void test_arr_ptr_str_0_load(void)
605{
606 TestStructTriv ar_gt[AR_SIZE] = {{.i = 0}, {.i = 0}, {.i = 2}, {.i = 3} };
607 TestStructTriv ar[AR_SIZE] = {};
608 TestArrayOfPtrToStuct obj = {.ar = {&ar[0], NULL, &ar[2], &ar[3]} };
609 int idx;
610
611 save_buffer(wire_arr_ptr_0, sizeof(wire_arr_ptr_0));
612 SUCCESS(load_vmstate_one(&vmsd_arps, &obj, 1,
613 wire_arr_ptr_0, sizeof(wire_arr_ptr_0)));
614 for (idx = 0; idx < AR_SIZE; ++idx) {
615
616 g_assert_cmpint(ar_gt[idx].i, ==, ar[idx].i);
617 }
618 for (idx = 0; idx < AR_SIZE; ++idx) {
619 if (idx == 1) {
620 g_assert_cmpint((uintptr_t)(obj.ar[idx]), ==, 0);
621 } else {
622 g_assert_cmpint((uintptr_t)(obj.ar[idx]), !=, 0);
623 }
624 }
625}
626
627typedef struct TestArrayOfPtrToInt {
628 int32_t *ar[AR_SIZE];
629} TestArrayOfPtrToInt;
630
631const VMStateDescription vmsd_arpp = {
632 .name = "test/arps",
633 .version_id = 1,
634 .minimum_version_id = 1,
635 .fields = (VMStateField[]) {
636 VMSTATE_ARRAY_OF_POINTER(ar, TestArrayOfPtrToInt,
637 AR_SIZE, 0, vmstate_info_int32, int32_t*),
638 VMSTATE_END_OF_LIST()
639 }
640};
641
642static void test_arr_ptr_prim_0_save(void)
643{
644 int32_t ar[AR_SIZE] = {0 , 1, 2, 3};
645 TestArrayOfPtrToInt sample = {.ar = {&ar[0], NULL, &ar[2], &ar[3]} };
646
647 save_vmstate(&vmsd_arpp, &sample);
648 compare_vmstate(wire_arr_ptr_0, sizeof(wire_arr_ptr_0));
649}
650
651static void test_arr_ptr_prim_0_load(void)
652{
653 int32_t ar_gt[AR_SIZE] = {0, 1, 2, 3};
654 int32_t ar[AR_SIZE] = {3 , 42, 1, 0};
655 TestArrayOfPtrToInt obj = {.ar = {&ar[0], NULL, &ar[2], &ar[3]} };
656 int idx;
657
658 save_buffer(wire_arr_ptr_0, sizeof(wire_arr_ptr_0));
659 SUCCESS(load_vmstate_one(&vmsd_arpp, &obj, 1,
660 wire_arr_ptr_0, sizeof(wire_arr_ptr_0)));
661 for (idx = 0; idx < AR_SIZE; ++idx) {
662
663 if (idx == 1) {
664 g_assert_cmpint(42, ==, ar[idx]);
665 } else {
666 g_assert_cmpint(ar_gt[idx], ==, ar[idx]);
667 }
668 }
669}
670
671
672typedef struct TestQtailqElement TestQtailqElement;
673
674struct TestQtailqElement {
675 bool b;
676 uint8_t u8;
677 QTAILQ_ENTRY(TestQtailqElement) next;
678};
679
680typedef struct TestQtailq {
681 int16_t i16;
682 QTAILQ_HEAD(, TestQtailqElement) q;
683 int32_t i32;
684} TestQtailq;
685
686static const VMStateDescription vmstate_q_element = {
687 .name = "test/queue-element",
688 .version_id = 1,
689 .minimum_version_id = 1,
690 .fields = (VMStateField[]) {
691 VMSTATE_BOOL(b, TestQtailqElement),
692 VMSTATE_UINT8(u8, TestQtailqElement),
693 VMSTATE_END_OF_LIST()
694 },
695};
696
697static const VMStateDescription vmstate_q = {
698 .name = "test/queue",
699 .version_id = 1,
700 .minimum_version_id = 1,
701 .fields = (VMStateField[]) {
702 VMSTATE_INT16(i16, TestQtailq),
703 VMSTATE_QTAILQ_V(q, TestQtailq, 1, vmstate_q_element, TestQtailqElement,
704 next),
705 VMSTATE_INT32(i32, TestQtailq),
706 VMSTATE_END_OF_LIST()
707 }
708};
709
710uint8_t wire_q[] = {
711 0xfe, 0x0,
712 0x01,
713 0x01,
714 0x82,
715 0x01,
716 0x00,
717 0x41,
718 0x00,
719 0x00, 0x01, 0x11, 0x70,
720 QEMU_VM_EOF,
721};
722
723static void test_save_q(void)
724{
725 TestQtailq obj_q = {
726 .i16 = -512,
727 .i32 = 70000,
728 };
729
730 TestQtailqElement obj_qe1 = {
731 .b = true,
732 .u8 = 130,
733 };
734
735 TestQtailqElement obj_qe2 = {
736 .b = false,
737 .u8 = 65,
738 };
739
740 QTAILQ_INIT(&obj_q.q);
741 QTAILQ_INSERT_TAIL(&obj_q.q, &obj_qe1, next);
742 QTAILQ_INSERT_TAIL(&obj_q.q, &obj_qe2, next);
743
744 save_vmstate(&vmstate_q, &obj_q);
745 compare_vmstate(wire_q, sizeof(wire_q));
746}
747
748static void test_load_q(void)
749{
750 TestQtailq obj_q = {
751 .i16 = -512,
752 .i32 = 70000,
753 };
754
755 TestQtailqElement obj_qe1 = {
756 .b = true,
757 .u8 = 130,
758 };
759
760 TestQtailqElement obj_qe2 = {
761 .b = false,
762 .u8 = 65,
763 };
764
765 QTAILQ_INIT(&obj_q.q);
766 QTAILQ_INSERT_TAIL(&obj_q.q, &obj_qe1, next);
767 QTAILQ_INSERT_TAIL(&obj_q.q, &obj_qe2, next);
768
769 QEMUFile *fsave = open_test_file(true);
770
771 qemu_put_buffer(fsave, wire_q, sizeof(wire_q));
772 g_assert(!qemu_file_get_error(fsave));
773 qemu_fclose(fsave);
774
775 QEMUFile *fload = open_test_file(false);
776 TestQtailq tgt;
777
778 QTAILQ_INIT(&tgt.q);
779 vmstate_load_state(fload, &vmstate_q, &tgt, 1);
780 char eof = qemu_get_byte(fload);
781 g_assert(!qemu_file_get_error(fload));
782 g_assert_cmpint(tgt.i16, ==, obj_q.i16);
783 g_assert_cmpint(tgt.i32, ==, obj_q.i32);
784 g_assert_cmpint(eof, ==, QEMU_VM_EOF);
785
786 TestQtailqElement *qele_from = QTAILQ_FIRST(&obj_q.q);
787 TestQtailqElement *qlast_from = QTAILQ_LAST(&obj_q.q);
788 TestQtailqElement *qele_to = QTAILQ_FIRST(&tgt.q);
789 TestQtailqElement *qlast_to = QTAILQ_LAST(&tgt.q);
790
791 while (1) {
792 g_assert_cmpint(qele_to->b, ==, qele_from->b);
793 g_assert_cmpint(qele_to->u8, ==, qele_from->u8);
794 if ((qele_from == qlast_from) || (qele_to == qlast_to)) {
795 break;
796 }
797 qele_from = QTAILQ_NEXT(qele_from, next);
798 qele_to = QTAILQ_NEXT(qele_to, next);
799 }
800
801 g_assert_cmpint((uintptr_t) qele_from, ==, (uintptr_t) qlast_from);
802 g_assert_cmpint((uintptr_t) qele_to, ==, (uintptr_t) qlast_to);
803
804
805 TestQtailqElement *qele;
806 while (!QTAILQ_EMPTY(&tgt.q)) {
807 qele = QTAILQ_LAST(&tgt.q);
808 QTAILQ_REMOVE(&tgt.q, qele, next);
809 free(qele);
810 qele = NULL;
811 }
812 qemu_fclose(fload);
813}
814
815
816typedef struct TestGTreeInterval {
817 uint64_t low;
818 uint64_t high;
819} TestGTreeInterval;
820
821#define VMSTATE_INTERVAL \
822{ \
823 .name = "interval", \
824 .version_id = 1, \
825 .minimum_version_id = 1, \
826 .fields = (VMStateField[]) { \
827 VMSTATE_UINT64(low, TestGTreeInterval), \
828 VMSTATE_UINT64(high, TestGTreeInterval), \
829 VMSTATE_END_OF_LIST() \
830 } \
831}
832
833
834typedef struct TestGTreeMapping {
835 uint64_t phys_addr;
836 uint32_t flags;
837} TestGTreeMapping;
838
839#define VMSTATE_MAPPING \
840{ \
841 .name = "mapping", \
842 .version_id = 1, \
843 .minimum_version_id = 1, \
844 .fields = (VMStateField[]) { \
845 VMSTATE_UINT64(phys_addr, TestGTreeMapping), \
846 VMSTATE_UINT32(flags, TestGTreeMapping), \
847 VMSTATE_END_OF_LIST() \
848 }, \
849}
850
851static const VMStateDescription vmstate_interval_mapping[2] = {
852 VMSTATE_MAPPING,
853 VMSTATE_INTERVAL
854};
855
856typedef struct TestGTreeDomain {
857 int32_t id;
858 GTree *mappings;
859} TestGTreeDomain;
860
861typedef struct TestGTreeIOMMU {
862 int32_t id;
863 GTree *domains;
864} TestGTreeIOMMU;
865
866
867static gint interval_cmp(gconstpointer a, gconstpointer b, gpointer user_data)
868{
869 TestGTreeInterval *inta = (TestGTreeInterval *)a;
870 TestGTreeInterval *intb = (TestGTreeInterval *)b;
871
872 if (inta->high < intb->low) {
873 return -1;
874 } else if (intb->high < inta->low) {
875 return 1;
876 } else {
877 return 0;
878 }
879}
880
881
882static gint int_cmp(gconstpointer a, gconstpointer b, gpointer user_data)
883{
884 uint ua = GPOINTER_TO_UINT(a);
885 uint ub = GPOINTER_TO_UINT(b);
886 return (ua > ub) - (ua < ub);
887}
888
889static void destroy_domain(gpointer data)
890{
891 TestGTreeDomain *domain = (TestGTreeDomain *)data;
892
893 g_tree_destroy(domain->mappings);
894 g_free(domain);
895}
896
897static int domain_preload(void *opaque)
898{
899 TestGTreeDomain *domain = opaque;
900
901 domain->mappings = g_tree_new_full((GCompareDataFunc)interval_cmp,
902 NULL, g_free, g_free);
903 return 0;
904}
905
906static int iommu_preload(void *opaque)
907{
908 TestGTreeIOMMU *iommu = opaque;
909
910 iommu->domains = g_tree_new_full((GCompareDataFunc)int_cmp,
911 NULL, NULL, destroy_domain);
912 return 0;
913}
914
915static const VMStateDescription vmstate_domain = {
916 .name = "domain",
917 .version_id = 1,
918 .minimum_version_id = 1,
919 .pre_load = domain_preload,
920 .fields = (VMStateField[]) {
921 VMSTATE_INT32(id, TestGTreeDomain),
922 VMSTATE_GTREE_V(mappings, TestGTreeDomain, 1,
923 vmstate_interval_mapping,
924 TestGTreeInterval, TestGTreeMapping),
925 VMSTATE_END_OF_LIST()
926 }
927};
928
929static const VMStateDescription vmstate_iommu = {
930 .name = "iommu",
931 .version_id = 1,
932 .minimum_version_id = 1,
933 .pre_load = iommu_preload,
934 .fields = (VMStateField[]) {
935 VMSTATE_INT32(id, TestGTreeIOMMU),
936 VMSTATE_GTREE_DIRECT_KEY_V(domains, TestGTreeIOMMU, 1,
937 &vmstate_domain, TestGTreeDomain),
938 VMSTATE_END_OF_LIST()
939 }
940};
941
942uint8_t first_domain_dump[] = {
943
944 0x00, 0x0, 0x0, 0x6,
945 0x00, 0x0, 0x0, 0x2,
946 0x1,
947
948 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
949 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF,
950
951 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x00,
952 0x00, 0x00, 0x00, 0x01,
953 0x1,
954
955 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,
956 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4F, 0xFF,
957
958 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00,
959 0x00, 0x00, 0x00, 0x02,
960 0x0,
961 QEMU_VM_EOF,
962};
963
964static TestGTreeDomain *create_first_domain(void)
965{
966 TestGTreeDomain *domain;
967 TestGTreeMapping *map_a, *map_b;
968 TestGTreeInterval *a, *b;
969
970 domain = g_malloc0(sizeof(TestGTreeDomain));
971 domain->id = 6;
972
973 a = g_malloc0(sizeof(TestGTreeInterval));
974 a->low = 0x1000;
975 a->high = 0x1FFF;
976
977 b = g_malloc0(sizeof(TestGTreeInterval));
978 b->low = 0x4000;
979 b->high = 0x4FFF;
980
981 map_a = g_malloc0(sizeof(TestGTreeMapping));
982 map_a->phys_addr = 0xa000;
983 map_a->flags = 1;
984
985 map_b = g_malloc0(sizeof(TestGTreeMapping));
986 map_b->phys_addr = 0xe0000;
987 map_b->flags = 2;
988
989 domain->mappings = g_tree_new_full((GCompareDataFunc)interval_cmp, NULL,
990 (GDestroyNotify)g_free,
991 (GDestroyNotify)g_free);
992 g_tree_insert(domain->mappings, a, map_a);
993 g_tree_insert(domain->mappings, b, map_b);
994 return domain;
995}
996
997static void test_gtree_save_domain(void)
998{
999 TestGTreeDomain *first_domain = create_first_domain();
1000
1001 save_vmstate(&vmstate_domain, first_domain);
1002 compare_vmstate(first_domain_dump, sizeof(first_domain_dump));
1003 destroy_domain(first_domain);
1004}
1005
1006struct match_node_data {
1007 GTree *tree;
1008 gpointer key;
1009 gpointer value;
1010};
1011
1012struct tree_cmp_data {
1013 GTree *tree1;
1014 GTree *tree2;
1015 GTraverseFunc match_node;
1016};
1017
1018static gboolean match_interval_mapping_node(gpointer key,
1019 gpointer value, gpointer data)
1020{
1021 TestGTreeMapping *map_a, *map_b;
1022 TestGTreeInterval *a, *b;
1023 struct match_node_data *d = (struct match_node_data *)data;
1024 char *str = g_strdup_printf("dest");
1025
1026 g_free(str);
1027 a = (TestGTreeInterval *)key;
1028 b = (TestGTreeInterval *)d->key;
1029
1030 map_a = (TestGTreeMapping *)value;
1031 map_b = (TestGTreeMapping *)d->value;
1032
1033 assert(a->low == b->low);
1034 assert(a->high == b->high);
1035 assert(map_a->phys_addr == map_b->phys_addr);
1036 assert(map_a->flags == map_b->flags);
1037 g_tree_remove(d->tree, key);
1038 return true;
1039}
1040
1041static gboolean diff_tree(gpointer key, gpointer value, gpointer data)
1042{
1043 struct tree_cmp_data *tp = (struct tree_cmp_data *)data;
1044 struct match_node_data d = {tp->tree2, key, value};
1045
1046 g_tree_foreach(tp->tree2, tp->match_node, &d);
1047 g_tree_remove(tp->tree1, key);
1048 return false;
1049}
1050
1051static void compare_trees(GTree *tree1, GTree *tree2,
1052 GTraverseFunc function)
1053{
1054 struct tree_cmp_data tp = {tree1, tree2, function};
1055
1056 g_tree_foreach(tree1, diff_tree, &tp);
1057 assert(g_tree_nnodes(tree1) == 0);
1058 assert(g_tree_nnodes(tree2) == 0);
1059}
1060
1061static void diff_domain(TestGTreeDomain *d1, TestGTreeDomain *d2)
1062{
1063 assert(d1->id == d2->id);
1064 compare_trees(d1->mappings, d2->mappings, match_interval_mapping_node);
1065}
1066
1067static gboolean match_domain_node(gpointer key, gpointer value, gpointer data)
1068{
1069 uint64_t id1, id2;
1070 TestGTreeDomain *d1, *d2;
1071 struct match_node_data *d = (struct match_node_data *)data;
1072
1073 id1 = (uint64_t)(uintptr_t)key;
1074 id2 = (uint64_t)(uintptr_t)d->key;
1075 d1 = (TestGTreeDomain *)value;
1076 d2 = (TestGTreeDomain *)d->value;
1077 assert(id1 == id2);
1078 diff_domain(d1, d2);
1079 g_tree_remove(d->tree, key);
1080 return true;
1081}
1082
1083static void diff_iommu(TestGTreeIOMMU *iommu1, TestGTreeIOMMU *iommu2)
1084{
1085 assert(iommu1->id == iommu2->id);
1086 compare_trees(iommu1->domains, iommu2->domains, match_domain_node);
1087}
1088
1089static void test_gtree_load_domain(void)
1090{
1091 TestGTreeDomain *dest_domain = g_malloc0(sizeof(TestGTreeDomain));
1092 TestGTreeDomain *orig_domain = create_first_domain();
1093 QEMUFile *fload, *fsave;
1094 char eof;
1095
1096 fsave = open_test_file(true);
1097 qemu_put_buffer(fsave, first_domain_dump, sizeof(first_domain_dump));
1098 g_assert(!qemu_file_get_error(fsave));
1099 qemu_fclose(fsave);
1100
1101 fload = open_test_file(false);
1102
1103 vmstate_load_state(fload, &vmstate_domain, dest_domain, 1);
1104 eof = qemu_get_byte(fload);
1105 g_assert(!qemu_file_get_error(fload));
1106 g_assert_cmpint(orig_domain->id, ==, dest_domain->id);
1107 g_assert_cmpint(eof, ==, QEMU_VM_EOF);
1108
1109 diff_domain(orig_domain, dest_domain);
1110 destroy_domain(orig_domain);
1111 destroy_domain(dest_domain);
1112 qemu_fclose(fload);
1113}
1114
1115uint8_t iommu_dump[] = {
1116
1117 0x00, 0x0, 0x0, 0x7,
1118 0x00, 0x0, 0x0, 0x2,
1119 0x1,
1120 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x0, 0x5,
1121 0x00, 0x0, 0x0, 0x5,
1122 0x00, 0x0, 0x0, 0x1,
1123 0x1,
1124
1125 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
1126 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF,
1127
1128 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00,
1129 0x00, 0x0, 0x0, 0x3,
1130 0x0,
1131 0x1,
1132 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x0, 0x6,
1133 0x00, 0x0, 0x0, 0x6,
1134 0x00, 0x0, 0x0, 0x2,
1135 0x1,
1136
1137 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
1138 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF,
1139
1140 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x00,
1141 0x00, 0x00, 0x00, 0x01,
1142 0x1,
1143
1144 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,
1145 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4F, 0xFF,
1146
1147 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00,
1148 0x00, 0x00, 0x00, 0x02,
1149 0x0,
1150 0x0,
1151 QEMU_VM_EOF,
1152};
1153
1154static TestGTreeIOMMU *create_iommu(void)
1155{
1156 TestGTreeIOMMU *iommu = g_malloc0(sizeof(TestGTreeIOMMU));
1157 TestGTreeDomain *first_domain = create_first_domain();
1158 TestGTreeDomain *second_domain;
1159 TestGTreeMapping *map_c;
1160 TestGTreeInterval *c;
1161
1162 iommu->id = 7;
1163 iommu->domains = g_tree_new_full((GCompareDataFunc)int_cmp, NULL,
1164 NULL,
1165 destroy_domain);
1166
1167 second_domain = g_malloc0(sizeof(TestGTreeDomain));
1168 second_domain->id = 5;
1169 second_domain->mappings = g_tree_new_full((GCompareDataFunc)interval_cmp,
1170 NULL,
1171 (GDestroyNotify)g_free,
1172 (GDestroyNotify)g_free);
1173
1174 g_tree_insert(iommu->domains, GUINT_TO_POINTER(6), first_domain);
1175 g_tree_insert(iommu->domains, (gpointer)0x0000000000000005, second_domain);
1176
1177 c = g_malloc0(sizeof(TestGTreeInterval));
1178 c->low = 0x1000000;
1179 c->high = 0x1FFFFFF;
1180
1181 map_c = g_malloc0(sizeof(TestGTreeMapping));
1182 map_c->phys_addr = 0xF000000;
1183 map_c->flags = 0x3;
1184
1185 g_tree_insert(second_domain->mappings, c, map_c);
1186 return iommu;
1187}
1188
1189static void destroy_iommu(TestGTreeIOMMU *iommu)
1190{
1191 g_tree_destroy(iommu->domains);
1192 g_free(iommu);
1193}
1194
1195static void test_gtree_save_iommu(void)
1196{
1197 TestGTreeIOMMU *iommu = create_iommu();
1198
1199 save_vmstate(&vmstate_iommu, iommu);
1200 compare_vmstate(iommu_dump, sizeof(iommu_dump));
1201 destroy_iommu(iommu);
1202}
1203
1204static void test_gtree_load_iommu(void)
1205{
1206 TestGTreeIOMMU *dest_iommu = g_malloc0(sizeof(TestGTreeIOMMU));
1207 TestGTreeIOMMU *orig_iommu = create_iommu();
1208 QEMUFile *fsave, *fload;
1209 char eof;
1210 int ret;
1211
1212 fsave = open_test_file(true);
1213 qemu_put_buffer(fsave, iommu_dump, sizeof(iommu_dump));
1214 g_assert(!qemu_file_get_error(fsave));
1215 qemu_fclose(fsave);
1216
1217 fload = open_test_file(false);
1218 vmstate_load_state(fload, &vmstate_iommu, dest_iommu, 1);
1219 ret = qemu_file_get_error(fload);
1220 eof = qemu_get_byte(fload);
1221 ret = qemu_file_get_error(fload);
1222 g_assert(!ret);
1223 g_assert_cmpint(orig_iommu->id, ==, dest_iommu->id);
1224 g_assert_cmpint(eof, ==, QEMU_VM_EOF);
1225
1226 diff_iommu(orig_iommu, dest_iommu);
1227 destroy_iommu(orig_iommu);
1228 destroy_iommu(dest_iommu);
1229 qemu_fclose(fload);
1230}
1231
1232typedef struct TmpTestStruct {
1233 TestStruct *parent;
1234 int64_t diff;
1235} TmpTestStruct;
1236
1237static int tmp_child_pre_save(void *opaque)
1238{
1239 struct TmpTestStruct *tts = opaque;
1240
1241 tts->diff = tts->parent->b - tts->parent->a;
1242
1243 return 0;
1244}
1245
1246static int tmp_child_post_load(void *opaque, int version_id)
1247{
1248 struct TmpTestStruct *tts = opaque;
1249
1250 tts->parent->b = tts->parent->a + tts->diff;
1251
1252 return 0;
1253}
1254
1255static const VMStateDescription vmstate_tmp_back_to_parent = {
1256 .name = "test/tmp_child_parent",
1257 .fields = (VMStateField[]) {
1258 VMSTATE_UINT64(f, TestStruct),
1259 VMSTATE_END_OF_LIST()
1260 }
1261};
1262
1263static const VMStateDescription vmstate_tmp_child = {
1264 .name = "test/tmp_child",
1265 .pre_save = tmp_child_pre_save,
1266 .post_load = tmp_child_post_load,
1267 .fields = (VMStateField[]) {
1268 VMSTATE_INT64(diff, TmpTestStruct),
1269 VMSTATE_STRUCT_POINTER(parent, TmpTestStruct,
1270 vmstate_tmp_back_to_parent, TestStruct),
1271 VMSTATE_END_OF_LIST()
1272 }
1273};
1274
1275static const VMStateDescription vmstate_with_tmp = {
1276 .name = "test/with_tmp",
1277 .version_id = 1,
1278 .fields = (VMStateField[]) {
1279 VMSTATE_UINT32(a, TestStruct),
1280 VMSTATE_UINT64(d, TestStruct),
1281 VMSTATE_WITH_TMP(TestStruct, TmpTestStruct, vmstate_tmp_child),
1282 VMSTATE_END_OF_LIST()
1283 }
1284};
1285
1286static void obj_tmp_copy(void *target, void *source)
1287{
1288 memcpy(target, source, sizeof(TestStruct));
1289}
1290
1291static void test_tmp_struct(void)
1292{
1293 TestStruct obj, obj_clone;
1294
1295 uint8_t const wire_with_tmp[] = {
1296 0x00, 0x00, 0x00, 0x02,
1297 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
1298 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
1299 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
1300 QEMU_VM_EOF,
1301 };
1302
1303 memset(&obj, 0, sizeof(obj));
1304 obj.a = 2;
1305 obj.b = 4;
1306 obj.d = 1;
1307 obj.f = 8;
1308 save_vmstate(&vmstate_with_tmp, &obj);
1309
1310 compare_vmstate(wire_with_tmp, sizeof(wire_with_tmp));
1311
1312 memset(&obj, 0, sizeof(obj));
1313 SUCCESS(load_vmstate(&vmstate_with_tmp, &obj, &obj_clone,
1314 obj_tmp_copy, 1, wire_with_tmp,
1315 sizeof(wire_with_tmp)));
1316 g_assert_cmpint(obj.a, ==, 2);
1317 g_assert_cmpint(obj.b, ==, 4);
1318 g_assert_cmpint(obj.d, ==, 1);
1319 g_assert_cmpint(obj.f, ==, 8);
1320}
1321
1322int main(int argc, char **argv)
1323{
1324 temp_fd = mkstemp(temp_file);
1325
1326 module_call_init(MODULE_INIT_QOM);
1327
1328 setenv("QTEST_SILENT_ERRORS", "1", 1);
1329
1330 g_test_init(&argc, &argv, NULL);
1331 g_test_add_func("/vmstate/simple/primitive", test_simple_primitive);
1332 g_test_add_func("/vmstate/simple/array", test_simple_array);
1333 g_test_add_func("/vmstate/versioned/load/v1", test_load_v1);
1334 g_test_add_func("/vmstate/versioned/load/v2", test_load_v2);
1335 g_test_add_func("/vmstate/field_exists/load/noskip", test_load_noskip);
1336 g_test_add_func("/vmstate/field_exists/load/skip", test_load_skip);
1337 g_test_add_func("/vmstate/field_exists/save/noskip", test_save_noskip);
1338 g_test_add_func("/vmstate/field_exists/save/skip", test_save_skip);
1339 g_test_add_func("/vmstate/array/ptr/str/no0/save",
1340 test_arr_ptr_str_no0_save);
1341 g_test_add_func("/vmstate/array/ptr/str/no0/load",
1342 test_arr_ptr_str_no0_load);
1343 g_test_add_func("/vmstate/array/ptr/str/0/save", test_arr_ptr_str_0_save);
1344 g_test_add_func("/vmstate/array/ptr/str/0/load",
1345 test_arr_ptr_str_0_load);
1346 g_test_add_func("/vmstate/array/ptr/prim/0/save",
1347 test_arr_ptr_prim_0_save);
1348 g_test_add_func("/vmstate/array/ptr/prim/0/load",
1349 test_arr_ptr_prim_0_load);
1350 g_test_add_func("/vmstate/qtailq/save/saveq", test_save_q);
1351 g_test_add_func("/vmstate/qtailq/load/loadq", test_load_q);
1352 g_test_add_func("/vmstate/gtree/save/savedomain", test_gtree_save_domain);
1353 g_test_add_func("/vmstate/gtree/load/loaddomain", test_gtree_load_domain);
1354 g_test_add_func("/vmstate/gtree/save/saveiommu", test_gtree_save_iommu);
1355 g_test_add_func("/vmstate/gtree/load/loadiommu", test_gtree_load_iommu);
1356 g_test_add_func("/vmstate/tmp_struct", test_tmp_struct);
1357 g_test_run();
1358
1359 close(temp_fd);
1360 unlink(temp_file);
1361
1362 return 0;
1363}
1364