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

blueswir1's avatar
blueswir1 committed
25
#include "config-host.h"
26 27
#include "qemu-common.h"
#include "hw/hw.h"
28
#include "hw/qdev.h"
Paolo Bonzini's avatar
Paolo Bonzini committed
29
#include "net/net.h"
30
#include "monitor/monitor.h"
31
#include "sysemu/sysemu.h"
32
#include "qemu/timer.h"
33
#include "audio/audio.h"
34
#include "migration/migration.h"
35 36
#include "qemu/sockets.h"
#include "qemu/queue.h"
37
#include "sysemu/cpus.h"
38
#include "exec/memory.h"
39
#include "qmp-commands.h"
40
#include "trace.h"
41
#include "qemu/iov.h"
42
#include "block/snapshot.h"
43
#include "block/qapi.h"
44

45 46
#define SELF_ANNOUNCE_ROUNDS 5

47
#ifndef ETH_P_RARP
Stefan Berger's avatar
Stefan Berger committed
48
#define ETH_P_RARP 0x8035
49 50 51 52 53 54
#endif
#define ARP_HTYPE_ETH 0x0001
#define ARP_PTYPE_IP 0x0800
#define ARP_OP_REQUEST_REV 0x3

static int announce_self_create(uint8_t *buf,
55
                                uint8_t *mac_addr)
56
{
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
    /* Ethernet header. */
    memset(buf, 0xff, 6);         /* destination MAC addr */
    memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
    *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */

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

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

    return 60; /* len (FCS will be added by hardware) */
77 78
}

79
static void qemu_announce_self_iter(NICState *nic, void *opaque)
80
{
81
    uint8_t buf[60];
82 83 84 85
    int len;

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

86
    qemu_send_packet_raw(qemu_get_queue(nic), buf, len);
87 88 89 90 91
}


static void qemu_announce_self_once(void *opaque)
{
92 93
    static int count = SELF_ANNOUNCE_ROUNDS;
    QEMUTimer *timer = *(QEMUTimer **)opaque;
94

95 96
    qemu_foreach_nic(qemu_announce_self_iter, NULL);

97 98
    if (--count) {
        /* delay 50ms, 150ms, 250ms, ... */
99
        timer_mod(timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) +
100
                       50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100);
101
    } else {
102 103
            timer_del(timer);
            timer_free(timer);
104 105 106 107 108
    }
}

void qemu_announce_self(void)
{
109 110 111
    static QEMUTimer *timer;
    timer = timer_new_ms(QEMU_CLOCK_REALTIME, qemu_announce_self_once, &timer);
    qemu_announce_self_once(&timer);
112 113 114 115 116
}

/***********************************************************/
/* savevm/loadvm support */

117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
static ssize_t block_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
                                   int64_t pos)
{
    int ret;
    QEMUIOVector qiov;

    qemu_iovec_init_external(&qiov, iov, iovcnt);
    ret = bdrv_writev_vmstate(opaque, &qiov, pos);
    if (ret < 0) {
        return ret;
    }

    return qiov.size;
}

132
static int block_put_buffer(void *opaque, const uint8_t *buf,
133 134
                           int64_t pos, int size)
{
135
    bdrv_save_vmstate(opaque, buf, pos, size);
136 137 138
    return size;
}

139
static int block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
140
{
141
    return bdrv_load_vmstate(opaque, buf, pos, size);
142 143 144 145
}

static int bdrv_fclose(void *opaque)
{
146
    return bdrv_flush(opaque);
147 148
}

149 150 151 152 153 154
static const QEMUFileOps bdrv_read_ops = {
    .get_buffer = block_get_buffer,
    .close =      bdrv_fclose
};

static const QEMUFileOps bdrv_write_ops = {
155 156 157
    .put_buffer     = block_put_buffer,
    .writev_buffer  = block_writev_buffer,
    .close          = bdrv_fclose
158 159
};

160
static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
161
{
162
    if (is_writable) {
163
        return qemu_fopen_ops(bs, &bdrv_write_ops);
164
    }
165
    return qemu_fopen_ops(bs, &bdrv_read_ops);
166 167
}

168

169 170 171
/* QEMUFile timer support.
 * Not in qemu-file.c to not add qemu-timer.c as dependency to qemu-file.c
 */
172

173
void timer_put(QEMUFile *f, QEMUTimer *ts)
174 175 176
{
    uint64_t expire_time;

177
    expire_time = timer_expire_time_ns(ts);
178 179 180
    qemu_put_be64(f, expire_time);
}

