Statistics
| Branch: | Revision:

root / savevm.c @ b784421c

History | View | Annotate | Download (54.5 kB)

1
/*
2
 * QEMU System Emulator
3
 *
4
 * Copyright (c) 2003-2008 Fabrice Bellard
5
 *
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
 * of this software and associated documentation files (the "Software"), to deal
8
 * in the Software without restriction, including without limitation the rights
9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
 * copies of the Software, and to permit persons to whom the Software is
11
 * furnished to do so, subject to the following conditions:
12
 *
13
 * The above copyright notice and this permission notice shall be included in
14
 * all copies or substantial portions of the Software.
15
 *
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
 * THE SOFTWARE.
23
 */
24
#include <unistd.h>
25
#include <fcntl.h>
26
#include <signal.h>
27
#include <time.h>
28
#include <errno.h>
29
#include <sys/time.h>
30
#include <zlib.h>
31

    
32
/* Needed early for CONFIG_BSD etc. */
33
#include "config-host.h"
34

    
35
#ifndef _WIN32
36
#include <sys/times.h>
37
#include <sys/wait.h>
38
#include <termios.h>
39
#include <sys/mman.h>
40
#include <sys/ioctl.h>
41
#include <sys/resource.h>
42
#include <sys/socket.h>
43
#include <netinet/in.h>
44
#include <net/if.h>
45
#include <arpa/inet.h>
46
#include <dirent.h>
47
#include <netdb.h>
48
#include <sys/select.h>
49
#ifdef CONFIG_BSD
50
#include <sys/stat.h>
51
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
52
#include <libutil.h>
53
#else
54
#include <util.h>
55
#endif
56
#ifdef __linux__
57
#include <pty.h>
58
#include <malloc.h>
59
#include <linux/rtc.h>
60
#endif
61
#endif
62
#endif
63

    
64
#ifdef _WIN32
65
#include <windows.h>
66
#include <malloc.h>
67
#include <sys/timeb.h>
68
#include <mmsystem.h>
69
#define getopt_long_only getopt_long
70
#define memalign(align, size) malloc(size)
71
#endif
72

    
73
#include "qemu-common.h"
74
#include "hw/hw.h"
75
#include "hw/qdev.h"
76
#include "net.h"
77
#include "monitor.h"
78
#include "sysemu.h"
79
#include "qemu-timer.h"
80
#include "qemu-char.h"
81
#include "audio/audio.h"
82
#include "migration.h"
83
#include "qemu_socket.h"
84
#include "qemu-queue.h"
85

    
86
#define SELF_ANNOUNCE_ROUNDS 5
87

    
88
#ifndef ETH_P_RARP
89
#define ETH_P_RARP 0x8035
90
#endif
91
#define ARP_HTYPE_ETH 0x0001
92
#define ARP_PTYPE_IP 0x0800
93
#define ARP_OP_REQUEST_REV 0x3
94

    
95
static int announce_self_create(uint8_t *buf,
96
                                uint8_t *mac_addr)
97
{
98
    /* Ethernet header. */
99
    memset(buf, 0xff, 6);         /* destination MAC addr */
100
    memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
101
    *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */
102

    
103
    /* RARP header. */
104
    *(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */
105
    *(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */
106
    *(buf + 18) = 6; /* hardware addr length (ethernet) */
107
    *(buf + 19) = 4; /* protocol addr length (IPv4) */
108
    *(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */
109
    memcpy(buf + 22, mac_addr, 6); /* source hw addr */
110
    memset(buf + 28, 0x00, 4);     /* source protocol addr */
111
    memcpy(buf + 32, mac_addr, 6); /* target hw addr */
112
    memset(buf + 38, 0x00, 4);     /* target protocol addr */
113

    
114
    /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
115
    memset(buf + 42, 0x00, 18);
116

    
117
    return 60; /* len (FCS will be added by hardware) */
118
}
119

    
120
static void qemu_announce_self_iter(NICState *nic, void *opaque)
121
{
122
    uint8_t buf[60];
123
    int len;
124

    
125
    len = announce_self_create(buf, nic->conf->macaddr.a);
126

    
127
    qemu_send_packet_raw(&nic->nc, buf, len);
128
}
129

    
130

    
131
static void qemu_announce_self_once(void *opaque)
132
{
133
    static int count = SELF_ANNOUNCE_ROUNDS;
134
    QEMUTimer *timer = *(QEMUTimer **)opaque;
135

    
136
    qemu_foreach_nic(qemu_announce_self_iter, NULL);
137

    
138
    if (--count) {
139
        /* delay 50ms, 150ms, 250ms, ... */
140
        qemu_mod_timer(timer, qemu_get_clock_ms(rt_clock) +
141
                       50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100);
142
    } else {
143
            qemu_del_timer(timer);
144
            qemu_free_timer(timer);
145
    }
146
}
147

    
148
void qemu_announce_self(void)
149
{
150
        static QEMUTimer *timer;
151
        timer = qemu_new_timer_ms(rt_clock, qemu_announce_self_once, &timer);
152
        qemu_announce_self_once(&timer);
153
}
154

    
155
/***********************************************************/
156
/* savevm/loadvm support */
157

    
158
#define IO_BUF_SIZE 32768
159

    
160
struct QEMUFile {
161
    QEMUFilePutBufferFunc *put_buffer;
162
    QEMUFileGetBufferFunc *get_buffer;
163
    QEMUFileCloseFunc *close;
164
    QEMUFileRateLimit *rate_limit;
165
    QEMUFileSetRateLimit *set_rate_limit;
166
    QEMUFileGetRateLimit *get_rate_limit;
167
    void *opaque;
168
    int is_write;
169

    
170
    int64_t buf_offset; /* start of buffer when writing, end of buffer
171
                           when reading */
172
    int buf_index;
173
    int buf_size; /* 0 when writing */
174
    uint8_t buf[IO_BUF_SIZE];
175

    
176
    int has_error;
177
};
178

    
179
typedef struct QEMUFileStdio
180
{
181
    FILE *stdio_file;
182
    QEMUFile *file;
183
} QEMUFileStdio;
184

    
185
typedef struct QEMUFileSocket
186
{
187
    int fd;
188
    QEMUFile *file;
189
} QEMUFileSocket;
190

    
191
static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
192
{
193
    QEMUFileSocket *s = opaque;
194
    ssize_t len;
195

    
196
    do {
197
        len = recv(s->fd, (void *)buf, size, 0);
198
    } while (len == -1 && socket_error() == EINTR);
199

    
200
    if (len == -1)
201
        len = -socket_error();
202

    
203
    return len;
204
}
205

    
206
static int socket_close(void *opaque)
207
{
208
    QEMUFileSocket *s = opaque;
209
    qemu_free(s);
210
    return 0;
211
}
212

    
213
static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
214
{
215
    QEMUFileStdio *s = opaque;
216
    return fwrite(buf, 1, size, s->stdio_file);
217
}
218

    
219
static int stdio_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
220
{
221
    QEMUFileStdio *s = opaque;
222
    FILE *fp = s->stdio_file;
223
    int bytes;
224

    
225
    do {
226
        clearerr(fp);
227
        bytes = fread(buf, 1, size, fp);
228
    } while ((bytes == 0) && ferror(fp) && (errno == EINTR));
229
    return bytes;
230
}
231

    
232
static int stdio_pclose(void *opaque)
233
{
234
    QEMUFileStdio *s = opaque;
235
    int ret;
236
    ret = pclose(s->stdio_file);
237
    qemu_free(s);
238
    return ret;
239
}
240

    
241
static int stdio_fclose(void *opaque)
242
{
243
    QEMUFileStdio *s = opaque;
244
    fclose(s->stdio_file);
245
    qemu_free(s);
246
    return 0;
247
}
248

    
249
QEMUFile *qemu_popen(FILE *stdio_file, const char *mode)
250
{
251
    QEMUFileStdio *s;
252

    
253
    if (stdio_file == NULL || mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
254
        fprintf(stderr, "qemu_popen: Argument validity check failed\n");
255
        return NULL;
256
    }
257

    
258
    s = qemu_mallocz(sizeof(QEMUFileStdio));
259

    
260
    s->stdio_file = stdio_file;
261

    
262
    if(mode[0] == 'r') {
263
        s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_pclose, 
264
                                 NULL, NULL, NULL);
265
    } else {
266
        s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_pclose, 
267
                                 NULL, NULL, NULL);
268
    }
269
    return s->file;
270
}
271

    
272
QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
273
{
274
    FILE *popen_file;
275

    
276
    popen_file = popen(command, mode);
277
    if(popen_file == NULL) {
278
        return NULL;
279
    }
280

    
281
    return qemu_popen(popen_file, mode);
282
}
283

    
284
int qemu_stdio_fd(QEMUFile *f)
285
{
286
    QEMUFileStdio *p;
287
    int fd;
288

    
289
    p = (QEMUFileStdio *)f->opaque;
290
    fd = fileno(p->stdio_file);
291

    
292
    return fd;
293
}
294

    
295
QEMUFile *qemu_fdopen(int fd, const char *mode)
296
{
297
    QEMUFileStdio *s;
298

    
299
    if (mode == NULL ||
300
        (mode[0] != 'r' && mode[0] != 'w') ||
301
        mode[1] != 'b' || mode[2] != 0) {
302
        fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
303
        return NULL;
304
    }
305

    
306
    s = qemu_mallocz(sizeof(QEMUFileStdio));
307
    s->stdio_file = fdopen(fd, mode);
308
    if (!s->stdio_file)
309
        goto fail;
310

    
311
    if(mode[0] == 'r') {
312
        s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_fclose, 
313
                                 NULL, NULL, NULL);
314
    } else {
315
        s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_fclose, 
316
                                 NULL, NULL, NULL);
317
    }
