Annotation of qemu/savevm.c, revision 1.1.1.10

1.1       root        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: 
1.1.1.6   root       31: /* Needed early for CONFIG_BSD etc. */
1.1.1.5   root       32: #include "config-host.h"
                     33: 
1.1       root       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>
1.1.1.6   root       48: #ifdef CONFIG_BSD
1.1       root       49: #include <sys/stat.h>
1.1.1.6   root       50: #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
1.1       root       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
1.1.1.5   root       64: #include <windows.h>
1.1       root       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: 
1.1.1.5   root       72: #include "qemu-common.h"
                     73: #include "hw/hw.h"
1.1.1.8   root       74: #include "hw/qdev.h"
1.1.1.5   root       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"
1.1.1.6   root       83: #include "qemu-queue.h"
1.1.1.10! root       84: #include "cpus.h"
1.1.1.5   root       85: 
1.1       root       86: #define SELF_ANNOUNCE_ROUNDS 5
                     87: 
1.1.1.6   root       88: #ifndef ETH_P_RARP
1.1.1.8   root       89: #define ETH_P_RARP 0x8035
1.1.1.6   root       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,
1.1       root       96:                                uint8_t *mac_addr)
                     97: {
1.1.1.6   root       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);
1.1       root      116: 
1.1.1.6   root      117:     return 60; /* len (FCS will be added by hardware) */
                    118: }
1.1       root      119: 
1.1.1.6   root      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);
1.1       root      126: 
1.1.1.6   root      127:     qemu_send_packet_raw(&nic->nc, buf, len);
1.1       root      128: }
                    129: 
