4 * Copyright (c) 2009-2017 Red Hat Inc
7 * Juan Quintela <quintela@redhat.com>
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.
13 #include "qemu/osdep.h"
14 #include "qemu-common.h"
15 #include "migration.h"
16 #include "migration/vmstate.h"
17 #include "migration/savevm.h"
18 #include "qemu-file.h"
19 #include "qemu/bitops.h"
20 #include "qemu/error-report.h"
24 static void vmstate_subsection_save(QEMUFile
*f
, const VMStateDescription
*vmsd
,
25 void *opaque
, QJSON
*vmdesc
);
26 static int vmstate_subsection_load(QEMUFile
*f
, const VMStateDescription
*vmsd
,
29 static int vmstate_n_elems(void *opaque
, VMStateField
*field
)
33 if (field
->flags
& VMS_ARRAY
) {
35 } else if (field
->flags
& VMS_VARRAY_INT32
) {
36 n_elems
= *(int32_t *)(opaque
+field
->num_offset
);
37 } else if (field
->flags
& VMS_VARRAY_UINT32
) {
38 n_elems
= *(uint32_t *)(opaque
+field
->num_offset
);
39 } else if (field
->flags
& VMS_VARRAY_UINT16
) {
40 n_elems
= *(uint16_t *)(opaque
+field
->num_offset
);
41 } else if (field
->flags
& VMS_VARRAY_UINT8
) {
42 n_elems
= *(uint8_t *)(opaque
+field
->num_offset
);
45 if (field
->flags
& VMS_MULTIPLY_ELEMENTS
) {
46 n_elems
*= field
->num
;
49 trace_vmstate_n_elems(field
->name
, n_elems
);
53 static int vmstate_size(void *opaque
, VMStateField
*field
)
55 int size
= field
->size
;
57 if (field
->flags
& VMS_VBUFFER
) {
58 size
= *(int32_t *)(opaque
+field
->size_offset
);
59 if (field
->flags
& VMS_MULTIPLY
) {
67 static void vmstate_handle_alloc(void *ptr
, VMStateField
*field
, void *opaque
)
69 if (field
->flags
& VMS_POINTER
&& field
->flags
& VMS_ALLOC
) {
70 gsize size
= vmstate_size(opaque
, field
);
71 size
*= vmstate_n_elems(opaque
, field
);
73 *(void **)ptr
= g_malloc(size
);
78 int vmstate_load_state(QEMUFile
*f
, const VMStateDescription
*vmsd
,
79 void *opaque
, int version_id
)
81 VMStateField
*field
= vmsd
->fields
;
84 trace_vmstate_load_state(vmsd
->name
, version_id
);
85 if (version_id
> vmsd
->version_id
) {
86 error_report("%s: incoming version_id %d is too new "
87 "for local version_id %d",
88 vmsd
->name
, version_id
, vmsd
->version_id
);
89 trace_vmstate_load_state_end(vmsd
->name
, "too new", -EINVAL
);
92 if (version_id
< vmsd
->minimum_version_id
) {
93 if (vmsd
->load_state_old
&&
94 version_id
>= vmsd
->minimum_version_id_old
) {
95 ret
= vmsd
->load_state_old(f
, opaque
, version_id
);
96 trace_vmstate_load_state_end(vmsd
->name
, "old path", ret
);
99 error_report("%s: incoming version_id %d is too old "
100 "for local minimum version_id %d",
101 vmsd
->name
, version_id
, vmsd
->minimum_version_id
);
102 trace_vmstate_load_state_end(vmsd
->name
, "too old", -EINVAL
);
105 if (vmsd
->pre_load
) {
106 int ret
= vmsd
->pre_load(opaque
);
111 while (field
->name
) {
112 trace_vmstate_load_state_field(vmsd
->name
, field
->name
);
113 if ((field
->field_exists
&&
114 field
->field_exists(opaque
, version_id
)) ||
115 (!field
->field_exists
&&
116 field
->version_id
<= version_id
)) {
117 void *first_elem
= opaque
+ field
->offset
;
118 int i
, n_elems
= vmstate_n_elems(opaque
, field
);
119 int size
= vmstate_size(opaque
, field
);
121 vmstate_handle_alloc(first_elem
, field
, opaque
);
122 if (field
->flags
& VMS_POINTER
) {
123 first_elem
= *(void **)first_elem
;
124 assert(first_elem
|| !n_elems
|| !size
);
126 for (i
= 0; i
< n_elems
; i
++) {
127 void *curr_elem
= first_elem
+ size
* i
;
129 if (field
->flags
& VMS_ARRAY_OF_POINTER
) {
130 curr_elem
= *(void **)curr_elem
;
132 if (!curr_elem
&& size
) {
133 /* if null pointer check placeholder and do not follow */
134 assert(field
->flags
& VMS_ARRAY_OF_POINTER
);
135 ret
= vmstate_info_nullptr
.get(f
, curr_elem
, size
, NULL
);
136 } else if (field
->flags
& VMS_STRUCT
) {
137 ret
= vmstate_load_state(f
, field
->vmsd
, curr_elem
,
138 field
->vmsd
->version_id
);
140 ret
= field
->info
->get(f
, curr_elem
, size
, field
);
143 ret
= qemu_file_get_error(f
);
146 qemu_file_set_error(f
, ret
);
147 error_report("Failed to load %s:%s", vmsd
->name
,
149 trace_vmstate_load_field_error(field
->name
, ret
);
153 } else if (field
->flags
& VMS_MUST_EXIST
) {
154 error_report("Input validation failed: %s/%s",
155 vmsd
->name
, field
->name
);
160 ret
= vmstate_subsection_load(f
, vmsd
, opaque
);
164 if (vmsd
->post_load
) {
165 ret
= vmsd
->post_load(opaque
, version_id
);
167 trace_vmstate_load_state_end(vmsd
->name
, "end", ret
);
171 static int vmfield_name_num(VMStateField
*start
, VMStateField
*search
)
176 for (field
= start
; field
->name
; field
++) {
177 if (!strcmp(field
->name
, search
->name
)) {
178 if (field
== search
) {
188 static bool vmfield_name_is_unique(VMStateField
*start
, VMStateField
*search
)
193 for (field
= start
; field
->name
; field
++) {
194 if (!strcmp(field
->name
, search
->name
)) {
196 /* name found more than once, so it's not unique */
206 static const char *vmfield_get_type_name(VMStateField
*field
)
208 const char *type
= "unknown";
210 if (field
->flags
& VMS_STRUCT
) {
212 } else if (field
->info
->name
) {
213 type
= field
->info
->name
;
219 static bool vmsd_can_compress(VMStateField
*field
)
221 if (field
->field_exists
) {
222 /* Dynamically existing fields mess up compression */
226 if (field
->flags
& VMS_STRUCT
) {
227 VMStateField
*sfield
= field
->vmsd
->fields
;
228 while (sfield
->name
) {
229 if (!vmsd_can_compress(sfield
)) {
230 /* Child elements can't compress, so can't we */
236 if (field
->vmsd
->subsections
) {
237 /* Subsections may come and go, better don't compress */
245 static void vmsd_desc_field_start(const VMStateDescription
*vmsd
, QJSON
*vmdesc
,
246 VMStateField
*field
, int i
, int max
)
248 char *name
, *old_name
;
249 bool is_array
= max
> 1;
250 bool can_compress
= vmsd_can_compress(field
);
256 name
= g_strdup(field
->name
);
258 /* Field name is not unique, need to make it unique */
259 if (!vmfield_name_is_unique(vmsd
->fields
, field
)) {
260 int num
= vmfield_name_num(vmsd
->fields
, field
);
262 name
= g_strdup_printf("%s[%d]", name
, num
);
266 json_start_object(vmdesc
, NULL
);
267 json_prop_str(vmdesc
, "name", name
);
270 json_prop_int(vmdesc
, "array_len", max
);
272 json_prop_int(vmdesc
, "index", i
);
275 json_prop_str(vmdesc
, "type", vmfield_get_type_name(field
));
277 if (field
->flags
& VMS_STRUCT
) {
278 json_start_object(vmdesc
, "struct");
284 static void vmsd_desc_field_end(const VMStateDescription
*vmsd
, QJSON
*vmdesc
,
285 VMStateField
*field
, size_t size
, int i
)
291 if (field
->flags
& VMS_STRUCT
) {
292 /* We printed a struct in between, close its child object */
293 json_end_object(vmdesc
);
296 json_prop_int(vmdesc
, "size", size
);
297 json_end_object(vmdesc
);
301 bool vmstate_save_needed(const VMStateDescription
*vmsd
, void *opaque
)
303 if (vmsd
->needed
&& !vmsd
->needed(opaque
)) {
304 /* optional section not needed */
311 int vmstate_save_state(QEMUFile
*f
, const VMStateDescription
*vmsd
,
312 void *opaque
, QJSON
*vmdesc
)
315 VMStateField
*field
= vmsd
->fields
;
317 trace_vmstate_save_state_top(vmsd
->name
);
319 if (vmsd
->pre_save
) {
320 ret
= vmsd
->pre_save(opaque
);
321 trace_vmstate_save_state_pre_save_res(vmsd
->name
, ret
);
323 error_report("pre-save failed: %s", vmsd
->name
);
329 json_prop_str(vmdesc
, "vmsd_name", vmsd
->name
);
330 json_prop_int(vmdesc
, "version", vmsd
->version_id
);
331 json_start_array(vmdesc
, "fields");
334 while (field
->name
) {
335 if (!field
->field_exists
||
336 field
->field_exists(opaque
, vmsd
->version_id
)) {
337 void *first_elem
= opaque
+ field
->offset
;
338 int i
, n_elems
= vmstate_n_elems(opaque
, field
);
339 int size
= vmstate_size(opaque
, field
);
340 int64_t old_offset
, written_bytes
;
341 QJSON
*vmdesc_loop
= vmdesc
;
343 trace_vmstate_save_state_loop(vmsd
->name
, field
->name
, n_elems
);
344 if (field
->flags
& VMS_POINTER
) {
345 first_elem
= *(void **)first_elem
;
346 assert(first_elem
|| !n_elems
|| !size
);
348 for (i
= 0; i
< n_elems
; i
++) {
349 void *curr_elem
= first_elem
+ size
* i
;
352 vmsd_desc_field_start(vmsd
, vmdesc_loop
, field
, i
, n_elems
);
353 old_offset
= qemu_ftell_fast(f
);
354 if (field
->flags
& VMS_ARRAY_OF_POINTER
) {
356 curr_elem
= *(void **)curr_elem
;
358 if (!curr_elem
&& size
) {
359 /* if null pointer write placeholder and do not follow */
360 assert(field
->flags
& VMS_ARRAY_OF_POINTER
);
361 ret
= vmstate_info_nullptr
.put(f
, curr_elem
, size
, NULL
,
363 } else if (field
->flags
& VMS_STRUCT
) {
364 ret
= vmstate_save_state(f
, field
->vmsd
, curr_elem
,
367 ret
= field
->info
->put(f
, curr_elem
, size
, field
,
371 error_report("Save of field %s/%s failed",
372 vmsd
->name
, field
->name
);
376 written_bytes
= qemu_ftell_fast(f
) - old_offset
;
377 vmsd_desc_field_end(vmsd
, vmdesc_loop
, field
, written_bytes
, i
);
379 /* Compressed arrays only care about the first element */
380 if (vmdesc_loop
&& vmsd_can_compress(field
)) {
385 if (field
->flags
& VMS_MUST_EXIST
) {
386 error_report("Output state validation failed: %s/%s",
387 vmsd
->name
, field
->name
);
388 assert(!(field
->flags
& VMS_MUST_EXIST
));
395 json_end_array(vmdesc
);
398 vmstate_subsection_save(f
, vmsd
, opaque
, vmdesc
);
403 static const VMStateDescription
*
404 vmstate_get_subsection(const VMStateDescription
**sub
, char *idstr
)
406 while (sub
&& *sub
&& (*sub
)->needed
) {
407 if (strcmp(idstr
, (*sub
)->name
) == 0) {
415 static int vmstate_subsection_load(QEMUFile
*f
, const VMStateDescription
*vmsd
,
418 trace_vmstate_subsection_load(vmsd
->name
);
420 while (qemu_peek_byte(f
, 0) == QEMU_VM_SUBSECTION
) {
421 char idstr
[256], *idstr_ret
;
423 uint8_t version_id
, len
, size
;
424 const VMStateDescription
*sub_vmsd
;
426 len
= qemu_peek_byte(f
, 1);
427 if (len
< strlen(vmsd
->name
) + 1) {
428 /* subsection name has be be "section_name/a" */
429 trace_vmstate_subsection_load_bad(vmsd
->name
, "(short)", "");
432 size
= qemu_peek_buffer(f
, (uint8_t **)&idstr_ret
, len
, 2);
434 trace_vmstate_subsection_load_bad(vmsd
->name
, "(peek fail)", "");
437 memcpy(idstr
, idstr_ret
, size
);
440 if (strncmp(vmsd
->name
, idstr
, strlen(vmsd
->name
)) != 0) {
441 trace_vmstate_subsection_load_bad(vmsd
->name
, idstr
, "(prefix)");
442 /* it doesn't have a valid subsection name */
445 sub_vmsd
= vmstate_get_subsection(vmsd
->subsections
, idstr
);
446 if (sub_vmsd
== NULL
) {
447 trace_vmstate_subsection_load_bad(vmsd
->name
, idstr
, "(lookup)");
450 qemu_file_skip(f
, 1); /* subsection */
451 qemu_file_skip(f
, 1); /* len */
452 qemu_file_skip(f
, len
); /* idstr */
453 version_id
= qemu_get_be32(f
);
455 ret
= vmstate_load_state(f
, sub_vmsd
, opaque
, version_id
);
457 trace_vmstate_subsection_load_bad(vmsd
->name
, idstr
, "(child)");
462 trace_vmstate_subsection_load_good(vmsd
->name
);
466 static void vmstate_subsection_save(QEMUFile
*f
, const VMStateDescription
*vmsd
,
467 void *opaque
, QJSON
*vmdesc
)
469 const VMStateDescription
**sub
= vmsd
->subsections
;
470 bool subsection_found
= false;
472 trace_vmstate_subsection_save_top(vmsd
->name
);
473 while (sub
&& *sub
&& (*sub
)->needed
) {
474 if ((*sub
)->needed(opaque
)) {
475 const VMStateDescription
*vmsdsub
= *sub
;
478 trace_vmstate_subsection_save_loop(vmsd
->name
, vmsdsub
->name
);
480 /* Only create subsection array when we have any */
481 if (!subsection_found
) {
482 json_start_array(vmdesc
, "subsections");
483 subsection_found
= true;
486 json_start_object(vmdesc
, NULL
);
489 qemu_put_byte(f
, QEMU_VM_SUBSECTION
);
490 len
= strlen(vmsdsub
->name
);
491 qemu_put_byte(f
, len
);
492 qemu_put_buffer(f
, (uint8_t *)vmsdsub
->name
, len
);
493 qemu_put_be32(f
, vmsdsub
->version_id
);
494 vmstate_save_state(f
, vmsdsub
, opaque
, vmdesc
);
497 json_end_object(vmdesc
);
503 if (vmdesc
&& subsection_found
) {
504 json_end_array(vmdesc
);