318
    return s->file;
319

    
320
fail:
321
    qemu_free(s);
322
    return NULL;
323
}
324

    
325
QEMUFile *qemu_fopen_socket(int fd)
326
{
327
    QEMUFileSocket *s = qemu_mallocz(sizeof(QEMUFileSocket));
328

    
329
    s->fd = fd;
330
    s->file = qemu_fopen_ops(s, NULL, socket_get_buffer, socket_close, 
331
                             NULL, NULL, NULL);
332
    return s->file;
333
}
334

    
335
static int file_put_buffer(void *opaque, const uint8_t *buf,
336
                            int64_t pos, int size)
337
{
338
    QEMUFileStdio *s = opaque;
339
    fseek(s->stdio_file, pos, SEEK_SET);
340
    return fwrite(buf, 1, size, s->stdio_file);
341
}
342

    
343
static int file_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
344
{
345
    QEMUFileStdio *s = opaque;
346
    fseek(s->stdio_file, pos, SEEK_SET);
347
    return fread(buf, 1, size, s->stdio_file);
348
}
349

    
350
QEMUFile *qemu_fopen(const char *filename, const char *mode)
351
{
352
    QEMUFileStdio *s;
353

    
354
    if (mode == NULL ||
355
        (mode[0] != 'r' && mode[0] != 'w') ||
356
        mode[1] != 'b' || mode[2] != 0) {
357
        fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
358
        return NULL;
359
    }
360

    
361
    s = qemu_mallocz(sizeof(QEMUFileStdio));
362

    
363
    s->stdio_file = fopen(filename, mode);
364
    if (!s->stdio_file)
365
        goto fail;
366
    
367
    if(mode[0] == 'w') {
368
        s->file = qemu_fopen_ops(s, file_put_buffer, NULL, stdio_fclose, 
369
                                 NULL, NULL, NULL);
370
    } else {
371
        s->file = qemu_fopen_ops(s, NULL, file_get_buffer, stdio_fclose, 
372
                               NULL, NULL, NULL);
373
    }
374
    return s->file;
375
fail:
376
    qemu_free(s);
377
    return NULL;
378
}
379

    
380
static int block_put_buffer(void *opaque, const uint8_t *buf,
381
                           int64_t pos, int size)
382
{
383
    bdrv_save_vmstate(opaque, buf, pos, size);
384
    return size;
385
}
386

    
387
static int block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
388
{
389
    return bdrv_load_vmstate(opaque, buf, pos, size);
390
}
391

    
392
static int bdrv_fclose(void *opaque)
393
{
394
    return 0;
395
}
396

    
397
static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
398
{
399
    if (is_writable)
400
        return qemu_fopen_ops(bs, block_put_buffer, NULL, bdrv_fclose, 
401
                              NULL, NULL, NULL);
402
    return qemu_fopen_ops(bs, NULL, block_get_buffer, bdrv_fclose, NULL, NULL, NULL);
403
}
404

    
405
QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
406
                         QEMUFileGetBufferFunc *get_buffer,
407
                         QEMUFileCloseFunc *close,
408
                         QEMUFileRateLimit *rate_limit,
409
                         QEMUFileSetRateLimit *set_rate_limit,
410
                         QEMUFileGetRateLimit *get_rate_limit)
