migration/vmstate.c

   1 /*
   2  * VMState interpreter
   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 "migration.h"
  16 #include "migration/vmstate.h"
  17 #include "savevm.h"
  18 #include "qemu-file.h"
  19 #include "qemu/bitops.h"
  20 #include "qemu/error-report.h"
  21 #include "trace.h"
  22 #include "qjson.h"
  23
  24 static int vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
  25                                    void *opaque, QJSON *vmdesc);
  26 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
  27                                    void *opaque);
  28
  29 static int vmstate_n_elems(void *opaque, const VMStateField *field)
  30 {
  31     int n_elems = 1;
  32
  33     if (field->flags & VMS_ARRAY) {
  34         n_elems = field->num;
  35     } else if (field->flags & VMS_VARRAY_INT32) {
  36         n_elems = *(int32_t *)(opaque+field->num_offset);
  37     } else if (field->flags & VMS_VARRAY_UINT32) {
  38         n_elems = *(uint32_t *)(opaque+field->num_offset);
  39     } else if (field->flags & VMS_VARRAY_UINT16) {
  40         n_elems = *(uint16_t *)(opaque+field->num_offset);
  41     } else if (field->flags & VMS_VARRAY_UINT8) {
  42         n_elems = *(uint8_t *)(opaque+field->num_offset);
  43     }
  44
  45     if (field->flags & VMS_MULTIPLY_ELEMENTS) {
  46         n_elems *= field->num;
  47     }
  48
  49     trace_vmstate_n_elems(field->name, n_elems);
  50     return n_elems;
  51 }
  52
  53 static int vmstate_size(void *opaque, const VMStateField *field)
  54 {
  55     int size = field->size;
  56
  57     if (field->flags & VMS_VBUFFER) {
  58         size = *(int32_t *)(opaque+field->size_offset);
  59         if (field->flags & VMS_MULTIPLY) {
  60             size *= field->size;
  61         }
  62     }
  63
  64     return size;
  65 }
  66
  67 static void vmstate_handle_alloc(void *ptr, const VMStateField *field,
  68                                  void *opaque)
  69 {
  70     if (field->flags & VMS_POINTER && field->flags & VMS_ALLOC) {
  71         gsize size = vmstate_size(opaque, field);
  72         size *= vmstate_n_elems(opaque, field);
  73         if (size) {
  74             *(void **)ptr = g_malloc(size);
  75         }
  76     }
  77 }
  78
  79 int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
  80                        void *opaque, int version_id)
  81 {
  82     const VMStateField *field = vmsd->fields;
  83     int ret = 0;
  84
  85     trace_vmstate_load_state(vmsd->name, version_id);
  86     if (version_id > vmsd->version_id) {
  87         error_report("%s: incoming version_id %d is too new "
  88                      "for local version_id %d",
  89                      vmsd->name, version_id, vmsd->version_id);
  90         trace_vmstate_load_state_end(vmsd->name, "too new", -EINVAL);
  91         return -EINVAL;
  92     }
  93     if  (version_id < vmsd->minimum_version_id) {
  94         if (vmsd->load_state_old &&
  95             version_id >= vmsd->minimum_version_id_old) {
  96             ret = vmsd->load_state_old(f, opaque, version_id);
  97             trace_vmstate_load_state_end(vmsd->name, "old path", ret);
  98             return ret;
  99         }
 100         error_report("%s: incoming version_id %d is too old "
 101                      "for local minimum version_id  %d",
 102                      vmsd->name, version_id, vmsd->minimum_version_id);
 103         trace_vmstate_load_state_end(vmsd->name, "too old", -EINVAL);
 104         return -EINVAL;
 105     }
 106     if (vmsd->pre_load) {
 107         int ret = vmsd->pre_load(opaque);
 108         if (ret) {
 109             return ret;
 110         }
 111     }
 112     while (field->name) {
 113         trace_vmstate_load_state_field(vmsd->name, field->name);
 114         if ((field->field_exists &&
 115              field->field_exists(opaque, version_id)) ||
 116             (!field->field_exists &&
 117              field->version_id <= version_id)) {
 118             void *first_elem = opaque + field->offset;
 119             int i, n_elems = vmstate_n_elems(opaque, field);
 120             int size = vmstate_size(opaque, field);
 121
 122             vmstate_handle_alloc(first_elem, field, opaque);
 123             if (field->flags & VMS_POINTER) {
 124                 first_elem = *(void **)first_elem;
 125                 assert(first_elem || !n_elems || !size);
 126             }
 127             for (i = 0; i < n_elems; i++) {
 128                 void *curr_elem = first_elem + size * i;
 129
 130                 if (field->flags & VMS_ARRAY_OF_POINTER) {
 131                     curr_elem = *(void **)curr_elem;
 132                 }
 133                 if (!curr_elem && size) {
 134                     /* if null pointer check placeholder and do not follow */
 135                     assert(field->flags & VMS_ARRAY_OF_POINTER);
 136                     ret = vmstate_info_nullptr.get(f, curr_elem, size, NULL);
 137                 } else if (field->flags & VMS_STRUCT) {
 138                     ret = vmstate_load_state(f, field->vmsd, curr_elem,
 139                                              field->vmsd->version_id);
 140                 } else if (field->flags & VMS_VSTRUCT) {
 141                     ret = vmstate_load_state(f, field->vmsd, curr_elem,
 142                                              field->struct_version_id);
 143                 } else {
 144                     ret = field->info->get(f, curr_elem, size, field);
 145                 }
 146                 if (ret >= 0) {
 147                     ret = qemu_file_get_error(f);
 148                 }
 149                 if (ret < 0) {
 150                     qemu_file_set_error(f, ret);
 151                     error_report("Failed to load %s:%s", vmsd->name,
 152                                  field->name);
 153                     trace_vmstate_load_field_error(field->name, ret);
 154                     return ret;
 155                 }
 156             }
 157         } else if (field->flags & VMS_MUST_EXIST) {
 158             error_report("Input validation failed: %s/%s",
 159                          vmsd->name, field->name);
 160             return -1;
 161         }
 162         field++;
 163     }
 164     ret = vmstate_subsection_load(f, vmsd, opaque);
 165     if (ret != 0) {
 166         return ret;
 167     }
 168     if (vmsd->post_load) {
 169         ret = vmsd->post_load(opaque, version_id);
 170     }
 171     trace_vmstate_load_state_end(vmsd->name, "end", ret);
 172     return ret;
 173 }
 174
 175 static int vmfield_name_num(const VMStateField *start,
 176                             const VMStateField *search)
 177 {
 178     const VMStateField *field;
 179     int found = 0;
 180
 181     for (field = start; field->name; field++) {
 182         if (!strcmp(field->name, search->name)) {
 183             if (field == search) {
 184                 return found;
 185             }
 186             found++;
 187         }
 188     }
 189
 190     return -1;
 191 }
 192
 193 static bool vmfield_name_is_unique(const VMStateField *start,
 194                                    const VMStateField *search)
 195 {
 196     const VMStateField *field;
 197     int found = 0;
 198
 199     for (field = start; field->name; field++) {
 200         if (!strcmp(field->name, search->name)) {
 201             found++;
 202             /* name found more than once, so it's not unique */
 203             if (found > 1) {
 204                 return false;
 205             }
 206         }
 207     }
 208
 209     return true;
 210 }
 211
 212 static const char *vmfield_get_type_name(const VMStateField *field)
 213 {
 214     const char *type = "unknown";
 215
 216     if (field->flags & VMS_STRUCT) {
 217         type = "struct";
 218     } else if (field->flags & VMS_VSTRUCT) {
 219         type = "vstruct";
 220     } else if (field->info->name) {
 221         type = field->info->name;
 222     }
 223
 224     return type;
 225 }
 226
 227 static bool vmsd_can_compress(const VMStateField *field)
 228 {
 229     if (field->field_exists) {
 230         /* Dynamically existing fields mess up compression */
 231         return false;
 232     }
 233
 234     if (field->flags & VMS_STRUCT) {
 235         const VMStateField *sfield = field->vmsd->fields;
 236         while (sfield->name) {
 237             if (!vmsd_can_compress(sfield)) {
 238                 /* Child elements can't compress, so can't we */
 239                 return false;
 240             }
 241             sfield++;
 242         }
 243
 244         if (field->vmsd->subsections) {
 245             /* Subsections may come and go, better don't compress */
 246             return false;
 247         }
 248     }
 249
 250     return true;
 251 }
 252
 253 static void vmsd_desc_field_start(const VMStateDescription *vmsd, QJSON *vmdesc,
 254                                   const VMStateField *field, int i, int max)
 255 {
 256     char *name, *old_name;
 257     bool is_array = max > 1;
 258     bool can_compress = vmsd_can_compress(field);
 259
 260     if (!vmdesc) {
 261         return;
 262     }
 263
 264     name = g_strdup(field->name);
 265
 266     /* Field name is not unique, need to make it unique */
 267     if (!vmfield_name_is_unique(vmsd->fields, field)) {
 268         int num = vmfield_name_num(vmsd->fields, field);
 269         old_name = name;
 270         name = g_strdup_printf("%s[%d]", name, num);
 271         g_free(old_name);
 272     }
 273
 274     json_start_object(vmdesc, NULL);
 275     json_prop_str(vmdesc, "name", name);
 276     if (is_array) {
 277         if (can_compress) {
 278             json_prop_int(vmdesc, "array_len", max);
 279         } else {
 280             json_prop_int(vmdesc, "index", i);
 281         }
 282     }
 283     json_prop_str(vmdesc, "type", vmfield_get_type_name(field));
 284
 285     if (field->flags & VMS_STRUCT) {
 286         json_start_object(vmdesc, "struct");
 287     }
 288
 289     g_free(name);
 290 }
 291
 292 static void vmsd_desc_field_end(const VMStateDescription *vmsd, QJSON *vmdesc,
 293                                 const VMStateField *field, size_t size, int i)
 294 {
 295     if (!vmdesc) {
 296         return;
 297     }
 298
 299     if (field->flags & VMS_STRUCT) {
 300         /* We printed a struct in between, close its child object */
 301         json_end_object(vmdesc);
 302     }
 303
 304     json_prop_int(vmdesc, "size", size);
 305     json_end_object(vmdesc);
 306 }
 307
 308
 309 bool vmstate_save_needed(const VMStateDescription *vmsd, void *opaque)
 310 {
 311     if (vmsd->needed && !vmsd->needed(opaque)) {
 312         /* optional section not needed */
 313         return false;
 314     }
 315     return true;
 316 }
 317
 318
 319 int vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
 320                        void *opaque, QJSON *vmdesc_id)
 321 {
 322     return vmstate_save_state_v(f, vmsd, opaque, vmdesc_id, vmsd->version_id);
 323 }
 324
 325 int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
 326                          void *opaque, QJSON *vmdesc, int version_id)
 327 {
 328     int ret = 0;
 329     const VMStateField *field = vmsd->fields;
 330
 331     trace_vmstate_save_state_top(vmsd->name);
 332
 333     if (vmsd->pre_save) {
 334         ret = vmsd->pre_save(opaque);
 335         trace_vmstate_save_state_pre_save_res(vmsd->name, ret);
 336         if (ret) {
 337             error_report("pre-save failed: %s", vmsd->name);
 338             return ret;
 339         }
 340     }
 341
 342     if (vmdesc) {
 343         json_prop_str(vmdesc, "vmsd_name", vmsd->name);
 344         json_prop_int(vmdesc, "version", version_id);
 345         json_start_array(vmdesc, "fields");
 346     }
 347
 348     while (field->name) {
 349         if ((field->field_exists &&
 350              field->field_exists(opaque, version_id)) ||
 351             (!field->field_exists &&
 352              field->version_id <= version_id)) {
 353             void *first_elem = opaque + field->offset;
 354             int i, n_elems = vmstate_n_elems(opaque, field);
 355             int size = vmstate_size(opaque, field);
 356             int64_t old_offset, written_bytes;
 357             QJSON *vmdesc_loop = vmdesc;
 358
 359             trace_vmstate_save_state_loop(vmsd->name, field->name, n_elems);
 360             if (field->flags & VMS_POINTER) {
 361                 first_elem = *(void **)first_elem;
 362                 assert(first_elem || !n_elems || !size);
 363             }
 364             for (i = 0; i < n_elems; i++) {
 365                 void *curr_elem = first_elem + size * i;
 366                 ret = 0;
 367
 368                 vmsd_desc_field_start(vmsd, vmdesc_loop, field, i, n_elems);
 369                 old_offset = qemu_ftell_fast(f);
 370                 if (field->flags & VMS_ARRAY_OF_POINTER) {
 371                     assert(curr_elem);
 372                     curr_elem = *(void **)curr_elem;
 373                 }
 374                 if (!curr_elem && size) {
 375                     /* if null pointer write placeholder and do not follow */
 376                     assert(field->flags & VMS_ARRAY_OF_POINTER);
 377                     ret = vmstate_info_nullptr.put(f, curr_elem, size, NULL,
 378                                                    NULL);
 379                 } else if (field->flags & VMS_STRUCT) {
 380                     ret = vmstate_save_state(f, field->vmsd, curr_elem,
 381                                              vmdesc_loop);
 382                 } else if (field->flags & VMS_VSTRUCT) {
 383                     ret = vmstate_save_state_v(f, field->vmsd, curr_elem,
 384                                                vmdesc_loop,
 385                                                field->struct_version_id);
 386                 } else {
 387                     ret = field->info->put(f, curr_elem, size, field,
 388                                      vmdesc_loop);
 389                 }
 390                 if (ret) {
 391                     error_report("Save of field %s/%s failed",
 392                                  vmsd->name, field->name);
 393                     if (vmsd->post_save) {
 394                         vmsd->post_save(opaque);
 395                     }
 396                     return ret;
 397                 }
 398
 399                 written_bytes = qemu_ftell_fast(f) - old_offset;
 400                 vmsd_desc_field_end(vmsd, vmdesc_loop, field, written_bytes, i);
 401
 402                 /* Compressed arrays only care about the first element */
 403                 if (vmdesc_loop && vmsd_can_compress(field)) {
 404                     vmdesc_loop = NULL;
 405                 }
 406             }
 407         } else {
 408             if (field->flags & VMS_MUST_EXIST) {
 409                 error_report("Output state validation failed: %s/%s",
 410                         vmsd->name, field->name);
 411                 assert(!(field->flags & VMS_MUST_EXIST));
 412             }
 413         }
 414         field++;
 415     }
 416
 417     if (vmdesc) {
 418         json_end_array(vmdesc);
 419     }
 420
 421     ret = vmstate_subsection_save(f, vmsd, opaque, vmdesc);
 422
 423     if (vmsd->post_save) {
 424         int ps_ret = vmsd->post_save(opaque);
 425         if (!ret) {
 426             ret = ps_ret;
 427         }
 428     }
 429     return ret;
 430 }
 431
 432 static const VMStateDescription *
 433 vmstate_get_subsection(const VMStateDescription **sub, char *idstr)
 434 {
 435     while (sub && *sub) {
 436         if (strcmp(idstr, (*sub)->name) == 0) {
 437             return *sub;
 438         }
 439         sub++;
 440     }
 441     return NULL;
 442 }
 443
 444 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
 445                                    void *opaque)
 446 {
 447     trace_vmstate_subsection_load(vmsd->name);
 448
 449     while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
 450         char idstr[256], *idstr_ret;
 451         int ret;
 452         uint8_t version_id, len, size;
 453         const VMStateDescription *sub_vmsd;
 454
 455         len = qemu_peek_byte(f, 1);
 456         if (len < strlen(vmsd->name) + 1) {
 457             /* subsection name has be be "section_name/a" */
 458             trace_vmstate_subsection_load_bad(vmsd->name, "(short)", "");
 459             return 0;
 460         }
 461         size = qemu_peek_buffer(f, (uint8_t **)&idstr_ret, len, 2);
 462         if (size != len) {
 463             trace_vmstate_subsection_load_bad(vmsd->name, "(peek fail)", "");
 464             return 0;
 465         }
 466         memcpy(idstr, idstr_ret, size);
 467         idstr[size] = 0;
 468
 469         if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
 470             trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(prefix)");
 471             /* it doesn't have a valid subsection name */
 472             return 0;
 473         }
 474         sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
 475         if (sub_vmsd == NULL) {
 476             trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(lookup)");
 477             return -ENOENT;
 478         }
 479         qemu_file_skip(f, 1); /* subsection */
 480         qemu_file_skip(f, 1); /* len */
 481         qemu_file_skip(f, len); /* idstr */
 482         version_id = qemu_get_be32(f);
 483
 484         ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
 485         if (ret) {
 486             trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(child)");
 487             return ret;
 488         }
 489     }
 490
 491     trace_vmstate_subsection_load_good(vmsd->name);
 492     return 0;
 493 }
 494
 495 static int vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
 496                                    void *opaque, QJSON *vmdesc)
 497 {
 498     const VMStateDescription **sub = vmsd->subsections;
 499     bool subsection_found = false;
 500     int ret = 0;
 501
 502     trace_vmstate_subsection_save_top(vmsd->name);
 503     while (sub && *sub) {
 504         if (vmstate_save_needed(*sub, opaque)) {
 505             const VMStateDescription *vmsdsub = *sub;
 506             uint8_t len;
 507
 508             trace_vmstate_subsection_save_loop(vmsd->name, vmsdsub->name);
 509             if (vmdesc) {
 510                 /* Only create subsection array when we have any */
 511                 if (!subsection_found) {
 512                     json_start_array(vmdesc, "subsections");
 513                     subsection_found = true;
 514                 }
 515
 516                 json_start_object(vmdesc, NULL);
 517             }
 518
 519             qemu_put_byte(f, QEMU_VM_SUBSECTION);
 520             len = strlen(vmsdsub->name);
 521             qemu_put_byte(f, len);
 522             qemu_put_buffer(f, (uint8_t *)vmsdsub->name, len);
 523             qemu_put_be32(f, vmsdsub->version_id);
 524             ret = vmstate_save_state(f, vmsdsub, opaque, vmdesc);
 525             if (ret) {
 526                 return ret;
 527             }
 528
 529             if (vmdesc) {
 530                 json_end_object(vmdesc);
 531             }
 532         }
 533         sub++;
 534     }
 535
 536     if (vmdesc && subsection_found) {
 537         json_end_array(vmdesc);
 538     }
 539
 540     return ret;
 541 }