File:  [Qemu by Fabrice Bellard] / qemu / savevm.c
Revision 1.1.1.10 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:55:59 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu1000, qemu0151, HEAD
qemu 0.15.1

    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 <time.h>
   27: #include <errno.h>
   28: #include <sys/time.h>
   29: #include <zlib.h>
   30: 
   31: /* Needed early for CONFIG_BSD etc. */
   32: #include "config-host.h"
   33: 
   34: #ifndef _WIN32
   35: #include <sys/times.h>
   36: #include <sys/wait.h>
   37: #include <termios.h>
   38: #include <sys/mman.h>
   39: #include <sys/ioctl.h>
   40: #include <sys/resource.h>
   41: #include <sys/socket.h>
   42: #include <netinet/in.h>
   43: #include <net/if.h>
   44: #include <arpa/inet.h>
   45: #include <dirent.h>
   46: #include <netdb.h>
   47: #include <sys/select.h>
   48: #ifdef CONFIG_BSD
   49: #include <sys/stat.h>
   50: #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
   51: #include <libutil.h>
   52: #else
   53: #include <util.h>
   54: #endif
   55: #ifdef __linux__
   56: #include <pty.h>
   57: #include <malloc.h>
   58: #include <linux/rtc.h>
   59: #endif
   60: #endif
   61: #endif
   62: 
   63: #ifdef _WIN32
   64: #include <windows.h>
   65: #include <malloc.h>
   66: #include <sys/timeb.h>
   67: #include <mmsystem.h>
   68: #define getopt_long_only getopt_long
   69: #define memalign(align, size) malloc(size)
   70: #endif
   71: 
   72: #include "qemu-common.h"
   73: #include "hw/hw.h"
   74: #include "hw/qdev.h"
   75: #include "net.h"
   76: #include "monitor.h"
   77: #include "sysemu.h"
   78: #include "qemu-timer.h"
   79: #include "qemu-char.h"
   80: #include "audio/audio.h"
   81: #include "migration.h"
   82: #include "qemu_socket.h"
   83: #include "qemu-queue.h"
   84: #include "cpus.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_ms(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_ms(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 = qemu_recv(s->fd, 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: /* 32 bit uint. See that the received value is the same than the one
  886:    in the field */
  887: 
  888: static int get_uint32_equal(QEMUFile *f, void *pv, size_t size)
  889: {
  890:     uint32_t *v = pv;
  891:     uint32_t v2;
  892:     qemu_get_be32s(f, &v2);
  893: 
  894:     if (*v == v2) {
  895:         return 0;
  896:     }
  897:     return -EINVAL;
  898: }
  899: 
  900: const VMStateInfo vmstate_info_uint32_equal = {
  901:     .name = "uint32 equal",
  902:     .get  = get_uint32_equal,
  903:     .put  = put_uint32,
  904: };
  905: 
  906: /* 64 bit unsigned int */
  907: 
  908: static int get_uint64(QEMUFile *f, void *pv, size_t size)
  909: {
  910:     uint64_t *v = pv;
  911:     qemu_get_be64s(f, v);
  912:     return 0;
  913: }
  914: 
  915: static void put_uint64(QEMUFile *f, void *pv, size_t size)
  916: {
  917:     uint64_t *v = pv;
  918:     qemu_put_be64s(f, v);
  919: }
  920: 
  921: const VMStateInfo vmstate_info_uint64 = {
  922:     .name = "uint64",
  923:     .get  = get_uint64,
  924:     .put  = put_uint64,
  925: };
  926: 
  927: /* 8 bit int. See that the received value is the same than the one
  928:    in the field */
  929: 
  930: static int get_uint8_equal(QEMUFile *f, void *pv, size_t size)
  931: {
  932:     uint8_t *v = pv;
  933:     uint8_t v2;
  934:     qemu_get_8s(f, &v2);
  935: 
  936:     if (*v == v2)
  937:         return 0;
  938:     return -EINVAL;
  939: }
  940: 
  941: const VMStateInfo vmstate_info_uint8_equal = {
  942:     .name = "uint8 equal",
  943:     .get  = get_uint8_equal,
  944:     .put  = put_uint8,
  945: };
  946: 
  947: /* 16 bit unsigned int int. See that the received value is the same than the one
  948:    in the field */
  949: 
  950: static int get_uint16_equal(QEMUFile *f, void *pv, size_t size)
  951: {
  952:     uint16_t *v = pv;
  953:     uint16_t v2;
  954:     qemu_get_be16s(f, &v2);
  955: 
  956:     if (*v == v2)
  957:         return 0;
  958:     return -EINVAL;
  959: }
  960: 
  961: const VMStateInfo vmstate_info_uint16_equal = {
  962:     .name = "uint16 equal",
  963:     .get  = get_uint16_equal,
  964:     .put  = put_uint16,
  965: };
  966: 
  967: /* timers  */
  968: 
  969: static int get_timer(QEMUFile *f, void *pv, size_t size)
  970: {
  971:     QEMUTimer *v = pv;
  972:     qemu_get_timer(f, v);
  973:     return 0;
  974: }
  975: 
  976: static void put_timer(QEMUFile *f, void *pv, size_t size)
  977: {
  978:     QEMUTimer *v = pv;
  979:     qemu_put_timer(f, v);
  980: }
  981: 
  982: const VMStateInfo vmstate_info_timer = {
  983:     .name = "timer",
  984:     .get  = get_timer,
  985:     .put  = put_timer,
  986: };
  987: 
  988: /* uint8_t buffers */
  989: 
  990: static int get_buffer(QEMUFile *f, void *pv, size_t size)
  991: {
  992:     uint8_t *v = pv;
  993:     qemu_get_buffer(f, v, size);
  994:     return 0;
  995: }
  996: 
  997: static void put_buffer(QEMUFile *f, void *pv, size_t size)
  998: {
  999:     uint8_t *v = pv;
 1000:     qemu_put_buffer(f, v, size);
 1001: }
 1002: 
 1003: const VMStateInfo vmstate_info_buffer = {
 1004:     .name = "buffer",
 1005:     .get  = get_buffer,
 1006:     .put  = put_buffer,
 1007: };
 1008: 
 1009: /* unused buffers: space that was used for some fields that are
 1010:    not useful anymore */
 1011: 
 1012: static int get_unused_buffer(QEMUFile *f, void *pv, size_t size)
 1013: {
 1014:     uint8_t buf[1024];
 1015:     int block_len;
 1016: 
 1017:     while (size > 0) {
 1018:         block_len = MIN(sizeof(buf), size);
 1019:         size -= block_len;
 1020:         qemu_get_buffer(f, buf, block_len);
 1021:     }
 1022:    return 0;
 1023: }
 1024: 
 1025: static void put_unused_buffer(QEMUFile *f, void *pv, size_t size)
 1026: {
 1027:     static const uint8_t buf[1024];
 1028:     int block_len;
 1029: 
 1030:     while (size > 0) {
 1031:         block_len = MIN(sizeof(buf), size);
 1032:         size -= block_len;
 1033:         qemu_put_buffer(f, buf, block_len);
 1034:     }
 1035: }
 1036: 
 1037: const VMStateInfo vmstate_info_unused_buffer = {
 1038:     .name = "unused_buffer",
 1039:     .get  = get_unused_buffer,
 1040:     .put  = put_unused_buffer,
 1041: };
 1042: 
 1043: typedef struct CompatEntry {
 1044:     char idstr[256];
 1045:     int instance_id;
 1046: } CompatEntry;
 1047: 
 1048: typedef struct SaveStateEntry {
 1049:     QTAILQ_ENTRY(SaveStateEntry) entry;
 1050:     char idstr[256];
 1051:     int instance_id;
 1052:     int alias_id;
 1053:     int version_id;
 1054:     int section_id;
 1055:     SaveSetParamsHandler *set_params;
 1056:     SaveLiveStateHandler *save_live_state;
 1057:     SaveStateHandler *save_state;
 1058:     LoadStateHandler *load_state;
 1059:     const VMStateDescription *vmsd;
 1060:     void *opaque;
 1061:     CompatEntry *compat;
 1062:     int no_migrate;
 1063: } SaveStateEntry;
 1064: 
 1065: 
 1066: static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers =
 1067:     QTAILQ_HEAD_INITIALIZER(savevm_handlers);
 1068: static int global_section_id;
 1069: 
 1070: static int calculate_new_instance_id(const char *idstr)
 1071: {
 1072:     SaveStateEntry *se;
 1073:     int instance_id = 0;
 1074: 
 1075:     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
 1076:         if (strcmp(idstr, se->idstr) == 0
 1077:             && instance_id <= se->instance_id) {
 1078:             instance_id = se->instance_id + 1;
 1079:         }
 1080:     }
 1081:     return instance_id;
 1082: }
 1083: 
 1084: static int calculate_compat_instance_id(const char *idstr)
 1085: {
 1086:     SaveStateEntry *se;
 1087:     int instance_id = 0;
 1088: 
 1089:     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
 1090:         if (!se->compat)
 1091:             continue;
 1092: 
 1093:         if (strcmp(idstr, se->compat->idstr) == 0
 1094:             && instance_id <= se->compat->instance_id) {
 1095:             instance_id = se->compat->instance_id + 1;
 1096:         }
 1097:     }
 1098:     return instance_id;
 1099: }
 1100: 
 1101: /* TODO: Individual devices generally have very little idea about the rest
 1102:    of the system, so instance_id should be removed/replaced.
 1103:    Meanwhile pass -1 as instance_id if you do not already have a clearly
 1104:    distinguishing id for all instances of your device class. */
 1105: int register_savevm_live(DeviceState *dev,
 1106:                          const char *idstr,
 1107:                          int instance_id,
 1108:                          int version_id,
 1109:                          SaveSetParamsHandler *set_params,
 1110:                          SaveLiveStateHandler *save_live_state,
 1111:                          SaveStateHandler *save_state,
 1112:                          LoadStateHandler *load_state,
 1113:                          void *opaque)
 1114: {
 1115:     SaveStateEntry *se;
 1116: 
 1117:     se = qemu_mallocz(sizeof(SaveStateEntry));
 1118:     se->version_id = version_id;
 1119:     se->section_id = global_section_id++;
 1120:     se->set_params = set_params;
 1121:     se->save_live_state = save_live_state;
 1122:     se->save_state = save_state;
 1123:     se->load_state = load_state;
 1124:     se->opaque = opaque;
 1125:     se->vmsd = NULL;
 1126:     se->no_migrate = 0;
 1127: 
 1128:     if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
 1129:         char *id = dev->parent_bus->info->get_dev_path(dev);
 1130:         if (id) {
 1131:             pstrcpy(se->idstr, sizeof(se->idstr), id);
 1132:             pstrcat(se->idstr, sizeof(se->idstr), "/");
 1133:             qemu_free(id);
 1134: 
 1135:             se->compat = qemu_mallocz(sizeof(CompatEntry));
 1136:             pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr);
 1137:             se->compat->instance_id = instance_id == -1 ?
 1138:                          calculate_compat_instance_id(idstr) : instance_id;
 1139:             instance_id = -1;
 1140:         }
 1141:     }
 1142:     pstrcat(se->idstr, sizeof(se->idstr), idstr);
 1143: 
 1144:     if (instance_id == -1) {
 1145:         se->instance_id = calculate_new_instance_id(se->idstr);
 1146:     } else {
 1147:         se->instance_id = instance_id;
 1148:     }
 1149:     assert(!se->compat || se->instance_id == 0);
 1150:     /* add at the end of list */
 1151:     QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
 1152:     return 0;
 1153: }
 1154: 
 1155: int register_savevm(DeviceState *dev,
 1156:                     const char *idstr,
 1157:                     int instance_id,
 1158:                     int version_id,
 1159:                     SaveStateHandler *save_state,
 1160:                     LoadStateHandler *load_state,
 1161:                     void *opaque)
 1162: {
 1163:     return register_savevm_live(dev, idstr, instance_id, version_id,
 1164:                                 NULL, NULL, save_state, load_state, opaque);
 1165: }
 1166: 
 1167: void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
 1168: {
 1169:     SaveStateEntry *se, *new_se;
 1170:     char id[256] = "";
 1171: 
 1172:     if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
 1173:         char *path = dev->parent_bus->info->get_dev_path(dev);
 1174:         if (path) {
 1175:             pstrcpy(id, sizeof(id), path);
 1176:             pstrcat(id, sizeof(id), "/");
 1177:             qemu_free(path);
 1178:         }
 1179:     }
 1180:     pstrcat(id, sizeof(id), idstr);
 1181: 
 1182:     QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
 1183:         if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
 1184:             QTAILQ_REMOVE(&savevm_handlers, se, entry);
 1185:             if (se->compat) {
 1186:                 qemu_free(se->compat);
 1187:             }
 1188:             qemu_free(se);
 1189:         }
 1190:     }
 1191: }
 1192: 
 1193: /* mark a device as not to be migrated, that is the device should be
 1194:    unplugged before migration */
 1195: void register_device_unmigratable(DeviceState *dev, const char *idstr,
 1196:                                                             void *opaque)
 1197: {
 1198:     SaveStateEntry *se;
 1199:     char id[256] = "";
 1200: 
 1201:     if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
 1202:         char *path = dev->parent_bus->info->get_dev_path(dev);
 1203:         if (path) {
 1204:             pstrcpy(id, sizeof(id), path);
 1205:             pstrcat(id, sizeof(id), "/");
 1206:             qemu_free(path);
 1207:         }
 1208:     }
 1209:     pstrcat(id, sizeof(id), idstr);
 1210: 
 1211:     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
 1212:         if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
 1213:             se->no_migrate = 1;
 1214:         }
 1215:     }
 1216: }
 1217: 
 1218: int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
 1219:                                    const VMStateDescription *vmsd,
 1220:                                    void *opaque, int alias_id,
 1221:                                    int required_for_version)
 1222: {
 1223:     SaveStateEntry *se;
 1224: 
 1225:     /* If this triggers, alias support can be dropped for the vmsd. */
 1226:     assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id);
 1227: 
 1228:     se = qemu_mallocz(sizeof(SaveStateEntry));
 1229:     se->version_id = vmsd->version_id;
 1230:     se->section_id = global_section_id++;
 1231:     se->save_live_state = NULL;
 1232:     se->save_state = NULL;
 1233:     se->load_state = NULL;
 1234:     se->opaque = opaque;
 1235:     se->vmsd = vmsd;
 1236:     se->alias_id = alias_id;
 1237: 
 1238:     if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
 1239:         char *id = dev->parent_bus->info->get_dev_path(dev);
 1240:         if (id) {
 1241:             pstrcpy(se->idstr, sizeof(se->idstr), id);
 1242:             pstrcat(se->idstr, sizeof(se->idstr), "/");
 1243:             qemu_free(id);
 1244: 
 1245:             se->compat = qemu_mallocz(sizeof(CompatEntry));
 1246:             pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
 1247:             se->compat->instance_id = instance_id == -1 ?
 1248:                          calculate_compat_instance_id(vmsd->name) : instance_id;
 1249:             instance_id = -1;
 1250:         }
 1251:     }
 1252:     pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);
 1253: 
 1254:     if (instance_id == -1) {
 1255:         se->instance_id = calculate_new_instance_id(se->idstr);
 1256:     } else {
 1257:         se->instance_id = instance_id;
 1258:     }
 1259:     assert(!se->compat || se->instance_id == 0);
 1260:     /* add at the end of list */
 1261:     QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
 1262:     return 0;
 1263: }
 1264: 
 1265: int vmstate_register(DeviceState *dev, int instance_id,
 1266:                      const VMStateDescription *vmsd, void *opaque)
 1267: {
 1268:     return vmstate_register_with_alias_id(dev, instance_id, vmsd,
 1269:                                           opaque, -1, 0);
 1270: }
 1271: 
 1272: void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
 1273:                         void *opaque)
 1274: {
 1275:     SaveStateEntry *se, *new_se;
 1276: 
 1277:     QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
 1278:         if (se->vmsd == vmsd && se->opaque == opaque) {
 1279:             QTAILQ_REMOVE(&savevm_handlers, se, entry);
 1280:             if (se->compat) {
 1281:                 qemu_free(se->compat);
 1282:             }
 1283:             qemu_free(se);
 1284:         }
 1285:     }
 1286: }
 1287: 
 1288: static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
 1289:                                     void *opaque);
 1290: static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
 1291:                                    void *opaque);
 1292: 
 1293: int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
 1294:                        void *opaque, int version_id)
 1295: {
 1296:     VMStateField *field = vmsd->fields;
 1297:     int ret;
 1298: 
 1299:     if (version_id > vmsd->version_id) {
 1300:         return -EINVAL;
 1301:     }
 1302:     if (version_id < vmsd->minimum_version_id_old) {
 1303:         return -EINVAL;
 1304:     }
 1305:     if  (version_id < vmsd->minimum_version_id) {
 1306:         return vmsd->load_state_old(f, opaque, version_id);
 1307:     }
 1308:     if (vmsd->pre_load) {
 1309:         int ret = vmsd->pre_load(opaque);
 1310:         if (ret)
 1311:             return ret;
 1312:     }
 1313:     while(field->name) {
 1314:         if ((field->field_exists &&
 1315:              field->field_exists(opaque, version_id)) ||
 1316:             (!field->field_exists &&
 1317:              field->version_id <= version_id)) {
 1318:             void *base_addr = opaque + field->offset;
 1319:             int i, n_elems = 1;
 1320:             int size = field->size;
 1321: 
 1322:             if (field->flags & VMS_VBUFFER) {
 1323:                 size = *(int32_t *)(opaque+field->size_offset);
 1324:                 if (field->flags & VMS_MULTIPLY) {
 1325:                     size *= field->size;
 1326:                 }
 1327:             }
 1328:             if (field->flags & VMS_ARRAY) {
 1329:                 n_elems = field->num;
 1330:             } else if (field->flags & VMS_VARRAY_INT32) {
 1331:                 n_elems = *(int32_t *)(opaque+field->num_offset);
 1332:             } else if (field->flags & VMS_VARRAY_UINT32) {
 1333:                 n_elems = *(uint32_t *)(opaque+field->num_offset);
 1334:             } else if (field->flags & VMS_VARRAY_UINT16) {
 1335:                 n_elems = *(uint16_t *)(opaque+field->num_offset);
 1336:             } else if (field->flags & VMS_VARRAY_UINT8) {
 1337:                 n_elems = *(uint8_t *)(opaque+field->num_offset);
 1338:             }
 1339:             if (field->flags & VMS_POINTER) {
 1340:                 base_addr = *(void **)base_addr + field->start;
 1341:             }
 1342:             for (i = 0; i < n_elems; i++) {
 1343:                 void *addr = base_addr + size * i;
 1344: 
 1345:                 if (field->flags & VMS_ARRAY_OF_POINTER) {
 1346:                     addr = *(void **)addr;
 1347:                 }
 1348:                 if (field->flags & VMS_STRUCT) {
 1349:                     ret = vmstate_load_state(f, field->vmsd, addr, field->vmsd->version_id);
 1350:                 } else {
 1351:                     ret = field->info->get(f, addr, size);
 1352: 
 1353:                 }
 1354:                 if (ret < 0) {
 1355:                     return ret;
 1356:                 }
 1357:             }
 1358:         }
 1359:         field++;
 1360:     }
 1361:     ret = vmstate_subsection_load(f, vmsd, opaque);
 1362:     if (ret != 0) {
 1363:         return ret;
 1364:     }
 1365:     if (vmsd->post_load) {
 1366:         return vmsd->post_load(opaque, version_id);
 1367:     }
 1368:     return 0;
 1369: }
 1370: 
 1371: void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
 1372:                         void *opaque)
 1373: {
 1374:     VMStateField *field = vmsd->fields;
 1375: 
 1376:     if (vmsd->pre_save) {
 1377:         vmsd->pre_save(opaque);
 1378:     }
 1379:     while(field->name) {
 1380:         if (!field->field_exists ||
 1381:             field->field_exists(opaque, vmsd->version_id)) {
 1382:             void *base_addr = opaque + field->offset;
 1383:             int i, n_elems = 1;
 1384:             int size = field->size;
 1385: 
 1386:             if (field->flags & VMS_VBUFFER) {
 1387:                 size = *(int32_t *)(opaque+field->size_offset);
 1388:                 if (field->flags & VMS_MULTIPLY) {
 1389:                     size *= field->size;
 1390:                 }
 1391:             }
 1392:             if (field->flags & VMS_ARRAY) {
 1393:                 n_elems = field->num;
 1394:             } else if (field->flags & VMS_VARRAY_INT32) {
 1395:                 n_elems = *(int32_t *)(opaque+field->num_offset);
 1396:             } else if (field->flags & VMS_VARRAY_UINT16) {
 1397:                 n_elems = *(uint16_t *)(opaque+field->num_offset);
 1398:             } else if (field->flags & VMS_VARRAY_UINT8) {
 1399:                 n_elems = *(uint8_t *)(opaque+field->num_offset);
 1400:             }
 1401:             if (field->flags & VMS_POINTER) {
 1402:                 base_addr = *(void **)base_addr + field->start;
 1403:             }
 1404:             for (i = 0; i < n_elems; i++) {
 1405:                 void *addr = base_addr + size * i;
 1406: 
 1407:                 if (field->flags & VMS_ARRAY_OF_POINTER) {
 1408:                     addr = *(void **)addr;
 1409:                 }
 1410:                 if (field->flags & VMS_STRUCT) {
 1411:                     vmstate_save_state(f, field->vmsd, addr);
 1412:                 } else {
 1413:                     field->info->put(f, addr, size);
 1414:                 }
 1415:             }
 1416:         }
 1417:         field++;
 1418:     }
 1419:     vmstate_subsection_save(f, vmsd, opaque);
 1420: }
 1421: 
 1422: static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id)
 1423: {
 1424:     if (!se->vmsd) {         /* Old style */
 1425:         return se->load_state(f, se->opaque, version_id);
 1426:     }
 1427:     return vmstate_load_state(f, se->vmsd, se->opaque, version_id);
 1428: }
 1429: 
 1430: static void vmstate_save(QEMUFile *f, SaveStateEntry *se)
 1431: {
 1432:     if (!se->vmsd) {         /* Old style */
 1433:         se->save_state(f, se->opaque);
 1434:         return;
 1435:     }
 1436:     vmstate_save_state(f,se->vmsd, se->opaque);
 1437: }
 1438: 
 1439: #define QEMU_VM_FILE_MAGIC           0x5145564d
 1440: #define QEMU_VM_FILE_VERSION_COMPAT  0x00000002
 1441: #define QEMU_VM_FILE_VERSION         0x00000003
 1442: 
 1443: #define QEMU_VM_EOF                  0x00
 1444: #define QEMU_VM_SECTION_START        0x01
 1445: #define QEMU_VM_SECTION_PART         0x02
 1446: #define QEMU_VM_SECTION_END          0x03
 1447: #define QEMU_VM_SECTION_FULL         0x04
 1448: #define QEMU_VM_SUBSECTION           0x05
 1449: 
 1450: bool qemu_savevm_state_blocked(Monitor *mon)
 1451: {
 1452:     SaveStateEntry *se;
 1453: 
 1454:     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
 1455:         if (se->no_migrate) {
 1456:             monitor_printf(mon, "state blocked by non-migratable device '%s'\n",
 1457:                            se->idstr);
 1458:             return true;
 1459:         }
 1460:     }
 1461:     return false;
 1462: }
 1463: 
 1464: int qemu_savevm_state_begin(Monitor *mon, QEMUFile *f, int blk_enable,
 1465:                             int shared)
 1466: {
 1467:     SaveStateEntry *se;
 1468: 
 1469:     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
 1470:         if(se->set_params == NULL) {
 1471:             continue;
 1472: 	}
 1473: 	se->set_params(blk_enable, shared, se->opaque);
 1474:     }
 1475:     
 1476:     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
 1477:     qemu_put_be32(f, QEMU_VM_FILE_VERSION);
 1478: 
 1479:     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
 1480:         int len;
 1481: 
 1482:         if (se->save_live_state == NULL)
 1483:             continue;
 1484: 
 1485:         /* Section type */
 1486:         qemu_put_byte(f, QEMU_VM_SECTION_START);
 1487:         qemu_put_be32(f, se->section_id);
 1488: 
 1489:         /* ID string */
 1490:         len = strlen(se->idstr);
 1491:         qemu_put_byte(f, len);
 1492:         qemu_put_buffer(f, (uint8_t *)se->idstr, len);
 1493: 
 1494:         qemu_put_be32(f, se->instance_id);
 1495:         qemu_put_be32(f, se->version_id);
 1496: 
 1497:         se->save_live_state(mon, f, QEMU_VM_SECTION_START, se->opaque);
 1498:     }
 1499: 
 1500:     if (qemu_file_has_error(f)) {
 1501:         qemu_savevm_state_cancel(mon, f);
 1502:         return -EIO;
 1503:     }
 1504: 
 1505:     return 0;
 1506: }
 1507: 
 1508: int qemu_savevm_state_iterate(Monitor *mon, QEMUFile *f)
 1509: {
 1510:     SaveStateEntry *se;
 1511:     int ret = 1;
 1512: 
 1513:     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
 1514:         if (se->save_live_state == NULL)
 1515:             continue;
 1516: 
 1517:         /* Section type */
 1518:         qemu_put_byte(f, QEMU_VM_SECTION_PART);
 1519:         qemu_put_be32(f, se->section_id);
 1520: 
 1521:         ret = se->save_live_state(mon, f, QEMU_VM_SECTION_PART, se->opaque);
 1522:         if (!ret) {
 1523:             /* Do not proceed to the next vmstate before this one reported
 1524:                completion of the current stage. This serializes the migration
 1525:                and reduces the probability that a faster changing state is
 1526:                synchronized over and over again. */
 1527:             break;
 1528:         }
 1529:     }
 1530: 
 1531:     if (ret)
 1532:         return 1;
 1533: 
 1534:     if (qemu_file_has_error(f)) {
 1535:         qemu_savevm_state_cancel(mon, f);
 1536:         return -EIO;
 1537:     }
 1538: 
 1539:     return 0;
 1540: }
 1541: 
 1542: int qemu_savevm_state_complete(Monitor *mon, QEMUFile *f)
 1543: {
 1544:     SaveStateEntry *se;
 1545: 
 1546:     cpu_synchronize_all_states();
 1547: 
 1548:     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
 1549:         if (se->save_live_state == NULL)
 1550:             continue;
 1551: 
 1552:         /* Section type */
 1553:         qemu_put_byte(f, QEMU_VM_SECTION_END);
 1554:         qemu_put_be32(f, se->section_id);
 1555: 
 1556:         se->save_live_state(mon, f, QEMU_VM_SECTION_END, se->opaque);
 1557:     }
 1558: 
 1559:     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
 1560:         int len;
 1561: 
 1562: 	if (se->save_state == NULL && se->vmsd == NULL)
 1563: 	    continue;
 1564: 
 1565:         /* Section type */
 1566:         qemu_put_byte(f, QEMU_VM_SECTION_FULL);
 1567:         qemu_put_be32(f, se->section_id);
 1568: 
 1569:         /* ID string */
 1570:         len = strlen(se->idstr);
 1571:         qemu_put_byte(f, len);
 1572:         qemu_put_buffer(f, (uint8_t *)se->idstr, len);
 1573: 
 1574:         qemu_put_be32(f, se->instance_id);
 1575:         qemu_put_be32(f, se->version_id);
 1576: 
 1577:         vmstate_save(f, se);
 1578:     }
 1579: 
 1580:     qemu_put_byte(f, QEMU_VM_EOF);
 1581: 
 1582:     if (qemu_file_has_error(f))
 1583:         return -EIO;
 1584: 
 1585:     return 0;
 1586: }
 1587: 
 1588: void qemu_savevm_state_cancel(Monitor *mon, QEMUFile *f)
 1589: {
 1590:     SaveStateEntry *se;
 1591: 
 1592:     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
 1593:         if (se->save_live_state) {
 1594:             se->save_live_state(mon, f, -1, se->opaque);
 1595:         }
 1596:     }
 1597: }
 1598: 
 1599: static int qemu_savevm_state(Monitor *mon, QEMUFile *f)
 1600: {
 1601:     int saved_vm_running;
 1602:     int ret;
 1603: 
 1604:     saved_vm_running = vm_running;
 1605:     vm_stop(VMSTOP_SAVEVM);
 1606: 
 1607:     if (qemu_savevm_state_blocked(mon)) {
 1608:         ret = -EINVAL;
 1609:         goto out;
 1610:     }
 1611: 
 1612:     ret = qemu_savevm_state_begin(mon, f, 0, 0);
 1613:     if (ret < 0)
 1614:         goto out;
 1615: 
 1616:     do {
 1617:         ret = qemu_savevm_state_iterate(mon, f);
 1618:         if (ret < 0)
 1619:             goto out;
 1620:     } while (ret == 0);
 1621: 
 1622:     ret = qemu_savevm_state_complete(mon, f);
 1623: 
 1624: out:
 1625:     if (qemu_file_has_error(f))
 1626:         ret = -EIO;
 1627: 
 1628:     if (!ret && saved_vm_running)
 1629:         vm_start();
 1630: 
 1631:     return ret;
 1632: }
 1633: 
 1634: static SaveStateEntry *find_se(const char *idstr, int instance_id)
 1635: {
 1636:     SaveStateEntry *se;
 1637: 
 1638:     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
 1639:         if (!strcmp(se->idstr, idstr) &&
 1640:             (instance_id == se->instance_id ||
 1641:              instance_id == se->alias_id))
 1642:             return se;
 1643:         /* Migrating from an older version? */
 1644:         if (strstr(se->idstr, idstr) && se->compat) {
 1645:             if (!strcmp(se->compat->idstr, idstr) &&
 1646:                 (instance_id == se->compat->instance_id ||
 1647:                  instance_id == se->alias_id))
 1648:                 return se;
 1649:         }
 1650:     }
 1651:     return NULL;
 1652: }
 1653: 
 1654: static const VMStateDescription *vmstate_get_subsection(const VMStateSubsection *sub, char *idstr)
 1655: {
 1656:     while(sub && sub->needed) {
 1657:         if (strcmp(idstr, sub->vmsd->name) == 0) {
 1658:             return sub->vmsd;
 1659:         }
 1660:         sub++;
 1661:     }
 1662:     return NULL;
 1663: }
 1664: 
 1665: static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
 1666:                                    void *opaque)
 1667: {
 1668:     const VMStateSubsection *sub = vmsd->subsections;
 1669: 
 1670:     if (!sub || !sub->needed) {
 1671:         return 0;
 1672:     }
 1673: 
 1674:     while (qemu_peek_byte(f) == QEMU_VM_SUBSECTION) {
 1675:         char idstr[256];
 1676:         int ret;
 1677:         uint8_t version_id, len;
 1678:         const VMStateDescription *sub_vmsd;
 1679: 
 1680:         qemu_get_byte(f); /* subsection */
 1681:         len = qemu_get_byte(f);
 1682:         qemu_get_buffer(f, (uint8_t *)idstr, len);
 1683:         idstr[len] = 0;
 1684:         version_id = qemu_get_be32(f);
 1685: 
 1686:         sub_vmsd = vmstate_get_subsection(sub, idstr);
 1687:         if (sub_vmsd == NULL) {
 1688:             return -ENOENT;
 1689:         }
 1690:         assert(!sub_vmsd->subsections);
 1691:         ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
 1692:         if (ret) {
 1693:             return ret;
 1694:         }
 1695:     }
 1696:     return 0;
 1697: }
 1698: 
 1699: static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
 1700:                                     void *opaque)
 1701: {
 1702:     const VMStateSubsection *sub = vmsd->subsections;
 1703: 
 1704:     while (sub && sub->needed) {
 1705:         if (sub->needed(opaque)) {
 1706:             const VMStateDescription *vmsd = sub->vmsd;
 1707:             uint8_t len;
 1708: 
 1709:             qemu_put_byte(f, QEMU_VM_SUBSECTION);
 1710:             len = strlen(vmsd->name);
 1711:             qemu_put_byte(f, len);
 1712:             qemu_put_buffer(f, (uint8_t *)vmsd->name, len);
 1713:             qemu_put_be32(f, vmsd->version_id);
 1714:             assert(!vmsd->subsections);
 1715:             vmstate_save_state(f, vmsd, opaque);
 1716:         }
 1717:         sub++;
 1718:     }
 1719: }
 1720: 
 1721: typedef struct LoadStateEntry {
 1722:     QLIST_ENTRY(LoadStateEntry) entry;
 1723:     SaveStateEntry *se;
 1724:     int section_id;
 1725:     int version_id;
 1726: } LoadStateEntry;
 1727: 
 1728: int qemu_loadvm_state(QEMUFile *f)
 1729: {
 1730:     QLIST_HEAD(, LoadStateEntry) loadvm_handlers =
 1731:         QLIST_HEAD_INITIALIZER(loadvm_handlers);
 1732:     LoadStateEntry *le, *new_le;
 1733:     uint8_t section_type;
 1734:     unsigned int v;
 1735:     int ret;
 1736: 
 1737:     if (qemu_savevm_state_blocked(default_mon)) {
 1738:         return -EINVAL;
 1739:     }
 1740: 
 1741:     v = qemu_get_be32(f);
 1742:     if (v != QEMU_VM_FILE_MAGIC)
 1743:         return -EINVAL;
 1744: 
 1745:     v = qemu_get_be32(f);
 1746:     if (v == QEMU_VM_FILE_VERSION_COMPAT) {
 1747:         fprintf(stderr, "SaveVM v2 format is obsolete and don't work anymore\n");
 1748:         return -ENOTSUP;
 1749:     }
 1750:     if (v != QEMU_VM_FILE_VERSION)
 1751:         return -ENOTSUP;
 1752: 
 1753:     while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
 1754:         uint32_t instance_id, version_id, section_id;
 1755:         SaveStateEntry *se;
 1756:         char idstr[257];
 1757:         int len;
 1758: 
 1759:         switch (section_type) {
 1760:         case QEMU_VM_SECTION_START:
 1761:         case QEMU_VM_SECTION_FULL:
 1762:             /* Read section start */
 1763:             section_id = qemu_get_be32(f);
 1764:             len = qemu_get_byte(f);
 1765:             qemu_get_buffer(f, (uint8_t *)idstr, len);
 1766:             idstr[len] = 0;
 1767:             instance_id = qemu_get_be32(f);
 1768:             version_id = qemu_get_be32(f);
 1769: 
 1770:             /* Find savevm section */
 1771:             se = find_se(idstr, instance_id);
 1772:             if (se == NULL) {
 1773:                 fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
 1774:                 ret = -EINVAL;
 1775:                 goto out;
 1776:             }
 1777: 
 1778:             /* Validate version */
 1779:             if (version_id > se->version_id) {
 1780:                 fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
 1781:                         version_id, idstr, se->version_id);
 1782:                 ret = -EINVAL;
 1783:                 goto out;
 1784:             }
 1785: 
 1786:             /* Add entry */
 1787:             le = qemu_mallocz(sizeof(*le));
 1788: 
 1789:             le->se = se;
 1790:             le->section_id = section_id;
 1791:             le->version_id = version_id;
 1792:             QLIST_INSERT_HEAD(&loadvm_handlers, le, entry);
 1793: 
 1794:             ret = vmstate_load(f, le->se, le->version_id);
 1795:             if (ret < 0) {
 1796:                 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
 1797:                         instance_id, idstr);
 1798:                 goto out;
 1799:             }
 1800:             break;
 1801:         case QEMU_VM_SECTION_PART:
 1802:         case QEMU_VM_SECTION_END:
 1803:             section_id = qemu_get_be32(f);
 1804: 
 1805:             QLIST_FOREACH(le, &loadvm_handlers, entry) {
 1806:                 if (le->section_id == section_id) {
 1807:                     break;
 1808:                 }
 1809:             }
 1810:             if (le == NULL) {
 1811:                 fprintf(stderr, "Unknown savevm section %d\n", section_id);
 1812:                 ret = -EINVAL;
 1813:                 goto out;
 1814:             }
 1815: 
 1816:             ret = vmstate_load(f, le->se, le->version_id);
 1817:             if (ret < 0) {
 1818:                 fprintf(stderr, "qemu: warning: error while loading state section id %d\n",
 1819:                         section_id);
 1820:                 goto out;
 1821:             }
 1822:             break;
 1823:         default:
 1824:             fprintf(stderr, "Unknown savevm section type %d\n", section_type);
 1825:             ret = -EINVAL;
 1826:             goto out;
 1827:         }
 1828:     }
 1829: 
 1830:     cpu_synchronize_all_post_init();
 1831: 
 1832:     ret = 0;
 1833: 
 1834: out:
 1835:     QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
 1836:         QLIST_REMOVE(le, entry);
 1837:         qemu_free(le);
 1838:     }
 1839: 
 1840:     if (qemu_file_has_error(f))
 1841:         ret = -EIO;
 1842: 
 1843:     return ret;
 1844: }
 1845: 
 1846: static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
 1847:                               const char *name)
 1848: {
 1849:     QEMUSnapshotInfo *sn_tab, *sn;
 1850:     int nb_sns, i, ret;
 1851: 
 1852:     ret = -ENOENT;
 1853:     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
 1854:     if (nb_sns < 0)
 1855:         return ret;
 1856:     for(i = 0; i < nb_sns; i++) {
 1857:         sn = &sn_tab[i];
 1858:         if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
 1859:             *sn_info = *sn;
 1860:             ret = 0;
 1861:             break;
 1862:         }
 1863:     }
 1864:     qemu_free(sn_tab);
 1865:     return ret;
 1866: }
 1867: 
 1868: /*
 1869:  * Deletes snapshots of a given name in all opened images.
 1870:  */
 1871: static int del_existing_snapshots(Monitor *mon, const char *name)
 1872: {
 1873:     BlockDriverState *bs;
 1874:     QEMUSnapshotInfo sn1, *snapshot = &sn1;
 1875:     int ret;
 1876: 
 1877:     bs = NULL;
 1878:     while ((bs = bdrv_next(bs))) {
 1879:         if (bdrv_can_snapshot(bs) &&
 1880:             bdrv_snapshot_find(bs, snapshot, name) >= 0)
 1881:         {
 1882:             ret = bdrv_snapshot_delete(bs, name);
 1883:             if (ret < 0) {
 1884:                 monitor_printf(mon,
 1885:                                "Error while deleting snapshot on '%s'\n",
 1886:                                bdrv_get_device_name(bs));
 1887:                 return -1;
 1888:             }
 1889:         }
 1890:     }
 1891: 
 1892:     return 0;
 1893: }
 1894: 
 1895: void do_savevm(Monitor *mon, const QDict *qdict)
 1896: {
 1897:     BlockDriverState *bs, *bs1;
 1898:     QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
 1899:     int ret;
 1900:     QEMUFile *f;
 1901:     int saved_vm_running;
 1902:     uint32_t vm_state_size;
 1903: #ifdef _WIN32
 1904:     struct _timeb tb;
 1905:     struct tm *ptm;
 1906: #else
 1907:     struct timeval tv;
 1908:     struct tm tm;
 1909: #endif
 1910:     const char *name = qdict_get_try_str(qdict, "name");
 1911: 
 1912:     /* Verify if there is a device that doesn't support snapshots and is writable */
 1913:     bs = NULL;
 1914:     while ((bs = bdrv_next(bs))) {
 1915: 
 1916:         if (bdrv_is_removable(bs) || bdrv_is_read_only(bs)) {
 1917:             continue;
 1918:         }
 1919: 
 1920:         if (!bdrv_can_snapshot(bs)) {
 1921:             monitor_printf(mon, "Device '%s' is writable but does not support snapshots.\n",
 1922:                                bdrv_get_device_name(bs));
 1923:             return;
 1924:         }
 1925:     }
 1926: 
 1927:     bs = bdrv_snapshots();
 1928:     if (!bs) {
 1929:         monitor_printf(mon, "No block device can accept snapshots\n");
 1930:         return;
 1931:     }
 1932: 
 1933:     saved_vm_running = vm_running;
 1934:     vm_stop(VMSTOP_SAVEVM);
 1935: 
 1936:     memset(sn, 0, sizeof(*sn));
 1937: 
 1938:     /* fill auxiliary fields */
 1939: #ifdef _WIN32
 1940:     _ftime(&tb);
 1941:     sn->date_sec = tb.time;
 1942:     sn->date_nsec = tb.millitm * 1000000;
 1943: #else
 1944:     gettimeofday(&tv, NULL);
 1945:     sn->date_sec = tv.tv_sec;
 1946:     sn->date_nsec = tv.tv_usec * 1000;
 1947: #endif
 1948:     sn->vm_clock_nsec = qemu_get_clock_ns(vm_clock);
 1949: 
 1950:     if (name) {
 1951:         ret = bdrv_snapshot_find(bs, old_sn, name);
 1952:         if (ret >= 0) {
 1953:             pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
 1954:             pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
 1955:         } else {
 1956:             pstrcpy(sn->name, sizeof(sn->name), name);
 1957:         }
 1958:     } else {
 1959: #ifdef _WIN32
 1960:         ptm = localtime(&tb.time);
 1961:         strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", ptm);
 1962: #else
 1963:         /* cast below needed for OpenBSD where tv_sec is still 'long' */
 1964:         localtime_r((const time_t *)&tv.tv_sec, &tm);
 1965:         strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
 1966: #endif
 1967:     }
 1968: 
 1969:     /* Delete old snapshots of the same name */
 1970:     if (name && del_existing_snapshots(mon, name) < 0) {
 1971:         goto the_end;
 1972:     }
 1973: 
 1974:     /* save the VM state */
 1975:     f = qemu_fopen_bdrv(bs, 1);
 1976:     if (!f) {
 1977:         monitor_printf(mon, "Could not open VM state file\n");
 1978:         goto the_end;
 1979:     }
 1980:     ret = qemu_savevm_state(mon, f);
 1981:     vm_state_size = qemu_ftell(f);
 1982:     qemu_fclose(f);
 1983:     if (ret < 0) {
 1984:         monitor_printf(mon, "Error %d while writing VM\n", ret);
 1985:         goto the_end;
 1986:     }
 1987: 
 1988:     /* create the snapshots */
 1989: 
 1990:     bs1 = NULL;
 1991:     while ((bs1 = bdrv_next(bs1))) {
 1992:         if (bdrv_can_snapshot(bs1)) {
 1993:             /* Write VM state size only to the image that contains the state */
 1994:             sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
 1995:             ret = bdrv_snapshot_create(bs1, sn);
 1996:             if (ret < 0) {
 1997:                 monitor_printf(mon, "Error while creating snapshot on '%s'\n",
 1998:                                bdrv_get_device_name(bs1));
 1999:             }
 2000:         }
 2001:     }
 2002: 
 2003:  the_end:
 2004:     if (saved_vm_running)
 2005:         vm_start();
 2006: }
 2007: 
 2008: int load_vmstate(const char *name)
 2009: {
 2010:     BlockDriverState *bs, *bs_vm_state;
 2011:     QEMUSnapshotInfo sn;
 2012:     QEMUFile *f;
 2013:     int ret;
 2014: 
 2015:     bs_vm_state = bdrv_snapshots();
 2016:     if (!bs_vm_state) {
 2017:         error_report("No block device supports snapshots");
 2018:         return -ENOTSUP;
 2019:     }
 2020: 
 2021:     /* Don't even try to load empty VM states */
 2022:     ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
 2023:     if (ret < 0) {
 2024:         return ret;
 2025:     } else if (sn.vm_state_size == 0) {
 2026:         error_report("This is a disk-only snapshot. Revert to it offline "
 2027:             "using qemu-img.");
 2028:         return -EINVAL;
 2029:     }
 2030: 
 2031:     /* Verify if there is any device that doesn't support snapshots and is
 2032:     writable and check if the requested snapshot is available too. */
 2033:     bs = NULL;
 2034:     while ((bs = bdrv_next(bs))) {
 2035: 
 2036:         if (bdrv_is_removable(bs) || bdrv_is_read_only(bs)) {
 2037:             continue;
 2038:         }
 2039: 
 2040:         if (!bdrv_can_snapshot(bs)) {
 2041:             error_report("Device '%s' is writable but does not support snapshots.",
 2042:                                bdrv_get_device_name(bs));
 2043:             return -ENOTSUP;
 2044:         }
 2045: 
 2046:         ret = bdrv_snapshot_find(bs, &sn, name);
 2047:         if (ret < 0) {
 2048:             error_report("Device '%s' does not have the requested snapshot '%s'",
 2049:                            bdrv_get_device_name(bs), name);
 2050:             return ret;
 2051:         }
 2052:     }
 2053: 
 2054:     /* Flush all IO requests so they don't interfere with the new state.  */
 2055:     qemu_aio_flush();
 2056: 
 2057:     bs = NULL;
 2058:     while ((bs = bdrv_next(bs))) {
 2059:         if (bdrv_can_snapshot(bs)) {
 2060:             ret = bdrv_snapshot_goto(bs, name);
 2061:             if (ret < 0) {
 2062:                 error_report("Error %d while activating snapshot '%s' on '%s'",
 2063:                              ret, name, bdrv_get_device_name(bs));
 2064:                 return ret;
 2065:             }
 2066:         }
 2067:     }
 2068: 
 2069:     /* restore the VM state */
 2070:     f = qemu_fopen_bdrv(bs_vm_state, 0);
 2071:     if (!f) {
 2072:         error_report("Could not open VM state file");
 2073:         return -EINVAL;
 2074:     }
 2075: 
 2076:     qemu_system_reset(VMRESET_SILENT);
 2077:     ret = qemu_loadvm_state(f);
 2078: 
 2079:     qemu_fclose(f);
 2080:     if (ret < 0) {
 2081:         error_report("Error %d while loading VM state", ret);
 2082:         return ret;
 2083:     }
 2084: 
 2085:     return 0;
 2086: }
 2087: 
 2088: void do_delvm(Monitor *mon, const QDict *qdict)
 2089: {
 2090:     BlockDriverState *bs, *bs1;
 2091:     int ret;
 2092:     const char *name = qdict_get_str(qdict, "name");
 2093: 
 2094:     bs = bdrv_snapshots();
 2095:     if (!bs) {
 2096:         monitor_printf(mon, "No block device supports snapshots\n");
 2097:         return;
 2098:     }
 2099: 
 2100:     bs1 = NULL;
 2101:     while ((bs1 = bdrv_next(bs1))) {
 2102:         if (bdrv_can_snapshot(bs1)) {
 2103:             ret = bdrv_snapshot_delete(bs1, name);
 2104:             if (ret < 0) {
 2105:                 if (ret == -ENOTSUP)
 2106:                     monitor_printf(mon,
 2107:                                    "Snapshots not supported on device '%s'\n",
 2108:                                    bdrv_get_device_name(bs1));
 2109:                 else
 2110:                     monitor_printf(mon, "Error %d while deleting snapshot on "
 2111:                                    "'%s'\n", ret, bdrv_get_device_name(bs1));
 2112:             }
 2113:         }
 2114:     }
 2115: }
 2116: 
 2117: void do_info_snapshots(Monitor *mon)
 2118: {
 2119:     BlockDriverState *bs, *bs1;
 2120:     QEMUSnapshotInfo *sn_tab, *sn, s, *sn_info = &s;
 2121:     int nb_sns, i, ret, available;
 2122:     int total;
 2123:     int *available_snapshots;
 2124:     char buf[256];
 2125: 
 2126:     bs = bdrv_snapshots();
 2127:     if (!bs) {
 2128:         monitor_printf(mon, "No available block device supports snapshots\n");
 2129:         return;
 2130:     }
 2131: 
 2132:     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
 2133:     if (nb_sns < 0) {
 2134:         monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
 2135:         return;
 2136:     }
 2137: 
 2138:     if (nb_sns == 0) {
 2139:         monitor_printf(mon, "There is no snapshot available.\n");
 2140:         return;
 2141:     }
 2142: 
 2143:     available_snapshots = qemu_mallocz(sizeof(int) * nb_sns);
 2144:     total = 0;
 2145:     for (i = 0; i < nb_sns; i++) {
 2146:         sn = &sn_tab[i];
 2147:         available = 1;
 2148:         bs1 = NULL;
 2149: 
 2150:         while ((bs1 = bdrv_next(bs1))) {
 2151:             if (bdrv_can_snapshot(bs1) && bs1 != bs) {
 2152:                 ret = bdrv_snapshot_find(bs1, sn_info, sn->id_str);
 2153:                 if (ret < 0) {
 2154:                     available = 0;
 2155:                     break;
 2156:                 }
 2157:             }
 2158:         }
 2159: 
 2160:         if (available) {
 2161:             available_snapshots[total] = i;
 2162:             total++;
 2163:         }
 2164:     }
 2165: 
 2166:     if (total > 0) {
 2167:         monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
 2168:         for (i = 0; i < total; i++) {
 2169:             sn = &sn_tab[available_snapshots[i]];
 2170:             monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
 2171:         }
 2172:     } else {
 2173:         monitor_printf(mon, "There is no suitable snapshot available\n");
 2174:     }
 2175: 
 2176:     qemu_free(sn_tab);
 2177:     qemu_free(available_snapshots);
 2178: 
 2179: }

unix.superglobalmegacorp.com