savevm.c 64.9 KB
Newer Older
aliguori's avatar
aliguori committed
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/bitops.h"
42
#include "qemu/iov.h"
43
#include "block/snapshot.h"
44
#include "block/qapi.h"
45

aliguori's avatar
aliguori committed
46 47
#define SELF_ANNOUNCE_ROUNDS 5

Nolan's avatar
Nolan committed
48
#ifndef ETH_P_RARP
Stefan Berger's avatar
Stefan Berger committed
49
#define ETH_P_RARP 0x8035
Nolan's avatar
Nolan committed
50 51 52 53 54 55
#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,
aliguori's avatar
aliguori committed
56 57
				uint8_t *mac_addr)
{
Nolan's avatar
Nolan committed
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
    /* 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) */
aliguori's avatar
aliguori committed
78 79
}

80
static void qemu_announce_self_iter(NICState *nic, void *opaque)
aliguori's avatar
aliguori committed
81
{
Nolan's avatar
Nolan committed
82
    uint8_t buf[60];
83 84 85 86
    int len;

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

Jason Wang's avatar
Jason Wang committed
87
    qemu_send_packet_raw(qemu_get_queue(nic), buf, len);
88 89 90 91 92
}


static void qemu_announce_self_once(void *opaque)
{
93 94
    static int count = SELF_ANNOUNCE_ROUNDS;
    QEMUTimer *timer = *(QEMUTimer **)opaque;
aliguori's avatar
aliguori committed
95

96 97
    qemu_foreach_nic(qemu_announce_self_iter, NULL);

Nolan's avatar
Nolan committed
98 99
    if (--count) {
        /* delay 50ms, 150ms, 250ms, ... */
100
        qemu_mod_timer(timer, qemu_get_clock_ms(rt_clock) +
Nolan's avatar
Nolan committed
101
                       50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100);
102 103 104 105 106 107 108 109 110
    } else {
	    qemu_del_timer(timer);
	    qemu_free_timer(timer);
    }
}

void qemu_announce_self(void)
{
	static QEMUTimer *timer;
111
	timer = qemu_new_timer_ms(rt_clock, qemu_announce_self_once, &timer);
112
	qemu_announce_self_once(&timer);
aliguori's avatar
aliguori committed
113 114 115 116 117 118
}

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

#define IO_BUF_SIZE 32768
119
#define MAX_IOV_SIZE MIN(IOV_MAX, 64)
aliguori's avatar
aliguori committed
120 121

struct QEMUFile {
122
    const QEMUFileOps *ops;
aliguori's avatar
aliguori committed
123 124
    void *opaque;

125 126 127
    int64_t bytes_xfer;
    int64_t xfer_limit;

128 129
    int64_t pos; /* start of buffer when writing, end of buffer
                    when reading */
aliguori's avatar
aliguori committed
130 131 132 133
    int buf_index;
    int buf_size; /* 0 when writing */
    uint8_t buf[IO_BUF_SIZE];

134 135 136
    struct iovec iov[MAX_IOV_SIZE];
    unsigned int iovcnt;

137
    int last_error;
aliguori's avatar
aliguori committed
138 139
};

140
typedef struct QEMUFileStdio
aliguori's avatar
aliguori committed
141
{
142
    FILE *stdio_file;
aliguori's avatar
aliguori committed
143
    QEMUFile *file;
144
} QEMUFileStdio;
aliguori's avatar
aliguori committed
145 146 147 148 149 150 151

typedef struct QEMUFileSocket
{
    int fd;
    QEMUFile *file;
} QEMUFileSocket;

152 153
static ssize_t socket_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
                                    int64_t pos)
154 155 156 157 158 159 160 161 162 163 164 165
{
    QEMUFileSocket *s = opaque;
    ssize_t len;
    ssize_t size = iov_size(iov, iovcnt);

    len = iov_send(s->fd, iov, iovcnt, 0, size);
    if (len < size) {
        len = -socket_error();
    }
    return len;
}

