xref: /openbmc/qemu/migration/vmstate-types.c (revision 500eb6db)
1 /*
2  * VMStateInfo's for basic typse
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 "exec/cpu-common.h"
15 #include "qemu-file.h"
16 #include "migration.h"
17 #include "migration/vmstate.h"
18 #include "qemu/error-report.h"
19 #include "qemu/queue.h"
20 #include "trace.h"
21 
22 /* bool */
23 
24 static int get_bool(QEMUFile *f, void *pv, size_t size,
25                     const VMStateField *field)
26 {
27     bool *v = pv;
28     *v = qemu_get_byte(f);
29     return 0;
30 }
31 
32 static int put_bool(QEMUFile *f, void *pv, size_t size,
33                     const VMStateField *field, QJSON *vmdesc)
34 {
35     bool *v = pv;
36     qemu_put_byte(f, *v);
37     return 0;
38 }
39 
40 const VMStateInfo vmstate_info_bool = {
41     .name = "bool",
42     .get  = get_bool,
43     .put  = put_bool,
44 };
45 
46 /* 8 bit int */
47 
48 static int get_int8(QEMUFile *f, void *pv, size_t size,
49                     const VMStateField *field)
50 {
51     int8_t *v = pv;
52     qemu_get_s8s(f, v);
53     return 0;
54 }
55 
56 static int put_int8(QEMUFile *f, void *pv, size_t size,
57                     const VMStateField *field, QJSON *vmdesc)
58 {
59     int8_t *v = pv;
60     qemu_put_s8s(f, v);
61     return 0;
62 }
63 
64 const VMStateInfo vmstate_info_int8 = {
65     .name = "int8",
66     .get  = get_int8,
67     .put  = put_int8,
68 };
69 
70 /* 16 bit int */
71 
72 static int get_int16(QEMUFile *f, void *pv, size_t size,
73                      const VMStateField *field)
74 {
75     int16_t *v = pv;
76     qemu_get_sbe16s(f, v);
77     return 0;
78 }
79 
80 static int put_int16(QEMUFile *f, void *pv, size_t size,
81                      const VMStateField *field, QJSON *vmdesc)
82 {
83     int16_t *v = pv;
84     qemu_put_sbe16s(f, v);
85     return 0;
86 }
87 
88 const VMStateInfo vmstate_info_int16 = {
89     .name = "int16",
90     .get  = get_int16,
91     .put  = put_int16,
92 };
93 
94 /* 32 bit int */
95 
96 static int get_int32(QEMUFile *f, void *pv, size_t size,
97                      const VMStateField *field)
98 {
99     int32_t *v = pv;
100     qemu_get_sbe32s(f, v);
101     return 0;
102 }
103 
104 static int put_int32(QEMUFile *f, void *pv, size_t size,
105                      const VMStateField *field, QJSON *vmdesc)
106 {
107     int32_t *v = pv;
108     qemu_put_sbe32s(f, v);
109     return 0;
110 }
111 
112 const VMStateInfo vmstate_info_int32 = {
113     .name = "int32",
114     .get  = get_int32,
115     .put  = put_int32,
116 };
117 
118 /* 32 bit int. See that the received value is the same than the one
119    in the field */
120 
121 static int get_int32_equal(QEMUFile *f, void *pv, size_t size,
122                            const VMStateField *field)
123 {
124     int32_t *v = pv;
125     int32_t v2;
126     qemu_get_sbe32s(f, &v2);
127 
128     if (*v == v2) {
129         return 0;
130     }
131     error_report("%" PRIx32 " != %" PRIx32, *v, v2);
132     if (field->err_hint) {
133         error_printf("%s\n", field->err_hint);
134     }
135     return -EINVAL;
136 }
137 
138 const VMStateInfo vmstate_info_int32_equal = {
139     .name = "int32 equal",
140     .get  = get_int32_equal,
141     .put  = put_int32,
142 };
143 
144 /* 32 bit int. Check that the received value is non-negative
145  * and less than or equal to the one in the field.
146  */
147 
148 static int get_int32_le(QEMUFile *f, void *pv, size_t size,
149                         const VMStateField *field)
150 {
151     int32_t *cur = pv;
152     int32_t loaded;
153     qemu_get_sbe32s(f, &loaded);
154 
155     if (loaded >= 0 && loaded <= *cur) {
156         *cur = loaded;
157         return 0;
158     }
159     error_report("Invalid value %" PRId32
160                  " expecting positive value <= %" PRId32,
161                  loaded, *cur);
162     return -EINVAL;
163 }
164 
165 const VMStateInfo vmstate_info_int32_le = {
166     .name = "int32 le",
167     .get  = get_int32_le,
168     .put  = put_int32,
169 };
170 
171 /* 64 bit int */
172 
173 static int get_int64(QEMUFile *f, void *pv, size_t size,
174                      const VMStateField *field)
175 {
176     int64_t *v = pv;
177     qemu_get_sbe64s(f, v);
178     return 0;
179 }
180 
181 static int put_int64(QEMUFile *f, void *pv, size_t size,
182                      const VMStateField *field, QJSON *vmdesc)
183 {
184     int64_t *v = pv;
185     qemu_put_sbe64s(f, v);
186     return 0;
187 }
188 
189 const VMStateInfo vmstate_info_int64 = {
190     .name = "int64",
191     .get  = get_int64,
192     .put  = put_int64,
193 };
194 
195 /* 8 bit unsigned int */
196 
197 static int get_uint8(QEMUFile *f, void *pv, size_t size,
198                      const VMStateField *field)
199 {
200     uint8_t *v = pv;
201     qemu_get_8s(f, v);
202     return 0;
203 }
204 
205 static int put_uint8(QEMUFile *f, void *pv, size_t size,
206                      const VMStateField *field, QJSON *vmdesc)
207 {
208     uint8_t *v = pv;
209     qemu_put_8s(f, v);
210     return 0;
211 }
212 
213 const VMStateInfo vmstate_info_uint8 = {
214     .name = "uint8",
215     .get  = get_uint8,
216     .put  = put_uint8,
217 };
218 
219 /* 16 bit unsigned int */
220 
221 static int get_uint16(QEMUFile *f, void *pv, size_t size,
222                       const VMStateField *field)
223 {
224     uint16_t *v = pv;
225     qemu_get_be16s(f, v);
226     return 0;
227 }
228 
229 static int put_uint16(QEMUFile *f, void *pv, size_t size,
230                       const VMStateField *field, QJSON *vmdesc)
231 {
232     uint16_t *v = pv;
233     qemu_put_be16s(f, v);
234     return 0;
235 }
236 
237 const VMStateInfo vmstate_info_uint16 = {
238     .name = "uint16",
239     .get  = get_uint16,
240     .put  = put_uint16,
241 };
242 
243 /* 32 bit unsigned int */
244 
245 static int get_uint32(QEMUFile *f, void *pv, size_t size,
246                       const VMStateField *field)
247 {
248     uint32_t *v = pv;
249     qemu_get_be32s(f, v);
250     return 0;
251 }
252 
253 static int put_uint32(QEMUFile *f, void *pv, size_t size,
254                       const VMStateField *field, QJSON *vmdesc)
255 {
256     uint32_t *v = pv;
257     qemu_put_be32s(f, v);
258     return 0;
259 }
260 
261 const VMStateInfo vmstate_info_uint32 = {
262     .name = "uint32",
263     .get  = get_uint32,
264     .put  = put_uint32,
265 };
266 
267 /* 32 bit uint. See that the received value is the same than the one
268    in the field */
269 
270 static int get_uint32_equal(QEMUFile *f, void *pv, size_t size,
271                             const VMStateField *field)
272 {
273     uint32_t *v = pv;
274     uint32_t v2;
275     qemu_get_be32s(f, &v2);
276 
277     if (*v == v2) {
278         return 0;
279     }
280     error_report("%" PRIx32 " != %" PRIx32, *v, v2);
281     if (field->err_hint) {
282         error_printf("%s\n", field->err_hint);
283     }
284     return -EINVAL;
285 }
286 
287 const VMStateInfo vmstate_info_uint32_equal = {
288     .name = "uint32 equal",
289     .get  = get_uint32_equal,
290     .put  = put_uint32,
291 };
292 
293 /* 64 bit unsigned int */
294 
295 static int get_uint64(QEMUFile *f, void *pv, size_t size,
296                       const VMStateField *field)
297 {
298     uint64_t *v = pv;
299     qemu_get_be64s(f, v);
300     return 0;
301 }
302 
303 static int put_uint64(QEMUFile *f, void *pv, size_t size,
304                       const VMStateField *field, QJSON *vmdesc)
305 {
306     uint64_t *v = pv;
307     qemu_put_be64s(f, v);
308     return 0;
309 }
310 
311 const VMStateInfo vmstate_info_uint64 = {
312     .name = "uint64",
313     .get  = get_uint64,
314     .put  = put_uint64,
315 };
316 
317 static int get_nullptr(QEMUFile *f, void *pv, size_t size,
318                        const VMStateField *field)
319 
320 {
321     if (qemu_get_byte(f) == VMS_NULLPTR_MARKER) {
322         return  0;
323     }
324     error_report("vmstate: get_nullptr expected VMS_NULLPTR_MARKER");
325     return -EINVAL;
326 }
327 
328 static int put_nullptr(QEMUFile *f, void *pv, size_t size,
329                         const VMStateField *field, QJSON *vmdesc)
330 
331 {
332     if (pv == NULL) {
333         qemu_put_byte(f, VMS_NULLPTR_MARKER);
334         return 0;
335     }
336     error_report("vmstate: put_nullptr must be called with pv == NULL");
337     return -EINVAL;
338 }
339 
340 const VMStateInfo vmstate_info_nullptr = {
341     .name = "uint64",
342     .get  = get_nullptr,
343     .put  = put_nullptr,
344 };
345 
346 /* 64 bit unsigned int. See that the received value is the same than the one
347    in the field */
348 
349 static int get_uint64_equal(QEMUFile *f, void *pv, size_t size,
350                             const VMStateField *field)
351 {
352     uint64_t *v = pv;
353     uint64_t v2;
354     qemu_get_be64s(f, &v2);
355 
356     if (*v == v2) {
357         return 0;
358     }
359     error_report("%" PRIx64 " != %" PRIx64, *v, v2);
360     if (field->err_hint) {
361         error_printf("%s\n", field->err_hint);
362     }
363     return -EINVAL;
364 }
365 
366 const VMStateInfo vmstate_info_uint64_equal = {
367     .name = "int64 equal",
368     .get  = get_uint64_equal,
369     .put  = put_uint64,
370 };
371 
372 /* 8 bit int. See that the received value is the same than the one
373    in the field */
374 
375 static int get_uint8_equal(QEMUFile *f, void *pv, size_t size,
376                            const VMStateField *field)
377 {
378     uint8_t *v = pv;
379     uint8_t v2;
380     qemu_get_8s(f, &v2);
381 
382     if (*v == v2) {
383         return 0;
384     }
385     error_report("%x != %x", *v, v2);
386     if (field->err_hint) {
387         error_printf("%s\n", field->err_hint);
388     }
389     return -EINVAL;
390 }
391 
392 const VMStateInfo vmstate_info_uint8_equal = {
393     .name = "uint8 equal",
394     .get  = get_uint8_equal,
395     .put  = put_uint8,
396 };
397 
398 /* 16 bit unsigned int int. See that the received value is the same than the one
399    in the field */
400 
401 static int get_uint16_equal(QEMUFile *f, void *pv, size_t size,
402                             const VMStateField *field)
403 {
404     uint16_t *v = pv;
405     uint16_t v2;
406     qemu_get_be16s(f, &v2);
407 
408     if (*v == v2) {
409         return 0;
410     }
411     error_report("%x != %x", *v, v2);
412     if (field->err_hint) {
413         error_printf("%s\n", field->err_hint);
414     }
415     return -EINVAL;
416 }
417 
418 const VMStateInfo vmstate_info_uint16_equal = {
419     .name = "uint16 equal",
420     .get  = get_uint16_equal,
421     .put  = put_uint16,
422 };
423 
424 /* floating point */
425 
426 static int get_float64(QEMUFile *f, void *pv, size_t size,
427                        const VMStateField *field)
428 {
429     float64 *v = pv;
430 
431     *v = make_float64(qemu_get_be64(f));
432     return 0;
433 }
434 
435 static int put_float64(QEMUFile *f, void *pv, size_t size,
436                        const VMStateField *field, QJSON *vmdesc)
437 {
438     uint64_t *v = pv;
439 
440     qemu_put_be64(f, float64_val(*v));
441     return 0;
442 }
443 
444 const VMStateInfo vmstate_info_float64 = {
445     .name = "float64",
446     .get  = get_float64,
447     .put  = put_float64,
448 };
449 
450 /* CPU_DoubleU type */
451 
452 static int get_cpudouble(QEMUFile *f, void *pv, size_t size,
453                          const VMStateField *field)
454 {
455     CPU_DoubleU *v = pv;
456     qemu_get_be32s(f, &v->l.upper);
457     qemu_get_be32s(f, &v->l.lower);
458     return 0;
459 }
460 
461 static int put_cpudouble(QEMUFile *f, void *pv, size_t size,
462                          const VMStateField *field, QJSON *vmdesc)
463 {
464     CPU_DoubleU *v = pv;
465     qemu_put_be32s(f, &v->l.upper);
466     qemu_put_be32s(f, &v->l.lower);
467     return 0;
468 }
469 
470 const VMStateInfo vmstate_info_cpudouble = {
471     .name = "CPU_Double_U",
472     .get  = get_cpudouble,
473     .put  = put_cpudouble,
474 };
475 
476 /* uint8_t buffers */
477 
478 static int get_buffer(QEMUFile *f, void *pv, size_t size,
479                       const VMStateField *field)
480 {
481     uint8_t *v = pv;
482     qemu_get_buffer(f, v, size);
483     return 0;
484 }
485 
486 static int put_buffer(QEMUFile *f, void *pv, size_t size,
487                       const VMStateField *field, QJSON *vmdesc)
488 {
489     uint8_t *v = pv;
490     qemu_put_buffer(f, v, size);
491     return 0;
492 }
493 
494 const VMStateInfo vmstate_info_buffer = {
495     .name = "buffer",
496     .get  = get_buffer,
497     .put  = put_buffer,
498 };
499 
500 /* unused buffers: space that was used for some fields that are
501    not useful anymore */
502 
503 static int get_unused_buffer(QEMUFile *f, void *pv, size_t size,
504                              const VMStateField *field)
505 {
506     uint8_t buf[1024];
507     int block_len;
508 
509     while (size > 0) {
510         block_len = MIN(sizeof(buf), size);
511         size -= block_len;
512         qemu_get_buffer(f, buf, block_len);
513     }
514    return 0;
515 }
516 
517 static int put_unused_buffer(QEMUFile *f, void *pv, size_t size,
518                              const VMStateField *field, QJSON *vmdesc)
519 {
520     static const uint8_t buf[1024];
521     int block_len;
522 
523     while (size > 0) {
524         block_len = MIN(sizeof(buf), size);
525         size -= block_len;
526         qemu_put_buffer(f, buf, block_len);
527     }
528 
529     return 0;
530 }
531 
532 const VMStateInfo vmstate_info_unused_buffer = {
533     .name = "unused_buffer",
534     .get  = get_unused_buffer,
535     .put  = put_unused_buffer,
536 };
537 
538 /* vmstate_info_tmp, see VMSTATE_WITH_TMP, the idea is that we allocate
539  * a temporary buffer and the pre_load/pre_save methods in the child vmsd
540  * copy stuff from the parent into the child and do calculations to fill
541  * in fields that don't really exist in the parent but need to be in the
542  * stream.
543  */
544 static int get_tmp(QEMUFile *f, void *pv, size_t size,
545                    const VMStateField *field)
546 {
547     int ret;
548     const VMStateDescription *vmsd = field->vmsd;
549     int version_id = field->version_id;
550     void *tmp = g_malloc(size);
551 
552     /* Writes the parent field which is at the start of the tmp */
553     *(void **)tmp = pv;
554     ret = vmstate_load_state(f, vmsd, tmp, version_id);
555     g_free(tmp);
556     return ret;
557 }
558 
559 static int put_tmp(QEMUFile *f, void *pv, size_t size,
560                    const VMStateField *field, QJSON *vmdesc)
561 {
562     const VMStateDescription *vmsd = field->vmsd;
563     void *tmp = g_malloc(size);
564     int ret;
565 
566     /* Writes the parent field which is at the start of the tmp */
567     *(void **)tmp = pv;
568     ret = vmstate_save_state(f, vmsd, tmp, vmdesc);
569     g_free(tmp);
570 
571     return ret;
572 }
573 
574 const VMStateInfo vmstate_info_tmp = {
575     .name = "tmp",
576     .get = get_tmp,
577     .put = put_tmp,
578 };
579 
580 /* bitmaps (as defined by bitmap.h). Note that size here is the size
581  * of the bitmap in bits. The on-the-wire format of a bitmap is 64
582  * bit words with the bits in big endian order. The in-memory format
583  * is an array of 'unsigned long', which may be either 32 or 64 bits.
584  */
585 /* This is the number of 64 bit words sent over the wire */
586 #define BITS_TO_U64S(nr) DIV_ROUND_UP(nr, 64)
587 static int get_bitmap(QEMUFile *f, void *pv, size_t size,
588                       const VMStateField *field)
589 {
590     unsigned long *bmp = pv;
591     int i, idx = 0;
592     for (i = 0; i < BITS_TO_U64S(size); i++) {
593         uint64_t w = qemu_get_be64(f);
594         bmp[idx++] = w;
595         if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
596             bmp[idx++] = w >> 32;
597         }
598     }
599     return 0;
600 }
601 
602 static int put_bitmap(QEMUFile *f, void *pv, size_t size,
603                       const VMStateField *field, QJSON *vmdesc)
604 {
605     unsigned long *bmp = pv;
606     int i, idx = 0;
607     for (i = 0; i < BITS_TO_U64S(size); i++) {
608         uint64_t w = bmp[idx++];
609         if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
610             w |= ((uint64_t)bmp[idx++]) << 32;
611         }
612         qemu_put_be64(f, w);
613     }
614 
615     return 0;
616 }
617 
618 const VMStateInfo vmstate_info_bitmap = {
619     .name = "bitmap",
620     .get = get_bitmap,
621     .put = put_bitmap,
622 };
623 
624 /* get for QTAILQ
625  * meta data about the QTAILQ is encoded in a VMStateField structure
626  */
627 static int get_qtailq(QEMUFile *f, void *pv, size_t unused_size,
628                       const VMStateField *field)
629 {
630     int ret = 0;
631     const VMStateDescription *vmsd = field->vmsd;
632     /* size of a QTAILQ element */
633     size_t size = field->size;
634     /* offset of the QTAILQ entry in a QTAILQ element */
635     size_t entry_offset = field->start;
636     int version_id = field->version_id;
637     void *elm;
638 
639     trace_get_qtailq(vmsd->name, version_id);
640     if (version_id > vmsd->version_id) {
641         error_report("%s %s",  vmsd->name, "too new");
642         trace_get_qtailq_end(vmsd->name, "too new", -EINVAL);
643 
644         return -EINVAL;
645     }
646     if (version_id < vmsd->minimum_version_id) {
647         error_report("%s %s",  vmsd->name, "too old");
648         trace_get_qtailq_end(vmsd->name, "too old", -EINVAL);
649         return -EINVAL;
650     }
651 
652     while (qemu_get_byte(f)) {
653         elm = g_malloc(size);
654         ret = vmstate_load_state(f, vmsd, elm, version_id);
655         if (ret) {
656             return ret;
657         }
658         QTAILQ_RAW_INSERT_TAIL(pv, elm, entry_offset);
659     }
660 
661     trace_get_qtailq_end(vmsd->name, "end", ret);
662     return ret;
663 }
664 
665 /* put for QTAILQ */
666 static int put_qtailq(QEMUFile *f, void *pv, size_t unused_size,
667                       const VMStateField *field, QJSON *vmdesc)
668 {
669     const VMStateDescription *vmsd = field->vmsd;
670     /* offset of the QTAILQ entry in a QTAILQ element*/
671     size_t entry_offset = field->start;
672     void *elm;
673     int ret;
674 
675     trace_put_qtailq(vmsd->name, vmsd->version_id);
676 
677     QTAILQ_RAW_FOREACH(elm, pv, entry_offset) {
678         qemu_put_byte(f, true);
679         ret = vmstate_save_state(f, vmsd, elm, vmdesc);
680         if (ret) {
681             return ret;
682         }
683     }
684     qemu_put_byte(f, false);
685 
686     trace_put_qtailq_end(vmsd->name, "end");
687 
688     return 0;
689 }
690 const VMStateInfo vmstate_info_qtailq = {
691     .name = "qtailq",
692     .get  = get_qtailq,
693     .put  = put_qtailq,
694 };
695