blob: 39f338a4c4c212bee0c2e2c71cbd81ac28ae4d51 [file] [log] [blame]
Eduardo Habkost2668b4b2013-11-28 12:01:18 -02001/*
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 Maydell681c28a2016-02-08 18:08:51 +000025#include "qemu/osdep.h"
Eduardo Habkost2668b4b2013-11-28 12:01:18 -020026
27#include "qemu-common.h"
28#include "migration/migration.h"
29#include "migration/vmstate.h"
Daniel P. Berrange10817bf2015-09-01 14:48:02 +010030#include "qemu/coroutine.h"
Daniel P. Berrange89258392016-04-27 11:05:08 +010031#include "io/channel-file.h"
Eduardo Habkost2668b4b2013-11-28 12:01:18 -020032
Stefan Weil748bfb42014-07-07 21:03:38 +020033static char temp_file[] = "/tmp/vmst.test.XXXXXX";
34static int temp_fd;
Eduardo Habkost2668b4b2013-11-28 12:01:18 -020035
Dr. David Alan Gilbert9935bac2014-10-10 12:39:05 +010036
Eduardo Habkost2668b4b2013-11-28 12:01:18 -020037/* Duplicate temp_fd and seek to the beginning of the file */
Juan Quintelac6f66462014-04-05 18:34:36 +020038static QEMUFile *open_test_file(bool write)
Eduardo Habkost2668b4b2013-11-28 12:01:18 -020039{
40 int fd = dup(temp_fd);
Daniel P. Berrange89258392016-04-27 11:05:08 +010041 QIOChannel *ioc;
Marc-André Lureau4ae3c0e2016-07-07 20:48:06 +020042 QEMUFile *f;
43
Eduardo Habkost2668b4b2013-11-28 12:01:18 -020044 lseek(fd, 0, SEEK_SET);
Juan Quintelac6f66462014-04-05 18:34:36 +020045 if (write) {
Eduardo Habkost2668b4b2013-11-28 12:01:18 -020046 g_assert_cmpint(ftruncate(fd, 0), ==, 0);
47 }
Daniel P. Berrange89258392016-04-27 11:05:08 +010048 ioc = QIO_CHANNEL(qio_channel_file_new_fd(fd));
49 if (write) {
Marc-André Lureau4ae3c0e2016-07-07 20:48:06 +020050 f = qemu_fopen_channel_output(ioc);
Daniel P. Berrange89258392016-04-27 11:05:08 +010051 } else {
Marc-André Lureau4ae3c0e2016-07-07 20:48:06 +020052 f = qemu_fopen_channel_input(ioc);
Daniel P. Berrange89258392016-04-27 11:05:08 +010053 }
Marc-André Lureau4ae3c0e2016-07-07 20:48:06 +020054 object_unref(OBJECT(ioc));
55 return f;
Eduardo Habkost2668b4b2013-11-28 12:01:18 -020056}
57
Juan Quintela4ea7df42014-04-05 20:12:51 +020058#define SUCCESS(val) \
59 g_assert_cmpint((val), ==, 0)
60
61#define FAILURE(val) \
62 g_assert_cmpint((val), !=, 0)
63
64static void save_vmstate(const VMStateDescription *desc, void *obj)
65{
66 QEMUFile *f = open_test_file(true);
67
68 /* Save file with vmstate */
Alexander Graf8118f092015-01-22 15:01:39 +010069 vmstate_save_state(f, desc, obj, NULL);
Juan Quintela4ea7df42014-04-05 20:12:51 +020070 qemu_put_byte(f, QEMU_VM_EOF);
71 g_assert(!qemu_file_get_error(f));
72 qemu_fclose(f);
73}
74
Halil Pasic6d57b4c2016-10-21 16:37:38 +020075static 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 Gilbert5c379d92017-02-03 16:06:50 +000082static void compare_vmstate(const uint8_t *wire, size_t size)
Juan Quintela4ea7df42014-04-05 20:12:51 +020083{
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
104static int load_vmstate_one(const VMStateDescription *desc, void *obj,
Dr. David Alan Gilbert5c379d92017-02-03 16:06:50 +0000105 int version, const uint8_t *wire, size_t size)
Juan Quintela4ea7df42014-04-05 20:12:51 +0200106{
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
126static int load_vmstate(const VMStateDescription *desc,
127 void *obj, void *obj_clone,
128 void (*obj_copy)(void *, void*),
Dr. David Alan Gilbert5c379d92017-02-03 16:06:50 +0000129 int version, const uint8_t *wire, size_t size)
Juan Quintela4ea7df42014-04-05 20:12:51 +0200130{
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
159typedef 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
173TestSimple 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
193static 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
228uint8_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
246static void obj_simple_copy(void *target, void *source)
247{
248 memcpy(target, source, sizeof(TestSimple));
249}
250
251static 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 Quintela4ea7df42014-04-05 20:12:51 +0200281
282typedef struct TestStruct {
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200283 uint32_t a, b, c, e;
284 uint64_t d, f;
285 bool skip_c_e;
286} TestStruct;
287
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200288static const VMStateDescription vmstate_versioned = {
Juan Quintela4ea7df42014-04-05 20:12:51 +0200289 .name = "test/versioned",
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200290 .version_id = 2,
291 .minimum_version_id = 1,
Juan Quintela35d08452014-04-16 16:01:33 +0200292 .fields = (VMStateField[]) {
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200293 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
305static void test_load_v1(void)
306{
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200307 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 Pasic6d57b4c2016-10-21 16:37:38 +0200313 save_buffer(buf, sizeof(buf));
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200314
Juan Quintelac6f66462014-04-05 18:34:36 +0200315 QEMUFile *loading = open_test_file(false);
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200316 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
328static void test_load_v2(void)
329{
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200330 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 Pasic6d57b4c2016-10-21 16:37:38 +0200339 save_buffer(buf, sizeof(buf));
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200340
Juan Quintelac6f66462014-04-05 18:34:36 +0200341 QEMUFile *loading = open_test_file(false);
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200342 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
353static bool test_skip(void *opaque, int version_id)
354{
355 TestStruct *t = (TestStruct *)opaque;
356 return !t->skip_c_e;
357}
358
359static const VMStateDescription vmstate_skipping = {
Juan Quintela4ea7df42014-04-05 20:12:51 +0200360 .name = "test/skip",
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200361 .version_id = 2,
362 .minimum_version_id = 1,
Juan Quintela35d08452014-04-16 16:01:33 +0200363 .fields = (VMStateField[]) {
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200364 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
375static void test_save_noskip(void)
376{
Daniel P. Berrangea8ec4432016-04-27 11:04:53 +0100377 QEMUFile *fsave = open_test_file(true);
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200378 TestStruct obj = { .a = 1, .b = 2, .c = 3, .d = 4, .e = 5, .f = 6,
379 .skip_c_e = false };
Alexander Graf8118f092015-01-22 15:01:39 +0100380 vmstate_save_state(fsave, &vmstate_skipping, &obj, NULL);
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200381 g_assert(!qemu_file_get_error(fsave));
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200382
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200383 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. Berrangea8ec4432016-04-27 11:04:53 +0100391
Dr. David Alan Gilbert9935bac2014-10-10 12:39:05 +0100392 qemu_fclose(fsave);
Daniel P. Berrangea8ec4432016-04-27 11:04:53 +0100393 compare_vmstate(expected, sizeof(expected));
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200394}
395
396static void test_save_skip(void)
397{
Daniel P. Berrangea8ec4432016-04-27 11:04:53 +0100398 QEMUFile *fsave = open_test_file(true);
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200399 TestStruct obj = { .a = 1, .b = 2, .c = 3, .d = 4, .e = 5, .f = 6,
400 .skip_c_e = true };
Alexander Graf8118f092015-01-22 15:01:39 +0100401 vmstate_save_state(fsave, &vmstate_skipping, &obj, NULL);
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200402 g_assert(!qemu_file_get_error(fsave));
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200403
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200404 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 Habkost2668b4b2013-11-28 12:01:18 -0200410
Dr. David Alan Gilbert9935bac2014-10-10 12:39:05 +0100411 qemu_fclose(fsave);
Daniel P. Berrangea8ec4432016-04-27 11:04:53 +0100412 compare_vmstate(expected, sizeof(expected));
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200413}
414
415static void test_load_noskip(void)
416{
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200417 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 Pasic6d57b4c2016-10-21 16:37:38 +0200426 save_buffer(buf, sizeof(buf));
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200427
Daniel P. Berrangea8ec4432016-04-27 11:04:53 +0100428 QEMUFile *loading = open_test_file(false);
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200429 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
441static void test_load_skip(void)
442{
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200443 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 Pasic6d57b4c2016-10-21 16:37:38 +0200450 save_buffer(buf, sizeof(buf));
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200451
Daniel P. Berrangea8ec4432016-04-27 11:04:53 +0100452 QEMUFile *loading = open_test_file(false);
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200453 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 Pasic8cc49f02016-10-21 16:37:39 +0200465typedef struct {
466 int32_t i;
467} TestStructTriv;
468
469const 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
481typedef struct {
482 TestStructTriv *ar[AR_SIZE];
483} TestArrayOfPtrToStuct;
484
485const 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};
495static 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
511static 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 Duan7e99f222017-01-19 11:00:52 -0800534/* test QTAILQ migration */
535typedef struct TestQtailqElement TestQtailqElement;
536
537struct TestQtailqElement {
538 bool b;
539 uint8_t u8;
540 QTAILQ_ENTRY(TestQtailqElement) next;
541};
542
543typedef struct TestQtailq {
544 int16_t i16;
545 QTAILQ_HEAD(TestQtailqHead, TestQtailqElement) q;
546 int32_t i32;
547} TestQtailq;
548
549static 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
560static 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
573uint8_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
586static 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
611static 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 Gilbert5c379d92017-02-03 16:06:50 +0000678typedef struct TmpTestStruct {
679 TestStruct *parent;
680 int64_t diff;
681} TmpTestStruct;
682
683static 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
690static 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
699static 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
707static 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
719static 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
730static void obj_tmp_copy(void *target, void *source)
731{
732 memcpy(target, source, sizeof(TestStruct));
733}
734
735static 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 Habkost2668b4b2013-11-28 12:01:18 -0200766int main(int argc, char **argv)
767{
768 temp_fd = mkstemp(temp_file);
769
Daniel P. Berrange89258392016-04-27 11:05:08 +0100770 module_call_init(MODULE_INIT_QOM);
771
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200772 g_test_init(&argc, &argv, NULL);
Juan Quintela4ea7df42014-04-05 20:12:51 +0200773 g_test_add_func("/vmstate/simple/primitive", test_simple_primitive);
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200774 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 Pasic8cc49f02016-10-21 16:37:39 +0200780 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 Duan7e99f222017-01-19 11:00:52 -0800784 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 Gilbert5c379d92017-02-03 16:06:50 +0000786 g_test_add_func("/vmstate/tmp_struct", test_tmp_struct);
Eduardo Habkost2668b4b2013-11-28 12:01:18 -0200787 g_test_run();
788
789 close(temp_fd);
790 unlink(temp_file);
791
792 return 0;
793}