migration/savevm: move non SaveStateEntry condition check out of iteration
[qemu/ar7.git] / migration / savevm.c
blob69a827a92fdb6b78319c238ee64031146f7b30aa
1 /*
2 * QEMU System Emulator
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 * Copyright (c) 2009-2015 Red Hat Inc
7 * Authors:
8 * Juan Quintela <quintela@redhat.com>
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:
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
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.
29 #include "qemu/osdep.h"
30 #include "hw/boards.h"
31 #include "hw/xen/xen.h"
32 #include "net/net.h"
33 #include "migration.h"
34 #include "migration/snapshot.h"
35 #include "migration/misc.h"
36 #include "migration/register.h"
37 #include "migration/global_state.h"
38 #include "ram.h"
39 #include "qemu-file-channel.h"
40 #include "qemu-file.h"
41 #include "savevm.h"
42 #include "postcopy-ram.h"
43 #include "qapi/error.h"
44 #include "qapi/qapi-commands-migration.h"
45 #include "qapi/qapi-commands-misc.h"
46 #include "qapi/qmp/qerror.h"
47 #include "qemu/error-report.h"
48 #include "sysemu/cpus.h"
49 #include "exec/memory.h"
50 #include "exec/target_page.h"
51 #include "trace.h"
52 #include "qemu/iov.h"
53 #include "block/snapshot.h"
54 #include "qemu/cutils.h"
55 #include "io/channel-buffer.h"
56 #include "io/channel-file.h"
57 #include "sysemu/replay.h"
58 #include "qjson.h"
59 #include "migration/colo.h"
60 #include "qemu/bitmap.h"
61 #include "net/announce.h"
63 const unsigned int postcopy_ram_discard_version = 0;
65 /* Subcommands for QEMU_VM_COMMAND */
66 enum qemu_vm_cmd {
67 MIG_CMD_INVALID = 0, /* Must be 0 */
68 MIG_CMD_OPEN_RETURN_PATH, /* Tell the dest to open the Return path */
69 MIG_CMD_PING, /* Request a PONG on the RP */
71 MIG_CMD_POSTCOPY_ADVISE, /* Prior to any page transfers, just
72 warn we might want to do PC */
73 MIG_CMD_POSTCOPY_LISTEN, /* Start listening for incoming
74 pages as it's running. */
75 MIG_CMD_POSTCOPY_RUN, /* Start execution */
77 MIG_CMD_POSTCOPY_RAM_DISCARD, /* A list of pages to discard that
78 were previously sent during
79 precopy but are dirty. */
80 MIG_CMD_PACKAGED, /* Send a wrapped stream within this stream */
81 MIG_CMD_ENABLE_COLO, /* Enable COLO */
82 MIG_CMD_POSTCOPY_RESUME, /* resume postcopy on dest */
83 MIG_CMD_RECV_BITMAP, /* Request for recved bitmap on dst */
84 MIG_CMD_MAX
87 #define MAX_VM_CMD_PACKAGED_SIZE UINT32_MAX
88 static struct mig_cmd_args {
89 ssize_t len; /* -1 = variable */
90 const char *name;
91 } mig_cmd_args[] = {
92 [MIG_CMD_INVALID] = { .len = -1, .name = "INVALID" },
93 [MIG_CMD_OPEN_RETURN_PATH] = { .len = 0, .name = "OPEN_RETURN_PATH" },
94 [MIG_CMD_PING] = { .len = sizeof(uint32_t), .name = "PING" },
95 [MIG_CMD_POSTCOPY_ADVISE] = { .len = -1, .name = "POSTCOPY_ADVISE" },
96 [MIG_CMD_POSTCOPY_LISTEN] = { .len = 0, .name = "POSTCOPY_LISTEN" },
97 [MIG_CMD_POSTCOPY_RUN] = { .len = 0, .name = "POSTCOPY_RUN" },
98 [MIG_CMD_POSTCOPY_RAM_DISCARD] = {
99 .len = -1, .name = "POSTCOPY_RAM_DISCARD" },
100 [MIG_CMD_POSTCOPY_RESUME] = { .len = 0, .name = "POSTCOPY_RESUME" },
101 [MIG_CMD_PACKAGED] = { .len = 4, .name = "PACKAGED" },
102 [MIG_CMD_RECV_BITMAP] = { .len = -1, .name = "RECV_BITMAP" },
103 [MIG_CMD_MAX] = { .len = -1, .name = "MAX" },
106 /* Note for MIG_CMD_POSTCOPY_ADVISE:
107 * The format of arguments is depending on postcopy mode:
108 * - postcopy RAM only
109 * uint64_t host page size
110 * uint64_t taget page size
112 * - postcopy RAM and postcopy dirty bitmaps
113 * format is the same as for postcopy RAM only
115 * - postcopy dirty bitmaps only
116 * Nothing. Command length field is 0.
118 * Be careful: adding a new postcopy entity with some other parameters should
119 * not break format self-description ability. Good way is to introduce some
120 * generic extendable format with an exception for two old entities.
123 /***********************************************************/
124 /* savevm/loadvm support */
126 static ssize_t block_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
127 int64_t pos, Error **errp)
129 int ret;
130 QEMUIOVector qiov;
132 qemu_iovec_init_external(&qiov, iov, iovcnt);
133 ret = bdrv_writev_vmstate(opaque, &qiov, pos);
134 if (ret < 0) {
135 return ret;
138 return qiov.size;
141 static ssize_t block_get_buffer(void *opaque, uint8_t *buf, int64_t pos,
142 size_t size, Error **errp)
144 return bdrv_load_vmstate(opaque, buf, pos, size);
147 static int bdrv_fclose(void *opaque, Error **errp)
149 return bdrv_flush(opaque);
152 static const QEMUFileOps bdrv_read_ops = {
153 .get_buffer = block_get_buffer,
154 .close = bdrv_fclose
157 static const QEMUFileOps bdrv_write_ops = {
158 .writev_buffer = block_writev_buffer,
159 .close = bdrv_fclose
162 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
164 if (is_writable) {
165 return qemu_fopen_ops(bs, &bdrv_write_ops);
167 return qemu_fopen_ops(bs, &bdrv_read_ops);
171 /* QEMUFile timer support.
172 * Not in qemu-file.c to not add qemu-timer.c as dependency to qemu-file.c
175 void timer_put(QEMUFile *f, QEMUTimer *ts)
177 uint64_t expire_time;
179 expire_time = timer_expire_time_ns(ts);
180 qemu_put_be64(f, expire_time);
183 void timer_get(QEMUFile *f, QEMUTimer *ts)
185 uint64_t expire_time;
187 expire_time = qemu_get_be64(f);
188 if (expire_time != -1) {
189 timer_mod_ns(ts, expire_time);
190 } else {
191 timer_del(ts);
196 /* VMState timer support.
197 * Not in vmstate.c to not add qemu-timer.c as dependency to vmstate.c
200 static int get_timer(QEMUFile *f, void *pv, size_t size,
201 const VMStateField *field)
203 QEMUTimer *v = pv;
204 timer_get(f, v);
205 return 0;
208 static int put_timer(QEMUFile *f, void *pv, size_t size,
209 const VMStateField *field, QJSON *vmdesc)
211 QEMUTimer *v = pv;
212 timer_put(f, v);
214 return 0;
217 const VMStateInfo vmstate_info_timer = {
218 .name = "timer",
219 .get = get_timer,
220 .put = put_timer,
224 typedef struct CompatEntry {
225 char idstr[256];
226 int instance_id;
227 } CompatEntry;
229 typedef struct SaveStateEntry {
230 QTAILQ_ENTRY(SaveStateEntry) entry;
231 char idstr[256];
232 int instance_id;
233 int alias_id;
234 int version_id;
235 /* version id read from the stream */
236 int load_version_id;
237 int section_id;
238 /* section id read from the stream */
239 int load_section_id;
240 const SaveVMHandlers *ops;
241 const VMStateDescription *vmsd;
242 void *opaque;
243 CompatEntry *compat;
244 int is_ram;
245 } SaveStateEntry;
247 typedef struct SaveState {
248 QTAILQ_HEAD(, SaveStateEntry) handlers;
249 int global_section_id;
250 uint32_t len;
251 const char *name;
252 uint32_t target_page_bits;
253 uint32_t caps_count;
254 MigrationCapability *capabilities;
255 } SaveState;
257 static SaveState savevm_state = {
258 .handlers = QTAILQ_HEAD_INITIALIZER(savevm_state.handlers),
259 .global_section_id = 0,
262 static bool should_validate_capability(int capability)
264 assert(capability >= 0 && capability < MIGRATION_CAPABILITY__MAX);
265 /* Validate only new capabilities to keep compatibility. */
266 switch (capability) {
267 case MIGRATION_CAPABILITY_X_IGNORE_SHARED:
268 return true;
269 default:
270 return false;
274 static uint32_t get_validatable_capabilities_count(void)
276 MigrationState *s = migrate_get_current();
277 uint32_t result = 0;
278 int i;
279 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
280 if (should_validate_capability(i) && s->enabled_capabilities[i]) {
281 result++;
284 return result;
287 static int configuration_pre_save(void *opaque)
289 SaveState *state = opaque;
290 const char *current_name = MACHINE_GET_CLASS(current_machine)->name;
291 MigrationState *s = migrate_get_current();
292 int i, j;
294 state->len = strlen(current_name);
295 state->name = current_name;
296 state->target_page_bits = qemu_target_page_bits();
298 state->caps_count = get_validatable_capabilities_count();
299 state->capabilities = g_renew(MigrationCapability, state->capabilities,
300 state->caps_count);
301 for (i = j = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
302 if (should_validate_capability(i) && s->enabled_capabilities[i]) {
303 state->capabilities[j++] = i;
307 return 0;
310 static int configuration_pre_load(void *opaque)
312 SaveState *state = opaque;
314 /* If there is no target-page-bits subsection it means the source
315 * predates the variable-target-page-bits support and is using the
316 * minimum possible value for this CPU.
318 state->target_page_bits = qemu_target_page_bits_min();
319 return 0;
322 static bool configuration_validate_capabilities(SaveState *state)
324 bool ret = true;
325 MigrationState *s = migrate_get_current();
326 unsigned long *source_caps_bm;
327 int i;
329 source_caps_bm = bitmap_new(MIGRATION_CAPABILITY__MAX);
330 for (i = 0; i < state->caps_count; i++) {
331 MigrationCapability capability = state->capabilities[i];
332 set_bit(capability, source_caps_bm);
335 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
336 bool source_state, target_state;
337 if (!should_validate_capability(i)) {
338 continue;
340 source_state = test_bit(i, source_caps_bm);
341 target_state = s->enabled_capabilities[i];
342 if (source_state != target_state) {
343 error_report("Capability %s is %s, but received capability is %s",
344 MigrationCapability_str(i),
345 target_state ? "on" : "off",
346 source_state ? "on" : "off");
347 ret = false;
348 /* Don't break here to report all failed capabilities */
352 g_free(source_caps_bm);
353 return ret;
356 static int configuration_post_load(void *opaque, int version_id)
358 SaveState *state = opaque;
359 const char *current_name = MACHINE_GET_CLASS(current_machine)->name;
361 if (strncmp(state->name, current_name, state->len) != 0) {
362 error_report("Machine type received is '%.*s' and local is '%s'",
363 (int) state->len, state->name, current_name);
364 return -EINVAL;
367 if (state->target_page_bits != qemu_target_page_bits()) {
368 error_report("Received TARGET_PAGE_BITS is %d but local is %d",
369 state->target_page_bits, qemu_target_page_bits());
370 return -EINVAL;
373 if (!configuration_validate_capabilities(state)) {
374 return -EINVAL;
377 return 0;
380 static int get_capability(QEMUFile *f, void *pv, size_t size,
381 const VMStateField *field)
383 MigrationCapability *capability = pv;
384 char capability_str[UINT8_MAX + 1];
385 uint8_t len;
386 int i;
388 len = qemu_get_byte(f);
389 qemu_get_buffer(f, (uint8_t *)capability_str, len);
390 capability_str[len] = '\0';
391 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
392 if (!strcmp(MigrationCapability_str(i), capability_str)) {
393 *capability = i;
394 return 0;
397 error_report("Received unknown capability %s", capability_str);
398 return -EINVAL;
401 static int put_capability(QEMUFile *f, void *pv, size_t size,
402 const VMStateField *field, QJSON *vmdesc)
404 MigrationCapability *capability = pv;
405 const char *capability_str = MigrationCapability_str(*capability);
406 size_t len = strlen(capability_str);
407 assert(len <= UINT8_MAX);
409 qemu_put_byte(f, len);
410 qemu_put_buffer(f, (uint8_t *)capability_str, len);
411 return 0;
414 static const VMStateInfo vmstate_info_capability = {
415 .name = "capability",
416 .get = get_capability,
417 .put = put_capability,
420 /* The target-page-bits subsection is present only if the
421 * target page size is not the same as the default (ie the
422 * minimum page size for a variable-page-size guest CPU).
423 * If it is present then it contains the actual target page
424 * bits for the machine, and migration will fail if the
425 * two ends don't agree about it.
427 static bool vmstate_target_page_bits_needed(void *opaque)
429 return qemu_target_page_bits()
430 > qemu_target_page_bits_min();
433 static const VMStateDescription vmstate_target_page_bits = {
434 .name = "configuration/target-page-bits",
435 .version_id = 1,
436 .minimum_version_id = 1,
437 .needed = vmstate_target_page_bits_needed,
438 .fields = (VMStateField[]) {
439 VMSTATE_UINT32(target_page_bits, SaveState),
440 VMSTATE_END_OF_LIST()
444 static bool vmstate_capabilites_needed(void *opaque)
446 return get_validatable_capabilities_count() > 0;
449 static const VMStateDescription vmstate_capabilites = {
450 .name = "configuration/capabilities",
451 .version_id = 1,
452 .minimum_version_id = 1,
453 .needed = vmstate_capabilites_needed,
454 .fields = (VMStateField[]) {
455 VMSTATE_UINT32_V(caps_count, SaveState, 1),
456 VMSTATE_VARRAY_UINT32_ALLOC(capabilities, SaveState, caps_count, 1,
457 vmstate_info_capability,
458 MigrationCapability),
459 VMSTATE_END_OF_LIST()
463 static const VMStateDescription vmstate_configuration = {
464 .name = "configuration",
465 .version_id = 1,
466 .pre_load = configuration_pre_load,
467 .post_load = configuration_post_load,
468 .pre_save = configuration_pre_save,
469 .fields = (VMStateField[]) {
470 VMSTATE_UINT32(len, SaveState),
471 VMSTATE_VBUFFER_ALLOC_UINT32(name, SaveState, 0, NULL, len),
472 VMSTATE_END_OF_LIST()
474 .subsections = (const VMStateDescription*[]) {
475 &vmstate_target_page_bits,
476 &vmstate_capabilites,
477 NULL
481 static void dump_vmstate_vmsd(FILE *out_file,
482 const VMStateDescription *vmsd, int indent,
483 bool is_subsection);
485 static void dump_vmstate_vmsf(FILE *out_file, const VMStateField *field,
486 int indent)
488 fprintf(out_file, "%*s{\n", indent, "");
489 indent += 2;
490 fprintf(out_file, "%*s\"field\": \"%s\",\n", indent, "", field->name);
491 fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
492 field->version_id);
493 fprintf(out_file, "%*s\"field_exists\": %s,\n", indent, "",
494 field->field_exists ? "true" : "false");
495 fprintf(out_file, "%*s\"size\": %zu", indent, "", field->size);
496 if (field->vmsd != NULL) {
497 fprintf(out_file, ",\n");
498 dump_vmstate_vmsd(out_file, field->vmsd, indent, false);
500 fprintf(out_file, "\n%*s}", indent - 2, "");
503 static void dump_vmstate_vmss(FILE *out_file,
504 const VMStateDescription **subsection,
505 int indent)
507 if (*subsection != NULL) {
508 dump_vmstate_vmsd(out_file, *subsection, indent, true);
512 static void dump_vmstate_vmsd(FILE *out_file,
513 const VMStateDescription *vmsd, int indent,
514 bool is_subsection)
516 if (is_subsection) {
517 fprintf(out_file, "%*s{\n", indent, "");
518 } else {
519 fprintf(out_file, "%*s\"%s\": {\n", indent, "", "Description");
521 indent += 2;
522 fprintf(out_file, "%*s\"name\": \"%s\",\n", indent, "", vmsd->name);
523 fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
524 vmsd->version_id);
525 fprintf(out_file, "%*s\"minimum_version_id\": %d", indent, "",
526 vmsd->minimum_version_id);
527 if (vmsd->fields != NULL) {
528 const VMStateField *field = vmsd->fields;
529 bool first;
531 fprintf(out_file, ",\n%*s\"Fields\": [\n", indent, "");
532 first = true;
533 while (field->name != NULL) {
534 if (field->flags & VMS_MUST_EXIST) {
535 /* Ignore VMSTATE_VALIDATE bits; these don't get migrated */
536 field++;
537 continue;
539 if (!first) {
540 fprintf(out_file, ",\n");
542 dump_vmstate_vmsf(out_file, field, indent + 2);
543 field++;
544 first = false;
546 fprintf(out_file, "\n%*s]", indent, "");
548 if (vmsd->subsections != NULL) {
549 const VMStateDescription **subsection = vmsd->subsections;
550 bool first;
552 fprintf(out_file, ",\n%*s\"Subsections\": [\n", indent, "");
553 first = true;
554 while (*subsection != NULL) {
555 if (!first) {
556 fprintf(out_file, ",\n");
558 dump_vmstate_vmss(out_file, subsection, indent + 2);
559 subsection++;
560 first = false;
562 fprintf(out_file, "\n%*s]", indent, "");
564 fprintf(out_file, "\n%*s}", indent - 2, "");
567 static void dump_machine_type(FILE *out_file)
569 MachineClass *mc;
571 mc = MACHINE_GET_CLASS(current_machine);
573 fprintf(out_file, " \"vmschkmachine\": {\n");
574 fprintf(out_file, " \"Name\": \"%s\"\n", mc->name);
575 fprintf(out_file, " },\n");
578 void dump_vmstate_json_to_file(FILE *out_file)
580 GSList *list, *elt;
581 bool first;
583 fprintf(out_file, "{\n");
584 dump_machine_type(out_file);
586 first = true;
587 list = object_class_get_list(TYPE_DEVICE, true);
588 for (elt = list; elt; elt = elt->next) {
589 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
590 TYPE_DEVICE);
591 const char *name;
592 int indent = 2;
594 if (!dc->vmsd) {
595 continue;
598 if (!first) {
599 fprintf(out_file, ",\n");
601 name = object_class_get_name(OBJECT_CLASS(dc));
602 fprintf(out_file, "%*s\"%s\": {\n", indent, "", name);
603 indent += 2;
604 fprintf(out_file, "%*s\"Name\": \"%s\",\n", indent, "", name);
605 fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
606 dc->vmsd->version_id);
607 fprintf(out_file, "%*s\"minimum_version_id\": %d,\n", indent, "",
608 dc->vmsd->minimum_version_id);
610 dump_vmstate_vmsd(out_file, dc->vmsd, indent, false);
612 fprintf(out_file, "\n%*s}", indent - 2, "");
613 first = false;
615 fprintf(out_file, "\n}\n");
616 fclose(out_file);
619 static int calculate_new_instance_id(const char *idstr)
621 SaveStateEntry *se;
622 int instance_id = 0;
624 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
625 if (strcmp(idstr, se->idstr) == 0
626 && instance_id <= se->instance_id) {
627 instance_id = se->instance_id + 1;
630 return instance_id;
633 static int calculate_compat_instance_id(const char *idstr)
635 SaveStateEntry *se;
636 int instance_id = 0;
638 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
639 if (!se->compat) {
640 continue;
643 if (strcmp(idstr, se->compat->idstr) == 0
644 && instance_id <= se->compat->instance_id) {
645 instance_id = se->compat->instance_id + 1;
648 return instance_id;
651 static inline MigrationPriority save_state_priority(SaveStateEntry *se)
653 if (se->vmsd) {
654 return se->vmsd->priority;
656 return MIG_PRI_DEFAULT;
659 static void savevm_state_handler_insert(SaveStateEntry *nse)
661 MigrationPriority priority = save_state_priority(nse);
662 SaveStateEntry *se;
664 assert(priority <= MIG_PRI_MAX);
666 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
667 if (save_state_priority(se) < priority) {
668 break;
672 if (se) {
673 QTAILQ_INSERT_BEFORE(se, nse, entry);
674 } else {
675 QTAILQ_INSERT_TAIL(&savevm_state.handlers, nse, entry);
679 /* TODO: Individual devices generally have very little idea about the rest
680 of the system, so instance_id should be removed/replaced.
681 Meanwhile pass -1 as instance_id if you do not already have a clearly
682 distinguishing id for all instances of your device class. */
683 int register_savevm_live(DeviceState *dev,
684 const char *idstr,
685 int instance_id,
686 int version_id,
687 const SaveVMHandlers *ops,
688 void *opaque)
690 SaveStateEntry *se;
692 se = g_new0(SaveStateEntry, 1);
693 se->version_id = version_id;
694 se->section_id = savevm_state.global_section_id++;
695 se->ops = ops;
696 se->opaque = opaque;
697 se->vmsd = NULL;
698 /* if this is a live_savem then set is_ram */
699 if (ops->save_setup != NULL) {
700 se->is_ram = 1;
703 if (dev) {
704 char *id = qdev_get_dev_path(dev);
705 if (id) {
706 if (snprintf(se->idstr, sizeof(se->idstr), "%s/", id) >=
707 sizeof(se->idstr)) {
708 error_report("Path too long for VMState (%s)", id);
709 g_free(id);
710 g_free(se);
712 return -1;
714 g_free(id);
716 se->compat = g_new0(CompatEntry, 1);
717 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr);
718 se->compat->instance_id = instance_id == -1 ?
719 calculate_compat_instance_id(idstr) : instance_id;
720 instance_id = -1;
723 pstrcat(se->idstr, sizeof(se->idstr), idstr);
725 if (instance_id == -1) {
726 se->instance_id = calculate_new_instance_id(se->idstr);
727 } else {
728 se->instance_id = instance_id;
730 assert(!se->compat || se->instance_id == 0);
731 savevm_state_handler_insert(se);
732 return 0;
735 void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
737 SaveStateEntry *se, *new_se;
738 char id[256] = "";
740 if (dev) {
741 char *path = qdev_get_dev_path(dev);
742 if (path) {
743 pstrcpy(id, sizeof(id), path);
744 pstrcat(id, sizeof(id), "/");
745 g_free(path);
748 pstrcat(id, sizeof(id), idstr);
750 QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) {
751 if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
752 QTAILQ_REMOVE(&savevm_state.handlers, se, entry);
753 g_free(se->compat);
754 g_free(se);
759 int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
760 const VMStateDescription *vmsd,
761 void *opaque, int alias_id,
762 int required_for_version,
763 Error **errp)
765 SaveStateEntry *se;
767 /* If this triggers, alias support can be dropped for the vmsd. */
768 assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id);
770 se = g_new0(SaveStateEntry, 1);
771 se->version_id = vmsd->version_id;
772 se->section_id = savevm_state.global_section_id++;
773 se->opaque = opaque;
774 se->vmsd = vmsd;
775 se->alias_id = alias_id;
777 if (dev) {
778 char *id = qdev_get_dev_path(dev);
779 if (id) {
780 if (snprintf(se->idstr, sizeof(se->idstr), "%s/", id) >=
781 sizeof(se->idstr)) {
782 error_setg(errp, "Path too long for VMState (%s)", id);
783 g_free(id);
784 g_free(se);
786 return -1;
788 g_free(id);
790 se->compat = g_new0(CompatEntry, 1);
791 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
792 se->compat->instance_id = instance_id == -1 ?
793 calculate_compat_instance_id(vmsd->name) : instance_id;
794 instance_id = -1;
797 pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);
799 if (instance_id == -1) {
800 se->instance_id = calculate_new_instance_id(se->idstr);
801 } else {
802 se->instance_id = instance_id;
804 assert(!se->compat || se->instance_id == 0);
805 savevm_state_handler_insert(se);
806 return 0;
809 void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
810 void *opaque)
812 SaveStateEntry *se, *new_se;
814 QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) {
815 if (se->vmsd == vmsd && se->opaque == opaque) {
816 QTAILQ_REMOVE(&savevm_state.handlers, se, entry);
817 g_free(se->compat);
818 g_free(se);
823 static int vmstate_load(QEMUFile *f, SaveStateEntry *se)
825 trace_vmstate_load(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
826 if (!se->vmsd) { /* Old style */
827 return se->ops->load_state(f, se->opaque, se->load_version_id);
829 return vmstate_load_state(f, se->vmsd, se->opaque, se->load_version_id);
832 static void vmstate_save_old_style(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc)
834 int64_t old_offset, size;
836 old_offset = qemu_ftell_fast(f);
837 se->ops->save_state(f, se->opaque);
838 size = qemu_ftell_fast(f) - old_offset;
840 if (vmdesc) {
841 json_prop_int(vmdesc, "size", size);
842 json_start_array(vmdesc, "fields");
843 json_start_object(vmdesc, NULL);
844 json_prop_str(vmdesc, "name", "data");
845 json_prop_int(vmdesc, "size", size);
846 json_prop_str(vmdesc, "type", "buffer");
847 json_end_object(vmdesc);
848 json_end_array(vmdesc);
852 static int vmstate_save(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc)
854 trace_vmstate_save(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
855 if (!se->vmsd) {
856 vmstate_save_old_style(f, se, vmdesc);
857 return 0;
859 return vmstate_save_state(f, se->vmsd, se->opaque, vmdesc);
863 * Write the header for device section (QEMU_VM_SECTION START/END/PART/FULL)
865 static void save_section_header(QEMUFile *f, SaveStateEntry *se,
866 uint8_t section_type)
868 qemu_put_byte(f, section_type);
869 qemu_put_be32(f, se->section_id);
871 if (section_type == QEMU_VM_SECTION_FULL ||
872 section_type == QEMU_VM_SECTION_START) {
873 /* ID string */
874 size_t len = strlen(se->idstr);
875 qemu_put_byte(f, len);
876 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
878 qemu_put_be32(f, se->instance_id);
879 qemu_put_be32(f, se->version_id);
884 * Write a footer onto device sections that catches cases misformatted device
885 * sections.
887 static void save_section_footer(QEMUFile *f, SaveStateEntry *se)
889 if (migrate_get_current()->send_section_footer) {
890 qemu_put_byte(f, QEMU_VM_SECTION_FOOTER);
891 qemu_put_be32(f, se->section_id);
896 * qemu_savevm_command_send: Send a 'QEMU_VM_COMMAND' type element with the
897 * command and associated data.
899 * @f: File to send command on
900 * @command: Command type to send
901 * @len: Length of associated data
902 * @data: Data associated with command.
904 static void qemu_savevm_command_send(QEMUFile *f,
905 enum qemu_vm_cmd command,
906 uint16_t len,
907 uint8_t *data)
909 trace_savevm_command_send(command, len);
910 qemu_put_byte(f, QEMU_VM_COMMAND);
911 qemu_put_be16(f, (uint16_t)command);
912 qemu_put_be16(f, len);
913 qemu_put_buffer(f, data, len);
914 qemu_fflush(f);
917 void qemu_savevm_send_colo_enable(QEMUFile *f)
919 trace_savevm_send_colo_enable();
920 qemu_savevm_command_send(f, MIG_CMD_ENABLE_COLO, 0, NULL);
923 void qemu_savevm_send_ping(QEMUFile *f, uint32_t value)
925 uint32_t buf;
927 trace_savevm_send_ping(value);
928 buf = cpu_to_be32(value);
929 qemu_savevm_command_send(f, MIG_CMD_PING, sizeof(value), (uint8_t *)&buf);
932 void qemu_savevm_send_open_return_path(QEMUFile *f)
934 trace_savevm_send_open_return_path();
935 qemu_savevm_command_send(f, MIG_CMD_OPEN_RETURN_PATH, 0, NULL);
938 /* We have a buffer of data to send; we don't want that all to be loaded
939 * by the command itself, so the command contains just the length of the
940 * extra buffer that we then send straight after it.
941 * TODO: Must be a better way to organise that
943 * Returns:
944 * 0 on success
945 * -ve on error
947 int qemu_savevm_send_packaged(QEMUFile *f, const uint8_t *buf, size_t len)
949 uint32_t tmp;
951 if (len > MAX_VM_CMD_PACKAGED_SIZE) {
952 error_report("%s: Unreasonably large packaged state: %zu",
953 __func__, len);
954 return -1;
957 tmp = cpu_to_be32(len);
959 trace_qemu_savevm_send_packaged();
960 qemu_savevm_command_send(f, MIG_CMD_PACKAGED, 4, (uint8_t *)&tmp);
962 qemu_put_buffer(f, buf, len);
964 return 0;
967 /* Send prior to any postcopy transfer */
968 void qemu_savevm_send_postcopy_advise(QEMUFile *f)
970 if (migrate_postcopy_ram()) {
971 uint64_t tmp[2];
972 tmp[0] = cpu_to_be64(ram_pagesize_summary());
973 tmp[1] = cpu_to_be64(qemu_target_page_size());
975 trace_qemu_savevm_send_postcopy_advise();
976 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_ADVISE,
977 16, (uint8_t *)tmp);
978 } else {
979 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_ADVISE, 0, NULL);
983 /* Sent prior to starting the destination running in postcopy, discard pages
984 * that have already been sent but redirtied on the source.
985 * CMD_POSTCOPY_RAM_DISCARD consist of:
986 * byte version (0)
987 * byte Length of name field (not including 0)
988 * n x byte RAM block name
989 * byte 0 terminator (just for safety)
990 * n x Byte ranges within the named RAMBlock
991 * be64 Start of the range
992 * be64 Length
994 * name: RAMBlock name that these entries are part of
995 * len: Number of page entries
996 * start_list: 'len' addresses
997 * length_list: 'len' addresses
1000 void qemu_savevm_send_postcopy_ram_discard(QEMUFile *f, const char *name,
1001 uint16_t len,
1002 uint64_t *start_list,
1003 uint64_t *length_list)
1005 uint8_t *buf;
1006 uint16_t tmplen;
1007 uint16_t t;
1008 size_t name_len = strlen(name);
1010 trace_qemu_savevm_send_postcopy_ram_discard(name, len);
1011 assert(name_len < 256);
1012 buf = g_malloc0(1 + 1 + name_len + 1 + (8 + 8) * len);
1013 buf[0] = postcopy_ram_discard_version;
1014 buf[1] = name_len;
1015 memcpy(buf + 2, name, name_len);
1016 tmplen = 2 + name_len;
1017 buf[tmplen++] = '\0';
1019 for (t = 0; t < len; t++) {
1020 stq_be_p(buf + tmplen, start_list[t]);
1021 tmplen += 8;
1022 stq_be_p(buf + tmplen, length_list[t]);
1023 tmplen += 8;
1025 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RAM_DISCARD, tmplen, buf);
1026 g_free(buf);
1029 /* Get the destination into a state where it can receive postcopy data. */
1030 void qemu_savevm_send_postcopy_listen(QEMUFile *f)
1032 trace_savevm_send_postcopy_listen();
1033 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_LISTEN, 0, NULL);
1036 /* Kick the destination into running */
1037 void qemu_savevm_send_postcopy_run(QEMUFile *f)
1039 trace_savevm_send_postcopy_run();
1040 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RUN, 0, NULL);
1043 void qemu_savevm_send_postcopy_resume(QEMUFile *f)
1045 trace_savevm_send_postcopy_resume();
1046 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RESUME, 0, NULL);
1049 void qemu_savevm_send_recv_bitmap(QEMUFile *f, char *block_name)
1051 size_t len;
1052 char buf[256];
1054 trace_savevm_send_recv_bitmap(block_name);
1056 buf[0] = len = strlen(block_name);
1057 memcpy(buf + 1, block_name, len);
1059 qemu_savevm_command_send(f, MIG_CMD_RECV_BITMAP, len + 1, (uint8_t *)buf);
1062 bool qemu_savevm_state_blocked(Error **errp)
1064 SaveStateEntry *se;
1066 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1067 if (se->vmsd && se->vmsd->unmigratable) {
1068 error_setg(errp, "State blocked by non-migratable device '%s'",
1069 se->idstr);
1070 return true;
1073 return false;
1076 void qemu_savevm_state_header(QEMUFile *f)
1078 trace_savevm_state_header();
1079 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1080 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1082 if (migrate_get_current()->send_configuration) {
1083 qemu_put_byte(f, QEMU_VM_CONFIGURATION);
1084 vmstate_save_state(f, &vmstate_configuration, &savevm_state, 0);
1088 void qemu_savevm_state_setup(QEMUFile *f)
1090 SaveStateEntry *se;
1091 Error *local_err = NULL;
1092 int ret;
1094 trace_savevm_state_setup();
1095 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1096 if (!se->ops || !se->ops->save_setup) {
1097 continue;
1099 if (se->ops && se->ops->is_active) {
1100 if (!se->ops->is_active(se->opaque)) {
1101 continue;
1104 save_section_header(f, se, QEMU_VM_SECTION_START);
1106 ret = se->ops->save_setup(f, se->opaque);
1107 save_section_footer(f, se);
1108 if (ret < 0) {
1109 qemu_file_set_error(f, ret);
1110 break;
1114 if (precopy_notify(PRECOPY_NOTIFY_SETUP, &local_err)) {
1115 error_report_err(local_err);
1119 int qemu_savevm_state_resume_prepare(MigrationState *s)
1121 SaveStateEntry *se;
1122 int ret;
1124 trace_savevm_state_resume_prepare();
1126 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1127 if (!se->ops || !se->ops->resume_prepare) {
1128 continue;
1130 if (se->ops && se->ops->is_active) {
1131 if (!se->ops->is_active(se->opaque)) {
1132 continue;
1135 ret = se->ops->resume_prepare(s, se->opaque);
1136 if (ret < 0) {
1137 return ret;
1141 return 0;
1145 * this function has three return values:
1146 * negative: there was one error, and we have -errno.
1147 * 0 : We haven't finished, caller have to go again
1148 * 1 : We have finished, we can go to complete phase
1150 int qemu_savevm_state_iterate(QEMUFile *f, bool postcopy)
1152 SaveStateEntry *se;
1153 int ret = 1;
1155 trace_savevm_state_iterate();
1156 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1157 if (!se->ops || !se->ops->save_live_iterate) {
1158 continue;
1160 if (se->ops->is_active &&
1161 !se->ops->is_active(se->opaque)) {
1162 continue;
1164 if (se->ops->is_active_iterate &&
1165 !se->ops->is_active_iterate(se->opaque)) {
1166 continue;
1169 * In the postcopy phase, any device that doesn't know how to
1170 * do postcopy should have saved it's state in the _complete
1171 * call that's already run, it might get confused if we call
1172 * iterate afterwards.
1174 if (postcopy &&
1175 !(se->ops->has_postcopy && se->ops->has_postcopy(se->opaque))) {
1176 continue;
1178 if (qemu_file_rate_limit(f)) {
1179 return 0;
1181 trace_savevm_section_start(se->idstr, se->section_id);
1183 save_section_header(f, se, QEMU_VM_SECTION_PART);
1185 ret = se->ops->save_live_iterate(f, se->opaque);
1186 trace_savevm_section_end(se->idstr, se->section_id, ret);
1187 save_section_footer(f, se);
1189 if (ret < 0) {
1190 qemu_file_set_error(f, ret);
1192 if (ret <= 0) {
1193 /* Do not proceed to the next vmstate before this one reported
1194 completion of the current stage. This serializes the migration
1195 and reduces the probability that a faster changing state is
1196 synchronized over and over again. */
1197 break;
1200 return ret;
1203 static bool should_send_vmdesc(void)
1205 MachineState *machine = MACHINE(qdev_get_machine());
1206 bool in_postcopy = migration_in_postcopy();
1207 return !machine->suppress_vmdesc && !in_postcopy;
1211 * Calls the save_live_complete_postcopy methods
1212 * causing the last few pages to be sent immediately and doing any associated
1213 * cleanup.
1214 * Note postcopy also calls qemu_savevm_state_complete_precopy to complete
1215 * all the other devices, but that happens at the point we switch to postcopy.
1217 void qemu_savevm_state_complete_postcopy(QEMUFile *f)
1219 SaveStateEntry *se;
1220 int ret;
1222 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1223 if (!se->ops || !se->ops->save_live_complete_postcopy) {
1224 continue;
1226 if (se->ops && se->ops->is_active) {
1227 if (!se->ops->is_active(se->opaque)) {
1228 continue;
1231 trace_savevm_section_start(se->idstr, se->section_id);
1232 /* Section type */
1233 qemu_put_byte(f, QEMU_VM_SECTION_END);
1234 qemu_put_be32(f, se->section_id);
1236 ret = se->ops->save_live_complete_postcopy(f, se->opaque);
1237 trace_savevm_section_end(se->idstr, se->section_id, ret);
1238 save_section_footer(f, se);
1239 if (ret < 0) {
1240 qemu_file_set_error(f, ret);
1241 return;
1245 qemu_put_byte(f, QEMU_VM_EOF);
1246 qemu_fflush(f);
1249 static
1250 int qemu_savevm_state_complete_precopy_iterable(QEMUFile *f, bool in_postcopy)
1252 SaveStateEntry *se;
1253 int ret;
1255 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1256 if (!se->ops ||
1257 (in_postcopy && se->ops->has_postcopy &&
1258 se->ops->has_postcopy(se->opaque)) ||
1259 !se->ops->save_live_complete_precopy) {
1260 continue;
1263 if (se->ops && se->ops->is_active) {
1264 if (!se->ops->is_active(se->opaque)) {
1265 continue;
1268 trace_savevm_section_start(se->idstr, se->section_id);
1270 save_section_header(f, se, QEMU_VM_SECTION_END);
1272 ret = se->ops->save_live_complete_precopy(f, se->opaque);
1273 trace_savevm_section_end(se->idstr, se->section_id, ret);
1274 save_section_footer(f, se);
1275 if (ret < 0) {
1276 qemu_file_set_error(f, ret);
1277 return -1;
1281 return 0;
1284 static
1285 int qemu_savevm_state_complete_precopy_non_iterable(QEMUFile *f,
1286 bool in_postcopy,
1287 bool inactivate_disks)
1289 QJSON *vmdesc;
1290 int vmdesc_len;
1291 SaveStateEntry *se;
1292 int ret;
1294 vmdesc = qjson_new();
1295 json_prop_int(vmdesc, "page_size", qemu_target_page_size());
1296 json_start_array(vmdesc, "devices");
1297 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1299 if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1300 continue;
1302 if (se->vmsd && !vmstate_save_needed(se->vmsd, se->opaque)) {
1303 trace_savevm_section_skip(se->idstr, se->section_id);
1304 continue;
1307 trace_savevm_section_start(se->idstr, se->section_id);
1309 json_start_object(vmdesc, NULL);
1310 json_prop_str(vmdesc, "name", se->idstr);
1311 json_prop_int(vmdesc, "instance_id", se->instance_id);
1313 save_section_header(f, se, QEMU_VM_SECTION_FULL);
1314 ret = vmstate_save(f, se, vmdesc);
1315 if (ret) {
1316 qemu_file_set_error(f, ret);
1317 return ret;
1319 trace_savevm_section_end(se->idstr, se->section_id, 0);
1320 save_section_footer(f, se);
1322 json_end_object(vmdesc);
1325 if (inactivate_disks) {
1326 /* Inactivate before sending QEMU_VM_EOF so that the
1327 * bdrv_invalidate_cache_all() on the other end won't fail. */
1328 ret = bdrv_inactivate_all();
1329 if (ret) {
1330 error_report("%s: bdrv_inactivate_all() failed (%d)",
1331 __func__, ret);
1332 qemu_file_set_error(f, ret);
1333 return ret;
1336 if (!in_postcopy) {
1337 /* Postcopy stream will still be going */
1338 qemu_put_byte(f, QEMU_VM_EOF);
1341 json_end_array(vmdesc);
1342 qjson_finish(vmdesc);
1343 vmdesc_len = strlen(qjson_get_str(vmdesc));
1345 if (should_send_vmdesc()) {
1346 qemu_put_byte(f, QEMU_VM_VMDESCRIPTION);
1347 qemu_put_be32(f, vmdesc_len);
1348 qemu_put_buffer(f, (uint8_t *)qjson_get_str(vmdesc), vmdesc_len);
1350 qjson_destroy(vmdesc);
1352 return 0;
1355 int qemu_savevm_state_complete_precopy(QEMUFile *f, bool iterable_only,
1356 bool inactivate_disks)
1358 int ret;
1359 Error *local_err = NULL;
1360 bool in_postcopy = migration_in_postcopy();
1362 if (precopy_notify(PRECOPY_NOTIFY_COMPLETE, &local_err)) {
1363 error_report_err(local_err);
1366 trace_savevm_state_complete_precopy();
1368 cpu_synchronize_all_states();
1370 if (!in_postcopy || iterable_only) {
1371 ret = qemu_savevm_state_complete_precopy_iterable(f, in_postcopy);
1372 if (ret) {
1373 return ret;
1377 if (iterable_only) {
1378 goto flush;
1381 ret = qemu_savevm_state_complete_precopy_non_iterable(f, in_postcopy,
1382 inactivate_disks);
1383 if (ret) {
1384 return ret;
1387 flush:
1388 qemu_fflush(f);
1389 return 0;
1392 /* Give an estimate of the amount left to be transferred,
1393 * the result is split into the amount for units that can and
1394 * for units that can't do postcopy.
1396 void qemu_savevm_state_pending(QEMUFile *f, uint64_t threshold_size,
1397 uint64_t *res_precopy_only,
1398 uint64_t *res_compatible,
1399 uint64_t *res_postcopy_only)
1401 SaveStateEntry *se;
1403 *res_precopy_only = 0;
1404 *res_compatible = 0;
1405 *res_postcopy_only = 0;
1408 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1409 if (!se->ops || !se->ops->save_live_pending) {
1410 continue;
1412 if (se->ops && se->ops->is_active) {
1413 if (!se->ops->is_active(se->opaque)) {
1414 continue;
1417 se->ops->save_live_pending(f, se->opaque, threshold_size,
1418 res_precopy_only, res_compatible,
1419 res_postcopy_only);
1423 void qemu_savevm_state_cleanup(void)
1425 SaveStateEntry *se;
1426 Error *local_err = NULL;
1428 if (precopy_notify(PRECOPY_NOTIFY_CLEANUP, &local_err)) {
1429 error_report_err(local_err);
1432 trace_savevm_state_cleanup();
1433 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1434 if (se->ops && se->ops->save_cleanup) {
1435 se->ops->save_cleanup(se->opaque);
1440 static int qemu_savevm_state(QEMUFile *f, Error **errp)
1442 int ret;
1443 MigrationState *ms = migrate_get_current();
1444 MigrationStatus status;
1446 if (migration_is_setup_or_active(ms->state) ||
1447 ms->state == MIGRATION_STATUS_CANCELLING ||
1448 ms->state == MIGRATION_STATUS_COLO) {
1449 error_setg(errp, QERR_MIGRATION_ACTIVE);
1450 return -EINVAL;
1453 if (migrate_use_block()) {
1454 error_setg(errp, "Block migration and snapshots are incompatible");
1455 return -EINVAL;
1458 migrate_init(ms);
1459 ms->to_dst_file = f;
1461 qemu_mutex_unlock_iothread();
1462 qemu_savevm_state_header(f);
1463 qemu_savevm_state_setup(f);
1464 qemu_mutex_lock_iothread();
1466 while (qemu_file_get_error(f) == 0) {
1467 if (qemu_savevm_state_iterate(f, false) > 0) {
1468 break;
1472 ret = qemu_file_get_error(f);
1473 if (ret == 0) {
1474 qemu_savevm_state_complete_precopy(f, false, false);
1475 ret = qemu_file_get_error(f);
1477 qemu_savevm_state_cleanup();
1478 if (ret != 0) {
1479 error_setg_errno(errp, -ret, "Error while writing VM state");
1482 if (ret != 0) {
1483 status = MIGRATION_STATUS_FAILED;
1484 } else {
1485 status = MIGRATION_STATUS_COMPLETED;
1487 migrate_set_state(&ms->state, MIGRATION_STATUS_SETUP, status);
1489 /* f is outer parameter, it should not stay in global migration state after
1490 * this function finished */
1491 ms->to_dst_file = NULL;
1493 return ret;
1496 void qemu_savevm_live_state(QEMUFile *f)
1498 /* save QEMU_VM_SECTION_END section */
1499 qemu_savevm_state_complete_precopy(f, true, false);
1500 qemu_put_byte(f, QEMU_VM_EOF);
1503 int qemu_save_device_state(QEMUFile *f)
1505 SaveStateEntry *se;
1507 if (!migration_in_colo_state()) {
1508 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1509 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1511 cpu_synchronize_all_states();
1513 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1514 int ret;
1516 if (se->is_ram) {
1517 continue;
1519 if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1520 continue;
1522 if (se->vmsd && !vmstate_save_needed(se->vmsd, se->opaque)) {
1523 continue;
1526 save_section_header(f, se, QEMU_VM_SECTION_FULL);
1528 ret = vmstate_save(f, se, NULL);
1529 if (ret) {
1530 return ret;
1533 save_section_footer(f, se);
1536 qemu_put_byte(f, QEMU_VM_EOF);
1538 return qemu_file_get_error(f);
1541 static SaveStateEntry *find_se(const char *idstr, int instance_id)
1543 SaveStateEntry *se;
1545 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1546 if (!strcmp(se->idstr, idstr) &&
1547 (instance_id == se->instance_id ||
1548 instance_id == se->alias_id))
1549 return se;
1550 /* Migrating from an older version? */
1551 if (strstr(se->idstr, idstr) && se->compat) {
1552 if (!strcmp(se->compat->idstr, idstr) &&
1553 (instance_id == se->compat->instance_id ||
1554 instance_id == se->alias_id))
1555 return se;
1558 return NULL;
1561 enum LoadVMExitCodes {
1562 /* Allow a command to quit all layers of nested loadvm loops */
1563 LOADVM_QUIT = 1,
1566 /* ------ incoming postcopy messages ------ */
1567 /* 'advise' arrives before any transfers just to tell us that a postcopy
1568 * *might* happen - it might be skipped if precopy transferred everything
1569 * quickly.
1571 static int loadvm_postcopy_handle_advise(MigrationIncomingState *mis,
1572 uint16_t len)
1574 PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_ADVISE);
1575 uint64_t remote_pagesize_summary, local_pagesize_summary, remote_tps;
1576 Error *local_err = NULL;
1578 trace_loadvm_postcopy_handle_advise();
1579 if (ps != POSTCOPY_INCOMING_NONE) {
1580 error_report("CMD_POSTCOPY_ADVISE in wrong postcopy state (%d)", ps);
1581 return -1;
1584 switch (len) {
1585 case 0:
1586 if (migrate_postcopy_ram()) {
1587 error_report("RAM postcopy is enabled but have 0 byte advise");
1588 return -EINVAL;
1590 return 0;
1591 case 8 + 8:
1592 if (!migrate_postcopy_ram()) {
1593 error_report("RAM postcopy is disabled but have 16 byte advise");
1594 return -EINVAL;
1596 break;
1597 default:
1598 error_report("CMD_POSTCOPY_ADVISE invalid length (%d)", len);
1599 return -EINVAL;
1602 if (!postcopy_ram_supported_by_host(mis)) {
1603 postcopy_state_set(POSTCOPY_INCOMING_NONE);
1604 return -1;
1607 remote_pagesize_summary = qemu_get_be64(mis->from_src_file);
1608 local_pagesize_summary = ram_pagesize_summary();
1610 if (remote_pagesize_summary != local_pagesize_summary) {
1612 * This detects two potential causes of mismatch:
1613 * a) A mismatch in host page sizes
1614 * Some combinations of mismatch are probably possible but it gets
1615 * a bit more complicated. In particular we need to place whole
1616 * host pages on the dest at once, and we need to ensure that we
1617 * handle dirtying to make sure we never end up sending part of
1618 * a hostpage on it's own.
1619 * b) The use of different huge page sizes on source/destination
1620 * a more fine grain test is performed during RAM block migration
1621 * but this test here causes a nice early clear failure, and
1622 * also fails when passed to an older qemu that doesn't
1623 * do huge pages.
1625 error_report("Postcopy needs matching RAM page sizes (s=%" PRIx64
1626 " d=%" PRIx64 ")",
1627 remote_pagesize_summary, local_pagesize_summary);
1628 return -1;
1631 remote_tps = qemu_get_be64(mis->from_src_file);
1632 if (remote_tps != qemu_target_page_size()) {
1634 * Again, some differences could be dealt with, but for now keep it
1635 * simple.
1637 error_report("Postcopy needs matching target page sizes (s=%d d=%zd)",
1638 (int)remote_tps, qemu_target_page_size());
1639 return -1;
1642 if (postcopy_notify(POSTCOPY_NOTIFY_INBOUND_ADVISE, &local_err)) {
1643 error_report_err(local_err);
1644 return -1;
1647 if (ram_postcopy_incoming_init(mis)) {
1648 return -1;
1651 postcopy_state_set(POSTCOPY_INCOMING_ADVISE);
1653 return 0;
1656 /* After postcopy we will be told to throw some pages away since they're
1657 * dirty and will have to be demand fetched. Must happen before CPU is
1658 * started.
1659 * There can be 0..many of these messages, each encoding multiple pages.
1661 static int loadvm_postcopy_ram_handle_discard(MigrationIncomingState *mis,
1662 uint16_t len)
1664 int tmp;
1665 char ramid[256];
1666 PostcopyState ps = postcopy_state_get();
1668 trace_loadvm_postcopy_ram_handle_discard();
1670 switch (ps) {
1671 case POSTCOPY_INCOMING_ADVISE:
1672 /* 1st discard */
1673 tmp = postcopy_ram_prepare_discard(mis);
1674 if (tmp) {
1675 return tmp;
1677 break;
1679 case POSTCOPY_INCOMING_DISCARD:
1680 /* Expected state */
1681 break;
1683 default:
1684 error_report("CMD_POSTCOPY_RAM_DISCARD in wrong postcopy state (%d)",
1685 ps);
1686 return -1;
1688 /* We're expecting a
1689 * Version (0)
1690 * a RAM ID string (length byte, name, 0 term)
1691 * then at least 1 16 byte chunk
1693 if (len < (1 + 1 + 1 + 1 + 2 * 8)) {
1694 error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len);
1695 return -1;
1698 tmp = qemu_get_byte(mis->from_src_file);
1699 if (tmp != postcopy_ram_discard_version) {
1700 error_report("CMD_POSTCOPY_RAM_DISCARD invalid version (%d)", tmp);
1701 return -1;
1704 if (!qemu_get_counted_string(mis->from_src_file, ramid)) {
1705 error_report("CMD_POSTCOPY_RAM_DISCARD Failed to read RAMBlock ID");
1706 return -1;
1708 tmp = qemu_get_byte(mis->from_src_file);
1709 if (tmp != 0) {
1710 error_report("CMD_POSTCOPY_RAM_DISCARD missing nil (%d)", tmp);
1711 return -1;
1714 len -= 3 + strlen(ramid);
1715 if (len % 16) {
1716 error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len);
1717 return -1;
1719 trace_loadvm_postcopy_ram_handle_discard_header(ramid, len);
1720 while (len) {
1721 uint64_t start_addr, block_length;
1722 start_addr = qemu_get_be64(mis->from_src_file);
1723 block_length = qemu_get_be64(mis->from_src_file);
1725 len -= 16;
1726 int ret = ram_discard_range(ramid, start_addr, block_length);
1727 if (ret) {
1728 return ret;
1731 trace_loadvm_postcopy_ram_handle_discard_end();
1733 return 0;
1737 * Triggered by a postcopy_listen command; this thread takes over reading
1738 * the input stream, leaving the main thread free to carry on loading the rest
1739 * of the device state (from RAM).
1740 * (TODO:This could do with being in a postcopy file - but there again it's
1741 * just another input loop, not that postcopy specific)
1743 static void *postcopy_ram_listen_thread(void *opaque)
1745 MigrationIncomingState *mis = migration_incoming_get_current();
1746 QEMUFile *f = mis->from_src_file;
1747 int load_res;
1749 migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
1750 MIGRATION_STATUS_POSTCOPY_ACTIVE);
1751 qemu_sem_post(&mis->listen_thread_sem);
1752 trace_postcopy_ram_listen_thread_start();
1754 rcu_register_thread();
1756 * Because we're a thread and not a coroutine we can't yield
1757 * in qemu_file, and thus we must be blocking now.
1759 qemu_file_set_blocking(f, true);
1760 load_res = qemu_loadvm_state_main(f, mis);
1763 * This is tricky, but, mis->from_src_file can change after it
1764 * returns, when postcopy recovery happened. In the future, we may
1765 * want a wrapper for the QEMUFile handle.
1767 f = mis->from_src_file;
1769 /* And non-blocking again so we don't block in any cleanup */
1770 qemu_file_set_blocking(f, false);
1772 trace_postcopy_ram_listen_thread_exit();
1773 if (load_res < 0) {
1774 error_report("%s: loadvm failed: %d", __func__, load_res);
1775 qemu_file_set_error(f, load_res);
1776 migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
1777 MIGRATION_STATUS_FAILED);
1778 } else {
1780 * This looks good, but it's possible that the device loading in the
1781 * main thread hasn't finished yet, and so we might not be in 'RUN'
1782 * state yet; wait for the end of the main thread.
1784 qemu_event_wait(&mis->main_thread_load_event);
1786 postcopy_ram_incoming_cleanup(mis);
1788 if (load_res < 0) {
1790 * If something went wrong then we have a bad state so exit;
1791 * depending how far we got it might be possible at this point
1792 * to leave the guest running and fire MCEs for pages that never
1793 * arrived as a desperate recovery step.
1795 rcu_unregister_thread();
1796 exit(EXIT_FAILURE);
1799 migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
1800 MIGRATION_STATUS_COMPLETED);
1802 * If everything has worked fine, then the main thread has waited
1803 * for us to start, and we're the last use of the mis.
1804 * (If something broke then qemu will have to exit anyway since it's
1805 * got a bad migration state).
1807 migration_incoming_state_destroy();
1808 qemu_loadvm_state_cleanup();
1810 rcu_unregister_thread();
1811 mis->have_listen_thread = false;
1812 return NULL;
1815 /* After this message we must be able to immediately receive postcopy data */
1816 static int loadvm_postcopy_handle_listen(MigrationIncomingState *mis)
1818 PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_LISTENING);
1819 trace_loadvm_postcopy_handle_listen();
1820 Error *local_err = NULL;
1822 if (ps != POSTCOPY_INCOMING_ADVISE && ps != POSTCOPY_INCOMING_DISCARD) {
1823 error_report("CMD_POSTCOPY_LISTEN in wrong postcopy state (%d)", ps);
1824 return -1;
1826 if (ps == POSTCOPY_INCOMING_ADVISE) {
1828 * A rare case, we entered listen without having to do any discards,
1829 * so do the setup that's normally done at the time of the 1st discard.
1831 if (migrate_postcopy_ram()) {
1832 postcopy_ram_prepare_discard(mis);
1837 * Sensitise RAM - can now generate requests for blocks that don't exist
1838 * However, at this point the CPU shouldn't be running, and the IO
1839 * shouldn't be doing anything yet so don't actually expect requests
1841 if (migrate_postcopy_ram()) {
1842 if (postcopy_ram_enable_notify(mis)) {
1843 postcopy_ram_incoming_cleanup(mis);
1844 return -1;
1848 if (postcopy_notify(POSTCOPY_NOTIFY_INBOUND_LISTEN, &local_err)) {
1849 error_report_err(local_err);
1850 return -1;
1853 if (mis->have_listen_thread) {
1854 error_report("CMD_POSTCOPY_RAM_LISTEN already has a listen thread");
1855 return -1;
1858 mis->have_listen_thread = true;
1859 /* Start up the listening thread and wait for it to signal ready */
1860 qemu_sem_init(&mis->listen_thread_sem, 0);
1861 qemu_thread_create(&mis->listen_thread, "postcopy/listen",
1862 postcopy_ram_listen_thread, NULL,
1863 QEMU_THREAD_DETACHED);
1864 qemu_sem_wait(&mis->listen_thread_sem);
1865 qemu_sem_destroy(&mis->listen_thread_sem);
1867 return 0;
1871 typedef struct {
1872 QEMUBH *bh;
1873 } HandleRunBhData;
1875 static void loadvm_postcopy_handle_run_bh(void *opaque)
1877 Error *local_err = NULL;
1878 HandleRunBhData *data = opaque;
1879 MigrationIncomingState *mis = migration_incoming_get_current();
1881 /* TODO we should move all of this lot into postcopy_ram.c or a shared code
1882 * in migration.c
1884 cpu_synchronize_all_post_init();
1886 qemu_announce_self(&mis->announce_timer, migrate_announce_params());
1888 /* Make sure all file formats flush their mutable metadata.
1889 * If we get an error here, just don't restart the VM yet. */
1890 bdrv_invalidate_cache_all(&local_err);
1891 if (local_err) {
1892 error_report_err(local_err);
1893 local_err = NULL;
1894 autostart = false;
1897 trace_loadvm_postcopy_handle_run_cpu_sync();
1899 trace_loadvm_postcopy_handle_run_vmstart();
1901 dirty_bitmap_mig_before_vm_start();
1903 if (autostart) {
1904 /* Hold onto your hats, starting the CPU */
1905 vm_start();
1906 } else {
1907 /* leave it paused and let management decide when to start the CPU */
1908 runstate_set(RUN_STATE_PAUSED);
1911 qemu_bh_delete(data->bh);
1912 g_free(data);
1915 /* After all discards we can start running and asking for pages */
1916 static int loadvm_postcopy_handle_run(MigrationIncomingState *mis)
1918 PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_RUNNING);
1919 HandleRunBhData *data;
1921 trace_loadvm_postcopy_handle_run();
1922 if (ps != POSTCOPY_INCOMING_LISTENING) {
1923 error_report("CMD_POSTCOPY_RUN in wrong postcopy state (%d)", ps);
1924 return -1;
1927 data = g_new(HandleRunBhData, 1);
1928 data->bh = qemu_bh_new(loadvm_postcopy_handle_run_bh, data);
1929 qemu_bh_schedule(data->bh);
1931 /* We need to finish reading the stream from the package
1932 * and also stop reading anything more from the stream that loaded the
1933 * package (since it's now being read by the listener thread).
1934 * LOADVM_QUIT will quit all the layers of nested loadvm loops.
1936 return LOADVM_QUIT;
1939 static int loadvm_postcopy_handle_resume(MigrationIncomingState *mis)
1941 if (mis->state != MIGRATION_STATUS_POSTCOPY_RECOVER) {
1942 error_report("%s: illegal resume received", __func__);
1943 /* Don't fail the load, only for this. */
1944 return 0;
1948 * This means source VM is ready to resume the postcopy migration.
1949 * It's time to switch state and release the fault thread to
1950 * continue service page faults.
1952 migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_RECOVER,
1953 MIGRATION_STATUS_POSTCOPY_ACTIVE);
1954 qemu_sem_post(&mis->postcopy_pause_sem_fault);
1956 trace_loadvm_postcopy_handle_resume();
1958 /* Tell source that "we are ready" */
1959 migrate_send_rp_resume_ack(mis, MIGRATION_RESUME_ACK_VALUE);
1961 return 0;
1965 * Immediately following this command is a blob of data containing an embedded
1966 * chunk of migration stream; read it and load it.
1968 * @mis: Incoming state
1969 * @length: Length of packaged data to read
1971 * Returns: Negative values on error
1974 static int loadvm_handle_cmd_packaged(MigrationIncomingState *mis)
1976 int ret;
1977 size_t length;
1978 QIOChannelBuffer *bioc;
1980 length = qemu_get_be32(mis->from_src_file);
1981 trace_loadvm_handle_cmd_packaged(length);
1983 if (length > MAX_VM_CMD_PACKAGED_SIZE) {
1984 error_report("Unreasonably large packaged state: %zu", length);
1985 return -1;
1988 bioc = qio_channel_buffer_new(length);
1989 qio_channel_set_name(QIO_CHANNEL(bioc), "migration-loadvm-buffer");
1990 ret = qemu_get_buffer(mis->from_src_file,
1991 bioc->data,
1992 length);
1993 if (ret != length) {
1994 object_unref(OBJECT(bioc));
1995 error_report("CMD_PACKAGED: Buffer receive fail ret=%d length=%zu",
1996 ret, length);
1997 return (ret < 0) ? ret : -EAGAIN;
1999 bioc->usage += length;
2000 trace_loadvm_handle_cmd_packaged_received(ret);
2002 QEMUFile *packf = qemu_fopen_channel_input(QIO_CHANNEL(bioc));
2004 ret = qemu_loadvm_state_main(packf, mis);
2005 trace_loadvm_handle_cmd_packaged_main(ret);
2006 qemu_fclose(packf);
2007 object_unref(OBJECT(bioc));
2009 return ret;
2013 * Handle request that source requests for recved_bitmap on
2014 * destination. Payload format:
2016 * len (1 byte) + ramblock_name (<255 bytes)
2018 static int loadvm_handle_recv_bitmap(MigrationIncomingState *mis,
2019 uint16_t len)
2021 QEMUFile *file = mis->from_src_file;
2022 RAMBlock *rb;
2023 char block_name[256];
2024 size_t cnt;
2026 cnt = qemu_get_counted_string(file, block_name);
2027 if (!cnt) {
2028 error_report("%s: failed to read block name", __func__);
2029 return -EINVAL;
2032 /* Validate before using the data */
2033 if (qemu_file_get_error(file)) {
2034 return qemu_file_get_error(file);
2037 if (len != cnt + 1) {
2038 error_report("%s: invalid payload length (%d)", __func__, len);
2039 return -EINVAL;
2042 rb = qemu_ram_block_by_name(block_name);
2043 if (!rb) {
2044 error_report("%s: block '%s' not found", __func__, block_name);
2045 return -EINVAL;
2048 migrate_send_rp_recv_bitmap(mis, block_name);
2050 trace_loadvm_handle_recv_bitmap(block_name);
2052 return 0;
2055 static int loadvm_process_enable_colo(MigrationIncomingState *mis)
2057 migration_incoming_enable_colo();
2058 return colo_init_ram_cache();
2062 * Process an incoming 'QEMU_VM_COMMAND'
2063 * 0 just a normal return
2064 * LOADVM_QUIT All good, but exit the loop
2065 * <0 Error
2067 static int loadvm_process_command(QEMUFile *f)
2069 MigrationIncomingState *mis = migration_incoming_get_current();
2070 uint16_t cmd;
2071 uint16_t len;
2072 uint32_t tmp32;
2074 cmd = qemu_get_be16(f);
2075 len = qemu_get_be16(f);
2077 /* Check validity before continue processing of cmds */
2078 if (qemu_file_get_error(f)) {
2079 return qemu_file_get_error(f);
2082 trace_loadvm_process_command(cmd, len);
2083 if (cmd >= MIG_CMD_MAX || cmd == MIG_CMD_INVALID) {
2084 error_report("MIG_CMD 0x%x unknown (len 0x%x)", cmd, len);
2085 return -EINVAL;
2088 if (mig_cmd_args[cmd].len != -1 && mig_cmd_args[cmd].len != len) {
2089 error_report("%s received with bad length - expecting %zu, got %d",
2090 mig_cmd_args[cmd].name,
2091 (size_t)mig_cmd_args[cmd].len, len);
2092 return -ERANGE;
2095 switch (cmd) {
2096 case MIG_CMD_OPEN_RETURN_PATH:
2097 if (mis->to_src_file) {
2098 error_report("CMD_OPEN_RETURN_PATH called when RP already open");
2099 /* Not really a problem, so don't give up */
2100 return 0;
2102 mis->to_src_file = qemu_file_get_return_path(f);
2103 if (!mis->to_src_file) {
2104 error_report("CMD_OPEN_RETURN_PATH failed");
2105 return -1;
2107 break;
2109 case MIG_CMD_PING:
2110 tmp32 = qemu_get_be32(f);
2111 trace_loadvm_process_command_ping(tmp32);
2112 if (!mis->to_src_file) {
2113 error_report("CMD_PING (0x%x) received with no return path",
2114 tmp32);
2115 return -1;
2117 migrate_send_rp_pong(mis, tmp32);
2118 break;
2120 case MIG_CMD_PACKAGED:
2121 return loadvm_handle_cmd_packaged(mis);
2123 case MIG_CMD_POSTCOPY_ADVISE:
2124 return loadvm_postcopy_handle_advise(mis, len);
2126 case MIG_CMD_POSTCOPY_LISTEN:
2127 return loadvm_postcopy_handle_listen(mis);
2129 case MIG_CMD_POSTCOPY_RUN:
2130 return loadvm_postcopy_handle_run(mis);
2132 case MIG_CMD_POSTCOPY_RAM_DISCARD:
2133 return loadvm_postcopy_ram_handle_discard(mis, len);
2135 case MIG_CMD_POSTCOPY_RESUME:
2136 return loadvm_postcopy_handle_resume(mis);
2138 case MIG_CMD_RECV_BITMAP:
2139 return loadvm_handle_recv_bitmap(mis, len);
2141 case MIG_CMD_ENABLE_COLO:
2142 return loadvm_process_enable_colo(mis);
2145 return 0;
2149 * Read a footer off the wire and check that it matches the expected section
2151 * Returns: true if the footer was good
2152 * false if there is a problem (and calls error_report to say why)
2154 static bool check_section_footer(QEMUFile *f, SaveStateEntry *se)
2156 int ret;
2157 uint8_t read_mark;
2158 uint32_t read_section_id;
2160 if (!migrate_get_current()->send_section_footer) {
2161 /* No footer to check */
2162 return true;
2165 read_mark = qemu_get_byte(f);
2167 ret = qemu_file_get_error(f);
2168 if (ret) {
2169 error_report("%s: Read section footer failed: %d",
2170 __func__, ret);
2171 return false;
2174 if (read_mark != QEMU_VM_SECTION_FOOTER) {
2175 error_report("Missing section footer for %s", se->idstr);
2176 return false;
2179 read_section_id = qemu_get_be32(f);
2180 if (read_section_id != se->load_section_id) {
2181 error_report("Mismatched section id in footer for %s -"
2182 " read 0x%x expected 0x%x",
2183 se->idstr, read_section_id, se->load_section_id);
2184 return false;
2187 /* All good */
2188 return true;
2191 static int
2192 qemu_loadvm_section_start_full(QEMUFile *f, MigrationIncomingState *mis)
2194 uint32_t instance_id, version_id, section_id;
2195 SaveStateEntry *se;
2196 char idstr[256];
2197 int ret;
2199 /* Read section start */
2200 section_id = qemu_get_be32(f);
2201 if (!qemu_get_counted_string(f, idstr)) {
2202 error_report("Unable to read ID string for section %u",
2203 section_id);
2204 return -EINVAL;
2206 instance_id = qemu_get_be32(f);
2207 version_id = qemu_get_be32(f);
2209 ret = qemu_file_get_error(f);
2210 if (ret) {
2211 error_report("%s: Failed to read instance/version ID: %d",
2212 __func__, ret);
2213 return ret;
2216 trace_qemu_loadvm_state_section_startfull(section_id, idstr,
2217 instance_id, version_id);
2218 /* Find savevm section */
2219 se = find_se(idstr, instance_id);
2220 if (se == NULL) {
2221 error_report("Unknown savevm section or instance '%s' %d. "
2222 "Make sure that your current VM setup matches your "
2223 "saved VM setup, including any hotplugged devices",
2224 idstr, instance_id);
2225 return -EINVAL;
2228 /* Validate version */
2229 if (version_id > se->version_id) {
2230 error_report("savevm: unsupported version %d for '%s' v%d",
2231 version_id, idstr, se->version_id);
2232 return -EINVAL;
2234 se->load_version_id = version_id;
2235 se->load_section_id = section_id;
2237 /* Validate if it is a device's state */
2238 if (xen_enabled() && se->is_ram) {
2239 error_report("loadvm: %s RAM loading not allowed on Xen", idstr);
2240 return -EINVAL;
2243 ret = vmstate_load(f, se);
2244 if (ret < 0) {
2245 error_report("error while loading state for instance 0x%x of"
2246 " device '%s'", instance_id, idstr);
2247 return ret;
2249 if (!check_section_footer(f, se)) {
2250 return -EINVAL;
2253 return 0;
2256 static int
2257 qemu_loadvm_section_part_end(QEMUFile *f, MigrationIncomingState *mis)
2259 uint32_t section_id;
2260 SaveStateEntry *se;
2261 int ret;
2263 section_id = qemu_get_be32(f);
2265 ret = qemu_file_get_error(f);
2266 if (ret) {
2267 error_report("%s: Failed to read section ID: %d",
2268 __func__, ret);
2269 return ret;
2272 trace_qemu_loadvm_state_section_partend(section_id);
2273 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
2274 if (se->load_section_id == section_id) {
2275 break;
2278 if (se == NULL) {
2279 error_report("Unknown savevm section %d", section_id);
2280 return -EINVAL;
2283 ret = vmstate_load(f, se);
2284 if (ret < 0) {
2285 error_report("error while loading state section id %d(%s)",
2286 section_id, se->idstr);
2287 return ret;
2289 if (!check_section_footer(f, se)) {
2290 return -EINVAL;
2293 return 0;
2296 static int qemu_loadvm_state_header(QEMUFile *f)
2298 unsigned int v;
2299 int ret;
2301 v = qemu_get_be32(f);
2302 if (v != QEMU_VM_FILE_MAGIC) {
2303 error_report("Not a migration stream");
2304 return -EINVAL;
2307 v = qemu_get_be32(f);
2308 if (v == QEMU_VM_FILE_VERSION_COMPAT) {
2309 error_report("SaveVM v2 format is obsolete and don't work anymore");
2310 return -ENOTSUP;
2312 if (v != QEMU_VM_FILE_VERSION) {
2313 error_report("Unsupported migration stream version");
2314 return -ENOTSUP;
2317 if (migrate_get_current()->send_configuration) {
2318 if (qemu_get_byte(f) != QEMU_VM_CONFIGURATION) {
2319 error_report("Configuration section missing");
2320 qemu_loadvm_state_cleanup();
2321 return -EINVAL;
2323 ret = vmstate_load_state(f, &vmstate_configuration, &savevm_state, 0);
2325 if (ret) {
2326 qemu_loadvm_state_cleanup();
2327 return ret;
2330 return 0;
2333 static int qemu_loadvm_state_setup(QEMUFile *f)
2335 SaveStateEntry *se;
2336 int ret;
2338 trace_loadvm_state_setup();
2339 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
2340 if (!se->ops || !se->ops->load_setup) {
2341 continue;
2343 if (se->ops && se->ops->is_active) {
2344 if (!se->ops->is_active(se->opaque)) {
2345 continue;
2349 ret = se->ops->load_setup(f, se->opaque);
2350 if (ret < 0) {
2351 qemu_file_set_error(f, ret);
2352 error_report("Load state of device %s failed", se->idstr);
2353 return ret;
2356 return 0;
2359 void qemu_loadvm_state_cleanup(void)
2361 SaveStateEntry *se;
2363 trace_loadvm_state_cleanup();
2364 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
2365 if (se->ops && se->ops->load_cleanup) {
2366 se->ops->load_cleanup(se->opaque);
2371 /* Return true if we should continue the migration, or false. */
2372 static bool postcopy_pause_incoming(MigrationIncomingState *mis)
2374 trace_postcopy_pause_incoming();
2376 /* Clear the triggered bit to allow one recovery */
2377 mis->postcopy_recover_triggered = false;
2379 assert(mis->from_src_file);
2380 qemu_file_shutdown(mis->from_src_file);
2381 qemu_fclose(mis->from_src_file);
2382 mis->from_src_file = NULL;
2384 assert(mis->to_src_file);
2385 qemu_file_shutdown(mis->to_src_file);
2386 qemu_mutex_lock(&mis->rp_mutex);
2387 qemu_fclose(mis->to_src_file);
2388 mis->to_src_file = NULL;
2389 qemu_mutex_unlock(&mis->rp_mutex);
2391 migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
2392 MIGRATION_STATUS_POSTCOPY_PAUSED);
2394 /* Notify the fault thread for the invalidated file handle */
2395 postcopy_fault_thread_notify(mis);
2397 error_report("Detected IO failure for postcopy. "
2398 "Migration paused.");
2400 while (mis->state == MIGRATION_STATUS_POSTCOPY_PAUSED) {
2401 qemu_sem_wait(&mis->postcopy_pause_sem_dst);
2404 trace_postcopy_pause_incoming_continued();
2406 return true;
2409 int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis)
2411 uint8_t section_type;
2412 int ret = 0;
2414 retry:
2415 while (true) {
2416 section_type = qemu_get_byte(f);
2418 if (qemu_file_get_error(f)) {
2419 ret = qemu_file_get_error(f);
2420 break;
2423 trace_qemu_loadvm_state_section(section_type);
2424 switch (section_type) {
2425 case QEMU_VM_SECTION_START:
2426 case QEMU_VM_SECTION_FULL:
2427 ret = qemu_loadvm_section_start_full(f, mis);
2428 if (ret < 0) {
2429 goto out;
2431 break;
2432 case QEMU_VM_SECTION_PART:
2433 case QEMU_VM_SECTION_END:
2434 ret = qemu_loadvm_section_part_end(f, mis);
2435 if (ret < 0) {
2436 goto out;
2438 break;
2439 case QEMU_VM_COMMAND:
2440 ret = loadvm_process_command(f);
2441 trace_qemu_loadvm_state_section_command(ret);
2442 if ((ret < 0) || (ret & LOADVM_QUIT)) {
2443 goto out;
2445 break;
2446 case QEMU_VM_EOF:
2447 /* This is the end of migration */
2448 goto out;
2449 default:
2450 error_report("Unknown savevm section type %d", section_type);
2451 ret = -EINVAL;
2452 goto out;
2456 out:
2457 if (ret < 0) {
2458 qemu_file_set_error(f, ret);
2461 * If we are during an active postcopy, then we pause instead
2462 * of bail out to at least keep the VM's dirty data. Note
2463 * that POSTCOPY_INCOMING_LISTENING stage is still not enough,
2464 * during which we're still receiving device states and we
2465 * still haven't yet started the VM on destination.
2467 if (postcopy_state_get() == POSTCOPY_INCOMING_RUNNING &&
2468 postcopy_pause_incoming(mis)) {
2469 /* Reset f to point to the newly created channel */
2470 f = mis->from_src_file;
2471 goto retry;
2474 return ret;
2477 int qemu_loadvm_state(QEMUFile *f)
2479 MigrationIncomingState *mis = migration_incoming_get_current();
2480 Error *local_err = NULL;
2481 int ret;
2483 if (qemu_savevm_state_blocked(&local_err)) {
2484 error_report_err(local_err);
2485 return -EINVAL;
2488 ret = qemu_loadvm_state_header(f);
2489 if (ret) {
2490 return ret;
2493 if (qemu_loadvm_state_setup(f) != 0) {
2494 return -EINVAL;
2497 cpu_synchronize_all_pre_loadvm();
2499 ret = qemu_loadvm_state_main(f, mis);
2500 qemu_event_set(&mis->main_thread_load_event);
2502 trace_qemu_loadvm_state_post_main(ret);
2504 if (mis->have_listen_thread) {
2505 /* Listen thread still going, can't clean up yet */
2506 return ret;
2509 if (ret == 0) {
2510 ret = qemu_file_get_error(f);
2514 * Try to read in the VMDESC section as well, so that dumping tools that
2515 * intercept our migration stream have the chance to see it.
2518 /* We've got to be careful; if we don't read the data and just shut the fd
2519 * then the sender can error if we close while it's still sending.
2520 * We also mustn't read data that isn't there; some transports (RDMA)
2521 * will stall waiting for that data when the source has already closed.
2523 if (ret == 0 && should_send_vmdesc()) {
2524 uint8_t *buf;
2525 uint32_t size;
2526 uint8_t section_type = qemu_get_byte(f);
2528 if (section_type != QEMU_VM_VMDESCRIPTION) {
2529 error_report("Expected vmdescription section, but got %d",
2530 section_type);
2532 * It doesn't seem worth failing at this point since
2533 * we apparently have an otherwise valid VM state
2535 } else {
2536 buf = g_malloc(0x1000);
2537 size = qemu_get_be32(f);
2539 while (size > 0) {
2540 uint32_t read_chunk = MIN(size, 0x1000);
2541 qemu_get_buffer(f, buf, read_chunk);
2542 size -= read_chunk;
2544 g_free(buf);
2548 qemu_loadvm_state_cleanup();
2549 cpu_synchronize_all_post_init();
2551 return ret;
2554 int qemu_load_device_state(QEMUFile *f)
2556 MigrationIncomingState *mis = migration_incoming_get_current();
2557 int ret;
2559 /* Load QEMU_VM_SECTION_FULL section */
2560 ret = qemu_loadvm_state_main(f, mis);
2561 if (ret < 0) {
2562 error_report("Failed to load device state: %d", ret);
2563 return ret;
2566 cpu_synchronize_all_post_init();
2567 return 0;
2570 int save_snapshot(const char *name, Error **errp)
2572 BlockDriverState *bs, *bs1;
2573 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
2574 int ret = -1;
2575 QEMUFile *f;
2576 int saved_vm_running;
2577 uint64_t vm_state_size;
2578 qemu_timeval tv;
2579 struct tm tm;
2580 AioContext *aio_context;
2582 if (migration_is_blocked(errp)) {
2583 return ret;
2586 if (!replay_can_snapshot()) {
2587 error_setg(errp, "Record/replay does not allow making snapshot "
2588 "right now. Try once more later.");
2589 return ret;
2592 if (!bdrv_all_can_snapshot(&bs)) {
2593 error_setg(errp, "Device '%s' is writable but does not support "
2594 "snapshots", bdrv_get_device_name(bs));
2595 return ret;
2598 /* Delete old snapshots of the same name */
2599 if (name) {
2600 ret = bdrv_all_delete_snapshot(name, &bs1, errp);
2601 if (ret < 0) {
2602 error_prepend(errp, "Error while deleting snapshot on device "
2603 "'%s': ", bdrv_get_device_name(bs1));
2604 return ret;
2608 bs = bdrv_all_find_vmstate_bs();
2609 if (bs == NULL) {
2610 error_setg(errp, "No block device can accept snapshots");
2611 return ret;
2613 aio_context = bdrv_get_aio_context(bs);
2615 saved_vm_running = runstate_is_running();
2617 ret = global_state_store();
2618 if (ret) {
2619 error_setg(errp, "Error saving global state");
2620 return ret;
2622 vm_stop(RUN_STATE_SAVE_VM);
2624 bdrv_drain_all_begin();
2626 aio_context_acquire(aio_context);
2628 memset(sn, 0, sizeof(*sn));
2630 /* fill auxiliary fields */
2631 qemu_gettimeofday(&tv);
2632 sn->date_sec = tv.tv_sec;
2633 sn->date_nsec = tv.tv_usec * 1000;
2634 sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
2636 if (name) {
2637 ret = bdrv_snapshot_find(bs, old_sn, name);
2638 if (ret >= 0) {
2639 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
2640 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
2641 } else {
2642 pstrcpy(sn->name, sizeof(sn->name), name);
2644 } else {
2645 /* cast below needed for OpenBSD where tv_sec is still 'long' */
2646 localtime_r((const time_t *)&tv.tv_sec, &tm);
2647 strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
2650 /* save the VM state */
2651 f = qemu_fopen_bdrv(bs, 1);
2652 if (!f) {
2653 error_setg(errp, "Could not open VM state file");
2654 goto the_end;
2656 ret = qemu_savevm_state(f, errp);
2657 vm_state_size = qemu_ftell(f);
2658 qemu_fclose(f);
2659 if (ret < 0) {
2660 goto the_end;
2663 /* The bdrv_all_create_snapshot() call that follows acquires the AioContext
2664 * for itself. BDRV_POLL_WHILE() does not support nested locking because
2665 * it only releases the lock once. Therefore synchronous I/O will deadlock
2666 * unless we release the AioContext before bdrv_all_create_snapshot().
2668 aio_context_release(aio_context);
2669 aio_context = NULL;
2671 ret = bdrv_all_create_snapshot(sn, bs, vm_state_size, &bs);
2672 if (ret < 0) {
2673 error_setg(errp, "Error while creating snapshot on '%s'",
2674 bdrv_get_device_name(bs));
2675 goto the_end;
2678 ret = 0;
2680 the_end:
2681 if (aio_context) {
2682 aio_context_release(aio_context);
2685 bdrv_drain_all_end();
2687 if (saved_vm_running) {
2688 vm_start();
2690 return ret;
2693 void qmp_xen_save_devices_state(const char *filename, bool has_live, bool live,
2694 Error **errp)
2696 QEMUFile *f;
2697 QIOChannelFile *ioc;
2698 int saved_vm_running;
2699 int ret;
2701 if (!has_live) {
2702 /* live default to true so old version of Xen tool stack can have a
2703 * successfull live migration */
2704 live = true;
2707 saved_vm_running = runstate_is_running();
2708 vm_stop(RUN_STATE_SAVE_VM);
2709 global_state_store_running();
2711 ioc = qio_channel_file_new_path(filename, O_WRONLY | O_CREAT, 0660, errp);
2712 if (!ioc) {
2713 goto the_end;
2715 qio_channel_set_name(QIO_CHANNEL(ioc), "migration-xen-save-state");
2716 f = qemu_fopen_channel_output(QIO_CHANNEL(ioc));
2717 object_unref(OBJECT(ioc));
2718 ret = qemu_save_device_state(f);
2719 if (ret < 0 || qemu_fclose(f) < 0) {
2720 error_setg(errp, QERR_IO_ERROR);
2721 } else {
2722 /* libxl calls the QMP command "stop" before calling
2723 * "xen-save-devices-state" and in case of migration failure, libxl
2724 * would call "cont".
2725 * So call bdrv_inactivate_all (release locks) here to let the other
2726 * side of the migration take controle of the images.
2728 if (live && !saved_vm_running) {
2729 ret = bdrv_inactivate_all();
2730 if (ret) {
2731 error_setg(errp, "%s: bdrv_inactivate_all() failed (%d)",
2732 __func__, ret);
2737 the_end:
2738 if (saved_vm_running) {
2739 vm_start();
2743 void qmp_xen_load_devices_state(const char *filename, Error **errp)
2745 QEMUFile *f;
2746 QIOChannelFile *ioc;
2747 int ret;
2749 /* Guest must be paused before loading the device state; the RAM state
2750 * will already have been loaded by xc
2752 if (runstate_is_running()) {
2753 error_setg(errp, "Cannot update device state while vm is running");
2754 return;
2756 vm_stop(RUN_STATE_RESTORE_VM);
2758 ioc = qio_channel_file_new_path(filename, O_RDONLY | O_BINARY, 0, errp);
2759 if (!ioc) {
2760 return;
2762 qio_channel_set_name(QIO_CHANNEL(ioc), "migration-xen-load-state");
2763 f = qemu_fopen_channel_input(QIO_CHANNEL(ioc));
2764 object_unref(OBJECT(ioc));
2766 ret = qemu_loadvm_state(f);
2767 qemu_fclose(f);
2768 if (ret < 0) {
2769 error_setg(errp, QERR_IO_ERROR);
2771 migration_incoming_state_destroy();
2774 int load_snapshot(const char *name, Error **errp)
2776 BlockDriverState *bs, *bs_vm_state;
2777 QEMUSnapshotInfo sn;
2778 QEMUFile *f;
2779 int ret;
2780 AioContext *aio_context;
2781 MigrationIncomingState *mis = migration_incoming_get_current();
2783 if (!replay_can_snapshot()) {
2784 error_setg(errp, "Record/replay does not allow loading snapshot "
2785 "right now. Try once more later.");
2786 return -EINVAL;
2789 if (!bdrv_all_can_snapshot(&bs)) {
2790 error_setg(errp,
2791 "Device '%s' is writable but does not support snapshots",
2792 bdrv_get_device_name(bs));
2793 return -ENOTSUP;
2795 ret = bdrv_all_find_snapshot(name, &bs);
2796 if (ret < 0) {
2797 error_setg(errp,
2798 "Device '%s' does not have the requested snapshot '%s'",
2799 bdrv_get_device_name(bs), name);
2800 return ret;
2803 bs_vm_state = bdrv_all_find_vmstate_bs();
2804 if (!bs_vm_state) {
2805 error_setg(errp, "No block device supports snapshots");
2806 return -ENOTSUP;
2808 aio_context = bdrv_get_aio_context(bs_vm_state);
2810 /* Don't even try to load empty VM states */
2811 aio_context_acquire(aio_context);
2812 ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
2813 aio_context_release(aio_context);
2814 if (ret < 0) {
2815 return ret;
2816 } else if (sn.vm_state_size == 0) {
2817 error_setg(errp, "This is a disk-only snapshot. Revert to it "
2818 " offline using qemu-img");
2819 return -EINVAL;
2822 /* Flush all IO requests so they don't interfere with the new state. */
2823 bdrv_drain_all_begin();
2825 ret = bdrv_all_goto_snapshot(name, &bs, errp);
2826 if (ret < 0) {
2827 error_prepend(errp, "Could not load snapshot '%s' on '%s': ",
2828 name, bdrv_get_device_name(bs));
2829 goto err_drain;
2832 /* restore the VM state */
2833 f = qemu_fopen_bdrv(bs_vm_state, 0);
2834 if (!f) {
2835 error_setg(errp, "Could not open VM state file");
2836 ret = -EINVAL;
2837 goto err_drain;
2840 qemu_system_reset(SHUTDOWN_CAUSE_NONE);
2841 mis->from_src_file = f;
2843 aio_context_acquire(aio_context);
2844 ret = qemu_loadvm_state(f);
2845 migration_incoming_state_destroy();
2846 aio_context_release(aio_context);
2848 bdrv_drain_all_end();
2850 if (ret < 0) {
2851 error_setg(errp, "Error %d while loading VM state", ret);
2852 return ret;
2855 return 0;
2857 err_drain:
2858 bdrv_drain_all_end();
2859 return ret;
2862 void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
2864 qemu_ram_set_idstr(mr->ram_block,
2865 memory_region_name(mr), dev);
2866 qemu_ram_set_migratable(mr->ram_block);
2869 void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev)
2871 qemu_ram_unset_idstr(mr->ram_block);
2872 qemu_ram_unset_migratable(mr->ram_block);
2875 void vmstate_register_ram_global(MemoryRegion *mr)
2877 vmstate_register_ram(mr, NULL);
2880 bool vmstate_check_only_migratable(const VMStateDescription *vmsd)
2882 /* check needed if --only-migratable is specified */
2883 if (!only_migratable) {
2884 return true;
2887 return !(vmsd && vmsd->unmigratable);