configure: Fix compiler warnings in config.log (null arguments)
[qemu/ar7.git] / savevm.c
blobb72f6c0d17e72af837e7dcdabcd2a6ee426c5f98
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.
24 #include <unistd.h>
25 #include <fcntl.h>
26 #include <time.h>
27 #include <errno.h>
28 #include <sys/time.h>
29 #include <zlib.h>
31 /* Needed early for CONFIG_BSD etc. */
32 #include "config-host.h"
34 #ifndef _WIN32
35 #include <sys/times.h>
36 #include <sys/wait.h>
37 #include <termios.h>
38 #include <sys/mman.h>
39 #include <sys/ioctl.h>
40 #include <sys/resource.h>
41 #include <sys/socket.h>
42 #include <netinet/in.h>
43 #include <net/if.h>
44 #include <arpa/inet.h>
45 #include <dirent.h>
46 #include <netdb.h>
47 #include <sys/select.h>
48 #ifdef CONFIG_BSD
49 #include <sys/stat.h>
50 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
51 #include <libutil.h>
52 #else
53 #include <util.h>
54 #endif
55 #ifdef __linux__
56 #include <pty.h>
57 #include <malloc.h>
58 #include <linux/rtc.h>
59 #endif
60 #endif
61 #endif
63 #ifdef _WIN32
64 #include <windows.h>
65 #include <malloc.h>
66 #include <sys/timeb.h>
67 #include <mmsystem.h>
68 #define getopt_long_only getopt_long
69 #define memalign(align, size) malloc(size)
70 #endif
72 #include "qemu-common.h"
73 #include "hw/hw.h"
74 #include "hw/qdev.h"
75 #include "net.h"
76 #include "monitor.h"
77 #include "sysemu.h"
78 #include "qemu-timer.h"
79 #include "qemu-char.h"
80 #include "audio/audio.h"
81 #include "migration.h"
82 #include "qemu_socket.h"
83 #include "qemu-queue.h"
84 #include "qemu-timer.h"
85 #include "cpus.h"
87 #define SELF_ANNOUNCE_ROUNDS 5
89 #ifndef ETH_P_RARP
90 #define ETH_P_RARP 0x8035
91 #endif
92 #define ARP_HTYPE_ETH 0x0001
93 #define ARP_PTYPE_IP 0x0800
94 #define ARP_OP_REQUEST_REV 0x3
96 static int announce_self_create(uint8_t *buf,
97 uint8_t *mac_addr)
99 /* Ethernet header. */
100 memset(buf, 0xff, 6); /* destination MAC addr */
101 memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
102 *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */
104 /* RARP header. */
105 *(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */
106 *(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */
107 *(buf + 18) = 6; /* hardware addr length (ethernet) */
108 *(buf + 19) = 4; /* protocol addr length (IPv4) */
109 *(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */
110 memcpy(buf + 22, mac_addr, 6); /* source hw addr */
111 memset(buf + 28, 0x00, 4); /* source protocol addr */
112 memcpy(buf + 32, mac_addr, 6); /* target hw addr */
113 memset(buf + 38, 0x00, 4); /* target protocol addr */
115 /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
116 memset(buf + 42, 0x00, 18);
118 return 60; /* len (FCS will be added by hardware) */
121 static void qemu_announce_self_iter(NICState *nic, void *opaque)
123 uint8_t buf[60];
124 int len;
126 len = announce_self_create(buf, nic->conf->macaddr.a);
128 qemu_send_packet_raw(&nic->nc, buf, len);
132 static void qemu_announce_self_once(void *opaque)
134 static int count = SELF_ANNOUNCE_ROUNDS;
135 QEMUTimer *timer = *(QEMUTimer **)opaque;
137 qemu_foreach_nic(qemu_announce_self_iter, NULL);
139 if (--count) {
140 /* delay 50ms, 150ms, 250ms, ... */
141 qemu_mod_timer(timer, qemu_get_clock_ms(rt_clock) +
142 50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100);
143 } else {
144 qemu_del_timer(timer);
145 qemu_free_timer(timer);
149 void qemu_announce_self(void)
151 static QEMUTimer *timer;
152 timer = qemu_new_timer_ms(rt_clock, qemu_announce_self_once, &timer);
153 qemu_announce_self_once(&timer);
156 /***********************************************************/
157 /* savevm/loadvm support */
159 #define IO_BUF_SIZE 32768
161 struct QEMUFile {
162 QEMUFilePutBufferFunc *put_buffer;
163 QEMUFileGetBufferFunc *get_buffer;
164 QEMUFileCloseFunc *close;
165 QEMUFileRateLimit *rate_limit;
166 QEMUFileSetRateLimit *set_rate_limit;
167 QEMUFileGetRateLimit *get_rate_limit;
168 void *opaque;
169 int is_write;
171 int64_t buf_offset; /* start of buffer when writing, end of buffer
172 when reading */
173 int buf_index;
174 int buf_size; /* 0 when writing */
175 uint8_t buf[IO_BUF_SIZE];
177 int last_error;
180 typedef struct QEMUFileStdio
182 FILE *stdio_file;
183 QEMUFile *file;
184 } QEMUFileStdio;
186 typedef struct QEMUFileSocket
188 int fd;
189 QEMUFile *file;
190 } QEMUFileSocket;
192 static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
194 QEMUFileSocket *s = opaque;
195 ssize_t len;
197 do {
198 len = qemu_recv(s->fd, buf, size, 0);
199 } while (len == -1 && socket_error() == EINTR);
201 if (len == -1)
202 len = -socket_error();
204 return len;
207 static int socket_close(void *opaque)
209 QEMUFileSocket *s = opaque;
210 g_free(s);
211 return 0;
214 static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
216 QEMUFileStdio *s = opaque;
217 return fwrite(buf, 1, size, s->stdio_file);
220 static int stdio_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
222 QEMUFileStdio *s = opaque;
223 FILE *fp = s->stdio_file;
224 int bytes;
226 do {
227 clearerr(fp);
228 bytes = fread(buf, 1, size, fp);
229 } while ((bytes == 0) && ferror(fp) && (errno == EINTR));
230 return bytes;
233 static int stdio_pclose(void *opaque)
235 QEMUFileStdio *s = opaque;
236 int ret;
237 ret = pclose(s->stdio_file);
238 if (ret == -1) {
239 ret = -errno;
241 g_free(s);
242 return ret;
245 static int stdio_fclose(void *opaque)
247 QEMUFileStdio *s = opaque;
248 int ret = 0;
249 if (fclose(s->stdio_file) == EOF) {
250 ret = -errno;
252 g_free(s);
253 return ret;
256 QEMUFile *qemu_popen(FILE *stdio_file, const char *mode)
258 QEMUFileStdio *s;
260 if (stdio_file == NULL || mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
261 fprintf(stderr, "qemu_popen: Argument validity check failed\n");
262 return NULL;
265 s = g_malloc0(sizeof(QEMUFileStdio));
267 s->stdio_file = stdio_file;
269 if(mode[0] == 'r') {
270 s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_pclose,
271 NULL, NULL, NULL);
272 } else {
273 s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_pclose,
274 NULL, NULL, NULL);
276 return s->file;
279 QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
281 FILE *popen_file;
283 popen_file = popen(command, mode);
284 if(popen_file == NULL) {
285 return NULL;
288 return qemu_popen(popen_file, mode);
291 int qemu_stdio_fd(QEMUFile *f)
293 QEMUFileStdio *p;
294 int fd;
296 p = (QEMUFileStdio *)f->opaque;
297 fd = fileno(p->stdio_file);
299 return fd;
302 QEMUFile *qemu_fdopen(int fd, const char *mode)
304 QEMUFileStdio *s;
306 if (mode == NULL ||
307 (mode[0] != 'r' && mode[0] != 'w') ||
308 mode[1] != 'b' || mode[2] != 0) {
309 fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
310 return NULL;
313 s = g_malloc0(sizeof(QEMUFileStdio));
314 s->stdio_file = fdopen(fd, mode);
315 if (!s->stdio_file)
316 goto fail;
318 if(mode[0] == 'r') {
319 s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_fclose,
320 NULL, NULL, NULL);
321 } else {
322 s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_fclose,
323 NULL, NULL, NULL);
325 return s->file;
327 fail:
328 g_free(s);
329 return NULL;
332 QEMUFile *qemu_fopen_socket(int fd)
334 QEMUFileSocket *s = g_malloc0(sizeof(QEMUFileSocket));
336 s->fd = fd;
337 s->file = qemu_fopen_ops(s, NULL, socket_get_buffer, socket_close,
338 NULL, NULL, NULL);
339 return s->file;
342 static int file_put_buffer(void *opaque, const uint8_t *buf,
343 int64_t pos, int size)
345 QEMUFileStdio *s = opaque;
346 fseek(s->stdio_file, pos, SEEK_SET);
347 return fwrite(buf, 1, size, s->stdio_file);
350 static int file_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
352 QEMUFileStdio *s = opaque;
353 fseek(s->stdio_file, pos, SEEK_SET);
354 return fread(buf, 1, size, s->stdio_file);
357 QEMUFile *qemu_fopen(const char *filename, const char *mode)
359 QEMUFileStdio *s;
361 if (mode == NULL ||
362 (mode[0] != 'r' && mode[0] != 'w') ||
363 mode[1] != 'b' || mode[2] != 0) {
364 fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
365 return NULL;
368 s = g_malloc0(sizeof(QEMUFileStdio));
370 s->stdio_file = fopen(filename, mode);
371 if (!s->stdio_file)
372 goto fail;
374 if(mode[0] == 'w') {
375 s->file = qemu_fopen_ops(s, file_put_buffer, NULL, stdio_fclose,
376 NULL, NULL, NULL);
377 } else {
378 s->file = qemu_fopen_ops(s, NULL, file_get_buffer, stdio_fclose,
379 NULL, NULL, NULL);
381 return s->file;
382 fail:
383 g_free(s);
384 return NULL;
387 static int block_put_buffer(void *opaque, const uint8_t *buf,
388 int64_t pos, int size)
390 bdrv_save_vmstate(opaque, buf, pos, size);
391 return size;
394 static int block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
396 return bdrv_load_vmstate(opaque, buf, pos, size);
399 static int bdrv_fclose(void *opaque)
401 return 0;
404 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
406 if (is_writable)
407 return qemu_fopen_ops(bs, block_put_buffer, NULL, bdrv_fclose,
408 NULL, NULL, NULL);
409 return qemu_fopen_ops(bs, NULL, block_get_buffer, bdrv_fclose, NULL, NULL, NULL);
412 QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
413 QEMUFileGetBufferFunc *get_buffer,
414 QEMUFileCloseFunc *close,
415 QEMUFileRateLimit *rate_limit,
416 QEMUFileSetRateLimit *set_rate_limit,
417 QEMUFileGetRateLimit *get_rate_limit)
419 QEMUFile *f;
421 f = g_malloc0(sizeof(QEMUFile));
423 f->opaque = opaque;
424 f->put_buffer = put_buffer;
425 f->get_buffer = get_buffer;
426 f->close = close;
427 f->rate_limit = rate_limit;
428 f->set_rate_limit = set_rate_limit;
429 f->get_rate_limit = get_rate_limit;
430 f->is_write = 0;
432 return f;
435 int qemu_file_get_error(QEMUFile *f)
437 return f->last_error;
440 void qemu_file_set_error(QEMUFile *f, int ret)
442 f->last_error = ret;
445 /** Sets last_error conditionally
447 * Sets last_error only if ret is negative _and_ no error
448 * was set before.
450 static void qemu_file_set_if_error(QEMUFile *f, int ret)
452 if (ret < 0 && !f->last_error) {
453 qemu_file_set_error(f, ret);
457 /** Flushes QEMUFile buffer
459 * In case of error, last_error is set.
461 void qemu_fflush(QEMUFile *f)
463 if (!f->put_buffer)
464 return;
466 if (f->is_write && f->buf_index > 0) {
467 int len;
469 len = f->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
470 if (len > 0)
471 f->buf_offset += f->buf_index;
472 else
473 qemu_file_set_error(f, -EINVAL);
474 f->buf_index = 0;
478 static void qemu_fill_buffer(QEMUFile *f)
480 int len;
481 int pending;
483 if (!f->get_buffer)
484 return;
486 if (f->is_write)
487 abort();
489 pending = f->buf_size - f->buf_index;
490 if (pending > 0) {
491 memmove(f->buf, f->buf + f->buf_index, pending);
493 f->buf_index = 0;
494 f->buf_size = pending;
496 len = f->get_buffer(f->opaque, f->buf + pending, f->buf_offset,
497 IO_BUF_SIZE - pending);
498 if (len > 0) {
499 f->buf_size += len;
500 f->buf_offset += len;
501 } else if (len == 0) {
502 f->last_error = -EIO;
503 } else if (len != -EAGAIN)
504 qemu_file_set_error(f, len);
507 /** Calls close function and set last_error if needed
509 * Internal function. qemu_fflush() must be called before this.
511 * Returns f->close() return value, or 0 if close function is not set.
513 static int qemu_close(QEMUFile *f)
515 int ret = 0;
516 if (f->close) {
517 ret = f->close(f->opaque);
518 qemu_file_set_if_error(f, ret);
520 return ret;
523 /** Closes the file
525 * Returns negative error value if any error happened on previous operations or
526 * while closing the file. Returns 0 or positive number on success.
528 * The meaning of return value on success depends on the specific backend
529 * being used.
531 int qemu_fclose(QEMUFile *f)
533 int ret;
534 qemu_fflush(f);
535 ret = qemu_close(f);
536 /* If any error was spotted before closing, we should report it
537 * instead of the close() return value.
539 if (f->last_error) {
540 ret = f->last_error;
542 g_free(f);
543 return ret;
546 void qemu_file_put_notify(QEMUFile *f)
548 f->put_buffer(f->opaque, NULL, 0, 0);
551 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
553 int l;
555 if (!f->last_error && f->is_write == 0 && f->buf_index > 0) {
556 fprintf(stderr,
557 "Attempted to write to buffer while read buffer is not empty\n");
558 abort();
561 while (!f->last_error && size > 0) {
562 l = IO_BUF_SIZE - f->buf_index;
563 if (l > size)
564 l = size;
565 memcpy(f->buf + f->buf_index, buf, l);
566 f->is_write = 1;
567 f->buf_index += l;
568 buf += l;
569 size -= l;
570 if (f->buf_index >= IO_BUF_SIZE)
571 qemu_fflush(f);
575 void qemu_put_byte(QEMUFile *f, int v)
577 if (!f->last_error && f->is_write == 0 && f->buf_index > 0) {
578 fprintf(stderr,
579 "Attempted to write to buffer while read buffer is not empty\n");
580 abort();
583 f->buf[f->buf_index++] = v;
584 f->is_write = 1;
585 if (f->buf_index >= IO_BUF_SIZE)
586 qemu_fflush(f);
589 static void qemu_file_skip(QEMUFile *f, int size)
591 if (f->buf_index + size <= f->buf_size) {
592 f->buf_index += size;
596 static int qemu_peek_buffer(QEMUFile *f, uint8_t *buf, int size, size_t offset)
598 int pending;
599 int index;
601 if (f->is_write) {
602 abort();
605 index = f->buf_index + offset;
606 pending = f->buf_size - index;
607 if (pending < size) {
608 qemu_fill_buffer(f);
609 index = f->buf_index + offset;
610 pending = f->buf_size - index;
613 if (pending <= 0) {
614 return 0;
616 if (size > pending) {
617 size = pending;
620 memcpy(buf, f->buf + index, size);
621 return size;
624 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
626 int pending = size;
627 int done = 0;
629 while (pending > 0) {
630 int res;
632 res = qemu_peek_buffer(f, buf, pending, 0);
633 if (res == 0) {
634 return done;
636 qemu_file_skip(f, res);
637 buf += res;
638 pending -= res;
639 done += res;
641 return done;
644 static int qemu_peek_byte(QEMUFile *f, int offset)
646 int index = f->buf_index + offset;
648 if (f->is_write) {
649 abort();
652 if (index >= f->buf_size) {
653 qemu_fill_buffer(f);
654 index = f->buf_index + offset;
655 if (index >= f->buf_size) {
656 return 0;
659 return f->buf[index];
662 int qemu_get_byte(QEMUFile *f)
664 int result;
666 result = qemu_peek_byte(f, 0);
667 qemu_file_skip(f, 1);
668 return result;
671 int64_t qemu_ftell(QEMUFile *f)
673 return f->buf_offset - f->buf_size + f->buf_index;
676 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
678 if (whence == SEEK_SET) {
679 /* nothing to do */
680 } else if (whence == SEEK_CUR) {
681 pos += qemu_ftell(f);
682 } else {
683 /* SEEK_END not supported */
684 return -1;
686 if (f->put_buffer) {
687 qemu_fflush(f);
688 f->buf_offset = pos;
689 } else {
690 f->buf_offset = pos;
691 f->buf_index = 0;
692 f->buf_size = 0;
694 return pos;
697 int qemu_file_rate_limit(QEMUFile *f)
699 if (f->rate_limit)
700 return f->rate_limit(f->opaque);
702 return 0;
705 int64_t qemu_file_get_rate_limit(QEMUFile *f)
707 if (f->get_rate_limit)
708 return f->get_rate_limit(f->opaque);
710 return 0;
713 int64_t qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate)
715 /* any failed or completed migration keeps its state to allow probing of
716 * migration data, but has no associated file anymore */
717 if (f && f->set_rate_limit)
718 return f->set_rate_limit(f->opaque, new_rate);
720 return 0;
723 void qemu_put_be16(QEMUFile *f, unsigned int v)
725 qemu_put_byte(f, v >> 8);
726 qemu_put_byte(f, v);
729 void qemu_put_be32(QEMUFile *f, unsigned int v)
731 qemu_put_byte(f, v >> 24);
732 qemu_put_byte(f, v >> 16);
733 qemu_put_byte(f, v >> 8);
734 qemu_put_byte(f, v);
737 void qemu_put_be64(QEMUFile *f, uint64_t v)
739 qemu_put_be32(f, v >> 32);
740 qemu_put_be32(f, v);
743 unsigned int qemu_get_be16(QEMUFile *f)
745 unsigned int v;
746 v = qemu_get_byte(f) << 8;
747 v |= qemu_get_byte(f);
748 return v;
751 unsigned int qemu_get_be32(QEMUFile *f)
753 unsigned int v;
754 v = qemu_get_byte(f) << 24;
755 v |= qemu_get_byte(f) << 16;
756 v |= qemu_get_byte(f) << 8;
757 v |= qemu_get_byte(f);
758 return v;
761 uint64_t qemu_get_be64(QEMUFile *f)
763 uint64_t v;
764 v = (uint64_t)qemu_get_be32(f) << 32;
765 v |= qemu_get_be32(f);
766 return v;
770 /* timer */
772 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
774 uint64_t expire_time;
776 expire_time = qemu_timer_expire_time_ns(ts);
777 qemu_put_be64(f, expire_time);
780 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
782 uint64_t expire_time;
784 expire_time = qemu_get_be64(f);
785 if (expire_time != -1) {
786 qemu_mod_timer_ns(ts, expire_time);
787 } else {
788 qemu_del_timer(ts);
793 /* bool */
795 static int get_bool(QEMUFile *f, void *pv, size_t size)
797 bool *v = pv;
798 *v = qemu_get_byte(f);
799 return 0;
802 static void put_bool(QEMUFile *f, void *pv, size_t size)
804 bool *v = pv;
805 qemu_put_byte(f, *v);
808 const VMStateInfo vmstate_info_bool = {
809 .name = "bool",
810 .get = get_bool,
811 .put = put_bool,
814 /* 8 bit int */
816 static int get_int8(QEMUFile *f, void *pv, size_t size)
818 int8_t *v = pv;
819 qemu_get_s8s(f, v);
820 return 0;
823 static void put_int8(QEMUFile *f, void *pv, size_t size)
825 int8_t *v = pv;
826 qemu_put_s8s(f, v);
829 const VMStateInfo vmstate_info_int8 = {
830 .name = "int8",
831 .get = get_int8,
832 .put = put_int8,
835 /* 16 bit int */
837 static int get_int16(QEMUFile *f, void *pv, size_t size)
839 int16_t *v = pv;
840 qemu_get_sbe16s(f, v);
841 return 0;
844 static void put_int16(QEMUFile *f, void *pv, size_t size)
846 int16_t *v = pv;
847 qemu_put_sbe16s(f, v);
850 const VMStateInfo vmstate_info_int16 = {
851 .name = "int16",
852 .get = get_int16,
853 .put = put_int16,
856 /* 32 bit int */
858 static int get_int32(QEMUFile *f, void *pv, size_t size)
860 int32_t *v = pv;
861 qemu_get_sbe32s(f, v);
862 return 0;
865 static void put_int32(QEMUFile *f, void *pv, size_t size)
867 int32_t *v = pv;
868 qemu_put_sbe32s(f, v);
871 const VMStateInfo vmstate_info_int32 = {
872 .name = "int32",
873 .get = get_int32,
874 .put = put_int32,
877 /* 32 bit int. See that the received value is the same than the one
878 in the field */
880 static int get_int32_equal(QEMUFile *f, void *pv, size_t size)
882 int32_t *v = pv;
883 int32_t v2;
884 qemu_get_sbe32s(f, &v2);
886 if (*v == v2)
887 return 0;
888 return -EINVAL;
891 const VMStateInfo vmstate_info_int32_equal = {
892 .name = "int32 equal",
893 .get = get_int32_equal,
894 .put = put_int32,
897 /* 32 bit int. See that the received value is the less or the same
898 than the one in the field */
900 static int get_int32_le(QEMUFile *f, void *pv, size_t size)
902 int32_t *old = pv;
903 int32_t new;
904 qemu_get_sbe32s(f, &new);
906 if (*old <= new)
907 return 0;
908 return -EINVAL;
911 const VMStateInfo vmstate_info_int32_le = {
912 .name = "int32 equal",
913 .get = get_int32_le,
914 .put = put_int32,
917 /* 64 bit int */
919 static int get_int64(QEMUFile *f, void *pv, size_t size)
921 int64_t *v = pv;
922 qemu_get_sbe64s(f, v);
923 return 0;
926 static void put_int64(QEMUFile *f, void *pv, size_t size)
928 int64_t *v = pv;
929 qemu_put_sbe64s(f, v);
932 const VMStateInfo vmstate_info_int64 = {
933 .name = "int64",
934 .get = get_int64,
935 .put = put_int64,
938 /* 8 bit unsigned int */
940 static int get_uint8(QEMUFile *f, void *pv, size_t size)
942 uint8_t *v = pv;
943 qemu_get_8s(f, v);
944 return 0;
947 static void put_uint8(QEMUFile *f, void *pv, size_t size)
949 uint8_t *v = pv;
950 qemu_put_8s(f, v);
953 const VMStateInfo vmstate_info_uint8 = {
954 .name = "uint8",
955 .get = get_uint8,
956 .put = put_uint8,
959 /* 16 bit unsigned int */
961 static int get_uint16(QEMUFile *f, void *pv, size_t size)
963 uint16_t *v = pv;
964 qemu_get_be16s(f, v);
965 return 0;
968 static void put_uint16(QEMUFile *f, void *pv, size_t size)
970 uint16_t *v = pv;
971 qemu_put_be16s(f, v);
974 const VMStateInfo vmstate_info_uint16 = {
975 .name = "uint16",
976 .get = get_uint16,
977 .put = put_uint16,
980 /* 32 bit unsigned int */
982 static int get_uint32(QEMUFile *f, void *pv, size_t size)
984 uint32_t *v = pv;
985 qemu_get_be32s(f, v);
986 return 0;
989 static void put_uint32(QEMUFile *f, void *pv, size_t size)
991 uint32_t *v = pv;
992 qemu_put_be32s(f, v);
995 const VMStateInfo vmstate_info_uint32 = {
996 .name = "uint32",
997 .get = get_uint32,
998 .put = put_uint32,
1001 /* 32 bit uint. See that the received value is the same than the one
1002 in the field */
1004 static int get_uint32_equal(QEMUFile *f, void *pv, size_t size)
1006 uint32_t *v = pv;
1007 uint32_t v2;
1008 qemu_get_be32s(f, &v2);
1010 if (*v == v2) {
1011 return 0;
1013 return -EINVAL;
1016 const VMStateInfo vmstate_info_uint32_equal = {
1017 .name = "uint32 equal",
1018 .get = get_uint32_equal,
1019 .put = put_uint32,
1022 /* 64 bit unsigned int */
1024 static int get_uint64(QEMUFile *f, void *pv, size_t size)
1026 uint64_t *v = pv;
1027 qemu_get_be64s(f, v);
1028 return 0;
1031 static void put_uint64(QEMUFile *f, void *pv, size_t size)
1033 uint64_t *v = pv;
1034 qemu_put_be64s(f, v);
1037 const VMStateInfo vmstate_info_uint64 = {
1038 .name = "uint64",
1039 .get = get_uint64,
1040 .put = put_uint64,
1043 /* 8 bit int. See that the received value is the same than the one
1044 in the field */
1046 static int get_uint8_equal(QEMUFile *f, void *pv, size_t size)
1048 uint8_t *v = pv;
1049 uint8_t v2;
1050 qemu_get_8s(f, &v2);
1052 if (*v == v2)
1053 return 0;
1054 return -EINVAL;
1057 const VMStateInfo vmstate_info_uint8_equal = {
1058 .name = "uint8 equal",
1059 .get = get_uint8_equal,
1060 .put = put_uint8,
1063 /* 16 bit unsigned int int. See that the received value is the same than the one
1064 in the field */
1066 static int get_uint16_equal(QEMUFile *f, void *pv, size_t size)
1068 uint16_t *v = pv;
1069 uint16_t v2;
1070 qemu_get_be16s(f, &v2);
1072 if (*v == v2)
1073 return 0;
1074 return -EINVAL;
1077 const VMStateInfo vmstate_info_uint16_equal = {
1078 .name = "uint16 equal",
1079 .get = get_uint16_equal,
1080 .put = put_uint16,
1083 /* timers */
1085 static int get_timer(QEMUFile *f, void *pv, size_t size)
1087 QEMUTimer *v = pv;
1088 qemu_get_timer(f, v);
1089 return 0;
1092 static void put_timer(QEMUFile *f, void *pv, size_t size)
1094 QEMUTimer *v = pv;
1095 qemu_put_timer(f, v);
1098 const VMStateInfo vmstate_info_timer = {
1099 .name = "timer",
1100 .get = get_timer,
1101 .put = put_timer,
1104 /* uint8_t buffers */
1106 static int get_buffer(QEMUFile *f, void *pv, size_t size)
1108 uint8_t *v = pv;
1109 qemu_get_buffer(f, v, size);
1110 return 0;
1113 static void put_buffer(QEMUFile *f, void *pv, size_t size)
1115 uint8_t *v = pv;
1116 qemu_put_buffer(f, v, size);
1119 const VMStateInfo vmstate_info_buffer = {
1120 .name = "buffer",
1121 .get = get_buffer,
1122 .put = put_buffer,
1125 /* unused buffers: space that was used for some fields that are
1126 not useful anymore */
1128 static int get_unused_buffer(QEMUFile *f, void *pv, size_t size)
1130 uint8_t buf[1024];
1131 int block_len;
1133 while (size > 0) {
1134 block_len = MIN(sizeof(buf), size);
1135 size -= block_len;
1136 qemu_get_buffer(f, buf, block_len);
1138 return 0;
1141 static void put_unused_buffer(QEMUFile *f, void *pv, size_t size)
1143 static const uint8_t buf[1024];
1144 int block_len;
1146 while (size > 0) {
1147 block_len = MIN(sizeof(buf), size);
1148 size -= block_len;
1149 qemu_put_buffer(f, buf, block_len);
1153 const VMStateInfo vmstate_info_unused_buffer = {
1154 .name = "unused_buffer",
1155 .get = get_unused_buffer,
1156 .put = put_unused_buffer,
1159 typedef struct CompatEntry {
1160 char idstr[256];
1161 int instance_id;
1162 } CompatEntry;
1164 typedef struct SaveStateEntry {
1165 QTAILQ_ENTRY(SaveStateEntry) entry;
1166 char idstr[256];
1167 int instance_id;
1168 int alias_id;
1169 int version_id;
1170 int section_id;
1171 SaveSetParamsHandler *set_params;
1172 SaveLiveStateHandler *save_live_state;
1173 SaveStateHandler *save_state;
1174 LoadStateHandler *load_state;
1175 const VMStateDescription *vmsd;
1176 void *opaque;
1177 CompatEntry *compat;
1178 int no_migrate;
1179 } SaveStateEntry;
1182 static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers =
1183 QTAILQ_HEAD_INITIALIZER(savevm_handlers);
1184 static int global_section_id;
1186 static int calculate_new_instance_id(const char *idstr)
1188 SaveStateEntry *se;
1189 int instance_id = 0;
1191 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1192 if (strcmp(idstr, se->idstr) == 0
1193 && instance_id <= se->instance_id) {
1194 instance_id = se->instance_id + 1;
1197 return instance_id;
1200 static int calculate_compat_instance_id(const char *idstr)
1202 SaveStateEntry *se;
1203 int instance_id = 0;
1205 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1206 if (!se->compat)
1207 continue;
1209 if (strcmp(idstr, se->compat->idstr) == 0
1210 && instance_id <= se->compat->instance_id) {
1211 instance_id = se->compat->instance_id + 1;
1214 return instance_id;
1217 /* TODO: Individual devices generally have very little idea about the rest
1218 of the system, so instance_id should be removed/replaced.
1219 Meanwhile pass -1 as instance_id if you do not already have a clearly
1220 distinguishing id for all instances of your device class. */
1221 int register_savevm_live(DeviceState *dev,
1222 const char *idstr,
1223 int instance_id,
1224 int version_id,
1225 SaveSetParamsHandler *set_params,
1226 SaveLiveStateHandler *save_live_state,
1227 SaveStateHandler *save_state,
1228 LoadStateHandler *load_state,
1229 void *opaque)
1231 SaveStateEntry *se;
1233 se = g_malloc0(sizeof(SaveStateEntry));
1234 se->version_id = version_id;
1235 se->section_id = global_section_id++;
1236 se->set_params = set_params;
1237 se->save_live_state = save_live_state;
1238 se->save_state = save_state;
1239 se->load_state = load_state;
1240 se->opaque = opaque;
1241 se->vmsd = NULL;
1242 se->no_migrate = 0;
1244 if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
1245 char *id = dev->parent_bus->info->get_dev_path(dev);
1246 if (id) {
1247 pstrcpy(se->idstr, sizeof(se->idstr), id);
1248 pstrcat(se->idstr, sizeof(se->idstr), "/");
1249 g_free(id);
1251 se->compat = g_malloc0(sizeof(CompatEntry));
1252 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr);
1253 se->compat->instance_id = instance_id == -1 ?
1254 calculate_compat_instance_id(idstr) : instance_id;
1255 instance_id = -1;
1258 pstrcat(se->idstr, sizeof(se->idstr), idstr);
1260 if (instance_id == -1) {
1261 se->instance_id = calculate_new_instance_id(se->idstr);
1262 } else {
1263 se->instance_id = instance_id;
1265 assert(!se->compat || se->instance_id == 0);
1266 /* add at the end of list */
1267 QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1268 return 0;
1271 int register_savevm(DeviceState *dev,
1272 const char *idstr,
1273 int instance_id,
1274 int version_id,
1275 SaveStateHandler *save_state,
1276 LoadStateHandler *load_state,
1277 void *opaque)
1279 return register_savevm_live(dev, idstr, instance_id, version_id,
1280 NULL, NULL, save_state, load_state, opaque);
1283 void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
1285 SaveStateEntry *se, *new_se;
1286 char id[256] = "";
1288 if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
1289 char *path = dev->parent_bus->info->get_dev_path(dev);
1290 if (path) {
1291 pstrcpy(id, sizeof(id), path);
1292 pstrcat(id, sizeof(id), "/");
1293 g_free(path);
1296 pstrcat(id, sizeof(id), idstr);
1298 QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1299 if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
1300 QTAILQ_REMOVE(&savevm_handlers, se, entry);
1301 if (se->compat) {
1302 g_free(se->compat);
1304 g_free(se);
1309 int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
1310 const VMStateDescription *vmsd,
1311 void *opaque, int alias_id,
1312 int required_for_version)
1314 SaveStateEntry *se;
1316 /* If this triggers, alias support can be dropped for the vmsd. */
1317 assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id);
1319 se = g_malloc0(sizeof(SaveStateEntry));
1320 se->version_id = vmsd->version_id;
1321 se->section_id = global_section_id++;
1322 se->save_live_state = NULL;
1323 se->save_state = NULL;
1324 se->load_state = NULL;
1325 se->opaque = opaque;
1326 se->vmsd = vmsd;
1327 se->alias_id = alias_id;
1328 se->no_migrate = vmsd->unmigratable;
1330 if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
1331 char *id = dev->parent_bus->info->get_dev_path(dev);
1332 if (id) {
1333 pstrcpy(se->idstr, sizeof(se->idstr), id);
1334 pstrcat(se->idstr, sizeof(se->idstr), "/");
1335 g_free(id);
1337 se->compat = g_malloc0(sizeof(CompatEntry));
1338 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
1339 se->compat->instance_id = instance_id == -1 ?
1340 calculate_compat_instance_id(vmsd->name) : instance_id;
1341 instance_id = -1;
1344 pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);
1346 if (instance_id == -1) {
1347 se->instance_id = calculate_new_instance_id(se->idstr);
1348 } else {
1349 se->instance_id = instance_id;
1351 assert(!se->compat || se->instance_id == 0);
1352 /* add at the end of list */
1353 QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1354 return 0;
1357 int vmstate_register(DeviceState *dev, int instance_id,
1358 const VMStateDescription *vmsd, void *opaque)
1360 return vmstate_register_with_alias_id(dev, instance_id, vmsd,
1361 opaque, -1, 0);
1364 void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
1365 void *opaque)
1367 SaveStateEntry *se, *new_se;
1369 QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1370 if (se->vmsd == vmsd && se->opaque == opaque) {
1371 QTAILQ_REMOVE(&savevm_handlers, se, entry);
1372 if (se->compat) {
1373 g_free(se->compat);
1375 g_free(se);
1380 static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
1381 void *opaque);
1382 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
1383 void *opaque);
1385 int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
1386 void *opaque, int version_id)
1388 VMStateField *field = vmsd->fields;
1389 int ret;
1391 if (version_id > vmsd->version_id) {
1392 return -EINVAL;
1394 if (version_id < vmsd->minimum_version_id_old) {
1395 return -EINVAL;
1397 if (version_id < vmsd->minimum_version_id) {
1398 return vmsd->load_state_old(f, opaque, version_id);
1400 if (vmsd->pre_load) {
1401 int ret = vmsd->pre_load(opaque);
1402 if (ret)
1403 return ret;
1405 while(field->name) {
1406 if ((field->field_exists &&
1407 field->field_exists(opaque, version_id)) ||
1408 (!field->field_exists &&
1409 field->version_id <= version_id)) {
1410 void *base_addr = opaque + field->offset;
1411 int i, n_elems = 1;
1412 int size = field->size;
1414 if (field->flags & VMS_VBUFFER) {
1415 size = *(int32_t *)(opaque+field->size_offset);
1416 if (field->flags & VMS_MULTIPLY) {
1417 size *= field->size;
1420 if (field->flags & VMS_ARRAY) {
1421 n_elems = field->num;
1422 } else if (field->flags & VMS_VARRAY_INT32) {
1423 n_elems = *(int32_t *)(opaque+field->num_offset);
1424 } else if (field->flags & VMS_VARRAY_UINT32) {
1425 n_elems = *(uint32_t *)(opaque+field->num_offset);
1426 } else if (field->flags & VMS_VARRAY_UINT16) {
1427 n_elems = *(uint16_t *)(opaque+field->num_offset);
1428 } else if (field->flags & VMS_VARRAY_UINT8) {
1429 n_elems = *(uint8_t *)(opaque+field->num_offset);
1431 if (field->flags & VMS_POINTER) {
1432 base_addr = *(void **)base_addr + field->start;
1434 for (i = 0; i < n_elems; i++) {
1435 void *addr = base_addr + size * i;
1437 if (field->flags & VMS_ARRAY_OF_POINTER) {
1438 addr = *(void **)addr;
1440 if (field->flags & VMS_STRUCT) {
1441 ret = vmstate_load_state(f, field->vmsd, addr, field->vmsd->version_id);
1442 } else {
1443 ret = field->info->get(f, addr, size);
1446 if (ret < 0) {
1447 return ret;
1451 field++;
1453 ret = vmstate_subsection_load(f, vmsd, opaque);
1454 if (ret != 0) {
1455 return ret;
1457 if (vmsd->post_load) {
1458 return vmsd->post_load(opaque, version_id);
1460 return 0;
1463 void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
1464 void *opaque)
1466 VMStateField *field = vmsd->fields;
1468 if (vmsd->pre_save) {
1469 vmsd->pre_save(opaque);
1471 while(field->name) {
1472 if (!field->field_exists ||
1473 field->field_exists(opaque, vmsd->version_id)) {
1474 void *base_addr = opaque + field->offset;
1475 int i, n_elems = 1;
1476 int size = field->size;
1478 if (field->flags & VMS_VBUFFER) {
1479 size = *(int32_t *)(opaque+field->size_offset);
1480 if (field->flags & VMS_MULTIPLY) {
1481 size *= field->size;
1484 if (field->flags & VMS_ARRAY) {
1485 n_elems = field->num;
1486 } else if (field->flags & VMS_VARRAY_INT32) {
1487 n_elems = *(int32_t *)(opaque+field->num_offset);
1488 } else if (field->flags & VMS_VARRAY_UINT16) {
1489 n_elems = *(uint16_t *)(opaque+field->num_offset);
1490 } else if (field->flags & VMS_VARRAY_UINT8) {
1491 n_elems = *(uint8_t *)(opaque+field->num_offset);
1493 if (field->flags & VMS_POINTER) {
1494 base_addr = *(void **)base_addr + field->start;
1496 for (i = 0; i < n_elems; i++) {
1497 void *addr = base_addr + size * i;
1499 if (field->flags & VMS_ARRAY_OF_POINTER) {
1500 addr = *(void **)addr;
1502 if (field->flags & VMS_STRUCT) {
1503 vmstate_save_state(f, field->vmsd, addr);
1504 } else {
1505 field->info->put(f, addr, size);
1509 field++;
1511 vmstate_subsection_save(f, vmsd, opaque);
1514 static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id)
1516 if (!se->vmsd) { /* Old style */
1517 return se->load_state(f, se->opaque, version_id);
1519 return vmstate_load_state(f, se->vmsd, se->opaque, version_id);
1522 static void vmstate_save(QEMUFile *f, SaveStateEntry *se)
1524 if (!se->vmsd) { /* Old style */
1525 se->save_state(f, se->opaque);
1526 return;
1528 vmstate_save_state(f,se->vmsd, se->opaque);
1531 #define QEMU_VM_FILE_MAGIC 0x5145564d
1532 #define QEMU_VM_FILE_VERSION_COMPAT 0x00000002
1533 #define QEMU_VM_FILE_VERSION 0x00000003
1535 #define QEMU_VM_EOF 0x00
1536 #define QEMU_VM_SECTION_START 0x01
1537 #define QEMU_VM_SECTION_PART 0x02
1538 #define QEMU_VM_SECTION_END 0x03
1539 #define QEMU_VM_SECTION_FULL 0x04
1540 #define QEMU_VM_SUBSECTION 0x05
1542 bool qemu_savevm_state_blocked(Monitor *mon)
1544 SaveStateEntry *se;
1546 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1547 if (se->no_migrate) {
1548 monitor_printf(mon, "state blocked by non-migratable device '%s'\n",
1549 se->idstr);
1550 return true;
1553 return false;
1556 int qemu_savevm_state_begin(Monitor *mon, QEMUFile *f, int blk_enable,
1557 int shared)
1559 SaveStateEntry *se;
1560 int ret;
1562 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1563 if(se->set_params == NULL) {
1564 continue;
1566 se->set_params(blk_enable, shared, se->opaque);
1569 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1570 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1572 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1573 int len;
1575 if (se->save_live_state == NULL)
1576 continue;
1578 /* Section type */
1579 qemu_put_byte(f, QEMU_VM_SECTION_START);
1580 qemu_put_be32(f, se->section_id);
1582 /* ID string */
1583 len = strlen(se->idstr);
1584 qemu_put_byte(f, len);
1585 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1587 qemu_put_be32(f, se->instance_id);
1588 qemu_put_be32(f, se->version_id);
1590 ret = se->save_live_state(mon, f, QEMU_VM_SECTION_START, se->opaque);
1591 if (ret < 0) {
1592 qemu_savevm_state_cancel(mon, f);
1593 return ret;
1596 ret = qemu_file_get_error(f);
1597 if (ret != 0) {
1598 qemu_savevm_state_cancel(mon, f);
1601 return ret;
1606 * this function has three return values:
1607 * negative: there was one error, and we have -errno.
1608 * 0 : We haven't finished, caller have to go again
1609 * 1 : We have finished, we can go to complete phase
1611 int qemu_savevm_state_iterate(Monitor *mon, QEMUFile *f)
1613 SaveStateEntry *se;
1614 int ret = 1;
1616 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1617 if (se->save_live_state == NULL)
1618 continue;
1620 /* Section type */
1621 qemu_put_byte(f, QEMU_VM_SECTION_PART);
1622 qemu_put_be32(f, se->section_id);
1624 ret = se->save_live_state(mon, f, QEMU_VM_SECTION_PART, se->opaque);
1625 if (ret <= 0) {
1626 /* Do not proceed to the next vmstate before this one reported
1627 completion of the current stage. This serializes the migration
1628 and reduces the probability that a faster changing state is
1629 synchronized over and over again. */
1630 break;
1633 if (ret != 0) {
1634 return ret;
1636 ret = qemu_file_get_error(f);
1637 if (ret != 0) {
1638 qemu_savevm_state_cancel(mon, f);
1640 return ret;
1643 int qemu_savevm_state_complete(Monitor *mon, QEMUFile *f)
1645 SaveStateEntry *se;
1646 int ret;
1648 cpu_synchronize_all_states();
1650 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1651 if (se->save_live_state == NULL)
1652 continue;
1654 /* Section type */
1655 qemu_put_byte(f, QEMU_VM_SECTION_END);
1656 qemu_put_be32(f, se->section_id);
1658 ret = se->save_live_state(mon, f, QEMU_VM_SECTION_END, se->opaque);
1659 if (ret < 0) {
1660 return ret;
1664 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1665 int len;
1667 if (se->save_state == NULL && se->vmsd == NULL)
1668 continue;
1670 /* Section type */
1671 qemu_put_byte(f, QEMU_VM_SECTION_FULL);
1672 qemu_put_be32(f, se->section_id);
1674 /* ID string */
1675 len = strlen(se->idstr);
1676 qemu_put_byte(f, len);
1677 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1679 qemu_put_be32(f, se->instance_id);
1680 qemu_put_be32(f, se->version_id);
1682 vmstate_save(f, se);
1685 qemu_put_byte(f, QEMU_VM_EOF);
1687 return qemu_file_get_error(f);
1690 void qemu_savevm_state_cancel(Monitor *mon, QEMUFile *f)
1692 SaveStateEntry *se;
1694 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1695 if (se->save_live_state) {
1696 se->save_live_state(mon, f, -1, se->opaque);
1701 static int qemu_savevm_state(Monitor *mon, QEMUFile *f)
1703 int ret;
1705 if (qemu_savevm_state_blocked(mon)) {
1706 ret = -EINVAL;
1707 goto out;
1710 ret = qemu_savevm_state_begin(mon, f, 0, 0);
1711 if (ret < 0)
1712 goto out;
1714 do {
1715 ret = qemu_savevm_state_iterate(mon, f);
1716 if (ret < 0)
1717 goto out;
1718 } while (ret == 0);
1720 ret = qemu_savevm_state_complete(mon, f);
1722 out:
1723 if (ret == 0) {
1724 ret = qemu_file_get_error(f);
1727 return ret;
1730 static SaveStateEntry *find_se(const char *idstr, int instance_id)
1732 SaveStateEntry *se;
1734 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1735 if (!strcmp(se->idstr, idstr) &&
1736 (instance_id == se->instance_id ||
1737 instance_id == se->alias_id))
1738 return se;
1739 /* Migrating from an older version? */
1740 if (strstr(se->idstr, idstr) && se->compat) {
1741 if (!strcmp(se->compat->idstr, idstr) &&
1742 (instance_id == se->compat->instance_id ||
1743 instance_id == se->alias_id))
1744 return se;
1747 return NULL;
1750 static const VMStateDescription *vmstate_get_subsection(const VMStateSubsection *sub, char *idstr)
1752 while(sub && sub->needed) {
1753 if (strcmp(idstr, sub->vmsd->name) == 0) {
1754 return sub->vmsd;
1756 sub++;
1758 return NULL;
1761 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
1762 void *opaque)
1764 while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
1765 char idstr[256];
1766 int ret;
1767 uint8_t version_id, len, size;
1768 const VMStateDescription *sub_vmsd;
1770 len = qemu_peek_byte(f, 1);
1771 if (len < strlen(vmsd->name) + 1) {
1772 /* subsection name has be be "section_name/a" */
1773 return 0;
1775 size = qemu_peek_buffer(f, (uint8_t *)idstr, len, 2);
1776 if (size != len) {
1777 return 0;
1779 idstr[size] = 0;
1781 if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
1782 /* it don't have a valid subsection name */
1783 return 0;
1785 sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
1786 if (sub_vmsd == NULL) {
1787 return -ENOENT;
1789 qemu_file_skip(f, 1); /* subsection */
1790 qemu_file_skip(f, 1); /* len */
1791 qemu_file_skip(f, len); /* idstr */
1792 version_id = qemu_get_be32(f);
1794 ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
1795 if (ret) {
1796 return ret;
1799 return 0;
1802 static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
1803 void *opaque)
1805 const VMStateSubsection *sub = vmsd->subsections;
1807 while (sub && sub->needed) {
1808 if (sub->needed(opaque)) {
1809 const VMStateDescription *vmsd = sub->vmsd;
1810 uint8_t len;
1812 qemu_put_byte(f, QEMU_VM_SUBSECTION);
1813 len = strlen(vmsd->name);
1814 qemu_put_byte(f, len);
1815 qemu_put_buffer(f, (uint8_t *)vmsd->name, len);
1816 qemu_put_be32(f, vmsd->version_id);
1817 vmstate_save_state(f, vmsd, opaque);
1819 sub++;
1823 typedef struct LoadStateEntry {
1824 QLIST_ENTRY(LoadStateEntry) entry;
1825 SaveStateEntry *se;
1826 int section_id;
1827 int version_id;
1828 } LoadStateEntry;
1830 int qemu_loadvm_state(QEMUFile *f)
1832 QLIST_HEAD(, LoadStateEntry) loadvm_handlers =
1833 QLIST_HEAD_INITIALIZER(loadvm_handlers);
1834 LoadStateEntry *le, *new_le;
1835 uint8_t section_type;
1836 unsigned int v;
1837 int ret;
1839 if (qemu_savevm_state_blocked(default_mon)) {
1840 return -EINVAL;
1843 v = qemu_get_be32(f);
1844 if (v != QEMU_VM_FILE_MAGIC)
1845 return -EINVAL;
1847 v = qemu_get_be32(f);
1848 if (v == QEMU_VM_FILE_VERSION_COMPAT) {
1849 fprintf(stderr, "SaveVM v2 format is obsolete and don't work anymore\n");
1850 return -ENOTSUP;
1852 if (v != QEMU_VM_FILE_VERSION)
1853 return -ENOTSUP;
1855 while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
1856 uint32_t instance_id, version_id, section_id;
1857 SaveStateEntry *se;
1858 char idstr[257];
1859 int len;
1861 switch (section_type) {
1862 case QEMU_VM_SECTION_START:
1863 case QEMU_VM_SECTION_FULL:
1864 /* Read section start */
1865 section_id = qemu_get_be32(f);
1866 len = qemu_get_byte(f);
1867 qemu_get_buffer(f, (uint8_t *)idstr, len);
1868 idstr[len] = 0;
1869 instance_id = qemu_get_be32(f);
1870 version_id = qemu_get_be32(f);
1872 /* Find savevm section */
1873 se = find_se(idstr, instance_id);
1874 if (se == NULL) {
1875 fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
1876 ret = -EINVAL;
1877 goto out;
1880 /* Validate version */
1881 if (version_id > se->version_id) {
1882 fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
1883 version_id, idstr, se->version_id);
1884 ret = -EINVAL;
1885 goto out;
1888 /* Add entry */
1889 le = g_malloc0(sizeof(*le));
1891 le->se = se;
1892 le->section_id = section_id;
1893 le->version_id = version_id;
1894 QLIST_INSERT_HEAD(&loadvm_handlers, le, entry);
1896 ret = vmstate_load(f, le->se, le->version_id);
1897 if (ret < 0) {
1898 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
1899 instance_id, idstr);
1900 goto out;
1902 break;
1903 case QEMU_VM_SECTION_PART:
1904 case QEMU_VM_SECTION_END:
1905 section_id = qemu_get_be32(f);
1907 QLIST_FOREACH(le, &loadvm_handlers, entry) {
1908 if (le->section_id == section_id) {
1909 break;
1912 if (le == NULL) {
1913 fprintf(stderr, "Unknown savevm section %d\n", section_id);
1914 ret = -EINVAL;
1915 goto out;
1918 ret = vmstate_load(f, le->se, le->version_id);
1919 if (ret < 0) {
1920 fprintf(stderr, "qemu: warning: error while loading state section id %d\n",
1921 section_id);
1922 goto out;
1924 break;
1925 default:
1926 fprintf(stderr, "Unknown savevm section type %d\n", section_type);
1927 ret = -EINVAL;
1928 goto out;
1932 cpu_synchronize_all_post_init();
1934 ret = 0;
1936 out:
1937 QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
1938 QLIST_REMOVE(le, entry);
1939 g_free(le);
1942 if (ret == 0) {
1943 ret = qemu_file_get_error(f);
1946 return ret;
1949 static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
1950 const char *name)
1952 QEMUSnapshotInfo *sn_tab, *sn;
1953 int nb_sns, i, ret;
1955 ret = -ENOENT;
1956 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1957 if (nb_sns < 0)
1958 return ret;
1959 for(i = 0; i < nb_sns; i++) {
1960 sn = &sn_tab[i];
1961 if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
1962 *sn_info = *sn;
1963 ret = 0;
1964 break;
1967 g_free(sn_tab);
1968 return ret;
1972 * Deletes snapshots of a given name in all opened images.
1974 static int del_existing_snapshots(Monitor *mon, const char *name)
1976 BlockDriverState *bs;
1977 QEMUSnapshotInfo sn1, *snapshot = &sn1;
1978 int ret;
1980 bs = NULL;
1981 while ((bs = bdrv_next(bs))) {
1982 if (bdrv_can_snapshot(bs) &&
1983 bdrv_snapshot_find(bs, snapshot, name) >= 0)
1985 ret = bdrv_snapshot_delete(bs, name);
1986 if (ret < 0) {
1987 monitor_printf(mon,
1988 "Error while deleting snapshot on '%s'\n",
1989 bdrv_get_device_name(bs));
1990 return -1;
1995 return 0;
1998 void do_savevm(Monitor *mon, const QDict *qdict)
2000 BlockDriverState *bs, *bs1;
2001 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
2002 int ret;
2003 QEMUFile *f;
2004 int saved_vm_running;
2005 uint32_t vm_state_size;
2006 #ifdef _WIN32
2007 struct _timeb tb;
2008 struct tm *ptm;
2009 #else
2010 struct timeval tv;
2011 struct tm tm;
2012 #endif
2013 const char *name = qdict_get_try_str(qdict, "name");
2015 /* Verify if there is a device that doesn't support snapshots and is writable */
2016 bs = NULL;
2017 while ((bs = bdrv_next(bs))) {
2019 if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2020 continue;
2023 if (!bdrv_can_snapshot(bs)) {
2024 monitor_printf(mon, "Device '%s' is writable but does not support snapshots.\n",
2025 bdrv_get_device_name(bs));
2026 return;
2030 bs = bdrv_snapshots();
2031 if (!bs) {
2032 monitor_printf(mon, "No block device can accept snapshots\n");
2033 return;
2036 saved_vm_running = runstate_is_running();
2037 vm_stop(RUN_STATE_SAVE_VM);
2039 memset(sn, 0, sizeof(*sn));
2041 /* fill auxiliary fields */
2042 #ifdef _WIN32
2043 _ftime(&tb);
2044 sn->date_sec = tb.time;
2045 sn->date_nsec = tb.millitm * 1000000;
2046 #else
2047 gettimeofday(&tv, NULL);
2048 sn->date_sec = tv.tv_sec;
2049 sn->date_nsec = tv.tv_usec * 1000;
2050 #endif
2051 sn->vm_clock_nsec = qemu_get_clock_ns(vm_clock);
2053 if (name) {
2054 ret = bdrv_snapshot_find(bs, old_sn, name);
2055 if (ret >= 0) {
2056 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
2057 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
2058 } else {
2059 pstrcpy(sn->name, sizeof(sn->name), name);
2061 } else {
2062 #ifdef _WIN32
2063 ptm = localtime(&tb.time);
2064 strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", ptm);
2065 #else
2066 /* cast below needed for OpenBSD where tv_sec is still 'long' */
2067 localtime_r((const time_t *)&tv.tv_sec, &tm);
2068 strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
2069 #endif
2072 /* Delete old snapshots of the same name */
2073 if (name && del_existing_snapshots(mon, name) < 0) {
2074 goto the_end;
2077 /* save the VM state */
2078 f = qemu_fopen_bdrv(bs, 1);
2079 if (!f) {
2080 monitor_printf(mon, "Could not open VM state file\n");
2081 goto the_end;
2083 ret = qemu_savevm_state(mon, f);
2084 vm_state_size = qemu_ftell(f);
2085 qemu_fclose(f);
2086 if (ret < 0) {
2087 monitor_printf(mon, "Error %d while writing VM\n", ret);
2088 goto the_end;
2091 /* create the snapshots */
2093 bs1 = NULL;
2094 while ((bs1 = bdrv_next(bs1))) {
2095 if (bdrv_can_snapshot(bs1)) {
2096 /* Write VM state size only to the image that contains the state */
2097 sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
2098 ret = bdrv_snapshot_create(bs1, sn);
2099 if (ret < 0) {
2100 monitor_printf(mon, "Error while creating snapshot on '%s'\n",
2101 bdrv_get_device_name(bs1));
2106 the_end:
2107 if (saved_vm_running)
2108 vm_start();
2111 int load_vmstate(const char *name)
2113 BlockDriverState *bs, *bs_vm_state;
2114 QEMUSnapshotInfo sn;
2115 QEMUFile *f;
2116 int ret;
2118 bs_vm_state = bdrv_snapshots();
2119 if (!bs_vm_state) {
2120 error_report("No block device supports snapshots");
2121 return -ENOTSUP;
2124 /* Don't even try to load empty VM states */
2125 ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
2126 if (ret < 0) {
2127 return ret;
2128 } else if (sn.vm_state_size == 0) {
2129 error_report("This is a disk-only snapshot. Revert to it offline "
2130 "using qemu-img.");
2131 return -EINVAL;
2134 /* Verify if there is any device that doesn't support snapshots and is
2135 writable and check if the requested snapshot is available too. */
2136 bs = NULL;
2137 while ((bs = bdrv_next(bs))) {
2139 if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2140 continue;
2143 if (!bdrv_can_snapshot(bs)) {
2144 error_report("Device '%s' is writable but does not support snapshots.",
2145 bdrv_get_device_name(bs));
2146 return -ENOTSUP;
2149 ret = bdrv_snapshot_find(bs, &sn, name);
2150 if (ret < 0) {
2151 error_report("Device '%s' does not have the requested snapshot '%s'",
2152 bdrv_get_device_name(bs), name);
2153 return ret;
2157 /* Flush all IO requests so they don't interfere with the new state. */
2158 bdrv_drain_all();
2160 bs = NULL;
2161 while ((bs = bdrv_next(bs))) {
2162 if (bdrv_can_snapshot(bs)) {
2163 ret = bdrv_snapshot_goto(bs, name);
2164 if (ret < 0) {
2165 error_report("Error %d while activating snapshot '%s' on '%s'",
2166 ret, name, bdrv_get_device_name(bs));
2167 return ret;
2172 /* restore the VM state */
2173 f = qemu_fopen_bdrv(bs_vm_state, 0);
2174 if (!f) {
2175 error_report("Could not open VM state file");
2176 return -EINVAL;
2179 qemu_system_reset(VMRESET_SILENT);
2180 ret = qemu_loadvm_state(f);
2182 qemu_fclose(f);
2183 if (ret < 0) {
2184 error_report("Error %d while loading VM state", ret);
2185 return ret;
2188 return 0;
2191 void do_delvm(Monitor *mon, const QDict *qdict)
2193 BlockDriverState *bs, *bs1;
2194 int ret;
2195 const char *name = qdict_get_str(qdict, "name");
2197 bs = bdrv_snapshots();
2198 if (!bs) {
2199 monitor_printf(mon, "No block device supports snapshots\n");
2200 return;
2203 bs1 = NULL;
2204 while ((bs1 = bdrv_next(bs1))) {
2205 if (bdrv_can_snapshot(bs1)) {
2206 ret = bdrv_snapshot_delete(bs1, name);
2207 if (ret < 0) {
2208 if (ret == -ENOTSUP)
2209 monitor_printf(mon,
2210 "Snapshots not supported on device '%s'\n",
2211 bdrv_get_device_name(bs1));
2212 else
2213 monitor_printf(mon, "Error %d while deleting snapshot on "
2214 "'%s'\n", ret, bdrv_get_device_name(bs1));
2220 void do_info_snapshots(Monitor *mon)
2222 BlockDriverState *bs, *bs1;
2223 QEMUSnapshotInfo *sn_tab, *sn, s, *sn_info = &s;
2224 int nb_sns, i, ret, available;
2225 int total;
2226 int *available_snapshots;
2227 char buf[256];
2229 bs = bdrv_snapshots();
2230 if (!bs) {
2231 monitor_printf(mon, "No available block device supports snapshots\n");
2232 return;
2235 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2236 if (nb_sns < 0) {
2237 monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
2238 return;
2241 if (nb_sns == 0) {
2242 monitor_printf(mon, "There is no snapshot available.\n");
2243 return;
2246 available_snapshots = g_malloc0(sizeof(int) * nb_sns);
2247 total = 0;
2248 for (i = 0; i < nb_sns; i++) {
2249 sn = &sn_tab[i];
2250 available = 1;
2251 bs1 = NULL;
2253 while ((bs1 = bdrv_next(bs1))) {
2254 if (bdrv_can_snapshot(bs1) && bs1 != bs) {
2255 ret = bdrv_snapshot_find(bs1, sn_info, sn->id_str);
2256 if (ret < 0) {
2257 available = 0;
2258 break;
2263 if (available) {
2264 available_snapshots[total] = i;
2265 total++;
2269 if (total > 0) {
2270 monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
2271 for (i = 0; i < total; i++) {
2272 sn = &sn_tab[available_snapshots[i]];
2273 monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
2275 } else {
2276 monitor_printf(mon, "There is no suitable snapshot available\n");
2279 g_free(sn_tab);
2280 g_free(available_snapshots);