411
{
412
    QEMUFile *f;
413

    
414
    f = qemu_mallocz(sizeof(QEMUFile));
415

    
416
    f->opaque = opaque;
417
    f->put_buffer = put_buffer;
418
    f->get_buffer = get_buffer;
419
    f->close = close;
420
    f->rate_limit = rate_limit;
421
    f->set_rate_limit = set_rate_limit;
422
    f->get_rate_limit = get_rate_limit;
423
    f->is_write = 0;
424

    
425
    return f;
426
}
427

    
428
int qemu_file_has_error(QEMUFile *f)
429
{
430
    return f->has_error;
431
}
432

    
433
void qemu_file_set_error(QEMUFile *f)
434
{
435
    f->has_error = 1;
436
}
437

    
438
void qemu_fflush(QEMUFile *f)
439
{
440
    if (!f->put_buffer)
441
        return;
442

    
443
    if (f->is_write && f->buf_index > 0) {
444
        int len;
445

    
446
        len = f->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
447
        if (len > 0)
448
            f->buf_offset += f->buf_index;
449
        else
450
            f->has_error = 1;
451
        f->buf_index = 0;
452
    }
453
}
454

    
455
static void qemu_fill_buffer(QEMUFile *f)
456
{
457
    int len;
458

    
459
    if (!f->get_buffer)
460
        return;
461

    
462
    if (f->is_write)
463
        abort();
464

    
465
    len = f->get_buffer(f->opaque, f->buf, f->buf_offset, IO_BUF_SIZE);
466
    if (len > 0) {
467
        f->buf_index = 0;
468
        f->buf_size = len;
469
        f->buf_offset += len;
470
    } else if (len != -EAGAIN)
471
        f->has_error = 1;
472
}
473

    
474
int qemu_fclose(QEMUFile *f)
475
{
476
    int ret = 0;
477
    qemu_fflush(f);
478
    if (f->close)
479
        ret = f->close(f->opaque);
480
    qemu_free(f);
481
    return ret;
482
}
483

    
484
void qemu_file_put_notify(QEMUFile *f)
485
{
486
    f->put_buffer(f->opaque, NULL, 0, 0);
487
}
488

    
489
void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
490
{
491
    int l;
492

    
493
    if (!f->has_error && f->is_write == 0 && f->buf_index > 0) {
494
        fprintf(stderr,
495
                "Attempted to write to buffer while read buffer is not empty\n");
496
        abort();
497
    }
498

    
499
    while (!f->has_error && size > 0) {
500
        l = IO_BUF_SIZE - f->buf_index;
501
        if (l > size)
502
            l = size;
503
        memcpy(f->buf + f->buf_index, buf, l);
504
        f->is_write = 1;
505
        f->buf_index += l;
506
        buf += l;
507
        size -= l;
508
        if (f->buf_index >= IO_BUF_SIZE)
509
            qemu_fflush(f);
510
    }
511
}
512

    
513
void qemu_put_byte(QEMUFile *f, int v)
514
{
515
    if (!f->has_error && f->is_write == 0 && f->buf_index > 0) {
516
        fprintf(stderr,
517
                "Attempted to write to buffer while read buffer is not empty\n");
518
        abort();
519
    }
520

    
521
    f->buf[f->buf_index++] = v;
522
    f->is_write = 1;
523
    if (f->buf_index >= IO_BUF_SIZE)
524
        qemu_fflush(f);
525
}
526

    
527
int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
528
{
529
    int size, l;
530

    
531
    if (f->is_write)
532
        abort();
533

    
534
    size = size1;
535
    while (size > 0) {
536
        l = f->buf_size - f->buf_index;
537
        if (l == 0) {
538
            qemu_fill_buffer(f);
539
            l = f->buf_size - f->buf_index;
540
            if (l == 0)
541
                break;
542
        }
543
        if (l > size)
544
            l = size;
545
        memcpy(buf, f->buf + f->buf_index, l);
546
        f->buf_index += l;
547
        buf += l;
548
        size -= l;
549
    }
550
    return size1 - size;
551
}
552

    
553
static int qemu_peek_byte(QEMUFile *f)
554
{
555
    if (f->is_write)
556
        abort();
557

    
558
    if (f->buf_index >= f->buf_size) {
559
        qemu_fill_buffer(f);
560
        if (f->buf_index >= f->buf_size)
561
            return 0;
562
    }
563
    return f->buf[f->buf_index];
564
}
565

    
566
int qemu_get_byte(QEMUFile *f)
567
{
568
    if (f->is_write)
569
        abort();
570

    
571
    if (f->buf_index >= f->buf_size) {
572
        qemu_fill_buffer(f);
573
        if (f->buf_index >= f->buf_size)
574
            return 0;
575
    }
576
    return f->buf[f->buf_index++];
577
}
578

    
579
int64_t qemu_ftell(QEMUFile *f)
580
{
581
    return f->buf_offset - f->buf_size + f->buf_index;
582
}
583

    
584
int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
585
{
586
    if (whence == SEEK_SET) {
587
        /* nothing to do */
588
    } else if (whence == SEEK_CUR) {
589
        pos += qemu_ftell(f);
590
    } else {
591
        /* SEEK_END not supported */
592
        return -1;
593
    }
594
    if (f->put_buffer) {
595
        qemu_fflush(f);
596
        f->buf_offset = pos;
597
    } else {
598
        f->buf_offset = pos;
599
        f->buf_index = 0;
600
        f->buf_size = 0;
601
    }
602
    return pos;
603
}
604

    
605
int qemu_file_rate_limit(QEMUFile *f)
606
{
607
    if (f->rate_limit)
608
        return f->rate_limit(f->opaque);
609

    
610
    return 0;
611
}
612

    
613
int64_t qemu_file_get_rate_limit(QEMUFile *f)
614
{
615
    if (f->get_rate_limit)
616
        return f->get_rate_limit(f->opaque);
617

    
618
    return 0;
619
}
620

    
621
int64_t qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate)
622
{
623
    /* any failed or completed migration keeps its state to allow probing of
624
     * migration data, but has no associated file anymore */
625
    if (f && f->set_rate_limit)
626
        return f->set_rate_limit(f->opaque, new_rate);
627

    
628
    return 0;
629
}
630

    
631
void qemu_put_be16(QEMUFile *f, unsigned int v)
632
{
633
    qemu_put_byte(f, v >> 8);
634
    qemu_put_byte(f, v);
635
}
636

    
637
void qemu_put_be32(QEMUFile *f, unsigned int v)
638
{
639
    qemu_put_byte(f, v >> 24);
640
    qemu_put_byte(f, v >> 16);
641
    qemu_put_byte(f, v >> 8);
642
    qemu_put_byte(f, v);
643
}
644

    
645
void qemu_put_be64(QEMUFile *f, uint64_t v)
646
{
647
    qemu_put_be32(f, v >> 32);
648
    qemu_put_be32(f, v);
649
}
650

    
651
unsigned int qemu_get_be16(QEMUFile *f)
652
{
653
    unsigned int v;
654
    v = qemu_get_byte(f) << 8;
655
    v |= qemu_get_byte(f);
656
    return v;
657
}
658

    
659
unsigned int qemu_get_be32(QEMUFile *f)
660
{
661
    unsigned int v;
662
    v = qemu_get_byte(f) << 24;
663
    v |= qemu_get_byte(f) << 16;
664
    v |= qemu_get_byte(f) << 8;
665
    v |= qemu_get_byte(f);
666
    return v;
667
}
668

    
669
uint64_t qemu_get_be64(QEMUFile *f)
670
{
671
    uint64_t v;
672
    v = (uint64_t)qemu_get_be32(f) << 32;
673
    v |= qemu_get_be32(f);
674
    return v;
675
}
676

    
677
/* bool */
678

    
679
static int get_bool(QEMUFile *f, void *pv, size_t size)
680
{
681
    bool *v = pv;
682
    *v = qemu_get_byte(f);
683
    return 0;
684
}
685

    
686
static void put_bool(QEMUFile *f, void *pv, size_t size)
687
{
688
    bool *v = pv;
689
    qemu_put_byte(f, *v);
690
}
691

    
692
const VMStateInfo vmstate_info_bool = {
693
    .name = "bool",
694
    .get  = get_bool,
695
    .put  = put_bool,
696
};
697

    
698
/* 8 bit int */
699

    
700
static int get_int8(QEMUFile *f, void *pv, size_t size)
701
{
702
    int8_t *v = pv;
703
    qemu_get_s8s(f, v);
704
    return 0;
705
}
706

    
707
static void put_int8(QEMUFile *f, void *pv, size_t size)
708
{
709
    int8_t *v = pv;
710
    qemu_put_s8s(f, v);
711
}
712

    
713
const VMStateInfo vmstate_info_int8 = {
714
    .name = "int8",
715
    .get  = get_int8,
716
    .put  = put_int8,
717
};
718

    
719
/* 16 bit int */
720

    
721
static int get_int16(QEMUFile *f, void *pv, size_t size)
722
{
723
    int16_t *v = pv;
724
    qemu_get_sbe16s(f, v);
725
    return 0;
726
}
727

    
728
static void put_int16(QEMUFile *f, void *pv, size_t size)
729
{
730
    int16_t *v = pv;
731
    qemu_put_sbe16s(f, v);
732
}
733

    
734
const VMStateInfo vmstate_info_int16 = {
735
    .name = "int16",
736
    .get  = get_int16,
737
    .put  = put_int16,
738
};
739

    
740
/* 32 bit int */
741

    
742
static int get_int32(QEMUFile *f, void *pv, size_t size)
743
{
744
    int32_t *v = pv;
745
    qemu_get_sbe32s(f, v);
746
    return 0;
747
}
748

    
749
static void put_int32(QEMUFile *f, void *pv, size_t size)
750
{
751
    int32_t *v = pv;
752
    qemu_put_sbe32s(f, v);
753
}
754

    
755
const VMStateInfo vmstate_info_int32 = {
756
    .name = "int32",
757
    .get  = get_int32,
758
    .put  = put_int32,
759
};
760

    
761
/* 32 bit int. See that the received value is the same than the one
762
   in the field */
763

    
764
static int get_int32_equal(QEMUFile *f, void *pv, size_t size)
765
{
766
    int32_t *v = pv;
767
    int32_t v2;
768
    qemu_get_sbe32s(f, &v2);
769

    
770
    if (*v == v2)
771
        return 0;
772
    return -EINVAL;
773
}
774

    
775
const VMStateInfo vmstate_info_int32_equal = {
776
    .name = "int32 equal",
777
    .get  = get_int32_equal,
778
    .put  = put_int32,
779
};
780

    
781
/* 32 bit int. See that the received value is the less or the same
782
   than the one in the field */
783

    
784
static int get_int32_le(QEMUFile *f, void *pv, size_t size)
785
{
786
    int32_t *old = pv;
787
    int32_t new;
788
    qemu_get_sbe32s(f, &new);
789

    
790
    if (*old <= new)
791
        return 0;
792
    return -EINVAL;
793
}
794

    
795
const VMStateInfo vmstate_info_int32_le = {
796
    .name = "int32 equal",
797
    .get  = get_int32_le,
798
    .put  = put_int32,
799
};
800

    
801
/* 64 bit int */
802

    
803
static int get_int64(QEMUFile *f, void *pv, size_t size)
804
{
805
    int64_t *v = pv;
806
    qemu_get_sbe64s(f, v);
807
    return 0;
808
}
809

    
810
static void put_int64(QEMUFile *f, void *pv, size_t size)
811
{
812
    int64_t *v = pv;
813
    qemu_put_sbe64s(f, v);
814
}
815

    
816
const VMStateInfo vmstate_info_int64 = {
817
    .name = "int64",
818
    .get  = get_int64,
819
    .put  = put_int64,
820
};
821

    
822
/* 8 bit unsigned int */
823

    
824
static int get_uint8(QEMUFile *f, void *pv, size_t size)
825
{
826
    uint8_t *v = pv;
827
    qemu_get_8s(f, v);
828
    return 0;
829
}
830

    
831
static void put_uint8(QEMUFile *f, void *pv, size_t size)
832
{
833
    uint8_t *v = pv;
834
    qemu_put_8s(f, v);
835
}
836

    
837
const VMStateInfo vmstate_info_uint8 = {
838
    .name = "uint8",
839
    .get  = get_uint8,
840
    .put  = put_uint8,
841
};
842

    
843
/* 16 bit unsigned int */
844

    
845
static int get_uint16(QEMUFile *f, void *pv, size_t size)
846
{
847
    uint16_t *v = pv;
848
    qemu_get_be16s(f, v);
849
    return 0;
850
}
851

    
852
static void put_uint16(QEMUFile *f, void *pv, size_t size)
853
{
854
    uint16_t *v = pv;
855
    qemu_put_be16s(f, v);
856
}
857

    
858
const VMStateInfo vmstate_info_uint16 = {
859
    .name = "uint16",
860
    .get  = get_uint16,
861
    .put  = put_uint16,
862
};
863

    
864
/* 32 bit unsigned int */
865

    
866
static int get_uint32(QEMUFile *f, void *pv, size_t size)
867
{
868
    uint32_t *v = pv;
869
    qemu_get_be32s(f, v);
870
    return 0;
871
}
872

    
873
static void put_uint32(QEMUFile *f, void *pv, size_t size)
874
{
875
    uint32_t *v = pv;
876
    qemu_put_be32s(f, v);
877
}
878

    
879
const VMStateInfo vmstate_info_uint32 = {
880
    .name = "uint32",
881
    .get  = get_uint32,
882
    .put  = put_uint32,
883
};
884

    
885
/* 32 bit uint. See that the received value is the same than the one
886
   in the field */
