qemu-file.c

   1 #include "qemu-common.h"
   2 #include "qemu/iov.h"
   3 #include "qemu/sockets.h"
   4 #include "block/coroutine.h"
   5 #include "migration/migration.h"
   6 #include "migration/qemu-file.h"
   7 #include "trace.h"
   8
   9 #define IO_BUF_SIZE 32768
  10 #define MAX_IOV_SIZE MIN(IOV_MAX, 64)
  11
  12 struct QEMUFile {
  13     const QEMUFileOps *ops;
  14     void *opaque;
  15
  16     int64_t bytes_xfer;
  17     int64_t xfer_limit;
  18
  19     int64_t pos; /* start of buffer when writing, end of buffer
  20                     when reading */
  21     int buf_index;
  22     int buf_size; /* 0 when writing */
  23     uint8_t buf[IO_BUF_SIZE];
  24
  25     struct iovec iov[MAX_IOV_SIZE];
  26     unsigned int iovcnt;
  27
  28     int last_error;
  29 };
  30
  31 typedef struct QEMUFileStdio {
  32     FILE *stdio_file;
  33     QEMUFile *file;
  34 } QEMUFileStdio;
  35
  36 typedef struct QEMUFileSocket {
  37     int fd;
  38     QEMUFile *file;
  39 } QEMUFileSocket;
  40
  41 static ssize_t socket_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
  42                                     int64_t pos)
  43 {
  44     QEMUFileSocket *s = opaque;
  45     ssize_t len;
  46     ssize_t size = iov_size(iov, iovcnt);
  47
  48     len = iov_send(s->fd, iov, iovcnt, 0, size);
  49     if (len < size) {
  50         len = -socket_error();
  51     }
  52     return len;
  53 }
  54
  55 static int socket_get_fd(void *opaque)
  56 {
  57     QEMUFileSocket *s = opaque;
  58
  59     return s->fd;
  60 }
  61
  62 static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
  63 {
  64     QEMUFileSocket *s = opaque;
  65     ssize_t len;
  66
  67     for (;;) {
  68         len = qemu_recv(s->fd, buf, size, 0);
  69         if (len != -1) {
  70             break;
  71         }
  72         if (socket_error() == EAGAIN) {
  73             yield_until_fd_readable(s->fd);
  74         } else if (socket_error() != EINTR) {
  75             break;
  76         }
  77     }
  78
  79     if (len == -1) {
  80         len = -socket_error();
  81     }
  82     return len;
  83 }
  84
  85 static int socket_close(void *opaque)
  86 {
  87     QEMUFileSocket *s = opaque;
  88     closesocket(s->fd);
  89     g_free(s);
  90     return 0;
  91 }
  92
  93 static int stdio_get_fd(void *opaque)
  94 {
  95     QEMUFileStdio *s = opaque;
  96
  97     return fileno(s->stdio_file);
  98 }
  99
 100 static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos,
 101                             int size)
 102 {
 103     QEMUFileStdio *s = opaque;
 104     int res;
 105
 106     res = fwrite(buf, 1, size, s->stdio_file);
 107
 108     if (res != size) {
 109         return -errno;
 110     }
 111     return res;
 112 }
 113
 114 static int stdio_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
 115 {
 116     QEMUFileStdio *s = opaque;
 117     FILE *fp = s->stdio_file;
 118     int bytes;
 119
 120     for (;;) {
 121         clearerr(fp);
 122         bytes = fread(buf, 1, size, fp);
 123         if (bytes != 0 || !ferror(fp)) {
 124             break;
 125         }
 126         if (errno == EAGAIN) {
 127             yield_until_fd_readable(fileno(fp));
 128         } else if (errno != EINTR) {
 129             break;
 130         }
 131     }
 132     return bytes;
 133 }
 134
 135 static int stdio_pclose(void *opaque)
 136 {
 137     QEMUFileStdio *s = opaque;
 138     int ret;
 139     ret = pclose(s->stdio_file);
 140     if (ret == -1) {
 141         ret = -errno;
 142     } else if (!WIFEXITED(ret) || WEXITSTATUS(ret) != 0) {
 143         /* close succeeded, but non-zero exit code: */
 144         ret = -EIO; /* fake errno value */
 145     }
 146     g_free(s);
 147     return ret;
 148 }
 149
 150 static int stdio_fclose(void *opaque)
 151 {
 152     QEMUFileStdio *s = opaque;
 153     int ret = 0;
 154
 155     if (s->file->ops->put_buffer || s->file->ops->writev_buffer) {
 156         int fd = fileno(s->stdio_file);
 157         struct stat st;
 158
 159         ret = fstat(fd, &st);
 160         if (ret == 0 && S_ISREG(st.st_mode)) {
 161             /*
 162              * If the file handle is a regular file make sure the
 163              * data is flushed to disk before signaling success.
 164              */
 165             ret = fsync(fd);
 166             if (ret != 0) {
 167                 ret = -errno;
 168                 return ret;
 169             }
 170         }
 171     }
 172     if (fclose(s->stdio_file) == EOF) {
 173         ret = -errno;
 174     }
 175     g_free(s);
 176     return ret;
 177 }
 178
 179 static const QEMUFileOps stdio_pipe_read_ops = {
 180     .get_fd =     stdio_get_fd,
 181     .get_buffer = stdio_get_buffer,
 182     .close =      stdio_pclose
 183 };
 184
 185 static const QEMUFileOps stdio_pipe_write_ops = {
 186     .get_fd =     stdio_get_fd,
 187     .put_buffer = stdio_put_buffer,
 188     .close =      stdio_pclose
 189 };
 190
 191 QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
 192 {
 193     FILE *stdio_file;
 194     QEMUFileStdio *s;
 195
 196     if (mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
 197         fprintf(stderr, "qemu_popen: Argument validity check failed\n");
 198         return NULL;
 199     }
 200
 201     stdio_file = popen(command, mode);
 202     if (stdio_file == NULL) {
 203         return NULL;
 204     }
 205
 206     s = g_malloc0(sizeof(QEMUFileStdio));
 207
 208     s->stdio_file = stdio_file;
 209
 210     if (mode[0] == 'r') {
 211         s->file = qemu_fopen_ops(s, &stdio_pipe_read_ops);
 212     } else {
 213         s->file = qemu_fopen_ops(s, &stdio_pipe_write_ops);
 214     }
 215     return s->file;
 216 }
 217
 218 static const QEMUFileOps stdio_file_read_ops = {
 219     .get_fd =     stdio_get_fd,
 220     .get_buffer = stdio_get_buffer,
 221     .close =      stdio_fclose
 222 };
 223
 224 static const QEMUFileOps stdio_file_write_ops = {
 225     .get_fd =     stdio_get_fd,
 226     .put_buffer = stdio_put_buffer,
 227     .close =      stdio_fclose
 228 };
 229
 230 static ssize_t unix_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
 231                                   int64_t pos)
 232 {
 233     QEMUFileSocket *s = opaque;
 234     ssize_t len, offset;
 235     ssize_t size = iov_size(iov, iovcnt);
 236     ssize_t total = 0;
 237
 238     assert(iovcnt > 0);
 239     offset = 0;
 240     while (size > 0) {
 241         /* Find the next start position; skip all full-sized vector elements  */
 242         while (offset >= iov[0].iov_len) {
 243             offset -= iov[0].iov_len;
 244             iov++, iovcnt--;
 245         }
 246
 247         /* skip `offset' bytes from the (now) first element, undo it on exit */
 248         assert(iovcnt > 0);
 249         iov[0].iov_base += offset;
 250         iov[0].iov_len -= offset;
 251
 252         do {
 253             len = writev(s->fd, iov, iovcnt);
 254         } while (len == -1 && errno == EINTR);
 255         if (len == -1) {
 256             return -errno;
 257         }
 258
 259         /* Undo the changes above */
 260         iov[0].iov_base -= offset;
 261         iov[0].iov_len += offset;
 262
 263         /* Prepare for the next iteration */
 264         offset += len;
 265         total += len;
 266         size -= len;
 267     }
 268
 269     return total;
 270 }
 271
 272 static int unix_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
 273 {
 274     QEMUFileSocket *s = opaque;
 275     ssize_t len;
 276
 277     for (;;) {
 278         len = read(s->fd, buf, size);
 279         if (len != -1) {
 280             break;
 281         }
 282         if (errno == EAGAIN) {
 283             yield_until_fd_readable(s->fd);
 284         } else if (errno != EINTR) {
 285             break;
 286         }
 287     }
 288
 289     if (len == -1) {
 290         len = -errno;
 291     }
 292     return len;
 293 }
 294
 295 static int unix_close(void *opaque)
 296 {
 297     QEMUFileSocket *s = opaque;
 298     close(s->fd);
 299     g_free(s);
 300     return 0;
 301 }
 302
 303 static const QEMUFileOps unix_read_ops = {
 304     .get_fd =     socket_get_fd,
 305     .get_buffer = unix_get_buffer,
 306     .close =      unix_close
 307 };
 308
 309 static const QEMUFileOps unix_write_ops = {
 310     .get_fd =     socket_get_fd,
 311     .writev_buffer = unix_writev_buffer,
 312     .close =      unix_close
 313 };
 314
 315 QEMUFile *qemu_fdopen(int fd, const char *mode)
 316 {
 317     QEMUFileSocket *s;
 318
 319     if (mode == NULL ||
 320         (mode[0] != 'r' && mode[0] != 'w') ||
 321         mode[1] != 'b' || mode[2] != 0) {
 322         fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
 323         return NULL;
 324     }
 325
 326     s = g_malloc0(sizeof(QEMUFileSocket));
 327     s->fd = fd;
 328
 329     if (mode[0] == 'r') {
 330         s->file = qemu_fopen_ops(s, &unix_read_ops);
 331     } else {
 332         s->file = qemu_fopen_ops(s, &unix_write_ops);
 333     }
 334     return s->file;
 335 }
 336
 337 static const QEMUFileOps socket_read_ops = {
 338     .get_fd =     socket_get_fd,
 339     .get_buffer = socket_get_buffer,
 340     .close =      socket_close
 341 };
 342
 343 static const QEMUFileOps socket_write_ops = {
 344     .get_fd =     socket_get_fd,
 345     .writev_buffer = socket_writev_buffer,
 346     .close =      socket_close
 347 };
 348
 349 bool qemu_file_mode_is_not_valid(const char *mode)
 350 {
 351     if (mode == NULL ||
 352         (mode[0] != 'r' && mode[0] != 'w') ||
 353         mode[1] != 'b' || mode[2] != 0) {
 354         fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
 355         return true;
 356     }
 357
 358     return false;
 359 }
 360
 361 QEMUFile *qemu_fopen_socket(int fd, const char *mode)
 362 {
 363     QEMUFileSocket *s;
 364
 365     if (qemu_file_mode_is_not_valid(mode)) {
 366         return NULL;
 367     }
 368
 369     s = g_malloc0(sizeof(QEMUFileSocket));
 370     s->fd = fd;
 371     if (mode[0] == 'w') {
 372         qemu_set_block(s->fd);
 373         s->file = qemu_fopen_ops(s, &socket_write_ops);
 374     } else {
 375         s->file = qemu_fopen_ops(s, &socket_read_ops);
 376     }
 377     return s->file;
 378 }
 379
 380 QEMUFile *qemu_fopen(const char *filename, const char *mode)
 381 {
 382     QEMUFileStdio *s;
 383
 384     if (qemu_file_mode_is_not_valid(mode)) {
 385         return NULL;
 386     }
 387
 388     s = g_malloc0(sizeof(QEMUFileStdio));
 389
 390     s->stdio_file = fopen(filename, mode);
 391     if (!s->stdio_file) {
 392         goto fail;
 393     }
 394
 395     if (mode[0] == 'w') {
 396         s->file = qemu_fopen_ops(s, &stdio_file_write_ops);
 397     } else {
 398         s->file = qemu_fopen_ops(s, &stdio_file_read_ops);
 399     }
 400     return s->file;
 401 fail:
 402     g_free(s);
 403     return NULL;
 404 }
 405
 406 QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)
 407 {
 408     QEMUFile *f;
 409
 410     f = g_malloc0(sizeof(QEMUFile));
 411
 412     f->opaque = opaque;
 413     f->ops = ops;
 414     return f;
 415 }
 416
 417 /*
 418  * Get last error for stream f
 419  *
 420  * Return negative error value if there has been an error on previous
 421  * operations, return 0 if no error happened.
 422  *
 423  */
 424 int qemu_file_get_error(QEMUFile *f)
 425 {
 426     return f->last_error;
 427 }
 428
 429 void qemu_file_set_error(QEMUFile *f, int ret)
 430 {
 431     if (f->last_error == 0) {
 432         f->last_error = ret;
 433     }
 434 }
 435
 436 static inline bool qemu_file_is_writable(QEMUFile *f)
 437 {
 438     return f->ops->writev_buffer || f->ops->put_buffer;
 439 }
 440
 441 /**
 442  * Flushes QEMUFile buffer
 443  *
 444  * If there is writev_buffer QEMUFileOps it uses it otherwise uses
 445  * put_buffer ops.
 446  */
 447 void qemu_fflush(QEMUFile *f)
 448 {
 449     ssize_t ret = 0;
 450
 451     if (!qemu_file_is_writable(f)) {
 452         return;
 453     }
 454
 455     if (f->ops->writev_buffer) {
 456         if (f->iovcnt > 0) {
 457             ret = f->ops->writev_buffer(f->opaque, f->iov, f->iovcnt, f->pos);
 458         }
 459     } else {
 460         if (f->buf_index > 0) {
 461             ret = f->ops->put_buffer(f->opaque, f->buf, f->pos, f->buf_index);
 462         }
 463     }
 464     if (ret >= 0) {
 465         f->pos += ret;
 466     }
 467     f->buf_index = 0;
 468     f->iovcnt = 0;
 469     if (ret < 0) {
 470         qemu_file_set_error(f, ret);
 471     }
 472 }
 473
 474 void ram_control_before_iterate(QEMUFile *f, uint64_t flags)
 475 {
 476     int ret = 0;
 477
 478     if (f->ops->before_ram_iterate) {
 479         ret = f->ops->before_ram_iterate(f, f->opaque, flags);
 480         if (ret < 0) {
 481             qemu_file_set_error(f, ret);
 482         }
 483     }
 484 }
 485
 486 void ram_control_after_iterate(QEMUFile *f, uint64_t flags)
 487 {
 488     int ret = 0;
 489
 490     if (f->ops->after_ram_iterate) {
 491         ret = f->ops->after_ram_iterate(f, f->opaque, flags);
 492         if (ret < 0) {
 493             qemu_file_set_error(f, ret);
 494         }
 495     }
 496 }
 497
 498 void ram_control_load_hook(QEMUFile *f, uint64_t flags)
 499 {
 500     int ret = -EINVAL;
 501
 502     if (f->ops->hook_ram_load) {
 503         ret = f->ops->hook_ram_load(f, f->opaque, flags);
 504         if (ret < 0) {
 505             qemu_file_set_error(f, ret);
 506         }
 507     } else {
 508         qemu_file_set_error(f, ret);
 509     }
 510 }
 511
 512 size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset,
 513                          ram_addr_t offset, size_t size, int *bytes_sent)
 514 {
 515     if (f->ops->save_page) {
 516         int ret = f->ops->save_page(f, f->opaque, block_offset,
 517                                     offset, size, bytes_sent);
 518
 519         if (ret != RAM_SAVE_CONTROL_DELAYED) {
 520             if (bytes_sent && *bytes_sent > 0) {
 521                 qemu_update_position(f, *bytes_sent);
 522             } else if (ret < 0) {
 523                 qemu_file_set_error(f, ret);
 524             }
 525         }
 526
 527         return ret;
 528     }
 529
 530     return RAM_SAVE_CONTROL_NOT_SUPP;
 531 }
 532
 533 /*
 534  * Attempt to fill the buffer from the underlying file
 535  * Returns the number of bytes read, or negative value for an error.
 536  *
 537  * Note that it can return a partially full buffer even in a not error/not EOF
 538  * case if the underlying file descriptor gives a short read, and that can
 539  * happen even on a blocking fd.
 540  */
 541 static ssize_t qemu_fill_buffer(QEMUFile *f)
 542 {
 543     int len;
 544     int pending;
 545
 546     assert(!qemu_file_is_writable(f));
 547
 548     pending = f->buf_size - f->buf_index;
 549     if (pending > 0) {
 550         memmove(f->buf, f->buf + f->buf_index, pending);
 551     }
 552     f->buf_index = 0;
 553     f->buf_size = pending;
 554
 555     len = f->ops->get_buffer(f->opaque, f->buf + pending, f->pos,
 556                         IO_BUF_SIZE - pending);
 557     if (len > 0) {
 558         f->buf_size += len;
 559         f->pos += len;
 560     } else if (len == 0) {
 561         qemu_file_set_error(f, -EIO);
 562     } else if (len != -EAGAIN) {
 563         qemu_file_set_error(f, len);
 564     }
 565
 566     return len;
 567 }
 568
 569 int qemu_get_fd(QEMUFile *f)
 570 {
 571     if (f->ops->get_fd) {
 572         return f->ops->get_fd(f->opaque);
 573     }
 574     return -1;
 575 }
 576
 577 void qemu_update_position(QEMUFile *f, size_t size)
 578 {
 579     f->pos += size;
 580 }
 581
 582 /** Closes the file
 583  *
 584  * Returns negative error value if any error happened on previous operations or
 585  * while closing the file. Returns 0 or positive number on success.
 586  *
 587  * The meaning of return value on success depends on the specific backend
 588  * being used.
 589  */
 590 int qemu_fclose(QEMUFile *f)
 591 {
 592     int ret;
 593     qemu_fflush(f);
 594     ret = qemu_file_get_error(f);
 595
 596     if (f->ops->close) {
 597         int ret2 = f->ops->close(f->opaque);
 598         if (ret >= 0) {
 599             ret = ret2;
 600         }
 601     }
 602     /* If any error was spotted before closing, we should report it
 603      * instead of the close() return value.
 604      */
 605     if (f->last_error) {
 606         ret = f->last_error;
 607     }
 608     g_free(f);
 609     trace_qemu_file_fclose();
 610     return ret;
 611 }
 612
 613 static void add_to_iovec(QEMUFile *f, const uint8_t *buf, int size)
 614 {
 615     /* check for adjacent buffer and coalesce them */
 616     if (f->iovcnt > 0 && buf == f->iov[f->iovcnt - 1].iov_base +
 617         f->iov[f->iovcnt - 1].iov_len) {
 618         f->iov[f->iovcnt - 1].iov_len += size;
 619     } else {
 620         f->iov[f->iovcnt].iov_base = (uint8_t *)buf;
 621         f->iov[f->iovcnt++].iov_len = size;
 622     }
 623
 624     if (f->iovcnt >= MAX_IOV_SIZE) {
 625         qemu_fflush(f);
 626     }
 627 }
 628
 629 void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, int size)
 630 {
 631     if (!f->ops->writev_buffer) {
 632         qemu_put_buffer(f, buf, size);
 633         return;
 634     }
 635
 636     if (f->last_error) {
 637         return;
 638     }
 639
 640     f->bytes_xfer += size;
 641     add_to_iovec(f, buf, size);
 642 }
 643
 644 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
 645 {
 646     int l;
 647
 648     if (f->last_error) {
 649         return;
 650     }
 651
 652     while (size > 0) {
 653         l = IO_BUF_SIZE - f->buf_index;
 654         if (l > size) {
 655             l = size;
 656         }
 657         memcpy(f->buf + f->buf_index, buf, l);
 658         f->bytes_xfer += l;
 659         if (f->ops->writev_buffer) {
 660             add_to_iovec(f, f->buf + f->buf_index, l);
 661         }
 662         f->buf_index += l;
 663         if (f->buf_index == IO_BUF_SIZE) {
 664             qemu_fflush(f);
 665         }
 666         if (qemu_file_get_error(f)) {
 667             break;
 668         }
 669         buf += l;
 670         size -= l;
 671     }
 672 }
 673
 674 void qemu_put_byte(QEMUFile *f, int v)
 675 {
 676     if (f->last_error) {
 677         return;
 678     }
 679
 680     f->buf[f->buf_index] = v;
 681     f->bytes_xfer++;
 682     if (f->ops->writev_buffer) {
 683         add_to_iovec(f, f->buf + f->buf_index, 1);
 684     }
 685     f->buf_index++;
 686     if (f->buf_index == IO_BUF_SIZE) {
 687         qemu_fflush(f);
 688     }
 689 }
 690
 691 void qemu_file_skip(QEMUFile *f, int size)
 692 {
 693     if (f->buf_index + size <= f->buf_size) {
 694         f->buf_index += size;
 695     }
 696 }
 697
 698 /*
 699  * Read 'size' bytes from file (at 'offset') into buf without moving the
 700  * pointer.
 701  *
 702  * It will return size bytes unless there was an error, in which case it will
 703  * return as many as it managed to read (assuming blocking fd's which
 704  * all current QEMUFile are)
 705  */
 706 int qemu_peek_buffer(QEMUFile *f, uint8_t *buf, int size, size_t offset)
 707 {
 708     int pending;
 709     int index;
 710
 711     assert(!qemu_file_is_writable(f));
 712     assert(offset < IO_BUF_SIZE);
 713     assert(size <= IO_BUF_SIZE - offset);
 714
 715     /* The 1st byte to read from */
 716     index = f->buf_index + offset;
 717     /* The number of available bytes starting at index */
 718     pending = f->buf_size - index;
 719
 720     /*
 721      * qemu_fill_buffer might return just a few bytes, even when there isn't
 722      * an error, so loop collecting them until we get enough.
 723      */
 724     while (pending < size) {
 725         int received = qemu_fill_buffer(f);
 726
 727         if (received <= 0) {
 728             break;
 729         }
 730
 731         index = f->buf_index + offset;
 732         pending = f->buf_size - index;
 733     }
 734
 735     if (pending <= 0) {
 736         return 0;
 737     }
 738     if (size > pending) {
 739         size = pending;
 740     }
 741
 742     memcpy(buf, f->buf + index, size);
 743     return size;
 744 }
 745
 746 /*
 747  * Read 'size' bytes of data from the file into buf.
 748  * 'size' can be larger than the internal buffer.
 749  *
 750  * It will return size bytes unless there was an error, in which case it will
 751  * return as many as it managed to read (assuming blocking fd's which
 752  * all current QEMUFile are)
 753  */
 754 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
 755 {
 756     int pending = size;
 757     int done = 0;
 758
 759     while (pending > 0) {
 760         int res;
 761
 762         res = qemu_peek_buffer(f, buf, MIN(pending, IO_BUF_SIZE), 0);
 763         if (res == 0) {
 764             return done;
 765         }
 766         qemu_file_skip(f, res);
 767         buf += res;
 768         pending -= res;
 769         done += res;
 770     }
 771     return done;
 772 }
 773
 774 /*
 775  * Peeks a single byte from the buffer; this isn't guaranteed to work if
 776  * offset leaves a gap after the previous read/peeked data.
 777  */
 778 int qemu_peek_byte(QEMUFile *f, int offset)
 779 {
 780     int index = f->buf_index + offset;
 781
 782     assert(!qemu_file_is_writable(f));
 783     assert(offset < IO_BUF_SIZE);
 784
 785     if (index >= f->buf_size) {
 786         qemu_fill_buffer(f);
 787         index = f->buf_index + offset;
 788         if (index >= f->buf_size) {
 789             return 0;
 790         }
 791     }
 792     return f->buf[index];
 793 }
 794
 795 int qemu_get_byte(QEMUFile *f)
 796 {
 797     int result;
 798
 799     result = qemu_peek_byte(f, 0);
 800     qemu_file_skip(f, 1);
 801     return result;
 802 }
 803
 804 int64_t qemu_ftell(QEMUFile *f)
 805 {
 806     qemu_fflush(f);
 807     return f->pos;
 808 }
 809
 810 int qemu_file_rate_limit(QEMUFile *f)
 811 {
 812     if (qemu_file_get_error(f)) {
 813         return 1;
 814     }
 815     if (f->xfer_limit > 0 && f->bytes_xfer > f->xfer_limit) {
 816         return 1;
 817     }
 818     return 0;
 819 }
 820
 821 int64_t qemu_file_get_rate_limit(QEMUFile *f)
 822 {
 823     return f->xfer_limit;
 824 }
 825
 826 void qemu_file_set_rate_limit(QEMUFile *f, int64_t limit)
 827 {
 828     f->xfer_limit = limit;
 829 }
 830
 831 void qemu_file_reset_rate_limit(QEMUFile *f)
 832 {
 833     f->bytes_xfer = 0;
 834 }
 835
 836 void qemu_put_be16(QEMUFile *f, unsigned int v)
 837 {
 838     qemu_put_byte(f, v >> 8);
 839     qemu_put_byte(f, v);
 840 }
 841
 842 void qemu_put_be32(QEMUFile *f, unsigned int v)
 843 {
 844     qemu_put_byte(f, v >> 24);
 845     qemu_put_byte(f, v >> 16);
 846     qemu_put_byte(f, v >> 8);
 847     qemu_put_byte(f, v);
 848 }
 849
 850 void qemu_put_be64(QEMUFile *f, uint64_t v)
 851 {
 852     qemu_put_be32(f, v >> 32);
 853     qemu_put_be32(f, v);
 854 }
 855
 856 unsigned int qemu_get_be16(QEMUFile *f)
 857 {
 858     unsigned int v;
 859     v = qemu_get_byte(f) << 8;
 860     v |= qemu_get_byte(f);
 861     return v;
 862 }
 863
 864 unsigned int qemu_get_be32(QEMUFile *f)
 865 {
 866     unsigned int v;
 867     v = qemu_get_byte(f) << 24;
 868     v |= qemu_get_byte(f) << 16;
 869     v |= qemu_get_byte(f) << 8;
 870     v |= qemu_get_byte(f);
 871     return v;
 872 }
 873
 874 uint64_t qemu_get_be64(QEMUFile *f)
 875 {
 876     uint64_t v;
 877     v = (uint64_t)qemu_get_be32(f) << 32;
 878     v |= qemu_get_be32(f);
 879     return v;
 880 }