1.1.1.6   root      130: 
1.1.1.5   root      131: static void qemu_announce_self_once(void *opaque)
1.1       root      132: {
1.1.1.5   root      133:     static int count = SELF_ANNOUNCE_ROUNDS;
                    134:     QEMUTimer *timer = *(QEMUTimer **)opaque;
1.1       root      135: 
1.1.1.6   root      136:     qemu_foreach_nic(qemu_announce_self_iter, NULL);
                    137: 
                    138:     if (--count) {
                    139:         /* delay 50ms, 150ms, 250ms, ... */
1.1.1.10! root      140:         qemu_mod_timer(timer, qemu_get_clock_ms(rt_clock) +
1.1.1.6   root      141:                        50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100);
1.1.1.5   root      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;
1.1.1.10! root      151:        timer = qemu_new_timer_ms(rt_clock, qemu_announce_self_once, &timer);
1.1.1.5   root      152:        qemu_announce_self_once(&timer);
1.1       root      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;
1.1.1.5   root      165:     QEMUFileSetRateLimit *set_rate_limit;
1.1.1.6   root      166:     QEMUFileGetRateLimit *get_rate_limit;
1.1       root      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: 
1.1.1.6   root      179: typedef struct QEMUFileStdio
1.1       root      180: {
1.1.1.6   root      181:     FILE *stdio_file;
1.1       root      182:     QEMUFile *file;
1.1.1.6   root      183: } QEMUFileStdio;
1.1       root      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 {
1.1.1.10! root      197:         len = qemu_recv(s->fd, buf, size, 0);
1.1       root      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: 
1.1.1.6   root      213: static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
1.1       root      214: {
1.1.1.6   root      215:     QEMUFileStdio *s = opaque;
                    216:     return fwrite(buf, 1, size, s->stdio_file);
1.1       root      217: }
                    218: 
1.1.1.6   root      219: static int stdio_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
1.1       root      220: {
1.1.1.6   root      221:     QEMUFileStdio *s = opaque;
                    222:     FILE *fp = s->stdio_file;
1.1.1.5   root      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;
1.1       root      230: }
                    231: 
1.1.1.6   root      232: static int stdio_pclose(void *opaque)
1.1       root      233: {
1.1.1.6   root      234:     QEMUFileStdio *s = opaque;
1.1.1.8   root      235:     int ret;
                    236:     ret = pclose(s->stdio_file);
1.1       root      237:     qemu_free(s);
1.1.1.8   root      238:     return ret;
1.1       root      239: }
                    240: 
1.1.1.6   root      241: static int stdio_fclose(void *opaque)
1.1       root      242: {
1.1.1.6   root      243:     QEMUFileStdio *s = opaque;
                    244:     fclose(s->stdio_file);
                    245:     qemu_free(s);
                    246:     return 0;
                    247: }
1.1       root      248: 
1.1.1.6   root      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) {
1.1       root      254:         fprintf(stderr, "qemu_popen: Argument validity check failed\n");
                    255:         return NULL;
                    256:     }
                    257: 
1.1.1.6   root      258:     s = qemu_mallocz(sizeof(QEMUFileStdio));
1.1       root      259: 
1.1.1.6   root      260:     s->stdio_file = stdio_file;
1.1       root      261: 
                    262:     if(mode[0] == 'r') {
1.1.1.6   root      263:         s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_pclose, 
                    264:                                 NULL, NULL, NULL);
1.1       root      265:     } else {
1.1.1.6   root      266:         s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_pclose, 
                    267:                                 NULL, NULL, NULL);
1.1       root      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: 
1.1.1.6   root      284: int qemu_stdio_fd(QEMUFile *f)
1.1.1.5   root      285: {
1.1.1.6   root      286:     QEMUFileStdio *p;
1.1.1.5   root      287:     int fd;
                    288: 
1.1.1.6   root      289:     p = (QEMUFileStdio *)f->opaque;
                    290:     fd = fileno(p->stdio_file);
1.1.1.5   root      291: 
                    292:     return fd;
                    293: }
                    294: 
1.1.1.6   root      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: 
1.1       root      325: QEMUFile *qemu_fopen_socket(int fd)
                    326: {
                    327:     QEMUFileSocket *s = qemu_mallocz(sizeof(QEMUFileSocket));
                    328: 
                    329:     s->fd = fd;
1.1.1.6   root      330:     s->file = qemu_fopen_ops(s, NULL, socket_get_buffer, socket_close, 
                    331:                             NULL, NULL, NULL);
1.1       root      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;
1.1.1.6   root      339:     fseek(s->stdio_file, pos, SEEK_SET);
1.1.1.8   root      340:     return fwrite(buf, 1, size, s->stdio_file);
1.1       root      341: }
                    342: 
                    343: static int file_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
                    344: {
                    345:     QEMUFileStdio *s = opaque;
1.1.1.6   root      346:     fseek(s->stdio_file, pos, SEEK_SET);
                    347:     return fread(buf, 1, size, s->stdio_file);
1.1       root      348: }
                    349: 
                    350: QEMUFile *qemu_fopen(const char *filename, const char *mode)
                    351: {
                    352:     QEMUFileStdio *s;
                    353: 
1.1.1.6   root      354:     if (mode == NULL ||
                    355:        (mode[0] != 'r' && mode[0] != 'w') ||
                    356:        mode[1] != 'b' || mode[2] != 0) {
1.1.1.8   root      357:         fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
1.1.1.6   root      358:         return NULL;
                    359:     }
                    360: 
1.1       root      361:     s = qemu_mallocz(sizeof(QEMUFileStdio));
                    362: 
1.1.1.6   root      363:     s->stdio_file = fopen(filename, mode);
                    364:     if (!s->stdio_file)
1.1       root      365:         goto fail;
1.1.1.6   root      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;
1.1       root      375: fail:
                    376:     qemu_free(s);
                    377:     return NULL;
                    378: }
                    379: 
1.1.1.3   root      380: static int block_put_buffer(void *opaque, const uint8_t *buf,
1.1       root      381:                            int64_t pos, int size)
                    382: {
1.1.1.5   root      383:     bdrv_save_vmstate(opaque, buf, pos, size);
1.1       root      384:     return size;
                    385: }
                    386: 
1.1.1.3   root      387: static int block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
1.1       root      388: {
1.1.1.5   root      389:     return bdrv_load_vmstate(opaque, buf, pos, size);
1.1       root      390: }
                    391: 
                    392: static int bdrv_fclose(void *opaque)
                    393: {
                    394:     return 0;
                    395: }
                    396: 
1.1.1.5   root      397: static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
1.1       root      398: {
                    399:     if (is_writable)
1.1.1.6   root      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);
1.1       root      403: }
                    404: 
                    405: QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
                    406:                          QEMUFileGetBufferFunc *get_buffer,
                    407:                          QEMUFileCloseFunc *close,