887

    
888
static int get_uint32_equal(QEMUFile *f, void *pv, size_t size)
889
{
890
    uint32_t *v = pv;
891
    uint32_t v2;
892
    qemu_get_be32s(f, &v2);
893

    
894
    if (*v == v2) {
895
        return 0;
896
    }
897
    return -EINVAL;
898
}
899

    
900
const VMStateInfo vmstate_info_uint32_equal = {
901
    .name = "uint32 equal",
902
    .get  = get_uint32_equal,
903
    .put  = put_uint32,
904
};
905

    
906
/* 64 bit unsigned int */
907

    
908
static int get_uint64(QEMUFile *f, void *pv, size_t size)
909
{
910
    uint64_t *v = pv;
911
    qemu_get_be64s(f, v);
912
    return 0;
913
}
914

    
915
static void put_uint64(QEMUFile *f, void *pv, size_t size)
916
{
917
    uint64_t *v = pv;
918
    qemu_put_be64s(f, v);
919
}
920

    
921
const VMStateInfo vmstate_info_uint64 = {
922
    .name = "uint64",
923
    .get  = get_uint64,
924
    .put  = put_uint64,
925
};
926

    
927
/* 8 bit int. See that the received value is the same than the one
928
   in the field */
929

    
930
static int get_uint8_equal(QEMUFile *f, void *pv, size_t size)
931
{
932
    uint8_t *v = pv;
933
    uint8_t v2;
934
    qemu_get_8s(f, &v2);
935

    
936
    if (*v == v2)
937
        return 0;
938
    return -EINVAL;
939
}
940

    
941
const VMStateInfo vmstate_info_uint8_equal = {
942
    .name = "uint8 equal",
943
    .get  = get_uint8_equal,
944
    .put  = put_uint8,
945
};
946

    
947
/* 16 bit unsigned int int. See that the received value is the same than the one
948
   in the field */
949

    
950
static int get_uint16_equal(QEMUFile *f, void *pv, size_t size)
951
{
952
    uint16_t *v = pv;
953
    uint16_t v2;
954
    qemu_get_be16s(f, &v2);
955

    
956
    if (*v == v2)
957
        return 0;
958
    return -EINVAL;
959
}
960

    
961
const VMStateInfo vmstate_info_uint16_equal = {
962
    .name = "uint16 equal",
963
    .get  = get_uint16_equal,
964
    .put  = put_uint16,
965
};
966

    
967
/* timers  */
968

    
969
static int get_timer(QEMUFile *f, void *pv, size_t size)
970
{
971
    QEMUTimer *v = pv;
972
    qemu_get_timer(f, v);
973
    return 0;
974
}
975

    
976
static void put_timer(QEMUFile *f, void *pv, size_t size)
977
{
978
    QEMUTimer *v = pv;
979
    qemu_put_timer(f, v);
980
}
981

    
982
const VMStateInfo vmstate_info_timer = {
983
    .name = "timer",
984
    .get  = get_timer,
985
    .put  = put_timer,
986
};
987

    
988
/* uint8_t buffers */
989

    
990
static int get_buffer(QEMUFile *f, void *pv, size_t size)
991
{
992
    uint8_t *v = pv;
993
    qemu_get_buffer(f, v, size);
994
    return 0;
995
}
996

    
997
static void put_buffer(QEMUFile *f, void *pv, size_t size)
998
{
999
    uint8_t *v = pv;
1000
    qemu_put_buffer(f, v, size);
1001
}
1002

    
1003
const VMStateInfo vmstate_info_buffer = {
1004
    .name = "buffer",
1005
    .get  = get_buffer,
1006
    .put  = put_buffer,
1007
};
1008

    
1009
/* unused buffers: space that was used for some fields that are
1010
   not usefull anymore */
1011

    
1012
static int get_unused_buffer(QEMUFile *f, void *pv, size_t size)
1013
{
1014
    uint8_t buf[1024];
1015
    int block_len;
1016

    
1017
    while (size > 0) {
1018
        block_len = MIN(sizeof(buf), size);
1019
        size -= block_len;
1020
        qemu_get_buffer(f, buf, block_len);
1021
    }
1022
   return 0;
1023
}
1024

    
1025
static void put_unused_buffer(QEMUFile *f, void *pv, size_t size)
1026
{
1027
    static const uint8_t buf[1024];
1028
    int block_len;
1029

    
1030
    while (size > 0) {
1031
        block_len = MIN(sizeof(buf), size);
1032
        size -= block_len;
1033
        qemu_put_buffer(f, buf, block_len);
1034
    }
1035
}
1036

    
1037
const VMStateInfo vmstate_info_unused_buffer = {
1038
    .name = "unused_buffer",
1039
    .get  = get_unused_buffer,
1040
    .put  = put_unused_buffer,
1041
};
1042

    
1043
typedef struct CompatEntry {
1044
    char idstr[256];
1045
    int instance_id;
1046
} CompatEntry;
1047

    
1048
typedef struct SaveStateEntry {
1049
    QTAILQ_ENTRY(SaveStateEntry) entry;
1050
    char idstr[256];
1051
    int instance_id;
1052
    int alias_id;
1053
    int version_id;
1054
    int section_id;
1055
    SaveSetParamsHandler *set_params;
1056
    SaveLiveStateHandler *save_live_state;
1057
    SaveStateHandler *save_state;
1058
    LoadStateHandler *load_state;
1059
    const VMStateDescription *vmsd;
1060
    void *opaque;
1061
    CompatEntry *compat;
1062
    int no_migrate;
1063
} SaveStateEntry;
1064

    
1065

    
1066
static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers =
1067
    QTAILQ_HEAD_INITIALIZER(savevm_handlers);
1068
static int global_section_id;
1069

    
1070
static int calculate_new_instance_id(const char *idstr)
1071
{
1072
    SaveStateEntry *se;
1073
    int instance_id = 0;
1074

    
1075
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1076
        if (strcmp(idstr, se->idstr) == 0
1077
            && instance_id <= se->instance_id) {
1078
            instance_id = se->instance_id + 1;
1079
        }
1080
    }
1081
    return instance_id;
1082
}
1083

    
1084
static int calculate_compat_instance_id(const char *idstr)
1085
{
1086
    SaveStateEntry *se;
1087
    int instance_id = 0;
1088

    
1089
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1090
        if (!se->compat)
1091
            continue;
1092

    
1093
        if (strcmp(idstr, se->compat->idstr) == 0
1094
            && instance_id <= se->compat->instance_id) {
1095
            instance_id = se->compat->instance_id + 1;
1096
        }
1097
    }
1098
    return instance_id;
1099
}
1100

    
1101
/* TODO: Individual devices generally have very little idea about the rest
1102
   of the system, so instance_id should be removed/replaced.
1103
   Meanwhile pass -1 as instance_id if you do not already have a clearly
1104
   distinguishing id for all instances of your device class. */
1105
int register_savevm_live(DeviceState *dev,
1106
                         const char *idstr,
1107
                         int instance_id,
1108
                         int version_id,
1109
                         SaveSetParamsHandler *set_params,
1110
                         SaveLiveStateHandler *save_live_state,
1111
                         SaveStateHandler *save_state,
1112
                         LoadStateHandler *load_state,
1113
                         void *opaque)
1114
{
1115
    SaveStateEntry *se;
1116

    
1117
    se = qemu_mallocz(sizeof(SaveStateEntry));
1118
    se->version_id = version_id;
1119
    se->section_id = global_section_id++;
1120
    se->set_params = set_params;
1121
    se->save_live_state = save_live_state;
1122
    se->save_state = save_state;
1123
    se->load_state = load_state;
1124
    se->opaque = opaque;
1125
    se->vmsd = NULL;
1126
    se->no_migrate = 0;
1127

    
1128
    if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
1129
        char *id = dev->parent_bus->info->get_dev_path(dev);
1130
        if (id) {
1131
            pstrcpy(se->idstr, sizeof(se->idstr), id);
1132
            pstrcat(se->idstr, sizeof(se->idstr), "/");
1133
            qemu_free(id);
1134

    
1135
            se->compat = qemu_mallocz(sizeof(CompatEntry));
1136
            pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr);
1137
            se->compat->instance_id = instance_id == -1 ?
1138
                         calculate_compat_instance_id(idstr) : instance_id;
1139
            instance_id = -1;
1140
        }
1141
    }
1142
    pstrcat(se->idstr, sizeof(se->idstr), idstr);
1143

    
1144
    if (instance_id == -1) {
1145
        se->instance_id = calculate_new_instance_id(se->idstr);
1146
    } else {
1147
        se->instance_id = instance_id;
1148
    }
1149
    assert(!se->compat || se->instance_id == 0);
1150
    /* add at the end of list */
1151
    QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1152
    return 0;
