Statistics
| Branch: | Revision:

root / savevm.c @ f139a412

History | View | Annotate | Download (45.7 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 "net.h"
76
#include "monitor.h"
77
#include "sysemu.h"
78
#include "qemu-timer.h"
79
#include "qemu-char.h"
80
#include "block.h"
81
#include "audio/audio.h"
82
#include "migration.h"
83
#include "qemu_socket.h"
84
#include "qemu-queue.h"
85

    
86
/* point to the block driver where the snapshots are managed */
87
static BlockDriverState *bs_snapshots;
88

    
89
#define SELF_ANNOUNCE_ROUNDS 5
90

    
91
#ifndef ETH_P_RARP
92
#define ETH_P_RARP 0x0835
93
#endif
94
#define ARP_HTYPE_ETH 0x0001
95
#define ARP_PTYPE_IP 0x0800
96
#define ARP_OP_REQUEST_REV 0x3
97

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

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

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

    
120
    return 60; /* len (FCS will be added by hardware) */
121
}
122

    
123
static void qemu_announce_self_iter(NICState *nic, void *opaque)
124
{
125
    uint8_t buf[60];
126
    int len;
127

    
128
    len = announce_self_create(buf, nic->conf->macaddr.a);
129

    
130
    qemu_send_packet_raw(&nic->nc, buf, len);
131
}
132

    
133

    
134
static void qemu_announce_self_once(void *opaque)
135
{
136
    static int count = SELF_ANNOUNCE_ROUNDS;
137
    QEMUTimer *timer = *(QEMUTimer **)opaque;
138

    
139
    qemu_foreach_nic(qemu_announce_self_iter, NULL);
140

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

    
151
void qemu_announce_self(void)
152
{
153
        static QEMUTimer *timer;
154
        timer = qemu_new_timer(rt_clock, qemu_announce_self_once, &timer);
155
        qemu_announce_self_once(&timer);
156
}
157

    
158
/***********************************************************/
159
/* savevm/loadvm support */
160

    
161
#define IO_BUF_SIZE 32768
162

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

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

    
179
    int has_error;
180
};
181

    
182
typedef struct QEMUFileStdio
183
{
184
    FILE *stdio_file;
185
    QEMUFile *file;
186
} QEMUFileStdio;
187

    
188
typedef struct QEMUFileSocket
189
{
190
    int fd;
191
    QEMUFile *file;
192
} QEMUFileSocket;
193

    
194
static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
195
{
196
    QEMUFileSocket *s = opaque;
197
    ssize_t len;
198

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

    
203
    if (len == -1)
204
        len = -socket_error();
205

    
206
    return len;
207
}
208

    
209
static int socket_close(void *opaque)
210
{
211
    QEMUFileSocket *s = opaque;
212
    qemu_free(s);
213
    return 0;
214
}
215

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

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

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

    
235
static int stdio_pclose(void *opaque)
236
{
237
    QEMUFileStdio *s = opaque;
238
    pclose(s->stdio_file);
239
    qemu_free(s);
240
    return 0;
241
}
242

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

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

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

    
260
    s = qemu_mallocz(sizeof(QEMUFileStdio));
261

    
262
    s->stdio_file = stdio_file;
263

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

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

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

    
283
    return qemu_popen(popen_file, mode);
284
}
285

    
286
int qemu_stdio_fd(QEMUFile *f)
287
{
288
    QEMUFileStdio *p;
289
    int fd;
290

    
291
    p = (QEMUFileStdio *)f->opaque;
292
    fd = fileno(p->stdio_file);
293

    
294
    return fd;
295
}
296

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

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

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

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

    
322
fail:
323
    qemu_free(s);
324
    return NULL;
325
}
326

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

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

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

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

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

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

    
363
    s = qemu_mallocz(sizeof(QEMUFileStdio));
364

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

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

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

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

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

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

    
416
    f = qemu_mallocz(sizeof(QEMUFile));
417

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

    
427
    return f;
