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