Annotation of qemu/savevm.c, revision 1.1.1.11

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

unix.superglobalmegacorp.com