virtio-net: introduce a new macaddr control
[qemu/ar7.git] / savevm.c
blob304d1effe5490345971410c0de1398a163694d1c
1 /*
2 * QEMU System Emulator
4 * Copyright (c) 2003-2008 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
25 #include "config-host.h"
26 #include "qemu-common.h"
27 #include "hw/hw.h"
28 #include "hw/qdev.h"
29 #include "net/net.h"
30 #include "monitor/monitor.h"
31 #include "sysemu/sysemu.h"
32 #include "qemu/timer.h"
33 #include "audio/audio.h"
34 #include "migration/migration.h"
35 #include "qemu/sockets.h"
36 #include "qemu/queue.h"
37 #include "sysemu/cpus.h"
38 #include "exec/memory.h"
39 #include "qmp-commands.h"
40 #include "trace.h"
41 #include "qemu/bitops.h"
43 #define SELF_ANNOUNCE_ROUNDS 5
45 #ifndef ETH_P_RARP
46 #define ETH_P_RARP 0x8035
47 #endif
48 #define ARP_HTYPE_ETH 0x0001
49 #define ARP_PTYPE_IP 0x0800
50 #define ARP_OP_REQUEST_REV 0x3
52 static int announce_self_create(uint8_t *buf,
53 uint8_t *mac_addr)
55 /* Ethernet header. */
56 memset(buf, 0xff, 6); /* destination MAC addr */
57 memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
58 *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */
60 /* RARP header. */
61 *(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */
62 *(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */
63 *(buf + 18) = 6; /* hardware addr length (ethernet) */
64 *(buf + 19) = 4; /* protocol addr length (IPv4) */
65 *(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */
66 memcpy(buf + 22, mac_addr, 6); /* source hw addr */
67 memset(buf + 28, 0x00, 4); /* source protocol addr */
68 memcpy(buf + 32, mac_addr, 6); /* target hw addr */
69 memset(buf + 38, 0x00, 4); /* target protocol addr */
71 /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
72 memset(buf + 42, 0x00, 18);
74 return 60; /* len (FCS will be added by hardware) */
77 static void qemu_announce_self_iter(NICState *nic, void *opaque)
79 uint8_t buf[60];
80 int len;
82 len = announce_self_create(buf, nic->conf->macaddr.a);
84 qemu_send_packet_raw(&nic->nc, buf, len);
88 static void qemu_announce_self_once(void *opaque)
90 static int count = SELF_ANNOUNCE_ROUNDS;
91 QEMUTimer *timer = *(QEMUTimer **)opaque;
93 qemu_foreach_nic(qemu_announce_self_iter, NULL);
95 if (--count) {
96 /* delay 50ms, 150ms, 250ms, ... */
97 qemu_mod_timer(timer, qemu_get_clock_ms(rt_clock) +
98 50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100);
99 } else {
100 qemu_del_timer(timer);
101 qemu_free_timer(timer);
105 void qemu_announce_self(void)
107 static QEMUTimer *timer;
108 timer = qemu_new_timer_ms(rt_clock, qemu_announce_self_once, &timer);
109 qemu_announce_self_once(&timer);
112 /***********************************************************/
113 /* savevm/loadvm support */
115 #define IO_BUF_SIZE 32768
117 struct QEMUFile {
118 const QEMUFileOps *ops;
119 void *opaque;
120 int is_write;
122 int64_t buf_offset; /* start of buffer when writing, end of buffer
123 when reading */
124 int buf_index;
125 int buf_size; /* 0 when writing */
126 uint8_t buf[IO_BUF_SIZE];
128 int last_error;
131 typedef struct QEMUFileStdio
133 FILE *stdio_file;
134 QEMUFile *file;
135 } QEMUFileStdio;
137 typedef struct QEMUFileSocket
139 int fd;
140 QEMUFile *file;
141 } QEMUFileSocket;
143 static int socket_get_fd(void *opaque)
145 QEMUFileSocket *s = opaque;
147 return s->fd;
150 static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
152 QEMUFileSocket *s = opaque;
153 ssize_t len;
155 for (;;) {
156 len = qemu_recv(s->fd, buf, size, 0);
157 if (len != -1) {
158 break;
160 if (socket_error() == EAGAIN) {
161 assert(qemu_in_coroutine());
162 qemu_coroutine_yield();
163 } else if (socket_error() != EINTR) {
164 break;
168 if (len == -1) {
169 len = -socket_error();
171 return len;
174 static int socket_close(void *opaque)
176 QEMUFileSocket *s = opaque;
177 closesocket(s->fd);
178 g_free(s);
179 return 0;
182 static int stdio_get_fd(void *opaque)
184 QEMUFileStdio *s = opaque;
186 return fileno(s->stdio_file);
189 static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
191 QEMUFileStdio *s = opaque;
192 return fwrite(buf, 1, size, s->stdio_file);
195 static int stdio_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
197 QEMUFileStdio *s = opaque;
198 FILE *fp = s->stdio_file;
199 int bytes;
201 for (;;) {
202 clearerr(fp);
203 bytes = fread(buf, 1, size, fp);
204 if (bytes != 0 || !ferror(fp)) {
205 break;
207 if (errno == EAGAIN) {
208 assert(qemu_in_coroutine());
209 qemu_coroutine_yield();
210 } else if (errno != EINTR) {
211 break;
214 return bytes;
217 static int stdio_pclose(void *opaque)
219 QEMUFileStdio *s = opaque;
220 int ret;
221 ret = pclose(s->stdio_file);
222 if (ret == -1) {
223 ret = -errno;
225 g_free(s);
226 return ret;
229 static int stdio_fclose(void *opaque)
231 QEMUFileStdio *s = opaque;
232 int ret = 0;
233 if (fclose(s->stdio_file) == EOF) {
234 ret = -errno;
236 g_free(s);
237 return ret;
240 static const QEMUFileOps stdio_pipe_read_ops = {
241 .get_fd = stdio_get_fd,
242 .get_buffer = stdio_get_buffer,
243 .close = stdio_pclose
246 static const QEMUFileOps stdio_pipe_write_ops = {
247 .get_fd = stdio_get_fd,
248 .put_buffer = stdio_put_buffer,
249 .close = stdio_pclose
252 QEMUFile *qemu_popen(FILE *stdio_file, const char *mode)
254 QEMUFileStdio *s;
256 if (stdio_file == NULL || mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
257 fprintf(stderr, "qemu_popen: Argument validity check failed\n");
258 return NULL;
261 s = g_malloc0(sizeof(QEMUFileStdio));
263 s->stdio_file = stdio_file;
265 if(mode[0] == 'r') {
266 s->file = qemu_fopen_ops(s, &stdio_pipe_read_ops);
267 } else {
268 s->file = qemu_fopen_ops(s, &stdio_pipe_write_ops);
270 return s->file;
273 QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
275 FILE *popen_file;
277 popen_file = popen(command, mode);
278 if(popen_file == NULL) {
279 return NULL;
282 return qemu_popen(popen_file, mode);
285 static const QEMUFileOps stdio_file_read_ops = {
286 .get_fd = stdio_get_fd,
287 .get_buffer = stdio_get_buffer,
288 .close = stdio_fclose
291 static const QEMUFileOps stdio_file_write_ops = {
292 .get_fd = stdio_get_fd,
293 .put_buffer = stdio_put_buffer,
294 .close = stdio_fclose
297 QEMUFile *qemu_fdopen(int fd, const char *mode)
299 QEMUFileStdio *s;
301 if (mode == NULL ||
302 (mode[0] != 'r' && mode[0] != 'w') ||
303 mode[1] != 'b' || mode[2] != 0) {
304 fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
305 return NULL;
308 s = g_malloc0(sizeof(QEMUFileStdio));
309 s->stdio_file = fdopen(fd, mode);
310 if (!s->stdio_file)
311 goto fail;
313 if(mode[0] == 'r') {
314 s->file = qemu_fopen_ops(s, &stdio_file_read_ops);
315 } else {
316 s->file = qemu_fopen_ops(s, &stdio_file_write_ops);
318 return s->file;
320 fail:
321 g_free(s);
322 return NULL;
325 static const QEMUFileOps socket_read_ops = {
326 .get_fd = socket_get_fd,
327 .get_buffer = socket_get_buffer,
328 .close = socket_close
331 QEMUFile *qemu_fopen_socket(int fd)
333 QEMUFileSocket *s = g_malloc0(sizeof(QEMUFileSocket));
335 s->fd = fd;
336 s->file = qemu_fopen_ops(s, &socket_read_ops);
337 return s->file;
340 QEMUFile *qemu_fopen(const char *filename, const char *mode)
342 QEMUFileStdio *s;
344 if (mode == NULL ||
345 (mode[0] != 'r' && mode[0] != 'w') ||
346 mode[1] != 'b' || mode[2] != 0) {
347 fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
348 return NULL;
351 s = g_malloc0(sizeof(QEMUFileStdio));
353 s->stdio_file = fopen(filename, mode);
354 if (!s->stdio_file)
355 goto fail;
357 if(mode[0] == 'w') {
358 s->file = qemu_fopen_ops(s, &stdio_file_write_ops);
359 } else {
360 s->file = qemu_fopen_ops(s, &stdio_file_read_ops);
362 return s->file;
363 fail:
364 g_free(s);
365 return NULL;
368 static int block_put_buffer(void *opaque, const uint8_t *buf,
369 int64_t pos, int size)
371 bdrv_save_vmstate(opaque, buf, pos, size);
372 return size;
375 static int block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
377 return bdrv_load_vmstate(opaque, buf, pos, size);
380 static int bdrv_fclose(void *opaque)
382 return bdrv_flush(opaque);
385 static const QEMUFileOps bdrv_read_ops = {
386 .get_buffer = block_get_buffer,
387 .close = bdrv_fclose
390 static const QEMUFileOps bdrv_write_ops = {
391 .put_buffer = block_put_buffer,
392 .close = bdrv_fclose
395 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
397 if (is_writable)
398 return qemu_fopen_ops(bs, &bdrv_write_ops);
399 return qemu_fopen_ops(bs, &bdrv_read_ops);
402 QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)
404 QEMUFile *f;
406 f = g_malloc0(sizeof(QEMUFile));
408 f->opaque = opaque;
409 f->ops = ops;
410 f->is_write = 0;
412 return f;
415 int qemu_file_get_error(QEMUFile *f)
417 return f->last_error;
420 static void qemu_file_set_error(QEMUFile *f, int ret)
422 if (f->last_error == 0) {
423 f->last_error = ret;
427 /** Flushes QEMUFile buffer
430 static int qemu_fflush(QEMUFile *f)
432 int ret = 0;
434 if (!f->ops->put_buffer)
435 return 0;
437 if (f->is_write && f->buf_index > 0) {
438 ret = f->ops->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
439 if (ret >= 0) {
440 f->buf_offset += f->buf_index;
442 f->buf_index = 0;
444 return ret;
447 static void qemu_fill_buffer(QEMUFile *f)
449 int len;
450 int pending;
452 if (!f->ops->get_buffer)
453 return;
455 if (f->is_write)
456 abort();
458 pending = f->buf_size - f->buf_index;
459 if (pending > 0) {
460 memmove(f->buf, f->buf + f->buf_index, pending);
462 f->buf_index = 0;
463 f->buf_size = pending;
465 len = f->ops->get_buffer(f->opaque, f->buf + pending, f->buf_offset,
466 IO_BUF_SIZE - pending);
467 if (len > 0) {
468 f->buf_size += len;
469 f->buf_offset += len;
470 } else if (len == 0) {
471 qemu_file_set_error(f, -EIO);
472 } else if (len != -EAGAIN)
473 qemu_file_set_error(f, len);
476 int qemu_get_fd(QEMUFile *f)
478 if (f->ops->get_fd) {
479 return f->ops->get_fd(f->opaque);
481 return -1;
484 /** Closes the file
486 * Returns negative error value if any error happened on previous operations or
487 * while closing the file. Returns 0 or positive number on success.
489 * The meaning of return value on success depends on the specific backend
490 * being used.
492 int qemu_fclose(QEMUFile *f)
494 int ret;
495 ret = qemu_fflush(f);
497 if (f->ops->close) {
498 int ret2 = f->ops->close(f->opaque);
499 if (ret >= 0) {
500 ret = ret2;
503 /* If any error was spotted before closing, we should report it
504 * instead of the close() return value.
506 if (f->last_error) {
507 ret = f->last_error;
509 g_free(f);
510 return ret;
513 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
515 int l;
517 if (f->last_error) {
518 return;
521 if (f->is_write == 0 && f->buf_index > 0) {
522 fprintf(stderr,
523 "Attempted to write to buffer while read buffer is not empty\n");
524 abort();
527 while (size > 0) {
528 l = IO_BUF_SIZE - f->buf_index;
529 if (l > size)
530 l = size;
531 memcpy(f->buf + f->buf_index, buf, l);
532 f->is_write = 1;
533 f->buf_index += l;
534 buf += l;
535 size -= l;
536 if (f->buf_index >= IO_BUF_SIZE) {
537 int ret = qemu_fflush(f);
538 if (ret < 0) {
539 qemu_file_set_error(f, ret);
540 break;
546 void qemu_put_byte(QEMUFile *f, int v)
548 if (f->last_error) {
549 return;
552 if (f->is_write == 0 && f->buf_index > 0) {
553 fprintf(stderr,
554 "Attempted to write to buffer while read buffer is not empty\n");
555 abort();
558 f->buf[f->buf_index++] = v;
559 f->is_write = 1;
560 if (f->buf_index >= IO_BUF_SIZE) {
561 int ret = qemu_fflush(f);
562 if (ret < 0) {
563 qemu_file_set_error(f, ret);
568 static void qemu_file_skip(QEMUFile *f, int size)
570 if (f->buf_index + size <= f->buf_size) {
571 f->buf_index += size;
575 static int qemu_peek_buffer(QEMUFile *f, uint8_t *buf, int size, size_t offset)
577 int pending;
578 int index;
580 if (f->is_write) {
581 abort();
584 index = f->buf_index + offset;
585 pending = f->buf_size - index;
586 if (pending < size) {
587 qemu_fill_buffer(f);
588 index = f->buf_index + offset;
589 pending = f->buf_size - index;
592 if (pending <= 0) {
593 return 0;
595 if (size > pending) {
596 size = pending;
599 memcpy(buf, f->buf + index, size);
600 return size;
603 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
605 int pending = size;
606 int done = 0;
608 while (pending > 0) {
609 int res;
611 res = qemu_peek_buffer(f, buf, pending, 0);
612 if (res == 0) {
613 return done;
615 qemu_file_skip(f, res);
616 buf += res;
617 pending -= res;
618 done += res;
620 return done;
623 static int qemu_peek_byte(QEMUFile *f, int offset)
625 int index = f->buf_index + offset;
627 if (f->is_write) {
628 abort();
631 if (index >= f->buf_size) {
632 qemu_fill_buffer(f);
633 index = f->buf_index + offset;
634 if (index >= f->buf_size) {
635 return 0;
638 return f->buf[index];
641 int qemu_get_byte(QEMUFile *f)
643 int result;
645 result = qemu_peek_byte(f, 0);
646 qemu_file_skip(f, 1);
647 return result;
650 static int64_t qemu_ftell(QEMUFile *f)
652 return f->buf_offset - f->buf_size + f->buf_index;
655 int qemu_file_rate_limit(QEMUFile *f)
657 if (f->ops->rate_limit)
658 return f->ops->rate_limit(f->opaque);
660 return 0;
663 int64_t qemu_file_get_rate_limit(QEMUFile *f)
665 if (f->ops->get_rate_limit)
666 return f->ops->get_rate_limit(f->opaque);
668 return 0;
671 int64_t qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate)
673 /* any failed or completed migration keeps its state to allow probing of
674 * migration data, but has no associated file anymore */
675 if (f && f->ops->set_rate_limit)
676 return f->ops->set_rate_limit(f->opaque, new_rate);
678 return 0;
681 void qemu_put_be16(QEMUFile *f, unsigned int v)
683 qemu_put_byte(f, v >> 8);
684 qemu_put_byte(f, v);
687 void qemu_put_be32(QEMUFile *f, unsigned int v)
689 qemu_put_byte(f, v >> 24);
690 qemu_put_byte(f, v >> 16);
691 qemu_put_byte(f, v >> 8);
692 qemu_put_byte(f, v);
695 void qemu_put_be64(QEMUFile *f, uint64_t v)
697 qemu_put_be32(f, v >> 32);
698 qemu_put_be32(f, v);
701 unsigned int qemu_get_be16(QEMUFile *f)
703 unsigned int v;
704 v = qemu_get_byte(f) << 8;
705 v |= qemu_get_byte(f);
706 return v;
709 unsigned int qemu_get_be32(QEMUFile *f)
711 unsigned int v;
712 v = qemu_get_byte(f) << 24;
713 v |= qemu_get_byte(f) << 16;
714 v |= qemu_get_byte(f) << 8;
715 v |= qemu_get_byte(f);
716 return v;
719 uint64_t qemu_get_be64(QEMUFile *f)
721 uint64_t v;
722 v = (uint64_t)qemu_get_be32(f) << 32;
723 v |= qemu_get_be32(f);
724 return v;
728 /* timer */
730 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
732 uint64_t expire_time;
734 expire_time = qemu_timer_expire_time_ns(ts);
735 qemu_put_be64(f, expire_time);
738 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
740 uint64_t expire_time;
742 expire_time = qemu_get_be64(f);
743 if (expire_time != -1) {
744 qemu_mod_timer_ns(ts, expire_time);
745 } else {
746 qemu_del_timer(ts);
751 /* bool */
753 static int get_bool(QEMUFile *f, void *pv, size_t size)
755 bool *v = pv;
756 *v = qemu_get_byte(f);
757 return 0;
760 static void put_bool(QEMUFile *f, void *pv, size_t size)
762 bool *v = pv;
763 qemu_put_byte(f, *v);
766 const VMStateInfo vmstate_info_bool = {
767 .name = "bool",
768 .get = get_bool,
769 .put = put_bool,
772 /* 8 bit int */
774 static int get_int8(QEMUFile *f, void *pv, size_t size)
776 int8_t *v = pv;
777 qemu_get_s8s(f, v);
778 return 0;
781 static void put_int8(QEMUFile *f, void *pv, size_t size)
783 int8_t *v = pv;
784 qemu_put_s8s(f, v);
787 const VMStateInfo vmstate_info_int8 = {
788 .name = "int8",
789 .get = get_int8,
790 .put = put_int8,
793 /* 16 bit int */
795 static int get_int16(QEMUFile *f, void *pv, size_t size)
797 int16_t *v = pv;
798 qemu_get_sbe16s(f, v);
799 return 0;
802 static void put_int16(QEMUFile *f, void *pv, size_t size)
804 int16_t *v = pv;
805 qemu_put_sbe16s(f, v);
808 const VMStateInfo vmstate_info_int16 = {
809 .name = "int16",
810 .get = get_int16,
811 .put = put_int16,
814 /* 32 bit int */
816 static int get_int32(QEMUFile *f, void *pv, size_t size)
818 int32_t *v = pv;
819 qemu_get_sbe32s(f, v);
820 return 0;
823 static void put_int32(QEMUFile *f, void *pv, size_t size)
825 int32_t *v = pv;
826 qemu_put_sbe32s(f, v);
829 const VMStateInfo vmstate_info_int32 = {
830 .name = "int32",
831 .get = get_int32,
832 .put = put_int32,
835 /* 32 bit int. See that the received value is the same than the one
836 in the field */
838 static int get_int32_equal(QEMUFile *f, void *pv, size_t size)
840 int32_t *v = pv;
841 int32_t v2;
842 qemu_get_sbe32s(f, &v2);
844 if (*v == v2)
845 return 0;
846 return -EINVAL;
849 const VMStateInfo vmstate_info_int32_equal = {
850 .name = "int32 equal",
851 .get = get_int32_equal,
852 .put = put_int32,
855 /* 32 bit int. See that the received value is the less or the same
856 than the one in the field */
858 static int get_int32_le(QEMUFile *f, void *pv, size_t size)
860 int32_t *old = pv;
861 int32_t new;
862 qemu_get_sbe32s(f, &new);
864 if (*old <= new)
865 return 0;
866 return -EINVAL;
869 const VMStateInfo vmstate_info_int32_le = {
870 .name = "int32 equal",
871 .get = get_int32_le,
872 .put = put_int32,
875 /* 64 bit int */
877 static int get_int64(QEMUFile *f, void *pv, size_t size)
879 int64_t *v = pv;
880 qemu_get_sbe64s(f, v);
881 return 0;
884 static void put_int64(QEMUFile *f, void *pv, size_t size)
886 int64_t *v = pv;
887 qemu_put_sbe64s(f, v);
890 const VMStateInfo vmstate_info_int64 = {
891 .name = "int64",
892 .get = get_int64,
893 .put = put_int64,
896 /* 8 bit unsigned int */
898 static int get_uint8(QEMUFile *f, void *pv, size_t size)
900 uint8_t *v = pv;
901 qemu_get_8s(f, v);
902 return 0;
905 static void put_uint8(QEMUFile *f, void *pv, size_t size)
907 uint8_t *v = pv;
908 qemu_put_8s(f, v);
911 const VMStateInfo vmstate_info_uint8 = {
912 .name = "uint8",
913 .get = get_uint8,
914 .put = put_uint8,
917 /* 16 bit unsigned int */
919 static int get_uint16(QEMUFile *f, void *pv, size_t size)
921 uint16_t *v = pv;
922 qemu_get_be16s(f, v);
923 return 0;
926 static void put_uint16(QEMUFile *f, void *pv, size_t size)
928 uint16_t *v = pv;
929 qemu_put_be16s(f, v);
932 const VMStateInfo vmstate_info_uint16 = {
933 .name = "uint16",
934 .get = get_uint16,
935 .put = put_uint16,
938 /* 32 bit unsigned int */
940 static int get_uint32(QEMUFile *f, void *pv, size_t size)
942 uint32_t *v = pv;
943 qemu_get_be32s(f, v);
944 return 0;
947 static void put_uint32(QEMUFile *f, void *pv, size_t size)
949 uint32_t *v = pv;
950 qemu_put_be32s(f, v);
953 const VMStateInfo vmstate_info_uint32 = {
954 .name = "uint32",
955 .get = get_uint32,
956 .put = put_uint32,
959 /* 32 bit uint. See that the received value is the same than the one
960 in the field */
962 static int get_uint32_equal(QEMUFile *f, void *pv, size_t size)
964 uint32_t *v = pv;
965 uint32_t v2;
966 qemu_get_be32s(f, &v2);
968 if (*v == v2) {
969 return 0;
971 return -EINVAL;
974 const VMStateInfo vmstate_info_uint32_equal = {
975 .name = "uint32 equal",
976 .get = get_uint32_equal,
977 .put = put_uint32,
980 /* 64 bit unsigned int */
982 static int get_uint64(QEMUFile *f, void *pv, size_t size)
984 uint64_t *v = pv;
985 qemu_get_be64s(f, v);
986 return 0;
989 static void put_uint64(QEMUFile *f, void *pv, size_t size)
991 uint64_t *v = pv;
992 qemu_put_be64s(f, v);
995 const VMStateInfo vmstate_info_uint64 = {
996 .name = "uint64",
997 .get = get_uint64,
998 .put = put_uint64,
1001 /* 8 bit int. See that the received value is the same than the one
1002 in the field */
1004 static int get_uint8_equal(QEMUFile *f, void *pv, size_t size)
1006 uint8_t *v = pv;
1007 uint8_t v2;
1008 qemu_get_8s(f, &v2);
1010 if (*v == v2)
1011 return 0;
1012 return -EINVAL;
1015 const VMStateInfo vmstate_info_uint8_equal = {
1016 .name = "uint8 equal",
1017 .get = get_uint8_equal,
1018 .put = put_uint8,
1021 /* 16 bit unsigned int int. See that the received value is the same than the one
1022 in the field */
1024 static int get_uint16_equal(QEMUFile *f, void *pv, size_t size)
1026 uint16_t *v = pv;
1027 uint16_t v2;
1028 qemu_get_be16s(f, &v2);
1030 if (*v == v2)
1031 return 0;
1032 return -EINVAL;
1035 const VMStateInfo vmstate_info_uint16_equal = {
1036 .name = "uint16 equal",
1037 .get = get_uint16_equal,
1038 .put = put_uint16,
1041 /* timers */
1043 static int get_timer(QEMUFile *f, void *pv, size_t size)
1045 QEMUTimer *v = pv;
1046 qemu_get_timer(f, v);
1047 return 0;
1050 static void put_timer(QEMUFile *f, void *pv, size_t size)
1052 QEMUTimer *v = pv;
1053 qemu_put_timer(f, v);
1056 const VMStateInfo vmstate_info_timer = {
1057 .name = "timer",
1058 .get = get_timer,
1059 .put = put_timer,
1062 /* uint8_t buffers */
1064 static int get_buffer(QEMUFile *f, void *pv, size_t size)
1066 uint8_t *v = pv;
1067 qemu_get_buffer(f, v, size);
1068 return 0;
1071 static void put_buffer(QEMUFile *f, void *pv, size_t size)
1073 uint8_t *v = pv;
1074 qemu_put_buffer(f, v, size);
1077 const VMStateInfo vmstate_info_buffer = {
1078 .name = "buffer",
1079 .get = get_buffer,
1080 .put = put_buffer,
1083 /* unused buffers: space that was used for some fields that are
1084 not useful anymore */
1086 static int get_unused_buffer(QEMUFile *f, void *pv, size_t size)
1088 uint8_t buf[1024];
1089 int block_len;
1091 while (size > 0) {
1092 block_len = MIN(sizeof(buf), size);
1093 size -= block_len;
1094 qemu_get_buffer(f, buf, block_len);
1096 return 0;
1099 static void put_unused_buffer(QEMUFile *f, void *pv, size_t size)
1101 static const uint8_t buf[1024];
1102 int block_len;
1104 while (size > 0) {
1105 block_len = MIN(sizeof(buf), size);
1106 size -= block_len;
1107 qemu_put_buffer(f, buf, block_len);
1111 const VMStateInfo vmstate_info_unused_buffer = {
1112 .name = "unused_buffer",
1113 .get = get_unused_buffer,
1114 .put = put_unused_buffer,
1117 /* bitmaps (as defined by bitmap.h). Note that size here is the size
1118 * of the bitmap in bits. The on-the-wire format of a bitmap is 64
1119 * bit words with the bits in big endian order. The in-memory format
1120 * is an array of 'unsigned long', which may be either 32 or 64 bits.
1122 /* This is the number of 64 bit words sent over the wire */
1123 #define BITS_TO_U64S(nr) DIV_ROUND_UP(nr, 64)
1124 static int get_bitmap(QEMUFile *f, void *pv, size_t size)
1126 unsigned long *bmp = pv;
1127 int i, idx = 0;
1128 for (i = 0; i < BITS_TO_U64S(size); i++) {
1129 uint64_t w = qemu_get_be64(f);
1130 bmp[idx++] = w;
1131 if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
1132 bmp[idx++] = w >> 32;
1135 return 0;
1138 static void put_bitmap(QEMUFile *f, void *pv, size_t size)
1140 unsigned long *bmp = pv;
1141 int i, idx = 0;
1142 for (i = 0; i < BITS_TO_U64S(size); i++) {
1143 uint64_t w = bmp[idx++];
1144 if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
1145 w |= ((uint64_t)bmp[idx++]) << 32;
1147 qemu_put_be64(f, w);
1151 const VMStateInfo vmstate_info_bitmap = {
1152 .name = "bitmap",
1153 .get = get_bitmap,
1154 .put = put_bitmap,
1157 typedef struct CompatEntry {
1158 char idstr[256];
1159 int instance_id;
1160 } CompatEntry;
1162 typedef struct SaveStateEntry {
1163 QTAILQ_ENTRY(SaveStateEntry) entry;
1164 char idstr[256];
1165 int instance_id;
1166 int alias_id;
1167 int version_id;
1168 int section_id;
1169 SaveVMHandlers *ops;
1170 const VMStateDescription *vmsd;
1171 void *opaque;
1172 CompatEntry *compat;
1173 int no_migrate;
1174 int is_ram;
1175 } SaveStateEntry;
1178 static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers =
1179 QTAILQ_HEAD_INITIALIZER(savevm_handlers);
1180 static int global_section_id;
1182 static int calculate_new_instance_id(const char *idstr)
1184 SaveStateEntry *se;
1185 int instance_id = 0;
1187 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1188 if (strcmp(idstr, se->idstr) == 0
1189 && instance_id <= se->instance_id) {
1190 instance_id = se->instance_id + 1;
1193 return instance_id;
1196 static int calculate_compat_instance_id(const char *idstr)
1198 SaveStateEntry *se;
1199 int instance_id = 0;
1201 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1202 if (!se->compat)
1203 continue;
1205 if (strcmp(idstr, se->compat->idstr) == 0
1206 && instance_id <= se->compat->instance_id) {
1207 instance_id = se->compat->instance_id + 1;
1210 return instance_id;
1213 /* TODO: Individual devices generally have very little idea about the rest
1214 of the system, so instance_id should be removed/replaced.
1215 Meanwhile pass -1 as instance_id if you do not already have a clearly
1216 distinguishing id for all instances of your device class. */
1217 int register_savevm_live(DeviceState *dev,
1218 const char *idstr,
1219 int instance_id,
1220 int version_id,
1221 SaveVMHandlers *ops,
1222 void *opaque)
1224 SaveStateEntry *se;
1226 se = g_malloc0(sizeof(SaveStateEntry));
1227 se->version_id = version_id;
1228 se->section_id = global_section_id++;
1229 se->ops = ops;
1230 se->opaque = opaque;
1231 se->vmsd = NULL;
1232 se->no_migrate = 0;
1233 /* if this is a live_savem then set is_ram */
1234 if (ops->save_live_setup != NULL) {
1235 se->is_ram = 1;
1238 if (dev) {
1239 char *id = qdev_get_dev_path(dev);
1240 if (id) {
1241 pstrcpy(se->idstr, sizeof(se->idstr), id);
1242 pstrcat(se->idstr, sizeof(se->idstr), "/");
1243 g_free(id);
1245 se->compat = g_malloc0(sizeof(CompatEntry));
1246 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr);
1247 se->compat->instance_id = instance_id == -1 ?
1248 calculate_compat_instance_id(idstr) : instance_id;
1249 instance_id = -1;
1252 pstrcat(se->idstr, sizeof(se->idstr), idstr);
1254 if (instance_id == -1) {
1255 se->instance_id = calculate_new_instance_id(se->idstr);
1256 } else {
1257 se->instance_id = instance_id;
1259 assert(!se->compat || se->instance_id == 0);
1260 /* add at the end of list */
1261 QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1262 return 0;
1265 int register_savevm(DeviceState *dev,
1266 const char *idstr,
1267 int instance_id,
1268 int version_id,
1269 SaveStateHandler *save_state,
1270 LoadStateHandler *load_state,
1271 void *opaque)
1273 SaveVMHandlers *ops = g_malloc0(sizeof(SaveVMHandlers));
1274 ops->save_state = save_state;
1275 ops->load_state = load_state;
1276 return register_savevm_live(dev, idstr, instance_id, version_id,
1277 ops, opaque);
1280 void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
1282 SaveStateEntry *se, *new_se;
1283 char id[256] = "";
1285 if (dev) {
1286 char *path = qdev_get_dev_path(dev);
1287 if (path) {
1288 pstrcpy(id, sizeof(id), path);
1289 pstrcat(id, sizeof(id), "/");
1290 g_free(path);
1293 pstrcat(id, sizeof(id), idstr);
1295 QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1296 if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
1297 QTAILQ_REMOVE(&savevm_handlers, se, entry);
1298 if (se->compat) {
1299 g_free(se->compat);
1301 g_free(se->ops);
1302 g_free(se);
1307 int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
1308 const VMStateDescription *vmsd,
1309 void *opaque, int alias_id,
1310 int required_for_version)
1312 SaveStateEntry *se;
1314 /* If this triggers, alias support can be dropped for the vmsd. */
1315 assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id);
1317 se = g_malloc0(sizeof(SaveStateEntry));
1318 se->version_id = vmsd->version_id;
1319 se->section_id = global_section_id++;
1320 se->opaque = opaque;
1321 se->vmsd = vmsd;
1322 se->alias_id = alias_id;
1323 se->no_migrate = vmsd->unmigratable;
1325 if (dev) {
1326 char *id = qdev_get_dev_path(dev);
1327 if (id) {
1328 pstrcpy(se->idstr, sizeof(se->idstr), id);
1329 pstrcat(se->idstr, sizeof(se->idstr), "/");
1330 g_free(id);
1332 se->compat = g_malloc0(sizeof(CompatEntry));
1333 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
1334 se->compat->instance_id = instance_id == -1 ?
1335 calculate_compat_instance_id(vmsd->name) : instance_id;
1336 instance_id = -1;
1339 pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);
1341 if (instance_id == -1) {
1342 se->instance_id = calculate_new_instance_id(se->idstr);
1343 } else {
1344 se->instance_id = instance_id;
1346 assert(!se->compat || se->instance_id == 0);
1347 /* add at the end of list */
1348 QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1349 return 0;
1352 int vmstate_register(DeviceState *dev, int instance_id,
1353 const VMStateDescription *vmsd, void *opaque)
1355 return vmstate_register_with_alias_id(dev, instance_id, vmsd,
1356 opaque, -1, 0);
1359 void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
1360 void *opaque)
1362 SaveStateEntry *se, *new_se;
1364 QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1365 if (se->vmsd == vmsd && se->opaque == opaque) {
1366 QTAILQ_REMOVE(&savevm_handlers, se, entry);
1367 if (se->compat) {
1368 g_free(se->compat);
1370 g_free(se);
1375 static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
1376 void *opaque);
1377 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
1378 void *opaque);
1380 int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
1381 void *opaque, int version_id)
1383 VMStateField *field = vmsd->fields;
1384 int ret;
1386 if (version_id > vmsd->version_id) {
1387 return -EINVAL;
1389 if (version_id < vmsd->minimum_version_id_old) {
1390 return -EINVAL;
1392 if (version_id < vmsd->minimum_version_id) {
1393 return vmsd->load_state_old(f, opaque, version_id);
1395 if (vmsd->pre_load) {
1396 int ret = vmsd->pre_load(opaque);
1397 if (ret)
1398 return ret;
1400 while(field->name) {
1401 if ((field->field_exists &&
1402 field->field_exists(opaque, version_id)) ||
1403 (!field->field_exists &&
1404 field->version_id <= version_id)) {
1405 void *base_addr = opaque + field->offset;
1406 int i, n_elems = 1;
1407 int size = field->size;
1409 if (field->flags & VMS_VBUFFER) {
1410 size = *(int32_t *)(opaque+field->size_offset);
1411 if (field->flags & VMS_MULTIPLY) {
1412 size *= field->size;
1415 if (field->flags & VMS_ARRAY) {
1416 n_elems = field->num;
1417 } else if (field->flags & VMS_VARRAY_INT32) {
1418 n_elems = *(int32_t *)(opaque+field->num_offset);
1419 } else if (field->flags & VMS_VARRAY_UINT32) {
1420 n_elems = *(uint32_t *)(opaque+field->num_offset);
1421 } else if (field->flags & VMS_VARRAY_UINT16) {
1422 n_elems = *(uint16_t *)(opaque+field->num_offset);
1423 } else if (field->flags & VMS_VARRAY_UINT8) {
1424 n_elems = *(uint8_t *)(opaque+field->num_offset);
1426 if (field->flags & VMS_POINTER) {
1427 base_addr = *(void **)base_addr + field->start;
1429 for (i = 0; i < n_elems; i++) {
1430 void *addr = base_addr + size * i;
1432 if (field->flags & VMS_ARRAY_OF_POINTER) {
1433 addr = *(void **)addr;
1435 if (field->flags & VMS_STRUCT) {
1436 ret = vmstate_load_state(f, field->vmsd, addr, field->vmsd->version_id);
1437 } else {
1438 ret = field->info->get(f, addr, size);
1441 if (ret < 0) {
1442 return ret;
1446 field++;
1448 ret = vmstate_subsection_load(f, vmsd, opaque);
1449 if (ret != 0) {
1450 return ret;
1452 if (vmsd->post_load) {
1453 return vmsd->post_load(opaque, version_id);
1455 return 0;
1458 void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
1459 void *opaque)
1461 VMStateField *field = vmsd->fields;
1463 if (vmsd->pre_save) {
1464 vmsd->pre_save(opaque);
1466 while(field->name) {
1467 if (!field->field_exists ||
1468 field->field_exists(opaque, vmsd->version_id)) {
1469 void *base_addr = opaque + field->offset;
1470 int i, n_elems = 1;
1471 int size = field->size;
1473 if (field->flags & VMS_VBUFFER) {
1474 size = *(int32_t *)(opaque+field->size_offset);
1475 if (field->flags & VMS_MULTIPLY) {
1476 size *= field->size;
1479 if (field->flags & VMS_ARRAY) {
1480 n_elems = field->num;
1481 } else if (field->flags & VMS_VARRAY_INT32) {
1482 n_elems = *(int32_t *)(opaque+field->num_offset);
1483 } else if (field->flags & VMS_VARRAY_UINT32) {
1484 n_elems = *(uint32_t *)(opaque+field->num_offset);
1485 } else if (field->flags & VMS_VARRAY_UINT16) {
1486 n_elems = *(uint16_t *)(opaque+field->num_offset);
1487 } else if (field->flags & VMS_VARRAY_UINT8) {
1488 n_elems = *(uint8_t *)(opaque+field->num_offset);
1490 if (field->flags & VMS_POINTER) {
1491 base_addr = *(void **)base_addr + field->start;
1493 for (i = 0; i < n_elems; i++) {
1494 void *addr = base_addr + size * i;
1496 if (field->flags & VMS_ARRAY_OF_POINTER) {
1497 addr = *(void **)addr;
1499 if (field->flags & VMS_STRUCT) {
1500 vmstate_save_state(f, field->vmsd, addr);
1501 } else {
1502 field->info->put(f, addr, size);
1506 field++;
1508 vmstate_subsection_save(f, vmsd, opaque);
1511 static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id)
1513 if (!se->vmsd) { /* Old style */
1514 return se->ops->load_state(f, se->opaque, version_id);
1516 return vmstate_load_state(f, se->vmsd, se->opaque, version_id);
1519 static void vmstate_save(QEMUFile *f, SaveStateEntry *se)
1521 if (!se->vmsd) { /* Old style */
1522 se->ops->save_state(f, se->opaque);
1523 return;
1525 vmstate_save_state(f,se->vmsd, se->opaque);
1528 #define QEMU_VM_FILE_MAGIC 0x5145564d
1529 #define QEMU_VM_FILE_VERSION_COMPAT 0x00000002
1530 #define QEMU_VM_FILE_VERSION 0x00000003
1532 #define QEMU_VM_EOF 0x00
1533 #define QEMU_VM_SECTION_START 0x01
1534 #define QEMU_VM_SECTION_PART 0x02
1535 #define QEMU_VM_SECTION_END 0x03
1536 #define QEMU_VM_SECTION_FULL 0x04
1537 #define QEMU_VM_SUBSECTION 0x05
1539 bool qemu_savevm_state_blocked(Error **errp)
1541 SaveStateEntry *se;
1543 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1544 if (se->no_migrate) {
1545 error_set(errp, QERR_MIGRATION_NOT_SUPPORTED, se->idstr);
1546 return true;
1549 return false;
1552 int qemu_savevm_state_begin(QEMUFile *f,
1553 const MigrationParams *params)
1555 SaveStateEntry *se;
1556 int ret;
1558 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1559 if (!se->ops || !se->ops->set_params) {
1560 continue;
1562 se->ops->set_params(params, se->opaque);
1565 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1566 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1568 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1569 int len;
1571 if (!se->ops || !se->ops->save_live_setup) {
1572 continue;
1574 if (se->ops && se->ops->is_active) {
1575 if (!se->ops->is_active(se->opaque)) {
1576 continue;
1579 /* Section type */
1580 qemu_put_byte(f, QEMU_VM_SECTION_START);
1581 qemu_put_be32(f, se->section_id);
1583 /* ID string */
1584 len = strlen(se->idstr);
1585 qemu_put_byte(f, len);
1586 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1588 qemu_put_be32(f, se->instance_id);
1589 qemu_put_be32(f, se->version_id);
1591 ret = se->ops->save_live_setup(f, se->opaque);
1592 if (ret < 0) {
1593 qemu_savevm_state_cancel();
1594 return ret;
1597 ret = qemu_file_get_error(f);
1598 if (ret != 0) {
1599 qemu_savevm_state_cancel();
1602 return ret;
1607 * this function has three return values:
1608 * negative: there was one error, and we have -errno.
1609 * 0 : We haven't finished, caller have to go again
1610 * 1 : We have finished, we can go to complete phase
1612 int qemu_savevm_state_iterate(QEMUFile *f)
1614 SaveStateEntry *se;
1615 int ret = 1;
1617 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1618 if (!se->ops || !se->ops->save_live_iterate) {
1619 continue;
1621 if (se->ops && se->ops->is_active) {
1622 if (!se->ops->is_active(se->opaque)) {
1623 continue;
1626 if (qemu_file_rate_limit(f)) {
1627 return 0;
1629 trace_savevm_section_start();
1630 /* Section type */
1631 qemu_put_byte(f, QEMU_VM_SECTION_PART);
1632 qemu_put_be32(f, se->section_id);
1634 ret = se->ops->save_live_iterate(f, se->opaque);
1635 trace_savevm_section_end(se->section_id);
1637 if (ret <= 0) {
1638 /* Do not proceed to the next vmstate before this one reported
1639 completion of the current stage. This serializes the migration
1640 and reduces the probability that a faster changing state is
1641 synchronized over and over again. */
1642 break;
1645 if (ret != 0) {
1646 return ret;
1648 ret = qemu_file_get_error(f);
1649 if (ret != 0) {
1650 qemu_savevm_state_cancel();
1652 return ret;
1655 int qemu_savevm_state_complete(QEMUFile *f)
1657 SaveStateEntry *se;
1658 int ret;
1660 cpu_synchronize_all_states();
1662 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1663 if (!se->ops || !se->ops->save_live_complete) {
1664 continue;
1666 if (se->ops && se->ops->is_active) {
1667 if (!se->ops->is_active(se->opaque)) {
1668 continue;
1671 trace_savevm_section_start();
1672 /* Section type */
1673 qemu_put_byte(f, QEMU_VM_SECTION_END);
1674 qemu_put_be32(f, se->section_id);
1676 ret = se->ops->save_live_complete(f, se->opaque);
1677 trace_savevm_section_end(se->section_id);
1678 if (ret < 0) {
1679 return ret;
1683 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1684 int len;
1686 if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1687 continue;
1689 trace_savevm_section_start();
1690 /* Section type */
1691 qemu_put_byte(f, QEMU_VM_SECTION_FULL);
1692 qemu_put_be32(f, se->section_id);
1694 /* ID string */
1695 len = strlen(se->idstr);
1696 qemu_put_byte(f, len);
1697 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1699 qemu_put_be32(f, se->instance_id);
1700 qemu_put_be32(f, se->version_id);
1702 vmstate_save(f, se);
1703 trace_savevm_section_end(se->section_id);
1706 qemu_put_byte(f, QEMU_VM_EOF);
1708 return qemu_file_get_error(f);
1711 uint64_t qemu_savevm_state_pending(QEMUFile *f, uint64_t max_size)
1713 SaveStateEntry *se;
1714 uint64_t ret = 0;
1716 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1717 if (!se->ops || !se->ops->save_live_pending) {
1718 continue;
1720 if (se->ops && se->ops->is_active) {
1721 if (!se->ops->is_active(se->opaque)) {
1722 continue;
1725 ret += se->ops->save_live_pending(f, se->opaque, max_size);
1727 return ret;
1730 void qemu_savevm_state_cancel(void)
1732 SaveStateEntry *se;
1734 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1735 if (se->ops && se->ops->cancel) {
1736 se->ops->cancel(se->opaque);
1741 static int qemu_savevm_state(QEMUFile *f)
1743 int ret;
1744 MigrationParams params = {
1745 .blk = 0,
1746 .shared = 0
1749 if (qemu_savevm_state_blocked(NULL)) {
1750 ret = -EINVAL;
1751 goto out;
1754 ret = qemu_savevm_state_begin(f, &params);
1755 if (ret < 0)
1756 goto out;
1758 do {
1759 ret = qemu_savevm_state_iterate(f);
1760 if (ret < 0)
1761 goto out;
1762 } while (ret == 0);
1764 ret = qemu_savevm_state_complete(f);
1766 out:
1767 if (ret == 0) {
1768 ret = qemu_file_get_error(f);
1771 return ret;
1774 static int qemu_save_device_state(QEMUFile *f)
1776 SaveStateEntry *se;
1778 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1779 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1781 cpu_synchronize_all_states();
1783 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1784 int len;
1786 if (se->is_ram) {
1787 continue;
1789 if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1790 continue;
1793 /* Section type */
1794 qemu_put_byte(f, QEMU_VM_SECTION_FULL);
1795 qemu_put_be32(f, se->section_id);
1797 /* ID string */
1798 len = strlen(se->idstr);
1799 qemu_put_byte(f, len);
1800 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1802 qemu_put_be32(f, se->instance_id);
1803 qemu_put_be32(f, se->version_id);
1805 vmstate_save(f, se);
1808 qemu_put_byte(f, QEMU_VM_EOF);
1810 return qemu_file_get_error(f);
1813 static SaveStateEntry *find_se(const char *idstr, int instance_id)
1815 SaveStateEntry *se;
1817 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1818 if (!strcmp(se->idstr, idstr) &&
1819 (instance_id == se->instance_id ||
1820 instance_id == se->alias_id))
1821 return se;
1822 /* Migrating from an older version? */
1823 if (strstr(se->idstr, idstr) && se->compat) {
1824 if (!strcmp(se->compat->idstr, idstr) &&
1825 (instance_id == se->compat->instance_id ||
1826 instance_id == se->alias_id))
1827 return se;
1830 return NULL;
1833 static const VMStateDescription *vmstate_get_subsection(const VMStateSubsection *sub, char *idstr)
1835 while(sub && sub->needed) {
1836 if (strcmp(idstr, sub->vmsd->name) == 0) {
1837 return sub->vmsd;
1839 sub++;
1841 return NULL;
1844 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
1845 void *opaque)
1847 while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
1848 char idstr[256];
1849 int ret;
1850 uint8_t version_id, len, size;
1851 const VMStateDescription *sub_vmsd;
1853 len = qemu_peek_byte(f, 1);
1854 if (len < strlen(vmsd->name) + 1) {
1855 /* subsection name has be be "section_name/a" */
1856 return 0;
1858 size = qemu_peek_buffer(f, (uint8_t *)idstr, len, 2);
1859 if (size != len) {
1860 return 0;
1862 idstr[size] = 0;
1864 if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
1865 /* it don't have a valid subsection name */
1866 return 0;
1868 sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
1869 if (sub_vmsd == NULL) {
1870 return -ENOENT;
1872 qemu_file_skip(f, 1); /* subsection */
1873 qemu_file_skip(f, 1); /* len */
1874 qemu_file_skip(f, len); /* idstr */
1875 version_id = qemu_get_be32(f);
1877 ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
1878 if (ret) {
1879 return ret;
1882 return 0;
1885 static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
1886 void *opaque)
1888 const VMStateSubsection *sub = vmsd->subsections;
1890 while (sub && sub->needed) {
1891 if (sub->needed(opaque)) {
1892 const VMStateDescription *vmsd = sub->vmsd;
1893 uint8_t len;
1895 qemu_put_byte(f, QEMU_VM_SUBSECTION);
1896 len = strlen(vmsd->name);
1897 qemu_put_byte(f, len);
1898 qemu_put_buffer(f, (uint8_t *)vmsd->name, len);
1899 qemu_put_be32(f, vmsd->version_id);
1900 vmstate_save_state(f, vmsd, opaque);
1902 sub++;
1906 typedef struct LoadStateEntry {
1907 QLIST_ENTRY(LoadStateEntry) entry;
1908 SaveStateEntry *se;
1909 int section_id;
1910 int version_id;
1911 } LoadStateEntry;
1913 int qemu_loadvm_state(QEMUFile *f)
1915 QLIST_HEAD(, LoadStateEntry) loadvm_handlers =
1916 QLIST_HEAD_INITIALIZER(loadvm_handlers);
1917 LoadStateEntry *le, *new_le;
1918 uint8_t section_type;
1919 unsigned int v;
1920 int ret;
1922 if (qemu_savevm_state_blocked(NULL)) {
1923 return -EINVAL;
1926 v = qemu_get_be32(f);
1927 if (v != QEMU_VM_FILE_MAGIC)
1928 return -EINVAL;
1930 v = qemu_get_be32(f);
1931 if (v == QEMU_VM_FILE_VERSION_COMPAT) {
1932 fprintf(stderr, "SaveVM v2 format is obsolete and don't work anymore\n");
1933 return -ENOTSUP;
1935 if (v != QEMU_VM_FILE_VERSION)
1936 return -ENOTSUP;
1938 while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
1939 uint32_t instance_id, version_id, section_id;
1940 SaveStateEntry *se;
1941 char idstr[257];
1942 int len;
1944 switch (section_type) {
1945 case QEMU_VM_SECTION_START:
1946 case QEMU_VM_SECTION_FULL:
1947 /* Read section start */
1948 section_id = qemu_get_be32(f);
1949 len = qemu_get_byte(f);
1950 qemu_get_buffer(f, (uint8_t *)idstr, len);
1951 idstr[len] = 0;
1952 instance_id = qemu_get_be32(f);
1953 version_id = qemu_get_be32(f);
1955 /* Find savevm section */
1956 se = find_se(idstr, instance_id);
1957 if (se == NULL) {
1958 fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
1959 ret = -EINVAL;
1960 goto out;
1963 /* Validate version */
1964 if (version_id > se->version_id) {
1965 fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
1966 version_id, idstr, se->version_id);
1967 ret = -EINVAL;
1968 goto out;
1971 /* Add entry */
1972 le = g_malloc0(sizeof(*le));
1974 le->se = se;
1975 le->section_id = section_id;
1976 le->version_id = version_id;
1977 QLIST_INSERT_HEAD(&loadvm_handlers, le, entry);
1979 ret = vmstate_load(f, le->se, le->version_id);
1980 if (ret < 0) {
1981 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
1982 instance_id, idstr);
1983 goto out;
1985 break;
1986 case QEMU_VM_SECTION_PART:
1987 case QEMU_VM_SECTION_END:
1988 section_id = qemu_get_be32(f);
1990 QLIST_FOREACH(le, &loadvm_handlers, entry) {
1991 if (le->section_id == section_id) {
1992 break;
1995 if (le == NULL) {
1996 fprintf(stderr, "Unknown savevm section %d\n", section_id);
1997 ret = -EINVAL;
1998 goto out;
2001 ret = vmstate_load(f, le->se, le->version_id);
2002 if (ret < 0) {
2003 fprintf(stderr, "qemu: warning: error while loading state section id %d\n",
2004 section_id);
2005 goto out;
2007 break;
2008 default:
2009 fprintf(stderr, "Unknown savevm section type %d\n", section_type);
2010 ret = -EINVAL;
2011 goto out;
2015 cpu_synchronize_all_post_init();
2017 ret = 0;
2019 out:
2020 QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
2021 QLIST_REMOVE(le, entry);
2022 g_free(le);
2025 if (ret == 0) {
2026 ret = qemu_file_get_error(f);
2029 return ret;
2032 static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
2033 const char *name)
2035 QEMUSnapshotInfo *sn_tab, *sn;
2036 int nb_sns, i, ret;
2038 ret = -ENOENT;
2039 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2040 if (nb_sns < 0)
2041 return ret;
2042 for(i = 0; i < nb_sns; i++) {
2043 sn = &sn_tab[i];
2044 if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
2045 *sn_info = *sn;
2046 ret = 0;
2047 break;
2050 g_free(sn_tab);
2051 return ret;
2055 * Deletes snapshots of a given name in all opened images.
2057 static int del_existing_snapshots(Monitor *mon, const char *name)
2059 BlockDriverState *bs;
2060 QEMUSnapshotInfo sn1, *snapshot = &sn1;
2061 int ret;
2063 bs = NULL;
2064 while ((bs = bdrv_next(bs))) {
2065 if (bdrv_can_snapshot(bs) &&
2066 bdrv_snapshot_find(bs, snapshot, name) >= 0)
2068 ret = bdrv_snapshot_delete(bs, name);
2069 if (ret < 0) {
2070 monitor_printf(mon,
2071 "Error while deleting snapshot on '%s'\n",
2072 bdrv_get_device_name(bs));
2073 return -1;
2078 return 0;
2081 void do_savevm(Monitor *mon, const QDict *qdict)
2083 BlockDriverState *bs, *bs1;
2084 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
2085 int ret;
2086 QEMUFile *f;
2087 int saved_vm_running;
2088 uint64_t vm_state_size;
2089 qemu_timeval tv;
2090 struct tm tm;
2091 const char *name = qdict_get_try_str(qdict, "name");
2093 /* Verify if there is a device that doesn't support snapshots and is writable */
2094 bs = NULL;
2095 while ((bs = bdrv_next(bs))) {
2097 if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2098 continue;
2101 if (!bdrv_can_snapshot(bs)) {
2102 monitor_printf(mon, "Device '%s' is writable but does not support snapshots.\n",
2103 bdrv_get_device_name(bs));
2104 return;
2108 bs = bdrv_snapshots();
2109 if (!bs) {
2110 monitor_printf(mon, "No block device can accept snapshots\n");
2111 return;
2114 saved_vm_running = runstate_is_running();
2115 vm_stop(RUN_STATE_SAVE_VM);
2117 memset(sn, 0, sizeof(*sn));
2119 /* fill auxiliary fields */
2120 qemu_gettimeofday(&tv);
2121 sn->date_sec = tv.tv_sec;
2122 sn->date_nsec = tv.tv_usec * 1000;
2123 sn->vm_clock_nsec = qemu_get_clock_ns(vm_clock);
2125 if (name) {
2126 ret = bdrv_snapshot_find(bs, old_sn, name);
2127 if (ret >= 0) {
2128 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
2129 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
2130 } else {
2131 pstrcpy(sn->name, sizeof(sn->name), name);
2133 } else {
2134 /* cast below needed for OpenBSD where tv_sec is still 'long' */
2135 localtime_r((const time_t *)&tv.tv_sec, &tm);
2136 strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
2139 /* Delete old snapshots of the same name */
2140 if (name && del_existing_snapshots(mon, name) < 0) {
2141 goto the_end;
2144 /* save the VM state */
2145 f = qemu_fopen_bdrv(bs, 1);
2146 if (!f) {
2147 monitor_printf(mon, "Could not open VM state file\n");
2148 goto the_end;
2150 ret = qemu_savevm_state(f);
2151 vm_state_size = qemu_ftell(f);
2152 qemu_fclose(f);
2153 if (ret < 0) {
2154 monitor_printf(mon, "Error %d while writing VM\n", ret);
2155 goto the_end;
2158 /* create the snapshots */
2160 bs1 = NULL;
2161 while ((bs1 = bdrv_next(bs1))) {
2162 if (bdrv_can_snapshot(bs1)) {
2163 /* Write VM state size only to the image that contains the state */
2164 sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
2165 ret = bdrv_snapshot_create(bs1, sn);
2166 if (ret < 0) {
2167 monitor_printf(mon, "Error while creating snapshot on '%s'\n",
2168 bdrv_get_device_name(bs1));
2173 the_end:
2174 if (saved_vm_running)
2175 vm_start();
2178 void qmp_xen_save_devices_state(const char *filename, Error **errp)
2180 QEMUFile *f;
2181 int saved_vm_running;
2182 int ret;
2184 saved_vm_running = runstate_is_running();
2185 vm_stop(RUN_STATE_SAVE_VM);
2187 f = qemu_fopen(filename, "wb");
2188 if (!f) {
2189 error_set(errp, QERR_OPEN_FILE_FAILED, filename);
2190 goto the_end;
2192 ret = qemu_save_device_state(f);
2193 qemu_fclose(f);
2194 if (ret < 0) {
2195 error_set(errp, QERR_IO_ERROR);
2198 the_end:
2199 if (saved_vm_running)
2200 vm_start();
2203 int load_vmstate(const char *name)
2205 BlockDriverState *bs, *bs_vm_state;
2206 QEMUSnapshotInfo sn;
2207 QEMUFile *f;
2208 int ret;
2210 bs_vm_state = bdrv_snapshots();
2211 if (!bs_vm_state) {
2212 error_report("No block device supports snapshots");
2213 return -ENOTSUP;
2216 /* Don't even try to load empty VM states */
2217 ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
2218 if (ret < 0) {
2219 return ret;
2220 } else if (sn.vm_state_size == 0) {
2221 error_report("This is a disk-only snapshot. Revert to it offline "
2222 "using qemu-img.");
2223 return -EINVAL;
2226 /* Verify if there is any device that doesn't support snapshots and is
2227 writable and check if the requested snapshot is available too. */
2228 bs = NULL;
2229 while ((bs = bdrv_next(bs))) {
2231 if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2232 continue;
2235 if (!bdrv_can_snapshot(bs)) {
2236 error_report("Device '%s' is writable but does not support snapshots.",
2237 bdrv_get_device_name(bs));
2238 return -ENOTSUP;
2241 ret = bdrv_snapshot_find(bs, &sn, name);
2242 if (ret < 0) {
2243 error_report("Device '%s' does not have the requested snapshot '%s'",
2244 bdrv_get_device_name(bs), name);
2245 return ret;
2249 /* Flush all IO requests so they don't interfere with the new state. */
2250 bdrv_drain_all();
2252 bs = NULL;
2253 while ((bs = bdrv_next(bs))) {
2254 if (bdrv_can_snapshot(bs)) {
2255 ret = bdrv_snapshot_goto(bs, name);
2256 if (ret < 0) {
2257 error_report("Error %d while activating snapshot '%s' on '%s'",
2258 ret, name, bdrv_get_device_name(bs));
2259 return ret;
2264 /* restore the VM state */
2265 f = qemu_fopen_bdrv(bs_vm_state, 0);
2266 if (!f) {
2267 error_report("Could not open VM state file");
2268 return -EINVAL;
2271 qemu_system_reset(VMRESET_SILENT);
2272 ret = qemu_loadvm_state(f);
2274 qemu_fclose(f);
2275 if (ret < 0) {
2276 error_report("Error %d while loading VM state", ret);
2277 return ret;
2280 return 0;
2283 void do_delvm(Monitor *mon, const QDict *qdict)
2285 BlockDriverState *bs, *bs1;
2286 int ret;
2287 const char *name = qdict_get_str(qdict, "name");
2289 bs = bdrv_snapshots();
2290 if (!bs) {
2291 monitor_printf(mon, "No block device supports snapshots\n");
2292 return;
2295 bs1 = NULL;
2296 while ((bs1 = bdrv_next(bs1))) {
2297 if (bdrv_can_snapshot(bs1)) {
2298 ret = bdrv_snapshot_delete(bs1, name);
2299 if (ret < 0) {
2300 if (ret == -ENOTSUP)
2301 monitor_printf(mon,
2302 "Snapshots not supported on device '%s'\n",
2303 bdrv_get_device_name(bs1));
2304 else
2305 monitor_printf(mon, "Error %d while deleting snapshot on "
2306 "'%s'\n", ret, bdrv_get_device_name(bs1));
2312 void do_info_snapshots(Monitor *mon, const QDict *qdict)
2314 BlockDriverState *bs, *bs1;
2315 QEMUSnapshotInfo *sn_tab, *sn, s, *sn_info = &s;
2316 int nb_sns, i, ret, available;
2317 int total;
2318 int *available_snapshots;
2319 char buf[256];
2321 bs = bdrv_snapshots();
2322 if (!bs) {
2323 monitor_printf(mon, "No available block device supports snapshots\n");
2324 return;
2327 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2328 if (nb_sns < 0) {
2329 monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
2330 return;
2333 if (nb_sns == 0) {
2334 monitor_printf(mon, "There is no snapshot available.\n");
2335 return;
2338 available_snapshots = g_malloc0(sizeof(int) * nb_sns);
2339 total = 0;
2340 for (i = 0; i < nb_sns; i++) {
2341 sn = &sn_tab[i];
2342 available = 1;
2343 bs1 = NULL;
2345 while ((bs1 = bdrv_next(bs1))) {
2346 if (bdrv_can_snapshot(bs1) && bs1 != bs) {
2347 ret = bdrv_snapshot_find(bs1, sn_info, sn->id_str);
2348 if (ret < 0) {
2349 available = 0;
2350 break;
2355 if (available) {
2356 available_snapshots[total] = i;
2357 total++;
2361 if (total > 0) {
2362 monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
2363 for (i = 0; i < total; i++) {
2364 sn = &sn_tab[available_snapshots[i]];
2365 monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
2367 } else {
2368 monitor_printf(mon, "There is no suitable snapshot available\n");
2371 g_free(sn_tab);
2372 g_free(available_snapshots);
2376 void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
2378 qemu_ram_set_idstr(memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK,
2379 memory_region_name(mr), dev);
2382 void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev)
2384 /* Nothing do to while the implementation is in RAMBlock */
2387 void vmstate_register_ram_global(MemoryRegion *mr)
2389 vmstate_register_ram(mr, NULL);
2393 page = zrun nzrun
2394 | zrun nzrun page
2396 zrun = length
2398 nzrun = length byte...
2400 length = uleb128 encoded integer
2402 int xbzrle_encode_buffer(uint8_t *old_buf, uint8_t *new_buf, int slen,
2403 uint8_t *dst, int dlen)
2405 uint32_t zrun_len = 0, nzrun_len = 0;
2406 int d = 0, i = 0;
2407 long res, xor;
2408 uint8_t *nzrun_start = NULL;
2410 g_assert(!(((uintptr_t)old_buf | (uintptr_t)new_buf | slen) %
2411 sizeof(long)));
2413 while (i < slen) {
2414 /* overflow */
2415 if (d + 2 > dlen) {
2416 return -1;
2419 /* not aligned to sizeof(long) */
2420 res = (slen - i) % sizeof(long);
2421 while (res && old_buf[i] == new_buf[i]) {
2422 zrun_len++;
2423 i++;
2424 res--;
2427 /* word at a time for speed */
2428 if (!res) {
2429 while (i < slen &&
2430 (*(long *)(old_buf + i)) == (*(long *)(new_buf + i))) {
2431 i += sizeof(long);
2432 zrun_len += sizeof(long);
2435 /* go over the rest */
2436 while (i < slen && old_buf[i] == new_buf[i]) {
2437 zrun_len++;
2438 i++;
2442 /* buffer unchanged */
2443 if (zrun_len == slen) {
2444 return 0;
2447 /* skip last zero run */
2448 if (i == slen) {
2449 return d;
2452 d += uleb128_encode_small(dst + d, zrun_len);
2454 zrun_len = 0;
2455 nzrun_start = new_buf + i;
2457 /* overflow */
2458 if (d + 2 > dlen) {
2459 return -1;
2461 /* not aligned to sizeof(long) */
2462 res = (slen - i) % sizeof(long);
2463 while (res && old_buf[i] != new_buf[i]) {
2464 i++;
2465 nzrun_len++;
2466 res--;
2469 /* word at a time for speed, use of 32-bit long okay */
2470 if (!res) {
2471 /* truncation to 32-bit long okay */
2472 long mask = (long)0x0101010101010101ULL;
2473 while (i < slen) {
2474 xor = *(long *)(old_buf + i) ^ *(long *)(new_buf + i);
2475 if ((xor - mask) & ~xor & (mask << 7)) {
2476 /* found the end of an nzrun within the current long */
2477 while (old_buf[i] != new_buf[i]) {
2478 nzrun_len++;
2479 i++;
2481 break;
2482 } else {
2483 i += sizeof(long);
2484 nzrun_len += sizeof(long);
2489 d += uleb128_encode_small(dst + d, nzrun_len);
2490 /* overflow */
2491 if (d + nzrun_len > dlen) {
2492 return -1;
2494 memcpy(dst + d, nzrun_start, nzrun_len);
2495 d += nzrun_len;
2496 nzrun_len = 0;
2499 return d;
2502 int xbzrle_decode_buffer(uint8_t *src, int slen, uint8_t *dst, int dlen)
2504 int i = 0, d = 0;
2505 int ret;
2506 uint32_t count = 0;
2508 while (i < slen) {
2510 /* zrun */
2511 if ((slen - i) < 2) {
2512 return -1;
2515 ret = uleb128_decode_small(src + i, &count);
2516 if (ret < 0 || (i && !count)) {
2517 return -1;
2519 i += ret;
2520 d += count;
2522 /* overflow */
2523 if (d > dlen) {
2524 return -1;
2527 /* nzrun */
2528 if ((slen - i) < 2) {
2529 return -1;
2532 ret = uleb128_decode_small(src + i, &count);
2533 if (ret < 0 || !count) {
2534 return -1;
2536 i += ret;
2538 /* overflow */
2539 if (d + count > dlen || i + count > slen) {
2540 return -1;
2543 memcpy(dst + d, src + i, count);
2544 d += count;
2545 i += count;
2548 return d;