Statistics
| Branch: | Revision:

root / savevm.c @ 492d7bf5

History | View | Annotate | Download (41.4 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
#if defined(__NetBSD__)
46
#include <net/if_tap.h>
47
#endif
48
#ifdef __linux__
49
#include <linux/if_tun.h>
50
#endif
51
#include <arpa/inet.h>
52
#include <dirent.h>
53
#include <netdb.h>
54
#include <sys/select.h>
55
#ifdef CONFIG_BSD
56
#include <sys/stat.h>
57
#if defined(__FreeBSD__) || defined(__DragonFly__)
58
#include <libutil.h>
59
#else
60
#include <util.h>
61
#endif
62
#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
63
#include <freebsd/stdlib.h>
64
#else
65
#ifdef __linux__
66
#include <pty.h>
67
#include <malloc.h>
68
#include <linux/rtc.h>
69
#endif
70
#endif
71
#endif
72

    
73
#ifdef _WIN32
74
#include <windows.h>
75
#include <malloc.h>
76
#include <sys/timeb.h>
77
#include <mmsystem.h>
78
#define getopt_long_only getopt_long
79
#define memalign(align, size) malloc(size)
80
#endif
81

    
82
#include "qemu-common.h"
83
#include "hw/hw.h"
84
#include "net.h"
85
#include "monitor.h"
86
#include "sysemu.h"
87
#include "qemu-timer.h"
88
#include "qemu-char.h"
89
#include "block.h"
90
#include "audio/audio.h"
91
#include "migration.h"
92
#include "qemu_socket.h"
93
#include "qemu-queue.h"
94

    
95
/* point to the block driver where the snapshots are managed */
96
static BlockDriverState *bs_snapshots;
97

    
98
#define SELF_ANNOUNCE_ROUNDS 5
99
#define ETH_P_EXPERIMENTAL 0x01F1 /* just a number */
100
//#define ETH_P_EXPERIMENTAL 0x0012 /* make it the size of the packet */
101
#define EXPERIMENTAL_MAGIC 0xf1f23f4f
102

    
103
static int announce_self_create(uint8_t *buf, 
104
                                uint8_t *mac_addr)
105
{
106
    uint32_t magic = EXPERIMENTAL_MAGIC;
107
    uint16_t proto = htons(ETH_P_EXPERIMENTAL);
108

    
109
    /* FIXME: should we send a different packet (arp/rarp/ping)? */
110

    
111
    memset(buf, 0, 64);
112
    memset(buf, 0xff, 6);         /* h_dst */
113
    memcpy(buf + 6, mac_addr, 6); /* h_src */
114
    memcpy(buf + 12, &proto, 2);  /* h_proto */
115
    memcpy(buf + 14, &magic, 4);  /* magic */
116

    
117
    return 64; /* len */
118
}
119

    
120
static void qemu_announce_self_once(void *opaque)
121
{
122
    int i, len;
123
    VLANState *vlan;
124
    VLANClientState *vc;
125
    uint8_t buf[256];
126
    static int count = SELF_ANNOUNCE_ROUNDS;
127
    QEMUTimer *timer = *(QEMUTimer **)opaque;
128

    
129
    for (i = 0; i < MAX_NICS; i++) {
130
        if (!nd_table[i].used)
131
            continue;
132
        len = announce_self_create(buf, nd_table[i].macaddr);
133
        vlan = nd_table[i].vlan;
134
        QTAILQ_FOREACH(vc, &vlan->clients, next) {
135
            vc->receive(vc, buf, len);
136
        }
137
    }
138
    if (count--) {
139
            qemu_mod_timer(timer, qemu_get_clock(rt_clock) + 100);
140
    } else {
141
            qemu_del_timer(timer);
142
            qemu_free_timer(timer);
143
    }
144
}
145

    
146
void qemu_announce_self(void)
147
{
148
        static QEMUTimer *timer;
149
        timer = qemu_new_timer(rt_clock, qemu_announce_self_once, &timer);
150
        qemu_announce_self_once(&timer);
151
}
152

    
153
/***********************************************************/
154
/* savevm/loadvm support */
155

    
156
#define IO_BUF_SIZE 32768
157

    
158
struct QEMUFile {
159
    QEMUFilePutBufferFunc *put_buffer;
160
    QEMUFileGetBufferFunc *get_buffer;
161
    QEMUFileCloseFunc *close;
162
    QEMUFileRateLimit *rate_limit;
163
    QEMUFileSetRateLimit *set_rate_limit;
164
    void *opaque;
165
    int is_write;
166

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

    
173
    int has_error;
174
};
175

    
176
typedef struct QEMUFileStdio
177
{
178
    FILE *stdio_file;
179
    QEMUFile *file;
180
} QEMUFileStdio;
181

    
182
typedef struct QEMUFileSocket
183
{
184
    int fd;
185
    QEMUFile *file;
186
} QEMUFileSocket;
187

    
188
static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
189
{
190
    QEMUFileSocket *s = opaque;
191
    ssize_t len;
192

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

    
197
    if (len == -1)
198
        len = -socket_error();
199

    
200
    return len;
201
}
202

    
203
static int socket_close(void *opaque)
204
{
205
    QEMUFileSocket *s = opaque;
206
    qemu_free(s);
207
    return 0;
208
}
209

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

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

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

    
229
static int stdio_pclose(void *opaque)
230
{
231
    QEMUFileStdio *s = opaque;
232
    pclose(s->stdio_file);
233
    qemu_free(s);
234
    return 0;
235
}
236

    
237
static int stdio_fclose(void *opaque)
238
{
239
    QEMUFileStdio *s = opaque;
240
    fclose(s->stdio_file);
241
    qemu_free(s);
242
    return 0;
243
}
244

    
245
QEMUFile *qemu_popen(FILE *stdio_file, const char *mode)
246
{
247
    QEMUFileStdio *s;
248

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

    
254
    s = qemu_mallocz(sizeof(QEMUFileStdio));
255

    
256
    s->stdio_file = stdio_file;
257

    
258
    if(mode[0] == 'r') {
259
        s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_pclose, NULL, NULL);
260
    } else {
261
        s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_pclose, NULL, NULL);
262
    }
263
    return s->file;
