hw/arm/virt-acpi-build: don't save VirtGuestInfo on AcpiBuildState
[qemu.git] / migration / vmstate.c
1 #include "qemu/osdep.h"
2 #include "qemu-common.h"
3 #include "migration/migration.h"
4 #include "migration/qemu-file.h"
5 #include "migration/vmstate.h"
6 #include "qemu/bitops.h"
7 #include "qemu/error-report.h"
8 #include "trace.h"
9
10 static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
11 void *opaque, QJSON *vmdesc);
12 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
13 void *opaque);
14
15 static int vmstate_n_elems(void *opaque, VMStateField *field)
16 {
17 int n_elems = 1;
18
19 if (field->flags & VMS_ARRAY) {
20 n_elems = field->num;
21 } else if (field->flags & VMS_VARRAY_INT32) {
22 n_elems = *(int32_t *)(opaque+field->num_offset);
23 } else if (field->flags & VMS_VARRAY_UINT32) {
24 n_elems = *(uint32_t *)(opaque+field->num_offset);
25 } else if (field->flags & VMS_VARRAY_UINT16) {
26 n_elems = *(uint16_t *)(opaque+field->num_offset);
27 } else if (field->flags & VMS_VARRAY_UINT8) {
28 n_elems = *(uint8_t *)(opaque+field->num_offset);
29 }
30
31 if (field->flags & VMS_MULTIPLY_ELEMENTS) {
32 n_elems *= field->num;
33 }
34
35 trace_vmstate_n_elems(field->name, n_elems);
36 return n_elems;
37 }
38
39 static int vmstate_size(void *opaque, VMStateField *field)
40 {
41 int size = field->size;
42
43 if (field->flags & VMS_VBUFFER) {
44 size = *(int32_t *)(opaque+field->size_offset);
45 if (field->flags & VMS_MULTIPLY) {
46 size *= field->size;
47 }
48 }
49
50 return size;
51 }
52
53 static void *vmstate_base_addr(void *opaque, VMStateField *field, bool alloc)
54 {
55 void *base_addr = opaque + field->offset;
56
57 if (field->flags & VMS_POINTER) {
58 if (alloc && (field->flags & VMS_ALLOC)) {
59 gsize size = 0;
60 if (field->flags & VMS_VBUFFER) {
61 size = vmstate_size(opaque, field);
62 } else {
63 int n_elems = vmstate_n_elems(opaque, field);
64 if (n_elems) {
65 size = n_elems * field->size;
66 }
67 }
68 if (size) {
69 *((void **)base_addr + field->start) = g_malloc(size);
70 }
71 }
72 base_addr = *(void **)base_addr + field->start;
73 }
74
75 return base_addr;
76 }
77
78 int 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 trace_vmstate_load_state_end(vmsd->name, "too new", -EINVAL);
87 return -EINVAL;
88 }
89 if (version_id < vmsd->minimum_version_id) {
90 if (vmsd->load_state_old &&
91 version_id >= vmsd->minimum_version_id_old) {
92 ret = vmsd->load_state_old(f, opaque, version_id);
93 trace_vmstate_load_state_end(vmsd->name, "old path", ret);
94 return ret;
95 }
96 trace_vmstate_load_state_end(vmsd->name, "too old", -EINVAL);
97 return -EINVAL;
98 }
99 if (vmsd->pre_load) {
100 int ret = vmsd->pre_load(opaque);
101 if (ret) {
102 return ret;
103 }
104 }
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 *base_addr = vmstate_base_addr(opaque, field, true);
112 int i, n_elems = vmstate_n_elems(opaque, field);
113 int size = vmstate_size(opaque, field);
114
115 for (i = 0; i < n_elems; i++) {
116 void *addr = base_addr + size * i;
117
118 if (field->flags & VMS_ARRAY_OF_POINTER) {
119 addr = *(void **)addr;
120 }
121 if (field->flags & VMS_STRUCT) {
122 ret = vmstate_load_state(f, field->vmsd, addr,
123 field->vmsd->version_id);
124 } else {
125 ret = field->info->get(f, addr, size);
126
127 }
128 if (ret >= 0) {
129 ret = qemu_file_get_error(f);
130 }
131 if (ret < 0) {
132 qemu_file_set_error(f, ret);
133 error_report("Failed to load %s:%s", vmsd->name,
134 field->name);
135 trace_vmstate_load_field_error(field->name, ret);
136 return ret;
137 }
138 }
139 } else if (field->flags & VMS_MUST_EXIST) {
140 error_report("Input validation failed: %s/%s",
141 vmsd->name, field->name);
142 return -1;
143 }
144 field++;
145 }
146 ret = vmstate_subsection_load(f, vmsd, opaque);
147 if (ret != 0) {
148 return ret;
149 }
150 if (vmsd->post_load) {
151 ret = vmsd->post_load(opaque, version_id);
152 }
153 trace_vmstate_load_state_end(vmsd->name, "end", ret);
154 return ret;
155 }
156
157 static int vmfield_name_num(VMStateField *start, VMStateField *search)
158 {
159 VMStateField *field;
160 int found = 0;
161
162 for (field = start; field->name; field++) {
163 if (!strcmp(field->name, search->name)) {
164 if (field == search) {
165 return found;
166 }
167 found++;
168 }
169 }
170
171 return -1;
172 }
173
174 static bool vmfield_name_is_unique(VMStateField *start, VMStateField *search)
175 {
176 VMStateField *field;
177 int found = 0;
178
179 for (field = start; field->name; field++) {
180 if (!strcmp(field->name, search->name)) {
181 found++;
182 /* name found more than once, so it's not unique */
183 if (found > 1) {
184 return false;
185 }
186 }
187 }
188
189 return true;
190 }
191
192 static const char *vmfield_get_type_name(VMStateField *field)
193 {
194 const char *type = "unknown";
195
196 if (field->flags & VMS_STRUCT) {
197 type = "struct";
198 } else if (field->info->name) {
199 type = field->info->name;
200 }
201
202 return type;
203 }
204
205 static bool vmsd_can_compress(VMStateField *field)
206 {
207 if (field->field_exists) {
208 /* Dynamically existing fields mess up compression */
209 return false;
210 }
211
212 if (field->flags & VMS_STRUCT) {
213 VMStateField *sfield = field->vmsd->fields;
214 while (sfield->name) {
215 if (!vmsd_can_compress(sfield)) {
216 /* Child elements can't compress, so can't we */
217 return false;
218 }
219 sfield++;
220 }
221
222 if (field->vmsd->subsections) {
223 /* Subsections may come and go, better don't compress */
224 return false;
225 }
226 }
227
228 return true;
229 }
230
231 static void vmsd_desc_field_start(const VMStateDescription *vmsd, QJSON *vmdesc,
232 VMStateField *field, int i, int max)
233 {
234 char *name, *old_name;
235 bool is_array = max > 1;
236 bool can_compress = vmsd_can_compress(field);
237
238 if (!vmdesc) {
239 return;
240 }
241
242 name = g_strdup(field->name);
243
244 /* Field name is not unique, need to make it unique */
245 if (!vmfield_name_is_unique(vmsd->fields, field)) {
246 int num = vmfield_name_num(vmsd->fields, field);
247 old_name = name;
248 name = g_strdup_printf("%s[%d]", name, num);
249 g_free(old_name);
250 }
251
252 json_start_object(vmdesc, NULL);
253 json_prop_str(vmdesc, "name", name);
254 if (is_array) {
255 if (can_compress) {
256 json_prop_int(vmdesc, "array_len", max);
257 } else {
258 json_prop_int(vmdesc, "index", i);
259 }
260 }
261 json_prop_str(vmdesc, "type", vmfield_get_type_name(field));
262
263 if (field->flags & VMS_STRUCT) {
264 json_start_object(vmdesc, "struct");
265 }
266
267 g_free(name);
268 }
269
270 static void vmsd_desc_field_end(const VMStateDescription *vmsd, QJSON *vmdesc,
271 VMStateField *field, size_t size, int i)
272 {
273 if (!vmdesc) {
274 return;
275 }
276
277 if (field->flags & VMS_STRUCT) {
278 /* We printed a struct in between, close its child object */
279 json_end_object(vmdesc);
280 }
281
282 json_prop_int(vmdesc, "size", size);
283 json_end_object(vmdesc);
284 }
285
286
287 bool vmstate_save_needed(const VMStateDescription *vmsd, void *opaque)
288 {
289 if (vmsd->needed && !vmsd->needed(opaque)) {
290 /* optional section not needed */
291 return false;
292 }
293 return true;
294 }
295
296
297 void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
298 void *opaque, QJSON *vmdesc)
299 {
300 VMStateField *field = vmsd->fields;
301
302 if (vmsd->pre_save) {
303 vmsd->pre_save(opaque);
304 }
305
306 if (vmdesc) {
307 json_prop_str(vmdesc, "vmsd_name", vmsd->name);
308 json_prop_int(vmdesc, "version", vmsd->version_id);
309 json_start_array(vmdesc, "fields");
310 }
311
312 while (field->name) {
313 if (!field->field_exists ||
314 field->field_exists(opaque, vmsd->version_id)) {
315 void *base_addr = vmstate_base_addr(opaque, field, false);
316 int i, n_elems = vmstate_n_elems(opaque, field);
317 int size = vmstate_size(opaque, field);
318 int64_t old_offset, written_bytes;
319 QJSON *vmdesc_loop = vmdesc;
320
321 for (i = 0; i < n_elems; i++) {
322 void *addr = base_addr + size * i;
323
324 vmsd_desc_field_start(vmsd, vmdesc_loop, field, i, n_elems);
325 old_offset = qemu_ftell_fast(f);
326
327 if (field->flags & VMS_ARRAY_OF_POINTER) {
328 addr = *(void **)addr;
329 }
330 if (field->flags & VMS_STRUCT) {
331 vmstate_save_state(f, field->vmsd, addr, vmdesc_loop);
332 } else {
333 field->info->put(f, addr, size);
334 }
335
336 written_bytes = qemu_ftell_fast(f) - old_offset;
337 vmsd_desc_field_end(vmsd, vmdesc_loop, field, written_bytes, i);
338
339 /* Compressed arrays only care about the first element */
340 if (vmdesc_loop && vmsd_can_compress(field)) {
341 vmdesc_loop = NULL;
342 }
343 }
344 } else {
345 if (field->flags & VMS_MUST_EXIST) {
346 error_report("Output state validation failed: %s/%s",
347 vmsd->name, field->name);
348 assert(!(field->flags & VMS_MUST_EXIST));
349 }
350 }
351 field++;
352 }
353
354 if (vmdesc) {
355 json_end_array(vmdesc);
356 }
357
358 vmstate_subsection_save(f, vmsd, opaque, vmdesc);
359 }
360
361 static const VMStateDescription *
362 vmstate_get_subsection(const VMStateDescription **sub, char *idstr)
363 {
364 while (sub && *sub && (*sub)->needed) {
365 if (strcmp(idstr, (*sub)->name) == 0) {
366 return *sub;
367 }
368 sub++;
369 }
370 return NULL;
371 }
372
373 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
374 void *opaque)
375 {
376 trace_vmstate_subsection_load(vmsd->name);
377
378 while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
379 char idstr[256], *idstr_ret;
380 int ret;
381 uint8_t version_id, len, size;
382 const VMStateDescription *sub_vmsd;
383
384 len = qemu_peek_byte(f, 1);
385 if (len < strlen(vmsd->name) + 1) {
386 /* subsection name has be be "section_name/a" */
387 trace_vmstate_subsection_load_bad(vmsd->name, "(short)", "");
388 return 0;
389 }
390 size = qemu_peek_buffer(f, (uint8_t **)&idstr_ret, len, 2);
391 if (size != len) {
392 trace_vmstate_subsection_load_bad(vmsd->name, "(peek fail)", "");
393 return 0;
394 }
395 memcpy(idstr, idstr_ret, size);
396 idstr[size] = 0;
397
398 if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
399 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(prefix)");
400 /* it doesn't have a valid subsection name */
401 return 0;
402 }
403 sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
404 if (sub_vmsd == NULL) {
405 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(lookup)");
406 return -ENOENT;
407 }
408 qemu_file_skip(f, 1); /* subsection */
409 qemu_file_skip(f, 1); /* len */
410 qemu_file_skip(f, len); /* idstr */
411 version_id = qemu_get_be32(f);
412
413 ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
414 if (ret) {
415 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(child)");
416 return ret;
417 }
418 }
419
420 trace_vmstate_subsection_load_good(vmsd->name);
421 return 0;
422 }
423
424 static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
425 void *opaque, QJSON *vmdesc)
426 {
427 const VMStateDescription **sub = vmsd->subsections;
428 bool subsection_found = false;
429
430 while (sub && *sub && (*sub)->needed) {
431 if ((*sub)->needed(opaque)) {
432 const VMStateDescription *vmsd = *sub;
433 uint8_t len;
434
435 if (vmdesc) {
436 /* Only create subsection array when we have any */
437 if (!subsection_found) {
438 json_start_array(vmdesc, "subsections");
439 subsection_found = true;
440 }
441
442 json_start_object(vmdesc, NULL);
443 }
444
445 qemu_put_byte(f, QEMU_VM_SUBSECTION);
446 len = strlen(vmsd->name);
447 qemu_put_byte(f, len);
448 qemu_put_buffer(f, (uint8_t *)vmsd->name, len);
449 qemu_put_be32(f, vmsd->version_id);
450 vmstate_save_state(f, vmsd, opaque, vmdesc);
451
452 if (vmdesc) {
453 json_end_object(vmdesc);
454 }
455 }
456 sub++;
457 }
458
459 if (vmdesc && subsection_found) {
460 json_end_array(vmdesc);
461 }
462 }
463
464 /* bool */
465
466 static int get_bool(QEMUFile *f, void *pv, size_t size)
467 {
468 bool *v = pv;
469 *v = qemu_get_byte(f);
470 return 0;
471 }
472
473 static void put_bool(QEMUFile *f, void *pv, size_t size)
474 {
475 bool *v = pv;
476 qemu_put_byte(f, *v);
477 }
478
479 const VMStateInfo vmstate_info_bool = {
480 .name = "bool",
481 .get = get_bool,
482 .put = put_bool,
483 };
484
485 /* 8 bit int */
486
487 static int get_int8(QEMUFile *f, void *pv, size_t size)
488 {
489 int8_t *v = pv;
490 qemu_get_s8s(f, v);
491 return 0;
492 }
493
494 static void put_int8(QEMUFile *f, void *pv, size_t size)
495 {
496 int8_t *v = pv;
497 qemu_put_s8s(f, v);
498 }
499
500 const VMStateInfo vmstate_info_int8 = {
501 .name = "int8",
502 .get = get_int8,
503 .put = put_int8,
504 };
505
506 /* 16 bit int */
507
508 static int get_int16(QEMUFile *f, void *pv, size_t size)
509 {
510 int16_t *v = pv;
511 qemu_get_sbe16s(f, v);
512 return 0;
513 }
514
515 static void put_int16(QEMUFile *f, void *pv, size_t size)
516 {
517 int16_t *v = pv;
518 qemu_put_sbe16s(f, v);
519 }
520
521 const VMStateInfo vmstate_info_int16 = {
522 .name = "int16",
523 .get = get_int16,
524 .put = put_int16,
525 };
526
527 /* 32 bit int */
528
529 static int get_int32(QEMUFile *f, void *pv, size_t size)
530 {
531 int32_t *v = pv;
532 qemu_get_sbe32s(f, v);
533 return 0;
534 }
535
536 static void put_int32(QEMUFile *f, void *pv, size_t size)
537 {
538 int32_t *v = pv;
539 qemu_put_sbe32s(f, v);
540 }
541
542 const VMStateInfo vmstate_info_int32 = {
543 .name = "int32",
544 .get = get_int32,
545 .put = put_int32,
546 };
547
548 /* 32 bit int. See that the received value is the same than the one
549 in the field */
550
551 static int get_int32_equal(QEMUFile *f, void *pv, size_t size)
552 {
553 int32_t *v = pv;
554 int32_t v2;
555 qemu_get_sbe32s(f, &v2);
556
557 if (*v == v2) {
558 return 0;
559 }
560 error_report("%" PRIx32 " != %" PRIx32, *v, v2);
561 return -EINVAL;
562 }
563
564 const VMStateInfo vmstate_info_int32_equal = {
565 .name = "int32 equal",
566 .get = get_int32_equal,
567 .put = put_int32,
568 };
569
570 /* 32 bit int. Check that the received value is non-negative
571 * and less than or equal to the one in the field.
572 */
573
574 static int get_int32_le(QEMUFile *f, void *pv, size_t size)
575 {
576 int32_t *cur = pv;
577 int32_t loaded;
578 qemu_get_sbe32s(f, &loaded);
579
580 if (loaded >= 0 && loaded <= *cur) {
581 *cur = loaded;
582 return 0;
583 }
584 error_report("Invalid value %" PRId32
585 " expecting positive value <= %" PRId32,
586 loaded, *cur);
587 return -EINVAL;
588 }
589
590 const VMStateInfo vmstate_info_int32_le = {
591 .name = "int32 le",
592 .get = get_int32_le,
593 .put = put_int32,
594 };
595
596 /* 64 bit int */
597
598 static int get_int64(QEMUFile *f, void *pv, size_t size)
599 {
600 int64_t *v = pv;
601 qemu_get_sbe64s(f, v);
602 return 0;
603 }
604
605 static void put_int64(QEMUFile *f, void *pv, size_t size)
606 {
607 int64_t *v = pv;
608 qemu_put_sbe64s(f, v);
609 }
610
611 const VMStateInfo vmstate_info_int64 = {
612 .name = "int64",
613 .get = get_int64,
614 .put = put_int64,
615 };
616
617 /* 8 bit unsigned int */
618
619 static int get_uint8(QEMUFile *f, void *pv, size_t size)
620 {
621 uint8_t *v = pv;
622 qemu_get_8s(f, v);
623 return 0;
624 }
625
626 static void put_uint8(QEMUFile *f, void *pv, size_t size)
627 {
628 uint8_t *v = pv;
629 qemu_put_8s(f, v);
630 }
631
632 const VMStateInfo vmstate_info_uint8 = {
633 .name = "uint8",
634 .get = get_uint8,
635 .put = put_uint8,
636 };
637
638 /* 16 bit unsigned int */
639
640 static int get_uint16(QEMUFile *f, void *pv, size_t size)
641 {
642 uint16_t *v = pv;
643 qemu_get_be16s(f, v);
644 return 0;
645 }
646
647 static void put_uint16(QEMUFile *f, void *pv, size_t size)
648 {
649 uint16_t *v = pv;
650 qemu_put_be16s(f, v);
651 }
652
653 const VMStateInfo vmstate_info_uint16 = {
654 .name = "uint16",
655 .get = get_uint16,
656 .put = put_uint16,
657 };
658
659 /* 32 bit unsigned int */
660
661 static int get_uint32(QEMUFile *f, void *pv, size_t size)
662 {
663 uint32_t *v = pv;
664 qemu_get_be32s(f, v);
665 return 0;
666 }
667
668 static void put_uint32(QEMUFile *f, void *pv, size_t size)
669 {
670 uint32_t *v = pv;
671 qemu_put_be32s(f, v);
672 }
673
674 const VMStateInfo vmstate_info_uint32 = {
675 .name = "uint32",
676 .get = get_uint32,
677 .put = put_uint32,
678 };
679
680 /* 32 bit uint. See that the received value is the same than the one
681 in the field */
682
683 static int get_uint32_equal(QEMUFile *f, void *pv, size_t size)
684 {
685 uint32_t *v = pv;
686 uint32_t v2;
687 qemu_get_be32s(f, &v2);
688
689 if (*v == v2) {
690 return 0;
691 }
692 error_report("%" PRIx32 " != %" PRIx32, *v, v2);
693 return -EINVAL;
694 }
695
696 const VMStateInfo vmstate_info_uint32_equal = {
697 .name = "uint32 equal",
698 .get = get_uint32_equal,
699 .put = put_uint32,
700 };
701
702 /* 64 bit unsigned int */
703
704 static int get_uint64(QEMUFile *f, void *pv, size_t size)
705 {
706 uint64_t *v = pv;
707 qemu_get_be64s(f, v);
708 return 0;
709 }
710
711 static void put_uint64(QEMUFile *f, void *pv, size_t size)
712 {
713 uint64_t *v = pv;
714 qemu_put_be64s(f, v);
715 }
716
717 const VMStateInfo vmstate_info_uint64 = {
718 .name = "uint64",
719 .get = get_uint64,
720 .put = put_uint64,
721 };
722
723 /* 64 bit unsigned int. See that the received value is the same than the one
724 in the field */
725
726 static int get_uint64_equal(QEMUFile *f, void *pv, size_t size)
727 {
728 uint64_t *v = pv;
729 uint64_t v2;
730 qemu_get_be64s(f, &v2);
731
732 if (*v == v2) {
733 return 0;
734 }
735 error_report("%" PRIx64 " != %" PRIx64, *v, v2);
736 return -EINVAL;
737 }
738
739 const VMStateInfo vmstate_info_uint64_equal = {
740 .name = "int64 equal",
741 .get = get_uint64_equal,
742 .put = put_uint64,
743 };
744
745 /* 8 bit int. See that the received value is the same than the one
746 in the field */
747
748 static int get_uint8_equal(QEMUFile *f, void *pv, size_t size)
749 {
750 uint8_t *v = pv;
751 uint8_t v2;
752 qemu_get_8s(f, &v2);
753
754 if (*v == v2) {
755 return 0;
756 }
757 error_report("%x != %x", *v, v2);
758 return -EINVAL;
759 }
760
761 const VMStateInfo vmstate_info_uint8_equal = {
762 .name = "uint8 equal",
763 .get = get_uint8_equal,
764 .put = put_uint8,
765 };
766
767 /* 16 bit unsigned int int. See that the received value is the same than the one
768 in the field */
769
770 static int get_uint16_equal(QEMUFile *f, void *pv, size_t size)
771 {
772 uint16_t *v = pv;
773 uint16_t v2;
774 qemu_get_be16s(f, &v2);
775
776 if (*v == v2) {
777 return 0;
778 }
779 error_report("%x != %x", *v, v2);
780 return -EINVAL;
781 }
782
783 const VMStateInfo vmstate_info_uint16_equal = {
784 .name = "uint16 equal",
785 .get = get_uint16_equal,
786 .put = put_uint16,
787 };
788
789 /* floating point */
790
791 static int get_float64(QEMUFile *f, void *pv, size_t size)
792 {
793 float64 *v = pv;
794
795 *v = make_float64(qemu_get_be64(f));
796 return 0;
797 }
798
799 static void put_float64(QEMUFile *f, void *pv, size_t size)
800 {
801 uint64_t *v = pv;
802
803 qemu_put_be64(f, float64_val(*v));
804 }
805
806 const VMStateInfo vmstate_info_float64 = {
807 .name = "float64",
808 .get = get_float64,
809 .put = put_float64,
810 };
811
812 /* CPU_DoubleU type */
813
814 static int get_cpudouble(QEMUFile *f, void *pv, size_t size)
815 {
816 CPU_DoubleU *v = pv;
817 qemu_get_be32s(f, &v->l.upper);
818 qemu_get_be32s(f, &v->l.lower);
819 return 0;
820 }
821
822 static void put_cpudouble(QEMUFile *f, void *pv, size_t size)
823 {
824 CPU_DoubleU *v = pv;
825 qemu_put_be32s(f, &v->l.upper);
826 qemu_put_be32s(f, &v->l.lower);
827 }
828
829 const VMStateInfo vmstate_info_cpudouble = {
830 .name = "CPU_Double_U",
831 .get = get_cpudouble,
832 .put = put_cpudouble,
833 };
834
835 /* uint8_t buffers */
836
837 static int get_buffer(QEMUFile *f, void *pv, size_t size)
838 {
839 uint8_t *v = pv;
840 qemu_get_buffer(f, v, size);
841 return 0;
842 }
843
844 static void put_buffer(QEMUFile *f, void *pv, size_t size)
845 {
846 uint8_t *v = pv;
847 qemu_put_buffer(f, v, size);
848 }
849
850 const VMStateInfo vmstate_info_buffer = {
851 .name = "buffer",
852 .get = get_buffer,
853 .put = put_buffer,
854 };
855
856 /* unused buffers: space that was used for some fields that are
857 not useful anymore */
858
859 static int get_unused_buffer(QEMUFile *f, void *pv, size_t size)
860 {
861 uint8_t buf[1024];
862 int block_len;
863
864 while (size > 0) {
865 block_len = MIN(sizeof(buf), size);
866 size -= block_len;
867 qemu_get_buffer(f, buf, block_len);
868 }
869 return 0;
870 }
871
872 static void put_unused_buffer(QEMUFile *f, void *pv, size_t size)
873 {
874 static const uint8_t buf[1024];
875 int block_len;
876
877 while (size > 0) {
878 block_len = MIN(sizeof(buf), size);
879 size -= block_len;
880 qemu_put_buffer(f, buf, block_len);
881 }
882 }
883
884 const VMStateInfo vmstate_info_unused_buffer = {
885 .name = "unused_buffer",
886 .get = get_unused_buffer,
887 .put = put_unused_buffer,
888 };
889
890 /* bitmaps (as defined by bitmap.h). Note that size here is the size
891 * of the bitmap in bits. The on-the-wire format of a bitmap is 64
892 * bit words with the bits in big endian order. The in-memory format
893 * is an array of 'unsigned long', which may be either 32 or 64 bits.
894 */
895 /* This is the number of 64 bit words sent over the wire */
896 #define BITS_TO_U64S(nr) DIV_ROUND_UP(nr, 64)
897 static int get_bitmap(QEMUFile *f, void *pv, size_t size)
898 {
899 unsigned long *bmp = pv;
900 int i, idx = 0;
901 for (i = 0; i < BITS_TO_U64S(size); i++) {
902 uint64_t w = qemu_get_be64(f);
903 bmp[idx++] = w;
904 if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
905 bmp[idx++] = w >> 32;
906 }
907 }
908 return 0;
909 }
910
911 static void put_bitmap(QEMUFile *f, void *pv, size_t size)
912 {
913 unsigned long *bmp = pv;
914 int i, idx = 0;
915 for (i = 0; i < BITS_TO_U64S(size); i++) {
916 uint64_t w = bmp[idx++];
917 if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
918 w |= ((uint64_t)bmp[idx++]) << 32;
919 }
920 qemu_put_be64(f, w);
921 }
922 }
923
924 const VMStateInfo vmstate_info_bitmap = {
925 .name = "bitmap",
926 .get = get_bitmap,
927 .put = put_bitmap,
928 };