savevm.c 64.5 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

aliguori's avatar
aliguori committed
44 45
#define SELF_ANNOUNCE_ROUNDS 5

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

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

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

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


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

94 95
    qemu_foreach_nic(qemu_announce_self_iter, NULL);

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

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

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

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

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

123 124 125
    int64_t bytes_xfer;
    int64_t xfer_limit;

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

132 133 134
    struct iovec iov[MAX_IOV_SIZE];
    unsigned int iovcnt;

135
    int last_error;
aliguori's avatar
aliguori committed
136 137
};

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

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

150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
typedef struct {
    Coroutine *co;
    int fd;
} FDYieldUntilData;

static void fd_coroutine_enter(void *opaque)
{
    FDYieldUntilData *data = opaque;
    qemu_set_fd_handler(data->fd, NULL, NULL, NULL);
    qemu_coroutine_enter(data->co, NULL);
}

/**
 * Yield until a file descriptor becomes readable
 *
 * Note that this function clobbers the handlers for the file descriptor.
 */
static void coroutine_fn yield_until_fd_readable(int fd)
{
    FDYieldUntilData data;

    assert(qemu_in_coroutine());
    data.co = qemu_coroutine_self();
    data.fd = fd;
    qemu_set_fd_handler(fd, fd_coroutine_enter, NULL, &data);
    qemu_coroutine_yield();
}

178 179
static ssize_t socket_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
                                    int64_t pos)
180 181 182 183 184 185 186 187 188 189 190 191
{
    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
192 193 194 195 196 197 198
static int socket_get_fd(void *opaque)
{
    QEMUFileSocket *s = opaque;

    return s->fd;
}

aliguori's avatar
aliguori committed
199 200 201 202 203
static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
{
    QEMUFileSocket *s = opaque;
    ssize_t len;

204
    for (;;) {
Blue Swirl's avatar
Blue Swirl committed
205
        len = qemu_recv(s->fd, buf, size, 0);
206 207 208 209
        if (len != -1) {
            break;
        }
        if (socket_error() == EAGAIN) {
210
            yield_until_fd_readable(s->fd);
211 212 213 214
        } else if (socket_error() != EINTR) {
            break;
        }
    }
aliguori's avatar
aliguori committed
215

216
    if (len == -1) {
aliguori's avatar
aliguori committed
217
        len = -socket_error();
218
    }
aliguori's avatar
aliguori committed
219 220 221 222 223 224
    return len;
}

static int socket_close(void *opaque)
{
    QEMUFileSocket *s = opaque;
225
    closesocket(s->fd);
226
    g_free(s);
aliguori's avatar
aliguori committed
227 228 229
    return 0;
}

Paolo Bonzini's avatar
Paolo Bonzini committed
230 231 232 233 234 235 236
static int stdio_get_fd(void *opaque)
{
    QEMUFileStdio *s = opaque;

    return fileno(s->stdio_file);
}

237
static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
aliguori's avatar
aliguori committed
238
{
239 240
    QEMUFileStdio *s = opaque;
    return fwrite(buf, 1, size, s->stdio_file);
aliguori's avatar
aliguori committed
241 242
}

243
static int stdio_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
aliguori's avatar
aliguori committed
244
{
245 246
    QEMUFileStdio *s = opaque;
    FILE *fp = s->stdio_file;
247 248
    int bytes;

249
    for (;;) {
250 251
        clearerr(fp);
        bytes = fread(buf, 1, size, fp);
252 253 254 255
        if (bytes != 0 || !ferror(fp)) {
            break;
        }
        if (errno == EAGAIN) {
256
            yield_until_fd_readable(fileno(fp));
257 258 259 260
        } else if (errno != EINTR) {
            break;
        }
    }
261
    return bytes;
aliguori's avatar
aliguori committed
262 263
}

264 265 266
static int stdio_pclose(void *opaque)
{
    QEMUFileStdio *s = opaque;
267 268
    int ret;
    ret = pclose(s->stdio_file);
269 270
    if (ret == -1) {
        ret = -errno;
271 272 273
    } else if (!WIFEXITED(ret) || WEXITSTATUS(ret) != 0) {
        /* close succeeded, but non-zero exit code: */
        ret = -EIO; /* fake errno value */
274
    }
275
    g_free(s);
276
    return ret;
277 278 279
}

static int stdio_fclose(void *opaque)
aliguori's avatar
aliguori committed
280
{
281
    QEMUFileStdio *s = opaque;
282
    int ret = 0;
283

Orit Wasserman's avatar
Orit Wasserman committed
284
    if (s->file->ops->put_buffer || s->file->ops->writev_buffer) {
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
        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;
            }
        }
    }