264
}
265

    
266
QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
267
{
268
    FILE *popen_file;
269

    
270
    popen_file = popen(command, mode);
271
    if(popen_file == NULL) {
272
        return NULL;
273
    }
274

    
275
    return qemu_popen(popen_file, mode);
276
}
277

    
278
int qemu_stdio_fd(QEMUFile *f)
279
{
280
    QEMUFileStdio *p;
281
    int fd;
282

    
283
    p = (QEMUFileStdio *)f->opaque;
284
    fd = fileno(p->stdio_file);
285

    
286
    return fd;
287
}
288

    
289
QEMUFile *qemu_fdopen(int fd, const char *mode)
290
{
291
    QEMUFileStdio *s;
292

    
293
    if (mode == NULL ||
294
        (mode[0] != 'r' && mode[0] != 'w') ||
295
        mode[1] != 'b' || mode[2] != 0) {
296
        fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
297
        return NULL;
298
    }
299

    
300
    s = qemu_mallocz(sizeof(QEMUFileStdio));
301
    s->stdio_file = fdopen(fd, mode);
302
    if (!s->stdio_file)
303
        goto fail;
304

    
305
    if(mode[0] == 'r') {
306
        s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_fclose, NULL, NULL);
307
    } else {
308
        s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_fclose, NULL, NULL);
309
    }
310
    return s->file;
311

    
312
fail:
313
    qemu_free(s);
314
    return NULL;
315
}
316

    
317
QEMUFile *qemu_fopen_socket(int fd)
318
{
319
    QEMUFileSocket *s = qemu_mallocz(sizeof(QEMUFileSocket));
320

    
321
    s->fd = fd;
322
    s->file = qemu_fopen_ops(s, NULL, socket_get_buffer, socket_close, NULL, NULL);
323
    return s->file;
324
}
325

    
326
static int file_put_buffer(void *opaque, const uint8_t *buf,
327
                            int64_t pos, int size)
328
{
329
    QEMUFileStdio *s = opaque;
330
    fseek(s->stdio_file, pos, SEEK_SET);
331
    fwrite(buf, 1, size, s->stdio_file);
332
    return size;
333
}
334

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

    
342
QEMUFile *qemu_fopen(const char *filename, const char *mode)
343
{
344
    QEMUFileStdio *s;
345

    
346
    if (mode == NULL ||
347
        (mode[0] != 'r' && mode[0] != 'w') ||
348
        mode[1] != 'b' || mode[2] != 0) {
349
        fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
350
        return NULL;
351
    }
352

    
353
    s = qemu_mallocz(sizeof(QEMUFileStdio));
354

    
355
    s->stdio_file = fopen(filename, mode);
356
    if (!s->stdio_file)
357
        goto fail;
358

    
359
    if(mode[0] == 'w') {
360
        s->file = qemu_fopen_ops(s, file_put_buffer, NULL, stdio_fclose, NULL, NULL);
361
    } else {
362
        s->file = qemu_fopen_ops(s, NULL, file_get_buffer, stdio_fclose, NULL, NULL);
363
    }
364
    return s->file;
365
fail:
366
    qemu_free(s);
367
    return NULL;
368
}
369

    
370
static int block_put_buffer(void *opaque, const uint8_t *buf,
371
                           int64_t pos, int size)
372
{
373
    bdrv_save_vmstate(opaque, buf, pos, size);
374
    return size;
375
}
376

    
377
static int block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
378
{
379
    return bdrv_load_vmstate(opaque, buf, pos, size);
380
}
381

    
382
static int bdrv_fclose(void *opaque)
383
{
384
    return 0;
385
}
386

    
387
static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
388
{
389
    if (is_writable)
390
        return qemu_fopen_ops(bs, block_put_buffer, NULL, bdrv_fclose, NULL, NULL);
391
    return qemu_fopen_ops(bs, NULL, block_get_buffer, bdrv_fclose, NULL, NULL);
392
}
393

    
394
QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
395
                         QEMUFileGetBufferFunc *get_buffer,
396
                         QEMUFileCloseFunc *close,
397
                         QEMUFileRateLimit *rate_limit,
398
                         QEMUFileSetRateLimit *set_rate_limit)