181
void timer_get(QEMUFile *f, QEMUTimer *ts)
182 183 184 185 186
{
    uint64_t expire_time;

    expire_time = qemu_get_be64(f);
    if (expire_time != -1) {
187
        timer_mod_ns(ts, expire_time);
188
    } else {
189
        timer_del(ts);
190 191 192 193
    }
}


194 195 196
/* VMState timer support.
 * Not in vmstate.c to not add qemu-timer.c as dependency to vmstate.c
 */
197 198 199 200

static int get_timer(QEMUFile *f, void *pv, size_t size)
{
    QEMUTimer *v = pv;
201
    timer_get(f, v);
202 203 204
    return 0;
}

205
static void put_timer(QEMUFile *f, void *pv, size_t size)
206
{
207
    QEMUTimer *v = pv;
208
    timer_put(f, v);
209 210 211 212 213 214 215 216
}

const VMStateInfo vmstate_info_timer = {
    .name = "timer",
    .get  = get_timer,
    .put  = put_timer,
};

217

218 219 220 221 222
typedef struct CompatEntry {
    char idstr[256];
    int instance_id;
} CompatEntry;

223
typedef struct SaveStateEntry {
224
    QTAILQ_ENTRY(SaveStateEntry) entry;
225 226
    char idstr[256];
    int instance_id;
227
    int alias_id;
228 229
    int version_id;
    int section_id;
230
    SaveVMHandlers *ops;
231
    const VMStateDescription *vmsd;
232
    void *opaque;
233
    CompatEntry *compat;
234
    int no_migrate;
235
    int is_ram;
236 237
} SaveStateEntry;

lirans@il.ibm.com's avatar
lirans@il.ibm.com committed
238

239 240
static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers =
    QTAILQ_HEAD_INITIALIZER(savevm_handlers);
241
static int global_section_id;
242

243 244 245 246 247
static int calculate_new_instance_id(const char *idstr)
{
    SaveStateEntry *se;
    int instance_id = 0;

248
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
249 250 251 252 253 254 255 256
        if (strcmp(idstr, se->idstr) == 0
            && instance_id <= se->instance_id) {
            instance_id = se->instance_id + 1;
        }
    }
    return instance_id;
}

257 258 259 260 261 262
static int calculate_compat_instance_id(const char *idstr)
{
    SaveStateEntry *se;
    int instance_id = 0;

    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
263
        if (!se->compat) {
264
            continue;
265
        }
266 267 268 269 270 271 272 273 274

        if (strcmp(idstr, se->compat->idstr) == 0
            && instance_id <= se->compat->instance_id) {
            instance_id = se->compat->instance_id + 1;
        }
    }
    return instance_id;
}

275 276 277 278
/* TODO: Individual devices generally have very little idea about the rest
   of the system, so instance_id should be removed/replaced.
   Meanwhile pass -1 as instance_id if you do not already have a clearly
   distinguishing id for all instances of your device class. */
279 280
int register_savevm_live(DeviceState *dev,
                         const char *idstr,
281 282
                         int instance_id,
                         int version_id,
283
                         SaveVMHandlers *ops,
284 285
                         void *opaque)
{
286
    SaveStateEntry *se;
287

288
    se = g_malloc0(sizeof(SaveStateEntry));
289 290
    se->version_id = version_id;
    se->section_id = global_section_id++;
291
    se->ops = ops;
292
    se->opaque = opaque;
293
    se->vmsd = NULL;
294
    se->no_migrate = 0;
295
    /* if this is a live_savem then set is_ram */
296
    if (ops->save_live_setup != NULL) {
297 298
        se->is_ram = 1;
    }
299

300 301
    if (dev) {
        char *id = qdev_get_dev_path(dev);
302 303 304
        if (id) {
            pstrcpy(se->idstr, sizeof(se->idstr), id);
            pstrcat(se->idstr, sizeof(se->idstr), "/");
305
            g_free(id);
306

307
            se->compat = g_malloc0(sizeof(CompatEntry));
308 309 310 311 312 313 314 315
            pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr);
            se->compat->instance_id = instance_id == -1 ?
                         calculate_compat_instance_id(idstr) : instance_id;
            instance_id = -1;
        }
    }
    pstrcat(se->idstr, sizeof(se->idstr), idstr);

316
    if (instance_id == -1) {
317
        se->instance_id = calculate_new_instance_id(se->idstr);
318 319
    } else {
        se->instance_id = instance_id;
320
    }
321
    assert(!se->compat || se->instance_id == 0);
322
    /* add at the end of list */
323
    QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
324 325 326
    return 0;
}