Paolo Bonzini's avatar
Paolo Bonzini committed
166 167 168 169 170 171 172
static int socket_get_fd(void *opaque)
{
    QEMUFileSocket *s = opaque;

    return s->fd;
}

aliguori's avatar
aliguori committed
173 174 175 176 177
static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
{
    QEMUFileSocket *s = opaque;
    ssize_t len;

178
    for (;;) {
Blue Swirl's avatar
Blue Swirl committed
179
        len = qemu_recv(s->fd, buf, size, 0);
180 181 182 183
        if (len != -1) {
            break;
        }
        if (socket_error() == EAGAIN) {
184
            yield_until_fd_readable(s->fd);
185 186 187 188
        } else if (socket_error() != EINTR) {
            break;
        }
    }
aliguori's avatar
aliguori committed
189

190
    if (len == -1) {
aliguori's avatar
aliguori committed
191
        len = -socket_error();
192
    }
aliguori's avatar
aliguori committed
193 194 195 196 197 198
    return len;
}

static int socket_close(void *opaque)
{
    QEMUFileSocket *s = opaque;
199
    closesocket(s->fd);
200
    g_free(s);
aliguori's avatar
aliguori committed
201 202 203
    return 0;
}

Paolo Bonzini's avatar
Paolo Bonzini committed
204 205 206 207 208 209 210
static int stdio_get_fd(void *opaque)
{
    QEMUFileStdio *s = opaque;

    return fileno(s->stdio_file);
}

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

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

223
    for (;;) {
224 225
        clearerr(fp);
        bytes = fread(buf, 1, size, fp);
226 227 228 229
        if (bytes != 0 || !ferror(fp)) {
            break;
        }
        if (errno == EAGAIN) {
230
            yield_until_fd_readable(fileno(fp));
231 232 233 234
        } else if (errno != EINTR) {
            break;
        }
    }
235
    return bytes;
aliguori's avatar
aliguori committed
236 237
}

238 239 240
static int stdio_pclose(void *opaque)
{
    QEMUFileStdio *s = opaque;
241 242
    int ret;
    ret = pclose(s->stdio_file);
243 244
    if (ret == -1) {
        ret = -errno;
245 246 247
    } else if (!WIFEXITED(ret) || WEXITSTATUS(ret) != 0) {
        /* close succeeded, but non-zero exit code: */
        ret = -EIO; /* fake errno value */
248
    }
249
    g_free(s);
250
    return ret;
251 252 253
}

static int stdio_fclose(void *opaque)
aliguori's avatar
aliguori committed
254
{
255
    QEMUFileStdio *s = opaque;
256
    int ret = 0;
257

Orit Wasserman's avatar
Orit Wasserman committed
258
    if (s->file->ops->put_buffer || s->file->ops->writev_buffer) {
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
        int fd = fileno(s->stdio_file);
        struct stat st;

        ret = fstat(fd, &st);
        if (ret == 0 && S_ISREG(st.st_mode)) {
            /*
             * If the file handle is a regular file make sure the
             * data is flushed to disk before signaling success.
             */
            ret = fsync(fd);
            if (ret != 0) {
                ret = -errno;
                return ret;
            }
        }
    }
275 276 277
    if (fclose(s->stdio_file) == EOF) {
        ret = -errno;
    }
278
    g_free(s);
279
    return ret;
aliguori's avatar
aliguori committed
280 281
}

282
static const QEMUFileOps stdio_pipe_read_ops = {
Paolo Bonzini's avatar
Paolo Bonzini committed
283
    .get_fd =     stdio_get_fd,
284 285 286 287 288
    .get_buffer = stdio_get_buffer,
    .close =      stdio_pclose
};

static const QEMUFileOps stdio_pipe_write_ops = {
Paolo Bonzini's avatar
Paolo Bonzini committed
289
    .get_fd =     stdio_get_fd,
290 291 292 293
    .put_buffer = stdio_put_buffer,
    .close =      stdio_pclose
};