1.1.1.5   root      408:                          QEMUFileRateLimit *rate_limit,
1.1.1.6   root      409:                          QEMUFileSetRateLimit *set_rate_limit,
                    410:                          QEMUFileGetRateLimit *get_rate_limit)
1.1       root      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;
1.1.1.5   root      421:     f->set_rate_limit = set_rate_limit;
1.1.1.6   root      422:     f->get_rate_limit = get_rate_limit;
1.1       root      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: 
1.1.1.3   root      433: void qemu_file_set_error(QEMUFile *f)
                    434: {
                    435:     f->has_error = 1;
                    436: }
                    437: 
1.1       root      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: 
1.1.1.8   root      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: 
1.1       root      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: 
1.1.1.9   root      613: int64_t qemu_file_get_rate_limit(QEMUFile *f)
1.1.1.6   root      614: {
                    615:     if (f->get_rate_limit)
                    616:         return f->get_rate_limit(f->opaque);
                    617: 
                    618:     return 0;
                    619: }
                    620: 
1.1.1.9   root      621: int64_t qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate)
1.1.1.5   root      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: 
1.1       root      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: 
1.1.1.9   root      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: 
1.1.1.6   root      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: 
1.1.1.10! root      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: 
1.1.1.6   root      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
1.1.1.10! root     1010:    not useful anymore */
1.1.1.6   root     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: 
1.1.1.8   root     1043: typedef struct CompatEntry {
                   1044:     char idstr[256];
                   1045:     int instance_id;
                   1046: } CompatEntry;
                   1047: 
1.1       root     1048: typedef struct SaveStateEntry {
1.1.1.6   root     1049:     QTAILQ_ENTRY(SaveStateEntry) entry;
1.1       root     1050:     char idstr[256];
                   1051:     int instance_id;
1.1.1.8   root     1052:     int alias_id;
1.1       root     1053:     int version_id;
                   1054:     int section_id;
1.1.1.6   root     1055:     SaveSetParamsHandler *set_params;
1.1       root     1056:     SaveLiveStateHandler *save_live_state;
                   1057:     SaveStateHandler *save_state;
                   1058:     LoadStateHandler *load_state;
1.1.1.6   root     1059:     const VMStateDescription *vmsd;
1.1       root     1060:     void *opaque;
1.1.1.8   root     1061:     CompatEntry *compat;
                   1062:     int no_migrate;
1.1       root     1063: } SaveStateEntry;
                   1064: 
1.1.1.6   root     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: }
1.1       root     1083: 
1.1.1.8   root     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: 
1.1       root     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. */
1.1.1.8   root     1105: int register_savevm_live(DeviceState *dev,
                   1106:                          const char *idstr,
1.1       root     1107:                          int instance_id,
                   1108:                          int version_id,
1.1.1.6   root     1109:                          SaveSetParamsHandler *set_params,
1.1       root     1110:                          SaveLiveStateHandler *save_live_state,
                   1111:                          SaveStateHandler *save_state,
                   1112:                          LoadStateHandler *load_state,
                   1113:                          void *opaque)
                   1114: {
1.1.1.6   root     1115:     SaveStateEntry *se;
1.1       root     1116: 
1.1.1.6   root     1117:     se = qemu_mallocz(sizeof(SaveStateEntry));
1.1       root     1118:     se->version_id = version_id;
                   1119:     se->section_id = global_section_id++;
1.1.1.6   root     1120:     se->set_params = set_params;
1.1       root     1121:     se->save_live_state = save_live_state;
                   1122:     se->save_state = save_state;
                   1123:     se->load_state = load_state;
                   1124:     se->opaque = opaque;
1.1.1.6   root     1125:     se->vmsd = NULL;
1.1.1.8   root     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);
1.1       root     1143: 
1.1.1.6   root     1144:     if (instance_id == -1) {
1.1.1.8   root     1145:         se->instance_id = calculate_new_instance_id(se->idstr);
1.1.1.6   root     1146:     } else {
                   1147:         se->instance_id = instance_id;
1.1       root     1148:     }
1.1.1.8   root     1149:     assert(!se->compat || se->instance_id == 0);
1.1.1.6   root     1150:     /* add at the end of list */
                   1151:     QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1.1       root     1152:     return 0;
                   1153: }
                   1154: 
