blob: 1d49fde68b484abd74d4c12d7cc570ad949ba5fa [file] [log] [blame]
aliguoria672b462008-11-11 21:33:36 +00001/*
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 */
aliguoria672b462008-11-11 21:33:36 +000024
blueswir1d40cdb12009-03-07 16:52:02 +000025#include "config-host.h"
blueswir1511d2b12009-03-07 15:32:56 +000026#include "qemu-common.h"
27#include "hw/hw.h"
Alex Williamson7685ee62010-06-25 11:09:14 -060028#include "hw/qdev.h"
Paolo Bonzini1422e322012-10-24 08:43:34 +020029#include "net/net.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010030#include "monitor/monitor.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010031#include "sysemu/sysemu.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010032#include "qemu/timer.h"
blueswir1511d2b12009-03-07 15:32:56 +000033#include "audio/audio.h"
Paolo Bonzinicaf71f82012-12-17 18:19:50 +010034#include "migration/migration.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010035#include "qemu/sockets.h"
36#include "qemu/queue.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010037#include "sysemu/cpus.h"
Paolo Bonzini022c62c2012-12-17 18:19:49 +010038#include "exec/memory.h"
Stefano Stabellinia7ae8352012-01-25 12:24:51 +000039#include "qmp-commands.h"
Juan Quintela517a13c2012-05-21 23:46:44 +020040#include "trace.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010041#include "qemu/bitops.h"
blueswir1511d2b12009-03-07 15:32:56 +000042
aliguoria672b462008-11-11 21:33:36 +000043#define SELF_ANNOUNCE_ROUNDS 5
aliguoria672b462008-11-11 21:33:36 +000044
Nolan18995b92009-10-15 16:53:55 -070045#ifndef ETH_P_RARP
Stefan Bergerf8778a72010-04-24 08:54:07 -040046#define ETH_P_RARP 0x8035
Nolan18995b92009-10-15 16:53:55 -070047#endif
48#define ARP_HTYPE_ETH 0x0001
49#define ARP_PTYPE_IP 0x0800
50#define ARP_OP_REQUEST_REV 0x3
51
52static int announce_self_create(uint8_t *buf,
aliguoria672b462008-11-11 21:33:36 +000053 uint8_t *mac_addr)
54{
Nolan18995b92009-10-15 16:53:55 -070055 /* 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 */
aliguoria672b462008-11-11 21:33:36 +000059
Nolan18995b92009-10-15 16:53:55 -070060 /* 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 */
aliguoria672b462008-11-11 21:33:36 +000070
Nolan18995b92009-10-15 16:53:55 -070071 /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
72 memset(buf + 42, 0x00, 18);
aliguoria672b462008-11-11 21:33:36 +000073
Nolan18995b92009-10-15 16:53:55 -070074 return 60; /* len (FCS will be added by hardware) */
aliguoria672b462008-11-11 21:33:36 +000075}
76
Mark McLoughlinf401ca22009-11-25 18:49:32 +000077static 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
Jason Wangb356f762013-01-30 19:12:22 +080084 qemu_send_packet_raw(qemu_get_queue(nic), buf, len);
Mark McLoughlinf401ca22009-11-25 18:49:32 +000085}
86
87
Gleb Natapoved8b3302009-05-21 17:17:44 +030088static void qemu_announce_self_once(void *opaque)
aliguoria672b462008-11-11 21:33:36 +000089{
Gleb Natapoved8b3302009-05-21 17:17:44 +030090 static int count = SELF_ANNOUNCE_ROUNDS;
91 QEMUTimer *timer = *(QEMUTimer **)opaque;
aliguoria672b462008-11-11 21:33:36 +000092
Mark McLoughlinf401ca22009-11-25 18:49:32 +000093 qemu_foreach_nic(qemu_announce_self_iter, NULL);
94
Nolan18995b92009-10-15 16:53:55 -070095 if (--count) {
96 /* delay 50ms, 150ms, 250ms, ... */
Paolo Bonzini7bd427d2011-03-11 16:47:48 +010097 qemu_mod_timer(timer, qemu_get_clock_ms(rt_clock) +
Nolan18995b92009-10-15 16:53:55 -070098 50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100);
Gleb Natapoved8b3302009-05-21 17:17:44 +030099 } else {
100 qemu_del_timer(timer);
101 qemu_free_timer(timer);
102 }
103}
104
105void qemu_announce_self(void)
106{
107 static QEMUTimer *timer;
Paolo Bonzini7bd427d2011-03-11 16:47:48 +0100108 timer = qemu_new_timer_ms(rt_clock, qemu_announce_self_once, &timer);
Gleb Natapoved8b3302009-05-21 17:17:44 +0300109 qemu_announce_self_once(&timer);
aliguoria672b462008-11-11 21:33:36 +0000110}
111
112/***********************************************************/
113/* savevm/loadvm support */
114
115#define IO_BUF_SIZE 32768
116
117struct QEMUFile {
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200118 const QEMUFileOps *ops;
aliguoria672b462008-11-11 21:33:36 +0000119 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
Juan Quintela3961b4d2011-10-05 01:05:21 +0200128 int last_error;
aliguoria672b462008-11-11 21:33:36 +0000129};
130
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200131typedef struct QEMUFileStdio
aliguoria672b462008-11-11 21:33:36 +0000132{
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200133 FILE *stdio_file;
aliguoria672b462008-11-11 21:33:36 +0000134 QEMUFile *file;
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200135} QEMUFileStdio;
aliguoria672b462008-11-11 21:33:36 +0000136
137typedef struct QEMUFileSocket
138{
139 int fd;
140 QEMUFile *file;
141} QEMUFileSocket;
142
Stefan Hajnoczid7cd3692013-02-11 17:01:45 +0100143typedef struct {
144 Coroutine *co;
145 int fd;
146} FDYieldUntilData;
147
148static 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 */
160static 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
Paolo Bonzini70eb6332012-08-08 10:20:18 +0200171static int socket_get_fd(void *opaque)
172{
173 QEMUFileSocket *s = opaque;
174
175 return s->fd;
176}
177
aliguoria672b462008-11-11 21:33:36 +0000178static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
179{
180 QEMUFileSocket *s = opaque;
181 ssize_t len;
182
Paolo Bonzini595ab6412012-08-07 11:07:59 +0200183 for (;;) {
Blue Swirl00aa0042011-07-23 20:04:29 +0000184 len = qemu_recv(s->fd, buf, size, 0);
Paolo Bonzini595ab6412012-08-07 11:07:59 +0200185 if (len != -1) {
186 break;
187 }
188 if (socket_error() == EAGAIN) {
Stefan Hajnoczid7cd3692013-02-11 17:01:45 +0100189 yield_until_fd_readable(s->fd);
Paolo Bonzini595ab6412012-08-07 11:07:59 +0200190 } else if (socket_error() != EINTR) {
191 break;
192 }
193 }
aliguoria672b462008-11-11 21:33:36 +0000194
Paolo Bonzini595ab6412012-08-07 11:07:59 +0200195 if (len == -1) {
aliguoria672b462008-11-11 21:33:36 +0000196 len = -socket_error();
Paolo Bonzini595ab6412012-08-07 11:07:59 +0200197 }
aliguoria672b462008-11-11 21:33:36 +0000198 return len;
199}
200
201static int socket_close(void *opaque)
202{
203 QEMUFileSocket *s = opaque;
Paolo Bonziniab52a822012-08-07 10:50:26 +0200204 closesocket(s->fd);
Anthony Liguori7267c092011-08-20 22:09:37 -0500205 g_free(s);
aliguoria672b462008-11-11 21:33:36 +0000206 return 0;
207}
208
Paolo Bonzini70eb6332012-08-08 10:20:18 +0200209static int stdio_get_fd(void *opaque)
210{
211 QEMUFileStdio *s = opaque;
212
213 return fileno(s->stdio_file);
214}
215
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200216static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
aliguoria672b462008-11-11 21:33:36 +0000217{
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200218 QEMUFileStdio *s = opaque;
219 return fwrite(buf, 1, size, s->stdio_file);
aliguoria672b462008-11-11 21:33:36 +0000220}
221
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200222static int stdio_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
aliguoria672b462008-11-11 21:33:36 +0000223{
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200224 QEMUFileStdio *s = opaque;
225 FILE *fp = s->stdio_file;
Uri Lublin8a67ec42009-06-08 19:27:21 +0300226 int bytes;
227
Paolo Bonzini595ab6412012-08-07 11:07:59 +0200228 for (;;) {
Uri Lublin8a67ec42009-06-08 19:27:21 +0300229 clearerr(fp);
230 bytes = fread(buf, 1, size, fp);
Paolo Bonzini595ab6412012-08-07 11:07:59 +0200231 if (bytes != 0 || !ferror(fp)) {
232 break;
233 }
234 if (errno == EAGAIN) {
Stefan Hajnoczid7cd3692013-02-11 17:01:45 +0100235 yield_until_fd_readable(fileno(fp));
Paolo Bonzini595ab6412012-08-07 11:07:59 +0200236 } else if (errno != EINTR) {
237 break;
238 }
239 }
Uri Lublin8a67ec42009-06-08 19:27:21 +0300240 return bytes;
aliguoria672b462008-11-11 21:33:36 +0000241}
242
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200243static int stdio_pclose(void *opaque)
aliguoria672b462008-11-11 21:33:36 +0000244{
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200245 QEMUFileStdio *s = opaque;
Anthony Liguori41ef56e2010-06-02 14:55:25 -0500246 int ret;
247 ret = pclose(s->stdio_file);
Eduardo Habkost26f1af02011-11-10 10:41:44 -0200248 if (ret == -1) {
249 ret = -errno;
250 }
Anthony Liguori7267c092011-08-20 22:09:37 -0500251 g_free(s);
Anthony Liguori41ef56e2010-06-02 14:55:25 -0500252 return ret;
aliguoria672b462008-11-11 21:33:36 +0000253}
254
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200255static int stdio_fclose(void *opaque)
aliguoria672b462008-11-11 21:33:36 +0000256{
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200257 QEMUFileStdio *s = opaque;
Eduardo Habkost0e286702011-11-10 10:41:45 -0200258 int ret = 0;
Paolo Bonzinice39ee32013-02-22 17:36:37 +0100259
260 if (s->file->ops->put_buffer) {
261 int fd = fileno(s->stdio_file);
262 struct stat st;
263
264 ret = fstat(fd, &st);
265 if (ret == 0 && S_ISREG(st.st_mode)) {
266 /*
267 * If the file handle is a regular file make sure the
268 * data is flushed to disk before signaling success.
269 */
270 ret = fsync(fd);
271 if (ret != 0) {
272 ret = -errno;
273 return ret;
274 }
275 }
276 }
Eduardo Habkost0e286702011-11-10 10:41:45 -0200277 if (fclose(s->stdio_file) == EOF) {
278 ret = -errno;
279 }
Anthony Liguori7267c092011-08-20 22:09:37 -0500280 g_free(s);
Eduardo Habkost0e286702011-11-10 10:41:45 -0200281 return ret;
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200282}
aliguoria672b462008-11-11 21:33:36 +0000283
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200284static const QEMUFileOps stdio_pipe_read_ops = {
Paolo Bonzini70eb6332012-08-08 10:20:18 +0200285 .get_fd = stdio_get_fd,
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200286 .get_buffer = stdio_get_buffer,
287 .close = stdio_pclose
288};
289
290static const QEMUFileOps stdio_pipe_write_ops = {
Paolo Bonzini70eb6332012-08-08 10:20:18 +0200291 .get_fd = stdio_get_fd,
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200292 .put_buffer = stdio_put_buffer,
293 .close = stdio_pclose
294};
295
Paolo Bonzini817b9ed2013-02-22 17:36:36 +0100296QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200297{
Paolo Bonzini817b9ed2013-02-22 17:36:36 +0100298 FILE *stdio_file;
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200299 QEMUFileStdio *s;
300
Paolo Bonzini817b9ed2013-02-22 17:36:36 +0100301 stdio_file = popen(command, mode);
302 if (stdio_file == NULL) {
303 return NULL;
304 }
305
306 if (mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
aliguoria672b462008-11-11 21:33:36 +0000307 fprintf(stderr, "qemu_popen: Argument validity check failed\n");
308 return NULL;
309 }
310
Anthony Liguori7267c092011-08-20 22:09:37 -0500311 s = g_malloc0(sizeof(QEMUFileStdio));
aliguoria672b462008-11-11 21:33:36 +0000312
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200313 s->stdio_file = stdio_file;
aliguoria672b462008-11-11 21:33:36 +0000314
315 if(mode[0] == 'r') {
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200316 s->file = qemu_fopen_ops(s, &stdio_pipe_read_ops);
aliguoria672b462008-11-11 21:33:36 +0000317 } else {
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200318 s->file = qemu_fopen_ops(s, &stdio_pipe_write_ops);
aliguoria672b462008-11-11 21:33:36 +0000319 }
aliguoria672b462008-11-11 21:33:36 +0000320 return s->file;
321}
322
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200323static const QEMUFileOps stdio_file_read_ops = {
Paolo Bonzini70eb6332012-08-08 10:20:18 +0200324 .get_fd = stdio_get_fd,
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200325 .get_buffer = stdio_get_buffer,
326 .close = stdio_fclose
327};
328
329static const QEMUFileOps stdio_file_write_ops = {
Paolo Bonzini70eb6332012-08-08 10:20:18 +0200330 .get_fd = stdio_get_fd,
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200331 .put_buffer = stdio_put_buffer,
332 .close = stdio_fclose
333};
334
Paolo Bonzini5ac1fad2009-08-18 15:56:25 +0200335QEMUFile *qemu_fdopen(int fd, const char *mode)
336{
337 QEMUFileStdio *s;
338
339 if (mode == NULL ||
340 (mode[0] != 'r' && mode[0] != 'w') ||
341 mode[1] != 'b' || mode[2] != 0) {
342 fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
343 return NULL;
344 }
345
Anthony Liguori7267c092011-08-20 22:09:37 -0500346 s = g_malloc0(sizeof(QEMUFileStdio));
Paolo Bonzini5ac1fad2009-08-18 15:56:25 +0200347 s->stdio_file = fdopen(fd, mode);
348 if (!s->stdio_file)
349 goto fail;
350
351 if(mode[0] == 'r') {
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200352 s->file = qemu_fopen_ops(s, &stdio_file_read_ops);
Paolo Bonzini5ac1fad2009-08-18 15:56:25 +0200353 } else {
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200354 s->file = qemu_fopen_ops(s, &stdio_file_write_ops);
Paolo Bonzini5ac1fad2009-08-18 15:56:25 +0200355 }
356 return s->file;
357
358fail:
Anthony Liguori7267c092011-08-20 22:09:37 -0500359 g_free(s);
Paolo Bonzini5ac1fad2009-08-18 15:56:25 +0200360 return NULL;
361}
362
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200363static const QEMUFileOps socket_read_ops = {
Paolo Bonzini70eb6332012-08-08 10:20:18 +0200364 .get_fd = socket_get_fd,
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200365 .get_buffer = socket_get_buffer,
366 .close = socket_close
367};
368
aliguoria672b462008-11-11 21:33:36 +0000369QEMUFile *qemu_fopen_socket(int fd)
370{
Anthony Liguori7267c092011-08-20 22:09:37 -0500371 QEMUFileSocket *s = g_malloc0(sizeof(QEMUFileSocket));
aliguoria672b462008-11-11 21:33:36 +0000372
aliguoria672b462008-11-11 21:33:36 +0000373 s->fd = fd;
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200374 s->file = qemu_fopen_ops(s, &socket_read_ops);
aliguoria672b462008-11-11 21:33:36 +0000375 return s->file;
376}
377
aliguoria672b462008-11-11 21:33:36 +0000378QEMUFile *qemu_fopen(const char *filename, const char *mode)
379{
380 QEMUFileStdio *s;
381
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200382 if (mode == NULL ||
383 (mode[0] != 'r' && mode[0] != 'w') ||
384 mode[1] != 'b' || mode[2] != 0) {
Blue Swirl090414a2010-03-13 11:36:09 +0000385 fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200386 return NULL;
387 }
388
Anthony Liguori7267c092011-08-20 22:09:37 -0500389 s = g_malloc0(sizeof(QEMUFileStdio));
aliguoria672b462008-11-11 21:33:36 +0000390
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200391 s->stdio_file = fopen(filename, mode);
392 if (!s->stdio_file)
aliguoria672b462008-11-11 21:33:36 +0000393 goto fail;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200394
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200395 if(mode[0] == 'w') {
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200396 s->file = qemu_fopen_ops(s, &stdio_file_write_ops);
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200397 } else {
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200398 s->file = qemu_fopen_ops(s, &stdio_file_read_ops);
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200399 }
400 return s->file;
aliguoria672b462008-11-11 21:33:36 +0000401fail:
Anthony Liguori7267c092011-08-20 22:09:37 -0500402 g_free(s);
aliguoria672b462008-11-11 21:33:36 +0000403 return NULL;
404}
405
aliguori178e08a2009-04-05 19:10:55 +0000406static int block_put_buffer(void *opaque, const uint8_t *buf,
aliguoria672b462008-11-11 21:33:36 +0000407 int64_t pos, int size)
408{
Christoph Hellwig45566e92009-07-10 23:11:57 +0200409 bdrv_save_vmstate(opaque, buf, pos, size);
aliguoria672b462008-11-11 21:33:36 +0000410 return size;
411}
412
aliguori178e08a2009-04-05 19:10:55 +0000413static int block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
aliguoria672b462008-11-11 21:33:36 +0000414{
Christoph Hellwig45566e92009-07-10 23:11:57 +0200415 return bdrv_load_vmstate(opaque, buf, pos, size);
aliguoria672b462008-11-11 21:33:36 +0000416}
417
418static int bdrv_fclose(void *opaque)
419{
Paolo Bonziniad492c92012-06-06 00:04:50 +0200420 return bdrv_flush(opaque);
aliguoria672b462008-11-11 21:33:36 +0000421}
422
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200423static const QEMUFileOps bdrv_read_ops = {
424 .get_buffer = block_get_buffer,
425 .close = bdrv_fclose
426};
427
428static const QEMUFileOps bdrv_write_ops = {
429 .put_buffer = block_put_buffer,
430 .close = bdrv_fclose
431};
432
Christoph Hellwig45566e92009-07-10 23:11:57 +0200433static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
aliguoria672b462008-11-11 21:33:36 +0000434{
aliguoria672b462008-11-11 21:33:36 +0000435 if (is_writable)
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200436 return qemu_fopen_ops(bs, &bdrv_write_ops);
437 return qemu_fopen_ops(bs, &bdrv_read_ops);
aliguoria672b462008-11-11 21:33:36 +0000438}
439
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200440QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)
aliguoria672b462008-11-11 21:33:36 +0000441{
442 QEMUFile *f;
443
Anthony Liguori7267c092011-08-20 22:09:37 -0500444 f = g_malloc0(sizeof(QEMUFile));
aliguoria672b462008-11-11 21:33:36 +0000445
446 f->opaque = opaque;
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200447 f->ops = ops;
aliguoria672b462008-11-11 21:33:36 +0000448 f->is_write = 0;
449
450 return f;
451}
452
Juan Quintela624b9cc2011-10-05 01:02:52 +0200453int qemu_file_get_error(QEMUFile *f)
aliguoria672b462008-11-11 21:33:36 +0000454{
Juan Quintela3961b4d2011-10-05 01:05:21 +0200455 return f->last_error;
aliguoria672b462008-11-11 21:33:36 +0000456}
457
Paolo Bonzini05f28b82013-02-22 17:36:31 +0100458static void qemu_file_set_error(QEMUFile *f, int ret)
aliguori4dabe242009-04-05 19:30:51 +0000459{
Juan Quintelaafe41932013-01-14 13:36:28 +0100460 if (f->last_error == 0) {
461 f->last_error = ret;
462 }
aliguori4dabe242009-04-05 19:30:51 +0000463}
464
Eduardo Habkostd82ca912011-11-10 10:41:43 -0200465/** Flushes QEMUFile buffer
466 *
Eduardo Habkostd82ca912011-11-10 10:41:43 -0200467 */
Paolo Bonzini05f28b82013-02-22 17:36:31 +0100468static void qemu_fflush(QEMUFile *f)
aliguoria672b462008-11-11 21:33:36 +0000469{
Juan Quintela7311bea2012-08-29 19:08:59 +0200470 int ret = 0;
471
Paolo Bonzini93bf2102013-02-22 17:36:12 +0100472 if (!f->ops->put_buffer) {
473 return;
474 }
aliguoria672b462008-11-11 21:33:36 +0000475 if (f->is_write && f->buf_index > 0) {
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200476 ret = f->ops->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
Juan Quintela7311bea2012-08-29 19:08:59 +0200477 if (ret >= 0) {
aliguoria672b462008-11-11 21:33:36 +0000478 f->buf_offset += f->buf_index;
Juan Quintela7311bea2012-08-29 19:08:59 +0200479 }
aliguoria672b462008-11-11 21:33:36 +0000480 f->buf_index = 0;
481 }
Paolo Bonzini93bf2102013-02-22 17:36:12 +0100482 if (ret < 0) {
483 qemu_file_set_error(f, ret);
484 }
aliguoria672b462008-11-11 21:33:36 +0000485}
486
487static void qemu_fill_buffer(QEMUFile *f)
488{
489 int len;
Juan Quintela0046c452011-09-30 19:28:45 +0200490 int pending;
aliguoria672b462008-11-11 21:33:36 +0000491
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200492 if (!f->ops->get_buffer)
aliguoria672b462008-11-11 21:33:36 +0000493 return;
494
495 if (f->is_write)
496 abort();
497
Juan Quintela0046c452011-09-30 19:28:45 +0200498 pending = f->buf_size - f->buf_index;
499 if (pending > 0) {
500 memmove(f->buf, f->buf + f->buf_index, pending);
501 }
502 f->buf_index = 0;
503 f->buf_size = pending;
504
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200505 len = f->ops->get_buffer(f->opaque, f->buf + pending, f->buf_offset,
Juan Quintela0046c452011-09-30 19:28:45 +0200506 IO_BUF_SIZE - pending);
aliguoria672b462008-11-11 21:33:36 +0000507 if (len > 0) {
Juan Quintela0046c452011-09-30 19:28:45 +0200508 f->buf_size += len;
aliguoria672b462008-11-11 21:33:36 +0000509 f->buf_offset += len;
Juan Quintelafa39a302011-10-25 19:18:58 +0200510 } else if (len == 0) {
Juan Quintela02c4a052012-08-29 19:36:26 +0200511 qemu_file_set_error(f, -EIO);
aliguoria672b462008-11-11 21:33:36 +0000512 } else if (len != -EAGAIN)
Eduardo Habkostc29110d2011-11-10 10:41:39 -0200513 qemu_file_set_error(f, len);
aliguoria672b462008-11-11 21:33:36 +0000514}
515
Paolo Bonzini70eb6332012-08-08 10:20:18 +0200516int qemu_get_fd(QEMUFile *f)
517{
518 if (f->ops->get_fd) {
519 return f->ops->get_fd(f->opaque);
520 }
521 return -1;
522}
523
Eduardo Habkostd82ca912011-11-10 10:41:43 -0200524/** Closes the file
525 *
526 * Returns negative error value if any error happened on previous operations or
527 * while closing the file. Returns 0 or positive number on success.
528 *
529 * The meaning of return value on success depends on the specific backend
530 * being used.
531 */
532int qemu_fclose(QEMUFile *f)
533{
Juan Quintela29eee862012-08-29 19:14:54 +0200534 int ret;
Paolo Bonzini93bf2102013-02-22 17:36:12 +0100535 qemu_fflush(f);
536 ret = qemu_file_get_error(f);
Juan Quintela7311bea2012-08-29 19:08:59 +0200537
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200538 if (f->ops->close) {
539 int ret2 = f->ops->close(f->opaque);
Juan Quintela29eee862012-08-29 19:14:54 +0200540 if (ret >= 0) {
541 ret = ret2;
542 }
Juan Quintela7311bea2012-08-29 19:08:59 +0200543 }
Eduardo Habkostd82ca912011-11-10 10:41:43 -0200544 /* If any error was spotted before closing, we should report it
545 * instead of the close() return value.
546 */
547 if (f->last_error) {
548 ret = f->last_error;
549 }
Anthony Liguori7267c092011-08-20 22:09:37 -0500550 g_free(f);
aliguoria672b462008-11-11 21:33:36 +0000551 return ret;
552}
553
aliguoria672b462008-11-11 21:33:36 +0000554void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
555{
556 int l;
557
Juan Quintelac10682c2012-08-29 19:43:39 +0200558 if (f->last_error) {
559 return;
560 }
561
562 if (f->is_write == 0 && f->buf_index > 0) {
aliguoria672b462008-11-11 21:33:36 +0000563 fprintf(stderr,
564 "Attempted to write to buffer while read buffer is not empty\n");
565 abort();
566 }
567
Juan Quintelac10682c2012-08-29 19:43:39 +0200568 while (size > 0) {
aliguoria672b462008-11-11 21:33:36 +0000569 l = IO_BUF_SIZE - f->buf_index;
570 if (l > size)
571 l = size;
572 memcpy(f->buf + f->buf_index, buf, l);
573 f->is_write = 1;
574 f->buf_index += l;
575 buf += l;
576 size -= l;
Juan Quintela7311bea2012-08-29 19:08:59 +0200577 if (f->buf_index >= IO_BUF_SIZE) {
Paolo Bonzini93bf2102013-02-22 17:36:12 +0100578 qemu_fflush(f);
579 if (qemu_file_get_error(f)) {
Juan Quintelac10682c2012-08-29 19:43:39 +0200580 break;
581 }
Juan Quintela7311bea2012-08-29 19:08:59 +0200582 }
aliguoria672b462008-11-11 21:33:36 +0000583 }
584}
585
586void qemu_put_byte(QEMUFile *f, int v)
587{
Juan Quintelac10682c2012-08-29 19:43:39 +0200588 if (f->last_error) {
589 return;
590 }
591
592 if (f->is_write == 0 && f->buf_index > 0) {
aliguoria672b462008-11-11 21:33:36 +0000593 fprintf(stderr,
594 "Attempted to write to buffer while read buffer is not empty\n");
595 abort();
596 }
597
598 f->buf[f->buf_index++] = v;
599 f->is_write = 1;
Juan Quintela7311bea2012-08-29 19:08:59 +0200600 if (f->buf_index >= IO_BUF_SIZE) {
Paolo Bonzini93bf2102013-02-22 17:36:12 +0100601 qemu_fflush(f);
Juan Quintela7311bea2012-08-29 19:08:59 +0200602 }
aliguoria672b462008-11-11 21:33:36 +0000603}
604
Juan Quintelac6380722011-10-04 15:28:31 +0200605static void qemu_file_skip(QEMUFile *f, int size)
aliguoria672b462008-11-11 21:33:36 +0000606{
Juan Quintelac6380722011-10-04 15:28:31 +0200607 if (f->buf_index + size <= f->buf_size) {
608 f->buf_index += size;
aliguoria672b462008-11-11 21:33:36 +0000609 }
aliguoria672b462008-11-11 21:33:36 +0000610}
611
Juan Quintelac6380722011-10-04 15:28:31 +0200612static int qemu_peek_buffer(QEMUFile *f, uint8_t *buf, int size, size_t offset)
Juan Quintela811814b2010-07-26 21:38:43 +0200613{
Juan Quintelac6380722011-10-04 15:28:31 +0200614 int pending;
615 int index;
Juan Quintela811814b2010-07-26 21:38:43 +0200616
Juan Quintelab9ce1452011-10-04 13:55:32 +0200617 if (f->is_write) {
Juan Quintela811814b2010-07-26 21:38:43 +0200618 abort();
Juan Quintela811814b2010-07-26 21:38:43 +0200619 }
Juan Quintela811814b2010-07-26 21:38:43 +0200620
Juan Quintelac6380722011-10-04 15:28:31 +0200621 index = f->buf_index + offset;
622 pending = f->buf_size - index;
623 if (pending < size) {
Juan Quintela811814b2010-07-26 21:38:43 +0200624 qemu_fill_buffer(f);
Juan Quintelac6380722011-10-04 15:28:31 +0200625 index = f->buf_index + offset;
626 pending = f->buf_size - index;
627 }
628
629 if (pending <= 0) {
630 return 0;
631 }
632 if (size > pending) {
633 size = pending;
634 }
635
636 memcpy(buf, f->buf + index, size);
637 return size;
638}
639
640int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
641{
642 int pending = size;
643 int done = 0;
644
645 while (pending > 0) {
646 int res;
647
648 res = qemu_peek_buffer(f, buf, pending, 0);
649 if (res == 0) {
650 return done;
651 }
652 qemu_file_skip(f, res);
653 buf += res;
654 pending -= res;
655 done += res;
656 }
657 return done;
658}
659
660static int qemu_peek_byte(QEMUFile *f, int offset)
661{
662 int index = f->buf_index + offset;
663
664 if (f->is_write) {
665 abort();
666 }
667
668 if (index >= f->buf_size) {
669 qemu_fill_buffer(f);
670 index = f->buf_index + offset;
671 if (index >= f->buf_size) {
Juan Quintela811814b2010-07-26 21:38:43 +0200672 return 0;
Juan Quintelab9ce1452011-10-04 13:55:32 +0200673 }
Juan Quintela811814b2010-07-26 21:38:43 +0200674 }
Juan Quintelac6380722011-10-04 15:28:31 +0200675 return f->buf[index];
Juan Quintela811814b2010-07-26 21:38:43 +0200676}
677
aliguoria672b462008-11-11 21:33:36 +0000678int qemu_get_byte(QEMUFile *f)
679{
Juan Quintela65f3bb32011-10-06 14:29:32 +0200680 int result;
aliguoria672b462008-11-11 21:33:36 +0000681
Juan Quintelac6380722011-10-04 15:28:31 +0200682 result = qemu_peek_byte(f, 0);
683 qemu_file_skip(f, 1);
Juan Quintela65f3bb32011-10-06 14:29:32 +0200684 return result;
aliguoria672b462008-11-11 21:33:36 +0000685}
686
Stefan Hajnocziad55ab42013-02-12 10:37:14 +0100687int64_t qemu_ftell(QEMUFile *f)
aliguoria672b462008-11-11 21:33:36 +0000688{
Stefan Hajnocziad55ab42013-02-12 10:37:14 +0100689 /* buf_offset excludes buffer for writing but includes it for reading */
690 if (f->is_write) {
691 return f->buf_offset + f->buf_index;
692 } else {
693 return f->buf_offset - f->buf_size + f->buf_index;
694 }
aliguoria672b462008-11-11 21:33:36 +0000695}
696
aliguoria672b462008-11-11 21:33:36 +0000697int qemu_file_rate_limit(QEMUFile *f)
698{
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200699 if (f->ops->rate_limit)
700 return f->ops->rate_limit(f->opaque);
aliguoria672b462008-11-11 21:33:36 +0000701
702 return 0;
703}
704
Michael S. Tsirkin3d002df2010-11-23 19:05:54 +0200705int64_t qemu_file_get_rate_limit(QEMUFile *f)
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200706{
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200707 if (f->ops->get_rate_limit)
708 return f->ops->get_rate_limit(f->opaque);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200709
710 return 0;
711}
712
Michael S. Tsirkin3d002df2010-11-23 19:05:54 +0200713int64_t qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate)
Glauber Costa19629532009-05-20 18:26:57 -0400714{
Glauber Costa0bb05ea2009-07-14 18:26:51 -0400715 /* any failed or completed migration keeps its state to allow probing of
716 * migration data, but has no associated file anymore */
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200717 if (f && f->ops->set_rate_limit)
718 return f->ops->set_rate_limit(f->opaque, new_rate);
Glauber Costa19629532009-05-20 18:26:57 -0400719
720 return 0;
721}
722
aliguoria672b462008-11-11 21:33:36 +0000723void qemu_put_be16(QEMUFile *f, unsigned int v)
724{
725 qemu_put_byte(f, v >> 8);
726 qemu_put_byte(f, v);
727}
728
729void qemu_put_be32(QEMUFile *f, unsigned int v)
730{
731 qemu_put_byte(f, v >> 24);
732 qemu_put_byte(f, v >> 16);
733 qemu_put_byte(f, v >> 8);
734 qemu_put_byte(f, v);
735}
736
737void qemu_put_be64(QEMUFile *f, uint64_t v)
738{
739 qemu_put_be32(f, v >> 32);
740 qemu_put_be32(f, v);
741}
742
743unsigned int qemu_get_be16(QEMUFile *f)
744{
745 unsigned int v;
746 v = qemu_get_byte(f) << 8;
747 v |= qemu_get_byte(f);
748 return v;
749}
750
751unsigned int qemu_get_be32(QEMUFile *f)
752{
753 unsigned int v;
754 v = qemu_get_byte(f) << 24;
755 v |= qemu_get_byte(f) << 16;
756 v |= qemu_get_byte(f) << 8;
757 v |= qemu_get_byte(f);
758 return v;
759}
760
761uint64_t qemu_get_be64(QEMUFile *f)
762{
763 uint64_t v;
764 v = (uint64_t)qemu_get_be32(f) << 32;
765 v |= qemu_get_be32(f);
766 return v;
767}
768
Paolo Bonzini2ff68d02011-09-12 16:21:44 +0200769
770/* timer */
771
772void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
773{
774 uint64_t expire_time;
775
776 expire_time = qemu_timer_expire_time_ns(ts);
777 qemu_put_be64(f, expire_time);
778}
779
780void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
781{
782 uint64_t expire_time;
783
784 expire_time = qemu_get_be64(f);
785 if (expire_time != -1) {
786 qemu_mod_timer_ns(ts, expire_time);
787 } else {
788 qemu_del_timer(ts);
789 }
790}
791
792
Gerd Hoffmanncdae5cf2010-11-01 15:51:54 +0100793/* bool */
794
795static int get_bool(QEMUFile *f, void *pv, size_t size)
796{
797 bool *v = pv;
798 *v = qemu_get_byte(f);
799 return 0;
800}
801
802static void put_bool(QEMUFile *f, void *pv, size_t size)
803{
804 bool *v = pv;
805 qemu_put_byte(f, *v);
806}
807
808const VMStateInfo vmstate_info_bool = {
809 .name = "bool",
810 .get = get_bool,
811 .put = put_bool,
812};
813
Juan Quintela9ed7d6a2009-08-20 19:42:25 +0200814/* 8 bit int */
815
816static int get_int8(QEMUFile *f, void *pv, size_t size)
817{
818 int8_t *v = pv;
819 qemu_get_s8s(f, v);
820 return 0;
821}
822
Juan Quintela84e2e3e2009-09-29 22:48:20 +0200823static void put_int8(QEMUFile *f, void *pv, size_t size)
Juan Quintela9ed7d6a2009-08-20 19:42:25 +0200824{
Juan Quintela84e2e3e2009-09-29 22:48:20 +0200825 int8_t *v = pv;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +0200826 qemu_put_s8s(f, v);
827}
828
829const VMStateInfo vmstate_info_int8 = {
830 .name = "int8",
831 .get = get_int8,
832 .put = put_int8,
833};
834
835/* 16 bit int */
836
837static int get_int16(QEMUFile *f, void *pv, size_t size)
838{
839 int16_t *v = pv;
840 qemu_get_sbe16s(f, v);
841 return 0;
842}
843
Juan Quintela84e2e3e2009-09-29 22:48:20 +0200844static void put_int16(QEMUFile *f, void *pv, size_t size)
Juan Quintela9ed7d6a2009-08-20 19:42:25 +0200845{
Juan Quintela84e2e3e2009-09-29 22:48:20 +0200846 int16_t *v = pv;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +0200847 qemu_put_sbe16s(f, v);
848}
849
850const VMStateInfo vmstate_info_int16 = {
851 .name = "int16",
852 .get = get_int16,
853 .put = put_int16,
854};
855
856/* 32 bit int */
857
858static int get_int32(QEMUFile *f, void *pv, size_t size)
859{
860 int32_t *v = pv;
861 qemu_get_sbe32s(f, v);
862 return 0;
863}
864
Juan Quintela84e2e3e2009-09-29 22:48:20 +0200865static void put_int32(QEMUFile *f, void *pv, size_t size)
Juan Quintela9ed7d6a2009-08-20 19:42:25 +0200866{
Juan Quintela84e2e3e2009-09-29 22:48:20 +0200867 int32_t *v = pv;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +0200868 qemu_put_sbe32s(f, v);
869}
870
871const VMStateInfo vmstate_info_int32 = {
872 .name = "int32",
873 .get = get_int32,
874 .put = put_int32,
875};
876
Juan Quintela82501662009-08-20 19:42:32 +0200877/* 32 bit int. See that the received value is the same than the one
878 in the field */
879
880static int get_int32_equal(QEMUFile *f, void *pv, size_t size)
881{
882 int32_t *v = pv;
883 int32_t v2;
884 qemu_get_sbe32s(f, &v2);
885
886 if (*v == v2)
887 return 0;
888 return -EINVAL;
889}
890
891const VMStateInfo vmstate_info_int32_equal = {
892 .name = "int32 equal",
893 .get = get_int32_equal,
894 .put = put_int32,
895};
896
Juan Quintela0a031e02009-08-20 19:42:37 +0200897/* 32 bit int. See that the received value is the less or the same
898 than the one in the field */
899
900static int get_int32_le(QEMUFile *f, void *pv, size_t size)
901{
902 int32_t *old = pv;
903 int32_t new;
904 qemu_get_sbe32s(f, &new);
905
906 if (*old <= new)
907 return 0;
908 return -EINVAL;
909}
910
911const VMStateInfo vmstate_info_int32_le = {
912 .name = "int32 equal",
913 .get = get_int32_le,
914 .put = put_int32,
915};
916
Juan Quintela9ed7d6a2009-08-20 19:42:25 +0200917/* 64 bit int */
918
919static int get_int64(QEMUFile *f, void *pv, size_t size)
920{
921 int64_t *v = pv;
922 qemu_get_sbe64s(f, v);
923 return 0;
924}
925
Juan Quintela84e2e3e2009-09-29 22:48:20 +0200926static void put_int64(QEMUFile *f, void *pv, size_t size)
Juan Quintela9ed7d6a2009-08-20 19:42:25 +0200927{
Juan Quintela84e2e3e2009-09-29 22:48:20 +0200928 int64_t *v = pv;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +0200929 qemu_put_sbe64s(f, v);
930}
931
932const VMStateInfo vmstate_info_int64 = {
933 .name = "int64",
934 .get = get_int64,
935 .put = put_int64,
936};
937
938/* 8 bit unsigned int */
939
940static int get_uint8(QEMUFile *f, void *pv, size_t size)
941{
942 uint8_t *v = pv;
943 qemu_get_8s(f, v);
944 return 0;
945}
946
Juan Quintela84e2e3e2009-09-29 22:48:20 +0200947static void put_uint8(QEMUFile *f, void *pv, size_t size)
Juan Quintela9ed7d6a2009-08-20 19:42:25 +0200948{
Juan Quintela84e2e3e2009-09-29 22:48:20 +0200949 uint8_t *v = pv;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +0200950 qemu_put_8s(f, v);
951}
952
953const VMStateInfo vmstate_info_uint8 = {
954 .name = "uint8",
955 .get = get_uint8,
956 .put = put_uint8,
957};
958
959/* 16 bit unsigned int */
960
961static int get_uint16(QEMUFile *f, void *pv, size_t size)
962{
963 uint16_t *v = pv;
964 qemu_get_be16s(f, v);
965 return 0;
966}
967
Juan Quintela84e2e3e2009-09-29 22:48:20 +0200968static void put_uint16(QEMUFile *f, void *pv, size_t size)
Juan Quintela9ed7d6a2009-08-20 19:42:25 +0200969{
Juan Quintela84e2e3e2009-09-29 22:48:20 +0200970 uint16_t *v = pv;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +0200971 qemu_put_be16s(f, v);
972}
973
974const VMStateInfo vmstate_info_uint16 = {
975 .name = "uint16",
976 .get = get_uint16,
977 .put = put_uint16,
978};
979
980/* 32 bit unsigned int */
981
982static int get_uint32(QEMUFile *f, void *pv, size_t size)
983{
984 uint32_t *v = pv;
985 qemu_get_be32s(f, v);
986 return 0;
987}
988
Juan Quintela84e2e3e2009-09-29 22:48:20 +0200989static void put_uint32(QEMUFile *f, void *pv, size_t size)
Juan Quintela9ed7d6a2009-08-20 19:42:25 +0200990{
Juan Quintela84e2e3e2009-09-29 22:48:20 +0200991 uint32_t *v = pv;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +0200992 qemu_put_be32s(f, v);
993}
994
995const VMStateInfo vmstate_info_uint32 = {
996 .name = "uint32",
997 .get = get_uint32,
998 .put = put_uint32,
999};
1000
Juan Quintela9122a8f2011-03-10 12:33:48 +01001001/* 32 bit uint. See that the received value is the same than the one
1002 in the field */
1003
1004static int get_uint32_equal(QEMUFile *f, void *pv, size_t size)
1005{
1006 uint32_t *v = pv;
1007 uint32_t v2;
1008 qemu_get_be32s(f, &v2);
1009
1010 if (*v == v2) {
1011 return 0;
1012 }
1013 return -EINVAL;
1014}
1015
1016const VMStateInfo vmstate_info_uint32_equal = {
1017 .name = "uint32 equal",
1018 .get = get_uint32_equal,
1019 .put = put_uint32,
1020};
1021
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001022/* 64 bit unsigned int */
1023
1024static int get_uint64(QEMUFile *f, void *pv, size_t size)
1025{
1026 uint64_t *v = pv;
1027 qemu_get_be64s(f, v);
1028 return 0;
1029}
1030
Juan Quintela84e2e3e2009-09-29 22:48:20 +02001031static void put_uint64(QEMUFile *f, void *pv, size_t size)
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001032{
Juan Quintela84e2e3e2009-09-29 22:48:20 +02001033 uint64_t *v = pv;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001034 qemu_put_be64s(f, v);
1035}
1036
1037const VMStateInfo vmstate_info_uint64 = {
1038 .name = "uint64",
1039 .get = get_uint64,
1040 .put = put_uint64,
1041};
1042
Juan Quintela80cd83e2009-09-10 03:04:36 +02001043/* 8 bit int. See that the received value is the same than the one
1044 in the field */
1045
1046static int get_uint8_equal(QEMUFile *f, void *pv, size_t size)
1047{
1048 uint8_t *v = pv;
1049 uint8_t v2;
1050 qemu_get_8s(f, &v2);
1051
1052 if (*v == v2)
1053 return 0;
1054 return -EINVAL;
1055}
1056
1057const VMStateInfo vmstate_info_uint8_equal = {
Juan Quintelaaa1cce62009-10-15 19:16:06 +02001058 .name = "uint8 equal",
Juan Quintela80cd83e2009-09-10 03:04:36 +02001059 .get = get_uint8_equal,
1060 .put = put_uint8,
1061};
1062
Juan Quinteladc3b83a2009-10-15 23:16:13 +02001063/* 16 bit unsigned int int. See that the received value is the same than the one
1064 in the field */
1065
1066static int get_uint16_equal(QEMUFile *f, void *pv, size_t size)
1067{
1068 uint16_t *v = pv;
1069 uint16_t v2;
1070 qemu_get_be16s(f, &v2);
1071
1072 if (*v == v2)
1073 return 0;
1074 return -EINVAL;
1075}
1076
1077const VMStateInfo vmstate_info_uint16_equal = {
1078 .name = "uint16 equal",
1079 .get = get_uint16_equal,
1080 .put = put_uint16,
1081};
1082
Juan Quinteladde04632009-08-20 19:42:26 +02001083/* timers */
1084
1085static int get_timer(QEMUFile *f, void *pv, size_t size)
1086{
1087 QEMUTimer *v = pv;
1088 qemu_get_timer(f, v);
1089 return 0;
1090}
1091
Juan Quintela84e2e3e2009-09-29 22:48:20 +02001092static void put_timer(QEMUFile *f, void *pv, size_t size)
Juan Quinteladde04632009-08-20 19:42:26 +02001093{
Juan Quintela84e2e3e2009-09-29 22:48:20 +02001094 QEMUTimer *v = pv;
Juan Quinteladde04632009-08-20 19:42:26 +02001095 qemu_put_timer(f, v);
1096}
1097
1098const VMStateInfo vmstate_info_timer = {
1099 .name = "timer",
1100 .get = get_timer,
1101 .put = put_timer,
1102};
1103
Juan Quintela6f67c502009-08-20 19:42:35 +02001104/* uint8_t buffers */
1105
1106static int get_buffer(QEMUFile *f, void *pv, size_t size)
1107{
1108 uint8_t *v = pv;
1109 qemu_get_buffer(f, v, size);
1110 return 0;
1111}
1112
Juan Quintela84e2e3e2009-09-29 22:48:20 +02001113static void put_buffer(QEMUFile *f, void *pv, size_t size)
Juan Quintela6f67c502009-08-20 19:42:35 +02001114{
Juan Quintela84e2e3e2009-09-29 22:48:20 +02001115 uint8_t *v = pv;
Juan Quintela6f67c502009-08-20 19:42:35 +02001116 qemu_put_buffer(f, v, size);
1117}
1118
1119const VMStateInfo vmstate_info_buffer = {
1120 .name = "buffer",
1121 .get = get_buffer,
1122 .put = put_buffer,
1123};
1124
Juan Quintela76507c72009-10-19 15:46:28 +02001125/* unused buffers: space that was used for some fields that are
Stefan Weil61cc8702011-04-13 22:45:22 +02001126 not useful anymore */
Juan Quintela76507c72009-10-19 15:46:28 +02001127
1128static int get_unused_buffer(QEMUFile *f, void *pv, size_t size)
1129{
Jan Kiszka21174c32009-12-02 12:36:35 +01001130 uint8_t buf[1024];
1131 int block_len;
1132
1133 while (size > 0) {
1134 block_len = MIN(sizeof(buf), size);
1135 size -= block_len;
1136 qemu_get_buffer(f, buf, block_len);
1137 }
1138 return 0;
Juan Quintela76507c72009-10-19 15:46:28 +02001139}
1140
1141static void put_unused_buffer(QEMUFile *f, void *pv, size_t size)
1142{
Jan Kiszka21174c32009-12-02 12:36:35 +01001143 static const uint8_t buf[1024];
1144 int block_len;
1145
1146 while (size > 0) {
1147 block_len = MIN(sizeof(buf), size);
1148 size -= block_len;
1149 qemu_put_buffer(f, buf, block_len);
1150 }
Juan Quintela76507c72009-10-19 15:46:28 +02001151}
1152
1153const VMStateInfo vmstate_info_unused_buffer = {
1154 .name = "unused_buffer",
1155 .get = get_unused_buffer,
1156 .put = put_unused_buffer,
1157};
1158
Peter Maydell08e99e22012-10-30 07:45:12 +00001159/* bitmaps (as defined by bitmap.h). Note that size here is the size
1160 * of the bitmap in bits. The on-the-wire format of a bitmap is 64
1161 * bit words with the bits in big endian order. The in-memory format
1162 * is an array of 'unsigned long', which may be either 32 or 64 bits.
1163 */
1164/* This is the number of 64 bit words sent over the wire */
1165#define BITS_TO_U64S(nr) DIV_ROUND_UP(nr, 64)
1166static int get_bitmap(QEMUFile *f, void *pv, size_t size)
1167{
1168 unsigned long *bmp = pv;
1169 int i, idx = 0;
1170 for (i = 0; i < BITS_TO_U64S(size); i++) {
1171 uint64_t w = qemu_get_be64(f);
1172 bmp[idx++] = w;
1173 if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
1174 bmp[idx++] = w >> 32;
1175 }
1176 }
1177 return 0;
1178}
1179
1180static void put_bitmap(QEMUFile *f, void *pv, size_t size)
1181{
1182 unsigned long *bmp = pv;
1183 int i, idx = 0;
1184 for (i = 0; i < BITS_TO_U64S(size); i++) {
1185 uint64_t w = bmp[idx++];
1186 if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
1187 w |= ((uint64_t)bmp[idx++]) << 32;
1188 }
1189 qemu_put_be64(f, w);
1190 }
1191}
1192
1193const VMStateInfo vmstate_info_bitmap = {
1194 .name = "bitmap",
1195 .get = get_bitmap,
1196 .put = put_bitmap,
1197};
1198
Alex Williamson7685ee62010-06-25 11:09:14 -06001199typedef struct CompatEntry {
1200 char idstr[256];
1201 int instance_id;
1202} CompatEntry;
1203
aliguoria672b462008-11-11 21:33:36 +00001204typedef struct SaveStateEntry {
Blue Swirl72cf2d42009-09-12 07:36:22 +00001205 QTAILQ_ENTRY(SaveStateEntry) entry;
aliguoria672b462008-11-11 21:33:36 +00001206 char idstr[256];
1207 int instance_id;
Jan Kiszka4d2ffa02010-05-15 13:32:40 +02001208 int alias_id;
aliguoria672b462008-11-11 21:33:36 +00001209 int version_id;
1210 int section_id;
Juan Quintela22ea40f2012-06-26 17:19:10 +02001211 SaveVMHandlers *ops;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001212 const VMStateDescription *vmsd;
aliguoria672b462008-11-11 21:33:36 +00001213 void *opaque;
Alex Williamson7685ee62010-06-25 11:09:14 -06001214 CompatEntry *compat;
Cam Macdonell24312962010-07-26 18:11:00 -06001215 int no_migrate;
Stefano Stabellinia7ae8352012-01-25 12:24:51 +00001216 int is_ram;
aliguoria672b462008-11-11 21:33:36 +00001217} SaveStateEntry;
1218
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +02001219
Blue Swirl72cf2d42009-09-12 07:36:22 +00001220static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers =
1221 QTAILQ_HEAD_INITIALIZER(savevm_handlers);
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001222static int global_section_id;
aliguoria672b462008-11-11 21:33:36 +00001223
Juan Quintela8718e992009-09-01 02:12:31 +02001224static int calculate_new_instance_id(const char *idstr)
1225{
1226 SaveStateEntry *se;
1227 int instance_id = 0;
1228
Blue Swirl72cf2d42009-09-12 07:36:22 +00001229 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
Juan Quintela8718e992009-09-01 02:12:31 +02001230 if (strcmp(idstr, se->idstr) == 0
1231 && instance_id <= se->instance_id) {
1232 instance_id = se->instance_id + 1;
1233 }
1234 }
1235 return instance_id;
1236}
1237
Alex Williamson7685ee62010-06-25 11:09:14 -06001238static int calculate_compat_instance_id(const char *idstr)
1239{
1240 SaveStateEntry *se;
1241 int instance_id = 0;
1242
1243 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1244 if (!se->compat)
1245 continue;
1246
1247 if (strcmp(idstr, se->compat->idstr) == 0
1248 && instance_id <= se->compat->instance_id) {
1249 instance_id = se->compat->instance_id + 1;
1250 }
1251 }
1252 return instance_id;
1253}
1254
aliguoria672b462008-11-11 21:33:36 +00001255/* TODO: Individual devices generally have very little idea about the rest
1256 of the system, so instance_id should be removed/replaced.
1257 Meanwhile pass -1 as instance_id if you do not already have a clearly
1258 distinguishing id for all instances of your device class. */
Alex Williamson0be71e32010-06-25 11:09:07 -06001259int register_savevm_live(DeviceState *dev,
1260 const char *idstr,
aliguoria672b462008-11-11 21:33:36 +00001261 int instance_id,
1262 int version_id,
Juan Quintela7908c782012-06-26 18:46:10 +02001263 SaveVMHandlers *ops,
aliguoria672b462008-11-11 21:33:36 +00001264 void *opaque)
1265{
Juan Quintela8718e992009-09-01 02:12:31 +02001266 SaveStateEntry *se;
aliguoria672b462008-11-11 21:33:36 +00001267
Anthony Liguori7267c092011-08-20 22:09:37 -05001268 se = g_malloc0(sizeof(SaveStateEntry));
aliguoria672b462008-11-11 21:33:36 +00001269 se->version_id = version_id;
1270 se->section_id = global_section_id++;
Juan Quintela7908c782012-06-26 18:46:10 +02001271 se->ops = ops;
aliguoria672b462008-11-11 21:33:36 +00001272 se->opaque = opaque;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001273 se->vmsd = NULL;
Cam Macdonell24312962010-07-26 18:11:00 -06001274 se->no_migrate = 0;
Stefano Stabellinia7ae8352012-01-25 12:24:51 +00001275 /* if this is a live_savem then set is_ram */
Juan Quintela16310a32012-06-28 15:31:37 +02001276 if (ops->save_live_setup != NULL) {
Stefano Stabellinia7ae8352012-01-25 12:24:51 +00001277 se->is_ram = 1;
1278 }
aliguoria672b462008-11-11 21:33:36 +00001279
Anthony Liguori09e5ab62012-02-03 12:28:43 -06001280 if (dev) {
1281 char *id = qdev_get_dev_path(dev);
Alex Williamson7685ee62010-06-25 11:09:14 -06001282 if (id) {
1283 pstrcpy(se->idstr, sizeof(se->idstr), id);
1284 pstrcat(se->idstr, sizeof(se->idstr), "/");
Anthony Liguori7267c092011-08-20 22:09:37 -05001285 g_free(id);
Alex Williamson7685ee62010-06-25 11:09:14 -06001286
Anthony Liguori7267c092011-08-20 22:09:37 -05001287 se->compat = g_malloc0(sizeof(CompatEntry));
Alex Williamson7685ee62010-06-25 11:09:14 -06001288 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr);
1289 se->compat->instance_id = instance_id == -1 ?
1290 calculate_compat_instance_id(idstr) : instance_id;
1291 instance_id = -1;
1292 }
1293 }
1294 pstrcat(se->idstr, sizeof(se->idstr), idstr);
1295
Juan Quintela8718e992009-09-01 02:12:31 +02001296 if (instance_id == -1) {
Alex Williamson7685ee62010-06-25 11:09:14 -06001297 se->instance_id = calculate_new_instance_id(se->idstr);
Juan Quintela8718e992009-09-01 02:12:31 +02001298 } else {
1299 se->instance_id = instance_id;
aliguoria672b462008-11-11 21:33:36 +00001300 }
Alex Williamson7685ee62010-06-25 11:09:14 -06001301 assert(!se->compat || se->instance_id == 0);
Juan Quintela8718e992009-09-01 02:12:31 +02001302 /* add at the end of list */
Blue Swirl72cf2d42009-09-12 07:36:22 +00001303 QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
aliguoria672b462008-11-11 21:33:36 +00001304 return 0;
1305}
1306
Alex Williamson0be71e32010-06-25 11:09:07 -06001307int register_savevm(DeviceState *dev,
1308 const char *idstr,
aliguoria672b462008-11-11 21:33:36 +00001309 int instance_id,
1310 int version_id,
1311 SaveStateHandler *save_state,
1312 LoadStateHandler *load_state,
1313 void *opaque)
1314{
Juan Quintela7908c782012-06-26 18:46:10 +02001315 SaveVMHandlers *ops = g_malloc0(sizeof(SaveVMHandlers));
1316 ops->save_state = save_state;
1317 ops->load_state = load_state;
Alex Williamson0be71e32010-06-25 11:09:07 -06001318 return register_savevm_live(dev, idstr, instance_id, version_id,
Juan Quintela7908c782012-06-26 18:46:10 +02001319 ops, opaque);
aliguoria672b462008-11-11 21:33:36 +00001320}
1321
Alex Williamson0be71e32010-06-25 11:09:07 -06001322void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
aliguori41bd13a2009-04-17 17:10:59 +00001323{
Juan Quintela8718e992009-09-01 02:12:31 +02001324 SaveStateEntry *se, *new_se;
Alex Williamson7685ee62010-06-25 11:09:14 -06001325 char id[256] = "";
1326
Anthony Liguori09e5ab62012-02-03 12:28:43 -06001327 if (dev) {
1328 char *path = qdev_get_dev_path(dev);
Alex Williamson7685ee62010-06-25 11:09:14 -06001329 if (path) {
1330 pstrcpy(id, sizeof(id), path);
1331 pstrcat(id, sizeof(id), "/");
Anthony Liguori7267c092011-08-20 22:09:37 -05001332 g_free(path);
Alex Williamson7685ee62010-06-25 11:09:14 -06001333 }
1334 }
1335 pstrcat(id, sizeof(id), idstr);
aliguori41bd13a2009-04-17 17:10:59 +00001336
Blue Swirl72cf2d42009-09-12 07:36:22 +00001337 QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
Alex Williamson7685ee62010-06-25 11:09:14 -06001338 if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
Blue Swirl72cf2d42009-09-12 07:36:22 +00001339 QTAILQ_REMOVE(&savevm_handlers, se, entry);
Alex Williamson69e58af2010-07-21 08:35:31 -06001340 if (se->compat) {
Anthony Liguori7267c092011-08-20 22:09:37 -05001341 g_free(se->compat);
Alex Williamson69e58af2010-07-21 08:35:31 -06001342 }
Juan Quintela22ea40f2012-06-26 17:19:10 +02001343 g_free(se->ops);
Anthony Liguori7267c092011-08-20 22:09:37 -05001344 g_free(se);
aliguori41bd13a2009-04-17 17:10:59 +00001345 }
aliguori41bd13a2009-04-17 17:10:59 +00001346 }
1347}
1348
Alex Williamson0be71e32010-06-25 11:09:07 -06001349int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
Jan Kiszka4d2ffa02010-05-15 13:32:40 +02001350 const VMStateDescription *vmsd,
1351 void *opaque, int alias_id,
1352 int required_for_version)
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001353{
Juan Quintela8718e992009-09-01 02:12:31 +02001354 SaveStateEntry *se;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001355
Jan Kiszka4d2ffa02010-05-15 13:32:40 +02001356 /* If this triggers, alias support can be dropped for the vmsd. */
1357 assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id);
1358
Anthony Liguori7267c092011-08-20 22:09:37 -05001359 se = g_malloc0(sizeof(SaveStateEntry));
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001360 se->version_id = vmsd->version_id;
1361 se->section_id = global_section_id++;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001362 se->opaque = opaque;
1363 se->vmsd = vmsd;
Jan Kiszka4d2ffa02010-05-15 13:32:40 +02001364 se->alias_id = alias_id;
Gerd Hoffmann2837c8e2011-07-08 10:44:35 +02001365 se->no_migrate = vmsd->unmigratable;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001366
Anthony Liguori09e5ab62012-02-03 12:28:43 -06001367 if (dev) {
1368 char *id = qdev_get_dev_path(dev);
Alex Williamson7685ee62010-06-25 11:09:14 -06001369 if (id) {
1370 pstrcpy(se->idstr, sizeof(se->idstr), id);
1371 pstrcat(se->idstr, sizeof(se->idstr), "/");
Anthony Liguori7267c092011-08-20 22:09:37 -05001372 g_free(id);
Alex Williamson7685ee62010-06-25 11:09:14 -06001373
Anthony Liguori7267c092011-08-20 22:09:37 -05001374 se->compat = g_malloc0(sizeof(CompatEntry));
Alex Williamson7685ee62010-06-25 11:09:14 -06001375 pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
1376 se->compat->instance_id = instance_id == -1 ?
1377 calculate_compat_instance_id(vmsd->name) : instance_id;
1378 instance_id = -1;
1379 }
1380 }
1381 pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);
1382
Juan Quintela8718e992009-09-01 02:12:31 +02001383 if (instance_id == -1) {
Alex Williamson7685ee62010-06-25 11:09:14 -06001384 se->instance_id = calculate_new_instance_id(se->idstr);
Juan Quintela8718e992009-09-01 02:12:31 +02001385 } else {
1386 se->instance_id = instance_id;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001387 }
Alex Williamson7685ee62010-06-25 11:09:14 -06001388 assert(!se->compat || se->instance_id == 0);
Juan Quintela8718e992009-09-01 02:12:31 +02001389 /* add at the end of list */
Blue Swirl72cf2d42009-09-12 07:36:22 +00001390 QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001391 return 0;
1392}
1393
Alex Williamson0be71e32010-06-25 11:09:07 -06001394int vmstate_register(DeviceState *dev, int instance_id,
1395 const VMStateDescription *vmsd, void *opaque)
Jan Kiszka4d2ffa02010-05-15 13:32:40 +02001396{
Alex Williamson0be71e32010-06-25 11:09:07 -06001397 return vmstate_register_with_alias_id(dev, instance_id, vmsd,
1398 opaque, -1, 0);
Jan Kiszka4d2ffa02010-05-15 13:32:40 +02001399}
1400
Alex Williamson0be71e32010-06-25 11:09:07 -06001401void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
1402 void *opaque)
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001403{
Juan Quintela1eb75382009-09-10 03:04:29 +02001404 SaveStateEntry *se, *new_se;
1405
Blue Swirl72cf2d42009-09-12 07:36:22 +00001406 QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
Juan Quintela1eb75382009-09-10 03:04:29 +02001407 if (se->vmsd == vmsd && se->opaque == opaque) {
Blue Swirl72cf2d42009-09-12 07:36:22 +00001408 QTAILQ_REMOVE(&savevm_handlers, se, entry);
Alex Williamson69e58af2010-07-21 08:35:31 -06001409 if (se->compat) {
Anthony Liguori7267c092011-08-20 22:09:37 -05001410 g_free(se->compat);
Alex Williamson69e58af2010-07-21 08:35:31 -06001411 }
Anthony Liguori7267c092011-08-20 22:09:37 -05001412 g_free(se);
Juan Quintela1eb75382009-09-10 03:04:29 +02001413 }
1414 }
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001415}
1416
Juan Quintela811814b2010-07-26 21:38:43 +02001417static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
1418 void *opaque);
1419static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
1420 void *opaque);
1421
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001422int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
1423 void *opaque, int version_id)
1424{
1425 VMStateField *field = vmsd->fields;
Juan Quintela811814b2010-07-26 21:38:43 +02001426 int ret;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001427
1428 if (version_id > vmsd->version_id) {
1429 return -EINVAL;
1430 }
1431 if (version_id < vmsd->minimum_version_id_old) {
1432 return -EINVAL;
1433 }
1434 if (version_id < vmsd->minimum_version_id) {
1435 return vmsd->load_state_old(f, opaque, version_id);
1436 }
Juan Quintelafd4d52d2009-09-10 03:04:31 +02001437 if (vmsd->pre_load) {
1438 int ret = vmsd->pre_load(opaque);
1439 if (ret)
1440 return ret;
1441 }
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001442 while(field->name) {
Juan Quintelaf11f6a52009-09-29 22:49:07 +02001443 if ((field->field_exists &&
1444 field->field_exists(opaque, version_id)) ||
1445 (!field->field_exists &&
1446 field->version_id <= version_id)) {
Juan Quintelaf752a6a2009-08-20 19:42:27 +02001447 void *base_addr = opaque + field->offset;
Juan Quintela811814b2010-07-26 21:38:43 +02001448 int i, n_elems = 1;
Juan Quintelae61a1e02009-12-02 12:36:38 +01001449 int size = field->size;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001450
Juan Quintelae61a1e02009-12-02 12:36:38 +01001451 if (field->flags & VMS_VBUFFER) {
1452 size = *(int32_t *)(opaque+field->size_offset);
Juan Quintela33599e22009-12-02 12:36:43 +01001453 if (field->flags & VMS_MULTIPLY) {
1454 size *= field->size;
1455 }
Juan Quintelae61a1e02009-12-02 12:36:38 +01001456 }
Juan Quintelaf752a6a2009-08-20 19:42:27 +02001457 if (field->flags & VMS_ARRAY) {
1458 n_elems = field->num;
Juan Quintelad6698282009-10-16 11:27:17 +02001459 } else if (field->flags & VMS_VARRAY_INT32) {
1460 n_elems = *(int32_t *)(opaque+field->num_offset);
Juan Quintelaa624b082011-03-10 12:33:50 +01001461 } else if (field->flags & VMS_VARRAY_UINT32) {
1462 n_elems = *(uint32_t *)(opaque+field->num_offset);
Juan Quintelabdb49412009-10-16 11:35:18 +02001463 } else if (field->flags & VMS_VARRAY_UINT16) {
1464 n_elems = *(uint16_t *)(opaque+field->num_offset);
Juan Quintela82fa39b2011-03-10 12:33:49 +01001465 } else if (field->flags & VMS_VARRAY_UINT8) {
1466 n_elems = *(uint8_t *)(opaque+field->num_offset);
Juan Quinteladde04632009-08-20 19:42:26 +02001467 }
Juan Quintelaf752a6a2009-08-20 19:42:27 +02001468 if (field->flags & VMS_POINTER) {
Juan Quintelae61a1e02009-12-02 12:36:38 +01001469 base_addr = *(void **)base_addr + field->start;
Juan Quintelaf752a6a2009-08-20 19:42:27 +02001470 }
1471 for (i = 0; i < n_elems; i++) {
Juan Quintelae61a1e02009-12-02 12:36:38 +01001472 void *addr = base_addr + size * i;
Juan Quintelaec245e22009-08-20 19:42:29 +02001473
Juan Quintela19df4382009-09-29 22:48:41 +02001474 if (field->flags & VMS_ARRAY_OF_POINTER) {
1475 addr = *(void **)addr;
1476 }
Juan Quintelaec245e22009-08-20 19:42:29 +02001477 if (field->flags & VMS_STRUCT) {
Juan Quintelafa3aad22009-08-28 15:28:25 +02001478 ret = vmstate_load_state(f, field->vmsd, addr, field->vmsd->version_id);
Juan Quintelaec245e22009-08-20 19:42:29 +02001479 } else {
Juan Quintelae61a1e02009-12-02 12:36:38 +01001480 ret = field->info->get(f, addr, size);
Juan Quintelaec245e22009-08-20 19:42:29 +02001481
1482 }
Juan Quintelaf752a6a2009-08-20 19:42:27 +02001483 if (ret < 0) {
1484 return ret;
1485 }
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001486 }
1487 }
1488 field++;
1489 }
Juan Quintela811814b2010-07-26 21:38:43 +02001490 ret = vmstate_subsection_load(f, vmsd, opaque);
1491 if (ret != 0) {
1492 return ret;
1493 }
Juan Quintela752ff2f2009-09-10 03:04:30 +02001494 if (vmsd->post_load) {
Juan Quintelae59fb372009-09-29 22:48:21 +02001495 return vmsd->post_load(opaque, version_id);
Juan Quintela752ff2f2009-09-10 03:04:30 +02001496 }
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001497 return 0;
1498}
1499
1500void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
Juan Quintela84e2e3e2009-09-29 22:48:20 +02001501 void *opaque)
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001502{
1503 VMStateField *field = vmsd->fields;
1504
Juan Quintela8fb07912009-09-10 03:04:32 +02001505 if (vmsd->pre_save) {
1506 vmsd->pre_save(opaque);
1507 }
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001508 while(field->name) {
Juan Quintelaf11f6a52009-09-29 22:49:07 +02001509 if (!field->field_exists ||
1510 field->field_exists(opaque, vmsd->version_id)) {
1511 void *base_addr = opaque + field->offset;
1512 int i, n_elems = 1;
Juan Quintelae61a1e02009-12-02 12:36:38 +01001513 int size = field->size;
Juan Quinteladde04632009-08-20 19:42:26 +02001514
Juan Quintelae61a1e02009-12-02 12:36:38 +01001515 if (field->flags & VMS_VBUFFER) {
1516 size = *(int32_t *)(opaque+field->size_offset);
Juan Quintela33599e22009-12-02 12:36:43 +01001517 if (field->flags & VMS_MULTIPLY) {
1518 size *= field->size;
1519 }
Juan Quintelae61a1e02009-12-02 12:36:38 +01001520 }
Juan Quintelaf11f6a52009-09-29 22:49:07 +02001521 if (field->flags & VMS_ARRAY) {
1522 n_elems = field->num;
Juan Quintelad6698282009-10-16 11:27:17 +02001523 } else if (field->flags & VMS_VARRAY_INT32) {
1524 n_elems = *(int32_t *)(opaque+field->num_offset);
Amos Kong1329d182012-03-13 14:05:36 +08001525 } else if (field->flags & VMS_VARRAY_UINT32) {
1526 n_elems = *(uint32_t *)(opaque+field->num_offset);
Juan Quintelabdb49412009-10-16 11:35:18 +02001527 } else if (field->flags & VMS_VARRAY_UINT16) {
1528 n_elems = *(uint16_t *)(opaque+field->num_offset);
Juan Quintelab7844212011-03-15 15:53:25 +01001529 } else if (field->flags & VMS_VARRAY_UINT8) {
1530 n_elems = *(uint8_t *)(opaque+field->num_offset);
Juan Quintelaf11f6a52009-09-29 22:49:07 +02001531 }
1532 if (field->flags & VMS_POINTER) {
Juan Quintelae61a1e02009-12-02 12:36:38 +01001533 base_addr = *(void **)base_addr + field->start;
Juan Quintelaf11f6a52009-09-29 22:49:07 +02001534 }
1535 for (i = 0; i < n_elems; i++) {
Juan Quintelae61a1e02009-12-02 12:36:38 +01001536 void *addr = base_addr + size * i;
Juan Quintelaec245e22009-08-20 19:42:29 +02001537
Juan Quintela85953872009-12-02 12:36:37 +01001538 if (field->flags & VMS_ARRAY_OF_POINTER) {
1539 addr = *(void **)addr;
1540 }
Juan Quintelaf11f6a52009-09-29 22:49:07 +02001541 if (field->flags & VMS_STRUCT) {
1542 vmstate_save_state(f, field->vmsd, addr);
1543 } else {
Juan Quintelae61a1e02009-12-02 12:36:38 +01001544 field->info->put(f, addr, size);
Juan Quintelaf11f6a52009-09-29 22:49:07 +02001545 }
Juan Quintelaec245e22009-08-20 19:42:29 +02001546 }
Juan Quintelaf752a6a2009-08-20 19:42:27 +02001547 }
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001548 field++;
1549 }
Juan Quintela811814b2010-07-26 21:38:43 +02001550 vmstate_subsection_save(f, vmsd, opaque);
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001551}
1552
Juan Quintela4082be42009-08-20 19:42:24 +02001553static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id)
1554{
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001555 if (!se->vmsd) { /* Old style */
Juan Quintela22ea40f2012-06-26 17:19:10 +02001556 return se->ops->load_state(f, se->opaque, version_id);
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001557 }
1558 return vmstate_load_state(f, se->vmsd, se->opaque, version_id);
Juan Quintela4082be42009-08-20 19:42:24 +02001559}
1560
Alex Williamsondc912122011-01-11 14:39:43 -07001561static void vmstate_save(QEMUFile *f, SaveStateEntry *se)
Juan Quintela4082be42009-08-20 19:42:24 +02001562{
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001563 if (!se->vmsd) { /* Old style */
Juan Quintela22ea40f2012-06-26 17:19:10 +02001564 se->ops->save_state(f, se->opaque);
Alex Williamsondc912122011-01-11 14:39:43 -07001565 return;
Juan Quintela9ed7d6a2009-08-20 19:42:25 +02001566 }
1567 vmstate_save_state(f,se->vmsd, se->opaque);
Juan Quintela4082be42009-08-20 19:42:24 +02001568}
1569
aliguoria672b462008-11-11 21:33:36 +00001570#define QEMU_VM_FILE_MAGIC 0x5145564d
1571#define QEMU_VM_FILE_VERSION_COMPAT 0x00000002
1572#define QEMU_VM_FILE_VERSION 0x00000003
1573
1574#define QEMU_VM_EOF 0x00
1575#define QEMU_VM_SECTION_START 0x01
1576#define QEMU_VM_SECTION_PART 0x02
1577#define QEMU_VM_SECTION_END 0x03
1578#define QEMU_VM_SECTION_FULL 0x04
Juan Quintela811814b2010-07-26 21:38:43 +02001579#define QEMU_VM_SUBSECTION 0x05
aliguoria672b462008-11-11 21:33:36 +00001580
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02001581bool qemu_savevm_state_blocked(Error **errp)
Alex Williamsondc912122011-01-11 14:39:43 -07001582{
1583 SaveStateEntry *se;
1584
1585 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1586 if (se->no_migrate) {
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02001587 error_set(errp, QERR_MIGRATION_NOT_SUPPORTED, se->idstr);
Alex Williamsondc912122011-01-11 14:39:43 -07001588 return true;
1589 }
1590 }
1591 return false;
1592}
1593
Paolo Bonzini47c8c172013-02-22 17:36:13 +01001594void qemu_savevm_state_begin(QEMUFile *f,
1595 const MigrationParams *params)
aliguoria672b462008-11-11 21:33:36 +00001596{
1597 SaveStateEntry *se;
Juan Quintela39346382011-09-22 11:02:14 +02001598 int ret;
aliguoria672b462008-11-11 21:33:36 +00001599
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +02001600 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
Juan Quintela22ea40f2012-06-26 17:19:10 +02001601 if (!se->ops || !se->ops->set_params) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +02001602 continue;
Isaku Yamahata6607ae22012-06-19 18:43:09 +03001603 }
Juan Quintela22ea40f2012-06-26 17:19:10 +02001604 se->ops->set_params(params, se->opaque);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +02001605 }
1606
aliguoria672b462008-11-11 21:33:36 +00001607 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1608 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1609
Blue Swirl72cf2d42009-09-12 07:36:22 +00001610 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
aliguoria672b462008-11-11 21:33:36 +00001611 int len;
1612
Juan Quintelad1315aa2012-06-28 15:11:57 +02001613 if (!se->ops || !se->ops->save_live_setup) {
aliguoria672b462008-11-11 21:33:36 +00001614 continue;
Juan Quintela22ea40f2012-06-26 17:19:10 +02001615 }
Juan Quintela6bd68782012-06-27 10:59:15 +02001616 if (se->ops && se->ops->is_active) {
1617 if (!se->ops->is_active(se->opaque)) {
1618 continue;
1619 }
1620 }
aliguoria672b462008-11-11 21:33:36 +00001621 /* Section type */
1622 qemu_put_byte(f, QEMU_VM_SECTION_START);
1623 qemu_put_be32(f, se->section_id);
1624
1625 /* ID string */
1626 len = strlen(se->idstr);
1627 qemu_put_byte(f, len);
1628 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1629
1630 qemu_put_be32(f, se->instance_id);
1631 qemu_put_be32(f, se->version_id);
1632
Juan Quintelad1315aa2012-06-28 15:11:57 +02001633 ret = se->ops->save_live_setup(f, se->opaque);
Juan Quintela29757252011-10-19 15:22:18 +02001634 if (ret < 0) {
Paolo Bonzini47c8c172013-02-22 17:36:13 +01001635 qemu_file_set_error(f, ret);
1636 break;
Juan Quintela29757252011-10-19 15:22:18 +02001637 }
aliguoria672b462008-11-11 21:33:36 +00001638 }
aliguoria672b462008-11-11 21:33:36 +00001639}
1640
Juan Quintela39346382011-09-22 11:02:14 +02001641/*
Dong Xu Wang07f35072011-11-22 18:06:26 +08001642 * this function has three return values:
Juan Quintela39346382011-09-22 11:02:14 +02001643 * negative: there was one error, and we have -errno.
1644 * 0 : We haven't finished, caller have to go again
1645 * 1 : We have finished, we can go to complete phase
1646 */
Luiz Capitulino539de122011-12-05 14:06:56 -02001647int qemu_savevm_state_iterate(QEMUFile *f)
aliguoria672b462008-11-11 21:33:36 +00001648{
1649 SaveStateEntry *se;
1650 int ret = 1;
1651
Blue Swirl72cf2d42009-09-12 07:36:22 +00001652 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
Juan Quintela16310a32012-06-28 15:31:37 +02001653 if (!se->ops || !se->ops->save_live_iterate) {
aliguoria672b462008-11-11 21:33:36 +00001654 continue;
Juan Quintela22ea40f2012-06-26 17:19:10 +02001655 }
Juan Quintela6bd68782012-06-27 10:59:15 +02001656 if (se->ops && se->ops->is_active) {
1657 if (!se->ops->is_active(se->opaque)) {
1658 continue;
1659 }
1660 }
Juan Quintelaaac844e2012-05-22 00:38:26 +02001661 if (qemu_file_rate_limit(f)) {
1662 return 0;
1663 }
Juan Quintela517a13c2012-05-21 23:46:44 +02001664 trace_savevm_section_start();
aliguoria672b462008-11-11 21:33:36 +00001665 /* Section type */
1666 qemu_put_byte(f, QEMU_VM_SECTION_PART);
1667 qemu_put_be32(f, se->section_id);
1668
Juan Quintela16310a32012-06-28 15:31:37 +02001669 ret = se->ops->save_live_iterate(f, se->opaque);
Juan Quintela517a13c2012-05-21 23:46:44 +02001670 trace_savevm_section_end(se->section_id);
1671
Paolo Bonzini47c8c172013-02-22 17:36:13 +01001672 if (ret < 0) {
1673 qemu_file_set_error(f, ret);
1674 }
Juan Quintela29757252011-10-19 15:22:18 +02001675 if (ret <= 0) {
Jan Kiszka90697be2009-12-01 15:19:55 +01001676 /* Do not proceed to the next vmstate before this one reported
1677 completion of the current stage. This serializes the migration
1678 and reduces the probability that a faster changing state is
1679 synchronized over and over again. */
1680 break;
1681 }
aliguoria672b462008-11-11 21:33:36 +00001682 }
Juan Quintela39346382011-09-22 11:02:14 +02001683 return ret;
aliguoria672b462008-11-11 21:33:36 +00001684}
1685
Paolo Bonzini47c8c172013-02-22 17:36:13 +01001686void qemu_savevm_state_complete(QEMUFile *f)
aliguoria672b462008-11-11 21:33:36 +00001687{
1688 SaveStateEntry *se;
Juan Quintela29757252011-10-19 15:22:18 +02001689 int ret;
aliguoria672b462008-11-11 21:33:36 +00001690
Jan Kiszkaea375f92010-03-01 19:10:30 +01001691 cpu_synchronize_all_states();
1692
Blue Swirl72cf2d42009-09-12 07:36:22 +00001693 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
Juan Quintela16310a32012-06-28 15:31:37 +02001694 if (!se->ops || !se->ops->save_live_complete) {
aliguoria672b462008-11-11 21:33:36 +00001695 continue;
Juan Quintela22ea40f2012-06-26 17:19:10 +02001696 }
Juan Quintela6bd68782012-06-27 10:59:15 +02001697 if (se->ops && se->ops->is_active) {
1698 if (!se->ops->is_active(se->opaque)) {
1699 continue;
1700 }
1701 }
Juan Quintela517a13c2012-05-21 23:46:44 +02001702 trace_savevm_section_start();
aliguoria672b462008-11-11 21:33:36 +00001703 /* Section type */
1704 qemu_put_byte(f, QEMU_VM_SECTION_END);
1705 qemu_put_be32(f, se->section_id);
1706
Juan Quintela16310a32012-06-28 15:31:37 +02001707 ret = se->ops->save_live_complete(f, se->opaque);
Juan Quintela517a13c2012-05-21 23:46:44 +02001708 trace_savevm_section_end(se->section_id);
Juan Quintela29757252011-10-19 15:22:18 +02001709 if (ret < 0) {
Paolo Bonzini47c8c172013-02-22 17:36:13 +01001710 qemu_file_set_error(f, ret);
1711 return;
Juan Quintela29757252011-10-19 15:22:18 +02001712 }
aliguoria672b462008-11-11 21:33:36 +00001713 }
1714
Blue Swirl72cf2d42009-09-12 07:36:22 +00001715 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
aliguoria672b462008-11-11 21:33:36 +00001716 int len;
1717
Juan Quintela22ea40f2012-06-26 17:19:10 +02001718 if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
aliguoria672b462008-11-11 21:33:36 +00001719 continue;
Juan Quintela22ea40f2012-06-26 17:19:10 +02001720 }
Juan Quintela517a13c2012-05-21 23:46:44 +02001721 trace_savevm_section_start();
aliguoria672b462008-11-11 21:33:36 +00001722 /* Section type */
1723 qemu_put_byte(f, QEMU_VM_SECTION_FULL);
1724 qemu_put_be32(f, se->section_id);
1725
1726 /* ID string */
1727 len = strlen(se->idstr);
1728 qemu_put_byte(f, len);
1729 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1730
1731 qemu_put_be32(f, se->instance_id);
1732 qemu_put_be32(f, se->version_id);
1733
Alex Williamsondc912122011-01-11 14:39:43 -07001734 vmstate_save(f, se);
Juan Quintela517a13c2012-05-21 23:46:44 +02001735 trace_savevm_section_end(se->section_id);
aliguoria672b462008-11-11 21:33:36 +00001736 }
1737
1738 qemu_put_byte(f, QEMU_VM_EOF);
Paolo Bonziniedaae612013-02-22 17:36:29 +01001739 qemu_fflush(f);
aliguoria672b462008-11-11 21:33:36 +00001740}
1741
Juan Quintelae4ed1542012-09-21 11:18:18 +02001742uint64_t qemu_savevm_state_pending(QEMUFile *f, uint64_t max_size)
1743{
1744 SaveStateEntry *se;
1745 uint64_t ret = 0;
1746
1747 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1748 if (!se->ops || !se->ops->save_live_pending) {
1749 continue;
1750 }
1751 if (se->ops && se->ops->is_active) {
1752 if (!se->ops->is_active(se->opaque)) {
1753 continue;
1754 }
1755 }
1756 ret += se->ops->save_live_pending(f, se->opaque, max_size);
1757 }
1758 return ret;
1759}
1760
Juan Quintela65227732013-01-14 14:14:42 +01001761void qemu_savevm_state_cancel(void)
Jan Kiszka4ec7fcc2009-11-30 18:21:21 +01001762{
1763 SaveStateEntry *se;
1764
1765 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
Juan Quintela9b5bfab2012-06-26 19:26:41 +02001766 if (se->ops && se->ops->cancel) {
1767 se->ops->cancel(se->opaque);
Jan Kiszka4ec7fcc2009-11-30 18:21:21 +01001768 }
1769 }
1770}
1771
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02001772static int qemu_savevm_state(QEMUFile *f)
aliguoria672b462008-11-11 21:33:36 +00001773{
aliguoria672b462008-11-11 21:33:36 +00001774 int ret;
Isaku Yamahata6607ae22012-06-19 18:43:09 +03001775 MigrationParams params = {
1776 .blk = 0,
1777 .shared = 0
1778 };
aliguoria672b462008-11-11 21:33:36 +00001779
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02001780 if (qemu_savevm_state_blocked(NULL)) {
Paolo Bonzini04943eb2013-02-22 17:36:10 +01001781 return -EINVAL;
Alex Williamsondc912122011-01-11 14:39:43 -07001782 }
1783
Paolo Bonzini9b095032013-02-22 17:36:28 +01001784 qemu_mutex_unlock_iothread();
Paolo Bonzini47c8c172013-02-22 17:36:13 +01001785 qemu_savevm_state_begin(f, &params);
Paolo Bonzini9b095032013-02-22 17:36:28 +01001786 qemu_mutex_lock_iothread();
1787
Paolo Bonzini47c8c172013-02-22 17:36:13 +01001788 while (qemu_file_get_error(f) == 0) {
1789 if (qemu_savevm_state_iterate(f) > 0) {
1790 break;
1791 }
1792 }
aliguoria672b462008-11-11 21:33:36 +00001793
Paolo Bonzini47c8c172013-02-22 17:36:13 +01001794 ret = qemu_file_get_error(f);
Juan Quintela39346382011-09-22 11:02:14 +02001795 if (ret == 0) {
Paolo Bonzini47c8c172013-02-22 17:36:13 +01001796 qemu_savevm_state_complete(f);
Juan Quintela624b9cc2011-10-05 01:02:52 +02001797 ret = qemu_file_get_error(f);
Juan Quintela39346382011-09-22 11:02:14 +02001798 }
Paolo Bonzini04943eb2013-02-22 17:36:10 +01001799 if (ret != 0) {
1800 qemu_savevm_state_cancel();
1801 }
aliguoria672b462008-11-11 21:33:36 +00001802 return ret;
1803}
1804
Stefano Stabellinia7ae8352012-01-25 12:24:51 +00001805static int qemu_save_device_state(QEMUFile *f)
1806{
1807 SaveStateEntry *se;
1808
1809 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1810 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1811
1812 cpu_synchronize_all_states();
1813
1814 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1815 int len;
1816
1817 if (se->is_ram) {
1818 continue;
1819 }
Juan Quintela22ea40f2012-06-26 17:19:10 +02001820 if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
Stefano Stabellinia7ae8352012-01-25 12:24:51 +00001821 continue;
1822 }
1823
1824 /* Section type */
1825 qemu_put_byte(f, QEMU_VM_SECTION_FULL);
1826 qemu_put_be32(f, se->section_id);
1827
1828 /* ID string */
1829 len = strlen(se->idstr);
1830 qemu_put_byte(f, len);
1831 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1832
1833 qemu_put_be32(f, se->instance_id);
1834 qemu_put_be32(f, se->version_id);
1835
1836 vmstate_save(f, se);
1837 }
1838
1839 qemu_put_byte(f, QEMU_VM_EOF);
1840
1841 return qemu_file_get_error(f);
1842}
1843
aliguoria672b462008-11-11 21:33:36 +00001844static SaveStateEntry *find_se(const char *idstr, int instance_id)
1845{
1846 SaveStateEntry *se;
1847
Blue Swirl72cf2d42009-09-12 07:36:22 +00001848 QTAILQ_FOREACH(se, &savevm_handlers, entry) {
aliguoria672b462008-11-11 21:33:36 +00001849 if (!strcmp(se->idstr, idstr) &&
Jan Kiszka4d2ffa02010-05-15 13:32:40 +02001850 (instance_id == se->instance_id ||
1851 instance_id == se->alias_id))
aliguoria672b462008-11-11 21:33:36 +00001852 return se;
Alex Williamson7685ee62010-06-25 11:09:14 -06001853 /* Migrating from an older version? */
1854 if (strstr(se->idstr, idstr) && se->compat) {
1855 if (!strcmp(se->compat->idstr, idstr) &&
1856 (instance_id == se->compat->instance_id ||
1857 instance_id == se->alias_id))
1858 return se;
1859 }
aliguoria672b462008-11-11 21:33:36 +00001860 }
1861 return NULL;
1862}
1863
Juan Quintela811814b2010-07-26 21:38:43 +02001864static const VMStateDescription *vmstate_get_subsection(const VMStateSubsection *sub, char *idstr)
1865{
1866 while(sub && sub->needed) {
1867 if (strcmp(idstr, sub->vmsd->name) == 0) {
1868 return sub->vmsd;
1869 }
1870 sub++;
1871 }
1872 return NULL;
1873}
1874
1875static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
1876 void *opaque)
1877{
Juan Quintelac6380722011-10-04 15:28:31 +02001878 while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
Juan Quintela811814b2010-07-26 21:38:43 +02001879 char idstr[256];
1880 int ret;
Juan Quintelac6380722011-10-04 15:28:31 +02001881 uint8_t version_id, len, size;
Juan Quintela811814b2010-07-26 21:38:43 +02001882 const VMStateDescription *sub_vmsd;
1883
Juan Quintelac6380722011-10-04 15:28:31 +02001884 len = qemu_peek_byte(f, 1);
1885 if (len < strlen(vmsd->name) + 1) {
1886 /* subsection name has be be "section_name/a" */
1887 return 0;
1888 }
1889 size = qemu_peek_buffer(f, (uint8_t *)idstr, len, 2);
1890 if (size != len) {
1891 return 0;
1892 }
1893 idstr[size] = 0;
Juan Quintela811814b2010-07-26 21:38:43 +02001894
Juan Quintelac6380722011-10-04 15:28:31 +02001895 if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
1896 /* it don't have a valid subsection name */
1897 return 0;
1898 }
Juan Quintela3da9eeb2011-09-30 19:46:43 +02001899 sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
Juan Quintela811814b2010-07-26 21:38:43 +02001900 if (sub_vmsd == NULL) {
1901 return -ENOENT;
1902 }
Juan Quintelac6380722011-10-04 15:28:31 +02001903 qemu_file_skip(f, 1); /* subsection */
1904 qemu_file_skip(f, 1); /* len */
1905 qemu_file_skip(f, len); /* idstr */
1906 version_id = qemu_get_be32(f);
1907
Juan Quintela811814b2010-07-26 21:38:43 +02001908 ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
1909 if (ret) {
1910 return ret;
1911 }
1912 }
1913 return 0;
1914}
1915
1916static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
1917 void *opaque)
1918{
1919 const VMStateSubsection *sub = vmsd->subsections;
1920
1921 while (sub && sub->needed) {
1922 if (sub->needed(opaque)) {
1923 const VMStateDescription *vmsd = sub->vmsd;
1924 uint8_t len;
1925
1926 qemu_put_byte(f, QEMU_VM_SUBSECTION);
1927 len = strlen(vmsd->name);
1928 qemu_put_byte(f, len);
1929 qemu_put_buffer(f, (uint8_t *)vmsd->name, len);
1930 qemu_put_be32(f, vmsd->version_id);
1931 vmstate_save_state(f, vmsd, opaque);
1932 }
1933 sub++;
1934 }
1935}
1936
aliguoria672b462008-11-11 21:33:36 +00001937typedef struct LoadStateEntry {
Blue Swirl72cf2d42009-09-12 07:36:22 +00001938 QLIST_ENTRY(LoadStateEntry) entry;
aliguoria672b462008-11-11 21:33:36 +00001939 SaveStateEntry *se;
1940 int section_id;
1941 int version_id;
aliguoria672b462008-11-11 21:33:36 +00001942} LoadStateEntry;
1943
aliguoria672b462008-11-11 21:33:36 +00001944int qemu_loadvm_state(QEMUFile *f)
1945{
Blue Swirl72cf2d42009-09-12 07:36:22 +00001946 QLIST_HEAD(, LoadStateEntry) loadvm_handlers =
1947 QLIST_HEAD_INITIALIZER(loadvm_handlers);
Juan Quintelaf4dbb8d2009-09-01 02:12:33 +02001948 LoadStateEntry *le, *new_le;
aliguoria672b462008-11-11 21:33:36 +00001949 uint8_t section_type;
1950 unsigned int v;
1951 int ret;
1952
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02001953 if (qemu_savevm_state_blocked(NULL)) {
Alex Williamsondc912122011-01-11 14:39:43 -07001954 return -EINVAL;
1955 }
1956
aliguoria672b462008-11-11 21:33:36 +00001957 v = qemu_get_be32(f);
1958 if (v != QEMU_VM_FILE_MAGIC)
1959 return -EINVAL;
1960
1961 v = qemu_get_be32(f);
Juan Quintelabbfe1402009-09-10 03:04:24 +02001962 if (v == QEMU_VM_FILE_VERSION_COMPAT) {
1963 fprintf(stderr, "SaveVM v2 format is obsolete and don't work anymore\n");
1964 return -ENOTSUP;
1965 }
aliguoria672b462008-11-11 21:33:36 +00001966 if (v != QEMU_VM_FILE_VERSION)
1967 return -ENOTSUP;
1968
1969 while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
1970 uint32_t instance_id, version_id, section_id;
aliguoria672b462008-11-11 21:33:36 +00001971 SaveStateEntry *se;
1972 char idstr[257];
1973 int len;
1974
1975 switch (section_type) {
1976 case QEMU_VM_SECTION_START:
1977 case QEMU_VM_SECTION_FULL:
1978 /* Read section start */
1979 section_id = qemu_get_be32(f);
1980 len = qemu_get_byte(f);
1981 qemu_get_buffer(f, (uint8_t *)idstr, len);
1982 idstr[len] = 0;
1983 instance_id = qemu_get_be32(f);
1984 version_id = qemu_get_be32(f);
1985
1986 /* Find savevm section */
1987 se = find_se(idstr, instance_id);
1988 if (se == NULL) {
1989 fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
1990 ret = -EINVAL;
1991 goto out;
1992 }
1993
1994 /* Validate version */
1995 if (version_id > se->version_id) {
1996 fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
1997 version_id, idstr, se->version_id);
1998 ret = -EINVAL;
1999 goto out;
2000 }
2001
2002 /* Add entry */
Anthony Liguori7267c092011-08-20 22:09:37 -05002003 le = g_malloc0(sizeof(*le));
aliguoria672b462008-11-11 21:33:36 +00002004
2005 le->se = se;
2006 le->section_id = section_id;
2007 le->version_id = version_id;
Blue Swirl72cf2d42009-09-12 07:36:22 +00002008 QLIST_INSERT_HEAD(&loadvm_handlers, le, entry);
aliguoria672b462008-11-11 21:33:36 +00002009
Juan Quintela4082be42009-08-20 19:42:24 +02002010 ret = vmstate_load(f, le->se, le->version_id);
Juan Quintelab5a22e42009-08-20 19:42:23 +02002011 if (ret < 0) {
2012 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
2013 instance_id, idstr);
2014 goto out;
2015 }
aliguoria672b462008-11-11 21:33:36 +00002016 break;
2017 case QEMU_VM_SECTION_PART:
2018 case QEMU_VM_SECTION_END:
2019 section_id = qemu_get_be32(f);
2020
Blue Swirl72cf2d42009-09-12 07:36:22 +00002021 QLIST_FOREACH(le, &loadvm_handlers, entry) {
Juan Quintelaf4dbb8d2009-09-01 02:12:33 +02002022 if (le->section_id == section_id) {
2023 break;
2024 }
2025 }
aliguoria672b462008-11-11 21:33:36 +00002026 if (le == NULL) {
2027 fprintf(stderr, "Unknown savevm section %d\n", section_id);
2028 ret = -EINVAL;
2029 goto out;
2030 }
2031
Juan Quintela4082be42009-08-20 19:42:24 +02002032 ret = vmstate_load(f, le->se, le->version_id);
Juan Quintelab5a22e42009-08-20 19:42:23 +02002033 if (ret < 0) {
2034 fprintf(stderr, "qemu: warning: error while loading state section id %d\n",
2035 section_id);
2036 goto out;
2037 }
aliguoria672b462008-11-11 21:33:36 +00002038 break;
2039 default:
2040 fprintf(stderr, "Unknown savevm section type %d\n", section_type);
2041 ret = -EINVAL;
2042 goto out;
2043 }
2044 }
2045
Jan Kiszkaea375f92010-03-01 19:10:30 +01002046 cpu_synchronize_all_post_init();
2047
aliguoria672b462008-11-11 21:33:36 +00002048 ret = 0;
2049
2050out:
Blue Swirl72cf2d42009-09-12 07:36:22 +00002051 QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
2052 QLIST_REMOVE(le, entry);
Anthony Liguori7267c092011-08-20 22:09:37 -05002053 g_free(le);
aliguoria672b462008-11-11 21:33:36 +00002054 }
2055
Juan Quintela42802d42011-10-05 01:14:46 +02002056 if (ret == 0) {
2057 ret = qemu_file_get_error(f);
Juan Quintela624b9cc2011-10-05 01:02:52 +02002058 }
aliguoria672b462008-11-11 21:33:36 +00002059
2060 return ret;
2061}
2062
aliguoria672b462008-11-11 21:33:36 +00002063static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
2064 const char *name)
2065{
2066 QEMUSnapshotInfo *sn_tab, *sn;
2067 int nb_sns, i, ret;
2068
2069 ret = -ENOENT;
2070 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2071 if (nb_sns < 0)
2072 return ret;
2073 for(i = 0; i < nb_sns; i++) {
2074 sn = &sn_tab[i];
2075 if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
2076 *sn_info = *sn;
2077 ret = 0;
2078 break;
2079 }
2080 }
Anthony Liguori7267c092011-08-20 22:09:37 -05002081 g_free(sn_tab);
aliguoria672b462008-11-11 21:33:36 +00002082 return ret;
2083}
2084
Kevin Wolfcb499fb2009-11-03 17:34:37 +01002085/*
2086 * Deletes snapshots of a given name in all opened images.
2087 */
2088static int del_existing_snapshots(Monitor *mon, const char *name)
2089{
2090 BlockDriverState *bs;
Kevin Wolfcb499fb2009-11-03 17:34:37 +01002091 QEMUSnapshotInfo sn1, *snapshot = &sn1;
2092 int ret;
2093
Markus Armbrusterdbc13592010-06-02 18:55:21 +02002094 bs = NULL;
2095 while ((bs = bdrv_next(bs))) {
Kevin Wolfcb499fb2009-11-03 17:34:37 +01002096 if (bdrv_can_snapshot(bs) &&
2097 bdrv_snapshot_find(bs, snapshot, name) >= 0)
2098 {
2099 ret = bdrv_snapshot_delete(bs, name);
2100 if (ret < 0) {
2101 monitor_printf(mon,
2102 "Error while deleting snapshot on '%s'\n",
2103 bdrv_get_device_name(bs));
2104 return -1;
2105 }
2106 }
2107 }
2108
2109 return 0;
2110}
2111
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002112void do_savevm(Monitor *mon, const QDict *qdict)
aliguoria672b462008-11-11 21:33:36 +00002113{
2114 BlockDriverState *bs, *bs1;
2115 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
Kevin Wolfcb499fb2009-11-03 17:34:37 +01002116 int ret;
aliguoria672b462008-11-11 21:33:36 +00002117 QEMUFile *f;
2118 int saved_vm_running;
Kevin Wolfc2c9a462011-11-16 11:35:54 +01002119 uint64_t vm_state_size;
Stefan Weil68b891e2013-01-07 22:20:27 +01002120 qemu_timeval tv;
Miguel Di Ciurcio Filho7d631a12010-08-04 14:55:49 -03002121 struct tm tm;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002122 const char *name = qdict_get_try_str(qdict, "name");
aliguoria672b462008-11-11 21:33:36 +00002123
Miguel Di Ciurcio Filhofeeee5a2010-06-08 10:40:55 -03002124 /* Verify if there is a device that doesn't support snapshots and is writable */
Markus Armbrusterdbc13592010-06-02 18:55:21 +02002125 bs = NULL;
2126 while ((bs = bdrv_next(bs))) {
Miguel Di Ciurcio Filhofeeee5a2010-06-08 10:40:55 -03002127
Markus Armbruster07b70bf2011-08-03 15:08:11 +02002128 if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
Miguel Di Ciurcio Filhofeeee5a2010-06-08 10:40:55 -03002129 continue;
2130 }
2131
2132 if (!bdrv_can_snapshot(bs)) {
2133 monitor_printf(mon, "Device '%s' is writable but does not support snapshots.\n",
2134 bdrv_get_device_name(bs));
2135 return;
2136 }
2137 }
2138
Markus Armbrusterf9092b12010-06-25 10:33:39 +02002139 bs = bdrv_snapshots();
aliguoria672b462008-11-11 21:33:36 +00002140 if (!bs) {
aliguori376253e2009-03-05 23:01:23 +00002141 monitor_printf(mon, "No block device can accept snapshots\n");
aliguoria672b462008-11-11 21:33:36 +00002142 return;
2143 }
aliguoria672b462008-11-11 21:33:36 +00002144
Luiz Capitulino13548692011-07-29 15:36:43 -03002145 saved_vm_running = runstate_is_running();
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002146 vm_stop(RUN_STATE_SAVE_VM);
aliguoria672b462008-11-11 21:33:36 +00002147
Kevin Wolfcb499fb2009-11-03 17:34:37 +01002148 memset(sn, 0, sizeof(*sn));
aliguoria672b462008-11-11 21:33:36 +00002149
2150 /* fill auxiliary fields */
Stefan Weil68b891e2013-01-07 22:20:27 +01002151 qemu_gettimeofday(&tv);
aliguoria672b462008-11-11 21:33:36 +00002152 sn->date_sec = tv.tv_sec;
2153 sn->date_nsec = tv.tv_usec * 1000;
Paolo Bonzini74475452011-03-11 16:47:48 +01002154 sn->vm_clock_nsec = qemu_get_clock_ns(vm_clock);
aliguoria672b462008-11-11 21:33:36 +00002155
Miguel Di Ciurcio Filho7d631a12010-08-04 14:55:49 -03002156 if (name) {
2157 ret = bdrv_snapshot_find(bs, old_sn, name);
2158 if (ret >= 0) {
2159 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
2160 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
2161 } else {
2162 pstrcpy(sn->name, sizeof(sn->name), name);
2163 }
2164 } else {
Blue Swirld7d9b522010-09-09 19:13:04 +00002165 /* cast below needed for OpenBSD where tv_sec is still 'long' */
2166 localtime_r((const time_t *)&tv.tv_sec, &tm);
Miguel Di Ciurcio Filho7d631a12010-08-04 14:55:49 -03002167 strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
Miguel Di Ciurcio Filho7d631a12010-08-04 14:55:49 -03002168 }
2169
Kevin Wolfcb499fb2009-11-03 17:34:37 +01002170 /* Delete old snapshots of the same name */
Marcelo Tosattif139a412010-01-20 14:26:34 -02002171 if (name && del_existing_snapshots(mon, name) < 0) {
Kevin Wolfcb499fb2009-11-03 17:34:37 +01002172 goto the_end;
2173 }
2174
aliguoria672b462008-11-11 21:33:36 +00002175 /* save the VM state */
Christoph Hellwig45566e92009-07-10 23:11:57 +02002176 f = qemu_fopen_bdrv(bs, 1);
aliguoria672b462008-11-11 21:33:36 +00002177 if (!f) {
aliguori376253e2009-03-05 23:01:23 +00002178 monitor_printf(mon, "Could not open VM state file\n");
aliguoria672b462008-11-11 21:33:36 +00002179 goto the_end;
2180 }
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02002181 ret = qemu_savevm_state(f);
aliguori2d22b182008-12-11 21:06:49 +00002182 vm_state_size = qemu_ftell(f);
aliguoria672b462008-11-11 21:33:36 +00002183 qemu_fclose(f);
2184 if (ret < 0) {
aliguori376253e2009-03-05 23:01:23 +00002185 monitor_printf(mon, "Error %d while writing VM\n", ret);
aliguoria672b462008-11-11 21:33:36 +00002186 goto the_end;
2187 }
2188
2189 /* create the snapshots */
2190
Markus Armbrusterdbc13592010-06-02 18:55:21 +02002191 bs1 = NULL;
2192 while ((bs1 = bdrv_next(bs1))) {
Miguel Di Ciurcio Filhofeeee5a2010-06-08 10:40:55 -03002193 if (bdrv_can_snapshot(bs1)) {
aliguori2d22b182008-12-11 21:06:49 +00002194 /* Write VM state size only to the image that contains the state */
2195 sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
aliguoria672b462008-11-11 21:33:36 +00002196 ret = bdrv_snapshot_create(bs1, sn);
2197 if (ret < 0) {
aliguori376253e2009-03-05 23:01:23 +00002198 monitor_printf(mon, "Error while creating snapshot on '%s'\n",
2199 bdrv_get_device_name(bs1));
aliguoria672b462008-11-11 21:33:36 +00002200 }
2201 }
2202 }
2203
2204 the_end:
2205 if (saved_vm_running)
2206 vm_start();
2207}
2208
Stefano Stabellinia7ae8352012-01-25 12:24:51 +00002209void qmp_xen_save_devices_state(const char *filename, Error **errp)
2210{
2211 QEMUFile *f;
2212 int saved_vm_running;
2213 int ret;
2214
2215 saved_vm_running = runstate_is_running();
2216 vm_stop(RUN_STATE_SAVE_VM);
2217
2218 f = qemu_fopen(filename, "wb");
2219 if (!f) {
2220 error_set(errp, QERR_OPEN_FILE_FAILED, filename);
2221 goto the_end;
2222 }
2223 ret = qemu_save_device_state(f);
2224 qemu_fclose(f);
2225 if (ret < 0) {
2226 error_set(errp, QERR_IO_ERROR);
2227 }
2228
2229 the_end:
2230 if (saved_vm_running)
2231 vm_start();
Stefano Stabellinia7ae8352012-01-25 12:24:51 +00002232}
2233
Markus Armbruster03cd4652010-02-17 16:24:10 +01002234int load_vmstate(const char *name)
aliguoria672b462008-11-11 21:33:36 +00002235{
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002236 BlockDriverState *bs, *bs_vm_state;
aliguori2d22b182008-12-11 21:06:49 +00002237 QEMUSnapshotInfo sn;
aliguoria672b462008-11-11 21:33:36 +00002238 QEMUFile *f;
Gerd Hoffmann751c6a12009-07-22 16:42:57 +02002239 int ret;
aliguoria672b462008-11-11 21:33:36 +00002240
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002241 bs_vm_state = bdrv_snapshots();
2242 if (!bs_vm_state) {
2243 error_report("No block device supports snapshots");
2244 return -ENOTSUP;
2245 }
2246
2247 /* Don't even try to load empty VM states */
2248 ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
2249 if (ret < 0) {
2250 return ret;
2251 } else if (sn.vm_state_size == 0) {
Kevin Wolfe11480d2011-03-01 10:48:12 +01002252 error_report("This is a disk-only snapshot. Revert to it offline "
2253 "using qemu-img.");
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002254 return -EINVAL;
2255 }
2256
2257 /* Verify if there is any device that doesn't support snapshots and is
2258 writable and check if the requested snapshot is available too. */
Markus Armbrusterdbc13592010-06-02 18:55:21 +02002259 bs = NULL;
2260 while ((bs = bdrv_next(bs))) {
Miguel Di Ciurcio Filhofeeee5a2010-06-08 10:40:55 -03002261
Markus Armbruster07b70bf2011-08-03 15:08:11 +02002262 if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
Miguel Di Ciurcio Filhofeeee5a2010-06-08 10:40:55 -03002263 continue;
2264 }
2265
2266 if (!bdrv_can_snapshot(bs)) {
2267 error_report("Device '%s' is writable but does not support snapshots.",
2268 bdrv_get_device_name(bs));
2269 return -ENOTSUP;
2270 }
Miguel Di Ciurcio Filhofeeee5a2010-06-08 10:40:55 -03002271
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002272 ret = bdrv_snapshot_find(bs, &sn, name);
2273 if (ret < 0) {
2274 error_report("Device '%s' does not have the requested snapshot '%s'",
2275 bdrv_get_device_name(bs), name);
2276 return ret;
2277 }
aliguoria672b462008-11-11 21:33:36 +00002278 }
2279
2280 /* Flush all IO requests so they don't interfere with the new state. */
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00002281 bdrv_drain_all();
aliguoria672b462008-11-11 21:33:36 +00002282
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002283 bs = NULL;
2284 while ((bs = bdrv_next(bs))) {
2285 if (bdrv_can_snapshot(bs)) {
2286 ret = bdrv_snapshot_goto(bs, name);
aliguoria672b462008-11-11 21:33:36 +00002287 if (ret < 0) {
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002288 error_report("Error %d while activating snapshot '%s' on '%s'",
2289 ret, name, bdrv_get_device_name(bs));
2290 return ret;
aliguoria672b462008-11-11 21:33:36 +00002291 }
2292 }
2293 }
2294
aliguoria672b462008-11-11 21:33:36 +00002295 /* restore the VM state */
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002296 f = qemu_fopen_bdrv(bs_vm_state, 0);
aliguoria672b462008-11-11 21:33:36 +00002297 if (!f) {
Markus Armbruster1ecda022010-02-18 17:25:24 +01002298 error_report("Could not open VM state file");
Juan Quintela05f24012009-08-20 19:42:22 +02002299 return -EINVAL;
aliguoria672b462008-11-11 21:33:36 +00002300 }
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002301
Jan Kiszka5a8a49d2011-06-14 18:29:45 +02002302 qemu_system_reset(VMRESET_SILENT);
aliguoria672b462008-11-11 21:33:36 +00002303 ret = qemu_loadvm_state(f);
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002304
aliguoria672b462008-11-11 21:33:36 +00002305 qemu_fclose(f);
2306 if (ret < 0) {
Markus Armbruster1ecda022010-02-18 17:25:24 +01002307 error_report("Error %d while loading VM state", ret);
Juan Quintela05f24012009-08-20 19:42:22 +02002308 return ret;
aliguoria672b462008-11-11 21:33:36 +00002309 }
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002310
Juan Quintela05f24012009-08-20 19:42:22 +02002311 return 0;
Juan Quintela7b630342009-08-20 19:42:20 +02002312}
2313
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002314void do_delvm(Monitor *mon, const QDict *qdict)
aliguoria672b462008-11-11 21:33:36 +00002315{
2316 BlockDriverState *bs, *bs1;
Gerd Hoffmann751c6a12009-07-22 16:42:57 +02002317 int ret;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002318 const char *name = qdict_get_str(qdict, "name");
aliguoria672b462008-11-11 21:33:36 +00002319
Markus Armbrusterf9092b12010-06-25 10:33:39 +02002320 bs = bdrv_snapshots();
aliguoria672b462008-11-11 21:33:36 +00002321 if (!bs) {
aliguori376253e2009-03-05 23:01:23 +00002322 monitor_printf(mon, "No block device supports snapshots\n");
aliguoria672b462008-11-11 21:33:36 +00002323 return;
2324 }
2325
Markus Armbrusterdbc13592010-06-02 18:55:21 +02002326 bs1 = NULL;
2327 while ((bs1 = bdrv_next(bs1))) {
Miguel Di Ciurcio Filhofeeee5a2010-06-08 10:40:55 -03002328 if (bdrv_can_snapshot(bs1)) {
aliguoria672b462008-11-11 21:33:36 +00002329 ret = bdrv_snapshot_delete(bs1, name);
2330 if (ret < 0) {
2331 if (ret == -ENOTSUP)
aliguori376253e2009-03-05 23:01:23 +00002332 monitor_printf(mon,
2333 "Snapshots not supported on device '%s'\n",
2334 bdrv_get_device_name(bs1));
aliguoria672b462008-11-11 21:33:36 +00002335 else
aliguori376253e2009-03-05 23:01:23 +00002336 monitor_printf(mon, "Error %d while deleting snapshot on "
2337 "'%s'\n", ret, bdrv_get_device_name(bs1));
aliguoria672b462008-11-11 21:33:36 +00002338 }
2339 }
2340 }
2341}
2342
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08002343void do_info_snapshots(Monitor *mon, const QDict *qdict)
aliguoria672b462008-11-11 21:33:36 +00002344{
2345 BlockDriverState *bs, *bs1;
Miguel Di Ciurcio Filhof9209912010-08-04 14:55:48 -03002346 QEMUSnapshotInfo *sn_tab, *sn, s, *sn_info = &s;
2347 int nb_sns, i, ret, available;
2348 int total;
2349 int *available_snapshots;
aliguoria672b462008-11-11 21:33:36 +00002350 char buf[256];
2351
Markus Armbrusterf9092b12010-06-25 10:33:39 +02002352 bs = bdrv_snapshots();
aliguoria672b462008-11-11 21:33:36 +00002353 if (!bs) {
aliguori376253e2009-03-05 23:01:23 +00002354 monitor_printf(mon, "No available block device supports snapshots\n");
aliguoria672b462008-11-11 21:33:36 +00002355 return;
2356 }
aliguoria672b462008-11-11 21:33:36 +00002357
2358 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2359 if (nb_sns < 0) {
aliguori376253e2009-03-05 23:01:23 +00002360 monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
aliguoria672b462008-11-11 21:33:36 +00002361 return;
2362 }
Miguel Di Ciurcio Filhof9209912010-08-04 14:55:48 -03002363
2364 if (nb_sns == 0) {
2365 monitor_printf(mon, "There is no snapshot available.\n");
2366 return;
aliguoria672b462008-11-11 21:33:36 +00002367 }
Miguel Di Ciurcio Filhof9209912010-08-04 14:55:48 -03002368
Anthony Liguori7267c092011-08-20 22:09:37 -05002369 available_snapshots = g_malloc0(sizeof(int) * nb_sns);
Miguel Di Ciurcio Filhof9209912010-08-04 14:55:48 -03002370 total = 0;
2371 for (i = 0; i < nb_sns; i++) {
2372 sn = &sn_tab[i];
2373 available = 1;
2374 bs1 = NULL;
2375
2376 while ((bs1 = bdrv_next(bs1))) {
2377 if (bdrv_can_snapshot(bs1) && bs1 != bs) {
2378 ret = bdrv_snapshot_find(bs1, sn_info, sn->id_str);
2379 if (ret < 0) {
2380 available = 0;
2381 break;
2382 }
2383 }
2384 }
2385
2386 if (available) {
2387 available_snapshots[total] = i;
2388 total++;
2389 }
2390 }
2391
2392 if (total > 0) {
2393 monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
2394 for (i = 0; i < total; i++) {
2395 sn = &sn_tab[available_snapshots[i]];
2396 monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
2397 }
2398 } else {
2399 monitor_printf(mon, "There is no suitable snapshot available\n");
2400 }
2401
Anthony Liguori7267c092011-08-20 22:09:37 -05002402 g_free(sn_tab);
2403 g_free(available_snapshots);
Miguel Di Ciurcio Filhof9209912010-08-04 14:55:48 -03002404
aliguoria672b462008-11-11 21:33:36 +00002405}
Avi Kivityc5705a72011-12-20 15:59:12 +02002406
2407void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
2408{
Avi Kivity1ddde082012-01-08 13:18:19 +02002409 qemu_ram_set_idstr(memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK,
Avi Kivityc5705a72011-12-20 15:59:12 +02002410 memory_region_name(mr), dev);
2411}
2412
2413void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev)
2414{
2415 /* Nothing do to while the implementation is in RAMBlock */
2416}
2417
2418void vmstate_register_ram_global(MemoryRegion *mr)
2419{
2420 vmstate_register_ram(mr, NULL);
2421}