327 328
int register_savevm(DeviceState *dev,
                    const char *idstr,
329 330 331 332 333 334
                    int instance_id,
                    int version_id,
                    SaveStateHandler *save_state,
                    LoadStateHandler *load_state,
                    void *opaque)
{
335 336 337
    SaveVMHandlers *ops = g_malloc0(sizeof(SaveVMHandlers));
    ops->save_state = save_state;
    ops->load_state = load_state;
338
    return register_savevm_live(dev, idstr, instance_id, version_id,
339
                                ops, opaque);
340 341
}

342
void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
343
{
344
    SaveStateEntry *se, *new_se;
345 346
    char id[256] = "";

347 348
    if (dev) {
        char *path = qdev_get_dev_path(dev);
349 350 351
        if (path) {
            pstrcpy(id, sizeof(id), path);
            pstrcat(id, sizeof(id), "/");
352
            g_free(path);
353 354 355
        }
    }
    pstrcat(id, sizeof(id), idstr);
356

357
    QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
358
        if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
359
            QTAILQ_REMOVE(&savevm_handlers, se, entry);
360
            if (se->compat) {
361
                g_free(se->compat);
362
            }
363
            g_free(se->ops);
364
            g_free(se);
365 366 367 368
        }
    }
}

369
int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
370 371 372
                                   const VMStateDescription *vmsd,
                                   void *opaque, int alias_id,
                                   int required_for_version)
373
{
374
    SaveStateEntry *se;
375

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

379
    se = g_malloc0(sizeof(SaveStateEntry));
380 381 382 383
    se->version_id = vmsd->version_id;
    se->section_id = global_section_id++;
    se->opaque = opaque;
    se->vmsd = vmsd;
384
    se->alias_id = alias_id;
385
    se->no_migrate = vmsd->unmigratable;
386

387 388
    if (dev) {
        char *id = qdev_get_dev_path(dev);
389 390 391
        if (id) {
            pstrcpy(se->idstr, sizeof(se->idstr), id);
            pstrcat(se->idstr, sizeof(se->idstr), "/");
392
            g_free(id);
393

394
            se->compat = g_malloc0(sizeof(CompatEntry));
395 396 397 398 399 400 401 402
            pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
            se->compat->instance_id = instance_id == -1 ?
                         calculate_compat_instance_id(vmsd->name) : instance_id;
            instance_id = -1;
        }
    }
    pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);

403
    if (instance_id == -1) {
404
        se->instance_id = calculate_new_instance_id(se->idstr);
405 406
    } else {
        se->instance_id = instance_id;
407
    }
408
    assert(!se->compat || se->instance_id == 0);
409
    /* add at the end of list */
410
    QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
411 412 413
    return 0;
}

414 415
void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
                        void *opaque)
416
{
417 418
    SaveStateEntry *se, *new_se;

419
    QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
420
        if (se->vmsd == vmsd && se->opaque == opaque) {
421
            QTAILQ_REMOVE(&savevm_handlers, se, entry);
422
            if (se->compat) {
423
                g_free(se->compat);
424
            }
425
            g_free(se);
426 427
        }
    }
428 429
}

430 431
static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id)
{
432
    if (!se->vmsd) {         /* Old style */
433
        return se->ops->load_state(f, se->opaque, version_id);
434 435
    }
    return vmstate_load_state(f, se->vmsd, se->opaque, version_id);
436 437
}

Alex Williamson's avatar
Alex Williamson committed
438
static void vmstate_save(QEMUFile *f, SaveStateEntry *se)
439
{
440
    if (!se->vmsd) {         /* Old style */
441
        se->ops->save_state(f, se->opaque);
Alex Williamson's avatar
Alex Williamson committed
442
        return;
443
    }
444
    vmstate_save_state(f, se->vmsd, se->opaque);
445 446
}

Luiz Capitulino's avatar
Luiz Capitulino committed
447
bool qemu_savevm_state_blocked(Error **errp)
Alex Williamson's avatar
Alex Williamson committed
448 449 450 451 452
{
    SaveStateEntry *se;

    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
        if (se->no_migrate) {
Luiz Capitulino's avatar
Luiz Capitulino committed
453
            error_set(errp, QERR_MIGRATION_NOT_SUPPORTED, se->idstr);
Alex Williamson's avatar
Alex Williamson committed
454 455 456 457 458 459
            return true;
        }
    }
    return false;
}

460 461
void qemu_savevm_state_begin(QEMUFile *f,
                             const MigrationParams *params)