428
}
429

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

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

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

    
445
    if (f->is_write && f->buf_index > 0) {
446
        int len;
447

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

    
457
static void qemu_fill_buffer(QEMUFile *f)
458
{
459
    int len;
460

    
461
    if (!f->get_buffer)
462
        return;
463

    
464
    if (f->is_write)
465
        abort();
466

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

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

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

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

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

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

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

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

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

    
533
    if (f->is_write)
534
        abort();
535

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

    
555
int qemu_get_byte(QEMUFile *f)
556
{
557
    if (f->is_write)
558
        abort();
559

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

    
568
int64_t qemu_ftell(QEMUFile *f)
569
{
570
    return f->buf_offset - f->buf_size + f->buf_index;
571
}
572

    
573
int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
574
{
575
    if (whence == SEEK_SET) {
576
        /* nothing to do */
577
    } else if (whence == SEEK_CUR) {
578
        pos += qemu_ftell(f);
579
    } else {
580
        /* SEEK_END not supported */
581
        return -1;
582
    }
583
    if (f->put_buffer) {
584
        qemu_fflush(f);
585
        f->buf_offset = pos;
586
    } else {
587
        f->buf_offset = pos;
588
        f->buf_index = 0;
589
        f->buf_size = 0;
590
    }
591
    return pos;
592
}
593

    
594
int qemu_file_rate_limit(QEMUFile *f)
595
{
596
    if (f->rate_limit)
597
        return f->rate_limit(f->opaque);
598

    
599
    return 0;
600
}
601

    
602
size_t qemu_file_get_rate_limit(QEMUFile *f)
603
{
604
    if (f->get_rate_limit)
605
        return f->get_rate_limit(f->opaque);
606

    
607
    return 0;
608
}
609

    
610
size_t qemu_file_set_rate_limit(QEMUFile *f, size_t new_rate)
611
{
612
    /* any failed or completed migration keeps its state to allow probing of
613
     * migration data, but has no associated file anymore */
614
    if (f && f->set_rate_limit)
615
        return f->set_rate_limit(f->opaque, new_rate);
616

    
617
    return 0;
618
}
619

    
620
void qemu_put_be16(QEMUFile *f, unsigned int v)
621
{
622
    qemu_put_byte(f, v >> 8);
623
    qemu_put_byte(f, v);
624
}
625

    
626
void qemu_put_be32(QEMUFile *f, unsigned int v)
627
{
628
    qemu_put_byte(f, v >> 24);
629
    qemu_put_byte(f, v >> 16);
630
    qemu_put_byte(f, v >> 8);
631
    qemu_put_byte(f, v);
632
}
633

    
634
void qemu_put_be64(QEMUFile *f, uint64_t v)
635
{
636
    qemu_put_be32(f, v >> 32);
637
    qemu_put_be32(f, v);
638
}
639

    
640
unsigned int qemu_get_be16(QEMUFile *f)
641
{
642
    unsigned int v;
643
    v = qemu_get_byte(f) << 8;
644
    v |= qemu_get_byte(f);
645
    return v;
646
}
647

    
648
unsigned int qemu_get_be32(QEMUFile *f)
649
{
650
    unsigned int v;
651
    v = qemu_get_byte(f) << 24;
652
    v |= qemu_get_byte(f) << 16;
653
    v |= qemu_get_byte(f) << 8;
654
    v |= qemu_get_byte(f);
655
    return v;
656
}
657

    
658
uint64_t qemu_get_be64(QEMUFile *f)
659
{
660
    uint64_t v;
661
    v = (uint64_t)qemu_get_be32(f) << 32;
662
    v |= qemu_get_be32(f);
663
    return v;
664
}
665

    
666
/* 8 bit int */
667

    
668
static int get_int8(QEMUFile *f, void *pv, size_t size)
669
{
670
    int8_t *v = pv;
671
    qemu_get_s8s(f, v);
672
    return 0;
673
}
674

    
675
static void put_int8(QEMUFile *f, void *pv, size_t size)
676
{
677
    int8_t *v = pv;
678
    qemu_put_s8s(f, v);
679
}
680

    
681
const VMStateInfo vmstate_info_int8 = {
682
    .name = "int8",
683
    .get  = get_int8,
684
    .put  = put_int8,
685
};
686

    
687
/* 16 bit int */
688

    
689
static int get_int16(QEMUFile *f, void *pv, size_t size)
690
{
691
    int16_t *v = pv;
692
    qemu_get_sbe16s(f, v);
693
    return 0;
694
}
695

    
696
static void put_int16(QEMUFile *f, void *pv, size_t size)
697
{
698
    int16_t *v = pv;
699
    qemu_put_sbe16s(f, v);
700
}
701

    
702
const VMStateInfo vmstate_info_int16 = {
703
    .name = "int16",
704
    .get  = get_int16,
705
    .put  = put_int16,
706
};
707

    
708
/* 32 bit int */
709

    
710
static int get_int32(QEMUFile *f, void *pv, size_t size)
711
{
712
    int32_t *v = pv;
713
    qemu_get_sbe32s(f, v);
714
    return 0;
715
}
716

    
717
static void put_int32(QEMUFile *f, void *pv, size_t size)
718
{
719
    int32_t *v = pv;
720
    qemu_put_sbe32s(f, v);
721
}
722

    
723
const VMStateInfo vmstate_info_int32 = {
724
    .name = "int32",
725
    .get  = get_int32,
726
    .put  = put_int32,
727
};
728

    
729
/* 32 bit int. See that the received value is the same than the one
730
   in the field */
731

    
732
static int get_int32_equal(QEMUFile *f, void *pv, size_t size)
733
{
734
    int32_t *v = pv;
735
    int32_t v2;
736
    qemu_get_sbe32s(f, &v2);
737

    
738
    if (*v == v2)
739
        return 0;
740
    return -EINVAL;
741
}
742

    
743
const VMStateInfo vmstate_info_int32_equal = {
744
    .name = "int32 equal",
745
    .get  = get_int32_equal,
746
    .put  = put_int32,
747
};
748

    
749
/* 32 bit int. See that the received value is the less or the same
750
   than the one in the field */
751

    
752
static int get_int32_le(QEMUFile *f, void *pv, size_t size)
753
{
754
    int32_t *old = pv;
755
    int32_t new;
756
    qemu_get_sbe32s(f, &new);
757

    
758
    if (*old <= new)
759
        return 0;
760
    return -EINVAL;
761
}
762

    
763
const VMStateInfo vmstate_info_int32_le = {
764
    .name = "int32 equal",
765
    .get  = get_int32_le,
766
    .put  = put_int32,
767
};
768

    
769
/* 64 bit int */
770

    
771
static int get_int64(QEMUFile *f, void *pv, size_t size)
772
{
773
    int64_t *v = pv;
774
    qemu_get_sbe64s(f, v);
775
    return 0;
776
}
777

    
778
static void put_int64(QEMUFile *f, void *pv, size_t size)
779
{
780
    int64_t *v = pv;
781
    qemu_put_sbe64s(f, v);
782
}
783

    
784
const VMStateInfo vmstate_info_int64 = {
785
    .name = "int64",
786
    .get  = get_int64,
787
    .put  = put_int64,
788
};
789

    
790
/* 8 bit unsigned int */
791

    
792
static int get_uint8(QEMUFile *f, void *pv, size_t size)
793
{
794
    uint8_t *v = pv;
795
    qemu_get_8s(f, v);
796
    return 0;
797
}
798

    
799
static void put_uint8(QEMUFile *f, void *pv, size_t size)
800
{
801
    uint8_t *v = pv;
802
    qemu_put_8s(f, v);
803
}
804

    
805
const VMStateInfo vmstate_info_uint8 = {
806
    .name = "uint8",
807
    .get  = get_uint8,
808
    .put  = put_uint8,
809
};
810

    
811
/* 16 bit unsigned int */
812

    
813
static int get_uint16(QEMUFile *f, void *pv, size_t size)
814
{
815
    uint16_t *v = pv;
816
    qemu_get_be16s(f, v);
817
    return 0;
818
}
819

    
820
static void put_uint16(QEMUFile *f, void *pv, size_t size)
821
{
822
    uint16_t *v = pv;
823
    qemu_put_be16s(f, v);
824
}
825

    
826
const VMStateInfo vmstate_info_uint16 = {
827
    .name = "uint16",
828
    .get  = get_uint16,
829
    .put  = put_uint16,
830
};
831

    
832
/* 32 bit unsigned int */
833

    
834
static int get_uint32(QEMUFile *f, void *pv, size_t size)
835
{
836
    uint32_t *v = pv;
837
    qemu_get_be32s(f, v);
838
    return 0;
839
}
840

    
841
static void put_uint32(QEMUFile *f, void *pv, size_t size)
842
{
843
    uint32_t *v = pv;
844
    qemu_put_be32s(f, v);
845
}
846

    
847
const VMStateInfo vmstate_info_uint32 = {
848
    .name = "uint32",
849
    .get  = get_uint32,
850
    .put  = put_uint32,
851
};
852

    
853
/* 64 bit unsigned int */
854

    
855
static int get_uint64(QEMUFile *f, void *pv, size_t size)
856
{
857
    uint64_t *v = pv;
858
    qemu_get_be64s(f, v);
859
    return 0;
860
}
861

    
862
static void put_uint64(QEMUFile *f, void *pv, size_t size)
863
{
864
    uint64_t *v = pv;
865
    qemu_put_be64s(f, v);
866
}
867

    
868
const VMStateInfo vmstate_info_uint64 = {
869
    .name = "uint64",
870
    .get  = get_uint64,
871
    .put  = put_uint64,
872
};
873

    
874
/* 8 bit int. See that the received value is the same than the one
875
   in the field */
876

    
877
static int get_uint8_equal(QEMUFile *f, void *pv, size_t size)
878
{
879
    uint8_t *v = pv;
880
    uint8_t v2;
881
    qemu_get_8s(f, &v2);
882

    
883
    if (*v == v2)
884
        return 0;
885
    return -EINVAL;
886
}
887

    
888
const VMStateInfo vmstate_info_uint8_equal = {
889
    .name = "uint8 equal",
890
    .get  = get_uint8_equal,
891
    .put  = put_uint8,
892
};
893

    
894
/* 16 bit unsigned int int. See that the received value is the same than the one
895
   in the field */
896

    
897
static int get_uint16_equal(QEMUFile *f, void *pv, size_t size)
898
{
899
    uint16_t *v = pv;
900
    uint16_t v2;
901
    qemu_get_be16s(f, &v2);
902

    
903
    if (*v == v2)
904
        return 0;
905
    return -EINVAL;
906
}
907

    
908
const VMStateInfo vmstate_info_uint16_equal = {
909
    .name = "uint16 equal",
910
    .get  = get_uint16_equal,
911
    .put  = put_uint16,
912
};
913

    
914
/* timers  */
915

    
916
static int get_timer(QEMUFile *f, void *pv, size_t size)
917
{
918
    QEMUTimer *v = pv;
919
    qemu_get_timer(f, v);
920
    return 0;
921
}
922

    
923
static void put_timer(QEMUFile *f, void *pv, size_t size)
924
{
925
    QEMUTimer *v = pv;
926
    qemu_put_timer(f, v);
927
}
928

    
929
const VMStateInfo vmstate_info_timer = {
930
    .name = "timer",
931
    .get  = get_timer,
932
    .put  = put_timer,
933
};
934

    
935
/* uint8_t buffers */
936

    
937
static int get_buffer(QEMUFile *f, void *pv, size_t size)
938
{
939
    uint8_t *v = pv;
940
    qemu_get_buffer(f, v, size);
941
    return 0;
942
}
943

    
944
static void put_buffer(QEMUFile *f, void *pv, size_t size)
945
{
946
    uint8_t *v = pv;
947
    qemu_put_buffer(f, v, size);
948
}
949

    
950
const VMStateInfo vmstate_info_buffer = {
951
    .name = "buffer",
952
    .get  = get_buffer,
953
    .put  = put_buffer,
954
};
955

    
956
/* unused buffers: space that was used for some fields that are
957
   not usefull anymore */
958

    
959
static int get_unused_buffer(QEMUFile *f, void *pv, size_t size)
960
{
961
    uint8_t buf[1024];
962
    int block_len;
963

    
964
    while (size > 0) {
965
        block_len = MIN(sizeof(buf), size);
966
        size -= block_len;
967
        qemu_get_buffer(f, buf, block_len);
968
    }
969
   return 0;
970
}
971

    
972
static void put_unused_buffer(QEMUFile *f, void *pv, size_t size)
973
{
974
    static const uint8_t buf[1024];
975
    int block_len;
976

    
977
    while (size > 0) {
978
        block_len = MIN(sizeof(buf), size);
979
        size -= block_len;
980
        qemu_put_buffer(f, buf, block_len);
981
    }
982
}
983

    
984
const VMStateInfo vmstate_info_unused_buffer = {
985
    .name = "unused_buffer",
986
    .get  = get_unused_buffer,
987
    .put  = put_unused_buffer,
988
};
989

    
990
typedef struct SaveStateEntry {
991
    QTAILQ_ENTRY(SaveStateEntry) entry;
992
    char idstr[256];
993
    int instance_id;
994
    int version_id;
995
    int section_id;
996
    SaveSetParamsHandler *set_params;
997
    SaveLiveStateHandler *save_live_state;
998
    SaveStateHandler *save_state;
999
    LoadStateHandler *load_state;
1000
    const VMStateDescription *vmsd;
1001
    void *opaque;
1002
} SaveStateEntry;
1003

    
1004

    
1005
static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers =
1006
    QTAILQ_HEAD_INITIALIZER(savevm_handlers);
1007
static int global_section_id;
1008

    
1009
static int calculate_new_instance_id(const char *idstr)
1010
{
1011
    SaveStateEntry *se;
1012
    int instance_id = 0;
1013

    
1014
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1015
        if (strcmp(idstr, se->idstr) == 0
1016
            && instance_id <= se->instance_id) {
1017
            instance_id = se->instance_id + 1;
1018
        }
1019
    }
1020
    return instance_id;
1021
}
1022

    
1023
/* TODO: Individual devices generally have very little idea about the rest
1024
   of the system, so instance_id should be removed/replaced.
1025
   Meanwhile pass -1 as instance_id if you do not already have a clearly
1026
   distinguishing id for all instances of your device class. */
1027
int register_savevm_live(const char *idstr,
1028
                         int instance_id,
1029
                         int version_id,
1030
                         SaveSetParamsHandler *set_params,
1031
                         SaveLiveStateHandler *save_live_state,
1032
                         SaveStateHandler *save_state,
1033
                         LoadStateHandler *load_state,
1034
                         void *opaque)
1035
{
1036
    SaveStateEntry *se;
1037

    
1038
    se = qemu_mallocz(sizeof(SaveStateEntry));
1039
    pstrcpy(se->idstr, sizeof(se->idstr), idstr);
1040
    se->version_id = version_id;
1041
    se->section_id = global_section_id++;
1042
    se->set_params = set_params;
1043
    se->save_live_state = save_live_state;
1044
    se->save_state = save_state;
1045
    se->load_state = load_state;
1046
    se->opaque = opaque;
1047
    se->vmsd = NULL;
1048

    
1049
    if (instance_id == -1) {
1050
        se->instance_id = calculate_new_instance_id(idstr);
1051
    } else {
1052
        se->instance_id = instance_id;
1053
    }
1054
    /* add at the end of list */
1055
    QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1056
    return 0;
1057
}
1058

    
1059
int register_savevm(const char *idstr,
1060
                    int instance_id,
1061
                    int version_id,
1062
                    SaveStateHandler *save_state,
1063
                    LoadStateHandler *load_state,
1064
                    void *opaque)
1065
{
1066
    return register_savevm_live(idstr, instance_id, version_id,
1067
                                NULL, NULL, save_state, load_state, opaque);
1068
}
1069

    
1070
void unregister_savevm(const char *idstr, void *opaque)
1071
{
1072
    SaveStateEntry *se, *new_se;
1073

    
1074
    QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1075
        if (strcmp(se->idstr, idstr) == 0 && se->opaque == opaque) {
1076
            QTAILQ_REMOVE(&savevm_handlers, se, entry);
1077
            qemu_free(se);
1078
        }
1079
    }
1080
}
1081

    
1082
int vmstate_register(int instance_id, const VMStateDescription *vmsd,
1083
                     void *opaque)
1084
{
1085
    SaveStateEntry *se;
1086

    
1087
    se = qemu_mallocz(sizeof(SaveStateEntry));
1088
    pstrcpy(se->idstr, sizeof(se->idstr), vmsd->name);
1089
    se->version_id = vmsd->version_id;
1090
    se->section_id = global_section_id++;
1091
    se->save_live_state = NULL;
1092
    se->save_state = NULL;
1093
    se->load_state = NULL;
1094
    se->opaque = opaque;
1095
    se->vmsd = vmsd;
1096

    
1097
    if (instance_id == -1) {
1098
        se->instance_id = calculate_new_instance_id(vmsd->name);
1099
    } else {
1100
        se->instance_id = instance_id;
1101
    }
1102
    /* add at the end of list */
1103
    QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1104
    return 0;
1105
}
1106

    
1107
void vmstate_unregister(const VMStateDescription *vmsd, void *opaque)
1108
{
1109
    SaveStateEntry *se, *new_se;
1110

    
1111
    QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1112
        if (se->vmsd == vmsd && se->opaque == opaque) {
1113
            QTAILQ_REMOVE(&savevm_handlers, se, entry);
1114
            qemu_free(se);
1115
        }
1116
    }
1117
}
1118

    
1119
int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
1120
                       void *opaque, int version_id)