1153
}
1154

    
1155
int register_savevm(DeviceState *dev,
1156
                    const char *idstr,
1157
                    int instance_id,
1158
                    int version_id,
1159
                    SaveStateHandler *save_state,
1160
                    LoadStateHandler *load_state,
1161
                    void *opaque)
1162
{
1163
    return register_savevm_live(dev, idstr, instance_id, version_id,
1164
                                NULL, NULL, save_state, load_state, opaque);
1165
}
1166

    
1167
void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
1168
{
1169
    SaveStateEntry *se, *new_se;
1170
    char id[256] = "";
1171

    
1172
    if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
1173
        char *path = dev->parent_bus->info->get_dev_path(dev);
1174
        if (path) {
1175
            pstrcpy(id, sizeof(id), path);
1176
            pstrcat(id, sizeof(id), "/");
1177
            qemu_free(path);
1178
        }
1179
    }
1180
    pstrcat(id, sizeof(id), idstr);
1181

    
1182
    QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1183
        if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
1184
            QTAILQ_REMOVE(&savevm_handlers, se, entry);
1185
            if (se->compat) {
1186
                qemu_free(se->compat);
1187
            }
1188
            qemu_free(se);
1189
        }
1190
    }
1191
}
1192

    
1193
/* mark a device as not to be migrated, that is the device should be
1194
   unplugged before migration */
1195
void register_device_unmigratable(DeviceState *dev, const char *idstr,
1196
                                                            void *opaque)
1197
{
1198
    SaveStateEntry *se;
1199
    char id[256] = "";
1200

    
1201
    if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
1202
        char *path = dev->parent_bus->info->get_dev_path(dev);
1203
        if (path) {
1204
            pstrcpy(id, sizeof(id), path);
1205
            pstrcat(id, sizeof(id), "/");
1206
            qemu_free(path);
1207
        }
1208
    }
1209
    pstrcat(id, sizeof(id), idstr);
1210

    
1211
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1212
        if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
1213
            se->no_migrate = 1;
1214
        }
1215
    }
1216
}
1217

    
1218
int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
1219
                                   const VMStateDescription *vmsd,
1220
                                   void *opaque, int alias_id,
1221
                                   int required_for_version)
1222
{
1223
    SaveStateEntry *se;
1224

    
1225
    /* If this triggers, alias support can be dropped for the vmsd. */
1226
    assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id);
1227

    
1228
    se = qemu_mallocz(sizeof(SaveStateEntry));
1229
    se->version_id = vmsd->version_id;
1230
    se->section_id = global_section_id++;
1231
    se->save_live_state = NULL;
1232
    se->save_state = NULL;
1233
    se->load_state = NULL;
1234
    se->opaque = opaque;
1235
    se->vmsd = vmsd;
1236
    se->alias_id = alias_id;
1237

    
1238
    if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
1239
        char *id = dev->parent_bus->info->get_dev_path(dev);
1240
        if (id) {
1241
            pstrcpy(se->idstr, sizeof(se->idstr), id);
1242
            pstrcat(se->idstr, sizeof(se->idstr), "/");
1243
            qemu_free(id);
1244

    
1245
            se->compat = qemu_mallocz(sizeof(CompatEntry));
1246
            pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
1247
            se->compat->instance_id = instance_id == -1 ?
1248
                         calculate_compat_instance_id(vmsd->name) : instance_id;
1249
            instance_id = -1;
1250
        }
1251
    }
1252
    pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);
1253

    
1254
    if (instance_id == -1) {
1255
        se->instance_id = calculate_new_instance_id(se->idstr);
1256
    } else {
1257
        se->instance_id = instance_id;
1258
    }
1259
    assert(!se->compat || se->instance_id == 0);
1260
    /* add at the end of list */
1261
    QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1262
    return 0;
1263
}
1264

    
1265
int vmstate_register(DeviceState *dev, int instance_id,
1266
                     const VMStateDescription *vmsd, void *opaque)
1267
{
1268
    return vmstate_register_with_alias_id(dev, instance_id, vmsd,
1269
                                          opaque, -1, 0);
1270
}
1271

    
1272
void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
1273
                        void *opaque)
1274
{
1275
    SaveStateEntry *se, *new_se;
1276

    
1277
    QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1278
        if (se->vmsd == vmsd && se->opaque == opaque) {
1279
            QTAILQ_REMOVE(&savevm_handlers, se, entry);
1280
            if (se->compat) {
1281
                qemu_free(se->compat);
1282
            }
1283
            qemu_free(se);
1284
        }
1285
    }
1286
}
1287

    
1288
static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
1289
                                    void *opaque);
1290
static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
1291
                                   void *opaque);
1292

    
1293
int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
1294
                       void *opaque, int version_id)
1295
{
1296
    VMStateField *field = vmsd->fields;
1297
    int ret;
1298

    
1299
    if (version_id > vmsd->version_id) {
1300
        return -EINVAL;
1301
    }
1302
    if (version_id < vmsd->minimum_version_id_old) {
1303
        return -EINVAL;
1304
    }
1305
    if  (version_id < vmsd->minimum_version_id) {
1306
        return vmsd->load_state_old(f, opaque, version_id);
1307
    }
1308
    if (vmsd->pre_load) {
1309
        int ret = vmsd->pre_load(opaque);
1310
        if (ret)
1311
            return ret;
1312
    }
1313
    while(field->name) {
1314
        if ((field->field_exists &&
1315
             field->field_exists(opaque, version_id)) ||
1316
            (!field->field_exists &&
1317
             field->version_id <= version_id)) {
1318
            void *base_addr = opaque + field->offset;
1319
            int i, n_elems = 1;
1320
            int size = field->size;
1321

    
1322
            if (field->flags & VMS_VBUFFER) {
1323
                size = *(int32_t *)(opaque+field->size_offset);
1324
                if (field->flags & VMS_MULTIPLY) {
1325
                    size *= field->size;
1326
                }
1327
            }
1328
            if (field->flags & VMS_ARRAY) {
1329
                n_elems = field->num;
1330
            } else if (field->flags & VMS_VARRAY_INT32) {
1331
                n_elems = *(int32_t *)(opaque+field->num_offset);
1332
            } else if (field->flags & VMS_VARRAY_UINT32) {
1333
                n_elems = *(uint32_t *)(opaque+field->num_offset);
1334
            } else if (field->flags & VMS_VARRAY_UINT16) {
1335
                n_elems = *(uint16_t *)(opaque+field->num_offset);
1336
            } else if (field->flags & VMS_VARRAY_UINT8) {
1337
                n_elems = *(uint8_t *)(opaque+field->num_offset);
1338
            }
1339
            if (field->flags & VMS_POINTER) {
1340
                base_addr = *(void **)base_addr + field->start;
1341
            }
1342
            for (i = 0; i < n_elems; i++) {
1343
                void *addr = base_addr + size * i;
1344

    
1345
                if (field->flags & VMS_ARRAY_OF_POINTER) {
1346
                    addr = *(void **)addr;
1347
                }
1348
                if (field->flags & VMS_STRUCT) {
1349
                    ret = vmstate_load_state(f, field->vmsd, addr, field->vmsd->version_id);
1350
                } else {
1351
                    ret = field->info->get(f, addr, size);
1352

    
1353
                }
1354
                if (ret < 0) {
1355
                    return ret;
1356
                }
1357
            }
1358
        }
1359
        field++;
1360
    }
1361
    ret = vmstate_subsection_load(f, vmsd, opaque);
1362
    if (ret != 0) {
1363
        return ret;
1364
    }
1365
    if (vmsd->post_load) {
1366
        return vmsd->post_load(opaque, version_id);
1367
    }
1368
    return 0;
1369
}
1370

    
1371
void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
1372
                        void *opaque)
