Win32: Reduce section alignment for Windows.
[armpft.git] / savevm.c
blob17da35a9fbaf7ba80953ce8a357b8feb9dcdf1f2
1 /*
2 * QEMU System Emulator
4 * Copyright (c) 2003-2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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.
24 #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>
32 /* Needed early for HOST_BSD etc. */
33 #include "config-host.h"
35 #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>
55 #ifdef HOST_BSD
56 #include <sys/stat.h>
57 #if defined(__FreeBSD__) || defined(__DragonFly__)
58 #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
73 #ifdef _WIN32
74 #include <windows.h>
75 #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
82 #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"
94 /* point to the block driver where the snapshots are managed */
95 static BlockDriverState *bs_snapshots;
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
102 static int announce_self_create(uint8_t *buf,
103 uint8_t *mac_addr)
105 uint32_t magic = EXPERIMENTAL_MAGIC;
106 uint16_t proto = htons(ETH_P_EXPERIMENTAL);
108 /* FIXME: should we send a different packet (arp/rarp/ping)? */
110 memset(buf, 0, 64);
111 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 */
116 return 64; /* len */
119 static void qemu_announce_self_once(void *opaque)
121 int i, len;
122 VLANState *vlan;
123 VLANClientState *vc;
124 uint8_t buf[256];
125 static int count = SELF_ANNOUNCE_ROUNDS;
126 QEMUTimer *timer = *(QEMUTimer **)opaque;
128 for (i = 0; i < MAX_NICS; i++) {
129 if (!nd_table[i].used)
130 continue;
131 len = announce_self_create(buf, nd_table[i].macaddr);
132 vlan = nd_table[i].vlan;
133 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
134 vc->receive(vc, buf, len);
137 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);
145 void qemu_announce_self(void)
147 static QEMUTimer *timer;
148 timer = qemu_new_timer(rt_clock, qemu_announce_self_once, &timer);
149 qemu_announce_self_once(&timer);
152 /***********************************************************/
153 /* savevm/loadvm support */
155 #define IO_BUF_SIZE 32768
157 struct QEMUFile {
158 QEMUFilePutBufferFunc *put_buffer;
159 QEMUFileGetBufferFunc *get_buffer;
160 QEMUFileCloseFunc *close;
161 QEMUFileRateLimit *rate_limit;
162 QEMUFileSetRateLimit *set_rate_limit;
163 void *opaque;
164 int is_write;
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];
172 int has_error;
175 typedef struct QEMUFilePopen
177 FILE *popen_file;
178 QEMUFile *file;
179 } QEMUFilePopen;
181 typedef struct QEMUFileSocket
183 int fd;
184 QEMUFile *file;
185 } QEMUFileSocket;
187 static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
189 QEMUFileSocket *s = opaque;
190 ssize_t len;
192 do {
193 len = recv(s->fd, (void *)buf, size, 0);
194 } while (len == -1 && socket_error() == EINTR);
196 if (len == -1)
197 len = -socket_error();
199 return len;
202 static int socket_close(void *opaque)
204 QEMUFileSocket *s = opaque;
205 qemu_free(s);
206 return 0;
209 static int popen_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
211 QEMUFilePopen *s = opaque;
212 return fwrite(buf, 1, size, s->popen_file);
215 static int popen_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
217 QEMUFilePopen *s = opaque;
218 FILE *fp = s->popen_file;
219 int bytes;
221 do {
222 clearerr(fp);
223 bytes = fread(buf, 1, size, fp);
224 } while ((bytes == 0) && ferror(fp) && (errno == EINTR));
225 return bytes;
228 static int popen_close(void *opaque)
230 QEMUFilePopen *s = opaque;
231 pclose(s->popen_file);
232 qemu_free(s);
233 return 0;
236 QEMUFile *qemu_popen(FILE *popen_file, const char *mode)
238 QEMUFilePopen *s;
240 if (popen_file == NULL || mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
241 fprintf(stderr, "qemu_popen: Argument validity check failed\n");
242 return NULL;
245 s = qemu_mallocz(sizeof(QEMUFilePopen));
247 s->popen_file = popen_file;
249 if(mode[0] == 'r') {
250 s->file = qemu_fopen_ops(s, NULL, popen_get_buffer, popen_close, NULL, NULL);
251 } else {
252 s->file = qemu_fopen_ops(s, popen_put_buffer, NULL, popen_close, NULL, NULL);
254 return s->file;
257 QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
259 FILE *popen_file;
261 popen_file = popen(command, mode);
262 if(popen_file == NULL) {
263 return NULL;
266 return qemu_popen(popen_file, mode);
269 int qemu_popen_fd(QEMUFile *f)
271 QEMUFilePopen *p;
272 int fd;
274 p = (QEMUFilePopen *)f->opaque;
275 fd = fileno(p->popen_file);
277 return fd;
280 QEMUFile *qemu_fopen_socket(int fd)
282 QEMUFileSocket *s = qemu_mallocz(sizeof(QEMUFileSocket));
284 s->fd = fd;
285 s->file = qemu_fopen_ops(s, NULL, socket_get_buffer, socket_close, NULL, NULL);
286 return s->file;
289 typedef struct QEMUFileStdio
291 FILE *outfile;
292 } QEMUFileStdio;
294 static int file_put_buffer(void *opaque, const uint8_t *buf,
295 int64_t pos, int size)
297 QEMUFileStdio *s = opaque;
298 fseek(s->outfile, pos, SEEK_SET);
299 fwrite(buf, 1, size, s->outfile);
300 return size;
303 static int file_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
305 QEMUFileStdio *s = opaque;
306 fseek(s->outfile, pos, SEEK_SET);
307 return fread(buf, 1, size, s->outfile);
310 static int file_close(void *opaque)
312 QEMUFileStdio *s = opaque;
313 fclose(s->outfile);
314 qemu_free(s);
315 return 0;
318 QEMUFile *qemu_fopen(const char *filename, const char *mode)
320 QEMUFileStdio *s;
322 s = qemu_mallocz(sizeof(QEMUFileStdio));
324 s->outfile = fopen(filename, mode);
325 if (!s->outfile)
326 goto fail;
328 if (!strcmp(mode, "wb"))
329 return qemu_fopen_ops(s, file_put_buffer, NULL, file_close, NULL, NULL);
330 else if (!strcmp(mode, "rb"))
331 return qemu_fopen_ops(s, NULL, file_get_buffer, file_close, NULL, NULL);
333 fail:
334 if (s->outfile)
335 fclose(s->outfile);
336 qemu_free(s);
337 return NULL;
340 typedef struct QEMUFileBdrv
342 BlockDriverState *bs;
343 int64_t base_offset;
344 } QEMUFileBdrv;
346 static int block_put_buffer(void *opaque, const uint8_t *buf,
347 int64_t pos, int size)
349 QEMUFileBdrv *s = opaque;
350 bdrv_put_buffer(s->bs, buf, s->base_offset + pos, size);
351 return size;
354 static int block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
356 QEMUFileBdrv *s = opaque;
357 return bdrv_get_buffer(s->bs, buf, s->base_offset + pos, size);
360 static int bdrv_fclose(void *opaque)
362 QEMUFileBdrv *s = opaque;
363 qemu_free(s);
364 return 0;
367 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int64_t offset, int is_writable)
369 QEMUFileBdrv *s;
371 s = qemu_mallocz(sizeof(QEMUFileBdrv));
373 s->bs = bs;
374 s->base_offset = offset;
376 if (is_writable)
377 return qemu_fopen_ops(s, block_put_buffer, NULL, bdrv_fclose, NULL, NULL);
379 return qemu_fopen_ops(s, NULL, block_get_buffer, bdrv_fclose, NULL, NULL);
382 QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
383 QEMUFileGetBufferFunc *get_buffer,
384 QEMUFileCloseFunc *close,
385 QEMUFileRateLimit *rate_limit,
386 QEMUFileSetRateLimit *set_rate_limit)
388 QEMUFile *f;
390 f = qemu_mallocz(sizeof(QEMUFile));
392 f->opaque = opaque;
393 f->put_buffer = put_buffer;
394 f->get_buffer = get_buffer;
395 f->close = close;
396 f->rate_limit = rate_limit;
397 f->set_rate_limit = set_rate_limit;
398 f->is_write = 0;
400 return f;
403 int qemu_file_has_error(QEMUFile *f)
405 return f->has_error;
408 void qemu_file_set_error(QEMUFile *f)
410 f->has_error = 1;
413 void qemu_fflush(QEMUFile *f)
415 if (!f->put_buffer)
416 return;
418 if (f->is_write && f->buf_index > 0) {
419 int len;
421 len = f->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
422 if (len > 0)
423 f->buf_offset += f->buf_index;
424 else
425 f->has_error = 1;
426 f->buf_index = 0;
430 static void qemu_fill_buffer(QEMUFile *f)
432 int len;
434 if (!f->get_buffer)
435 return;
437 if (f->is_write)
438 abort();
440 len = f->get_buffer(f->opaque, f->buf, f->buf_offset, IO_BUF_SIZE);
441 if (len > 0) {
442 f->buf_index = 0;
443 f->buf_size = len;
444 f->buf_offset += len;
445 } else if (len != -EAGAIN)
446 f->has_error = 1;
449 int qemu_fclose(QEMUFile *f)
451 int ret = 0;
452 qemu_fflush(f);
453 if (f->close)
454 ret = f->close(f->opaque);
455 qemu_free(f);
456 return ret;
459 void qemu_file_put_notify(QEMUFile *f)
461 f->put_buffer(f->opaque, NULL, 0, 0);
464 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
466 int l;
468 if (!f->has_error && f->is_write == 0 && f->buf_index > 0) {
469 fprintf(stderr,
470 "Attempted to write to buffer while read buffer is not empty\n");
471 abort();
474 while (!f->has_error && size > 0) {
475 l = IO_BUF_SIZE - f->buf_index;
476 if (l > size)
477 l = size;
478 memcpy(f->buf + f->buf_index, buf, l);
479 f->is_write = 1;
480 f->buf_index += l;
481 buf += l;
482 size -= l;
483 if (f->buf_index >= IO_BUF_SIZE)
484 qemu_fflush(f);
488 void qemu_put_byte(QEMUFile *f, int v)
490 if (!f->has_error && f->is_write == 0 && f->buf_index > 0) {
491 fprintf(stderr,
492 "Attempted to write to buffer while read buffer is not empty\n");
493 abort();
496 f->buf[f->buf_index++] = v;
497 f->is_write = 1;
498 if (f->buf_index >= IO_BUF_SIZE)
499 qemu_fflush(f);
502 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
504 int size, l;
506 if (f->is_write)
507 abort();
509 size = size1;
510 while (size > 0) {
511 l = f->buf_size - f->buf_index;
512 if (l == 0) {
513 qemu_fill_buffer(f);
514 l = f->buf_size - f->buf_index;
515 if (l == 0)
516 break;
518 if (l > size)
519 l = size;
520 memcpy(buf, f->buf + f->buf_index, l);
521 f->buf_index += l;
522 buf += l;
523 size -= l;
525 return size1 - size;
528 int qemu_get_byte(QEMUFile *f)
530 if (f->is_write)
531 abort();
533 if (f->buf_index >= f->buf_size) {
534 qemu_fill_buffer(f);
535 if (f->buf_index >= f->buf_size)
536 return 0;
538 return f->buf[f->buf_index++];
541 int64_t qemu_ftell(QEMUFile *f)
543 return f->buf_offset - f->buf_size + f->buf_index;
546 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
548 if (whence == SEEK_SET) {
549 /* nothing to do */
550 } else if (whence == SEEK_CUR) {
551 pos += qemu_ftell(f);
552 } else {
553 /* SEEK_END not supported */
554 return -1;
556 if (f->put_buffer) {
557 qemu_fflush(f);
558 f->buf_offset = pos;
559 } else {
560 f->buf_offset = pos;
561 f->buf_index = 0;
562 f->buf_size = 0;
564 return pos;
567 int qemu_file_rate_limit(QEMUFile *f)
569 if (f->rate_limit)
570 return f->rate_limit(f->opaque);
572 return 0;
575 size_t qemu_file_set_rate_limit(QEMUFile *f, size_t new_rate)
577 if (f->set_rate_limit)
578 return f->set_rate_limit(f->opaque, new_rate);
580 return 0;
583 void qemu_put_be16(QEMUFile *f, unsigned int v)
585 qemu_put_byte(f, v >> 8);
586 qemu_put_byte(f, v);
589 void qemu_put_be32(QEMUFile *f, unsigned int v)
591 qemu_put_byte(f, v >> 24);
592 qemu_put_byte(f, v >> 16);
593 qemu_put_byte(f, v >> 8);
594 qemu_put_byte(f, v);
597 void qemu_put_be64(QEMUFile *f, uint64_t v)
599 qemu_put_be32(f, v >> 32);
600 qemu_put_be32(f, v);
603 unsigned int qemu_get_be16(QEMUFile *f)
605 unsigned int v;
606 v = qemu_get_byte(f) << 8;
607 v |= qemu_get_byte(f);
608 return v;
611 unsigned int qemu_get_be32(QEMUFile *f)
613 unsigned int v;
614 v = qemu_get_byte(f) << 24;
615 v |= qemu_get_byte(f) << 16;
616 v |= qemu_get_byte(f) << 8;
617 v |= qemu_get_byte(f);
618 return v;
621 uint64_t qemu_get_be64(QEMUFile *f)
623 uint64_t v;
624 v = (uint64_t)qemu_get_be32(f) << 32;
625 v |= qemu_get_be32(f);
626 return v;
629 typedef struct SaveStateEntry {
630 char idstr[256];
631 int instance_id;
632 int version_id;
633 int section_id;
634 SaveLiveStateHandler *save_live_state;
635 SaveStateHandler *save_state;
636 LoadStateHandler *load_state;
637 void *opaque;
638 struct SaveStateEntry *next;
639 } SaveStateEntry;
641 static SaveStateEntry *first_se;
643 /* TODO: Individual devices generally have very little idea about the rest
644 of the system, so instance_id should be removed/replaced.
645 Meanwhile pass -1 as instance_id if you do not already have a clearly
646 distinguishing id for all instances of your device class. */
647 int register_savevm_live(const char *idstr,
648 int instance_id,
649 int version_id,
650 SaveLiveStateHandler *save_live_state,
651 SaveStateHandler *save_state,
652 LoadStateHandler *load_state,
653 void *opaque)
655 SaveStateEntry *se, **pse;
656 static int global_section_id;
658 se = qemu_malloc(sizeof(SaveStateEntry));
659 pstrcpy(se->idstr, sizeof(se->idstr), idstr);
660 se->instance_id = (instance_id == -1) ? 0 : instance_id;
661 se->version_id = version_id;
662 se->section_id = global_section_id++;
663 se->save_live_state = save_live_state;
664 se->save_state = save_state;
665 se->load_state = load_state;
666 se->opaque = opaque;
667 se->next = NULL;
669 /* add at the end of list */
670 pse = &first_se;
671 while (*pse != NULL) {
672 if (instance_id == -1
673 && strcmp(se->idstr, (*pse)->idstr) == 0
674 && se->instance_id <= (*pse)->instance_id)
675 se->instance_id = (*pse)->instance_id + 1;
676 pse = &(*pse)->next;
678 *pse = se;
679 return 0;
682 int register_savevm(const char *idstr,
683 int instance_id,
684 int version_id,
685 SaveStateHandler *save_state,
686 LoadStateHandler *load_state,
687 void *opaque)
689 return register_savevm_live(idstr, instance_id, version_id,
690 NULL, save_state, load_state, opaque);
693 void unregister_savevm(const char *idstr, void *opaque)
695 SaveStateEntry **pse;
697 pse = &first_se;
698 while (*pse != NULL) {
699 if (strcmp((*pse)->idstr, idstr) == 0 && (*pse)->opaque == opaque) {
700 SaveStateEntry *next = (*pse)->next;
701 qemu_free(*pse);
702 *pse = next;
703 continue;
705 pse = &(*pse)->next;
709 #define QEMU_VM_FILE_MAGIC 0x5145564d
710 #define QEMU_VM_FILE_VERSION_COMPAT 0x00000002
711 #define QEMU_VM_FILE_VERSION 0x00000003
713 #define QEMU_VM_EOF 0x00
714 #define QEMU_VM_SECTION_START 0x01
715 #define QEMU_VM_SECTION_PART 0x02
716 #define QEMU_VM_SECTION_END 0x03
717 #define QEMU_VM_SECTION_FULL 0x04
719 int qemu_savevm_state_begin(QEMUFile *f)
721 SaveStateEntry *se;
723 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
724 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
726 for (se = first_se; se != NULL; se = se->next) {
727 int len;
729 if (se->save_live_state == NULL)
730 continue;
732 /* Section type */
733 qemu_put_byte(f, QEMU_VM_SECTION_START);
734 qemu_put_be32(f, se->section_id);
736 /* ID string */
737 len = strlen(se->idstr);
738 qemu_put_byte(f, len);
739 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
741 qemu_put_be32(f, se->instance_id);
742 qemu_put_be32(f, se->version_id);
744 se->save_live_state(f, QEMU_VM_SECTION_START, se->opaque);
747 if (qemu_file_has_error(f))
748 return -EIO;
750 return 0;
753 int qemu_savevm_state_iterate(QEMUFile *f)
755 SaveStateEntry *se;
756 int ret = 1;
758 for (se = first_se; se != NULL; se = se->next) {
759 if (se->save_live_state == NULL)
760 continue;
762 /* Section type */
763 qemu_put_byte(f, QEMU_VM_SECTION_PART);
764 qemu_put_be32(f, se->section_id);
766 ret &= !!se->save_live_state(f, QEMU_VM_SECTION_PART, se->opaque);
769 if (ret)
770 return 1;
772 if (qemu_file_has_error(f))
773 return -EIO;
775 return 0;
778 int qemu_savevm_state_complete(QEMUFile *f)
780 SaveStateEntry *se;
782 for (se = first_se; se != NULL; se = se->next) {
783 if (se->save_live_state == NULL)
784 continue;
786 /* Section type */
787 qemu_put_byte(f, QEMU_VM_SECTION_END);
788 qemu_put_be32(f, se->section_id);
790 se->save_live_state(f, QEMU_VM_SECTION_END, se->opaque);
793 for(se = first_se; se != NULL; se = se->next) {
794 int len;
796 if (se->save_state == NULL)
797 continue;
799 /* Section type */
800 qemu_put_byte(f, QEMU_VM_SECTION_FULL);
801 qemu_put_be32(f, se->section_id);
803 /* ID string */
804 len = strlen(se->idstr);
805 qemu_put_byte(f, len);
806 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
808 qemu_put_be32(f, se->instance_id);
809 qemu_put_be32(f, se->version_id);
811 se->save_state(f, se->opaque);
814 qemu_put_byte(f, QEMU_VM_EOF);
816 if (qemu_file_has_error(f))
817 return -EIO;
819 return 0;
822 int qemu_savevm_state(QEMUFile *f)
824 int saved_vm_running;
825 int ret;
827 saved_vm_running = vm_running;
828 vm_stop(0);
830 bdrv_flush_all();
832 ret = qemu_savevm_state_begin(f);
833 if (ret < 0)
834 goto out;
836 do {
837 ret = qemu_savevm_state_iterate(f);
838 if (ret < 0)
839 goto out;
840 } while (ret == 0);
842 ret = qemu_savevm_state_complete(f);
844 out:
845 if (qemu_file_has_error(f))
846 ret = -EIO;
848 if (!ret && saved_vm_running)
849 vm_start();
851 return ret;
854 static SaveStateEntry *find_se(const char *idstr, int instance_id)
856 SaveStateEntry *se;
858 for(se = first_se; se != NULL; se = se->next) {
859 if (!strcmp(se->idstr, idstr) &&
860 instance_id == se->instance_id)
861 return se;
863 return NULL;
866 typedef struct LoadStateEntry {
867 SaveStateEntry *se;
868 int section_id;
869 int version_id;
870 struct LoadStateEntry *next;
871 } LoadStateEntry;
873 static int qemu_loadvm_state_v2(QEMUFile *f)
875 SaveStateEntry *se;
876 int len, ret, instance_id, record_len, version_id;
877 int64_t total_len, end_pos, cur_pos;
878 char idstr[256];
880 total_len = qemu_get_be64(f);
881 end_pos = total_len + qemu_ftell(f);
882 for(;;) {
883 if (qemu_ftell(f) >= end_pos)
884 break;
885 len = qemu_get_byte(f);
886 qemu_get_buffer(f, (uint8_t *)idstr, len);
887 idstr[len] = '\0';
888 instance_id = qemu_get_be32(f);
889 version_id = qemu_get_be32(f);
890 record_len = qemu_get_be32(f);
891 cur_pos = qemu_ftell(f);
892 se = find_se(idstr, instance_id);
893 if (!se) {
894 fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
895 instance_id, idstr);
896 } else {
897 ret = se->load_state(f, se->opaque, version_id);
898 if (ret < 0) {
899 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
900 instance_id, idstr);
901 return ret;
904 /* always seek to exact end of record */
905 qemu_fseek(f, cur_pos + record_len, SEEK_SET);
908 if (qemu_file_has_error(f))
909 return -EIO;
911 return 0;
914 int qemu_loadvm_state(QEMUFile *f)
916 LoadStateEntry *first_le = NULL;
917 uint8_t section_type;
918 unsigned int v;
919 int ret;
921 v = qemu_get_be32(f);
922 if (v != QEMU_VM_FILE_MAGIC)
923 return -EINVAL;
925 v = qemu_get_be32(f);
926 if (v == QEMU_VM_FILE_VERSION_COMPAT)
927 return qemu_loadvm_state_v2(f);
928 if (v != QEMU_VM_FILE_VERSION)
929 return -ENOTSUP;
931 while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
932 uint32_t instance_id, version_id, section_id;
933 LoadStateEntry *le;
934 SaveStateEntry *se;
935 char idstr[257];
936 int len;
938 switch (section_type) {
939 case QEMU_VM_SECTION_START:
940 case QEMU_VM_SECTION_FULL:
941 /* Read section start */
942 section_id = qemu_get_be32(f);
943 len = qemu_get_byte(f);
944 qemu_get_buffer(f, (uint8_t *)idstr, len);
945 idstr[len] = 0;
946 instance_id = qemu_get_be32(f);
947 version_id = qemu_get_be32(f);
949 /* Find savevm section */
950 se = find_se(idstr, instance_id);
951 if (se == NULL) {
952 fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
953 ret = -EINVAL;
954 goto out;
957 /* Validate version */
958 if (version_id > se->version_id) {
959 fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
960 version_id, idstr, se->version_id);
961 ret = -EINVAL;
962 goto out;
965 /* Add entry */
966 le = qemu_mallocz(sizeof(*le));
968 le->se = se;
969 le->section_id = section_id;
970 le->version_id = version_id;
971 le->next = first_le;
972 first_le = le;
974 le->se->load_state(f, le->se->opaque, le->version_id);
975 break;
976 case QEMU_VM_SECTION_PART:
977 case QEMU_VM_SECTION_END:
978 section_id = qemu_get_be32(f);
980 for (le = first_le; le && le->section_id != section_id; le = le->next);
981 if (le == NULL) {
982 fprintf(stderr, "Unknown savevm section %d\n", section_id);
983 ret = -EINVAL;
984 goto out;
987 le->se->load_state(f, le->se->opaque, le->version_id);
988 break;
989 default:
990 fprintf(stderr, "Unknown savevm section type %d\n", section_type);
991 ret = -EINVAL;
992 goto out;
996 ret = 0;
998 out:
999 while (first_le) {
1000 LoadStateEntry *le = first_le;
1001 first_le = first_le->next;
1002 qemu_free(le);
1005 if (qemu_file_has_error(f))
1006 ret = -EIO;
1008 return ret;
1011 /* device can contain snapshots */
1012 static int bdrv_can_snapshot(BlockDriverState *bs)
1014 return (bs &&
1015 !bdrv_is_removable(bs) &&
1016 !bdrv_is_read_only(bs));
1019 /* device must be snapshots in order to have a reliable snapshot */
1020 static int bdrv_has_snapshot(BlockDriverState *bs)
1022 return (bs &&
1023 !bdrv_is_removable(bs) &&
1024 !bdrv_is_read_only(bs));
1027 static BlockDriverState *get_bs_snapshots(void)
1029 BlockDriverState *bs;
1030 int i;
1032 if (bs_snapshots)
1033 return bs_snapshots;
1034 for(i = 0; i <= nb_drives; i++) {
1035 bs = drives_table[i].bdrv;
1036 if (bdrv_can_snapshot(bs))
1037 goto ok;
1039 return NULL;
1041 bs_snapshots = bs;
1042 return bs;
1045 static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
1046 const char *name)
1048 QEMUSnapshotInfo *sn_tab, *sn;
1049 int nb_sns, i, ret;
1051 ret = -ENOENT;
1052 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1053 if (nb_sns < 0)
1054 return ret;
1055 for(i = 0; i < nb_sns; i++) {
1056 sn = &sn_tab[i];
1057 if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
1058 *sn_info = *sn;
1059 ret = 0;
1060 break;
1063 qemu_free(sn_tab);
1064 return ret;
1067 void do_savevm(Monitor *mon, const char *name)
1069 BlockDriverState *bs, *bs1;
1070 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
1071 int must_delete, ret, i;
1072 BlockDriverInfo bdi1, *bdi = &bdi1;
1073 QEMUFile *f;
1074 int saved_vm_running;
1075 uint32_t vm_state_size;
1076 #ifdef _WIN32
1077 struct _timeb tb;
1078 #else
1079 struct timeval tv;
1080 #endif
1082 bs = get_bs_snapshots();
1083 if (!bs) {
1084 monitor_printf(mon, "No block device can accept snapshots\n");
1085 return;
1088 /* ??? Should this occur after vm_stop? */
1089 qemu_aio_flush();
1091 saved_vm_running = vm_running;
1092 vm_stop(0);
1094 must_delete = 0;
1095 if (name) {
1096 ret = bdrv_snapshot_find(bs, old_sn, name);
1097 if (ret >= 0) {
1098 must_delete = 1;
1101 memset(sn, 0, sizeof(*sn));
1102 if (must_delete) {
1103 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
1104 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
1105 } else {
1106 if (name)
1107 pstrcpy(sn->name, sizeof(sn->name), name);
1110 /* fill auxiliary fields */
1111 #ifdef _WIN32
1112 _ftime(&tb);
1113 sn->date_sec = tb.time;
1114 sn->date_nsec = tb.millitm * 1000000;
1115 #else
1116 gettimeofday(&tv, NULL);
1117 sn->date_sec = tv.tv_sec;
1118 sn->date_nsec = tv.tv_usec * 1000;
1119 #endif
1120 sn->vm_clock_nsec = qemu_get_clock(vm_clock);
1122 if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
1123 monitor_printf(mon, "Device %s does not support VM state snapshots\n",
1124 bdrv_get_device_name(bs));
1125 goto the_end;
1128 /* save the VM state */
1129 f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
1130 if (!f) {
1131 monitor_printf(mon, "Could not open VM state file\n");
1132 goto the_end;
1134 ret = qemu_savevm_state(f);
1135 vm_state_size = qemu_ftell(f);
1136 qemu_fclose(f);
1137 if (ret < 0) {
1138 monitor_printf(mon, "Error %d while writing VM\n", ret);
1139 goto the_end;
1142 /* create the snapshots */
1144 for(i = 0; i < nb_drives; i++) {
1145 bs1 = drives_table[i].bdrv;
1146 if (bdrv_has_snapshot(bs1)) {
1147 if (must_delete) {
1148 ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
1149 if (ret < 0) {
1150 monitor_printf(mon,
1151 "Error while deleting snapshot on '%s'\n",
1152 bdrv_get_device_name(bs1));
1155 /* Write VM state size only to the image that contains the state */
1156 sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
1157 ret = bdrv_snapshot_create(bs1, sn);
1158 if (ret < 0) {
1159 monitor_printf(mon, "Error while creating snapshot on '%s'\n",
1160 bdrv_get_device_name(bs1));
1165 the_end:
1166 if (saved_vm_running)
1167 vm_start();
1170 void do_loadvm(Monitor *mon, const char *name)
1172 BlockDriverState *bs, *bs1;
1173 BlockDriverInfo bdi1, *bdi = &bdi1;
1174 QEMUSnapshotInfo sn;
1175 QEMUFile *f;
1176 int i, ret;
1177 int saved_vm_running;
1179 bs = get_bs_snapshots();
1180 if (!bs) {
1181 monitor_printf(mon, "No block device supports snapshots\n");
1182 return;
1185 /* Flush all IO requests so they don't interfere with the new state. */
1186 qemu_aio_flush();
1188 saved_vm_running = vm_running;
1189 vm_stop(0);
1191 for(i = 0; i <= nb_drives; i++) {
1192 bs1 = drives_table[i].bdrv;
1193 if (bdrv_has_snapshot(bs1)) {
1194 ret = bdrv_snapshot_goto(bs1, name);
1195 if (ret < 0) {
1196 if (bs != bs1)
1197 monitor_printf(mon, "Warning: ");
1198 switch(ret) {
1199 case -ENOTSUP:
1200 monitor_printf(mon,
1201 "Snapshots not supported on device '%s'\n",
1202 bdrv_get_device_name(bs1));
1203 break;
1204 case -ENOENT:
1205 monitor_printf(mon, "Could not find snapshot '%s' on "
1206 "device '%s'\n",
1207 name, bdrv_get_device_name(bs1));
1208 break;
1209 default:
1210 monitor_printf(mon, "Error %d while activating snapshot on"
1211 " '%s'\n", ret, bdrv_get_device_name(bs1));
1212 break;
1214 /* fatal on snapshot block device */
1215 if (bs == bs1)
1216 goto the_end;
1221 if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
1222 monitor_printf(mon, "Device %s does not support VM state snapshots\n",
1223 bdrv_get_device_name(bs));
1224 return;
1227 /* Don't even try to load empty VM states */
1228 ret = bdrv_snapshot_find(bs, &sn, name);
1229 if ((ret >= 0) && (sn.vm_state_size == 0))
1230 goto the_end;
1232 /* restore the VM state */
1233 f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
1234 if (!f) {
1235 monitor_printf(mon, "Could not open VM state file\n");
1236 goto the_end;
1238 ret = qemu_loadvm_state(f);
1239 qemu_fclose(f);
1240 if (ret < 0) {
1241 monitor_printf(mon, "Error %d while loading VM state\n", ret);
1243 the_end:
1244 if (saved_vm_running)
1245 vm_start();
1248 void do_delvm(Monitor *mon, const char *name)
1250 BlockDriverState *bs, *bs1;
1251 int i, ret;
1253 bs = get_bs_snapshots();
1254 if (!bs) {
1255 monitor_printf(mon, "No block device supports snapshots\n");
1256 return;
1259 for(i = 0; i <= nb_drives; i++) {
1260 bs1 = drives_table[i].bdrv;
1261 if (bdrv_has_snapshot(bs1)) {
1262 ret = bdrv_snapshot_delete(bs1, name);
1263 if (ret < 0) {
1264 if (ret == -ENOTSUP)
1265 monitor_printf(mon,
1266 "Snapshots not supported on device '%s'\n",
1267 bdrv_get_device_name(bs1));
1268 else
1269 monitor_printf(mon, "Error %d while deleting snapshot on "
1270 "'%s'\n", ret, bdrv_get_device_name(bs1));
1276 void do_info_snapshots(Monitor *mon)
1278 BlockDriverState *bs, *bs1;
1279 QEMUSnapshotInfo *sn_tab, *sn;
1280 int nb_sns, i;
1281 char buf[256];
1283 bs = get_bs_snapshots();
1284 if (!bs) {
1285 monitor_printf(mon, "No available block device supports snapshots\n");
1286 return;
1288 monitor_printf(mon, "Snapshot devices:");
1289 for(i = 0; i <= nb_drives; i++) {
1290 bs1 = drives_table[i].bdrv;
1291 if (bdrv_has_snapshot(bs1)) {
1292 if (bs == bs1)
1293 monitor_printf(mon, " %s", bdrv_get_device_name(bs1));
1296 monitor_printf(mon, "\n");
1298 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1299 if (nb_sns < 0) {
1300 monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
1301 return;
1303 monitor_printf(mon, "Snapshot list (from %s):\n",
1304 bdrv_get_device_name(bs));
1305 monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1306 for(i = 0; i < nb_sns; i++) {
1307 sn = &sn_tab[i];
1308 monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1310 qemu_free(sn_tab);