301 302 303
    if (fclose(s->stdio_file) == EOF) {
        ret = -errno;
    }
304
    g_free(s);
305
    return ret;
aliguori's avatar
aliguori committed
306 307
}

308
static const QEMUFileOps stdio_pipe_read_ops = {
Paolo Bonzini's avatar
Paolo Bonzini committed
309
    .get_fd =     stdio_get_fd,
310 311 312 313 314
    .get_buffer = stdio_get_buffer,
    .close =      stdio_pclose
};

static const QEMUFileOps stdio_pipe_write_ops = {
Paolo Bonzini's avatar
Paolo Bonzini committed
315
    .get_fd =     stdio_get_fd,
316 317 318 319
    .put_buffer = stdio_put_buffer,
    .close =      stdio_pclose
};

320
QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
aliguori's avatar
aliguori committed
321
{
322
    FILE *stdio_file;
323
    QEMUFileStdio *s;
aliguori's avatar
aliguori committed
324

325 326
    if (mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
        fprintf(stderr, "qemu_popen: Argument validity check failed\n");
327 328 329
        return NULL;
    }

330 331
    stdio_file = popen(command, mode);
    if (stdio_file == NULL) {
aliguori's avatar
aliguori committed
332 333 334
        return NULL;
    }

335
    s = g_malloc0(sizeof(QEMUFileStdio));
aliguori's avatar
aliguori committed
336

337
    s->stdio_file = stdio_file;
aliguori's avatar
aliguori committed
338 339

    if(mode[0] == 'r') {
340
        s->file = qemu_fopen_ops(s, &stdio_pipe_read_ops);
aliguori's avatar
aliguori committed
341
    } else {
342
        s->file = qemu_fopen_ops(s, &stdio_pipe_write_ops);
aliguori's avatar
aliguori committed
343 344 345 346
    }
    return s->file;
}

347
static const QEMUFileOps stdio_file_read_ops = {
Paolo Bonzini's avatar
Paolo Bonzini committed
348
    .get_fd =     stdio_get_fd,
349 350 351 352 353
    .get_buffer = stdio_get_buffer,
    .close =      stdio_fclose
};

static const QEMUFileOps stdio_file_write_ops = {
Paolo Bonzini's avatar
Paolo Bonzini committed
354
    .get_fd =     stdio_get_fd,
355 356 357 358
    .put_buffer = stdio_put_buffer,
    .close =      stdio_fclose
};

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 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443
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
444 445
QEMUFile *qemu_fdopen(int fd, const char *mode)
{
446
    QEMUFileSocket *s;
Paolo Bonzini's avatar
Paolo Bonzini committed
447 448 449 450 451 452 453 454

    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;
    }

455 456
    s = g_malloc0(sizeof(QEMUFileSocket));
    s->fd = fd;
Paolo Bonzini's avatar
Paolo Bonzini committed
457 458

    if(mode[0] == 'r') {
459
        s->file = qemu_fopen_ops(s, &unix_read_ops);
Paolo Bonzini's avatar
Paolo Bonzini committed
460
    } else {
461
        s->file = qemu_fopen_ops(s, &unix_write_ops);
Paolo Bonzini's avatar
Paolo Bonzini committed
462 463 464 465
    }
    return s->file;
}

466
static const QEMUFileOps socket_read_ops = {
Paolo Bonzini's avatar
Paolo Bonzini committed
467
    .get_fd =     socket_get_fd,
468 469 470 471
    .get_buffer = socket_get_buffer,
    .close =      socket_close
};

472 473
static const QEMUFileOps socket_write_ops = {
    .get_fd =     socket_get_fd,
474
    .writev_buffer = socket_writev_buffer,
475 476 477 478
    .close =      socket_close
};

