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