1121
{
1122
    VMStateField *field = vmsd->fields;
1123

    
1124
    if (version_id > vmsd->version_id) {
1125
        return -EINVAL;
1126
    }
1127
    if (version_id < vmsd->minimum_version_id_old) {
1128
        return -EINVAL;
1129
    }
1130
    if  (version_id < vmsd->minimum_version_id) {
1131
        return vmsd->load_state_old(f, opaque, version_id);
1132
    }
1133
    if (vmsd->pre_load) {
1134
        int ret = vmsd->pre_load(opaque);
1135
        if (ret)
1136
            return ret;
1137
    }
1138
    while(field->name) {
1139
        if ((field->field_exists &&
1140
             field->field_exists(opaque, version_id)) ||
1141
            (!field->field_exists &&
1142
             field->version_id <= version_id)) {
1143
            void *base_addr = opaque + field->offset;
1144
            int ret, i, n_elems = 1;
1145
            int size = field->size;
1146

    
1147
            if (field->flags & VMS_VBUFFER) {
1148
                size = *(int32_t *)(opaque+field->size_offset);
1149
                if (field->flags & VMS_MULTIPLY) {
1150
                    size *= field->size;
1151
                }
1152
            }
1153
            if (field->flags & VMS_ARRAY) {
1154
                n_elems = field->num;
1155
            } else if (field->flags & VMS_VARRAY_INT32) {
1156
                n_elems = *(int32_t *)(opaque+field->num_offset);
1157
            } else if (field->flags & VMS_VARRAY_UINT16) {
1158
                n_elems = *(uint16_t *)(opaque+field->num_offset);
1159
            }
1160
            if (field->flags & VMS_POINTER) {
1161
                base_addr = *(void **)base_addr + field->start;
1162
            }
1163
            for (i = 0; i < n_elems; i++) {
1164
                void *addr = base_addr + size * i;
1165

    
1166
                if (field->flags & VMS_ARRAY_OF_POINTER) {
1167
                    addr = *(void **)addr;
1168
                }
1169
                if (field->flags & VMS_STRUCT) {
1170
                    ret = vmstate_load_state(f, field->vmsd, addr, field->vmsd->version_id);
1171
                } else {
1172
                    ret = field->info->get(f, addr, size);
1173

    
1174
                }
1175
                if (ret < 0) {
1176
                    return ret;
1177
                }
1178
            }
1179
        }
1180
        field++;
1181
    }
1182
    if (vmsd->post_load) {
1183
        return vmsd->post_load(opaque, version_id);
1184
    }
1185
    return 0;
1186
}
1187

    
1188
void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
1189
                        void *opaque)
