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