399
{
400
    QEMUFile *f;
401

    
402
    f = qemu_mallocz(sizeof(QEMUFile));
403

    
404
    f->opaque = opaque;
405
    f->put_buffer = put_buffer;
406
    f->get_buffer = get_buffer;
407
    f->close = close;
408
    f->rate_limit = rate_limit;
409
    f->set_rate_limit = set_rate_limit;
410
    f->is_write = 0;
411

    
412
    return f;
413
}
414

    
415
int qemu_file_has_error(QEMUFile *f)
416
{
417
    return f->has_error;
418
}
419

    
420
void qemu_file_set_error(QEMUFile *f)
421
{
422
    f->has_error = 1;
423
}
424

    
425
void qemu_fflush(QEMUFile *f)
426
{
427
    if (!f->put_buffer)
428
        return;
429

    
430
    if (f->is_write && f->buf_index > 0) {
431
        int len;
432

    
433
        len = f->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
434
        if (len > 0)
435
            f->buf_offset += f->buf_index;
436
        else
437
            f->has_error = 1;
438
        f->buf_index = 0;
439
    }
440
}
441

    
442
static void qemu_fill_buffer(QEMUFile *f)
443
{
444
    int len;
445

    
446
    if (!f->get_buffer)
447
        return;
448

    
449
    if (f->is_write)
450
        abort();
451

    
452
    len = f->get_buffer(f->opaque, f->buf, f->buf_offset, IO_BUF_SIZE);
453
    if (len > 0) {
454
        f->buf_index = 0;
455
        f->buf_size = len;
456
        f->buf_offset += len;
457
    } else if (len != -EAGAIN)
458
        f->has_error = 1;
459
}
460

    
461
int qemu_fclose(QEMUFile *f)
462
{
463
    int ret = 0;
464
    qemu_fflush(f);
465
    if (f->close)
466
        ret = f->close(f->opaque);
467
    qemu_free(f);
468
    return ret;
469
}
470

    
471
void qemu_file_put_notify(QEMUFile *f)
472
{
473
    f->put_buffer(f->opaque, NULL, 0, 0);
474
}
475

    
476
void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
477
{
478
    int l;
479

    
480
    if (!f->has_error && f->is_write == 0 && f->buf_index > 0) {
481
        fprintf(stderr,
482
                "Attempted to write to buffer while read buffer is not empty\n");
483
        abort();
484
    }
485

    
486
    while (!f->has_error && size > 0) {
487
        l = IO_BUF_SIZE - f->buf_index;
488
        if (l > size)
489
            l = size;
490
        memcpy(f->buf + f->buf_index, buf, l);
491
        f->is_write = 1;
492
        f->buf_index += l;
493
        buf += l;
494
        size -= l;
495
        if (f->buf_index >= IO_BUF_SIZE)
496
            qemu_fflush(f);
497
    }
498
}
499

    
500
void qemu_put_byte(QEMUFile *f, int v)
501
{
502
    if (!f->has_error && f->is_write == 0 && f->buf_index > 0) {
503
        fprintf(stderr,
504
                "Attempted to write to buffer while read buffer is not empty\n");
505
        abort();
506
    }
507

    
508
    f->buf[f->buf_index++] = v;
509
    f->is_write = 1;
510
    if (f->buf_index >= IO_BUF_SIZE)
511
        qemu_fflush(f);
512
}
513

    
514
int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
515
{
516
    int size, l;
517

    
518
    if (f->is_write)
519
        abort();
520

    
521
    size = size1;
522
    while (size > 0) {
523
        l = f->buf_size - f->buf_index;
524
        if (l == 0) {
525
            qemu_fill_buffer(f);
526
            l = f->buf_size - f->buf_index;
527
            if (l == 0)
528
                break;
529
        }
530
        if (l > size)
531
            l = size;
532
        memcpy(buf, f->buf + f->buf_index, l);
533
        f->buf_index += l;
534
        buf += l;
535
        size -= l;
536
    }
537
    return size1 - size;
538
}
539

    
540
int qemu_get_byte(QEMUFile *f)
541
{
542
    if (f->is_write)
543
        abort();
544

    
545
    if (f->buf_index >= f->buf_size) {
546
        qemu_fill_buffer(f);
547
        if (f->buf_index >= f->buf_size)
548
            return 0;
549
    }
550
    return f->buf[f->buf_index++];
551
}
552

    
553
int64_t qemu_ftell(QEMUFile *f)
554
{
555
    return f->buf_offset - f->buf_size + f->buf_index;
556
}
557

    
558
int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
559
{
560
    if (whence == SEEK_SET) {
561
        /* nothing to do */
562
    } else if (whence == SEEK_CUR) {
563
        pos += qemu_ftell(f);
564
    } else {
565
        /* SEEK_END not supported */
566
        return -1;
567
    }
568
    if (f->put_buffer) {
569
        qemu_fflush(f);
570
        f->buf_offset = pos;
571
    } else {
572
        f->buf_offset = pos;
573
        f->buf_index = 0;
574
        f->buf_size = 0;
575
    }
576
    return pos;
577
}
578

    
579
int qemu_file_rate_limit(QEMUFile *f)
580
{
581
    if (f->rate_limit)
582
        return f->rate_limit(f->opaque);
583

    
584
    return 0;
585
}
586

    
587
size_t qemu_file_set_rate_limit(QEMUFile *f, size_t new_rate)
588
{
589
    /* any failed or completed migration keeps its state to allow probing of
590
     * migration data, but has no associated file anymore */
591
    if (f && f->set_rate_limit)
592
        return f->set_rate_limit(f->opaque, new_rate);
593

    
594
    return 0;
595
}
596

    
597
void qemu_put_be16(QEMUFile *f, unsigned int v)
598
{
599
    qemu_put_byte(f, v >> 8);
600
    qemu_put_byte(f, v);
601
}
602

    
603
void qemu_put_be32(QEMUFile *f, unsigned int v)
604
{
605
    qemu_put_byte(f, v >> 24);
606
    qemu_put_byte(f, v >> 16);
607
    qemu_put_byte(f, v >> 8);
608
    qemu_put_byte(f, v);
609
}
610

    
611
void qemu_put_be64(QEMUFile *f, uint64_t v)
612
{
613
    qemu_put_be32(f, v >> 32);
614
    qemu_put_be32(f, v);
615
}
616

    
617
unsigned int qemu_get_be16(QEMUFile *f)
618
{
619
    unsigned int v;
620
    v = qemu_get_byte(f) << 8;
621
    v |= qemu_get_byte(f);
622
    return v;
623
}
624

    
625
unsigned int qemu_get_be32(QEMUFile *f)
626
{
627
    unsigned int v;
628
    v = qemu_get_byte(f) << 24;
629
    v |= qemu_get_byte(f) << 16;
630
    v |= qemu_get_byte(f) << 8;
631
    v |= qemu_get_byte(f);
632
    return v;
633
}
634

    
635
uint64_t qemu_get_be64(QEMUFile *f)
636
{
637
    uint64_t v;
638
    v = (uint64_t)qemu_get_be32(f) << 32;
639
    v |= qemu_get_be32(f);
640
    return v;
641
}
642

    
643
/* 8 bit int */
644

    
645
static int get_int8(QEMUFile *f, void *pv, size_t size)
646
{
647
    int8_t *v = pv;
648
    qemu_get_s8s(f, v);
649
    return 0;
650
}
651

    
652
static void put_int8(QEMUFile *f, void *pv, size_t size)
653
{
654
    int8_t *v = pv;
655
    qemu_put_s8s(f, v);
656
}
657

    
658
const VMStateInfo vmstate_info_int8 = {
659
    .name = "int8",
660
    .get  = get_int8,
661
    .put  = put_int8,
662
};
663

    
664
/* 16 bit int */
665

    
666
static int get_int16(QEMUFile *f, void *pv, size_t size)
667
{
668
    int16_t *v = pv;
669
    qemu_get_sbe16s(f, v);
670
    return 0;
671
}
672

    
673
static void put_int16(QEMUFile *f, void *pv, size_t size)
674
{
675
    int16_t *v = pv;
676
    qemu_put_sbe16s(f, v);
677
}
678

    
679
const VMStateInfo vmstate_info_int16 = {
680
    .name = "int16",
681
    .get  = get_int16,
682
    .put  = put_int16,
683
};
684

    
685
/* 32 bit int */
686

    
687
static int get_int32(QEMUFile *f, void *pv, size_t size)
688
{
689
    int32_t *v = pv;
690
    qemu_get_sbe32s(f, v);
691
    return 0;
692
}
693

    
694
static void put_int32(QEMUFile *f, void *pv, size_t size)
695
{
696
    int32_t *v = pv;
697
    qemu_put_sbe32s(f, v);
698
}
699

    
700
const VMStateInfo vmstate_info_int32 = {
701
    .name = "int32",
702
    .get  = get_int32,
703
    .put  = put_int32,
704
};
705

    
706
/* 32 bit int. See that the received value is the same than the one
707
   in the field */
708

    
709
static int get_int32_equal(QEMUFile *f, void *pv, size_t size)
710
{
711
    int32_t *v = pv;
712
    int32_t v2;
713
    qemu_get_sbe32s(f, &v2);
714

    
715
    if (*v == v2)
716
        return 0;
717
    return -EINVAL;
718
}
719

    
720
const VMStateInfo vmstate_info_int32_equal = {
721
    .name = "int32 equal",
722
    .get  = get_int32_equal,
723
    .put  = put_int32,
724
};
725

    
726
/* 32 bit int. See that the received value is the less or the same
727
   than the one in the field */