294
QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
aliguori's avatar
aliguori committed
295
{
296
    FILE *stdio_file;
297
    QEMUFileStdio *s;
aliguori's avatar
aliguori committed
298

299 300
    if (mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
        fprintf(stderr, "qemu_popen: Argument validity check failed\n");
301 302 303
        return NULL;
    }

304 305
    stdio_file = popen(command, mode);
    if (stdio_file == NULL) {
aliguori's avatar
aliguori committed
306 307 308
        return NULL;
    }

309
    s = g_malloc0(sizeof(QEMUFileStdio));
aliguori's avatar
aliguori committed
310

311
    s->stdio_file = stdio_file;
aliguori's avatar
aliguori committed
312 313

    if(mode[0] == 'r') {
314
        s->file = qemu_fopen_ops(s, &stdio_pipe_read_ops);
aliguori's avatar
aliguori committed
315
    } else {
316
        s->file = qemu_fopen_ops(s, &stdio_pipe_write_ops);
aliguori's avatar
aliguori committed
317 318 319 320
    }
    return s->file;
}

321
static const QEMUFileOps stdio_file_read_ops = {
Paolo Bonzini's avatar
Paolo Bonzini committed
322
    .get_fd =     stdio_get_fd,
323 324 325 326 327
    .get_buffer = stdio_get_buffer,
    .close =      stdio_fclose
};

static const QEMUFileOps stdio_file_write_ops = {
Paolo Bonzini's avatar
Paolo Bonzini committed
328
    .get_fd =     stdio_get_fd,
329 330 331 332
    .put_buffer = stdio_put_buffer,
    .close =      stdio_fclose
};

333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
static ssize_t unix_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
                                  int64_t pos)
{
    QEMUFileSocket *s = opaque;
    ssize_t len, offset;
    ssize_t size = iov_size(iov, iovcnt);
    ssize_t total = 0;

    assert(iovcnt > 0);
    offset = 0;
    while (size > 0) {
        /* Find the next start position; skip all full-sized vector elements  */
        while (offset >= iov[0].iov_len) {
            offset -= iov[0].iov_len;
            iov++, iovcnt--;
        }

        /* skip `offset' bytes from the (now) first element, undo it on exit */
        assert(iovcnt > 0);
        iov[0].iov_base += offset;
        iov[0].iov_len -= offset;

        do {
            len = writev(s->fd, iov, iovcnt);
        } while (len == -1 && errno == EINTR);
        if (len == -1) {
            return -errno;
        }

        /* Undo the changes above */
        iov[0].iov_base -= offset;
        iov[0].iov_len += offset;

        /* Prepare for the next iteration */
        offset += len;
        total += len;
        size -= len;
    }

    return total;
}

static int unix_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
{
    QEMUFileSocket *s = opaque;
    ssize_t len;

    for (;;) {
        len = read(s->fd, buf, size);
        if (len != -1) {
            break;
        }
        if (errno == EAGAIN) {
            yield_until_fd_readable(s->fd);
        } else if (errno != EINTR) {
            break;
        }
    }

    if (len == -1) {
        len = -errno;
    }
    return len;
}

static int unix_close(void *opaque)
{
    QEMUFileSocket *s = opaque;
    close(s->fd);
    g_free(s);
    return 0;
}

static const QEMUFileOps unix_read_ops = {
    .get_fd =     socket_get_fd,
    .get_buffer = unix_get_buffer,
    .close =      unix_close
};

static const QEMUFileOps unix_write_ops = {
    .get_fd =     socket_get_fd,
    .writev_buffer = unix_writev_buffer,
    .close =      unix_close
};

Paolo Bonzini's avatar
Paolo Bonzini committed
418 419
QEMUFile *qemu_fdopen(int fd, const char *mode)
{
420
    QEMUFileSocket *s;
Paolo Bonzini's avatar
Paolo Bonzini committed
421 422 423 424 425 426 427 428

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

429 430
    s = g_malloc0(sizeof(QEMUFileSocket));
    s->fd = fd;
Paolo Bonzini's avatar
Paolo Bonzini committed
431 432

    if(mode[0] == 'r') {
433
        s->file = qemu_fopen_ops(s, &unix_read_ops);
Paolo Bonzini's avatar
Paolo Bonzini committed
434
    } else {
435
        s->file = qemu_fopen_ops(s, &unix_write_ops);
Paolo Bonzini's avatar
Paolo Bonzini committed
436 437 438 439
    }
    return s->file;
}