1190
{
1191
    VMStateField *field = vmsd->fields;
1192

    
1193
    if (vmsd->pre_save) {
1194
        vmsd->pre_save(opaque);
1195
    }
1196
    while(field->name) {
1197
        if (!field->field_exists ||
1198
            field->field_exists(opaque, vmsd->version_id)) {
1199
            void *base_addr = opaque + field->offset;
1200
            int i, n_elems = 1;
1201
            int size = field->size;
1202

    
1203
            if (field->flags & VMS_VBUFFER) {
1204
                size = *(int32_t *)(opaque+field->size_offset);
1205
                if (field->flags & VMS_MULTIPLY) {
1206
                    size *= field->size;
1207
                }
1208
            }
1209
            if (field->flags & VMS_ARRAY) {
1210
                n_elems = field->num;
1211
            } else if (field->flags & VMS_VARRAY_INT32) {
1212
                n_elems = *(int32_t *)(opaque+field->num_offset);
1213
            } else if (field->flags & VMS_VARRAY_UINT16) {
1214
                n_elems = *(uint16_t *)(opaque+field->num_offset);
1215
            }
1216
            if (field->flags & VMS_POINTER) {
1217
                base_addr = *(void **)base_addr + field->start;
1218
            }
1219
            for (i = 0; i < n_elems; i++) {
1220
                void *addr = base_addr + size * i;
1221

    
1222
                if (field->flags & VMS_ARRAY_OF_POINTER) {
1223
                    addr = *(void **)addr;
1224
                }
1225
                if (field->flags & VMS_STRUCT) {
1226
                    vmstate_save_state(f, field->vmsd, addr);
1227
                } else {
1228
                    field->info->put(f, addr, size);
1229
                }
1230
            }
1231
        }
1232
        field++;
1233
    }
1234
    if (vmsd->post_save) {
1235
        vmsd->post_save(opaque);
1236
    }
1237
}
1238

    
1239
static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id)
1240
{
1241
    if (!se->vmsd) {         /* Old style */
1242
        return se->load_state(f, se->opaque, version_id);
1243
    }
1244
    return vmstate_load_state(f, se->vmsd, se->opaque, version_id);
1245
}
1246

    
1247
static void vmstate_save(QEMUFile *f, SaveStateEntry *se)
1248
{
1249
    if (!se->vmsd) {         /* Old style */
1250
        se->save_state(f, se->opaque);
1251
        return;
1252
    }
1253
    vmstate_save_state(f,se->vmsd, se->opaque);
1254
}
1255

    
1256
#define QEMU_VM_FILE_MAGIC           0x5145564d
1257
#define QEMU_VM_FILE_VERSION_COMPAT  0x00000002
1258
#define QEMU_VM_FILE_VERSION         0x00000003
1259

    
1260
#define QEMU_VM_EOF                  0x00
1261
#define QEMU_VM_SECTION_START        0x01
1262
#define QEMU_VM_SECTION_PART         0x02
1263
#define QEMU_VM_SECTION_END          0x03
1264
#define QEMU_VM_SECTION_FULL         0x04
1265

    
1266
int qemu_savevm_state_begin(Monitor *mon, QEMUFile *f, int blk_enable,
1267
                            int shared)