1.1.1.8   root     1155: int register_savevm(DeviceState *dev,
                   1156:                     const char *idstr,
1.1       root     1157:                     int instance_id,
                   1158:                     int version_id,
                   1159:                     SaveStateHandler *save_state,
                   1160:                     LoadStateHandler *load_state,
                   1161:                     void *opaque)
                   1162: {
1.1.1.8   root     1163:     return register_savevm_live(dev, idstr, instance_id, version_id,
1.1.1.6   root     1164:                                 NULL, NULL, save_state, load_state, opaque);
1.1       root     1165: }
                   1166: 
1.1.1.8   root     1167: void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
1.1.1.4   root     1168: {
1.1.1.6   root     1169:     SaveStateEntry *se, *new_se;
1.1.1.8   root     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);
1.1.1.4   root     1181: 
1.1.1.6   root     1182:     QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1.1.1.8   root     1183:         if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
1.1.1.6   root     1184:             QTAILQ_REMOVE(&savevm_handlers, se, entry);
1.1.1.8   root     1185:             if (se->compat) {
                   1186:                 qemu_free(se->compat);
                   1187:             }
1.1.1.6   root     1188:             qemu_free(se);
1.1.1.4   root     1189:         }
                   1190:     }
                   1191: }
                   1192: 
1.1.1.8   root     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)
1.1.1.6   root     1197: {
                   1198:     SaveStateEntry *se;
1.1.1.8   root     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);
1.1.1.6   root     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;
1.1.1.8   root     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);
1.1.1.6   root     1253: 
                   1254:     if (instance_id == -1) {
1.1.1.8   root     1255:         se->instance_id = calculate_new_instance_id(se->idstr);
1.1.1.6   root     1256:     } else {
                   1257:         se->instance_id = instance_id;
                   1258:     }
1.1.1.8   root     1259:     assert(!se->compat || se->instance_id == 0);
1.1.1.6   root     1260:     /* add at the end of list */
                   1261:     QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
                   1262:     return 0;
                   1263: }
                   1264: 
1.1.1.8   root     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)
1.1.1.6   root     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);
1.1.1.8   root     1280:             if (se->compat) {
                   1281:                 qemu_free(se->compat);
                   1282:             }
1.1.1.6   root     1283:             qemu_free(se);
                   1284:         }
                   1285:     }
                   1286: }
                   1287: 
1.1.1.8   root     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: 
1.1.1.6   root     1293: int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
                   1294:                        void *opaque, int version_id)
                   1295: {
                   1296:     VMStateField *field = vmsd->fields;
1.1.1.8   root     1297:     int ret;
1.1.1.6   root     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;
1.1.1.8   root     1319:             int i, n_elems = 1;
1.1.1.6   root     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);
1.1.1.10! root     1332:             } else if (field->flags & VMS_VARRAY_UINT32) {
        !          1333:                 n_elems = *(uint32_t *)(opaque+field->num_offset);
1.1.1.6   root     1334:             } else if (field->flags & VMS_VARRAY_UINT16) {
                   1335:                 n_elems = *(uint16_t *)(opaque+field->num_offset);
1.1.1.10! root     1336:             } else if (field->flags & VMS_VARRAY_UINT8) {
        !          1337:                 n_elems = *(uint8_t *)(opaque+field->num_offset);
1.1.1.6   root     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:     }
1.1.1.8   root     1361:     ret = vmstate_subsection_load(f, vmsd, opaque);
                   1362:     if (ret != 0) {
                   1363:         return ret;
                   1364:     }
1.1.1.6   root     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);
1.1.1.10! root     1398:             } else if (field->flags & VMS_VARRAY_UINT8) {
        !          1399:                 n_elems = *(uint8_t *)(opaque+field->num_offset);
1.1.1.6   root     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:     }
1.1.1.8   root     1419:     vmstate_subsection_save(f, vmsd, opaque);
1.1.1.6   root     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: 
1.1.1.9   root     1430: static void vmstate_save(QEMUFile *f, SaveStateEntry *se)
1.1.1.6   root     1431: {
                   1432:     if (!se->vmsd) {         /* Old style */
                   1433:         se->save_state(f, se->opaque);
1.1.1.9   root     1434:         return;
1.1.1.6   root     1435:     }
                   1436:     vmstate_save_state(f,se->vmsd, se->opaque);
                   1437: }
                   1438: 