728

    
729
static int get_int32_le(QEMUFile *f, void *pv, size_t size)
730
{
731
    int32_t *old = pv;
732
    int32_t new;
733
    qemu_get_sbe32s(f, &new);
734

    
735
    if (*old <= new)
736
        return 0;
737
    return -EINVAL;
738
}
739

    
740
const VMStateInfo vmstate_info_int32_le = {
741
    .name = "int32 equal",
742
    .get  = get_int32_le,
743
    .put  = put_int32,
744
};
745

    
746
/* 64 bit int */
747

    
748
static int get_int64(QEMUFile *f, void *pv, size_t size)
749
{
750
    int64_t *v = pv;
751
    qemu_get_sbe64s(f, v);
752
    return 0;
753
}
754

    
755
static void put_int64(QEMUFile *f, void *pv, size_t size)
756
{
757
    int64_t *v = pv;
758
    qemu_put_sbe64s(f, v);
759
}
760

    
761
const VMStateInfo vmstate_info_int64 = {
762
    .name = "int64",
763
    .get  = get_int64,
764
    .put  = put_int64,
765
};
766

    
767
/* 8 bit unsigned int */
768

    
769
static int get_uint8(QEMUFile *f, void *pv, size_t size)
770
{
771
    uint8_t *v = pv;
772
    qemu_get_8s(f, v);
773
    return 0;
774
}
775

    
776
static void put_uint8(QEMUFile *f, void *pv, size_t size)
777
{
778
    uint8_t *v = pv;
779
    qemu_put_8s(f, v);
780
}
781

    
782
const VMStateInfo vmstate_info_uint8 = {
783
    .name = "uint8",
784
    .get  = get_uint8,
785
    .put  = put_uint8,
786
};
787

    
788
/* 16 bit unsigned int */
789

    
790
static int get_uint16(QEMUFile *f, void *pv, size_t size)
791
{
792
    uint16_t *v = pv;
793
    qemu_get_be16s(f, v);
794
    return 0;
795
}
796

    
797
static void put_uint16(QEMUFile *f, void *pv, size_t size)
798
{
799
    uint16_t *v = pv;
800
    qemu_put_be16s(f, v);
801
}
802

    
803
const VMStateInfo vmstate_info_uint16 = {
804
    .name = "uint16",
805
    .get  = get_uint16,
806
    .put  = put_uint16,
807
};
808

    
809
/* 32 bit unsigned int */
810

    
811
static int get_uint32(QEMUFile *f, void *pv, size_t size)
812
{
813
    uint32_t *v = pv;
814
    qemu_get_be32s(f, v);
815
    return 0;
816
}
817

    
818
static void put_uint32(QEMUFile *f, void *pv, size_t size)
819
{
820
    uint32_t *v = pv;
821
    qemu_put_be32s(f, v);
822
}
823

    
824
const VMStateInfo vmstate_info_uint32 = {
825
    .name = "uint32",
826
    .get  = get_uint32,
827
    .put  = put_uint32,
828
};
829

    
830
/* 64 bit unsigned int */
831

    
832
static int get_uint64(QEMUFile *f, void *pv, size_t size)
833
{
834
    uint64_t *v = pv;
835
    qemu_get_be64s(f, v);
836
    return 0;
837
}
838

    
839
static void put_uint64(QEMUFile *f, void *pv, size_t size)
840
{
841
    uint64_t *v = pv;
842
    qemu_put_be64s(f, v);
843
}
844

    
845
const VMStateInfo vmstate_info_uint64 = {
846
    .name = "uint64",
847
    .get  = get_uint64,
848
    .put  = put_uint64,
849
};
850

    
851
/* 8 bit int. See that the received value is the same than the one
852
   in the field */
853

    
854
static int get_uint8_equal(QEMUFile *f, void *pv, size_t size)
855
{
856
    uint8_t *v = pv;
857
    uint8_t v2;
858
    qemu_get_8s(f, &v2);
859

    
860
    if (*v == v2)
861
        return 0;
862
    return -EINVAL;
863
}
864

    
865
const VMStateInfo vmstate_info_uint8_equal = {
866
    .name = "int32 equal",
867
    .get  = get_uint8_equal,
868
    .put  = put_uint8,
869
};
870

    
871
/* timers  */
872

    
873
static int get_timer(QEMUFile *f, void *pv, size_t size)
874
{
875
    QEMUTimer *v = pv;
876
    qemu_get_timer(f, v);
877
    return 0;
878
}
879

    
880
static void put_timer(QEMUFile *f, void *pv, size_t size)
881
{
882
    QEMUTimer *v = pv;
883
    qemu_put_timer(f, v);
884
}
885

    
886
const VMStateInfo vmstate_info_timer = {
887
    .name = "timer",
888
    .get  = get_timer,
889
    .put  = put_timer,
890
};
891

    
892
/* uint8_t buffers */
893

    
894
static int get_buffer(QEMUFile *f, void *pv, size_t size)
895
{
896
    uint8_t *v = pv;
897
    qemu_get_buffer(f, v, size);
898
    return 0;
899
}
900

    
901
static void put_buffer(QEMUFile *f, void *pv, size_t size)
902
{
903
    uint8_t *v = pv;
904
    qemu_put_buffer(f, v, size);
905
}
906

    
907
const VMStateInfo vmstate_info_buffer = {
908
    .name = "buffer",
909
    .get  = get_buffer,
910
    .put  = put_buffer,
911
};
912

    
913
typedef struct SaveStateEntry {
914
    QTAILQ_ENTRY(SaveStateEntry) entry;
915
    char idstr[256];
916
    int instance_id;
917
    int version_id;
918
    int section_id;
919
    SaveLiveStateHandler *save_live_state;
920
    SaveStateHandler *save_state;
921
    LoadStateHandler *load_state;
922
    const VMStateDescription *vmsd;
923
    void *opaque;
924
} SaveStateEntry;
925

    
926
static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers =
927
    QTAILQ_HEAD_INITIALIZER(savevm_handlers);
928
static int global_section_id;
929

    
930
static int calculate_new_instance_id(const char *idstr)
931
{
932
    SaveStateEntry *se;
933
    int instance_id = 0;
934

    
935
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
936
        if (strcmp(idstr, se->idstr) == 0
937
            && instance_id <= se->instance_id) {
938
            instance_id = se->instance_id + 1;
939
        }
940
    }
941
    return instance_id;
942
}
943

    
944
/* TODO: Individual devices generally have very little idea about the rest
945
   of the system, so instance_id should be removed/replaced.
946
   Meanwhile pass -1 as instance_id if you do not already have a clearly
947
   distinguishing id for all instances of your device class. */
