1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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/vmstate.h"
36#include "migration/misc.h"
37#include "migration/register.h"
38#include "migration/global_state.h"
39#include "ram.h"
40#include "qemu-file-channel.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/qapi-commands-misc.h"
47#include "qapi/qmp/qerror.h"
48#include "qemu/error-report.h"
49#include "sysemu/cpus.h"
50#include "exec/memory.h"
51#include "exec/target_page.h"
52#include "trace.h"
53#include "qemu/iov.h"
54#include "qemu/main-loop.h"
55#include "block/snapshot.h"
56#include "qemu/cutils.h"
57#include "io/channel-buffer.h"
58#include "io/channel-file.h"
59#include "sysemu/replay.h"
60#include "sysemu/runstate.h"
61#include "sysemu/sysemu.h"
62#include "qjson.h"
63#include "migration/colo.h"
64#include "qemu/bitmap.h"
65#include "net/announce.h"
66
67const unsigned int postcopy_ram_discard_version = 0;
68
69
70enum qemu_vm_cmd {
71 MIG_CMD_INVALID = 0,
72 MIG_CMD_OPEN_RETURN_PATH,
73 MIG_CMD_PING,
74
75 MIG_CMD_POSTCOPY_ADVISE,
76
77 MIG_CMD_POSTCOPY_LISTEN,
78
79 MIG_CMD_POSTCOPY_RUN,
80
81 MIG_CMD_POSTCOPY_RAM_DISCARD,
82
83
84 MIG_CMD_PACKAGED,
85 MIG_CMD_ENABLE_COLO,
86 MIG_CMD_POSTCOPY_RESUME,
87 MIG_CMD_RECV_BITMAP,
88 MIG_CMD_MAX
89};
90
91#define MAX_VM_CMD_PACKAGED_SIZE UINT32_MAX
92static struct mig_cmd_args {
93 ssize_t len;
94 const char *name;
95} mig_cmd_args[] = {
96 [MIG_CMD_INVALID] = { .len = -1, .name = "INVALID" },
97 [MIG_CMD_OPEN_RETURN_PATH] = { .len = 0, .name = "OPEN_RETURN_PATH" },
98 [MIG_CMD_PING] = { .len = sizeof(uint32_t), .name = "PING" },
99 [MIG_CMD_POSTCOPY_ADVISE] = { .len = -1, .name = "POSTCOPY_ADVISE" },
100 [MIG_CMD_POSTCOPY_LISTEN] = { .len = 0, .name = "POSTCOPY_LISTEN" },
101 [MIG_CMD_POSTCOPY_RUN] = { .len = 0, .name = "POSTCOPY_RUN" },
102 [MIG_CMD_POSTCOPY_RAM_DISCARD] = {
103 .len = -1, .name = "POSTCOPY_RAM_DISCARD" },
104 [MIG_CMD_POSTCOPY_RESUME] = { .len = 0, .name = "POSTCOPY_RESUME" },
105 [MIG_CMD_PACKAGED] = { .len = 4, .name = "PACKAGED" },
106 [MIG_CMD_RECV_BITMAP] = { .len = -1, .name = "RECV_BITMAP" },
107 [MIG_CMD_MAX] = { .len = -1, .name = "MAX" },
108};
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130static ssize_t block_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
131 int64_t pos, Error **errp)
132{
133 int ret;
134 QEMUIOVector qiov;
135
136 qemu_iovec_init_external(&qiov, iov, iovcnt);
137 ret = bdrv_writev_vmstate(opaque, &qiov, pos);
138 if (ret < 0) {
139 return ret;
140 }
141
142 return qiov.size;
143}
144
145static ssize_t block_get_buffer(void *opaque, uint8_t *buf, int64_t pos,
146 size_t size, Error **errp)
147{
148 return bdrv_load_vmstate(opaque, buf, pos, size);
149}
150
151static int bdrv_fclose(void *opaque, Error **errp)
152{
153 return bdrv_flush(opaque);
154}
155
156static const QEMUFileOps bdrv_read_ops = {
157 .get_buffer = block_get_buffer,
158 .close = bdrv_fclose
159};
160
161static const QEMUFileOps bdrv_write_ops = {
162 .writev_buffer = block_writev_buffer,
163 .close = bdrv_fclose
164};
165
166static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
167{
168 if (is_writable) {
169 return qemu_fopen_ops(bs, &bdrv_write_ops);
170 }
171 return qemu_fopen_ops(bs, &bdrv_read_ops);
172}
173
174
175
176
177
178
179void timer_put(QEMUFile *f, QEMUTimer *ts)
180{
181 uint64_t expire_time;
182
183 expire_time = timer_expire_time_ns(ts);
184 qemu_put_be64(f, expire_time);
185}
186
187void timer_get(QEMUFile *f, QEMUTimer *ts)
188{
189 uint64_t expire_time;
190
191 expire_time = qemu_get_be64(f);
192 if (expire_time != -1) {
193 timer_mod_ns(ts, expire_time);
194 } else {
195 timer_del(ts);
196 }
197}
198
199
200
201
202
203
204static int get_timer(QEMUFile *f, void *pv, size_t size,
205 const VMStateField *field)
206{
207 QEMUTimer *v = pv;
208 timer_get(f, v);
209 return 0;
210}
211
212static int put_timer(QEMUFile *f, void *pv, size_t size,
213 const VMStateField *field, QJSON *vmdesc)
214{
215 QEMUTimer *v = pv;
216 timer_put(f, v);
217
218 return 0;
219}
220
221const VMStateInfo vmstate_info_timer = {
222 .name = "timer",
223 .get = get_timer,
224 .put = put_timer,
225};
226
227
228typedef struct CompatEntry {
229 char idstr[256];
230 int instance_id;
231} CompatEntry;
232
233typedef struct SaveStateEntry {
234 QTAILQ_ENTRY(SaveStateEntry) entry;
235 char idstr[256];
236 uint32_t instance_id;
237 int alias_id;
238 int version_id;
239
240 int load_version_id;
241 int section_id;
242
243 int load_section_id;
244 const SaveVMHandlers *ops;
245 const VMStateDescription *vmsd;
246 void *opaque;
247 CompatEntry *compat;
248 int is_ram;
249} SaveStateEntry;
250
251typedef struct SaveState {
252 QTAILQ_HEAD(, SaveStateEntry) handlers;
253 SaveStateEntry *handler_pri_head[MIG_PRI_MAX + 1];
254 int global_section_id;
255 uint32_t len;
256 const char *name;
257 uint32_t target_page_bits;
258 uint32_t caps_count;
259 MigrationCapability *capabilities;
260 QemuUUID uuid;
261} SaveState;
262
263static SaveState savevm_state = {
264 .handlers = QTAILQ_HEAD_INITIALIZER(savevm_state.handlers),
265 .handler_pri_head = { [MIG_PRI_DEFAULT ... MIG_PRI_MAX] = NULL },
266 .global_section_id = 0,
267};
268
269static bool should_validate_capability(int capability)
270{
271 assert(capability >= 0 && capability < MIGRATION_CAPABILITY__MAX);
272
273 switch (capability) {
274 case MIGRATION_CAPABILITY_X_IGNORE_SHARED:
275 return true;
276 default:
277 return false;
278 }
279}
280
281static uint32_t get_validatable_capabilities_count(void)
282{
283 MigrationState *s = migrate_get_current();
284 uint32_t result = 0;
285 int i;
286 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
287 if (should_validate_capability(i) && s->enabled_capabilities[i]) {
288 result++;
289 }
290 }
291 return result;
292}
293
294static int configuration_pre_save(void *opaque)
295{
296 SaveState *state = opaque;
297 const char *current_name = MACHINE_GET_CLASS(current_machine)->name;
298 MigrationState *s = migrate_get_current();
299 int i, j;
300
301 state->len = strlen(current_name);
302 state->name = current_name;
303 state->target_page_bits = qemu_target_page_bits();
304
305 state->caps_count = get_validatable_capabilities_count();
306 state->capabilities = g_renew(MigrationCapability, state->capabilities,
307 state->caps_count);
308 for (i = j = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
309 if (should_validate_capability(i) && s->enabled_capabilities[i]) {
310 state->capabilities[j++] = i;
311 }
312 }
313 state->uuid = qemu_uuid;
314
315 return 0;
316}
317
318static int configuration_pre_load(void *opaque)
319{
320 SaveState *state = opaque;
321
322
323
324
325
326 state->target_page_bits = qemu_target_page_bits_min();
327 return 0;
328}
329
330static bool configuration_validate_capabilities(SaveState *state)
331{
332 bool ret = true;
333 MigrationState *s = migrate_get_current();
334 unsigned long *source_caps_bm;
335 int i;
336
337 source_caps_bm = bitmap_new(MIGRATION_CAPABILITY__MAX);
338 for (i = 0; i < state->caps_count; i++) {
339 MigrationCapability capability = state->capabilities[i];
340 set_bit(capability, source_caps_bm);
341 }
342
343 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
344 bool source_state, target_state;
345 if (!should_validate_capability(i)) {
346 continue;
347 }
348 source_state = test_bit(i, source_caps_bm);
349 target_state = s->enabled_capabilities[i];
350 if (source_state != target_state) {
351 error_report("Capability %s is %s, but received capability is %s",
352 MigrationCapability_str(i),
353 target_state ? "on" : "off",
354 source_state ? "on" : "off");
355 ret = false;
356
357 }
358 }
359
360 g_free(source_caps_bm);
361 return ret;
362}
363
364static int configuration_post_load(void *opaque, int version_id)
365{
366 SaveState *state = opaque;
367 const char *current_name = MACHINE_GET_CLASS(current_machine)->name;
368
369 if (strncmp(state->name, current_name, state->len) != 0) {
370 error_report("Machine type received is '%.*s' and local is '%s'",
371 (int) state->len, state->name, current_name);
372 return -EINVAL;
373 }
374
375 if (state->target_page_bits != qemu_target_page_bits()) {
376 error_report("Received TARGET_PAGE_BITS is %d but local is %d",
377 state->target_page_bits, qemu_target_page_bits());
378 return -EINVAL;
379 }
380
381 if (!configuration_validate_capabilities(state)) {
382 return -EINVAL;
383 }
384
385 return 0;
386}
387
388static int get_capability(QEMUFile *f, void *pv, size_t size,
389 const VMStateField *field)
390{
391 MigrationCapability *capability = pv;
392 char capability_str[UINT8_MAX + 1];
393 uint8_t len;
394 int i;
395
396 len = qemu_get_byte(f);
397 qemu_get_buffer(f, (uint8_t *)capability_str, len);
398 capability_str[len] = '\0';
399 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
400 if (!strcmp(MigrationCapability_str(i), capability_str)) {
401 *capability = i;
402 return 0;
403 }
404 }
405 error_report("Received unknown capability %s", capability_str);
406 return -EINVAL;
407}
408
409static int put_capability(QEMUFile *f, void *pv, size_t size,
410 const VMStateField *field, QJSON *vmdesc)
411{
412 MigrationCapability *capability = pv;
413 const char *capability_str = MigrationCapability_str(*capability);
414 size_t len = strlen(capability_str);
415 assert(len <= UINT8_MAX);
416
417 qemu_put_byte(f, len);
418 qemu_put_buffer(f, (uint8_t *)capability_str, len);
419 return 0;
420}
421
422static const VMStateInfo vmstate_info_capability = {
423 .name = "capability",
424 .get = get_capability,
425 .put = put_capability,
426};
427
428
429
430
431
432
433
434
435static bool vmstate_target_page_bits_needed(void *opaque)
436{
437 return qemu_target_page_bits()
438 > qemu_target_page_bits_min();
439}
440
441static const VMStateDescription vmstate_target_page_bits = {
442 .name = "configuration/target-page-bits",
443 .version_id = 1,
444 .minimum_version_id = 1,
445 .needed = vmstate_target_page_bits_needed,
446 .fields = (VMStateField[]) {
447 VMSTATE_UINT32(target_page_bits, SaveState),
448 VMSTATE_END_OF_LIST()
449 }
450};
451
452static bool vmstate_capabilites_needed(void *opaque)
453{
454 return get_validatable_capabilities_count() > 0;
455}
456
457static const VMStateDescription vmstate_capabilites = {
458 .name = "configuration/capabilities",
459 .version_id = 1,
460 .minimum_version_id = 1,
461 .needed = vmstate_capabilites_needed,
462 .fields = (VMStateField[]) {
463 VMSTATE_UINT32_V(caps_count, SaveState, 1),
464 VMSTATE_VARRAY_UINT32_ALLOC(capabilities, SaveState, caps_count, 1,
465 vmstate_info_capability,
466 MigrationCapability),
467 VMSTATE_END_OF_LIST()
468 }
469};
470
471static bool vmstate_uuid_needed(void *opaque)
472{
473 return qemu_uuid_set && migrate_validate_uuid();
474}
475
476static int vmstate_uuid_post_load(void *opaque, int version_id)
477{
478 SaveState *state = opaque;
479 char uuid_src[UUID_FMT_LEN + 1];
480 char uuid_dst[UUID_FMT_LEN + 1];
481
482 if (!qemu_uuid_set) {
483
484
485
486
487 qemu_uuid_unparse(&state->uuid, uuid_src);
488 warn_report("UUID is received %s, but local uuid isn't set",
489 uuid_src);
490 return 0;
491 }
492 if (!qemu_uuid_is_equal(&state->uuid, &qemu_uuid)) {
493 qemu_uuid_unparse(&state->uuid, uuid_src);
494 qemu_uuid_unparse(&qemu_uuid, uuid_dst);
495 error_report("UUID received is %s and local is %s", uuid_src, uuid_dst);
496 return -EINVAL;
497 }
498 return 0;
499}
500
501static const VMStateDescription vmstate_uuid = {
502 .name = "configuration/uuid",
503 .version_id = 1,
504 .minimum_version_id = 1,
505 .needed = vmstate_uuid_needed,
506 .post_load = vmstate_uuid_post_load,
507 .fields = (VMStateField[]) {
508 VMSTATE_UINT8_ARRAY_V(uuid.data, SaveState, sizeof(QemuUUID), 1),
509 VMSTATE_END_OF_LIST()
510 }
511};
512
513static const VMStateDescription vmstate_configuration = {
514 .name = "configuration",
515 .version_id = 1,
516 .pre_load = configuration_pre_load,
517 .post_load = configuration_post_load,
518 .pre_save = configuration_pre_save,
519 .fields = (VMStateField[]) {
520 VMSTATE_UINT32(len, SaveState),
521 VMSTATE_VBUFFER_ALLOC_UINT32(name, SaveState, 0, NULL, len),
522 VMSTATE_END_OF_LIST()
523 },
524 .subsections = (const VMStateDescription*[]) {
525 &vmstate_target_page_bits,
526 &vmstate_capabilites,
527 &vmstate_uuid,
528 NULL
529 }
530};
531
532static void dump_vmstate_vmsd(FILE *out_file,
533 const VMStateDescription *vmsd, int indent,
534 bool is_subsection);
535
536static void dump_vmstate_vmsf(FILE *out_file, const VMStateField *field,
537 int indent)
538{
539 fprintf(out_file, "%*s{\n", indent, "");
540 indent += 2;
541 fprintf(out_file, "%*s\"field\": \"%s\",\n", indent, "", field->name);
542 fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
543 field->version_id);
544 fprintf(out_file, "%*s\"field_exists\": %s,\n", indent, "",
545 field->field_exists ? "true" : "false");
546 fprintf(out_file, "%*s\"size\": %zu", indent, "", field->size);
547 if (field->vmsd != NULL) {
548 fprintf(out_file, ",\n");
549 dump_vmstate_vmsd(out_file, field->vmsd, indent, false);
550 }
551 fprintf(out_file, "\n%*s}", indent - 2, "");
552}
553
554static void dump_vmstate_vmss(FILE *out_file,
555 const VMStateDescription **subsection,
556 int indent)
557{
558 if (*subsection != NULL) {
559 dump_vmstate_vmsd(out_file, *subsection, indent, true);
560 }
561}
562
563static void dump_vmstate_vmsd(FILE *out_file,
564 const VMStateDescription *vmsd, int indent,
565 bool is_subsection)
566{
567 if (is_subsection) {
568 fprintf(out_file, "%*s{\n", indent, "");
569 } else {
570 fprintf(out_file, "%*s\"%s\": {\n", indent, "", "Description");
571 }
572 indent += 2;
573 fprintf(out_file, "%*s\"name\": \"%s\",\n", indent, "", vmsd->name);
574 fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
575 vmsd->version_id);
576 fprintf(out_file, "%*s\"minimum_version_id\": %d", indent, "",
577 vmsd->minimum_version_id);
578 if (vmsd->fields != NULL) {
579 const VMStateField *field = vmsd->fields;
580 bool first;
581
582 fprintf(out_file, ",\n%*s\"Fields\": [\n", indent, "");
583 first = true;
584 while (field->name != NULL) {
585 if (field->flags & VMS_MUST_EXIST) {
586
587 field++;
588 continue;
589 }
590 if (!first) {
591 fprintf(out_file, ",\n");
592 }
593 dump_vmstate_vmsf(out_file, field, indent + 2);
594 field++;
595 first = false;
596 }
597 fprintf(out_file, "\n%*s]", indent, "");
598 }
599 if (vmsd->subsections != NULL) {
600 const VMStateDescription **subsection = vmsd->subsections;
601 bool first;
602
603 fprintf(out_file, ",\n%*s\"Subsections\": [\n", indent, "");
604 first = true;
605 while (*subsection != NULL) {
606 if (!first) {
607 fprintf(out_file, ",\n");
608 }
609 dump_vmstate_vmss(out_file, subsection, indent + 2);
610 subsection++;
611 first = false;
612 }
613 fprintf(out_file, "\n%*s]", indent, "");
614 }
615 fprintf(out_file, "\n%*s}", indent - 2, "");
616}
617
618static void dump_machine_type(FILE *out_file)
619{
620 MachineClass *mc;
621
622 mc = MACHINE_GET_CLASS(current_machine);
623
624 fprintf(out_file, " \"vmschkmachine\": {\n");
625 fprintf(out_file, " \"Name\": \"%s\"\n", mc->name);
626 fprintf(out_file, " },\n");
627}
628
629void dump_vmstate_json_to_file(FILE *out_file)
630{
631 GSList *list, *elt;
632 bool first;
633
634 fprintf(out_file, "{\n");
635 dump_machine_type(out_file);
636
637 first = true;
638 list = object_class_get_list(TYPE_DEVICE, true);
639 for (elt = list; elt; elt = elt->next) {
640 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
641 TYPE_DEVICE);
642 const char *name;
643 int indent = 2;
644
645 if (!dc->vmsd) {
646 continue;
647 }
648
649 if (!first) {
650 fprintf(out_file, ",\n");
651 }
652 name = object_class_get_name(OBJECT_CLASS(dc));
653 fprintf(out_file, "%*s\"%s\": {\n", indent, "", name);
654 indent += 2;
655 fprintf(out_file, "%*s\"Name\": \"%s\",\n", indent, "", name);
656 fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
657 dc->vmsd->version_id);
658 fprintf(out_file, "%*s\"minimum_version_id\": %d,\n", indent, "",
659 dc->vmsd->minimum_version_id);
660
661 dump_vmstate_vmsd(out_file, dc->vmsd, indent, false);
662
663 fprintf(out_file, "\n%*s}", indent - 2, "");
664 first = false;
665 }
666 fprintf(out_file, "\n}\n");
667 fclose(out_file);
668 g_slist_free(list);
669}
670
671static uint32_t calculate_new_instance_id(const char *idstr)
672{
673 SaveStateEntry *se;
674 uint32_t instance_id = 0;
675
676 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
677 if (strcmp(idstr, se->idstr) == 0
678 && instance_id <= se->instance_id) {
679 instance_id = se->instance_id + 1;
680 }
681 }
682
683 assert(instance_id != VMSTATE_INSTANCE_ID_ANY);
684 return instance_id;
685}
686
687static int calculate_compat_instance_id(const char *idstr)
688{
689 SaveStateEntry *se;
690 int instance_id = 0;
691
692 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
693 if (!se->compat) {
694 continue;
695 }
696
697 if (strcmp(idstr, se->compat->idstr) == 0
698 && instance_id <= se->compat->instance_id) {
699 instance_id = se->compat->instance_id + 1;
700 }
701 }
702 return instance_id;
703}
704
705static inline MigrationPriority save_state_priority(SaveStateEntry *se)
706{
707 if (se->vmsd) {
708 return se->vmsd->priority;
709 }
710 return MIG_PRI_DEFAULT;
711}
712
713static void savevm_state_handler_insert(SaveStateEntry *nse)
714{
715 MigrationPriority priority = save_state_priority(nse);
716 SaveStateEntry *se;
717 int i;
718
719 assert(priority <= MIG_PRI_MAX);
720
721 for (i = priority - 1; i >= 0; i--) {
722 se = savevm_state.handler_pri_head[i];
723 if (se != NULL) {
724 assert(save_state_priority(se) < priority);
725 break;
726 }
727 }
728
729 if (i >= 0) {
730 QTAILQ_INSERT_BEFORE(se, nse, entry);
731 } else {
732 QTAILQ_INSERT_TAIL(&savevm_state.handlers, nse, entry);
733 }
734
735 if (savevm_state.handler_pri_head[priority] == NULL) {
736 savevm_state.handler_pri_head[priority] = nse;
737 }
738}
739
740static void savevm_state_handler_remove(SaveStateEntry *se)
741{
742 SaveStateEntry *next;
743 MigrationPriority priority = save_state_priority(se);
744
745 if (se == savevm_state.handler_pri_head[priority]) {
746 next = QTAILQ_NEXT(se, entry);
747 if (next != NULL && save_state_priority(next) == priority) {
748 savevm_state.handler_pri_head[priority] = next;
749 } else {
750 savevm_state.handler_pri_head[priority] = NULL;
751 }
752 }
753 QTAILQ_REMOVE(&savevm_state.handlers, se, entry);
754}
755
756
757
758
759
760int register_savevm_live(const char *idstr,
761 uint32_t instance_id,
762 int version_id,
763 const SaveVMHandlers *ops,
764 void *opaque)
765{
766 SaveStateEntry *se;
767
768 se = g_new0(SaveStateEntry, 1);
769 se->version_id = version_id;
770 se->section_id = savevm_state.global_section_id++;
771 se->ops = ops;
772 se->opaque = opaque;
773 se->vmsd = NULL;
774
775 if (ops->save_setup != NULL) {
776 se->is_ram = 1;
777 }
778
779 pstrcat(se->idstr, sizeof(se->idstr), idstr);
780
781 if (instance_id == VMSTATE_INSTANCE_ID_ANY) {
782 se->instance_id = calculate_new_instance_id(se->idstr);
783 } else {
784 se->instance_id = instance_id;
785 }
786 assert(!se->compat || se->instance_id == 0);
787 savevm_state_handler_insert(se);
788 return 0;
789}
790
791void unregister_savevm(VMStateIf *obj, const char *idstr, void *opaque)
792{
793 SaveStateEntry *se, *new_se;
794 char id[256] = "";
795
796 if (obj) {
797 char *oid = vmstate_if_get_id(obj);
798 if (oid) {
799 pstrcpy(id, sizeof(id), oid);
800 pstrcat(id, sizeof(id), "/");
801 g_free(oid);
802 }
803 }
804 pstrcat(id, sizeof(id), idstr);
805
806 QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) {
807 if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
808 savevm_state_handler_remove(se);
809 g_free(se->compat);
810 g_free(se);
811 }
812 }
813}
814
815int vmstate_register_with_alias_id(VMStateIf *obj, uint32_t instance_id,
816 const VMStateDescription *vmsd,
817 void *opaque, int alias_id,
818 int required_for_version,
819 Error **errp)
820{
821 SaveStateEntry *se;
822
823
824 assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id);
825
826 se = g_new0(SaveStateEntry, 1);
827 se->version_id = vmsd->version_id;
828 se->section_id = savevm_state.global_section_id++;
829 se->opaque = opaque;
830 se->vmsd = vmsd;
831 se->alias_id = alias_id;
832
833 if (obj) {
834 char *id = vmstate_if_get_id(obj);
835 if (id) {
836 if (snprintf(se->idstr, sizeof(se->idstr), "%s/", id) >=
837 sizeof(se->idstr)) {
838 error_setg(errp, "Path too long for VMState (%s)", id);
839 g_free(id);
840 g_free(se);
841
842 return -1;
843 }
844 g_free(id);
845
846 se->compat = g_new0(CompatEntry, 1);
847 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
848 se->compat->instance_id = instance_id == VMSTATE_INSTANCE_ID_ANY ?
849 calculate_compat_instance_id(vmsd->name) : instance_id;
850 instance_id = VMSTATE_INSTANCE_ID_ANY;
851 }
852 }
853 pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);
854
855 if (instance_id == VMSTATE_INSTANCE_ID_ANY) {
856 se->instance_id = calculate_new_instance_id(se->idstr);
857 } else {
858 se->instance_id = instance_id;
859 }
860 assert(!se->compat || se->instance_id == 0);
861 savevm_state_handler_insert(se);
862 return 0;
863}
864
865void vmstate_unregister(VMStateIf *obj, const VMStateDescription *vmsd,
866 void *opaque)
867{
868 SaveStateEntry *se, *new_se;
869
870 QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) {
871 if (se->vmsd == vmsd && se->opaque == opaque) {
872 savevm_state_handler_remove(se);
873 g_free(se->compat);
874 g_free(se);
875 }
876 }
877}
878
879static int vmstate_load(QEMUFile *f, SaveStateEntry *se)
880{
881 trace_vmstate_load(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
882 if (!se->vmsd) {
883 return se->ops->load_state(f, se->opaque, se->load_version_id);
884 }
885 return vmstate_load_state(f, se->vmsd, se->opaque, se->load_version_id);
886}
887
888static void vmstate_save_old_style(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc)
889{
890 int64_t old_offset, size;
891
892 old_offset = qemu_ftell_fast(f);
893 se->ops->save_state(f, se->opaque);
894 size = qemu_ftell_fast(f) - old_offset;
895
896 if (vmdesc) {
897 json_prop_int(vmdesc, "size", size);
898 json_start_array(vmdesc, "fields");
899 json_start_object(vmdesc, NULL);
900 json_prop_str(vmdesc, "name", "data");
901 json_prop_int(vmdesc, "size", size);
902 json_prop_str(vmdesc, "type", "buffer");
903 json_end_object(vmdesc);
904 json_end_array(vmdesc);
905 }
906}
907
908static int vmstate_save(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc)
909{
910 trace_vmstate_save(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
911 if (!se->vmsd) {
912 vmstate_save_old_style(f, se, vmdesc);
913 return 0;
914 }
915 return vmstate_save_state(f, se->vmsd, se->opaque, vmdesc);
916}
917
918
919
920
921static void save_section_header(QEMUFile *f, SaveStateEntry *se,
922 uint8_t section_type)
923{
924 qemu_put_byte(f, section_type);
925 qemu_put_be32(f, se->section_id);
926
927 if (section_type == QEMU_VM_SECTION_FULL ||
928 section_type == QEMU_VM_SECTION_START) {
929
930 size_t len = strlen(se->idstr);
931 qemu_put_byte(f, len);
932 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
933
934 qemu_put_be32(f, se->instance_id);
935 qemu_put_be32(f, se->version_id);
936 }
937}
938
939
940
941
942
943static void save_section_footer(QEMUFile *f, SaveStateEntry *se)
944{
945 if (migrate_get_current()->send_section_footer) {
946 qemu_put_byte(f, QEMU_VM_SECTION_FOOTER);
947 qemu_put_be32(f, se->section_id);
948 }
949}
950
951
952
953
954
955
956
957
958
959
960static void qemu_savevm_command_send(QEMUFile *f,
961 enum qemu_vm_cmd command,
962 uint16_t len,
963 uint8_t *data)
964{
965 trace_savevm_command_send(command, len);
966 qemu_put_byte(f, QEMU_VM_COMMAND);
967 qemu_put_be16(f, (uint16_t)command);
968 qemu_put_be16(f, len);
969 qemu_put_buffer(f, data, len);
970 qemu_fflush(f);
971}
972
973void qemu_savevm_send_colo_enable(QEMUFile *f)
974{
975 trace_savevm_send_colo_enable();
976 qemu_savevm_command_send(f, MIG_CMD_ENABLE_COLO, 0, NULL);
977}
978
979void qemu_savevm_send_ping(QEMUFile *f, uint32_t value)
980{
981 uint32_t buf;
982
983 trace_savevm_send_ping(value);
984 buf = cpu_to_be32(value);
985 qemu_savevm_command_send(f, MIG_CMD_PING, sizeof(value), (uint8_t *)&buf);
986}
987
988void qemu_savevm_send_open_return_path(QEMUFile *f)
989{
990 trace_savevm_send_open_return_path();
991 qemu_savevm_command_send(f, MIG_CMD_OPEN_RETURN_PATH, 0, NULL);
992}
993
994
995
996
997
998
999
1000
1001
1002
1003int qemu_savevm_send_packaged(QEMUFile *f, const uint8_t *buf, size_t len)
1004{
1005 uint32_t tmp;
1006
1007 if (len > MAX_VM_CMD_PACKAGED_SIZE) {
1008 error_report("%s: Unreasonably large packaged state: %zu",
1009 __func__, len);
1010 return -1;
1011 }
1012
1013 tmp = cpu_to_be32(len);
1014
1015 trace_qemu_savevm_send_packaged();
1016 qemu_savevm_command_send(f, MIG_CMD_PACKAGED, 4, (uint8_t *)&tmp);
1017
1018 qemu_put_buffer(f, buf, len);
1019
1020 return 0;
1021}
1022
1023
1024void qemu_savevm_send_postcopy_advise(QEMUFile *f)
1025{
1026 if (migrate_postcopy_ram()) {
1027 uint64_t tmp[2];
1028 tmp[0] = cpu_to_be64(ram_pagesize_summary());
1029 tmp[1] = cpu_to_be64(qemu_target_page_size());
1030
1031 trace_qemu_savevm_send_postcopy_advise();
1032 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_ADVISE,
1033 16, (uint8_t *)tmp);
1034 } else {
1035 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_ADVISE, 0, NULL);
1036 }
1037}
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056void qemu_savevm_send_postcopy_ram_discard(QEMUFile *f, const char *name,
1057 uint16_t len,
1058 uint64_t *start_list,
1059 uint64_t *length_list)
1060{
1061 uint8_t *buf;
1062 uint16_t tmplen;
1063 uint16_t t;
1064 size_t name_len = strlen(name);
1065
1066 trace_qemu_savevm_send_postcopy_ram_discard(name, len);
1067 assert(name_len < 256);
1068 buf = g_malloc0(1 + 1 + name_len + 1 + (8 + 8) * len);
1069 buf[0] = postcopy_ram_discard_version;
1070 buf[1] = name_len;
1071 memcpy(buf + 2, name, name_len);
1072 tmplen = 2 + name_len;
1073 buf[tmplen++] = '\0';
1074
1075 for (t = 0; t < len; t++) {
1076 stq_be_p(buf + tmplen, start_list[t]);
1077 tmplen += 8;
1078 stq_be_p(buf + tmplen, length_list[t]);
1079 tmplen += 8;
1080 }
1081 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RAM_DISCARD, tmplen, buf);
1082 g_free(buf);
1083}
1084
1085
1086void qemu_savevm_send_postcopy_listen(QEMUFile *f)
1087{
1088 trace_savevm_send_postcopy_listen();
1089 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_LISTEN, 0, NULL);
1090}
1091
1092
1093void qemu_savevm_send_postcopy_run(QEMUFile *f)
1094{
1095 trace_savevm_send_postcopy_run();
1096 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RUN, 0, NULL);
1097}
1098
1099void qemu_savevm_send_postcopy_resume(QEMUFile *f)
1100{
1101 trace_savevm_send_postcopy_resume();
1102 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RESUME, 0, NULL);
1103}
1104
1105void qemu_savevm_send_recv_bitmap(QEMUFile *f, char *block_name)
1106{
1107 size_t len;
1108 char buf[256];
1109
1110 trace_savevm_send_recv_bitmap(block_name);
1111
1112 buf[0] = len = strlen(block_name);
1113 memcpy(buf + 1, block_name, len);
1114
1115 qemu_savevm_command_send(f, MIG_CMD_RECV_BITMAP, len + 1, (uint8_t *)buf);
1116}
1117
1118bool qemu_savevm_state_blocked(Error **errp)
1119{
1120 SaveStateEntry *se;
1121
1122 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1123 if (se->vmsd && se->vmsd->unmigratable) {
1124 error_setg(errp, "State blocked by non-migratable device '%s'",
1125 se->idstr);
1126 return true;
1127 }
1128 }
1129 return false;
1130}
1131
1132void qemu_savevm_state_header(QEMUFile *f)
1133{
1134 trace_savevm_state_header();
1135 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1136 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1137
1138 if (migrate_get_current()->send_configuration) {
1139 qemu_put_byte(f, QEMU_VM_CONFIGURATION);
1140 vmstate_save_state(f, &vmstate_configuration, &savevm_state, 0);
1141 }
1142}
1143
1144bool qemu_savevm_state_guest_unplug_pending(void)
1145{
1146 SaveStateEntry *se;
1147
1148 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1149 if (se->vmsd && se->vmsd->dev_unplug_pending &&
1150 se->vmsd->dev_unplug_pending(se->opaque)) {
1151 return true;
1152 }
1153 }
1154
1155 return false;
1156}
1157
1158void qemu_savevm_state_setup(QEMUFile *f)
1159{
1160 SaveStateEntry *se;
1161 Error *local_err = NULL;
1162 int ret;
1163
1164 trace_savevm_state_setup();
1165 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1166 if (!se->ops || !se->ops->save_setup) {
1167 continue;
1168 }
1169 if (se->ops->is_active) {
1170 if (!se->ops->is_active(se->opaque)) {
1171 continue;
1172 }
1173 }
1174 save_section_header(f, se, QEMU_VM_SECTION_START);
1175
1176 ret = se->ops->save_setup(f, se->opaque);
1177 save_section_footer(f, se);
1178 if (ret < 0) {
1179 qemu_file_set_error(f, ret);
1180 break;
1181 }
1182 }
1183
1184 if (precopy_notify(PRECOPY_NOTIFY_SETUP, &local_err)) {
1185 error_report_err(local_err);
1186 }
1187}
1188
1189int qemu_savevm_state_resume_prepare(MigrationState *s)
1190{
1191 SaveStateEntry *se;
1192 int ret;
1193
1194 trace_savevm_state_resume_prepare();
1195
1196 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1197 if (!se->ops || !se->ops->resume_prepare) {
1198 continue;
1199 }
1200 if (se->ops->is_active) {
1201 if (!se->ops->is_active(se->opaque)) {
1202 continue;
1203 }
1204 }
1205 ret = se->ops->resume_prepare(s, se->opaque);
1206 if (ret < 0) {
1207 return ret;
1208 }
1209 }
1210
1211 return 0;
1212}
1213
1214
1215
1216
1217
1218
1219
1220int qemu_savevm_state_iterate(QEMUFile *f, bool postcopy)
1221{
1222 SaveStateEntry *se;
1223 int ret = 1;
1224
1225 trace_savevm_state_iterate();
1226 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1227 if (!se->ops || !se->ops->save_live_iterate) {
1228 continue;
1229 }
1230 if (se->ops->is_active &&
1231 !se->ops->is_active(se->opaque)) {
1232 continue;
1233 }
1234 if (se->ops->is_active_iterate &&
1235 !se->ops->is_active_iterate(se->opaque)) {
1236 continue;
1237 }
1238
1239
1240
1241
1242
1243
1244 if (postcopy &&
1245 !(se->ops->has_postcopy && se->ops->has_postcopy(se->opaque))) {
1246 continue;
1247 }
1248 if (qemu_file_rate_limit(f)) {
1249 return 0;
1250 }
1251 trace_savevm_section_start(se->idstr, se->section_id);
1252
1253 save_section_header(f, se, QEMU_VM_SECTION_PART);
1254
1255 ret = se->ops->save_live_iterate(f, se->opaque);
1256 trace_savevm_section_end(se->idstr, se->section_id, ret);
1257 save_section_footer(f, se);
1258
1259 if (ret < 0) {
1260 error_report("failed to save SaveStateEntry with id(name): %d(%s)",
1261 se->section_id, se->idstr);
1262 qemu_file_set_error(f, ret);
1263 }
1264 if (ret <= 0) {
1265
1266
1267
1268
1269 break;
1270 }
1271 }
1272 return ret;
1273}
1274
1275static bool should_send_vmdesc(void)
1276{
1277 MachineState *machine = MACHINE(qdev_get_machine());
1278 bool in_postcopy = migration_in_postcopy();
1279 return !machine->suppress_vmdesc && !in_postcopy;
1280}
1281
1282
1283
1284
1285
1286
1287
1288
1289void qemu_savevm_state_complete_postcopy(QEMUFile *f)
1290{
1291 SaveStateEntry *se;
1292 int ret;
1293
1294 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1295 if (!se->ops || !se->ops->save_live_complete_postcopy) {
1296 continue;
1297 }
1298 if (se->ops->is_active) {
1299 if (!se->ops->is_active(se->opaque)) {
1300 continue;
1301 }
1302 }
1303 trace_savevm_section_start(se->idstr, se->section_id);
1304
1305 qemu_put_byte(f, QEMU_VM_SECTION_END);
1306 qemu_put_be32(f, se->section_id);
1307
1308 ret = se->ops->save_live_complete_postcopy(f, se->opaque);
1309 trace_savevm_section_end(se->idstr, se->section_id, ret);
1310 save_section_footer(f, se);
1311 if (ret < 0) {
1312 qemu_file_set_error(f, ret);
1313 return;
1314 }
1315 }
1316
1317 qemu_put_byte(f, QEMU_VM_EOF);
1318 qemu_fflush(f);
1319}
1320
1321static
1322int qemu_savevm_state_complete_precopy_iterable(QEMUFile *f, bool in_postcopy)
1323{
1324 SaveStateEntry *se;
1325 int ret;
1326
1327 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1328 if (!se->ops ||
1329 (in_postcopy && se->ops->has_postcopy &&
1330 se->ops->has_postcopy(se->opaque)) ||
1331 !se->ops->save_live_complete_precopy) {
1332 continue;
1333 }
1334
1335 if (se->ops->is_active) {
1336 if (!se->ops->is_active(se->opaque)) {
1337 continue;
1338 }
1339 }
1340 trace_savevm_section_start(se->idstr, se->section_id);
1341
1342 save_section_header(f, se, QEMU_VM_SECTION_END);
1343
1344 ret = se->ops->save_live_complete_precopy(f, se->opaque);
1345 trace_savevm_section_end(se->idstr, se->section_id, ret);
1346 save_section_footer(f, se);
1347 if (ret < 0) {
1348 qemu_file_set_error(f, ret);
1349 return -1;
1350 }
1351 }
1352
1353 return 0;
1354}
1355
1356static
1357int qemu_savevm_state_complete_precopy_non_iterable(QEMUFile *f,
1358 bool in_postcopy,
1359 bool inactivate_disks)
1360{
1361 g_autoptr(QJSON) vmdesc = NULL;
1362 int vmdesc_len;
1363 SaveStateEntry *se;
1364 int ret;
1365
1366 vmdesc = qjson_new();
1367 json_prop_int(vmdesc, "page_size", qemu_target_page_size());
1368 json_start_array(vmdesc, "devices");
1369 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1370
1371 if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1372 continue;
1373 }
1374 if (se->vmsd && !vmstate_save_needed(se->vmsd, se->opaque)) {
1375 trace_savevm_section_skip(se->idstr, se->section_id);
1376 continue;
1377 }
1378
1379 trace_savevm_section_start(se->idstr, se->section_id);
1380
1381 json_start_object(vmdesc, NULL);
1382 json_prop_str(vmdesc, "name", se->idstr);
1383 json_prop_int(vmdesc, "instance_id", se->instance_id);
1384
1385 save_section_header(f, se, QEMU_VM_SECTION_FULL);
1386 ret = vmstate_save(f, se, vmdesc);
1387 if (ret) {
1388 qemu_file_set_error(f, ret);
1389 return ret;
1390 }
1391 trace_savevm_section_end(se->idstr, se->section_id, 0);
1392 save_section_footer(f, se);
1393
1394 json_end_object(vmdesc);
1395 }
1396
1397 if (inactivate_disks) {
1398
1399
1400 ret = bdrv_inactivate_all();
1401 if (ret) {
1402 error_report("%s: bdrv_inactivate_all() failed (%d)",
1403 __func__, ret);
1404 qemu_file_set_error(f, ret);
1405 return ret;
1406 }
1407 }
1408 if (!in_postcopy) {
1409
1410 qemu_put_byte(f, QEMU_VM_EOF);
1411 }
1412
1413 json_end_array(vmdesc);
1414 qjson_finish(vmdesc);
1415 vmdesc_len = strlen(qjson_get_str(vmdesc));
1416
1417 if (should_send_vmdesc()) {
1418 qemu_put_byte(f, QEMU_VM_VMDESCRIPTION);
1419 qemu_put_be32(f, vmdesc_len);
1420 qemu_put_buffer(f, (uint8_t *)qjson_get_str(vmdesc), vmdesc_len);
1421 }
1422
1423 return 0;
1424}
1425
1426int qemu_savevm_state_complete_precopy(QEMUFile *f, bool iterable_only,
1427 bool inactivate_disks)
1428{
1429 int ret;
1430 Error *local_err = NULL;
1431 bool in_postcopy = migration_in_postcopy();
1432
1433 if (precopy_notify(PRECOPY_NOTIFY_COMPLETE, &local_err)) {
1434 error_report_err(local_err);
1435 }
1436
1437 trace_savevm_state_complete_precopy();
1438
1439 cpu_synchronize_all_states();
1440
1441 if (!in_postcopy || iterable_only) {
1442 ret = qemu_savevm_state_complete_precopy_iterable(f, in_postcopy);
1443 if (ret) {
1444 return ret;
1445 }
1446 }
1447
1448 if (iterable_only) {
1449 goto flush;
1450 }
1451
1452 ret = qemu_savevm_state_complete_precopy_non_iterable(f, in_postcopy,
1453 inactivate_disks);
1454 if (ret) {
1455 return ret;
1456 }
1457
1458flush:
1459 qemu_fflush(f);
1460 return 0;
1461}
1462
1463
1464
1465
1466
1467void qemu_savevm_state_pending(QEMUFile *f, uint64_t threshold_size,
1468 uint64_t *res_precopy_only,
1469 uint64_t *res_compatible,
1470 uint64_t *res_postcopy_only)
1471{
1472 SaveStateEntry *se;
1473
1474 *res_precopy_only = 0;
1475 *res_compatible = 0;
1476 *res_postcopy_only = 0;
1477
1478
1479 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1480 if (!se->ops || !se->ops->save_live_pending) {
1481 continue;
1482 }
1483 if (se->ops->is_active) {
1484 if (!se->ops->is_active(se->opaque)) {
1485 continue;
1486 }
1487 }
1488 se->ops->save_live_pending(f, se->opaque, threshold_size,
1489 res_precopy_only, res_compatible,
1490 res_postcopy_only);
1491 }
1492}
1493
1494void qemu_savevm_state_cleanup(void)
1495{
1496 SaveStateEntry *se;
1497 Error *local_err = NULL;
1498
1499 if (precopy_notify(PRECOPY_NOTIFY_CLEANUP, &local_err)) {
1500 error_report_err(local_err);
1501 }
1502
1503 trace_savevm_state_cleanup();
1504 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1505 if (se->ops && se->ops->save_cleanup) {
1506 se->ops->save_cleanup(se->opaque);
1507 }
1508 }
1509}
1510
1511static int qemu_savevm_state(QEMUFile *f, Error **errp)
1512{
1513 int ret;
1514 MigrationState *ms = migrate_get_current();
1515 MigrationStatus status;
1516
1517 if (migration_is_running(ms->state)) {
1518 error_setg(errp, QERR_MIGRATION_ACTIVE);
1519 return -EINVAL;
1520 }
1521
1522 if (migrate_use_block()) {
1523 error_setg(errp, "Block migration and snapshots are incompatible");
1524 return -EINVAL;
1525 }
1526
1527 migrate_init(ms);
1528 memset(&ram_counters, 0, sizeof(ram_counters));
1529 ms->to_dst_file = f;
1530
1531 qemu_mutex_unlock_iothread();
1532 qemu_savevm_state_header(f);
1533 qemu_savevm_state_setup(f);
1534 qemu_mutex_lock_iothread();
1535
1536 while (qemu_file_get_error(f) == 0) {
1537 if (qemu_savevm_state_iterate(f, false) > 0) {
1538 break;
1539 }
1540 }
1541
1542 ret = qemu_file_get_error(f);
1543 if (ret == 0) {
1544 qemu_savevm_state_complete_precopy(f, false, false);
1545 ret = qemu_file_get_error(f);
1546 }
1547 qemu_savevm_state_cleanup();
1548 if (ret != 0) {
1549 error_setg_errno(errp, -ret, "Error while writing VM state");
1550 }
1551
1552 if (ret != 0) {
1553 status = MIGRATION_STATUS_FAILED;
1554 } else {
1555 status = MIGRATION_STATUS_COMPLETED;
1556 }
1557 migrate_set_state(&ms->state, MIGRATION_STATUS_SETUP, status);
1558
1559
1560
1561 ms->to_dst_file = NULL;
1562
1563 return ret;
1564}
1565
1566void qemu_savevm_live_state(QEMUFile *f)
1567{
1568
1569 qemu_savevm_state_complete_precopy(f, true, false);
1570 qemu_put_byte(f, QEMU_VM_EOF);
1571}
1572
1573int qemu_save_device_state(QEMUFile *f)
1574{
1575 SaveStateEntry *se;
1576
1577 if (!migration_in_colo_state()) {
1578 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1579 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1580 }
1581 cpu_synchronize_all_states();
1582
1583 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1584 int ret;
1585
1586 if (se->is_ram) {
1587 continue;
1588 }
1589 if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1590 continue;
1591 }
1592 if (se->vmsd && !vmstate_save_needed(se->vmsd, se->opaque)) {
1593 continue;
1594 }
1595
1596 save_section_header(f, se, QEMU_VM_SECTION_FULL);
1597
1598 ret = vmstate_save(f, se, NULL);
1599 if (ret) {
1600 return ret;
1601 }
1602
1603 save_section_footer(f, se);
1604 }
1605
1606 qemu_put_byte(f, QEMU_VM_EOF);
1607
1608 return qemu_file_get_error(f);
1609}
1610
1611static SaveStateEntry *find_se(const char *idstr, uint32_t instance_id)
1612{
1613 SaveStateEntry *se;
1614
1615 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1616 if (!strcmp(se->idstr, idstr) &&
1617 (instance_id == se->instance_id ||
1618 instance_id == se->alias_id))
1619 return se;
1620
1621 if (strstr(se->idstr, idstr) && se->compat) {
1622 if (!strcmp(se->compat->idstr, idstr) &&
1623 (instance_id == se->compat->instance_id ||
1624 instance_id == se->alias_id))
1625 return se;
1626 }
1627 }
1628 return NULL;
1629}
1630
1631enum LoadVMExitCodes {
1632
1633 LOADVM_QUIT = 1,
1634};
1635
1636
1637
1638
1639
1640
1641static int loadvm_postcopy_handle_advise(MigrationIncomingState *mis,
1642 uint16_t len)
1643{
1644 PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_ADVISE);
1645 uint64_t remote_pagesize_summary, local_pagesize_summary, remote_tps;
1646 Error *local_err = NULL;
1647
1648 trace_loadvm_postcopy_handle_advise();
1649 if (ps != POSTCOPY_INCOMING_NONE) {
1650 error_report("CMD_POSTCOPY_ADVISE in wrong postcopy state (%d)", ps);
1651 return -1;
1652 }
1653
1654 switch (len) {
1655 case 0:
1656 if (migrate_postcopy_ram()) {
1657 error_report("RAM postcopy is enabled but have 0 byte advise");
1658 return -EINVAL;
1659 }
1660 return 0;
1661 case 8 + 8:
1662 if (!migrate_postcopy_ram()) {
1663 error_report("RAM postcopy is disabled but have 16 byte advise");
1664 return -EINVAL;
1665 }
1666 break;
1667 default:
1668 error_report("CMD_POSTCOPY_ADVISE invalid length (%d)", len);
1669 return -EINVAL;
1670 }
1671
1672 if (!postcopy_ram_supported_by_host(mis)) {
1673 postcopy_state_set(POSTCOPY_INCOMING_NONE);
1674 return -1;
1675 }
1676
1677 remote_pagesize_summary = qemu_get_be64(mis->from_src_file);
1678 local_pagesize_summary = ram_pagesize_summary();
1679
1680 if (remote_pagesize_summary != local_pagesize_summary) {
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695 error_report("Postcopy needs matching RAM page sizes (s=%" PRIx64
1696 " d=%" PRIx64 ")",
1697 remote_pagesize_summary, local_pagesize_summary);
1698 return -1;
1699 }
1700
1701 remote_tps = qemu_get_be64(mis->from_src_file);
1702 if (remote_tps != qemu_target_page_size()) {
1703
1704
1705
1706
1707 error_report("Postcopy needs matching target page sizes (s=%d d=%zd)",
1708 (int)remote_tps, qemu_target_page_size());
1709 return -1;
1710 }
1711
1712 if (postcopy_notify(POSTCOPY_NOTIFY_INBOUND_ADVISE, &local_err)) {
1713 error_report_err(local_err);
1714 return -1;
1715 }
1716
1717 if (ram_postcopy_incoming_init(mis)) {
1718 return -1;
1719 }
1720
1721 return 0;
1722}
1723
1724
1725
1726
1727
1728
1729static int loadvm_postcopy_ram_handle_discard(MigrationIncomingState *mis,
1730 uint16_t len)
1731{
1732 int tmp;
1733 char ramid[256];
1734 PostcopyState ps = postcopy_state_get();
1735
1736 trace_loadvm_postcopy_ram_handle_discard();
1737
1738 switch (ps) {
1739 case POSTCOPY_INCOMING_ADVISE:
1740
1741 tmp = postcopy_ram_prepare_discard(mis);
1742 if (tmp) {
1743 return tmp;
1744 }
1745 break;
1746
1747 case POSTCOPY_INCOMING_DISCARD:
1748
1749 break;
1750
1751 default:
1752 error_report("CMD_POSTCOPY_RAM_DISCARD in wrong postcopy state (%d)",
1753 ps);
1754 return -1;
1755 }
1756
1757
1758
1759
1760
1761 if (len < (1 + 1 + 1 + 1 + 2 * 8)) {
1762 error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len);
1763 return -1;
1764 }
1765
1766 tmp = qemu_get_byte(mis->from_src_file);
1767 if (tmp != postcopy_ram_discard_version) {
1768 error_report("CMD_POSTCOPY_RAM_DISCARD invalid version (%d)", tmp);
1769 return -1;
1770 }
1771
1772 if (!qemu_get_counted_string(mis->from_src_file, ramid)) {
1773 error_report("CMD_POSTCOPY_RAM_DISCARD Failed to read RAMBlock ID");
1774 return -1;
1775 }
1776 tmp = qemu_get_byte(mis->from_src_file);
1777 if (tmp != 0) {
1778 error_report("CMD_POSTCOPY_RAM_DISCARD missing nil (%d)", tmp);
1779 return -1;
1780 }
1781
1782 len -= 3 + strlen(ramid);
1783 if (len % 16) {
1784 error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len);
1785 return -1;
1786 }
1787 trace_loadvm_postcopy_ram_handle_discard_header(ramid, len);
1788 while (len) {
1789 uint64_t start_addr, block_length;
1790 start_addr = qemu_get_be64(mis->from_src_file);
1791 block_length = qemu_get_be64(mis->from_src_file);
1792
1793 len -= 16;
1794 int ret = ram_discard_range(ramid, start_addr, block_length);
1795 if (ret) {
1796 return ret;
1797 }
1798 }
1799 trace_loadvm_postcopy_ram_handle_discard_end();
1800
1801 return 0;
1802}
1803
1804
1805
1806
1807
1808
1809
1810
1811static void *postcopy_ram_listen_thread(void *opaque)
1812{
1813 MigrationIncomingState *mis = migration_incoming_get_current();
1814 QEMUFile *f = mis->from_src_file;
1815 int load_res;
1816
1817 migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
1818 MIGRATION_STATUS_POSTCOPY_ACTIVE);
1819 qemu_sem_post(&mis->listen_thread_sem);
1820 trace_postcopy_ram_listen_thread_start();
1821
1822 rcu_register_thread();
1823
1824
1825
1826
1827 qemu_file_set_blocking(f, true);
1828 load_res = qemu_loadvm_state_main(f, mis);
1829
1830
1831
1832
1833
1834
1835 f = mis->from_src_file;
1836
1837
1838 qemu_file_set_blocking(f, false);
1839
1840 trace_postcopy_ram_listen_thread_exit();
1841 if (load_res < 0) {
1842 error_report("%s: loadvm failed: %d", __func__, load_res);
1843 qemu_file_set_error(f, load_res);
1844 migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
1845 MIGRATION_STATUS_FAILED);
1846 } else {
1847
1848
1849
1850
1851
1852 qemu_event_wait(&mis->main_thread_load_event);
1853 }
1854 postcopy_ram_incoming_cleanup(mis);
1855
1856 if (load_res < 0) {
1857
1858
1859
1860
1861
1862
1863 rcu_unregister_thread();
1864 exit(EXIT_FAILURE);
1865 }
1866
1867 migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
1868 MIGRATION_STATUS_COMPLETED);
1869
1870
1871
1872
1873
1874
1875 migration_incoming_state_destroy();
1876 qemu_loadvm_state_cleanup();
1877
1878 rcu_unregister_thread();
1879 mis->have_listen_thread = false;
1880 postcopy_state_set(POSTCOPY_INCOMING_END);
1881
1882 return NULL;
1883}
1884
1885
1886static int loadvm_postcopy_handle_listen(MigrationIncomingState *mis)
1887{
1888 PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_LISTENING);
1889 trace_loadvm_postcopy_handle_listen();
1890 Error *local_err = NULL;
1891
1892 if (ps != POSTCOPY_INCOMING_ADVISE && ps != POSTCOPY_INCOMING_DISCARD) {
1893 error_report("CMD_POSTCOPY_LISTEN in wrong postcopy state (%d)", ps);
1894 return -1;
1895 }
1896 if (ps == POSTCOPY_INCOMING_ADVISE) {
1897
1898
1899
1900
1901 if (migrate_postcopy_ram()) {
1902 postcopy_ram_prepare_discard(mis);
1903 }
1904 }
1905
1906
1907
1908
1909
1910
1911 if (migrate_postcopy_ram()) {
1912 if (postcopy_ram_incoming_setup(mis)) {
1913 postcopy_ram_incoming_cleanup(mis);
1914 return -1;
1915 }
1916 }
1917
1918 if (postcopy_notify(POSTCOPY_NOTIFY_INBOUND_LISTEN, &local_err)) {
1919 error_report_err(local_err);
1920 return -1;
1921 }
1922
1923 mis->have_listen_thread = true;
1924
1925 qemu_sem_init(&mis->listen_thread_sem, 0);
1926 qemu_thread_create(&mis->listen_thread, "postcopy/listen",
1927 postcopy_ram_listen_thread, NULL,
1928 QEMU_THREAD_DETACHED);
1929 qemu_sem_wait(&mis->listen_thread_sem);
1930 qemu_sem_destroy(&mis->listen_thread_sem);
1931
1932 return 0;
1933}
1934
1935static void loadvm_postcopy_handle_run_bh(void *opaque)
1936{
1937 Error *local_err = NULL;
1938 MigrationIncomingState *mis = opaque;
1939
1940
1941
1942
1943 cpu_synchronize_all_post_init();
1944
1945 qemu_announce_self(&mis->announce_timer, migrate_announce_params());
1946
1947
1948
1949 bdrv_invalidate_cache_all(&local_err);
1950 if (local_err) {
1951 error_report_err(local_err);
1952 local_err = NULL;
1953 autostart = false;
1954 }
1955
1956 trace_loadvm_postcopy_handle_run_cpu_sync();
1957
1958 trace_loadvm_postcopy_handle_run_vmstart();
1959
1960 dirty_bitmap_mig_before_vm_start();
1961
1962 if (autostart) {
1963
1964 vm_start();
1965 } else {
1966
1967 runstate_set(RUN_STATE_PAUSED);
1968 }
1969
1970 qemu_bh_delete(mis->bh);
1971}
1972
1973
1974static int loadvm_postcopy_handle_run(MigrationIncomingState *mis)
1975{
1976 PostcopyState ps = postcopy_state_get();
1977
1978 trace_loadvm_postcopy_handle_run();
1979 if (ps != POSTCOPY_INCOMING_LISTENING) {
1980 error_report("CMD_POSTCOPY_RUN in wrong postcopy state (%d)", ps);
1981 return -1;
1982 }
1983
1984 postcopy_state_set(POSTCOPY_INCOMING_RUNNING);
1985 mis->bh = qemu_bh_new(loadvm_postcopy_handle_run_bh, mis);
1986 qemu_bh_schedule(mis->bh);
1987
1988
1989
1990
1991
1992
1993 return LOADVM_QUIT;
1994}
1995
1996static int loadvm_postcopy_handle_resume(MigrationIncomingState *mis)
1997{
1998 if (mis->state != MIGRATION_STATUS_POSTCOPY_RECOVER) {
1999 error_report("%s: illegal resume received", __func__);
2000
2001 return 0;
2002 }
2003
2004
2005
2006
2007
2008
2009 migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_RECOVER,
2010 MIGRATION_STATUS_POSTCOPY_ACTIVE);
2011 qemu_sem_post(&mis->postcopy_pause_sem_fault);
2012
2013 trace_loadvm_postcopy_handle_resume();
2014
2015
2016 migrate_send_rp_resume_ack(mis, MIGRATION_RESUME_ACK_VALUE);
2017
2018 return 0;
2019}
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031static int loadvm_handle_cmd_packaged(MigrationIncomingState *mis)
2032{
2033 int ret;
2034 size_t length;
2035 QIOChannelBuffer *bioc;
2036
2037 length = qemu_get_be32(mis->from_src_file);
2038 trace_loadvm_handle_cmd_packaged(length);
2039
2040 if (length > MAX_VM_CMD_PACKAGED_SIZE) {
2041 error_report("Unreasonably large packaged state: %zu", length);
2042 return -1;
2043 }
2044
2045 bioc = qio_channel_buffer_new(length);
2046 qio_channel_set_name(QIO_CHANNEL(bioc), "migration-loadvm-buffer");
2047 ret = qemu_get_buffer(mis->from_src_file,
2048 bioc->data,
2049 length);
2050 if (ret != length) {
2051 object_unref(OBJECT(bioc));
2052 error_report("CMD_PACKAGED: Buffer receive fail ret=%d length=%zu",
2053 ret, length);
2054 return (ret < 0) ? ret : -EAGAIN;
2055 }
2056 bioc->usage += length;
2057 trace_loadvm_handle_cmd_packaged_received(ret);
2058
2059 QEMUFile *packf = qemu_fopen_channel_input(QIO_CHANNEL(bioc));
2060
2061 ret = qemu_loadvm_state_main(packf, mis);
2062 trace_loadvm_handle_cmd_packaged_main(ret);
2063 qemu_fclose(packf);
2064 object_unref(OBJECT(bioc));
2065
2066 return ret;
2067}
2068
2069
2070
2071
2072
2073
2074
2075static int loadvm_handle_recv_bitmap(MigrationIncomingState *mis,
2076 uint16_t len)
2077{
2078 QEMUFile *file = mis->from_src_file;
2079 RAMBlock *rb;
2080 char block_name[256];
2081 size_t cnt;
2082
2083 cnt = qemu_get_counted_string(file, block_name);
2084 if (!cnt) {
2085 error_report("%s: failed to read block name", __func__);
2086 return -EINVAL;
2087 }
2088
2089
2090 if (qemu_file_get_error(file)) {
2091 return qemu_file_get_error(file);
2092 }
2093
2094 if (len != cnt + 1) {
2095 error_report("%s: invalid payload length (%d)", __func__, len);
2096 return -EINVAL;
2097 }
2098
2099 rb = qemu_ram_block_by_name(block_name);
2100 if (!rb) {
2101 error_report("%s: block '%s' not found", __func__, block_name);
2102 return -EINVAL;
2103 }
2104
2105 migrate_send_rp_recv_bitmap(mis, block_name);
2106
2107 trace_loadvm_handle_recv_bitmap(block_name);
2108
2109 return 0;
2110}
2111
2112static int loadvm_process_enable_colo(MigrationIncomingState *mis)
2113{
2114 migration_incoming_enable_colo();
2115 return colo_init_ram_cache();
2116}
2117
2118
2119
2120
2121
2122
2123
2124static int loadvm_process_command(QEMUFile *f)
2125{
2126 MigrationIncomingState *mis = migration_incoming_get_current();
2127 uint16_t cmd;
2128 uint16_t len;
2129 uint32_t tmp32;
2130
2131 cmd = qemu_get_be16(f);
2132 len = qemu_get_be16(f);
2133
2134
2135 if (qemu_file_get_error(f)) {
2136 return qemu_file_get_error(f);
2137 }
2138
2139 trace_loadvm_process_command(cmd, len);
2140 if (cmd >= MIG_CMD_MAX || cmd == MIG_CMD_INVALID) {
2141 error_report("MIG_CMD 0x%x unknown (len 0x%x)", cmd, len);
2142 return -EINVAL;
2143 }
2144
2145 if (mig_cmd_args[cmd].len != -1 && mig_cmd_args[cmd].len != len) {
2146 error_report("%s received with bad length - expecting %zu, got %d",
2147 mig_cmd_args[cmd].name,
2148 (size_t)mig_cmd_args[cmd].len, len);
2149 return -ERANGE;
2150 }
2151
2152 switch (cmd) {
2153 case MIG_CMD_OPEN_RETURN_PATH:
2154 if (mis->to_src_file) {
2155 error_report("CMD_OPEN_RETURN_PATH called when RP already open");
2156
2157 return 0;
2158 }
2159 mis->to_src_file = qemu_file_get_return_path(f);
2160 if (!mis->to_src_file) {
2161 error_report("CMD_OPEN_RETURN_PATH failed");
2162 return -1;
2163 }
2164 break;
2165
2166 case MIG_CMD_PING:
2167 tmp32 = qemu_get_be32(f);
2168 trace_loadvm_process_command_ping(tmp32);
2169 if (!mis->to_src_file) {
2170 error_report("CMD_PING (0x%x) received with no return path",
2171 tmp32);
2172 return -1;
2173 }
2174 migrate_send_rp_pong(mis, tmp32);
2175 break;
2176
2177 case MIG_CMD_PACKAGED:
2178 return loadvm_handle_cmd_packaged(mis);
2179
2180 case MIG_CMD_POSTCOPY_ADVISE:
2181 return loadvm_postcopy_handle_advise(mis, len);
2182
2183 case MIG_CMD_POSTCOPY_LISTEN:
2184 return loadvm_postcopy_handle_listen(mis);
2185
2186 case MIG_CMD_POSTCOPY_RUN:
2187 return loadvm_postcopy_handle_run(mis);
2188
2189 case MIG_CMD_POSTCOPY_RAM_DISCARD:
2190 return loadvm_postcopy_ram_handle_discard(mis, len);
2191
2192 case MIG_CMD_POSTCOPY_RESUME:
2193 return loadvm_postcopy_handle_resume(mis);
2194
2195 case MIG_CMD_RECV_BITMAP:
2196 return loadvm_handle_recv_bitmap(mis, len);
2197
2198 case MIG_CMD_ENABLE_COLO:
2199 return loadvm_process_enable_colo(mis);
2200 }
2201
2202 return 0;
2203}
2204
2205
2206
2207
2208
2209
2210
2211static bool check_section_footer(QEMUFile *f, SaveStateEntry *se)
2212{
2213 int ret;
2214 uint8_t read_mark;
2215 uint32_t read_section_id;
2216
2217 if (!migrate_get_current()->send_section_footer) {
2218
2219 return true;
2220 }
2221
2222 read_mark = qemu_get_byte(f);
2223
2224 ret = qemu_file_get_error(f);
2225 if (ret) {
2226 error_report("%s: Read section footer failed: %d",
2227 __func__, ret);
2228 return false;
2229 }
2230
2231 if (read_mark != QEMU_VM_SECTION_FOOTER) {
2232 error_report("Missing section footer for %s", se->idstr);
2233 return false;
2234 }
2235
2236 read_section_id = qemu_get_be32(f);
2237 if (read_section_id != se->load_section_id) {
2238 error_report("Mismatched section id in footer for %s -"
2239 " read 0x%x expected 0x%x",
2240 se->idstr, read_section_id, se->load_section_id);
2241 return false;
2242 }
2243
2244
2245 return true;
2246}
2247
2248static int
2249qemu_loadvm_section_start_full(QEMUFile *f, MigrationIncomingState *mis)
2250{
2251 uint32_t instance_id, version_id, section_id;
2252 SaveStateEntry *se;
2253 char idstr[256];
2254 int ret;
2255
2256
2257 section_id = qemu_get_be32(f);
2258 if (!qemu_get_counted_string(f, idstr)) {
2259 error_report("Unable to read ID string for section %u",
2260 section_id);
2261 return -EINVAL;
2262 }
2263 instance_id = qemu_get_be32(f);
2264 version_id = qemu_get_be32(f);
2265
2266 ret = qemu_file_get_error(f);
2267 if (ret) {
2268 error_report("%s: Failed to read instance/version ID: %d",
2269 __func__, ret);
2270 return ret;
2271 }
2272
2273 trace_qemu_loadvm_state_section_startfull(section_id, idstr,
2274 instance_id, version_id);
2275
2276 se = find_se(idstr, instance_id);
2277 if (se == NULL) {
2278 error_report("Unknown savevm section or instance '%s' %"PRIu32". "
2279 "Make sure that your current VM setup matches your "
2280 "saved VM setup, including any hotplugged devices",
2281 idstr, instance_id);
2282 return -EINVAL;
2283 }
2284
2285
2286 if (version_id > se->version_id) {
2287 error_report("savevm: unsupported version %d for '%s' v%d",
2288 version_id, idstr, se->version_id);
2289 return -EINVAL;
2290 }
2291 se->load_version_id = version_id;
2292 se->load_section_id = section_id;
2293
2294
2295 if (xen_enabled() && se->is_ram) {
2296 error_report("loadvm: %s RAM loading not allowed on Xen", idstr);
2297 return -EINVAL;
2298 }
2299
2300 ret = vmstate_load(f, se);
2301 if (ret < 0) {
2302 error_report("error while loading state for instance 0x%"PRIx32" of"
2303 " device '%s'", instance_id, idstr);
2304 return ret;
2305 }
2306 if (!check_section_footer(f, se)) {
2307 return -EINVAL;
2308 }
2309
2310 return 0;
2311}
2312
2313static int
2314qemu_loadvm_section_part_end(QEMUFile *f, MigrationIncomingState *mis)
2315{
2316 uint32_t section_id;
2317 SaveStateEntry *se;
2318 int ret;
2319
2320 section_id = qemu_get_be32(f);
2321
2322 ret = qemu_file_get_error(f);
2323 if (ret) {
2324 error_report("%s: Failed to read section ID: %d",
2325 __func__, ret);
2326 return ret;
2327 }
2328
2329 trace_qemu_loadvm_state_section_partend(section_id);
2330 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
2331 if (se->load_section_id == section_id) {
2332 break;
2333 }
2334 }
2335 if (se == NULL) {
2336 error_report("Unknown savevm section %d", section_id);
2337 return -EINVAL;
2338 }
2339
2340 ret = vmstate_load(f, se);
2341 if (ret < 0) {
2342 error_report("error while loading state section id %d(%s)",
2343 section_id, se->idstr);
2344 return ret;
2345 }
2346 if (!check_section_footer(f, se)) {
2347 return -EINVAL;
2348 }
2349
2350 return 0;
2351}
2352
2353static int qemu_loadvm_state_header(QEMUFile *f)
2354{
2355 unsigned int v;
2356 int ret;
2357
2358 v = qemu_get_be32(f);
2359 if (v != QEMU_VM_FILE_MAGIC) {
2360 error_report("Not a migration stream");
2361 return -EINVAL;
2362 }
2363
2364 v = qemu_get_be32(f);
2365 if (v == QEMU_VM_FILE_VERSION_COMPAT) {
2366 error_report("SaveVM v2 format is obsolete and don't work anymore");
2367 return -ENOTSUP;
2368 }
2369 if (v != QEMU_VM_FILE_VERSION) {
2370 error_report("Unsupported migration stream version");
2371 return -ENOTSUP;
2372 }
2373
2374 if (migrate_get_current()->send_configuration) {
2375 if (qemu_get_byte(f) != QEMU_VM_CONFIGURATION) {
2376 error_report("Configuration section missing");
2377 qemu_loadvm_state_cleanup();
2378 return -EINVAL;
2379 }
2380 ret = vmstate_load_state(f, &vmstate_configuration, &savevm_state, 0);
2381
2382 if (ret) {
2383 qemu_loadvm_state_cleanup();
2384 return ret;
2385 }
2386 }
2387 return 0;
2388}
2389
2390static int qemu_loadvm_state_setup(QEMUFile *f)
2391{
2392 SaveStateEntry *se;
2393 int ret;
2394
2395 trace_loadvm_state_setup();
2396 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
2397 if (!se->ops || !se->ops->load_setup) {
2398 continue;
2399 }
2400 if (se->ops->is_active) {
2401 if (!se->ops->is_active(se->opaque)) {
2402 continue;
2403 }
2404 }
2405
2406 ret = se->ops->load_setup(f, se->opaque);
2407 if (ret < 0) {
2408 qemu_file_set_error(f, ret);
2409 error_report("Load state of device %s failed", se->idstr);
2410 return ret;
2411 }
2412 }
2413 return 0;
2414}
2415
2416void qemu_loadvm_state_cleanup(void)
2417{
2418 SaveStateEntry *se;
2419
2420 trace_loadvm_state_cleanup();
2421 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
2422 if (se->ops && se->ops->load_cleanup) {
2423 se->ops->load_cleanup(se->opaque);
2424 }
2425 }
2426}
2427
2428
2429static bool postcopy_pause_incoming(MigrationIncomingState *mis)
2430{
2431 trace_postcopy_pause_incoming();
2432
2433
2434 mis->postcopy_recover_triggered = false;
2435
2436 assert(mis->from_src_file);
2437 qemu_file_shutdown(mis->from_src_file);
2438 qemu_fclose(mis->from_src_file);
2439 mis->from_src_file = NULL;
2440
2441 assert(mis->to_src_file);
2442 qemu_file_shutdown(mis->to_src_file);
2443 qemu_mutex_lock(&mis->rp_mutex);
2444 qemu_fclose(mis->to_src_file);
2445 mis->to_src_file = NULL;
2446 qemu_mutex_unlock(&mis->rp_mutex);
2447
2448 migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
2449 MIGRATION_STATUS_POSTCOPY_PAUSED);
2450
2451
2452 postcopy_fault_thread_notify(mis);
2453
2454 error_report("Detected IO failure for postcopy. "
2455 "Migration paused.");
2456
2457 while (mis->state == MIGRATION_STATUS_POSTCOPY_PAUSED) {
2458 qemu_sem_wait(&mis->postcopy_pause_sem_dst);
2459 }
2460
2461 trace_postcopy_pause_incoming_continued();
2462
2463 return true;
2464}
2465
2466int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis)
2467{
2468 uint8_t section_type;
2469 int ret = 0;
2470
2471retry:
2472 while (true) {
2473 section_type = qemu_get_byte(f);
2474
2475 if (qemu_file_get_error(f)) {
2476 ret = qemu_file_get_error(f);
2477 break;
2478 }
2479
2480 trace_qemu_loadvm_state_section(section_type);
2481 switch (section_type) {
2482 case QEMU_VM_SECTION_START:
2483 case QEMU_VM_SECTION_FULL:
2484 ret = qemu_loadvm_section_start_full(f, mis);
2485 if (ret < 0) {
2486 goto out;
2487 }
2488 break;
2489 case QEMU_VM_SECTION_PART:
2490 case QEMU_VM_SECTION_END:
2491 ret = qemu_loadvm_section_part_end(f, mis);
2492 if (ret < 0) {
2493 goto out;
2494 }
2495 break;
2496 case QEMU_VM_COMMAND:
2497 ret = loadvm_process_command(f);
2498 trace_qemu_loadvm_state_section_command(ret);
2499 if ((ret < 0) || (ret == LOADVM_QUIT)) {
2500 goto out;
2501 }
2502 break;
2503 case QEMU_VM_EOF:
2504
2505 goto out;
2506 default:
2507 error_report("Unknown savevm section type %d", section_type);
2508 ret = -EINVAL;
2509 goto out;
2510 }
2511 }
2512
2513out:
2514 if (ret < 0) {
2515 qemu_file_set_error(f, ret);
2516
2517
2518
2519
2520
2521
2522
2523
2524 if (postcopy_state_get() == POSTCOPY_INCOMING_RUNNING &&
2525 postcopy_pause_incoming(mis)) {
2526
2527 f = mis->from_src_file;
2528 goto retry;
2529 }
2530 }
2531 return ret;
2532}
2533
2534int qemu_loadvm_state(QEMUFile *f)
2535{
2536 MigrationIncomingState *mis = migration_incoming_get_current();
2537 Error *local_err = NULL;
2538 int ret;
2539
2540 if (qemu_savevm_state_blocked(&local_err)) {
2541 error_report_err(local_err);
2542 return -EINVAL;
2543 }
2544
2545 ret = qemu_loadvm_state_header(f);
2546 if (ret) {
2547 return ret;
2548 }
2549
2550 if (qemu_loadvm_state_setup(f) != 0) {
2551 return -EINVAL;
2552 }
2553
2554 cpu_synchronize_all_pre_loadvm();
2555
2556 ret = qemu_loadvm_state_main(f, mis);
2557 qemu_event_set(&mis->main_thread_load_event);
2558
2559 trace_qemu_loadvm_state_post_main(ret);
2560
2561 if (mis->have_listen_thread) {
2562
2563 return ret;
2564 }
2565
2566 if (ret == 0) {
2567 ret = qemu_file_get_error(f);
2568 }
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580 if (ret == 0 && should_send_vmdesc()) {
2581 uint8_t *buf;
2582 uint32_t size;
2583 uint8_t section_type = qemu_get_byte(f);
2584
2585 if (section_type != QEMU_VM_VMDESCRIPTION) {
2586 error_report("Expected vmdescription section, but got %d",
2587 section_type);
2588
2589
2590
2591
2592 } else {
2593 buf = g_malloc(0x1000);
2594 size = qemu_get_be32(f);
2595
2596 while (size > 0) {
2597 uint32_t read_chunk = MIN(size, 0x1000);
2598 qemu_get_buffer(f, buf, read_chunk);
2599 size -= read_chunk;
2600 }
2601 g_free(buf);
2602 }
2603 }
2604
2605 qemu_loadvm_state_cleanup();
2606 cpu_synchronize_all_post_init();
2607
2608 return ret;
2609}
2610
2611int qemu_load_device_state(QEMUFile *f)
2612{
2613 MigrationIncomingState *mis = migration_incoming_get_current();
2614 int ret;
2615
2616
2617 ret = qemu_loadvm_state_main(f, mis);
2618 if (ret < 0) {
2619 error_report("Failed to load device state: %d", ret);
2620 return ret;
2621 }
2622
2623 cpu_synchronize_all_post_init();
2624 return 0;
2625}
2626
2627int save_snapshot(const char *name, Error **errp)
2628{
2629 BlockDriverState *bs, *bs1;
2630 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
2631 int ret = -1;
2632 QEMUFile *f;
2633 int saved_vm_running;
2634 uint64_t vm_state_size;
2635 qemu_timeval tv;
2636 struct tm tm;
2637 AioContext *aio_context;
2638
2639 if (migration_is_blocked(errp)) {
2640 return ret;
2641 }
2642
2643 if (!replay_can_snapshot()) {
2644 error_setg(errp, "Record/replay does not allow making snapshot "
2645 "right now. Try once more later.");
2646 return ret;
2647 }
2648
2649 if (!bdrv_all_can_snapshot(&bs)) {
2650 error_setg(errp, "Device '%s' is writable but does not support "
2651 "snapshots", bdrv_get_device_name(bs));
2652 return ret;
2653 }
2654
2655
2656 if (name) {
2657 ret = bdrv_all_delete_snapshot(name, &bs1, errp);
2658 if (ret < 0) {
2659 error_prepend(errp, "Error while deleting snapshot on device "
2660 "'%s': ", bdrv_get_device_name(bs1));
2661 return ret;
2662 }
2663 }
2664
2665 bs = bdrv_all_find_vmstate_bs();
2666 if (bs == NULL) {
2667 error_setg(errp, "No block device can accept snapshots");
2668 return ret;
2669 }
2670 aio_context = bdrv_get_aio_context(bs);
2671
2672 saved_vm_running = runstate_is_running();
2673
2674 ret = global_state_store();
2675 if (ret) {
2676 error_setg(errp, "Error saving global state");
2677 return ret;
2678 }
2679 vm_stop(RUN_STATE_SAVE_VM);
2680
2681 bdrv_drain_all_begin();
2682
2683 aio_context_acquire(aio_context);
2684
2685 memset(sn, 0, sizeof(*sn));
2686
2687
2688 qemu_gettimeofday(&tv);
2689 sn->date_sec = tv.tv_sec;
2690 sn->date_nsec = tv.tv_usec * 1000;
2691 sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
2692
2693 if (name) {
2694 ret = bdrv_snapshot_find(bs, old_sn, name);
2695 if (ret >= 0) {
2696 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
2697 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
2698 } else {
2699 pstrcpy(sn->name, sizeof(sn->name), name);
2700 }
2701 } else {
2702
2703 localtime_r((const time_t *)&tv.tv_sec, &tm);
2704 strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
2705 }
2706
2707
2708 f = qemu_fopen_bdrv(bs, 1);
2709 if (!f) {
2710 error_setg(errp, "Could not open VM state file");
2711 goto the_end;
2712 }
2713 ret = qemu_savevm_state(f, errp);
2714 vm_state_size = qemu_ftell(f);
2715 qemu_fclose(f);
2716 if (ret < 0) {
2717 goto the_end;
2718 }
2719
2720
2721
2722
2723
2724
2725 aio_context_release(aio_context);
2726 aio_context = NULL;
2727
2728 ret = bdrv_all_create_snapshot(sn, bs, vm_state_size, &bs);
2729 if (ret < 0) {
2730 error_setg(errp, "Error while creating snapshot on '%s'",
2731 bdrv_get_device_name(bs));
2732 goto the_end;
2733 }
2734
2735 ret = 0;
2736
2737 the_end:
2738 if (aio_context) {
2739 aio_context_release(aio_context);
2740 }
2741
2742 bdrv_drain_all_end();
2743
2744 if (saved_vm_running) {
2745 vm_start();
2746 }
2747 return ret;
2748}
2749
2750void qmp_xen_save_devices_state(const char *filename, bool has_live, bool live,
2751 Error **errp)
2752{
2753 QEMUFile *f;
2754 QIOChannelFile *ioc;
2755 int saved_vm_running;
2756 int ret;
2757
2758 if (!has_live) {
2759
2760
2761 live = true;
2762 }
2763
2764 saved_vm_running = runstate_is_running();
2765 vm_stop(RUN_STATE_SAVE_VM);
2766 global_state_store_running();
2767
2768 ioc = qio_channel_file_new_path(filename, O_WRONLY | O_CREAT, 0660, errp);
2769 if (!ioc) {
2770 goto the_end;
2771 }
2772 qio_channel_set_name(QIO_CHANNEL(ioc), "migration-xen-save-state");
2773 f = qemu_fopen_channel_output(QIO_CHANNEL(ioc));
2774 object_unref(OBJECT(ioc));
2775 ret = qemu_save_device_state(f);
2776 if (ret < 0 || qemu_fclose(f) < 0) {
2777 error_setg(errp, QERR_IO_ERROR);
2778 } else {
2779
2780
2781
2782
2783
2784
2785 if (live && !saved_vm_running) {
2786 ret = bdrv_inactivate_all();
2787 if (ret) {
2788 error_setg(errp, "%s: bdrv_inactivate_all() failed (%d)",
2789 __func__, ret);
2790 }
2791 }
2792 }
2793
2794 the_end:
2795 if (saved_vm_running) {
2796 vm_start();
2797 }
2798}
2799
2800void qmp_xen_load_devices_state(const char *filename, Error **errp)
2801{
2802 QEMUFile *f;
2803 QIOChannelFile *ioc;
2804 int ret;
2805
2806
2807
2808
2809 if (runstate_is_running()) {
2810 error_setg(errp, "Cannot update device state while vm is running");
2811 return;
2812 }
2813 vm_stop(RUN_STATE_RESTORE_VM);
2814
2815 ioc = qio_channel_file_new_path(filename, O_RDONLY | O_BINARY, 0, errp);
2816 if (!ioc) {
2817 return;
2818 }
2819 qio_channel_set_name(QIO_CHANNEL(ioc), "migration-xen-load-state");
2820 f = qemu_fopen_channel_input(QIO_CHANNEL(ioc));
2821 object_unref(OBJECT(ioc));
2822
2823 ret = qemu_loadvm_state(f);
2824 qemu_fclose(f);
2825 if (ret < 0) {
2826 error_setg(errp, QERR_IO_ERROR);
2827 }
2828 migration_incoming_state_destroy();
2829}
2830
2831int load_snapshot(const char *name, Error **errp)
2832{
2833 BlockDriverState *bs, *bs_vm_state;
2834 QEMUSnapshotInfo sn;
2835 QEMUFile *f;
2836 int ret;
2837 AioContext *aio_context;
2838 MigrationIncomingState *mis = migration_incoming_get_current();
2839
2840 if (!replay_can_snapshot()) {
2841 error_setg(errp, "Record/replay does not allow loading snapshot "
2842 "right now. Try once more later.");
2843 return -EINVAL;
2844 }
2845
2846 if (!bdrv_all_can_snapshot(&bs)) {
2847 error_setg(errp,
2848 "Device '%s' is writable but does not support snapshots",
2849 bdrv_get_device_name(bs));
2850 return -ENOTSUP;
2851 }
2852 ret = bdrv_all_find_snapshot(name, &bs);
2853 if (ret < 0) {
2854 error_setg(errp,
2855 "Device '%s' does not have the requested snapshot '%s'",
2856 bdrv_get_device_name(bs), name);
2857 return ret;
2858 }
2859
2860 bs_vm_state = bdrv_all_find_vmstate_bs();
2861 if (!bs_vm_state) {
2862 error_setg(errp, "No block device supports snapshots");
2863 return -ENOTSUP;
2864 }
2865 aio_context = bdrv_get_aio_context(bs_vm_state);
2866
2867
2868 aio_context_acquire(aio_context);
2869 ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
2870 aio_context_release(aio_context);
2871 if (ret < 0) {
2872 return ret;
2873 } else if (sn.vm_state_size == 0) {
2874 error_setg(errp, "This is a disk-only snapshot. Revert to it "
2875 " offline using qemu-img");
2876 return -EINVAL;
2877 }
2878
2879
2880 bdrv_drain_all_begin();
2881
2882 ret = bdrv_all_goto_snapshot(name, &bs, errp);
2883 if (ret < 0) {
2884 error_prepend(errp, "Could not load snapshot '%s' on '%s': ",
2885 name, bdrv_get_device_name(bs));
2886 goto err_drain;
2887 }
2888
2889
2890 f = qemu_fopen_bdrv(bs_vm_state, 0);
2891 if (!f) {
2892 error_setg(errp, "Could not open VM state file");
2893 ret = -EINVAL;
2894 goto err_drain;
2895 }
2896
2897 qemu_system_reset(SHUTDOWN_CAUSE_NONE);
2898 mis->from_src_file = f;
2899
2900 aio_context_acquire(aio_context);
2901 ret = qemu_loadvm_state(f);
2902 migration_incoming_state_destroy();
2903 aio_context_release(aio_context);
2904
2905 bdrv_drain_all_end();
2906
2907 if (ret < 0) {
2908 error_setg(errp, "Error %d while loading VM state", ret);
2909 return ret;
2910 }
2911
2912 return 0;
2913
2914err_drain:
2915 bdrv_drain_all_end();
2916 return ret;
2917}
2918
2919void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
2920{
2921 qemu_ram_set_idstr(mr->ram_block,
2922 memory_region_name(mr), dev);
2923 qemu_ram_set_migratable(mr->ram_block);
2924}
2925
2926void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev)
2927{
2928 qemu_ram_unset_idstr(mr->ram_block);
2929 qemu_ram_unset_migratable(mr->ram_block);
2930}
2931
2932void vmstate_register_ram_global(MemoryRegion *mr)
2933{
2934 vmstate_register_ram(mr, NULL);
2935}
2936
2937bool vmstate_check_only_migratable(const VMStateDescription *vmsd)
2938{
2939
2940 if (!only_migratable) {
2941 return true;
2942 }
2943
2944 return !(vmsd && vmsd->unmigratable);
2945}
2946