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 "migration.h"
15 #include "migration/vmstate.h"
17 #include "qapi/qmp/json-writer.h"
18 #include "qemu-file.h"
19 #include "qemu/bitops.h"
20 #include "qemu/error-report.h"
23 static int vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
24 void *opaque, JSONWriter *vmdesc);
25 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
28 static int vmstate_n_elems(void *opaque, const VMStateField *field)
32 if (field->flags & VMS_ARRAY) {
34 } else if (field->flags & VMS_VARRAY_INT32) {
35 n_elems = *(int32_t *)(opaque + field->num_offset);
36 } else if (field->flags & VMS_VARRAY_UINT32) {
37 n_elems = *(uint32_t *)(opaque + field->num_offset);
38 } else if (field->flags & VMS_VARRAY_UINT16) {
39 n_elems = *(uint16_t *)(opaque + field->num_offset);
40 } else if (field->flags & VMS_VARRAY_UINT8) {
41 n_elems = *(uint8_t *)(opaque + field->num_offset);
44 if (field->flags & VMS_MULTIPLY_ELEMENTS) {
45 n_elems *= field->num;
48 trace_vmstate_n_elems(field->name, n_elems);
52 static int vmstate_size(void *opaque, const VMStateField *field)
54 int size = field->size;
56 if (field->flags & VMS_VBUFFER) {
57 size = *(int32_t *)(opaque + field->size_offset);
58 if (field->flags & VMS_MULTIPLY) {
66 static void vmstate_handle_alloc(void *ptr, const VMStateField *field,
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 const 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 error_report("%s: incoming version_id %d is too old "
94 "for local minimum version_id %d",
95 vmsd->name, version_id, vmsd->minimum_version_id);
96 trace_vmstate_load_state_end(vmsd->name, "too old", -EINVAL);
100 int ret = vmsd->pre_load(opaque);
105 while (field->name) {
106 trace_vmstate_load_state_field(vmsd->name, field->name);
107 if ((field->field_exists &&
108 field->field_exists(opaque, version_id)) ||
109 (!field->field_exists &&
110 field->version_id <= version_id)) {
111 void *first_elem = opaque + field->offset;
112 int i, n_elems = vmstate_n_elems(opaque, field);
113 int size = vmstate_size(opaque, field);
115 vmstate_handle_alloc(first_elem, field, opaque);
116 if (field->flags & VMS_POINTER) {
117 first_elem = *(void **)first_elem;
118 assert(first_elem || !n_elems || !size);
120 for (i = 0; i < n_elems; i++) {
121 void *curr_elem = first_elem + size * i;
123 if (field->flags & VMS_ARRAY_OF_POINTER) {
124 curr_elem = *(void **)curr_elem;
126 if (!curr_elem && size) {
127 /* if null pointer check placeholder and do not follow */
128 assert(field->flags & VMS_ARRAY_OF_POINTER);
129 ret = vmstate_info_nullptr.get(f, curr_elem, size, NULL);
130 } else if (field->flags & VMS_STRUCT) {
131 ret = vmstate_load_state(f, field->vmsd, curr_elem,
132 field->vmsd->version_id);
133 } else if (field->flags & VMS_VSTRUCT) {
134 ret = vmstate_load_state(f, field->vmsd, curr_elem,
135 field->struct_version_id);
137 ret = field->info->get(f, curr_elem, size, field);
140 ret = qemu_file_get_error(f);
143 qemu_file_set_error(f, ret);
144 error_report("Failed to load %s:%s", vmsd->name,
146 trace_vmstate_load_field_error(field->name, ret);
150 } else if (field->flags & VMS_MUST_EXIST) {
151 error_report("Input validation failed: %s/%s",
152 vmsd->name, field->name);
157 assert(field->flags == VMS_END);
158 ret = vmstate_subsection_load(f, vmsd, opaque);
162 if (vmsd->post_load) {
163 ret = vmsd->post_load(opaque, version_id);
165 trace_vmstate_load_state_end(vmsd->name, "end", ret);
169 static int vmfield_name_num(const VMStateField *start,
170 const VMStateField *search)
172 const VMStateField *field;
175 for (field = start; field->name; field++) {
176 if (!strcmp(field->name, search->name)) {
177 if (field == search) {
187 static bool vmfield_name_is_unique(const VMStateField *start,
188 const VMStateField *search)
190 const VMStateField *field;
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(const VMStateField *field)
208 const char *type = "unknown";
210 if (field->flags & VMS_STRUCT) {
212 } else if (field->flags & VMS_VSTRUCT) {
214 } else if (field->info->name) {
215 type = field->info->name;
221 static bool vmsd_can_compress(const VMStateField *field)
223 if (field->field_exists) {
224 /* Dynamically existing fields mess up compression */
228 if (field->flags & VMS_STRUCT) {
229 const VMStateField *sfield = field->vmsd->fields;
230 while (sfield->name) {
231 if (!vmsd_can_compress(sfield)) {
232 /* Child elements can't compress, so can't we */
238 if (field->vmsd->subsections) {
239 /* Subsections may come and go, better don't compress */
247 static void vmsd_desc_field_start(const VMStateDescription *vmsd,
249 const VMStateField *field, int i, int max)
251 char *name, *old_name;
252 bool is_array = max > 1;
253 bool can_compress = vmsd_can_compress(field);
259 name = g_strdup(field->name);
261 /* Field name is not unique, need to make it unique */
262 if (!vmfield_name_is_unique(vmsd->fields, field)) {
263 int num = vmfield_name_num(vmsd->fields, field);
265 name = g_strdup_printf("%s[%d]", name, num);
269 json_writer_start_object(vmdesc, NULL);
270 json_writer_str(vmdesc, "name", name);
273 json_writer_int64(vmdesc, "array_len", max);
275 json_writer_int64(vmdesc, "index", i);
278 json_writer_str(vmdesc, "type", vmfield_get_type_name(field));
280 if (field->flags & VMS_STRUCT) {
281 json_writer_start_object(vmdesc, "struct");
287 static void vmsd_desc_field_end(const VMStateDescription *vmsd,
289 const VMStateField *field, size_t size, int i)
295 if (field->flags & VMS_STRUCT) {
296 /* We printed a struct in between, close its child object */
297 json_writer_end_object(vmdesc);
300 json_writer_int64(vmdesc, "size", size);
301 json_writer_end_object(vmdesc);
305 bool vmstate_save_needed(const VMStateDescription *vmsd, void *opaque)
307 if (vmsd->needed && !vmsd->needed(opaque)) {
308 /* optional section not needed */
315 int vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
316 void *opaque, JSONWriter *vmdesc_id)
318 return vmstate_save_state_v(f, vmsd, opaque, vmdesc_id, vmsd->version_id);
321 int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
322 void *opaque, JSONWriter *vmdesc, int version_id)
325 const VMStateField *field = vmsd->fields;
327 trace_vmstate_save_state_top(vmsd->name);
329 if (vmsd->pre_save) {
330 ret = vmsd->pre_save(opaque);
331 trace_vmstate_save_state_pre_save_res(vmsd->name, ret);
333 error_report("pre-save failed: %s", vmsd->name);
339 json_writer_str(vmdesc, "vmsd_name", vmsd->name);
340 json_writer_int64(vmdesc, "version", version_id);
341 json_writer_start_array(vmdesc, "fields");
344 while (field->name) {
345 if ((field->field_exists &&
346 field->field_exists(opaque, version_id)) ||
347 (!field->field_exists &&
348 field->version_id <= version_id)) {
349 void *first_elem = opaque + field->offset;
350 int i, n_elems = vmstate_n_elems(opaque, field);
351 int size = vmstate_size(opaque, field);
352 uint64_t old_offset, written_bytes;
353 JSONWriter *vmdesc_loop = vmdesc;
355 trace_vmstate_save_state_loop(vmsd->name, field->name, n_elems);
356 if (field->flags & VMS_POINTER) {
357 first_elem = *(void **)first_elem;
358 assert(first_elem || !n_elems || !size);
360 for (i = 0; i < n_elems; i++) {
361 void *curr_elem = first_elem + size * i;
363 vmsd_desc_field_start(vmsd, vmdesc_loop, field, i, n_elems);
364 old_offset = qemu_file_transferred_noflush(f);
365 if (field->flags & VMS_ARRAY_OF_POINTER) {
367 curr_elem = *(void **)curr_elem;
369 if (!curr_elem && size) {
370 /* if null pointer write placeholder and do not follow */
371 assert(field->flags & VMS_ARRAY_OF_POINTER);
372 ret = vmstate_info_nullptr.put(f, curr_elem, size, NULL,
374 } else if (field->flags & VMS_STRUCT) {
375 ret = vmstate_save_state(f, field->vmsd, curr_elem,
377 } else if (field->flags & VMS_VSTRUCT) {
378 ret = vmstate_save_state_v(f, field->vmsd, curr_elem,
380 field->struct_version_id);
382 ret = field->info->put(f, curr_elem, size, field,
386 error_report("Save of field %s/%s failed",
387 vmsd->name, field->name);
388 if (vmsd->post_save) {
389 vmsd->post_save(opaque);
394 written_bytes = qemu_file_transferred_noflush(f) - old_offset;
395 vmsd_desc_field_end(vmsd, vmdesc_loop, field, written_bytes, i);
397 /* Compressed arrays only care about the first element */
398 if (vmdesc_loop && vmsd_can_compress(field)) {
403 if (field->flags & VMS_MUST_EXIST) {
404 error_report("Output state validation failed: %s/%s",
405 vmsd->name, field->name);
406 assert(!(field->flags & VMS_MUST_EXIST));
411 assert(field->flags == VMS_END);
414 json_writer_end_array(vmdesc);
417 ret = vmstate_subsection_save(f, vmsd, opaque, vmdesc);
419 if (vmsd->post_save) {
420 int ps_ret = vmsd->post_save(opaque);
428 static const VMStateDescription *
429 vmstate_get_subsection(const VMStateDescription **sub, char *idstr)
431 while (sub && *sub) {
432 if (strcmp(idstr, (*sub)->name) == 0) {
440 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
443 trace_vmstate_subsection_load(vmsd->name);
445 while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
446 char idstr[256], *idstr_ret;
448 uint8_t version_id, len, size;
449 const VMStateDescription *sub_vmsd;
451 len = qemu_peek_byte(f, 1);
452 if (len < strlen(vmsd->name) + 1) {
453 /* subsection name has be be "section_name/a" */
454 trace_vmstate_subsection_load_bad(vmsd->name, "(short)", "");
457 size = qemu_peek_buffer(f, (uint8_t **)&idstr_ret, len, 2);
459 trace_vmstate_subsection_load_bad(vmsd->name, "(peek fail)", "");
462 memcpy(idstr, idstr_ret, size);
465 if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
466 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(prefix)");
467 /* it doesn't have a valid subsection name */
470 sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
471 if (sub_vmsd == NULL) {
472 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(lookup)");
475 qemu_file_skip(f, 1); /* subsection */
476 qemu_file_skip(f, 1); /* len */
477 qemu_file_skip(f, len); /* idstr */
478 version_id = qemu_get_be32(f);
480 ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
482 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(child)");
487 trace_vmstate_subsection_load_good(vmsd->name);
491 static int vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
492 void *opaque, JSONWriter *vmdesc)
494 const VMStateDescription **sub = vmsd->subsections;
495 bool vmdesc_has_subsections = false;
498 trace_vmstate_subsection_save_top(vmsd->name);
499 while (sub && *sub) {
500 if (vmstate_save_needed(*sub, opaque)) {
501 const VMStateDescription *vmsdsub = *sub;
504 trace_vmstate_subsection_save_loop(vmsd->name, vmsdsub->name);
506 /* Only create subsection array when we have any */
507 if (!vmdesc_has_subsections) {
508 json_writer_start_array(vmdesc, "subsections");
509 vmdesc_has_subsections = true;
512 json_writer_start_object(vmdesc, NULL);
515 qemu_put_byte(f, QEMU_VM_SUBSECTION);
516 len = strlen(vmsdsub->name);
517 qemu_put_byte(f, len);
518 qemu_put_buffer(f, (uint8_t *)vmsdsub->name, len);
519 qemu_put_be32(f, vmsdsub->version_id);
520 ret = vmstate_save_state(f, vmsdsub, opaque, vmdesc);
526 json_writer_end_object(vmdesc);
532 if (vmdesc_has_subsections) {
533 json_writer_end_array(vmdesc);