948
int register_savevm_live(const char *idstr,
949
                         int instance_id,
950
                         int version_id,
951
                         SaveLiveStateHandler *save_live_state,
952
                         SaveStateHandler *save_state,
953
                         LoadStateHandler *load_state,
954
                         void *opaque)
955
{
956
    SaveStateEntry *se;
957

    
958
    se = qemu_malloc(sizeof(SaveStateEntry));
959
    pstrcpy(se->idstr, sizeof(se->idstr), idstr);
960
    se->version_id = version_id;
961
    se->section_id = global_section_id++;
962
    se->save_live_state = save_live_state;
963
    se->save_state = save_state;
964
    se->load_state = load_state;
965
    se->opaque = opaque;
966
    se->vmsd = NULL;
967

    
968
    if (instance_id == -1) {
969
        se->instance_id = calculate_new_instance_id(idstr);
970
    } else {
971
        se->instance_id = instance_id;
972
    }
973
    /* add at the end of list */
974
    QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
975
    return 0;
976
}
977

    
978
int register_savevm(const char *idstr,
979
                    int instance_id,
980
                    int version_id,
981
                    SaveStateHandler *save_state,
982
                    LoadStateHandler *load_state,
983
                    void *opaque)
984
{
985
    return register_savevm_live(idstr, instance_id, version_id,
986
                                NULL, save_state, load_state, opaque);
987
}
988

    
989
void unregister_savevm(const char *idstr, void *opaque)
990
{
991
    SaveStateEntry *se, *new_se;
992

    
993
    QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
994
        if (strcmp(se->idstr, idstr) == 0 && se->opaque == opaque) {
995
            QTAILQ_REMOVE(&savevm_handlers, se, entry);
996
            qemu_free(se);
997
        }
998
    }
999
}
1000

    
1001
int vmstate_register(int instance_id, const VMStateDescription *vmsd,
1002
                     void *opaque)
1003
{
1004
    SaveStateEntry *se;
1005

    
1006
    se = qemu_malloc(sizeof(SaveStateEntry));
1007
    pstrcpy(se->idstr, sizeof(se->idstr), vmsd->name);
1008
    se->version_id = vmsd->version_id;
1009
    se->section_id = global_section_id++;
1010
    se->save_live_state = NULL;
1011
    se->save_state = NULL;
1012
    se->load_state = NULL;
1013
    se->opaque = opaque;
1014
    se->vmsd = vmsd;
1015

    
1016
    if (instance_id == -1) {
1017
        se->instance_id = calculate_new_instance_id(vmsd->name);
1018
    } else {
1019
        se->instance_id = instance_id;
1020
    }
1021
    /* add at the end of list */
1022
    QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1023
    return 0;
1024
}
1025

    
1026
void vmstate_unregister(const VMStateDescription *vmsd, void *opaque)
1027
{
1028
    SaveStateEntry *se, *new_se;
1029

    
1030
    QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1031
        if (se->vmsd == vmsd && se->opaque == opaque) {
1032
            QTAILQ_REMOVE(&savevm_handlers, se, entry);
1033
            qemu_free(se);
1034
        }
1035
    }
1036
}
1037

    
1038
int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
1039
                       void *opaque, int version_id)
1040
{
1041
    VMStateField *field = vmsd->fields;
1042

    
1043
    if (version_id > vmsd->version_id) {
1044
        return -EINVAL;
1045
    }
1046
    if (version_id < vmsd->minimum_version_id_old) {
1047
        return -EINVAL;
1048
    }
1049
    if  (version_id < vmsd->minimum_version_id) {
1050
        return vmsd->load_state_old(f, opaque, version_id);
1051
    }
1052
    if (vmsd->pre_load) {
1053
        int ret = vmsd->pre_load(opaque);
1054
        if (ret)
1055
            return ret;
1056
    }
1057
    while(field->name) {
1058
        if ((field->field_exists &&
1059
             field->field_exists(opaque, version_id)) ||
1060
            (!field->field_exists &&
1061
             field->version_id <= version_id)) {
1062
            void *base_addr = opaque + field->offset;
1063
            int ret, i, n_elems = 1;
1064

    
1065
            if (field->flags & VMS_ARRAY) {
1066
                n_elems = field->num;
1067
            } else if (field->flags & VMS_VARRAY) {
1068
                n_elems = *(size_t *)(opaque+field->num_offset);
1069
            }
1070
            if (field->flags & VMS_POINTER) {
1071
                base_addr = *(void **)base_addr;
1072
            }
1073
            for (i = 0; i < n_elems; i++) {
1074
                void *addr = base_addr + field->size * i;
1075

    
1076
                if (field->flags & VMS_ARRAY_OF_POINTER) {
1077
                    addr = *(void **)addr;
1078
                }
1079
                if (field->flags & VMS_STRUCT) {
1080
                    ret = vmstate_load_state(f, field->vmsd, addr, field->vmsd->version_id);
1081
                } else {
1082
                    ret = field->info->get(f, addr, field->size);
1083

    
1084
                }
1085
                if (ret < 0) {
1086
                    return ret;
1087
                }
1088
            }
1089
        }
1090
        field++;
1091
    }
1092
    if (vmsd->post_load) {
1093
        return vmsd->post_load(opaque, version_id);
1094
    }
1095
    return 0;
1096
}
1097

    
1098
void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
1099
                        void *opaque)
