File:  [Qemu by Fabrice Bellard] / qemu / savevm.c
Revision 1.1.1.9 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:33:41 2018 UTC (19 months, 2 weeks ago) by root
Branches: qemu, MAIN
CVS tags: qemu0150, qemu0141, qemu0140, HEAD
qemu 0.14.0

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

unix.superglobalmegacorp.com