File:  [Qemu by Fabrice Bellard] / qemu / savevm.c
Revision 1.1.1.1 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 16:50:31 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu0100, HEAD
qemu 0.10.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 "qemu-common.h"
   25: #include "hw/hw.h"
   26: #include "net.h"
   27: #include "console.h"
   28: #include "sysemu.h"
   29: #include "qemu-timer.h"
   30: #include "qemu-char.h"
   31: #include "block.h"
   32: #include "audio/audio.h"
   33: #include "migration.h"
   34: #include "qemu_socket.h"
   35: 
   36: #include <unistd.h>
   37: #include <fcntl.h>
   38: #include <signal.h>
   39: #include <time.h>
   40: #include <errno.h>
   41: #include <sys/time.h>
   42: #include <zlib.h>
   43: 
   44: #ifndef _WIN32
   45: #include <sys/times.h>
   46: #include <sys/wait.h>
   47: #include <termios.h>
   48: #include <sys/mman.h>
   49: #include <sys/ioctl.h>
   50: #include <sys/resource.h>
   51: #include <sys/socket.h>
   52: #include <netinet/in.h>
   53: #include <net/if.h>
   54: #if defined(__NetBSD__)
   55: #include <net/if_tap.h>
   56: #endif
   57: #ifdef __linux__
   58: #include <linux/if_tun.h>
   59: #endif
   60: #include <arpa/inet.h>
   61: #include <dirent.h>
   62: #include <netdb.h>
   63: #include <sys/select.h>
   64: #ifdef _BSD
   65: #include <sys/stat.h>
   66: #ifdef __FreeBSD__
   67: #include <libutil.h>
   68: #else
   69: #include <util.h>
   70: #endif
   71: #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
   72: #include <freebsd/stdlib.h>
   73: #else
   74: #ifdef __linux__
   75: #include <pty.h>
   76: #include <malloc.h>
   77: #include <linux/rtc.h>
   78: #endif
   79: #endif
   80: #endif
   81: 
   82: #ifdef _WIN32
   83: #include <malloc.h>
   84: #include <sys/timeb.h>
   85: #include <mmsystem.h>
   86: #define getopt_long_only getopt_long
   87: #define memalign(align, size) malloc(size)
   88: #endif
   89: 
   90: /* point to the block driver where the snapshots are managed */
   91: static BlockDriverState *bs_snapshots;
   92: 
   93: #define SELF_ANNOUNCE_ROUNDS 5
   94: #define ETH_P_EXPERIMENTAL 0x01F1 /* just a number */
   95: //#define ETH_P_EXPERIMENTAL 0x0012 /* make it the size of the packet */
   96: #define EXPERIMENTAL_MAGIC 0xf1f23f4f
   97: 
   98: static int announce_self_create(uint8_t *buf, 
   99: 				uint8_t *mac_addr)
  100: {
  101:     uint32_t magic = EXPERIMENTAL_MAGIC;
  102:     uint16_t proto = htons(ETH_P_EXPERIMENTAL);
  103: 
  104:     /* FIXME: should we send a different packet (arp/rarp/ping)? */
  105: 
  106:     memset(buf, 0xff, 6);         /* h_dst */
  107:     memcpy(buf + 6, mac_addr, 6); /* h_src */
  108:     memcpy(buf + 12, &proto, 2);  /* h_proto */
  109:     memcpy(buf + 14, &magic, 4);  /* magic */
  110: 
  111:     return 18; /* len */
  112: }
  113: 
  114: void qemu_announce_self(void)
  115: {
  116:     int i, j, len;
  117:     VLANState *vlan;
  118:     VLANClientState *vc;
  119:     uint8_t buf[256];
  120: 
  121:     for (i = 0; i < nb_nics; i++) {
  122:         len = announce_self_create(buf, nd_table[i].macaddr);
  123:         vlan = nd_table[i].vlan;
  124:         for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
  125:             for (j=0; j < SELF_ANNOUNCE_ROUNDS; j++)
  126:                 vc->fd_read(vc->opaque, buf, len);
  127:         }
  128:     }
  129: }
  130: 
  131: /***********************************************************/
  132: /* savevm/loadvm support */
  133: 
  134: #define IO_BUF_SIZE 32768
  135: 
  136: struct QEMUFile {
  137:     QEMUFilePutBufferFunc *put_buffer;
  138:     QEMUFileGetBufferFunc *get_buffer;
  139:     QEMUFileCloseFunc *close;
  140:     QEMUFileRateLimit *rate_limit;
  141:     void *opaque;
  142:     int is_write;
  143: 
  144:     int64_t buf_offset; /* start of buffer when writing, end of buffer
  145:                            when reading */
  146:     int buf_index;
  147:     int buf_size; /* 0 when writing */
  148:     uint8_t buf[IO_BUF_SIZE];
  149: 
  150:     int has_error;
  151: };
  152: 
  153: typedef struct QEMUFilePopen
  154: {
  155:     FILE *popen_file;
  156:     QEMUFile *file;
  157: } QEMUFilePopen;
  158: 
  159: typedef struct QEMUFileSocket
  160: {
  161:     int fd;
  162:     QEMUFile *file;
  163: } QEMUFileSocket;
  164: 
  165: static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
  166: {
  167:     QEMUFileSocket *s = opaque;
  168:     ssize_t len;
  169: 
  170:     do {
  171:         len = recv(s->fd, buf, size, 0);
  172:     } while (len == -1 && socket_error() == EINTR);
  173: 
  174:     if (len == -1)
  175:         len = -socket_error();
  176: 
  177:     return len;
  178: }
  179: 
  180: static int socket_close(void *opaque)
  181: {
  182:     QEMUFileSocket *s = opaque;
  183:     qemu_free(s);
  184:     return 0;
  185: }
  186: 
  187: static int popen_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
  188: {
  189:     QEMUFilePopen *s = opaque;
  190:     return fwrite(buf, 1, size, s->popen_file);
  191: }
  192: 
  193: static int popen_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
  194: {
  195:     QEMUFilePopen *s = opaque;
  196:     return fread(buf, 1, size, s->popen_file);
  197: }
  198: 
  199: static int popen_close(void *opaque)
  200: {
  201:     QEMUFilePopen *s = opaque;
  202:     pclose(s->popen_file);
  203:     qemu_free(s);
  204:     return 0;
  205: }
  206: 
  207: QEMUFile *qemu_popen(FILE *popen_file, const char *mode)
  208: {
  209:     QEMUFilePopen *s;
  210: 
  211:     if (popen_file == NULL || mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
  212:         fprintf(stderr, "qemu_popen: Argument validity check failed\n");
  213:         return NULL;
  214:     }
  215: 
  216:     s = qemu_mallocz(sizeof(QEMUFilePopen));
  217: 
  218:     s->popen_file = popen_file;
  219: 
  220:     if(mode[0] == 'r') {
  221:         s->file = qemu_fopen_ops(s, NULL, popen_get_buffer, popen_close, NULL);
  222:     } else {
  223:         s->file = qemu_fopen_ops(s, popen_put_buffer, NULL, popen_close, NULL);
  224:     }
  225:     fprintf(stderr, "qemu_popen: returning result of qemu_fopen_ops\n");
  226:     return s->file;
  227: }
  228: 
  229: QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
  230: {
  231:     FILE *popen_file;
  232: 
  233:     popen_file = popen(command, mode);
  234:     if(popen_file == NULL) {
  235:         return NULL;
  236:     }
  237: 
  238:     return qemu_popen(popen_file, mode);
  239: }
  240: 
  241: QEMUFile *qemu_fopen_socket(int fd)
  242: {
  243:     QEMUFileSocket *s = qemu_mallocz(sizeof(QEMUFileSocket));
  244: 
  245:     s->fd = fd;
  246:     s->file = qemu_fopen_ops(s, NULL, socket_get_buffer, socket_close, NULL);
  247:     return s->file;
  248: }
  249: 
  250: typedef struct QEMUFileStdio
  251: {
  252:     FILE *outfile;
  253: } QEMUFileStdio;
  254: 
  255: static int file_put_buffer(void *opaque, const uint8_t *buf,
  256:                             int64_t pos, int size)
  257: {
  258:     QEMUFileStdio *s = opaque;
  259:     fseek(s->outfile, pos, SEEK_SET);
  260:     fwrite(buf, 1, size, s->outfile);
  261:     return size;
  262: }
  263: 
  264: static int file_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
  265: {
  266:     QEMUFileStdio *s = opaque;
  267:     fseek(s->outfile, pos, SEEK_SET);
  268:     return fread(buf, 1, size, s->outfile);
  269: }
  270: 
  271: static int file_close(void *opaque)
  272: {
  273:     QEMUFileStdio *s = opaque;
  274:     fclose(s->outfile);
  275:     qemu_free(s);
  276:     return 0;
  277: }
  278: 
  279: QEMUFile *qemu_fopen(const char *filename, const char *mode)
  280: {
  281:     QEMUFileStdio *s;
  282: 
  283:     s = qemu_mallocz(sizeof(QEMUFileStdio));
  284: 
  285:     s->outfile = fopen(filename, mode);
  286:     if (!s->outfile)
  287:         goto fail;
  288: 
  289:     if (!strcmp(mode, "wb"))
  290:         return qemu_fopen_ops(s, file_put_buffer, NULL, file_close, NULL);
  291:     else if (!strcmp(mode, "rb"))
  292:         return qemu_fopen_ops(s, NULL, file_get_buffer, file_close, NULL);
  293: 
  294: fail:
  295:     if (s->outfile)
  296:         fclose(s->outfile);
  297:     qemu_free(s);
  298:     return NULL;
  299: }
  300: 
  301: typedef struct QEMUFileBdrv
  302: {
  303:     BlockDriverState *bs;
  304:     int64_t base_offset;
  305: } QEMUFileBdrv;
  306: 
  307: static int bdrv_put_buffer(void *opaque, const uint8_t *buf,
  308:                            int64_t pos, int size)
  309: {
  310:     QEMUFileBdrv *s = opaque;
  311:     bdrv_pwrite(s->bs, s->base_offset + pos, buf, size);
  312:     return size;
  313: }
  314: 
  315: static int bdrv_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
  316: {
  317:     QEMUFileBdrv *s = opaque;
  318:     return bdrv_pread(s->bs, s->base_offset + pos, buf, size);
  319: }
  320: 
  321: static int bdrv_fclose(void *opaque)
  322: {
  323:     QEMUFileBdrv *s = opaque;
  324:     qemu_free(s);
  325:     return 0;
  326: }
  327: 
  328: static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int64_t offset, int is_writable)
  329: {
  330:     QEMUFileBdrv *s;
  331: 
  332:     s = qemu_mallocz(sizeof(QEMUFileBdrv));
  333: 
  334:     s->bs = bs;
  335:     s->base_offset = offset;
  336: 
  337:     if (is_writable)
  338:         return qemu_fopen_ops(s, bdrv_put_buffer, NULL, bdrv_fclose, NULL);
  339: 
  340:     return qemu_fopen_ops(s, NULL, bdrv_get_buffer, bdrv_fclose, NULL);
  341: }
  342: 
  343: QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
  344:                          QEMUFileGetBufferFunc *get_buffer,
  345:                          QEMUFileCloseFunc *close,
  346:                          QEMUFileRateLimit *rate_limit)
  347: {
  348:     QEMUFile *f;
  349: 
  350:     f = qemu_mallocz(sizeof(QEMUFile));
  351: 
  352:     f->opaque = opaque;
  353:     f->put_buffer = put_buffer;
  354:     f->get_buffer = get_buffer;
  355:     f->close = close;
  356:     f->rate_limit = rate_limit;
  357:     f->is_write = 0;
  358: 
  359:     return f;
  360: }
  361: 
  362: int qemu_file_has_error(QEMUFile *f)
  363: {
  364:     return f->has_error;
  365: }
  366: 
  367: void qemu_fflush(QEMUFile *f)
  368: {
  369:     if (!f->put_buffer)
  370:         return;
  371: 
  372:     if (f->is_write && f->buf_index > 0) {
  373:         int len;
  374: 
  375:         len = f->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
  376:         if (len > 0)
  377:             f->buf_offset += f->buf_index;
  378:         else
  379:             f->has_error = 1;
  380:         f->buf_index = 0;
  381:     }
  382: }
  383: 
  384: static void qemu_fill_buffer(QEMUFile *f)
  385: {
  386:     int len;
  387: 
  388:     if (!f->get_buffer)
  389:         return;
  390: 
  391:     if (f->is_write)
  392:         abort();
  393: 
  394:     len = f->get_buffer(f->opaque, f->buf, f->buf_offset, IO_BUF_SIZE);
  395:     if (len > 0) {
  396:         f->buf_index = 0;
  397:         f->buf_size = len;
  398:         f->buf_offset += len;
  399:     } else if (len != -EAGAIN)
  400:         f->has_error = 1;
  401: }
  402: 
  403: int qemu_fclose(QEMUFile *f)
  404: {
  405:     int ret = 0;
  406:     qemu_fflush(f);
  407:     if (f->close)
  408:         ret = f->close(f->opaque);
  409:     qemu_free(f);
  410:     return ret;
  411: }
  412: 
  413: void qemu_file_put_notify(QEMUFile *f)
  414: {
  415:     f->put_buffer(f->opaque, NULL, 0, 0);
  416: }
  417: 
  418: void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
  419: {
  420:     int l;
  421: 
  422:     if (!f->has_error && f->is_write == 0 && f->buf_index > 0) {
  423:         fprintf(stderr,
  424:                 "Attempted to write to buffer while read buffer is not empty\n");
  425:         abort();
  426:     }
  427: 
  428:     while (!f->has_error && size > 0) {
  429:         l = IO_BUF_SIZE - f->buf_index;
  430:         if (l > size)
  431:             l = size;
  432:         memcpy(f->buf + f->buf_index, buf, l);
  433:         f->is_write = 1;
  434:         f->buf_index += l;
  435:         buf += l;
  436:         size -= l;
  437:         if (f->buf_index >= IO_BUF_SIZE)
  438:             qemu_fflush(f);
  439:     }
  440: }
  441: 
  442: void qemu_put_byte(QEMUFile *f, int v)
  443: {
  444:     if (!f->has_error && f->is_write == 0 && f->buf_index > 0) {
  445:         fprintf(stderr,
  446:                 "Attempted to write to buffer while read buffer is not empty\n");
  447:         abort();
  448:     }
  449: 
  450:     f->buf[f->buf_index++] = v;
  451:     f->is_write = 1;
  452:     if (f->buf_index >= IO_BUF_SIZE)
  453:         qemu_fflush(f);
  454: }
  455: 
  456: int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
  457: {
  458:     int size, l;
  459: 
  460:     if (f->is_write)
  461:         abort();
  462: 
  463:     size = size1;
  464:     while (size > 0) {
  465:         l = f->buf_size - f->buf_index;
  466:         if (l == 0) {
  467:             qemu_fill_buffer(f);
  468:             l = f->buf_size - f->buf_index;
  469:             if (l == 0)
  470:                 break;
  471:         }
  472:         if (l > size)
  473:             l = size;
  474:         memcpy(buf, f->buf + f->buf_index, l);
  475:         f->buf_index += l;
  476:         buf += l;
  477:         size -= l;
  478:     }
  479:     return size1 - size;
  480: }
  481: 
  482: int qemu_get_byte(QEMUFile *f)
  483: {
  484:     if (f->is_write)
  485:         abort();
  486: 
  487:     if (f->buf_index >= f->buf_size) {
  488:         qemu_fill_buffer(f);
  489:         if (f->buf_index >= f->buf_size)
  490:             return 0;
  491:     }
  492:     return f->buf[f->buf_index++];
  493: }
  494: 
  495: int64_t qemu_ftell(QEMUFile *f)
  496: {
  497:     return f->buf_offset - f->buf_size + f->buf_index;
  498: }
  499: 
  500: int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
  501: {
  502:     if (whence == SEEK_SET) {
  503:         /* nothing to do */
  504:     } else if (whence == SEEK_CUR) {
  505:         pos += qemu_ftell(f);
  506:     } else {
  507:         /* SEEK_END not supported */
  508:         return -1;
  509:     }
  510:     if (f->put_buffer) {
  511:         qemu_fflush(f);
  512:         f->buf_offset = pos;
  513:     } else {
  514:         f->buf_offset = pos;
  515:         f->buf_index = 0;
  516:         f->buf_size = 0;
  517:     }
  518:     return pos;
  519: }
  520: 
  521: int qemu_file_rate_limit(QEMUFile *f)
  522: {
  523:     if (f->rate_limit)
  524:         return f->rate_limit(f->opaque);
  525: 
  526:     return 0;
  527: }
  528: 
  529: void qemu_put_be16(QEMUFile *f, unsigned int v)
  530: {
  531:     qemu_put_byte(f, v >> 8);
  532:     qemu_put_byte(f, v);
  533: }
  534: 
  535: void qemu_put_be32(QEMUFile *f, unsigned int v)
  536: {
  537:     qemu_put_byte(f, v >> 24);
  538:     qemu_put_byte(f, v >> 16);
  539:     qemu_put_byte(f, v >> 8);
  540:     qemu_put_byte(f, v);
  541: }
  542: 
  543: void qemu_put_be64(QEMUFile *f, uint64_t v)
  544: {
  545:     qemu_put_be32(f, v >> 32);
  546:     qemu_put_be32(f, v);
  547: }
  548: 
  549: unsigned int qemu_get_be16(QEMUFile *f)
  550: {
  551:     unsigned int v;
  552:     v = qemu_get_byte(f) << 8;
  553:     v |= qemu_get_byte(f);
  554:     return v;
  555: }
  556: 
  557: unsigned int qemu_get_be32(QEMUFile *f)
  558: {
  559:     unsigned int v;
  560:     v = qemu_get_byte(f) << 24;
  561:     v |= qemu_get_byte(f) << 16;
  562:     v |= qemu_get_byte(f) << 8;
  563:     v |= qemu_get_byte(f);
  564:     return v;
  565: }
  566: 
  567: uint64_t qemu_get_be64(QEMUFile *f)
  568: {
  569:     uint64_t v;
  570:     v = (uint64_t)qemu_get_be32(f) << 32;
  571:     v |= qemu_get_be32(f);
  572:     return v;
  573: }
  574: 
  575: typedef struct SaveStateEntry {
  576:     char idstr[256];
  577:     int instance_id;
  578:     int version_id;
  579:     int section_id;
  580:     SaveLiveStateHandler *save_live_state;
  581:     SaveStateHandler *save_state;
  582:     LoadStateHandler *load_state;
  583:     void *opaque;
  584:     struct SaveStateEntry *next;
  585: } SaveStateEntry;
  586: 
  587: static SaveStateEntry *first_se;
  588: 
  589: /* TODO: Individual devices generally have very little idea about the rest
  590:    of the system, so instance_id should be removed/replaced.
  591:    Meanwhile pass -1 as instance_id if you do not already have a clearly
  592:    distinguishing id for all instances of your device class. */
  593: int register_savevm_live(const char *idstr,
  594:                          int instance_id,
  595:                          int version_id,
  596:                          SaveLiveStateHandler *save_live_state,
  597:                          SaveStateHandler *save_state,
  598:                          LoadStateHandler *load_state,
  599:                          void *opaque)
  600: {
  601:     SaveStateEntry *se, **pse;
  602:     static int global_section_id;
  603: 
  604:     se = qemu_malloc(sizeof(SaveStateEntry));
  605:     pstrcpy(se->idstr, sizeof(se->idstr), idstr);
  606:     se->instance_id = (instance_id == -1) ? 0 : instance_id;
  607:     se->version_id = version_id;
  608:     se->section_id = global_section_id++;
  609:     se->save_live_state = save_live_state;
  610:     se->save_state = save_state;
  611:     se->load_state = load_state;
  612:     se->opaque = opaque;
  613:     se->next = NULL;
  614: 
  615:     /* add at the end of list */
  616:     pse = &first_se;
  617:     while (*pse != NULL) {
  618:         if (instance_id == -1
  619:                 && strcmp(se->idstr, (*pse)->idstr) == 0
  620:                 && se->instance_id <= (*pse)->instance_id)
  621:             se->instance_id = (*pse)->instance_id + 1;
  622:         pse = &(*pse)->next;
  623:     }
  624:     *pse = se;
  625:     return 0;
  626: }
  627: 
  628: int register_savevm(const char *idstr,
  629:                     int instance_id,
  630:                     int version_id,
  631:                     SaveStateHandler *save_state,
  632:                     LoadStateHandler *load_state,
  633:                     void *opaque)
  634: {
  635:     return register_savevm_live(idstr, instance_id, version_id,
  636:                                 NULL, save_state, load_state, opaque);
  637: }
  638: 
  639: #define QEMU_VM_FILE_MAGIC           0x5145564d
  640: #define QEMU_VM_FILE_VERSION_COMPAT  0x00000002
  641: #define QEMU_VM_FILE_VERSION         0x00000003
  642: 
  643: #define QEMU_VM_EOF                  0x00
  644: #define QEMU_VM_SECTION_START        0x01
  645: #define QEMU_VM_SECTION_PART         0x02
  646: #define QEMU_VM_SECTION_END          0x03
  647: #define QEMU_VM_SECTION_FULL         0x04
  648: 
  649: int qemu_savevm_state_begin(QEMUFile *f)
  650: {
  651:     SaveStateEntry *se;
  652: 
  653:     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
  654:     qemu_put_be32(f, QEMU_VM_FILE_VERSION);
  655: 
  656:     for (se = first_se; se != NULL; se = se->next) {
  657:         int len;
  658: 
  659:         if (se->save_live_state == NULL)
  660:             continue;
  661: 
  662:         /* Section type */
  663:         qemu_put_byte(f, QEMU_VM_SECTION_START);
  664:         qemu_put_be32(f, se->section_id);
  665: 
  666:         /* ID string */
  667:         len = strlen(se->idstr);
  668:         qemu_put_byte(f, len);
  669:         qemu_put_buffer(f, (uint8_t *)se->idstr, len);
  670: 
  671:         qemu_put_be32(f, se->instance_id);
  672:         qemu_put_be32(f, se->version_id);
  673: 
  674:         se->save_live_state(f, QEMU_VM_SECTION_START, se->opaque);
  675:     }
  676: 
  677:     if (qemu_file_has_error(f))
  678:         return -EIO;
  679: 
  680:     return 0;
  681: }
  682: 
  683: int qemu_savevm_state_iterate(QEMUFile *f)
  684: {
  685:     SaveStateEntry *se;
  686:     int ret = 1;
  687: 
  688:     for (se = first_se; se != NULL; se = se->next) {
  689:         if (se->save_live_state == NULL)
  690:             continue;
  691: 
  692:         /* Section type */
  693:         qemu_put_byte(f, QEMU_VM_SECTION_PART);
  694:         qemu_put_be32(f, se->section_id);
  695: 
  696:         ret &= !!se->save_live_state(f, QEMU_VM_SECTION_PART, se->opaque);
  697:     }
  698: 
  699:     if (ret)
  700:         return 1;
  701: 
  702:     if (qemu_file_has_error(f))
  703:         return -EIO;
  704: 
  705:     return 0;
  706: }
  707: 
  708: int qemu_savevm_state_complete(QEMUFile *f)
  709: {
  710:     SaveStateEntry *se;
  711: 
  712:     for (se = first_se; se != NULL; se = se->next) {
  713:         if (se->save_live_state == NULL)
  714:             continue;
  715: 
  716:         /* Section type */
  717:         qemu_put_byte(f, QEMU_VM_SECTION_END);
  718:         qemu_put_be32(f, se->section_id);
  719: 
  720:         se->save_live_state(f, QEMU_VM_SECTION_END, se->opaque);
  721:     }
  722: 
  723:     for(se = first_se; se != NULL; se = se->next) {
  724:         int len;
  725: 
  726: 	if (se->save_state == NULL)
  727: 	    continue;
  728: 
  729:         /* Section type */
  730:         qemu_put_byte(f, QEMU_VM_SECTION_FULL);
  731:         qemu_put_be32(f, se->section_id);
  732: 
  733:         /* ID string */
  734:         len = strlen(se->idstr);
  735:         qemu_put_byte(f, len);
  736:         qemu_put_buffer(f, (uint8_t *)se->idstr, len);
  737: 
  738:         qemu_put_be32(f, se->instance_id);
  739:         qemu_put_be32(f, se->version_id);
  740: 
  741:         se->save_state(f, se->opaque);
  742:     }
  743: 
  744:     qemu_put_byte(f, QEMU_VM_EOF);
  745: 
  746:     if (qemu_file_has_error(f))
  747:         return -EIO;
  748: 
  749:     return 0;
  750: }
  751: 
  752: int qemu_savevm_state(QEMUFile *f)
  753: {
  754:     int saved_vm_running;
  755:     int ret;
  756: 
  757:     saved_vm_running = vm_running;
  758:     vm_stop(0);
  759: 
  760:     bdrv_flush_all();
  761: 
  762:     ret = qemu_savevm_state_begin(f);
  763:     if (ret < 0)
  764:         goto out;
  765: 
  766:     do {
  767:         ret = qemu_savevm_state_iterate(f);
  768:         if (ret < 0)
  769:             goto out;
  770:     } while (ret == 0);
  771: 
  772:     ret = qemu_savevm_state_complete(f);
  773: 
  774: out:
  775:     if (qemu_file_has_error(f))
  776:         ret = -EIO;
  777: 
  778:     if (!ret && saved_vm_running)
  779:         vm_start();
  780: 
  781:     return ret;
  782: }
  783: 
  784: static SaveStateEntry *find_se(const char *idstr, int instance_id)
  785: {
  786:     SaveStateEntry *se;
  787: 
  788:     for(se = first_se; se != NULL; se = se->next) {
  789:         if (!strcmp(se->idstr, idstr) &&
  790:             instance_id == se->instance_id)
  791:             return se;
  792:     }
  793:     return NULL;
  794: }
  795: 
  796: typedef struct LoadStateEntry {
  797:     SaveStateEntry *se;
  798:     int section_id;
  799:     int version_id;
  800:     struct LoadStateEntry *next;
  801: } LoadStateEntry;
  802: 
  803: static int qemu_loadvm_state_v2(QEMUFile *f)
  804: {
  805:     SaveStateEntry *se;
  806:     int len, ret, instance_id, record_len, version_id;
  807:     int64_t total_len, end_pos, cur_pos;
  808:     char idstr[256];
  809: 
  810:     total_len = qemu_get_be64(f);
  811:     end_pos = total_len + qemu_ftell(f);
  812:     for(;;) {
  813:         if (qemu_ftell(f) >= end_pos)
  814:             break;
  815:         len = qemu_get_byte(f);
  816:         qemu_get_buffer(f, (uint8_t *)idstr, len);
  817:         idstr[len] = '\0';
  818:         instance_id = qemu_get_be32(f);
  819:         version_id = qemu_get_be32(f);
  820:         record_len = qemu_get_be32(f);
  821:         cur_pos = qemu_ftell(f);
  822:         se = find_se(idstr, instance_id);
  823:         if (!se) {
  824:             fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
  825:                     instance_id, idstr);
  826:         } else {
  827:             ret = se->load_state(f, se->opaque, version_id);
  828:             if (ret < 0) {
  829:                 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
  830:                         instance_id, idstr);
  831:             }
  832:         }
  833:         /* always seek to exact end of record */
  834:         qemu_fseek(f, cur_pos + record_len, SEEK_SET);
  835:     }
  836: 
  837:     if (qemu_file_has_error(f))
  838:         return -EIO;
  839: 
  840:     return 0;
  841: }
  842: 
  843: int qemu_loadvm_state(QEMUFile *f)
  844: {
  845:     LoadStateEntry *first_le = NULL;
  846:     uint8_t section_type;
  847:     unsigned int v;
  848:     int ret;
  849: 
  850:     v = qemu_get_be32(f);
  851:     if (v != QEMU_VM_FILE_MAGIC)
  852:         return -EINVAL;
  853: 
  854:     v = qemu_get_be32(f);
  855:     if (v == QEMU_VM_FILE_VERSION_COMPAT)
  856:         return qemu_loadvm_state_v2(f);
  857:     if (v != QEMU_VM_FILE_VERSION)
  858:         return -ENOTSUP;
  859: 
  860:     while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
  861:         uint32_t instance_id, version_id, section_id;
  862:         LoadStateEntry *le;
  863:         SaveStateEntry *se;
  864:         char idstr[257];
  865:         int len;
  866: 
  867:         switch (section_type) {
  868:         case QEMU_VM_SECTION_START:
  869:         case QEMU_VM_SECTION_FULL:
  870:             /* Read section start */
  871:             section_id = qemu_get_be32(f);
  872:             len = qemu_get_byte(f);
  873:             qemu_get_buffer(f, (uint8_t *)idstr, len);
  874:             idstr[len] = 0;
  875:             instance_id = qemu_get_be32(f);
  876:             version_id = qemu_get_be32(f);
  877: 
  878:             /* Find savevm section */
  879:             se = find_se(idstr, instance_id);
  880:             if (se == NULL) {
  881:                 fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
  882:                 ret = -EINVAL;
  883:                 goto out;
  884:             }
  885: 
  886:             /* Validate version */
  887:             if (version_id > se->version_id) {
  888:                 fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
  889:                         version_id, idstr, se->version_id);
  890:                 ret = -EINVAL;
  891:                 goto out;
  892:             }
  893: 
  894:             /* Add entry */
  895:             le = qemu_mallocz(sizeof(*le));
  896: 
  897:             le->se = se;
  898:             le->section_id = section_id;
  899:             le->version_id = version_id;
  900:             le->next = first_le;
  901:             first_le = le;
  902: 
  903:             le->se->load_state(f, le->se->opaque, le->version_id);
  904:             break;
  905:         case QEMU_VM_SECTION_PART:
  906:         case QEMU_VM_SECTION_END:
  907:             section_id = qemu_get_be32(f);
  908: 
  909:             for (le = first_le; le && le->section_id != section_id; le = le->next);
  910:             if (le == NULL) {
  911:                 fprintf(stderr, "Unknown savevm section %d\n", section_id);
  912:                 ret = -EINVAL;
  913:                 goto out;
  914:             }
  915: 
  916:             le->se->load_state(f, le->se->opaque, le->version_id);
  917:             break;
  918:         default:
  919:             fprintf(stderr, "Unknown savevm section type %d\n", section_type);
  920:             ret = -EINVAL;
  921:             goto out;
  922:         }
  923:     }
  924: 
  925:     ret = 0;
  926: 
  927: out:
  928:     while (first_le) {
  929:         LoadStateEntry *le = first_le;
  930:         first_le = first_le->next;
  931:         qemu_free(le);
  932:     }
  933: 
  934:     if (qemu_file_has_error(f))
  935:         ret = -EIO;
  936: 
  937:     return ret;
  938: }
  939: 
  940: /* device can contain snapshots */
  941: static int bdrv_can_snapshot(BlockDriverState *bs)
  942: {
  943:     return (bs &&
  944:             !bdrv_is_removable(bs) &&
  945:             !bdrv_is_read_only(bs));
  946: }
  947: 
  948: /* device must be snapshots in order to have a reliable snapshot */
  949: static int bdrv_has_snapshot(BlockDriverState *bs)
  950: {
  951:     return (bs &&
  952:             !bdrv_is_removable(bs) &&
  953:             !bdrv_is_read_only(bs));
  954: }
  955: 
  956: static BlockDriverState *get_bs_snapshots(void)
  957: {
  958:     BlockDriverState *bs;
  959:     int i;
  960: 
  961:     if (bs_snapshots)
  962:         return bs_snapshots;
  963:     for(i = 0; i <= nb_drives; i++) {
  964:         bs = drives_table[i].bdrv;
  965:         if (bdrv_can_snapshot(bs))
  966:             goto ok;
  967:     }
  968:     return NULL;
  969:  ok:
  970:     bs_snapshots = bs;
  971:     return bs;
  972: }
  973: 
  974: static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
  975:                               const char *name)
  976: {
  977:     QEMUSnapshotInfo *sn_tab, *sn;
  978:     int nb_sns, i, ret;
  979: 
  980:     ret = -ENOENT;
  981:     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
  982:     if (nb_sns < 0)
  983:         return ret;
  984:     for(i = 0; i < nb_sns; i++) {
  985:         sn = &sn_tab[i];
  986:         if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
  987:             *sn_info = *sn;
  988:             ret = 0;
  989:             break;
  990:         }
  991:     }
  992:     qemu_free(sn_tab);
  993:     return ret;
  994: }
  995: 
  996: void do_savevm(const char *name)
  997: {
  998:     BlockDriverState *bs, *bs1;
  999:     QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
 1000:     int must_delete, ret, i;
 1001:     BlockDriverInfo bdi1, *bdi = &bdi1;
 1002:     QEMUFile *f;
 1003:     int saved_vm_running;
 1004:     uint32_t vm_state_size;
 1005: #ifdef _WIN32
 1006:     struct _timeb tb;
 1007: #else
 1008:     struct timeval tv;
 1009: #endif
 1010: 
 1011:     bs = get_bs_snapshots();
 1012:     if (!bs) {
 1013:         term_printf("No block device can accept snapshots\n");
 1014:         return;
 1015:     }
 1016: 
 1017:     /* ??? Should this occur after vm_stop?  */
 1018:     qemu_aio_flush();
 1019: 
 1020:     saved_vm_running = vm_running;
 1021:     vm_stop(0);
 1022: 
 1023:     must_delete = 0;
 1024:     if (name) {
 1025:         ret = bdrv_snapshot_find(bs, old_sn, name);
 1026:         if (ret >= 0) {
 1027:             must_delete = 1;
 1028:         }
 1029:     }
 1030:     memset(sn, 0, sizeof(*sn));
 1031:     if (must_delete) {
 1032:         pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
 1033:         pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
 1034:     } else {
 1035:         if (name)
 1036:             pstrcpy(sn->name, sizeof(sn->name), name);
 1037:     }
 1038: 
 1039:     /* fill auxiliary fields */
 1040: #ifdef _WIN32
 1041:     _ftime(&tb);
 1042:     sn->date_sec = tb.time;
 1043:     sn->date_nsec = tb.millitm * 1000000;
 1044: #else
 1045:     gettimeofday(&tv, NULL);
 1046:     sn->date_sec = tv.tv_sec;
 1047:     sn->date_nsec = tv.tv_usec * 1000;
 1048: #endif
 1049:     sn->vm_clock_nsec = qemu_get_clock(vm_clock);
 1050: 
 1051:     if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
 1052:         term_printf("Device %s does not support VM state snapshots\n",
 1053:                     bdrv_get_device_name(bs));
 1054:         goto the_end;
 1055:     }
 1056: 
 1057:     /* save the VM state */
 1058:     f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
 1059:     if (!f) {
 1060:         term_printf("Could not open VM state file\n");
 1061:         goto the_end;
 1062:     }
 1063:     ret = qemu_savevm_state(f);
 1064:     vm_state_size = qemu_ftell(f);
 1065:     qemu_fclose(f);
 1066:     if (ret < 0) {
 1067:         term_printf("Error %d while writing VM\n", ret);
 1068:         goto the_end;
 1069:     }
 1070: 
 1071:     /* create the snapshots */
 1072: 
 1073:     for(i = 0; i < nb_drives; i++) {
 1074:         bs1 = drives_table[i].bdrv;
 1075:         if (bdrv_has_snapshot(bs1)) {
 1076:             if (must_delete) {
 1077:                 ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
 1078:                 if (ret < 0) {
 1079:                     term_printf("Error while deleting snapshot on '%s'\n",
 1080:                                 bdrv_get_device_name(bs1));
 1081:                 }
 1082:             }
 1083:             /* Write VM state size only to the image that contains the state */
 1084:             sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
 1085:             ret = bdrv_snapshot_create(bs1, sn);
 1086:             if (ret < 0) {
 1087:                 term_printf("Error while creating snapshot on '%s'\n",
 1088:                             bdrv_get_device_name(bs1));
 1089:             }
 1090:         }
 1091:     }
 1092: 
 1093:  the_end:
 1094:     if (saved_vm_running)
 1095:         vm_start();
 1096: }
 1097: 
 1098: void do_loadvm(const char *name)
 1099: {
 1100:     BlockDriverState *bs, *bs1;
 1101:     BlockDriverInfo bdi1, *bdi = &bdi1;
 1102:     QEMUSnapshotInfo sn;
 1103:     QEMUFile *f;
 1104:     int i, ret;
 1105:     int saved_vm_running;
 1106: 
 1107:     bs = get_bs_snapshots();
 1108:     if (!bs) {
 1109:         term_printf("No block device supports snapshots\n");
 1110:         return;
 1111:     }
 1112: 
 1113:     /* Flush all IO requests so they don't interfere with the new state.  */
 1114:     qemu_aio_flush();
 1115: 
 1116:     saved_vm_running = vm_running;
 1117:     vm_stop(0);
 1118: 
 1119:     for(i = 0; i <= nb_drives; i++) {
 1120:         bs1 = drives_table[i].bdrv;
 1121:         if (bdrv_has_snapshot(bs1)) {
 1122:             ret = bdrv_snapshot_goto(bs1, name);
 1123:             if (ret < 0) {
 1124:                 if (bs != bs1)
 1125:                     term_printf("Warning: ");
 1126:                 switch(ret) {
 1127:                 case -ENOTSUP:
 1128:                     term_printf("Snapshots not supported on device '%s'\n",
 1129:                                 bdrv_get_device_name(bs1));
 1130:                     break;
 1131:                 case -ENOENT:
 1132:                     term_printf("Could not find snapshot '%s' on device '%s'\n",
 1133:                                 name, bdrv_get_device_name(bs1));
 1134:                     break;
 1135:                 default:
 1136:                     term_printf("Error %d while activating snapshot on '%s'\n",
 1137:                                 ret, bdrv_get_device_name(bs1));
 1138:                     break;
 1139:                 }
 1140:                 /* fatal on snapshot block device */
 1141:                 if (bs == bs1)
 1142:                     goto the_end;
 1143:             }
 1144:         }
 1145:     }
 1146: 
 1147:     if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
 1148:         term_printf("Device %s does not support VM state snapshots\n",
 1149:                     bdrv_get_device_name(bs));
 1150:         return;
 1151:     }
 1152: 
 1153:     /* Don't even try to load empty VM states */
 1154:     ret = bdrv_snapshot_find(bs, &sn, name);
 1155:     if ((ret >= 0) && (sn.vm_state_size == 0))
 1156:         goto the_end;
 1157: 
 1158:     /* restore the VM state */
 1159:     f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
 1160:     if (!f) {
 1161:         term_printf("Could not open VM state file\n");
 1162:         goto the_end;
 1163:     }
 1164:     ret = qemu_loadvm_state(f);
 1165:     qemu_fclose(f);
 1166:     if (ret < 0) {
 1167:         term_printf("Error %d while loading VM state\n", ret);
 1168:     }
 1169:  the_end:
 1170:     if (saved_vm_running)
 1171:         vm_start();
 1172: }
 1173: 
 1174: void do_delvm(const char *name)
 1175: {
 1176:     BlockDriverState *bs, *bs1;
 1177:     int i, ret;
 1178: 
 1179:     bs = get_bs_snapshots();
 1180:     if (!bs) {
 1181:         term_printf("No block device supports snapshots\n");
 1182:         return;
 1183:     }
 1184: 
 1185:     for(i = 0; i <= nb_drives; i++) {
 1186:         bs1 = drives_table[i].bdrv;
 1187:         if (bdrv_has_snapshot(bs1)) {
 1188:             ret = bdrv_snapshot_delete(bs1, name);
 1189:             if (ret < 0) {
 1190:                 if (ret == -ENOTSUP)
 1191:                     term_printf("Snapshots not supported on device '%s'\n",
 1192:                                 bdrv_get_device_name(bs1));
 1193:                 else
 1194:                     term_printf("Error %d while deleting snapshot on '%s'\n",
 1195:                                 ret, bdrv_get_device_name(bs1));
 1196:             }
 1197:         }
 1198:     }
 1199: }
 1200: 
 1201: void do_info_snapshots(void)
 1202: {
 1203:     BlockDriverState *bs, *bs1;
 1204:     QEMUSnapshotInfo *sn_tab, *sn;
 1205:     int nb_sns, i;
 1206:     char buf[256];
 1207: 
 1208:     bs = get_bs_snapshots();
 1209:     if (!bs) {
 1210:         term_printf("No available block device supports snapshots\n");
 1211:         return;
 1212:     }
 1213:     term_printf("Snapshot devices:");
 1214:     for(i = 0; i <= nb_drives; i++) {
 1215:         bs1 = drives_table[i].bdrv;
 1216:         if (bdrv_has_snapshot(bs1)) {
 1217:             if (bs == bs1)
 1218:                 term_printf(" %s", bdrv_get_device_name(bs1));
 1219:         }
 1220:     }
 1221:     term_printf("\n");
 1222: 
 1223:     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
 1224:     if (nb_sns < 0) {
 1225:         term_printf("bdrv_snapshot_list: error %d\n", nb_sns);
 1226:         return;
 1227:     }
 1228:     term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs));
 1229:     term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
 1230:     for(i = 0; i < nb_sns; i++) {
 1231:         sn = &sn_tab[i];
 1232:         term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
 1233:     }
 1234:     qemu_free(sn_tab);
 1235: }

unix.superglobalmegacorp.com