migration: convert unix socket protocol to use QIOChannel
[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 "cpu.h"
31 #include "hw/boards.h"
32 #include "hw/hw.h"
33 #include "hw/qdev.h"
34 #include "net/net.h"
35 #include "monitor/monitor.h"
36 #include "sysemu/sysemu.h"
37 #include "qemu/timer.h"
38 #include "audio/audio.h"
39 #include "migration/migration.h"
40 #include "migration/postcopy-ram.h"
41 #include "qapi/qmp/qerror.h"
42 #include "qemu/error-report.h"
43 #include "qemu/sockets.h"
44 #include "qemu/queue.h"
45 #include "sysemu/cpus.h"
46 #include "exec/memory.h"
47 #include "qmp-commands.h"
48 #include "trace.h"
49 #include "qemu/bitops.h"
50 #include "qemu/iov.h"
51 #include "block/snapshot.h"
52 #include "block/qapi.h"
53 #include "qemu/cutils.h"
54 #include "io/channel-buffer.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
63 const unsigned int postcopy_ram_discard_version = 0;
64
65 static bool skip_section_footers;
66
67 static struct mig_cmd_args {
68 ssize_t len; /* -1 = variable */
69 const char *name;
70 } mig_cmd_args[] = {
71 [MIG_CMD_INVALID] = { .len = -1, .name = "INVALID" },
72 [MIG_CMD_OPEN_RETURN_PATH] = { .len = 0, .name = "OPEN_RETURN_PATH" },
73 [MIG_CMD_PING] = { .len = sizeof(uint32_t), .name = "PING" },
74 [MIG_CMD_POSTCOPY_ADVISE] = { .len = 16, .name = "POSTCOPY_ADVISE" },
75 [MIG_CMD_POSTCOPY_LISTEN] = { .len = 0, .name = "POSTCOPY_LISTEN" },
76 [MIG_CMD_POSTCOPY_RUN] = { .len = 0, .name = "POSTCOPY_RUN" },
77 [MIG_CMD_POSTCOPY_RAM_DISCARD] = {
78 .len = -1, .name = "POSTCOPY_RAM_DISCARD" },
79 [MIG_CMD_PACKAGED] = { .len = 4, .name = "PACKAGED" },
80 [MIG_CMD_MAX] = { .len = -1, .name = "MAX" },
81 };
82
83 static int announce_self_create(uint8_t *buf,
84 uint8_t *mac_addr)
85 {
86 /* Ethernet header. */
87 memset(buf, 0xff, 6); /* destination MAC addr */
88 memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
89 *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */
90
91 /* RARP header. */
92 *(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */
93 *(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */
94 *(buf + 18) = 6; /* hardware addr length (ethernet) */
95 *(buf + 19) = 4; /* protocol addr length (IPv4) */
96 *(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */
97 memcpy(buf + 22, mac_addr, 6); /* source hw addr */
98 memset(buf + 28, 0x00, 4); /* source protocol addr */
99 memcpy(buf + 32, mac_addr, 6); /* target hw addr */
100 memset(buf + 38, 0x00, 4); /* target protocol addr */
101
102 /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
103 memset(buf + 42, 0x00, 18);
104
105 return 60; /* len (FCS will be added by hardware) */
106 }
107
108 static void qemu_announce_self_iter(NICState *nic, void *opaque)
109 {
110 uint8_t buf[60];
111 int len;
112
113 trace_qemu_announce_self_iter(qemu_ether_ntoa(&nic->conf->macaddr));
114 len = announce_self_create(buf, nic->conf->macaddr.a);
115
116 qemu_send_packet_raw(qemu_get_queue(nic), buf, len);
117 }
118
119
120 static void qemu_announce_self_once(void *opaque)
121 {
122 static int count = SELF_ANNOUNCE_ROUNDS;
123 QEMUTimer *timer = *(QEMUTimer **)opaque;
124
125 qemu_foreach_nic(qemu_announce_self_iter, NULL);
126
127 if (--count) {
128 /* delay 50ms, 150ms, 250ms, ... */
129 timer_mod(timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) +
130 self_announce_delay(count));
131 } else {
132 timer_del(timer);
133 timer_free(timer);
134 }
135 }
136
137 void qemu_announce_self(void)
138 {
139 static QEMUTimer *timer;
140 timer = timer_new_ms(QEMU_CLOCK_REALTIME, qemu_announce_self_once, &timer);
141 qemu_announce_self_once(&timer);
142 }
143
144 /***********************************************************/
145 /* savevm/loadvm support */
146
147 static ssize_t block_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
148 int64_t pos)
149 {
150 int ret;
151 QEMUIOVector qiov;
152
153 qemu_iovec_init_external(&qiov, iov, iovcnt);
154 ret = bdrv_writev_vmstate(opaque, &qiov, pos);
155 if (ret < 0) {
156 return ret;
157 }
158
159 return qiov.size;
160 }
161
162 static ssize_t block_put_buffer(void *opaque, const uint8_t *buf,
163 int64_t pos, size_t size)
164 {
165 bdrv_save_vmstate(opaque, buf, pos, size);
166 return size;
167 }
168
169 static ssize_t block_get_buffer(void *opaque, uint8_t *buf, int64_t pos,
170 size_t size)
171 {
172 return bdrv_load_vmstate(opaque, buf, pos, size);
173 }
174
175 static int bdrv_fclose(void *opaque)
176 {
177 return bdrv_flush(opaque);
178 }
179
180 static const QEMUFileOps bdrv_read_ops = {
181 .get_buffer = block_get_buffer,
182 .close = bdrv_fclose
183 };
184
185 static const QEMUFileOps bdrv_write_ops = {
186 .put_buffer = block_put_buffer,
187 .writev_buffer = block_writev_buffer,
188 .close = bdrv_fclose
189 };
190
191 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
192 {
193 if (is_writable) {
194 return qemu_fopen_ops(bs, &bdrv_write_ops);
195 }
196 return qemu_fopen_ops(bs, &bdrv_read_ops);
197 }
198
199
200 /* QEMUFile timer support.
201 * Not in qemu-file.c to not add qemu-timer.c as dependency to qemu-file.c
202 */
203
204 void timer_put(QEMUFile *f, QEMUTimer *ts)
205 {
206 uint64_t expire_time;
207
208 expire_time = timer_expire_time_ns(ts);
209 qemu_put_be64(f, expire_time);
210 }
211
212 void timer_get(QEMUFile *f, QEMUTimer *ts)
213 {
214 uint64_t expire_time;
215
216 expire_time = qemu_get_be64(f);
217 if (expire_time != -1) {
218 timer_mod_ns(ts, expire_time);
219 } else {
220 timer_del(ts);
221 }
222 }
223
224
225 /* VMState timer support.
226 * Not in vmstate.c to not add qemu-timer.c as dependency to vmstate.c
227 */
228
229 static int get_timer(QEMUFile *f, void *pv, size_t size)
230 {
231 QEMUTimer *v = pv;
232 timer_get(f, v);
233 return 0;
234 }
235
236 static void put_timer(QEMUFile *f, void *pv, size_t size)
237 {
238 QEMUTimer *v = pv;
239 timer_put(f, v);
240 }
241
242 const VMStateInfo vmstate_info_timer = {
243 .name = "timer",
244 .get = get_timer,
245 .put = put_timer,
246 };
247
248
249 typedef struct CompatEntry {
250 char idstr[256];
251 int instance_id;
252 } CompatEntry;
253
254 typedef struct SaveStateEntry {
255 QTAILQ_ENTRY(SaveStateEntry) entry;
256 char idstr[256];
257 int instance_id;
258 int alias_id;
259 int version_id;
260 int section_id;
261 SaveVMHandlers *ops;
262 const VMStateDescription *vmsd;
263 void *opaque;
264 CompatEntry *compat;
265 int is_ram;
266 } SaveStateEntry;
267
268 typedef struct SaveState {
269 QTAILQ_HEAD(, SaveStateEntry) handlers;
270 int global_section_id;
271 bool skip_configuration;
272 uint32_t len;
273 const char *name;
274 } SaveState;
275
276 static SaveState savevm_state = {
277 .handlers = QTAILQ_HEAD_INITIALIZER(savevm_state.handlers),
278 .global_section_id = 0,
279 .skip_configuration = false,
280 };
281
282 void savevm_skip_configuration(void)
283 {
284 savevm_state.skip_configuration = true;
285 }
286
287
288 static void configuration_pre_save(void *opaque)
289 {
290 SaveState *state = opaque;
291 const char *current_name = MACHINE_GET_CLASS(current_machine)->name;
292
293 state->len = strlen(current_name);
294 state->name = current_name;
295 }
296
297 static int configuration_post_load(void *opaque, int version_id)
298 {
299 SaveState *state = opaque;
300 const char *current_name = MACHINE_GET_CLASS(current_machine)->name;
301
302 if (strncmp(state->name, current_name, state->len) != 0) {
303 error_report("Machine type received is '%.*s' and local is '%s'",
304 (int) state->len, state->name, current_name);
305 return -EINVAL;
306 }
307 return 0;
308 }
309
310 static const VMStateDescription vmstate_configuration = {
311 .name = "configuration",
312 .version_id = 1,
313 .post_load = configuration_post_load,
314 .pre_save = configuration_pre_save,
315 .fields = (VMStateField[]) {
316 VMSTATE_UINT32(len, SaveState),
317 VMSTATE_VBUFFER_ALLOC_UINT32(name, SaveState, 0, NULL, 0, len),
318 VMSTATE_END_OF_LIST()
319 },
320 };
321
322 static void dump_vmstate_vmsd(FILE *out_file,
323 const VMStateDescription *vmsd, int indent,
324 bool is_subsection);
325
326 static void dump_vmstate_vmsf(FILE *out_file, const VMStateField *field,
327 int indent)
328 {
329 fprintf(out_file, "%*s{\n", indent, "");
330 indent += 2;
331 fprintf(out_file, "%*s\"field\": \"%s\",\n", indent, "", field->name);
332 fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
333 field->version_id);
334 fprintf(out_file, "%*s\"field_exists\": %s,\n", indent, "",
335 field->field_exists ? "true" : "false");
336 fprintf(out_file, "%*s\"size\": %zu", indent, "", field->size);
337 if (field->vmsd != NULL) {
338 fprintf(out_file, ",\n");
339 dump_vmstate_vmsd(out_file, field->vmsd, indent, false);
340 }
341 fprintf(out_file, "\n%*s}", indent - 2, "");
342 }
343
344 static void dump_vmstate_vmss(FILE *out_file,
345 const VMStateDescription **subsection,
346 int indent)
347 {
348 if (*subsection != NULL) {
349 dump_vmstate_vmsd(out_file, *subsection, indent, true);
350 }
351 }
352
353 static void dump_vmstate_vmsd(FILE *out_file,
354 const VMStateDescription *vmsd, int indent,
355 bool is_subsection)
356 {
357 if (is_subsection) {
358 fprintf(out_file, "%*s{\n", indent, "");
359 } else {
360 fprintf(out_file, "%*s\"%s\": {\n", indent, "", "Description");
361 }
362 indent += 2;
363 fprintf(out_file, "%*s\"name\": \"%s\",\n", indent, "", vmsd->name);
364 fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
365 vmsd->version_id);
366 fprintf(out_file, "%*s\"minimum_version_id\": %d", indent, "",
367 vmsd->minimum_version_id);
368 if (vmsd->fields != NULL) {
369 const VMStateField *field = vmsd->fields;
370 bool first;
371
372 fprintf(out_file, ",\n%*s\"Fields\": [\n", indent, "");
373 first = true;
374 while (field->name != NULL) {
375 if (field->flags & VMS_MUST_EXIST) {
376 /* Ignore VMSTATE_VALIDATE bits; these don't get migrated */
377 field++;
378 continue;
379 }
380 if (!first) {
381 fprintf(out_file, ",\n");
382 }
383 dump_vmstate_vmsf(out_file, field, indent + 2);
384 field++;
385 first = false;
386 }
387 fprintf(out_file, "\n%*s]", indent, "");
388 }
389 if (vmsd->subsections != NULL) {
390 const VMStateDescription **subsection = vmsd->subsections;
391 bool first;
392
393 fprintf(out_file, ",\n%*s\"Subsections\": [\n", indent, "");
394 first = true;
395 while (*subsection != NULL) {
396 if (!first) {
397 fprintf(out_file, ",\n");
398 }
399 dump_vmstate_vmss(out_file, subsection, indent + 2);
400 subsection++;
401 first = false;
402 }
403 fprintf(out_file, "\n%*s]", indent, "");
404 }
405 fprintf(out_file, "\n%*s}", indent - 2, "");
406 }
407
408 static void dump_machine_type(FILE *out_file)
409 {
410 MachineClass *mc;
411
412 mc = MACHINE_GET_CLASS(current_machine);
413
414 fprintf(out_file, " \"vmschkmachine\": {\n");
415 fprintf(out_file, " \"Name\": \"%s\"\n", mc->name);
416 fprintf(out_file, " },\n");
417 }
418
419 void dump_vmstate_json_to_file(FILE *out_file)
420 {
421 GSList *list, *elt;
422 bool first;
423
424 fprintf(out_file, "{\n");
425 dump_machine_type(out_file);
426
427 first = true;
428 list = object_class_get_list(TYPE_DEVICE, true);
429 for (elt = list; elt; elt = elt->next) {
430 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
431 TYPE_DEVICE);
432 const char *name;
433 int indent = 2;
434
435 if (!dc->vmsd) {
436 continue;
437 }
438
439 if (!first) {
440 fprintf(out_file, ",\n");
441 }
442 name = object_class_get_name(OBJECT_CLASS(dc));
443 fprintf(out_file, "%*s\"%s\": {\n", indent, "", name);
444 indent += 2;
445 fprintf(out_file, "%*s\"Name\": \"%s\",\n", indent, "", name);
446 fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
447 dc->vmsd->version_id);
448 fprintf(out_file, "%*s\"minimum_version_id\": %d,\n", indent, "",
449 dc->vmsd->minimum_version_id);
450
451 dump_vmstate_vmsd(out_file, dc->vmsd, indent, false);
452
453 fprintf(out_file, "\n%*s}", indent - 2, "");
454 first = false;
455 }
456 fprintf(out_file, "\n}\n");
457 fclose(out_file);
458 }
459
460 static int calculate_new_instance_id(const char *idstr)
461 {
462 SaveStateEntry *se;
463 int instance_id = 0;
464
465 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
466 if (strcmp(idstr, se->idstr) == 0
467 && instance_id <= se->instance_id) {
468 instance_id = se->instance_id + 1;
469 }
470 }
471 return instance_id;
472 }
473
474 static int calculate_compat_instance_id(const char *idstr)
475 {
476 SaveStateEntry *se;
477 int instance_id = 0;
478
479 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
480 if (!se->compat) {
481 continue;
482 }
483
484 if (strcmp(idstr, se->compat->idstr) == 0
485 && instance_id <= se->compat->instance_id) {
486 instance_id = se->compat->instance_id + 1;
487 }
488 }
489 return instance_id;
490 }
491
492 /* TODO: Individual devices generally have very little idea about the rest
493 of the system, so instance_id should be removed/replaced.
494 Meanwhile pass -1 as instance_id if you do not already have a clearly
495 distinguishing id for all instances of your device class. */
496 int register_savevm_live(DeviceState *dev,
497 const char *idstr,
498 int instance_id,
499 int version_id,
500 SaveVMHandlers *ops,
501 void *opaque)
502 {
503 SaveStateEntry *se;
504
505 se = g_new0(SaveStateEntry, 1);
506 se->version_id = version_id;
507 se->section_id = savevm_state.global_section_id++;
508 se->ops = ops;
509 se->opaque = opaque;
510 se->vmsd = NULL;
511 /* if this is a live_savem then set is_ram */
512 if (ops->save_live_setup != NULL) {
513 se->is_ram = 1;
514 }
515
516 if (dev) {
517 char *id = qdev_get_dev_path(dev);
518 if (id) {
519 pstrcpy(se->idstr, sizeof(se->idstr), id);
520 pstrcat(se->idstr, sizeof(se->idstr), "/");
521 g_free(id);
522
523 se->compat = g_new0(CompatEntry, 1);
524 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr);
525 se->compat->instance_id = instance_id == -1 ?
526 calculate_compat_instance_id(idstr) : instance_id;
527 instance_id = -1;
528 }
529 }
530 pstrcat(se->idstr, sizeof(se->idstr), idstr);
531
532 if (instance_id == -1) {
533 se->instance_id = calculate_new_instance_id(se->idstr);
534 } else {
535 se->instance_id = instance_id;
536 }
537 assert(!se->compat || se->instance_id == 0);
538 /* add at the end of list */
539 QTAILQ_INSERT_TAIL(&savevm_state.handlers, se, entry);
540 return 0;
541 }
542
543 int register_savevm(DeviceState *dev,
544 const char *idstr,
545 int instance_id,
546 int version_id,
547 SaveStateHandler *save_state,
548 LoadStateHandler *load_state,
549 void *opaque)
550 {
551 SaveVMHandlers *ops = g_new0(SaveVMHandlers, 1);
552 ops->save_state = save_state;
553 ops->load_state = load_state;
554 return register_savevm_live(dev, idstr, instance_id, version_id,
555 ops, opaque);
556 }
557
558 void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
559 {
560 SaveStateEntry *se, *new_se;
561 char id[256] = "";
562
563 if (dev) {
564 char *path = qdev_get_dev_path(dev);
565 if (path) {
566 pstrcpy(id, sizeof(id), path);
567 pstrcat(id, sizeof(id), "/");
568 g_free(path);
569 }
570 }
571 pstrcat(id, sizeof(id), idstr);
572
573 QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) {
574 if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
575 QTAILQ_REMOVE(&savevm_state.handlers, se, entry);
576 g_free(se->compat);
577 g_free(se->ops);
578 g_free(se);
579 }
580 }
581 }
582
583 int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
584 const VMStateDescription *vmsd,
585 void *opaque, int alias_id,
586 int required_for_version)
587 {
588 SaveStateEntry *se;
589
590 /* If this triggers, alias support can be dropped for the vmsd. */
591 assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id);
592
593 se = g_new0(SaveStateEntry, 1);
594 se->version_id = vmsd->version_id;
595 se->section_id = savevm_state.global_section_id++;
596 se->opaque = opaque;
597 se->vmsd = vmsd;
598 se->alias_id = alias_id;
599
600 if (dev) {
601 char *id = qdev_get_dev_path(dev);
602 if (id) {
603 pstrcpy(se->idstr, sizeof(se->idstr), id);
604 pstrcat(se->idstr, sizeof(se->idstr), "/");
605 g_free(id);
606
607 se->compat = g_new0(CompatEntry, 1);
608 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
609 se->compat->instance_id = instance_id == -1 ?
610 calculate_compat_instance_id(vmsd->name) : instance_id;
611 instance_id = -1;
612 }
613 }
614 pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);
615
616 if (instance_id == -1) {
617 se->instance_id = calculate_new_instance_id(se->idstr);
618 } else {
619 se->instance_id = instance_id;
620 }
621 assert(!se->compat || se->instance_id == 0);
622 /* add at the end of list */
623 QTAILQ_INSERT_TAIL(&savevm_state.handlers, se, entry);
624 return 0;
625 }
626
627 void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
628 void *opaque)
629 {
630 SaveStateEntry *se, *new_se;
631
632 QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) {
633 if (se->vmsd == vmsd && se->opaque == opaque) {
634 QTAILQ_REMOVE(&savevm_state.handlers, se, entry);
635 g_free(se->compat);
636 g_free(se);
637 }
638 }
639 }
640
641 static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id)
642 {
643 trace_vmstate_load(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
644 if (!se->vmsd) { /* Old style */
645 return se->ops->load_state(f, se->opaque, version_id);
646 }
647 return vmstate_load_state(f, se->vmsd, se->opaque, version_id);
648 }
649
650 static void vmstate_save_old_style(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc)
651 {
652 int64_t old_offset, size;
653
654 old_offset = qemu_ftell_fast(f);
655 se->ops->save_state(f, se->opaque);
656 size = qemu_ftell_fast(f) - old_offset;
657
658 if (vmdesc) {
659 json_prop_int(vmdesc, "size", size);
660 json_start_array(vmdesc, "fields");
661 json_start_object(vmdesc, NULL);
662 json_prop_str(vmdesc, "name", "data");
663 json_prop_int(vmdesc, "size", size);
664 json_prop_str(vmdesc, "type", "buffer");
665 json_end_object(vmdesc);
666 json_end_array(vmdesc);
667 }
668 }
669
670 static void vmstate_save(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc)
671 {
672 trace_vmstate_save(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
673 if (!se->vmsd) {
674 vmstate_save_old_style(f, se, vmdesc);
675 return;
676 }
677 vmstate_save_state(f, se->vmsd, se->opaque, vmdesc);
678 }
679
680 void savevm_skip_section_footers(void)
681 {
682 skip_section_footers = true;
683 }
684
685 /*
686 * Write the header for device section (QEMU_VM_SECTION START/END/PART/FULL)
687 */
688 static void save_section_header(QEMUFile *f, SaveStateEntry *se,
689 uint8_t section_type)
690 {
691 qemu_put_byte(f, section_type);
692 qemu_put_be32(f, se->section_id);
693
694 if (section_type == QEMU_VM_SECTION_FULL ||
695 section_type == QEMU_VM_SECTION_START) {
696 /* ID string */
697 size_t len = strlen(se->idstr);
698 qemu_put_byte(f, len);
699 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
700
701 qemu_put_be32(f, se->instance_id);
702 qemu_put_be32(f, se->version_id);
703 }
704 }
705
706 /*
707 * Write a footer onto device sections that catches cases misformatted device
708 * sections.
709 */
710 static void save_section_footer(QEMUFile *f, SaveStateEntry *se)
711 {
712 if (!skip_section_footers) {
713 qemu_put_byte(f, QEMU_VM_SECTION_FOOTER);
714 qemu_put_be32(f, se->section_id);
715 }
716 }
717
718 /**
719 * qemu_savevm_command_send: Send a 'QEMU_VM_COMMAND' type element with the
720 * command and associated data.
721 *
722 * @f: File to send command on
723 * @command: Command type to send
724 * @len: Length of associated data
725 * @data: Data associated with command.
726 */
727 void qemu_savevm_command_send(QEMUFile *f,
728 enum qemu_vm_cmd command,
729 uint16_t len,
730 uint8_t *data)
731 {
732 trace_savevm_command_send(command, len);
733 qemu_put_byte(f, QEMU_VM_COMMAND);
734 qemu_put_be16(f, (uint16_t)command);
735 qemu_put_be16(f, len);
736 qemu_put_buffer(f, data, len);
737 qemu_fflush(f);
738 }
739
740 void qemu_savevm_send_ping(QEMUFile *f, uint32_t value)
741 {
742 uint32_t buf;
743
744 trace_savevm_send_ping(value);
745 buf = cpu_to_be32(value);
746 qemu_savevm_command_send(f, MIG_CMD_PING, sizeof(value), (uint8_t *)&buf);
747 }
748
749 void qemu_savevm_send_open_return_path(QEMUFile *f)
750 {
751 trace_savevm_send_open_return_path();
752 qemu_savevm_command_send(f, MIG_CMD_OPEN_RETURN_PATH, 0, NULL);
753 }
754
755 /* We have a buffer of data to send; we don't want that all to be loaded
756 * by the command itself, so the command contains just the length of the
757 * extra buffer that we then send straight after it.
758 * TODO: Must be a better way to organise that
759 *
760 * Returns:
761 * 0 on success
762 * -ve on error
763 */
764 int qemu_savevm_send_packaged(QEMUFile *f, const uint8_t *buf, size_t len)
765 {
766 uint32_t tmp;
767
768 if (len > MAX_VM_CMD_PACKAGED_SIZE) {
769 error_report("%s: Unreasonably large packaged state: %zu",
770 __func__, len);
771 return -1;
772 }
773
774 tmp = cpu_to_be32(len);
775
776 trace_qemu_savevm_send_packaged();
777 qemu_savevm_command_send(f, MIG_CMD_PACKAGED, 4, (uint8_t *)&tmp);
778
779 qemu_put_buffer(f, buf, len);
780
781 return 0;
782 }
783
784 /* Send prior to any postcopy transfer */
785 void qemu_savevm_send_postcopy_advise(QEMUFile *f)
786 {
787 uint64_t tmp[2];
788 tmp[0] = cpu_to_be64(getpagesize());
789 tmp[1] = cpu_to_be64(1ul << qemu_target_page_bits());
790
791 trace_qemu_savevm_send_postcopy_advise();
792 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_ADVISE, 16, (uint8_t *)tmp);
793 }
794
795 /* Sent prior to starting the destination running in postcopy, discard pages
796 * that have already been sent but redirtied on the source.
797 * CMD_POSTCOPY_RAM_DISCARD consist of:
798 * byte version (0)
799 * byte Length of name field (not including 0)
800 * n x byte RAM block name
801 * byte 0 terminator (just for safety)
802 * n x Byte ranges within the named RAMBlock
803 * be64 Start of the range
804 * be64 Length
805 *
806 * name: RAMBlock name that these entries are part of
807 * len: Number of page entries
808 * start_list: 'len' addresses
809 * length_list: 'len' addresses
810 *
811 */
812 void qemu_savevm_send_postcopy_ram_discard(QEMUFile *f, const char *name,
813 uint16_t len,
814 uint64_t *start_list,
815 uint64_t *length_list)
816 {
817 uint8_t *buf;
818 uint16_t tmplen;
819 uint16_t t;
820 size_t name_len = strlen(name);
821
822 trace_qemu_savevm_send_postcopy_ram_discard(name, len);
823 assert(name_len < 256);
824 buf = g_malloc0(1 + 1 + name_len + 1 + (8 + 8) * len);
825 buf[0] = postcopy_ram_discard_version;
826 buf[1] = name_len;
827 memcpy(buf + 2, name, name_len);
828 tmplen = 2 + name_len;
829 buf[tmplen++] = '\0';
830
831 for (t = 0; t < len; t++) {
832 cpu_to_be64w((uint64_t *)(buf + tmplen), start_list[t]);
833 tmplen += 8;
834 cpu_to_be64w((uint64_t *)(buf + tmplen), length_list[t]);
835 tmplen += 8;
836 }
837 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RAM_DISCARD, tmplen, buf);
838 g_free(buf);
839 }
840
841 /* Get the destination into a state where it can receive postcopy data. */
842 void qemu_savevm_send_postcopy_listen(QEMUFile *f)
843 {
844 trace_savevm_send_postcopy_listen();
845 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_LISTEN, 0, NULL);
846 }
847
848 /* Kick the destination into running */
849 void qemu_savevm_send_postcopy_run(QEMUFile *f)
850 {
851 trace_savevm_send_postcopy_run();
852 qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RUN, 0, NULL);
853 }
854
855 bool qemu_savevm_state_blocked(Error **errp)
856 {
857 SaveStateEntry *se;
858
859 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
860 if (se->vmsd && se->vmsd->unmigratable) {
861 error_setg(errp, "State blocked by non-migratable device '%s'",
862 se->idstr);
863 return true;
864 }
865 }
866 return false;
867 }
868
869 static bool enforce_config_section(void)
870 {
871 MachineState *machine = MACHINE(qdev_get_machine());
872 return machine->enforce_config_section;
873 }
874
875 void qemu_savevm_state_header(QEMUFile *f)
876 {
877 trace_savevm_state_header();
878 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
879 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
880
881 if (!savevm_state.skip_configuration || enforce_config_section()) {
882 qemu_put_byte(f, QEMU_VM_CONFIGURATION);
883 vmstate_save_state(f, &vmstate_configuration, &savevm_state, 0);
884 }
885
886 }
887
888 void qemu_savevm_state_begin(QEMUFile *f,
889 const MigrationParams *params)
890 {
891 SaveStateEntry *se;
892 int ret;
893
894 trace_savevm_state_begin();
895 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
896 if (!se->ops || !se->ops->set_params) {
897 continue;
898 }
899 se->ops->set_params(params, se->opaque);
900 }
901
902 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
903 if (!se->ops || !se->ops->save_live_setup) {
904 continue;
905 }
906 if (se->ops && se->ops->is_active) {
907 if (!se->ops->is_active(se->opaque)) {
908 continue;
909 }
910 }
911 save_section_header(f, se, QEMU_VM_SECTION_START);
912
913 ret = se->ops->save_live_setup(f, se->opaque);
914 save_section_footer(f, se);
915 if (ret < 0) {
916 qemu_file_set_error(f, ret);
917 break;
918 }
919 }
920 }
921
922 /*
923 * this function has three return values:
924 * negative: there was one error, and we have -errno.
925 * 0 : We haven't finished, caller have to go again
926 * 1 : We have finished, we can go to complete phase
927 */
928 int qemu_savevm_state_iterate(QEMUFile *f, bool postcopy)
929 {
930 SaveStateEntry *se;
931 int ret = 1;
932
933 trace_savevm_state_iterate();
934 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
935 if (!se->ops || !se->ops->save_live_iterate) {
936 continue;
937 }
938 if (se->ops && se->ops->is_active) {
939 if (!se->ops->is_active(se->opaque)) {
940 continue;
941 }
942 }
943 /*
944 * In the postcopy phase, any device that doesn't know how to
945 * do postcopy should have saved it's state in the _complete
946 * call that's already run, it might get confused if we call
947 * iterate afterwards.
948 */
949 if (postcopy && !se->ops->save_live_complete_postcopy) {
950 continue;
951 }
952 if (qemu_file_rate_limit(f)) {
953 return 0;
954 }
955 trace_savevm_section_start(se->idstr, se->section_id);
956
957 save_section_header(f, se, QEMU_VM_SECTION_PART);
958
959 ret = se->ops->save_live_iterate(f, se->opaque);
960 trace_savevm_section_end(se->idstr, se->section_id, ret);
961 save_section_footer(f, se);
962
963 if (ret < 0) {
964 qemu_file_set_error(f, ret);
965 }
966 if (ret <= 0) {
967 /* Do not proceed to the next vmstate before this one reported
968 completion of the current stage. This serializes the migration
969 and reduces the probability that a faster changing state is
970 synchronized over and over again. */
971 break;
972 }
973 }
974 return ret;
975 }
976
977 static bool should_send_vmdesc(void)
978 {
979 MachineState *machine = MACHINE(qdev_get_machine());
980 bool in_postcopy = migration_in_postcopy(migrate_get_current());
981 return !machine->suppress_vmdesc && !in_postcopy;
982 }
983
984 /*
985 * Calls the save_live_complete_postcopy methods
986 * causing the last few pages to be sent immediately and doing any associated
987 * cleanup.
988 * Note postcopy also calls qemu_savevm_state_complete_precopy to complete
989 * all the other devices, but that happens at the point we switch to postcopy.
990 */
991 void qemu_savevm_state_complete_postcopy(QEMUFile *f)
992 {
993 SaveStateEntry *se;
994 int ret;
995
996 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
997 if (!se->ops || !se->ops->save_live_complete_postcopy) {
998 continue;
999 }
1000 if (se->ops && se->ops->is_active) {
1001 if (!se->ops->is_active(se->opaque)) {
1002 continue;
1003 }
1004 }
1005 trace_savevm_section_start(se->idstr, se->section_id);
1006 /* Section type */
1007 qemu_put_byte(f, QEMU_VM_SECTION_END);
1008 qemu_put_be32(f, se->section_id);
1009
1010 ret = se->ops->save_live_complete_postcopy(f, se->opaque);
1011 trace_savevm_section_end(se->idstr, se->section_id, ret);
1012 save_section_footer(f, se);
1013 if (ret < 0) {
1014 qemu_file_set_error(f, ret);
1015 return;
1016 }
1017 }
1018
1019 qemu_put_byte(f, QEMU_VM_EOF);
1020 qemu_fflush(f);
1021 }
1022
1023 void qemu_savevm_state_complete_precopy(QEMUFile *f, bool iterable_only)
1024 {
1025 QJSON *vmdesc;
1026 int vmdesc_len;
1027 SaveStateEntry *se;
1028 int ret;
1029 bool in_postcopy = migration_in_postcopy(migrate_get_current());
1030
1031 trace_savevm_state_complete_precopy();
1032
1033 cpu_synchronize_all_states();
1034
1035 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1036 if (!se->ops ||
1037 (in_postcopy && se->ops->save_live_complete_postcopy) ||
1038 (in_postcopy && !iterable_only) ||
1039 !se->ops->save_live_complete_precopy) {
1040 continue;
1041 }
1042
1043 if (se->ops && se->ops->is_active) {
1044 if (!se->ops->is_active(se->opaque)) {
1045 continue;
1046 }
1047 }
1048 trace_savevm_section_start(se->idstr, se->section_id);
1049
1050 save_section_header(f, se, QEMU_VM_SECTION_END);
1051
1052 ret = se->ops->save_live_complete_precopy(f, se->opaque);
1053 trace_savevm_section_end(se->idstr, se->section_id, ret);
1054 save_section_footer(f, se);
1055 if (ret < 0) {
1056 qemu_file_set_error(f, ret);
1057 return;
1058 }
1059 }
1060
1061 if (iterable_only) {
1062 return;
1063 }
1064
1065 vmdesc = qjson_new();
1066 json_prop_int(vmdesc, "page_size", TARGET_PAGE_SIZE);
1067 json_start_array(vmdesc, "devices");
1068 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1069
1070 if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1071 continue;
1072 }
1073 if (se->vmsd && !vmstate_save_needed(se->vmsd, se->opaque)) {
1074 trace_savevm_section_skip(se->idstr, se->section_id);
1075 continue;
1076 }
1077
1078 trace_savevm_section_start(se->idstr, se->section_id);
1079
1080 json_start_object(vmdesc, NULL);
1081 json_prop_str(vmdesc, "name", se->idstr);
1082 json_prop_int(vmdesc, "instance_id", se->instance_id);
1083
1084 save_section_header(f, se, QEMU_VM_SECTION_FULL);
1085 vmstate_save(f, se, vmdesc);
1086 trace_savevm_section_end(se->idstr, se->section_id, 0);
1087 save_section_footer(f, se);
1088
1089 json_end_object(vmdesc);
1090 }
1091
1092 if (!in_postcopy) {
1093 /* Postcopy stream will still be going */
1094 qemu_put_byte(f, QEMU_VM_EOF);
1095 }
1096
1097 json_end_array(vmdesc);
1098 qjson_finish(vmdesc);
1099 vmdesc_len = strlen(qjson_get_str(vmdesc));
1100
1101 if (should_send_vmdesc()) {
1102 qemu_put_byte(f, QEMU_VM_VMDESCRIPTION);
1103 qemu_put_be32(f, vmdesc_len);
1104 qemu_put_buffer(f, (uint8_t *)qjson_get_str(vmdesc), vmdesc_len);
1105 }
1106 qjson_destroy(vmdesc);
1107
1108 qemu_fflush(f);
1109 }
1110
1111 /* Give an estimate of the amount left to be transferred,
1112 * the result is split into the amount for units that can and
1113 * for units that can't do postcopy.
1114 */
1115 void qemu_savevm_state_pending(QEMUFile *f, uint64_t max_size,
1116 uint64_t *res_non_postcopiable,
1117 uint64_t *res_postcopiable)
1118 {
1119 SaveStateEntry *se;
1120
1121 *res_non_postcopiable = 0;
1122 *res_postcopiable = 0;
1123
1124
1125 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1126 if (!se->ops || !se->ops->save_live_pending) {
1127 continue;
1128 }
1129 if (se->ops && se->ops->is_active) {
1130 if (!se->ops->is_active(se->opaque)) {
1131 continue;
1132 }
1133 }
1134 se->ops->save_live_pending(f, se->opaque, max_size,
1135 res_non_postcopiable, res_postcopiable);
1136 }
1137 }
1138
1139 void qemu_savevm_state_cleanup(void)
1140 {
1141 SaveStateEntry *se;
1142
1143 trace_savevm_state_cleanup();
1144 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1145 if (se->ops && se->ops->cleanup) {
1146 se->ops->cleanup(se->opaque);
1147 }
1148 }
1149 }
1150
1151 static int qemu_savevm_state(QEMUFile *f, Error **errp)
1152 {
1153 int ret;
1154 MigrationParams params = {
1155 .blk = 0,
1156 .shared = 0
1157 };
1158 MigrationState *ms = migrate_init(&params);
1159 ms->to_dst_file = f;
1160
1161 if (migration_is_blocked(errp)) {
1162 return -EINVAL;
1163 }
1164
1165 qemu_mutex_unlock_iothread();
1166 qemu_savevm_state_header(f);
1167 qemu_savevm_state_begin(f, &params);
1168 qemu_mutex_lock_iothread();
1169
1170 while (qemu_file_get_error(f) == 0) {
1171 if (qemu_savevm_state_iterate(f, false) > 0) {
1172 break;
1173 }
1174 }
1175
1176 ret = qemu_file_get_error(f);
1177 if (ret == 0) {
1178 qemu_savevm_state_complete_precopy(f, false);
1179 ret = qemu_file_get_error(f);
1180 }
1181 qemu_savevm_state_cleanup();
1182 if (ret != 0) {
1183 error_setg_errno(errp, -ret, "Error while writing VM state");
1184 }
1185 return ret;
1186 }
1187
1188 static int qemu_save_device_state(QEMUFile *f)
1189 {
1190 SaveStateEntry *se;
1191
1192 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1193 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1194
1195 cpu_synchronize_all_states();
1196
1197 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1198 if (se->is_ram) {
1199 continue;
1200 }
1201 if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1202 continue;
1203 }
1204 if (se->vmsd && !vmstate_save_needed(se->vmsd, se->opaque)) {
1205 continue;
1206 }
1207
1208 save_section_header(f, se, QEMU_VM_SECTION_FULL);
1209
1210 vmstate_save(f, se, NULL);
1211
1212 save_section_footer(f, se);
1213 }
1214
1215 qemu_put_byte(f, QEMU_VM_EOF);
1216
1217 return qemu_file_get_error(f);
1218 }
1219
1220 static SaveStateEntry *find_se(const char *idstr, int instance_id)
1221 {
1222 SaveStateEntry *se;
1223
1224 QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1225 if (!strcmp(se->idstr, idstr) &&
1226 (instance_id == se->instance_id ||
1227 instance_id == se->alias_id))
1228 return se;
1229 /* Migrating from an older version? */
1230 if (strstr(se->idstr, idstr) && se->compat) {
1231 if (!strcmp(se->compat->idstr, idstr) &&
1232 (instance_id == se->compat->instance_id ||
1233 instance_id == se->alias_id))
1234 return se;
1235 }
1236 }
1237 return NULL;
1238 }
1239
1240 enum LoadVMExitCodes {
1241 /* Allow a command to quit all layers of nested loadvm loops */
1242 LOADVM_QUIT = 1,
1243 };
1244
1245 static int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis);
1246
1247 /* ------ incoming postcopy messages ------ */
1248 /* 'advise' arrives before any transfers just to tell us that a postcopy
1249 * *might* happen - it might be skipped if precopy transferred everything
1250 * quickly.
1251 */
1252 static int loadvm_postcopy_handle_advise(MigrationIncomingState *mis)
1253 {
1254 PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_ADVISE);
1255 uint64_t remote_hps, remote_tps;
1256
1257 trace_loadvm_postcopy_handle_advise();
1258 if (ps != POSTCOPY_INCOMING_NONE) {
1259 error_report("CMD_POSTCOPY_ADVISE in wrong postcopy state (%d)", ps);
1260 return -1;
1261 }
1262
1263 if (!postcopy_ram_supported_by_host()) {
1264 return -1;
1265 }
1266
1267 remote_hps = qemu_get_be64(mis->from_src_file);
1268 if (remote_hps != getpagesize()) {
1269 /*
1270 * Some combinations of mismatch are probably possible but it gets
1271 * a bit more complicated. In particular we need to place whole
1272 * host pages on the dest at once, and we need to ensure that we
1273 * handle dirtying to make sure we never end up sending part of
1274 * a hostpage on it's own.
1275 */
1276 error_report("Postcopy needs matching host page sizes (s=%d d=%d)",
1277 (int)remote_hps, getpagesize());
1278 return -1;
1279 }
1280
1281 remote_tps = qemu_get_be64(mis->from_src_file);
1282 if (remote_tps != (1ul << qemu_target_page_bits())) {
1283 /*
1284 * Again, some differences could be dealt with, but for now keep it
1285 * simple.
1286 */
1287 error_report("Postcopy needs matching target page sizes (s=%d d=%d)",
1288 (int)remote_tps, 1 << qemu_target_page_bits());
1289 return -1;
1290 }
1291
1292 if (ram_postcopy_incoming_init(mis)) {
1293 return -1;
1294 }
1295
1296 postcopy_state_set(POSTCOPY_INCOMING_ADVISE);
1297
1298 return 0;
1299 }
1300
1301 /* After postcopy we will be told to throw some pages away since they're
1302 * dirty and will have to be demand fetched. Must happen before CPU is
1303 * started.
1304 * There can be 0..many of these messages, each encoding multiple pages.
1305 */
1306 static int loadvm_postcopy_ram_handle_discard(MigrationIncomingState *mis,
1307 uint16_t len)
1308 {
1309 int tmp;
1310 char ramid[256];
1311 PostcopyState ps = postcopy_state_get();
1312
1313 trace_loadvm_postcopy_ram_handle_discard();
1314
1315 switch (ps) {
1316 case POSTCOPY_INCOMING_ADVISE:
1317 /* 1st discard */
1318 tmp = postcopy_ram_prepare_discard(mis);
1319 if (tmp) {
1320 return tmp;
1321 }
1322 break;
1323
1324 case POSTCOPY_INCOMING_DISCARD:
1325 /* Expected state */
1326 break;
1327
1328 default:
1329 error_report("CMD_POSTCOPY_RAM_DISCARD in wrong postcopy state (%d)",
1330 ps);
1331 return -1;
1332 }
1333 /* We're expecting a
1334 * Version (0)
1335 * a RAM ID string (length byte, name, 0 term)
1336 * then at least 1 16 byte chunk
1337 */
1338 if (len < (1 + 1 + 1 + 1 + 2 * 8)) {
1339 error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len);
1340 return -1;
1341 }
1342
1343 tmp = qemu_get_byte(mis->from_src_file);
1344 if (tmp != postcopy_ram_discard_version) {
1345 error_report("CMD_POSTCOPY_RAM_DISCARD invalid version (%d)", tmp);
1346 return -1;
1347 }
1348
1349 if (!qemu_get_counted_string(mis->from_src_file, ramid)) {
1350 error_report("CMD_POSTCOPY_RAM_DISCARD Failed to read RAMBlock ID");
1351 return -1;
1352 }
1353 tmp = qemu_get_byte(mis->from_src_file);
1354 if (tmp != 0) {
1355 error_report("CMD_POSTCOPY_RAM_DISCARD missing nil (%d)", tmp);
1356 return -1;
1357 }
1358
1359 len -= 3 + strlen(ramid);
1360 if (len % 16) {
1361 error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len);
1362 return -1;
1363 }
1364 trace_loadvm_postcopy_ram_handle_discard_header(ramid, len);
1365 while (len) {
1366 uint64_t start_addr, block_length;
1367 start_addr = qemu_get_be64(mis->from_src_file);
1368 block_length = qemu_get_be64(mis->from_src_file);
1369
1370 len -= 16;
1371 int ret = ram_discard_range(mis, ramid, start_addr,
1372 block_length);
1373 if (ret) {
1374 return ret;
1375 }
1376 }
1377 trace_loadvm_postcopy_ram_handle_discard_end();
1378
1379 return 0;
1380 }
1381
1382 /*
1383 * Triggered by a postcopy_listen command; this thread takes over reading
1384 * the input stream, leaving the main thread free to carry on loading the rest
1385 * of the device state (from RAM).
1386 * (TODO:This could do with being in a postcopy file - but there again it's
1387 * just another input loop, not that postcopy specific)
1388 */
1389 static void *postcopy_ram_listen_thread(void *opaque)
1390 {
1391 QEMUFile *f = opaque;
1392 MigrationIncomingState *mis = migration_incoming_get_current();
1393 int load_res;
1394
1395 migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
1396 MIGRATION_STATUS_POSTCOPY_ACTIVE);
1397 qemu_sem_post(&mis->listen_thread_sem);
1398 trace_postcopy_ram_listen_thread_start();
1399
1400 /*
1401 * Because we're a thread and not a coroutine we can't yield
1402 * in qemu_file, and thus we must be blocking now.
1403 */
1404 qemu_file_set_blocking(f, true);
1405 load_res = qemu_loadvm_state_main(f, mis);
1406 /* And non-blocking again so we don't block in any cleanup */
1407 qemu_file_set_blocking(f, false);
1408
1409 trace_postcopy_ram_listen_thread_exit();
1410 if (load_res < 0) {
1411 error_report("%s: loadvm failed: %d", __func__, load_res);
1412 qemu_file_set_error(f, load_res);
1413 migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
1414 MIGRATION_STATUS_FAILED);
1415 } else {
1416 /*
1417 * This looks good, but it's possible that the device loading in the
1418 * main thread hasn't finished yet, and so we might not be in 'RUN'
1419 * state yet; wait for the end of the main thread.
1420 */
1421 qemu_event_wait(&mis->main_thread_load_event);
1422 }
1423 postcopy_ram_incoming_cleanup(mis);
1424
1425 if (load_res < 0) {
1426 /*
1427 * If something went wrong then we have a bad state so exit;
1428 * depending how far we got it might be possible at this point
1429 * to leave the guest running and fire MCEs for pages that never
1430 * arrived as a desperate recovery step.
1431 */
1432 exit(EXIT_FAILURE);
1433 }
1434
1435 migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
1436 MIGRATION_STATUS_COMPLETED);
1437 /*
1438 * If everything has worked fine, then the main thread has waited
1439 * for us to start, and we're the last use of the mis.
1440 * (If something broke then qemu will have to exit anyway since it's
1441 * got a bad migration state).
1442 */
1443 migration_incoming_state_destroy();
1444
1445
1446 return NULL;
1447 }
1448
1449 /* After this message we must be able to immediately receive postcopy data */
1450 static int loadvm_postcopy_handle_listen(MigrationIncomingState *mis)
1451 {
1452 PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_LISTENING);
1453 trace_loadvm_postcopy_handle_listen();
1454 if (ps != POSTCOPY_INCOMING_ADVISE && ps != POSTCOPY_INCOMING_DISCARD) {
1455 error_report("CMD_POSTCOPY_LISTEN in wrong postcopy state (%d)", ps);
1456 return -1;
1457 }
1458 if (ps == POSTCOPY_INCOMING_ADVISE) {
1459 /*
1460 * A rare case, we entered listen without having to do any discards,
1461 * so do the setup that's normally done at the time of the 1st discard.
1462 */
1463 postcopy_ram_prepare_discard(mis);
1464 }
1465
1466 /*
1467 * Sensitise RAM - can now generate requests for blocks that don't exist
1468 * However, at this point the CPU shouldn't be running, and the IO
1469 * shouldn't be doing anything yet so don't actually expect requests
1470 */
1471 if (postcopy_ram_enable_notify(mis)) {
1472 return -1;
1473 }
1474
1475 if (mis->have_listen_thread) {
1476 error_report("CMD_POSTCOPY_RAM_LISTEN already has a listen thread");
1477 return -1;
1478 }
1479
1480 mis->have_listen_thread = true;
1481 /* Start up the listening thread and wait for it to signal ready */
1482 qemu_sem_init(&mis->listen_thread_sem, 0);
1483 qemu_thread_create(&mis->listen_thread, "postcopy/listen",
1484 postcopy_ram_listen_thread, mis->from_src_file,
1485 QEMU_THREAD_DETACHED);
1486 qemu_sem_wait(&mis->listen_thread_sem);
1487 qemu_sem_destroy(&mis->listen_thread_sem);
1488
1489 return 0;
1490 }
1491
1492
1493 typedef struct {
1494 QEMUBH *bh;
1495 } HandleRunBhData;
1496
1497 static void loadvm_postcopy_handle_run_bh(void *opaque)
1498 {
1499 Error *local_err = NULL;
1500 HandleRunBhData *data = opaque;
1501
1502 /* TODO we should move all of this lot into postcopy_ram.c or a shared code
1503 * in migration.c
1504 */
1505 cpu_synchronize_all_post_init();
1506
1507 qemu_announce_self();
1508
1509 /* Make sure all file formats flush their mutable metadata */
1510 bdrv_invalidate_cache_all(&local_err);
1511 if (local_err) {
1512 error_report_err(local_err);
1513 }
1514
1515 trace_loadvm_postcopy_handle_run_cpu_sync();
1516 cpu_synchronize_all_post_init();
1517
1518 trace_loadvm_postcopy_handle_run_vmstart();
1519
1520 if (autostart) {
1521 /* Hold onto your hats, starting the CPU */
1522 vm_start();
1523 } else {
1524 /* leave it paused and let management decide when to start the CPU */
1525 runstate_set(RUN_STATE_PAUSED);
1526 }
1527
1528 qemu_bh_delete(data->bh);
1529 g_free(data);
1530 }
1531
1532 /* After all discards we can start running and asking for pages */
1533 static int loadvm_postcopy_handle_run(MigrationIncomingState *mis)
1534 {
1535 PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_RUNNING);
1536 HandleRunBhData *data;
1537
1538 trace_loadvm_postcopy_handle_run();
1539 if (ps != POSTCOPY_INCOMING_LISTENING) {
1540 error_report("CMD_POSTCOPY_RUN in wrong postcopy state (%d)", ps);
1541 return -1;
1542 }
1543
1544 data = g_new(HandleRunBhData, 1);
1545 data->bh = qemu_bh_new(loadvm_postcopy_handle_run_bh, data);
1546 qemu_bh_schedule(data->bh);
1547
1548 /* We need to finish reading the stream from the package
1549 * and also stop reading anything more from the stream that loaded the
1550 * package (since it's now being read by the listener thread).
1551 * LOADVM_QUIT will quit all the layers of nested loadvm loops.
1552 */
1553 return LOADVM_QUIT;
1554 }
1555
1556 /**
1557 * Immediately following this command is a blob of data containing an embedded
1558 * chunk of migration stream; read it and load it.
1559 *
1560 * @mis: Incoming state
1561 * @length: Length of packaged data to read
1562 *
1563 * Returns: Negative values on error
1564 *
1565 */
1566 static int loadvm_handle_cmd_packaged(MigrationIncomingState *mis)
1567 {
1568 int ret;
1569 size_t length;
1570 QIOChannelBuffer *bioc;
1571
1572 length = qemu_get_be32(mis->from_src_file);
1573 trace_loadvm_handle_cmd_packaged(length);
1574
1575 if (length > MAX_VM_CMD_PACKAGED_SIZE) {
1576 error_report("Unreasonably large packaged state: %zu", length);
1577 return -1;
1578 }
1579
1580 bioc = qio_channel_buffer_new(length);
1581 ret = qemu_get_buffer(mis->from_src_file,
1582 bioc->data,
1583 length);
1584 if (ret != length) {
1585 object_unref(OBJECT(bioc));
1586 error_report("CMD_PACKAGED: Buffer receive fail ret=%d length=%zu",
1587 ret, length);
1588 return (ret < 0) ? ret : -EAGAIN;
1589 }
1590 bioc->usage += length;
1591 trace_loadvm_handle_cmd_packaged_received(ret);
1592
1593 QEMUFile *packf = qemu_fopen_channel_input(QIO_CHANNEL(bioc));
1594
1595 ret = qemu_loadvm_state_main(packf, mis);
1596 trace_loadvm_handle_cmd_packaged_main(ret);
1597 qemu_fclose(packf);
1598 object_unref(OBJECT(bioc));
1599
1600 return ret;
1601 }
1602
1603 /*
1604 * Process an incoming 'QEMU_VM_COMMAND'
1605 * 0 just a normal return
1606 * LOADVM_QUIT All good, but exit the loop
1607 * <0 Error
1608 */
1609 static int loadvm_process_command(QEMUFile *f)
1610 {
1611 MigrationIncomingState *mis = migration_incoming_get_current();
1612 uint16_t cmd;
1613 uint16_t len;
1614 uint32_t tmp32;
1615
1616 cmd = qemu_get_be16(f);
1617 len = qemu_get_be16(f);
1618
1619 trace_loadvm_process_command(cmd, len);
1620 if (cmd >= MIG_CMD_MAX || cmd == MIG_CMD_INVALID) {
1621 error_report("MIG_CMD 0x%x unknown (len 0x%x)", cmd, len);
1622 return -EINVAL;
1623 }
1624
1625 if (mig_cmd_args[cmd].len != -1 && mig_cmd_args[cmd].len != len) {
1626 error_report("%s received with bad length - expecting %zu, got %d",
1627 mig_cmd_args[cmd].name,
1628 (size_t)mig_cmd_args[cmd].len, len);
1629 return -ERANGE;
1630 }
1631
1632 switch (cmd) {
1633 case MIG_CMD_OPEN_RETURN_PATH:
1634 if (mis->to_src_file) {
1635 error_report("CMD_OPEN_RETURN_PATH called when RP already open");
1636 /* Not really a problem, so don't give up */
1637 return 0;
1638 }
1639 mis->to_src_file = qemu_file_get_return_path(f);
1640 if (!mis->to_src_file) {
1641 error_report("CMD_OPEN_RETURN_PATH failed");
1642 return -1;
1643 }
1644 break;
1645
1646 case MIG_CMD_PING:
1647 tmp32 = qemu_get_be32(f);
1648 trace_loadvm_process_command_ping(tmp32);
1649 if (!mis->to_src_file) {
1650 error_report("CMD_PING (0x%x) received with no return path",
1651 tmp32);
1652 return -1;
1653 }
1654 migrate_send_rp_pong(mis, tmp32);
1655 break;
1656
1657 case MIG_CMD_PACKAGED:
1658 return loadvm_handle_cmd_packaged(mis);
1659
1660 case MIG_CMD_POSTCOPY_ADVISE:
1661 return loadvm_postcopy_handle_advise(mis);
1662
1663 case MIG_CMD_POSTCOPY_LISTEN:
1664 return loadvm_postcopy_handle_listen(mis);
1665
1666 case MIG_CMD_POSTCOPY_RUN:
1667 return loadvm_postcopy_handle_run(mis);
1668
1669 case MIG_CMD_POSTCOPY_RAM_DISCARD:
1670 return loadvm_postcopy_ram_handle_discard(mis, len);
1671 }
1672
1673 return 0;
1674 }
1675
1676 struct LoadStateEntry {
1677 QLIST_ENTRY(LoadStateEntry) entry;
1678 SaveStateEntry *se;
1679 int section_id;
1680 int version_id;
1681 };
1682
1683 /*
1684 * Read a footer off the wire and check that it matches the expected section
1685 *
1686 * Returns: true if the footer was good
1687 * false if there is a problem (and calls error_report to say why)
1688 */
1689 static bool check_section_footer(QEMUFile *f, LoadStateEntry *le)
1690 {
1691 uint8_t read_mark;
1692 uint32_t read_section_id;
1693
1694 if (skip_section_footers) {
1695 /* No footer to check */
1696 return true;
1697 }
1698
1699 read_mark = qemu_get_byte(f);
1700
1701 if (read_mark != QEMU_VM_SECTION_FOOTER) {
1702 error_report("Missing section footer for %s", le->se->idstr);
1703 return false;
1704 }
1705
1706 read_section_id = qemu_get_be32(f);
1707 if (read_section_id != le->section_id) {
1708 error_report("Mismatched section id in footer for %s -"
1709 " read 0x%x expected 0x%x",
1710 le->se->idstr, read_section_id, le->section_id);
1711 return false;
1712 }
1713
1714 /* All good */
1715 return true;
1716 }
1717
1718 void loadvm_free_handlers(MigrationIncomingState *mis)
1719 {
1720 LoadStateEntry *le, *new_le;
1721
1722 QLIST_FOREACH_SAFE(le, &mis->loadvm_handlers, entry, new_le) {
1723 QLIST_REMOVE(le, entry);
1724 g_free(le);
1725 }
1726 }
1727
1728 static int
1729 qemu_loadvm_section_start_full(QEMUFile *f, MigrationIncomingState *mis)
1730 {
1731 uint32_t instance_id, version_id, section_id;
1732 SaveStateEntry *se;
1733 LoadStateEntry *le;
1734 char idstr[256];
1735 int ret;
1736
1737 /* Read section start */
1738 section_id = qemu_get_be32(f);
1739 if (!qemu_get_counted_string(f, idstr)) {
1740 error_report("Unable to read ID string for section %u",
1741 section_id);
1742 return -EINVAL;
1743 }
1744 instance_id = qemu_get_be32(f);
1745 version_id = qemu_get_be32(f);
1746
1747 trace_qemu_loadvm_state_section_startfull(section_id, idstr,
1748 instance_id, version_id);
1749 /* Find savevm section */
1750 se = find_se(idstr, instance_id);
1751 if (se == NULL) {
1752 error_report("Unknown savevm section or instance '%s' %d",
1753 idstr, instance_id);
1754 return -EINVAL;
1755 }
1756
1757 /* Validate version */
1758 if (version_id > se->version_id) {
1759 error_report("savevm: unsupported version %d for '%s' v%d",
1760 version_id, idstr, se->version_id);
1761 return -EINVAL;
1762 }
1763
1764 /* Add entry */
1765 le = g_malloc0(sizeof(*le));
1766
1767 le->se = se;
1768 le->section_id = section_id;
1769 le->version_id = version_id;
1770 QLIST_INSERT_HEAD(&mis->loadvm_handlers, le, entry);
1771
1772 ret = vmstate_load(f, le->se, le->version_id);
1773 if (ret < 0) {
1774 error_report("error while loading state for instance 0x%x of"
1775 " device '%s'", instance_id, idstr);
1776 return ret;
1777 }
1778 if (!check_section_footer(f, le)) {
1779 return -EINVAL;
1780 }
1781
1782 return 0;
1783 }
1784
1785 static int
1786 qemu_loadvm_section_part_end(QEMUFile *f, MigrationIncomingState *mis)
1787 {
1788 uint32_t section_id;
1789 LoadStateEntry *le;
1790 int ret;
1791
1792 section_id = qemu_get_be32(f);
1793
1794 trace_qemu_loadvm_state_section_partend(section_id);
1795 QLIST_FOREACH(le, &mis->loadvm_handlers, entry) {
1796 if (le->section_id == section_id) {
1797 break;
1798 }
1799 }
1800 if (le == NULL) {
1801 error_report("Unknown savevm section %d", section_id);
1802 return -EINVAL;
1803 }
1804
1805 ret = vmstate_load(f, le->se, le->version_id);
1806 if (ret < 0) {
1807 error_report("error while loading state section id %d(%s)",
1808 section_id, le->se->idstr);
1809 return ret;
1810 }
1811 if (!check_section_footer(f, le)) {
1812 return -EINVAL;
1813 }
1814
1815 return 0;
1816 }
1817
1818 static int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis)
1819 {
1820 uint8_t section_type;
1821 int ret;
1822
1823 while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
1824
1825 trace_qemu_loadvm_state_section(section_type);
1826 switch (section_type) {
1827 case QEMU_VM_SECTION_START:
1828 case QEMU_VM_SECTION_FULL:
1829 ret = qemu_loadvm_section_start_full(f, mis);
1830 if (ret < 0) {
1831 return ret;
1832 }
1833 break;
1834 case QEMU_VM_SECTION_PART:
1835 case QEMU_VM_SECTION_END:
1836 ret = qemu_loadvm_section_part_end(f, mis);
1837 if (ret < 0) {
1838 return ret;
1839 }
1840 break;
1841 case QEMU_VM_COMMAND:
1842 ret = loadvm_process_command(f);
1843 trace_qemu_loadvm_state_section_command(ret);
1844 if ((ret < 0) || (ret & LOADVM_QUIT)) {
1845 return ret;
1846 }
1847 break;
1848 default:
1849 error_report("Unknown savevm section type %d", section_type);
1850 return -EINVAL;
1851 }
1852 }
1853
1854 return 0;
1855 }
1856
1857 int qemu_loadvm_state(QEMUFile *f)
1858 {
1859 MigrationIncomingState *mis = migration_incoming_get_current();
1860 Error *local_err = NULL;
1861 unsigned int v;
1862 int ret;
1863
1864 if (qemu_savevm_state_blocked(&local_err)) {
1865 error_report_err(local_err);
1866 return -EINVAL;
1867 }
1868
1869 v = qemu_get_be32(f);
1870 if (v != QEMU_VM_FILE_MAGIC) {
1871 error_report("Not a migration stream");
1872 return -EINVAL;
1873 }
1874
1875 v = qemu_get_be32(f);
1876 if (v == QEMU_VM_FILE_VERSION_COMPAT) {
1877 error_report("SaveVM v2 format is obsolete and don't work anymore");
1878 return -ENOTSUP;
1879 }
1880 if (v != QEMU_VM_FILE_VERSION) {
1881 error_report("Unsupported migration stream version");
1882 return -ENOTSUP;
1883 }
1884
1885 if (!savevm_state.skip_configuration || enforce_config_section()) {
1886 if (qemu_get_byte(f) != QEMU_VM_CONFIGURATION) {
1887 error_report("Configuration section missing");
1888 return -EINVAL;
1889 }
1890 ret = vmstate_load_state(f, &vmstate_configuration, &savevm_state, 0);
1891
1892 if (ret) {
1893 return ret;
1894 }
1895 }
1896
1897 ret = qemu_loadvm_state_main(f, mis);
1898 qemu_event_set(&mis->main_thread_load_event);
1899
1900 trace_qemu_loadvm_state_post_main(ret);
1901
1902 if (mis->have_listen_thread) {
1903 /* Listen thread still going, can't clean up yet */
1904 return ret;
1905 }
1906
1907 if (ret == 0) {
1908 ret = qemu_file_get_error(f);
1909 }
1910
1911 /*
1912 * Try to read in the VMDESC section as well, so that dumping tools that
1913 * intercept our migration stream have the chance to see it.
1914 */
1915
1916 /* We've got to be careful; if we don't read the data and just shut the fd
1917 * then the sender can error if we close while it's still sending.
1918 * We also mustn't read data that isn't there; some transports (RDMA)
1919 * will stall waiting for that data when the source has already closed.
1920 */
1921 if (ret == 0 && should_send_vmdesc()) {
1922 uint8_t *buf;
1923 uint32_t size;
1924 uint8_t section_type = qemu_get_byte(f);
1925
1926 if (section_type != QEMU_VM_VMDESCRIPTION) {
1927 error_report("Expected vmdescription section, but got %d",
1928 section_type);
1929 /*
1930 * It doesn't seem worth failing at this point since
1931 * we apparently have an otherwise valid VM state
1932 */
1933 } else {
1934 buf = g_malloc(0x1000);
1935 size = qemu_get_be32(f);
1936
1937 while (size > 0) {
1938 uint32_t read_chunk = MIN(size, 0x1000);
1939 qemu_get_buffer(f, buf, read_chunk);
1940 size -= read_chunk;
1941 }
1942 g_free(buf);
1943 }
1944 }
1945
1946 cpu_synchronize_all_post_init();
1947
1948 return ret;
1949 }
1950
1951 void hmp_savevm(Monitor *mon, const QDict *qdict)
1952 {
1953 BlockDriverState *bs, *bs1;
1954 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
1955 int ret;
1956 QEMUFile *f;
1957 int saved_vm_running;
1958 uint64_t vm_state_size;
1959 qemu_timeval tv;
1960 struct tm tm;
1961 const char *name = qdict_get_try_str(qdict, "name");
1962 Error *local_err = NULL;
1963 AioContext *aio_context;
1964
1965 if (!bdrv_all_can_snapshot(&bs)) {
1966 monitor_printf(mon, "Device '%s' is writable but does not "
1967 "support snapshots.\n", bdrv_get_device_name(bs));
1968 return;
1969 }
1970
1971 /* Delete old snapshots of the same name */
1972 if (name && bdrv_all_delete_snapshot(name, &bs1, &local_err) < 0) {
1973 error_reportf_err(local_err,
1974 "Error while deleting snapshot on device '%s': ",
1975 bdrv_get_device_name(bs1));
1976 return;
1977 }
1978
1979 bs = bdrv_all_find_vmstate_bs();
1980 if (bs == NULL) {
1981 monitor_printf(mon, "No block device can accept snapshots\n");
1982 return;
1983 }
1984 aio_context = bdrv_get_aio_context(bs);
1985
1986 saved_vm_running = runstate_is_running();
1987
1988 ret = global_state_store();
1989 if (ret) {
1990 monitor_printf(mon, "Error saving global state\n");
1991 return;
1992 }
1993 vm_stop(RUN_STATE_SAVE_VM);
1994
1995 aio_context_acquire(aio_context);
1996
1997 memset(sn, 0, sizeof(*sn));
1998
1999 /* fill auxiliary fields */
2000 qemu_gettimeofday(&tv);
2001 sn->date_sec = tv.tv_sec;
2002 sn->date_nsec = tv.tv_usec * 1000;
2003 sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
2004
2005 if (name) {
2006 ret = bdrv_snapshot_find(bs, old_sn, name);
2007 if (ret >= 0) {
2008 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
2009 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
2010 } else {
2011 pstrcpy(sn->name, sizeof(sn->name), name);
2012 }
2013 } else {
2014 /* cast below needed for OpenBSD where tv_sec is still 'long' */
2015 localtime_r((const time_t *)&tv.tv_sec, &tm);
2016 strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
2017 }
2018
2019 /* save the VM state */
2020 f = qemu_fopen_bdrv(bs, 1);
2021 if (!f) {
2022 monitor_printf(mon, "Could not open VM state file\n");
2023 goto the_end;
2024 }
2025 ret = qemu_savevm_state(f, &local_err);
2026 vm_state_size = qemu_ftell(f);
2027 qemu_fclose(f);
2028 if (ret < 0) {
2029 error_report_err(local_err);
2030 goto the_end;
2031 }
2032
2033 ret = bdrv_all_create_snapshot(sn, bs, vm_state_size, &bs);
2034 if (ret < 0) {
2035 monitor_printf(mon, "Error while creating snapshot on '%s'\n",
2036 bdrv_get_device_name(bs));
2037 }
2038
2039 the_end:
2040 aio_context_release(aio_context);
2041 if (saved_vm_running) {
2042 vm_start();
2043 }
2044 }
2045
2046 void qmp_xen_save_devices_state(const char *filename, Error **errp)
2047 {
2048 QEMUFile *f;
2049 int saved_vm_running;
2050 int ret;
2051
2052 saved_vm_running = runstate_is_running();
2053 vm_stop(RUN_STATE_SAVE_VM);
2054 global_state_store_running();
2055
2056 f = qemu_fopen(filename, "wb");
2057 if (!f) {
2058 error_setg_file_open(errp, errno, filename);
2059 goto the_end;
2060 }
2061 ret = qemu_save_device_state(f);
2062 qemu_fclose(f);
2063 if (ret < 0) {
2064 error_setg(errp, QERR_IO_ERROR);
2065 }
2066
2067 the_end:
2068 if (saved_vm_running) {
2069 vm_start();
2070 }
2071 }
2072
2073 int load_vmstate(const char *name)
2074 {
2075 BlockDriverState *bs, *bs_vm_state;
2076 QEMUSnapshotInfo sn;
2077 QEMUFile *f;
2078 int ret;
2079 AioContext *aio_context;
2080
2081 if (!bdrv_all_can_snapshot(&bs)) {
2082 error_report("Device '%s' is writable but does not support snapshots.",
2083 bdrv_get_device_name(bs));
2084 return -ENOTSUP;
2085 }
2086 ret = bdrv_all_find_snapshot(name, &bs);
2087 if (ret < 0) {
2088 error_report("Device '%s' does not have the requested snapshot '%s'",
2089 bdrv_get_device_name(bs), name);
2090 return ret;
2091 }
2092
2093 bs_vm_state = bdrv_all_find_vmstate_bs();
2094 if (!bs_vm_state) {
2095 error_report("No block device supports snapshots");
2096 return -ENOTSUP;
2097 }
2098 aio_context = bdrv_get_aio_context(bs_vm_state);
2099
2100 /* Don't even try to load empty VM states */
2101 aio_context_acquire(aio_context);
2102 ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
2103 aio_context_release(aio_context);
2104 if (ret < 0) {
2105 return ret;
2106 } else if (sn.vm_state_size == 0) {
2107 error_report("This is a disk-only snapshot. Revert to it offline "
2108 "using qemu-img.");
2109 return -EINVAL;
2110 }
2111
2112 /* Flush all IO requests so they don't interfere with the new state. */
2113 bdrv_drain_all();
2114
2115 ret = bdrv_all_goto_snapshot(name, &bs);
2116 if (ret < 0) {
2117 error_report("Error %d while activating snapshot '%s' on '%s'",
2118 ret, name, bdrv_get_device_name(bs));
2119 return ret;
2120 }
2121
2122 /* restore the VM state */
2123 f = qemu_fopen_bdrv(bs_vm_state, 0);
2124 if (!f) {
2125 error_report("Could not open VM state file");
2126 return -EINVAL;
2127 }
2128
2129 qemu_system_reset(VMRESET_SILENT);
2130 migration_incoming_state_new(f);
2131
2132 aio_context_acquire(aio_context);
2133 ret = qemu_loadvm_state(f);
2134 qemu_fclose(f);
2135 aio_context_release(aio_context);
2136
2137 migration_incoming_state_destroy();
2138 if (ret < 0) {
2139 error_report("Error %d while loading VM state", ret);
2140 return ret;
2141 }
2142
2143 return 0;
2144 }
2145
2146 void hmp_delvm(Monitor *mon, const QDict *qdict)
2147 {
2148 BlockDriverState *bs;
2149 Error *err;
2150 const char *name = qdict_get_str(qdict, "name");
2151
2152 if (bdrv_all_delete_snapshot(name, &bs, &err) < 0) {
2153 error_reportf_err(err,
2154 "Error while deleting snapshot on device '%s': ",
2155 bdrv_get_device_name(bs));
2156 }
2157 }
2158
2159 void hmp_info_snapshots(Monitor *mon, const QDict *qdict)
2160 {
2161 BlockDriverState *bs, *bs1;
2162 QEMUSnapshotInfo *sn_tab, *sn;
2163 int nb_sns, i;
2164 int total;
2165 int *available_snapshots;
2166 AioContext *aio_context;
2167
2168 bs = bdrv_all_find_vmstate_bs();
2169 if (!bs) {
2170 monitor_printf(mon, "No available block device supports snapshots\n");
2171 return;
2172 }
2173 aio_context = bdrv_get_aio_context(bs);
2174
2175 aio_context_acquire(aio_context);
2176 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2177 aio_context_release(aio_context);
2178
2179 if (nb_sns < 0) {
2180 monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
2181 return;
2182 }
2183
2184 if (nb_sns == 0) {
2185 monitor_printf(mon, "There is no snapshot available.\n");
2186 return;
2187 }
2188
2189 available_snapshots = g_new0(int, nb_sns);
2190 total = 0;
2191 for (i = 0; i < nb_sns; i++) {
2192 if (bdrv_all_find_snapshot(sn_tab[i].id_str, &bs1) == 0) {
2193 available_snapshots[total] = i;
2194 total++;
2195 }
2196 }
2197
2198 if (total > 0) {
2199 bdrv_snapshot_dump((fprintf_function)monitor_printf, mon, NULL);
2200 monitor_printf(mon, "\n");
2201 for (i = 0; i < total; i++) {
2202 sn = &sn_tab[available_snapshots[i]];
2203 bdrv_snapshot_dump((fprintf_function)monitor_printf, mon, sn);
2204 monitor_printf(mon, "\n");
2205 }
2206 } else {
2207 monitor_printf(mon, "There is no suitable snapshot available\n");
2208 }
2209
2210 g_free(sn_tab);
2211 g_free(available_snapshots);
2212
2213 }
2214
2215 void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
2216 {
2217 qemu_ram_set_idstr(mr->ram_block,
2218 memory_region_name(mr), dev);
2219 }
2220
2221 void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev)
2222 {
2223 qemu_ram_unset_idstr(mr->ram_block);
2224 }
2225
2226 void vmstate_register_ram_global(MemoryRegion *mr)
2227 {
2228 vmstate_register_ram(mr, NULL);
2229 }