1373
{
1374
    VMStateField *field = vmsd->fields;
1375

    
1376
    if (vmsd->pre_save) {
1377
        vmsd->pre_save(opaque);
1378
    }
1379
    while(field->name) {
1380
        if (!field->field_exists ||
1381
            field->field_exists(opaque, vmsd->version_id)) {
1382
            void *base_addr = opaque + field->offset;
1383
            int i, n_elems = 1;
1384
            int size = field->size;
1385

    
1386
            if (field->flags & VMS_VBUFFER) {
1387
                size = *(int32_t *)(opaque+field->size_offset);
1388
                if (field->flags & VMS_MULTIPLY) {
1389
                    size *= field->size;
1390
                }
1391
            }
1392
            if (field->flags & VMS_ARRAY) {
1393
                n_elems = field->num;
1394
            } else if (field->flags & VMS_VARRAY_INT32) {
1395
                n_elems = *(int32_t *)(opaque+field->num_offset);
1396
            } else if (field->flags & VMS_VARRAY_UINT16) {
1397
                n_elems = *(uint16_t *)(opaque+field->num_offset);
1398
            } else if (field->flags & VMS_VARRAY_UINT8) {
1399
                n_elems = *(uint8_t *)(opaque+field->num_offset);
1400
            }
1401
            if (field->flags & VMS_POINTER) {
1402
                base_addr = *(void **)base_addr + field->start;
1403
            }
1404
            for (i = 0; i < n_elems; i++) {
1405
                void *addr = base_addr + size * i;
1406

    
1407
                if (field->flags & VMS_ARRAY_OF_POINTER) {
1408
                    addr = *(void **)addr;
1409
                }
1410
                if (field->flags & VMS_STRUCT) {
1411
                    vmstate_save_state(f, field->vmsd, addr);
1412
                } else {
1413
                    field->info->put(f, addr, size);
1414
                }
1415
            }
1416
        }
1417
        field++;
1418
    }
1419
    vmstate_subsection_save(f, vmsd, opaque);
1420
}
1421

    
1422
static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id)
1423
{
1424
    if (!se->vmsd) {         /* Old style */
1425
        return se->load_state(f, se->opaque, version_id);
1426
    }
1427
    return vmstate_load_state(f, se->vmsd, se->opaque, version_id);
1428
}
1429

    
1430
static void vmstate_save(QEMUFile *f, SaveStateEntry *se)
1431
{
1432
    if (!se->vmsd) {         /* Old style */
1433
        se->save_state(f, se->opaque);
1434
        return;
1435
    }
1436
    vmstate_save_state(f,se->vmsd, se->opaque);
1437
}
1438

    
1439
#define QEMU_VM_FILE_MAGIC           0x5145564d
1440
#define QEMU_VM_FILE_VERSION_COMPAT  0x00000002
1441
#define QEMU_VM_FILE_VERSION         0x00000003
1442

    
1443
#define QEMU_VM_EOF                  0x00
1444
#define QEMU_VM_SECTION_START        0x01
1445
#define QEMU_VM_SECTION_PART         0x02
1446
#define QEMU_VM_SECTION_END          0x03
1447
#define QEMU_VM_SECTION_FULL         0x04
1448
#define QEMU_VM_SUBSECTION           0x05
1449

    
1450
bool qemu_savevm_state_blocked(Monitor *mon)
1451
{
1452
    SaveStateEntry *se;
1453

    
1454
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1455
        if (se->no_migrate) {
1456
            monitor_printf(mon, "state blocked by non-migratable device '%s'\n",
1457
                           se->idstr);
1458
            return true;
1459
        }
1460
    }
1461
    return false;
1462
}
1463

    
1464
int qemu_savevm_state_begin(Monitor *mon, QEMUFile *f, int blk_enable,
1465
                            int shared)
1466
{
1467
    SaveStateEntry *se;
1468

    
1469
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1470
        if(se->set_params == NULL) {
1471
            continue;
1472
        }
1473
        se->set_params(blk_enable, shared, se->opaque);
1474
    }
1475
    
1476
    qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1477
    qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1478

    
1479
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1480
        int len;
1481

    
1482
        if (se->save_live_state == NULL)
1483
            continue;
1484

    
1485
        /* Section type */
1486
        qemu_put_byte(f, QEMU_VM_SECTION_START);
1487
        qemu_put_be32(f, se->section_id);
1488

    
1489
        /* ID string */
1490
        len = strlen(se->idstr);
1491
        qemu_put_byte(f, len);
1492
        qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1493

    
1494
        qemu_put_be32(f, se->instance_id);
1495
        qemu_put_be32(f, se->version_id);
1496

    
1497
        se->save_live_state(mon, f, QEMU_VM_SECTION_START, se->opaque);
1498
    }
1499

    
1500
    if (qemu_file_has_error(f)) {
1501
        qemu_savevm_state_cancel(mon, f);
1502
        return -EIO;
1503
    }
1504

    
1505
    return 0;
1506
}
1507

    
1508
int qemu_savevm_state_iterate(Monitor *mon, QEMUFile *f)
1509
{
1510
    SaveStateEntry *se;
1511
    int ret = 1;
1512

    
1513
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1514
        if (se->save_live_state == NULL)
1515
            continue;
1516

    
1517
        /* Section type */
1518
        qemu_put_byte(f, QEMU_VM_SECTION_PART);
1519
        qemu_put_be32(f, se->section_id);
1520

    
1521
        ret = se->save_live_state(mon, f, QEMU_VM_SECTION_PART, se->opaque);
1522
        if (!ret) {
1523
            /* Do not proceed to the next vmstate before this one reported
1524
               completion of the current stage. This serializes the migration
1525
               and reduces the probability that a faster changing state is
1526
               synchronized over and over again. */
1527
            break;
1528
        }
1529
    }
1530

    
1531
    if (ret)
1532
        return 1;
1533

    
1534
    if (qemu_file_has_error(f)) {
1535
        qemu_savevm_state_cancel(mon, f);
1536
        return -EIO;
1537
    }
1538

    
1539
    return 0;
1540
}
1541

    
1542
int qemu_savevm_state_complete(Monitor *mon, QEMUFile *f)
1543
{
1544
    SaveStateEntry *se;
1545

    
1546
    cpu_synchronize_all_states();
1547

    
1548
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1549
        if (se->save_live_state == NULL)
1550
            continue;
1551

    
1552
        /* Section type */
1553
        qemu_put_byte(f, QEMU_VM_SECTION_END);
1554
        qemu_put_be32(f, se->section_id);
1555

    
1556
        se->save_live_state(mon, f, QEMU_VM_SECTION_END, se->opaque);
1557
    }
1558

    
1559
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1560
        int len;
1561

    
1562
        if (se->save_state == NULL && se->vmsd == NULL)
1563
            continue;
1564

    
1565
        /* Section type */
1566
        qemu_put_byte(f, QEMU_VM_SECTION_FULL);
1567
        qemu_put_be32(f, se->section_id);
1568

    
1569
        /* ID string */
1570
        len = strlen(se->idstr);
1571
        qemu_put_byte(f, len);
1572
        qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1573

    
1574
        qemu_put_be32(f, se->instance_id);
1575
        qemu_put_be32(f, se->version_id);
1576

    
1577
        vmstate_save(f, se);
1578
    }
1579

    
1580
    qemu_put_byte(f, QEMU_VM_EOF);
1581

    
1582
    if (qemu_file_has_error(f))
1583
        return -EIO;
1584

    
1585
    return 0;
1586
}
1587

    
1588
void qemu_savevm_state_cancel(Monitor *mon, QEMUFile *f)
1589
{
1590
    SaveStateEntry *se;
1591

    
1592
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1593
        if (se->save_live_state) {
1594
            se->save_live_state(mon, f, -1, se->opaque);
1595
        }
1596
    }
1597
}
1598

    
1599
static int qemu_savevm_state(Monitor *mon, QEMUFile *f)
1600
{
1601
    int saved_vm_running;
1602
    int ret;
1603

    
1604
    saved_vm_running = vm_running;
1605
    vm_stop(VMSTOP_SAVEVM);
1606

    
1607
    if (qemu_savevm_state_blocked(mon)) {
1608
        ret = -EINVAL;
1609
        goto out;
1610
    }
1611

    
1612
    ret = qemu_savevm_state_begin(mon, f, 0, 0);
1613
    if (ret < 0)
1614
        goto out;
1615

    
1616
    do {
1617
        ret = qemu_savevm_state_iterate(mon, f);
1618
        if (ret < 0)
1619
            goto out;
1620
    } while (ret == 0);
1621

    
1622
    ret = qemu_savevm_state_complete(mon, f);
1623

    
1624
out:
1625
    if (qemu_file_has_error(f))
1626
        ret = -EIO;
1627

    
1628
    if (!ret && saved_vm_running)
1629
        vm_start();
1630

    
1631
    return ret;
1632
}
1633

    
1634
static SaveStateEntry *find_se(const char *idstr, int instance_id)
1635
{
1636
    SaveStateEntry *se;
1637

    
1638
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1639
        if (!strcmp(se->idstr, idstr) &&
1640
            (instance_id == se->instance_id ||
1641
             instance_id == se->alias_id))
1642
            return se;
1643
        /* Migrating from an older version? */
1644
        if (strstr(se->idstr, idstr) && se->compat) {
1645
            if (!strcmp(se->compat->idstr, idstr) &&
1646
                (instance_id == se->compat->instance_id ||
1647
                 instance_id == se->alias_id))
1648
                return se;
1649
        }
1650
    }
1651
    return NULL;
1652
}
1653

    
1654
static const VMStateDescription *vmstate_get_subsection(const VMStateSubsection *sub, char *idstr)
1655
{
1656
    while(sub && sub->needed) {
1657
        if (strcmp(idstr, sub->vmsd->name) == 0) {
1658
            return sub->vmsd;
1659
        }
1660
        sub++;
1661
    }
1662
    return NULL;
1663
}
1664

    
1665
static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
1666
                                   void *opaque)
