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