QEMUFile *qemu_fopen_socket(int fd, const char *mode)
aliguori's avatar
aliguori committed
479
{
480
    QEMUFileSocket *s = g_malloc0(sizeof(QEMUFileSocket));
aliguori's avatar
aliguori committed
481

482 483 484 485 486 487 488
    if (mode == NULL ||
        (mode[0] != 'r' && mode[0] != 'w') ||
        mode[1] != 'b' || mode[2] != 0) {
        fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
        return NULL;
    }

aliguori's avatar
aliguori committed
489
    s->fd = fd;
490
    if (mode[0] == 'w') {
491
        qemu_set_block(s->fd);
492 493 494 495
        s->file = qemu_fopen_ops(s, &socket_write_ops);
    } else {
        s->file = qemu_fopen_ops(s, &socket_read_ops);
    }
aliguori's avatar
aliguori committed
496 497 498 499 500 501 502
    return s->file;
}

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

503 504 505
    if (mode == NULL ||
	(mode[0] != 'r' && mode[0] != 'w') ||
	mode[1] != 'b' || mode[2] != 0) {
Blue Swirl's avatar
Blue Swirl committed
506
        fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
507 508 509
        return NULL;
    }

510
    s = g_malloc0(sizeof(QEMUFileStdio));
aliguori's avatar
aliguori committed
511

512 513
    s->stdio_file = fopen(filename, mode);
    if (!s->stdio_file)
aliguori's avatar
aliguori committed
514
        goto fail;
lirans@il.ibm.com's avatar
lirans@il.ibm.com committed
515
    
516
    if(mode[0] == 'w') {
517
        s->file = qemu_fopen_ops(s, &stdio_file_write_ops);
518
    } else {
519
        s->file = qemu_fopen_ops(s, &stdio_file_read_ops);
520 521
    }
    return s->file;
aliguori's avatar
aliguori committed
522
fail:
523
    g_free(s);
aliguori's avatar
aliguori committed
524 525 526
    return NULL;
}

527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
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;
}

542
static int block_put_buffer(void *opaque, const uint8_t *buf,
aliguori's avatar
aliguori committed
543 544
                           int64_t pos, int size)
{
545
    bdrv_save_vmstate(opaque, buf, pos, size);
aliguori's avatar
aliguori committed
546 547 548
    return size;
}

549
static int block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
aliguori's avatar
aliguori committed
550
{
551
    return bdrv_load_vmstate(opaque, buf, pos, size);
aliguori's avatar
aliguori committed
552 553 554 555
}

static int bdrv_fclose(void *opaque)
{
556
    return bdrv_flush(opaque);
aliguori's avatar
aliguori committed
557 558
}

559 560 561 562 563 564
static const QEMUFileOps bdrv_read_ops = {
    .get_buffer = block_get_buffer,
    .close =      bdrv_fclose
};

static const QEMUFileOps bdrv_write_ops = {
565 566 567
    .put_buffer     = block_put_buffer,
    .writev_buffer  = block_writev_buffer,
    .close          = bdrv_fclose
568 569
};

570
static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
aliguori's avatar
aliguori committed
571 572
{
    if (is_writable)
573 574
        return qemu_fopen_ops(bs, &bdrv_write_ops);
    return qemu_fopen_ops(bs, &bdrv_read_ops);
aliguori's avatar
aliguori committed
575 576
}

577
QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)
aliguori's avatar
aliguori committed
578 579 580
{
    QEMUFile *f;

581
    f = g_malloc0(sizeof(QEMUFile));
aliguori's avatar
aliguori committed
582 583

    f->opaque = opaque;
584
    f->ops = ops;
aliguori's avatar
aliguori committed
585 586 587
    return f;
}

588
int qemu_file_get_error(QEMUFile *f)
aliguori's avatar
aliguori committed
589
{
590
    return f->last_error;
aliguori's avatar
aliguori committed
591 592
}

593
static void qemu_file_set_error(QEMUFile *f, int ret)
594
{
595 596 597
    if (f->last_error == 0) {
        f->last_error = ret;
    }
598 599
}

600 601 602 603 604
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
605 606
/**
 * Flushes QEMUFile buffer
607
 *
Orit Wasserman's avatar
Orit Wasserman committed
608 609
 * If there is writev_buffer QEMUFileOps it uses it otherwise uses
 * put_buffer ops.
610
 */
