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 "migration/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 void 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, 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, 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, VMStateField *field, 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
78int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
79 void *opaque, int version_id)
80{
81 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
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 {
140 ret = field->info->get(f, curr_elem, size, field);
141 }
142 if (ret >= 0) {
143 ret = qemu_file_get_error(f);
144 }
145 if (ret < 0) {
146 qemu_file_set_error(f, ret);
147 error_report("Failed to load %s:%s", vmsd->name,
148 field->name);
149 trace_vmstate_load_field_error(field->name, ret);
150 return ret;
151 }
152 }
153 } else if (field->flags & VMS_MUST_EXIST) {
154 error_report("Input validation failed: %s/%s",
155 vmsd->name, field->name);
156 return -1;
157 }
158 field++;
159 }
160 ret = vmstate_subsection_load(f, vmsd, opaque);
161 if (ret != 0) {
162 return ret;
163 }
164 if (vmsd->post_load) {
165 ret = vmsd->post_load(opaque, version_id);
166 }
167 trace_vmstate_load_state_end(vmsd->name, "end", ret);
168 return ret;
169}
170
171static int vmfield_name_num(VMStateField *start, VMStateField *search)
172{
173 VMStateField *field;
174 int found = 0;
175
176 for (field = start; field->name; field++) {
177 if (!strcmp(field->name, search->name)) {
178 if (field == search) {
179 return found;
180 }
181 found++;
182 }
183 }
184
185 return -1;
186}
187
188static bool vmfield_name_is_unique(VMStateField *start, VMStateField *search)
189{
190 VMStateField *field;
191 int found = 0;
192
193 for (field = start; field->name; field++) {
194 if (!strcmp(field->name, search->name)) {
195 found++;
196
197 if (found > 1) {
198 return false;
199 }
200 }
201 }
202
203 return true;
204}
205
206static const char *vmfield_get_type_name(VMStateField *field)
207{
208 const char *type = "unknown";
209
210 if (field->flags & VMS_STRUCT) {
211 type = "struct";
212 } else if (field->info->name) {
213 type = field->info->name;
214 }
215
216 return type;
217}
218
219static bool vmsd_can_compress(VMStateField *field)
220{
221 if (field->field_exists) {
222
223 return false;
224 }
225
226 if (field->flags & VMS_STRUCT) {
227 VMStateField *sfield = field->vmsd->fields;
228 while (sfield->name) {
229 if (!vmsd_can_compress(sfield)) {
230
231 return false;
232 }
233 sfield++;
234 }
235
236 if (field->vmsd->subsections) {
237
238 return false;
239 }
240 }
241
242 return true;
243}
244
245static void vmsd_desc_field_start(const VMStateDescription *vmsd, QJSON *vmdesc,
246 VMStateField *field, int i, int max)
247{
248 char *name, *old_name;
249 bool is_array = max > 1;
250 bool can_compress = vmsd_can_compress(field);
251
252 if (!vmdesc) {
253 return;
254 }
255
256 name = g_strdup(field->name);
257
258
259 if (!vmfield_name_is_unique(vmsd->fields, field)) {
260 int num = vmfield_name_num(vmsd->fields, field);
261 old_name = name;
262 name = g_strdup_printf("%s[%d]", name, num);
263 g_free(old_name);
264 }
265
266 json_start_object(vmdesc, NULL);
267 json_prop_str(vmdesc, "name", name);
268 if (is_array) {
269 if (can_compress) {
270 json_prop_int(vmdesc, "array_len", max);
271 } else {
272 json_prop_int(vmdesc, "index", i);
273 }
274 }
275 json_prop_str(vmdesc, "type", vmfield_get_type_name(field));
276
277 if (field->flags & VMS_STRUCT) {
278 json_start_object(vmdesc, "struct");
279 }
280
281 g_free(name);
282}
283
284static void vmsd_desc_field_end(const VMStateDescription *vmsd, QJSON *vmdesc,
285 VMStateField *field, size_t size, int i)
286{
287 if (!vmdesc) {
288 return;
289 }
290
291 if (field->flags & VMS_STRUCT) {
292
293 json_end_object(vmdesc);
294 }
295
296 json_prop_int(vmdesc, "size", size);
297 json_end_object(vmdesc);
298}
299
300
301bool vmstate_save_needed(const VMStateDescription *vmsd, void *opaque)
302{
303 if (vmsd->needed && !vmsd->needed(opaque)) {
304
305 return false;
306 }
307 return true;
308}
309
310
311void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
312 void *opaque, QJSON *vmdesc)
313{
314 VMStateField *field = vmsd->fields;
315
316 trace_vmstate_save_state_top(vmsd->name);
317
318 if (vmsd->pre_save) {
319 vmsd->pre_save(opaque);
320 }
321
322 if (vmdesc) {
323 json_prop_str(vmdesc, "vmsd_name", vmsd->name);
324 json_prop_int(vmdesc, "version", vmsd->version_id);
325 json_start_array(vmdesc, "fields");
326 }
327
328 while (field->name) {
329 if (!field->field_exists ||
330 field->field_exists(opaque, vmsd->version_id)) {
331 void *first_elem = opaque + field->offset;
332 int i, n_elems = vmstate_n_elems(opaque, field);
333 int size = vmstate_size(opaque, field);
334 int64_t old_offset, written_bytes;
335 QJSON *vmdesc_loop = vmdesc;
336
337 trace_vmstate_save_state_loop(vmsd->name, field->name, n_elems);
338 if (field->flags & VMS_POINTER) {
339 first_elem = *(void **)first_elem;
340 assert(first_elem || !n_elems || !size);
341 }
342 for (i = 0; i < n_elems; i++) {
343 void *curr_elem = first_elem + size * i;
344
345 vmsd_desc_field_start(vmsd, vmdesc_loop, field, i, n_elems);
346 old_offset = qemu_ftell_fast(f);
347 if (field->flags & VMS_ARRAY_OF_POINTER) {
348 assert(curr_elem);
349 curr_elem = *(void **)curr_elem;
350 }
351 if (!curr_elem && size) {
352
353 assert(field->flags & VMS_ARRAY_OF_POINTER);
354 vmstate_info_nullptr.put(f, curr_elem, size, NULL, NULL);
355 } else if (field->flags & VMS_STRUCT) {
356 vmstate_save_state(f, field->vmsd, curr_elem, vmdesc_loop);
357 } else {
358 field->info->put(f, curr_elem, size, field, vmdesc_loop);
359 }
360
361 written_bytes = qemu_ftell_fast(f) - old_offset;
362 vmsd_desc_field_end(vmsd, vmdesc_loop, field, written_bytes, i);
363
364
365 if (vmdesc_loop && vmsd_can_compress(field)) {
366 vmdesc_loop = NULL;
367 }
368 }
369 } else {
370 if (field->flags & VMS_MUST_EXIST) {
371 error_report("Output state validation failed: %s/%s",
372 vmsd->name, field->name);
373 assert(!(field->flags & VMS_MUST_EXIST));
374 }
375 }
376 field++;
377 }
378
379 if (vmdesc) {
380 json_end_array(vmdesc);
381 }
382
383 vmstate_subsection_save(f, vmsd, opaque, vmdesc);
384}
385
386static const VMStateDescription *
387vmstate_get_subsection(const VMStateDescription **sub, char *idstr)
388{
389 while (sub && *sub && (*sub)->needed) {
390 if (strcmp(idstr, (*sub)->name) == 0) {
391 return *sub;
392 }
393 sub++;
394 }
395 return NULL;
396}
397
398static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
399 void *opaque)
400{
401 trace_vmstate_subsection_load(vmsd->name);
402
403 while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
404 char idstr[256], *idstr_ret;
405 int ret;
406 uint8_t version_id, len, size;
407 const VMStateDescription *sub_vmsd;
408
409 len = qemu_peek_byte(f, 1);
410 if (len < strlen(vmsd->name) + 1) {
411
412 trace_vmstate_subsection_load_bad(vmsd->name, "(short)", "");
413 return 0;
414 }
415 size = qemu_peek_buffer(f, (uint8_t **)&idstr_ret, len, 2);
416 if (size != len) {
417 trace_vmstate_subsection_load_bad(vmsd->name, "(peek fail)", "");
418 return 0;
419 }
420 memcpy(idstr, idstr_ret, size);
421 idstr[size] = 0;
422
423 if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
424 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(prefix)");
425
426 return 0;
427 }
428 sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
429 if (sub_vmsd == NULL) {
430 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(lookup)");
431 return -ENOENT;
432 }
433 qemu_file_skip(f, 1);
434 qemu_file_skip(f, 1);
435 qemu_file_skip(f, len);
436 version_id = qemu_get_be32(f);
437
438 ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
439 if (ret) {
440 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(child)");
441 return ret;
442 }
443 }
444
445 trace_vmstate_subsection_load_good(vmsd->name);
446 return 0;
447}
448
449static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
450 void *opaque, QJSON *vmdesc)
451{
452 const VMStateDescription **sub = vmsd->subsections;
453 bool subsection_found = false;
454
455 trace_vmstate_subsection_save_top(vmsd->name);
456 while (sub && *sub && (*sub)->needed) {
457 if ((*sub)->needed(opaque)) {
458 const VMStateDescription *vmsdsub = *sub;
459 uint8_t len;
460
461 trace_vmstate_subsection_save_loop(vmsd->name, vmsdsub->name);
462 if (vmdesc) {
463
464 if (!subsection_found) {
465 json_start_array(vmdesc, "subsections");
466 subsection_found = true;
467 }
468
469 json_start_object(vmdesc, NULL);
470 }
471
472 qemu_put_byte(f, QEMU_VM_SUBSECTION);
473 len = strlen(vmsdsub->name);
474 qemu_put_byte(f, len);
475 qemu_put_buffer(f, (uint8_t *)vmsdsub->name, len);
476 qemu_put_be32(f, vmsdsub->version_id);
477 vmstate_save_state(f, vmsdsub, opaque, vmdesc);
478
479 if (vmdesc) {
480 json_end_object(vmdesc);
481 }
482 }
483 sub++;
484 }
485
486 if (vmdesc && subsection_found) {
487 json_end_array(vmdesc);
488 }
489}
490