savevm.c 65 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,
56
                                uint8_t *mac_addr)
aliguori's avatar
aliguori committed
57
{
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
        timer_mod(timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) +
Nolan's avatar
Nolan committed
101
                       50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100);
102
    } else {
103 104
            timer_del(timer);
            timer_free(timer);
105 106 107 108 109
    }
}

void qemu_announce_self(void)
{
110 111 112
    static QEMUTimer *timer;
    timer = timer_new_ms(QEMU_CLOCK_REALTIME, qemu_announce_self_once, &timer);
    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
};

Eduardo Habkost's avatar
Eduardo Habkost committed
140
typedef struct QEMUFileStdio {
141
    FILE *stdio_file;
aliguori's avatar
aliguori committed
142
    QEMUFile *file;
143
} QEMUFileStdio;
aliguori's avatar
aliguori committed
144

Eduardo Habkost's avatar
Eduardo Habkost committed
145
typedef struct QEMUFileSocket {
aliguori's avatar
aliguori committed
146 147 148 149
    int fd;
    QEMUFile *file;
} QEMUFileSocket;

150 151
static ssize_t socket_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
                                    int64_t pos)
152 153 154 155 156 157 158 159 160 161 162 163
{
    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
164 165 166 167 168 169 170
static int socket_get_fd(void *opaque)
{
    QEMUFileSocket *s = opaque;

    return s->fd;
}

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

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

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

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

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

    return fileno(s->stdio_file);
}

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

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

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

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

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

Orit Wasserman's avatar
Orit Wasserman committed
257
    if (s->file->ops->put_buffer || s->file->ops->writev_buffer) {
258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
        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;
            }
        }
    }
274 275 276
    if (fclose(s->stdio_file) == EOF) {
        ret = -errno;
    }
277
    g_free(s);
278
    return ret;
aliguori's avatar
aliguori committed
279 280
}

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

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

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

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

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

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

310
    s->stdio_file = stdio_file;
aliguori's avatar
aliguori committed
311

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

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

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

332 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
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
417 418
QEMUFile *qemu_fdopen(int fd, const char *mode)
{
419
    QEMUFileSocket *s;
Paolo Bonzini's avatar
Paolo Bonzini committed
420 421

    if (mode == NULL ||
422 423
        (mode[0] != 'r' && mode[0] != 'w') ||
        mode[1] != 'b' || mode[2] != 0) {
Paolo Bonzini's avatar
Paolo Bonzini committed
424 425 426 427
        fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
        return NULL;
    }

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

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

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

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

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

    return false;
}

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

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

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

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

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

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

492
    s->stdio_file = fopen(filename, mode);
