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