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