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 }; 688