Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20200117-1' into...
[qemu.git] / migration / vmstate.c
1 /*
2 * VMState interpreter
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 "migration.h"
15 #include "migration/vmstate.h"
16 #include "savevm.h"
17 #include "qemu-file.h"
18 #include "qemu/bitops.h"
19 #include "qemu/error-report.h"
20 #include "trace.h"
21 #include "qjson.h"
22
23 static int vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
24 void *opaque, QJSON *vmdesc);
25 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
26 void *opaque);
27
28 static int vmstate_n_elems(void *opaque, const VMStateField *field)
29 {
30 int n_elems = 1;
31
32 if (field->flags & VMS_ARRAY) {
33 n_elems = field->num;
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);
42 }
43
44 if (field->flags & VMS_MULTIPLY_ELEMENTS) {
45 n_elems *= field->num;
46 }
47
48 trace_vmstate_n_elems(field->name, n_elems);
49 return n_elems;
50 }
51
52 static int vmstate_size(void *opaque, const VMStateField *field)
53 {
54 int size = field->size;
55
56 if (field->flags & VMS_VBUFFER) {
57 size = *(int32_t *)(opaque+field->size_offset);
58 if (field->flags & VMS_MULTIPLY) {
59 size *= field->size;
60 }
61 }
62
63 return size;
64 }
65
66 static void vmstate_handle_alloc(void *ptr, const VMStateField *field,
67 void *opaque)
68 {
69 if (field->flags & VMS_POINTER && field->flags & VMS_ALLOC) {
70 gsize size = vmstate_size(opaque, field);
71 size *= vmstate_n_elems(opaque, field);
72 if (size) {
73 *(void **)ptr = g_malloc(size);
74 }
75 }
76 }
77
78 int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
79 void *opaque, int version_id)
80 {
81 const VMStateField *field = vmsd->fields;
82 int ret = 0;
83
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);
90 return -EINVAL;
91 }
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);
97 return ret;
98 }
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);
103 return -EINVAL;
104 }
105 if (vmsd->pre_load) {
106 int ret = vmsd->pre_load(opaque);
107 if (ret) {
108 return ret;
109 }
110 }
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);
120
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);
125 }
126 for (i = 0; i < n_elems; i++) {
127 void *curr_elem = first_elem + size * i;
128
129 if (field->flags & VMS_ARRAY_OF_POINTER) {
130 curr_elem = *(void **)curr_elem;
131 }
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);
139 } else if (field->flags & VMS_VSTRUCT) {
140 ret = vmstate_load_state(f, field->vmsd, curr_elem,
141 field->struct_version_id);
142 } else {
143 ret = field->info->get(f, curr_elem, size, field);
144 }
145 if (ret >= 0) {
146 ret = qemu_file_get_error(f);
147 }
148 if (ret < 0) {
149 qemu_file_set_error(f, ret);
150 error_report("Failed to load %s:%s", vmsd->name,
151 field->name);
152 trace_vmstate_load_field_error(field->name, ret);
153 return ret;
154 }
155 }
156 } else if (field->flags & VMS_MUST_EXIST) {
157 error_report("Input validation failed: %s/%s",
158 vmsd->name, field->name);
159 return -1;
160 }
161 field++;
162 }
163 ret = vmstate_subsection_load(f, vmsd, opaque);
164 if (ret != 0) {
165 return ret;
166 }
167 if (vmsd->post_load) {
168 ret = vmsd->post_load(opaque, version_id);
169 }
170 trace_vmstate_load_state_end(vmsd->name, "end", ret);
171 return ret;
172 }
173
174 static int vmfield_name_num(const VMStateField *start,
175 const VMStateField *search)
176 {
177 const VMStateField *field;
178 int found = 0;
179
180 for (field = start; field->name; field++) {
181 if (!strcmp(field->name, search->name)) {
182 if (field == search) {
183 return found;
184 }
185 found++;
186 }
187 }
188
189 return -1;
190 }
191
192 static bool vmfield_name_is_unique(const VMStateField *start,
193 const VMStateField *search)
194 {
195 const VMStateField *field;
196 int found = 0;
197
198 for (field = start; field->name; field++) {
199 if (!strcmp(field->name, search->name)) {
200 found++;
201 /* name found more than once, so it's not unique */
202 if (found > 1) {
203 return false;
204 }
205 }
206 }
207
208 return true;
209 }
210
211 static const char *vmfield_get_type_name(const VMStateField *field)
212 {
213 const char *type = "unknown";
214
215 if (field->flags & VMS_STRUCT) {
216 type = "struct";
217 } else if (field->flags & VMS_VSTRUCT) {
218 type = "vstruct";
219 } else if (field->info->name) {
220 type = field->info->name;
221 }
222
223 return type;
224 }
225
226 static bool vmsd_can_compress(const VMStateField *field)
227 {
228 if (field->field_exists) {
229 /* Dynamically existing fields mess up compression */
230 return false;
231 }
232
233 if (field->flags & VMS_STRUCT) {
234 const VMStateField *sfield = field->vmsd->fields;
235 while (sfield->name) {
236 if (!vmsd_can_compress(sfield)) {
237 /* Child elements can't compress, so can't we */
238 return false;
239 }
240 sfield++;
241 }
242
243 if (field->vmsd->subsections) {
244 /* Subsections may come and go, better don't compress */
245 return false;
246 }
247 }
248
249 return true;
250 }
251
252 static void vmsd_desc_field_start(const VMStateDescription *vmsd, QJSON *vmdesc,
253 const VMStateField *field, int i, int max)
254 {
255 char *name, *old_name;
256 bool is_array = max > 1;
257 bool can_compress = vmsd_can_compress(field);
258
259 if (!vmdesc) {
260 return;
261 }
262
263 name = g_strdup(field->name);
264
265 /* Field name is not unique, need to make it unique */
266 if (!vmfield_name_is_unique(vmsd->fields, field)) {
267 int num = vmfield_name_num(vmsd->fields, field);
268 old_name = name;
269 name = g_strdup_printf("%s[%d]", name, num);
270 g_free(old_name);
271 }
272
273 json_start_object(vmdesc, NULL);
274 json_prop_str(vmdesc, "name", name);
275 if (is_array) {
276 if (can_compress) {
277 json_prop_int(vmdesc, "array_len", max);
278 } else {
279 json_prop_int(vmdesc, "index", i);
280 }
281 }
282 json_prop_str(vmdesc, "type", vmfield_get_type_name(field));
283
284 if (field->flags & VMS_STRUCT) {
285 json_start_object(vmdesc, "struct");
286 }
287
288 g_free(name);
289 }
290
291 static void vmsd_desc_field_end(const VMStateDescription *vmsd, QJSON *vmdesc,
292 const VMStateField *field, size_t size, int i)
293 {
294 if (!vmdesc) {
295 return;
296 }
297
298 if (field->flags & VMS_STRUCT) {
299 /* We printed a struct in between, close its child object */
300 json_end_object(vmdesc);
301 }
302
303 json_prop_int(vmdesc, "size", size);
304 json_end_object(vmdesc);
305 }
306
307
308 bool vmstate_save_needed(const VMStateDescription *vmsd, void *opaque)
309 {
310 if (vmsd->needed && !vmsd->needed(opaque)) {
311 /* optional section not needed */
312 return false;
313 }
314 return true;
315 }
316
317
318 int vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
319 void *opaque, QJSON *vmdesc_id)
320 {
321 return vmstate_save_state_v(f, vmsd, opaque, vmdesc_id, vmsd->version_id);
322 }
323
324 int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
325 void *opaque, QJSON *vmdesc, int version_id)
326 {
327 int ret = 0;
328 const VMStateField *field = vmsd->fields;
329
330 trace_vmstate_save_state_top(vmsd->name);
331
332 if (vmsd->pre_save) {
333 ret = vmsd->pre_save(opaque);
334 trace_vmstate_save_state_pre_save_res(vmsd->name, ret);
335 if (ret) {
336 error_report("pre-save failed: %s", vmsd->name);
337 return ret;
338 }
339 }
340
341 if (vmdesc) {
342 json_prop_str(vmdesc, "vmsd_name", vmsd->name);
343 json_prop_int(vmdesc, "version", version_id);
344 json_start_array(vmdesc, "fields");
345 }
346
347 while (field->name) {
348 if ((field->field_exists &&
349 field->field_exists(opaque, version_id)) ||
350 (!field->field_exists &&
351 field->version_id <= version_id)) {
352 void *first_elem = opaque + field->offset;
353 int i, n_elems = vmstate_n_elems(opaque, field);
354 int size = vmstate_size(opaque, field);
355 int64_t old_offset, written_bytes;
356 QJSON *vmdesc_loop = vmdesc;
357
358 trace_vmstate_save_state_loop(vmsd->name, field->name, n_elems);
359 if (field->flags & VMS_POINTER) {
360 first_elem = *(void **)first_elem;
361 assert(first_elem || !n_elems || !size);
362 }
363 for (i = 0; i < n_elems; i++) {
364 void *curr_elem = first_elem + size * i;
365 ret = 0;
366
367 vmsd_desc_field_start(vmsd, vmdesc_loop, field, i, n_elems);
368 old_offset = qemu_ftell_fast(f);
369 if (field->flags & VMS_ARRAY_OF_POINTER) {
370 assert(curr_elem);
371 curr_elem = *(void **)curr_elem;
372 }
373 if (!curr_elem && size) {
374 /* if null pointer write placeholder and do not follow */
375 assert(field->flags & VMS_ARRAY_OF_POINTER);
376 ret = vmstate_info_nullptr.put(f, curr_elem, size, NULL,
377 NULL);
378 } else if (field->flags & VMS_STRUCT) {
379 ret = vmstate_save_state(f, field->vmsd, curr_elem,
380 vmdesc_loop);
381 } else if (field->flags & VMS_VSTRUCT) {
382 ret = vmstate_save_state_v(f, field->vmsd, curr_elem,
383 vmdesc_loop,
384 field->struct_version_id);
385 } else {
386 ret = field->info->put(f, curr_elem, size, field,
387 vmdesc_loop);
388 }
389 if (ret) {
390 error_report("Save of field %s/%s failed",
391 vmsd->name, field->name);
392 if (vmsd->post_save) {
393 vmsd->post_save(opaque);
394 }
395 return ret;
396 }
397
398 written_bytes = qemu_ftell_fast(f) - old_offset;
399 vmsd_desc_field_end(vmsd, vmdesc_loop, field, written_bytes, i);
400
401 /* Compressed arrays only care about the first element */
402 if (vmdesc_loop && vmsd_can_compress(field)) {
403 vmdesc_loop = NULL;
404 }
405 }
406 } else {
407 if (field->flags & VMS_MUST_EXIST) {
408 error_report("Output state validation failed: %s/%s",
409 vmsd->name, field->name);
410 assert(!(field->flags & VMS_MUST_EXIST));
411 }
412 }
413 field++;
414 }
415
416 if (vmdesc) {
417 json_end_array(vmdesc);
418 }
419
420 ret = vmstate_subsection_save(f, vmsd, opaque, vmdesc);
421
422 if (vmsd->post_save) {
423 int ps_ret = vmsd->post_save(opaque);
424 if (!ret) {
425 ret = ps_ret;
426 }
427 }
428 return ret;
429 }
430
431 static const VMStateDescription *
432 vmstate_get_subsection(const VMStateDescription **sub, char *idstr)
433 {
434 while (sub && *sub) {
435 if (strcmp(idstr, (*sub)->name) == 0) {
436 return *sub;
437 }
438 sub++;
439 }
440 return NULL;
441 }
442
443 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
444 void *opaque)
445 {
446 trace_vmstate_subsection_load(vmsd->name);
447
448 while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
449 char idstr[256], *idstr_ret;
450 int ret;
451 uint8_t version_id, len, size;
452 const VMStateDescription *sub_vmsd;
453
454 len = qemu_peek_byte(f, 1);
455 if (len < strlen(vmsd->name) + 1) {
456 /* subsection name has be be "section_name/a" */
457 trace_vmstate_subsection_load_bad(vmsd->name, "(short)", "");
458 return 0;
459 }
460 size = qemu_peek_buffer(f, (uint8_t **)&idstr_ret, len, 2);
461 if (size != len) {
462 trace_vmstate_subsection_load_bad(vmsd->name, "(peek fail)", "");
463 return 0;
464 }
465 memcpy(idstr, idstr_ret, size);
466 idstr[size] = 0;
467
468 if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
469 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(prefix)");
470 /* it doesn't have a valid subsection name */
471 return 0;
472 }
473 sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
474 if (sub_vmsd == NULL) {
475 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(lookup)");
476 return -ENOENT;
477 }
478 qemu_file_skip(f, 1); /* subsection */
479 qemu_file_skip(f, 1); /* len */
480 qemu_file_skip(f, len); /* idstr */
481 version_id = qemu_get_be32(f);
482
483 ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
484 if (ret) {
485 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(child)");
486 return ret;
487 }
488 }
489
490 trace_vmstate_subsection_load_good(vmsd->name);
491 return 0;
492 }
493
494 static int vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
495 void *opaque, QJSON *vmdesc)
496 {
497 const VMStateDescription **sub = vmsd->subsections;
498 bool vmdesc_has_subsections = false;
499 int ret = 0;
500
501 trace_vmstate_subsection_save_top(vmsd->name);
502 while (sub && *sub) {
503 if (vmstate_save_needed(*sub, opaque)) {
504 const VMStateDescription *vmsdsub = *sub;
505 uint8_t len;
506
507 trace_vmstate_subsection_save_loop(vmsd->name, vmsdsub->name);
508 if (vmdesc) {
509 /* Only create subsection array when we have any */
510 if (!vmdesc_has_subsections) {
511 json_start_array(vmdesc, "subsections");
512 vmdesc_has_subsections = true;
513 }
514
515 json_start_object(vmdesc, NULL);
516 }
517
518 qemu_put_byte(f, QEMU_VM_SUBSECTION);
519 len = strlen(vmsdsub->name);
520 qemu_put_byte(f, len);
521 qemu_put_buffer(f, (uint8_t *)vmsdsub->name, len);
522 qemu_put_be32(f, vmsdsub->version_id);
523 ret = vmstate_save_state(f, vmsdsub, opaque, vmdesc);
524 if (ret) {
525 return ret;
526 }
527
528 if (vmdesc) {
529 json_end_object(vmdesc);
530 }
531 }
532 sub++;
533 }
534
535 if (vmdesc_has_subsections) {
536 json_end_array(vmdesc);
537 }
538
539 return ret;
540 }