462 463
{
    SaveStateEntry *se;
464
    int ret;
465

lirans@il.ibm.com's avatar
lirans@il.ibm.com committed
466
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
467
        if (!se->ops || !se->ops->set_params) {
lirans@il.ibm.com's avatar
lirans@il.ibm.com committed
468
            continue;
469
        }
470
        se->ops->set_params(params, se->opaque);
lirans@il.ibm.com's avatar
lirans@il.ibm.com committed
471
    }
472

473 474 475
    qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
    qemu_put_be32(f, QEMU_VM_FILE_VERSION);

476
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
477 478
        int len;

479
        if (!se->ops || !se->ops->save_live_setup) {
480
            continue;
481
        }
482 483 484 485 486
        if (se->ops && se->ops->is_active) {
            if (!se->ops->is_active(se->opaque)) {
                continue;
            }
        }
487 488 489 490 491 492 493 494 495 496 497 498
        /* Section type */
        qemu_put_byte(f, QEMU_VM_SECTION_START);
        qemu_put_be32(f, se->section_id);

        /* ID string */
        len = strlen(se->idstr);
        qemu_put_byte(f, len);
        qemu_put_buffer(f, (uint8_t *)se->idstr, len);

        qemu_put_be32(f, se->instance_id);
        qemu_put_be32(f, se->version_id);

499
        ret = se->ops->save_live_setup(f, se->opaque);
500
        if (ret < 0) {
501 502
            qemu_file_set_error(f, ret);
            break;
503
        }
504 505 506
    }
}

507
/*
508
 * this function has three return values:
509 510 511 512
 *   negative: there was one error, and we have -errno.
 *   0 : We haven't finished, caller have to go again
 *   1 : We have finished, we can go to complete phase
 */
513
int qemu_savevm_state_iterate(QEMUFile *f)
514 515 516 517
{
    SaveStateEntry *se;
    int ret = 1;

518
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
519
        if (!se->ops || !se->ops->save_live_iterate) {
520
            continue;
521
        }
522 523 524 525 526
        if (se->ops && se->ops->is_active) {
            if (!se->ops->is_active(se->opaque)) {
                continue;
            }
        }
527 528 529
        if (qemu_file_rate_limit(f)) {
            return 0;
        }
530
        trace_savevm_section_start();
531 532 533 534
        /* Section type */
        qemu_put_byte(f, QEMU_VM_SECTION_PART);
        qemu_put_be32(f, se->section_id);

535
        ret = se->ops->save_live_iterate(f, se->opaque);
536 537
        trace_savevm_section_end(se->section_id);

538 539 540
        if (ret < 0) {
            qemu_file_set_error(f, ret);
        }
541
        if (ret <= 0) {
542 543 544 545 546 547
            /* Do not proceed to the next vmstate before this one reported
               completion of the current stage. This serializes the migration
               and reduces the probability that a faster changing state is
               synchronized over and over again. */
            break;
        }
548
    }
549
    return ret;
550 551
}

552
void qemu_savevm_state_complete(QEMUFile *f)
553 554
{
    SaveStateEntry *se;
555
    int ret;
556

557 558
    cpu_synchronize_all_states();

559
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
560
        if (!se->ops || !se->ops->save_live_complete) {
561
            continue;
562
        }
563 564 565 566 567
        if (se->ops && se->ops->is_active) {
            if (!se->ops->is_active(se->opaque)) {
                continue;
            }
        }
568
        trace_savevm_section_start();
569 570 571 572
        /* Section type */
        qemu_put_byte(f, QEMU_VM_SECTION_END);
        qemu_put_be32(f, se->section_id);

573
        ret = se->ops->save_live_complete(f, se->opaque);
574
        trace_savevm_section_end(se->section_id);
575
        if (ret < 0) {
576 577
            qemu_file_set_error(f, ret);
            return;
578
        }
579 580
    }

581
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
582 583
        int len;

584
        if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
585
            continue;
586
        }
587
        trace_savevm_section_start();
588 589 590 591 592 593 594 595 596 597 598 599
        /* Section type */
        qemu_put_byte(f, QEMU_VM_SECTION_FULL);
        qemu_put_be32(f, se->section_id);

        /* ID string */
        len = strlen(se->idstr);
        qemu_put_byte(f, len);
        qemu_put_buffer(f, (uint8_t *)se->idstr, len);

        qemu_put_be32(f, se->instance_id);
        qemu_put_be32(f, se->version_id);

Alex Williamson's avatar
Alex Williamson committed
600
        vmstate_save(f, se);
601
        trace_savevm_section_end(se->section_id);
602 603 604
    }

    qemu_put_byte(f, QEMU_VM_EOF);