1.1       root     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
1.1.1.8   root     1448: #define QEMU_VM_SUBSECTION           0x05
1.1       root     1449: 
1.1.1.9   root     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: 
1.1.1.6   root     1464: int qemu_savevm_state_begin(Monitor *mon, QEMUFile *f, int blk_enable,
                   1465:                             int shared)
1.1       root     1466: {
                   1467:     SaveStateEntry *se;
                   1468: 
1.1.1.6   root     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:     
1.1       root     1476:     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
                   1477:     qemu_put_be32(f, QEMU_VM_FILE_VERSION);
                   1478: 
1.1.1.6   root     1479:     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1.1       root     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: 
1.1.1.6   root     1497:         se->save_live_state(mon, f, QEMU_VM_SECTION_START, se->opaque);
1.1       root     1498:     }
                   1499: 
1.1.1.6   root     1500:     if (qemu_file_has_error(f)) {
                   1501:         qemu_savevm_state_cancel(mon, f);
1.1       root     1502:         return -EIO;
1.1.1.6   root     1503:     }
1.1       root     1504: 
                   1505:     return 0;
                   1506: }
                   1507: 
1.1.1.6   root     1508: int qemu_savevm_state_iterate(Monitor *mon, QEMUFile *f)
1.1       root     1509: {
                   1510:     SaveStateEntry *se;
                   1511:     int ret = 1;
                   1512: 
1.1.1.6   root     1513:     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1.1       root     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: 
1.1.1.6   root     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:         }
1.1       root     1529:     }
                   1530: 
                   1531:     if (ret)
                   1532:         return 1;
                   1533: 
1.1.1.6   root     1534:     if (qemu_file_has_error(f)) {
                   1535:         qemu_savevm_state_cancel(mon, f);
1.1       root     1536:         return -EIO;
1.1.1.6   root     1537:     }
1.1       root     1538: 
                   1539:     return 0;
                   1540: }
                   1541: 
1.1.1.6   root     1542: int qemu_savevm_state_complete(Monitor *mon, QEMUFile *f)
1.1       root     1543: {
                   1544:     SaveStateEntry *se;
1.1.1.8   root     1545: 
                   1546:     cpu_synchronize_all_states();
1.1       root     1547: 
1.1.1.6   root     1548:     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1.1       root     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: 
1.1.1.6   root     1556:         se->save_live_state(mon, f, QEMU_VM_SECTION_END, se->opaque);
1.1       root     1557:     }
                   1558: 
1.1.1.6   root     1559:     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1.1       root     1560:         int len;
                   1561: 
1.1.1.6   root     1562:        if (se->save_state == NULL && se->vmsd == NULL)
1.1       root     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: 
1.1.1.9   root     1577:         vmstate_save(f, se);
1.1       root     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: 
1.1.1.6   root     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)
1.1       root     1600: {
                   1601:     int saved_vm_running;
                   1602:     int ret;
                   1603: 
                   1604:     saved_vm_running = vm_running;
1.1.1.10! root     1605:     vm_stop(VMSTOP_SAVEVM);
1.1       root     1606: 
1.1.1.9   root     1607:     if (qemu_savevm_state_blocked(mon)) {
                   1608:         ret = -EINVAL;
                   1609:         goto out;
                   1610:     }
1.1       root     1611: 
1.1.1.6   root     1612:     ret = qemu_savevm_state_begin(mon, f, 0, 0);
1.1       root     1613:     if (ret < 0)
                   1614:         goto out;
                   1615: 
                   1616:     do {
1.1.1.6   root     1617:         ret = qemu_savevm_state_iterate(mon, f);
1.1       root     1618:         if (ret < 0)
                   1619:             goto out;
                   1620:     } while (ret == 0);
                   1621: 
1.1.1.6   root     1622:     ret = qemu_savevm_state_complete(mon, f);
1.1       root     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: 
1.1.1.6   root     1638:     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1.1       root     1639:         if (!strcmp(se->idstr, idstr) &&
1.1.1.8   root     1640:             (instance_id == se->instance_id ||
                   1641:              instance_id == se->alias_id))
1.1       root     1642:             return se;
1.1.1.8   root     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++;
1.1       root     1661:     }
                   1662:     return NULL;
                   1663: }
                   1664: 
