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/error.h"
18 #include "qapi/qmp/json-writer.h"
19 #include "qemu-file.h"
20 #include "qemu/bitops.h"
21 #include "qemu/error-report.h"
24 static int vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
25 void *opaque, JSONWriter *vmdesc);
26 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
29 /* Whether this field should exist for either save or load the VM? */
31 vmstate_field_exists(const VMStateDescription *vmsd, const VMStateField *field,
32 void *opaque, int version_id)
36 if (field->field_exists) {
37 /* If there's the function checker, that's the solo truth */
38 result = field->field_exists(opaque, version_id);
39 trace_vmstate_field_exists(vmsd->name, field->name, field->version_id,
43 * Otherwise, we only save/load if field version is same or older.
44 * For example, when loading from an old binary with old version,
45 * we ignore new fields with newer version_ids.
47 result = field->version_id <= version_id;
53 static int vmstate_n_elems(void *opaque, const VMStateField *field)
57 if (field->flags & VMS_ARRAY) {
59 } else if (field->flags & VMS_VARRAY_INT32) {
60 n_elems = *(int32_t *)(opaque + field->num_offset);
61 } else if (field->flags & VMS_VARRAY_UINT32) {
62 n_elems = *(uint32_t *)(opaque + field->num_offset);
63 } else if (field->flags & VMS_VARRAY_UINT16) {
64 n_elems = *(uint16_t *)(opaque + field->num_offset);
65 } else if (field->flags & VMS_VARRAY_UINT8) {
66 n_elems = *(uint8_t *)(opaque + field->num_offset);
69 if (field->flags & VMS_MULTIPLY_ELEMENTS) {
70 n_elems *= field->num;
73 trace_vmstate_n_elems(field->name, n_elems);
77 static int vmstate_size(void *opaque, const VMStateField *field)
79 int size = field->size;
81 if (field->flags & VMS_VBUFFER) {
82 size = *(int32_t *)(opaque + field->size_offset);
83 if (field->flags & VMS_MULTIPLY) {
91 static void vmstate_handle_alloc(void *ptr, const VMStateField *field,
94 if (field->flags & VMS_POINTER && field->flags & VMS_ALLOC) {
95 gsize size = vmstate_size(opaque, field);
96 size *= vmstate_n_elems(opaque, field);
98 *(void **)ptr = g_malloc(size);
103 int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
104 void *opaque, int version_id)
106 const VMStateField *field = vmsd->fields;
109 trace_vmstate_load_state(vmsd->name, version_id);
110 if (version_id > vmsd->version_id) {
111 error_report("%s: incoming version_id %d is too new "
112 "for local version_id %d",
113 vmsd->name, version_id, vmsd->version_id);
114 trace_vmstate_load_state_end(vmsd->name, "too new", -EINVAL);
117 if (version_id < vmsd->minimum_version_id) {
118 error_report("%s: incoming version_id %d is too old "
119 "for local minimum version_id %d",
120 vmsd->name, version_id, vmsd->minimum_version_id);
121 trace_vmstate_load_state_end(vmsd->name, "too old", -EINVAL);
124 if (vmsd->pre_load) {
125 ret = vmsd->pre_load(opaque);
130 while (field->name) {
131 trace_vmstate_load_state_field(vmsd->name, field->name);
132 if (vmstate_field_exists(vmsd, field, opaque, version_id)) {
133 void *first_elem = opaque + field->offset;
134 int i, n_elems = vmstate_n_elems(opaque, field);
135 int size = vmstate_size(opaque, field);
137 vmstate_handle_alloc(first_elem, field, opaque);
138 if (field->flags & VMS_POINTER) {
139 first_elem = *(void **)first_elem;
140 assert(first_elem || !n_elems || !size);
142 for (i = 0; i < n_elems; i++) {
143 void *curr_elem = first_elem + size * i;
145 if (field->flags & VMS_ARRAY_OF_POINTER) {
146 curr_elem = *(void **)curr_elem;
148 if (!curr_elem && size) {
149 /* if null pointer check placeholder and do not follow */
150 assert(field->flags & VMS_ARRAY_OF_POINTER);
151 ret = vmstate_info_nullptr.get(f, curr_elem, size, NULL);
152 } else if (field->flags & VMS_STRUCT) {
153 ret = vmstate_load_state(f, field->vmsd, curr_elem,
154 field->vmsd->version_id);
155 } else if (field->flags & VMS_VSTRUCT) {
156 ret = vmstate_load_state(f, field->vmsd, curr_elem,
157 field->struct_version_id);
159 ret = field->info->get(f, curr_elem, size, field);
162 ret = qemu_file_get_error(f);
165 qemu_file_set_error(f, ret);
166 error_report("Failed to load %s:%s", vmsd->name,
168 trace_vmstate_load_field_error(field->name, ret);
172 } else if (field->flags & VMS_MUST_EXIST) {
173 error_report("Input validation failed: %s/%s",
174 vmsd->name, field->name);
179 assert(field->flags == VMS_END);
180 ret = vmstate_subsection_load(f, vmsd, opaque);
182 qemu_file_set_error(f, ret);
185 if (vmsd->post_load) {
186 ret = vmsd->post_load(opaque, version_id);
188 trace_vmstate_load_state_end(vmsd->name, "end", ret);
192 static int vmfield_name_num(const VMStateField *start,
193 const VMStateField *search)
195 const VMStateField *field;
198 for (field = start; field->name; field++) {
199 if (!strcmp(field->name, search->name)) {
200 if (field == search) {
210 static bool vmfield_name_is_unique(const VMStateField *start,
211 const VMStateField *search)
213 const VMStateField *field;
216 for (field = start; field->name; field++) {
217 if (!strcmp(field->name, search->name)) {
219 /* name found more than once, so it's not unique */
229 static const char *vmfield_get_type_name(const VMStateField *field)
231 const char *type = "unknown";
233 if (field->flags & VMS_STRUCT) {
235 } else if (field->flags & VMS_VSTRUCT) {
237 } else if (field->info->name) {
238 type = field->info->name;
244 static bool vmsd_can_compress(const VMStateField *field)
246 if (field->field_exists) {
247 /* Dynamically existing fields mess up compression */
251 if (field->flags & VMS_STRUCT) {
252 const VMStateField *sfield = field->vmsd->fields;
253 while (sfield->name) {
254 if (!vmsd_can_compress(sfield)) {
255 /* Child elements can't compress, so can't we */
261 if (field->vmsd->subsections) {
262 /* Subsections may come and go, better don't compress */
270 static void vmsd_desc_field_start(const VMStateDescription *vmsd,
272 const VMStateField *field, int i, int max)
274 char *name, *old_name;
275 bool is_array = max > 1;
276 bool can_compress = vmsd_can_compress(field);
282 name = g_strdup(field->name);
284 /* Field name is not unique, need to make it unique */
285 if (!vmfield_name_is_unique(vmsd->fields, field)) {
286 int num = vmfield_name_num(vmsd->fields, field);
288 name = g_strdup_printf("%s[%d]", name, num);
292 json_writer_start_object(vmdesc, NULL);
293 json_writer_str(vmdesc, "name", name);
296 json_writer_int64(vmdesc, "array_len", max);
298 json_writer_int64(vmdesc, "index", i);
301 json_writer_str(vmdesc, "type", vmfield_get_type_name(field));
303 if (field->flags & VMS_STRUCT) {
304 json_writer_start_object(vmdesc, "struct");
310 static void vmsd_desc_field_end(const VMStateDescription *vmsd,
312 const VMStateField *field, size_t size, int i)
318 if (field->flags & VMS_STRUCT) {
319 /* We printed a struct in between, close its child object */
320 json_writer_end_object(vmdesc);
323 json_writer_int64(vmdesc, "size", size);
324 json_writer_end_object(vmdesc);
328 bool vmstate_section_needed(const VMStateDescription *vmsd, void *opaque)
330 if (vmsd->needed && !vmsd->needed(opaque)) {
331 /* optional section not needed */
338 int vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
339 void *opaque, JSONWriter *vmdesc_id)
341 return vmstate_save_state_v(f, vmsd, opaque, vmdesc_id, vmsd->version_id, NULL);
344 int vmstate_save_state_with_err(QEMUFile *f, const VMStateDescription *vmsd,
345 void *opaque, JSONWriter *vmdesc_id, Error **errp)
347 return vmstate_save_state_v(f, vmsd, opaque, vmdesc_id, vmsd->version_id, errp);
350 int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
351 void *opaque, JSONWriter *vmdesc, int version_id, Error **errp)
354 const VMStateField *field = vmsd->fields;
356 trace_vmstate_save_state_top(vmsd->name);
358 if (vmsd->pre_save) {
359 ret = vmsd->pre_save(opaque);
360 trace_vmstate_save_state_pre_save_res(vmsd->name, ret);
362 error_setg(errp, "pre-save failed: %s", vmsd->name);
368 json_writer_str(vmdesc, "vmsd_name", vmsd->name);
369 json_writer_int64(vmdesc, "version", version_id);
370 json_writer_start_array(vmdesc, "fields");
373 while (field->name) {
374 if (vmstate_field_exists(vmsd, field, opaque, version_id)) {
375 void *first_elem = opaque + field->offset;
376 int i, n_elems = vmstate_n_elems(opaque, field);
377 int size = vmstate_size(opaque, field);
378 uint64_t old_offset, written_bytes;
379 JSONWriter *vmdesc_loop = vmdesc;
381 trace_vmstate_save_state_loop(vmsd->name, field->name, n_elems);
382 if (field->flags & VMS_POINTER) {
383 first_elem = *(void **)first_elem;
384 assert(first_elem || !n_elems || !size);
386 for (i = 0; i < n_elems; i++) {
387 void *curr_elem = first_elem + size * i;
389 vmsd_desc_field_start(vmsd, vmdesc_loop, field, i, n_elems);
390 old_offset = qemu_file_transferred(f);
391 if (field->flags & VMS_ARRAY_OF_POINTER) {
393 curr_elem = *(void **)curr_elem;
395 if (!curr_elem && size) {
396 /* if null pointer write placeholder and do not follow */
397 assert(field->flags & VMS_ARRAY_OF_POINTER);
398 ret = vmstate_info_nullptr.put(f, curr_elem, size, NULL,
400 } else if (field->flags & VMS_STRUCT) {
401 ret = vmstate_save_state(f, field->vmsd, curr_elem,
403 } else if (field->flags & VMS_VSTRUCT) {
404 ret = vmstate_save_state_v(f, field->vmsd, curr_elem,
406 field->struct_version_id, errp);
408 ret = field->info->put(f, curr_elem, size, field,
412 error_setg(errp, "Save of field %s/%s failed",
413 vmsd->name, field->name);
414 if (vmsd->post_save) {
415 vmsd->post_save(opaque);
420 written_bytes = qemu_file_transferred(f) - old_offset;
421 vmsd_desc_field_end(vmsd, vmdesc_loop, field, written_bytes, i);
423 /* Compressed arrays only care about the first element */
424 if (vmdesc_loop && vmsd_can_compress(field)) {
429 if (field->flags & VMS_MUST_EXIST) {
430 error_report("Output state validation failed: %s/%s",
431 vmsd->name, field->name);
432 assert(!(field->flags & VMS_MUST_EXIST));
437 assert(field->flags == VMS_END);
440 json_writer_end_array(vmdesc);
443 ret = vmstate_subsection_save(f, vmsd, opaque, vmdesc);
445 if (vmsd->post_save) {
446 int ps_ret = vmsd->post_save(opaque);
454 static const VMStateDescription *
455 vmstate_get_subsection(const VMStateDescription **sub, char *idstr)
457 while (sub && *sub) {
458 if (strcmp(idstr, (*sub)->name) == 0) {
466 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
469 trace_vmstate_subsection_load(vmsd->name);
471 while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
472 char idstr[256], *idstr_ret;
474 uint8_t version_id, len, size;
475 const VMStateDescription *sub_vmsd;
477 len = qemu_peek_byte(f, 1);
478 if (len < strlen(vmsd->name) + 1) {
479 /* subsection name has be be "section_name/a" */
480 trace_vmstate_subsection_load_bad(vmsd->name, "(short)", "");
483 size = qemu_peek_buffer(f, (uint8_t **)&idstr_ret, len, 2);
485 trace_vmstate_subsection_load_bad(vmsd->name, "(peek fail)", "");
488 memcpy(idstr, idstr_ret, size);
491 if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
492 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(prefix)");
493 /* it doesn't have a valid subsection name */
496 sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
497 if (sub_vmsd == NULL) {
498 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(lookup)");
501 qemu_file_skip(f, 1); /* subsection */
502 qemu_file_skip(f, 1); /* len */
503 qemu_file_skip(f, len); /* idstr */
504 version_id = qemu_get_be32(f);
506 ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
508 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(child)");
513 trace_vmstate_subsection_load_good(vmsd->name);
517 static int vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
518 void *opaque, JSONWriter *vmdesc)
520 const VMStateDescription **sub = vmsd->subsections;
521 bool vmdesc_has_subsections = false;
524 trace_vmstate_subsection_save_top(vmsd->name);
525 while (sub && *sub) {
526 if (vmstate_section_needed(*sub, opaque)) {
527 const VMStateDescription *vmsdsub = *sub;
530 trace_vmstate_subsection_save_loop(vmsd->name, vmsdsub->name);
532 /* Only create subsection array when we have any */
533 if (!vmdesc_has_subsections) {
534 json_writer_start_array(vmdesc, "subsections");
535 vmdesc_has_subsections = true;
538 json_writer_start_object(vmdesc, NULL);
541 qemu_put_byte(f, QEMU_VM_SUBSECTION);
542 len = strlen(vmsdsub->name);
543 qemu_put_byte(f, len);
544 qemu_put_buffer(f, (uint8_t *)vmsdsub->name, len);
545 qemu_put_be32(f, vmsdsub->version_id);
546 ret = vmstate_save_state(f, vmsdsub, opaque, vmdesc);
552 json_writer_end_object(vmdesc);
558 if (vmdesc_has_subsections) {
559 json_writer_end_array(vmdesc);