1667
{
1668
    const VMStateSubsection *sub = vmsd->subsections;
1669

    
1670
    if (!sub || !sub->needed) {
1671
        return 0;
1672
    }
1673

    
1674
    while (qemu_peek_byte(f) == QEMU_VM_SUBSECTION) {
1675
        char idstr[256];
1676
        int ret;
1677
        uint8_t version_id, len;
1678
        const VMStateDescription *sub_vmsd;
1679

    
1680
        qemu_get_byte(f); /* subsection */
1681
        len = qemu_get_byte(f);
1682
        qemu_get_buffer(f, (uint8_t *)idstr, len);
1683
        idstr[len] = 0;
1684
        version_id = qemu_get_be32(f);
1685

    
1686
        sub_vmsd = vmstate_get_subsection(sub, idstr);
1687
        if (sub_vmsd == NULL) {
1688
            return -ENOENT;
1689
        }
1690
        assert(!sub_vmsd->subsections);
1691
        ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
1692
        if (ret) {
1693
            return ret;
1694
        }
1695
    }
1696
    return 0;
1697
}
1698

    
1699
static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
1700
                                    void *opaque)
1701
{
1702
    const VMStateSubsection *sub = vmsd->subsections;
1703

    
1704
    while (sub && sub->needed) {
1705
        if (sub->needed(opaque)) {
1706
            const VMStateDescription *vmsd = sub->vmsd;
1707
            uint8_t len;
1708

    
1709
            qemu_put_byte(f, QEMU_VM_SUBSECTION);
1710
            len = strlen(vmsd->name);
1711
            qemu_put_byte(f, len);
1712
            qemu_put_buffer(f, (uint8_t *)vmsd->name, len);
1713
            qemu_put_be32(f, vmsd->version_id);
1714
            assert(!vmsd->subsections);
1715
            vmstate_save_state(f, vmsd, opaque);
1716
        }
1717
        sub++;
1718
    }
1719
}
1720

    
1721
typedef struct LoadStateEntry {
1722
    QLIST_ENTRY(LoadStateEntry) entry;
1723
    SaveStateEntry *se;
1724
    int section_id;
1725
    int version_id;
1726
} LoadStateEntry;
1727

    
1728
int qemu_loadvm_state(QEMUFile *f)
1729
{
1730
    QLIST_HEAD(, LoadStateEntry) loadvm_handlers =
1731
        QLIST_HEAD_INITIALIZER(loadvm_handlers);
1732
    LoadStateEntry *le, *new_le;
1733
    uint8_t section_type;
1734
    unsigned int v;
1735
    int ret;
1736

    
1737
    if (qemu_savevm_state_blocked(default_mon)) {
1738
        return -EINVAL;
1739
    }
1740

    
1741
    v = qemu_get_be32(f);
1742
    if (v != QEMU_VM_FILE_MAGIC)
1743
        return -EINVAL;
1744

    
1745
    v = qemu_get_be32(f);
1746
    if (v == QEMU_VM_FILE_VERSION_COMPAT) {
1747
        fprintf(stderr, "SaveVM v2 format is obsolete and don't work anymore\n");
1748
        return -ENOTSUP;
1749
    }
1750
    if (v != QEMU_VM_FILE_VERSION)
1751
        return -ENOTSUP;
1752

    
1753
    while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
1754
        uint32_t instance_id, version_id, section_id;
1755
        SaveStateEntry *se;
1756
        char idstr[257];
1757
        int len;
1758

    
1759
        switch (section_type) {
1760
        case QEMU_VM_SECTION_START:
1761
        case QEMU_VM_SECTION_FULL:
1762
            /* Read section start */
1763
            section_id = qemu_get_be32(f);
1764
            len = qemu_get_byte(f);
1765
            qemu_get_buffer(f, (uint8_t *)idstr, len);
1766
            idstr[len] = 0;
1767
            instance_id = qemu_get_be32(f);
1768
            version_id = qemu_get_be32(f);
1769

    
1770
            /* Find savevm section */
1771
            se = find_se(idstr, instance_id);
1772
            if (se == NULL) {
1773
                fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
1774
                ret = -EINVAL;
1775
                goto out;
1776
            }
1777

    
1778
            /* Validate version */
1779
            if (version_id > se->version_id) {
1780
                fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
1781
                        version_id, idstr, se->version_id);
1782
                ret = -EINVAL;
1783
                goto out;
1784
            }
1785

    
1786
            /* Add entry */
1787
            le = qemu_mallocz(sizeof(*le));
1788

    
1789
            le->se = se;
1790
            le->section_id = section_id;
1791
            le->version_id = version_id;
1792
            QLIST_INSERT_HEAD(&loadvm_handlers, le, entry);
1793

    
1794
            ret = vmstate_load(f, le->se, le->version_id);
1795
            if (ret < 0) {
1796
                fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
1797
                        instance_id, idstr);
1798
                goto out;
1799
            }
1800
            break;
1801
        case QEMU_VM_SECTION_PART:
1802
        case QEMU_VM_SECTION_END:
1803
            section_id = qemu_get_be32(f);
1804

    
1805
            QLIST_FOREACH(le, &loadvm_handlers, entry) {
1806
                if (le->section_id == section_id) {
1807
                    break;
1808
                }
1809
            }
1810
            if (le == NULL) {
1811
                fprintf(stderr, "Unknown savevm section %d\n", section_id);
1812
                ret = -EINVAL;
1813
                goto out;
1814
            }
1815

    
1816
            ret = vmstate_load(f, le->se, le->version_id);
1817
            if (ret < 0) {
1818
                fprintf(stderr, "qemu: warning: error while loading state section id %d\n",
1819
                        section_id);
1820
                goto out;
1821
            }
1822
            break;
1823
        default:
1824
            fprintf(stderr, "Unknown savevm section type %d\n", section_type);
1825
            ret = -EINVAL;
1826
            goto out;
1827
        }
1828
    }
1829

    
1830
    cpu_synchronize_all_post_init();
1831

    
1832
    ret = 0;
1833

    
1834
out:
1835
    QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
1836
        QLIST_REMOVE(le, entry);
1837
        qemu_free(le);
1838
    }
1839

    
1840
    if (qemu_file_has_error(f))
1841
        ret = -EIO;
1842

    
1843
    return ret;
1844
}
1845

    
1846
static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
1847
                              const char *name)
1848
{
1849
    QEMUSnapshotInfo *sn_tab, *sn;
1850
    int nb_sns, i, ret;
1851

    
1852
    ret = -ENOENT;
1853
    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1854
    if (nb_sns < 0)
1855
        return ret;
1856
    for(i = 0; i < nb_sns; i++) {
1857
        sn = &sn_tab[i];
1858
        if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
1859
            *sn_info = *sn;
1860
            ret = 0;
1861
            break;
1862
        }
1863
    }
1864
    qemu_free(sn_tab);
1865
    return ret;
1866
}
1867

    
1868
/*
1869
 * Deletes snapshots of a given name in all opened images.
1870
 */