1.1.1.8   root     1665: static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
                   1666:                                    void *opaque)
                   1667: {
1.1.1.9   root     1668:     const VMStateSubsection *sub = vmsd->subsections;
                   1669: 
                   1670:     if (!sub || !sub->needed) {
                   1671:         return 0;
                   1672:     }
                   1673: 
1.1.1.8   root     1674:     while (qemu_peek_byte(f) == QEMU_VM_SUBSECTION) {
                   1675:         char idstr[256];
                   1676:         int ret;
1.1.1.9   root     1677:         uint8_t version_id, len;
1.1.1.8   root     1678:         const VMStateDescription *sub_vmsd;
                   1679: 
1.1.1.9   root     1680:         qemu_get_byte(f); /* subsection */
1.1.1.8   root     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: 
1.1.1.9   root     1686:         sub_vmsd = vmstate_get_subsection(sub, idstr);
1.1.1.8   root     1687:         if (sub_vmsd == NULL) {
                   1688:             return -ENOENT;
                   1689:         }
1.1.1.9   root     1690:         assert(!sub_vmsd->subsections);
1.1.1.8   root     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);
1.1.1.9   root     1714:             assert(!vmsd->subsections);
1.1.1.8   root     1715:             vmstate_save_state(f, vmsd, opaque);
                   1716:         }
                   1717:         sub++;
                   1718:     }
                   1719: }
                   1720: 
1.1       root     1721: typedef struct LoadStateEntry {
1.1.1.6   root     1722:     QLIST_ENTRY(LoadStateEntry) entry;
1.1       root     1723:     SaveStateEntry *se;
                   1724:     int section_id;
                   1725:     int version_id;
                   1726: } LoadStateEntry;
                   1727: 
                   1728: int qemu_loadvm_state(QEMUFile *f)
                   1729: {
1.1.1.6   root     1730:     QLIST_HEAD(, LoadStateEntry) loadvm_handlers =
                   1731:         QLIST_HEAD_INITIALIZER(loadvm_handlers);
                   1732:     LoadStateEntry *le, *new_le;
1.1       root     1733:     uint8_t section_type;
                   1734:     unsigned int v;
                   1735:     int ret;
                   1736: 
1.1.1.9   root     1737:     if (qemu_savevm_state_blocked(default_mon)) {
                   1738:         return -EINVAL;
                   1739:     }
                   1740: 
1.1       root     1741:     v = qemu_get_be32(f);
                   1742:     if (v != QEMU_VM_FILE_MAGIC)
                   1743:         return -EINVAL;
                   1744: 
                   1745:     v = qemu_get_be32(f);
1.1.1.6   root     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:     }
1.1       root     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;
1.1.1.6   root     1792:             QLIST_INSERT_HEAD(&loadvm_handlers, le, entry);
1.1       root     1793: 
1.1.1.6   root     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:             }
1.1       root     1800:             break;
                   1801:         case QEMU_VM_SECTION_PART:
                   1802:         case QEMU_VM_SECTION_END:
                   1803:             section_id = qemu_get_be32(f);
                   1804: 
1.1.1.6   root     1805:             QLIST_FOREACH(le, &loadvm_handlers, entry) {
                   1806:                 if (le->section_id == section_id) {
                   1807:                     break;
                   1808:                 }
                   1809:             }
1.1       root     1810:             if (le == NULL) {
                   1811:                 fprintf(stderr, "Unknown savevm section %d\n", section_id);
                   1812:                 ret = -EINVAL;
                   1813:                 goto out;
                   1814:             }
                   1815: 
1.1.1.6   root     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:             }
1.1       root     1822:             break;
                   1823:         default:
                   1824:             fprintf(stderr, "Unknown savevm section type %d\n", section_type);
                   1825:             ret = -EINVAL;
                   1826:             goto out;
                   1827:         }
                   1828:     }
                   1829: 
1.1.1.8   root     1830:     cpu_synchronize_all_post_init();
                   1831: 
1.1       root     1832:     ret = 0;
                   1833: 
                   1834: out:
1.1.1.6   root     1835:     QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
                   1836:         QLIST_REMOVE(le, entry);