1100
{
1101
    VMStateField *field = vmsd->fields;
1102

    
1103
    if (vmsd->pre_save) {
1104
        vmsd->pre_save(opaque);
1105
    }
1106
    while(field->name) {
1107
        if (!field->field_exists ||
1108
            field->field_exists(opaque, vmsd->version_id)) {
1109
            void *base_addr = opaque + field->offset;
1110
            int i, n_elems = 1;
1111

    
1112
            if (field->flags & VMS_ARRAY) {
1113
                n_elems = field->num;
1114
            } else if (field->flags & VMS_VARRAY) {
1115
                n_elems = *(size_t *)(opaque+field->num_offset);
1116
            }
1117
            if (field->flags & VMS_POINTER) {
1118
                base_addr = *(void **)base_addr;
1119
            }
1120
            for (i = 0; i < n_elems; i++) {
1121
                void *addr = base_addr + field->size * i;
1122

    
1123
                if (field->flags & VMS_STRUCT) {
1124
                    vmstate_save_state(f, field->vmsd, addr);
1125
                } else {
1126
                    field->info->put(f, addr, field->size);
1127
                }
1128
            }
1129
        }
1130
        field++;
1131
    }
1132
    if (vmsd->post_save) {
1133
        vmsd->post_save(opaque);
1134
    }
1135
}
1136

    
1137
static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id)
1138
{
1139
    if (!se->vmsd) {         /* Old style */
1140
        return se->load_state(f, se->opaque, version_id);
1141
    }
1142
    return vmstate_load_state(f, se->vmsd, se->opaque, version_id);
1143
}
1144

    
1145
static void vmstate_save(QEMUFile *f, SaveStateEntry *se)
1146
{
1147
    if (!se->vmsd) {         /* Old style */
1148
        se->save_state(f, se->opaque);
1149
        return;
1150
    }
1151
    vmstate_save_state(f,se->vmsd, se->opaque);
1152
}
1153

    
1154
#define QEMU_VM_FILE_MAGIC           0x5145564d
1155
#define QEMU_VM_FILE_VERSION_COMPAT  0x00000002
1156
#define QEMU_VM_FILE_VERSION         0x00000003
1157

    
1158
#define QEMU_VM_EOF                  0x00
1159
#define QEMU_VM_SECTION_START        0x01
1160
#define QEMU_VM_SECTION_PART         0x02
1161
#define QEMU_VM_SECTION_END          0x03
1162
#define QEMU_VM_SECTION_FULL         0x04
1163

    
1164
int qemu_savevm_state_begin(QEMUFile *f)
1165
{
1166
    SaveStateEntry *se;
1167

    
1168
    qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1169
    qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1170

    
1171
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1172
        int len;
1173

    
1174
        if (se->save_live_state == NULL)
1175
            continue;
1176

    
1177
        /* Section type */
1178
        qemu_put_byte(f, QEMU_VM_SECTION_START);
1179
        qemu_put_be32(f, se->section_id);
1180

    
1181
        /* ID string */
1182
        len = strlen(se->idstr);
1183
        qemu_put_byte(f, len);
1184
        qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1185

    
1186
        qemu_put_be32(f, se->instance_id);
1187
        qemu_put_be32(f, se->version_id);
1188

    
1189
        se->save_live_state(f, QEMU_VM_SECTION_START, se->opaque);
1190
    }
1191

    
1192
    if (qemu_file_has_error(f))
1193
        return -EIO;
1194

    
1195
    return 0;
1196
}
1197

    
1198
int qemu_savevm_state_iterate(QEMUFile *f)
1199
{
1200
    SaveStateEntry *se;
1201
    int ret = 1;
1202

    
1203
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1204
        if (se->save_live_state == NULL)
1205
            continue;
1206

    
1207
        /* Section type */
1208
        qemu_put_byte(f, QEMU_VM_SECTION_PART);
1209
        qemu_put_be32(f, se->section_id);
1210

    
1211
        ret &= !!se->save_live_state(f, QEMU_VM_SECTION_PART, se->opaque);
1212
    }
1213

    
1214
    if (ret)
1215
        return 1;
1216

    
1217
    if (qemu_file_has_error(f))
1218
        return -EIO;
1219

    
1220
    return 0;
1221
}
1222

    
1223
int qemu_savevm_state_complete(QEMUFile *f)
1224
{
1225
    SaveStateEntry *se;
1226

    
1227
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1228
        if (se->save_live_state == NULL)
1229
            continue;
1230

    
1231
        /* Section type */
1232
        qemu_put_byte(f, QEMU_VM_SECTION_END);
1233
        qemu_put_be32(f, se->section_id);
1234

    
1235
        se->save_live_state(f, QEMU_VM_SECTION_END, se->opaque);
1236
    }
1237

    
1238
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1239
        int len;
1240

    
1241
        if (se->save_state == NULL && se->vmsd == NULL)
1242
            continue;
1243

    
1244
        /* Section type */
1245
        qemu_put_byte(f, QEMU_VM_SECTION_FULL);
1246
        qemu_put_be32(f, se->section_id);
1247

    
1248
        /* ID string */
1249
        len = strlen(se->idstr);
1250
        qemu_put_byte(f, len);
1251
        qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1252

    
1253
        qemu_put_be32(f, se->instance_id);
1254
        qemu_put_be32(f, se->version_id);
1255

    
1256
        vmstate_save(f, se);
1257
    }
1258

    
1259
    qemu_put_byte(f, QEMU_VM_EOF);
1260

    
1261
    if (qemu_file_has_error(f))
1262
        return -EIO;
1263

    
1264
    return 0;
1265
}
1266

    
1267
int qemu_savevm_state(QEMUFile *f)
1268
{
1269
    int saved_vm_running;
1270
    int ret;
1271

    
1272
    saved_vm_running = vm_running;
1273
    vm_stop(0);
1274

    
1275
    bdrv_flush_all();
1276

    
1277
    ret = qemu_savevm_state_begin(f);
1278
    if (ret < 0)
1279
        goto out;
1280

    
1281
    do {
1282
        ret = qemu_savevm_state_iterate(f);
1283
        if (ret < 0)
1284
            goto out;
1285
    } while (ret == 0);
1286

    
1287
    ret = qemu_savevm_state_complete(f);
1288

    
1289
out:
1290
    if (qemu_file_has_error(f))
1291
        ret = -EIO;
1292

    
1293
    if (!ret && saved_vm_running)
1294
        vm_start();
1295

    
1296
    return ret;
1297
}
1298

    
1299
static SaveStateEntry *find_se(const char *idstr, int instance_id)
1300
{
1301
    SaveStateEntry *se;
1302

    
1303
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1304
        if (!strcmp(se->idstr, idstr) &&
1305
            instance_id == se->instance_id)
1306
            return se;
1307
    }
1308
    return NULL;
