target-i386/cpu.c: Add feature name array for ext4_features
[qemu/agraf.git] / savevm.c
blob4e970ca0db47ddc26300506c04d718b5848a7194
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 f->last_error = ret;
425 /** Flushes QEMUFile buffer
428 static int qemu_fflush(QEMUFile *f)
430 int ret = 0;
432 if (!f->ops->put_buffer)
433 return 0;
435 if (f->is_write && f->buf_index > 0) {
436 ret = f->ops->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
437 if (ret >= 0) {
438 f->buf_offset += f->buf_index;
440 f->buf_index = 0;
442 return ret;
445 static void qemu_fill_buffer(QEMUFile *f)
447 int len;
448 int pending;
450 if (!f->ops->get_buffer)
451 return;
453 if (f->is_write)
454 abort();
456 pending = f->buf_size - f->buf_index;
457 if (pending > 0) {
458 memmove(f->buf, f->buf + f->buf_index, pending);
460 f->buf_index = 0;
461 f->buf_size = pending;
463 len = f->ops->get_buffer(f->opaque, f->buf + pending, f->buf_offset,
464 IO_BUF_SIZE - pending);
465 if (len > 0) {
466 f->buf_size += len;
467 f->buf_offset += len;
468 } else if (len == 0) {
469 qemu_file_set_error(f, -EIO);
470 } else if (len != -EAGAIN)
471 qemu_file_set_error(f, len);
474 int qemu_get_fd(QEMUFile *f)
476 if (f->ops->get_fd) {
477 return f->ops->get_fd(f->opaque);
479 return -1;
482 /** Closes the file
484 * Returns negative error value if any error happened on previous operations or
485 * while closing the file. Returns 0 or positive number on success.
487 * The meaning of return value on success depends on the specific backend
488 * being used.
490 int qemu_fclose(QEMUFile *f)
492 int ret;
493 ret = qemu_fflush(f);
495 if (f->ops->close) {
496 int ret2 = f->ops->close(f->opaque);
497 if (ret >= 0) {
498 ret = ret2;
501 /* If any error was spotted before closing, we should report it
502 * instead of the close() return value.
504 if (f->last_error) {
505 ret = f->last_error;
507 g_free(f);
508 return ret;
511 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
513 int l;
515 if (f->last_error) {
516 return;
519 if (f->is_write == 0 && f->buf_index > 0) {
520 fprintf(stderr,
521 "Attempted to write to buffer while read buffer is not empty\n");
522 abort();
525 while (size > 0) {
526 l = IO_BUF_SIZE - f->buf_index;
527 if (l > size)
528 l = size;
529 memcpy(f->buf + f->buf_index, buf, l);
530 f->is_write = 1;
531 f->buf_index += l;
532 buf += l;
533 size -= l;
534 if (f->buf_index >= IO_BUF_SIZE) {
535 int ret = qemu_fflush(f);
536 if (ret < 0) {
537 qemu_file_set_error(f, ret);
538 break;
544 void qemu_put_byte(QEMUFile *f, int v)
546 if (f->last_error) {
547 return;
550 if (f->is_write == 0 && f->buf_index > 0) {
551 fprintf(stderr,
552 "Attempted to write to buffer while read buffer is not empty\n");
553 abort();
556 f->buf[f->buf_index++] = v;
557 f->is_write = 1;
558 if (f->buf_index >= IO_BUF_SIZE) {
559 int ret = qemu_fflush(f);
560 if (ret < 0) {
561 qemu_file_set_error(f, ret);
566 static void qemu_file_skip(QEMUFile *f, int size)
568 if (f->buf_index + size <= f->buf_size) {
569 f->buf_index += size;
573 static int qemu_peek_buffer(QEMUFile *f, uint8_t *buf, int size, size_t offset)
575 int pending;
576 int index;
578 if (f->is_write) {
579 abort();
582 index = f->buf_index + offset;
583 pending = f->buf_size - index;
584 if (pending < size) {
585 qemu_fill_buffer(f);
586 index = f->buf_index + offset;
587 pending = f->buf_size - index;
590 if (pending <= 0) {
591 return 0;
593 if (size > pending) {
594 size = pending;
597 memcpy(buf, f->buf + index, size);
598 return size;
601 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
603 int pending = size;
604 int done = 0;
606 while (pending > 0) {
607 int res;
609 res = qemu_peek_buffer(f, buf, pending, 0);
610 if (res == 0) {
611 return done;
613 qemu_file_skip(f, res);
614 buf += res;
615 pending -= res;
616 done += res;
618 return done;
621 static int qemu_peek_byte(QEMUFile *f, int offset)
623 int index = f->buf_index + offset;
625 if (f->is_write) {
626 abort();
629 if (index >= f->buf_size) {
630 qemu_fill_buffer(f);
631 index = f->buf_index + offset;
632 if (index >= f->buf_size) {
633 return 0;
636 return f->buf[index];
639 int qemu_get_byte(QEMUFile *f)
641 int result;
643 result = qemu_peek_byte(f, 0);
644 qemu_file_skip(f, 1);
645 return result;
648 static int64_t qemu_ftell(QEMUFile *f)
650 return f->buf_offset - f->buf_size + f->buf_index;
653 int qemu_file_rate_limit(QEMUFile *f)
655 if (f->ops->rate_limit)
656 return f->ops->rate_limit(f->opaque);
658 return 0;
661 int64_t qemu_file_get_rate_limit(QEMUFile *f)
663 if (f->ops->get_rate_limit)
664 return f->ops->get_rate_limit(f->opaque);
666 return 0;
669 int64_t qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate)
671 /* any failed or completed migration keeps its state to allow probing of
672 * migration data, but has no associated file anymore */
673 if (f && f->ops->set_rate_limit)
674 return f->ops->set_rate_limit(f->opaque, new_rate);
676 return 0;
679 void qemu_put_be16(QEMUFile *f, unsigned int v)
681 qemu_put_byte(f, v >> 8);
682 qemu_put_byte(f, v);
685 void qemu_put_be32(QEMUFile *f, unsigned int v)
687 qemu_put_byte(f, v >> 24);
688 qemu_put_byte(f, v >> 16);
689 qemu_put_byte(f, v >> 8);
690 qemu_put_byte(f, v);
693 void qemu_put_be64(QEMUFile *f, uint64_t v)
695 qemu_put_be32(f, v >> 32);
696 qemu_put_be32(f, v);
699 unsigned int qemu_get_be16(QEMUFile *f)
701 unsigned int v;
702 v = qemu_get_byte(f) << 8;
703 v |= qemu_get_byte(f);
704 return v;
707 unsigned int qemu_get_be32(QEMUFile *f)
709 unsigned int v;
710 v = qemu_get_byte(f) << 24;
711 v |= qemu_get_byte(f) << 16;
712 v |= qemu_get_byte(f) << 8;
713 v |= qemu_get_byte(f);
714 return v;
717 uint64_t qemu_get_be64(QEMUFile *f)
719 uint64_t v;
720 v = (uint64_t)qemu_get_be32(f) << 32;
721 v |= qemu_get_be32(f);
722 return v;
726 /* timer */
728 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
730 uint64_t expire_time;
732 expire_time = qemu_timer_expire_time_ns(ts);
733 qemu_put_be64(f, expire_time);
736 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
738 uint64_t expire_time;
740 expire_time = qemu_get_be64(f);
741 if (expire_time != -1) {
742 qemu_mod_timer_ns(ts, expire_time);
743 } else {
744 qemu_del_timer(ts);
749 /* bool */
751 static int get_bool(QEMUFile *f, void *pv, size_t size)
753 bool *v = pv;
754 *v = qemu_get_byte(f);
755 return 0;
758 static void put_bool(QEMUFile *f, void *pv, size_t size)
760 bool *v = pv;
761 qemu_put_byte(f, *v);
764 const VMStateInfo vmstate_info_bool = {
765 .name = "bool",
766 .get = get_bool,
767 .put = put_bool,
770 /* 8 bit int */
772 static int get_int8(QEMUFile *f, void *pv, size_t size)
774 int8_t *v = pv;
775 qemu_get_s8s(f, v);
776 return 0;
779 static void put_int8(QEMUFile *f, void *pv, size_t size)
781 int8_t *v = pv;
782 qemu_put_s8s(f, v);
785 const VMStateInfo vmstate_info_int8 = {
786 .name = "int8",
787 .get = get_int8,
788 .put = put_int8,
791 /* 16 bit int */
793 static int get_int16(QEMUFile *f, void *pv, size_t size)
795 int16_t *v = pv;
796 qemu_get_sbe16s(f, v);
797 return 0;
800 static void put_int16(QEMUFile *f, void *pv, size_t size)
802 int16_t *v = pv;
803 qemu_put_sbe16s(f, v);
806 const VMStateInfo vmstate_info_int16 = {
807 .name = "int16",
808 .get = get_int16,
809 .put = put_int16,
812 /* 32 bit int */
814 static int get_int32(QEMUFile *f, void *pv, size_t size)
816 int32_t *v = pv;
817 qemu_get_sbe32s(f, v);
818 return 0;
821 static void put_int32(QEMUFile *f, void *pv, size_t size)
823 int32_t *v = pv;
824 qemu_put_sbe32s(f, v);
827 const VMStateInfo vmstate_info_int32 = {
828 .name = "int32",
829 .get = get_int32,
830 .put = put_int32,
833 /* 32 bit int. See that the received value is the same than the one
834 in the field */
836 static int get_int32_equal(QEMUFile *f, void *pv, size_t size)
838 int32_t *v = pv;
839 int32_t v2;
840 qemu_get_sbe32s(f, &v2);
842 if (*v == v2)
843 return 0;
844 return -EINVAL;
847 const VMStateInfo vmstate_info_int32_equal = {
848 .name = "int32 equal",
849 .get = get_int32_equal,
850 .put = put_int32,
853 /* 32 bit int. See that the received value is the less or the same
854 than the one in the field */
856 static int get_int32_le(QEMUFile *f, void *pv, size_t size)
858 int32_t *old = pv;
859 int32_t new;
860 qemu_get_sbe32s(f, &new);
862 if (*old <= new)
863 return 0;
864 return -EINVAL;
867 const VMStateInfo vmstate_info_int32_le = {
868 .name = "int32 equal",
869 .get = get_int32_le,
870 .put = put_int32,
873 /* 64 bit int */
875 static int get_int64(QEMUFile *f, void *pv, size_t size)
877 int64_t *v = pv;
878 qemu_get_sbe64s(f, v);
879 return 0;
882 static void put_int64(QEMUFile *f, void *pv, size_t size)
884 int64_t *v = pv;
885 qemu_put_sbe64s(f, v);
888 const VMStateInfo vmstate_info_int64 = {
889 .name = "int64",
890 .get = get_int64,
891 .put = put_int64,
894 /* 8 bit unsigned int */
896 static int get_uint8(QEMUFile *f, void *pv, size_t size)
898 uint8_t *v = pv;
899 qemu_get_8s(f, v);
900 return 0;
903 static void put_uint8(QEMUFile *f, void *pv, size_t size)
905 uint8_t *v = pv;
906 qemu_put_8s(f, v);
909 const VMStateInfo vmstate_info_uint8 = {
910 .name = "uint8",
911 .get = get_uint8,
912 .put = put_uint8,
915 /* 16 bit unsigned int */
917 static int get_uint16(QEMUFile *f, void *pv, size_t size)
919 uint16_t *v = pv;
920 qemu_get_be16s(f, v);
921 return 0;
924 static void put_uint16(QEMUFile *f, void *pv, size_t size)
926 uint16_t *v = pv;
927 qemu_put_be16s(f, v);
930 const VMStateInfo vmstate_info_uint16 = {
931 .name = "uint16",
932 .get = get_uint16,
933 .put = put_uint16,
936 /* 32 bit unsigned int */
938 static int get_uint32(QEMUFile *f, void *pv, size_t size)
940 uint32_t *v = pv;
941 qemu_get_be32s(f, v);
942 return 0;
945 static void put_uint32(QEMUFile *f, void *pv, size_t size)
947 uint32_t *v = pv;
948 qemu_put_be32s(f, v);
951 const VMStateInfo vmstate_info_uint32 = {
952 .name = "uint32",
953 .get = get_uint32,
954 .put = put_uint32,
957 /* 32 bit uint. See that the received value is the same than the one
958 in the field */
960 static int get_uint32_equal(QEMUFile *f, void *pv, size_t size)
962 uint32_t *v = pv;
963 uint32_t v2;
964 qemu_get_be32s(f, &v2);
966 if (*v == v2) {
967 return 0;
969 return -EINVAL;
972 const VMStateInfo vmstate_info_uint32_equal = {
973 .name = "uint32 equal",
974 .get = get_uint32_equal,
975 .put = put_uint32,
978 /* 64 bit unsigned int */
980 static int get_uint64(QEMUFile *f, void *pv, size_t size)
982 uint64_t *v = pv;
983 qemu_get_be64s(f, v);
984 return 0;
987 static void put_uint64(QEMUFile *f, void *pv, size_t size)
989 uint64_t *v = pv;
990 qemu_put_be64s(f, v);
993 const VMStateInfo vmstate_info_uint64 = {
994 .name = "uint64",
995 .get = get_uint64,
996 .put = put_uint64,
999 /* 8 bit int. See that the received value is the same than the one
1000 in the field */
1002 static int get_uint8_equal(QEMUFile *f, void *pv, size_t size)
1004 uint8_t *v = pv;
1005 uint8_t v2;
1006 qemu_get_8s(f, &v2);
1008 if (*v == v2)
1009 return 0;
1010 return -EINVAL;
1013 const VMStateInfo vmstate_info_uint8_equal = {
1014 .name = "uint8 equal",
1015 .get = get_uint8_equal,
1016 .put = put_uint8,
1019 /* 16 bit unsigned int int. See that the received value is the same than the one
1020 in the field */
1022 static int get_uint16_equal(QEMUFile *f, void *pv, size_t size)
1024 uint16_t *v = pv;
1025 uint16_t v2;
1026 qemu_get_be16s(f, &v2);
1028 if (*v == v2)
1029 return 0;
1030 return -EINVAL;
1033 const VMStateInfo vmstate_info_uint16_equal = {
1034 .name = "uint16 equal",
1035 .get = get_uint16_equal,
1036 .put = put_uint16,
1039 /* timers */
1041 static int get_timer(QEMUFile *f, void *pv, size_t size)
1043 QEMUTimer *v = pv;
1044 qemu_get_timer(f, v);
1045 return 0;
1048 static void put_timer(QEMUFile *f, void *pv, size_t size)
1050 QEMUTimer *v = pv;
1051 qemu_put_timer(f, v);
1054 const VMStateInfo vmstate_info_timer = {
1055 .name = "timer",
1056 .get = get_timer,
1057 .put = put_timer,
1060 /* uint8_t buffers */
1062 static int get_buffer(QEMUFile *f, void *pv, size_t size)
1064 uint8_t *v = pv;
1065 qemu_get_buffer(f, v, size);
1066 return 0;
1069 static void put_buffer(QEMUFile *f, void *pv, size_t size)
1071 uint8_t *v = pv;
1072 qemu_put_buffer(f, v, size);
1075 const VMStateInfo vmstate_info_buffer = {
1076 .name = "buffer",
1077 .get = get_buffer,
1078 .put = put_buffer,
1081 /* unused buffers: space that was used for some fields that are
1082 not useful anymore */
1084 static int get_unused_buffer(QEMUFile *f, void *pv, size_t size)
1086 uint8_t buf[1024];
1087 int block_len;
1089 while (size > 0) {
1090 block_len = MIN(sizeof(buf), size);
1091 size -= block_len;
1092 qemu_get_buffer(f, buf, block_len);
1094 return 0;
1097 static void put_unused_buffer(QEMUFile *f, void *pv, size_t size)
1099 static const uint8_t buf[1024];
1100 int block_len;
1102 while (size > 0) {
1103 block_len = MIN(sizeof(buf), size);
1104 size -= block_len;
1105 qemu_put_buffer(f, buf, block_len);
1109 const VMStateInfo vmstate_info_unused_buffer = {
1110 .name = "unused_buffer",
1111 .get = get_unused_buffer,
1112 .put = put_unused_buffer,
1115 /* bitmaps (as defined by bitmap.h). Note that size here is the size
1116 * of the bitmap in bits. The on-the-wire format of a bitmap is 64
1117 * bit words with the bits in big endian order. The in-memory format
1118 * is an array of 'unsigned long', which may be either 32 or 64 bits.
1120 /* This is the number of 64 bit words sent over the wire */
1121 #define BITS_TO_U64S(nr) DIV_ROUND_UP(nr, 64)
1122 static int get_bitmap(QEMUFile *f, void *pv, size_t size)
1124 unsigned long *bmp = pv;
1125 int i, idx = 0;
1126 for (i = 0; i < BITS_TO_U64S(size); i++) {
1127 uint64_t w = qemu_get_be64(f);
1128 bmp[idx++] = w;
1129 if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
1130 bmp[idx++] = w >> 32;
1133 return 0;
1136 static void put_bitmap(QEMUFile *f, void *pv, size_t size)
1138 unsigned long *bmp = pv;
1139 int i, idx = 0;
1140 for (i = 0; i < BITS_TO_U64S(size); i++) {
1141 uint64_t w = bmp[idx++];
1142 if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
1143 w |= ((uint64_t)bmp[idx++]) << 32;
1145 qemu_put_be64(f, w);
1149 const VMStateInfo vmstate_info_bitmap = {
1150 .name = "bitmap",
1151 .get = get_bitmap,
1152 .put = put_bitmap,
1155 typedef struct CompatEntry {
1156 char idstr[256];
1157 int instance_id;
1158 } CompatEntry;
1160 typedef struct SaveStateEntry {
1161 QTAILQ_ENTRY(SaveStateEntry) entry;
1162 char idstr[256];
1163 int instance_id;
1164 int alias_id;
1165 int version_id;
1166 int section_id;
1167 SaveVMHandlers *ops;
1168 const VMStateDescription *vmsd;
1169 void *opaque;
1170 CompatEntry *compat;
1171 int no_migrate;
1172 int is_ram;
1173 } SaveStateEntry;
1176 static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers =
1177 QTAILQ_HEAD_INITIALIZER(savevm_handlers);
1178 static int global_section_id;
1180 static int calculate_new_instance_id(const char *idstr)
1182 SaveStateEntry *se;
1183 int instance_id = 0;
1185 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1186 if (strcmp(idstr, se->idstr) == 0
1187 && instance_id <= se->instance_id) {
1188 instance_id = se->instance_id + 1;
1191 return instance_id;
1194 static int calculate_compat_instance_id(const char *idstr)
1196 SaveStateEntry *se;
1197 int instance_id = 0;
1199 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1200 if (!se->compat)
1201 continue;
1203 if (strcmp(idstr, se->compat->idstr) == 0
1204 && instance_id <= se->compat->instance_id) {
1205 instance_id = se->compat->instance_id + 1;
1208 return instance_id;
1211 /* TODO: Individual devices generally have very little idea about the rest
1212 of the system, so instance_id should be removed/replaced.
1213 Meanwhile pass -1 as instance_id if you do not already have a clearly
1214 distinguishing id for all instances of your device class. */
1215 int register_savevm_live(DeviceState *dev,
1216 const char *idstr,
1217 int instance_id,
1218 int version_id,
1219 SaveVMHandlers *ops,
1220 void *opaque)
1222 SaveStateEntry *se;
1224 se = g_malloc0(sizeof(SaveStateEntry));
1225 se->version_id = version_id;
1226 se->section_id = global_section_id++;
1227 se->ops = ops;
1228 se->opaque = opaque;
1229 se->vmsd = NULL;
1230 se->no_migrate = 0;
1231 /* if this is a live_savem then set is_ram */
1232 if (ops->save_live_setup != NULL) {
1233 se->is_ram = 1;
1236 if (dev) {
1237 char *id = qdev_get_dev_path(dev);
1238 if (id) {
1239 pstrcpy(se->idstr, sizeof(se->idstr), id);
1240 pstrcat(se->idstr, sizeof(se->idstr), "/");
1241 g_free(id);
1243 se->compat = g_malloc0(sizeof(CompatEntry));
1244 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr);
1245 se->compat->instance_id = instance_id == -1 ?
1246 calculate_compat_instance_id(idstr) : instance_id;
1247 instance_id = -1;
1250 pstrcat(se->idstr, sizeof(se->idstr), idstr);
1252 if (instance_id == -1) {
1253 se->instance_id = calculate_new_instance_id(se->idstr);
1254 } else {
1255 se->instance_id = instance_id;
1257 assert(!se->compat || se->instance_id == 0);
1258 /* add at the end of list */
1259 QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1260 return 0;
1263 int register_savevm(DeviceState *dev,
1264 const char *idstr,
1265 int instance_id,
1266 int version_id,
1267 SaveStateHandler *save_state,
1268 LoadStateHandler *load_state,
1269 void *opaque)
1271 SaveVMHandlers *ops = g_malloc0(sizeof(SaveVMHandlers));
1272 ops->save_state = save_state;
1273 ops->load_state = load_state;
1274 return register_savevm_live(dev, idstr, instance_id, version_id,
1275 ops, opaque);
1278 void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
1280 SaveStateEntry *se, *new_se;
1281 char id[256] = "";
1283 if (dev) {
1284 char *path = qdev_get_dev_path(dev);
1285 if (path) {
1286 pstrcpy(id, sizeof(id), path);
1287 pstrcat(id, sizeof(id), "/");
1288 g_free(path);
1291 pstrcat(id, sizeof(id), idstr);
1293 QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1294 if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
1295 QTAILQ_REMOVE(&savevm_handlers, se, entry);
1296 if (se->compat) {
1297 g_free(se->compat);
1299 g_free(se->ops);
1300 g_free(se);
1305 int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
1306 const VMStateDescription *vmsd,
1307 void *opaque, int alias_id,
1308 int required_for_version)
1310 SaveStateEntry *se;
1312 /* If this triggers, alias support can be dropped for the vmsd. */
1313 assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id);
1315 se = g_malloc0(sizeof(SaveStateEntry));
1316 se->version_id = vmsd->version_id;
1317 se->section_id = global_section_id++;
1318 se->opaque = opaque;
1319 se->vmsd = vmsd;
1320 se->alias_id = alias_id;
1321 se->no_migrate = vmsd->unmigratable;
1323 if (dev) {
1324 char *id = qdev_get_dev_path(dev);
1325 if (id) {
1326 pstrcpy(se->idstr, sizeof(se->idstr), id);
1327 pstrcat(se->idstr, sizeof(se->idstr), "/");
1328 g_free(id);
1330 se->compat = g_malloc0(sizeof(CompatEntry));
1331 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
1332 se->compat->instance_id = instance_id == -1 ?
1333 calculate_compat_instance_id(vmsd->name) : instance_id;
1334 instance_id = -1;
1337 pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);
1339 if (instance_id == -1) {
1340 se->instance_id = calculate_new_instance_id(se->idstr);
1341 } else {
1342 se->instance_id = instance_id;
1344 assert(!se->compat || se->instance_id == 0);
1345 /* add at the end of list */
1346 QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1347 return 0;
1350 int vmstate_register(DeviceState *dev, int instance_id,
1351 const VMStateDescription *vmsd, void *opaque)
1353 return vmstate_register_with_alias_id(dev, instance_id, vmsd,
1354 opaque, -1, 0);
1357 void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
1358 void *opaque)
1360 SaveStateEntry *se, *new_se;
1362 QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1363 if (se->vmsd == vmsd && se->opaque == opaque) {
1364 QTAILQ_REMOVE(&savevm_handlers, se, entry);
1365 if (se->compat) {
1366 g_free(se->compat);
1368 g_free(se);
1373 static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
1374 void *opaque);
1375 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
1376 void *opaque);
1378 int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
1379 void *opaque, int version_id)
1381 VMStateField *field = vmsd->fields;
1382 int ret;
1384 if (version_id > vmsd->version_id) {
1385 return -EINVAL;
1387 if (version_id < vmsd->minimum_version_id_old) {
1388 return -EINVAL;
1390 if (version_id < vmsd->minimum_version_id) {
1391 return vmsd->load_state_old(f, opaque, version_id);
1393 if (vmsd->pre_load) {
1394 int ret = vmsd->pre_load(opaque);
1395 if (ret)
1396 return ret;
1398 while(field->name) {
1399 if ((field->field_exists &&
1400 field->field_exists(opaque, version_id)) ||
1401 (!field->field_exists &&
1402 field->version_id <= version_id)) {
1403 void *base_addr = opaque + field->offset;
1404 int i, n_elems = 1;
1405 int size = field->size;
1407 if (field->flags & VMS_VBUFFER) {
1408 size = *(int32_t *)(opaque+field->size_offset);
1409 if (field->flags & VMS_MULTIPLY) {
1410 size *= field->size;
1413 if (field->flags & VMS_ARRAY) {
1414 n_elems = field->num;
1415 } else if (field->flags & VMS_VARRAY_INT32) {
1416 n_elems = *(int32_t *)(opaque+field->num_offset);
1417 } else if (field->flags & VMS_VARRAY_UINT32) {
1418 n_elems = *(uint32_t *)(opaque+field->num_offset);
1419 } else if (field->flags & VMS_VARRAY_UINT16) {
1420 n_elems = *(uint16_t *)(opaque+field->num_offset);
1421 } else if (field->flags & VMS_VARRAY_UINT8) {
1422 n_elems = *(uint8_t *)(opaque+field->num_offset);
1424 if (field->flags & VMS_POINTER) {
1425 base_addr = *(void **)base_addr + field->start;
1427 for (i = 0; i < n_elems; i++) {
1428 void *addr = base_addr + size * i;
1430 if (field->flags & VMS_ARRAY_OF_POINTER) {
1431 addr = *(void **)addr;
1433 if (field->flags & VMS_STRUCT) {
1434 ret = vmstate_load_state(f, field->vmsd, addr, field->vmsd->version_id);
1435 } else {
1436 ret = field->info->get(f, addr, size);
1439 if (ret < 0) {
1440 return ret;
1444 field++;
1446 ret = vmstate_subsection_load(f, vmsd, opaque);
1447 if (ret != 0) {
1448 return ret;
1450 if (vmsd->post_load) {
1451 return vmsd->post_load(opaque, version_id);
1453 return 0;
1456 void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
1457 void *opaque)
1459 VMStateField *field = vmsd->fields;
1461 if (vmsd->pre_save) {
1462 vmsd->pre_save(opaque);
1464 while(field->name) {
1465 if (!field->field_exists ||
1466 field->field_exists(opaque, vmsd->version_id)) {
1467 void *base_addr = opaque + field->offset;
1468 int i, n_elems = 1;
1469 int size = field->size;
1471 if (field->flags & VMS_VBUFFER) {
1472 size = *(int32_t *)(opaque+field->size_offset);
1473 if (field->flags & VMS_MULTIPLY) {
1474 size *= field->size;
1477 if (field->flags & VMS_ARRAY) {
1478 n_elems = field->num;
1479 } else if (field->flags & VMS_VARRAY_INT32) {
1480 n_elems = *(int32_t *)(opaque+field->num_offset);
1481 } else if (field->flags & VMS_VARRAY_UINT32) {
1482 n_elems = *(uint32_t *)(opaque+field->num_offset);
1483 } else if (field->flags & VMS_VARRAY_UINT16) {
1484 n_elems = *(uint16_t *)(opaque+field->num_offset);
1485 } else if (field->flags & VMS_VARRAY_UINT8) {
1486 n_elems = *(uint8_t *)(opaque+field->num_offset);
1488 if (field->flags & VMS_POINTER) {
1489 base_addr = *(void **)base_addr + field->start;
1491 for (i = 0; i < n_elems; i++) {
1492 void *addr = base_addr + size * i;
1494 if (field->flags & VMS_ARRAY_OF_POINTER) {
1495 addr = *(void **)addr;
1497 if (field->flags & VMS_STRUCT) {
1498 vmstate_save_state(f, field->vmsd, addr);
1499 } else {
1500 field->info->put(f, addr, size);
1504 field++;
1506 vmstate_subsection_save(f, vmsd, opaque);
1509 static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id)
1511 if (!se->vmsd) { /* Old style */
1512 return se->ops->load_state(f, se->opaque, version_id);
1514 return vmstate_load_state(f, se->vmsd, se->opaque, version_id);
1517 static void vmstate_save(QEMUFile *f, SaveStateEntry *se)
1519 if (!se->vmsd) { /* Old style */
1520 se->ops->save_state(f, se->opaque);
1521 return;
1523 vmstate_save_state(f,se->vmsd, se->opaque);
1526 #define QEMU_VM_FILE_MAGIC 0x5145564d
1527 #define QEMU_VM_FILE_VERSION_COMPAT 0x00000002
1528 #define QEMU_VM_FILE_VERSION 0x00000003
1530 #define QEMU_VM_EOF 0x00
1531 #define QEMU_VM_SECTION_START 0x01
1532 #define QEMU_VM_SECTION_PART 0x02
1533 #define QEMU_VM_SECTION_END 0x03
1534 #define QEMU_VM_SECTION_FULL 0x04
1535 #define QEMU_VM_SUBSECTION 0x05
1537 bool qemu_savevm_state_blocked(Error **errp)
1539 SaveStateEntry *se;
1541 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1542 if (se->no_migrate) {
1543 error_set(errp, QERR_MIGRATION_NOT_SUPPORTED, se->idstr);
1544 return true;
1547 return false;
1550 int qemu_savevm_state_begin(QEMUFile *f,
1551 const MigrationParams *params)
1553 SaveStateEntry *se;
1554 int ret;
1556 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1557 if (!se->ops || !se->ops->set_params) {
1558 continue;
1560 se->ops->set_params(params, se->opaque);
1563 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1564 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1566 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1567 int len;
1569 if (!se->ops || !se->ops->save_live_setup) {
1570 continue;
1572 if (se->ops && se->ops->is_active) {
1573 if (!se->ops->is_active(se->opaque)) {
1574 continue;
1577 /* Section type */
1578 qemu_put_byte(f, QEMU_VM_SECTION_START);
1579 qemu_put_be32(f, se->section_id);
1581 /* ID string */
1582 len = strlen(se->idstr);
1583 qemu_put_byte(f, len);
1584 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1586 qemu_put_be32(f, se->instance_id);
1587 qemu_put_be32(f, se->version_id);
1589 ret = se->ops->save_live_setup(f, se->opaque);
1590 if (ret < 0) {
1591 qemu_savevm_state_cancel(f);
1592 return ret;
1595 ret = qemu_file_get_error(f);
1596 if (ret != 0) {
1597 qemu_savevm_state_cancel(f);
1600 return ret;
1605 * this function has three return values:
1606 * negative: there was one error, and we have -errno.
1607 * 0 : We haven't finished, caller have to go again
1608 * 1 : We have finished, we can go to complete phase
1610 int qemu_savevm_state_iterate(QEMUFile *f)
1612 SaveStateEntry *se;
1613 int ret = 1;
1615 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1616 if (!se->ops || !se->ops->save_live_iterate) {
1617 continue;
1619 if (se->ops && se->ops->is_active) {
1620 if (!se->ops->is_active(se->opaque)) {
1621 continue;
1624 if (qemu_file_rate_limit(f)) {
1625 return 0;
1627 trace_savevm_section_start();
1628 /* Section type */
1629 qemu_put_byte(f, QEMU_VM_SECTION_PART);
1630 qemu_put_be32(f, se->section_id);
1632 ret = se->ops->save_live_iterate(f, se->opaque);
1633 trace_savevm_section_end(se->section_id);
1635 if (ret <= 0) {
1636 /* Do not proceed to the next vmstate before this one reported
1637 completion of the current stage. This serializes the migration
1638 and reduces the probability that a faster changing state is
1639 synchronized over and over again. */
1640 break;
1643 if (ret != 0) {
1644 return ret;
1646 ret = qemu_file_get_error(f);
1647 if (ret != 0) {
1648 qemu_savevm_state_cancel(f);
1650 return ret;
1653 int qemu_savevm_state_complete(QEMUFile *f)
1655 SaveStateEntry *se;
1656 int ret;
1658 cpu_synchronize_all_states();
1660 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1661 if (!se->ops || !se->ops->save_live_complete) {
1662 continue;
1664 if (se->ops && se->ops->is_active) {
1665 if (!se->ops->is_active(se->opaque)) {
1666 continue;
1669 trace_savevm_section_start();
1670 /* Section type */
1671 qemu_put_byte(f, QEMU_VM_SECTION_END);
1672 qemu_put_be32(f, se->section_id);
1674 ret = se->ops->save_live_complete(f, se->opaque);
1675 trace_savevm_section_end(se->section_id);
1676 if (ret < 0) {
1677 return ret;
1681 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1682 int len;
1684 if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1685 continue;
1687 trace_savevm_section_start();
1688 /* Section type */
1689 qemu_put_byte(f, QEMU_VM_SECTION_FULL);
1690 qemu_put_be32(f, se->section_id);
1692 /* ID string */
1693 len = strlen(se->idstr);
1694 qemu_put_byte(f, len);
1695 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1697 qemu_put_be32(f, se->instance_id);
1698 qemu_put_be32(f, se->version_id);
1700 vmstate_save(f, se);
1701 trace_savevm_section_end(se->section_id);
1704 qemu_put_byte(f, QEMU_VM_EOF);
1706 return qemu_file_get_error(f);
1709 uint64_t qemu_savevm_state_pending(QEMUFile *f, uint64_t max_size)
1711 SaveStateEntry *se;
1712 uint64_t ret = 0;
1714 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1715 if (!se->ops || !se->ops->save_live_pending) {
1716 continue;
1718 if (se->ops && se->ops->is_active) {
1719 if (!se->ops->is_active(se->opaque)) {
1720 continue;
1723 ret += se->ops->save_live_pending(f, se->opaque, max_size);
1725 return ret;
1728 void qemu_savevm_state_cancel(QEMUFile *f)
1730 SaveStateEntry *se;
1732 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1733 if (se->ops && se->ops->cancel) {
1734 se->ops->cancel(se->opaque);
1739 static int qemu_savevm_state(QEMUFile *f)
1741 int ret;
1742 MigrationParams params = {
1743 .blk = 0,
1744 .shared = 0
1747 if (qemu_savevm_state_blocked(NULL)) {
1748 ret = -EINVAL;
1749 goto out;
1752 ret = qemu_savevm_state_begin(f, &params);
1753 if (ret < 0)
1754 goto out;
1756 do {
1757 ret = qemu_savevm_state_iterate(f);
1758 if (ret < 0)
1759 goto out;
1760 } while (ret == 0);
1762 ret = qemu_savevm_state_complete(f);
1764 out:
1765 if (ret == 0) {
1766 ret = qemu_file_get_error(f);
1769 return ret;
1772 static int qemu_save_device_state(QEMUFile *f)
1774 SaveStateEntry *se;
1776 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1777 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1779 cpu_synchronize_all_states();
1781 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1782 int len;
1784 if (se->is_ram) {
1785 continue;
1787 if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1788 continue;
1791 /* Section type */
1792 qemu_put_byte(f, QEMU_VM_SECTION_FULL);
1793 qemu_put_be32(f, se->section_id);
1795 /* ID string */
1796 len = strlen(se->idstr);
1797 qemu_put_byte(f, len);
1798 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1800 qemu_put_be32(f, se->instance_id);
1801 qemu_put_be32(f, se->version_id);
1803 vmstate_save(f, se);
1806 qemu_put_byte(f, QEMU_VM_EOF);
1808 return qemu_file_get_error(f);
1811 static SaveStateEntry *find_se(const char *idstr, int instance_id)
1813 SaveStateEntry *se;
1815 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1816 if (!strcmp(se->idstr, idstr) &&
1817 (instance_id == se->instance_id ||
1818 instance_id == se->alias_id))
1819 return se;
1820 /* Migrating from an older version? */
1821 if (strstr(se->idstr, idstr) && se->compat) {
1822 if (!strcmp(se->compat->idstr, idstr) &&
1823 (instance_id == se->compat->instance_id ||
1824 instance_id == se->alias_id))
1825 return se;
1828 return NULL;
1831 static const VMStateDescription *vmstate_get_subsection(const VMStateSubsection *sub, char *idstr)
1833 while(sub && sub->needed) {
1834 if (strcmp(idstr, sub->vmsd->name) == 0) {
1835 return sub->vmsd;
1837 sub++;
1839 return NULL;
1842 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
1843 void *opaque)
1845 while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
1846 char idstr[256];
1847 int ret;
1848 uint8_t version_id, len, size;
1849 const VMStateDescription *sub_vmsd;
1851 len = qemu_peek_byte(f, 1);
1852 if (len < strlen(vmsd->name) + 1) {
1853 /* subsection name has be be "section_name/a" */
1854 return 0;
1856 size = qemu_peek_buffer(f, (uint8_t *)idstr, len, 2);
1857 if (size != len) {
1858 return 0;
1860 idstr[size] = 0;
1862 if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
1863 /* it don't have a valid subsection name */
1864 return 0;
1866 sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
1867 if (sub_vmsd == NULL) {
1868 return -ENOENT;
1870 qemu_file_skip(f, 1); /* subsection */
1871 qemu_file_skip(f, 1); /* len */
1872 qemu_file_skip(f, len); /* idstr */
1873 version_id = qemu_get_be32(f);
1875 ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
1876 if (ret) {
1877 return ret;
1880 return 0;
1883 static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
1884 void *opaque)
1886 const VMStateSubsection *sub = vmsd->subsections;
1888 while (sub && sub->needed) {
1889 if (sub->needed(opaque)) {
1890 const VMStateDescription *vmsd = sub->vmsd;
1891 uint8_t len;
1893 qemu_put_byte(f, QEMU_VM_SUBSECTION);
1894 len = strlen(vmsd->name);
1895 qemu_put_byte(f, len);
1896 qemu_put_buffer(f, (uint8_t *)vmsd->name, len);
1897 qemu_put_be32(f, vmsd->version_id);
1898 vmstate_save_state(f, vmsd, opaque);
1900 sub++;
1904 typedef struct LoadStateEntry {
1905 QLIST_ENTRY(LoadStateEntry) entry;
1906 SaveStateEntry *se;
1907 int section_id;
1908 int version_id;
1909 } LoadStateEntry;
1911 int qemu_loadvm_state(QEMUFile *f)
1913 QLIST_HEAD(, LoadStateEntry) loadvm_handlers =
1914 QLIST_HEAD_INITIALIZER(loadvm_handlers);
1915 LoadStateEntry *le, *new_le;
1916 uint8_t section_type;
1917 unsigned int v;
1918 int ret;
1920 if (qemu_savevm_state_blocked(NULL)) {
1921 return -EINVAL;
1924 v = qemu_get_be32(f);
1925 if (v != QEMU_VM_FILE_MAGIC)
1926 return -EINVAL;
1928 v = qemu_get_be32(f);
1929 if (v == QEMU_VM_FILE_VERSION_COMPAT) {
1930 fprintf(stderr, "SaveVM v2 format is obsolete and don't work anymore\n");
1931 return -ENOTSUP;
1933 if (v != QEMU_VM_FILE_VERSION)
1934 return -ENOTSUP;
1936 while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
1937 uint32_t instance_id, version_id, section_id;
1938 SaveStateEntry *se;
1939 char idstr[257];
1940 int len;
1942 switch (section_type) {
1943 case QEMU_VM_SECTION_START:
1944 case QEMU_VM_SECTION_FULL:
1945 /* Read section start */
1946 section_id = qemu_get_be32(f);
1947 len = qemu_get_byte(f);
1948 qemu_get_buffer(f, (uint8_t *)idstr, len);
1949 idstr[len] = 0;
1950 instance_id = qemu_get_be32(f);
1951 version_id = qemu_get_be32(f);
1953 /* Find savevm section */
1954 se = find_se(idstr, instance_id);
1955 if (se == NULL) {
1956 fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
1957 ret = -EINVAL;
1958 goto out;
1961 /* Validate version */
1962 if (version_id > se->version_id) {
1963 fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
1964 version_id, idstr, se->version_id);
1965 ret = -EINVAL;
1966 goto out;
1969 /* Add entry */
1970 le = g_malloc0(sizeof(*le));
1972 le->se = se;
1973 le->section_id = section_id;
1974 le->version_id = version_id;
1975 QLIST_INSERT_HEAD(&loadvm_handlers, le, entry);
1977 ret = vmstate_load(f, le->se, le->version_id);
1978 if (ret < 0) {
1979 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
1980 instance_id, idstr);
1981 goto out;
1983 break;
1984 case QEMU_VM_SECTION_PART:
1985 case QEMU_VM_SECTION_END:
1986 section_id = qemu_get_be32(f);
1988 QLIST_FOREACH(le, &loadvm_handlers, entry) {
1989 if (le->section_id == section_id) {
1990 break;
1993 if (le == NULL) {
1994 fprintf(stderr, "Unknown savevm section %d\n", section_id);
1995 ret = -EINVAL;
1996 goto out;
1999 ret = vmstate_load(f, le->se, le->version_id);
2000 if (ret < 0) {
2001 fprintf(stderr, "qemu: warning: error while loading state section id %d\n",
2002 section_id);
2003 goto out;
2005 break;
2006 default:
2007 fprintf(stderr, "Unknown savevm section type %d\n", section_type);
2008 ret = -EINVAL;
2009 goto out;
2013 cpu_synchronize_all_post_init();
2015 ret = 0;
2017 out:
2018 QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
2019 QLIST_REMOVE(le, entry);
2020 g_free(le);
2023 if (ret == 0) {
2024 ret = qemu_file_get_error(f);
2027 return ret;
2030 static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
2031 const char *name)
2033 QEMUSnapshotInfo *sn_tab, *sn;
2034 int nb_sns, i, ret;
2036 ret = -ENOENT;
2037 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2038 if (nb_sns < 0)
2039 return ret;
2040 for(i = 0; i < nb_sns; i++) {
2041 sn = &sn_tab[i];
2042 if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
2043 *sn_info = *sn;
2044 ret = 0;
2045 break;
2048 g_free(sn_tab);
2049 return ret;
2053 * Deletes snapshots of a given name in all opened images.
2055 static int del_existing_snapshots(Monitor *mon, const char *name)
2057 BlockDriverState *bs;
2058 QEMUSnapshotInfo sn1, *snapshot = &sn1;
2059 int ret;
2061 bs = NULL;
2062 while ((bs = bdrv_next(bs))) {
2063 if (bdrv_can_snapshot(bs) &&
2064 bdrv_snapshot_find(bs, snapshot, name) >= 0)
2066 ret = bdrv_snapshot_delete(bs, name);
2067 if (ret < 0) {
2068 monitor_printf(mon,
2069 "Error while deleting snapshot on '%s'\n",
2070 bdrv_get_device_name(bs));
2071 return -1;
2076 return 0;
2079 void do_savevm(Monitor *mon, const QDict *qdict)
2081 BlockDriverState *bs, *bs1;
2082 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
2083 int ret;
2084 QEMUFile *f;
2085 int saved_vm_running;
2086 uint64_t vm_state_size;
2087 qemu_timeval tv;
2088 struct tm tm;
2089 const char *name = qdict_get_try_str(qdict, "name");
2091 /* Verify if there is a device that doesn't support snapshots and is writable */
2092 bs = NULL;
2093 while ((bs = bdrv_next(bs))) {
2095 if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2096 continue;
2099 if (!bdrv_can_snapshot(bs)) {
2100 monitor_printf(mon, "Device '%s' is writable but does not support snapshots.\n",
2101 bdrv_get_device_name(bs));
2102 return;
2106 bs = bdrv_snapshots();
2107 if (!bs) {
2108 monitor_printf(mon, "No block device can accept snapshots\n");
2109 return;
2112 saved_vm_running = runstate_is_running();
2113 vm_stop(RUN_STATE_SAVE_VM);
2115 memset(sn, 0, sizeof(*sn));
2117 /* fill auxiliary fields */
2118 qemu_gettimeofday(&tv);
2119 sn->date_sec = tv.tv_sec;
2120 sn->date_nsec = tv.tv_usec * 1000;
2121 sn->vm_clock_nsec = qemu_get_clock_ns(vm_clock);
2123 if (name) {
2124 ret = bdrv_snapshot_find(bs, old_sn, name);
2125 if (ret >= 0) {
2126 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
2127 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
2128 } else {
2129 pstrcpy(sn->name, sizeof(sn->name), name);
2131 } else {
2132 /* cast below needed for OpenBSD where tv_sec is still 'long' */
2133 localtime_r((const time_t *)&tv.tv_sec, &tm);
2134 strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
2137 /* Delete old snapshots of the same name */
2138 if (name && del_existing_snapshots(mon, name) < 0) {
2139 goto the_end;
2142 /* save the VM state */
2143 f = qemu_fopen_bdrv(bs, 1);
2144 if (!f) {
2145 monitor_printf(mon, "Could not open VM state file\n");
2146 goto the_end;
2148 ret = qemu_savevm_state(f);
2149 vm_state_size = qemu_ftell(f);
2150 qemu_fclose(f);
2151 if (ret < 0) {
2152 monitor_printf(mon, "Error %d while writing VM\n", ret);
2153 goto the_end;
2156 /* create the snapshots */
2158 bs1 = NULL;
2159 while ((bs1 = bdrv_next(bs1))) {
2160 if (bdrv_can_snapshot(bs1)) {
2161 /* Write VM state size only to the image that contains the state */
2162 sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
2163 ret = bdrv_snapshot_create(bs1, sn);
2164 if (ret < 0) {
2165 monitor_printf(mon, "Error while creating snapshot on '%s'\n",
2166 bdrv_get_device_name(bs1));
2171 the_end:
2172 if (saved_vm_running)
2173 vm_start();
2176 void qmp_xen_save_devices_state(const char *filename, Error **errp)
2178 QEMUFile *f;
2179 int saved_vm_running;
2180 int ret;
2182 saved_vm_running = runstate_is_running();
2183 vm_stop(RUN_STATE_SAVE_VM);
2185 f = qemu_fopen(filename, "wb");
2186 if (!f) {
2187 error_set(errp, QERR_OPEN_FILE_FAILED, filename);
2188 goto the_end;
2190 ret = qemu_save_device_state(f);
2191 qemu_fclose(f);
2192 if (ret < 0) {
2193 error_set(errp, QERR_IO_ERROR);
2196 the_end:
2197 if (saved_vm_running)
2198 vm_start();
2201 int load_vmstate(const char *name)
2203 BlockDriverState *bs, *bs_vm_state;
2204 QEMUSnapshotInfo sn;
2205 QEMUFile *f;
2206 int ret;
2208 bs_vm_state = bdrv_snapshots();
2209 if (!bs_vm_state) {
2210 error_report("No block device supports snapshots");
2211 return -ENOTSUP;
2214 /* Don't even try to load empty VM states */
2215 ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
2216 if (ret < 0) {
2217 return ret;
2218 } else if (sn.vm_state_size == 0) {
2219 error_report("This is a disk-only snapshot. Revert to it offline "
2220 "using qemu-img.");
2221 return -EINVAL;
2224 /* Verify if there is any device that doesn't support snapshots and is
2225 writable and check if the requested snapshot is available too. */
2226 bs = NULL;
2227 while ((bs = bdrv_next(bs))) {
2229 if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2230 continue;
2233 if (!bdrv_can_snapshot(bs)) {
2234 error_report("Device '%s' is writable but does not support snapshots.",
2235 bdrv_get_device_name(bs));
2236 return -ENOTSUP;
2239 ret = bdrv_snapshot_find(bs, &sn, name);
2240 if (ret < 0) {
2241 error_report("Device '%s' does not have the requested snapshot '%s'",
2242 bdrv_get_device_name(bs), name);
2243 return ret;
2247 /* Flush all IO requests so they don't interfere with the new state. */
2248 bdrv_drain_all();
2250 bs = NULL;
2251 while ((bs = bdrv_next(bs))) {
2252 if (bdrv_can_snapshot(bs)) {
2253 ret = bdrv_snapshot_goto(bs, name);
2254 if (ret < 0) {
2255 error_report("Error %d while activating snapshot '%s' on '%s'",
2256 ret, name, bdrv_get_device_name(bs));
2257 return ret;
2262 /* restore the VM state */
2263 f = qemu_fopen_bdrv(bs_vm_state, 0);
2264 if (!f) {
2265 error_report("Could not open VM state file");
2266 return -EINVAL;
2269 qemu_system_reset(VMRESET_SILENT);
2270 ret = qemu_loadvm_state(f);
2272 qemu_fclose(f);
2273 if (ret < 0) {
2274 error_report("Error %d while loading VM state", ret);
2275 return ret;
2278 return 0;
2281 void do_delvm(Monitor *mon, const QDict *qdict)
2283 BlockDriverState *bs, *bs1;
2284 int ret;
2285 const char *name = qdict_get_str(qdict, "name");
2287 bs = bdrv_snapshots();
2288 if (!bs) {
2289 monitor_printf(mon, "No block device supports snapshots\n");
2290 return;
2293 bs1 = NULL;
2294 while ((bs1 = bdrv_next(bs1))) {
2295 if (bdrv_can_snapshot(bs1)) {
2296 ret = bdrv_snapshot_delete(bs1, name);
2297 if (ret < 0) {
2298 if (ret == -ENOTSUP)
2299 monitor_printf(mon,
2300 "Snapshots not supported on device '%s'\n",
2301 bdrv_get_device_name(bs1));
2302 else
2303 monitor_printf(mon, "Error %d while deleting snapshot on "
2304 "'%s'\n", ret, bdrv_get_device_name(bs1));
2310 void do_info_snapshots(Monitor *mon)
2312 BlockDriverState *bs, *bs1;
2313 QEMUSnapshotInfo *sn_tab, *sn, s, *sn_info = &s;
2314 int nb_sns, i, ret, available;
2315 int total;
2316 int *available_snapshots;
2317 char buf[256];
2319 bs = bdrv_snapshots();
2320 if (!bs) {
2321 monitor_printf(mon, "No available block device supports snapshots\n");
2322 return;
2325 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2326 if (nb_sns < 0) {
2327 monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
2328 return;
2331 if (nb_sns == 0) {
2332 monitor_printf(mon, "There is no snapshot available.\n");
2333 return;
2336 available_snapshots = g_malloc0(sizeof(int) * nb_sns);
2337 total = 0;
2338 for (i = 0; i < nb_sns; i++) {
2339 sn = &sn_tab[i];
2340 available = 1;
2341 bs1 = NULL;
2343 while ((bs1 = bdrv_next(bs1))) {
2344 if (bdrv_can_snapshot(bs1) && bs1 != bs) {
2345 ret = bdrv_snapshot_find(bs1, sn_info, sn->id_str);
2346 if (ret < 0) {
2347 available = 0;
2348 break;
2353 if (available) {
2354 available_snapshots[total] = i;
2355 total++;
2359 if (total > 0) {
2360 monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
2361 for (i = 0; i < total; i++) {
2362 sn = &sn_tab[available_snapshots[i]];
2363 monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
2365 } else {
2366 monitor_printf(mon, "There is no suitable snapshot available\n");
2369 g_free(sn_tab);
2370 g_free(available_snapshots);
2374 void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
2376 qemu_ram_set_idstr(memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK,
2377 memory_region_name(mr), dev);
2380 void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev)
2382 /* Nothing do to while the implementation is in RAMBlock */
2385 void vmstate_register_ram_global(MemoryRegion *mr)
2387 vmstate_register_ram(mr, NULL);
2391 page = zrun nzrun
2392 | zrun nzrun page
2394 zrun = length
2396 nzrun = length byte...
2398 length = uleb128 encoded integer
2400 int xbzrle_encode_buffer(uint8_t *old_buf, uint8_t *new_buf, int slen,
2401 uint8_t *dst, int dlen)
2403 uint32_t zrun_len = 0, nzrun_len = 0;
2404 int d = 0, i = 0;
2405 long res, xor;
2406 uint8_t *nzrun_start = NULL;
2408 g_assert(!(((uintptr_t)old_buf | (uintptr_t)new_buf | slen) %
2409 sizeof(long)));
2411 while (i < slen) {
2412 /* overflow */
2413 if (d + 2 > dlen) {
2414 return -1;
2417 /* not aligned to sizeof(long) */
2418 res = (slen - i) % sizeof(long);
2419 while (res && old_buf[i] == new_buf[i]) {
2420 zrun_len++;
2421 i++;
2422 res--;
2425 /* word at a time for speed */
2426 if (!res) {
2427 while (i < slen &&
2428 (*(long *)(old_buf + i)) == (*(long *)(new_buf + i))) {
2429 i += sizeof(long);
2430 zrun_len += sizeof(long);
2433 /* go over the rest */
2434 while (i < slen && old_buf[i] == new_buf[i]) {
2435 zrun_len++;
2436 i++;
2440 /* buffer unchanged */
2441 if (zrun_len == slen) {
2442 return 0;
2445 /* skip last zero run */
2446 if (i == slen) {
2447 return d;
2450 d += uleb128_encode_small(dst + d, zrun_len);
2452 zrun_len = 0;
2453 nzrun_start = new_buf + i;
2455 /* overflow */
2456 if (d + 2 > dlen) {
2457 return -1;
2459 /* not aligned to sizeof(long) */
2460 res = (slen - i) % sizeof(long);
2461 while (res && old_buf[i] != new_buf[i]) {
2462 i++;
2463 nzrun_len++;
2464 res--;
2467 /* word at a time for speed, use of 32-bit long okay */
2468 if (!res) {
2469 /* truncation to 32-bit long okay */
2470 long mask = (long)0x0101010101010101ULL;
2471 while (i < slen) {
2472 xor = *(long *)(old_buf + i) ^ *(long *)(new_buf + i);
2473 if ((xor - mask) & ~xor & (mask << 7)) {
2474 /* found the end of an nzrun within the current long */
2475 while (old_buf[i] != new_buf[i]) {
2476 nzrun_len++;
2477 i++;
2479 break;
2480 } else {
2481 i += sizeof(long);
2482 nzrun_len += sizeof(long);
2487 d += uleb128_encode_small(dst + d, nzrun_len);
2488 /* overflow */
2489 if (d + nzrun_len > dlen) {
2490 return -1;
2492 memcpy(dst + d, nzrun_start, nzrun_len);
2493 d += nzrun_len;
2494 nzrun_len = 0;
2497 return d;
2500 int xbzrle_decode_buffer(uint8_t *src, int slen, uint8_t *dst, int dlen)
2502 int i = 0, d = 0;
2503 int ret;
2504 uint32_t count = 0;
2506 while (i < slen) {
2508 /* zrun */
2509 if ((slen - i) < 2) {
2510 return -1;
2513 ret = uleb128_decode_small(src + i, &count);
2514 if (ret < 0 || (i && !count)) {
2515 return -1;
2517 i += ret;
2518 d += count;
2520 /* overflow */
2521 if (d > dlen) {
2522 return -1;
2525 /* nzrun */
2526 if ((slen - i) < 2) {
2527 return -1;
2530 ret = uleb128_decode_small(src + i, &count);
2531 if (ret < 0 || !count) {
2532 return -1;
2534 i += ret;
2536 /* overflow */
2537 if (d + count > dlen || i + count > slen) {
2538 return -1;
2541 memcpy(dst + d, src + i, count);
2542 d += count;
2543 i += count;
2546 return d;