611
static void qemu_fflush(QEMUFile *f)
aliguori's avatar
aliguori committed
612
{
Orit Wasserman's avatar
Orit Wasserman committed
613
    ssize_t ret = 0;
614

615
    if (!qemu_file_is_writable(f)) {
616 617
        return;
    }
Orit Wasserman's avatar
Orit Wasserman committed
618

619 620
    if (f->ops->writev_buffer) {
        if (f->iovcnt > 0) {
621
            ret = f->ops->writev_buffer(f->opaque, f->iov, f->iovcnt, f->pos);
622
        }
623 624 625
    } else {
        if (f->buf_index > 0) {
            ret = f->ops->put_buffer(f->opaque, f->buf, f->pos, f->buf_index);
626
        }
aliguori's avatar
aliguori committed
627
    }
628 629 630 631 632
    if (ret >= 0) {
        f->pos += ret;
    }
    f->buf_index = 0;
    f->iovcnt = 0;
633 634 635
    if (ret < 0) {
        qemu_file_set_error(f, ret);
    }
aliguori's avatar
aliguori committed
636 637 638 639 640
}

static void qemu_fill_buffer(QEMUFile *f)
{
    int len;
641
    int pending;
aliguori's avatar
aliguori committed
642

643
    assert(!qemu_file_is_writable(f));
aliguori's avatar
aliguori committed
644

645 646 647 648 649 650 651
    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;

652
    len = f->ops->get_buffer(f->opaque, f->buf + pending, f->pos,
653
                        IO_BUF_SIZE - pending);
aliguori's avatar
aliguori committed
654
    if (len > 0) {
655
        f->buf_size += len;
656
        f->pos += len;
657
    } else if (len == 0) {
658
        qemu_file_set_error(f, -EIO);
aliguori's avatar
aliguori committed
659
    } else if (len != -EAGAIN)
660
        qemu_file_set_error(f, len);
aliguori's avatar
aliguori committed
661 662
}

Paolo Bonzini's avatar
Paolo Bonzini committed
663 664 665 666 667 668 669 670
int qemu_get_fd(QEMUFile *f)
{
    if (f->ops->get_fd) {
        return f->ops->get_fd(f->opaque);
    }
    return -1;
}

