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