1268
{
1269
    SaveStateEntry *se;
1270

    
1271
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1272
        if(se->set_params == NULL) {
1273
            continue;
1274
        }
1275
        se->set_params(blk_enable, shared, se->opaque);
1276
    }
1277
    
1278
    qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1279
    qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1280

    
1281
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1282
        int len;
1283

    
1284
        if (se->save_live_state == NULL)
1285
            continue;
1286

    
1287
        /* Section type */
1288
        qemu_put_byte(f, QEMU_VM_SECTION_START);
1289
        qemu_put_be32(f, se->section_id);
1290

    
1291
        /* ID string */
1292
        len = strlen(se->idstr);
1293
        qemu_put_byte(f, len);
1294
        qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1295

    
1296
        qemu_put_be32(f, se->instance_id);
1297
        qemu_put_be32(f, se->version_id);
1298

    
1299
        se->save_live_state(mon, f, QEMU_VM_SECTION_START, se->opaque);
1300
    }
1301

    
1302
    if (qemu_file_has_error(f)) {
1303
        qemu_savevm_state_cancel(mon, f);
1304
        return -EIO;
1305
    }
1306

    
1307
    return 0;
1308
}
1309

    
1310
int qemu_savevm_state_iterate(Monitor *mon, QEMUFile *f)
1311
{
1312
    SaveStateEntry *se;
1313
    int ret = 1;
1314

    
1315
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1316
        if (se->save_live_state == NULL)
1317
            continue;
1318

    
1319
        /* Section type */
1320
        qemu_put_byte(f, QEMU_VM_SECTION_PART);
1321
        qemu_put_be32(f, se->section_id);
1322

    
1323
        ret = se->save_live_state(mon, f, QEMU_VM_SECTION_PART, se->opaque);
1324
        if (!ret) {
1325
            /* Do not proceed to the next vmstate before this one reported
1326
               completion of the current stage. This serializes the migration
1327
               and reduces the probability that a faster changing state is
1328
               synchronized over and over again. */
1329
            break;
1330
        }
1331
    }
1332

    
1333
    if (ret)
1334
        return 1;
1335

    
1336
    if (qemu_file_has_error(f)) {
1337
        qemu_savevm_state_cancel(mon, f);
1338
        return -EIO;
1339
    }
1340

    
1341
    return 0;
1342
}
1343

    
1344
int qemu_savevm_state_complete(Monitor *mon, QEMUFile *f)
1345
{
1346
    SaveStateEntry *se;
1347

    
1348
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1349
        if (se->save_live_state == NULL)
1350
            continue;
1351

    
1352
        /* Section type */
1353
        qemu_put_byte(f, QEMU_VM_SECTION_END);
1354
        qemu_put_be32(f, se->section_id);
1355

    
1356
        se->save_live_state(mon, f, QEMU_VM_SECTION_END, se->opaque);
1357
    }
