linux-user: Support for restarting system calls for OpenRISC targets
[qemu.git] / tests / test-vmstate.c
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 #include <glib.h>
27
28 #include "qemu-common.h"
29 #include "migration/migration.h"
30 #include "migration/vmstate.h"
31 #include "qemu/coroutine.h"
32
33 static char temp_file[] = "/tmp/vmst.test.XXXXXX";
34 static int temp_fd;
35
36 /* Fake yield_until_fd_readable() implementation so we don't have to pull the
37 * coroutine code as dependency.
38 */
39 void yield_until_fd_readable(int fd)
40 {
41 fd_set fds;
42 FD_ZERO(&fds);
43 FD_SET(fd, &fds);
44 select(fd + 1, &fds, NULL, NULL, NULL);
45 }
46
47 /*
48 * Some tests use 'open_test_file' to work on a real fd, some use
49 * an in memory file (QEMUSizedBuffer+qemu_bufopen); we could pick one
50 * but this way we test both.
51 */
52
53 /* Duplicate temp_fd and seek to the beginning of the file */
54 static QEMUFile *open_test_file(bool write)
55 {
56 int fd = dup(temp_fd);
57 lseek(fd, 0, SEEK_SET);
58 if (write) {
59 g_assert_cmpint(ftruncate(fd, 0), ==, 0);
60 }
61 return qemu_fdopen(fd, write ? "wb" : "rb");
62 }
63
64 /*
65 * Check that the contents of the memory-buffered file f match
66 * the given size/data.
67 */
68 static void check_mem_file(QEMUFile *f, void *data, size_t size)
69 {
70 uint8_t *result = g_malloc(size);
71 const QEMUSizedBuffer *qsb = qemu_buf_get(f);
72 g_assert_cmpint(qsb_get_length(qsb), ==, size);
73 g_assert_cmpint(qsb_get_buffer(qsb, 0, size, result), ==, size);
74 g_assert_cmpint(memcmp(result, data, size), ==, 0);
75 g_free(result);
76 }
77
78 #define SUCCESS(val) \
79 g_assert_cmpint((val), ==, 0)
80
81 #define FAILURE(val) \
82 g_assert_cmpint((val), !=, 0)
83
84 static void save_vmstate(const VMStateDescription *desc, void *obj)
85 {
86 QEMUFile *f = open_test_file(true);
87
88 /* Save file with vmstate */
89 vmstate_save_state(f, desc, obj, NULL);
90 qemu_put_byte(f, QEMU_VM_EOF);
91 g_assert(!qemu_file_get_error(f));
92 qemu_fclose(f);
93 }
94
95 static void compare_vmstate(uint8_t *wire, size_t size)
96 {
97 QEMUFile *f = open_test_file(false);
98 uint8_t result[size];
99
100 /* read back as binary */
101
102 g_assert_cmpint(qemu_get_buffer(f, result, sizeof(result)), ==,
103 sizeof(result));
104 g_assert(!qemu_file_get_error(f));
105
106 /* Compare that what is on the file is the same that what we
107 expected to be there */
108 SUCCESS(memcmp(result, wire, sizeof(result)));
109
110 /* Must reach EOF */
111 qemu_get_byte(f);
112 g_assert_cmpint(qemu_file_get_error(f), ==, -EIO);
113
114 qemu_fclose(f);
115 }
116
117 static int load_vmstate_one(const VMStateDescription *desc, void *obj,
118 int version, uint8_t *wire, size_t size)
119 {
120 QEMUFile *f;
121 int ret;
122
123 f = open_test_file(true);
124 qemu_put_buffer(f, wire, size);
125 qemu_fclose(f);
126
127 f = open_test_file(false);
128 ret = vmstate_load_state(f, desc, obj, version);
129 if (ret) {
130 g_assert(qemu_file_get_error(f));
131 } else{
132 g_assert(!qemu_file_get_error(f));
133 }
134 qemu_fclose(f);
135 return ret;
136 }
137
138
139 static int load_vmstate(const VMStateDescription *desc,
140 void *obj, void *obj_clone,
141 void (*obj_copy)(void *, void*),
142 int version, uint8_t *wire, size_t size)
143 {
144 /* We test with zero size */
145 obj_copy(obj_clone, obj);
146 FAILURE(load_vmstate_one(desc, obj, version, wire, 0));
147
148 /* Stream ends with QEMU_EOF, so we need at least 3 bytes to be
149 * able to test in the middle */
150
151 if (size > 3) {
152
153 /* We test with size - 2. We can't test size - 1 due to EOF tricks */
154 obj_copy(obj, obj_clone);
155 FAILURE(load_vmstate_one(desc, obj, version, wire, size - 2));
156
157 /* Test with size/2, first half of real state */
158 obj_copy(obj, obj_clone);
159 FAILURE(load_vmstate_one(desc, obj, version, wire, size/2));
160
161 /* Test with size/2, second half of real state */
162 obj_copy(obj, obj_clone);
163 FAILURE(load_vmstate_one(desc, obj, version, wire + (size/2), size/2));
164
165 }
166 obj_copy(obj, obj_clone);
167 return load_vmstate_one(desc, obj, version, wire, size);
168 }
169
170 /* Test struct that we are going to use for our tests */
171
172 typedef struct TestSimple {
173 bool b_1, b_2;
174 uint8_t u8_1;
175 uint16_t u16_1;
176 uint32_t u32_1;
177 uint64_t u64_1;
178 int8_t i8_1, i8_2;
179 int16_t i16_1, i16_2;
180 int32_t i32_1, i32_2;
181 int64_t i64_1, i64_2;
182 } TestSimple;
183
184 /* Object instantiation, we are going to use it in more than one test */
185
186 TestSimple obj_simple = {
187 .b_1 = true,
188 .b_2 = false,
189 .u8_1 = 130,
190 .u16_1 = 512,
191 .u32_1 = 70000,
192 .u64_1 = 12121212,
193 .i8_1 = 65,
194 .i8_2 = -65,
195 .i16_1 = 512,
196 .i16_2 = -512,
197 .i32_1 = 70000,
198 .i32_2 = -70000,
199 .i64_1 = 12121212,
200 .i64_2 = -12121212,
201 };
202
203 /* Description of the values. If you add a primitive type
204 you are expected to add a test here */
205
206 static const VMStateDescription vmstate_simple_primitive = {
207 .name = "simple/primitive",
208 .version_id = 1,
209 .minimum_version_id = 1,
210 .fields = (VMStateField[]) {
211 VMSTATE_BOOL(b_1, TestSimple),
212 VMSTATE_BOOL(b_2, TestSimple),
213 VMSTATE_UINT8(u8_1, TestSimple),
214 VMSTATE_UINT16(u16_1, TestSimple),
215 VMSTATE_UINT32(u32_1, TestSimple),
216 VMSTATE_UINT64(u64_1, TestSimple),
217 VMSTATE_INT8(i8_1, TestSimple),
218 VMSTATE_INT8(i8_2, TestSimple),
219 VMSTATE_INT16(i16_1, TestSimple),
220 VMSTATE_INT16(i16_2, TestSimple),
221 VMSTATE_INT32(i32_1, TestSimple),
222 VMSTATE_INT32(i32_2, TestSimple),
223 VMSTATE_INT64(i64_1, TestSimple),
224 VMSTATE_INT64(i64_2, TestSimple),
225 VMSTATE_END_OF_LIST()
226 }
227 };
228
229 /* It describes what goes through the wire. Our tests are basically:
230
231 * save test
232 - save a struct a vmstate to a file
233 - read that file back (binary read, no vmstate)
234 - compare it with what we expect to be on the wire
235 * load test
236 - save to the file what we expect to be on the wire
237 - read struct back with vmstate in a different
238 - compare back with the original struct
239 */
240
241 uint8_t wire_simple_primitive[] = {
242 /* b_1 */ 0x01,
243 /* b_2 */ 0x00,
244 /* u8_1 */ 0x82,
245 /* u16_1 */ 0x02, 0x00,
246 /* u32_1 */ 0x00, 0x01, 0x11, 0x70,
247 /* u64_1 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0xf4, 0x7c,
248 /* i8_1 */ 0x41,
249 /* i8_2 */ 0xbf,
250 /* i16_1 */ 0x02, 0x00,
251 /* i16_2 */ 0xfe, 0x0,
252 /* i32_1 */ 0x00, 0x01, 0x11, 0x70,
253 /* i32_2 */ 0xff, 0xfe, 0xee, 0x90,
254 /* i64_1 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0xf4, 0x7c,
255 /* i64_2 */ 0xff, 0xff, 0xff, 0xff, 0xff, 0x47, 0x0b, 0x84,
256 QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */
257 };
258
259 static void obj_simple_copy(void *target, void *source)
260 {
261 memcpy(target, source, sizeof(TestSimple));
262 }
263
264 static void test_simple_primitive(void)
265 {
266 TestSimple obj, obj_clone;
267
268 memset(&obj, 0, sizeof(obj));
269 save_vmstate(&vmstate_simple_primitive, &obj_simple);
270
271 compare_vmstate(wire_simple_primitive, sizeof(wire_simple_primitive));
272
273 SUCCESS(load_vmstate(&vmstate_simple_primitive, &obj, &obj_clone,
274 obj_simple_copy, 1, wire_simple_primitive,
275 sizeof(wire_simple_primitive)));
276
277 #define FIELD_EQUAL(name) g_assert_cmpint(obj.name, ==, obj_simple.name)
278
279 FIELD_EQUAL(b_1);
280 FIELD_EQUAL(b_2);
281 FIELD_EQUAL(u8_1);
282 FIELD_EQUAL(u16_1);
283 FIELD_EQUAL(u32_1);
284 FIELD_EQUAL(u64_1);
285 FIELD_EQUAL(i8_1);
286 FIELD_EQUAL(i8_2);
287 FIELD_EQUAL(i16_1);
288 FIELD_EQUAL(i16_2);
289 FIELD_EQUAL(i32_1);
290 FIELD_EQUAL(i32_2);
291 FIELD_EQUAL(i64_1);
292 FIELD_EQUAL(i64_2);
293 }
294 #undef FIELD_EQUAL
295
296 typedef struct TestStruct {
297 uint32_t a, b, c, e;
298 uint64_t d, f;
299 bool skip_c_e;
300 } TestStruct;
301
302 static const VMStateDescription vmstate_versioned = {
303 .name = "test/versioned",
304 .version_id = 2,
305 .minimum_version_id = 1,
306 .fields = (VMStateField[]) {
307 VMSTATE_UINT32(a, TestStruct),
308 VMSTATE_UINT32_V(b, TestStruct, 2), /* Versioned field in the middle, so
309 * we catch bugs more easily.
310 */
311 VMSTATE_UINT32(c, TestStruct),
312 VMSTATE_UINT64(d, TestStruct),
313 VMSTATE_UINT32_V(e, TestStruct, 2),
314 VMSTATE_UINT64_V(f, TestStruct, 2),
315 VMSTATE_END_OF_LIST()
316 }
317 };
318
319 static void test_load_v1(void)
320 {
321 QEMUFile *fsave = open_test_file(true);
322 uint8_t buf[] = {
323 0, 0, 0, 10, /* a */
324 0, 0, 0, 30, /* c */
325 0, 0, 0, 0, 0, 0, 0, 40, /* d */
326 QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */
327 };
328 qemu_put_buffer(fsave, buf, sizeof(buf));
329 qemu_fclose(fsave);
330
331 QEMUFile *loading = open_test_file(false);
332 TestStruct obj = { .b = 200, .e = 500, .f = 600 };
333 vmstate_load_state(loading, &vmstate_versioned, &obj, 1);
334 g_assert(!qemu_file_get_error(loading));
335 g_assert_cmpint(obj.a, ==, 10);
336 g_assert_cmpint(obj.b, ==, 200);
337 g_assert_cmpint(obj.c, ==, 30);
338 g_assert_cmpint(obj.d, ==, 40);
339 g_assert_cmpint(obj.e, ==, 500);
340 g_assert_cmpint(obj.f, ==, 600);
341 qemu_fclose(loading);
342 }
343
344 static void test_load_v2(void)
345 {
346 QEMUFile *fsave = open_test_file(true);
347 uint8_t buf[] = {
348 0, 0, 0, 10, /* a */
349 0, 0, 0, 20, /* b */
350 0, 0, 0, 30, /* c */
351 0, 0, 0, 0, 0, 0, 0, 40, /* d */
352 0, 0, 0, 50, /* e */
353 0, 0, 0, 0, 0, 0, 0, 60, /* f */
354 QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */
355 };
356 qemu_put_buffer(fsave, buf, sizeof(buf));
357 qemu_fclose(fsave);
358
359 QEMUFile *loading = open_test_file(false);
360 TestStruct obj;
361 vmstate_load_state(loading, &vmstate_versioned, &obj, 2);
362 g_assert_cmpint(obj.a, ==, 10);
363 g_assert_cmpint(obj.b, ==, 20);
364 g_assert_cmpint(obj.c, ==, 30);
365 g_assert_cmpint(obj.d, ==, 40);
366 g_assert_cmpint(obj.e, ==, 50);
367 g_assert_cmpint(obj.f, ==, 60);
368 qemu_fclose(loading);
369 }
370
371 static bool test_skip(void *opaque, int version_id)
372 {
373 TestStruct *t = (TestStruct *)opaque;
374 return !t->skip_c_e;
375 }
376
377 static const VMStateDescription vmstate_skipping = {
378 .name = "test/skip",
379 .version_id = 2,
380 .minimum_version_id = 1,
381 .fields = (VMStateField[]) {
382 VMSTATE_UINT32(a, TestStruct),
383 VMSTATE_UINT32(b, TestStruct),
384 VMSTATE_UINT32_TEST(c, TestStruct, test_skip),
385 VMSTATE_UINT64(d, TestStruct),
386 VMSTATE_UINT32_TEST(e, TestStruct, test_skip),
387 VMSTATE_UINT64_V(f, TestStruct, 2),
388 VMSTATE_END_OF_LIST()
389 }
390 };
391
392
393 static void test_save_noskip(void)
394 {
395 QEMUFile *fsave = qemu_bufopen("w", NULL);
396 TestStruct obj = { .a = 1, .b = 2, .c = 3, .d = 4, .e = 5, .f = 6,
397 .skip_c_e = false };
398 vmstate_save_state(fsave, &vmstate_skipping, &obj, NULL);
399 g_assert(!qemu_file_get_error(fsave));
400
401 uint8_t expected[] = {
402 0, 0, 0, 1, /* a */
403 0, 0, 0, 2, /* b */
404 0, 0, 0, 3, /* c */
405 0, 0, 0, 0, 0, 0, 0, 4, /* d */
406 0, 0, 0, 5, /* e */
407 0, 0, 0, 0, 0, 0, 0, 6, /* f */
408 };
409 check_mem_file(fsave, expected, sizeof(expected));
410 qemu_fclose(fsave);
411 }
412
413 static void test_save_skip(void)
414 {
415 QEMUFile *fsave = qemu_bufopen("w", NULL);
416 TestStruct obj = { .a = 1, .b = 2, .c = 3, .d = 4, .e = 5, .f = 6,
417 .skip_c_e = true };
418 vmstate_save_state(fsave, &vmstate_skipping, &obj, NULL);
419 g_assert(!qemu_file_get_error(fsave));
420
421 uint8_t expected[] = {
422 0, 0, 0, 1, /* a */
423 0, 0, 0, 2, /* b */
424 0, 0, 0, 0, 0, 0, 0, 4, /* d */
425 0, 0, 0, 0, 0, 0, 0, 6, /* f */
426 };
427 check_mem_file(fsave, expected, sizeof(expected));
428
429 qemu_fclose(fsave);
430 }
431
432 static void test_load_noskip(void)
433 {
434 uint8_t buf[] = {
435 0, 0, 0, 10, /* a */
436 0, 0, 0, 20, /* b */
437 0, 0, 0, 30, /* c */
438 0, 0, 0, 0, 0, 0, 0, 40, /* d */
439 0, 0, 0, 50, /* e */
440 0, 0, 0, 0, 0, 0, 0, 60, /* f */
441 QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */
442 };
443
444 QEMUSizedBuffer *qsb = qsb_create(buf, sizeof(buf));
445 g_assert(qsb);
446 QEMUFile *loading = qemu_bufopen("r", qsb);
447 TestStruct obj = { .skip_c_e = false };
448 vmstate_load_state(loading, &vmstate_skipping, &obj, 2);
449 g_assert(!qemu_file_get_error(loading));
450 g_assert_cmpint(obj.a, ==, 10);
451 g_assert_cmpint(obj.b, ==, 20);
452 g_assert_cmpint(obj.c, ==, 30);
453 g_assert_cmpint(obj.d, ==, 40);
454 g_assert_cmpint(obj.e, ==, 50);
455 g_assert_cmpint(obj.f, ==, 60);
456 qemu_fclose(loading);
457 qsb_free(qsb);
458 }
459
460 static void test_load_skip(void)
461 {
462 uint8_t buf[] = {
463 0, 0, 0, 10, /* a */
464 0, 0, 0, 20, /* b */
465 0, 0, 0, 0, 0, 0, 0, 40, /* d */
466 0, 0, 0, 0, 0, 0, 0, 60, /* f */
467 QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */
468 };
469
470 QEMUSizedBuffer *qsb = qsb_create(buf, sizeof(buf));
471 g_assert(qsb);
472 QEMUFile *loading = qemu_bufopen("r", qsb);
473 TestStruct obj = { .skip_c_e = true, .c = 300, .e = 500 };
474 vmstate_load_state(loading, &vmstate_skipping, &obj, 2);
475 g_assert(!qemu_file_get_error(loading));
476 g_assert_cmpint(obj.a, ==, 10);
477 g_assert_cmpint(obj.b, ==, 20);
478 g_assert_cmpint(obj.c, ==, 300);
479 g_assert_cmpint(obj.d, ==, 40);
480 g_assert_cmpint(obj.e, ==, 500);
481 g_assert_cmpint(obj.f, ==, 60);
482 qemu_fclose(loading);
483 qsb_free(qsb);
484 }
485
486 int main(int argc, char **argv)
487 {
488 temp_fd = mkstemp(temp_file);
489
490 g_test_init(&argc, &argv, NULL);
491 g_test_add_func("/vmstate/simple/primitive", test_simple_primitive);
492 g_test_add_func("/vmstate/versioned/load/v1", test_load_v1);
493 g_test_add_func("/vmstate/versioned/load/v2", test_load_v2);
494 g_test_add_func("/vmstate/field_exists/load/noskip", test_load_noskip);
495 g_test_add_func("/vmstate/field_exists/load/skip", test_load_skip);
496 g_test_add_func("/vmstate/field_exists/save/noskip", test_save_noskip);
497 g_test_add_func("/vmstate/field_exists/save/skip", test_save_skip);
498 g_test_run();
499
500 close(temp_fd);
501 unlink(temp_file);
502
503 return 0;
504 }