440
static const QEMUFileOps socket_read_ops = {
Paolo Bonzini's avatar
Paolo Bonzini committed
441
    .get_fd =     socket_get_fd,
442 443 444 445
    .get_buffer = socket_get_buffer,
    .close =      socket_close
};

446 447
static const QEMUFileOps socket_write_ops = {
    .get_fd =     socket_get_fd,
448
    .writev_buffer = socket_writev_buffer,
449 450 451
    .close =      socket_close
};

452
bool qemu_file_mode_is_not_valid(const char *mode)
aliguori's avatar
aliguori committed
453
{
454 455 456 457
    if (mode == NULL ||
        (mode[0] != 'r' && mode[0] != 'w') ||
        mode[1] != 'b' || mode[2] != 0) {
        fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
458 459 460 461 462 463 464 465 466 467 468
        return true;
    }

    return false;
}

QEMUFile *qemu_fopen_socket(int fd, const char *mode)
{
    QEMUFileSocket *s;

    if (qemu_file_mode_is_not_valid(mode)) {
469 470 471
        return NULL;
    }

472
    s = g_malloc0(sizeof(QEMUFileSocket));
aliguori's avatar
aliguori committed
473
    s->fd = fd;
474
    if (mode[0] == 'w') {
475
        qemu_set_block(s->fd);
476 477 478 479
        s->file = qemu_fopen_ops(s, &socket_write_ops);
    } else {
        s->file = qemu_fopen_ops(s, &socket_read_ops);
    }
aliguori's avatar
aliguori committed
480 481 482 483 484 485 486
    return s->file;
}

QEMUFile *qemu_fopen(const char *filename, const char *mode)
{
    QEMUFileStdio *s;

487
    if (qemu_file_mode_is_not_valid(mode)) {
488 489 490
        return NULL;
    }

491
    s = g_malloc0(sizeof(QEMUFileStdio));
aliguori's avatar
aliguori committed
492

493 494
    s->stdio_file = fopen(filename, mode);
    if (!s->stdio_file)
aliguori's avatar
aliguori committed
495
        goto fail;
lirans@il.ibm.com's avatar
lirans@il.ibm.com committed
496
    
497
    if(mode[0] == 'w') {
498
        s->file = qemu_fopen_ops(s, &stdio_file_write_ops);
499
    } else {
500
        s->file = qemu_fopen_ops(s, &stdio_file_read_ops);
501 502
    }
    return s->file;
aliguori's avatar
aliguori committed
503
fail:
504
    g_free(s);
aliguori's avatar
aliguori committed
505 506 507
    return NULL;
}

508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
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;
}

523
static int block_put_buffer(void *opaque, const uint8_t *buf,
aliguori's avatar
aliguori committed
524 525
                           int64_t pos, int size)
{
526
    bdrv_save_vmstate(opaque, buf, pos, size);
aliguori's avatar
aliguori committed
527 528 529
    return size;
}

530
static int block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
aliguori's avatar
aliguori committed
531
{
532
    return bdrv_load_vmstate(opaque, buf, pos, size);
aliguori's avatar
aliguori committed
533 534 535 536
}

static int bdrv_fclose(void *opaque)
{
537
    return bdrv_flush(opaque);
aliguori's avatar
aliguori committed
538 539
}

540 541 542 543 544 545
static const QEMUFileOps bdrv_read_ops = {
    .get_buffer = block_get_buffer,
    .close =      bdrv_fclose
};

static const QEMUFileOps bdrv_write_ops = {
546 547 548
    .put_buffer     = block_put_buffer,
    .writev_buffer  = block_writev_buffer,
    .close          = bdrv_fclose
549 550
};

