PPC: Enable doorbell excp handlers
[qemu.git] / savevm.c
1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
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:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
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.
23 */
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>
30
31 /* Needed early for CONFIG_BSD etc. */
32 #include "config-host.h"
33
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
62
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
71
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
88 #define SELF_ANNOUNCE_ROUNDS 5
89
90 #ifndef ETH_P_RARP
91 #define ETH_P_RARP 0x8035
92 #endif
93 #define ARP_HTYPE_ETH 0x0001
94 #define ARP_PTYPE_IP 0x0800
95 #define ARP_OP_REQUEST_REV 0x3
96
97 static int announce_self_create(uint8_t *buf,
98 uint8_t *mac_addr)
99 {
100 /* Ethernet header. */
101 memset(buf, 0xff, 6); /* destination MAC addr */
102 memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
103 *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */
104
105 /* RARP header. */
106 *(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */
107 *(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */
108 *(buf + 18) = 6; /* hardware addr length (ethernet) */
109 *(buf + 19) = 4; /* protocol addr length (IPv4) */
110 *(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */
111 memcpy(buf + 22, mac_addr, 6); /* source hw addr */
112 memset(buf + 28, 0x00, 4); /* source protocol addr */
113 memcpy(buf + 32, mac_addr, 6); /* target hw addr */
114 memset(buf + 38, 0x00, 4); /* target protocol addr */
115
116 /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
117 memset(buf + 42, 0x00, 18);
118
119 return 60; /* len (FCS will be added by hardware) */
120 }
121
122 static void qemu_announce_self_iter(NICState *nic, void *opaque)
123 {
124 uint8_t buf[60];
125 int len;
126
127 len = announce_self_create(buf, nic->conf->macaddr.a);
128
129 qemu_send_packet_raw(&nic->nc, buf, len);
130 }
131
132
133 static void qemu_announce_self_once(void *opaque)
134 {
135 static int count = SELF_ANNOUNCE_ROUNDS;
136 QEMUTimer *timer = *(QEMUTimer **)opaque;
137
138 qemu_foreach_nic(qemu_announce_self_iter, NULL);
139
140 if (--count) {
141 /* delay 50ms, 150ms, 250ms, ... */
142 qemu_mod_timer(timer, qemu_get_clock_ms(rt_clock) +
143 50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100);
144 } else {
145 qemu_del_timer(timer);
146 qemu_free_timer(timer);
147 }
148 }
149
150 void qemu_announce_self(void)
151 {
152 static QEMUTimer *timer;
153 timer = qemu_new_timer_ms(rt_clock, qemu_announce_self_once, &timer);
154 qemu_announce_self_once(&timer);
155 }
156
157 /***********************************************************/
158 /* savevm/loadvm support */
159
160 #define IO_BUF_SIZE 32768
161
162 struct QEMUFile {
163 QEMUFilePutBufferFunc *put_buffer;
164 QEMUFileGetBufferFunc *get_buffer;
165 QEMUFileCloseFunc *close;
166 QEMUFileRateLimit *rate_limit;
167 QEMUFileSetRateLimit *set_rate_limit;
168 QEMUFileGetRateLimit *get_rate_limit;
169 void *opaque;
170 int is_write;
171
172 int64_t buf_offset; /* start of buffer when writing, end of buffer
173 when reading */
174 int buf_index;
175 int buf_size; /* 0 when writing */
176 uint8_t buf[IO_BUF_SIZE];
177
178 int last_error;
179 };
180
181 typedef struct QEMUFileStdio
182 {
183 FILE *stdio_file;
184 QEMUFile *file;
185 } QEMUFileStdio;
186
187 typedef struct QEMUFileSocket
188 {
189 int fd;
190 QEMUFile *file;
191 } QEMUFileSocket;
192
193 static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
194 {
195 QEMUFileSocket *s = opaque;
196 ssize_t len;
197
198 do {
199 len = qemu_recv(s->fd, buf, size, 0);
200 } while (len == -1 && socket_error() == EINTR);
201
202 if (len == -1)
203 len = -socket_error();
204
205 return len;
206 }
207
208 static int socket_close(void *opaque)
209 {
210 QEMUFileSocket *s = opaque;
211 g_free(s);
212 return 0;
213 }
214
215 static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
216 {
217 QEMUFileStdio *s = opaque;
218 return fwrite(buf, 1, size, s->stdio_file);
219 }
220
221 static int stdio_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
222 {
223 QEMUFileStdio *s = opaque;
224 FILE *fp = s->stdio_file;
225 int bytes;
226
227 do {
228 clearerr(fp);
229 bytes = fread(buf, 1, size, fp);
230 } while ((bytes == 0) && ferror(fp) && (errno == EINTR));
231 return bytes;
232 }
233
234 static int stdio_pclose(void *opaque)
235 {
236 QEMUFileStdio *s = opaque;
237 int ret;
238 ret = pclose(s->stdio_file);
239 if (ret == -1) {
240 ret = -errno;
241 }
242 g_free(s);
243 return ret;
244 }
245
246 static int stdio_fclose(void *opaque)
247 {
248 QEMUFileStdio *s = opaque;
249 int ret = 0;
250 if (fclose(s->stdio_file) == EOF) {
251 ret = -errno;
252 }
253 g_free(s);
254 return ret;
255 }
256
257 QEMUFile *qemu_popen(FILE *stdio_file, const char *mode)
258 {
259 QEMUFileStdio *s;
260
261 if (stdio_file == NULL || mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
262 fprintf(stderr, "qemu_popen: Argument validity check failed\n");
263 return NULL;
264 }
265
266 s = g_malloc0(sizeof(QEMUFileStdio));
267
268 s->stdio_file = stdio_file;
269
270 if(mode[0] == 'r') {
271 s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_pclose,
272 NULL, NULL, NULL);
273 } else {
274 s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_pclose,
275 NULL, NULL, NULL);
276 }
277 return s->file;
278 }
279
280 QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
281 {
282 FILE *popen_file;
283
284 popen_file = popen(command, mode);
285 if(popen_file == NULL) {
286 return NULL;
287 }
288
289 return qemu_popen(popen_file, mode);
290 }
291
292 int qemu_stdio_fd(QEMUFile *f)
293 {
294 QEMUFileStdio *p;
295 int fd;
296
297 p = (QEMUFileStdio *)f->opaque;
298 fd = fileno(p->stdio_file);
299
300 return fd;
301 }
302
303 QEMUFile *qemu_fdopen(int fd, const char *mode)
304 {
305 QEMUFileStdio *s;
306
307 if (mode == NULL ||
308 (mode[0] != 'r' && mode[0] != 'w') ||
309 mode[1] != 'b' || mode[2] != 0) {
310 fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
311 return NULL;
312 }
313
314 s = g_malloc0(sizeof(QEMUFileStdio));
315 s->stdio_file = fdopen(fd, mode);
316 if (!s->stdio_file)
317 goto fail;
318
319 if(mode[0] == 'r') {
320 s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_fclose,
321 NULL, NULL, NULL);
322 } else {
323 s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_fclose,
324 NULL, NULL, NULL);
325 }
326 return s->file;
327
328 fail:
329 g_free(s);
330 return NULL;
331 }
332
333 QEMUFile *qemu_fopen_socket(int fd)
334 {
335 QEMUFileSocket *s = g_malloc0(sizeof(QEMUFileSocket));
336
337 s->fd = fd;
338 s->file = qemu_fopen_ops(s, NULL, socket_get_buffer, socket_close,
339 NULL, NULL, NULL);
340 return s->file;
341 }
342
343 static int file_put_buffer(void *opaque, const uint8_t *buf,
344 int64_t pos, int size)
345 {
346 QEMUFileStdio *s = opaque;
347 fseek(s->stdio_file, pos, SEEK_SET);
348 return fwrite(buf, 1, size, s->stdio_file);
349 }
350
351 static int file_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
352 {
353 QEMUFileStdio *s = opaque;
354 fseek(s->stdio_file, pos, SEEK_SET);
355 return fread(buf, 1, size, s->stdio_file);
356 }
357
358 QEMUFile *qemu_fopen(const char *filename, const char *mode)
359 {
360 QEMUFileStdio *s;
361
362 if (mode == NULL ||
363 (mode[0] != 'r' && mode[0] != 'w') ||
364 mode[1] != 'b' || mode[2] != 0) {
365 fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
366 return NULL;
367 }
368
369 s = g_malloc0(sizeof(QEMUFileStdio));
370
371 s->stdio_file = fopen(filename, mode);
372 if (!s->stdio_file)
373 goto fail;
374
375 if(mode[0] == 'w') {
376 s->file = qemu_fopen_ops(s, file_put_buffer, NULL, stdio_fclose,
377 NULL, NULL, NULL);
378 } else {
379 s->file = qemu_fopen_ops(s, NULL, file_get_buffer, stdio_fclose,
380 NULL, NULL, NULL);
381 }
382 return s->file;
383 fail:
384 g_free(s);
385 return NULL;
386 }
387
388 static int block_put_buffer(void *opaque, const uint8_t *buf,
389 int64_t pos, int size)
390 {
391 bdrv_save_vmstate(opaque, buf, pos, size);
392 return size;
393 }
394
395 static int block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
396 {
397 return bdrv_load_vmstate(opaque, buf, pos, size);
398 }
399
400 static int bdrv_fclose(void *opaque)
401 {
402 return 0;
403 }
404
405 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
406 {
407 if (is_writable)
408 return qemu_fopen_ops(bs, block_put_buffer, NULL, bdrv_fclose,
409 NULL, NULL, NULL);
410 return qemu_fopen_ops(bs, NULL, block_get_buffer, bdrv_fclose, NULL, NULL, NULL);
411 }
412
413 QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
414 QEMUFileGetBufferFunc *get_buffer,
415 QEMUFileCloseFunc *close,
416 QEMUFileRateLimit *rate_limit,
417 QEMUFileSetRateLimit *set_rate_limit,
418 QEMUFileGetRateLimit *get_rate_limit)
419 {
420 QEMUFile *f;
421
422 f = g_malloc0(sizeof(QEMUFile));
423
424 f->opaque = opaque;
425 f->put_buffer = put_buffer;
426 f->get_buffer = get_buffer;
427 f->close = close;
428 f->rate_limit = rate_limit;
429 f->set_rate_limit = set_rate_limit;
430 f->get_rate_limit = get_rate_limit;
431 f->is_write = 0;
432
433 return f;
434 }
435
436 int qemu_file_get_error(QEMUFile *f)
437 {
438 return f->last_error;
439 }
440
441 void qemu_file_set_error(QEMUFile *f, int ret)
442 {
443 f->last_error = ret;
444 }
445
446 /** Sets last_error conditionally
447 *
448 * Sets last_error only if ret is negative _and_ no error
449 * was set before.
450 */
451 static void qemu_file_set_if_error(QEMUFile *f, int ret)
452 {
453 if (ret < 0 && !f->last_error) {
454 qemu_file_set_error(f, ret);
455 }
456 }
457
458 /** Flushes QEMUFile buffer
459 *
460 * In case of error, last_error is set.
461 */
462 void qemu_fflush(QEMUFile *f)
463 {
464 if (!f->put_buffer)
465 return;
466
467 if (f->is_write && f->buf_index > 0) {
468 int len;
469
470 len = f->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
471 if (len > 0)
472 f->buf_offset += f->buf_index;
473 else
474 qemu_file_set_error(f, -EINVAL);
475 f->buf_index = 0;
476 }
477 }
478
479 static void qemu_fill_buffer(QEMUFile *f)
480 {
481 int len;
482 int pending;
483
484 if (!f->get_buffer)
485 return;
486
487 if (f->is_write)
488 abort();
489
490 pending = f->buf_size - f->buf_index;
491 if (pending > 0) {
492 memmove(f->buf, f->buf + f->buf_index, pending);
493 }
494 f->buf_index = 0;
495 f->buf_size = pending;
496
497 len = f->get_buffer(f->opaque, f->buf + pending, f->buf_offset,
498 IO_BUF_SIZE - pending);
499 if (len > 0) {
500 f->buf_size += len;
501 f->buf_offset += len;
502 } else if (len == 0) {
503 f->last_error = -EIO;
504 } else if (len != -EAGAIN)
505 qemu_file_set_error(f, len);
506 }
507
508 /** Calls close function and set last_error if needed
509 *
510 * Internal function. qemu_fflush() must be called before this.
511 *
512 * Returns f->close() return value, or 0 if close function is not set.
513 */
514 static int qemu_close(QEMUFile *f)
515 {
516 int ret = 0;
517 if (f->close) {
518 ret = f->close(f->opaque);
519 qemu_file_set_if_error(f, ret);
520 }
521 return ret;
522 }
523
524 /** Closes the file
525 *
526 * Returns negative error value if any error happened on previous operations or
527 * while closing the file. Returns 0 or positive number on success.
528 *
529 * The meaning of return value on success depends on the specific backend
530 * being used.
531 */
532 int qemu_fclose(QEMUFile *f)
533 {
534 int ret;
535 qemu_fflush(f);
536 ret = qemu_close(f);
537 /* If any error was spotted before closing, we should report it
538 * instead of the close() return value.
539 */
540 if (f->last_error) {
541 ret = f->last_error;
542 }
543 g_free(f);
544 return ret;
545 }
546
547 void qemu_file_put_notify(QEMUFile *f)
548 {
549 f->put_buffer(f->opaque, NULL, 0, 0);
550 }
551
552 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
553 {
554 int l;
555
556 if (!f->last_error && f->is_write == 0 && f->buf_index > 0) {
557 fprintf(stderr,
558 "Attempted to write to buffer while read buffer is not empty\n");
559 abort();
560 }
561
562 while (!f->last_error && size > 0) {
563 l = IO_BUF_SIZE - f->buf_index;
564 if (l > size)
565 l = size;
566 memcpy(f->buf + f->buf_index, buf, l);
567 f->is_write = 1;
568 f->buf_index += l;
569 buf += l;
570 size -= l;
571 if (f->buf_index >= IO_BUF_SIZE)
572 qemu_fflush(f);
573 }
574 }
575
576 void qemu_put_byte(QEMUFile *f, int v)
577 {
578 if (!f->last_error && f->is_write == 0 && f->buf_index > 0) {
579 fprintf(stderr,
580 "Attempted to write to buffer while read buffer is not empty\n");
581 abort();
582 }
583
584 f->buf[f->buf_index++] = v;
585 f->is_write = 1;
586 if (f->buf_index >= IO_BUF_SIZE)
587 qemu_fflush(f);
588 }
589
590 static void qemu_file_skip(QEMUFile *f, int size)
591 {
592 if (f->buf_index + size <= f->buf_size) {
593 f->buf_index += size;
594 }
595 }
596
597 static int qemu_peek_buffer(QEMUFile *f, uint8_t *buf, int size, size_t offset)
598 {
599 int pending;
600 int index;
601
602 if (f->is_write) {
603 abort();
604 }
605
606 index = f->buf_index + offset;
607 pending = f->buf_size - index;
608 if (pending < size) {
609 qemu_fill_buffer(f);
610 index = f->buf_index + offset;
611 pending = f->buf_size - index;
612 }
613
614 if (pending <= 0) {
615 return 0;
616 }
617 if (size > pending) {
618 size = pending;
619 }
620
621 memcpy(buf, f->buf + index, size);
622 return size;
623 }
624
625 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
626 {
627 int pending = size;
628 int done = 0;
629
630 while (pending > 0) {
631 int res;
632
633 res = qemu_peek_buffer(f, buf, pending, 0);
634 if (res == 0) {
635 return done;
636 }
637 qemu_file_skip(f, res);
638 buf += res;
639 pending -= res;
640 done += res;
641 }
642 return done;
643 }
644
645 static int qemu_peek_byte(QEMUFile *f, int offset)
646 {
647 int index = f->buf_index + offset;
648
649 if (f->is_write) {
650 abort();
651 }
652
653 if (index >= f->buf_size) {
654 qemu_fill_buffer(f);
655 index = f->buf_index + offset;
656 if (index >= f->buf_size) {
657 return 0;
658 }
659 }
660 return f->buf[index];
661 }
662
663 int qemu_get_byte(QEMUFile *f)
664 {
665 int result;
666
667 result = qemu_peek_byte(f, 0);
668 qemu_file_skip(f, 1);
669 return result;
670 }
671
672 int64_t qemu_ftell(QEMUFile *f)
673 {
674 return f->buf_offset - f->buf_size + f->buf_index;
675 }
676
677 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
678 {
679 if (whence == SEEK_SET) {
680 /* nothing to do */
681 } else if (whence == SEEK_CUR) {
682 pos += qemu_ftell(f);
683 } else {
684 /* SEEK_END not supported */
685 return -1;
686 }
687 if (f->put_buffer) {
688 qemu_fflush(f);
689 f->buf_offset = pos;
690 } else {
691 f->buf_offset = pos;
692 f->buf_index = 0;
693 f->buf_size = 0;
694 }
695 return pos;
696 }
697
698 int qemu_file_rate_limit(QEMUFile *f)
699 {
700 if (f->rate_limit)
701 return f->rate_limit(f->opaque);
702
703 return 0;
704 }
705
706 int64_t qemu_file_get_rate_limit(QEMUFile *f)
707 {
708 if (f->get_rate_limit)
709 return f->get_rate_limit(f->opaque);
710
711 return 0;
712 }
713
714 int64_t qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate)
715 {
716 /* any failed or completed migration keeps its state to allow probing of
717 * migration data, but has no associated file anymore */
718 if (f && f->set_rate_limit)
719 return f->set_rate_limit(f->opaque, new_rate);
720
721 return 0;
722 }
723
724 void qemu_put_be16(QEMUFile *f, unsigned int v)
725 {
726 qemu_put_byte(f, v >> 8);
727 qemu_put_byte(f, v);
728 }
729
730 void qemu_put_be32(QEMUFile *f, unsigned int v)
731 {
732 qemu_put_byte(f, v >> 24);
733 qemu_put_byte(f, v >> 16);
734 qemu_put_byte(f, v >> 8);
735 qemu_put_byte(f, v);
736 }
737
738 void qemu_put_be64(QEMUFile *f, uint64_t v)
739 {
740 qemu_put_be32(f, v >> 32);
741 qemu_put_be32(f, v);
742 }
743
744 unsigned int qemu_get_be16(QEMUFile *f)
745 {
746 unsigned int v;
747 v = qemu_get_byte(f) << 8;
748 v |= qemu_get_byte(f);
749 return v;
750 }
751
752 unsigned int qemu_get_be32(QEMUFile *f)
753 {
754 unsigned int v;
755 v = qemu_get_byte(f) << 24;
756 v |= qemu_get_byte(f) << 16;
757 v |= qemu_get_byte(f) << 8;
758 v |= qemu_get_byte(f);
759 return v;
760 }
761
762 uint64_t qemu_get_be64(QEMUFile *f)
763 {
764 uint64_t v;
765 v = (uint64_t)qemu_get_be32(f) << 32;
766 v |= qemu_get_be32(f);
767 return v;
768 }
769
770
771 /* timer */
772
773 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
774 {
775 uint64_t expire_time;
776
777 expire_time = qemu_timer_expire_time_ns(ts);
778 qemu_put_be64(f, expire_time);
779 }
780
781 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
782 {
783 uint64_t expire_time;
784
785 expire_time = qemu_get_be64(f);
786 if (expire_time != -1) {
787 qemu_mod_timer_ns(ts, expire_time);
788 } else {
789 qemu_del_timer(ts);
790 }
791 }
792
793
794 /* bool */
795
796 static int get_bool(QEMUFile *f, void *pv, size_t size)
797 {
798 bool *v = pv;
799 *v = qemu_get_byte(f);
800 return 0;
801 }
802
803 static void put_bool(QEMUFile *f, void *pv, size_t size)
804 {
805 bool *v = pv;
806 qemu_put_byte(f, *v);
807 }
808
809 const VMStateInfo vmstate_info_bool = {
810 .name = "bool",
811 .get = get_bool,
812 .put = put_bool,
813 };
814
815 /* 8 bit int */
816
817 static int get_int8(QEMUFile *f, void *pv, size_t size)
818 {
819 int8_t *v = pv;
820 qemu_get_s8s(f, v);
821 return 0;
822 }
823
824 static void put_int8(QEMUFile *f, void *pv, size_t size)
825 {
826 int8_t *v = pv;
827 qemu_put_s8s(f, v);
828 }
829
830 const VMStateInfo vmstate_info_int8 = {
831 .name = "int8",
832 .get = get_int8,
833 .put = put_int8,
834 };
835
836 /* 16 bit int */
837
838 static int get_int16(QEMUFile *f, void *pv, size_t size)
839 {
840 int16_t *v = pv;
841 qemu_get_sbe16s(f, v);
842 return 0;
843 }
844
845 static void put_int16(QEMUFile *f, void *pv, size_t size)
846 {
847 int16_t *v = pv;
848 qemu_put_sbe16s(f, v);
849 }
850
851 const VMStateInfo vmstate_info_int16 = {
852 .name = "int16",
853 .get = get_int16,
854 .put = put_int16,
855 };
856
857 /* 32 bit int */
858
859 static int get_int32(QEMUFile *f, void *pv, size_t size)
860 {
861 int32_t *v = pv;
862 qemu_get_sbe32s(f, v);
863 return 0;
864 }
865
866 static void put_int32(QEMUFile *f, void *pv, size_t size)
867 {
868 int32_t *v = pv;
869 qemu_put_sbe32s(f, v);
870 }
871
872 const VMStateInfo vmstate_info_int32 = {
873 .name = "int32",
874 .get = get_int32,
875 .put = put_int32,
876 };
877
878 /* 32 bit int. See that the received value is the same than the one
879 in the field */
880
881 static int get_int32_equal(QEMUFile *f, void *pv, size_t size)
882 {
883 int32_t *v = pv;
884 int32_t v2;
885 qemu_get_sbe32s(f, &v2);
886
887 if (*v == v2)
888 return 0;
889 return -EINVAL;
890 }
891
892 const VMStateInfo vmstate_info_int32_equal = {
893 .name = "int32 equal",
894 .get = get_int32_equal,
895 .put = put_int32,
896 };
897
898 /* 32 bit int. See that the received value is the less or the same
899 than the one in the field */
900
901 static int get_int32_le(QEMUFile *f, void *pv, size_t size)
902 {
903 int32_t *old = pv;
904 int32_t new;
905 qemu_get_sbe32s(f, &new);
906
907 if (*old <= new)
908 return 0;
909 return -EINVAL;
910 }
911
912 const VMStateInfo vmstate_info_int32_le = {
913 .name = "int32 equal",
914 .get = get_int32_le,
915 .put = put_int32,
916 };
917
918 /* 64 bit int */
919
920 static int get_int64(QEMUFile *f, void *pv, size_t size)
921 {
922 int64_t *v = pv;
923 qemu_get_sbe64s(f, v);
924 return 0;
925 }
926
927 static void put_int64(QEMUFile *f, void *pv, size_t size)
928 {
929 int64_t *v = pv;
930 qemu_put_sbe64s(f, v);
931 }
932
933 const VMStateInfo vmstate_info_int64 = {
934 .name = "int64",
935 .get = get_int64,
936 .put = put_int64,
937 };
938
939 /* 8 bit unsigned int */
940
941 static int get_uint8(QEMUFile *f, void *pv, size_t size)
942 {
943 uint8_t *v = pv;
944 qemu_get_8s(f, v);
945 return 0;
946 }
947
948 static void put_uint8(QEMUFile *f, void *pv, size_t size)
949 {
950 uint8_t *v = pv;
951 qemu_put_8s(f, v);
952 }
953
954 const VMStateInfo vmstate_info_uint8 = {
955 .name = "uint8",
956 .get = get_uint8,
957 .put = put_uint8,
958 };
959
960 /* 16 bit unsigned int */
961
962 static int get_uint16(QEMUFile *f, void *pv, size_t size)
963 {
964 uint16_t *v = pv;
965 qemu_get_be16s(f, v);
966 return 0;
967 }
968
969 static void put_uint16(QEMUFile *f, void *pv, size_t size)
970 {
971 uint16_t *v = pv;
972 qemu_put_be16s(f, v);
973 }
974
975 const VMStateInfo vmstate_info_uint16 = {
976 .name = "uint16",
977 .get = get_uint16,
978 .put = put_uint16,
979 };
980
981 /* 32 bit unsigned int */
982
983 static int get_uint32(QEMUFile *f, void *pv, size_t size)
984 {
985 uint32_t *v = pv;
986 qemu_get_be32s(f, v);
987 return 0;
988 }
989
990 static void put_uint32(QEMUFile *f, void *pv, size_t size)
991 {
992 uint32_t *v = pv;
993 qemu_put_be32s(f, v);
994 }
995
996 const VMStateInfo vmstate_info_uint32 = {
997 .name = "uint32",
998 .get = get_uint32,
999 .put = put_uint32,
1000 };
1001
1002 /* 32 bit uint. See that the received value is the same than the one
1003 in the field */
1004
1005 static int get_uint32_equal(QEMUFile *f, void *pv, size_t size)
1006 {
1007 uint32_t *v = pv;
1008 uint32_t v2;
1009 qemu_get_be32s(f, &v2);
1010
1011 if (*v == v2) {
1012 return 0;
1013 }
1014 return -EINVAL;
1015 }
1016
1017 const VMStateInfo vmstate_info_uint32_equal = {
1018 .name = "uint32 equal",
1019 .get = get_uint32_equal,
1020 .put = put_uint32,
1021 };
1022
1023 /* 64 bit unsigned int */
1024
1025 static int get_uint64(QEMUFile *f, void *pv, size_t size)
1026 {
1027 uint64_t *v = pv;
1028 qemu_get_be64s(f, v);
1029 return 0;
1030 }
1031
1032 static void put_uint64(QEMUFile *f, void *pv, size_t size)
1033 {
1034 uint64_t *v = pv;
1035 qemu_put_be64s(f, v);
1036 }
1037
1038 const VMStateInfo vmstate_info_uint64 = {
1039 .name = "uint64",
1040 .get = get_uint64,
1041 .put = put_uint64,
1042 };
1043
1044 /* 8 bit int. See that the received value is the same than the one
1045 in the field */
1046
1047 static int get_uint8_equal(QEMUFile *f, void *pv, size_t size)
1048 {
1049 uint8_t *v = pv;
1050 uint8_t v2;
1051 qemu_get_8s(f, &v2);
1052
1053 if (*v == v2)
1054 return 0;
1055 return -EINVAL;
1056 }
1057
1058 const VMStateInfo vmstate_info_uint8_equal = {
1059 .name = "uint8 equal",
1060 .get = get_uint8_equal,
1061 .put = put_uint8,
1062 };
1063
1064 /* 16 bit unsigned int int. See that the received value is the same than the one
1065 in the field */
1066
1067 static int get_uint16_equal(QEMUFile *f, void *pv, size_t size)
1068 {
1069 uint16_t *v = pv;
1070 uint16_t v2;
1071 qemu_get_be16s(f, &v2);
1072
1073 if (*v == v2)
1074 return 0;
1075 return -EINVAL;
1076 }
1077
1078 const VMStateInfo vmstate_info_uint16_equal = {
1079 .name = "uint16 equal",
1080 .get = get_uint16_equal,
1081 .put = put_uint16,
1082 };
1083
1084 /* timers */
1085
1086 static int get_timer(QEMUFile *f, void *pv, size_t size)
1087 {
1088 QEMUTimer *v = pv;
1089 qemu_get_timer(f, v);
1090 return 0;
1091 }
1092
1093 static void put_timer(QEMUFile *f, void *pv, size_t size)
1094 {
1095 QEMUTimer *v = pv;
1096 qemu_put_timer(f, v);
1097 }
1098
1099 const VMStateInfo vmstate_info_timer = {
1100 .name = "timer",
1101 .get = get_timer,
1102 .put = put_timer,
1103 };
1104
1105 /* uint8_t buffers */
1106
1107 static int get_buffer(QEMUFile *f, void *pv, size_t size)
1108 {
1109 uint8_t *v = pv;
1110 qemu_get_buffer(f, v, size);
1111 return 0;
1112 }
1113
1114 static void put_buffer(QEMUFile *f, void *pv, size_t size)
1115 {
1116 uint8_t *v = pv;
1117 qemu_put_buffer(f, v, size);
1118 }
1119
1120 const VMStateInfo vmstate_info_buffer = {
1121 .name = "buffer",
1122 .get = get_buffer,
1123 .put = put_buffer,
1124 };
1125
1126 /* unused buffers: space that was used for some fields that are
1127 not useful anymore */
1128
1129 static int get_unused_buffer(QEMUFile *f, void *pv, size_t size)
1130 {
1131 uint8_t buf[1024];
1132 int block_len;
1133
1134 while (size > 0) {
1135 block_len = MIN(sizeof(buf), size);
1136 size -= block_len;
1137 qemu_get_buffer(f, buf, block_len);
1138 }
1139 return 0;
1140 }
1141
1142 static void put_unused_buffer(QEMUFile *f, void *pv, size_t size)
1143 {
1144 static const uint8_t buf[1024];
1145 int block_len;
1146
1147 while (size > 0) {
1148 block_len = MIN(sizeof(buf), size);
1149 size -= block_len;
1150 qemu_put_buffer(f, buf, block_len);
1151 }
1152 }
1153
1154 const VMStateInfo vmstate_info_unused_buffer = {
1155 .name = "unused_buffer",
1156 .get = get_unused_buffer,
1157 .put = put_unused_buffer,
1158 };
1159
1160 typedef struct CompatEntry {
1161 char idstr[256];
1162 int instance_id;
1163 } CompatEntry;
1164
1165 typedef struct SaveStateEntry {
1166 QTAILQ_ENTRY(SaveStateEntry) entry;
1167 char idstr[256];
1168 int instance_id;
1169 int alias_id;
1170 int version_id;
1171 int section_id;
1172 SaveSetParamsHandler *set_params;
1173 SaveLiveStateHandler *save_live_state;
1174 SaveStateHandler *save_state;
1175 LoadStateHandler *load_state;
1176 const VMStateDescription *vmsd;
1177 void *opaque;
1178 CompatEntry *compat;
1179 int no_migrate;
1180 } SaveStateEntry;
1181
1182
1183 static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers =
1184 QTAILQ_HEAD_INITIALIZER(savevm_handlers);
1185 static int global_section_id;
1186
1187 static int calculate_new_instance_id(const char *idstr)
1188 {
1189 SaveStateEntry *se;
1190 int instance_id = 0;
1191
1192 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1193 if (strcmp(idstr, se->idstr) == 0
1194 && instance_id <= se->instance_id) {
1195 instance_id = se->instance_id + 1;
1196 }
1197 }
1198 return instance_id;
1199 }
1200
1201 static int calculate_compat_instance_id(const char *idstr)
1202 {
1203 SaveStateEntry *se;
1204 int instance_id = 0;
1205
1206 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1207 if (!se->compat)
1208 continue;
1209
1210 if (strcmp(idstr, se->compat->idstr) == 0
1211 && instance_id <= se->compat->instance_id) {
1212 instance_id = se->compat->instance_id + 1;
1213 }
1214 }
1215 return instance_id;
1216 }
1217
1218 /* TODO: Individual devices generally have very little idea about the rest
1219 of the system, so instance_id should be removed/replaced.
1220 Meanwhile pass -1 as instance_id if you do not already have a clearly
1221 distinguishing id for all instances of your device class. */
1222 int register_savevm_live(DeviceState *dev,
1223 const char *idstr,
1224 int instance_id,
1225 int version_id,
1226 SaveSetParamsHandler *set_params,
1227 SaveLiveStateHandler *save_live_state,
1228 SaveStateHandler *save_state,
1229 LoadStateHandler *load_state,
1230 void *opaque)
1231 {
1232 SaveStateEntry *se;
1233
1234 se = g_malloc0(sizeof(SaveStateEntry));
1235 se->version_id = version_id;
1236 se->section_id = global_section_id++;
1237 se->set_params = set_params;
1238 se->save_live_state = save_live_state;
1239 se->save_state = save_state;
1240 se->load_state = load_state;
1241 se->opaque = opaque;
1242 se->vmsd = NULL;
1243 se->no_migrate = 0;
1244
1245 if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
1246 char *id = dev->parent_bus->info->get_dev_path(dev);
1247 if (id) {
1248 pstrcpy(se->idstr, sizeof(se->idstr), id);
1249 pstrcat(se->idstr, sizeof(se->idstr), "/");
1250 g_free(id);
1251
1252 se->compat = g_malloc0(sizeof(CompatEntry));
1253 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr);
1254 se->compat->instance_id = instance_id == -1 ?
1255 calculate_compat_instance_id(idstr) : instance_id;
1256 instance_id = -1;
1257 }
1258 }
1259 pstrcat(se->idstr, sizeof(se->idstr), idstr);
1260
1261 if (instance_id == -1) {
1262 se->instance_id = calculate_new_instance_id(se->idstr);
1263 } else {
1264 se->instance_id = instance_id;
1265 }
1266 assert(!se->compat || se->instance_id == 0);
1267 /* add at the end of list */
1268 QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1269 return 0;
1270 }
1271
1272 int register_savevm(DeviceState *dev,
1273 const char *idstr,
1274 int instance_id,
1275 int version_id,
1276 SaveStateHandler *save_state,
1277 LoadStateHandler *load_state,
1278 void *opaque)
1279 {
1280 return register_savevm_live(dev, idstr, instance_id, version_id,
1281 NULL, NULL, save_state, load_state, opaque);
1282 }
1283
1284 void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
1285 {
1286 SaveStateEntry *se, *new_se;
1287 char id[256] = "";
1288
1289 if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
1290 char *path = dev->parent_bus->info->get_dev_path(dev);
1291 if (path) {
1292 pstrcpy(id, sizeof(id), path);
1293 pstrcat(id, sizeof(id), "/");
1294 g_free(path);
1295 }
1296 }
1297 pstrcat(id, sizeof(id), idstr);
1298
1299 QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1300 if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
1301 QTAILQ_REMOVE(&savevm_handlers, se, entry);
1302 if (se->compat) {
1303 g_free(se->compat);
1304 }
1305 g_free(se);
1306 }
1307 }
1308 }
1309
1310 int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
1311 const VMStateDescription *vmsd,
1312 void *opaque, int alias_id,
1313 int required_for_version)
1314 {
1315 SaveStateEntry *se;
1316
1317 /* If this triggers, alias support can be dropped for the vmsd. */
1318 assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id);
1319
1320 se = g_malloc0(sizeof(SaveStateEntry));
1321 se->version_id = vmsd->version_id;
1322 se->section_id = global_section_id++;
1323 se->save_live_state = NULL;
1324 se->save_state = NULL;
1325 se->load_state = NULL;
1326 se->opaque = opaque;
1327 se->vmsd = vmsd;
1328 se->alias_id = alias_id;
1329 se->no_migrate = vmsd->unmigratable;
1330
1331 if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
1332 char *id = dev->parent_bus->info->get_dev_path(dev);
1333 if (id) {
1334 pstrcpy(se->idstr, sizeof(se->idstr), id);
1335 pstrcat(se->idstr, sizeof(se->idstr), "/");
1336 g_free(id);
1337
1338 se->compat = g_malloc0(sizeof(CompatEntry));
1339 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
1340 se->compat->instance_id = instance_id == -1 ?
1341 calculate_compat_instance_id(vmsd->name) : instance_id;
1342 instance_id = -1;
1343 }
1344 }
1345 pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);
1346
1347 if (instance_id == -1) {
1348 se->instance_id = calculate_new_instance_id(se->idstr);
1349 } else {
1350 se->instance_id = instance_id;
1351 }
1352 assert(!se->compat || se->instance_id == 0);
1353 /* add at the end of list */
1354 QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1355 return 0;
1356 }
1357
1358 int vmstate_register(DeviceState *dev, int instance_id,
1359 const VMStateDescription *vmsd, void *opaque)
1360 {
1361 return vmstate_register_with_alias_id(dev, instance_id, vmsd,
1362 opaque, -1, 0);
1363 }
1364
1365 void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
1366 void *opaque)
1367 {
1368 SaveStateEntry *se, *new_se;
1369
1370 QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1371 if (se->vmsd == vmsd && se->opaque == opaque) {
1372 QTAILQ_REMOVE(&savevm_handlers, se, entry);
1373 if (se->compat) {
1374 g_free(se->compat);
1375 }
1376 g_free(se);
1377 }
1378 }
1379 }
1380
1381 static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
1382 void *opaque);
1383 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
1384 void *opaque);
1385
1386 int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
1387 void *opaque, int version_id)
1388 {
1389 VMStateField *field = vmsd->fields;
1390 int ret;
1391
1392 if (version_id > vmsd->version_id) {
1393 return -EINVAL;
1394 }
1395 if (version_id < vmsd->minimum_version_id_old) {
1396 return -EINVAL;
1397 }
1398 if (version_id < vmsd->minimum_version_id) {
1399 return vmsd->load_state_old(f, opaque, version_id);
1400 }
1401 if (vmsd->pre_load) {
1402 int ret = vmsd->pre_load(opaque);
1403 if (ret)
1404 return ret;
1405 }
1406 while(field->name) {
1407 if ((field->field_exists &&
1408 field->field_exists(opaque, version_id)) ||
1409 (!field->field_exists &&
1410 field->version_id <= version_id)) {
1411 void *base_addr = opaque + field->offset;
1412 int i, n_elems = 1;
1413 int size = field->size;
1414
1415 if (field->flags & VMS_VBUFFER) {
1416 size = *(int32_t *)(opaque+field->size_offset);
1417 if (field->flags & VMS_MULTIPLY) {
1418 size *= field->size;
1419 }
1420 }
1421 if (field->flags & VMS_ARRAY) {
1422 n_elems = field->num;
1423 } else if (field->flags & VMS_VARRAY_INT32) {
1424 n_elems = *(int32_t *)(opaque+field->num_offset);
1425 } else if (field->flags & VMS_VARRAY_UINT32) {
1426 n_elems = *(uint32_t *)(opaque+field->num_offset);
1427 } else if (field->flags & VMS_VARRAY_UINT16) {
1428 n_elems = *(uint16_t *)(opaque+field->num_offset);
1429 } else if (field->flags & VMS_VARRAY_UINT8) {
1430 n_elems = *(uint8_t *)(opaque+field->num_offset);
1431 }
1432 if (field->flags & VMS_POINTER) {
1433 base_addr = *(void **)base_addr + field->start;
1434 }
1435 for (i = 0; i < n_elems; i++) {
1436 void *addr = base_addr + size * i;
1437
1438 if (field->flags & VMS_ARRAY_OF_POINTER) {
1439 addr = *(void **)addr;
1440 }
1441 if (field->flags & VMS_STRUCT) {
1442 ret = vmstate_load_state(f, field->vmsd, addr, field->vmsd->version_id);
1443 } else {
1444 ret = field->info->get(f, addr, size);
1445
1446 }
1447 if (ret < 0) {
1448 return ret;
1449 }
1450 }
1451 }
1452 field++;
1453 }
1454 ret = vmstate_subsection_load(f, vmsd, opaque);
1455 if (ret != 0) {
1456 return ret;
1457 }
1458 if (vmsd->post_load) {
1459 return vmsd->post_load(opaque, version_id);
1460 }
1461 return 0;
1462 }
1463
1464 void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
1465 void *opaque)
1466 {
1467 VMStateField *field = vmsd->fields;
1468
1469 if (vmsd->pre_save) {
1470 vmsd->pre_save(opaque);
1471 }
1472 while(field->name) {
1473 if (!field->field_exists ||
1474 field->field_exists(opaque, vmsd->version_id)) {
1475 void *base_addr = opaque + field->offset;
1476 int i, n_elems = 1;
1477 int size = field->size;
1478
1479 if (field->flags & VMS_VBUFFER) {
1480 size = *(int32_t *)(opaque+field->size_offset);
1481 if (field->flags & VMS_MULTIPLY) {
1482 size *= field->size;
1483 }
1484 }
1485 if (field->flags & VMS_ARRAY) {
1486 n_elems = field->num;
1487 } else if (field->flags & VMS_VARRAY_INT32) {
1488 n_elems = *(int32_t *)(opaque+field->num_offset);
1489 } else if (field->flags & VMS_VARRAY_UINT16) {
1490 n_elems = *(uint16_t *)(opaque+field->num_offset);
1491 } else if (field->flags & VMS_VARRAY_UINT8) {
1492 n_elems = *(uint8_t *)(opaque+field->num_offset);
1493 }
1494 if (field->flags & VMS_POINTER) {
1495 base_addr = *(void **)base_addr + field->start;
1496 }
1497 for (i = 0; i < n_elems; i++) {
1498 void *addr = base_addr + size * i;
1499
1500 if (field->flags & VMS_ARRAY_OF_POINTER) {
1501 addr = *(void **)addr;
1502 }
1503 if (field->flags & VMS_STRUCT) {
1504 vmstate_save_state(f, field->vmsd, addr);
1505 } else {
1506 field->info->put(f, addr, size);
1507 }
1508 }
1509 }
1510 field++;
1511 }
1512 vmstate_subsection_save(f, vmsd, opaque);
1513 }
1514
1515 static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id)
1516 {
1517 if (!se->vmsd) { /* Old style */
1518 return se->load_state(f, se->opaque, version_id);
1519 }
1520 return vmstate_load_state(f, se->vmsd, se->opaque, version_id);
1521 }
1522
1523 static void vmstate_save(QEMUFile *f, SaveStateEntry *se)
1524 {
1525 if (!se->vmsd) { /* Old style */
1526 se->save_state(f, se->opaque);
1527 return;
1528 }
1529 vmstate_save_state(f,se->vmsd, se->opaque);
1530 }
1531
1532 #define QEMU_VM_FILE_MAGIC 0x5145564d
1533 #define QEMU_VM_FILE_VERSION_COMPAT 0x00000002
1534 #define QEMU_VM_FILE_VERSION 0x00000003
1535
1536 #define QEMU_VM_EOF 0x00
1537 #define QEMU_VM_SECTION_START 0x01
1538 #define QEMU_VM_SECTION_PART 0x02
1539 #define QEMU_VM_SECTION_END 0x03
1540 #define QEMU_VM_SECTION_FULL 0x04
1541 #define QEMU_VM_SUBSECTION 0x05
1542
1543 bool qemu_savevm_state_blocked(Monitor *mon)
1544 {
1545 SaveStateEntry *se;
1546
1547 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1548 if (se->no_migrate) {
1549 monitor_printf(mon, "state blocked by non-migratable device '%s'\n",
1550 se->idstr);
1551 return true;
1552 }
1553 }
1554 return false;
1555 }
1556
1557 int qemu_savevm_state_begin(Monitor *mon, QEMUFile *f, int blk_enable,
1558 int shared)
1559 {
1560 SaveStateEntry *se;
1561 int ret;
1562
1563 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1564 if(se->set_params == NULL) {
1565 continue;
1566 }
1567 se->set_params(blk_enable, shared, se->opaque);
1568 }
1569
1570 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1571 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1572
1573 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1574 int len;
1575
1576 if (se->save_live_state == NULL)
1577 continue;
1578
1579 /* Section type */
1580 qemu_put_byte(f, QEMU_VM_SECTION_START);
1581 qemu_put_be32(f, se->section_id);
1582
1583 /* ID string */
1584 len = strlen(se->idstr);
1585 qemu_put_byte(f, len);
1586 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1587
1588 qemu_put_be32(f, se->instance_id);
1589 qemu_put_be32(f, se->version_id);
1590
1591 ret = se->save_live_state(mon, f, QEMU_VM_SECTION_START, se->opaque);
1592 if (ret < 0) {
1593 qemu_savevm_state_cancel(mon, f);
1594 return ret;
1595 }
1596 }
1597 ret = qemu_file_get_error(f);
1598 if (ret != 0) {
1599 qemu_savevm_state_cancel(mon, f);
1600 }
1601
1602 return ret;
1603
1604 }
1605
1606 /*
1607 * this function has three return values:
1608 * negative: there was one error, and we have -errno.
1609 * 0 : We haven't finished, caller have to go again
1610 * 1 : We have finished, we can go to complete phase
1611 */
1612 int qemu_savevm_state_iterate(Monitor *mon, QEMUFile *f)
1613 {
1614 SaveStateEntry *se;
1615 int ret = 1;
1616
1617 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1618 if (se->save_live_state == NULL)
1619 continue;
1620
1621 /* Section type */
1622 qemu_put_byte(f, QEMU_VM_SECTION_PART);
1623 qemu_put_be32(f, se->section_id);
1624
1625 ret = se->save_live_state(mon, f, QEMU_VM_SECTION_PART, se->opaque);
1626 if (ret <= 0) {
1627 /* Do not proceed to the next vmstate before this one reported
1628 completion of the current stage. This serializes the migration
1629 and reduces the probability that a faster changing state is
1630 synchronized over and over again. */
1631 break;
1632 }
1633 }
1634 if (ret != 0) {
1635 return ret;
1636 }
1637 ret = qemu_file_get_error(f);
1638 if (ret != 0) {
1639 qemu_savevm_state_cancel(mon, f);
1640 }
1641 return ret;
1642 }
1643
1644 int qemu_savevm_state_complete(Monitor *mon, QEMUFile *f)
1645 {
1646 SaveStateEntry *se;
1647 int ret;
1648
1649 cpu_synchronize_all_states();
1650
1651 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1652 if (se->save_live_state == NULL)
1653 continue;
1654
1655 /* Section type */
1656 qemu_put_byte(f, QEMU_VM_SECTION_END);
1657 qemu_put_be32(f, se->section_id);
1658
1659 ret = se->save_live_state(mon, f, QEMU_VM_SECTION_END, se->opaque);
1660 if (ret < 0) {
1661 return ret;
1662 }
1663 }
1664
1665 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1666 int len;
1667
1668 if (se->save_state == NULL && se->vmsd == NULL)
1669 continue;
1670
1671 /* Section type */
1672 qemu_put_byte(f, QEMU_VM_SECTION_FULL);
1673 qemu_put_be32(f, se->section_id);
1674
1675 /* ID string */
1676 len = strlen(se->idstr);
1677 qemu_put_byte(f, len);
1678 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1679
1680 qemu_put_be32(f, se->instance_id);
1681 qemu_put_be32(f, se->version_id);
1682
1683 vmstate_save(f, se);
1684 }
1685
1686 qemu_put_byte(f, QEMU_VM_EOF);
1687
1688 return qemu_file_get_error(f);
1689 }
1690
1691 void qemu_savevm_state_cancel(Monitor *mon, QEMUFile *f)
1692 {
1693 SaveStateEntry *se;
1694
1695 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1696 if (se->save_live_state) {
1697 se->save_live_state(mon, f, -1, se->opaque);
1698 }
1699 }
1700 }
1701
1702 static int qemu_savevm_state(Monitor *mon, QEMUFile *f)
1703 {
1704 int ret;
1705
1706 if (qemu_savevm_state_blocked(mon)) {
1707 ret = -EINVAL;
1708 goto out;
1709 }
1710
1711 ret = qemu_savevm_state_begin(mon, f, 0, 0);
1712 if (ret < 0)
1713 goto out;
1714
1715 do {
1716 ret = qemu_savevm_state_iterate(mon, f);
1717 if (ret < 0)
1718 goto out;
1719 } while (ret == 0);
1720
1721 ret = qemu_savevm_state_complete(mon, f);
1722
1723 out:
1724 if (ret == 0) {
1725 ret = qemu_file_get_error(f);
1726 }
1727
1728 return ret;
1729 }
1730
1731 static SaveStateEntry *find_se(const char *idstr, int instance_id)
1732 {
1733 SaveStateEntry *se;
1734
1735 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1736 if (!strcmp(se->idstr, idstr) &&
1737 (instance_id == se->instance_id ||
1738 instance_id == se->alias_id))
1739 return se;
1740 /* Migrating from an older version? */
1741 if (strstr(se->idstr, idstr) && se->compat) {
1742 if (!strcmp(se->compat->idstr, idstr) &&
1743 (instance_id == se->compat->instance_id ||
1744 instance_id == se->alias_id))
1745 return se;
1746 }
1747 }
1748 return NULL;
1749 }
1750
1751 static const VMStateDescription *vmstate_get_subsection(const VMStateSubsection *sub, char *idstr)
1752 {
1753 while(sub && sub->needed) {
1754 if (strcmp(idstr, sub->vmsd->name) == 0) {
1755 return sub->vmsd;
1756 }
1757 sub++;
1758 }
1759 return NULL;
1760 }
1761
1762 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
1763 void *opaque)
1764 {
1765 while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
1766 char idstr[256];
1767 int ret;
1768 uint8_t version_id, len, size;
1769 const VMStateDescription *sub_vmsd;
1770
1771 len = qemu_peek_byte(f, 1);
1772 if (len < strlen(vmsd->name) + 1) {
1773 /* subsection name has be be "section_name/a" */
1774 return 0;
1775 }
1776 size = qemu_peek_buffer(f, (uint8_t *)idstr, len, 2);
1777 if (size != len) {
1778 return 0;
1779 }
1780 idstr[size] = 0;
1781
1782 if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
1783 /* it don't have a valid subsection name */
1784 return 0;
1785 }
1786 sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
1787 if (sub_vmsd == NULL) {
1788 return -ENOENT;
1789 }
1790 qemu_file_skip(f, 1); /* subsection */
1791 qemu_file_skip(f, 1); /* len */
1792 qemu_file_skip(f, len); /* idstr */
1793 version_id = qemu_get_be32(f);
1794
1795 ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
1796 if (ret) {
1797 return ret;
1798 }
1799 }
1800 return 0;
1801 }
1802
1803 static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
1804 void *opaque)
1805 {
1806 const VMStateSubsection *sub = vmsd->subsections;
1807
1808 while (sub && sub->needed) {
1809 if (sub->needed(opaque)) {
1810 const VMStateDescription *vmsd = sub->vmsd;
1811 uint8_t len;
1812
1813 qemu_put_byte(f, QEMU_VM_SUBSECTION);
1814 len = strlen(vmsd->name);
1815 qemu_put_byte(f, len);
1816 qemu_put_buffer(f, (uint8_t *)vmsd->name, len);
1817 qemu_put_be32(f, vmsd->version_id);
1818 vmstate_save_state(f, vmsd, opaque);
1819 }
1820 sub++;
1821 }
1822 }
1823
1824 typedef struct LoadStateEntry {
1825 QLIST_ENTRY(LoadStateEntry) entry;
1826 SaveStateEntry *se;
1827 int section_id;
1828 int version_id;
1829 } LoadStateEntry;
1830
1831 int qemu_loadvm_state(QEMUFile *f)
1832 {
1833 QLIST_HEAD(, LoadStateEntry) loadvm_handlers =
1834 QLIST_HEAD_INITIALIZER(loadvm_handlers);
1835 LoadStateEntry *le, *new_le;
1836 uint8_t section_type;
1837 unsigned int v;
1838 int ret;
1839
1840 if (qemu_savevm_state_blocked(default_mon)) {
1841 return -EINVAL;
1842 }
1843
1844 v = qemu_get_be32(f);
1845 if (v != QEMU_VM_FILE_MAGIC)
1846 return -EINVAL;
1847
1848 v = qemu_get_be32(f);
1849 if (v == QEMU_VM_FILE_VERSION_COMPAT) {
1850 fprintf(stderr, "SaveVM v2 format is obsolete and don't work anymore\n");
1851 return -ENOTSUP;
1852 }
1853 if (v != QEMU_VM_FILE_VERSION)
1854 return -ENOTSUP;
1855
1856 while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
1857 uint32_t instance_id, version_id, section_id;
1858 SaveStateEntry *se;
1859 char idstr[257];
1860 int len;
1861
1862 switch (section_type) {
1863 case QEMU_VM_SECTION_START:
1864 case QEMU_VM_SECTION_FULL:
1865 /* Read section start */
1866 section_id = qemu_get_be32(f);
1867 len = qemu_get_byte(f);
1868 qemu_get_buffer(f, (uint8_t *)idstr, len);
1869 idstr[len] = 0;
1870 instance_id = qemu_get_be32(f);
1871 version_id = qemu_get_be32(f);
1872
1873 /* Find savevm section */
1874 se = find_se(idstr, instance_id);
1875 if (se == NULL) {
1876 fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
1877 ret = -EINVAL;
1878 goto out;
1879 }
1880
1881 /* Validate version */
1882 if (version_id > se->version_id) {
1883 fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
1884 version_id, idstr, se->version_id);
1885 ret = -EINVAL;
1886 goto out;
1887 }
1888
1889 /* Add entry */
1890 le = g_malloc0(sizeof(*le));
1891
1892 le->se = se;
1893 le->section_id = section_id;
1894 le->version_id = version_id;
1895 QLIST_INSERT_HEAD(&loadvm_handlers, le, entry);
1896
1897 ret = vmstate_load(f, le->se, le->version_id);
1898 if (ret < 0) {
1899 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
1900 instance_id, idstr);
1901 goto out;
1902 }
1903 break;
1904 case QEMU_VM_SECTION_PART:
1905 case QEMU_VM_SECTION_END:
1906 section_id = qemu_get_be32(f);
1907
1908 QLIST_FOREACH(le, &loadvm_handlers, entry) {
1909 if (le->section_id == section_id) {
1910 break;
1911 }
1912 }
1913 if (le == NULL) {
1914 fprintf(stderr, "Unknown savevm section %d\n", section_id);
1915 ret = -EINVAL;
1916 goto out;
1917 }
1918
1919 ret = vmstate_load(f, le->se, le->version_id);
1920 if (ret < 0) {
1921 fprintf(stderr, "qemu: warning: error while loading state section id %d\n",
1922 section_id);
1923 goto out;
1924 }
1925 break;
1926 default:
1927 fprintf(stderr, "Unknown savevm section type %d\n", section_type);
1928 ret = -EINVAL;
1929 goto out;
1930 }
1931 }
1932
1933 cpu_synchronize_all_post_init();
1934
1935 ret = 0;
1936
1937 out:
1938 QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
1939 QLIST_REMOVE(le, entry);
1940 g_free(le);
1941 }
1942
1943 if (ret == 0) {
1944 ret = qemu_file_get_error(f);
1945 }
1946
1947 return ret;
1948 }
1949
1950 static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
1951 const char *name)
1952 {
1953 QEMUSnapshotInfo *sn_tab, *sn;
1954 int nb_sns, i, ret;
1955
1956 ret = -ENOENT;
1957 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1958 if (nb_sns < 0)
1959 return ret;
1960 for(i = 0; i < nb_sns; i++) {
1961 sn = &sn_tab[i];
1962 if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
1963 *sn_info = *sn;
1964 ret = 0;
1965 break;
1966 }
1967 }
1968 g_free(sn_tab);
1969 return ret;
1970 }
1971
1972 /*
1973 * Deletes snapshots of a given name in all opened images.
1974 */
1975 static int del_existing_snapshots(Monitor *mon, const char *name)
1976 {
1977 BlockDriverState *bs;
1978 QEMUSnapshotInfo sn1, *snapshot = &sn1;
1979 int ret;
1980
1981 bs = NULL;
1982 while ((bs = bdrv_next(bs))) {
1983 if (bdrv_can_snapshot(bs) &&
1984 bdrv_snapshot_find(bs, snapshot, name) >= 0)
1985 {
1986 ret = bdrv_snapshot_delete(bs, name);
1987 if (ret < 0) {
1988 monitor_printf(mon,
1989 "Error while deleting snapshot on '%s'\n",
1990 bdrv_get_device_name(bs));
1991 return -1;
1992 }
1993 }
1994 }
1995
1996 return 0;
1997 }
1998
1999 void do_savevm(Monitor *mon, const QDict *qdict)
2000 {
2001 BlockDriverState *bs, *bs1;
2002 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
2003 int ret;
2004 QEMUFile *f;
2005 int saved_vm_running;
2006 uint64_t vm_state_size;
2007 #ifdef _WIN32
2008 struct _timeb tb;
2009 struct tm *ptm;
2010 #else
2011 struct timeval tv;
2012 struct tm tm;
2013 #endif
2014 const char *name = qdict_get_try_str(qdict, "name");
2015
2016 /* Verify if there is a device that doesn't support snapshots and is writable */
2017 bs = NULL;
2018 while ((bs = bdrv_next(bs))) {
2019
2020 if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2021 continue;
2022 }
2023
2024 if (!bdrv_can_snapshot(bs)) {
2025 monitor_printf(mon, "Device '%s' is writable but does not support snapshots.\n",
2026 bdrv_get_device_name(bs));
2027 return;
2028 }
2029 }
2030
2031 bs = bdrv_snapshots();
2032 if (!bs) {
2033 monitor_printf(mon, "No block device can accept snapshots\n");
2034 return;
2035 }
2036
2037 saved_vm_running = runstate_is_running();
2038 vm_stop(RUN_STATE_SAVE_VM);
2039
2040 memset(sn, 0, sizeof(*sn));
2041
2042 /* fill auxiliary fields */
2043 #ifdef _WIN32
2044 _ftime(&tb);
2045 sn->date_sec = tb.time;
2046 sn->date_nsec = tb.millitm * 1000000;
2047 #else
2048 gettimeofday(&tv, NULL);
2049 sn->date_sec = tv.tv_sec;
2050 sn->date_nsec = tv.tv_usec * 1000;
2051 #endif
2052 sn->vm_clock_nsec = qemu_get_clock_ns(vm_clock);
2053
2054 if (name) {
2055 ret = bdrv_snapshot_find(bs, old_sn, name);
2056 if (ret >= 0) {
2057 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
2058 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
2059 } else {
2060 pstrcpy(sn->name, sizeof(sn->name), name);
2061 }
2062 } else {
2063 #ifdef _WIN32
2064 ptm = localtime(&tb.time);
2065 strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", ptm);
2066 #else
2067 /* cast below needed for OpenBSD where tv_sec is still 'long' */
2068 localtime_r((const time_t *)&tv.tv_sec, &tm);
2069 strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
2070 #endif
2071 }
2072
2073 /* Delete old snapshots of the same name */
2074 if (name && del_existing_snapshots(mon, name) < 0) {
2075 goto the_end;
2076 }
2077
2078 /* save the VM state */
2079 f = qemu_fopen_bdrv(bs, 1);
2080 if (!f) {
2081 monitor_printf(mon, "Could not open VM state file\n");
2082 goto the_end;
2083 }
2084 ret = qemu_savevm_state(mon, f);
2085 vm_state_size = qemu_ftell(f);
2086 qemu_fclose(f);
2087 if (ret < 0) {
2088 monitor_printf(mon, "Error %d while writing VM\n", ret);
2089 goto the_end;
2090 }
2091
2092 /* create the snapshots */
2093
2094 bs1 = NULL;
2095 while ((bs1 = bdrv_next(bs1))) {
2096 if (bdrv_can_snapshot(bs1)) {
2097 /* Write VM state size only to the image that contains the state */
2098 sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
2099 ret = bdrv_snapshot_create(bs1, sn);
2100 if (ret < 0) {
2101 monitor_printf(mon, "Error while creating snapshot on '%s'\n",
2102 bdrv_get_device_name(bs1));
2103 }
2104 }
2105 }
2106
2107 the_end:
2108 if (saved_vm_running)
2109 vm_start();
2110 }
2111
2112 int load_vmstate(const char *name)
2113 {
2114 BlockDriverState *bs, *bs_vm_state;
2115 QEMUSnapshotInfo sn;
2116 QEMUFile *f;
2117 int ret;
2118
2119 bs_vm_state = bdrv_snapshots();
2120 if (!bs_vm_state) {
2121 error_report("No block device supports snapshots");
2122 return -ENOTSUP;
2123 }
2124
2125 /* Don't even try to load empty VM states */
2126 ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
2127 if (ret < 0) {
2128 return ret;
2129 } else if (sn.vm_state_size == 0) {
2130 error_report("This is a disk-only snapshot. Revert to it offline "
2131 "using qemu-img.");
2132 return -EINVAL;
2133 }
2134
2135 /* Verify if there is any device that doesn't support snapshots and is
2136 writable and check if the requested snapshot is available too. */
2137 bs = NULL;
2138 while ((bs = bdrv_next(bs))) {
2139
2140 if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2141 continue;
2142 }
2143
2144 if (!bdrv_can_snapshot(bs)) {
2145 error_report("Device '%s' is writable but does not support snapshots.",
2146 bdrv_get_device_name(bs));
2147 return -ENOTSUP;
2148 }
2149
2150 ret = bdrv_snapshot_find(bs, &sn, name);
2151 if (ret < 0) {
2152 error_report("Device '%s' does not have the requested snapshot '%s'",
2153 bdrv_get_device_name(bs), name);
2154 return ret;
2155 }
2156 }
2157
2158 /* Flush all IO requests so they don't interfere with the new state. */
2159 bdrv_drain_all();
2160
2161 bs = NULL;
2162 while ((bs = bdrv_next(bs))) {
2163 if (bdrv_can_snapshot(bs)) {
2164 ret = bdrv_snapshot_goto(bs, name);
2165 if (ret < 0) {
2166 error_report("Error %d while activating snapshot '%s' on '%s'",
2167 ret, name, bdrv_get_device_name(bs));
2168 return ret;
2169 }
2170 }
2171 }
2172
2173 /* restore the VM state */
2174 f = qemu_fopen_bdrv(bs_vm_state, 0);
2175 if (!f) {
2176 error_report("Could not open VM state file");
2177 return -EINVAL;
2178 }
2179
2180 qemu_system_reset(VMRESET_SILENT);
2181 ret = qemu_loadvm_state(f);
2182
2183 qemu_fclose(f);
2184 if (ret < 0) {
2185 error_report("Error %d while loading VM state", ret);
2186 return ret;
2187 }
2188
2189 return 0;
2190 }
2191
2192 void do_delvm(Monitor *mon, const QDict *qdict)
2193 {
2194 BlockDriverState *bs, *bs1;
2195 int ret;
2196 const char *name = qdict_get_str(qdict, "name");
2197
2198 bs = bdrv_snapshots();
2199 if (!bs) {
2200 monitor_printf(mon, "No block device supports snapshots\n");
2201 return;
2202 }
2203
2204 bs1 = NULL;
2205 while ((bs1 = bdrv_next(bs1))) {
2206 if (bdrv_can_snapshot(bs1)) {
2207 ret = bdrv_snapshot_delete(bs1, name);
2208 if (ret < 0) {
2209 if (ret == -ENOTSUP)
2210 monitor_printf(mon,
2211 "Snapshots not supported on device '%s'\n",
2212 bdrv_get_device_name(bs1));
2213 else
2214 monitor_printf(mon, "Error %d while deleting snapshot on "
2215 "'%s'\n", ret, bdrv_get_device_name(bs1));
2216 }
2217 }
2218 }
2219 }
2220
2221 void do_info_snapshots(Monitor *mon)
2222 {
2223 BlockDriverState *bs, *bs1;
2224 QEMUSnapshotInfo *sn_tab, *sn, s, *sn_info = &s;
2225 int nb_sns, i, ret, available;
2226 int total;
2227 int *available_snapshots;
2228 char buf[256];
2229
2230 bs = bdrv_snapshots();
2231 if (!bs) {
2232 monitor_printf(mon, "No available block device supports snapshots\n");
2233 return;
2234 }
2235
2236 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2237 if (nb_sns < 0) {
2238 monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
2239 return;
2240 }
2241
2242 if (nb_sns == 0) {
2243 monitor_printf(mon, "There is no snapshot available.\n");
2244 return;
2245 }
2246
2247 available_snapshots = g_malloc0(sizeof(int) * nb_sns);
2248 total = 0;
2249 for (i = 0; i < nb_sns; i++) {
2250 sn = &sn_tab[i];
2251 available = 1;
2252 bs1 = NULL;
2253
2254 while ((bs1 = bdrv_next(bs1))) {
2255 if (bdrv_can_snapshot(bs1) && bs1 != bs) {
2256 ret = bdrv_snapshot_find(bs1, sn_info, sn->id_str);
2257 if (ret < 0) {
2258 available = 0;
2259 break;
2260 }
2261 }
2262 }
2263
2264 if (available) {
2265 available_snapshots[total] = i;
2266 total++;
2267 }
2268 }
2269
2270 if (total > 0) {
2271 monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
2272 for (i = 0; i < total; i++) {
2273 sn = &sn_tab[available_snapshots[i]];
2274 monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
2275 }
2276 } else {
2277 monitor_printf(mon, "There is no suitable snapshot available\n");
2278 }
2279
2280 g_free(sn_tab);
2281 g_free(available_snapshots);
2282
2283 }
2284
2285 void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
2286 {
2287 qemu_ram_set_idstr(memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK,
2288 memory_region_name(mr), dev);
2289 }
2290
2291 void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev)
2292 {
2293 /* Nothing do to while the implementation is in RAMBlock */
2294 }
2295
2296 void vmstate_register_ram_global(MemoryRegion *mr)
2297 {
2298 vmstate_register_ram(mr, NULL);
2299 }