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