551
static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
aliguori's avatar
aliguori committed
552 553
{
    if (is_writable)
554 555
        return qemu_fopen_ops(bs, &bdrv_write_ops);
    return qemu_fopen_ops(bs, &bdrv_read_ops);
aliguori's avatar
aliguori committed
556 557
}

558
QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)
aliguori's avatar
aliguori committed
559 560 561
{
    QEMUFile *f;

562
    f = g_malloc0(sizeof(QEMUFile));
aliguori's avatar
aliguori committed
563 564

    f->opaque = opaque;
565
    f->ops = ops;
aliguori's avatar
aliguori committed
566 567 568
    return f;
}

569
int qemu_file_get_error(QEMUFile *f)
aliguori's avatar
aliguori committed
570
{
571
    return f->last_error;
aliguori's avatar
aliguori committed
572 573
}

574
static void qemu_file_set_error(QEMUFile *f, int ret)
575
{
576 577 578
    if (f->last_error == 0) {
        f->last_error = ret;
    }
579 580
}

581 582 583 584 585
static inline bool qemu_file_is_writable(QEMUFile *f)
{
    return f->ops->writev_buffer || f->ops->put_buffer;
}

Orit Wasserman's avatar
Orit Wasserman committed
586 587
/**
 * Flushes QEMUFile buffer
588
 *
Orit Wasserman's avatar
Orit Wasserman committed
589 590
 * If there is writev_buffer QEMUFileOps it uses it otherwise uses
 * put_buffer ops.
591
 */
Michael R. Hines's avatar
Michael R. Hines committed
592
void qemu_fflush(QEMUFile *f)
aliguori's avatar
aliguori committed
593
{
Orit Wasserman's avatar
Orit Wasserman committed
594
    ssize_t ret = 0;
595

596
    if (!qemu_file_is_writable(f)) {
597 598
        return;
    }
Orit Wasserman's avatar
Orit Wasserman committed
599

600 601
    if (f->ops->writev_buffer) {
        if (f->iovcnt > 0) {
602
            ret = f->ops->writev_buffer(f->opaque, f->iov, f->iovcnt, f->pos);
603
        }
604 605 606
    } else {
        if (f->buf_index > 0) {
            ret = f->ops->put_buffer(f->opaque, f->buf, f->pos, f->buf_index);
607
        }
aliguori's avatar
aliguori committed
608
    }
609 610 611 612 613
    if (ret >= 0) {
        f->pos += ret;
    }
    f->buf_index = 0;
    f->iovcnt = 0;
614 615 616
    if (ret < 0) {
        qemu_file_set_error(f, ret);
    }
aliguori's avatar
aliguori committed
617 618
}

Michael R. Hines's avatar
Michael R. Hines committed
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664
void ram_control_before_iterate(QEMUFile *f, uint64_t flags)
{
    int ret = 0;

    if (f->ops->before_ram_iterate) {
        ret = f->ops->before_ram_iterate(f, f->opaque, flags);
        if (ret < 0) {
            qemu_file_set_error(f, ret);
        }
    }
}

void ram_control_after_iterate(QEMUFile *f, uint64_t flags)
{
    int ret = 0;

    if (f->ops->after_ram_iterate) {
        ret = f->ops->after_ram_iterate(f, f->opaque, flags);
        if (ret < 0) {
            qemu_file_set_error(f, ret);
        }
    }
}

void ram_control_load_hook(QEMUFile *f, uint64_t flags)
{
    int ret = 0;

    if (f->ops->hook_ram_load) {
        ret = f->ops->hook_ram_load(f, f->opaque, flags);
        if (ret < 0) {
            qemu_file_set_error(f, ret);
        }
    } else {
        qemu_file_set_error(f, ret);
    }
}