1.1       root     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: 
1.1.1.6   root     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: 
1.1.1.8   root     1877:     bs = NULL;
                   1878:     while ((bs = bdrv_next(bs))) {
1.1.1.6   root     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)
1.1       root     1896: {
                   1897:     BlockDriverState *bs, *bs1;
                   1898:     QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
1.1.1.6   root     1899:     int ret;
1.1       root     1900:     QEMUFile *f;
                   1901:     int saved_vm_running;
                   1902:     uint32_t vm_state_size;
                   1903: #ifdef _WIN32
                   1904:     struct _timeb tb;
1.1.1.9   root     1905:     struct tm *ptm;
1.1       root     1906: #else
                   1907:     struct timeval tv;
1.1.1.9   root     1908:     struct tm tm;
1.1       root     1909: #endif
1.1.1.6   root     1910:     const char *name = qdict_get_try_str(qdict, "name");
1.1       root     1911: 
1.1.1.8   root     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();
1.1       root     1928:     if (!bs) {
1.1.1.5   root     1929:         monitor_printf(mon, "No block device can accept snapshots\n");
1.1       root     1930:         return;
                   1931:     }
                   1932: 
                   1933:     saved_vm_running = vm_running;
1.1.1.10! root     1934:     vm_stop(VMSTOP_SAVEVM);
1.1       root     1935: 
1.1.1.6   root     1936:     memset(sn, 0, sizeof(*sn));
1.1       root     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
1.1.1.10! root     1948:     sn->vm_clock_nsec = qemu_get_clock_ns(vm_clock);
1.1       root     1949: 
1.1.1.9   root     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: 
1.1.1.6   root     1969:     /* Delete old snapshots of the same name */
1.1.1.7   root     1970:     if (name && del_existing_snapshots(mon, name) < 0) {
1.1.1.6   root     1971:         goto the_end;
                   1972:     }
                   1973: 
1.1       root     1974:     /* save the VM state */
1.1.1.5   root     1975:     f = qemu_fopen_bdrv(bs, 1);
1.1       root     1976:     if (!f) {
1.1.1.5   root     1977:         monitor_printf(mon, "Could not open VM state file\n");
1.1       root     1978:         goto the_end;
                   1979:     }
1.1.1.6   root     1980:     ret = qemu_savevm_state(mon, f);
1.1       root     1981:     vm_state_size = qemu_ftell(f);
                   1982:     qemu_fclose(f);
                   1983:     if (ret < 0) {
1.1.1.5   root     1984:         monitor_printf(mon, "Error %d while writing VM\n", ret);
1.1       root     1985:         goto the_end;
                   1986:     }
                   1987: 
                   1988:     /* create the snapshots */
                   1989: 
1.1.1.8   root     1990:     bs1 = NULL;
                   1991:     while ((bs1 = bdrv_next(bs1))) {
                   1992:         if (bdrv_can_snapshot(bs1)) {
1.1       root     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) {
1.1.1.5   root     1997:                 monitor_printf(mon, "Error while creating snapshot on '%s'\n",
                   1998:                                bdrv_get_device_name(bs1));
1.1       root     1999:             }
                   2000:         }
                   2001:     }
                   2002: 
                   2003:  the_end:
                   2004:     if (saved_vm_running)
                   2005:         vm_start();
                   2006: }
                   2007: 
1.1.1.8   root     2008: int load_vmstate(const char *name)
1.1       root     2009: {
1.1.1.9   root     2010:     BlockDriverState *bs, *bs_vm_state;
1.1       root     2011:     QEMUSnapshotInfo sn;
                   2012:     QEMUFile *f;
1.1.1.6   root     2013:     int ret;
1.1       root     2014: 
1.1.1.9   root     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) {
1.1.1.10! root     2026:         error_report("This is a disk-only snapshot. Revert to it offline "
        !          2027:             "using qemu-img.");
1.1.1.9   root     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. */
1.1.1.8   root     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: 
1.1.1.9   root     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:         }
1.1       root     2052:     }
                   2053: 
                   2054:     /* Flush all IO requests so they don't interfere with the new state.  */
                   2055:     qemu_aio_flush();
                   2056: 
