blob: 975e7ab46fb5f9c8361d9a36b16c125702a07440 [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#include <unistd.h>
25#include <fcntl.h>
26#include <signal.h>
27#include <time.h>
28#include <errno.h>
29#include <sys/time.h>
30#include <zlib.h>
31
Juan Quintela71e72a12009-07-27 16:12:56 +020032/* Needed early for CONFIG_BSD etc. */
blueswir1d40cdb12009-03-07 16:52:02 +000033#include "config-host.h"
34
aliguoria672b462008-11-11 21:33:36 +000035#ifndef _WIN32
36#include <sys/times.h>
37#include <sys/wait.h>
38#include <termios.h>
39#include <sys/mman.h>
40#include <sys/ioctl.h>
41#include <sys/resource.h>
42#include <sys/socket.h>
43#include <netinet/in.h>
44#include <net/if.h>
45#if defined(__NetBSD__)
46#include <net/if_tap.h>
47#endif
48#ifdef __linux__
49#include <linux/if_tun.h>
50#endif
51#include <arpa/inet.h>
52#include <dirent.h>
53#include <netdb.h>
54#include <sys/select.h>
Juan Quintela71e72a12009-07-27 16:12:56 +020055#ifdef CONFIG_BSD
aliguoria672b462008-11-11 21:33:36 +000056#include <sys/stat.h>
blueswir1c5e97232009-03-07 20:06:23 +000057#if defined(__FreeBSD__) || defined(__DragonFly__)
aliguoria672b462008-11-11 21:33:36 +000058#include <libutil.h>
59#else
60#include <util.h>
61#endif
62#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
63#include <freebsd/stdlib.h>
64#else
65#ifdef __linux__
66#include <pty.h>
67#include <malloc.h>
68#include <linux/rtc.h>
69#endif
70#endif
71#endif
72
73#ifdef _WIN32
aliguori49dc7682009-03-08 16:26:59 +000074#include <windows.h>
aliguoria672b462008-11-11 21:33:36 +000075#include <malloc.h>
76#include <sys/timeb.h>
77#include <mmsystem.h>
78#define getopt_long_only getopt_long
79#define memalign(align, size) malloc(size)
80#endif
81
blueswir1511d2b12009-03-07 15:32:56 +000082#include "qemu-common.h"
83#include "hw/hw.h"
84#include "net.h"
85#include "monitor.h"
86#include "sysemu.h"
87#include "qemu-timer.h"
88#include "qemu-char.h"
89#include "block.h"
90#include "audio/audio.h"
91#include "migration.h"
92#include "qemu_socket.h"
93
aliguoria672b462008-11-11 21:33:36 +000094/* point to the block driver where the snapshots are managed */
95static BlockDriverState *bs_snapshots;
96
97#define SELF_ANNOUNCE_ROUNDS 5
98#define ETH_P_EXPERIMENTAL 0x01F1 /* just a number */
99//#define ETH_P_EXPERIMENTAL 0x0012 /* make it the size of the packet */
100#define EXPERIMENTAL_MAGIC 0xf1f23f4f
101
102static int announce_self_create(uint8_t *buf,
103 uint8_t *mac_addr)
104{
105 uint32_t magic = EXPERIMENTAL_MAGIC;
106 uint16_t proto = htons(ETH_P_EXPERIMENTAL);
107
108 /* FIXME: should we send a different packet (arp/rarp/ping)? */
109
Gleb Natapov976305b2009-05-21 17:17:43 +0300110 memset(buf, 0, 64);
aliguoria672b462008-11-11 21:33:36 +0000111 memset(buf, 0xff, 6); /* h_dst */
112 memcpy(buf + 6, mac_addr, 6); /* h_src */
113 memcpy(buf + 12, &proto, 2); /* h_proto */
114 memcpy(buf + 14, &magic, 4); /* magic */
115
Gleb Natapov976305b2009-05-21 17:17:43 +0300116 return 64; /* len */
aliguoria672b462008-11-11 21:33:36 +0000117}
118
Gleb Natapoved8b3302009-05-21 17:17:44 +0300119static void qemu_announce_self_once(void *opaque)
aliguoria672b462008-11-11 21:33:36 +0000120{
Gleb Natapoved8b3302009-05-21 17:17:44 +0300121 int i, len;
aliguoria672b462008-11-11 21:33:36 +0000122 VLANState *vlan;
123 VLANClientState *vc;
124 uint8_t buf[256];
Gleb Natapoved8b3302009-05-21 17:17:44 +0300125 static int count = SELF_ANNOUNCE_ROUNDS;
126 QEMUTimer *timer = *(QEMUTimer **)opaque;
aliguoria672b462008-11-11 21:33:36 +0000127
aliguori3450df32009-03-13 15:03:58 +0000128 for (i = 0; i < MAX_NICS; i++) {
129 if (!nd_table[i].used)
130 continue;
aliguoria672b462008-11-11 21:33:36 +0000131 len = announce_self_create(buf, nd_table[i].macaddr);
132 vlan = nd_table[i].vlan;
Gleb Natapoved8b3302009-05-21 17:17:44 +0300133 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
Mark McLoughline3f5ec22009-05-18 13:33:03 +0100134 vc->receive(vc, buf, len);
aliguoria672b462008-11-11 21:33:36 +0000135 }
136 }
Gleb Natapoved8b3302009-05-21 17:17:44 +0300137 if (count--) {
138 qemu_mod_timer(timer, qemu_get_clock(rt_clock) + 100);
139 } else {
140 qemu_del_timer(timer);
141 qemu_free_timer(timer);
142 }
143}
144
145void qemu_announce_self(void)
146{
147 static QEMUTimer *timer;
148 timer = qemu_new_timer(rt_clock, qemu_announce_self_once, &timer);
149 qemu_announce_self_once(&timer);
aliguoria672b462008-11-11 21:33:36 +0000150}
151
152/***********************************************************/
153/* savevm/loadvm support */
154
155#define IO_BUF_SIZE 32768
156
157struct QEMUFile {
158 QEMUFilePutBufferFunc *put_buffer;
159 QEMUFileGetBufferFunc *get_buffer;
160 QEMUFileCloseFunc *close;
161 QEMUFileRateLimit *rate_limit;
Glauber Costa19629532009-05-20 18:26:57 -0400162 QEMUFileSetRateLimit *set_rate_limit;
aliguoria672b462008-11-11 21:33:36 +0000163 void *opaque;
164 int is_write;
165
166 int64_t buf_offset; /* start of buffer when writing, end of buffer
167 when reading */
168 int buf_index;
169 int buf_size; /* 0 when writing */
170 uint8_t buf[IO_BUF_SIZE];
171
172 int has_error;
173};
174
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200175typedef struct QEMUFileStdio
aliguoria672b462008-11-11 21:33:36 +0000176{
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200177 FILE *stdio_file;
aliguoria672b462008-11-11 21:33:36 +0000178 QEMUFile *file;
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200179} QEMUFileStdio;
aliguoria672b462008-11-11 21:33:36 +0000180
181typedef struct QEMUFileSocket
182{
183 int fd;
184 QEMUFile *file;
185} QEMUFileSocket;
186
187static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
188{
189 QEMUFileSocket *s = opaque;
190 ssize_t len;
191
192 do {
Blue Swirlc5b76b32009-06-13 08:44:31 +0000193 len = recv(s->fd, (void *)buf, size, 0);
aliguoria672b462008-11-11 21:33:36 +0000194 } while (len == -1 && socket_error() == EINTR);
195
196 if (len == -1)
197 len = -socket_error();
198
199 return len;
200}
201
202static int socket_close(void *opaque)
203{
204 QEMUFileSocket *s = opaque;
205 qemu_free(s);
206 return 0;
207}
208
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200209static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
aliguoria672b462008-11-11 21:33:36 +0000210{
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200211 QEMUFileStdio *s = opaque;
212 return fwrite(buf, 1, size, s->stdio_file);
aliguoria672b462008-11-11 21:33:36 +0000213}
214
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200215static int stdio_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
aliguoria672b462008-11-11 21:33:36 +0000216{
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200217 QEMUFileStdio *s = opaque;
218 FILE *fp = s->stdio_file;
Uri Lublin8a67ec42009-06-08 19:27:21 +0300219 int bytes;
220
221 do {
222 clearerr(fp);
223 bytes = fread(buf, 1, size, fp);
224 } while ((bytes == 0) && ferror(fp) && (errno == EINTR));
225 return bytes;
aliguoria672b462008-11-11 21:33:36 +0000226}
227
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200228static int stdio_pclose(void *opaque)
aliguoria672b462008-11-11 21:33:36 +0000229{
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200230 QEMUFileStdio *s = opaque;
231 pclose(s->stdio_file);
aliguoria672b462008-11-11 21:33:36 +0000232 qemu_free(s);
233 return 0;
234}
235
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200236static int stdio_fclose(void *opaque)
aliguoria672b462008-11-11 21:33:36 +0000237{
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200238 QEMUFileStdio *s = opaque;
239 fclose(s->stdio_file);
240 qemu_free(s);
241 return 0;
242}
aliguoria672b462008-11-11 21:33:36 +0000243
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200244QEMUFile *qemu_popen(FILE *stdio_file, const char *mode)
245{
246 QEMUFileStdio *s;
247
248 if (stdio_file == NULL || mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
aliguoria672b462008-11-11 21:33:36 +0000249 fprintf(stderr, "qemu_popen: Argument validity check failed\n");
250 return NULL;
251 }
252
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200253 s = qemu_mallocz(sizeof(QEMUFileStdio));
aliguoria672b462008-11-11 21:33:36 +0000254
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200255 s->stdio_file = stdio_file;
aliguoria672b462008-11-11 21:33:36 +0000256
257 if(mode[0] == 'r') {
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200258 s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_pclose, NULL, NULL);
aliguoria672b462008-11-11 21:33:36 +0000259 } else {
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200260 s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_pclose, NULL, NULL);
aliguoria672b462008-11-11 21:33:36 +0000261 }
aliguoria672b462008-11-11 21:33:36 +0000262 return s->file;
263}
264
265QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
266{
267 FILE *popen_file;
268
269 popen_file = popen(command, mode);
270 if(popen_file == NULL) {
271 return NULL;
272 }
273
274 return qemu_popen(popen_file, mode);
275}
276
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200277int qemu_stdio_fd(QEMUFile *f)
Chris Lalancette8a43b1e2009-05-25 16:38:23 +0200278{
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200279 QEMUFileStdio *p;
Chris Lalancette8a43b1e2009-05-25 16:38:23 +0200280 int fd;
281
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200282 p = (QEMUFileStdio *)f->opaque;
283 fd = fileno(p->stdio_file);
Chris Lalancette8a43b1e2009-05-25 16:38:23 +0200284
285 return fd;
286}
287
aliguoria672b462008-11-11 21:33:36 +0000288QEMUFile *qemu_fopen_socket(int fd)
289{
290 QEMUFileSocket *s = qemu_mallocz(sizeof(QEMUFileSocket));
291
aliguoria672b462008-11-11 21:33:36 +0000292 s->fd = fd;
Glauber Costa19629532009-05-20 18:26:57 -0400293 s->file = qemu_fopen_ops(s, NULL, socket_get_buffer, socket_close, NULL, NULL);
aliguoria672b462008-11-11 21:33:36 +0000294 return s->file;
295}
296
aliguoria672b462008-11-11 21:33:36 +0000297static int file_put_buffer(void *opaque, const uint8_t *buf,
298 int64_t pos, int size)
299{
300 QEMUFileStdio *s = opaque;
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200301 fseek(s->stdio_file, pos, SEEK_SET);
302 fwrite(buf, 1, size, s->stdio_file);
aliguoria672b462008-11-11 21:33:36 +0000303 return size;
304}
305
306static int file_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
307{
308 QEMUFileStdio *s = opaque;
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200309 fseek(s->stdio_file, pos, SEEK_SET);
310 return fread(buf, 1, size, s->stdio_file);
aliguoria672b462008-11-11 21:33:36 +0000311}
312
313QEMUFile *qemu_fopen(const char *filename, const char *mode)
314{
315 QEMUFileStdio *s;
316
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200317 if (mode == NULL ||
318 (mode[0] != 'r' && mode[0] != 'w') ||
319 mode[1] != 'b' || mode[2] != 0) {
320 fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
321 return NULL;
322 }
323
aliguoria672b462008-11-11 21:33:36 +0000324 s = qemu_mallocz(sizeof(QEMUFileStdio));
aliguoria672b462008-11-11 21:33:36 +0000325
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200326 s->stdio_file = fopen(filename, mode);
327 if (!s->stdio_file)
aliguoria672b462008-11-11 21:33:36 +0000328 goto fail;
329
Paolo Bonzini7f79dd22009-08-12 14:17:35 +0200330 if(mode[0] == 'w') {
331 s->file = qemu_fopen_ops(s, file_put_buffer, NULL, stdio_fclose, NULL, NULL);
332 } else {
333 s->file = qemu_fopen_ops(s, NULL, file_get_buffer, stdio_fclose, NULL, NULL);
334 }
335 return s->file;
aliguoria672b462008-11-11 21:33:36 +0000336fail:
aliguoria672b462008-11-11 21:33:36 +0000337 qemu_free(s);
338 return NULL;
339}
340
aliguori178e08a2009-04-05 19:10:55 +0000341static int block_put_buffer(void *opaque, const uint8_t *buf,
aliguoria672b462008-11-11 21:33:36 +0000342 int64_t pos, int size)
343{
Christoph Hellwig45566e92009-07-10 23:11:57 +0200344 bdrv_save_vmstate(opaque, buf, pos, size);
aliguoria672b462008-11-11 21:33:36 +0000345 return size;
346}
347
aliguori178e08a2009-04-05 19:10:55 +0000348static int block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
aliguoria672b462008-11-11 21:33:36 +0000349{
Christoph Hellwig45566e92009-07-10 23:11:57 +0200350 return bdrv_load_vmstate(opaque, buf, pos, size);
aliguoria672b462008-11-11 21:33:36 +0000351}
352
353static int bdrv_fclose(void *opaque)
354{
aliguoria672b462008-11-11 21:33:36 +0000355 return 0;
356}
357
Christoph Hellwig45566e92009-07-10 23:11:57 +0200358static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
aliguoria672b462008-11-11 21:33:36 +0000359{
aliguoria672b462008-11-11 21:33:36 +0000360 if (is_writable)
Christoph Hellwig45566e92009-07-10 23:11:57 +0200361 return qemu_fopen_ops(bs, block_put_buffer, NULL, bdrv_fclose, NULL, NULL);
362 return qemu_fopen_ops(bs, NULL, block_get_buffer, bdrv_fclose, NULL, NULL);
aliguoria672b462008-11-11 21:33:36 +0000363}
364
365QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
366 QEMUFileGetBufferFunc *get_buffer,
367 QEMUFileCloseFunc *close,
Glauber Costa19629532009-05-20 18:26:57 -0400368 QEMUFileRateLimit *rate_limit,
369 QEMUFileSetRateLimit *set_rate_limit)
aliguoria672b462008-11-11 21:33:36 +0000370{
371 QEMUFile *f;
372
373 f = qemu_mallocz(sizeof(QEMUFile));
aliguoria672b462008-11-11 21:33:36 +0000374
375 f->opaque = opaque;
376 f->put_buffer = put_buffer;
377 f->get_buffer = get_buffer;
378 f->close = close;
379 f->rate_limit = rate_limit;
Glauber Costa19629532009-05-20 18:26:57 -0400380 f->set_rate_limit = set_rate_limit;
aliguoria672b462008-11-11 21:33:36 +0000381 f->is_write = 0;
382
383 return f;
384}
385
386int qemu_file_has_error(QEMUFile *f)
387{
388 return f->has_error;
389}
390
aliguori4dabe242009-04-05 19:30:51 +0000391void qemu_file_set_error(QEMUFile *f)
392{
393 f->has_error = 1;
394}
395
aliguoria672b462008-11-11 21:33:36 +0000396void qemu_fflush(QEMUFile *f)
397{
398 if (!f->put_buffer)
399 return;
400
401 if (f->is_write && f->buf_index > 0) {
402 int len;
403
404 len = f->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
405 if (len > 0)
406 f->buf_offset += f->buf_index;
407 else
408 f->has_error = 1;
409 f->buf_index = 0;
410 }
411}
412
413static void qemu_fill_buffer(QEMUFile *f)
414{
415 int len;
416
417 if (!f->get_buffer)
418 return;
419
420 if (f->is_write)
421 abort();
422
423 len = f->get_buffer(f->opaque, f->buf, f->buf_offset, IO_BUF_SIZE);
424 if (len > 0) {
425 f->buf_index = 0;
426 f->buf_size = len;
427 f->buf_offset += len;
428 } else if (len != -EAGAIN)
429 f->has_error = 1;
430}
431
432int qemu_fclose(QEMUFile *f)
433{
434 int ret = 0;
435 qemu_fflush(f);
436 if (f->close)
437 ret = f->close(f->opaque);
438 qemu_free(f);
439 return ret;
440}
441
442void qemu_file_put_notify(QEMUFile *f)
443{
444 f->put_buffer(f->opaque, NULL, 0, 0);
445}
446
447void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
448{
449 int l;
450
451 if (!f->has_error && f->is_write == 0 && f->buf_index > 0) {
452 fprintf(stderr,
453 "Attempted to write to buffer while read buffer is not empty\n");
454 abort();
455 }
456
457 while (!f->has_error && size > 0) {
458 l = IO_BUF_SIZE - f->buf_index;
459 if (l > size)
460 l = size;
461 memcpy(f->buf + f->buf_index, buf, l);
462 f->is_write = 1;
463 f->buf_index += l;
464 buf += l;
465 size -= l;
466 if (f->buf_index >= IO_BUF_SIZE)
467 qemu_fflush(f);
468 }
469}
470
471void qemu_put_byte(QEMUFile *f, int v)
472{
473 if (!f->has_error && f->is_write == 0 && f->buf_index > 0) {
474 fprintf(stderr,
475 "Attempted to write to buffer while read buffer is not empty\n");
476 abort();
477 }
478
479 f->buf[f->buf_index++] = v;
480 f->is_write = 1;
481 if (f->buf_index >= IO_BUF_SIZE)
482 qemu_fflush(f);
483}
484
485int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
486{
487 int size, l;
488
489 if (f->is_write)
490 abort();
491
492 size = size1;
493 while (size > 0) {
494 l = f->buf_size - f->buf_index;
495 if (l == 0) {
496 qemu_fill_buffer(f);
497 l = f->buf_size - f->buf_index;
498 if (l == 0)
499 break;
500 }
501 if (l > size)
502 l = size;
503 memcpy(buf, f->buf + f->buf_index, l);
504 f->buf_index += l;
505 buf += l;
506 size -= l;
507 }
508 return size1 - size;
509}
510
511int qemu_get_byte(QEMUFile *f)
512{
513 if (f->is_write)
514 abort();
515
516 if (f->buf_index >= f->buf_size) {
517 qemu_fill_buffer(f);
518 if (f->buf_index >= f->buf_size)
519 return 0;
520 }
521 return f->buf[f->buf_index++];
522}
523
524int64_t qemu_ftell(QEMUFile *f)
525{
526 return f->buf_offset - f->buf_size + f->buf_index;
527}
528
529int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
530{
531 if (whence == SEEK_SET) {
532 /* nothing to do */
533 } else if (whence == SEEK_CUR) {
534 pos += qemu_ftell(f);
535 } else {
536 /* SEEK_END not supported */
537 return -1;
538 }
539 if (f->put_buffer) {
540 qemu_fflush(f);
541 f->buf_offset = pos;
542 } else {
543 f->buf_offset = pos;
544 f->buf_index = 0;
545 f->buf_size = 0;
546 }
547 return pos;
548}
549
550int qemu_file_rate_limit(QEMUFile *f)
551{
552 if (f->rate_limit)
553 return f->rate_limit(f->opaque);
554
555 return 0;
556}
557
Glauber Costa19629532009-05-20 18:26:57 -0400558size_t qemu_file_set_rate_limit(QEMUFile *f, size_t new_rate)
559{
Glauber Costa0bb05ea2009-07-14 18:26:51 -0400560 /* any failed or completed migration keeps its state to allow probing of
561 * migration data, but has no associated file anymore */
562 if (f && f->set_rate_limit)
Glauber Costa19629532009-05-20 18:26:57 -0400563 return f->set_rate_limit(f->opaque, new_rate);
564
565 return 0;
566}
567
aliguoria672b462008-11-11 21:33:36 +0000568void qemu_put_be16(QEMUFile *f, unsigned int v)
569{
570 qemu_put_byte(f, v >> 8);
571 qemu_put_byte(f, v);
572}
573
574void qemu_put_be32(QEMUFile *f, unsigned int v)
575{
576 qemu_put_byte(f, v >> 24);
577 qemu_put_byte(f, v >> 16);
578 qemu_put_byte(f, v >> 8);
579 qemu_put_byte(f, v);
580}
581
582void qemu_put_be64(QEMUFile *f, uint64_t v)
583{
584 qemu_put_be32(f, v >> 32);
585 qemu_put_be32(f, v);
586}
587
588unsigned int qemu_get_be16(QEMUFile *f)
589{
590 unsigned int v;
591 v = qemu_get_byte(f) << 8;
592 v |= qemu_get_byte(f);
593 return v;
594}
595
596unsigned int qemu_get_be32(QEMUFile *f)
597{
598 unsigned int v;
599 v = qemu_get_byte(f) << 24;
600 v |= qemu_get_byte(f) << 16;
601 v |= qemu_get_byte(f) << 8;
602 v |= qemu_get_byte(f);
603 return v;
604}
605
606uint64_t qemu_get_be64(QEMUFile *f)
607{
608 uint64_t v;
609 v = (uint64_t)qemu_get_be32(f) << 32;
610 v |= qemu_get_be32(f);
611 return v;
612}
613
614typedef struct SaveStateEntry {
615 char idstr[256];
616 int instance_id;
617 int version_id;
618 int section_id;
619 SaveLiveStateHandler *save_live_state;
620 SaveStateHandler *save_state;
621 LoadStateHandler *load_state;
622 void *opaque;
623 struct SaveStateEntry *next;
624} SaveStateEntry;
625
626static SaveStateEntry *first_se;
627
628/* TODO: Individual devices generally have very little idea about the rest
629 of the system, so instance_id should be removed/replaced.
630 Meanwhile pass -1 as instance_id if you do not already have a clearly
631 distinguishing id for all instances of your device class. */
632int register_savevm_live(const char *idstr,
633 int instance_id,
634 int version_id,
635 SaveLiveStateHandler *save_live_state,
636 SaveStateHandler *save_state,
637 LoadStateHandler *load_state,
638 void *opaque)
639{
640 SaveStateEntry *se, **pse;
641 static int global_section_id;
642
643 se = qemu_malloc(sizeof(SaveStateEntry));
aliguoria672b462008-11-11 21:33:36 +0000644 pstrcpy(se->idstr, sizeof(se->idstr), idstr);
645 se->instance_id = (instance_id == -1) ? 0 : instance_id;
646 se->version_id = version_id;
647 se->section_id = global_section_id++;
648 se->save_live_state = save_live_state;
649 se->save_state = save_state;
650 se->load_state = load_state;
651 se->opaque = opaque;
652 se->next = NULL;
653
654 /* add at the end of list */
655 pse = &first_se;
656 while (*pse != NULL) {
657 if (instance_id == -1
658 && strcmp(se->idstr, (*pse)->idstr) == 0
659 && se->instance_id <= (*pse)->instance_id)
660 se->instance_id = (*pse)->instance_id + 1;
661 pse = &(*pse)->next;
662 }
663 *pse = se;
664 return 0;
665}
666
667int register_savevm(const char *idstr,
668 int instance_id,
669 int version_id,
670 SaveStateHandler *save_state,
671 LoadStateHandler *load_state,
672 void *opaque)
673{
674 return register_savevm_live(idstr, instance_id, version_id,
675 NULL, save_state, load_state, opaque);
676}
677
aliguori41bd13a2009-04-17 17:10:59 +0000678void unregister_savevm(const char *idstr, void *opaque)
679{
680 SaveStateEntry **pse;
681
682 pse = &first_se;
683 while (*pse != NULL) {
684 if (strcmp((*pse)->idstr, idstr) == 0 && (*pse)->opaque == opaque) {
685 SaveStateEntry *next = (*pse)->next;
686 qemu_free(*pse);
687 *pse = next;
688 continue;
689 }
690 pse = &(*pse)->next;
691 }
692}
693
aliguoria672b462008-11-11 21:33:36 +0000694#define QEMU_VM_FILE_MAGIC 0x5145564d
695#define QEMU_VM_FILE_VERSION_COMPAT 0x00000002
696#define QEMU_VM_FILE_VERSION 0x00000003
697
698#define QEMU_VM_EOF 0x00
699#define QEMU_VM_SECTION_START 0x01
700#define QEMU_VM_SECTION_PART 0x02
701#define QEMU_VM_SECTION_END 0x03
702#define QEMU_VM_SECTION_FULL 0x04
703
704int qemu_savevm_state_begin(QEMUFile *f)
705{
706 SaveStateEntry *se;
707
708 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
709 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
710
711 for (se = first_se; se != NULL; se = se->next) {
712 int len;
713
714 if (se->save_live_state == NULL)
715 continue;
716
717 /* Section type */
718 qemu_put_byte(f, QEMU_VM_SECTION_START);
719 qemu_put_be32(f, se->section_id);
720
721 /* ID string */
722 len = strlen(se->idstr);
723 qemu_put_byte(f, len);
724 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
725
726 qemu_put_be32(f, se->instance_id);
727 qemu_put_be32(f, se->version_id);
728
729 se->save_live_state(f, QEMU_VM_SECTION_START, se->opaque);
730 }
731
732 if (qemu_file_has_error(f))
733 return -EIO;
734
735 return 0;
736}
737
738int qemu_savevm_state_iterate(QEMUFile *f)
739{
740 SaveStateEntry *se;
741 int ret = 1;
742
743 for (se = first_se; se != NULL; se = se->next) {
744 if (se->save_live_state == NULL)
745 continue;
746
747 /* Section type */
748 qemu_put_byte(f, QEMU_VM_SECTION_PART);
749 qemu_put_be32(f, se->section_id);
750
751 ret &= !!se->save_live_state(f, QEMU_VM_SECTION_PART, se->opaque);
752 }
753
754 if (ret)
755 return 1;
756
757 if (qemu_file_has_error(f))
758 return -EIO;
759
760 return 0;
761}
762
763int qemu_savevm_state_complete(QEMUFile *f)
764{
765 SaveStateEntry *se;
766
767 for (se = first_se; se != NULL; se = se->next) {
768 if (se->save_live_state == NULL)
769 continue;
770
771 /* Section type */
772 qemu_put_byte(f, QEMU_VM_SECTION_END);
773 qemu_put_be32(f, se->section_id);
774
775 se->save_live_state(f, QEMU_VM_SECTION_END, se->opaque);
776 }
777
778 for(se = first_se; se != NULL; se = se->next) {
779 int len;
780
781 if (se->save_state == NULL)
782 continue;
783
784 /* Section type */
785 qemu_put_byte(f, QEMU_VM_SECTION_FULL);
786 qemu_put_be32(f, se->section_id);
787
788 /* ID string */
789 len = strlen(se->idstr);
790 qemu_put_byte(f, len);
791 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
792
793 qemu_put_be32(f, se->instance_id);
794 qemu_put_be32(f, se->version_id);
795
796 se->save_state(f, se->opaque);
797 }
798
799 qemu_put_byte(f, QEMU_VM_EOF);
800
801 if (qemu_file_has_error(f))
802 return -EIO;
803
804 return 0;
805}
806
807int qemu_savevm_state(QEMUFile *f)
808{
809 int saved_vm_running;
810 int ret;
811
812 saved_vm_running = vm_running;
813 vm_stop(0);
814
815 bdrv_flush_all();
816
817 ret = qemu_savevm_state_begin(f);
818 if (ret < 0)
819 goto out;
820
821 do {
822 ret = qemu_savevm_state_iterate(f);
823 if (ret < 0)
824 goto out;
825 } while (ret == 0);
826
827 ret = qemu_savevm_state_complete(f);
828
829out:
830 if (qemu_file_has_error(f))
831 ret = -EIO;
832
833 if (!ret && saved_vm_running)
834 vm_start();
835
836 return ret;
837}
838
839static SaveStateEntry *find_se(const char *idstr, int instance_id)
840{
841 SaveStateEntry *se;
842
843 for(se = first_se; se != NULL; se = se->next) {
844 if (!strcmp(se->idstr, idstr) &&
845 instance_id == se->instance_id)
846 return se;
847 }
848 return NULL;
849}
850
851typedef struct LoadStateEntry {
852 SaveStateEntry *se;
853 int section_id;
854 int version_id;
855 struct LoadStateEntry *next;
856} LoadStateEntry;
857
858static int qemu_loadvm_state_v2(QEMUFile *f)
859{
860 SaveStateEntry *se;
861 int len, ret, instance_id, record_len, version_id;
862 int64_t total_len, end_pos, cur_pos;
863 char idstr[256];
864
865 total_len = qemu_get_be64(f);
866 end_pos = total_len + qemu_ftell(f);
867 for(;;) {
868 if (qemu_ftell(f) >= end_pos)
869 break;
870 len = qemu_get_byte(f);
871 qemu_get_buffer(f, (uint8_t *)idstr, len);
872 idstr[len] = '\0';
873 instance_id = qemu_get_be32(f);
874 version_id = qemu_get_be32(f);
875 record_len = qemu_get_be32(f);
876 cur_pos = qemu_ftell(f);
877 se = find_se(idstr, instance_id);
878 if (!se) {
879 fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
880 instance_id, idstr);
881 } else {
882 ret = se->load_state(f, se->opaque, version_id);
883 if (ret < 0) {
884 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
885 instance_id, idstr);
Anthony Liguorid02f7092009-05-01 09:36:03 -0500886 return ret;
aliguoria672b462008-11-11 21:33:36 +0000887 }
888 }
889 /* always seek to exact end of record */
890 qemu_fseek(f, cur_pos + record_len, SEEK_SET);
891 }
892
893 if (qemu_file_has_error(f))
894 return -EIO;
895
896 return 0;
897}
898
899int qemu_loadvm_state(QEMUFile *f)
900{
901 LoadStateEntry *first_le = NULL;
902 uint8_t section_type;
903 unsigned int v;
904 int ret;
905
906 v = qemu_get_be32(f);
907 if (v != QEMU_VM_FILE_MAGIC)
908 return -EINVAL;
909
910 v = qemu_get_be32(f);
911 if (v == QEMU_VM_FILE_VERSION_COMPAT)
912 return qemu_loadvm_state_v2(f);
913 if (v != QEMU_VM_FILE_VERSION)
914 return -ENOTSUP;
915
916 while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
917 uint32_t instance_id, version_id, section_id;
918 LoadStateEntry *le;
919 SaveStateEntry *se;
920 char idstr[257];
921 int len;
922
923 switch (section_type) {
924 case QEMU_VM_SECTION_START:
925 case QEMU_VM_SECTION_FULL:
926 /* Read section start */
927 section_id = qemu_get_be32(f);
928 len = qemu_get_byte(f);
929 qemu_get_buffer(f, (uint8_t *)idstr, len);
930 idstr[len] = 0;
931 instance_id = qemu_get_be32(f);
932 version_id = qemu_get_be32(f);
933
934 /* Find savevm section */
935 se = find_se(idstr, instance_id);
936 if (se == NULL) {
937 fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
938 ret = -EINVAL;
939 goto out;
940 }
941
942 /* Validate version */
943 if (version_id > se->version_id) {
944 fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
945 version_id, idstr, se->version_id);
946 ret = -EINVAL;
947 goto out;
948 }
949
950 /* Add entry */
951 le = qemu_mallocz(sizeof(*le));
aliguoria672b462008-11-11 21:33:36 +0000952
953 le->se = se;
954 le->section_id = section_id;
955 le->version_id = version_id;
956 le->next = first_le;
957 first_le = le;
958
959 le->se->load_state(f, le->se->opaque, le->version_id);
960 break;
961 case QEMU_VM_SECTION_PART:
962 case QEMU_VM_SECTION_END:
963 section_id = qemu_get_be32(f);
964
965 for (le = first_le; le && le->section_id != section_id; le = le->next);
966 if (le == NULL) {
967 fprintf(stderr, "Unknown savevm section %d\n", section_id);
968 ret = -EINVAL;
969 goto out;
970 }
971
972 le->se->load_state(f, le->se->opaque, le->version_id);
973 break;
974 default:
975 fprintf(stderr, "Unknown savevm section type %d\n", section_type);
976 ret = -EINVAL;
977 goto out;
978 }
979 }
980
981 ret = 0;
982
983out:
984 while (first_le) {
985 LoadStateEntry *le = first_le;
986 first_le = first_le->next;
987 qemu_free(le);
988 }
989
990 if (qemu_file_has_error(f))
991 ret = -EIO;
992
993 return ret;
994}
995
996/* device can contain snapshots */
997static int bdrv_can_snapshot(BlockDriverState *bs)
998{
999 return (bs &&
1000 !bdrv_is_removable(bs) &&
1001 !bdrv_is_read_only(bs));
1002}
1003
1004/* device must be snapshots in order to have a reliable snapshot */
1005static int bdrv_has_snapshot(BlockDriverState *bs)
1006{
1007 return (bs &&
1008 !bdrv_is_removable(bs) &&
1009 !bdrv_is_read_only(bs));
1010}
1011
1012static BlockDriverState *get_bs_snapshots(void)
1013{
1014 BlockDriverState *bs;
Gerd Hoffmann751c6a12009-07-22 16:42:57 +02001015 DriveInfo *dinfo;
aliguoria672b462008-11-11 21:33:36 +00001016
1017 if (bs_snapshots)
1018 return bs_snapshots;
Gerd Hoffmann751c6a12009-07-22 16:42:57 +02001019 TAILQ_FOREACH(dinfo, &drives, next) {
1020 bs = dinfo->bdrv;
aliguoria672b462008-11-11 21:33:36 +00001021 if (bdrv_can_snapshot(bs))
1022 goto ok;
1023 }
1024 return NULL;
1025 ok:
1026 bs_snapshots = bs;
1027 return bs;
1028}
1029
1030static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
1031 const char *name)
1032{
1033 QEMUSnapshotInfo *sn_tab, *sn;
1034 int nb_sns, i, ret;
1035
1036 ret = -ENOENT;
1037 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1038 if (nb_sns < 0)
1039 return ret;
1040 for(i = 0; i < nb_sns; i++) {
1041 sn = &sn_tab[i];
1042 if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
1043 *sn_info = *sn;
1044 ret = 0;
1045 break;
1046 }
1047 }
1048 qemu_free(sn_tab);
1049 return ret;
1050}
1051
aliguori376253e2009-03-05 23:01:23 +00001052void do_savevm(Monitor *mon, const char *name)
aliguoria672b462008-11-11 21:33:36 +00001053{
Gerd Hoffmann751c6a12009-07-22 16:42:57 +02001054 DriveInfo *dinfo;
aliguoria672b462008-11-11 21:33:36 +00001055 BlockDriverState *bs, *bs1;
1056 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
Gerd Hoffmann751c6a12009-07-22 16:42:57 +02001057 int must_delete, ret;
aliguoria672b462008-11-11 21:33:36 +00001058 QEMUFile *f;
1059 int saved_vm_running;
aliguori2d22b182008-12-11 21:06:49 +00001060 uint32_t vm_state_size;
aliguoria672b462008-11-11 21:33:36 +00001061#ifdef _WIN32
1062 struct _timeb tb;
1063#else
1064 struct timeval tv;
1065#endif
1066
1067 bs = get_bs_snapshots();
1068 if (!bs) {
aliguori376253e2009-03-05 23:01:23 +00001069 monitor_printf(mon, "No block device can accept snapshots\n");
aliguoria672b462008-11-11 21:33:36 +00001070 return;
1071 }
1072
1073 /* ??? Should this occur after vm_stop? */
1074 qemu_aio_flush();
1075
1076 saved_vm_running = vm_running;
1077 vm_stop(0);
1078
1079 must_delete = 0;
1080 if (name) {
1081 ret = bdrv_snapshot_find(bs, old_sn, name);
1082 if (ret >= 0) {
1083 must_delete = 1;
1084 }
1085 }
1086 memset(sn, 0, sizeof(*sn));
1087 if (must_delete) {
1088 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
1089 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
1090 } else {
1091 if (name)
1092 pstrcpy(sn->name, sizeof(sn->name), name);
1093 }
1094
1095 /* fill auxiliary fields */
1096#ifdef _WIN32
1097 _ftime(&tb);
1098 sn->date_sec = tb.time;
1099 sn->date_nsec = tb.millitm * 1000000;
1100#else
1101 gettimeofday(&tv, NULL);
1102 sn->date_sec = tv.tv_sec;
1103 sn->date_nsec = tv.tv_usec * 1000;
1104#endif
1105 sn->vm_clock_nsec = qemu_get_clock(vm_clock);
1106
aliguoria672b462008-11-11 21:33:36 +00001107 /* save the VM state */
Christoph Hellwig45566e92009-07-10 23:11:57 +02001108 f = qemu_fopen_bdrv(bs, 1);
aliguoria672b462008-11-11 21:33:36 +00001109 if (!f) {
aliguori376253e2009-03-05 23:01:23 +00001110 monitor_printf(mon, "Could not open VM state file\n");
aliguoria672b462008-11-11 21:33:36 +00001111 goto the_end;
1112 }
1113 ret = qemu_savevm_state(f);
aliguori2d22b182008-12-11 21:06:49 +00001114 vm_state_size = qemu_ftell(f);
aliguoria672b462008-11-11 21:33:36 +00001115 qemu_fclose(f);
1116 if (ret < 0) {
aliguori376253e2009-03-05 23:01:23 +00001117 monitor_printf(mon, "Error %d while writing VM\n", ret);
aliguoria672b462008-11-11 21:33:36 +00001118 goto the_end;
1119 }
1120
1121 /* create the snapshots */
1122
Gerd Hoffmann751c6a12009-07-22 16:42:57 +02001123 TAILQ_FOREACH(dinfo, &drives, next) {
1124 bs1 = dinfo->bdrv;
aliguoria672b462008-11-11 21:33:36 +00001125 if (bdrv_has_snapshot(bs1)) {
1126 if (must_delete) {
1127 ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
1128 if (ret < 0) {
aliguori376253e2009-03-05 23:01:23 +00001129 monitor_printf(mon,
1130 "Error while deleting snapshot on '%s'\n",
1131 bdrv_get_device_name(bs1));
aliguoria672b462008-11-11 21:33:36 +00001132 }
1133 }
aliguori2d22b182008-12-11 21:06:49 +00001134 /* Write VM state size only to the image that contains the state */
1135 sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
aliguoria672b462008-11-11 21:33:36 +00001136 ret = bdrv_snapshot_create(bs1, sn);
1137 if (ret < 0) {
aliguori376253e2009-03-05 23:01:23 +00001138 monitor_printf(mon, "Error while creating snapshot on '%s'\n",
1139 bdrv_get_device_name(bs1));
aliguoria672b462008-11-11 21:33:36 +00001140 }
1141 }
1142 }
1143
1144 the_end:
1145 if (saved_vm_running)
1146 vm_start();
1147}
1148
aliguori376253e2009-03-05 23:01:23 +00001149void do_loadvm(Monitor *mon, const char *name)
aliguoria672b462008-11-11 21:33:36 +00001150{
Gerd Hoffmann751c6a12009-07-22 16:42:57 +02001151 DriveInfo *dinfo;
aliguoria672b462008-11-11 21:33:36 +00001152 BlockDriverState *bs, *bs1;
aliguori2d22b182008-12-11 21:06:49 +00001153 QEMUSnapshotInfo sn;
aliguoria672b462008-11-11 21:33:36 +00001154 QEMUFile *f;
Gerd Hoffmann751c6a12009-07-22 16:42:57 +02001155 int ret;
aliguoria672b462008-11-11 21:33:36 +00001156 int saved_vm_running;
1157
1158 bs = get_bs_snapshots();
1159 if (!bs) {
aliguori376253e2009-03-05 23:01:23 +00001160 monitor_printf(mon, "No block device supports snapshots\n");
aliguoria672b462008-11-11 21:33:36 +00001161 return;
1162 }
1163
1164 /* Flush all IO requests so they don't interfere with the new state. */
1165 qemu_aio_flush();
1166
1167 saved_vm_running = vm_running;
1168 vm_stop(0);
1169
Gerd Hoffmann751c6a12009-07-22 16:42:57 +02001170 TAILQ_FOREACH(dinfo, &drives, next) {
1171 bs1 = dinfo->bdrv;
aliguoria672b462008-11-11 21:33:36 +00001172 if (bdrv_has_snapshot(bs1)) {
1173 ret = bdrv_snapshot_goto(bs1, name);
1174 if (ret < 0) {
1175 if (bs != bs1)
aliguori376253e2009-03-05 23:01:23 +00001176 monitor_printf(mon, "Warning: ");
aliguoria672b462008-11-11 21:33:36 +00001177 switch(ret) {
1178 case -ENOTSUP:
aliguori376253e2009-03-05 23:01:23 +00001179 monitor_printf(mon,
1180 "Snapshots not supported on device '%s'\n",
1181 bdrv_get_device_name(bs1));
aliguoria672b462008-11-11 21:33:36 +00001182 break;
1183 case -ENOENT:
aliguori376253e2009-03-05 23:01:23 +00001184 monitor_printf(mon, "Could not find snapshot '%s' on "
1185 "device '%s'\n",
1186 name, bdrv_get_device_name(bs1));
aliguoria672b462008-11-11 21:33:36 +00001187 break;
1188 default:
aliguori376253e2009-03-05 23:01:23 +00001189 monitor_printf(mon, "Error %d while activating snapshot on"
1190 " '%s'\n", ret, bdrv_get_device_name(bs1));
aliguoria672b462008-11-11 21:33:36 +00001191 break;
1192 }
1193 /* fatal on snapshot block device */
1194 if (bs == bs1)
1195 goto the_end;
1196 }
1197 }
1198 }
1199
aliguori2d22b182008-12-11 21:06:49 +00001200 /* Don't even try to load empty VM states */
1201 ret = bdrv_snapshot_find(bs, &sn, name);
1202 if ((ret >= 0) && (sn.vm_state_size == 0))
1203 goto the_end;
1204
aliguoria672b462008-11-11 21:33:36 +00001205 /* restore the VM state */
Christoph Hellwig45566e92009-07-10 23:11:57 +02001206 f = qemu_fopen_bdrv(bs, 0);
aliguoria672b462008-11-11 21:33:36 +00001207 if (!f) {
aliguori376253e2009-03-05 23:01:23 +00001208 monitor_printf(mon, "Could not open VM state file\n");
aliguoria672b462008-11-11 21:33:36 +00001209 goto the_end;
1210 }
1211 ret = qemu_loadvm_state(f);
1212 qemu_fclose(f);
1213 if (ret < 0) {
aliguori376253e2009-03-05 23:01:23 +00001214 monitor_printf(mon, "Error %d while loading VM state\n", ret);
aliguoria672b462008-11-11 21:33:36 +00001215 }
1216 the_end:
1217 if (saved_vm_running)
1218 vm_start();
1219}
1220
aliguori376253e2009-03-05 23:01:23 +00001221void do_delvm(Monitor *mon, const char *name)
aliguoria672b462008-11-11 21:33:36 +00001222{
Gerd Hoffmann751c6a12009-07-22 16:42:57 +02001223 DriveInfo *dinfo;
aliguoria672b462008-11-11 21:33:36 +00001224 BlockDriverState *bs, *bs1;
Gerd Hoffmann751c6a12009-07-22 16:42:57 +02001225 int ret;
aliguoria672b462008-11-11 21:33:36 +00001226
1227 bs = get_bs_snapshots();
1228 if (!bs) {
aliguori376253e2009-03-05 23:01:23 +00001229 monitor_printf(mon, "No block device supports snapshots\n");
aliguoria672b462008-11-11 21:33:36 +00001230 return;
1231 }
1232
Gerd Hoffmann751c6a12009-07-22 16:42:57 +02001233 TAILQ_FOREACH(dinfo, &drives, next) {
1234 bs1 = dinfo->bdrv;
aliguoria672b462008-11-11 21:33:36 +00001235 if (bdrv_has_snapshot(bs1)) {
1236 ret = bdrv_snapshot_delete(bs1, name);
1237 if (ret < 0) {
1238 if (ret == -ENOTSUP)
aliguori376253e2009-03-05 23:01:23 +00001239 monitor_printf(mon,
1240 "Snapshots not supported on device '%s'\n",
1241 bdrv_get_device_name(bs1));
aliguoria672b462008-11-11 21:33:36 +00001242 else
aliguori376253e2009-03-05 23:01:23 +00001243 monitor_printf(mon, "Error %d while deleting snapshot on "
1244 "'%s'\n", ret, bdrv_get_device_name(bs1));
aliguoria672b462008-11-11 21:33:36 +00001245 }
1246 }
1247 }
1248}
1249
aliguori376253e2009-03-05 23:01:23 +00001250void do_info_snapshots(Monitor *mon)
aliguoria672b462008-11-11 21:33:36 +00001251{
Gerd Hoffmann751c6a12009-07-22 16:42:57 +02001252 DriveInfo *dinfo;
aliguoria672b462008-11-11 21:33:36 +00001253 BlockDriverState *bs, *bs1;
1254 QEMUSnapshotInfo *sn_tab, *sn;
1255 int nb_sns, i;
1256 char buf[256];
1257
1258 bs = get_bs_snapshots();
1259 if (!bs) {
aliguori376253e2009-03-05 23:01:23 +00001260 monitor_printf(mon, "No available block device supports snapshots\n");
aliguoria672b462008-11-11 21:33:36 +00001261 return;
1262 }
aliguori376253e2009-03-05 23:01:23 +00001263 monitor_printf(mon, "Snapshot devices:");
Gerd Hoffmann751c6a12009-07-22 16:42:57 +02001264 TAILQ_FOREACH(dinfo, &drives, next) {
1265 bs1 = dinfo->bdrv;
aliguoria672b462008-11-11 21:33:36 +00001266 if (bdrv_has_snapshot(bs1)) {
1267 if (bs == bs1)
aliguori376253e2009-03-05 23:01:23 +00001268 monitor_printf(mon, " %s", bdrv_get_device_name(bs1));
aliguoria672b462008-11-11 21:33:36 +00001269 }
1270 }
aliguori376253e2009-03-05 23:01:23 +00001271 monitor_printf(mon, "\n");
aliguoria672b462008-11-11 21:33:36 +00001272
1273 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1274 if (nb_sns < 0) {
aliguori376253e2009-03-05 23:01:23 +00001275 monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
aliguoria672b462008-11-11 21:33:36 +00001276 return;
1277 }
aliguori376253e2009-03-05 23:01:23 +00001278 monitor_printf(mon, "Snapshot list (from %s):\n",
1279 bdrv_get_device_name(bs));
1280 monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
aliguoria672b462008-11-11 21:33:36 +00001281 for(i = 0; i < nb_sns; i++) {
1282 sn = &sn_tab[i];
aliguori376253e2009-03-05 23:01:23 +00001283 monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
aliguoria672b462008-11-11 21:33:36 +00001284 }
1285 qemu_free(sn_tab);
1286}