size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset,
                         ram_addr_t offset, size_t size, int *bytes_sent)
{
    if (f->ops->save_page) {
        int ret = f->ops->save_page(f, f->opaque, block_offset,
                                    offset, size, bytes_sent);

        if (ret != RAM_SAVE_CONTROL_DELAYED) {
665
            if (bytes_sent && *bytes_sent > 0) {
Michael R. Hines's avatar
Michael R. Hines committed
666 667 668 669 670 671 672 673 674 675 676 677
                qemu_update_position(f, *bytes_sent);
            } else if (ret < 0) {
                qemu_file_set_error(f, ret);
            }
        }

        return ret;
    }

    return RAM_SAVE_CONTROL_NOT_SUPP;
}

aliguori's avatar
aliguori committed
678 679 680
static void qemu_fill_buffer(QEMUFile *f)
{
    int len;
681
    int pending;
aliguori's avatar
aliguori committed
682

683
    assert(!qemu_file_is_writable(f));
aliguori's avatar
aliguori committed
684

685 686 687 688 689 690 691
    pending = f->buf_size - f->buf_index;
    if (pending > 0) {
        memmove(f->buf, f->buf + f->buf_index, pending);
    }
    f->buf_index = 0;
    f->buf_size = pending;

692
    len = f->ops->get_buffer(f->opaque, f->buf + pending, f->pos,
693
                        IO_BUF_SIZE - pending);
aliguori's avatar
aliguori committed
694
    if (len > 0) {
695
        f->buf_size += len;
696
        f->pos += len;
697
    } else if (len == 0) {
698
        qemu_file_set_error(f, -EIO);
aliguori's avatar
aliguori committed
699
    } else if (len != -EAGAIN)
700
        qemu_file_set_error(f, len);
aliguori's avatar
aliguori committed
701 702
}

Paolo Bonzini's avatar
Paolo Bonzini committed
703 704 705 706 707 708 709 710
int qemu_get_fd(QEMUFile *f)
{
    if (f->ops->get_fd) {
        return f->ops->get_fd(f->opaque);
    }
    return -1;
}

711 712 713 714 715
void qemu_update_position(QEMUFile *f, size_t size)
{
    f->pos += size;
}

716 717 718 719 720 721 722 723 724 725
/** Closes the file
 *
 * Returns negative error value if any error happened on previous operations or
 * while closing the file. Returns 0 or positive number on success.
 *
 * The meaning of return value on success depends on the specific backend
 * being used.
 */
int qemu_fclose(QEMUFile *f)
{
726
    int ret;
727 728
    qemu_fflush(f);
    ret = qemu_file_get_error(f);
729

730 731
    if (f->ops->close) {
        int ret2 = f->ops->close(f->opaque);
732 733 734
        if (ret >= 0) {
            ret = ret2;
        }
735
    }
736 737 738 739 740 741
    /* If any error was spotted before closing, we should report it
     * instead of the close() return value.
     */
    if (f->last_error) {
        ret = f->last_error;
    }
742
    g_free(f);
aliguori's avatar
aliguori committed
743 744 745
    return ret;
}

746 747 748 749 750 751 752 753 754 755
static void add_to_iovec(QEMUFile *f, const uint8_t *buf, int size)
{
    /* check for adjacent buffer and coalesce them */
    if (f->iovcnt > 0 && buf == f->iov[f->iovcnt - 1].iov_base +
        f->iov[f->iovcnt - 1].iov_len) {
        f->iov[f->iovcnt - 1].iov_len += size;
    } else {
        f->iov[f->iovcnt].iov_base = (uint8_t *)buf;
        f->iov[f->iovcnt++].iov_len = size;
    }
756

757
    if (f->iovcnt >= MAX_IOV_SIZE) {
758 759
        qemu_fflush(f);
    }
760 761
}

Orit Wasserman's avatar
Orit Wasserman committed
762 763
void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, int size)
{
764 765 766 767 768
    if (!f->ops->writev_buffer) {
        qemu_put_buffer(f, buf, size);
        return;
    }

Orit Wasserman's avatar
Orit Wasserman committed
769 770 771 772 773
    if (f->last_error) {
        return;
    }

    f->bytes_xfer += size;
774
    add_to_iovec(f, buf, size);
Orit Wasserman's avatar
Orit Wasserman committed
775 776
}

