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