1309
}
1310

    
1311
typedef struct LoadStateEntry {
1312
    QLIST_ENTRY(LoadStateEntry) entry;
1313
    SaveStateEntry *se;
1314
    int section_id;
1315
    int version_id;
1316
} LoadStateEntry;
1317

    
1318
int qemu_loadvm_state(QEMUFile *f)
1319
{
1320
    QLIST_HEAD(, LoadStateEntry) loadvm_handlers =
1321
        QLIST_HEAD_INITIALIZER(loadvm_handlers);
1322
    LoadStateEntry *le, *new_le;
1323
    uint8_t section_type;
1324
    unsigned int v;
1325
    int ret;
1326

    
1327
    v = qemu_get_be32(f);
1328
    if (v != QEMU_VM_FILE_MAGIC)
1329
        return -EINVAL;
1330

    
1331
    v = qemu_get_be32(f);
1332
    if (v == QEMU_VM_FILE_VERSION_COMPAT) {
1333
        fprintf(stderr, "SaveVM v2 format is obsolete and don't work anymore\n");
1334
        return -ENOTSUP;
1335
    }
1336
    if (v != QEMU_VM_FILE_VERSION)
1337
        return -ENOTSUP;
1338

    
1339
    while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
1340
        uint32_t instance_id, version_id, section_id;
1341
        SaveStateEntry *se;
1342
        char idstr[257];
1343
        int len;
1344

    
1345
        switch (section_type) {
1346
        case QEMU_VM_SECTION_START:
1347
        case QEMU_VM_SECTION_FULL:
1348
            /* Read section start */
1349
            section_id = qemu_get_be32(f);
1350
            len = qemu_get_byte(f);
1351
            qemu_get_buffer(f, (uint8_t *)idstr, len);
1352
            idstr[len] = 0;
1353
            instance_id = qemu_get_be32(f);
1354
            version_id = qemu_get_be32(f);
1355

    
1356
            /* Find savevm section */
1357
            se = find_se(idstr, instance_id);
1358
            if (se == NULL) {
1359
                fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
1360
                ret = -EINVAL;
1361
                goto out;
1362
            }
1363

    
1364
            /* Validate version */
1365
            if (version_id > se->version_id) {
1366
                fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
1367
                        version_id, idstr, se->version_id);
1368
                ret = -EINVAL;
1369
                goto out;
1370
            }
1371

    
1372
            /* Add entry */
1373
            le = qemu_mallocz(sizeof(*le));
1374

    
1375
            le->se = se;
1376
            le->section_id = section_id;
1377
            le->version_id = version_id;
1378
            QLIST_INSERT_HEAD(&loadvm_handlers, le, entry);
1379

    
1380
            ret = vmstate_load(f, le->se, le->version_id);
1381
            if (ret < 0) {
1382
                fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
1383
                        instance_id, idstr);
1384
                goto out;
1385
            }
1386
            break;
1387
        case QEMU_VM_SECTION_PART:
1388
        case QEMU_VM_SECTION_END:
1389
            section_id = qemu_get_be32(f);
1390

    
1391
            QLIST_FOREACH(le, &loadvm_handlers, entry) {
1392
                if (le->section_id == section_id) {
1393
                    break;
1394
                }
1395
            }
1396
            if (le == NULL) {
1397
                fprintf(stderr, "Unknown savevm section %d\n", section_id);
1398
                ret = -EINVAL;
1399
                goto out;
1400
            }
1401

    
1402
            ret = vmstate_load(f, le->se, le->version_id);
1403
            if (ret < 0) {
1404
                fprintf(stderr, "qemu: warning: error while loading state section id %d\n",
1405
                        section_id);
1406
                goto out;
1407
            }
1408
            break;
1409
        default:
1410
            fprintf(stderr, "Unknown savevm section type %d\n", section_type);
1411
            ret = -EINVAL;
1412
            goto out;
1413
        }
1414
    }
1415

    
1416
    ret = 0;
1417

    
1418
out:
1419
    QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
1420
        QLIST_REMOVE(le, entry);
1421
        qemu_free(le);
1422
    }
1423

    
1424
    if (qemu_file_has_error(f))
1425
        ret = -EIO;
1426

    
1427
    return ret;
1428
}
1429

    
1430
/* device can contain snapshots */
1431
static int bdrv_can_snapshot(BlockDriverState *bs)
1432
{
1433
    return (bs &&
1434
            !bdrv_is_removable(bs) &&
1435
            !bdrv_is_read_only(bs));
1436
}
1437

    
1438
/* device must be snapshots in order to have a reliable snapshot */
1439
static int bdrv_has_snapshot(BlockDriverState *bs)
1440
{
1441
    return (bs &&
1442
            !bdrv_is_removable(bs) &&
1443
            !bdrv_is_read_only(bs));
1444
}
1445

    
1446
static BlockDriverState *get_bs_snapshots(void)
1447
{
1448
    BlockDriverState *bs;
1449
    DriveInfo *dinfo;
1450

    
1451
    if (bs_snapshots)
1452
        return bs_snapshots;
1453
    QTAILQ_FOREACH(dinfo, &drives, next) {
1454
        bs = dinfo->bdrv;
1455
        if (bdrv_can_snapshot(bs))
1456
            goto ok;
1457
    }
1458
    return NULL;
1459
 ok:
1460
    bs_snapshots = bs;
1461
    return bs;
1462
}
1463

    
1464
static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
1465
                              const char *name)
1466
{
1467
    QEMUSnapshotInfo *sn_tab, *sn;
1468
    int nb_sns, i, ret;
1469

    
1470
    ret = -ENOENT;
1471
    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1472
    if (nb_sns < 0)
1473
        return ret;
1474
    for(i = 0; i < nb_sns; i++) {
1475
        sn = &sn_tab[i];
1476
        if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
1477
            *sn_info = *sn;
1478
            ret = 0;
1479
            break;
1480
        }
1481
    }
1482
    qemu_free(sn_tab);
1483
    return ret;