605
    qemu_fflush(f);
606 607
}

608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
uint64_t qemu_savevm_state_pending(QEMUFile *f, uint64_t max_size)
{
    SaveStateEntry *se;
    uint64_t ret = 0;

    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
        if (!se->ops || !se->ops->save_live_pending) {
            continue;
        }
        if (se->ops && se->ops->is_active) {
            if (!se->ops->is_active(se->opaque)) {
                continue;
            }
        }
        ret += se->ops->save_live_pending(f, se->opaque, max_size);
    }
    return ret;
}

627
void qemu_savevm_state_cancel(void)
628 629 630 631
{
    SaveStateEntry *se;

    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
632 633
        if (se->ops && se->ops->cancel) {
            se->ops->cancel(se->opaque);
634 635 636 637
        }
    }
}

Luiz Capitulino's avatar
Luiz Capitulino committed
638
static int qemu_savevm_state(QEMUFile *f)
639 640
{
    int ret;
641 642 643 644
    MigrationParams params = {
        .blk = 0,
        .shared = 0
    };
645

Luiz Capitulino's avatar
Luiz Capitulino committed
646
    if (qemu_savevm_state_blocked(NULL)) {
647
        return -EINVAL;
Alex Williamson's avatar
Alex Williamson committed
648 649
    }

650
    qemu_mutex_unlock_iothread();
651
    qemu_savevm_state_begin(f, &params);
652 653
    qemu_mutex_lock_iothread();

654 655 656 657 658
    while (qemu_file_get_error(f) == 0) {
        if (qemu_savevm_state_iterate(f) > 0) {
            break;
        }
    }
659

660
    ret = qemu_file_get_error(f);
661
    if (ret == 0) {
662
        qemu_savevm_state_complete(f);
663
        ret = qemu_file_get_error(f);
664
    }
665 666 667
    if (ret != 0) {
        qemu_savevm_state_cancel();
    }
668 669 670
    return ret;
}

671 672 673 674 675 676 677 678 679 680 681 682 683 684 685
static int qemu_save_device_state(QEMUFile *f)
{
    SaveStateEntry *se;

    qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
    qemu_put_be32(f, QEMU_VM_FILE_VERSION);

    cpu_synchronize_all_states();

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

        if (se->is_ram) {
            continue;
        }
686
        if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
            continue;
        }

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

        /* ID string */
        len = strlen(se->idstr);
        qemu_put_byte(f, len);
        qemu_put_buffer(f, (uint8_t *)se->idstr, len);

        qemu_put_be32(f, se->instance_id);
        qemu_put_be32(f, se->version_id);

        vmstate_save(f, se);
    }

    qemu_put_byte(f, QEMU_VM_EOF);

    return qemu_file_get_error(f);
}

710 711 712 713
static SaveStateEntry *find_se(const char *idstr, int instance_id)
{
    SaveStateEntry *se;

714
    QTAILQ_FOREACH(se, &savevm_handlers, entry) {
715
        if (!strcmp(se->idstr, idstr) &&
716 717
            (instance_id == se->instance_id ||
             instance_id == se->alias_id))
718
            return se;
719 720 721 722 723 724 725
        /* Migrating from an older version? */
        if (strstr(se->idstr, idstr) && se->compat) {
            if (!strcmp(se->compat->idstr, idstr) &&
                (instance_id == se->compat->instance_id ||
                 instance_id == se->alias_id))
                return se;
        }
726 727 728 729 730
    }
    return NULL;
}

typedef struct LoadStateEntry {
731
    QLIST_ENTRY(LoadStateEntry) entry;
732 733 734 735 736 737 738
    SaveStateEntry *se;
    int section_id;
    int version_id;
} LoadStateEntry;

