Annotation of qemu/savevm.c, revision 1.1.1.9

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

unix.superglobalmegacorp.com