1 #include "qemu/osdep.h"
2 #include "qemu-common.h"
3 #include "migration/migration.h"
4 #include "migration/qemu-file.h"
5 #include "migration/vmstate.h"
6 #include "qemu/bitops.h"
7 #include "qemu/error-report.h"
8 #include "qemu/queue.h"
10 #include "migration/qjson.h"
12 static void vmstate_subsection_save(QEMUFile
*f
, const VMStateDescription
*vmsd
,
13 void *opaque
, QJSON
*vmdesc
);
14 static int vmstate_subsection_load(QEMUFile
*f
, const VMStateDescription
*vmsd
,
17 static int vmstate_n_elems(void *opaque
, VMStateField
*field
)
21 if (field
->flags
& VMS_ARRAY
) {
23 } else if (field
->flags
& VMS_VARRAY_INT32
) {
24 n_elems
= *(int32_t *)(opaque
+field
->num_offset
);
25 } else if (field
->flags
& VMS_VARRAY_UINT32
) {
26 n_elems
= *(uint32_t *)(opaque
+field
->num_offset
);
27 } else if (field
->flags
& VMS_VARRAY_UINT16
) {
28 n_elems
= *(uint16_t *)(opaque
+field
->num_offset
);
29 } else if (field
->flags
& VMS_VARRAY_UINT8
) {
30 n_elems
= *(uint8_t *)(opaque
+field
->num_offset
);
33 if (field
->flags
& VMS_MULTIPLY_ELEMENTS
) {
34 n_elems
*= field
->num
;
37 trace_vmstate_n_elems(field
->name
, n_elems
);
41 static int vmstate_size(void *opaque
, VMStateField
*field
)
43 int size
= field
->size
;
45 if (field
->flags
& VMS_VBUFFER
) {
46 size
= *(int32_t *)(opaque
+field
->size_offset
);
47 if (field
->flags
& VMS_MULTIPLY
) {
55 static void *vmstate_base_addr(void *opaque
, VMStateField
*field
, bool alloc
)
57 void *base_addr
= opaque
+ field
->offset
;
59 if (field
->flags
& VMS_POINTER
) {
60 if (alloc
&& (field
->flags
& VMS_ALLOC
)) {
62 if (field
->flags
& VMS_VBUFFER
) {
63 size
= vmstate_size(opaque
, field
);
65 int n_elems
= vmstate_n_elems(opaque
, field
);
67 size
= n_elems
* field
->size
;
71 *((void **)base_addr
+ field
->start
) = g_malloc(size
);
74 base_addr
= *(void **)base_addr
+ field
->start
;
80 int vmstate_load_state(QEMUFile
*f
, const VMStateDescription
*vmsd
,
81 void *opaque
, int version_id
)
83 VMStateField
*field
= vmsd
->fields
;
86 trace_vmstate_load_state(vmsd
->name
, version_id
);
87 if (version_id
> vmsd
->version_id
) {
88 error_report("%s: incoming version_id %d is too new "
89 "for local version_id %d",
90 vmsd
->name
, version_id
, vmsd
->version_id
);
91 trace_vmstate_load_state_end(vmsd
->name
, "too new", -EINVAL
);
94 if (version_id
< vmsd
->minimum_version_id
) {
95 if (vmsd
->load_state_old
&&
96 version_id
>= vmsd
->minimum_version_id_old
) {
97 ret
= vmsd
->load_state_old(f
, opaque
, version_id
);
98 trace_vmstate_load_state_end(vmsd
->name
, "old path", ret
);
101 error_report("%s: incoming version_id %d is too old "
102 "for local minimum version_id %d",
103 vmsd
->name
, version_id
, vmsd
->minimum_version_id
);
104 trace_vmstate_load_state_end(vmsd
->name
, "too old", -EINVAL
);
107 if (vmsd
->pre_load
) {
108 int ret
= vmsd
->pre_load(opaque
);
113 while (field
->name
) {
114 trace_vmstate_load_state_field(vmsd
->name
, field
->name
);
115 if ((field
->field_exists
&&
116 field
->field_exists(opaque
, version_id
)) ||
117 (!field
->field_exists
&&
118 field
->version_id
<= version_id
)) {
119 void *base_addr
= vmstate_base_addr(opaque
, field
, true);
120 int i
, n_elems
= vmstate_n_elems(opaque
, field
);
121 int size
= vmstate_size(opaque
, field
);
123 for (i
= 0; i
< n_elems
; i
++) {
124 void *addr
= base_addr
+ size
* i
;
126 if (field
->flags
& VMS_ARRAY_OF_POINTER
) {
127 addr
= *(void **)addr
;
129 if (field
->flags
& VMS_STRUCT
) {
130 ret
= vmstate_load_state(f
, field
->vmsd
, addr
,
131 field
->vmsd
->version_id
);
133 ret
= field
->info
->get(f
, addr
, size
, field
);
136 ret
= qemu_file_get_error(f
);
139 qemu_file_set_error(f
, ret
);
140 error_report("Failed to load %s:%s", vmsd
->name
,
142 trace_vmstate_load_field_error(field
->name
, ret
);
146 } else if (field
->flags
& VMS_MUST_EXIST
) {
147 error_report("Input validation failed: %s/%s",
148 vmsd
->name
, field
->name
);
153 ret
= vmstate_subsection_load(f
, vmsd
, opaque
);
157 if (vmsd
->post_load
) {
158 ret
= vmsd
->post_load(opaque
, version_id
);
160 trace_vmstate_load_state_end(vmsd
->name
, "end", ret
);
164 static int vmfield_name_num(VMStateField
*start
, VMStateField
*search
)
169 for (field
= start
; field
->name
; field
++) {
170 if (!strcmp(field
->name
, search
->name
)) {
171 if (field
== search
) {
181 static bool vmfield_name_is_unique(VMStateField
*start
, VMStateField
*search
)
186 for (field
= start
; field
->name
; field
++) {
187 if (!strcmp(field
->name
, search
->name
)) {
189 /* name found more than once, so it's not unique */
199 static const char *vmfield_get_type_name(VMStateField
*field
)
201 const char *type
= "unknown";
203 if (field
->flags
& VMS_STRUCT
) {
205 } else if (field
->info
->name
) {
206 type
= field
->info
->name
;
212 static bool vmsd_can_compress(VMStateField
*field
)
214 if (field
->field_exists
) {
215 /* Dynamically existing fields mess up compression */
219 if (field
->flags
& VMS_STRUCT
) {
220 VMStateField
*sfield
= field
->vmsd
->fields
;
221 while (sfield
->name
) {
222 if (!vmsd_can_compress(sfield
)) {
223 /* Child elements can't compress, so can't we */
229 if (field
->vmsd
->subsections
) {
230 /* Subsections may come and go, better don't compress */
238 static void vmsd_desc_field_start(const VMStateDescription
*vmsd
, QJSON
*vmdesc
,
239 VMStateField
*field
, int i
, int max
)
241 char *name
, *old_name
;
242 bool is_array
= max
> 1;
243 bool can_compress
= vmsd_can_compress(field
);
249 name
= g_strdup(field
->name
);
251 /* Field name is not unique, need to make it unique */
252 if (!vmfield_name_is_unique(vmsd
->fields
, field
)) {
253 int num
= vmfield_name_num(vmsd
->fields
, field
);
255 name
= g_strdup_printf("%s[%d]", name
, num
);
259 json_start_object(vmdesc
, NULL
);
260 json_prop_str(vmdesc
, "name", name
);
263 json_prop_int(vmdesc
, "array_len", max
);
265 json_prop_int(vmdesc
, "index", i
);
268 json_prop_str(vmdesc
, "type", vmfield_get_type_name(field
));
270 if (field
->flags
& VMS_STRUCT
) {
271 json_start_object(vmdesc
, "struct");
277 static void vmsd_desc_field_end(const VMStateDescription
*vmsd
, QJSON
*vmdesc
,
278 VMStateField
*field
, size_t size
, int i
)
284 if (field
->flags
& VMS_STRUCT
) {
285 /* We printed a struct in between, close its child object */
286 json_end_object(vmdesc
);
289 json_prop_int(vmdesc
, "size", size
);
290 json_end_object(vmdesc
);
294 bool vmstate_save_needed(const VMStateDescription
*vmsd
, void *opaque
)
296 if (vmsd
->needed
&& !vmsd
->needed(opaque
)) {
297 /* optional section not needed */
304 void vmstate_save_state(QEMUFile
*f
, const VMStateDescription
*vmsd
,
305 void *opaque
, QJSON
*vmdesc
)
307 VMStateField
*field
= vmsd
->fields
;
309 if (vmsd
->pre_save
) {
310 vmsd
->pre_save(opaque
);
314 json_prop_str(vmdesc
, "vmsd_name", vmsd
->name
);
315 json_prop_int(vmdesc
, "version", vmsd
->version_id
);
316 json_start_array(vmdesc
, "fields");
319 while (field
->name
) {
320 if (!field
->field_exists
||
321 field
->field_exists(opaque
, vmsd
->version_id
)) {
322 void *base_addr
= vmstate_base_addr(opaque
, field
, false);
323 int i
, n_elems
= vmstate_n_elems(opaque
, field
);
324 int size
= vmstate_size(opaque
, field
);
325 int64_t old_offset
, written_bytes
;
326 QJSON
*vmdesc_loop
= vmdesc
;
328 for (i
= 0; i
< n_elems
; i
++) {
329 void *addr
= base_addr
+ size
* i
;
331 vmsd_desc_field_start(vmsd
, vmdesc_loop
, field
, i
, n_elems
);
332 old_offset
= qemu_ftell_fast(f
);
334 if (field
->flags
& VMS_ARRAY_OF_POINTER
) {
335 addr
= *(void **)addr
;
337 if (field
->flags
& VMS_STRUCT
) {
338 vmstate_save_state(f
, field
->vmsd
, addr
, vmdesc_loop
);
340 field
->info
->put(f
, addr
, size
, field
, vmdesc_loop
);
343 written_bytes
= qemu_ftell_fast(f
) - old_offset
;
344 vmsd_desc_field_end(vmsd
, vmdesc_loop
, field
, written_bytes
, i
);
346 /* Compressed arrays only care about the first element */
347 if (vmdesc_loop
&& vmsd_can_compress(field
)) {
352 if (field
->flags
& VMS_MUST_EXIST
) {
353 error_report("Output state validation failed: %s/%s",
354 vmsd
->name
, field
->name
);
355 assert(!(field
->flags
& VMS_MUST_EXIST
));
362 json_end_array(vmdesc
);
365 vmstate_subsection_save(f
, vmsd
, opaque
, vmdesc
);
368 static const VMStateDescription
*
369 vmstate_get_subsection(const VMStateDescription
**sub
, char *idstr
)
371 while (sub
&& *sub
&& (*sub
)->needed
) {
372 if (strcmp(idstr
, (*sub
)->name
) == 0) {
380 static int vmstate_subsection_load(QEMUFile
*f
, const VMStateDescription
*vmsd
,
383 trace_vmstate_subsection_load(vmsd
->name
);
385 while (qemu_peek_byte(f
, 0) == QEMU_VM_SUBSECTION
) {
386 char idstr
[256], *idstr_ret
;
388 uint8_t version_id
, len
, size
;
389 const VMStateDescription
*sub_vmsd
;
391 len
= qemu_peek_byte(f
, 1);
392 if (len
< strlen(vmsd
->name
) + 1) {
393 /* subsection name has be be "section_name/a" */
394 trace_vmstate_subsection_load_bad(vmsd
->name
, "(short)", "");
397 size
= qemu_peek_buffer(f
, (uint8_t **)&idstr_ret
, len
, 2);
399 trace_vmstate_subsection_load_bad(vmsd
->name
, "(peek fail)", "");
402 memcpy(idstr
, idstr_ret
, size
);
405 if (strncmp(vmsd
->name
, idstr
, strlen(vmsd
->name
)) != 0) {
406 trace_vmstate_subsection_load_bad(vmsd
->name
, idstr
, "(prefix)");
407 /* it doesn't have a valid subsection name */
410 sub_vmsd
= vmstate_get_subsection(vmsd
->subsections
, idstr
);
411 if (sub_vmsd
== NULL
) {
412 trace_vmstate_subsection_load_bad(vmsd
->name
, idstr
, "(lookup)");
415 qemu_file_skip(f
, 1); /* subsection */
416 qemu_file_skip(f
, 1); /* len */
417 qemu_file_skip(f
, len
); /* idstr */
418 version_id
= qemu_get_be32(f
);
420 ret
= vmstate_load_state(f
, sub_vmsd
, opaque
, version_id
);
422 trace_vmstate_subsection_load_bad(vmsd
->name
, idstr
, "(child)");
427 trace_vmstate_subsection_load_good(vmsd
->name
);
431 static void vmstate_subsection_save(QEMUFile
*f
, const VMStateDescription
*vmsd
,
432 void *opaque
, QJSON
*vmdesc
)
434 const VMStateDescription
**sub
= vmsd
->subsections
;
435 bool subsection_found
= false;
437 while (sub
&& *sub
&& (*sub
)->needed
) {
438 if ((*sub
)->needed(opaque
)) {
439 const VMStateDescription
*vmsd
= *sub
;
443 /* Only create subsection array when we have any */
444 if (!subsection_found
) {
445 json_start_array(vmdesc
, "subsections");
446 subsection_found
= true;
449 json_start_object(vmdesc
, NULL
);
452 qemu_put_byte(f
, QEMU_VM_SUBSECTION
);
453 len
= strlen(vmsd
->name
);
454 qemu_put_byte(f
, len
);
455 qemu_put_buffer(f
, (uint8_t *)vmsd
->name
, len
);
456 qemu_put_be32(f
, vmsd
->version_id
);
457 vmstate_save_state(f
, vmsd
, opaque
, vmdesc
);
460 json_end_object(vmdesc
);
466 if (vmdesc
&& subsection_found
) {
467 json_end_array(vmdesc
);
473 static int get_bool(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
)
476 *v
= qemu_get_byte(f
);
480 static int put_bool(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
,
484 qemu_put_byte(f
, *v
);
488 const VMStateInfo vmstate_info_bool
= {
496 static int get_int8(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
)
503 static int put_int8(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
,
511 const VMStateInfo vmstate_info_int8
= {
519 static int get_int16(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
)
522 qemu_get_sbe16s(f
, v
);
526 static int put_int16(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
,
530 qemu_put_sbe16s(f
, v
);
534 const VMStateInfo vmstate_info_int16
= {
542 static int get_int32(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
)
545 qemu_get_sbe32s(f
, v
);
549 static int put_int32(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
,
553 qemu_put_sbe32s(f
, v
);
557 const VMStateInfo vmstate_info_int32
= {
563 /* 32 bit int. See that the received value is the same than the one
566 static int get_int32_equal(QEMUFile
*f
, void *pv
, size_t size
,
571 qemu_get_sbe32s(f
, &v2
);
576 error_report("%" PRIx32
" != %" PRIx32
, *v
, v2
);
580 const VMStateInfo vmstate_info_int32_equal
= {
581 .name
= "int32 equal",
582 .get
= get_int32_equal
,
586 /* 32 bit int. Check that the received value is non-negative
587 * and less than or equal to the one in the field.
590 static int get_int32_le(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
)
594 qemu_get_sbe32s(f
, &loaded
);
596 if (loaded
>= 0 && loaded
<= *cur
) {
600 error_report("Invalid value %" PRId32
601 " expecting positive value <= %" PRId32
,
606 const VMStateInfo vmstate_info_int32_le
= {
614 static int get_int64(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
)
617 qemu_get_sbe64s(f
, v
);
621 static int put_int64(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
,
625 qemu_put_sbe64s(f
, v
);
629 const VMStateInfo vmstate_info_int64
= {
635 /* 8 bit unsigned int */
637 static int get_uint8(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
)
644 static int put_uint8(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
,
652 const VMStateInfo vmstate_info_uint8
= {
658 /* 16 bit unsigned int */
660 static int get_uint16(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
)
663 qemu_get_be16s(f
, v
);
667 static int put_uint16(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
,
671 qemu_put_be16s(f
, v
);
675 const VMStateInfo vmstate_info_uint16
= {
681 /* 32 bit unsigned int */
683 static int get_uint32(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
)
686 qemu_get_be32s(f
, v
);
690 static int put_uint32(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
,
694 qemu_put_be32s(f
, v
);
698 const VMStateInfo vmstate_info_uint32
= {
704 /* 32 bit uint. See that the received value is the same than the one
707 static int get_uint32_equal(QEMUFile
*f
, void *pv
, size_t size
,
712 qemu_get_be32s(f
, &v2
);
717 error_report("%" PRIx32
" != %" PRIx32
, *v
, v2
);
721 const VMStateInfo vmstate_info_uint32_equal
= {
722 .name
= "uint32 equal",
723 .get
= get_uint32_equal
,
727 /* 64 bit unsigned int */
729 static int get_uint64(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
)
732 qemu_get_be64s(f
, v
);
736 static int put_uint64(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
,
740 qemu_put_be64s(f
, v
);
744 const VMStateInfo vmstate_info_uint64
= {
750 /* 64 bit unsigned int. See that the received value is the same than the one
753 static int get_uint64_equal(QEMUFile
*f
, void *pv
, size_t size
,
758 qemu_get_be64s(f
, &v2
);
763 error_report("%" PRIx64
" != %" PRIx64
, *v
, v2
);
767 const VMStateInfo vmstate_info_uint64_equal
= {
768 .name
= "int64 equal",
769 .get
= get_uint64_equal
,
773 /* 8 bit int. See that the received value is the same than the one
776 static int get_uint8_equal(QEMUFile
*f
, void *pv
, size_t size
,
786 error_report("%x != %x", *v
, v2
);
790 const VMStateInfo vmstate_info_uint8_equal
= {
791 .name
= "uint8 equal",
792 .get
= get_uint8_equal
,
796 /* 16 bit unsigned int int. See that the received value is the same than the one
799 static int get_uint16_equal(QEMUFile
*f
, void *pv
, size_t size
,
804 qemu_get_be16s(f
, &v2
);
809 error_report("%x != %x", *v
, v2
);
813 const VMStateInfo vmstate_info_uint16_equal
= {
814 .name
= "uint16 equal",
815 .get
= get_uint16_equal
,
821 static int get_float64(QEMUFile
*f
, void *pv
, size_t size
,
826 *v
= make_float64(qemu_get_be64(f
));
830 static int put_float64(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
,
835 qemu_put_be64(f
, float64_val(*v
));
839 const VMStateInfo vmstate_info_float64
= {
845 /* CPU_DoubleU type */
847 static int get_cpudouble(QEMUFile
*f
, void *pv
, size_t size
,
851 qemu_get_be32s(f
, &v
->l
.upper
);
852 qemu_get_be32s(f
, &v
->l
.lower
);
856 static int put_cpudouble(QEMUFile
*f
, void *pv
, size_t size
,
857 VMStateField
*field
, QJSON
*vmdesc
)
860 qemu_put_be32s(f
, &v
->l
.upper
);
861 qemu_put_be32s(f
, &v
->l
.lower
);
865 const VMStateInfo vmstate_info_cpudouble
= {
866 .name
= "CPU_Double_U",
867 .get
= get_cpudouble
,
868 .put
= put_cpudouble
,
871 /* uint8_t buffers */
873 static int get_buffer(QEMUFile
*f
, void *pv
, size_t size
,
877 qemu_get_buffer(f
, v
, size
);
881 static int put_buffer(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
,
885 qemu_put_buffer(f
, v
, size
);
889 const VMStateInfo vmstate_info_buffer
= {
895 /* unused buffers: space that was used for some fields that are
896 not useful anymore */
898 static int get_unused_buffer(QEMUFile
*f
, void *pv
, size_t size
,
905 block_len
= MIN(sizeof(buf
), size
);
907 qemu_get_buffer(f
, buf
, block_len
);
912 static int put_unused_buffer(QEMUFile
*f
, void *pv
, size_t size
,
913 VMStateField
*field
, QJSON
*vmdesc
)
915 static const uint8_t buf
[1024];
919 block_len
= MIN(sizeof(buf
), size
);
921 qemu_put_buffer(f
, buf
, block_len
);
927 const VMStateInfo vmstate_info_unused_buffer
= {
928 .name
= "unused_buffer",
929 .get
= get_unused_buffer
,
930 .put
= put_unused_buffer
,
933 /* bitmaps (as defined by bitmap.h). Note that size here is the size
934 * of the bitmap in bits. The on-the-wire format of a bitmap is 64
935 * bit words with the bits in big endian order. The in-memory format
936 * is an array of 'unsigned long', which may be either 32 or 64 bits.
938 /* This is the number of 64 bit words sent over the wire */
939 #define BITS_TO_U64S(nr) DIV_ROUND_UP(nr, 64)
940 static int get_bitmap(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
)
942 unsigned long *bmp
= pv
;
944 for (i
= 0; i
< BITS_TO_U64S(size
); i
++) {
945 uint64_t w
= qemu_get_be64(f
);
947 if (sizeof(unsigned long) == 4 && idx
< BITS_TO_LONGS(size
)) {
948 bmp
[idx
++] = w
>> 32;
954 static int put_bitmap(QEMUFile
*f
, void *pv
, size_t size
, VMStateField
*field
,
957 unsigned long *bmp
= pv
;
959 for (i
= 0; i
< BITS_TO_U64S(size
); i
++) {
960 uint64_t w
= bmp
[idx
++];
961 if (sizeof(unsigned long) == 4 && idx
< BITS_TO_LONGS(size
)) {
962 w
|= ((uint64_t)bmp
[idx
++]) << 32;
970 const VMStateInfo vmstate_info_bitmap
= {
977 * meta data about the QTAILQ is encoded in a VMStateField structure
979 static int get_qtailq(QEMUFile
*f
, void *pv
, size_t unused_size
,
983 const VMStateDescription
*vmsd
= field
->vmsd
;
984 /* size of a QTAILQ element */
985 size_t size
= field
->size
;
986 /* offset of the QTAILQ entry in a QTAILQ element */
987 size_t entry_offset
= field
->start
;
988 int version_id
= field
->version_id
;
991 trace_get_qtailq(vmsd
->name
, version_id
);
992 if (version_id
> vmsd
->version_id
) {
993 error_report("%s %s", vmsd
->name
, "too new");
994 trace_get_qtailq_end(vmsd
->name
, "too new", -EINVAL
);
998 if (version_id
< vmsd
->minimum_version_id
) {
999 error_report("%s %s", vmsd
->name
, "too old");
1000 trace_get_qtailq_end(vmsd
->name
, "too old", -EINVAL
);
1004 while (qemu_get_byte(f
)) {
1005 elm
= g_malloc(size
);
1006 ret
= vmstate_load_state(f
, vmsd
, elm
, version_id
);
1010 QTAILQ_RAW_INSERT_TAIL(pv
, elm
, entry_offset
);
1013 trace_get_qtailq_end(vmsd
->name
, "end", ret
);
1017 /* put for QTAILQ */
1018 static int put_qtailq(QEMUFile
*f
, void *pv
, size_t unused_size
,
1019 VMStateField
*field
, QJSON
*vmdesc
)
1021 const VMStateDescription
*vmsd
= field
->vmsd
;
1022 /* offset of the QTAILQ entry in a QTAILQ element*/
1023 size_t entry_offset
= field
->start
;
1026 trace_put_qtailq(vmsd
->name
, vmsd
->version_id
);
1028 QTAILQ_RAW_FOREACH(elm
, pv
, entry_offset
) {
1029 qemu_put_byte(f
, true);
1030 vmstate_save_state(f
, vmsd
, elm
, vmdesc
);
1032 qemu_put_byte(f
, false);
1034 trace_put_qtailq_end(vmsd
->name
, "end");
1038 const VMStateInfo vmstate_info_qtailq
= {