671 672 673 674 675 676 677 678 679 680
/** 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)
{
681
    int ret;
682 683
    qemu_fflush(f);
    ret = qemu_file_get_error(f);
684

685 686
    if (f->ops->close) {
        int ret2 = f->ops->close(f->opaque);
687 688 689
        if (ret >= 0) {
            ret = ret2;
        }
690
    }
691 692 693 694 695 696
    /* 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;
    }
697
    g_free(f);
aliguori's avatar
aliguori committed
698 699 700
    return ret;
}

701 702 703 704 705 706 707 708 709 710
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;
    }
711

712
    if (f->iovcnt >= MAX_IOV_SIZE) {
713 714
        qemu_fflush(f);
    }
715 716
}

Orit Wasserman's avatar
Orit Wasserman committed
717 718
void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, int size)
{
719 720 721 722 723
    if (!f->ops->writev_buffer) {
        qemu_put_buffer(f, buf, size);
        return;
    }

Orit Wasserman's avatar
Orit Wasserman committed
724 725 726 727 728
    if (f->last_error) {
        return;
    }

    f->bytes_xfer += size;
729
    add_to_iovec(f, buf, size);
Orit Wasserman's avatar
Orit Wasserman committed
730 731
}

aliguori's avatar
aliguori committed
732 733 734 735
void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
{
    int l;

736 737 738 739 740
    if (f->last_error) {
        return;
    }

    while (size > 0) {
aliguori's avatar
aliguori committed
741 742 743 744
        l = IO_BUF_SIZE - f->buf_index;
        if (l > size)
            l = size;
        memcpy(f->buf + f->buf_index, buf, l);
745 746 747
        f->bytes_xfer += size;
        if (f->ops->writev_buffer) {
            add_to_iovec(f, f->buf + f->buf_index, l);
748 749 750 751
        }
        f->buf_index += l;
        if (f->buf_index == IO_BUF_SIZE) {
            qemu_fflush(f);
752
        }
Orit Wasserman's avatar
Orit Wasserman committed
753 754 755
        if (qemu_file_get_error(f)) {
            break;
        }
aliguori's avatar
aliguori committed
756 757 758 759 760 761 762
        buf += l;
        size -= l;
    }
}

void qemu_put_byte(QEMUFile *f, int v)
{
763 764 765 766
    if (f->last_error) {
        return;
    }

767
    f->buf[f->buf_index] = v;
768
    f->bytes_xfer++;
769 770
    if (f->ops->writev_buffer) {
        add_to_iovec(f, f->buf + f->buf_index, 1);
771 772 773 774
    }
    f->buf_index++;
    if (f->buf_index == IO_BUF_SIZE) {
        qemu_fflush(f);
775
    }
aliguori's avatar
aliguori committed
776 777
}

778
static void qemu_file_skip(QEMUFile *f, int size)
aliguori's avatar
aliguori committed
779
{
780 781 782 783 784 785
    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
786
{
787 788
    int pending;
    int index;
aliguori's avatar
aliguori committed
789

790
    assert(!qemu_file_is_writable(f));
aliguori's avatar
aliguori committed
791

792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821
    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
822
        }
823 824 825 826
        qemu_file_skip(f, res);
        buf += res;
        pending -= res;
        done += res;
aliguori's avatar
aliguori committed
827
    }
828
    return done;
aliguori's avatar
aliguori committed
829 830
}

831
static int qemu_peek_byte(QEMUFile *f, int offset)
Juan Quintela's avatar
Juan Quintela committed
832
{
833 834
    int index = f->buf_index + offset;

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

837
    if (index >= f->buf_size) {
Juan Quintela's avatar
Juan Quintela committed
838
        qemu_fill_buffer(f);
839 840
        index = f->buf_index + offset;
        if (index >= f->buf_size) {
Juan Quintela's avatar
Juan Quintela committed
841
            return 0;
842
        }
Juan Quintela's avatar
Juan Quintela committed
843
    }
844
    return f->buf[index];
Juan Quintela's avatar
Juan Quintela committed
845 846
}

aliguori's avatar
aliguori committed
847 848
int qemu_get_byte(QEMUFile *f)
{
849
    int result;
aliguori's avatar
aliguori committed
850

851 852
    result = qemu_peek_byte(f, 0);
    qemu_file_skip(f, 1);
853
    return result;
aliguori's avatar
aliguori committed
854 855
}

856
int64_t qemu_ftell(QEMUFile *f)
aliguori's avatar
aliguori committed
857
{
858 859
    qemu_fflush(f);
    return f->pos;
aliguori's avatar
aliguori committed
860 861 862 863
}

int qemu_file_rate_limit(QEMUFile *f)
{
864 865 866 867 868 869
    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
870 871 872
    return 0;
}

873
int64_t qemu_file_get_rate_limit(QEMUFile *f)
lirans@il.ibm.com's avatar
lirans@il.ibm.com committed
874
{
875
    return f->xfer_limit;
lirans@il.ibm.com's avatar
lirans@il.ibm.com committed
876 877
}

878
void qemu_file_set_rate_limit(QEMUFile *f, int64_t limit)
879
{
880 881
    f->xfer_limit = limit;
}
882

883 884 885
void qemu_file_reset_rate_limit(QEMUFile *f)
{
    f->bytes_xfer = 0;
886 887
}

aliguori's avatar
aliguori committed
888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933
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;
}

934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957

/* timer */

void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
{
    uint64_t expire_time;

    expire_time = qemu_timer_expire_time_ns(ts);
    qemu_put_be64(f, expire_time);
}

void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
{
    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
958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978
/* 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,
};

979 980 981 982 983 984 985 986 987
/* 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;
}

988
static void put_int8(QEMUFile *f, void *pv, size_t size)
989
{
990
    int8_t *v = pv;
991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008
    qemu_put_s8s(f, v);
}

const VMStateInfo vmstate_info_int8 = {
    .name = "int8",
    .get  = get_int8,
    .put  = put_int8,
};

/* 16 bit int */

static int get_int16(QEMUFile *f, void *pv, size_t size)
{
    int16_t *v = pv;
    qemu_get_sbe16s(f, v);
    return 0;
}

1009
static void put_int16(QEMUFile *f, void *pv, size_t size)
1010
{
1011
    int16_t *v = pv;
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
    qemu_put_sbe16s(f, v);
}

const VMStateInfo vmstate_info_int16 = {
    .name = "int16",
    .get  = get_int16,
    .put  = put_int16,
};

/* 32 bit int */

static int get_int32(QEMUFile *f, void *pv, size_t size)
{
    int32_t *v = pv;
    qemu_get_sbe32s(f, v);
    return 0;
}

1030
static void put_int32(QEMUFile *f, void *pv, size_t size)
1031
{
1032
    int32_t *v = pv;
1033 1034 1035 1036 1037 1038 1039 1040 1041
    qemu_put_sbe32s(f, v);
}

const VMStateInfo vmstate_info_int32 = {
    .name = "int32",
    .get  = get_int32,
    .put  = put_int32,
};

1042 1043 1044 1045