Merge branch 'arm-devs.for-upstream' of git://git.linaro.org/people/pmaydell/qemu-arm
[qemu-kvm.git] / savevm.c
blob43d3d1bbebeebb7b8de2f0b3055177804303a48a
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"
86 #include "memory.h"
87 #include "qmp-commands.h"
88 #include "trace.h"
89 #include "bitops.h"
91 #define SELF_ANNOUNCE_ROUNDS 5
93 #ifndef ETH_P_RARP
94 #define ETH_P_RARP 0x8035
95 #endif
96 #define ARP_HTYPE_ETH 0x0001
97 #define ARP_PTYPE_IP 0x0800
98 #define ARP_OP_REQUEST_REV 0x3
100 static int announce_self_create(uint8_t *buf,
101 uint8_t *mac_addr)
103 /* Ethernet header. */
104 memset(buf, 0xff, 6); /* destination MAC addr */
105 memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
106 *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */
108 /* RARP header. */
109 *(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */
110 *(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */
111 *(buf + 18) = 6; /* hardware addr length (ethernet) */
112 *(buf + 19) = 4; /* protocol addr length (IPv4) */
113 *(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */
114 memcpy(buf + 22, mac_addr, 6); /* source hw addr */
115 memset(buf + 28, 0x00, 4); /* source protocol addr */
116 memcpy(buf + 32, mac_addr, 6); /* target hw addr */
117 memset(buf + 38, 0x00, 4); /* target protocol addr */
119 /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
120 memset(buf + 42, 0x00, 18);
122 return 60; /* len (FCS will be added by hardware) */
125 static void qemu_announce_self_iter(NICState *nic, void *opaque)
127 uint8_t buf[60];
128 int len;
130 len = announce_self_create(buf, nic->conf->macaddr.a);
132 qemu_send_packet_raw(&nic->nc, buf, len);
136 static void qemu_announce_self_once(void *opaque)
138 static int count = SELF_ANNOUNCE_ROUNDS;
139 QEMUTimer *timer = *(QEMUTimer **)opaque;
141 qemu_foreach_nic(qemu_announce_self_iter, NULL);
143 if (--count) {
144 /* delay 50ms, 150ms, 250ms, ... */
145 qemu_mod_timer(timer, qemu_get_clock_ms(rt_clock) +
146 50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100);
147 } else {
148 qemu_del_timer(timer);
149 qemu_free_timer(timer);
153 void qemu_announce_self(void)
155 static QEMUTimer *timer;
156 timer = qemu_new_timer_ms(rt_clock, qemu_announce_self_once, &timer);
157 qemu_announce_self_once(&timer);
160 /***********************************************************/
161 /* savevm/loadvm support */
163 #define IO_BUF_SIZE 32768
165 struct QEMUFile {
166 QEMUFilePutBufferFunc *put_buffer;
167 QEMUFileGetBufferFunc *get_buffer;
168 QEMUFileCloseFunc *close;
169 QEMUFileRateLimit *rate_limit;
170 QEMUFileSetRateLimit *set_rate_limit;
171 QEMUFileGetRateLimit *get_rate_limit;
172 void *opaque;
173 int is_write;
175 int64_t buf_offset; /* start of buffer when writing, end of buffer
176 when reading */
177 int buf_index;
178 int buf_size; /* 0 when writing */
179 uint8_t buf[IO_BUF_SIZE];
181 int last_error;
184 typedef struct QEMUFileStdio
186 FILE *stdio_file;
187 QEMUFile *file;
188 } QEMUFileStdio;
190 typedef struct QEMUFileSocket
192 int fd;
193 QEMUFile *file;
194 } QEMUFileSocket;
196 static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
198 QEMUFileSocket *s = opaque;
199 ssize_t len;
201 do {
202 len = qemu_recv(s->fd, buf, size, 0);
203 } while (len == -1 && socket_error() == EINTR);
205 if (len == -1)
206 len = -socket_error();
208 return len;
211 static int socket_close(void *opaque)
213 QEMUFileSocket *s = opaque;
214 g_free(s);
215 return 0;
218 static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
220 QEMUFileStdio *s = opaque;
221 return fwrite(buf, 1, size, s->stdio_file);
224 static int stdio_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
226 QEMUFileStdio *s = opaque;
227 FILE *fp = s->stdio_file;
228 int bytes;
230 do {
231 clearerr(fp);
232 bytes = fread(buf, 1, size, fp);
233 } while ((bytes == 0) && ferror(fp) && (errno == EINTR));
234 return bytes;
237 static int stdio_pclose(void *opaque)
239 QEMUFileStdio *s = opaque;
240 int ret;
241 ret = pclose(s->stdio_file);
242 if (ret == -1) {
243 ret = -errno;
245 g_free(s);
246 return ret;
249 static int stdio_fclose(void *opaque)
251 QEMUFileStdio *s = opaque;
252 int ret = 0;
253 if (fclose(s->stdio_file) == EOF) {
254 ret = -errno;
256 g_free(s);
257 return ret;
260 QEMUFile *qemu_popen(FILE *stdio_file, const char *mode)
262 QEMUFileStdio *s;
264 if (stdio_file == NULL || mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
265 fprintf(stderr, "qemu_popen: Argument validity check failed\n");
266 return NULL;
269 s = g_malloc0(sizeof(QEMUFileStdio));
271 s->stdio_file = stdio_file;
273 if(mode[0] == 'r') {
274 s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_pclose,
275 NULL, NULL, NULL);
276 } else {
277 s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_pclose,
278 NULL, NULL, NULL);
280 return s->file;
283 QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
285 FILE *popen_file;
287 popen_file = popen(command, mode);
288 if(popen_file == NULL) {
289 return NULL;
292 return qemu_popen(popen_file, mode);
295 int qemu_stdio_fd(QEMUFile *f)
297 QEMUFileStdio *p;
298 int fd;
300 p = (QEMUFileStdio *)f->opaque;
301 fd = fileno(p->stdio_file);
303 return fd;
306 QEMUFile *qemu_fdopen(int fd, const char *mode)
308 QEMUFileStdio *s;
310 if (mode == NULL ||
311 (mode[0] != 'r' && mode[0] != 'w') ||
312 mode[1] != 'b' || mode[2] != 0) {
313 fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
314 return NULL;
317 s = g_malloc0(sizeof(QEMUFileStdio));
318 s->stdio_file = fdopen(fd, mode);
319 if (!s->stdio_file)
320 goto fail;
322 if(mode[0] == 'r') {
323 s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_fclose,
324 NULL, NULL, NULL);
325 } else {
326 s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_fclose,
327 NULL, NULL, NULL);
329 return s->file;
331 fail:
332 g_free(s);
333 return NULL;
336 QEMUFile *qemu_fopen_socket(int fd)
338 QEMUFileSocket *s = g_malloc0(sizeof(QEMUFileSocket));
340 s->fd = fd;
341 s->file = qemu_fopen_ops(s, NULL, socket_get_buffer, socket_close,
342 NULL, NULL, NULL);
343 return s->file;
346 static int file_put_buffer(void *opaque, const uint8_t *buf,
347 int64_t pos, int size)
349 QEMUFileStdio *s = opaque;
350 fseek(s->stdio_file, pos, SEEK_SET);
351 return fwrite(buf, 1, size, s->stdio_file);
354 static int file_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
356 QEMUFileStdio *s = opaque;
357 fseek(s->stdio_file, pos, SEEK_SET);
358 return fread(buf, 1, size, s->stdio_file);
361 QEMUFile *qemu_fopen(const char *filename, const char *mode)
363 QEMUFileStdio *s;
365 if (mode == NULL ||
366 (mode[0] != 'r' && mode[0] != 'w') ||
367 mode[1] != 'b' || mode[2] != 0) {
368 fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
369 return NULL;
372 s = g_malloc0(sizeof(QEMUFileStdio));
374 s->stdio_file = fopen(filename, mode);
375 if (!s->stdio_file)
376 goto fail;
378 if(mode[0] == 'w') {
379 s->file = qemu_fopen_ops(s, file_put_buffer, NULL, stdio_fclose,
380 NULL, NULL, NULL);
381 } else {
382 s->file = qemu_fopen_ops(s, NULL, file_get_buffer, stdio_fclose,
383 NULL, NULL, NULL);
385 return s->file;
386 fail:
387 g_free(s);
388 return NULL;
391 static int block_put_buffer(void *opaque, const uint8_t *buf,
392 int64_t pos, int size)
394 bdrv_save_vmstate(opaque, buf, pos, size);
395 return size;
398 static int block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
400 return bdrv_load_vmstate(opaque, buf, pos, size);
403 static int bdrv_fclose(void *opaque)
405 return bdrv_flush(opaque);
408 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
410 if (is_writable)
411 return qemu_fopen_ops(bs, block_put_buffer, NULL, bdrv_fclose,
412 NULL, NULL, NULL);
413 return qemu_fopen_ops(bs, NULL, block_get_buffer, bdrv_fclose, NULL, NULL, NULL);
416 QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
417 QEMUFileGetBufferFunc *get_buffer,
418 QEMUFileCloseFunc *close,
419 QEMUFileRateLimit *rate_limit,
420 QEMUFileSetRateLimit *set_rate_limit,
421 QEMUFileGetRateLimit *get_rate_limit)
423 QEMUFile *f;
425 f = g_malloc0(sizeof(QEMUFile));
427 f->opaque = opaque;
428 f->put_buffer = put_buffer;
429 f->get_buffer = get_buffer;
430 f->close = close;
431 f->rate_limit = rate_limit;
432 f->set_rate_limit = set_rate_limit;
433 f->get_rate_limit = get_rate_limit;
434 f->is_write = 0;
436 return f;
439 int qemu_file_get_error(QEMUFile *f)
441 return f->last_error;
444 static void qemu_file_set_error(QEMUFile *f, int ret)
446 f->last_error = ret;
449 /** Flushes QEMUFile buffer
452 static int qemu_fflush(QEMUFile *f)
454 int ret = 0;
456 if (!f->put_buffer)
457 return 0;
459 if (f->is_write && f->buf_index > 0) {
460 ret = f->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
461 if (ret >= 0) {
462 f->buf_offset += f->buf_index;
464 f->buf_index = 0;
466 return ret;
469 static void qemu_fill_buffer(QEMUFile *f)
471 int len;
472 int pending;
474 if (!f->get_buffer)
475 return;
477 if (f->is_write)
478 abort();
480 pending = f->buf_size - f->buf_index;
481 if (pending > 0) {
482 memmove(f->buf, f->buf + f->buf_index, pending);
484 f->buf_index = 0;
485 f->buf_size = pending;
487 len = f->get_buffer(f->opaque, f->buf + pending, f->buf_offset,
488 IO_BUF_SIZE - pending);
489 if (len > 0) {
490 f->buf_size += len;
491 f->buf_offset += len;
492 } else if (len == 0) {
493 qemu_file_set_error(f, -EIO);
494 } else if (len != -EAGAIN)
495 qemu_file_set_error(f, len);
498 /** Closes the file
500 * Returns negative error value if any error happened on previous operations or
501 * while closing the file. Returns 0 or positive number on success.
503 * The meaning of return value on success depends on the specific backend
504 * being used.
506 int qemu_fclose(QEMUFile *f)
508 int ret;
509 ret = qemu_fflush(f);
511 if (f->close) {
512 int ret2 = f->close(f->opaque);
513 if (ret >= 0) {
514 ret = ret2;
517 /* If any error was spotted before closing, we should report it
518 * instead of the close() return value.
520 if (f->last_error) {
521 ret = f->last_error;
523 g_free(f);
524 return ret;
527 int qemu_file_put_notify(QEMUFile *f)
529 return f->put_buffer(f->opaque, NULL, 0, 0);
532 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
534 int l;
536 if (f->last_error) {
537 return;
540 if (f->is_write == 0 && f->buf_index > 0) {
541 fprintf(stderr,
542 "Attempted to write to buffer while read buffer is not empty\n");
543 abort();
546 while (size > 0) {
547 l = IO_BUF_SIZE - f->buf_index;
548 if (l > size)
549 l = size;
550 memcpy(f->buf + f->buf_index, buf, l);
551 f->is_write = 1;
552 f->buf_index += l;
553 buf += l;
554 size -= l;
555 if (f->buf_index >= IO_BUF_SIZE) {
556 int ret = qemu_fflush(f);
557 if (ret < 0) {
558 qemu_file_set_error(f, ret);
559 break;
565 void qemu_put_byte(QEMUFile *f, int v)
567 if (f->last_error) {
568 return;
571 if (f->is_write == 0 && f->buf_index > 0) {
572 fprintf(stderr,
573 "Attempted to write to buffer while read buffer is not empty\n");
574 abort();
577 f->buf[f->buf_index++] = v;
578 f->is_write = 1;
579 if (f->buf_index >= IO_BUF_SIZE) {
580 int ret = qemu_fflush(f);
581 if (ret < 0) {
582 qemu_file_set_error(f, ret);
587 static void qemu_file_skip(QEMUFile *f, int size)
589 if (f->buf_index + size <= f->buf_size) {
590 f->buf_index += size;
594 static int qemu_peek_buffer(QEMUFile *f, uint8_t *buf, int size, size_t offset)
596 int pending;
597 int index;
599 if (f->is_write) {
600 abort();
603 index = f->buf_index + offset;
604 pending = f->buf_size - index;
605 if (pending < size) {
606 qemu_fill_buffer(f);
607 index = f->buf_index + offset;
608 pending = f->buf_size - index;
611 if (pending <= 0) {
612 return 0;
614 if (size > pending) {
615 size = pending;
618 memcpy(buf, f->buf + index, size);
619 return size;
622 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
624 int pending = size;
625 int done = 0;
627 while (pending > 0) {
628 int res;
630 res = qemu_peek_buffer(f, buf, pending, 0);
631 if (res == 0) {
632 return done;
634 qemu_file_skip(f, res);
635 buf += res;
636 pending -= res;
637 done += res;
639 return done;
642 static int qemu_peek_byte(QEMUFile *f, int offset)
644 int index = f->buf_index + offset;
646 if (f->is_write) {
647 abort();
650 if (index >= f->buf_size) {
651 qemu_fill_buffer(f);
652 index = f->buf_index + offset;
653 if (index >= f->buf_size) {
654 return 0;
657 return f->buf[index];
660 int qemu_get_byte(QEMUFile *f)
662 int result;
664 result = qemu_peek_byte(f, 0);
665 qemu_file_skip(f, 1);
666 return result;
669 static int64_t qemu_ftell(QEMUFile *f)
671 return f->buf_offset - f->buf_size + f->buf_index;
674 int qemu_file_rate_limit(QEMUFile *f)
676 if (f->rate_limit)
677 return f->rate_limit(f->opaque);
679 return 0;
682 int64_t qemu_file_get_rate_limit(QEMUFile *f)
684 if (f->get_rate_limit)
685 return f->get_rate_limit(f->opaque);
687 return 0;
690 int64_t qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate)
692 /* any failed or completed migration keeps its state to allow probing of
693 * migration data, but has no associated file anymore */
694 if (f && f->set_rate_limit)
695 return f->set_rate_limit(f->opaque, new_rate);
697 return 0;
700 void qemu_put_be16(QEMUFile *f, unsigned int v)
702 qemu_put_byte(f, v >> 8);
703 qemu_put_byte(f, v);
706 void qemu_put_be32(QEMUFile *f, unsigned int v)
708 qemu_put_byte(f, v >> 24);
709 qemu_put_byte(f, v >> 16);
710 qemu_put_byte(f, v >> 8);
711 qemu_put_byte(f, v);
714 void qemu_put_be64(QEMUFile *f, uint64_t v)
716 qemu_put_be32(f, v >> 32);
717 qemu_put_be32(f, v);
720 unsigned int qemu_get_be16(QEMUFile *f)
722 unsigned int v;
723 v = qemu_get_byte(f) << 8;
724 v |= qemu_get_byte(f);
725 return v;
728 unsigned int qemu_get_be32(QEMUFile *f)
730 unsigned int v;
731 v = qemu_get_byte(f) << 24;
732 v |= qemu_get_byte(f) << 16;
733 v |= qemu_get_byte(f) << 8;
734 v |= qemu_get_byte(f);
735 return v;
738 uint64_t qemu_get_be64(QEMUFile *f)
740 uint64_t v;
741 v = (uint64_t)qemu_get_be32(f) << 32;
742 v |= qemu_get_be32(f);
743 return v;
747 /* timer */
749 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
751 uint64_t expire_time;
753 expire_time = qemu_timer_expire_time_ns(ts);
754 qemu_put_be64(f, expire_time);
757 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
759 uint64_t expire_time;
761 expire_time = qemu_get_be64(f);
762 if (expire_time != -1) {
763 qemu_mod_timer_ns(ts, expire_time);
764 } else {
765 qemu_del_timer(ts);
770 /* bool */
772 static int get_bool(QEMUFile *f, void *pv, size_t size)
774 bool *v = pv;
775 *v = qemu_get_byte(f);
776 return 0;
779 static void put_bool(QEMUFile *f, void *pv, size_t size)
781 bool *v = pv;
782 qemu_put_byte(f, *v);
785 const VMStateInfo vmstate_info_bool = {
786 .name = "bool",
787 .get = get_bool,
788 .put = put_bool,
791 /* 8 bit int */
793 static int get_int8(QEMUFile *f, void *pv, size_t size)
795 int8_t *v = pv;
796 qemu_get_s8s(f, v);
797 return 0;
800 static void put_int8(QEMUFile *f, void *pv, size_t size)
802 int8_t *v = pv;
803 qemu_put_s8s(f, v);
806 const VMStateInfo vmstate_info_int8 = {
807 .name = "int8",
808 .get = get_int8,
809 .put = put_int8,
812 /* 16 bit int */
814 static int get_int16(QEMUFile *f, void *pv, size_t size)
816 int16_t *v = pv;
817 qemu_get_sbe16s(f, v);
818 return 0;
821 static void put_int16(QEMUFile *f, void *pv, size_t size)
823 int16_t *v = pv;
824 qemu_put_sbe16s(f, v);
827 const VMStateInfo vmstate_info_int16 = {
828 .name = "int16",
829 .get = get_int16,
830 .put = put_int16,
833 /* 32 bit int */
835 static int get_int32(QEMUFile *f, void *pv, size_t size)
837 int32_t *v = pv;
838 qemu_get_sbe32s(f, v);
839 return 0;
842 static void put_int32(QEMUFile *f, void *pv, size_t size)
844 int32_t *v = pv;
845 qemu_put_sbe32s(f, v);
848 const VMStateInfo vmstate_info_int32 = {
849 .name = "int32",
850 .get = get_int32,
851 .put = put_int32,
854 /* 32 bit int. See that the received value is the same than the one
855 in the field */
857 static int get_int32_equal(QEMUFile *f, void *pv, size_t size)
859 int32_t *v = pv;
860 int32_t v2;
861 qemu_get_sbe32s(f, &v2);
863 if (*v == v2)
864 return 0;
865 return -EINVAL;
868 const VMStateInfo vmstate_info_int32_equal = {
869 .name = "int32 equal",
870 .get = get_int32_equal,
871 .put = put_int32,
874 /* 32 bit int. See that the received value is the less or the same
875 than the one in the field */
877 static int get_int32_le(QEMUFile *f, void *pv, size_t size)
879 int32_t *old = pv;
880 int32_t new;
881 qemu_get_sbe32s(f, &new);
883 if (*old <= new)
884 return 0;
885 return -EINVAL;
888 const VMStateInfo vmstate_info_int32_le = {
889 .name = "int32 equal",
890 .get = get_int32_le,
891 .put = put_int32,
894 /* 64 bit int */
896 static int get_int64(QEMUFile *f, void *pv, size_t size)
898 int64_t *v = pv;
899 qemu_get_sbe64s(f, v);
900 return 0;
903 static void put_int64(QEMUFile *f, void *pv, size_t size)
905 int64_t *v = pv;
906 qemu_put_sbe64s(f, v);
909 const VMStateInfo vmstate_info_int64 = {
910 .name = "int64",
911 .get = get_int64,
912 .put = put_int64,
915 /* 8 bit unsigned int */
917 static int get_uint8(QEMUFile *f, void *pv, size_t size)
919 uint8_t *v = pv;
920 qemu_get_8s(f, v);
921 return 0;
924 static void put_uint8(QEMUFile *f, void *pv, size_t size)
926 uint8_t *v = pv;
927 qemu_put_8s(f, v);
930 const VMStateInfo vmstate_info_uint8 = {
931 .name = "uint8",
932 .get = get_uint8,
933 .put = put_uint8,
936 /* 16 bit unsigned int */
938 static int get_uint16(QEMUFile *f, void *pv, size_t size)
940 uint16_t *v = pv;
941 qemu_get_be16s(f, v);
942 return 0;
945 static void put_uint16(QEMUFile *f, void *pv, size_t size)
947 uint16_t *v = pv;
948 qemu_put_be16s(f, v);
951 const VMStateInfo vmstate_info_uint16 = {
952 .name = "uint16",
953 .get = get_uint16,
954 .put = put_uint16,
957 /* 32 bit unsigned int */
959 static int get_uint32(QEMUFile *f, void *pv, size_t size)
961 uint32_t *v = pv;
962 qemu_get_be32s(f, v);
963 return 0;
966 static void put_uint32(QEMUFile *f, void *pv, size_t size)
968 uint32_t *v = pv;
969 qemu_put_be32s(f, v);
972 const VMStateInfo vmstate_info_uint32 = {
973 .name = "uint32",
974 .get = get_uint32,
975 .put = put_uint32,
978 /* 32 bit uint. See that the received value is the same than the one
979 in the field */
981 static int get_uint32_equal(QEMUFile *f, void *pv, size_t size)
983 uint32_t *v = pv;
984 uint32_t v2;
985 qemu_get_be32s(f, &v2);
987 if (*v == v2) {
988 return 0;
990 return -EINVAL;
993 const VMStateInfo vmstate_info_uint32_equal = {
994 .name = "uint32 equal",
995 .get = get_uint32_equal,
996 .put = put_uint32,
999 /* 64 bit unsigned int */
1001 static int get_uint64(QEMUFile *f, void *pv, size_t size)
1003 uint64_t *v = pv;
1004 qemu_get_be64s(f, v);
1005 return 0;
1008 static void put_uint64(QEMUFile *f, void *pv, size_t size)
1010 uint64_t *v = pv;
1011 qemu_put_be64s(f, v);
1014 const VMStateInfo vmstate_info_uint64 = {
1015 .name = "uint64",
1016 .get = get_uint64,
1017 .put = put_uint64,
1020 /* 8 bit int. See that the received value is the same than the one
1021 in the field */
1023 static int get_uint8_equal(QEMUFile *f, void *pv, size_t size)
1025 uint8_t *v = pv;
1026 uint8_t v2;
1027 qemu_get_8s(f, &v2);
1029 if (*v == v2)
1030 return 0;
1031 return -EINVAL;
1034 const VMStateInfo vmstate_info_uint8_equal = {
1035 .name = "uint8 equal",
1036 .get = get_uint8_equal,
1037 .put = put_uint8,
1040 /* 16 bit unsigned int int. See that the received value is the same than the one
1041 in the field */
1043 static int get_uint16_equal(QEMUFile *f, void *pv, size_t size)
1045 uint16_t *v = pv;
1046 uint16_t v2;
1047 qemu_get_be16s(f, &v2);
1049 if (*v == v2)
1050 return 0;
1051 return -EINVAL;
1054 const VMStateInfo vmstate_info_uint16_equal = {
1055 .name = "uint16 equal",
1056 .get = get_uint16_equal,
1057 .put = put_uint16,
1060 /* timers */
1062 static int get_timer(QEMUFile *f, void *pv, size_t size)
1064 QEMUTimer *v = pv;
1065 qemu_get_timer(f, v);
1066 return 0;
1069 static void put_timer(QEMUFile *f, void *pv, size_t size)
1071 QEMUTimer *v = pv;
1072 qemu_put_timer(f, v);
1075 const VMStateInfo vmstate_info_timer = {
1076 .name = "timer",
1077 .get = get_timer,
1078 .put = put_timer,
1081 /* uint8_t buffers */
1083 static int get_buffer(QEMUFile *f, void *pv, size_t size)
1085 uint8_t *v = pv;
1086 qemu_get_buffer(f, v, size);
1087 return 0;
1090 static void put_buffer(QEMUFile *f, void *pv, size_t size)
1092 uint8_t *v = pv;
1093 qemu_put_buffer(f, v, size);
1096 const VMStateInfo vmstate_info_buffer = {
1097 .name = "buffer",
1098 .get = get_buffer,
1099 .put = put_buffer,
1102 /* unused buffers: space that was used for some fields that are
1103 not useful anymore */
1105 static int get_unused_buffer(QEMUFile *f, void *pv, size_t size)
1107 uint8_t buf[1024];
1108 int block_len;
1110 while (size > 0) {
1111 block_len = MIN(sizeof(buf), size);
1112 size -= block_len;
1113 qemu_get_buffer(f, buf, block_len);
1115 return 0;
1118 static void put_unused_buffer(QEMUFile *f, void *pv, size_t size)
1120 static const uint8_t buf[1024];
1121 int block_len;
1123 while (size > 0) {
1124 block_len = MIN(sizeof(buf), size);
1125 size -= block_len;
1126 qemu_put_buffer(f, buf, block_len);
1130 const VMStateInfo vmstate_info_unused_buffer = {
1131 .name = "unused_buffer",
1132 .get = get_unused_buffer,
1133 .put = put_unused_buffer,
1136 /* bitmaps (as defined by bitmap.h). Note that size here is the size
1137 * of the bitmap in bits. The on-the-wire format of a bitmap is 64
1138 * bit words with the bits in big endian order. The in-memory format
1139 * is an array of 'unsigned long', which may be either 32 or 64 bits.
1141 /* This is the number of 64 bit words sent over the wire */
1142 #define BITS_TO_U64S(nr) DIV_ROUND_UP(nr, 64)
1143 static int get_bitmap(QEMUFile *f, void *pv, size_t size)
1145 unsigned long *bmp = pv;
1146 int i, idx = 0;
1147 for (i = 0; i < BITS_TO_U64S(size); i++) {
1148 uint64_t w = qemu_get_be64(f);
1149 bmp[idx++] = w;
1150 if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
1151 bmp[idx++] = w >> 32;
1154 return 0;
1157 static void put_bitmap(QEMUFile *f, void *pv, size_t size)
1159 unsigned long *bmp = pv;
1160 int i, idx = 0;
1161 for (i = 0; i < BITS_TO_U64S(size); i++) {
1162 uint64_t w = bmp[idx++];
1163 if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
1164 w |= ((uint64_t)bmp[idx++]) << 32;
1166 qemu_put_be64(f, w);
1170 const VMStateInfo vmstate_info_bitmap = {
1171 .name = "bitmap",
1172 .get = get_bitmap,
1173 .put = put_bitmap,
1176 typedef struct CompatEntry {
1177 char idstr[256];
1178 int instance_id;
1179 } CompatEntry;
1181 typedef struct SaveStateEntry {
1182 QTAILQ_ENTRY(SaveStateEntry) entry;
1183 char idstr[256];
1184 int instance_id;
1185 int alias_id;
1186 int version_id;
1187 int section_id;
1188 SaveVMHandlers *ops;
1189 const VMStateDescription *vmsd;
1190 void *opaque;
1191 CompatEntry *compat;
1192 int no_migrate;
1193 int is_ram;
1194 } SaveStateEntry;
1197 static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers =
1198 QTAILQ_HEAD_INITIALIZER(savevm_handlers);
1199 static int global_section_id;
1201 static int calculate_new_instance_id(const char *idstr)
1203 SaveStateEntry *se;
1204 int instance_id = 0;
1206 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1207 if (strcmp(idstr, se->idstr) == 0
1208 && instance_id <= se->instance_id) {
1209 instance_id = se->instance_id + 1;
1212 return instance_id;
1215 static int calculate_compat_instance_id(const char *idstr)
1217 SaveStateEntry *se;
1218 int instance_id = 0;
1220 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1221 if (!se->compat)
1222 continue;
1224 if (strcmp(idstr, se->compat->idstr) == 0
1225 && instance_id <= se->compat->instance_id) {
1226 instance_id = se->compat->instance_id + 1;
1229 return instance_id;
1232 /* TODO: Individual devices generally have very little idea about the rest
1233 of the system, so instance_id should be removed/replaced.
1234 Meanwhile pass -1 as instance_id if you do not already have a clearly
1235 distinguishing id for all instances of your device class. */
1236 int register_savevm_live(DeviceState *dev,
1237 const char *idstr,
1238 int instance_id,
1239 int version_id,
1240 SaveVMHandlers *ops,
1241 void *opaque)
1243 SaveStateEntry *se;
1245 se = g_malloc0(sizeof(SaveStateEntry));
1246 se->version_id = version_id;
1247 se->section_id = global_section_id++;
1248 se->ops = ops;
1249 se->opaque = opaque;
1250 se->vmsd = NULL;
1251 se->no_migrate = 0;
1252 /* if this is a live_savem then set is_ram */
1253 if (ops->save_live_setup != NULL) {
1254 se->is_ram = 1;
1257 if (dev) {
1258 char *id = qdev_get_dev_path(dev);
1259 if (id) {
1260 pstrcpy(se->idstr, sizeof(se->idstr), id);
1261 pstrcat(se->idstr, sizeof(se->idstr), "/");
1262 g_free(id);
1264 se->compat = g_malloc0(sizeof(CompatEntry));
1265 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr);
1266 se->compat->instance_id = instance_id == -1 ?
1267 calculate_compat_instance_id(idstr) : instance_id;
1268 instance_id = -1;
1271 pstrcat(se->idstr, sizeof(se->idstr), idstr);
1273 if (instance_id == -1) {
1274 se->instance_id = calculate_new_instance_id(se->idstr);
1275 } else {
1276 se->instance_id = instance_id;
1278 assert(!se->compat || se->instance_id == 0);
1279 /* add at the end of list */
1280 QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1281 return 0;
1284 int register_savevm(DeviceState *dev,
1285 const char *idstr,
1286 int instance_id,
1287 int version_id,
1288 SaveStateHandler *save_state,
1289 LoadStateHandler *load_state,
1290 void *opaque)
1292 SaveVMHandlers *ops = g_malloc0(sizeof(SaveVMHandlers));
1293 ops->save_state = save_state;
1294 ops->load_state = load_state;
1295 return register_savevm_live(dev, idstr, instance_id, version_id,
1296 ops, opaque);
1299 void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
1301 SaveStateEntry *se, *new_se;
1302 char id[256] = "";
1304 if (dev) {
1305 char *path = qdev_get_dev_path(dev);
1306 if (path) {
1307 pstrcpy(id, sizeof(id), path);
1308 pstrcat(id, sizeof(id), "/");
1309 g_free(path);
1312 pstrcat(id, sizeof(id), idstr);
1314 QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1315 if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
1316 QTAILQ_REMOVE(&savevm_handlers, se, entry);
1317 if (se->compat) {
1318 g_free(se->compat);
1320 g_free(se->ops);
1321 g_free(se);
1326 int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
1327 const VMStateDescription *vmsd,
1328 void *opaque, int alias_id,
1329 int required_for_version)
1331 SaveStateEntry *se;
1333 /* If this triggers, alias support can be dropped for the vmsd. */
1334 assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id);
1336 se = g_malloc0(sizeof(SaveStateEntry));
1337 se->version_id = vmsd->version_id;
1338 se->section_id = global_section_id++;
1339 se->opaque = opaque;
1340 se->vmsd = vmsd;
1341 se->alias_id = alias_id;
1342 se->no_migrate = vmsd->unmigratable;
1344 if (dev) {
1345 char *id = qdev_get_dev_path(dev);
1346 if (id) {
1347 pstrcpy(se->idstr, sizeof(se->idstr), id);
1348 pstrcat(se->idstr, sizeof(se->idstr), "/");
1349 g_free(id);
1351 se->compat = g_malloc0(sizeof(CompatEntry));
1352 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
1353 se->compat->instance_id = instance_id == -1 ?
1354 calculate_compat_instance_id(vmsd->name) : instance_id;
1355 instance_id = -1;
1358 pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);
1360 if (instance_id == -1) {
1361 se->instance_id = calculate_new_instance_id(se->idstr);
1362 } else {
1363 se->instance_id = instance_id;
1365 assert(!se->compat || se->instance_id == 0);
1366 /* add at the end of list */
1367 QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1368 return 0;
1371 int vmstate_register(DeviceState *dev, int instance_id,
1372 const VMStateDescription *vmsd, void *opaque)
1374 return vmstate_register_with_alias_id(dev, instance_id, vmsd,
1375 opaque, -1, 0);
1378 void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
1379 void *opaque)
1381 SaveStateEntry *se, *new_se;
1383 QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1384 if (se->vmsd == vmsd && se->opaque == opaque) {
1385 QTAILQ_REMOVE(&savevm_handlers, se, entry);
1386 if (se->compat) {
1387 g_free(se->compat);
1389 g_free(se);
1394 static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
1395 void *opaque);
1396 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
1397 void *opaque);
1399 int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
1400 void *opaque, int version_id)
1402 VMStateField *field = vmsd->fields;
1403 int ret;
1405 if (version_id > vmsd->version_id) {
1406 return -EINVAL;
1408 if (version_id < vmsd->minimum_version_id_old) {
1409 return -EINVAL;
1411 if (version_id < vmsd->minimum_version_id) {
1412 return vmsd->load_state_old(f, opaque, version_id);
1414 if (vmsd->pre_load) {
1415 int ret = vmsd->pre_load(opaque);
1416 if (ret)
1417 return ret;
1419 while(field->name) {
1420 if ((field->field_exists &&
1421 field->field_exists(opaque, version_id)) ||
1422 (!field->field_exists &&
1423 field->version_id <= version_id)) {
1424 void *base_addr = opaque + field->offset;
1425 int i, n_elems = 1;
1426 int size = field->size;
1428 if (field->flags & VMS_VBUFFER) {
1429 size = *(int32_t *)(opaque+field->size_offset);
1430 if (field->flags & VMS_MULTIPLY) {
1431 size *= field->size;
1434 if (field->flags & VMS_ARRAY) {
1435 n_elems = field->num;
1436 } else if (field->flags & VMS_VARRAY_INT32) {
1437 n_elems = *(int32_t *)(opaque+field->num_offset);
1438 } else if (field->flags & VMS_VARRAY_UINT32) {
1439 n_elems = *(uint32_t *)(opaque+field->num_offset);
1440 } else if (field->flags & VMS_VARRAY_UINT16) {
1441 n_elems = *(uint16_t *)(opaque+field->num_offset);
1442 } else if (field->flags & VMS_VARRAY_UINT8) {
1443 n_elems = *(uint8_t *)(opaque+field->num_offset);
1445 if (field->flags & VMS_POINTER) {
1446 base_addr = *(void **)base_addr + field->start;
1448 for (i = 0; i < n_elems; i++) {
1449 void *addr = base_addr + size * i;
1451 if (field->flags & VMS_ARRAY_OF_POINTER) {
1452 addr = *(void **)addr;
1454 if (field->flags & VMS_STRUCT) {
1455 ret = vmstate_load_state(f, field->vmsd, addr, field->vmsd->version_id);
1456 } else {
1457 ret = field->info->get(f, addr, size);
1460 if (ret < 0) {
1461 return ret;
1465 field++;
1467 ret = vmstate_subsection_load(f, vmsd, opaque);
1468 if (ret != 0) {
1469 return ret;
1471 if (vmsd->post_load) {
1472 return vmsd->post_load(opaque, version_id);
1474 return 0;
1477 void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
1478 void *opaque)
1480 VMStateField *field = vmsd->fields;
1482 if (vmsd->pre_save) {
1483 vmsd->pre_save(opaque);
1485 while(field->name) {
1486 if (!field->field_exists ||
1487 field->field_exists(opaque, vmsd->version_id)) {
1488 void *base_addr = opaque + field->offset;
1489 int i, n_elems = 1;
1490 int size = field->size;
1492 if (field->flags & VMS_VBUFFER) {
1493 size = *(int32_t *)(opaque+field->size_offset);
1494 if (field->flags & VMS_MULTIPLY) {
1495 size *= field->size;
1498 if (field->flags & VMS_ARRAY) {
1499 n_elems = field->num;
1500 } else if (field->flags & VMS_VARRAY_INT32) {
1501 n_elems = *(int32_t *)(opaque+field->num_offset);
1502 } else if (field->flags & VMS_VARRAY_UINT32) {
1503 n_elems = *(uint32_t *)(opaque+field->num_offset);
1504 } else if (field->flags & VMS_VARRAY_UINT16) {
1505 n_elems = *(uint16_t *)(opaque+field->num_offset);
1506 } else if (field->flags & VMS_VARRAY_UINT8) {
1507 n_elems = *(uint8_t *)(opaque+field->num_offset);
1509 if (field->flags & VMS_POINTER) {
1510 base_addr = *(void **)base_addr + field->start;
1512 for (i = 0; i < n_elems; i++) {
1513 void *addr = base_addr + size * i;
1515 if (field->flags & VMS_ARRAY_OF_POINTER) {
1516 addr = *(void **)addr;
1518 if (field->flags & VMS_STRUCT) {
1519 vmstate_save_state(f, field->vmsd, addr);
1520 } else {
1521 field->info->put(f, addr, size);
1525 field++;
1527 vmstate_subsection_save(f, vmsd, opaque);
1530 static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id)
1532 if (!se->vmsd) { /* Old style */
1533 return se->ops->load_state(f, se->opaque, version_id);
1535 return vmstate_load_state(f, se->vmsd, se->opaque, version_id);
1538 static void vmstate_save(QEMUFile *f, SaveStateEntry *se)
1540 if (!se->vmsd) { /* Old style */
1541 se->ops->save_state(f, se->opaque);
1542 return;
1544 vmstate_save_state(f,se->vmsd, se->opaque);
1547 #define QEMU_VM_FILE_MAGIC 0x5145564d
1548 #define QEMU_VM_FILE_VERSION_COMPAT 0x00000002
1549 #define QEMU_VM_FILE_VERSION 0x00000003
1551 #define QEMU_VM_EOF 0x00
1552 #define QEMU_VM_SECTION_START 0x01
1553 #define QEMU_VM_SECTION_PART 0x02
1554 #define QEMU_VM_SECTION_END 0x03
1555 #define QEMU_VM_SECTION_FULL 0x04
1556 #define QEMU_VM_SUBSECTION 0x05
1558 bool qemu_savevm_state_blocked(Error **errp)
1560 SaveStateEntry *se;
1562 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1563 if (se->no_migrate) {
1564 error_set(errp, QERR_MIGRATION_NOT_SUPPORTED, se->idstr);
1565 return true;
1568 return false;
1571 int qemu_savevm_state_begin(QEMUFile *f,
1572 const MigrationParams *params)
1574 SaveStateEntry *se;
1575 int ret;
1577 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1578 if (!se->ops || !se->ops->set_params) {
1579 continue;
1581 se->ops->set_params(params, se->opaque);
1584 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1585 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1587 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1588 int len;
1590 if (!se->ops || !se->ops->save_live_setup) {
1591 continue;
1593 if (se->ops && se->ops->is_active) {
1594 if (!se->ops->is_active(se->opaque)) {
1595 continue;
1598 /* Section type */
1599 qemu_put_byte(f, QEMU_VM_SECTION_START);
1600 qemu_put_be32(f, se->section_id);
1602 /* ID string */
1603 len = strlen(se->idstr);
1604 qemu_put_byte(f, len);
1605 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1607 qemu_put_be32(f, se->instance_id);
1608 qemu_put_be32(f, se->version_id);
1610 ret = se->ops->save_live_setup(f, se->opaque);
1611 if (ret < 0) {
1612 qemu_savevm_state_cancel(f);
1613 return ret;
1616 ret = qemu_file_get_error(f);
1617 if (ret != 0) {
1618 qemu_savevm_state_cancel(f);
1621 return ret;
1626 * this function has three return values:
1627 * negative: there was one error, and we have -errno.
1628 * 0 : We haven't finished, caller have to go again
1629 * 1 : We have finished, we can go to complete phase
1631 int qemu_savevm_state_iterate(QEMUFile *f)
1633 SaveStateEntry *se;
1634 int ret = 1;
1636 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1637 if (!se->ops || !se->ops->save_live_iterate) {
1638 continue;
1640 if (se->ops && se->ops->is_active) {
1641 if (!se->ops->is_active(se->opaque)) {
1642 continue;
1645 if (qemu_file_rate_limit(f)) {
1646 return 0;
1648 trace_savevm_section_start();
1649 /* Section type */
1650 qemu_put_byte(f, QEMU_VM_SECTION_PART);
1651 qemu_put_be32(f, se->section_id);
1653 ret = se->ops->save_live_iterate(f, se->opaque);
1654 trace_savevm_section_end(se->section_id);
1656 if (ret <= 0) {
1657 /* Do not proceed to the next vmstate before this one reported
1658 completion of the current stage. This serializes the migration
1659 and reduces the probability that a faster changing state is
1660 synchronized over and over again. */
1661 break;
1664 if (ret != 0) {
1665 return ret;
1667 ret = qemu_file_get_error(f);
1668 if (ret != 0) {
1669 qemu_savevm_state_cancel(f);
1671 return ret;
1674 int qemu_savevm_state_complete(QEMUFile *f)
1676 SaveStateEntry *se;
1677 int ret;
1679 cpu_synchronize_all_states();
1681 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1682 if (!se->ops || !se->ops->save_live_complete) {
1683 continue;
1685 if (se->ops && se->ops->is_active) {
1686 if (!se->ops->is_active(se->opaque)) {
1687 continue;
1690 trace_savevm_section_start();
1691 /* Section type */
1692 qemu_put_byte(f, QEMU_VM_SECTION_END);
1693 qemu_put_be32(f, se->section_id);
1695 ret = se->ops->save_live_complete(f, se->opaque);
1696 trace_savevm_section_end(se->section_id);
1697 if (ret < 0) {
1698 return ret;
1702 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1703 int len;
1705 if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1706 continue;
1708 trace_savevm_section_start();
1709 /* Section type */
1710 qemu_put_byte(f, QEMU_VM_SECTION_FULL);
1711 qemu_put_be32(f, se->section_id);
1713 /* ID string */
1714 len = strlen(se->idstr);
1715 qemu_put_byte(f, len);
1716 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1718 qemu_put_be32(f, se->instance_id);
1719 qemu_put_be32(f, se->version_id);
1721 vmstate_save(f, se);
1722 trace_savevm_section_end(se->section_id);
1725 qemu_put_byte(f, QEMU_VM_EOF);
1727 return qemu_file_get_error(f);
1730 void qemu_savevm_state_cancel(QEMUFile *f)
1732 SaveStateEntry *se;
1734 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1735 if (se->ops && se->ops->cancel) {
1736 se->ops->cancel(se->opaque);
1741 static int qemu_savevm_state(QEMUFile *f)
1743 int ret;
1744 MigrationParams params = {
1745 .blk = 0,
1746 .shared = 0
1749 if (qemu_savevm_state_blocked(NULL)) {
1750 ret = -EINVAL;
1751 goto out;
1754 ret = qemu_savevm_state_begin(f, &params);
1755 if (ret < 0)
1756 goto out;
1758 do {
1759 ret = qemu_savevm_state_iterate(f);
1760 if (ret < 0)
1761 goto out;
1762 } while (ret == 0);
1764 ret = qemu_savevm_state_complete(f);
1766 out:
1767 if (ret == 0) {
1768 ret = qemu_file_get_error(f);
1771 return ret;
1774 static int qemu_save_device_state(QEMUFile *f)
1776 SaveStateEntry *se;
1778 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1779 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1781 cpu_synchronize_all_states();
1783 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1784 int len;
1786 if (se->is_ram) {
1787 continue;
1789 if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1790 continue;
1793 /* Section type */
1794 qemu_put_byte(f, QEMU_VM_SECTION_FULL);
1795 qemu_put_be32(f, se->section_id);
1797 /* ID string */
1798 len = strlen(se->idstr);
1799 qemu_put_byte(f, len);
1800 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1802 qemu_put_be32(f, se->instance_id);
1803 qemu_put_be32(f, se->version_id);
1805 vmstate_save(f, se);
1808 qemu_put_byte(f, QEMU_VM_EOF);
1810 return qemu_file_get_error(f);
1813 static SaveStateEntry *find_se(const char *idstr, int instance_id)
1815 SaveStateEntry *se;
1817 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1818 if (!strcmp(se->idstr, idstr) &&
1819 (instance_id == se->instance_id ||
1820 instance_id == se->alias_id))
1821 return se;
1822 /* Migrating from an older version? */
1823 if (strstr(se->idstr, idstr) && se->compat) {
1824 if (!strcmp(se->compat->idstr, idstr) &&
1825 (instance_id == se->compat->instance_id ||
1826 instance_id == se->alias_id))
1827 return se;
1830 return NULL;
1833 static const VMStateDescription *vmstate_get_subsection(const VMStateSubsection *sub, char *idstr)
1835 while(sub && sub->needed) {
1836 if (strcmp(idstr, sub->vmsd->name) == 0) {
1837 return sub->vmsd;
1839 sub++;
1841 return NULL;
1844 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
1845 void *opaque)
1847 while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
1848 char idstr[256];
1849 int ret;
1850 uint8_t version_id, len, size;
1851 const VMStateDescription *sub_vmsd;
1853 len = qemu_peek_byte(f, 1);
1854 if (len < strlen(vmsd->name) + 1) {
1855 /* subsection name has be be "section_name/a" */
1856 return 0;
1858 size = qemu_peek_buffer(f, (uint8_t *)idstr, len, 2);
1859 if (size != len) {
1860 return 0;
1862 idstr[size] = 0;
1864 if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
1865 /* it don't have a valid subsection name */
1866 return 0;
1868 sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
1869 if (sub_vmsd == NULL) {
1870 return -ENOENT;
1872 qemu_file_skip(f, 1); /* subsection */
1873 qemu_file_skip(f, 1); /* len */
1874 qemu_file_skip(f, len); /* idstr */
1875 version_id = qemu_get_be32(f);
1877 ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
1878 if (ret) {
1879 return ret;
1882 return 0;
1885 static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
1886 void *opaque)
1888 const VMStateSubsection *sub = vmsd->subsections;
1890 while (sub && sub->needed) {
1891 if (sub->needed(opaque)) {
1892 const VMStateDescription *vmsd = sub->vmsd;
1893 uint8_t len;
1895 qemu_put_byte(f, QEMU_VM_SUBSECTION);
1896 len = strlen(vmsd->name);
1897 qemu_put_byte(f, len);
1898 qemu_put_buffer(f, (uint8_t *)vmsd->name, len);
1899 qemu_put_be32(f, vmsd->version_id);
1900 vmstate_save_state(f, vmsd, opaque);
1902 sub++;
1906 typedef struct LoadStateEntry {
1907 QLIST_ENTRY(LoadStateEntry) entry;
1908 SaveStateEntry *se;
1909 int section_id;
1910 int version_id;
1911 } LoadStateEntry;
1913 int qemu_loadvm_state(QEMUFile *f)
1915 QLIST_HEAD(, LoadStateEntry) loadvm_handlers =
1916 QLIST_HEAD_INITIALIZER(loadvm_handlers);
1917 LoadStateEntry *le, *new_le;
1918 uint8_t section_type;
1919 unsigned int v;
1920 int ret;
1922 if (qemu_savevm_state_blocked(NULL)) {
1923 return -EINVAL;
1926 v = qemu_get_be32(f);
1927 if (v != QEMU_VM_FILE_MAGIC)
1928 return -EINVAL;
1930 v = qemu_get_be32(f);
1931 if (v == QEMU_VM_FILE_VERSION_COMPAT) {
1932 fprintf(stderr, "SaveVM v2 format is obsolete and don't work anymore\n");
1933 return -ENOTSUP;
1935 if (v != QEMU_VM_FILE_VERSION)
1936 return -ENOTSUP;
1938 while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
1939 uint32_t instance_id, version_id, section_id;
1940 SaveStateEntry *se;
1941 char idstr[257];
1942 int len;
1944 switch (section_type) {
1945 case QEMU_VM_SECTION_START:
1946 case QEMU_VM_SECTION_FULL:
1947 /* Read section start */
1948 section_id = qemu_get_be32(f);
1949 len = qemu_get_byte(f);
1950 qemu_get_buffer(f, (uint8_t *)idstr, len);
1951 idstr[len] = 0;
1952 instance_id = qemu_get_be32(f);
1953 version_id = qemu_get_be32(f);
1955 /* Find savevm section */
1956 se = find_se(idstr, instance_id);
1957 if (se == NULL) {
1958 fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
1959 ret = -EINVAL;
1960 goto out;
1963 /* Validate version */
1964 if (version_id > se->version_id) {
1965 fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
1966 version_id, idstr, se->version_id);
1967 ret = -EINVAL;
1968 goto out;
1971 /* Add entry */
1972 le = g_malloc0(sizeof(*le));
1974 le->se = se;
1975 le->section_id = section_id;
1976 le->version_id = version_id;
1977 QLIST_INSERT_HEAD(&loadvm_handlers, le, entry);
1979 ret = vmstate_load(f, le->se, le->version_id);
1980 if (ret < 0) {
1981 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
1982 instance_id, idstr);
1983 goto out;
1985 break;
1986 case QEMU_VM_SECTION_PART:
1987 case QEMU_VM_SECTION_END:
1988 section_id = qemu_get_be32(f);
1990 QLIST_FOREACH(le, &loadvm_handlers, entry) {
1991 if (le->section_id == section_id) {
1992 break;
1995 if (le == NULL) {
1996 fprintf(stderr, "Unknown savevm section %d\n", section_id);
1997 ret = -EINVAL;
1998 goto out;
2001 ret = vmstate_load(f, le->se, le->version_id);
2002 if (ret < 0) {
2003 fprintf(stderr, "qemu: warning: error while loading state section id %d\n",
2004 section_id);
2005 goto out;
2007 break;
2008 default:
2009 fprintf(stderr, "Unknown savevm section type %d\n", section_type);
2010 ret = -EINVAL;
2011 goto out;
2015 cpu_synchronize_all_post_init();
2017 ret = 0;
2019 out:
2020 QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
2021 QLIST_REMOVE(le, entry);
2022 g_free(le);
2025 if (ret == 0) {
2026 ret = qemu_file_get_error(f);
2029 return ret;
2032 static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
2033 const char *name)
2035 QEMUSnapshotInfo *sn_tab, *sn;
2036 int nb_sns, i, ret;
2038 ret = -ENOENT;
2039 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2040 if (nb_sns < 0)
2041 return ret;
2042 for(i = 0; i < nb_sns; i++) {
2043 sn = &sn_tab[i];
2044 if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
2045 *sn_info = *sn;
2046 ret = 0;
2047 break;
2050 g_free(sn_tab);
2051 return ret;
2055 * Deletes snapshots of a given name in all opened images.
2057 static int del_existing_snapshots(Monitor *mon, const char *name)
2059 BlockDriverState *bs;
2060 QEMUSnapshotInfo sn1, *snapshot = &sn1;
2061 int ret;
2063 bs = NULL;
2064 while ((bs = bdrv_next(bs))) {
2065 if (bdrv_can_snapshot(bs) &&
2066 bdrv_snapshot_find(bs, snapshot, name) >= 0)
2068 ret = bdrv_snapshot_delete(bs, name);
2069 if (ret < 0) {
2070 monitor_printf(mon,
2071 "Error while deleting snapshot on '%s'\n",
2072 bdrv_get_device_name(bs));
2073 return -1;
2078 return 0;
2081 void do_savevm(Monitor *mon, const QDict *qdict)
2083 BlockDriverState *bs, *bs1;
2084 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
2085 int ret;
2086 QEMUFile *f;
2087 int saved_vm_running;
2088 uint64_t vm_state_size;
2089 #ifdef _WIN32
2090 struct _timeb tb;
2091 struct tm *ptm;
2092 #else
2093 struct timeval tv;
2094 struct tm tm;
2095 #endif
2096 const char *name = qdict_get_try_str(qdict, "name");
2098 /* Verify if there is a device that doesn't support snapshots and is writable */
2099 bs = NULL;
2100 while ((bs = bdrv_next(bs))) {
2102 if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2103 continue;
2106 if (!bdrv_can_snapshot(bs)) {
2107 monitor_printf(mon, "Device '%s' is writable but does not support snapshots.\n",
2108 bdrv_get_device_name(bs));
2109 return;
2113 bs = bdrv_snapshots();
2114 if (!bs) {
2115 monitor_printf(mon, "No block device can accept snapshots\n");
2116 return;
2119 saved_vm_running = runstate_is_running();
2120 vm_stop(RUN_STATE_SAVE_VM);
2122 memset(sn, 0, sizeof(*sn));
2124 /* fill auxiliary fields */
2125 #ifdef _WIN32
2126 _ftime(&tb);
2127 sn->date_sec = tb.time;
2128 sn->date_nsec = tb.millitm * 1000000;
2129 #else
2130 gettimeofday(&tv, NULL);
2131 sn->date_sec = tv.tv_sec;
2132 sn->date_nsec = tv.tv_usec * 1000;
2133 #endif
2134 sn->vm_clock_nsec = qemu_get_clock_ns(vm_clock);
2136 if (name) {
2137 ret = bdrv_snapshot_find(bs, old_sn, name);
2138 if (ret >= 0) {
2139 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
2140 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
2141 } else {
2142 pstrcpy(sn->name, sizeof(sn->name), name);
2144 } else {
2145 #ifdef _WIN32
2146 time_t t = tb.time;
2147 ptm = localtime(&t);
2148 strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", ptm);
2149 #else
2150 /* cast below needed for OpenBSD where tv_sec is still 'long' */
2151 localtime_r((const time_t *)&tv.tv_sec, &tm);
2152 strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
2153 #endif
2156 /* Delete old snapshots of the same name */
2157 if (name && del_existing_snapshots(mon, name) < 0) {
2158 goto the_end;
2161 /* save the VM state */
2162 f = qemu_fopen_bdrv(bs, 1);
2163 if (!f) {
2164 monitor_printf(mon, "Could not open VM state file\n");
2165 goto the_end;
2167 ret = qemu_savevm_state(f);
2168 vm_state_size = qemu_ftell(f);
2169 qemu_fclose(f);
2170 if (ret < 0) {
2171 monitor_printf(mon, "Error %d while writing VM\n", ret);
2172 goto the_end;
2175 /* create the snapshots */
2177 bs1 = NULL;
2178 while ((bs1 = bdrv_next(bs1))) {
2179 if (bdrv_can_snapshot(bs1)) {
2180 /* Write VM state size only to the image that contains the state */
2181 sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
2182 ret = bdrv_snapshot_create(bs1, sn);
2183 if (ret < 0) {
2184 monitor_printf(mon, "Error while creating snapshot on '%s'\n",
2185 bdrv_get_device_name(bs1));
2190 the_end:
2191 if (saved_vm_running)
2192 vm_start();
2195 void qmp_xen_save_devices_state(const char *filename, Error **errp)
2197 QEMUFile *f;
2198 int saved_vm_running;
2199 int ret;
2201 saved_vm_running = runstate_is_running();
2202 vm_stop(RUN_STATE_SAVE_VM);
2204 f = qemu_fopen(filename, "wb");
2205 if (!f) {
2206 error_set(errp, QERR_OPEN_FILE_FAILED, filename);
2207 goto the_end;
2209 ret = qemu_save_device_state(f);
2210 qemu_fclose(f);
2211 if (ret < 0) {
2212 error_set(errp, QERR_IO_ERROR);
2215 the_end:
2216 if (saved_vm_running)
2217 vm_start();
2220 int load_vmstate(const char *name)
2222 BlockDriverState *bs, *bs_vm_state;
2223 QEMUSnapshotInfo sn;
2224 QEMUFile *f;
2225 int ret;
2227 bs_vm_state = bdrv_snapshots();
2228 if (!bs_vm_state) {
2229 error_report("No block device supports snapshots");
2230 return -ENOTSUP;
2233 /* Don't even try to load empty VM states */
2234 ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
2235 if (ret < 0) {
2236 return ret;
2237 } else if (sn.vm_state_size == 0) {
2238 error_report("This is a disk-only snapshot. Revert to it offline "
2239 "using qemu-img.");
2240 return -EINVAL;
2243 /* Verify if there is any device that doesn't support snapshots and is
2244 writable and check if the requested snapshot is available too. */
2245 bs = NULL;
2246 while ((bs = bdrv_next(bs))) {
2248 if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2249 continue;
2252 if (!bdrv_can_snapshot(bs)) {
2253 error_report("Device '%s' is writable but does not support snapshots.",
2254 bdrv_get_device_name(bs));
2255 return -ENOTSUP;
2258 ret = bdrv_snapshot_find(bs, &sn, name);
2259 if (ret < 0) {
2260 error_report("Device '%s' does not have the requested snapshot '%s'",
2261 bdrv_get_device_name(bs), name);
2262 return ret;
2266 /* Flush all IO requests so they don't interfere with the new state. */
2267 bdrv_drain_all();
2269 bs = NULL;
2270 while ((bs = bdrv_next(bs))) {
2271 if (bdrv_can_snapshot(bs)) {
2272 ret = bdrv_snapshot_goto(bs, name);
2273 if (ret < 0) {
2274 error_report("Error %d while activating snapshot '%s' on '%s'",
2275 ret, name, bdrv_get_device_name(bs));
2276 return ret;
2281 /* restore the VM state */
2282 f = qemu_fopen_bdrv(bs_vm_state, 0);
2283 if (!f) {
2284 error_report("Could not open VM state file");
2285 return -EINVAL;
2288 qemu_system_reset(VMRESET_SILENT);
2289 ret = qemu_loadvm_state(f);
2291 qemu_fclose(f);
2292 if (ret < 0) {
2293 error_report("Error %d while loading VM state", ret);
2294 return ret;
2297 return 0;
2300 void do_delvm(Monitor *mon, const QDict *qdict)
2302 BlockDriverState *bs, *bs1;
2303 int ret;
2304 const char *name = qdict_get_str(qdict, "name");
2306 bs = bdrv_snapshots();
2307 if (!bs) {
2308 monitor_printf(mon, "No block device supports snapshots\n");
2309 return;
2312 bs1 = NULL;
2313 while ((bs1 = bdrv_next(bs1))) {
2314 if (bdrv_can_snapshot(bs1)) {
2315 ret = bdrv_snapshot_delete(bs1, name);
2316 if (ret < 0) {
2317 if (ret == -ENOTSUP)
2318 monitor_printf(mon,
2319 "Snapshots not supported on device '%s'\n",
2320 bdrv_get_device_name(bs1));
2321 else
2322 monitor_printf(mon, "Error %d while deleting snapshot on "
2323 "'%s'\n", ret, bdrv_get_device_name(bs1));
2329 void do_info_snapshots(Monitor *mon)
2331 BlockDriverState *bs, *bs1;
2332 QEMUSnapshotInfo *sn_tab, *sn, s, *sn_info = &s;
2333 int nb_sns, i, ret, available;
2334 int total;
2335 int *available_snapshots;
2336 char buf[256];
2338 bs = bdrv_snapshots();
2339 if (!bs) {
2340 monitor_printf(mon, "No available block device supports snapshots\n");
2341 return;
2344 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2345 if (nb_sns < 0) {
2346 monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
2347 return;
2350 if (nb_sns == 0) {
2351 monitor_printf(mon, "There is no snapshot available.\n");
2352 return;
2355 available_snapshots = g_malloc0(sizeof(int) * nb_sns);
2356 total = 0;
2357 for (i = 0; i < nb_sns; i++) {
2358 sn = &sn_tab[i];
2359 available = 1;
2360 bs1 = NULL;
2362 while ((bs1 = bdrv_next(bs1))) {
2363 if (bdrv_can_snapshot(bs1) && bs1 != bs) {
2364 ret = bdrv_snapshot_find(bs1, sn_info, sn->id_str);
2365 if (ret < 0) {
2366 available = 0;
2367 break;
2372 if (available) {
2373 available_snapshots[total] = i;
2374 total++;
2378 if (total > 0) {
2379 monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
2380 for (i = 0; i < total; i++) {
2381 sn = &sn_tab[available_snapshots[i]];
2382 monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
2384 } else {
2385 monitor_printf(mon, "There is no suitable snapshot available\n");
2388 g_free(sn_tab);
2389 g_free(available_snapshots);
2393 void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
2395 qemu_ram_set_idstr(memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK,
2396 memory_region_name(mr), dev);
2399 void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev)
2401 /* Nothing do to while the implementation is in RAMBlock */
2404 void vmstate_register_ram_global(MemoryRegion *mr)
2406 vmstate_register_ram(mr, NULL);
2410 page = zrun nzrun
2411 | zrun nzrun page
2413 zrun = length
2415 nzrun = length byte...
2417 length = uleb128 encoded integer
2419 int xbzrle_encode_buffer(uint8_t *old_buf, uint8_t *new_buf, int slen,
2420 uint8_t *dst, int dlen)
2422 uint32_t zrun_len = 0, nzrun_len = 0;
2423 int d = 0, i = 0;
2424 long res, xor;
2425 uint8_t *nzrun_start = NULL;
2427 g_assert(!(((uintptr_t)old_buf | (uintptr_t)new_buf | slen) %
2428 sizeof(long)));
2430 while (i < slen) {
2431 /* overflow */
2432 if (d + 2 > dlen) {
2433 return -1;
2436 /* not aligned to sizeof(long) */
2437 res = (slen - i) % sizeof(long);
2438 while (res && old_buf[i] == new_buf[i]) {
2439 zrun_len++;
2440 i++;
2441 res--;
2444 /* word at a time for speed */
2445 if (!res) {
2446 while (i < slen &&
2447 (*(long *)(old_buf + i)) == (*(long *)(new_buf + i))) {
2448 i += sizeof(long);
2449 zrun_len += sizeof(long);
2452 /* go over the rest */
2453 while (i < slen && old_buf[i] == new_buf[i]) {
2454 zrun_len++;
2455 i++;
2459 /* buffer unchanged */
2460 if (zrun_len == slen) {
2461 return 0;
2464 /* skip last zero run */
2465 if (i == slen) {
2466 return d;
2469 d += uleb128_encode_small(dst + d, zrun_len);
2471 zrun_len = 0;
2472 nzrun_start = new_buf + i;
2474 /* overflow */
2475 if (d + 2 > dlen) {
2476 return -1;
2478 /* not aligned to sizeof(long) */
2479 res = (slen - i) % sizeof(long);
2480 while (res && old_buf[i] != new_buf[i]) {
2481 i++;
2482 nzrun_len++;
2483 res--;
2486 /* word at a time for speed, use of 32-bit long okay */
2487 if (!res) {
2488 /* truncation to 32-bit long okay */
2489 long mask = (long)0x0101010101010101ULL;
2490 while (i < slen) {
2491 xor = *(long *)(old_buf + i) ^ *(long *)(new_buf + i);
2492 if ((xor - mask) & ~xor & (mask << 7)) {
2493 /* found the end of an nzrun within the current long */
2494 while (old_buf[i] != new_buf[i]) {
2495 nzrun_len++;
2496 i++;
2498 break;
2499 } else {
2500 i += sizeof(long);
2501 nzrun_len += sizeof(long);
2506 d += uleb128_encode_small(dst + d, nzrun_len);
2507 /* overflow */
2508 if (d + nzrun_len > dlen) {
2509 return -1;
2511 memcpy(dst + d, nzrun_start, nzrun_len);
2512 d += nzrun_len;
2513 nzrun_len = 0;
2516 return d;
2519 int xbzrle_decode_buffer(uint8_t *src, int slen, uint8_t *dst, int dlen)
2521 int i = 0, d = 0;
2522 int ret;
2523 uint32_t count = 0;
2525 while (i < slen) {
2527 /* zrun */
2528 if ((slen - i) < 2) {
2529 return -1;
2532 ret = uleb128_decode_small(src + i, &count);
2533 if (ret < 0 || (i && !count)) {
2534 return -1;
2536 i += ret;
2537 d += count;
2539 /* overflow */
2540 if (d > dlen) {
2541 return -1;
2544 /* nzrun */
2545 if ((slen - i) < 2) {
2546 return -1;
2549 ret = uleb128_decode_small(src + i, &count);
2550 if (ret < 0 || !count) {
2551 return -1;
2553 i += ret;
2555 /* overflow */
2556 if (d + count > dlen || i + count > slen) {
2557 return -1;
2560 memcpy(dst + d, src + i, count);
2561 d += count;
2562 i += count;
2565 return d;