int qemu_loadvm_state(QEMUFile *f)
{
739 740
    QLIST_HEAD(, LoadStateEntry) loadvm_handlers =
        QLIST_HEAD_INITIALIZER(loadvm_handlers);
741
    LoadStateEntry *le, *new_le;
742 743 744 745
    uint8_t section_type;
    unsigned int v;
    int ret;

Luiz Capitulino's avatar
Luiz Capitulino committed
746
    if (qemu_savevm_state_blocked(NULL)) {
Alex Williamson's avatar
Alex Williamson committed
747 748 749
        return -EINVAL;
    }

750
    v = qemu_get_be32(f);
751
    if (v != QEMU_VM_FILE_MAGIC) {
752
        return -EINVAL;
753
    }
754 755

    v = qemu_get_be32(f);
Juan Quintela's avatar
Juan Quintela committed
756 757 758 759
    if (v == QEMU_VM_FILE_VERSION_COMPAT) {
        fprintf(stderr, "SaveVM v2 format is obsolete and don't work anymore\n");
        return -ENOTSUP;
    }
760
    if (v != QEMU_VM_FILE_VERSION) {
761
        return -ENOTSUP;
762
    }
763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797

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

        switch (section_type) {
        case QEMU_VM_SECTION_START:
        case QEMU_VM_SECTION_FULL:
            /* Read section start */
            section_id = qemu_get_be32(f);
            len = qemu_get_byte(f);
            qemu_get_buffer(f, (uint8_t *)idstr, len);
            idstr[len] = 0;
            instance_id = qemu_get_be32(f);
            version_id = qemu_get_be32(f);

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

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

            /* Add entry */
798
            le = g_malloc0(sizeof(*le));
799 800 801 802

            le->se = se;
            le->section_id = section_id;
            le->version_id = version_id;
803
            QLIST_INSERT_HEAD(&loadvm_handlers, le, entry);
804

805
            ret = vmstate_load(f, le->se, le->version_id);
806 807 808 809 810
            if (ret < 0) {
                fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
                        instance_id, idstr);
                goto out;
            }
811 812 813 814 815
            break;
        case QEMU_VM_SECTION_PART:
        case QEMU_VM_SECTION_END:
            section_id = qemu_get_be32(f);

816
            QLIST_FOREACH(le, &loadvm_handlers, entry) {
817 818 819 820
                if (le->section_id == section_id) {
                    break;
                }
            }
821 822 823 824 825 826
            if (le == NULL) {
                fprintf(stderr, "Unknown savevm section %d\n", section_id);
                ret = -EINVAL;
                goto out;
            }

827
            ret = vmstate_load(f, le->se, le->version_id);
828 829 830 831 832
            if (ret < 0) {
                fprintf(stderr, "qemu: warning: error while loading state section id %d\n",
                        section_id);
                goto out;
            }
833 834 835 836 837 838 839 840
            break;
        default:
            fprintf(stderr, "Unknown savevm section type %d\n", section_type);
            ret = -EINVAL;
            goto out;
        }
    }

841 842
    cpu_synchronize_all_post_init();

843 844 845
    ret = 0;

out:
846 847
    QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
        QLIST_REMOVE(le, entry);
848
        g_free(le);
849 850
    }

851 852
    if (ret == 0) {
        ret = qemu_file_get_error(f);
853
    }
854 855 856 857

    return ret;
}

858 859 860 861 862 863 864 865 866 867 868
static BlockDriverState *find_vmstate_bs(void)
{
    BlockDriverState *bs = NULL;
    while ((bs = bdrv_next(bs))) {
        if (bdrv_can_snapshot(bs)) {
            return bs;
        }
    }
    return NULL;
}

869 870 871 872 873 874 875
/*
 * Deletes snapshots of a given name in all opened images.
 */
static int del_existing_snapshots(Monitor *mon, const char *name)
{
    BlockDriverState *bs;
    QEMUSnapshotInfo sn1, *snapshot = &sn1;
876
    Error *err = NULL;
877

878 879
    bs = NULL;
    while ((bs = bdrv_next(bs))) {
880
        if (bdrv_can_snapshot(bs) &&
881
            bdrv_snapshot_find(bs, snapshot, name) >= 0) {
882 883
            bdrv_snapshot_delete_by_id_or_name(bs, name, &err);
            if (error_is_set(&err)) {
884
                monitor_printf(mon,
885 886 887 888 889
                               "Error while deleting snapshot on device '%s':"
                               " %s\n",
                               bdrv_get_device_name(bs),
                               error_get_pretty(err));
                error_free(err);
890 891 892 893 894 895 896 897
                return -1;
            }
        }
    }

    return 0;
}

