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