1358

    
1359
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1360
        int len;
1361

    
1362
        if (se->save_state == NULL && se->vmsd == NULL)
1363
            continue;
1364

    
1365
        /* Section type */
1366
        qemu_put_byte(f, QEMU_VM_SECTION_FULL);
1367
        qemu_put_be32(f, se->section_id);
1368

    
1369
        /* ID string */
1370
        len = strlen(se->idstr);
1371
        qemu_put_byte(f, len);
1372
        qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1373

    
1374
        qemu_put_be32(f, se->instance_id);
1375
        qemu_put_be32(f, se->version_id);
1376

    
1377
        vmstate_save(f, se);
1378
    }
1379

    
1380
    qemu_put_byte(f, QEMU_VM_EOF);
1381

    
1382
    if (qemu_file_has_error(f))
1383
        return -EIO;
1384

    
1385
    return 0;
1386
}
1387

    
1388
void qemu_savevm_state_cancel(Monitor *mon, QEMUFile *f)
1389
{
1390
    SaveStateEntry *se;
1391

    
1392
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1393
        if (se->save_live_state) {
1394
            se->save_live_state(mon, f, -1, se->opaque);
1395
        }
1396
    }
1397
}
1398

    
1399
static int qemu_savevm_state(Monitor *mon, QEMUFile *f)
1400
{
1401
    int saved_vm_running;
1402
    int ret;
1403

    
1404
    saved_vm_running = vm_running;
1405
    vm_stop(0);
1406

    
1407
    bdrv_flush_all();
1408

    
1409
    ret = qemu_savevm_state_begin(mon, f, 0, 0);
1410
    if (ret < 0)
1411
        goto out;
1412

    
1413
    do {
1414
        ret = qemu_savevm_state_iterate(mon, f);
1415
        if (ret < 0)
1416
            goto out;
1417
    } while (ret == 0);
1418

    
1419
    ret = qemu_savevm_state_complete(mon, f);
1420

    
1421
out:
1422
    if (qemu_file_has_error(f))
1423
        ret = -EIO;
1424

    
1425
    if (!ret && saved_vm_running)
1426
        vm_start();
1427

    
1428
    return ret;
1429
}
1430

    
1431
static SaveStateEntry *find_se(const char *idstr, int instance_id)
1432
{
1433
    SaveStateEntry *se;
1434

    
1435
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1436
        if (!strcmp(se->idstr, idstr) &&
1437
            instance_id == se->instance_id)
1438
            return se;
1439
    }
1440
    return NULL;
1441
}
1442

    
1443
typedef struct LoadStateEntry {
1444
    QLIST_ENTRY(LoadStateEntry) entry;
1445
    SaveStateEntry *se;
1446
    int section_id;
1447
    int version_id;
1448
} LoadStateEntry;
1449

    
1450
int qemu_loadvm_state(QEMUFile *f)
1451
{
1452
    QLIST_HEAD(, LoadStateEntry) loadvm_handlers =
1453
        QLIST_HEAD_INITIALIZER(loadvm_handlers);
1454
    LoadStateEntry *le, *new_le;
1455
    uint8_t section_type;
1456
    unsigned int v;
1457
    int ret;
1458

    
1459
    v = qemu_get_be32(f);
1460
    if (v != QEMU_VM_FILE_MAGIC)
1461
        return -EINVAL;
1462

    
1463
    v = qemu_get_be32(f);
1464
    if (v == QEMU_VM_FILE_VERSION_COMPAT) {
1465
        fprintf(stderr, "SaveVM v2 format is obsolete and don't work anymore\n");
1466
        return -ENOTSUP;
1467
    }
1468
    if (v != QEMU_VM_FILE_VERSION)
1469
        return -ENOTSUP;
1470

    
1471
    while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
1472
        uint32_t instance_id, version_id, section_id;
1473
        SaveStateEntry *se;
1474
        char idstr[257];
1475
        int len;
1476

    
1477
        switch (section_type) {
1478
        case QEMU_VM_SECTION_START:
1479
        case QEMU_VM_SECTION_FULL:
1480
            /* Read section start */
1481
            section_id = qemu_get_be32(f);
1482
            len = qemu_get_byte(f);
1483
            qemu_get_buffer(f, (uint8_t *)idstr, len);
1484
            idstr[len] = 0;
1485
            instance_id = qemu_get_be32(f);
1486
            version_id = qemu_get_be32(f);
1487

    
1488
            /* Find savevm section */
1489
            se = find_se(idstr, instance_id);
1490
            if (se == NULL) {
1491
                fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
1492
                ret = -EINVAL;
1493
                goto out;
1494
            }
1495

    
1496
            /* Validate version */
1497
            if (version_id > se->version_id) {
1498
                fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
1499
                        version_id, idstr, se->version_id);
1500
                ret = -EINVAL;
1501
                goto out;
1502
            }
1503

    
1504
            /* Add entry */
1505
            le = qemu_mallocz(sizeof(*le));
1506

    
1507
            le->se = se;
1508
            le->section_id = section_id;
1509
            le->version_id = version_id;
1510
            QLIST_INSERT_HEAD(&loadvm_handlers, le, entry);
1511

    
1512
            ret = vmstate_load(f, le->se, le->version_id);
1513
            if (ret < 0) {
1514
                fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
1515
                        instance_id, idstr);
1516
                goto out;
1517
            }
1518
            break;
1519
        case QEMU_VM_SECTION_PART:
1520
        case QEMU_VM_SECTION_END:
1521
            section_id = qemu_get_be32(f);
1522

    
1523
            QLIST_FOREACH(le, &loadvm_handlers, entry) {
1524
                if (le->section_id == section_id) {
1525
                    break;
1526
                }
1527
            }
1528
            if (le == NULL) {
1529
                fprintf(stderr, "Unknown savevm section %d\n", section_id);
1530
                ret = -EINVAL;
1531
                goto out;
1532
            }
