Annotation of qemu/savevm.c, revision 1.1.1.12

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

unix.superglobalmegacorp.com