migration/vmstate-types.c

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