]> git.proxmox.com Git - mirror_qemu.git/blob - migration/vmstate-types.c
accel/tcg: Rename tcg_cpus_exec() -> tcg_cpu_exec()
[mirror_qemu.git] / migration / vmstate-types.c
1 /*
2 * VMStateInfo's for basic typse
3 *
4 * Copyright (c) 2009-2017 Red Hat Inc
5 *
6 * Authors:
7 * Juan Quintela <quintela@redhat.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
11 */
12
13 #include "qemu/osdep.h"
14 #include "qemu/cpu-float.h"
15 #include "qemu-file.h"
16 #include "migration.h"
17 #include "migration/vmstate.h"
18 #include "qemu/error-report.h"
19 #include "qemu/queue.h"
20 #include "trace.h"
21
22 /* bool */
23
24 static int get_bool(QEMUFile *f, void *pv, size_t size,
25 const VMStateField *field)
26 {
27 bool *v = pv;
28 *v = qemu_get_byte(f);
29 return 0;
30 }
31
32 static int put_bool(QEMUFile *f, void *pv, size_t size,
33 const VMStateField *field, JSONWriter *vmdesc)
34 {
35 bool *v = pv;
36 qemu_put_byte(f, *v);
37 return 0;
38 }
39
40 const VMStateInfo vmstate_info_bool = {
41 .name = "bool",
42 .get = get_bool,
43 .put = put_bool,
44 };
45
46 /* 8 bit int */
47
48 static int get_int8(QEMUFile *f, void *pv, size_t size,
49 const VMStateField *field)
50 {
51 int8_t *v = pv;
52 qemu_get_s8s(f, v);
53 return 0;
54 }
55
56 static int put_int8(QEMUFile *f, void *pv, size_t size,
57 const VMStateField *field, JSONWriter *vmdesc)
58 {
59 int8_t *v = pv;
60 qemu_put_s8s(f, v);
61 return 0;
62 }
63
64 const VMStateInfo vmstate_info_int8 = {
65 .name = "int8",
66 .get = get_int8,
67 .put = put_int8,
68 };
69
70 /* 16 bit int */
71
72 static int get_int16(QEMUFile *f, void *pv, size_t size,
73 const VMStateField *field)
74 {
75 int16_t *v = pv;
76 qemu_get_sbe16s(f, v);
77 return 0;
78 }
79
80 static int put_int16(QEMUFile *f, void *pv, size_t size,
81 const VMStateField *field, JSONWriter *vmdesc)
82 {
83 int16_t *v = pv;
84 qemu_put_sbe16s(f, v);
85 return 0;
86 }
87
88 const VMStateInfo vmstate_info_int16 = {
89 .name = "int16",
90 .get = get_int16,
91 .put = put_int16,
92 };
93
94 /* 32 bit int */
95
96 static int get_int32(QEMUFile *f, void *pv, size_t size,
97 const VMStateField *field)
98 {
99 int32_t *v = pv;
100 qemu_get_sbe32s(f, v);
101 return 0;
102 }
103
104 static int put_int32(QEMUFile *f, void *pv, size_t size,
105 const VMStateField *field, JSONWriter *vmdesc)
106 {
107 int32_t *v = pv;
108 qemu_put_sbe32s(f, v);
109 return 0;
110 }
111
112 const VMStateInfo vmstate_info_int32 = {
113 .name = "int32",
114 .get = get_int32,
115 .put = put_int32,
116 };
117
118 /* 32 bit int. See that the received value is the same than the one
119 in the field */
120
121 static int get_int32_equal(QEMUFile *f, void *pv, size_t size,
122 const VMStateField *field)
123 {
124 int32_t *v = pv;
125 int32_t v2;
126 qemu_get_sbe32s(f, &v2);
127
128 if (*v == v2) {
129 return 0;
130 }
131 error_report("%" PRIx32 " != %" PRIx32, *v, v2);
132 if (field->err_hint) {
133 error_printf("%s\n", field->err_hint);
134 }
135 return -EINVAL;
136 }
137
138 const VMStateInfo vmstate_info_int32_equal = {
139 .name = "int32 equal",
140 .get = get_int32_equal,
141 .put = put_int32,
142 };
143
144 /* 32 bit int. Check that the received value is non-negative
145 * and less than or equal to the one in the field.
146 */
147
148 static int get_int32_le(QEMUFile *f, void *pv, size_t size,
149 const VMStateField *field)
150 {
151 int32_t *cur = pv;
152 int32_t loaded;
153 qemu_get_sbe32s(f, &loaded);
154
155 if (loaded >= 0 && loaded <= *cur) {
156 *cur = loaded;
157 return 0;
158 }
159 error_report("Invalid value %" PRId32
160 " expecting positive value <= %" PRId32,
161 loaded, *cur);
162 return -EINVAL;
163 }
164
165 const VMStateInfo vmstate_info_int32_le = {
166 .name = "int32 le",
167 .get = get_int32_le,
168 .put = put_int32,
169 };
170
171 /* 64 bit int */
172
173 static int get_int64(QEMUFile *f, void *pv, size_t size,
174 const VMStateField *field)
175 {
176 int64_t *v = pv;
177 qemu_get_sbe64s(f, v);
178 return 0;
179 }
180
181 static int put_int64(QEMUFile *f, void *pv, size_t size,
182 const VMStateField *field, JSONWriter *vmdesc)
183 {
184 int64_t *v = pv;
185 qemu_put_sbe64s(f, v);
186 return 0;
187 }
188
189 const VMStateInfo vmstate_info_int64 = {
190 .name = "int64",
191 .get = get_int64,
192 .put = put_int64,
193 };
194
195 /* 8 bit unsigned int */
196
197 static int get_uint8(QEMUFile *f, void *pv, size_t size,
198 const VMStateField *field)
199 {
200 uint8_t *v = pv;
201 qemu_get_8s(f, v);
202 return 0;
203 }
204
205 static int put_uint8(QEMUFile *f, void *pv, size_t size,
206 const VMStateField *field, JSONWriter *vmdesc)
207 {
208 uint8_t *v = pv;
209 qemu_put_8s(f, v);
210 return 0;
211 }
212
213 const VMStateInfo vmstate_info_uint8 = {
214 .name = "uint8",
215 .get = get_uint8,
216 .put = put_uint8,
217 };
218
219 /* 16 bit unsigned int */
220
221 static int get_uint16(QEMUFile *f, void *pv, size_t size,
222 const VMStateField *field)
223 {
224 uint16_t *v = pv;
225 qemu_get_be16s(f, v);
226 return 0;
227 }
228
229 static int put_uint16(QEMUFile *f, void *pv, size_t size,
230 const VMStateField *field, JSONWriter *vmdesc)
231 {
232 uint16_t *v = pv;
233 qemu_put_be16s(f, v);
234 return 0;
235 }
236
237 const VMStateInfo vmstate_info_uint16 = {
238 .name = "uint16",
239 .get = get_uint16,
240 .put = put_uint16,
241 };
242
243 /* 32 bit unsigned int */
244
245 static int get_uint32(QEMUFile *f, void *pv, size_t size,
246 const VMStateField *field)
247 {
248 uint32_t *v = pv;
249 qemu_get_be32s(f, v);
250 return 0;
251 }
252
253 static int put_uint32(QEMUFile *f, void *pv, size_t size,
254 const VMStateField *field, JSONWriter *vmdesc)
255 {
256 uint32_t *v = pv;
257 qemu_put_be32s(f, v);
258 return 0;
259 }
260
261 const VMStateInfo vmstate_info_uint32 = {
262 .name = "uint32",
263 .get = get_uint32,
264 .put = put_uint32,
265 };
266
267 /* 32 bit uint. See that the received value is the same than the one
268 in the field */
269
270 static int get_uint32_equal(QEMUFile *f, void *pv, size_t size,
271 const VMStateField *field)
272 {
273 uint32_t *v = pv;
274 uint32_t v2;
275 qemu_get_be32s(f, &v2);
276
277 if (*v == v2) {
278 return 0;
279 }
280 error_report("%" PRIx32 " != %" PRIx32, *v, v2);
281 if (field->err_hint) {
282 error_printf("%s\n", field->err_hint);
283 }
284 return -EINVAL;
285 }
286
287 const VMStateInfo vmstate_info_uint32_equal = {
288 .name = "uint32 equal",
289 .get = get_uint32_equal,
290 .put = put_uint32,
291 };
292
293 /* 64 bit unsigned int */
294
295 static int get_uint64(QEMUFile *f, void *pv, size_t size,
296 const VMStateField *field)
297 {
298 uint64_t *v = pv;
299 qemu_get_be64s(f, v);
300 return 0;
301 }
302
303 static int put_uint64(QEMUFile *f, void *pv, size_t size,
304 const VMStateField *field, JSONWriter *vmdesc)
305 {
306 uint64_t *v = pv;
307 qemu_put_be64s(f, v);
308 return 0;
309 }
310
311 const VMStateInfo vmstate_info_uint64 = {
312 .name = "uint64",
313 .get = get_uint64,
314 .put = put_uint64,
315 };
316
317 static int get_nullptr(QEMUFile *f, void *pv, size_t size,
318 const VMStateField *field)
319
320 {
321 if (qemu_get_byte(f) == VMS_NULLPTR_MARKER) {
322 return 0;
323 }
324 error_report("vmstate: get_nullptr expected VMS_NULLPTR_MARKER");
325 return -EINVAL;
326 }
327
328 static int put_nullptr(QEMUFile *f, void *pv, size_t size,
329 const VMStateField *field, JSONWriter *vmdesc)
330
331 {
332 if (pv == NULL) {
333 qemu_put_byte(f, VMS_NULLPTR_MARKER);
334 return 0;
335 }
336 error_report("vmstate: put_nullptr must be called with pv == NULL");
337 return -EINVAL;
338 }
339
340 const VMStateInfo vmstate_info_nullptr = {
341 .name = "uint64",
342 .get = get_nullptr,
343 .put = put_nullptr,
344 };
345
346 /* 64 bit unsigned int. See that the received value is the same than the one
347 in the field */
348
349 static int get_uint64_equal(QEMUFile *f, void *pv, size_t size,
350 const VMStateField *field)
351 {
352 uint64_t *v = pv;
353 uint64_t v2;
354 qemu_get_be64s(f, &v2);
355
356 if (*v == v2) {
357 return 0;
358 }
359 error_report("%" PRIx64 " != %" PRIx64, *v, v2);
360 if (field->err_hint) {
361 error_printf("%s\n", field->err_hint);
362 }
363 return -EINVAL;
364 }
365
366 const VMStateInfo vmstate_info_uint64_equal = {
367 .name = "int64 equal",
368 .get = get_uint64_equal,
369 .put = put_uint64,
370 };
371
372 /* 8 bit int. See that the received value is the same than the one
373 in the field */
374
375 static int get_uint8_equal(QEMUFile *f, void *pv, size_t size,
376 const VMStateField *field)
377 {
378 uint8_t *v = pv;
379 uint8_t v2;
380 qemu_get_8s(f, &v2);
381
382 if (*v == v2) {
383 return 0;
384 }
385 error_report("%x != %x", *v, v2);
386 if (field->err_hint) {
387 error_printf("%s\n", field->err_hint);
388 }
389 return -EINVAL;
390 }
391
392 const VMStateInfo vmstate_info_uint8_equal = {
393 .name = "uint8 equal",
394 .get = get_uint8_equal,
395 .put = put_uint8,
396 };
397
398 /* 16 bit unsigned int int. See that the received value is the same than the one
399 in the field */
400
401 static int get_uint16_equal(QEMUFile *f, void *pv, size_t size,
402 const VMStateField *field)
403 {
404 uint16_t *v = pv;
405 uint16_t v2;
406 qemu_get_be16s(f, &v2);
407
408 if (*v == v2) {
409 return 0;
410 }
411 error_report("%x != %x", *v, v2);
412 if (field->err_hint) {
413 error_printf("%s\n", field->err_hint);
414 }
415 return -EINVAL;
416 }
417
418 const VMStateInfo vmstate_info_uint16_equal = {
419 .name = "uint16 equal",
420 .get = get_uint16_equal,
421 .put = put_uint16,
422 };
423
424 /* CPU_DoubleU type */
425
426 static int get_cpudouble(QEMUFile *f, void *pv, size_t size,
427 const VMStateField *field)
428 {
429 CPU_DoubleU *v = pv;
430 qemu_get_be32s(f, &v->l.upper);
431 qemu_get_be32s(f, &v->l.lower);
432 return 0;
433 }
434
435 static int put_cpudouble(QEMUFile *f, void *pv, size_t size,
436 const VMStateField *field, JSONWriter *vmdesc)
437 {
438 CPU_DoubleU *v = pv;
439 qemu_put_be32s(f, &v->l.upper);
440 qemu_put_be32s(f, &v->l.lower);
441 return 0;
442 }
443
444 const VMStateInfo vmstate_info_cpudouble = {
445 .name = "CPU_Double_U",
446 .get = get_cpudouble,
447 .put = put_cpudouble,
448 };
449
450 /* uint8_t buffers */
451
452 static int get_buffer(QEMUFile *f, void *pv, size_t size,
453 const VMStateField *field)
454 {
455 uint8_t *v = pv;
456 qemu_get_buffer(f, v, size);
457 return 0;
458 }
459
460 static int put_buffer(QEMUFile *f, void *pv, size_t size,
461 const VMStateField *field, JSONWriter *vmdesc)
462 {
463 uint8_t *v = pv;
464 qemu_put_buffer(f, v, size);
465 return 0;
466 }
467
468 const VMStateInfo vmstate_info_buffer = {
469 .name = "buffer",
470 .get = get_buffer,
471 .put = put_buffer,
472 };
473
474 /* unused buffers: space that was used for some fields that are
475 not useful anymore */
476
477 static int get_unused_buffer(QEMUFile *f, void *pv, size_t size,
478 const VMStateField *field)
479 {
480 uint8_t buf[1024];
481 int block_len;
482
483 while (size > 0) {
484 block_len = MIN(sizeof(buf), size);
485 size -= block_len;
486 qemu_get_buffer(f, buf, block_len);
487 }
488 return 0;
489 }
490
491 static int put_unused_buffer(QEMUFile *f, void *pv, size_t size,
492 const VMStateField *field, JSONWriter *vmdesc)
493 {
494 static const uint8_t buf[1024];
495 int block_len;
496
497 while (size > 0) {
498 block_len = MIN(sizeof(buf), size);
499 size -= block_len;
500 qemu_put_buffer(f, buf, block_len);
501 }
502
503 return 0;
504 }
505
506 const VMStateInfo vmstate_info_unused_buffer = {
507 .name = "unused_buffer",
508 .get = get_unused_buffer,
509 .put = put_unused_buffer,
510 };
511
512 /* vmstate_info_tmp, see VMSTATE_WITH_TMP, the idea is that we allocate
513 * a temporary buffer and the pre_load/pre_save methods in the child vmsd
514 * copy stuff from the parent into the child and do calculations to fill
515 * in fields that don't really exist in the parent but need to be in the
516 * stream.
517 */
518 static int get_tmp(QEMUFile *f, void *pv, size_t size,
519 const VMStateField *field)
520 {
521 int ret;
522 const VMStateDescription *vmsd = field->vmsd;
523 int version_id = field->version_id;
524 void *tmp = g_malloc(size);
525
526 /* Writes the parent field which is at the start of the tmp */
527 *(void **)tmp = pv;
528 ret = vmstate_load_state(f, vmsd, tmp, version_id);
529 g_free(tmp);
530 return ret;
531 }
532
533 static int put_tmp(QEMUFile *f, void *pv, size_t size,
534 const VMStateField *field, JSONWriter *vmdesc)
535 {
536 const VMStateDescription *vmsd = field->vmsd;
537 void *tmp = g_malloc(size);
538 int ret;
539
540 /* Writes the parent field which is at the start of the tmp */
541 *(void **)tmp = pv;
542 ret = vmstate_save_state(f, vmsd, tmp, vmdesc);
543 g_free(tmp);
544
545 return ret;
546 }
547
548 const VMStateInfo vmstate_info_tmp = {
549 .name = "tmp",
550 .get = get_tmp,
551 .put = put_tmp,
552 };
553
554 /* bitmaps (as defined by bitmap.h). Note that size here is the size
555 * of the bitmap in bits. The on-the-wire format of a bitmap is 64
556 * bit words with the bits in big endian order. The in-memory format
557 * is an array of 'unsigned long', which may be either 32 or 64 bits.
558 */
559 /* This is the number of 64 bit words sent over the wire */
560 #define BITS_TO_U64S(nr) DIV_ROUND_UP(nr, 64)
561 static int get_bitmap(QEMUFile *f, void *pv, size_t size,
562 const VMStateField *field)
563 {
564 unsigned long *bmp = pv;
565 int i, idx = 0;
566 for (i = 0; i < BITS_TO_U64S(size); i++) {
567 uint64_t w = qemu_get_be64(f);
568 bmp[idx++] = w;
569 if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
570 bmp[idx++] = w >> 32;
571 }
572 }
573 return 0;
574 }
575
576 static int put_bitmap(QEMUFile *f, void *pv, size_t size,
577 const VMStateField *field, JSONWriter *vmdesc)
578 {
579 unsigned long *bmp = pv;
580 int i, idx = 0;
581 for (i = 0; i < BITS_TO_U64S(size); i++) {
582 uint64_t w = bmp[idx++];
583 if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
584 w |= ((uint64_t)bmp[idx++]) << 32;
585 }
586 qemu_put_be64(f, w);
587 }
588
589 return 0;
590 }
591
592 const VMStateInfo vmstate_info_bitmap = {
593 .name = "bitmap",
594 .get = get_bitmap,
595 .put = put_bitmap,
596 };
597
598 /* get for QTAILQ
599 * meta data about the QTAILQ is encoded in a VMStateField structure
600 */
601 static int get_qtailq(QEMUFile *f, void *pv, size_t unused_size,
602 const VMStateField *field)
603 {
604 int ret = 0;
605 const VMStateDescription *vmsd = field->vmsd;
606 /* size of a QTAILQ element */
607 size_t size = field->size;
608 /* offset of the QTAILQ entry in a QTAILQ element */
609 size_t entry_offset = field->start;
610 int version_id = field->version_id;
611 void *elm;
612
613 trace_get_qtailq(vmsd->name, version_id);
614 if (version_id > vmsd->version_id) {
615 error_report("%s %s", vmsd->name, "too new");
616 trace_get_qtailq_end(vmsd->name, "too new", -EINVAL);
617
618 return -EINVAL;
619 }
620 if (version_id < vmsd->minimum_version_id) {
621 error_report("%s %s", vmsd->name, "too old");
622 trace_get_qtailq_end(vmsd->name, "too old", -EINVAL);
623 return -EINVAL;
624 }
625
626 while (qemu_get_byte(f)) {
627 elm = g_malloc(size);
628 ret = vmstate_load_state(f, vmsd, elm, version_id);
629 if (ret) {
630 return ret;
631 }
632 QTAILQ_RAW_INSERT_TAIL(pv, elm, entry_offset);
633 }
634
635 trace_get_qtailq_end(vmsd->name, "end", ret);
636 return ret;
637 }
638
639 /* put for QTAILQ */
640 static int put_qtailq(QEMUFile *f, void *pv, size_t unused_size,
641 const VMStateField *field, JSONWriter *vmdesc)
642 {
643 const VMStateDescription *vmsd = field->vmsd;
644 /* offset of the QTAILQ entry in a QTAILQ element*/
645 size_t entry_offset = field->start;
646 void *elm;
647 int ret;
648
649 trace_put_qtailq(vmsd->name, vmsd->version_id);
650
651 QTAILQ_RAW_FOREACH(elm, pv, entry_offset) {
652 qemu_put_byte(f, true);
653 ret = vmstate_save_state(f, vmsd, elm, vmdesc);
654 if (ret) {
655 return ret;
656 }
657 }
658 qemu_put_byte(f, false);
659
660 trace_put_qtailq_end(vmsd->name, "end");
661
662 return 0;
663 }
664 const VMStateInfo vmstate_info_qtailq = {
665 .name = "qtailq",
666 .get = get_qtailq,
667 .put = put_qtailq,
668 };
669
670 struct put_gtree_data {
671 QEMUFile *f;
672 const VMStateDescription *key_vmsd;
673 const VMStateDescription *val_vmsd;
674 JSONWriter *vmdesc;
675 int ret;
676 };
677
678 static gboolean put_gtree_elem(gpointer key, gpointer value, gpointer data)
679 {
680 struct put_gtree_data *capsule = (struct put_gtree_data *)data;
681 QEMUFile *f = capsule->f;
682 int ret;
683
684 qemu_put_byte(f, true);
685
686 /* put the key */
687 if (!capsule->key_vmsd) {
688 qemu_put_be64(f, (uint64_t)(uintptr_t)(key)); /* direct key */
689 } else {
690 ret = vmstate_save_state(f, capsule->key_vmsd, key, capsule->vmdesc);
691 if (ret) {
692 capsule->ret = ret;
693 return true;
694 }
695 }
696
697 /* put the data */
698 ret = vmstate_save_state(f, capsule->val_vmsd, value, capsule->vmdesc);
699 if (ret) {
700 capsule->ret = ret;
701 return true;
702 }
703 return false;
704 }
705
706 static int put_gtree(QEMUFile *f, void *pv, size_t unused_size,
707 const VMStateField *field, JSONWriter *vmdesc)
708 {
709 bool direct_key = (!field->start);
710 const VMStateDescription *key_vmsd = direct_key ? NULL : &field->vmsd[1];
711 const VMStateDescription *val_vmsd = &field->vmsd[0];
712 const char *key_vmsd_name = direct_key ? "direct" : key_vmsd->name;
713 struct put_gtree_data capsule = {
714 .f = f,
715 .key_vmsd = key_vmsd,
716 .val_vmsd = val_vmsd,
717 .vmdesc = vmdesc,
718 .ret = 0};
719 GTree **pval = pv;
720 GTree *tree = *pval;
721 uint32_t nnodes = g_tree_nnodes(tree);
722 int ret;
723
724 trace_put_gtree(field->name, key_vmsd_name, val_vmsd->name, nnodes);
725 qemu_put_be32(f, nnodes);
726 g_tree_foreach(tree, put_gtree_elem, (gpointer)&capsule);
727 qemu_put_byte(f, false);
728 ret = capsule.ret;
729 if (ret) {
730 error_report("%s : failed to save gtree (%d)", field->name, ret);
731 }
732 trace_put_gtree_end(field->name, key_vmsd_name, val_vmsd->name, ret);
733 return ret;
734 }
735
736 static int get_gtree(QEMUFile *f, void *pv, size_t unused_size,
737 const VMStateField *field)
738 {
739 bool direct_key = (!field->start);
740 const VMStateDescription *key_vmsd = direct_key ? NULL : &field->vmsd[1];
741 const VMStateDescription *val_vmsd = &field->vmsd[0];
742 const char *key_vmsd_name = direct_key ? "direct" : key_vmsd->name;
743 int version_id = field->version_id;
744 size_t key_size = field->start;
745 size_t val_size = field->size;
746 int nnodes, count = 0;
747 GTree **pval = pv;
748 GTree *tree = *pval;
749 void *key, *val;
750 int ret = 0;
751
752 /* in case of direct key, the key vmsd can be {}, ie. check fields */
753 if (!direct_key && version_id > key_vmsd->version_id) {
754 error_report("%s %s", key_vmsd->name, "too new");
755 return -EINVAL;
756 }
757 if (!direct_key && version_id < key_vmsd->minimum_version_id) {
758 error_report("%s %s", key_vmsd->name, "too old");
759 return -EINVAL;
760 }
761 if (version_id > val_vmsd->version_id) {
762 error_report("%s %s", val_vmsd->name, "too new");
763 return -EINVAL;
764 }
765 if (version_id < val_vmsd->minimum_version_id) {
766 error_report("%s %s", val_vmsd->name, "too old");
767 return -EINVAL;
768 }
769
770 nnodes = qemu_get_be32(f);
771 trace_get_gtree(field->name, key_vmsd_name, val_vmsd->name, nnodes);
772
773 while (qemu_get_byte(f)) {
774 if ((++count) > nnodes) {
775 ret = -EINVAL;
776 break;
777 }
778 if (direct_key) {
779 key = (void *)(uintptr_t)qemu_get_be64(f);
780 } else {
781 key = g_malloc0(key_size);
782 ret = vmstate_load_state(f, key_vmsd, key, version_id);
783 if (ret) {
784 error_report("%s : failed to load %s (%d)",
785 field->name, key_vmsd->name, ret);
786 goto key_error;
787 }
788 }
789 val = g_malloc0(val_size);
790 ret = vmstate_load_state(f, val_vmsd, val, version_id);
791 if (ret) {
792 error_report("%s : failed to load %s (%d)",
793 field->name, val_vmsd->name, ret);
794 goto val_error;
795 }
796 g_tree_insert(tree, key, val);
797 }
798 if (count != nnodes) {
799 error_report("%s inconsistent stream when loading the gtree",
800 field->name);
801 return -EINVAL;
802 }
803 trace_get_gtree_end(field->name, key_vmsd_name, val_vmsd->name, ret);
804 return ret;
805 val_error:
806 g_free(val);
807 key_error:
808 if (!direct_key) {
809 g_free(key);
810 }
811 trace_get_gtree_end(field->name, key_vmsd_name, val_vmsd->name, ret);
812 return ret;
813 }
814
815
816 const VMStateInfo vmstate_info_gtree = {
817 .name = "gtree",
818 .get = get_gtree,
819 .put = put_gtree,
820 };
821
822 static int put_qlist(QEMUFile *f, void *pv, size_t unused_size,
823 const VMStateField *field, JSONWriter *vmdesc)
824 {
825 const VMStateDescription *vmsd = field->vmsd;
826 /* offset of the QTAILQ entry in a QTAILQ element*/
827 size_t entry_offset = field->start;
828 void *elm;
829 int ret;
830
831 trace_put_qlist(field->name, vmsd->name, vmsd->version_id);
832 QLIST_RAW_FOREACH(elm, pv, entry_offset) {
833 qemu_put_byte(f, true);
834 ret = vmstate_save_state(f, vmsd, elm, vmdesc);
835 if (ret) {
836 error_report("%s: failed to save %s (%d)", field->name,
837 vmsd->name, ret);
838 return ret;
839 }
840 }
841 qemu_put_byte(f, false);
842 trace_put_qlist_end(field->name, vmsd->name);
843
844 return 0;
845 }
846
847 static int get_qlist(QEMUFile *f, void *pv, size_t unused_size,
848 const VMStateField *field)
849 {
850 int ret = 0;
851 const VMStateDescription *vmsd = field->vmsd;
852 /* size of a QLIST element */
853 size_t size = field->size;
854 /* offset of the QLIST entry in a QLIST element */
855 size_t entry_offset = field->start;
856 int version_id = field->version_id;
857 void *elm, *prev = NULL;
858
859 trace_get_qlist(field->name, vmsd->name, vmsd->version_id);
860 if (version_id > vmsd->version_id) {
861 error_report("%s %s", vmsd->name, "too new");
862 return -EINVAL;
863 }
864 if (version_id < vmsd->minimum_version_id) {
865 error_report("%s %s", vmsd->name, "too old");
866 return -EINVAL;
867 }
868
869 while (qemu_get_byte(f)) {
870 elm = g_malloc(size);
871 ret = vmstate_load_state(f, vmsd, elm, version_id);
872 if (ret) {
873 error_report("%s: failed to load %s (%d)", field->name,
874 vmsd->name, ret);
875 g_free(elm);
876 return ret;
877 }
878 if (!prev) {
879 QLIST_RAW_INSERT_HEAD(pv, elm, entry_offset);
880 } else {
881 QLIST_RAW_INSERT_AFTER(pv, prev, elm, entry_offset);
882 }
883 prev = elm;
884 }
885 trace_get_qlist_end(field->name, vmsd->name);
886
887 return ret;
888 }
889
890 const VMStateInfo vmstate_info_qlist = {
891 .name = "qlist",
892 .get = get_qlist,
893 .put = put_qlist,
894 };