savevm.c 65.1 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
        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 110
    }
}

void qemu_announce_self(void)
{
	static QEMUTimer *timer;
111
	timer = timer_new_ms(QEMU_CLOCK_REALTIME, 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 570 571 572 573 574 575
/*
 * 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.
 *
 */
576
int qemu_file_get_error(QEMUFile *f)
aliguori's avatar
aliguori committed
577
{
578
    return f->last_error;
aliguori's avatar
aliguori committed
579 580
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

788 789 790 791 792
    if (f->last_error) {
        return;
    }

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

void qemu_put_byte(QEMUFile *f, int v)
{
815 816 817 818
    if (f->last_error) {
        return;
    }

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

830
static void qemu_file_skip(QEMUFile *f, int size)
aliguori's avatar
aliguori committed
831
{
832 833 834 835 836 837
    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
838
{
839 840
    int pending;
    int index;
aliguori's avatar
aliguori committed
841

842
    assert(!qemu_file_is_writable(f));
aliguori's avatar
aliguori committed
843

844 845 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
    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
874
        }
875 876 877 878
        qemu_file_skip(f, res);
        buf += res;
        pending -= res;
        done += res;
aliguori's avatar
aliguori committed
879
    }
880
    return done;
aliguori's avatar
aliguori committed
881 882
}

883
static int qemu_peek_byte(QEMUFile *f, int offset)
Juan Quintela's avatar
Juan Quintela committed
884
{
885 886
    int index = f->buf_index + offset;

887
    assert(!qemu_file_is_writable(f));
Juan Quintela's avatar
Juan Quintela committed
888

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

aliguori's avatar
aliguori committed
899 900
int qemu_get_byte(QEMUFile *f)
{
901
    int result;
aliguori's avatar
aliguori committed
902

903 904
    result = qemu_peek_byte(f, 0);
    qemu_file_skip(f, 1);
905
    return result;
aliguori's avatar
aliguori committed
906 907
}

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

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

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

930
void qemu_file_set_rate_limit(QEMUFile *f, int64_t limit)
931
{
932 933
    f->xfer_limit = limit;
}
934

935 936 937
void qemu_file_reset_rate_limit(QEMUFile *f)
{
    f->bytes_xfer = 0;
938 939
}

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

986 987 988

/* timer */

989
void timer_put(QEMUFile *f, QEMUTimer *ts)
990 991 992
{
    uint64_t expire_time;

993
    expire_time = timer_expire_time_ns(ts);
994 995 996
    qemu_put_be64(f, expire_time);
}

997
void timer_get(QEMUFile *f, QEMUTimer *ts)
998 999 1000 1001 1002
{
    uint64_t expire_time;

    expire_time = qemu_get_be64(f);
    if (expire_time != -1) {
1003
        timer_mod_ns(ts, expire_time);
1004
    } else {
1005
        timer_del(ts);
1006 1007 1008 1009
    }
}


Gerd Hoffmann's avatar
Gerd Hoffmann committed
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
/* bool */

static int get_bool