Eduardo Habkost's avatar
Eduardo Habkost committed
493
    if (!s->stdio_file) {
aliguori's avatar
aliguori committed
494
        goto fail;
Eduardo Habkost's avatar
Eduardo Habkost committed
495 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
{
Eduardo Habkost's avatar
Eduardo Habkost committed
553
    if (is_writable) {
554
        return qemu_fopen_ops(bs, &bdrv_write_ops);
Eduardo Habkost's avatar
Eduardo Habkost committed
555
    }
556
    return qemu_fopen_ops(bs, &bdrv_read_ops);
aliguori's avatar
aliguori committed
557 558
}

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

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

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

570 571 572 573 574 575 576
/*
 * Get last error for stream f
 *
 * Return negative error value if there has been an error on previous
 * operations, return 0 if no error happened.
 *
 */
577
int qemu_file_get_error(QEMUFile *f)
aliguori's avatar
aliguori committed
578
{
579
    return f->last_error;
aliguori's avatar
aliguori committed
580 581
}

582
void qemu_file_set_error(QEMUFile *f, int ret)
583
{
584 585 586
    if (f->last_error == 0) {
        f->last_error = ret;
    }
587 588
}

589 590 591 592 593
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
594 595
/**
 * Flushes QEMUFile buffer
596
 *
Orit Wasserman's avatar
Orit Wasserman committed
597 598
 * If there is writev_buffer QEMUFileOps it uses it otherwise uses
 * put_buffer ops.
599
 */
Michael R. Hines's avatar
Michael R. Hines committed
600
void qemu_fflush(QEMUFile *f)
aliguori's avatar
aliguori committed
601
{
Orit Wasserman's avatar
Orit Wasserman committed
602
    ssize_t ret = 0;
603

604
    if (!qemu_file_is_writable(f)) {
605 606
        return;
    }
Orit Wasserman's avatar
Orit Wasserman committed
607

608 609
    if (f->ops->writev_buffer) {
        if (f->iovcnt > 0) {
610
            ret = f->ops->writev_buffer(f->opaque, f->iov, f->iovcnt, f->pos);
611
        }
612 613 614
    } else {
        if (f->buf_index > 0) {
            ret = f->ops->put_buffer(f->opaque, f->buf, f->pos, f->buf_index);
615
        }
aliguori's avatar
aliguori committed
616
    }
617 618 619 620 621
    if (ret >= 0) {
        f->pos += ret;
    }
    f->buf_index = 0;
    f->iovcnt = 0;
622 623 624
    if (ret < 0) {
        qemu_file_set_error(f, ret);
    }
aliguori's avatar
aliguori committed
625 626
}

Michael R. Hines's avatar
Michael R. Hines committed
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
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)
{
653
    int ret = -EINVAL;
Michael R. Hines's avatar
Michael R. Hines committed
654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672

    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) {
673
            if (bytes_sent && *bytes_sent > 0) {
Michael R. Hines's avatar
Michael R. Hines committed
674 675 676 677 678 679 680 681 682 683 684 685
                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
686 687 688
static void qemu_fill_buffer(QEMUFile *f)
{
    int len;
689
    int pending;
aliguori's avatar
aliguori committed
690

691
    assert(!qemu_file_is_writable(f));
aliguori's avatar
aliguori committed
692

693 694 695 696 697 698 699
    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;

700
    len = f->ops->get_buffer(f->opaque, f->buf + pending, f->pos,
701
                        IO_BUF_SIZE - pending);
aliguori's avatar
aliguori committed
702
    if (len > 0) {
703
        f->buf_size += len;
704
        f->pos += len;
705
    } else if (len == 0) {
706
        qemu_file_set_error(f, -EIO);
Eduardo Habkost's avatar
Eduardo Habkost committed
707
    } else if (len != -EAGAIN) {
708
        qemu_file_set_error(f, len);
Eduardo Habkost's avatar
Eduardo Habkost committed
709
    }
aliguori's avatar
aliguori committed
710 711
}

Paolo Bonzini's avatar
Paolo Bonzini committed
712 713 714 715 716 717 718 719
int qemu_get_fd(QEMUFile *f)
{
    if (f->ops->get_fd) {
        return f->ops->get_fd(f->opaque);
    }
    return -1;
}

720 721 722 723 724
void qemu_update_position(QEMUFile *f, size_t size)
{
    f->pos += size;
}

725 726 727 728 729 730 731 732 733 734
/** 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)
{
735
    int ret;
736 737
    qemu_fflush(f);
    ret = qemu_file_get_error(f);
738

739 740
    if (f->ops->close) {
        int ret2 = f->ops->close(f->opaque);
741 742 743
        if (ret >= 0) {
            ret = ret2;
        }
744
    }
745 746 747 748 749 750
    /* 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;
    }
751
    g_free(f);
aliguori's avatar
aliguori committed
752 753 754
    return ret;
}

755 756 757 758 759 760 761 762 763 764
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;
    }
765

766
    if (f->iovcnt >= MAX_IOV_SIZE) {
767 768
        qemu_fflush(f);
    }
769 770
}

Orit Wasserman's avatar
Orit Wasserman committed
771 772
void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, int size)
{
773 774 775 776 777
    if (!f->ops->writev_buffer) {
        qemu_put_buffer(f, buf, size);
        return;
    }

Orit Wasserman's avatar
Orit Wasserman committed
778 779 780 781 782
    if (f->last_error) {
        return;
    }

    f->bytes_xfer += size;
783
    add_to_iovec(f, buf, size);
Orit Wasserman's avatar
Orit Wasserman committed
784 785
}

aliguori's avatar
aliguori committed
786 787 788 789
void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
{
    int l;

790 791 792 793 794
    if (f->last_error) {
        return;
    }

    while (size > 0) {
aliguori's avatar
aliguori committed
795
        l = IO_BUF_SIZE - f->buf_index;
Eduardo Habkost's avatar
Eduardo Habkost committed
796
        if (l > size) {
aliguori's avatar
aliguori committed
797
            l = size;
Eduardo Habkost's avatar
Eduardo Habkost committed
798
        }
aliguori's avatar
aliguori committed
799
        memcpy(f->buf + f->buf_index, buf, l);
800
        f->bytes_xfer += l;
801 802
        if (f->ops->writev_buffer) {
            add_to_iovec(f, f->buf + f->buf_index, l);
803 804 805 806
        }
        f->buf_index += l;
        if (f->buf_index == IO_BUF_SIZE) {
            qemu_fflush(f);
807
        }
Orit Wasserman's avatar
Orit Wasserman committed
808 809 810
        if (qemu_file_get_error(f)) {
            break;
        }
aliguori's avatar
aliguori committed
811 812 813 814 815 816 817
        buf += l;
        size -= l;
    }
}

void qemu_put_byte(QEMUFile *f, int v)
{
818 819 820 821
    if (f->last_error) {
        return;
    }

822
    f->buf[f->buf_index] = v;
823
    f->bytes_xfer++;
824 825
    if (f->ops->writev_buffer) {
        add_to_iovec(f, f->buf + f->buf_index, 1);
826 827 828 829
    }
    f->buf_index++;
    if (f->buf_index == IO_BUF_SIZE) {
        qemu_fflush(f);
830
    }
aliguori's avatar
aliguori committed
831 832
}

833
void qemu_file_skip(QEMUFile *f, int size)
aliguori's avatar
aliguori committed
834
{
835 836 837 838 839
    if (f->buf_index + size <= f->buf_size) {
        f->buf_index += size;
    }
}

840
int qemu_peek_buffer(QEMUFile *f, uint8_t *buf, int size, size_t offset)
aliguori's avatar
aliguori committed
841
{
842 843
    int pending;
    int index;
aliguori's avatar
aliguori committed
844

845
    assert(!qemu_file_is_writable(f));
aliguori's avatar
aliguori committed
846

847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876
    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
877
        }
878 879 880 881
        qemu_file_skip(f, res);
        buf += res;
        pending -= res;
        done += res;
aliguori's avatar
aliguori committed
882
    }
883
    return done;
aliguori's avatar
aliguori committed
884 885
}

886
int qemu_peek_byte(QEMUFile *f, int offset)
Juan Quintela's avatar
Juan Quintela committed
887
{
888 889
    int index = f->buf_index + offset;

890
    assert(!qemu_file_is_writable(f));
Juan Quintela's avatar
Juan Quintela committed
891

892
    if (index >= f->buf_size) {
Juan Quintela's avatar
Juan Quintela committed
893
        qemu_fill_buffer(f);
894 895
        index = f->buf_index + offset;
        if (index >= f->buf_size) {
Juan Quintela's avatar
Juan Quintela committed
896
            return 0;
897
        }
Juan Quintela's avatar
Juan Quintela committed
898
    }
899
    return f->buf[index];
Juan Quintela's avatar
Juan Quintela committed
900 901
}

aliguori's avatar
aliguori committed
902 903
int qemu_get_byte(QEMUFile *f)
{
904
    int result;
aliguori's avatar
aliguori committed
905

906 907
    result = qemu_peek_byte(f, 0);
    qemu_file_skip(f, 1);
908
    return result;
aliguori's avatar
aliguori committed
909 910
}

911
int64_t qemu_ftell(QEMUFile *f)
aliguori's avatar
aliguori committed
912
{
913 914
    qemu_fflush(f);
    return f->pos;
aliguori's avatar
aliguori committed
915 916 917 918
}

int qemu_file_rate_limit(QEMUFile *f)
{
919 920 921 922 923 924
    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
925 926 927
    return 0;
}

928
int64_t qemu_file_get_rate_limit(QEMUFile *f)
lirans@il.ibm.com's avatar
lirans@il.ibm.com committed
929
{
930
    return f->xfer_limit;
lirans@il.ibm.com's avatar
lirans@il.ibm.com committed
931 932
}

933
void qemu_file_set_rate_limit(QEMUFile *f, int64_t limit)
934
{
935 936
    f->xfer_limit = limit;
}
937

938 939 940
void qemu_file_reset_rate_limit(QEMUFile *f)
{
    f->bytes_xfer = 0;
941 942
}

aliguori's avatar
aliguori committed
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 979 980 981 982 983 984 985 986 987 988
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;
}

989 990 991

/* timer */

992
void timer_put(QEMUFile *f, QEMUTimer *ts)
993 994 995
{
    uint64_t expire_time;