aliguori's avatar
aliguori committed
777 778 779 780
void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
{
    int l;

781 782 783 784 785
    if (f->last_error) {
        return;
    }

    while (size > 0) {
aliguori's avatar
aliguori committed
786 787 788 789
        l = IO_BUF_SIZE - f->buf_index;
        if (l > size)
            l = size;
        memcpy(f->buf + f->buf_index, buf, l);
790 791 792
        f->bytes_xfer += size;
        if (f->ops->writev_buffer) {
            add_to_iovec(f, f->buf + f->buf_index, l);
793 794 795 796
        }
        f->buf_index += l;
        if (f->buf_index == IO_BUF_SIZE) {
            qemu_fflush(f);
797
        }
Orit Wasserman's avatar
Orit Wasserman committed
798 799 800
        if (qemu_file_get_error(f)) {
            break;
        }
aliguori's avatar
aliguori committed
801 802 803 804 805 806 807
        buf += l;
        size -= l;
    }
}

void qemu_put_byte(QEMUFile *f, int v)
{
808 809 810 811
    if (f->last_error) {
        return;
    }

812
    f->buf[f->buf_index] = v;
813
    f->bytes_xfer++;
814 815
    if (f->ops->writev_buffer) {
        add_to_iovec(f, f->buf + f->buf_index, 1);
816 817 818 819
    }
    f->buf_index++;
    if (f->buf_index == IO_BUF_SIZE) {
        qemu_fflush(f);
820
    }
aliguori's avatar
aliguori committed
821 822
}

823
static void qemu_file_skip(QEMUFile *f, int size)
aliguori's avatar
aliguori committed
824
{
825 826 827 828 829 830
    if (f->buf_index + size <= f->buf_size) {
        f->buf_index += size;
    }
}

static int qemu_peek_buffer(QEMUFile *f, uint8_t *buf, int size, size_t offset)
aliguori's avatar
aliguori committed
831
{
832 833
    int pending;
    int index;
aliguori's avatar
aliguori committed
834

835
    assert(!qemu_file_is_writable(f));
aliguori's avatar
aliguori committed
836

837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866
    index = f->buf_index + offset;
    pending = f->buf_size - index;
    if (pending < size) {
        qemu_fill_buffer(f);
        index = f->buf_index + offset;
        pending = f->buf_size - index;
    }

    if (pending <= 0) {
        return 0;
    }
    if (size > pending) {
        size = pending;
    }

    memcpy(buf, f->buf + index, size);
    return size;
}

int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
{
    int pending = size;
    int done = 0;

    while (pending > 0) {
        int res;

        res = qemu_peek_buffer(f, buf, pending, 0);
        if (res == 0) {
            return done;
aliguori's avatar
aliguori committed
867
        }
868 869 870 871
        qemu_file_skip(f, res);
        buf += res;
        pending -= res;
        done += res;
aliguori's avatar
aliguori committed
872
    }
873
    return done;
aliguori's avatar
aliguori committed
874 875
}

876
static int qemu_peek_byte(QEMUFile *f, int offset)
Juan Quintela's avatar
Juan Quintela committed
877
{
878 879
    int index = f->buf_index + offset;

880
    assert(!qemu_file_is_writable(f));
Juan Quintela's avatar
Juan Quintela committed
881

882
    if (index >= f->buf_size) {
Juan Quintela's avatar
Juan Quintela committed
883
        qemu_fill_buffer(f);
884 885
        index = f->buf_index + offset;
        if (index >= f->buf_size) {
Juan Quintela's avatar
Juan Quintela committed
886
            return 0;
887
        }
Juan Quintela's avatar
Juan Quintela committed
888
    }
889
    return f->buf[index];
Juan Quintela's avatar
Juan Quintela committed
890 891
}

aliguori's avatar
aliguori committed
892 893
int qemu_get_byte(QEMUFile *f)
{
894
    int result;
aliguori's avatar
aliguori committed
895

896 897
    result = qemu_peek_byte(f, 0);
    qemu_file_skip(f, 1);
898
    return result;
aliguori's avatar
aliguori committed
899 900
}