1871
static int del_existing_snapshots(Monitor *mon, const char *name)
1872
{
1873
    BlockDriverState *bs;
1874
    QEMUSnapshotInfo sn1, *snapshot = &sn1;
1875
    int ret;
1876

    
1877
    bs = NULL;
1878
    while ((bs = bdrv_next(bs))) {
1879
        if (bdrv_can_snapshot(bs) &&
1880
            bdrv_snapshot_find(bs, snapshot, name) >= 0)
1881
        {
1882
            ret = bdrv_snapshot_delete(bs, name);
1883
            if (ret < 0) {
1884
                monitor_printf(mon,
1885
                               "Error while deleting snapshot on '%s'\n",
1886
                               bdrv_get_device_name(bs));
1887
                return -1;
1888
            }
1889
        }
1890
    }
1891

    
1892
    return 0;
1893
}
1894

    
1895
void do_savevm(Monitor *mon, const QDict *qdict)
1896
{
1897
    BlockDriverState *bs, *bs1;
1898
    QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
1899
    int ret;
1900
    QEMUFile *f;
1901
    int saved_vm_running;
1902
    uint32_t vm_state_size;
1903
#ifdef _WIN32
1904
    struct _timeb tb;
1905
    struct tm *ptm;
1906
#else
1907
    struct timeval tv;
1908
    struct tm tm;
1909
#endif
1910
    const char *name = qdict_get_try_str(qdict, "name");
1911

    
1912
    /* Verify if there is a device that doesn't support snapshots and is writable */
1913
    bs = NULL;
1914
    while ((bs = bdrv_next(bs))) {
1915

    
1916
        if (bdrv_is_removable(bs) || bdrv_is_read_only(bs)) {
1917
            continue;
1918
        }
1919

    
1920
        if (!bdrv_can_snapshot(bs)) {
1921
            monitor_printf(mon, "Device '%s' is writable but does not support snapshots.\n",
1922
                               bdrv_get_device_name(bs));
1923
            return;
1924
        }
1925
    }
1926

    
1927
    bs = bdrv_snapshots();
1928
    if (!bs) {
1929
        monitor_printf(mon, "No block device can accept snapshots\n");
1930
        return;
1931
    }
1932

    
1933
    saved_vm_running = vm_running;
1934
    vm_stop(VMSTOP_SAVEVM);
1935

    
1936
    memset(sn, 0, sizeof(*sn));
1937

    
1938
    /* fill auxiliary fields */
1939
#ifdef _WIN32
1940
    _ftime(&tb);
1941
    sn->date_sec = tb.time;
1942
    sn->date_nsec = tb.millitm * 1000000;
1943
#else
1944
    gettimeofday(&tv, NULL);
1945
    sn->date_sec = tv.tv_sec;
1946
    sn->date_nsec = tv.tv_usec * 1000;
1947
#endif
1948
    sn->vm_clock_nsec = qemu_get_clock_ns(vm_clock);
1949

    
1950
    if (name) {
1951
        ret = bdrv_snapshot_find(bs, old_sn, name);
1952
        if (ret >= 0) {
1953
            pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
1954
            pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
1955
        } else {
1956
            pstrcpy(sn->name, sizeof(sn->name), name);
1957
        }
1958
    } else {
1959
#ifdef _WIN32
1960
        ptm = localtime(&tb.time);
1961
        strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", ptm);
1962
#else
1963
        /* cast below needed for OpenBSD where tv_sec is still 'long' */
1964
        localtime_r((const time_t *)&tv.tv_sec, &tm);
1965
        strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
1966
#endif
1967
    }
1968

    
1969
    /* Delete old snapshots of the same name */
1970
    if (name && del_existing_snapshots(mon, name) < 0) {
1971
        goto the_end;
1972
    }
1973

    
1974
    /* save the VM state */
1975
    f = qemu_fopen_bdrv(bs, 1);
1976
    if (!f) {
1977
        monitor_printf(mon, "Could not open VM state file\n");
1978
        goto the_end;
1979
    }
1980
    ret = qemu_savevm_state(mon, f);
1981
    vm_state_size = qemu_ftell(f);
1982
    qemu_fclose(f);
1983
    if (ret < 0) {
1984
        monitor_printf(mon, "Error %d while writing VM\n", ret);
1985
        goto the_end;
1986
    }
1987

    
1988
    /* create the snapshots */
1989

    
1990
    bs1 = NULL;
1991
    while ((bs1 = bdrv_next(bs1))) {
1992
        if (bdrv_can_snapshot(bs1)) {
1993
            /* Write VM state size only to the image that contains the state */
1994
            sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
1995
            ret = bdrv_snapshot_create(bs1, sn);
1996
            if (ret < 0) {
1997
                monitor_printf(mon, "Error while creating snapshot on '%s'\n",
1998
                               bdrv_get_device_name(bs1));
1999
            }
2000
        }
2001
    }
2002

    
2003
 the_end:
2004
    if (saved_vm_running)
2005
        vm_start();
2006
}
2007

    
2008
int load_vmstate(const char *name)
2009
{
2010
    BlockDriverState *bs, *bs_vm_state;
2011
    QEMUSnapshotInfo sn;
2012
    QEMUFile *f;
2013
    int ret;
2014

    
2015
    bs_vm_state = bdrv_snapshots();
2016
    if (!bs_vm_state) {
2017
        error_report("No block device supports snapshots");
2018
        return -ENOTSUP;
2019
    }
2020

    
2021
    /* Don't even try to load empty VM states */
2022
    ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
2023
    if (ret < 0) {
2024
        return ret;
2025
    } else if (sn.vm_state_size == 0) {
2026
        error_report("This is a disk-only snapshot. Revert to it offline "
2027
            "using qemu-img.");
2028
        return -EINVAL;
2029
    }
2030

    
2031
    /* Verify if there is any device that doesn't support snapshots and is
2032
    writable and check if the requested snapshot is available too. */
2033
    bs = NULL;
2034
    while ((bs = bdrv_next(bs))) {
2035

    
2036
        if (bdrv_is_removable(bs) || bdrv_is_read_only(bs)) {
2037
            continue;
2038
        }
2039

    
2040
        if (!bdrv_can_snapshot(bs)) {
2041
            error_report("Device '%s' is writable but does not support snapshots.",
2042
                               bdrv_get_device_name(bs));
2043
            return -ENOTSUP;
2044
        }
2045

    
2046
        ret = bdrv_snapshot_find(bs, &sn, name);
2047
        if (ret < 0) {
2048
            error_report("Device '%s' does not have the requested snapshot '%s'",
2049
                           bdrv_get_device_name(bs), name);
2050
            return ret;
2051
        }
2052
    }
2053

    
2054
    /* Flush all IO requests so they don't interfere with the new state.  */
2055
    qemu_aio_flush();
2056

    
2057
    bs = NULL;
2058
    while ((bs = bdrv_next(bs))) {
2059
        if (bdrv_can_snapshot(bs)) {
2060
            ret = bdrv_snapshot_goto(bs, name);
2061
            if (ret < 0) {
2062
                error_report("Error %d while activating snapshot '%s' on '%s'",
2063
                             ret, name, bdrv_get_device_name(bs));
2064
                return ret;
2065
            }
2066
        }
2067
    }
2068

    
2069
    /* restore the VM state */
2070
    f = qemu_fopen_bdrv(bs_vm_state, 0);
2071
    if (!f) {
2072
        error_report("Could not open VM state file");
2073
        return -EINVAL;
2074
    }
2075

    
2076
    ret = qemu_loadvm_state(f);
2077

    
2078
    qemu_fclose(f);
2079
    if (ret < 0) {
2080
        error_report("Error %d while loading VM state", ret);
2081
        return ret;
2082
    }
2083

    
2084
    return 0;
2085
}
2086

    
2087
void do_delvm(Monitor *mon, const QDict *qdict)
2088
{
2089
    BlockDriverState *bs, *bs1;
2090
    int ret;
2091
    const char *name = qdict_get_str(qdict, "name");
2092

    
2093
    bs = bdrv_snapshots();
2094
    if (!bs) {
2095
        monitor_printf(mon, "No block device supports snapshots\n");
2096
        return;
2097
    }
2098

    
2099
    bs1 = NULL;
2100
    while ((bs1 = bdrv_next(bs1))) {
2101
        if (bdrv_can_snapshot(bs1)) {
2102
            ret = bdrv_snapshot_delete(bs1, name);
2103
            if (ret < 0) {
2104
                if (ret == -ENOTSUP)
2105
                    monitor_printf(mon,
2106
                                   "Snapshots not supported on device '%s'\n",
2107
                                   bdrv_get_device_name(bs1));
2108
                else
2109
                    monitor_printf(mon, "Error %d while deleting snapshot on "
2110
                                   "'%s'\n", ret, bdrv_get_device_name(bs1));
2111
            }
2112
        }
2113
    }
2114
}
2115

    
2116
void do_info_snapshots(Monitor *mon)
2117
{
2118
    BlockDriverState *bs, *bs1;
2119
    QEMUSnapshotInfo *sn_tab, *sn, s, *sn_info = &s;
2120
    int nb_sns, i, ret, available;
2121
    int total;
2122
    int *available_snapshots;
2123
    char buf[256];
2124

    
2125
    bs = bdrv_snapshots();
2126
    if (!bs) {
2127
        monitor_printf(mon, "No available block device supports snapshots\n");
2128
        return;
2129
    }
2130

    
2131
    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2132
    if (nb_sns < 0) {
2133
        monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
2134
        return;
2135
    }
2136

    
2137
    if (nb_sns == 0) {
2138
        monitor_printf(mon, "There is no snapshot available.\n");
2139
        return;
2140
    }
2141

    
2142
    available_snapshots = qemu_mallocz(sizeof(int) * nb_sns);
2143
    total = 0;
2144
    for (i = 0; i < nb_sns; i++) {
2145
        sn = &sn_tab[i];
2146
        available = 1;
2147
        bs1 = NULL;
2148

    
2149
        while ((bs1 = bdrv_next(bs1))) {
2150
            if (bdrv_can_snapshot(bs1) && bs1 != bs) {
2151
                ret = bdrv_snapshot_find(bs1, sn_info, sn->id_str);
2152
                if (ret < 0) {
2153
                    available = 0;
2154
                    break;
2155
                }
2156
            }
2157
        }
2158

    
2159
        if (available) {
2160
            available_snapshots[total] = i;
2161
            total++;
2162
        }
2163
    }
2164

    
2165
    if (total > 0) {
2166
        monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
2167
        for (i = 0; i < total; i++) {
2168
            sn = &sn_tab[available_snapshots[i]];
2169
            monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
2170
        }
2171
    } else {
2172
        monitor_printf(mon, "There is no suitable snapshot available\n");
2173
    }
2174

    
2175
    qemu_free(sn_tab);
2176
    qemu_free(available_snapshots);
2177

    
2178
}