Statistics
| Branch: | Revision:

root / savevm.c @ ea375f9a

History | View | Annotate | Download (45.8 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
    cpu_synchronize_all_states();
1349

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

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

    
1358
        se->save_live_state(mon, f, QEMU_VM_SECTION_END, se->opaque);
1359
    }
1360

    
1361
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1362
        int len;
1363

    
1364
        if (se->save_state == NULL && se->vmsd == NULL)
1365
            continue;
1366

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

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

    
1376
        qemu_put_be32(f, se->instance_id);
1377
        qemu_put_be32(f, se->version_id);
1378

    
1379
        vmstate_save(f, se);
1380
    }
1381

    
1382
    qemu_put_byte(f, QEMU_VM_EOF);
1383

    
1384
    if (qemu_file_has_error(f))
1385
        return -EIO;
1386

    
1387
    return 0;
1388
}
1389

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

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

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

    
1406
    saved_vm_running = vm_running;
1407
    vm_stop(0);
1408

    
1409
    bdrv_flush_all();
1410

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

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

    
1421
    ret = qemu_savevm_state_complete(mon, f);
1422

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

    
1427
    if (!ret && saved_vm_running)
1428
        vm_start();
1429

    
1430
    return ret;
1431
}
1432

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

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

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

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

    
1461
    v = qemu_get_be32(f);
1462
    if (v != QEMU_VM_FILE_MAGIC)
1463
        return -EINVAL;
1464

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

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

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

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

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

    
1506
            /* Add entry */
1507
            le = qemu_mallocz(sizeof(*le));
1508

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

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

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

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

    
1550
    cpu_synchronize_all_post_init();
1551

    
1552
    ret = 0;
1553

    
1554
out:
1555
    QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
1556
        QLIST_REMOVE(le, entry);
1557
        qemu_free(le);
1558
    }
1559

    
1560
    if (qemu_file_has_error(f))
1561
        ret = -EIO;
1562

    
1563
    return ret;
1564
}
1565

    
1566
/* device can contain snapshots */
1567
static int bdrv_can_snapshot(BlockDriverState *bs)
1568
{
1569
    return (bs &&
1570
            !bdrv_is_removable(bs) &&
1571
            !bdrv_is_read_only(bs));
1572
}
1573

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

    
1582
static BlockDriverState *get_bs_snapshots(void)
1583
{
1584
    BlockDriverState *bs;
1585
    DriveInfo *dinfo;
1586

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

    
1600
static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
1601
                              const char *name)
1602
{
1603
    QEMUSnapshotInfo *sn_tab, *sn;
1604
    int nb_sns, i, ret;
1605

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

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

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

    
1647
    return 0;
1648
}
1649

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

    
1666
    bs = get_bs_snapshots();
1667
    if (!bs) {
1668
        monitor_printf(mon, "No block device can accept snapshots\n");
1669
        return;
1670
    }
1671

    
1672
    /* ??? Should this occur after vm_stop?  */
1673
    qemu_aio_flush();
1674

    
1675
    saved_vm_running = vm_running;
1676
    vm_stop(0);
1677

    
1678
    memset(sn, 0, sizeof(*sn));
1679
    if (name) {
1680
        ret = bdrv_snapshot_find(bs, old_sn, name);
1681
        if (ret >= 0) {
1682
            pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
1683
            pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
1684
        } else {
1685
            pstrcpy(sn->name, sizeof(sn->name), name);
1686
        }
1687
    }
1688

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

    
1701
    /* Delete old snapshots of the same name */
1702
    if (name && del_existing_snapshots(mon, name) < 0) {
1703
        goto the_end;
1704
    }
1705

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

    
1720
    /* create the snapshots */
1721

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

    
1735
 the_end:
1736
    if (saved_vm_running)
1737
        vm_start();
1738
}
1739

    
1740
int load_vmstate(Monitor *mon, const char *name)
1741
{
1742
    DriveInfo *dinfo;
1743
    BlockDriverState *bs, *bs1;
1744
    QEMUSnapshotInfo sn;
1745
    QEMUFile *f;
1746
    int ret;
1747

    
1748
    bs = get_bs_snapshots();
1749
    if (!bs) {
1750
        monitor_printf(mon, "No block device supports snapshots\n");
1751
        return -EINVAL;
1752
    }
1753

    
1754
    /* Flush all IO requests so they don't interfere with the new state.  */
1755
    qemu_aio_flush();
1756

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

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

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

    
1807
void do_delvm(Monitor *mon, const QDict *qdict)
1808
{
1809
    DriveInfo *dinfo;
1810
    BlockDriverState *bs, *bs1;
1811
    int ret;
1812
    const char *name = qdict_get_str(qdict, "name");
1813

    
1814
    bs = get_bs_snapshots();
1815
    if (!bs) {
1816
        monitor_printf(mon, "No block device supports snapshots\n");
1817
        return;
1818
    }
1819

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

    
1837
void do_info_snapshots(Monitor *mon)
1838
{
1839
    DriveInfo *dinfo;
1840
    BlockDriverState *bs, *bs1;
1841
    QEMUSnapshotInfo *sn_tab, *sn;
1842
    int nb_sns, i;
1843
    char buf[256];
1844

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

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