901
int64_t qemu_ftell(QEMUFile *f)
aliguori's avatar
aliguori committed
902
{
903 904
    qemu_fflush(f);
    return f->pos;
aliguori's avatar
aliguori committed
905 906 907 908
}

int qemu_file_rate_limit(QEMUFile *f)
{
909 910 911 912 913 914
    if (qemu_file_get_error(f)) {
        return 1;
    }
    if (f->xfer_limit > 0 && f->bytes_xfer > f->xfer_limit) {
        return 1;
    }
aliguori's avatar
aliguori committed
915 916 917
    return 0;
}

918
int64_t qemu_file_get_rate_limit(QEMUFile *f)
lirans@il.ibm.com's avatar
lirans@il.ibm.com committed
919
{
920
    return f->xfer_limit;
lirans@il.ibm.com's avatar
lirans@il.ibm.com committed
921 922
}

923
void qemu_file_set_rate_limit(QEMUFile *f, int64_t limit)
924
{
925 926
    f->xfer_limit = limit;
}
927

928 929 930
void qemu_file_reset_rate_limit(QEMUFile *f)
{
    f->bytes_xfer = 0;
931 932
}

aliguori's avatar
aliguori committed
933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978
void qemu_put_be16(QEMUFile *f, unsigned int v)
{
    qemu_put_byte(f, v >> 8);
    qemu_put_byte(f, v);
}

void qemu_put_be32(QEMUFile *f, unsigned int v)
{
    qemu_put_byte(f, v >> 24);
    qemu_put_byte(f, v >> 16);
    qemu_put_byte(f, v >> 8);
    qemu_put_byte(f, v);
}

void qemu_put_be64(QEMUFile *f, uint64_t v)
{
    qemu_put_be32(f, v >> 32);
    qemu_put_be32(f, v);
}

unsigned int qemu_get_be16(QEMUFile *f)
{
    unsigned int v;
    v = qemu_get_byte(f) << 8;
    v |= qemu_get_byte(f);
    return v;
}

unsigned int qemu_get_be32(QEMUFile *f)
{
    unsigned int v;
    v = qemu_get_byte(f) << 24;
    v |= qemu_get_byte(f) << 16;
    v |= qemu_get_byte(f) << 8;
    v |= qemu_get_byte(f);
    return v;
}

uint64_t qemu_get_be64(QEMUFile *f)
{
    uint64_t v;
    v = (uint64_t)qemu_get_be32(f) << 32;
    v |= qemu_get_be32(f);
    return v;
}

979 980 981

/* timer */

982
void timer_put(QEMUFile *f, QEMUTimer *ts)
983 984 985
{
    uint64_t expire_time;

986
    expire_time = timer_expire_time_ns(ts);
987 988 989
    qemu_put_be64(f, expire_time);
}

990
void timer_get(QEMUFile *f, QEMUTimer *ts)
991 992 993 994 995 996 997 998 999 1000 1001 1002
{
    uint64_t expire_time;

    expire_time = qemu_get_be64(f);
    if (expire_time != -1) {
        qemu_mod_timer_ns(ts, expire_time);
    } else {
        qemu_del_timer(ts);
    }
}


Gerd Hoffmann's avatar
Gerd Hoffmann committed
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
/* bool */

static int get_bool(QEMUFile *f, void *pv, size_t size)
{
    bool *v = pv;
    *v = qemu_get_byte(f);
    return 0;
}

static void put_bool(QEMUFile *f, void *pv, size_t size)
{
    bool *v = pv;
    qemu_put_byte(f, *v);
}

const VMStateInfo vmstate_info_bool = {
    .name = "bool",
    .get  = get_bool,
    .put  = put_bool,
};

1024 1025 1026 1027 1028 1029 1030 1031 1032
/* 8 bit int */

static int get_int8(QEMUFile *f, void *pv, size_t size)
{
    int8_t *v = pv;
    qemu_get_s8s(f, v);
    return 0;
}

1033
static void put_int8(QEMUFile *f, void *pv, size_t size)
1034
{