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