1 /* 2 * QEMU System Emulator 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * Copyright (c) 2009-2015 Red Hat Inc 6 * 7 * Authors: 8 * Juan Quintela <quintela@redhat.com> 9 * 10 * Permission is hereby granted, free of charge, to any person obtaining a copy 11 * of this software and associated documentation files (the "Software"), to deal 12 * in the Software without restriction, including without limitation the rights 13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 14 * copies of the Software, and to permit persons to whom the Software is 15 * furnished to do so, subject to the following conditions: 16 * 17 * The above copyright notice and this permission notice shall be included in 18 * all copies or substantial portions of the Software. 19 * 20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 23 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 26 * THE SOFTWARE. 27 */ 28 29 #include "qemu/osdep.h" 30 #include "hw/boards.h" 31 #include "net/net.h" 32 #include "migration.h" 33 #include "migration/snapshot.h" 34 #include "migration-stats.h" 35 #include "migration/vmstate.h" 36 #include "migration/misc.h" 37 #include "migration/register.h" 38 #include "migration/global_state.h" 39 #include "migration/channel-block.h" 40 #include "ram.h" 41 #include "qemu-file.h" 42 #include "savevm.h" 43 #include "postcopy-ram.h" 44 #include "qapi/error.h" 45 #include "qapi/qapi-commands-migration.h" 46 #include "qapi/clone-visitor.h" 47 #include "qapi/qapi-builtin-visit.h" 48 #include "qapi/qmp/qerror.h" 49 #include "qemu/error-report.h" 50 #include "sysemu/cpus.h" 51 #include "exec/memory.h" 52 #include "exec/target_page.h" 53 #include "trace.h" 54 #include "qemu/iov.h" 55 #include "qemu/job.h" 56 #include "qemu/main-loop.h" 57 #include "block/snapshot.h" 58 #include "qemu/cutils.h" 59 #include "io/channel-buffer.h" 60 #include "io/channel-file.h" 61 #include "sysemu/replay.h" 62 #include "sysemu/runstate.h" 63 #include "sysemu/sysemu.h" 64 #include "sysemu/xen.h" 65 #include "migration/colo.h" 66 #include "qemu/bitmap.h" 67 #include "net/announce.h" 68 #include "qemu/yank.h" 69 #include "yank_functions.h" 70 #include "sysemu/qtest.h" 71 #include "options.h" 72 73 const unsigned int postcopy_ram_discard_version; 74 75 /* Subcommands for QEMU_VM_COMMAND */ 76 enum qemu_vm_cmd { 77 MIG_CMD_INVALID = 0, /* Must be 0 */ 78 MIG_CMD_OPEN_RETURN_PATH, /* Tell the dest to open the Return path */ 79 MIG_CMD_PING, /* Request a PONG on the RP */ 80 81 MIG_CMD_POSTCOPY_ADVISE, /* Prior to any page transfers, just 82 warn we might want to do PC */ 83 MIG_CMD_POSTCOPY_LISTEN, /* Start listening for incoming 84 pages as it's running. */ 85 MIG_CMD_POSTCOPY_RUN, /* Start execution */ 86 87 MIG_CMD_POSTCOPY_RAM_DISCARD, /* A list of pages to discard that 88 were previously sent during 89 precopy but are dirty. */ 90 MIG_CMD_PACKAGED, /* Send a wrapped stream within this stream */ 91 MIG_CMD_ENABLE_COLO, /* Enable COLO */ 92 MIG_CMD_POSTCOPY_RESUME, /* resume postcopy on dest */ 93 MIG_CMD_RECV_BITMAP, /* Request for recved bitmap on dst */ 94 MIG_CMD_MAX 95 }; 96 97 #define MAX_VM_CMD_PACKAGED_SIZE UINT32_MAX 98 static struct mig_cmd_args { 99 ssize_t len; /* -1 = variable */ 100 const char *name; 101 } mig_cmd_args[] = { 102 [MIG_CMD_INVALID] = { .len = -1, .name = "INVALID" }, 103 [MIG_CMD_OPEN_RETURN_PATH] = { .len = 0, .name = "OPEN_RETURN_PATH" }, 104 [MIG_CMD_PING] = { .len = sizeof(uint32_t), .name = "PING" }, 105 [MIG_CMD_POSTCOPY_ADVISE] = { .len = -1, .name = "POSTCOPY_ADVISE" }, 106 [MIG_CMD_POSTCOPY_LISTEN] = { .len = 0, .name = "POSTCOPY_LISTEN" }, 107 [MIG_CMD_POSTCOPY_RUN] = { .len = 0, .name = "POSTCOPY_RUN" }, 108 [MIG_CMD_POSTCOPY_RAM_DISCARD] = { 109 .len = -1, .name = "POSTCOPY_RAM_DISCARD" }, 110 [MIG_CMD_POSTCOPY_RESUME] = { .len = 0, .name = "POSTCOPY_RESUME" }, 111 [MIG_CMD_PACKAGED] = { .len = 4, .name = "PACKAGED" }, 112 [MIG_CMD_RECV_BITMAP] = { .len = -1, .name = "RECV_BITMAP" }, 113 [MIG_CMD_MAX] = { .len = -1, .name = "MAX" }, 114 }; 115 116 /* Note for MIG_CMD_POSTCOPY_ADVISE: 117 * The format of arguments is depending on postcopy mode: 118 * - postcopy RAM only 119 * uint64_t host page size 120 * uint64_t target page size 121 * 122 * - postcopy RAM and postcopy dirty bitmaps 123 * format is the same as for postcopy RAM only 124 * 125 * - postcopy dirty bitmaps only 126 * Nothing. Command length field is 0. 127 * 128 * Be careful: adding a new postcopy entity with some other parameters should 129 * not break format self-description ability. Good way is to introduce some 130 * generic extendable format with an exception for two old entities. 131 */ 132 133 /***********************************************************/ 134 /* savevm/loadvm support */ 135 136 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable) 137 { 138 if (is_writable) { 139 return qemu_file_new_output(QIO_CHANNEL(qio_channel_block_new(bs))); 140 } else { 141 return qemu_file_new_input(QIO_CHANNEL(qio_channel_block_new(bs))); 142 } 143 } 144 145 146 /* QEMUFile timer support. 147 * Not in qemu-file.c to not add qemu-timer.c as dependency to qemu-file.c 148 */ 149 150 void timer_put(QEMUFile *f, QEMUTimer *ts) 151 { 152 uint64_t expire_time; 153 154 expire_time = timer_expire_time_ns(ts); 155 qemu_put_be64(f, expire_time); 156 } 157 158 void timer_get(QEMUFile *f, QEMUTimer *ts) 159 { 160 uint64_t expire_time; 161 162 expire_time = qemu_get_be64(f); 163 if (expire_time != -1) { 164 timer_mod_ns(ts, expire_time); 165 } else { 166 timer_del(ts); 167 } 168 } 169 170 171 /* VMState timer support. 172 * Not in vmstate.c to not add qemu-timer.c as dependency to vmstate.c 173 */ 174 175 static int get_timer(QEMUFile *f, void *pv, size_t size, 176 const VMStateField *field) 177 { 178 QEMUTimer *v = pv; 179 timer_get(f, v); 180 return 0; 181 } 182 183 static int put_timer(QEMUFile *f, void *pv, size_t size, 184 const VMStateField *field, JSONWriter *vmdesc) 185 { 186 QEMUTimer *v = pv; 187 timer_put(f, v); 188 189 return 0; 190 } 191 192 const VMStateInfo vmstate_info_timer = { 193 .name = "timer", 194 .get = get_timer, 195 .put = put_timer, 196 }; 197 198 199 typedef struct CompatEntry { 200 char idstr[256]; 201 int instance_id; 202 } CompatEntry; 203 204 typedef struct SaveStateEntry { 205 QTAILQ_ENTRY(SaveStateEntry) entry; 206 char idstr[256]; 207 uint32_t instance_id; 208 int alias_id; 209 int version_id; 210 /* version id read from the stream */ 211 int load_version_id; 212 int section_id; 213 /* section id read from the stream */ 214 int load_section_id; 215 const SaveVMHandlers *ops; 216 const VMStateDescription *vmsd; 217 void *opaque; 218 CompatEntry *compat; 219 int is_ram; 220 } SaveStateEntry; 221 222 typedef struct SaveState { 223 QTAILQ_HEAD(, SaveStateEntry) handlers; 224 SaveStateEntry *handler_pri_head[MIG_PRI_MAX + 1]; 225 int global_section_id; 226 uint32_t len; 227 const char *name; 228 uint32_t target_page_bits; 229 uint32_t caps_count; 230 MigrationCapability *capabilities; 231 QemuUUID uuid; 232 } SaveState; 233 234 static SaveState savevm_state = { 235 .handlers = QTAILQ_HEAD_INITIALIZER(savevm_state.handlers), 236 .handler_pri_head = { [MIG_PRI_DEFAULT ... MIG_PRI_MAX] = NULL }, 237 .global_section_id = 0, 238 }; 239 240 static bool should_validate_capability(int capability) 241 { 242 assert(capability >= 0 && capability < MIGRATION_CAPABILITY__MAX); 243 /* Validate only new capabilities to keep compatibility. */ 244 switch (capability) { 245 case MIGRATION_CAPABILITY_X_IGNORE_SHARED: 246 return true; 247 default: 248 return false; 249 } 250 } 251 252 static uint32_t get_validatable_capabilities_count(void) 253 { 254 MigrationState *s = migrate_get_current(); 255 uint32_t result = 0; 256 int i; 257 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) { 258 if (should_validate_capability(i) && s->capabilities[i]) { 259 result++; 260 } 261 } 262 return result; 263 } 264 265 static int configuration_pre_save(void *opaque) 266 { 267 SaveState *state = opaque; 268 const char *current_name = MACHINE_GET_CLASS(current_machine)->name; 269 MigrationState *s = migrate_get_current(); 270 int i, j; 271 272 state->len = strlen(current_name); 273 state->name = current_name; 274 state->target_page_bits = qemu_target_page_bits(); 275 276 state->caps_count = get_validatable_capabilities_count(); 277 state->capabilities = g_renew(MigrationCapability, state->capabilities, 278 state->caps_count); 279 for (i = j = 0; i < MIGRATION_CAPABILITY__MAX; i++) { 280 if (should_validate_capability(i) && s->capabilities[i]) { 281 state->capabilities[j++] = i; 282 } 283 } 284 state->uuid = qemu_uuid; 285 286 return 0; 287 } 288 289 static int configuration_post_save(void *opaque) 290 { 291 SaveState *state = opaque; 292 293 g_free(state->capabilities); 294 state->capabilities = NULL; 295 state->caps_count = 0; 296 return 0; 297 } 298 299 static int configuration_pre_load(void *opaque) 300 { 301 SaveState *state = opaque; 302 303 /* If there is no target-page-bits subsection it means the source 304 * predates the variable-target-page-bits support and is using the 305 * minimum possible value for this CPU. 306 */ 307 state->target_page_bits = qemu_target_page_bits_min(); 308 return 0; 309 } 310 311 static bool configuration_validate_capabilities(SaveState *state) 312 { 313 bool ret = true; 314 MigrationState *s = migrate_get_current(); 315 unsigned long *source_caps_bm; 316 int i; 317 318 source_caps_bm = bitmap_new(MIGRATION_CAPABILITY__MAX); 319 for (i = 0; i < state->caps_count; i++) { 320 MigrationCapability capability = state->capabilities[i]; 321 set_bit(capability, source_caps_bm); 322 } 323 324 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) { 325 bool source_state, target_state; 326 if (!should_validate_capability(i)) { 327 continue; 328 } 329 source_state = test_bit(i, source_caps_bm); 330 target_state = s->capabilities[i]; 331 if (source_state != target_state) { 332 error_report("Capability %s is %s, but received capability is %s", 333 MigrationCapability_str(i), 334 target_state ? "on" : "off", 335 source_state ? "on" : "off"); 336 ret = false; 337 /* Don't break here to report all failed capabilities */ 338 } 339 } 340 341 g_free(source_caps_bm); 342 return ret; 343 } 344 345 static int configuration_post_load(void *opaque, int version_id) 346 { 347 SaveState *state = opaque; 348 const char *current_name = MACHINE_GET_CLASS(current_machine)->name; 349 int ret = 0; 350 351 if (strncmp(state->name, current_name, state->len) != 0) { 352 error_report("Machine type received is '%.*s' and local is '%s'", 353 (int) state->len, state->name, current_name); 354 ret = -EINVAL; 355 goto out; 356 } 357 358 if (state->target_page_bits != qemu_target_page_bits()) { 359 error_report("Received TARGET_PAGE_BITS is %d but local is %d", 360 state->target_page_bits, qemu_target_page_bits()); 361 ret = -EINVAL; 362 goto out; 363 } 364 365 if (!configuration_validate_capabilities(state)) { 366 ret = -EINVAL; 367 goto out; 368 } 369 370 out: 371 g_free((void *)state->name); 372 state->name = NULL; 373 state->len = 0; 374 g_free(state->capabilities); 375 state->capabilities = NULL; 376 state->caps_count = 0; 377 378 return ret; 379 } 380 381 static int get_capability(QEMUFile *f, void *pv, size_t size, 382 const VMStateField *field) 383 { 384 MigrationCapability *capability = pv; 385 char capability_str[UINT8_MAX + 1]; 386 uint8_t len; 387 int i; 388 389 len = qemu_get_byte(f); 390 qemu_get_buffer(f, (uint8_t *)capability_str, len); 391 capability_str[len] = '\0'; 392 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) { 393 if (!strcmp(MigrationCapability_str(i), capability_str)) { 394 *capability = i; 395 return 0; 396 } 397 } 398 error_report("Received unknown capability %s", capability_str); 399 return -EINVAL; 400 } 401 402 static int put_capability(QEMUFile *f, void *pv, size_t size, 403 const VMStateField *field, JSONWriter *vmdesc) 404 { 405 MigrationCapability *capability = pv; 406 const char *capability_str = MigrationCapability_str(*capability); 407 size_t len = strlen(capability_str); 408 assert(len <= UINT8_MAX); 409 410 qemu_put_byte(f, len); 411 qemu_put_buffer(f, (uint8_t *)capability_str, len); 412 return 0; 413 } 414 415 static const VMStateInfo vmstate_info_capability = { 416 .name = "capability", 417 .get = get_capability, 418 .put = put_capability, 419 }; 420 421 /* The target-page-bits subsection is present only if the 422 * target page size is not the same as the default (ie the 423 * minimum page size for a variable-page-size guest CPU). 424 * If it is present then it contains the actual target page 425 * bits for the machine, and migration will fail if the 426 * two ends don't agree about it. 427 */ 428 static bool vmstate_target_page_bits_needed(void *opaque) 429 { 430 return qemu_target_page_bits() 431 > qemu_target_page_bits_min(); 432 } 433 434 static const VMStateDescription vmstate_target_page_bits = { 435 .name = "configuration/target-page-bits", 436 .version_id = 1, 437 .minimum_version_id = 1, 438 .needed = vmstate_target_page_bits_needed, 439 .fields = (VMStateField[]) { 440 VMSTATE_UINT32(target_page_bits, SaveState), 441 VMSTATE_END_OF_LIST() 442 } 443 }; 444 445 static bool vmstate_capabilites_needed(void *opaque) 446 { 447 return get_validatable_capabilities_count() > 0; 448 } 449 450 static const VMStateDescription vmstate_capabilites = { 451 .name = "configuration/capabilities", 452 .version_id = 1, 453 .minimum_version_id = 1, 454 .needed = vmstate_capabilites_needed, 455 .fields = (VMStateField[]) { 456 VMSTATE_UINT32_V(caps_count, SaveState, 1), 457 VMSTATE_VARRAY_UINT32_ALLOC(capabilities, SaveState, caps_count, 1, 458 vmstate_info_capability, 459 MigrationCapability), 460 VMSTATE_END_OF_LIST() 461 } 462 }; 463 464 static bool vmstate_uuid_needed(void *opaque) 465 { 466 return qemu_uuid_set && migrate_validate_uuid(); 467 } 468 469 static int vmstate_uuid_post_load(void *opaque, int version_id) 470 { 471 SaveState *state = opaque; 472 char uuid_src[UUID_FMT_LEN + 1]; 473 char uuid_dst[UUID_FMT_LEN + 1]; 474 475 if (!qemu_uuid_set) { 476 /* 477 * It's warning because user might not know UUID in some cases, 478 * e.g. load an old snapshot 479 */ 480 qemu_uuid_unparse(&state->uuid, uuid_src); 481 warn_report("UUID is received %s, but local uuid isn't set", 482 uuid_src); 483 return 0; 484 } 485 if (!qemu_uuid_is_equal(&state->uuid, &qemu_uuid)) { 486 qemu_uuid_unparse(&state->uuid, uuid_src); 487 qemu_uuid_unparse(&qemu_uuid, uuid_dst); 488 error_report("UUID received is %s and local is %s", uuid_src, uuid_dst); 489 return -EINVAL; 490 } 491 return 0; 492 } 493 494 static const VMStateDescription vmstate_uuid = { 495 .name = "configuration/uuid", 496 .version_id = 1, 497 .minimum_version_id = 1, 498 .needed = vmstate_uuid_needed, 499 .post_load = vmstate_uuid_post_load, 500 .fields = (VMStateField[]) { 501 VMSTATE_UINT8_ARRAY_V(uuid.data, SaveState, sizeof(QemuUUID), 1), 502 VMSTATE_END_OF_LIST() 503 } 504 }; 505 506 static const VMStateDescription vmstate_configuration = { 507 .name = "configuration", 508 .version_id = 1, 509 .pre_load = configuration_pre_load, 510 .post_load = configuration_post_load, 511 .pre_save = configuration_pre_save, 512 .post_save = configuration_post_save, 513 .fields = (VMStateField[]) { 514 VMSTATE_UINT32(len, SaveState), 515 VMSTATE_VBUFFER_ALLOC_UINT32(name, SaveState, 0, NULL, len), 516 VMSTATE_END_OF_LIST() 517 }, 518 .subsections = (const VMStateDescription *[]) { 519 &vmstate_target_page_bits, 520 &vmstate_capabilites, 521 &vmstate_uuid, 522 NULL 523 } 524 }; 525 526 static void dump_vmstate_vmsd(FILE *out_file, 527 const VMStateDescription *vmsd, int indent, 528 bool is_subsection); 529 530 static void dump_vmstate_vmsf(FILE *out_file, const VMStateField *field, 531 int indent) 532 { 533 fprintf(out_file, "%*s{\n", indent, ""); 534 indent += 2; 535 fprintf(out_file, "%*s\"field\": \"%s\",\n", indent, "", field->name); 536 fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "", 537 field->version_id); 538 fprintf(out_file, "%*s\"field_exists\": %s,\n", indent, "", 539 field->field_exists ? "true" : "false"); 540 if (field->flags & VMS_ARRAY) { 541 fprintf(out_file, "%*s\"num\": %d,\n", indent, "", field->num); 542 } 543 fprintf(out_file, "%*s\"size\": %zu", indent, "", field->size); 544 if (field->vmsd != NULL) { 545 fprintf(out_file, ",\n"); 546 dump_vmstate_vmsd(out_file, field->vmsd, indent, false); 547 } 548 fprintf(out_file, "\n%*s}", indent - 2, ""); 549 } 550 551 static void dump_vmstate_vmss(FILE *out_file, 552 const VMStateDescription **subsection, 553 int indent) 554 { 555 if (*subsection != NULL) { 556 dump_vmstate_vmsd(out_file, *subsection, indent, true); 557 } 558 } 559 560 static void dump_vmstate_vmsd(FILE *out_file, 561 const VMStateDescription *vmsd, int indent, 562 bool is_subsection) 563 { 564 if (is_subsection) { 565 fprintf(out_file, "%*s{\n", indent, ""); 566 } else { 567 fprintf(out_file, "%*s\"%s\": {\n", indent, "", "Description"); 568 } 569 indent += 2; 570 fprintf(out_file, "%*s\"name\": \"%s\",\n", indent, "", vmsd->name); 571 fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "", 572 vmsd->version_id); 573 fprintf(out_file, "%*s\"minimum_version_id\": %d", indent, "", 574 vmsd->minimum_version_id); 575 if (vmsd->fields != NULL) { 576 const VMStateField *field = vmsd->fields; 577 bool first; 578 579 fprintf(out_file, ",\n%*s\"Fields\": [\n", indent, ""); 580 first = true; 581 while (field->name != NULL) { 582 if (field->flags & VMS_MUST_EXIST) { 583 /* Ignore VMSTATE_VALIDATE bits; these don't get migrated */ 584 field++; 585 continue; 586 } 587 if (!first) { 588 fprintf(out_file, ",\n"); 589 } 590 dump_vmstate_vmsf(out_file, field, indent + 2); 591 field++; 592 first = false; 593 } 594 assert(field->flags == VMS_END); 595 fprintf(out_file, "\n%*s]", indent, ""); 596 } 597 if (vmsd->subsections != NULL) { 598 const VMStateDescription **subsection = vmsd->subsections; 599 bool first; 600 601 fprintf(out_file, ",\n%*s\"Subsections\": [\n", indent, ""); 602 first = true; 603 while (*subsection != NULL) { 604 if (!first) { 605 fprintf(out_file, ",\n"); 606 } 607 dump_vmstate_vmss(out_file, subsection, indent + 2); 608 subsection++; 609 first = false; 610 } 611 fprintf(out_file, "\n%*s]", indent, ""); 612 } 613 fprintf(out_file, "\n%*s}", indent - 2, ""); 614 } 615 616 static void dump_machine_type(FILE *out_file) 617 { 618 MachineClass *mc; 619 620 mc = MACHINE_GET_CLASS(current_machine); 621 622 fprintf(out_file, " \"vmschkmachine\": {\n"); 623 fprintf(out_file, " \"Name\": \"%s\"\n", mc->name); 624 fprintf(out_file, " },\n"); 625 } 626 627 void dump_vmstate_json_to_file(FILE *out_file) 628 { 629 GSList *list, *elt; 630 bool first; 631 632 fprintf(out_file, "{\n"); 633 dump_machine_type(out_file); 634 635 first = true; 636 list = object_class_get_list(TYPE_DEVICE, true); 637 for (elt = list; elt; elt = elt->next) { 638 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data, 639 TYPE_DEVICE); 640 const char *name; 641 int indent = 2; 642 643 if (!dc->vmsd) { 644 continue; 645 } 646 647 if (!first) { 648 fprintf(out_file, ",\n"); 649 } 650 name = object_class_get_name(OBJECT_CLASS(dc)); 651 fprintf(out_file, "%*s\"%s\": {\n", indent, "", name); 652 indent += 2; 653 fprintf(out_file, "%*s\"Name\": \"%s\",\n", indent, "", name); 654 fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "", 655 dc->vmsd->version_id); 656 fprintf(out_file, "%*s\"minimum_version_id\": %d,\n", indent, "", 657 dc->vmsd->minimum_version_id); 658 659 dump_vmstate_vmsd(out_file, dc->vmsd, indent, false); 660 661 fprintf(out_file, "\n%*s}", indent - 2, ""); 662 first = false; 663 } 664 fprintf(out_file, "\n}\n"); 665 fclose(out_file); 666 g_slist_free(list); 667 } 668 669 static uint32_t calculate_new_instance_id(const char *idstr) 670 { 671 SaveStateEntry *se; 672 uint32_t instance_id = 0; 673 674 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 675 if (strcmp(idstr, se->idstr) == 0 676 && instance_id <= se->instance_id) { 677 instance_id = se->instance_id + 1; 678 } 679 } 680 /* Make sure we never loop over without being noticed */ 681 assert(instance_id != VMSTATE_INSTANCE_ID_ANY); 682 return instance_id; 683 } 684 685 static int calculate_compat_instance_id(const char *idstr) 686 { 687 SaveStateEntry *se; 688 int instance_id = 0; 689 690 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 691 if (!se->compat) { 692 continue; 693 } 694 695 if (strcmp(idstr, se->compat->idstr) == 0 696 && instance_id <= se->compat->instance_id) { 697 instance_id = se->compat->instance_id + 1; 698 } 699 } 700 return instance_id; 701 } 702 703 static inline MigrationPriority save_state_priority(SaveStateEntry *se) 704 { 705 if (se->vmsd) { 706 return se->vmsd->priority; 707 } 708 return MIG_PRI_DEFAULT; 709 } 710 711 static void savevm_state_handler_insert(SaveStateEntry *nse) 712 { 713 MigrationPriority priority = save_state_priority(nse); 714 SaveStateEntry *se; 715 int i; 716 717 assert(priority <= MIG_PRI_MAX); 718 719 for (i = priority - 1; i >= 0; i--) { 720 se = savevm_state.handler_pri_head[i]; 721 if (se != NULL) { 722 assert(save_state_priority(se) < priority); 723 break; 724 } 725 } 726 727 if (i >= 0) { 728 QTAILQ_INSERT_BEFORE(se, nse, entry); 729 } else { 730 QTAILQ_INSERT_TAIL(&savevm_state.handlers, nse, entry); 731 } 732 733 if (savevm_state.handler_pri_head[priority] == NULL) { 734 savevm_state.handler_pri_head[priority] = nse; 735 } 736 } 737 738 static void savevm_state_handler_remove(SaveStateEntry *se) 739 { 740 SaveStateEntry *next; 741 MigrationPriority priority = save_state_priority(se); 742 743 if (se == savevm_state.handler_pri_head[priority]) { 744 next = QTAILQ_NEXT(se, entry); 745 if (next != NULL && save_state_priority(next) == priority) { 746 savevm_state.handler_pri_head[priority] = next; 747 } else { 748 savevm_state.handler_pri_head[priority] = NULL; 749 } 750 } 751 QTAILQ_REMOVE(&savevm_state.handlers, se, entry); 752 } 753 754 /* TODO: Individual devices generally have very little idea about the rest 755 of the system, so instance_id should be removed/replaced. 756 Meanwhile pass -1 as instance_id if you do not already have a clearly 757 distinguishing id for all instances of your device class. */ 758 int register_savevm_live(const char *idstr, 759 uint32_t instance_id, 760 int version_id, 761 const SaveVMHandlers *ops, 762 void *opaque) 763 { 764 SaveStateEntry *se; 765 766 se = g_new0(SaveStateEntry, 1); 767 se->version_id = version_id; 768 se->section_id = savevm_state.global_section_id++; 769 se->ops = ops; 770 se->opaque = opaque; 771 se->vmsd = NULL; 772 /* if this is a live_savem then set is_ram */ 773 if (ops->save_setup != NULL) { 774 se->is_ram = 1; 775 } 776 777 pstrcat(se->idstr, sizeof(se->idstr), idstr); 778 779 if (instance_id == VMSTATE_INSTANCE_ID_ANY) { 780 se->instance_id = calculate_new_instance_id(se->idstr); 781 } else { 782 se->instance_id = instance_id; 783 } 784 assert(!se->compat || se->instance_id == 0); 785 savevm_state_handler_insert(se); 786 return 0; 787 } 788 789 void unregister_savevm(VMStateIf *obj, const char *idstr, void *opaque) 790 { 791 SaveStateEntry *se, *new_se; 792 char id[256] = ""; 793 794 if (obj) { 795 char *oid = vmstate_if_get_id(obj); 796 if (oid) { 797 pstrcpy(id, sizeof(id), oid); 798 pstrcat(id, sizeof(id), "/"); 799 g_free(oid); 800 } 801 } 802 pstrcat(id, sizeof(id), idstr); 803 804 QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) { 805 if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) { 806 savevm_state_handler_remove(se); 807 g_free(se->compat); 808 g_free(se); 809 } 810 } 811 } 812 813 /* 814 * Perform some basic checks on vmsd's at registration 815 * time. 816 */ 817 static void vmstate_check(const VMStateDescription *vmsd) 818 { 819 const VMStateField *field = vmsd->fields; 820 const VMStateDescription **subsection = vmsd->subsections; 821 822 if (field) { 823 while (field->name) { 824 if (field->flags & (VMS_STRUCT | VMS_VSTRUCT)) { 825 /* Recurse to sub structures */ 826 vmstate_check(field->vmsd); 827 } 828 /* Carry on */ 829 field++; 830 } 831 /* Check for the end of field list canary */ 832 if (field->flags != VMS_END) { 833 error_report("VMSTATE not ending with VMS_END: %s", vmsd->name); 834 g_assert_not_reached(); 835 } 836 } 837 838 while (subsection && *subsection) { 839 /* 840 * The name of a subsection should start with the name of the 841 * current object. 842 */ 843 assert(!strncmp(vmsd->name, (*subsection)->name, strlen(vmsd->name))); 844 vmstate_check(*subsection); 845 subsection++; 846 } 847 } 848 849 int vmstate_register_with_alias_id(VMStateIf *obj, uint32_t instance_id, 850 const VMStateDescription *vmsd, 851 void *opaque, int alias_id, 852 int required_for_version, 853 Error **errp) 854 { 855 SaveStateEntry *se; 856 857 /* If this triggers, alias support can be dropped for the vmsd. */ 858 assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id); 859 860 se = g_new0(SaveStateEntry, 1); 861 se->version_id = vmsd->version_id; 862 se->section_id = savevm_state.global_section_id++; 863 se->opaque = opaque; 864 se->vmsd = vmsd; 865 se->alias_id = alias_id; 866 867 if (obj) { 868 char *id = vmstate_if_get_id(obj); 869 if (id) { 870 if (snprintf(se->idstr, sizeof(se->idstr), "%s/", id) >= 871 sizeof(se->idstr)) { 872 error_setg(errp, "Path too long for VMState (%s)", id); 873 g_free(id); 874 g_free(se); 875 876 return -1; 877 } 878 g_free(id); 879 880 se->compat = g_new0(CompatEntry, 1); 881 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name); 882 se->compat->instance_id = instance_id == VMSTATE_INSTANCE_ID_ANY ? 883 calculate_compat_instance_id(vmsd->name) : instance_id; 884 instance_id = VMSTATE_INSTANCE_ID_ANY; 885 } 886 } 887 pstrcat(se->idstr, sizeof(se->idstr), vmsd->name); 888 889 if (instance_id == VMSTATE_INSTANCE_ID_ANY) { 890 se->instance_id = calculate_new_instance_id(se->idstr); 891 } else { 892 se->instance_id = instance_id; 893 } 894 895 /* Perform a recursive sanity check during the test runs */ 896 if (qtest_enabled()) { 897 vmstate_check(vmsd); 898 } 899 assert(!se->compat || se->instance_id == 0); 900 savevm_state_handler_insert(se); 901 return 0; 902 } 903 904 void vmstate_unregister(VMStateIf *obj, const VMStateDescription *vmsd, 905 void *opaque) 906 { 907 SaveStateEntry *se, *new_se; 908 909 QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) { 910 if (se->vmsd == vmsd && se->opaque == opaque) { 911 savevm_state_handler_remove(se); 912 g_free(se->compat); 913 g_free(se); 914 } 915 } 916 } 917 918 static int vmstate_load(QEMUFile *f, SaveStateEntry *se) 919 { 920 trace_vmstate_load(se->idstr, se->vmsd ? se->vmsd->name : "(old)"); 921 if (!se->vmsd) { /* Old style */ 922 return se->ops->load_state(f, se->opaque, se->load_version_id); 923 } 924 return vmstate_load_state(f, se->vmsd, se->opaque, se->load_version_id); 925 } 926 927 static void vmstate_save_old_style(QEMUFile *f, SaveStateEntry *se, 928 JSONWriter *vmdesc) 929 { 930 uint64_t old_offset = qemu_file_transferred(f); 931 se->ops->save_state(f, se->opaque); 932 uint64_t size = qemu_file_transferred(f) - old_offset; 933 934 if (vmdesc) { 935 json_writer_int64(vmdesc, "size", size); 936 json_writer_start_array(vmdesc, "fields"); 937 json_writer_start_object(vmdesc, NULL); 938 json_writer_str(vmdesc, "name", "data"); 939 json_writer_int64(vmdesc, "size", size); 940 json_writer_str(vmdesc, "type", "buffer"); 941 json_writer_end_object(vmdesc); 942 json_writer_end_array(vmdesc); 943 } 944 } 945 946 /* 947 * Write the header for device section (QEMU_VM_SECTION START/END/PART/FULL) 948 */ 949 static void save_section_header(QEMUFile *f, SaveStateEntry *se, 950 uint8_t section_type) 951 { 952 qemu_put_byte(f, section_type); 953 qemu_put_be32(f, se->section_id); 954 955 if (section_type == QEMU_VM_SECTION_FULL || 956 section_type == QEMU_VM_SECTION_START) { 957 /* ID string */ 958 size_t len = strlen(se->idstr); 959 qemu_put_byte(f, len); 960 qemu_put_buffer(f, (uint8_t *)se->idstr, len); 961 962 qemu_put_be32(f, se->instance_id); 963 qemu_put_be32(f, se->version_id); 964 } 965 } 966 967 /* 968 * Write a footer onto device sections that catches cases misformatted device 969 * sections. 970 */ 971 static void save_section_footer(QEMUFile *f, SaveStateEntry *se) 972 { 973 if (migrate_get_current()->send_section_footer) { 974 qemu_put_byte(f, QEMU_VM_SECTION_FOOTER); 975 qemu_put_be32(f, se->section_id); 976 } 977 } 978 979 static int vmstate_save(QEMUFile *f, SaveStateEntry *se, JSONWriter *vmdesc) 980 { 981 int ret; 982 Error *local_err = NULL; 983 MigrationState *s = migrate_get_current(); 984 985 if ((!se->ops || !se->ops->save_state) && !se->vmsd) { 986 return 0; 987 } 988 if (se->vmsd && !vmstate_section_needed(se->vmsd, se->opaque)) { 989 trace_savevm_section_skip(se->idstr, se->section_id); 990 return 0; 991 } 992 993 trace_savevm_section_start(se->idstr, se->section_id); 994 save_section_header(f, se, QEMU_VM_SECTION_FULL); 995 if (vmdesc) { 996 json_writer_start_object(vmdesc, NULL); 997 json_writer_str(vmdesc, "name", se->idstr); 998 json_writer_int64(vmdesc, "instance_id", se->instance_id); 999 } 1000 1001 trace_vmstate_save(se->idstr, se->vmsd ? se->vmsd->name : "(old)"); 1002 if (!se->vmsd) { 1003 vmstate_save_old_style(f, se, vmdesc); 1004 } else { 1005 ret = vmstate_save_state_with_err(f, se->vmsd, se->opaque, vmdesc, &local_err); 1006 if (ret) { 1007 migrate_set_error(s, local_err); 1008 error_report_err(local_err); 1009 return ret; 1010 } 1011 } 1012 1013 trace_savevm_section_end(se->idstr, se->section_id, 0); 1014 save_section_footer(f, se); 1015 if (vmdesc) { 1016 json_writer_end_object(vmdesc); 1017 } 1018 return 0; 1019 } 1020 /** 1021 * qemu_savevm_command_send: Send a 'QEMU_VM_COMMAND' type element with the 1022 * command and associated data. 1023 * 1024 * @f: File to send command on 1025 * @command: Command type to send 1026 * @len: Length of associated data 1027 * @data: Data associated with command. 1028 */ 1029 static void qemu_savevm_command_send(QEMUFile *f, 1030 enum qemu_vm_cmd command, 1031 uint16_t len, 1032 uint8_t *data) 1033 { 1034 trace_savevm_command_send(command, len); 1035 qemu_put_byte(f, QEMU_VM_COMMAND); 1036 qemu_put_be16(f, (uint16_t)command); 1037 qemu_put_be16(f, len); 1038 qemu_put_buffer(f, data, len); 1039 qemu_fflush(f); 1040 } 1041 1042 void qemu_savevm_send_colo_enable(QEMUFile *f) 1043 { 1044 trace_savevm_send_colo_enable(); 1045 qemu_savevm_command_send(f, MIG_CMD_ENABLE_COLO, 0, NULL); 1046 } 1047 1048 void qemu_savevm_send_ping(QEMUFile *f, uint32_t value) 1049 { 1050 uint32_t buf; 1051 1052 trace_savevm_send_ping(value); 1053 buf = cpu_to_be32(value); 1054 qemu_savevm_command_send(f, MIG_CMD_PING, sizeof(value), (uint8_t *)&buf); 1055 } 1056 1057 void qemu_savevm_send_open_return_path(QEMUFile *f) 1058 { 1059 trace_savevm_send_open_return_path(); 1060 qemu_savevm_command_send(f, MIG_CMD_OPEN_RETURN_PATH, 0, NULL); 1061 } 1062 1063 /* We have a buffer of data to send; we don't want that all to be loaded 1064 * by the command itself, so the command contains just the length of the 1065 * extra buffer that we then send straight after it. 1066 * TODO: Must be a better way to organise that 1067 * 1068 * Returns: 1069 * 0 on success 1070 * -ve on error 1071 */ 1072 int qemu_savevm_send_packaged(QEMUFile *f, const uint8_t *buf, size_t len) 1073 { 1074 uint32_t tmp; 1075 MigrationState *ms = migrate_get_current(); 1076 Error *local_err = NULL; 1077 1078 if (len > MAX_VM_CMD_PACKAGED_SIZE) { 1079 error_setg(&local_err, "%s: Unreasonably large packaged state: %zu", 1080 __func__, len); 1081 migrate_set_error(ms, local_err); 1082 error_report_err(local_err); 1083 return -1; 1084 } 1085 1086 tmp = cpu_to_be32(len); 1087 1088 trace_qemu_savevm_send_packaged(); 1089 qemu_savevm_command_send(f, MIG_CMD_PACKAGED, 4, (uint8_t *)&tmp); 1090 1091 qemu_put_buffer(f, buf, len); 1092 1093 return 0; 1094 } 1095 1096 /* Send prior to any postcopy transfer */ 1097 void qemu_savevm_send_postcopy_advise(QEMUFile *f) 1098 { 1099 if (migrate_postcopy_ram()) { 1100 uint64_t tmp[2]; 1101 tmp[0] = cpu_to_be64(ram_pagesize_summary()); 1102 tmp[1] = cpu_to_be64(qemu_target_page_size()); 1103 1104 trace_qemu_savevm_send_postcopy_advise(); 1105 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_ADVISE, 1106 16, (uint8_t *)tmp); 1107 } else { 1108 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_ADVISE, 0, NULL); 1109 } 1110 } 1111 1112 /* Sent prior to starting the destination running in postcopy, discard pages 1113 * that have already been sent but redirtied on the source. 1114 * CMD_POSTCOPY_RAM_DISCARD consist of: 1115 * byte version (0) 1116 * byte Length of name field (not including 0) 1117 * n x byte RAM block name 1118 * byte 0 terminator (just for safety) 1119 * n x Byte ranges within the named RAMBlock 1120 * be64 Start of the range 1121 * be64 Length 1122 * 1123 * name: RAMBlock name that these entries are part of 1124 * len: Number of page entries 1125 * start_list: 'len' addresses 1126 * length_list: 'len' addresses 1127 * 1128 */ 1129 void qemu_savevm_send_postcopy_ram_discard(QEMUFile *f, const char *name, 1130 uint16_t len, 1131 uint64_t *start_list, 1132 uint64_t *length_list) 1133 { 1134 uint8_t *buf; 1135 uint16_t tmplen; 1136 uint16_t t; 1137 size_t name_len = strlen(name); 1138 1139 trace_qemu_savevm_send_postcopy_ram_discard(name, len); 1140 assert(name_len < 256); 1141 buf = g_malloc0(1 + 1 + name_len + 1 + (8 + 8) * len); 1142 buf[0] = postcopy_ram_discard_version; 1143 buf[1] = name_len; 1144 memcpy(buf + 2, name, name_len); 1145 tmplen = 2 + name_len; 1146 buf[tmplen++] = '\0'; 1147 1148 for (t = 0; t < len; t++) { 1149 stq_be_p(buf + tmplen, start_list[t]); 1150 tmplen += 8; 1151 stq_be_p(buf + tmplen, length_list[t]); 1152 tmplen += 8; 1153 } 1154 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RAM_DISCARD, tmplen, buf); 1155 g_free(buf); 1156 } 1157 1158 /* Get the destination into a state where it can receive postcopy data. */ 1159 void qemu_savevm_send_postcopy_listen(QEMUFile *f) 1160 { 1161 trace_savevm_send_postcopy_listen(); 1162 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_LISTEN, 0, NULL); 1163 } 1164 1165 /* Kick the destination into running */ 1166 void qemu_savevm_send_postcopy_run(QEMUFile *f) 1167 { 1168 trace_savevm_send_postcopy_run(); 1169 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RUN, 0, NULL); 1170 } 1171 1172 void qemu_savevm_send_postcopy_resume(QEMUFile *f) 1173 { 1174 trace_savevm_send_postcopy_resume(); 1175 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RESUME, 0, NULL); 1176 } 1177 1178 void qemu_savevm_send_recv_bitmap(QEMUFile *f, char *block_name) 1179 { 1180 size_t len; 1181 char buf[256]; 1182 1183 trace_savevm_send_recv_bitmap(block_name); 1184 1185 buf[0] = len = strlen(block_name); 1186 memcpy(buf + 1, block_name, len); 1187 1188 qemu_savevm_command_send(f, MIG_CMD_RECV_BITMAP, len + 1, (uint8_t *)buf); 1189 } 1190 1191 bool qemu_savevm_state_blocked(Error **errp) 1192 { 1193 SaveStateEntry *se; 1194 1195 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 1196 if (se->vmsd && se->vmsd->unmigratable) { 1197 error_setg(errp, "State blocked by non-migratable device '%s'", 1198 se->idstr); 1199 return true; 1200 } 1201 } 1202 return false; 1203 } 1204 1205 void qemu_savevm_non_migratable_list(strList **reasons) 1206 { 1207 SaveStateEntry *se; 1208 1209 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 1210 if (se->vmsd && se->vmsd->unmigratable) { 1211 QAPI_LIST_PREPEND(*reasons, 1212 g_strdup_printf("non-migratable device: %s", 1213 se->idstr)); 1214 } 1215 } 1216 } 1217 1218 void qemu_savevm_state_header(QEMUFile *f) 1219 { 1220 MigrationState *s = migrate_get_current(); 1221 1222 s->vmdesc = json_writer_new(false); 1223 1224 trace_savevm_state_header(); 1225 qemu_put_be32(f, QEMU_VM_FILE_MAGIC); 1226 qemu_put_be32(f, QEMU_VM_FILE_VERSION); 1227 1228 if (s->send_configuration) { 1229 qemu_put_byte(f, QEMU_VM_CONFIGURATION); 1230 1231 /* 1232 * This starts the main json object and is paired with the 1233 * json_writer_end_object in 1234 * qemu_savevm_state_complete_precopy_non_iterable 1235 */ 1236 json_writer_start_object(s->vmdesc, NULL); 1237 1238 json_writer_start_object(s->vmdesc, "configuration"); 1239 vmstate_save_state(f, &vmstate_configuration, &savevm_state, s->vmdesc); 1240 json_writer_end_object(s->vmdesc); 1241 } 1242 } 1243 1244 bool qemu_savevm_state_guest_unplug_pending(void) 1245 { 1246 SaveStateEntry *se; 1247 1248 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 1249 if (se->vmsd && se->vmsd->dev_unplug_pending && 1250 se->vmsd->dev_unplug_pending(se->opaque)) { 1251 return true; 1252 } 1253 } 1254 1255 return false; 1256 } 1257 1258 int qemu_savevm_state_prepare(Error **errp) 1259 { 1260 SaveStateEntry *se; 1261 int ret; 1262 1263 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 1264 if (!se->ops || !se->ops->save_prepare) { 1265 continue; 1266 } 1267 if (se->ops->is_active) { 1268 if (!se->ops->is_active(se->opaque)) { 1269 continue; 1270 } 1271 } 1272 1273 ret = se->ops->save_prepare(se->opaque, errp); 1274 if (ret < 0) { 1275 return ret; 1276 } 1277 } 1278 1279 return 0; 1280 } 1281 1282 void qemu_savevm_state_setup(QEMUFile *f) 1283 { 1284 MigrationState *ms = migrate_get_current(); 1285 SaveStateEntry *se; 1286 Error *local_err = NULL; 1287 int ret; 1288 1289 json_writer_int64(ms->vmdesc, "page_size", qemu_target_page_size()); 1290 json_writer_start_array(ms->vmdesc, "devices"); 1291 1292 trace_savevm_state_setup(); 1293 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 1294 if (se->vmsd && se->vmsd->early_setup) { 1295 ret = vmstate_save(f, se, ms->vmdesc); 1296 if (ret) { 1297 qemu_file_set_error(f, ret); 1298 break; 1299 } 1300 continue; 1301 } 1302 1303 if (!se->ops || !se->ops->save_setup) { 1304 continue; 1305 } 1306 if (se->ops->is_active) { 1307 if (!se->ops->is_active(se->opaque)) { 1308 continue; 1309 } 1310 } 1311 save_section_header(f, se, QEMU_VM_SECTION_START); 1312 1313 ret = se->ops->save_setup(f, se->opaque); 1314 save_section_footer(f, se); 1315 if (ret < 0) { 1316 qemu_file_set_error(f, ret); 1317 break; 1318 } 1319 } 1320 1321 if (precopy_notify(PRECOPY_NOTIFY_SETUP, &local_err)) { 1322 error_report_err(local_err); 1323 } 1324 } 1325 1326 int qemu_savevm_state_resume_prepare(MigrationState *s) 1327 { 1328 SaveStateEntry *se; 1329 int ret; 1330 1331 trace_savevm_state_resume_prepare(); 1332 1333 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 1334 if (!se->ops || !se->ops->resume_prepare) { 1335 continue; 1336 } 1337 if (se->ops->is_active) { 1338 if (!se->ops->is_active(se->opaque)) { 1339 continue; 1340 } 1341 } 1342 ret = se->ops->resume_prepare(s, se->opaque); 1343 if (ret < 0) { 1344 return ret; 1345 } 1346 } 1347 1348 return 0; 1349 } 1350 1351 /* 1352 * this function has three return values: 1353 * negative: there was one error, and we have -errno. 1354 * 0 : We haven't finished, caller have to go again 1355 * 1 : We have finished, we can go to complete phase 1356 */ 1357 int qemu_savevm_state_iterate(QEMUFile *f, bool postcopy) 1358 { 1359 SaveStateEntry *se; 1360 int ret = 1; 1361 1362 trace_savevm_state_iterate(); 1363 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 1364 if (!se->ops || !se->ops->save_live_iterate) { 1365 continue; 1366 } 1367 if (se->ops->is_active && 1368 !se->ops->is_active(se->opaque)) { 1369 continue; 1370 } 1371 if (se->ops->is_active_iterate && 1372 !se->ops->is_active_iterate(se->opaque)) { 1373 continue; 1374 } 1375 /* 1376 * In the postcopy phase, any device that doesn't know how to 1377 * do postcopy should have saved it's state in the _complete 1378 * call that's already run, it might get confused if we call 1379 * iterate afterwards. 1380 */ 1381 if (postcopy && 1382 !(se->ops->has_postcopy && se->ops->has_postcopy(se->opaque))) { 1383 continue; 1384 } 1385 if (migration_rate_exceeded(f)) { 1386 return 0; 1387 } 1388 trace_savevm_section_start(se->idstr, se->section_id); 1389 1390 save_section_header(f, se, QEMU_VM_SECTION_PART); 1391 1392 ret = se->ops->save_live_iterate(f, se->opaque); 1393 trace_savevm_section_end(se->idstr, se->section_id, ret); 1394 save_section_footer(f, se); 1395 1396 if (ret < 0) { 1397 error_report("failed to save SaveStateEntry with id(name): " 1398 "%d(%s): %d", 1399 se->section_id, se->idstr, ret); 1400 qemu_file_set_error(f, ret); 1401 } 1402 if (ret <= 0) { 1403 /* Do not proceed to the next vmstate before this one reported 1404 completion of the current stage. This serializes the migration 1405 and reduces the probability that a faster changing state is 1406 synchronized over and over again. */ 1407 break; 1408 } 1409 } 1410 return ret; 1411 } 1412 1413 static bool should_send_vmdesc(void) 1414 { 1415 MachineState *machine = MACHINE(qdev_get_machine()); 1416 bool in_postcopy = migration_in_postcopy(); 1417 return !machine->suppress_vmdesc && !in_postcopy; 1418 } 1419 1420 /* 1421 * Calls the save_live_complete_postcopy methods 1422 * causing the last few pages to be sent immediately and doing any associated 1423 * cleanup. 1424 * Note postcopy also calls qemu_savevm_state_complete_precopy to complete 1425 * all the other devices, but that happens at the point we switch to postcopy. 1426 */ 1427 void qemu_savevm_state_complete_postcopy(QEMUFile *f) 1428 { 1429 SaveStateEntry *se; 1430 int ret; 1431 1432 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 1433 if (!se->ops || !se->ops->save_live_complete_postcopy) { 1434 continue; 1435 } 1436 if (se->ops->is_active) { 1437 if (!se->ops->is_active(se->opaque)) { 1438 continue; 1439 } 1440 } 1441 trace_savevm_section_start(se->idstr, se->section_id); 1442 /* Section type */ 1443 qemu_put_byte(f, QEMU_VM_SECTION_END); 1444 qemu_put_be32(f, se->section_id); 1445 1446 ret = se->ops->save_live_complete_postcopy(f, se->opaque); 1447 trace_savevm_section_end(se->idstr, se->section_id, ret); 1448 save_section_footer(f, se); 1449 if (ret < 0) { 1450 qemu_file_set_error(f, ret); 1451 return; 1452 } 1453 } 1454 1455 qemu_put_byte(f, QEMU_VM_EOF); 1456 qemu_fflush(f); 1457 } 1458 1459 static 1460 int qemu_savevm_state_complete_precopy_iterable(QEMUFile *f, bool in_postcopy) 1461 { 1462 SaveStateEntry *se; 1463 int ret; 1464 1465 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 1466 if (!se->ops || 1467 (in_postcopy && se->ops->has_postcopy && 1468 se->ops->has_postcopy(se->opaque)) || 1469 !se->ops->save_live_complete_precopy) { 1470 continue; 1471 } 1472 1473 if (se->ops->is_active) { 1474 if (!se->ops->is_active(se->opaque)) { 1475 continue; 1476 } 1477 } 1478 trace_savevm_section_start(se->idstr, se->section_id); 1479 1480 save_section_header(f, se, QEMU_VM_SECTION_END); 1481 1482 ret = se->ops->save_live_complete_precopy(f, se->opaque); 1483 trace_savevm_section_end(se->idstr, se->section_id, ret); 1484 save_section_footer(f, se); 1485 if (ret < 0) { 1486 qemu_file_set_error(f, ret); 1487 return -1; 1488 } 1489 } 1490 1491 return 0; 1492 } 1493 1494 int qemu_savevm_state_complete_precopy_non_iterable(QEMUFile *f, 1495 bool in_postcopy, 1496 bool inactivate_disks) 1497 { 1498 MigrationState *ms = migrate_get_current(); 1499 JSONWriter *vmdesc = ms->vmdesc; 1500 int vmdesc_len; 1501 SaveStateEntry *se; 1502 int ret; 1503 1504 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 1505 if (se->vmsd && se->vmsd->early_setup) { 1506 /* Already saved during qemu_savevm_state_setup(). */ 1507 continue; 1508 } 1509 1510 ret = vmstate_save(f, se, vmdesc); 1511 if (ret) { 1512 qemu_file_set_error(f, ret); 1513 return ret; 1514 } 1515 } 1516 1517 if (inactivate_disks) { 1518 /* Inactivate before sending QEMU_VM_EOF so that the 1519 * bdrv_activate_all() on the other end won't fail. */ 1520 ret = bdrv_inactivate_all(); 1521 if (ret) { 1522 Error *local_err = NULL; 1523 error_setg(&local_err, "%s: bdrv_inactivate_all() failed (%d)", 1524 __func__, ret); 1525 migrate_set_error(ms, local_err); 1526 error_report_err(local_err); 1527 qemu_file_set_error(f, ret); 1528 return ret; 1529 } 1530 } 1531 if (!in_postcopy) { 1532 /* Postcopy stream will still be going */ 1533 qemu_put_byte(f, QEMU_VM_EOF); 1534 } 1535 1536 json_writer_end_array(vmdesc); 1537 json_writer_end_object(vmdesc); 1538 vmdesc_len = strlen(json_writer_get(vmdesc)); 1539 1540 if (should_send_vmdesc()) { 1541 qemu_put_byte(f, QEMU_VM_VMDESCRIPTION); 1542 qemu_put_be32(f, vmdesc_len); 1543 qemu_put_buffer(f, (uint8_t *)json_writer_get(vmdesc), vmdesc_len); 1544 } 1545 1546 /* Free it now to detect any inconsistencies. */ 1547 json_writer_free(vmdesc); 1548 ms->vmdesc = NULL; 1549 1550 return 0; 1551 } 1552 1553 int qemu_savevm_state_complete_precopy(QEMUFile *f, bool iterable_only, 1554 bool inactivate_disks) 1555 { 1556 int ret; 1557 Error *local_err = NULL; 1558 bool in_postcopy = migration_in_postcopy(); 1559 1560 if (precopy_notify(PRECOPY_NOTIFY_COMPLETE, &local_err)) { 1561 error_report_err(local_err); 1562 } 1563 1564 trace_savevm_state_complete_precopy(); 1565 1566 cpu_synchronize_all_states(); 1567 1568 if (!in_postcopy || iterable_only) { 1569 ret = qemu_savevm_state_complete_precopy_iterable(f, in_postcopy); 1570 if (ret) { 1571 return ret; 1572 } 1573 } 1574 1575 if (iterable_only) { 1576 goto flush; 1577 } 1578 1579 ret = qemu_savevm_state_complete_precopy_non_iterable(f, in_postcopy, 1580 inactivate_disks); 1581 if (ret) { 1582 return ret; 1583 } 1584 1585 flush: 1586 return qemu_fflush(f); 1587 } 1588 1589 /* Give an estimate of the amount left to be transferred, 1590 * the result is split into the amount for units that can and 1591 * for units that can't do postcopy. 1592 */ 1593 void qemu_savevm_state_pending_estimate(uint64_t *must_precopy, 1594 uint64_t *can_postcopy) 1595 { 1596 SaveStateEntry *se; 1597 1598 *must_precopy = 0; 1599 *can_postcopy = 0; 1600 1601 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 1602 if (!se->ops || !se->ops->state_pending_estimate) { 1603 continue; 1604 } 1605 if (se->ops->is_active) { 1606 if (!se->ops->is_active(se->opaque)) { 1607 continue; 1608 } 1609 } 1610 se->ops->state_pending_estimate(se->opaque, must_precopy, can_postcopy); 1611 } 1612 } 1613 1614 void qemu_savevm_state_pending_exact(uint64_t *must_precopy, 1615 uint64_t *can_postcopy) 1616 { 1617 SaveStateEntry *se; 1618 1619 *must_precopy = 0; 1620 *can_postcopy = 0; 1621 1622 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 1623 if (!se->ops || !se->ops->state_pending_exact) { 1624 continue; 1625 } 1626 if (se->ops->is_active) { 1627 if (!se->ops->is_active(se->opaque)) { 1628 continue; 1629 } 1630 } 1631 se->ops->state_pending_exact(se->opaque, must_precopy, can_postcopy); 1632 } 1633 } 1634 1635 void qemu_savevm_state_cleanup(void) 1636 { 1637 SaveStateEntry *se; 1638 Error *local_err = NULL; 1639 1640 if (precopy_notify(PRECOPY_NOTIFY_CLEANUP, &local_err)) { 1641 error_report_err(local_err); 1642 } 1643 1644 trace_savevm_state_cleanup(); 1645 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 1646 if (se->ops && se->ops->save_cleanup) { 1647 se->ops->save_cleanup(se->opaque); 1648 } 1649 } 1650 } 1651 1652 static int qemu_savevm_state(QEMUFile *f, Error **errp) 1653 { 1654 int ret; 1655 MigrationState *ms = migrate_get_current(); 1656 MigrationStatus status; 1657 1658 if (migration_is_running(ms->state)) { 1659 error_setg(errp, QERR_MIGRATION_ACTIVE); 1660 return -EINVAL; 1661 } 1662 1663 if (migrate_block()) { 1664 error_setg(errp, "Block migration and snapshots are incompatible"); 1665 return -EINVAL; 1666 } 1667 1668 ret = migrate_init(ms, errp); 1669 if (ret) { 1670 return ret; 1671 } 1672 ms->to_dst_file = f; 1673 1674 qemu_savevm_state_header(f); 1675 qemu_savevm_state_setup(f); 1676 1677 while (qemu_file_get_error(f) == 0) { 1678 if (qemu_savevm_state_iterate(f, false) > 0) { 1679 break; 1680 } 1681 } 1682 1683 ret = qemu_file_get_error(f); 1684 if (ret == 0) { 1685 qemu_savevm_state_complete_precopy(f, false, false); 1686 ret = qemu_file_get_error(f); 1687 } 1688 qemu_savevm_state_cleanup(); 1689 if (ret != 0) { 1690 error_setg_errno(errp, -ret, "Error while writing VM state"); 1691 } 1692 1693 if (ret != 0) { 1694 status = MIGRATION_STATUS_FAILED; 1695 } else { 1696 status = MIGRATION_STATUS_COMPLETED; 1697 } 1698 migrate_set_state(&ms->state, MIGRATION_STATUS_SETUP, status); 1699 1700 /* f is outer parameter, it should not stay in global migration state after 1701 * this function finished */ 1702 ms->to_dst_file = NULL; 1703 1704 return ret; 1705 } 1706 1707 void qemu_savevm_live_state(QEMUFile *f) 1708 { 1709 /* save QEMU_VM_SECTION_END section */ 1710 qemu_savevm_state_complete_precopy(f, true, false); 1711 qemu_put_byte(f, QEMU_VM_EOF); 1712 } 1713 1714 int qemu_save_device_state(QEMUFile *f) 1715 { 1716 SaveStateEntry *se; 1717 1718 if (!migration_in_colo_state()) { 1719 qemu_put_be32(f, QEMU_VM_FILE_MAGIC); 1720 qemu_put_be32(f, QEMU_VM_FILE_VERSION); 1721 } 1722 cpu_synchronize_all_states(); 1723 1724 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 1725 int ret; 1726 1727 if (se->is_ram) { 1728 continue; 1729 } 1730 ret = vmstate_save(f, se, NULL); 1731 if (ret) { 1732 return ret; 1733 } 1734 } 1735 1736 qemu_put_byte(f, QEMU_VM_EOF); 1737 1738 return qemu_file_get_error(f); 1739 } 1740 1741 static SaveStateEntry *find_se(const char *idstr, uint32_t instance_id) 1742 { 1743 SaveStateEntry *se; 1744 1745 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 1746 if (!strcmp(se->idstr, idstr) && 1747 (instance_id == se->instance_id || 1748 instance_id == se->alias_id)) 1749 return se; 1750 /* Migrating from an older version? */ 1751 if (strstr(se->idstr, idstr) && se->compat) { 1752 if (!strcmp(se->compat->idstr, idstr) && 1753 (instance_id == se->compat->instance_id || 1754 instance_id == se->alias_id)) 1755 return se; 1756 } 1757 } 1758 return NULL; 1759 } 1760 1761 enum LoadVMExitCodes { 1762 /* Allow a command to quit all layers of nested loadvm loops */ 1763 LOADVM_QUIT = 1, 1764 }; 1765 1766 /* ------ incoming postcopy messages ------ */ 1767 /* 'advise' arrives before any transfers just to tell us that a postcopy 1768 * *might* happen - it might be skipped if precopy transferred everything 1769 * quickly. 1770 */ 1771 static int loadvm_postcopy_handle_advise(MigrationIncomingState *mis, 1772 uint16_t len) 1773 { 1774 PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_ADVISE); 1775 uint64_t remote_pagesize_summary, local_pagesize_summary, remote_tps; 1776 size_t page_size = qemu_target_page_size(); 1777 Error *local_err = NULL; 1778 1779 trace_loadvm_postcopy_handle_advise(); 1780 if (ps != POSTCOPY_INCOMING_NONE) { 1781 error_report("CMD_POSTCOPY_ADVISE in wrong postcopy state (%d)", ps); 1782 return -1; 1783 } 1784 1785 switch (len) { 1786 case 0: 1787 if (migrate_postcopy_ram()) { 1788 error_report("RAM postcopy is enabled but have 0 byte advise"); 1789 return -EINVAL; 1790 } 1791 return 0; 1792 case 8 + 8: 1793 if (!migrate_postcopy_ram()) { 1794 error_report("RAM postcopy is disabled but have 16 byte advise"); 1795 return -EINVAL; 1796 } 1797 break; 1798 default: 1799 error_report("CMD_POSTCOPY_ADVISE invalid length (%d)", len); 1800 return -EINVAL; 1801 } 1802 1803 if (!postcopy_ram_supported_by_host(mis, &local_err)) { 1804 error_report_err(local_err); 1805 postcopy_state_set(POSTCOPY_INCOMING_NONE); 1806 return -1; 1807 } 1808 1809 remote_pagesize_summary = qemu_get_be64(mis->from_src_file); 1810 local_pagesize_summary = ram_pagesize_summary(); 1811 1812 if (remote_pagesize_summary != local_pagesize_summary) { 1813 /* 1814 * This detects two potential causes of mismatch: 1815 * a) A mismatch in host page sizes 1816 * Some combinations of mismatch are probably possible but it gets 1817 * a bit more complicated. In particular we need to place whole 1818 * host pages on the dest at once, and we need to ensure that we 1819 * handle dirtying to make sure we never end up sending part of 1820 * a hostpage on it's own. 1821 * b) The use of different huge page sizes on source/destination 1822 * a more fine grain test is performed during RAM block migration 1823 * but this test here causes a nice early clear failure, and 1824 * also fails when passed to an older qemu that doesn't 1825 * do huge pages. 1826 */ 1827 error_report("Postcopy needs matching RAM page sizes (s=%" PRIx64 1828 " d=%" PRIx64 ")", 1829 remote_pagesize_summary, local_pagesize_summary); 1830 return -1; 1831 } 1832 1833 remote_tps = qemu_get_be64(mis->from_src_file); 1834 if (remote_tps != page_size) { 1835 /* 1836 * Again, some differences could be dealt with, but for now keep it 1837 * simple. 1838 */ 1839 error_report("Postcopy needs matching target page sizes (s=%d d=%zd)", 1840 (int)remote_tps, page_size); 1841 return -1; 1842 } 1843 1844 if (postcopy_notify(POSTCOPY_NOTIFY_INBOUND_ADVISE, &local_err)) { 1845 error_report_err(local_err); 1846 return -1; 1847 } 1848 1849 if (ram_postcopy_incoming_init(mis)) { 1850 return -1; 1851 } 1852 1853 return 0; 1854 } 1855 1856 /* After postcopy we will be told to throw some pages away since they're 1857 * dirty and will have to be demand fetched. Must happen before CPU is 1858 * started. 1859 * There can be 0..many of these messages, each encoding multiple pages. 1860 */ 1861 static int loadvm_postcopy_ram_handle_discard(MigrationIncomingState *mis, 1862 uint16_t len) 1863 { 1864 int tmp; 1865 char ramid[256]; 1866 PostcopyState ps = postcopy_state_get(); 1867 1868 trace_loadvm_postcopy_ram_handle_discard(); 1869 1870 switch (ps) { 1871 case POSTCOPY_INCOMING_ADVISE: 1872 /* 1st discard */ 1873 tmp = postcopy_ram_prepare_discard(mis); 1874 if (tmp) { 1875 return tmp; 1876 } 1877 break; 1878 1879 case POSTCOPY_INCOMING_DISCARD: 1880 /* Expected state */ 1881 break; 1882 1883 default: 1884 error_report("CMD_POSTCOPY_RAM_DISCARD in wrong postcopy state (%d)", 1885 ps); 1886 return -1; 1887 } 1888 /* We're expecting a 1889 * Version (0) 1890 * a RAM ID string (length byte, name, 0 term) 1891 * then at least 1 16 byte chunk 1892 */ 1893 if (len < (1 + 1 + 1 + 1 + 2 * 8)) { 1894 error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len); 1895 return -1; 1896 } 1897 1898 tmp = qemu_get_byte(mis->from_src_file); 1899 if (tmp != postcopy_ram_discard_version) { 1900 error_report("CMD_POSTCOPY_RAM_DISCARD invalid version (%d)", tmp); 1901 return -1; 1902 } 1903 1904 if (!qemu_get_counted_string(mis->from_src_file, ramid)) { 1905 error_report("CMD_POSTCOPY_RAM_DISCARD Failed to read RAMBlock ID"); 1906 return -1; 1907 } 1908 tmp = qemu_get_byte(mis->from_src_file); 1909 if (tmp != 0) { 1910 error_report("CMD_POSTCOPY_RAM_DISCARD missing nil (%d)", tmp); 1911 return -1; 1912 } 1913 1914 len -= 3 + strlen(ramid); 1915 if (len % 16) { 1916 error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len); 1917 return -1; 1918 } 1919 trace_loadvm_postcopy_ram_handle_discard_header(ramid, len); 1920 while (len) { 1921 uint64_t start_addr, block_length; 1922 start_addr = qemu_get_be64(mis->from_src_file); 1923 block_length = qemu_get_be64(mis->from_src_file); 1924 1925 len -= 16; 1926 int ret = ram_discard_range(ramid, start_addr, block_length); 1927 if (ret) { 1928 return ret; 1929 } 1930 } 1931 trace_loadvm_postcopy_ram_handle_discard_end(); 1932 1933 return 0; 1934 } 1935 1936 /* 1937 * Triggered by a postcopy_listen command; this thread takes over reading 1938 * the input stream, leaving the main thread free to carry on loading the rest 1939 * of the device state (from RAM). 1940 * (TODO:This could do with being in a postcopy file - but there again it's 1941 * just another input loop, not that postcopy specific) 1942 */ 1943 static void *postcopy_ram_listen_thread(void *opaque) 1944 { 1945 MigrationIncomingState *mis = migration_incoming_get_current(); 1946 QEMUFile *f = mis->from_src_file; 1947 int load_res; 1948 MigrationState *migr = migrate_get_current(); 1949 1950 object_ref(OBJECT(migr)); 1951 1952 migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE, 1953 MIGRATION_STATUS_POSTCOPY_ACTIVE); 1954 qemu_sem_post(&mis->thread_sync_sem); 1955 trace_postcopy_ram_listen_thread_start(); 1956 1957 rcu_register_thread(); 1958 /* 1959 * Because we're a thread and not a coroutine we can't yield 1960 * in qemu_file, and thus we must be blocking now. 1961 */ 1962 qemu_file_set_blocking(f, true); 1963 load_res = qemu_loadvm_state_main(f, mis); 1964 1965 /* 1966 * This is tricky, but, mis->from_src_file can change after it 1967 * returns, when postcopy recovery happened. In the future, we may 1968 * want a wrapper for the QEMUFile handle. 1969 */ 1970 f = mis->from_src_file; 1971 1972 /* And non-blocking again so we don't block in any cleanup */ 1973 qemu_file_set_blocking(f, false); 1974 1975 trace_postcopy_ram_listen_thread_exit(); 1976 if (load_res < 0) { 1977 qemu_file_set_error(f, load_res); 1978 dirty_bitmap_mig_cancel_incoming(); 1979 if (postcopy_state_get() == POSTCOPY_INCOMING_RUNNING && 1980 !migrate_postcopy_ram() && migrate_dirty_bitmaps()) 1981 { 1982 error_report("%s: loadvm failed during postcopy: %d. All states " 1983 "are migrated except dirty bitmaps. Some dirty " 1984 "bitmaps may be lost, and present migrated dirty " 1985 "bitmaps are correctly migrated and valid.", 1986 __func__, load_res); 1987 load_res = 0; /* prevent further exit() */ 1988 } else { 1989 error_report("%s: loadvm failed: %d", __func__, load_res); 1990 migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE, 1991 MIGRATION_STATUS_FAILED); 1992 } 1993 } 1994 if (load_res >= 0) { 1995 /* 1996 * This looks good, but it's possible that the device loading in the 1997 * main thread hasn't finished yet, and so we might not be in 'RUN' 1998 * state yet; wait for the end of the main thread. 1999 */ 2000 qemu_event_wait(&mis->main_thread_load_event); 2001 } 2002 postcopy_ram_incoming_cleanup(mis); 2003 2004 if (load_res < 0) { 2005 /* 2006 * If something went wrong then we have a bad state so exit; 2007 * depending how far we got it might be possible at this point 2008 * to leave the guest running and fire MCEs for pages that never 2009 * arrived as a desperate recovery step. 2010 */ 2011 rcu_unregister_thread(); 2012 exit(EXIT_FAILURE); 2013 } 2014 2015 migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE, 2016 MIGRATION_STATUS_COMPLETED); 2017 /* 2018 * If everything has worked fine, then the main thread has waited 2019 * for us to start, and we're the last use of the mis. 2020 * (If something broke then qemu will have to exit anyway since it's 2021 * got a bad migration state). 2022 */ 2023 migration_incoming_state_destroy(); 2024 qemu_loadvm_state_cleanup(); 2025 2026 rcu_unregister_thread(); 2027 mis->have_listen_thread = false; 2028 postcopy_state_set(POSTCOPY_INCOMING_END); 2029 2030 object_unref(OBJECT(migr)); 2031 2032 return NULL; 2033 } 2034 2035 /* After this message we must be able to immediately receive postcopy data */ 2036 static int loadvm_postcopy_handle_listen(MigrationIncomingState *mis) 2037 { 2038 PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_LISTENING); 2039 Error *local_err = NULL; 2040 2041 trace_loadvm_postcopy_handle_listen("enter"); 2042 2043 if (ps != POSTCOPY_INCOMING_ADVISE && ps != POSTCOPY_INCOMING_DISCARD) { 2044 error_report("CMD_POSTCOPY_LISTEN in wrong postcopy state (%d)", ps); 2045 return -1; 2046 } 2047 if (ps == POSTCOPY_INCOMING_ADVISE) { 2048 /* 2049 * A rare case, we entered listen without having to do any discards, 2050 * so do the setup that's normally done at the time of the 1st discard. 2051 */ 2052 if (migrate_postcopy_ram()) { 2053 postcopy_ram_prepare_discard(mis); 2054 } 2055 } 2056 2057 trace_loadvm_postcopy_handle_listen("after discard"); 2058 2059 /* 2060 * Sensitise RAM - can now generate requests for blocks that don't exist 2061 * However, at this point the CPU shouldn't be running, and the IO 2062 * shouldn't be doing anything yet so don't actually expect requests 2063 */ 2064 if (migrate_postcopy_ram()) { 2065 if (postcopy_ram_incoming_setup(mis)) { 2066 postcopy_ram_incoming_cleanup(mis); 2067 return -1; 2068 } 2069 } 2070 2071 trace_loadvm_postcopy_handle_listen("after uffd"); 2072 2073 if (postcopy_notify(POSTCOPY_NOTIFY_INBOUND_LISTEN, &local_err)) { 2074 error_report_err(local_err); 2075 return -1; 2076 } 2077 2078 mis->have_listen_thread = true; 2079 postcopy_thread_create(mis, &mis->listen_thread, "postcopy/listen", 2080 postcopy_ram_listen_thread, QEMU_THREAD_DETACHED); 2081 trace_loadvm_postcopy_handle_listen("return"); 2082 2083 return 0; 2084 } 2085 2086 static void loadvm_postcopy_handle_run_bh(void *opaque) 2087 { 2088 Error *local_err = NULL; 2089 MigrationIncomingState *mis = opaque; 2090 2091 trace_loadvm_postcopy_handle_run_bh("enter"); 2092 2093 /* TODO we should move all of this lot into postcopy_ram.c or a shared code 2094 * in migration.c 2095 */ 2096 cpu_synchronize_all_post_init(); 2097 2098 trace_loadvm_postcopy_handle_run_bh("after cpu sync"); 2099 2100 qemu_announce_self(&mis->announce_timer, migrate_announce_params()); 2101 2102 trace_loadvm_postcopy_handle_run_bh("after announce"); 2103 2104 /* Make sure all file formats throw away their mutable metadata. 2105 * If we get an error here, just don't restart the VM yet. */ 2106 bdrv_activate_all(&local_err); 2107 if (local_err) { 2108 error_report_err(local_err); 2109 local_err = NULL; 2110 autostart = false; 2111 } 2112 2113 trace_loadvm_postcopy_handle_run_bh("after invalidate cache"); 2114 2115 dirty_bitmap_mig_before_vm_start(); 2116 2117 if (autostart) { 2118 /* Hold onto your hats, starting the CPU */ 2119 vm_start(); 2120 } else { 2121 /* leave it paused and let management decide when to start the CPU */ 2122 runstate_set(RUN_STATE_PAUSED); 2123 } 2124 2125 qemu_bh_delete(mis->bh); 2126 2127 trace_loadvm_postcopy_handle_run_bh("return"); 2128 } 2129 2130 /* After all discards we can start running and asking for pages */ 2131 static int loadvm_postcopy_handle_run(MigrationIncomingState *mis) 2132 { 2133 PostcopyState ps = postcopy_state_get(); 2134 2135 trace_loadvm_postcopy_handle_run(); 2136 if (ps != POSTCOPY_INCOMING_LISTENING) { 2137 error_report("CMD_POSTCOPY_RUN in wrong postcopy state (%d)", ps); 2138 return -1; 2139 } 2140 2141 postcopy_state_set(POSTCOPY_INCOMING_RUNNING); 2142 mis->bh = qemu_bh_new(loadvm_postcopy_handle_run_bh, mis); 2143 qemu_bh_schedule(mis->bh); 2144 2145 /* We need to finish reading the stream from the package 2146 * and also stop reading anything more from the stream that loaded the 2147 * package (since it's now being read by the listener thread). 2148 * LOADVM_QUIT will quit all the layers of nested loadvm loops. 2149 */ 2150 return LOADVM_QUIT; 2151 } 2152 2153 /* We must be with page_request_mutex held */ 2154 static gboolean postcopy_sync_page_req(gpointer key, gpointer value, 2155 gpointer data) 2156 { 2157 MigrationIncomingState *mis = data; 2158 void *host_addr = (void *) key; 2159 ram_addr_t rb_offset; 2160 RAMBlock *rb; 2161 int ret; 2162 2163 rb = qemu_ram_block_from_host(host_addr, true, &rb_offset); 2164 if (!rb) { 2165 /* 2166 * This should _never_ happen. However be nice for a migrating VM to 2167 * not crash/assert. Post an error (note: intended to not use *_once 2168 * because we do want to see all the illegal addresses; and this can 2169 * never be triggered by the guest so we're safe) and move on next. 2170 */ 2171 error_report("%s: illegal host addr %p", __func__, host_addr); 2172 /* Try the next entry */ 2173 return FALSE; 2174 } 2175 2176 ret = migrate_send_rp_message_req_pages(mis, rb, rb_offset); 2177 if (ret) { 2178 /* Please refer to above comment. */ 2179 error_report("%s: send rp message failed for addr %p", 2180 __func__, host_addr); 2181 return FALSE; 2182 } 2183 2184 trace_postcopy_page_req_sync(host_addr); 2185 2186 return FALSE; 2187 } 2188 2189 static void migrate_send_rp_req_pages_pending(MigrationIncomingState *mis) 2190 { 2191 WITH_QEMU_LOCK_GUARD(&mis->page_request_mutex) { 2192 g_tree_foreach(mis->page_requested, postcopy_sync_page_req, mis); 2193 } 2194 } 2195 2196 static int loadvm_postcopy_handle_resume(MigrationIncomingState *mis) 2197 { 2198 if (mis->state != MIGRATION_STATUS_POSTCOPY_RECOVER) { 2199 error_report("%s: illegal resume received", __func__); 2200 /* Don't fail the load, only for this. */ 2201 return 0; 2202 } 2203 2204 /* 2205 * Reset the last_rb before we resend any page req to source again, since 2206 * the source should have it reset already. 2207 */ 2208 mis->last_rb = NULL; 2209 2210 /* 2211 * This means source VM is ready to resume the postcopy migration. 2212 */ 2213 migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_RECOVER, 2214 MIGRATION_STATUS_POSTCOPY_ACTIVE); 2215 2216 trace_loadvm_postcopy_handle_resume(); 2217 2218 /* Tell source that "we are ready" */ 2219 migrate_send_rp_resume_ack(mis, MIGRATION_RESUME_ACK_VALUE); 2220 2221 /* 2222 * After a postcopy recovery, the source should have lost the postcopy 2223 * queue, or potentially the requested pages could have been lost during 2224 * the network down phase. Let's re-sync with the source VM by re-sending 2225 * all the pending pages that we eagerly need, so these threads won't get 2226 * blocked too long due to the recovery. 2227 * 2228 * Without this procedure, the faulted destination VM threads (waiting for 2229 * page requests right before the postcopy is interrupted) can keep hanging 2230 * until the pages are sent by the source during the background copying of 2231 * pages, or another thread faulted on the same address accidentally. 2232 */ 2233 migrate_send_rp_req_pages_pending(mis); 2234 2235 /* 2236 * It's time to switch state and release the fault thread to continue 2237 * service page faults. Note that this should be explicitly after the 2238 * above call to migrate_send_rp_req_pages_pending(). In short: 2239 * migrate_send_rp_message_req_pages() is not thread safe, yet. 2240 */ 2241 qemu_sem_post(&mis->postcopy_pause_sem_fault); 2242 2243 if (migrate_postcopy_preempt()) { 2244 /* 2245 * The preempt channel will be created in async manner, now let's 2246 * wait for it and make sure it's created. 2247 */ 2248 qemu_sem_wait(&mis->postcopy_qemufile_dst_done); 2249 assert(mis->postcopy_qemufile_dst); 2250 /* Kick the fast ram load thread too */ 2251 qemu_sem_post(&mis->postcopy_pause_sem_fast_load); 2252 } 2253 2254 return 0; 2255 } 2256 2257 /** 2258 * Immediately following this command is a blob of data containing an embedded 2259 * chunk of migration stream; read it and load it. 2260 * 2261 * @mis: Incoming state 2262 * @length: Length of packaged data to read 2263 * 2264 * Returns: Negative values on error 2265 * 2266 */ 2267 static int loadvm_handle_cmd_packaged(MigrationIncomingState *mis) 2268 { 2269 int ret; 2270 size_t length; 2271 QIOChannelBuffer *bioc; 2272 2273 length = qemu_get_be32(mis->from_src_file); 2274 trace_loadvm_handle_cmd_packaged(length); 2275 2276 if (length > MAX_VM_CMD_PACKAGED_SIZE) { 2277 error_report("Unreasonably large packaged state: %zu", length); 2278 return -1; 2279 } 2280 2281 bioc = qio_channel_buffer_new(length); 2282 qio_channel_set_name(QIO_CHANNEL(bioc), "migration-loadvm-buffer"); 2283 ret = qemu_get_buffer(mis->from_src_file, 2284 bioc->data, 2285 length); 2286 if (ret != length) { 2287 object_unref(OBJECT(bioc)); 2288 error_report("CMD_PACKAGED: Buffer receive fail ret=%d length=%zu", 2289 ret, length); 2290 return (ret < 0) ? ret : -EAGAIN; 2291 } 2292 bioc->usage += length; 2293 trace_loadvm_handle_cmd_packaged_received(ret); 2294 2295 QEMUFile *packf = qemu_file_new_input(QIO_CHANNEL(bioc)); 2296 2297 ret = qemu_loadvm_state_main(packf, mis); 2298 trace_loadvm_handle_cmd_packaged_main(ret); 2299 qemu_fclose(packf); 2300 object_unref(OBJECT(bioc)); 2301 2302 return ret; 2303 } 2304 2305 /* 2306 * Handle request that source requests for recved_bitmap on 2307 * destination. Payload format: 2308 * 2309 * len (1 byte) + ramblock_name (<255 bytes) 2310 */ 2311 static int loadvm_handle_recv_bitmap(MigrationIncomingState *mis, 2312 uint16_t len) 2313 { 2314 QEMUFile *file = mis->from_src_file; 2315 RAMBlock *rb; 2316 char block_name[256]; 2317 size_t cnt; 2318 2319 cnt = qemu_get_counted_string(file, block_name); 2320 if (!cnt) { 2321 error_report("%s: failed to read block name", __func__); 2322 return -EINVAL; 2323 } 2324 2325 /* Validate before using the data */ 2326 if (qemu_file_get_error(file)) { 2327 return qemu_file_get_error(file); 2328 } 2329 2330 if (len != cnt + 1) { 2331 error_report("%s: invalid payload length (%d)", __func__, len); 2332 return -EINVAL; 2333 } 2334 2335 rb = qemu_ram_block_by_name(block_name); 2336 if (!rb) { 2337 error_report("%s: block '%s' not found", __func__, block_name); 2338 return -EINVAL; 2339 } 2340 2341 migrate_send_rp_recv_bitmap(mis, block_name); 2342 2343 trace_loadvm_handle_recv_bitmap(block_name); 2344 2345 return 0; 2346 } 2347 2348 static int loadvm_process_enable_colo(MigrationIncomingState *mis) 2349 { 2350 int ret = migration_incoming_enable_colo(); 2351 2352 if (!ret) { 2353 ret = colo_init_ram_cache(); 2354 if (ret) { 2355 migration_incoming_disable_colo(); 2356 } 2357 } 2358 return ret; 2359 } 2360 2361 /* 2362 * Process an incoming 'QEMU_VM_COMMAND' 2363 * 0 just a normal return 2364 * LOADVM_QUIT All good, but exit the loop 2365 * <0 Error 2366 */ 2367 static int loadvm_process_command(QEMUFile *f) 2368 { 2369 MigrationIncomingState *mis = migration_incoming_get_current(); 2370 uint16_t cmd; 2371 uint16_t len; 2372 uint32_t tmp32; 2373 2374 cmd = qemu_get_be16(f); 2375 len = qemu_get_be16(f); 2376 2377 /* Check validity before continue processing of cmds */ 2378 if (qemu_file_get_error(f)) { 2379 return qemu_file_get_error(f); 2380 } 2381 2382 if (cmd >= MIG_CMD_MAX || cmd == MIG_CMD_INVALID) { 2383 error_report("MIG_CMD 0x%x unknown (len 0x%x)", cmd, len); 2384 return -EINVAL; 2385 } 2386 2387 trace_loadvm_process_command(mig_cmd_args[cmd].name, len); 2388 2389 if (mig_cmd_args[cmd].len != -1 && mig_cmd_args[cmd].len != len) { 2390 error_report("%s received with bad length - expecting %zu, got %d", 2391 mig_cmd_args[cmd].name, 2392 (size_t)mig_cmd_args[cmd].len, len); 2393 return -ERANGE; 2394 } 2395 2396 switch (cmd) { 2397 case MIG_CMD_OPEN_RETURN_PATH: 2398 if (mis->to_src_file) { 2399 error_report("CMD_OPEN_RETURN_PATH called when RP already open"); 2400 /* Not really a problem, so don't give up */ 2401 return 0; 2402 } 2403 mis->to_src_file = qemu_file_get_return_path(f); 2404 if (!mis->to_src_file) { 2405 error_report("CMD_OPEN_RETURN_PATH failed"); 2406 return -1; 2407 } 2408 2409 /* 2410 * Switchover ack is enabled but no device uses it, so send an ACK to 2411 * source that it's OK to switchover. Do it here, after return path has 2412 * been created. 2413 */ 2414 if (migrate_switchover_ack() && !mis->switchover_ack_pending_num) { 2415 int ret = migrate_send_rp_switchover_ack(mis); 2416 if (ret) { 2417 error_report( 2418 "Could not send switchover ack RP MSG, err %d (%s)", ret, 2419 strerror(-ret)); 2420 return ret; 2421 } 2422 } 2423 break; 2424 2425 case MIG_CMD_PING: 2426 tmp32 = qemu_get_be32(f); 2427 trace_loadvm_process_command_ping(tmp32); 2428 if (!mis->to_src_file) { 2429 error_report("CMD_PING (0x%x) received with no return path", 2430 tmp32); 2431 return -1; 2432 } 2433 migrate_send_rp_pong(mis, tmp32); 2434 break; 2435 2436 case MIG_CMD_PACKAGED: 2437 return loadvm_handle_cmd_packaged(mis); 2438 2439 case MIG_CMD_POSTCOPY_ADVISE: 2440 return loadvm_postcopy_handle_advise(mis, len); 2441 2442 case MIG_CMD_POSTCOPY_LISTEN: 2443 return loadvm_postcopy_handle_listen(mis); 2444 2445 case MIG_CMD_POSTCOPY_RUN: 2446 return loadvm_postcopy_handle_run(mis); 2447 2448 case MIG_CMD_POSTCOPY_RAM_DISCARD: 2449 return loadvm_postcopy_ram_handle_discard(mis, len); 2450 2451 case MIG_CMD_POSTCOPY_RESUME: 2452 return loadvm_postcopy_handle_resume(mis); 2453 2454 case MIG_CMD_RECV_BITMAP: 2455 return loadvm_handle_recv_bitmap(mis, len); 2456 2457 case MIG_CMD_ENABLE_COLO: 2458 return loadvm_process_enable_colo(mis); 2459 } 2460 2461 return 0; 2462 } 2463 2464 /* 2465 * Read a footer off the wire and check that it matches the expected section 2466 * 2467 * Returns: true if the footer was good 2468 * false if there is a problem (and calls error_report to say why) 2469 */ 2470 static bool check_section_footer(QEMUFile *f, SaveStateEntry *se) 2471 { 2472 int ret; 2473 uint8_t read_mark; 2474 uint32_t read_section_id; 2475 2476 if (!migrate_get_current()->send_section_footer) { 2477 /* No footer to check */ 2478 return true; 2479 } 2480 2481 read_mark = qemu_get_byte(f); 2482 2483 ret = qemu_file_get_error(f); 2484 if (ret) { 2485 error_report("%s: Read section footer failed: %d", 2486 __func__, ret); 2487 return false; 2488 } 2489 2490 if (read_mark != QEMU_VM_SECTION_FOOTER) { 2491 error_report("Missing section footer for %s", se->idstr); 2492 return false; 2493 } 2494 2495 read_section_id = qemu_get_be32(f); 2496 if (read_section_id != se->load_section_id) { 2497 error_report("Mismatched section id in footer for %s -" 2498 " read 0x%x expected 0x%x", 2499 se->idstr, read_section_id, se->load_section_id); 2500 return false; 2501 } 2502 2503 /* All good */ 2504 return true; 2505 } 2506 2507 static int 2508 qemu_loadvm_section_start_full(QEMUFile *f, MigrationIncomingState *mis) 2509 { 2510 uint32_t instance_id, version_id, section_id; 2511 SaveStateEntry *se; 2512 char idstr[256]; 2513 int ret; 2514 2515 /* Read section start */ 2516 section_id = qemu_get_be32(f); 2517 if (!qemu_get_counted_string(f, idstr)) { 2518 error_report("Unable to read ID string for section %u", 2519 section_id); 2520 return -EINVAL; 2521 } 2522 instance_id = qemu_get_be32(f); 2523 version_id = qemu_get_be32(f); 2524 2525 ret = qemu_file_get_error(f); 2526 if (ret) { 2527 error_report("%s: Failed to read instance/version ID: %d", 2528 __func__, ret); 2529 return ret; 2530 } 2531 2532 trace_qemu_loadvm_state_section_startfull(section_id, idstr, 2533 instance_id, version_id); 2534 /* Find savevm section */ 2535 se = find_se(idstr, instance_id); 2536 if (se == NULL) { 2537 error_report("Unknown savevm section or instance '%s' %"PRIu32". " 2538 "Make sure that your current VM setup matches your " 2539 "saved VM setup, including any hotplugged devices", 2540 idstr, instance_id); 2541 return -EINVAL; 2542 } 2543 2544 /* Validate version */ 2545 if (version_id > se->version_id) { 2546 error_report("savevm: unsupported version %d for '%s' v%d", 2547 version_id, idstr, se->version_id); 2548 return -EINVAL; 2549 } 2550 se->load_version_id = version_id; 2551 se->load_section_id = section_id; 2552 2553 /* Validate if it is a device's state */ 2554 if (xen_enabled() && se->is_ram) { 2555 error_report("loadvm: %s RAM loading not allowed on Xen", idstr); 2556 return -EINVAL; 2557 } 2558 2559 ret = vmstate_load(f, se); 2560 if (ret < 0) { 2561 error_report("error while loading state for instance 0x%"PRIx32" of" 2562 " device '%s'", instance_id, idstr); 2563 return ret; 2564 } 2565 if (!check_section_footer(f, se)) { 2566 return -EINVAL; 2567 } 2568 2569 return 0; 2570 } 2571 2572 static int 2573 qemu_loadvm_section_part_end(QEMUFile *f, MigrationIncomingState *mis) 2574 { 2575 uint32_t section_id; 2576 SaveStateEntry *se; 2577 int ret; 2578 2579 section_id = qemu_get_be32(f); 2580 2581 ret = qemu_file_get_error(f); 2582 if (ret) { 2583 error_report("%s: Failed to read section ID: %d", 2584 __func__, ret); 2585 return ret; 2586 } 2587 2588 trace_qemu_loadvm_state_section_partend(section_id); 2589 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 2590 if (se->load_section_id == section_id) { 2591 break; 2592 } 2593 } 2594 if (se == NULL) { 2595 error_report("Unknown savevm section %d", section_id); 2596 return -EINVAL; 2597 } 2598 2599 ret = vmstate_load(f, se); 2600 if (ret < 0) { 2601 error_report("error while loading state section id %d(%s)", 2602 section_id, se->idstr); 2603 return ret; 2604 } 2605 if (!check_section_footer(f, se)) { 2606 return -EINVAL; 2607 } 2608 2609 return 0; 2610 } 2611 2612 static int qemu_loadvm_state_header(QEMUFile *f) 2613 { 2614 unsigned int v; 2615 int ret; 2616 2617 v = qemu_get_be32(f); 2618 if (v != QEMU_VM_FILE_MAGIC) { 2619 error_report("Not a migration stream"); 2620 return -EINVAL; 2621 } 2622 2623 v = qemu_get_be32(f); 2624 if (v == QEMU_VM_FILE_VERSION_COMPAT) { 2625 error_report("SaveVM v2 format is obsolete and don't work anymore"); 2626 return -ENOTSUP; 2627 } 2628 if (v != QEMU_VM_FILE_VERSION) { 2629 error_report("Unsupported migration stream version"); 2630 return -ENOTSUP; 2631 } 2632 2633 if (migrate_get_current()->send_configuration) { 2634 if (qemu_get_byte(f) != QEMU_VM_CONFIGURATION) { 2635 error_report("Configuration section missing"); 2636 qemu_loadvm_state_cleanup(); 2637 return -EINVAL; 2638 } 2639 ret = vmstate_load_state(f, &vmstate_configuration, &savevm_state, 0); 2640 2641 if (ret) { 2642 qemu_loadvm_state_cleanup(); 2643 return ret; 2644 } 2645 } 2646 return 0; 2647 } 2648 2649 static void qemu_loadvm_state_switchover_ack_needed(MigrationIncomingState *mis) 2650 { 2651 SaveStateEntry *se; 2652 2653 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 2654 if (!se->ops || !se->ops->switchover_ack_needed) { 2655 continue; 2656 } 2657 2658 if (se->ops->switchover_ack_needed(se->opaque)) { 2659 mis->switchover_ack_pending_num++; 2660 } 2661 } 2662 2663 trace_loadvm_state_switchover_ack_needed(mis->switchover_ack_pending_num); 2664 } 2665 2666 static int qemu_loadvm_state_setup(QEMUFile *f) 2667 { 2668 SaveStateEntry *se; 2669 int ret; 2670 2671 trace_loadvm_state_setup(); 2672 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 2673 if (!se->ops || !se->ops->load_setup) { 2674 continue; 2675 } 2676 if (se->ops->is_active) { 2677 if (!se->ops->is_active(se->opaque)) { 2678 continue; 2679 } 2680 } 2681 2682 ret = se->ops->load_setup(f, se->opaque); 2683 if (ret < 0) { 2684 qemu_file_set_error(f, ret); 2685 error_report("Load state of device %s failed", se->idstr); 2686 return ret; 2687 } 2688 } 2689 return 0; 2690 } 2691 2692 void qemu_loadvm_state_cleanup(void) 2693 { 2694 SaveStateEntry *se; 2695 2696 trace_loadvm_state_cleanup(); 2697 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { 2698 if (se->ops && se->ops->load_cleanup) { 2699 se->ops->load_cleanup(se->opaque); 2700 } 2701 } 2702 } 2703 2704 /* Return true if we should continue the migration, or false. */ 2705 static bool postcopy_pause_incoming(MigrationIncomingState *mis) 2706 { 2707 int i; 2708 2709 trace_postcopy_pause_incoming(); 2710 2711 assert(migrate_postcopy_ram()); 2712 2713 /* 2714 * Unregister yank with either from/to src would work, since ioc behind it 2715 * is the same 2716 */ 2717 migration_ioc_unregister_yank_from_file(mis->from_src_file); 2718 2719 assert(mis->from_src_file); 2720 qemu_file_shutdown(mis->from_src_file); 2721 qemu_fclose(mis->from_src_file); 2722 mis->from_src_file = NULL; 2723 2724 assert(mis->to_src_file); 2725 qemu_file_shutdown(mis->to_src_file); 2726 qemu_mutex_lock(&mis->rp_mutex); 2727 qemu_fclose(mis->to_src_file); 2728 mis->to_src_file = NULL; 2729 qemu_mutex_unlock(&mis->rp_mutex); 2730 2731 /* 2732 * NOTE: this must happen before reset the PostcopyTmpPages below, 2733 * otherwise it's racy to reset those fields when the fast load thread 2734 * can be accessing it in parallel. 2735 */ 2736 if (mis->postcopy_qemufile_dst) { 2737 qemu_file_shutdown(mis->postcopy_qemufile_dst); 2738 /* Take the mutex to make sure the fast ram load thread halted */ 2739 qemu_mutex_lock(&mis->postcopy_prio_thread_mutex); 2740 migration_ioc_unregister_yank_from_file(mis->postcopy_qemufile_dst); 2741 qemu_fclose(mis->postcopy_qemufile_dst); 2742 mis->postcopy_qemufile_dst = NULL; 2743 qemu_mutex_unlock(&mis->postcopy_prio_thread_mutex); 2744 } 2745 2746 /* Current state can be either ACTIVE or RECOVER */ 2747 migrate_set_state(&mis->state, mis->state, 2748 MIGRATION_STATUS_POSTCOPY_PAUSED); 2749 2750 /* Notify the fault thread for the invalidated file handle */ 2751 postcopy_fault_thread_notify(mis); 2752 2753 /* 2754 * If network is interrupted, any temp page we received will be useless 2755 * because we didn't mark them as "received" in receivedmap. After a 2756 * proper recovery later (which will sync src dirty bitmap with receivedmap 2757 * on dest) these cached small pages will be resent again. 2758 */ 2759 for (i = 0; i < mis->postcopy_channels; i++) { 2760 postcopy_temp_page_reset(&mis->postcopy_tmp_pages[i]); 2761 } 2762 2763 error_report("Detected IO failure for postcopy. " 2764 "Migration paused."); 2765 2766 while (mis->state == MIGRATION_STATUS_POSTCOPY_PAUSED) { 2767 qemu_sem_wait(&mis->postcopy_pause_sem_dst); 2768 } 2769 2770 trace_postcopy_pause_incoming_continued(); 2771 2772 return true; 2773 } 2774 2775 int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis) 2776 { 2777 uint8_t section_type; 2778 int ret = 0; 2779 2780 retry: 2781 while (true) { 2782 section_type = qemu_get_byte(f); 2783 2784 ret = qemu_file_get_error_obj_any(f, mis->postcopy_qemufile_dst, NULL); 2785 if (ret) { 2786 break; 2787 } 2788 2789 trace_qemu_loadvm_state_section(section_type); 2790 switch (section_type) { 2791 case QEMU_VM_SECTION_START: 2792 case QEMU_VM_SECTION_FULL: 2793 ret = qemu_loadvm_section_start_full(f, mis); 2794 if (ret < 0) { 2795 goto out; 2796 } 2797 break; 2798 case QEMU_VM_SECTION_PART: 2799 case QEMU_VM_SECTION_END: 2800 ret = qemu_loadvm_section_part_end(f, mis); 2801 if (ret < 0) { 2802 goto out; 2803 } 2804 break; 2805 case QEMU_VM_COMMAND: 2806 ret = loadvm_process_command(f); 2807 trace_qemu_loadvm_state_section_command(ret); 2808 if ((ret < 0) || (ret == LOADVM_QUIT)) { 2809 goto out; 2810 } 2811 break; 2812 case QEMU_VM_EOF: 2813 /* This is the end of migration */ 2814 goto out; 2815 default: 2816 error_report("Unknown savevm section type %d", section_type); 2817 ret = -EINVAL; 2818 goto out; 2819 } 2820 } 2821 2822 out: 2823 if (ret < 0) { 2824 qemu_file_set_error(f, ret); 2825 2826 /* Cancel bitmaps incoming regardless of recovery */ 2827 dirty_bitmap_mig_cancel_incoming(); 2828 2829 /* 2830 * If we are during an active postcopy, then we pause instead 2831 * of bail out to at least keep the VM's dirty data. Note 2832 * that POSTCOPY_INCOMING_LISTENING stage is still not enough, 2833 * during which we're still receiving device states and we 2834 * still haven't yet started the VM on destination. 2835 * 2836 * Only RAM postcopy supports recovery. Still, if RAM postcopy is 2837 * enabled, canceled bitmaps postcopy will not affect RAM postcopy 2838 * recovering. 2839 */ 2840 if (postcopy_state_get() == POSTCOPY_INCOMING_RUNNING && 2841 migrate_postcopy_ram() && postcopy_pause_incoming(mis)) { 2842 /* Reset f to point to the newly created channel */ 2843 f = mis->from_src_file; 2844 goto retry; 2845 } 2846 } 2847 return ret; 2848 } 2849 2850 int qemu_loadvm_state(QEMUFile *f) 2851 { 2852 MigrationIncomingState *mis = migration_incoming_get_current(); 2853 Error *local_err = NULL; 2854 int ret; 2855 2856 if (qemu_savevm_state_blocked(&local_err)) { 2857 error_report_err(local_err); 2858 return -EINVAL; 2859 } 2860 2861 ret = qemu_loadvm_state_header(f); 2862 if (ret) { 2863 return ret; 2864 } 2865 2866 if (qemu_loadvm_state_setup(f) != 0) { 2867 return -EINVAL; 2868 } 2869 2870 if (migrate_switchover_ack()) { 2871 qemu_loadvm_state_switchover_ack_needed(mis); 2872 } 2873 2874 cpu_synchronize_all_pre_loadvm(); 2875 2876 ret = qemu_loadvm_state_main(f, mis); 2877 qemu_event_set(&mis->main_thread_load_event); 2878 2879 trace_qemu_loadvm_state_post_main(ret); 2880 2881 if (mis->have_listen_thread) { 2882 /* Listen thread still going, can't clean up yet */ 2883 return ret; 2884 } 2885 2886 if (ret == 0) { 2887 ret = qemu_file_get_error(f); 2888 } 2889 2890 /* 2891 * Try to read in the VMDESC section as well, so that dumping tools that 2892 * intercept our migration stream have the chance to see it. 2893 */ 2894 2895 /* We've got to be careful; if we don't read the data and just shut the fd 2896 * then the sender can error if we close while it's still sending. 2897 * We also mustn't read data that isn't there; some transports (RDMA) 2898 * will stall waiting for that data when the source has already closed. 2899 */ 2900 if (ret == 0 && should_send_vmdesc()) { 2901 uint8_t *buf; 2902 uint32_t size; 2903 uint8_t section_type = qemu_get_byte(f); 2904 2905 if (section_type != QEMU_VM_VMDESCRIPTION) { 2906 error_report("Expected vmdescription section, but got %d", 2907 section_type); 2908 /* 2909 * It doesn't seem worth failing at this point since 2910 * we apparently have an otherwise valid VM state 2911 */ 2912 } else { 2913 buf = g_malloc(0x1000); 2914 size = qemu_get_be32(f); 2915 2916 while (size > 0) { 2917 uint32_t read_chunk = MIN(size, 0x1000); 2918 qemu_get_buffer(f, buf, read_chunk); 2919 size -= read_chunk; 2920 } 2921 g_free(buf); 2922 } 2923 } 2924 2925 qemu_loadvm_state_cleanup(); 2926 cpu_synchronize_all_post_init(); 2927 2928 return ret; 2929 } 2930 2931 int qemu_load_device_state(QEMUFile *f) 2932 { 2933 MigrationIncomingState *mis = migration_incoming_get_current(); 2934 int ret; 2935 2936 /* Load QEMU_VM_SECTION_FULL section */ 2937 ret = qemu_loadvm_state_main(f, mis); 2938 if (ret < 0) { 2939 error_report("Failed to load device state: %d", ret); 2940 return ret; 2941 } 2942 2943 cpu_synchronize_all_post_init(); 2944 return 0; 2945 } 2946 2947 int qemu_loadvm_approve_switchover(void) 2948 { 2949 MigrationIncomingState *mis = migration_incoming_get_current(); 2950 2951 if (!mis->switchover_ack_pending_num) { 2952 return -EINVAL; 2953 } 2954 2955 mis->switchover_ack_pending_num--; 2956 trace_loadvm_approve_switchover(mis->switchover_ack_pending_num); 2957 2958 if (mis->switchover_ack_pending_num) { 2959 return 0; 2960 } 2961 2962 return migrate_send_rp_switchover_ack(mis); 2963 } 2964 2965 bool save_snapshot(const char *name, bool overwrite, const char *vmstate, 2966 bool has_devices, strList *devices, Error **errp) 2967 { 2968 BlockDriverState *bs; 2969 QEMUSnapshotInfo sn1, *sn = &sn1; 2970 int ret = -1, ret2; 2971 QEMUFile *f; 2972 int saved_vm_running; 2973 uint64_t vm_state_size; 2974 g_autoptr(GDateTime) now = g_date_time_new_now_local(); 2975 AioContext *aio_context; 2976 2977 GLOBAL_STATE_CODE(); 2978 2979 if (migration_is_blocked(errp)) { 2980 return false; 2981 } 2982 2983 if (!replay_can_snapshot()) { 2984 error_setg(errp, "Record/replay does not allow making snapshot " 2985 "right now. Try once more later."); 2986 return false; 2987 } 2988 2989 if (!bdrv_all_can_snapshot(has_devices, devices, errp)) { 2990 return false; 2991 } 2992 2993 /* Delete old snapshots of the same name */ 2994 if (name) { 2995 if (overwrite) { 2996 if (bdrv_all_delete_snapshot(name, has_devices, 2997 devices, errp) < 0) { 2998 return false; 2999 } 3000 } else { 3001 ret2 = bdrv_all_has_snapshot(name, has_devices, devices, errp); 3002 if (ret2 < 0) { 3003 return false; 3004 } 3005 if (ret2 == 1) { 3006 error_setg(errp, 3007 "Snapshot '%s' already exists in one or more devices", 3008 name); 3009 return false; 3010 } 3011 } 3012 } 3013 3014 bs = bdrv_all_find_vmstate_bs(vmstate, has_devices, devices, errp); 3015 if (bs == NULL) { 3016 return false; 3017 } 3018 aio_context = bdrv_get_aio_context(bs); 3019 3020 saved_vm_running = runstate_is_running(); 3021 3022 global_state_store(); 3023 vm_stop(RUN_STATE_SAVE_VM); 3024 3025 bdrv_drain_all_begin(); 3026 3027 aio_context_acquire(aio_context); 3028 3029 memset(sn, 0, sizeof(*sn)); 3030 3031 /* fill auxiliary fields */ 3032 sn->date_sec = g_date_time_to_unix(now); 3033 sn->date_nsec = g_date_time_get_microsecond(now) * 1000; 3034 sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL); 3035 if (replay_mode != REPLAY_MODE_NONE) { 3036 sn->icount = replay_get_current_icount(); 3037 } else { 3038 sn->icount = -1ULL; 3039 } 3040 3041 if (name) { 3042 pstrcpy(sn->name, sizeof(sn->name), name); 3043 } else { 3044 g_autofree char *autoname = g_date_time_format(now, "vm-%Y%m%d%H%M%S"); 3045 pstrcpy(sn->name, sizeof(sn->name), autoname); 3046 } 3047 3048 /* save the VM state */ 3049 f = qemu_fopen_bdrv(bs, 1); 3050 if (!f) { 3051 error_setg(errp, "Could not open VM state file"); 3052 goto the_end; 3053 } 3054 ret = qemu_savevm_state(f, errp); 3055 vm_state_size = qemu_file_transferred(f); 3056 ret2 = qemu_fclose(f); 3057 if (ret < 0) { 3058 goto the_end; 3059 } 3060 if (ret2 < 0) { 3061 ret = ret2; 3062 goto the_end; 3063 } 3064 3065 /* The bdrv_all_create_snapshot() call that follows acquires the AioContext 3066 * for itself. BDRV_POLL_WHILE() does not support nested locking because 3067 * it only releases the lock once. Therefore synchronous I/O will deadlock 3068 * unless we release the AioContext before bdrv_all_create_snapshot(). 3069 */ 3070 aio_context_release(aio_context); 3071 aio_context = NULL; 3072 3073 ret = bdrv_all_create_snapshot(sn, bs, vm_state_size, 3074 has_devices, devices, errp); 3075 if (ret < 0) { 3076 bdrv_all_delete_snapshot(sn->name, has_devices, devices, NULL); 3077 goto the_end; 3078 } 3079 3080 ret = 0; 3081 3082 the_end: 3083 if (aio_context) { 3084 aio_context_release(aio_context); 3085 } 3086 3087 bdrv_drain_all_end(); 3088 3089 if (saved_vm_running) { 3090 vm_start(); 3091 } 3092 return ret == 0; 3093 } 3094 3095 void qmp_xen_save_devices_state(const char *filename, bool has_live, bool live, 3096 Error **errp) 3097 { 3098 QEMUFile *f; 3099 QIOChannelFile *ioc; 3100 int saved_vm_running; 3101 int ret; 3102 3103 if (!has_live) { 3104 /* live default to true so old version of Xen tool stack can have a 3105 * successful live migration */ 3106 live = true; 3107 } 3108 3109 saved_vm_running = runstate_is_running(); 3110 vm_stop(RUN_STATE_SAVE_VM); 3111 global_state_store_running(); 3112 3113 ioc = qio_channel_file_new_path(filename, O_WRONLY | O_CREAT | O_TRUNC, 3114 0660, errp); 3115 if (!ioc) { 3116 goto the_end; 3117 } 3118 qio_channel_set_name(QIO_CHANNEL(ioc), "migration-xen-save-state"); 3119 f = qemu_file_new_output(QIO_CHANNEL(ioc)); 3120 object_unref(OBJECT(ioc)); 3121 ret = qemu_save_device_state(f); 3122 if (ret < 0 || qemu_fclose(f) < 0) { 3123 error_setg(errp, QERR_IO_ERROR); 3124 } else { 3125 /* libxl calls the QMP command "stop" before calling 3126 * "xen-save-devices-state" and in case of migration failure, libxl 3127 * would call "cont". 3128 * So call bdrv_inactivate_all (release locks) here to let the other 3129 * side of the migration take control of the images. 3130 */ 3131 if (live && !saved_vm_running) { 3132 ret = bdrv_inactivate_all(); 3133 if (ret) { 3134 error_setg(errp, "%s: bdrv_inactivate_all() failed (%d)", 3135 __func__, ret); 3136 } 3137 } 3138 } 3139 3140 the_end: 3141 if (saved_vm_running) { 3142 vm_start(); 3143 } 3144 } 3145 3146 void qmp_xen_load_devices_state(const char *filename, Error **errp) 3147 { 3148 QEMUFile *f; 3149 QIOChannelFile *ioc; 3150 int ret; 3151 3152 /* Guest must be paused before loading the device state; the RAM state 3153 * will already have been loaded by xc 3154 */ 3155 if (runstate_is_running()) { 3156 error_setg(errp, "Cannot update device state while vm is running"); 3157 return; 3158 } 3159 vm_stop(RUN_STATE_RESTORE_VM); 3160 3161 ioc = qio_channel_file_new_path(filename, O_RDONLY | O_BINARY, 0, errp); 3162 if (!ioc) { 3163 return; 3164 } 3165 qio_channel_set_name(QIO_CHANNEL(ioc), "migration-xen-load-state"); 3166 f = qemu_file_new_input(QIO_CHANNEL(ioc)); 3167 object_unref(OBJECT(ioc)); 3168 3169 ret = qemu_loadvm_state(f); 3170 qemu_fclose(f); 3171 if (ret < 0) { 3172 error_setg(errp, QERR_IO_ERROR); 3173 } 3174 migration_incoming_state_destroy(); 3175 } 3176 3177 bool load_snapshot(const char *name, const char *vmstate, 3178 bool has_devices, strList *devices, Error **errp) 3179 { 3180 BlockDriverState *bs_vm_state; 3181 QEMUSnapshotInfo sn; 3182 QEMUFile *f; 3183 int ret; 3184 AioContext *aio_context; 3185 MigrationIncomingState *mis = migration_incoming_get_current(); 3186 3187 if (!bdrv_all_can_snapshot(has_devices, devices, errp)) { 3188 return false; 3189 } 3190 ret = bdrv_all_has_snapshot(name, has_devices, devices, errp); 3191 if (ret < 0) { 3192 return false; 3193 } 3194 if (ret == 0) { 3195 error_setg(errp, "Snapshot '%s' does not exist in one or more devices", 3196 name); 3197 return false; 3198 } 3199 3200 bs_vm_state = bdrv_all_find_vmstate_bs(vmstate, has_devices, devices, errp); 3201 if (!bs_vm_state) { 3202 return false; 3203 } 3204 aio_context = bdrv_get_aio_context(bs_vm_state); 3205 3206 /* Don't even try to load empty VM states */ 3207 aio_context_acquire(aio_context); 3208 ret = bdrv_snapshot_find(bs_vm_state, &sn, name); 3209 aio_context_release(aio_context); 3210 if (ret < 0) { 3211 return false; 3212 } else if (sn.vm_state_size == 0) { 3213 error_setg(errp, "This is a disk-only snapshot. Revert to it " 3214 " offline using qemu-img"); 3215 return false; 3216 } 3217 3218 /* 3219 * Flush the record/replay queue. Now the VM state is going 3220 * to change. Therefore we don't need to preserve its consistency 3221 */ 3222 replay_flush_events(); 3223 3224 /* Flush all IO requests so they don't interfere with the new state. */ 3225 bdrv_drain_all_begin(); 3226 3227 ret = bdrv_all_goto_snapshot(name, has_devices, devices, errp); 3228 if (ret < 0) { 3229 goto err_drain; 3230 } 3231 3232 /* restore the VM state */ 3233 f = qemu_fopen_bdrv(bs_vm_state, 0); 3234 if (!f) { 3235 error_setg(errp, "Could not open VM state file"); 3236 goto err_drain; 3237 } 3238 3239 qemu_system_reset(SHUTDOWN_CAUSE_SNAPSHOT_LOAD); 3240 mis->from_src_file = f; 3241 3242 if (!yank_register_instance(MIGRATION_YANK_INSTANCE, errp)) { 3243 ret = -EINVAL; 3244 goto err_drain; 3245 } 3246 aio_context_acquire(aio_context); 3247 ret = qemu_loadvm_state(f); 3248 migration_incoming_state_destroy(); 3249 aio_context_release(aio_context); 3250 3251 bdrv_drain_all_end(); 3252 3253 if (ret < 0) { 3254 error_setg(errp, "Error %d while loading VM state", ret); 3255 return false; 3256 } 3257 3258 return true; 3259 3260 err_drain: 3261 bdrv_drain_all_end(); 3262 return false; 3263 } 3264 3265 bool delete_snapshot(const char *name, bool has_devices, 3266 strList *devices, Error **errp) 3267 { 3268 if (!bdrv_all_can_snapshot(has_devices, devices, errp)) { 3269 return false; 3270 } 3271 3272 if (bdrv_all_delete_snapshot(name, has_devices, devices, errp) < 0) { 3273 return false; 3274 } 3275 3276 return true; 3277 } 3278 3279 void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev) 3280 { 3281 qemu_ram_set_idstr(mr->ram_block, 3282 memory_region_name(mr), dev); 3283 qemu_ram_set_migratable(mr->ram_block); 3284 } 3285 3286 void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev) 3287 { 3288 qemu_ram_unset_idstr(mr->ram_block); 3289 qemu_ram_unset_migratable(mr->ram_block); 3290 } 3291 3292 void vmstate_register_ram_global(MemoryRegion *mr) 3293 { 3294 vmstate_register_ram(mr, NULL); 3295 } 3296 3297 bool vmstate_check_only_migratable(const VMStateDescription *vmsd) 3298 { 3299 /* check needed if --only-migratable is specified */ 3300 if (!only_migratable) { 3301 return true; 3302 } 3303 3304 return !(vmsd && vmsd->unmigratable); 3305 } 3306 3307 typedef struct SnapshotJob { 3308 Job common; 3309 char *tag; 3310 char *vmstate; 3311 strList *devices; 3312 Coroutine *co; 3313 Error **errp; 3314 bool ret; 3315 } SnapshotJob; 3316 3317 static void qmp_snapshot_job_free(SnapshotJob *s) 3318 { 3319 g_free(s->tag); 3320 g_free(s->vmstate); 3321 qapi_free_strList(s->devices); 3322 } 3323 3324 3325 static void snapshot_load_job_bh(void *opaque) 3326 { 3327 Job *job = opaque; 3328 SnapshotJob *s = container_of(job, SnapshotJob, common); 3329 int orig_vm_running; 3330 3331 job_progress_set_remaining(&s->common, 1); 3332 3333 orig_vm_running = runstate_is_running(); 3334 vm_stop(RUN_STATE_RESTORE_VM); 3335 3336 s->ret = load_snapshot(s->tag, s->vmstate, true, s->devices, s->errp); 3337 if (s->ret && orig_vm_running) { 3338 vm_start(); 3339 } 3340 3341 job_progress_update(&s->common, 1); 3342 3343 qmp_snapshot_job_free(s); 3344 aio_co_wake(s->co); 3345 } 3346 3347 static void snapshot_save_job_bh(void *opaque) 3348 { 3349 Job *job = opaque; 3350 SnapshotJob *s = container_of(job, SnapshotJob, common); 3351 3352 job_progress_set_remaining(&s->common, 1); 3353 s->ret = save_snapshot(s->tag, false, s->vmstate, 3354 true, s->devices, s->errp); 3355 job_progress_update(&s->common, 1); 3356 3357 qmp_snapshot_job_free(s); 3358 aio_co_wake(s->co); 3359 } 3360 3361 static void snapshot_delete_job_bh(void *opaque) 3362 { 3363 Job *job = opaque; 3364 SnapshotJob *s = container_of(job, SnapshotJob, common); 3365 3366 job_progress_set_remaining(&s->common, 1); 3367 s->ret = delete_snapshot(s->tag, true, s->devices, s->errp); 3368 job_progress_update(&s->common, 1); 3369 3370 qmp_snapshot_job_free(s); 3371 aio_co_wake(s->co); 3372 } 3373 3374 static int coroutine_fn snapshot_save_job_run(Job *job, Error **errp) 3375 { 3376 SnapshotJob *s = container_of(job, SnapshotJob, common); 3377 s->errp = errp; 3378 s->co = qemu_coroutine_self(); 3379 aio_bh_schedule_oneshot(qemu_get_aio_context(), 3380 snapshot_save_job_bh, job); 3381 qemu_coroutine_yield(); 3382 return s->ret ? 0 : -1; 3383 } 3384 3385 static int coroutine_fn snapshot_load_job_run(Job *job, Error **errp) 3386 { 3387 SnapshotJob *s = container_of(job, SnapshotJob, common); 3388 s->errp = errp; 3389 s->co = qemu_coroutine_self(); 3390 aio_bh_schedule_oneshot(qemu_get_aio_context(), 3391 snapshot_load_job_bh, job); 3392 qemu_coroutine_yield(); 3393 return s->ret ? 0 : -1; 3394 } 3395 3396 static int coroutine_fn snapshot_delete_job_run(Job *job, Error **errp) 3397 { 3398 SnapshotJob *s = container_of(job, SnapshotJob, common); 3399 s->errp = errp; 3400 s->co = qemu_coroutine_self(); 3401 aio_bh_schedule_oneshot(qemu_get_aio_context(), 3402 snapshot_delete_job_bh, job); 3403 qemu_coroutine_yield(); 3404 return s->ret ? 0 : -1; 3405 } 3406 3407 3408 static const JobDriver snapshot_load_job_driver = { 3409 .instance_size = sizeof(SnapshotJob), 3410 .job_type = JOB_TYPE_SNAPSHOT_LOAD, 3411 .run = snapshot_load_job_run, 3412 }; 3413 3414 static const JobDriver snapshot_save_job_driver = { 3415 .instance_size = sizeof(SnapshotJob), 3416 .job_type = JOB_TYPE_SNAPSHOT_SAVE, 3417 .run = snapshot_save_job_run, 3418 }; 3419 3420 static const JobDriver snapshot_delete_job_driver = { 3421 .instance_size = sizeof(SnapshotJob), 3422 .job_type = JOB_TYPE_SNAPSHOT_DELETE, 3423 .run = snapshot_delete_job_run, 3424 }; 3425 3426 3427 void qmp_snapshot_save(const char *job_id, 3428 const char *tag, 3429 const char *vmstate, 3430 strList *devices, 3431 Error **errp) 3432 { 3433 SnapshotJob *s; 3434 3435 s = job_create(job_id, &snapshot_save_job_driver, NULL, 3436 qemu_get_aio_context(), JOB_MANUAL_DISMISS, 3437 NULL, NULL, errp); 3438 if (!s) { 3439 return; 3440 } 3441 3442 s->tag = g_strdup(tag); 3443 s->vmstate = g_strdup(vmstate); 3444 s->devices = QAPI_CLONE(strList, devices); 3445 3446 job_start(&s->common); 3447 } 3448 3449 void qmp_snapshot_load(const char *job_id, 3450 const char *tag, 3451 const char *vmstate, 3452 strList *devices, 3453 Error **errp) 3454 { 3455 SnapshotJob *s; 3456 3457 s = job_create(job_id, &snapshot_load_job_driver, NULL, 3458 qemu_get_aio_context(), JOB_MANUAL_DISMISS, 3459 NULL, NULL, errp); 3460 if (!s) { 3461 return; 3462 } 3463 3464 s->tag = g_strdup(tag); 3465 s->vmstate = g_strdup(vmstate); 3466 s->devices = QAPI_CLONE(strList, devices); 3467 3468 job_start(&s->common); 3469 } 3470 3471 void qmp_snapshot_delete(const char *job_id, 3472 const char *tag, 3473 strList *devices, 3474 Error **errp) 3475 { 3476 SnapshotJob *s; 3477 3478 s = job_create(job_id, &snapshot_delete_job_driver, NULL, 3479 qemu_get_aio_context(), JOB_MANUAL_DISMISS, 3480 NULL, NULL, errp); 3481 if (!s) { 3482 return; 3483 } 3484 3485 s->tag = g_strdup(tag); 3486 s->devices = QAPI_CLONE(strList, devices); 3487 3488 job_start(&s->common); 3489 } 3490