1.1.1.9   root     2057:     bs = NULL;
                   2058:     while ((bs = bdrv_next(bs))) {
                   2059:         if (bdrv_can_snapshot(bs)) {
                   2060:             ret = bdrv_snapshot_goto(bs, name);
1.1       root     2061:             if (ret < 0) {
1.1.1.9   root     2062:                 error_report("Error %d while activating snapshot '%s' on '%s'",
                   2063:                              ret, name, bdrv_get_device_name(bs));
                   2064:                 return ret;
1.1       root     2065:             }
                   2066:         }
                   2067:     }
                   2068: 
                   2069:     /* restore the VM state */
1.1.1.9   root     2070:     f = qemu_fopen_bdrv(bs_vm_state, 0);
1.1       root     2071:     if (!f) {
1.1.1.8   root     2072:         error_report("Could not open VM state file");
1.1.1.6   root     2073:         return -EINVAL;
1.1       root     2074:     }
1.1.1.9   root     2075: 
1.1.1.10! root     2076:     qemu_system_reset(VMRESET_SILENT);
1.1       root     2077:     ret = qemu_loadvm_state(f);
1.1.1.9   root     2078: 
1.1       root     2079:     qemu_fclose(f);
                   2080:     if (ret < 0) {
1.1.1.8   root     2081:         error_report("Error %d while loading VM state", ret);
1.1.1.6   root     2082:         return ret;
1.1       root     2083:     }
1.1.1.9   root     2084: 
1.1.1.6   root     2085:     return 0;
1.1       root     2086: }
                   2087: 
1.1.1.6   root     2088: void do_delvm(Monitor *mon, const QDict *qdict)
1.1       root     2089: {
                   2090:     BlockDriverState *bs, *bs1;
1.1.1.6   root     2091:     int ret;
                   2092:     const char *name = qdict_get_str(qdict, "name");
1.1       root     2093: 
1.1.1.8   root     2094:     bs = bdrv_snapshots();
1.1       root     2095:     if (!bs) {
1.1.1.5   root     2096:         monitor_printf(mon, "No block device supports snapshots\n");
1.1       root     2097:         return;
                   2098:     }
                   2099: 
1.1.1.8   root     2100:     bs1 = NULL;
                   2101:     while ((bs1 = bdrv_next(bs1))) {
                   2102:         if (bdrv_can_snapshot(bs1)) {
1.1       root     2103:             ret = bdrv_snapshot_delete(bs1, name);
                   2104:             if (ret < 0) {
                   2105:                 if (ret == -ENOTSUP)
1.1.1.5   root     2106:                     monitor_printf(mon,
                   2107:                                    "Snapshots not supported on device '%s'\n",
                   2108:                                    bdrv_get_device_name(bs1));
1.1       root     2109:                 else
1.1.1.5   root     2110:                     monitor_printf(mon, "Error %d while deleting snapshot on "
                   2111:                                    "'%s'\n", ret, bdrv_get_device_name(bs1));
1.1       root     2112:             }
                   2113:         }
                   2114:     }
                   2115: }
                   2116: 
1.1.1.5   root     2117: void do_info_snapshots(Monitor *mon)
1.1       root     2118: {
                   2119:     BlockDriverState *bs, *bs1;
1.1.1.9   root     2120:     QEMUSnapshotInfo *sn_tab, *sn, s, *sn_info = &s;
                   2121:     int nb_sns, i, ret, available;
                   2122:     int total;
                   2123:     int *available_snapshots;
1.1       root     2124:     char buf[256];
                   2125: 
1.1.1.8   root     2126:     bs = bdrv_snapshots();
1.1       root     2127:     if (!bs) {
1.1.1.5   root     2128:         monitor_printf(mon, "No available block device supports snapshots\n");
1.1       root     2129:         return;
                   2130:     }
                   2131: 
                   2132:     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
                   2133:     if (nb_sns < 0) {
1.1.1.5   root     2134:         monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
1.1       root     2135:         return;
                   2136:     }
1.1.1.9   root     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++) {
1.1       root     2146:         sn = &sn_tab[i];
1.1.1.9   root     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:         }
1.1       root     2164:     }
1.1.1.9   root     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: 
1.1       root     2176:     qemu_free(sn_tab);
1.1.1.9   root     2177:     qemu_free(available_snapshots);
                   2178: 
1.1       root     2179: }

unix.superglobalmegacorp.com