← Back to branch summary

~ahs3/+junk/cq-qemu

« back to all changes in this revision

Viewing changes to savevm.c

  • Committer: Al Stone
  • Date: 2012-02-09 01:17:20 UTC
  • Revision ID: albert.stone@canonical.com-20120209011720-tztl7ik3qayz80p4
first commit to bzr for qemu

Show diffs side-by-side

added added

removed removed

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