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