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
815typedef struct TmpTestStruct {
816 TestStruct *parent;
817 int64_t diff;
818} TmpTestStruct;
819
820static int tmp_child_pre_save(void *opaque)
821{
822 struct TmpTestStruct *tts = opaque;
823
824 tts->diff = tts->parent->b - tts->parent->a;
825
826 return 0;
827}
828
829static int tmp_child_post_load(void *opaque, int version_id)
830{
831 struct TmpTestStruct *tts = opaque;
832
833 tts->parent->b = tts->parent->a + tts->diff;
834
835 return 0;
836}
837
838static const VMStateDescription vmstate_tmp_back_to_parent = {
839 .name = "test/tmp_child_parent",
840 .fields = (VMStateField[]) {
841 VMSTATE_UINT64(f, TestStruct),
842 VMSTATE_END_OF_LIST()
843 }
844};
845
846static const VMStateDescription vmstate_tmp_child = {
847 .name = "test/tmp_child",
848 .pre_save = tmp_child_pre_save,
849 .post_load = tmp_child_post_load,
850 .fields = (VMStateField[]) {
851 VMSTATE_INT64(diff, TmpTestStruct),
852 VMSTATE_STRUCT_POINTER(parent, TmpTestStruct,
853 vmstate_tmp_back_to_parent, TestStruct),
854 VMSTATE_END_OF_LIST()
855 }
856};
857
858static const VMStateDescription vmstate_with_tmp = {
859 .name = "test/with_tmp",
860 .version_id = 1,
861 .fields = (VMStateField[]) {
862 VMSTATE_UINT32(a, TestStruct),
863 VMSTATE_UINT64(d, TestStruct),
864 VMSTATE_WITH_TMP(TestStruct, TmpTestStruct, vmstate_tmp_child),
865 VMSTATE_END_OF_LIST()
866 }
867};
868
869static void obj_tmp_copy(void *target, void *source)
870{
871 memcpy(target, source, sizeof(TestStruct));
872}
873
874static void test_tmp_struct(void)
875{
876 TestStruct obj, obj_clone;
877
878 uint8_t const wire_with_tmp[] = {
879 0x00, 0x00, 0x00, 0x02,
880 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
881 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
882 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
883 QEMU_VM_EOF,
884 };
885
886 memset(&obj, 0, sizeof(obj));
887 obj.a = 2;
888 obj.b = 4;
889 obj.d = 1;
890 obj.f = 8;
891 save_vmstate(&vmstate_with_tmp, &obj);
892
893 compare_vmstate(wire_with_tmp, sizeof(wire_with_tmp));
894
895 memset(&obj, 0, sizeof(obj));
896 SUCCESS(load_vmstate(&vmstate_with_tmp, &obj, &obj_clone,
897 obj_tmp_copy, 1, wire_with_tmp,
898 sizeof(wire_with_tmp)));
899 g_assert_cmpint(obj.a, ==, 2);
900 g_assert_cmpint(obj.b, ==, 4);
901 g_assert_cmpint(obj.d, ==, 1);
902 g_assert_cmpint(obj.f, ==, 8);
903}
904
905int main(int argc, char **argv)
906{
907 temp_fd = mkstemp(temp_file);
908
909 module_call_init(MODULE_INIT_QOM);
910
911 setenv("QTEST_SILENT_ERRORS", "1", 1);
912
913 g_test_init(&argc, &argv, NULL);
914 g_test_add_func("/vmstate/simple/primitive", test_simple_primitive);
915 g_test_add_func("/vmstate/simple/array", test_simple_array);
916 g_test_add_func("/vmstate/versioned/load/v1", test_load_v1);
917 g_test_add_func("/vmstate/versioned/load/v2", test_load_v2);
918 g_test_add_func("/vmstate/field_exists/load/noskip", test_load_noskip);
919 g_test_add_func("/vmstate/field_exists/load/skip", test_load_skip);
920 g_test_add_func("/vmstate/field_exists/save/noskip", test_save_noskip);
921 g_test_add_func("/vmstate/field_exists/save/skip", test_save_skip);
922 g_test_add_func("/vmstate/array/ptr/str/no0/save",
923 test_arr_ptr_str_no0_save);
924 g_test_add_func("/vmstate/array/ptr/str/no0/load",
925 test_arr_ptr_str_no0_load);
926 g_test_add_func("/vmstate/array/ptr/str/0/save", test_arr_ptr_str_0_save);
927 g_test_add_func("/vmstate/array/ptr/str/0/load",
928 test_arr_ptr_str_0_load);
929 g_test_add_func("/vmstate/array/ptr/prim/0/save",
930 test_arr_ptr_prim_0_save);
931 g_test_add_func("/vmstate/array/ptr/prim/0/load",
932 test_arr_ptr_prim_0_load);
933 g_test_add_func("/vmstate/qtailq/save/saveq", test_save_q);
934 g_test_add_func("/vmstate/qtailq/load/loadq", test_load_q);
935 g_test_add_func("/vmstate/tmp_struct", test_tmp_struct);
936 g_test_run();
937
938 close(temp_fd);
939 unlink(temp_file);
940
941 return 0;
942}
943