4 * Copyright (c) 2003-2008 Fabrice Bellard
5 * Copyright (c) 2009-2015 Red Hat Inc
8 * Juan Quintela <quintela@redhat.com>
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:
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
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
29 #include "config-host.h"
30 #include "qemu-common.h"
31 #include "hw/boards.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 "qapi/qmp/qerror.h"
41 #include "qemu/error-report.h"
42 #include "qemu/sockets.h"
43 #include "qemu/queue.h"
44 #include "sysemu/cpus.h"
45 #include "exec/memory.h"
46 #include "qmp-commands.h"
49 #include "block/snapshot.h"
50 #include "block/qapi.h"
54 #define ETH_P_RARP 0x8035
56 #define ARP_HTYPE_ETH 0x0001
57 #define ARP_PTYPE_IP 0x0800
58 #define ARP_OP_REQUEST_REV 0x3
60 static bool skip_section_footers
;
62 static struct mig_cmd_args
{
63 ssize_t len
; /* -1 = variable */
66 [MIG_CMD_INVALID
] = { .len
= -1, .name
= "INVALID" },
67 [MIG_CMD_OPEN_RETURN_PATH
] = { .len
= 0, .name
= "OPEN_RETURN_PATH" },
68 [MIG_CMD_PING
] = { .len
= sizeof(uint32_t), .name
= "PING" },
69 [MIG_CMD_MAX
] = { .len
= -1, .name
= "MAX" },
72 static int announce_self_create(uint8_t *buf
,
75 /* Ethernet header. */
76 memset(buf
, 0xff, 6); /* destination MAC addr */
77 memcpy(buf
+ 6, mac_addr
, 6); /* source MAC addr */
78 *(uint16_t *)(buf
+ 12) = htons(ETH_P_RARP
); /* ethertype */
81 *(uint16_t *)(buf
+ 14) = htons(ARP_HTYPE_ETH
); /* hardware addr space */
82 *(uint16_t *)(buf
+ 16) = htons(ARP_PTYPE_IP
); /* protocol addr space */
83 *(buf
+ 18) = 6; /* hardware addr length (ethernet) */
84 *(buf
+ 19) = 4; /* protocol addr length (IPv4) */
85 *(uint16_t *)(buf
+ 20) = htons(ARP_OP_REQUEST_REV
); /* opcode */
86 memcpy(buf
+ 22, mac_addr
, 6); /* source hw addr */
87 memset(buf
+ 28, 0x00, 4); /* source protocol addr */
88 memcpy(buf
+ 32, mac_addr
, 6); /* target hw addr */
89 memset(buf
+ 38, 0x00, 4); /* target protocol addr */
91 /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
92 memset(buf
+ 42, 0x00, 18);
94 return 60; /* len (FCS will be added by hardware) */
97 static void qemu_announce_self_iter(NICState
*nic
, void *opaque
)
102 trace_qemu_announce_self_iter(qemu_ether_ntoa(&nic
->conf
->macaddr
));
103 len
= announce_self_create(buf
, nic
->conf
->macaddr
.a
);
105 qemu_send_packet_raw(qemu_get_queue(nic
), buf
, len
);
109 static void qemu_announce_self_once(void *opaque
)
111 static int count
= SELF_ANNOUNCE_ROUNDS
;
112 QEMUTimer
*timer
= *(QEMUTimer
**)opaque
;
114 qemu_foreach_nic(qemu_announce_self_iter
, NULL
);
117 /* delay 50ms, 150ms, 250ms, ... */
118 timer_mod(timer
, qemu_clock_get_ms(QEMU_CLOCK_REALTIME
) +
119 self_announce_delay(count
));
126 void qemu_announce_self(void)
128 static QEMUTimer
*timer
;
129 timer
= timer_new_ms(QEMU_CLOCK_REALTIME
, qemu_announce_self_once
, &timer
);
130 qemu_announce_self_once(&timer
);
133 /***********************************************************/
134 /* savevm/loadvm support */
136 static ssize_t
block_writev_buffer(void *opaque
, struct iovec
*iov
, int iovcnt
,
142 qemu_iovec_init_external(&qiov
, iov
, iovcnt
);
143 ret
= bdrv_writev_vmstate(opaque
, &qiov
, pos
);
151 static ssize_t
block_put_buffer(void *opaque
, const uint8_t *buf
,
152 int64_t pos
, size_t size
)
154 bdrv_save_vmstate(opaque
, buf
, pos
, size
);
158 static ssize_t
block_get_buffer(void *opaque
, uint8_t *buf
, int64_t pos
,
161 return bdrv_load_vmstate(opaque
, buf
, pos
, size
);
164 static int bdrv_fclose(void *opaque
)
166 return bdrv_flush(opaque
);
169 static const QEMUFileOps bdrv_read_ops
= {
170 .get_buffer
= block_get_buffer
,
174 static const QEMUFileOps bdrv_write_ops
= {
175 .put_buffer
= block_put_buffer
,
176 .writev_buffer
= block_writev_buffer
,
180 static QEMUFile
*qemu_fopen_bdrv(BlockDriverState
*bs
, int is_writable
)
183 return qemu_fopen_ops(bs
, &bdrv_write_ops
);
185 return qemu_fopen_ops(bs
, &bdrv_read_ops
);
189 /* QEMUFile timer support.
190 * Not in qemu-file.c to not add qemu-timer.c as dependency to qemu-file.c
193 void timer_put(QEMUFile
*f
, QEMUTimer
*ts
)
195 uint64_t expire_time
;
197 expire_time
= timer_expire_time_ns(ts
);
198 qemu_put_be64(f
, expire_time
);
201 void timer_get(QEMUFile
*f
, QEMUTimer
*ts
)
203 uint64_t expire_time
;
205 expire_time
= qemu_get_be64(f
);
206 if (expire_time
!= -1) {
207 timer_mod_ns(ts
, expire_time
);
214 /* VMState timer support.
215 * Not in vmstate.c to not add qemu-timer.c as dependency to vmstate.c
218 static int get_timer(QEMUFile
*f
, void *pv
, size_t size
)
225 static void put_timer(QEMUFile
*f
, void *pv
, size_t size
)
231 const VMStateInfo vmstate_info_timer
= {
238 typedef struct CompatEntry
{
243 typedef struct SaveStateEntry
{
244 QTAILQ_ENTRY(SaveStateEntry
) entry
;
251 const VMStateDescription
*vmsd
;
257 typedef struct SaveState
{
258 QTAILQ_HEAD(, SaveStateEntry
) handlers
;
259 int global_section_id
;
260 bool skip_configuration
;
265 static SaveState savevm_state
= {
266 .handlers
= QTAILQ_HEAD_INITIALIZER(savevm_state
.handlers
),
267 .global_section_id
= 0,
268 .skip_configuration
= false,
271 void savevm_skip_configuration(void)
273 savevm_state
.skip_configuration
= true;
277 static void configuration_pre_save(void *opaque
)
279 SaveState
*state
= opaque
;
280 const char *current_name
= MACHINE_GET_CLASS(current_machine
)->name
;
282 state
->len
= strlen(current_name
);
283 state
->name
= current_name
;
286 static int configuration_post_load(void *opaque
, int version_id
)
288 SaveState
*state
= opaque
;
289 const char *current_name
= MACHINE_GET_CLASS(current_machine
)->name
;
291 if (strncmp(state
->name
, current_name
, state
->len
) != 0) {
292 error_report("Machine type received is '%s' and local is '%s'",
293 state
->name
, current_name
);
299 static const VMStateDescription vmstate_configuration
= {
300 .name
= "configuration",
302 .post_load
= configuration_post_load
,
303 .pre_save
= configuration_pre_save
,
304 .fields
= (VMStateField
[]) {
305 VMSTATE_UINT32(len
, SaveState
),
306 VMSTATE_VBUFFER_ALLOC_UINT32(name
, SaveState
, 0, NULL
, 0, len
),
307 VMSTATE_END_OF_LIST()
311 static void dump_vmstate_vmsd(FILE *out_file
,
312 const VMStateDescription
*vmsd
, int indent
,
315 static void dump_vmstate_vmsf(FILE *out_file
, const VMStateField
*field
,
318 fprintf(out_file
, "%*s{\n", indent
, "");
320 fprintf(out_file
, "%*s\"field\": \"%s\",\n", indent
, "", field
->name
);
321 fprintf(out_file
, "%*s\"version_id\": %d,\n", indent
, "",
323 fprintf(out_file
, "%*s\"field_exists\": %s,\n", indent
, "",
324 field
->field_exists
? "true" : "false");
325 fprintf(out_file
, "%*s\"size\": %zu", indent
, "", field
->size
);
326 if (field
->vmsd
!= NULL
) {
327 fprintf(out_file
, ",\n");
328 dump_vmstate_vmsd(out_file
, field
->vmsd
, indent
, false);
330 fprintf(out_file
, "\n%*s}", indent
- 2, "");
333 static void dump_vmstate_vmss(FILE *out_file
,
334 const VMStateDescription
**subsection
,
337 if (*subsection
!= NULL
) {
338 dump_vmstate_vmsd(out_file
, *subsection
, indent
, true);
342 static void dump_vmstate_vmsd(FILE *out_file
,
343 const VMStateDescription
*vmsd
, int indent
,
347 fprintf(out_file
, "%*s{\n", indent
, "");
349 fprintf(out_file
, "%*s\"%s\": {\n", indent
, "", "Description");
352 fprintf(out_file
, "%*s\"name\": \"%s\",\n", indent
, "", vmsd
->name
);
353 fprintf(out_file
, "%*s\"version_id\": %d,\n", indent
, "",
355 fprintf(out_file
, "%*s\"minimum_version_id\": %d", indent
, "",
356 vmsd
->minimum_version_id
);
357 if (vmsd
->fields
!= NULL
) {
358 const VMStateField
*field
= vmsd
->fields
;
361 fprintf(out_file
, ",\n%*s\"Fields\": [\n", indent
, "");
363 while (field
->name
!= NULL
) {
364 if (field
->flags
& VMS_MUST_EXIST
) {
365 /* Ignore VMSTATE_VALIDATE bits; these don't get migrated */
370 fprintf(out_file
, ",\n");
372 dump_vmstate_vmsf(out_file
, field
, indent
+ 2);
376 fprintf(out_file
, "\n%*s]", indent
, "");
378 if (vmsd
->subsections
!= NULL
) {
379 const VMStateDescription
**subsection
= vmsd
->subsections
;
382 fprintf(out_file
, ",\n%*s\"Subsections\": [\n", indent
, "");
384 while (*subsection
!= NULL
) {
386 fprintf(out_file
, ",\n");
388 dump_vmstate_vmss(out_file
, subsection
, indent
+ 2);
392 fprintf(out_file
, "\n%*s]", indent
, "");
394 fprintf(out_file
, "\n%*s}", indent
- 2, "");
397 static void dump_machine_type(FILE *out_file
)
401 mc
= MACHINE_GET_CLASS(current_machine
);
403 fprintf(out_file
, " \"vmschkmachine\": {\n");
404 fprintf(out_file
, " \"Name\": \"%s\"\n", mc
->name
);
405 fprintf(out_file
, " },\n");
408 void dump_vmstate_json_to_file(FILE *out_file
)
413 fprintf(out_file
, "{\n");
414 dump_machine_type(out_file
);
417 list
= object_class_get_list(TYPE_DEVICE
, true);
418 for (elt
= list
; elt
; elt
= elt
->next
) {
419 DeviceClass
*dc
= OBJECT_CLASS_CHECK(DeviceClass
, elt
->data
,
429 fprintf(out_file
, ",\n");
431 name
= object_class_get_name(OBJECT_CLASS(dc
));
432 fprintf(out_file
, "%*s\"%s\": {\n", indent
, "", name
);
434 fprintf(out_file
, "%*s\"Name\": \"%s\",\n", indent
, "", name
);
435 fprintf(out_file
, "%*s\"version_id\": %d,\n", indent
, "",
436 dc
->vmsd
->version_id
);
437 fprintf(out_file
, "%*s\"minimum_version_id\": %d,\n", indent
, "",
438 dc
->vmsd
->minimum_version_id
);
440 dump_vmstate_vmsd(out_file
, dc
->vmsd
, indent
, false);
442 fprintf(out_file
, "\n%*s}", indent
- 2, "");
445 fprintf(out_file
, "\n}\n");
449 static int calculate_new_instance_id(const char *idstr
)
454 QTAILQ_FOREACH(se
, &savevm_state
.handlers
, entry
) {
455 if (strcmp(idstr
, se
->idstr
) == 0
456 && instance_id
<= se
->instance_id
) {
457 instance_id
= se
->instance_id
+ 1;
463 static int calculate_compat_instance_id(const char *idstr
)
468 QTAILQ_FOREACH(se
, &savevm_state
.handlers
, entry
) {
473 if (strcmp(idstr
, se
->compat
->idstr
) == 0
474 && instance_id
<= se
->compat
->instance_id
) {
475 instance_id
= se
->compat
->instance_id
+ 1;
481 /* TODO: Individual devices generally have very little idea about the rest
482 of the system, so instance_id should be removed/replaced.
483 Meanwhile pass -1 as instance_id if you do not already have a clearly
484 distinguishing id for all instances of your device class. */
485 int register_savevm_live(DeviceState
*dev
,
494 se
= g_new0(SaveStateEntry
, 1);
495 se
->version_id
= version_id
;
496 se
->section_id
= savevm_state
.global_section_id
++;
500 /* if this is a live_savem then set is_ram */
501 if (ops
->save_live_setup
!= NULL
) {
506 char *id
= qdev_get_dev_path(dev
);
508 pstrcpy(se
->idstr
, sizeof(se
->idstr
), id
);
509 pstrcat(se
->idstr
, sizeof(se
->idstr
), "/");
512 se
->compat
= g_new0(CompatEntry
, 1);
513 pstrcpy(se
->compat
->idstr
, sizeof(se
->compat
->idstr
), idstr
);
514 se
->compat
->instance_id
= instance_id
== -1 ?
515 calculate_compat_instance_id(idstr
) : instance_id
;
519 pstrcat(se
->idstr
, sizeof(se
->idstr
), idstr
);
521 if (instance_id
== -1) {
522 se
->instance_id
= calculate_new_instance_id(se
->idstr
);
524 se
->instance_id
= instance_id
;
526 assert(!se
->compat
|| se
->instance_id
== 0);
527 /* add at the end of list */
528 QTAILQ_INSERT_TAIL(&savevm_state
.handlers
, se
, entry
);
532 int register_savevm(DeviceState
*dev
,
536 SaveStateHandler
*save_state
,
537 LoadStateHandler
*load_state
,
540 SaveVMHandlers
*ops
= g_new0(SaveVMHandlers
, 1);
541 ops
->save_state
= save_state
;
542 ops
->load_state
= load_state
;
543 return register_savevm_live(dev
, idstr
, instance_id
, version_id
,
547 void unregister_savevm(DeviceState
*dev
, const char *idstr
, void *opaque
)
549 SaveStateEntry
*se
, *new_se
;
553 char *path
= qdev_get_dev_path(dev
);
555 pstrcpy(id
, sizeof(id
), path
);
556 pstrcat(id
, sizeof(id
), "/");
560 pstrcat(id
, sizeof(id
), idstr
);
562 QTAILQ_FOREACH_SAFE(se
, &savevm_state
.handlers
, entry
, new_se
) {
563 if (strcmp(se
->idstr
, id
) == 0 && se
->opaque
== opaque
) {
564 QTAILQ_REMOVE(&savevm_state
.handlers
, se
, entry
);
572 int vmstate_register_with_alias_id(DeviceState
*dev
, int instance_id
,
573 const VMStateDescription
*vmsd
,
574 void *opaque
, int alias_id
,
575 int required_for_version
)
579 /* If this triggers, alias support can be dropped for the vmsd. */
580 assert(alias_id
== -1 || required_for_version
>= vmsd
->minimum_version_id
);
582 se
= g_new0(SaveStateEntry
, 1);
583 se
->version_id
= vmsd
->version_id
;
584 se
->section_id
= savevm_state
.global_section_id
++;
587 se
->alias_id
= alias_id
;
590 char *id
= qdev_get_dev_path(dev
);
592 pstrcpy(se
->idstr
, sizeof(se
->idstr
), id
);
593 pstrcat(se
->idstr
, sizeof(se
->idstr
), "/");
596 se
->compat
= g_new0(CompatEntry
, 1);
597 pstrcpy(se
->compat
->idstr
, sizeof(se
->compat
->idstr
), vmsd
->name
);
598 se
->compat
->instance_id
= instance_id
== -1 ?
599 calculate_compat_instance_id(vmsd
->name
) : instance_id
;
603 pstrcat(se
->idstr
, sizeof(se
->idstr
), vmsd
->name
);
605 if (instance_id
== -1) {
606 se
->instance_id
= calculate_new_instance_id(se
->idstr
);
608 se
->instance_id
= instance_id
;
610 assert(!se
->compat
|| se
->instance_id
== 0);
611 /* add at the end of list */
612 QTAILQ_INSERT_TAIL(&savevm_state
.handlers
, se
, entry
);
616 void vmstate_unregister(DeviceState
*dev
, const VMStateDescription
*vmsd
,
619 SaveStateEntry
*se
, *new_se
;
621 QTAILQ_FOREACH_SAFE(se
, &savevm_state
.handlers
, entry
, new_se
) {
622 if (se
->vmsd
== vmsd
&& se
->opaque
== opaque
) {
623 QTAILQ_REMOVE(&savevm_state
.handlers
, se
, entry
);
630 static int vmstate_load(QEMUFile
*f
, SaveStateEntry
*se
, int version_id
)
632 trace_vmstate_load(se
->idstr
, se
->vmsd
? se
->vmsd
->name
: "(old)");
633 if (!se
->vmsd
) { /* Old style */
634 return se
->ops
->load_state(f
, se
->opaque
, version_id
);
636 return vmstate_load_state(f
, se
->vmsd
, se
->opaque
, version_id
);
639 static void vmstate_save_old_style(QEMUFile
*f
, SaveStateEntry
*se
, QJSON
*vmdesc
)
641 int64_t old_offset
, size
;
643 old_offset
= qemu_ftell_fast(f
);
644 se
->ops
->save_state(f
, se
->opaque
);
645 size
= qemu_ftell_fast(f
) - old_offset
;
648 json_prop_int(vmdesc
, "size", size
);
649 json_start_array(vmdesc
, "fields");
650 json_start_object(vmdesc
, NULL
);
651 json_prop_str(vmdesc
, "name", "data");
652 json_prop_int(vmdesc
, "size", size
);
653 json_prop_str(vmdesc
, "type", "buffer");
654 json_end_object(vmdesc
);
655 json_end_array(vmdesc
);
659 static void vmstate_save(QEMUFile
*f
, SaveStateEntry
*se
, QJSON
*vmdesc
)
661 trace_vmstate_save(se
->idstr
, se
->vmsd
? se
->vmsd
->name
: "(old)");
663 vmstate_save_old_style(f
, se
, vmdesc
);
666 vmstate_save_state(f
, se
->vmsd
, se
->opaque
, vmdesc
);
669 void savevm_skip_section_footers(void)
671 skip_section_footers
= true;
675 * Write the header for device section (QEMU_VM_SECTION START/END/PART/FULL)
677 static void save_section_header(QEMUFile
*f
, SaveStateEntry
*se
,
678 uint8_t section_type
)
680 qemu_put_byte(f
, section_type
);
681 qemu_put_be32(f
, se
->section_id
);
683 if (section_type
== QEMU_VM_SECTION_FULL
||
684 section_type
== QEMU_VM_SECTION_START
) {
686 size_t len
= strlen(se
->idstr
);
687 qemu_put_byte(f
, len
);
688 qemu_put_buffer(f
, (uint8_t *)se
->idstr
, len
);
690 qemu_put_be32(f
, se
->instance_id
);
691 qemu_put_be32(f
, se
->version_id
);
696 * Write a footer onto device sections that catches cases misformatted device
699 static void save_section_footer(QEMUFile
*f
, SaveStateEntry
*se
)
701 if (!skip_section_footers
) {
702 qemu_put_byte(f
, QEMU_VM_SECTION_FOOTER
);
703 qemu_put_be32(f
, se
->section_id
);
708 * qemu_savevm_command_send: Send a 'QEMU_VM_COMMAND' type element with the
709 * command and associated data.
711 * @f: File to send command on
712 * @command: Command type to send
713 * @len: Length of associated data
714 * @data: Data associated with command.
716 void qemu_savevm_command_send(QEMUFile
*f
,
717 enum qemu_vm_cmd command
,
721 trace_savevm_command_send(command
, len
);
722 qemu_put_byte(f
, QEMU_VM_COMMAND
);
723 qemu_put_be16(f
, (uint16_t)command
);
724 qemu_put_be16(f
, len
);
725 qemu_put_buffer(f
, data
, len
);
729 void qemu_savevm_send_ping(QEMUFile
*f
, uint32_t value
)
733 trace_savevm_send_ping(value
);
734 buf
= cpu_to_be32(value
);
735 qemu_savevm_command_send(f
, MIG_CMD_PING
, sizeof(value
), (uint8_t *)&buf
);
738 void qemu_savevm_send_open_return_path(QEMUFile
*f
)
740 trace_savevm_send_open_return_path();
741 qemu_savevm_command_send(f
, MIG_CMD_OPEN_RETURN_PATH
, 0, NULL
);
744 bool qemu_savevm_state_blocked(Error
**errp
)
748 QTAILQ_FOREACH(se
, &savevm_state
.handlers
, entry
) {
749 if (se
->vmsd
&& se
->vmsd
->unmigratable
) {
750 error_setg(errp
, "State blocked by non-migratable device '%s'",
758 void qemu_savevm_state_header(QEMUFile
*f
)
760 trace_savevm_state_header();
761 qemu_put_be32(f
, QEMU_VM_FILE_MAGIC
);
762 qemu_put_be32(f
, QEMU_VM_FILE_VERSION
);
764 if (!savevm_state
.skip_configuration
) {
765 qemu_put_byte(f
, QEMU_VM_CONFIGURATION
);
766 vmstate_save_state(f
, &vmstate_configuration
, &savevm_state
, 0);
771 void qemu_savevm_state_begin(QEMUFile
*f
,
772 const MigrationParams
*params
)
777 trace_savevm_state_begin();
778 QTAILQ_FOREACH(se
, &savevm_state
.handlers
, entry
) {
779 if (!se
->ops
|| !se
->ops
->set_params
) {
782 se
->ops
->set_params(params
, se
->opaque
);
785 QTAILQ_FOREACH(se
, &savevm_state
.handlers
, entry
) {
786 if (!se
->ops
|| !se
->ops
->save_live_setup
) {
789 if (se
->ops
&& se
->ops
->is_active
) {
790 if (!se
->ops
->is_active(se
->opaque
)) {
794 save_section_header(f
, se
, QEMU_VM_SECTION_START
);
796 ret
= se
->ops
->save_live_setup(f
, se
->opaque
);
797 save_section_footer(f
, se
);
799 qemu_file_set_error(f
, ret
);
806 * this function has three return values:
807 * negative: there was one error, and we have -errno.
808 * 0 : We haven't finished, caller have to go again
809 * 1 : We have finished, we can go to complete phase
811 int qemu_savevm_state_iterate(QEMUFile
*f
)
816 trace_savevm_state_iterate();
817 QTAILQ_FOREACH(se
, &savevm_state
.handlers
, entry
) {
818 if (!se
->ops
|| !se
->ops
->save_live_iterate
) {
821 if (se
->ops
&& se
->ops
->is_active
) {
822 if (!se
->ops
->is_active(se
->opaque
)) {
826 if (qemu_file_rate_limit(f
)) {
829 trace_savevm_section_start(se
->idstr
, se
->section_id
);
831 save_section_header(f
, se
, QEMU_VM_SECTION_PART
);
833 ret
= se
->ops
->save_live_iterate(f
, se
->opaque
);
834 trace_savevm_section_end(se
->idstr
, se
->section_id
, ret
);
835 save_section_footer(f
, se
);
838 qemu_file_set_error(f
, ret
);
841 /* Do not proceed to the next vmstate before this one reported
842 completion of the current stage. This serializes the migration
843 and reduces the probability that a faster changing state is
844 synchronized over and over again. */
851 static bool should_send_vmdesc(void)
853 MachineState
*machine
= MACHINE(qdev_get_machine());
854 return !machine
->suppress_vmdesc
;
857 void qemu_savevm_state_complete_precopy(QEMUFile
*f
)
864 trace_savevm_state_complete_precopy();
866 cpu_synchronize_all_states();
868 QTAILQ_FOREACH(se
, &savevm_state
.handlers
, entry
) {
869 if (!se
->ops
|| !se
->ops
->save_live_complete_precopy
) {
872 if (se
->ops
&& se
->ops
->is_active
) {
873 if (!se
->ops
->is_active(se
->opaque
)) {
877 trace_savevm_section_start(se
->idstr
, se
->section_id
);
879 save_section_header(f
, se
, QEMU_VM_SECTION_END
);
881 ret
= se
->ops
->save_live_complete_precopy(f
, se
->opaque
);
882 trace_savevm_section_end(se
->idstr
, se
->section_id
, ret
);
883 save_section_footer(f
, se
);
885 qemu_file_set_error(f
, ret
);
890 vmdesc
= qjson_new();
891 json_prop_int(vmdesc
, "page_size", TARGET_PAGE_SIZE
);
892 json_start_array(vmdesc
, "devices");
893 QTAILQ_FOREACH(se
, &savevm_state
.handlers
, entry
) {
895 if ((!se
->ops
|| !se
->ops
->save_state
) && !se
->vmsd
) {
898 if (se
->vmsd
&& !vmstate_save_needed(se
->vmsd
, se
->opaque
)) {
899 trace_savevm_section_skip(se
->idstr
, se
->section_id
);
903 trace_savevm_section_start(se
->idstr
, se
->section_id
);
905 json_start_object(vmdesc
, NULL
);
906 json_prop_str(vmdesc
, "name", se
->idstr
);
907 json_prop_int(vmdesc
, "instance_id", se
->instance_id
);
909 save_section_header(f
, se
, QEMU_VM_SECTION_FULL
);
911 vmstate_save(f
, se
, vmdesc
);
913 json_end_object(vmdesc
);
914 trace_savevm_section_end(se
->idstr
, se
->section_id
, 0);
915 save_section_footer(f
, se
);
918 qemu_put_byte(f
, QEMU_VM_EOF
);
920 json_end_array(vmdesc
);
921 qjson_finish(vmdesc
);
922 vmdesc_len
= strlen(qjson_get_str(vmdesc
));
924 if (should_send_vmdesc()) {
925 qemu_put_byte(f
, QEMU_VM_VMDESCRIPTION
);
926 qemu_put_be32(f
, vmdesc_len
);
927 qemu_put_buffer(f
, (uint8_t *)qjson_get_str(vmdesc
), vmdesc_len
);
929 object_unref(OBJECT(vmdesc
));
934 uint64_t qemu_savevm_state_pending(QEMUFile
*f
, uint64_t max_size
)
939 QTAILQ_FOREACH(se
, &savevm_state
.handlers
, entry
) {
940 if (!se
->ops
|| !se
->ops
->save_live_pending
) {
943 if (se
->ops
&& se
->ops
->is_active
) {
944 if (!se
->ops
->is_active(se
->opaque
)) {
948 ret
+= se
->ops
->save_live_pending(f
, se
->opaque
, max_size
);
953 void qemu_savevm_state_cleanup(void)
957 trace_savevm_state_cleanup();
958 QTAILQ_FOREACH(se
, &savevm_state
.handlers
, entry
) {
959 if (se
->ops
&& se
->ops
->cleanup
) {
960 se
->ops
->cleanup(se
->opaque
);
965 static int qemu_savevm_state(QEMUFile
*f
, Error
**errp
)
968 MigrationParams params
= {
972 MigrationState
*ms
= migrate_init(¶ms
);
975 if (qemu_savevm_state_blocked(errp
)) {
979 qemu_mutex_unlock_iothread();
980 qemu_savevm_state_header(f
);
981 qemu_savevm_state_begin(f
, ¶ms
);
982 qemu_mutex_lock_iothread();
984 while (qemu_file_get_error(f
) == 0) {
985 if (qemu_savevm_state_iterate(f
) > 0) {
990 ret
= qemu_file_get_error(f
);
992 qemu_savevm_state_complete_precopy(f
);
993 ret
= qemu_file_get_error(f
);
996 qemu_savevm_state_cleanup();
997 error_setg_errno(errp
, -ret
, "Error while writing VM state");
1002 static int qemu_save_device_state(QEMUFile
*f
)
1006 qemu_put_be32(f
, QEMU_VM_FILE_MAGIC
);
1007 qemu_put_be32(f
, QEMU_VM_FILE_VERSION
);
1009 cpu_synchronize_all_states();
1011 QTAILQ_FOREACH(se
, &savevm_state
.handlers
, entry
) {
1015 if ((!se
->ops
|| !se
->ops
->save_state
) && !se
->vmsd
) {
1018 if (se
->vmsd
&& !vmstate_save_needed(se
->vmsd
, se
->opaque
)) {
1022 save_section_header(f
, se
, QEMU_VM_SECTION_FULL
);
1024 vmstate_save(f
, se
, NULL
);
1026 save_section_footer(f
, se
);
1029 qemu_put_byte(f
, QEMU_VM_EOF
);
1031 return qemu_file_get_error(f
);
1034 static SaveStateEntry
*find_se(const char *idstr
, int instance_id
)
1038 QTAILQ_FOREACH(se
, &savevm_state
.handlers
, entry
) {
1039 if (!strcmp(se
->idstr
, idstr
) &&
1040 (instance_id
== se
->instance_id
||
1041 instance_id
== se
->alias_id
))
1043 /* Migrating from an older version? */
1044 if (strstr(se
->idstr
, idstr
) && se
->compat
) {
1045 if (!strcmp(se
->compat
->idstr
, idstr
) &&
1046 (instance_id
== se
->compat
->instance_id
||
1047 instance_id
== se
->alias_id
))
1055 * loadvm_process_command: Process an incoming 'QEMU_VM_COMMAND'
1057 * Returns: 0 on success, negative on error (in which case it will issue an
1059 * @f: The stream to read the command data from.
1061 static int loadvm_process_command(QEMUFile
*f
)
1063 MigrationIncomingState
*mis
= migration_incoming_get_current();
1068 cmd
= qemu_get_be16(f
);
1069 len
= qemu_get_be16(f
);
1071 trace_loadvm_process_command(cmd
, len
);
1072 if (cmd
>= MIG_CMD_MAX
|| cmd
== MIG_CMD_INVALID
) {
1073 error_report("MIG_CMD 0x%x unknown (len 0x%x)", cmd
, len
);
1077 if (mig_cmd_args
[cmd
].len
!= -1 && mig_cmd_args
[cmd
].len
!= len
) {
1078 error_report("%s received with bad length - expecting %zu, got %d",
1079 mig_cmd_args
[cmd
].name
,
1080 (size_t)mig_cmd_args
[cmd
].len
, len
);
1085 case MIG_CMD_OPEN_RETURN_PATH
:
1086 if (mis
->to_src_file
) {
1087 error_report("CMD_OPEN_RETURN_PATH called when RP already open");
1088 /* Not really a problem, so don't give up */
1091 mis
->to_src_file
= qemu_file_get_return_path(f
);
1092 if (!mis
->to_src_file
) {
1093 error_report("CMD_OPEN_RETURN_PATH failed");
1099 tmp32
= qemu_get_be32(f
);
1100 trace_loadvm_process_command_ping(tmp32
);
1101 if (!mis
->to_src_file
) {
1102 error_report("CMD_PING (0x%x) received with no return path",
1106 /* migrate_send_rp_pong(mis, tmp32); TODO: gets added later */
1113 struct LoadStateEntry
{
1114 QLIST_ENTRY(LoadStateEntry
) entry
;
1121 * Read a footer off the wire and check that it matches the expected section
1123 * Returns: true if the footer was good
1124 * false if there is a problem (and calls error_report to say why)
1126 static bool check_section_footer(QEMUFile
*f
, LoadStateEntry
*le
)
1129 uint32_t read_section_id
;
1131 if (skip_section_footers
) {
1132 /* No footer to check */
1136 read_mark
= qemu_get_byte(f
);
1138 if (read_mark
!= QEMU_VM_SECTION_FOOTER
) {
1139 error_report("Missing section footer for %s", le
->se
->idstr
);
1143 read_section_id
= qemu_get_be32(f
);
1144 if (read_section_id
!= le
->section_id
) {
1145 error_report("Mismatched section id in footer for %s -"
1146 " read 0x%x expected 0x%x",
1147 le
->se
->idstr
, read_section_id
, le
->section_id
);
1155 void loadvm_free_handlers(MigrationIncomingState
*mis
)
1157 LoadStateEntry
*le
, *new_le
;
1159 QLIST_FOREACH_SAFE(le
, &mis
->loadvm_handlers
, entry
, new_le
) {
1160 QLIST_REMOVE(le
, entry
);
1165 int qemu_loadvm_state(QEMUFile
*f
)
1167 MigrationIncomingState
*mis
= migration_incoming_get_current();
1168 Error
*local_err
= NULL
;
1169 uint8_t section_type
;
1172 int file_error_after_eof
= -1;
1174 if (qemu_savevm_state_blocked(&local_err
)) {
1175 error_report_err(local_err
);
1179 v
= qemu_get_be32(f
);
1180 if (v
!= QEMU_VM_FILE_MAGIC
) {
1181 error_report("Not a migration stream");
1185 v
= qemu_get_be32(f
);
1186 if (v
== QEMU_VM_FILE_VERSION_COMPAT
) {
1187 error_report("SaveVM v2 format is obsolete and don't work anymore");
1190 if (v
!= QEMU_VM_FILE_VERSION
) {
1191 error_report("Unsupported migration stream version");
1195 if (!savevm_state
.skip_configuration
) {
1196 if (qemu_get_byte(f
) != QEMU_VM_CONFIGURATION
) {
1197 error_report("Configuration section missing");
1200 ret
= vmstate_load_state(f
, &vmstate_configuration
, &savevm_state
, 0);
1207 while ((section_type
= qemu_get_byte(f
)) != QEMU_VM_EOF
) {
1208 uint32_t instance_id
, version_id
, section_id
;
1213 trace_qemu_loadvm_state_section(section_type
);
1214 switch (section_type
) {
1215 case QEMU_VM_SECTION_START
:
1216 case QEMU_VM_SECTION_FULL
:
1217 /* Read section start */
1218 section_id
= qemu_get_be32(f
);
1219 if (!qemu_get_counted_string(f
, idstr
)) {
1220 error_report("Unable to read ID string for section %u",
1224 instance_id
= qemu_get_be32(f
);
1225 version_id
= qemu_get_be32(f
);
1227 trace_qemu_loadvm_state_section_startfull(section_id
, idstr
,
1228 instance_id
, version_id
);
1229 /* Find savevm section */
1230 se
= find_se(idstr
, instance_id
);
1232 error_report("Unknown savevm section or instance '%s' %d",
1233 idstr
, instance_id
);
1238 /* Validate version */
1239 if (version_id
> se
->version_id
) {
1240 error_report("savevm: unsupported version %d for '%s' v%d",
1241 version_id
, idstr
, se
->version_id
);
1247 le
= g_malloc0(sizeof(*le
));
1250 le
->section_id
= section_id
;
1251 le
->version_id
= version_id
;
1252 QLIST_INSERT_HEAD(&mis
->loadvm_handlers
, le
, entry
);
1254 ret
= vmstate_load(f
, le
->se
, le
->version_id
);
1256 error_report("error while loading state for instance 0x%x of"
1257 " device '%s'", instance_id
, idstr
);
1260 if (!check_section_footer(f
, le
)) {
1265 case QEMU_VM_SECTION_PART
:
1266 case QEMU_VM_SECTION_END
:
1267 section_id
= qemu_get_be32(f
);
1269 trace_qemu_loadvm_state_section_partend(section_id
);
1270 QLIST_FOREACH(le
, &mis
->loadvm_handlers
, entry
) {
1271 if (le
->section_id
== section_id
) {
1276 error_report("Unknown savevm section %d", section_id
);
1281 ret
= vmstate_load(f
, le
->se
, le
->version_id
);
1283 error_report("error while loading state section id %d(%s)",
1284 section_id
, le
->se
->idstr
);
1287 if (!check_section_footer(f
, le
)) {
1292 case QEMU_VM_COMMAND
:
1293 ret
= loadvm_process_command(f
);
1299 error_report("Unknown savevm section type %d", section_type
);
1305 file_error_after_eof
= qemu_file_get_error(f
);
1308 * Try to read in the VMDESC section as well, so that dumping tools that
1309 * intercept our migration stream have the chance to see it.
1312 /* We've got to be careful; if we don't read the data and just shut the fd
1313 * then the sender can error if we close while it's still sending.
1314 * We also mustn't read data that isn't there; some transports (RDMA)
1315 * will stall waiting for that data when the source has already closed.
1317 if (should_send_vmdesc()) {
1320 section_type
= qemu_get_byte(f
);
1322 if (section_type
!= QEMU_VM_VMDESCRIPTION
) {
1323 error_report("Expected vmdescription section, but got %d",
1326 * It doesn't seem worth failing at this point since
1327 * we apparently have an otherwise valid VM state
1330 buf
= g_malloc(0x1000);
1331 size
= qemu_get_be32(f
);
1334 uint32_t read_chunk
= MIN(size
, 0x1000);
1335 qemu_get_buffer(f
, buf
, read_chunk
);
1342 cpu_synchronize_all_post_init();
1348 /* We may not have a VMDESC section, so ignore relative errors */
1349 ret
= file_error_after_eof
;
1355 static BlockDriverState
*find_vmstate_bs(void)
1357 BlockDriverState
*bs
= NULL
;
1358 while ((bs
= bdrv_next(bs
))) {
1359 if (bdrv_can_snapshot(bs
)) {
1367 * Deletes snapshots of a given name in all opened images.
1369 static int del_existing_snapshots(Monitor
*mon
, const char *name
)
1371 BlockDriverState
*bs
;
1372 QEMUSnapshotInfo sn1
, *snapshot
= &sn1
;
1376 while ((bs
= bdrv_next(bs
))) {
1377 if (bdrv_can_snapshot(bs
) &&
1378 bdrv_snapshot_find(bs
, snapshot
, name
) >= 0) {
1379 bdrv_snapshot_delete_by_id_or_name(bs
, name
, &err
);
1382 "Error while deleting snapshot on device '%s':"
1384 bdrv_get_device_name(bs
),
1385 error_get_pretty(err
));
1395 void hmp_savevm(Monitor
*mon
, const QDict
*qdict
)
1397 BlockDriverState
*bs
, *bs1
;
1398 QEMUSnapshotInfo sn1
, *sn
= &sn1
, old_sn1
, *old_sn
= &old_sn1
;
1401 int saved_vm_running
;
1402 uint64_t vm_state_size
;
1405 const char *name
= qdict_get_try_str(qdict
, "name");
1406 Error
*local_err
= NULL
;
1408 /* Verify if there is a device that doesn't support snapshots and is writable */
1410 while ((bs
= bdrv_next(bs
))) {
1412 if (!bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
1416 if (!bdrv_can_snapshot(bs
)) {
1417 monitor_printf(mon
, "Device '%s' is writable but does not support snapshots.\n",
1418 bdrv_get_device_name(bs
));
1423 bs
= find_vmstate_bs();
1425 monitor_printf(mon
, "No block device can accept snapshots\n");
1429 saved_vm_running
= runstate_is_running();
1431 ret
= global_state_store();
1433 monitor_printf(mon
, "Error saving global state\n");
1436 vm_stop(RUN_STATE_SAVE_VM
);
1438 memset(sn
, 0, sizeof(*sn
));
1440 /* fill auxiliary fields */
1441 qemu_gettimeofday(&tv
);
1442 sn
->date_sec
= tv
.tv_sec
;
1443 sn
->date_nsec
= tv
.tv_usec
* 1000;
1444 sn
->vm_clock_nsec
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
1447 ret
= bdrv_snapshot_find(bs
, old_sn
, name
);
1449 pstrcpy(sn
->name
, sizeof(sn
->name
), old_sn
->name
);
1450 pstrcpy(sn
->id_str
, sizeof(sn
->id_str
), old_sn
->id_str
);
1452 pstrcpy(sn
->name
, sizeof(sn
->name
), name
);
1455 /* cast below needed for OpenBSD where tv_sec is still 'long' */
1456 localtime_r((const time_t *)&tv
.tv_sec
, &tm
);
1457 strftime(sn
->name
, sizeof(sn
->name
), "vm-%Y%m%d%H%M%S", &tm
);
1460 /* Delete old snapshots of the same name */
1461 if (name
&& del_existing_snapshots(mon
, name
) < 0) {
1465 /* save the VM state */
1466 f
= qemu_fopen_bdrv(bs
, 1);
1468 monitor_printf(mon
, "Could not open VM state file\n");
1471 ret
= qemu_savevm_state(f
, &local_err
);
1472 vm_state_size
= qemu_ftell(f
);
1475 monitor_printf(mon
, "%s\n", error_get_pretty(local_err
));
1476 error_free(local_err
);
1480 /* create the snapshots */
1483 while ((bs1
= bdrv_next(bs1
))) {
1484 if (bdrv_can_snapshot(bs1
)) {
1485 /* Write VM state size only to the image that contains the state */
1486 sn
->vm_state_size
= (bs
== bs1
? vm_state_size
: 0);
1487 ret
= bdrv_snapshot_create(bs1
, sn
);
1489 monitor_printf(mon
, "Error while creating snapshot on '%s'\n",
1490 bdrv_get_device_name(bs1
));
1496 if (saved_vm_running
) {
1501 void qmp_xen_save_devices_state(const char *filename
, Error
**errp
)
1504 int saved_vm_running
;
1507 saved_vm_running
= runstate_is_running();
1508 vm_stop(RUN_STATE_SAVE_VM
);
1509 global_state_store_running();
1511 f
= qemu_fopen(filename
, "wb");
1513 error_setg_file_open(errp
, errno
, filename
);
1516 ret
= qemu_save_device_state(f
);
1519 error_setg(errp
, QERR_IO_ERROR
);
1523 if (saved_vm_running
) {
1528 int load_vmstate(const char *name
)
1530 BlockDriverState
*bs
, *bs_vm_state
;
1531 QEMUSnapshotInfo sn
;
1535 bs_vm_state
= find_vmstate_bs();
1537 error_report("No block device supports snapshots");
1541 /* Don't even try to load empty VM states */
1542 ret
= bdrv_snapshot_find(bs_vm_state
, &sn
, name
);
1545 } else if (sn
.vm_state_size
== 0) {
1546 error_report("This is a disk-only snapshot. Revert to it offline "
1551 /* Verify if there is any device that doesn't support snapshots and is
1552 writable and check if the requested snapshot is available too. */
1554 while ((bs
= bdrv_next(bs
))) {
1556 if (!bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
1560 if (!bdrv_can_snapshot(bs
)) {
1561 error_report("Device '%s' is writable but does not support snapshots.",
1562 bdrv_get_device_name(bs
));
1566 ret
= bdrv_snapshot_find(bs
, &sn
, name
);
1568 error_report("Device '%s' does not have the requested snapshot '%s'",
1569 bdrv_get_device_name(bs
), name
);
1574 /* Flush all IO requests so they don't interfere with the new state. */
1578 while ((bs
= bdrv_next(bs
))) {
1579 if (bdrv_can_snapshot(bs
)) {
1580 ret
= bdrv_snapshot_goto(bs
, name
);
1582 error_report("Error %d while activating snapshot '%s' on '%s'",
1583 ret
, name
, bdrv_get_device_name(bs
));
1589 /* restore the VM state */
1590 f
= qemu_fopen_bdrv(bs_vm_state
, 0);
1592 error_report("Could not open VM state file");
1596 qemu_system_reset(VMRESET_SILENT
);
1597 migration_incoming_state_new(f
);
1598 ret
= qemu_loadvm_state(f
);
1601 migration_incoming_state_destroy();
1603 error_report("Error %d while loading VM state", ret
);
1610 void hmp_delvm(Monitor
*mon
, const QDict
*qdict
)
1612 BlockDriverState
*bs
;
1614 const char *name
= qdict_get_str(qdict
, "name");
1616 if (!find_vmstate_bs()) {
1617 monitor_printf(mon
, "No block device supports snapshots\n");
1622 while ((bs
= bdrv_next(bs
))) {
1623 if (bdrv_can_snapshot(bs
)) {
1625 bdrv_snapshot_delete_by_id_or_name(bs
, name
, &err
);
1628 "Error while deleting snapshot on device '%s':"
1630 bdrv_get_device_name(bs
),
1631 error_get_pretty(err
));
1638 void hmp_info_snapshots(Monitor
*mon
, const QDict
*qdict
)
1640 BlockDriverState
*bs
, *bs1
;
1641 QEMUSnapshotInfo
*sn_tab
, *sn
, s
, *sn_info
= &s
;
1642 int nb_sns
, i
, ret
, available
;
1644 int *available_snapshots
;
1646 bs
= find_vmstate_bs();
1648 monitor_printf(mon
, "No available block device supports snapshots\n");
1652 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
1654 monitor_printf(mon
, "bdrv_snapshot_list: error %d\n", nb_sns
);
1659 monitor_printf(mon
, "There is no snapshot available.\n");
1663 available_snapshots
= g_new0(int, nb_sns
);
1665 for (i
= 0; i
< nb_sns
; i
++) {
1670 while ((bs1
= bdrv_next(bs1
))) {
1671 if (bdrv_can_snapshot(bs1
) && bs1
!= bs
) {
1672 ret
= bdrv_snapshot_find(bs1
, sn_info
, sn
->id_str
);
1681 available_snapshots
[total
] = i
;
1687 bdrv_snapshot_dump((fprintf_function
)monitor_printf
, mon
, NULL
);
1688 monitor_printf(mon
, "\n");
1689 for (i
= 0; i
< total
; i
++) {
1690 sn
= &sn_tab
[available_snapshots
[i
]];
1691 bdrv_snapshot_dump((fprintf_function
)monitor_printf
, mon
, sn
);
1692 monitor_printf(mon
, "\n");
1695 monitor_printf(mon
, "There is no suitable snapshot available\n");
1699 g_free(available_snapshots
);
1703 void vmstate_register_ram(MemoryRegion
*mr
, DeviceState
*dev
)
1705 qemu_ram_set_idstr(memory_region_get_ram_addr(mr
) & TARGET_PAGE_MASK
,
1706 memory_region_name(mr
), dev
);
1709 void vmstate_unregister_ram(MemoryRegion
*mr
, DeviceState
*dev
)
1711 qemu_ram_unset_idstr(memory_region_get_ram_addr(mr
) & TARGET_PAGE_MASK
);
1714 void vmstate_register_ram_global(MemoryRegion
*mr
)
1716 vmstate_register_ram(mr
, NULL
);