1533

    
1534
            ret = vmstate_load(f, le->se, le->version_id);
1535
            if (ret < 0) {
1536
                fprintf(stderr, "qemu: warning: error while loading state section id %d\n",
1537
                        section_id);
1538
                goto out;
1539
            }
1540
            break;
1541
        default:
1542
            fprintf(stderr, "Unknown savevm section type %d\n", section_type);
1543
            ret = -EINVAL;
1544
            goto out;
1545
        }
1546
    }
1547

    
1548
    ret = 0;
1549

    
1550
out:
1551
    QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
1552
        QLIST_REMOVE(le, entry);
1553
        qemu_free(le);
1554
    }
1555

    
1556
    if (qemu_file_has_error(f))
1557
        ret = -EIO;
1558

    
1559
    return ret;
1560
}
1561

    
1562
/* device can contain snapshots */
1563
static int bdrv_can_snapshot(BlockDriverState *bs)
1564
{
1565
    return (bs &&
1566
            !bdrv_is_removable(bs) &&
1567
            !bdrv_is_read_only(bs));
1568
}
1569

    
1570
/* device must be snapshots in order to have a reliable snapshot */
1571
static int bdrv_has_snapshot(BlockDriverState *bs)
1572
{
1573
    return (bs &&
1574
            !bdrv_is_removable(bs) &&
1575
            !bdrv_is_read_only(bs));
1576
}
1577

    
1578
static BlockDriverState *get_bs_snapshots(void)
1579
{
1580
    BlockDriverState *bs;
1581
    DriveInfo *dinfo;
1582

    
1583
    if (bs_snapshots)
1584
        return bs_snapshots;
1585
    QTAILQ_FOREACH(dinfo, &drives, next) {
1586
        bs = dinfo->bdrv;
1587
        if (bdrv_can_snapshot(bs))
1588
            goto ok;
1589
    }
1590
    return NULL;
1591
 ok:
1592
    bs_snapshots = bs;
1593
    return bs;
1594
}
1595

    
1596
static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
1597
                              const char *name)
1598
{
1599
    QEMUSnapshotInfo *sn_tab, *sn;
1600
    int nb_sns, i, ret;
1601

    
1602
    ret = -ENOENT;
1603
    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1604
    if (nb_sns < 0)
1605
        return ret;
1606
    for(i = 0; i < nb_sns; i++) {
1607
        sn = &sn_tab[i];
1608
        if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
1609
            *sn_info = *sn;
1610
            ret = 0;
1611
            break;
1612
        }
1613
    }
1614
    qemu_free(sn_tab);
1615
    return ret;
1616
}
1617

    
1618
/*
1619
 * Deletes snapshots of a given name in all opened images.
1620
 */