898
void do_savevm(Monitor *mon, const QDict *qdict)
899 900 901
{
    BlockDriverState *bs, *bs1;
    QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
902
    int ret;
903 904
    QEMUFile *f;
    int saved_vm_running;
Kevin Wolf's avatar
Kevin Wolf committed
905
    uint64_t vm_state_size;
906
    qemu_timeval tv;
907
    struct tm tm;
908
    const char *name = qdict_get_try_str(qdict, "name");
909

910
    /* Verify if there is a device that doesn't support snapshots and is writable */
911 912
    bs = NULL;
    while ((bs = bdrv_next(bs))) {
913

914
        if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
915 916 917 918 919 920 921 922 923 924
            continue;
        }

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

925
    bs = find_vmstate_bs();
926
    if (!bs) {
927
        monitor_printf(mon, "No block device can accept snapshots\n");
928 929 930
        return;
    }

931
    saved_vm_running = runstate_is_running();
932
    vm_stop(RUN_STATE_SAVE_VM);
933

934
    memset(sn, 0, sizeof(*sn));
935 936

    /* fill auxiliary fields */
937
    qemu_gettimeofday(&tv);
938 939
    sn->date_sec = tv.tv_sec;
    sn->date_nsec = tv.tv_usec * 1000;
940
    sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
941

942 943 944 945 946 947 948 949 950
    if (name) {
        ret = bdrv_snapshot_find(bs, old_sn, name);
        if (ret >= 0) {
            pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
            pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
        } else {
            pstrcpy(sn->name, sizeof(sn->name), name);
        }
    } else {
Blue Swirl's avatar
Blue Swirl committed
951 952
        /* cast below needed for OpenBSD where tv_sec is still 'long' */
        localtime_r((const time_t *)&tv.tv_sec, &tm);
953 954 955
        strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
    }

956
    /* Delete old snapshots of the same name */
957
    if (name && del_existing_snapshots(mon, name) < 0) {
958 959 960
        goto the_end;
    }

961
    /* save the VM state */
962
    f = qemu_fopen_bdrv(bs, 1);
963
    if (!f) {
964
        monitor_printf(mon, "Could not open VM state file\n");
965 966
        goto the_end;
    }
Luiz Capitulino's avatar
Luiz Capitulino committed
967
    ret = qemu_savevm_state(f);
968
    vm_state_size = qemu_ftell(f);
969 970
    qemu_fclose(f);
    if (ret < 0) {
971
        monitor_printf(mon, "Error %d while writing VM\n", ret);
972 973 974 975 976
        goto the_end;
    }

    /* create the snapshots */

977 978
    bs1 = NULL;
    while ((bs1 = bdrv_next(bs1))) {
979
        if (bdrv_can_snapshot(bs1)) {
980 981
            /* Write VM state size only to the image that contains the state */
            sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
982 983
            ret = bdrv_snapshot_create(bs1, sn);
            if (ret < 0) {
984 985
                monitor_printf(mon, "Error while creating snapshot on '%s'\n",
                               bdrv_get_device_name(bs1));
986 987 988 989 990
            }
        }
    }

 the_end:
991
    if (saved_vm_running) {
992
        vm_start();
993
    }
994 995
}

996 997 998 999 1000 1001 1002 1003 1004 1005 1006
void qmp_xen_save_devices_state(const char *filename, Error **errp)
{
    QEMUFile *f;
    int saved_vm_running;
    int ret;

    saved_vm_running = runstate_is_running();
    vm_stop(RUN_STATE_SAVE_VM);

    f = qemu_fopen(filename, "wb");
    if (!f) {
1007
        error_setg_file_open(errp, errno, filename);
1008 1009 1010 1011 1012 1013 1014 1015 1016
        goto the_end;
    }
    ret = qemu_save_device_state(f);
    qemu_fclose(f);
    if (ret < 0) {
        error_set(errp, QERR_IO_ERROR);
    }

 the_end:
1017
    if (saved_vm_running) {
1018
        vm_start();
1019
    }
1020 1021
}

1022
int load_vmstate(const char *name)
1023
{
1024
    BlockDriverState *bs, *bs_vm_state;
1025
    QEMUSnapshotInfo sn;
1026
    QEMUFile *f;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
1027
    int ret;
1028

1029
    bs_vm_state = find_vmstate_bs();
1030 1031 1032 1033 1034 1035 1036 1037 1038 1039
    if (!bs_vm_state) {
        error_report("No block device supports snapshots");
        return -ENOTSUP;
    }

    /* Don't even try to load empty VM states */
    ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
    if (ret < 0) {
        return ret;
    } else if (sn.vm_state_size == 0) {
1040 1041
        error_report("This is a disk-only snapshot. Revert to it offline "
            "using qemu-img.");
1042 1043 1044 1045 1046
        return -EINVAL;
    }

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

1050
        if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
1051 1052 1053 1054 1055 1056 1057 1058 1059
            continue;
        }

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

1060 1061 1062 1063 1064 1065
        ret = bdrv_snapshot_find(bs, &sn, name);
        if (ret < 0) {
            error_report("Device '%s' does not have the requested snapshot '%s'",
                           bdrv_get_device_name(bs), name);
            return ret;
        }
1066 1067 1068
    }

    /* Flush all IO requests so they don't interfere with the new state.  */