1484
}
1485

    
1486
void do_savevm(Monitor *mon, const QDict *qdict)
1487
{
1488
    DriveInfo *dinfo;
1489
    BlockDriverState *bs, *bs1;
1490
    QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
1491
    int must_delete, ret;
1492
    QEMUFile *f;
1493
    int saved_vm_running;
1494
    uint32_t vm_state_size;
1495
#ifdef _WIN32
1496
    struct _timeb tb;
1497
#else
1498
    struct timeval tv;
1499
#endif
1500
    const char *name = qdict_get_try_str(qdict, "name");
1501

    
1502
    bs = get_bs_snapshots();
1503
    if (!bs) {
1504
        monitor_printf(mon, "No block device can accept snapshots\n");
1505
        return;
1506
    }
1507

    
1508
    /* ??? Should this occur after vm_stop?  */
1509
    qemu_aio_flush();
1510

    
1511
    saved_vm_running = vm_running;
1512
    vm_stop(0);
1513

    
1514
    must_delete = 0;
1515
    if (name) {
1516
        ret = bdrv_snapshot_find(bs, old_sn, name);
1517
        if (ret >= 0) {
1518
            must_delete = 1;
1519
        }
1520
    }
1521
    memset(sn, 0, sizeof(*sn));
1522
    if (must_delete) {
1523
        pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
1524
        pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
1525
    } else {
1526
        if (name)
1527
            pstrcpy(sn->name, sizeof(sn->name), name);
1528
    }
1529

    
1530
    /* fill auxiliary fields */
1531
#ifdef _WIN32
1532
    _ftime(&tb);
1533
    sn->date_sec = tb.time;
1534
    sn->date_nsec = tb.millitm * 1000000;
1535
#else
1536
    gettimeofday(&tv, NULL);
1537
    sn->date_sec = tv.tv_sec;
1538
    sn->date_nsec = tv.tv_usec * 1000;
1539
#endif
1540
    sn->vm_clock_nsec = qemu_get_clock(vm_clock);
1541

    
1542
    /* save the VM state */
1543
    f = qemu_fopen_bdrv(bs, 1);
1544
    if (!f) {
1545
        monitor_printf(mon, "Could not open VM state file\n");
1546
        goto the_end;
1547
    }
1548
    ret = qemu_savevm_state(f);
1549
    vm_state_size = qemu_ftell(f);
1550
    qemu_fclose(f);
1551
    if (ret < 0) {
1552
        monitor_printf(mon, "Error %d while writing VM\n", ret);
1553
        goto the_end;
1554
    }
1555

    
1556
    /* create the snapshots */
1557

    
1558
    QTAILQ_FOREACH(dinfo, &drives, next) {
1559
        bs1 = dinfo->bdrv;
1560
        if (bdrv_has_snapshot(bs1)) {
1561
            if (must_delete) {
1562
                ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
1563
                if (ret < 0) {
1564
                    monitor_printf(mon,
1565
                                   "Error while deleting snapshot on '%s'\n",
1566
                                   bdrv_get_device_name(bs1));
1567
                }
1568
            }
1569
            /* Write VM state size only to the image that contains the state */
1570
            sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
1571
            ret = bdrv_snapshot_create(bs1, sn);
1572
            if (ret < 0) {
1573
                monitor_printf(mon, "Error while creating snapshot on '%s'\n",
1574
                               bdrv_get_device_name(bs1));
1575
            }
1576
        }
1577
    }
1578

    
1579
 the_end:
1580
    if (saved_vm_running)
1581
        vm_start();
1582
}
1583

    
1584
int load_vmstate(Monitor *mon, const char *name)
1585
{
1586
    DriveInfo *dinfo;
1587
    BlockDriverState *bs, *bs1;
1588
    QEMUSnapshotInfo sn;
1589
    QEMUFile *f;
1590
    int ret;
1591

    
1592
    bs = get_bs_snapshots();
1593
    if (!bs) {
1594
        monitor_printf(mon, "No block device supports snapshots\n");
1595
        return -EINVAL;
1596
    }
1597

    
1598
    /* Flush all IO requests so they don't interfere with the new state.  */
1599
    qemu_aio_flush();
1600

    
1601
    QTAILQ_FOREACH(dinfo, &drives, next) {
1602
        bs1 = dinfo->bdrv;
1603
        if (bdrv_has_snapshot(bs1)) {
1604
            ret = bdrv_snapshot_goto(bs1, name);
1605
            if (ret < 0) {
1606
                if (bs != bs1)
1607
                    monitor_printf(mon, "Warning: ");
1608
                switch(ret) {
1609
                case -ENOTSUP:
1610
                    monitor_printf(mon,
1611
                                   "Snapshots not supported on device '%s'\n",
1612
                                   bdrv_get_device_name(bs1));
1613
                    break;
1614
                case -ENOENT:
1615
                    monitor_printf(mon, "Could not find snapshot '%s' on "
1616
                                   "device '%s'\n",
1617
                                   name, bdrv_get_device_name(bs1));
1618
                    break;
1619
                default:
1620
                    monitor_printf(mon, "Error %d while activating snapshot on"
1621
                                   " '%s'\n", ret, bdrv_get_device_name(bs1));
1622
                    break;
1623
                }
1624
                /* fatal on snapshot block device */
1625
                if (bs == bs1)
1626
                    return 0;
1627
            }
1628
        }
1629
    }
1630

    
1631
    /* Don't even try to load empty VM states */
1632
    ret = bdrv_snapshot_find(bs, &sn, name);
1633
    if ((ret >= 0) && (sn.vm_state_size == 0))
1634
        return -EINVAL;
1635

    
1636
    /* restore the VM state */
1637
    f = qemu_fopen_bdrv(bs, 0);
1638
    if (!f) {
1639
        monitor_printf(mon, "Could not open VM state file\n");
1640
        return -EINVAL;
1641
    }
1642
    ret = qemu_loadvm_state(f);
1643
    qemu_fclose(f);
1644
    if (ret < 0) {
1645
        monitor_printf(mon, "Error %d while loading VM state\n", ret);
1646
        return ret;
1647
    }
1648
    return 0;
1649
}
1650

    
1651
void do_delvm(Monitor *mon, const QDict *qdict)
1652
{
1653
    DriveInfo *dinfo;
1654
    BlockDriverState *bs, *bs1;
1655
    int ret;
1656
    const char *name = qdict_get_str(qdict, "name");
1657

    
1658
    bs = get_bs_snapshots();
1659
    if (!bs) {
1660
        monitor_printf(mon, "No block device supports snapshots\n");
1661
        return;
1662
    }
1663

    
1664
    QTAILQ_FOREACH(dinfo, &drives, next) {
1665
        bs1 = dinfo->bdrv;
1666
        if (bdrv_has_snapshot(bs1)) {
1667
            ret = bdrv_snapshot_delete(bs1, name);
1668
            if (ret < 0) {
1669
                if (ret == -ENOTSUP)
1670
                    monitor_printf(mon,
1671
                                   "Snapshots not supported on device '%s'\n",
1672
                                   bdrv_get_device_name(bs1));
1673
                else
1674
                    monitor_printf(mon, "Error %d while deleting snapshot on "
1675
                                   "'%s'\n", ret, bdrv_get_device_name(bs1));
1676
            }
1677
        }
1678
    }
1679
}
1680

    
1681
void do_info_snapshots(Monitor *mon)
1682
{
1683
    DriveInfo *dinfo;
1684
    BlockDriverState *bs, *bs1;
1685
    QEMUSnapshotInfo *sn_tab, *sn;
1686
    int nb_sns, i;
1687
    char buf[256];
1688

    
1689
    bs = get_bs_snapshots();
1690
    if (!bs) {
1691
        monitor_printf(mon, "No available block device supports snapshots\n");
1692
        return;
1693
    }
1694
    monitor_printf(mon, "Snapshot devices:");
1695
    QTAILQ_FOREACH(dinfo, &drives, next) {
1696
        bs1 = dinfo->bdrv;
1697
        if (bdrv_has_snapshot(bs1)) {
1698
            if (bs == bs1)
1699
                monitor_printf(mon, " %s", bdrv_get_device_name(bs1));
1700
        }
1701
    }
1702
    monitor_printf(mon, "\n");
1703

    
1704
    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1705
    if (nb_sns < 0) {
1706
        monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
1707
        return;
1708
    }
1709
    monitor_printf(mon, "Snapshot list (from %s):\n",
1710
                   bdrv_get_device_name(bs));
1711
    monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1712
    for(i = 0; i < nb_sns; i++) {
1713
        sn = &sn_tab[i];
1714
        monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1715
    }
1716
    qemu_free(sn_tab);
1717
}