1621
static int del_existing_snapshots(Monitor *mon, const char *name)
1622
{
1623
    BlockDriverState *bs;
1624
    DriveInfo *dinfo;
1625
    QEMUSnapshotInfo sn1, *snapshot = &sn1;
1626
    int ret;
1627

    
1628
    QTAILQ_FOREACH(dinfo, &drives, next) {
1629
        bs = dinfo->bdrv;
1630
        if (bdrv_can_snapshot(bs) &&
1631
            bdrv_snapshot_find(bs, snapshot, name) >= 0)
1632
        {
1633
            ret = bdrv_snapshot_delete(bs, name);
1634
            if (ret < 0) {
1635
                monitor_printf(mon,
1636
                               "Error while deleting snapshot on '%s'\n",
1637
                               bdrv_get_device_name(bs));
1638
                return -1;
1639
            }
1640
        }
1641
    }
1642

    
1643
    return 0;
1644
}
1645

    
1646
void do_savevm(Monitor *mon, const QDict *qdict)
1647
{
1648
    DriveInfo *dinfo;
1649
    BlockDriverState *bs, *bs1;
1650
    QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
1651
    int ret;
1652
    QEMUFile *f;
1653
    int saved_vm_running;
1654
    uint32_t vm_state_size;
1655
#ifdef _WIN32
1656
    struct _timeb tb;
1657
#else
1658
    struct timeval tv;
1659
#endif
1660
    const char *name = qdict_get_try_str(qdict, "name");
1661

    
1662
    bs = get_bs_snapshots();
1663
    if (!bs) {
1664
        monitor_printf(mon, "No block device can accept snapshots\n");
1665
        return;
1666
    }
1667

    
1668
    /* ??? Should this occur after vm_stop?  */
1669
    qemu_aio_flush();
1670

    
1671
    saved_vm_running = vm_running;
1672
    vm_stop(0);
1673

    
1674
    memset(sn, 0, sizeof(*sn));
1675
    if (name) {
1676
        ret = bdrv_snapshot_find(bs, old_sn, name);
1677
        if (ret >= 0) {
1678
            pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
1679
            pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
1680
        } else {
1681
            pstrcpy(sn->name, sizeof(sn->name), name);
1682
        }
1683
    }
1684

    
1685
    /* fill auxiliary fields */
1686
#ifdef _WIN32
1687
    _ftime(&tb);
1688
    sn->date_sec = tb.time;
1689
    sn->date_nsec = tb.millitm * 1000000;
1690
#else
1691
    gettimeofday(&tv, NULL);
1692
    sn->date_sec = tv.tv_sec;
1693
    sn->date_nsec = tv.tv_usec * 1000;
1694
#endif
1695
    sn->vm_clock_nsec = qemu_get_clock(vm_clock);
1696

    
1697
    /* Delete old snapshots of the same name */
1698
    if (name && del_existing_snapshots(mon, name) < 0) {
1699
        goto the_end;
1700
    }
1701

    
1702
    /* save the VM state */
1703
    f = qemu_fopen_bdrv(bs, 1);
1704
    if (!f) {
1705
        monitor_printf(mon, "Could not open VM state file\n");
1706
        goto the_end;
1707
    }
1708
    ret = qemu_savevm_state(mon, f);
1709
    vm_state_size = qemu_ftell(f);
1710
    qemu_fclose(f);
1711
    if (ret < 0) {
1712
        monitor_printf(mon, "Error %d while writing VM\n", ret);
1713
        goto the_end;
1714
    }
1715

    
1716
    /* create the snapshots */
1717

    
1718
    QTAILQ_FOREACH(dinfo, &drives, next) {
1719
        bs1 = dinfo->bdrv;
1720
        if (bdrv_has_snapshot(bs1)) {
1721
            /* Write VM state size only to the image that contains the state */
1722
            sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
1723
            ret = bdrv_snapshot_create(bs1, sn);
1724
            if (ret < 0) {
1725
                monitor_printf(mon, "Error while creating snapshot on '%s'\n",
1726
                               bdrv_get_device_name(bs1));
1727
            }
1728
        }
1729
    }
1730

    
1731
 the_end:
1732
    if (saved_vm_running)
1733
        vm_start();
1734
}
1735

    
1736
int load_vmstate(Monitor *mon, const char *name)
1737
{
1738
    DriveInfo *dinfo;
1739
    BlockDriverState *bs, *bs1;
1740
    QEMUSnapshotInfo sn;
1741
    QEMUFile *f;
1742
    int ret;
1743

    
1744
    bs = get_bs_snapshots();
1745
    if (!bs) {
1746
        monitor_printf(mon, "No block device supports snapshots\n");
1747
        return -EINVAL;
1748
    }
1749

    
1750
    /* Flush all IO requests so they don't interfere with the new state.  */
1751
    qemu_aio_flush();
1752

    
1753
    QTAILQ_FOREACH(dinfo, &drives, next) {
1754
        bs1 = dinfo->bdrv;
1755
        if (bdrv_has_snapshot(bs1)) {
1756
            ret = bdrv_snapshot_goto(bs1, name);
1757
            if (ret < 0) {
1758
                if (bs != bs1)
1759
                    monitor_printf(mon, "Warning: ");
1760
                switch(ret) {
1761
                case -ENOTSUP:
1762
                    monitor_printf(mon,
1763
                                   "Snapshots not supported on device '%s'\n",
1764
                                   bdrv_get_device_name(bs1));
1765
                    break;
1766
                case -ENOENT:
1767
                    monitor_printf(mon, "Could not find snapshot '%s' on "
1768
                                   "device '%s'\n",
1769
                                   name, bdrv_get_device_name(bs1));
1770
                    break;
1771
                default:
1772
                    monitor_printf(mon, "Error %d while activating snapshot on"
1773
                                   " '%s'\n", ret, bdrv_get_device_name(bs1));
1774
                    break;
1775
                }
1776
                /* fatal on snapshot block device */
1777
                if (bs == bs1)
1778
                    return 0;
1779
            }
1780
        }
1781
    }
1782

    
1783
    /* Don't even try to load empty VM states */
1784
    ret = bdrv_snapshot_find(bs, &sn, name);
1785
    if ((ret >= 0) && (sn.vm_state_size == 0))
1786
        return -EINVAL;
1787

    
1788
    /* restore the VM state */
1789
    f = qemu_fopen_bdrv(bs, 0);
1790
    if (!f) {
1791
        monitor_printf(mon, "Could not open VM state file\n");
1792
        return -EINVAL;
1793
    }
1794
    ret = qemu_loadvm_state(f);
1795
    qemu_fclose(f);
1796
    if (ret < 0) {
1797
        monitor_printf(mon, "Error %d while loading VM state\n", ret);
1798
        return ret;
1799
    }
1800
    return 0;
1801
}
1802

    
1803
void do_delvm(Monitor *mon, const QDict *qdict)
1804
{
1805
    DriveInfo *dinfo;
1806
    BlockDriverState *bs, *bs1;
1807
    int ret;
1808
    const char *name = qdict_get_str(qdict, "name");
1809

    
1810
    bs = get_bs_snapshots();
1811
    if (!bs) {
1812
        monitor_printf(mon, "No block device supports snapshots\n");
1813
        return;
1814
    }
1815

    
1816
    QTAILQ_FOREACH(dinfo, &drives, next) {
1817
        bs1 = dinfo->bdrv;
1818
        if (bdrv_has_snapshot(bs1)) {
1819
            ret = bdrv_snapshot_delete(bs1, name);
1820
            if (ret < 0) {
1821
                if (ret == -ENOTSUP)
1822
                    monitor_printf(mon,
1823
                                   "Snapshots not supported on device '%s'\n",
1824
                                   bdrv_get_device_name(bs1));
1825
                else
1826
                    monitor_printf(mon, "Error %d while deleting snapshot on "
1827
                                   "'%s'\n", ret, bdrv_get_device_name(bs1));
1828
            }
1829
        }
1830
    }
1831
}
1832

    
1833
void do_info_snapshots(Monitor *mon)
1834
{
1835
    DriveInfo *dinfo;
1836
    BlockDriverState *bs, *bs1;
1837
    QEMUSnapshotInfo *sn_tab, *sn;
1838
    int nb_sns, i;
1839
    char buf[256];
1840

    
1841
    bs = get_bs_snapshots();
1842
    if (!bs) {
1843
        monitor_printf(mon, "No available block device supports snapshots\n");
1844
        return;
1845
    }
1846
    monitor_printf(mon, "Snapshot devices:");
1847
    QTAILQ_FOREACH(dinfo, &drives, next) {
1848
        bs1 = dinfo->bdrv;
1849
        if (bdrv_has_snapshot(bs1)) {
1850
            if (bs == bs1)
1851
                monitor_printf(mon, " %s", bdrv_get_device_name(bs1));
1852
        }
1853
    }
1854
    monitor_printf(mon, "\n");
1855

    
1856
    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1857
    if (nb_sns < 0) {
1858
        monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
1859
        return;
1860
    }
1861
    monitor_printf(mon, "Snapshot list (from %s):\n",
1862
                   bdrv_get_device_name(bs));
1863
    monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1864
    for(i = 0; i < nb_sns; i++) {
1865
        sn = &sn_tab[i];
1866
        monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1867
    }
1868
    qemu_free(sn_tab);
1869
}