1069
    bdrv_drain_all();
1070

1071 1072 1073 1074
    bs = NULL;
    while ((bs = bdrv_next(bs))) {
        if (bdrv_can_snapshot(bs)) {
            ret = bdrv_snapshot_goto(bs, name);
1075
            if (ret < 0) {
1076 1077 1078
                error_report("Error %d while activating snapshot '%s' on '%s'",
                             ret, name, bdrv_get_device_name(bs));
                return ret;
1079 1080 1081 1082 1083
            }
        }
    }

    /* restore the VM state */
1084
    f = qemu_fopen_bdrv(bs_vm_state, 0);
1085
    if (!f) {
1086
        error_report("Could not open VM state file");
1087
        return -EINVAL;
1088
    }
1089

Jan Kiszka's avatar
Jan Kiszka committed
1090
    qemu_system_reset(VMRESET_SILENT);
1091
    ret = qemu_loadvm_state(f);
1092

1093 1094
    qemu_fclose(f);
    if (ret < 0) {
1095
        error_report("Error %d while loading VM state", ret);
1096
        return ret;
1097
    }
1098

1099
    return 0;
1100 1101
}

1102
void do_delvm(Monitor *mon, const QDict *qdict)
1103 1104
{
    BlockDriverState *bs, *bs1;
1105
    Error *err = NULL;
1106
    const char *name = qdict_get_str(qdict, "name");
1107

1108
    bs = find_vmstate_bs();
1109
    if (!bs) {
1110
        monitor_printf(mon, "No block device supports snapshots\n");
1111 1112 1113
        return;
    }

1114 1115
    bs1 = NULL;
    while ((bs1 = bdrv_next(bs1))) {
1116
        if (bdrv_can_snapshot(bs1)) {
1117 1118 1119 1120 1121 1122 1123 1124
            bdrv_snapshot_delete_by_id_or_name(bs, name, &err);
            if (error_is_set(&err)) {
                monitor_printf(mon,
                               "Error while deleting snapshot on device '%s':"
                               " %s\n",
                               bdrv_get_device_name(bs),
                               error_get_pretty(err));
                error_free(err);
1125 1126 1127 1128 1129
            }
        }
    }
}

1130
void do_info_snapshots(Monitor *mon, const QDict *qdict)
1131 1132
{
    BlockDriverState *bs, *bs1;
1133 1134 1135 1136
    QEMUSnapshotInfo *sn_tab, *sn, s, *sn_info = &s;
    int nb_sns, i, ret, available;
    int total;
    int *available_snapshots;
1137

1138
    bs = find_vmstate_bs();
1139
    if (!bs) {
1140
        monitor_printf(mon, "No available block device supports snapshots\n");
1141 1142 1143 1144 1145
        return;
    }

    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
    if (nb_sns < 0) {
1146
        monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
1147 1148
        return;
    }
1149 1150 1151 1152 1153 1154

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

1155
    available_snapshots = g_malloc0(sizeof(int) * nb_sns);
1156 1157
    total = 0;
    for (i = 0; i < nb_sns; i++) {
1158
        sn = &sn_tab[i];
1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
        available = 1;
        bs1 = NULL;

        while ((bs1 = bdrv_next(bs1))) {
            if (bdrv_can_snapshot(bs1) && bs1 != bs) {
                ret = bdrv_snapshot_find(bs1, sn_info, sn->id_str);
                if (ret < 0) {
                    available = 0;
                    break;
                }
            }
        }

        if (available) {
            available_snapshots[total] = i;
            total++;
        }
1176
    }
1177 1178

    if (total > 0) {
1179 1180
        bdrv_snapshot_dump((fprintf_function)monitor_printf, mon, NULL);
        monitor_printf(mon, "\n");
1181 1182
        for (i = 0; i < total; i++) {
            sn = &sn_tab[available_snapshots[i]];
1183 1184
            bdrv_snapshot_dump((fprintf_function)monitor_printf, mon, sn);
            monitor_printf(mon, "\n");
1185 1186 1187 1188 1189
        }
    } else {
        monitor_printf(mon, "There is no suitable snapshot available\n");
    }

1190 1191
    g_free(sn_tab);
    g_free(available_snapshots);
1192

1193
}
1194 1195 1196

void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
{
1197
    qemu_ram_set_idstr(memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK,
1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
                       memory_region_name(mr), dev);
}

void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev)
{
    /* Nothing do to while the implementation is in RAMBlock */
}

void vmstate_register_ram_global(MemoryRegion *mr)
{
    vmstate_register_ram(mr, NULL);
}