migration/qemu-file.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "qemu/osdep.h"
  25 #include <zlib.h>
  26 #include "qemu-common.h"
  27 #include "qemu/error-report.h"
  28 #include "qemu/iov.h"
  29 #include "qemu/sockets.h"
  30 #include "qemu/coroutine.h"
  31 #include "migration/migration.h"
  32 #include "migration/qemu-file.h"
  33 #include "trace.h"
  34
  35 #define IO_BUF_SIZE 32768
  36 #define MAX_IOV_SIZE MIN(IOV_MAX, 64)
  37
  38 struct QEMUFile {
  39     const QEMUFileOps *ops;
  40     const QEMUFileHooks *hooks;
  41     void *opaque;
  42
  43     int64_t bytes_xfer;
  44     int64_t xfer_limit;
  45
  46     int64_t pos; /* start of buffer when writing, end of buffer
  47                     when reading */
  48     int buf_index;
  49     int buf_size; /* 0 when writing */
  50     uint8_t buf[IO_BUF_SIZE];
  51
  52     struct iovec iov[MAX_IOV_SIZE];
  53     unsigned int iovcnt;
  54
  55     int last_error;
  56 };
  57
  58 /*
  59  * Stop a file from being read/written - not all backing files can do this
  60  * typically only sockets can.
  61  */
  62 int qemu_file_shutdown(QEMUFile *f)
  63 {
  64     if (!f->ops->shut_down) {
  65         return -ENOSYS;
  66     }
  67     return f->ops->shut_down(f->opaque, true, true);
  68 }
  69
  70 /*
  71  * Result: QEMUFile* for a 'return path' for comms in the opposite direction
  72  *         NULL if not available
  73  */
  74 QEMUFile *qemu_file_get_return_path(QEMUFile *f)
  75 {
  76     if (!f->ops->get_return_path) {
  77         return NULL;
  78     }
  79     return f->ops->get_return_path(f->opaque);
  80 }
  81
  82 bool qemu_file_mode_is_not_valid(const char *mode)
  83 {
  84     if (mode == NULL ||
  85         (mode[0] != 'r' && mode[0] != 'w') ||
  86         mode[1] != 'b' || mode[2] != 0) {
  87         fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
  88         return true;
  89     }
  90
  91     return false;
  92 }
  93
  94 QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)
  95 {
  96     QEMUFile *f;
  97
  98     f = g_new0(QEMUFile, 1);
  99
 100     f->opaque = opaque;
 101     f->ops = ops;
 102     return f;
 103 }
 104
 105
 106 void qemu_file_set_hooks(QEMUFile *f, const QEMUFileHooks *hooks)
 107 {
 108     f->hooks = hooks;
 109 }
 110
 111 /*
 112  * Get last error for stream f
 113  *
 114  * Return negative error value if there has been an error on previous
 115  * operations, return 0 if no error happened.
 116  *
 117  */
 118 int qemu_file_get_error(QEMUFile *f)
 119 {
 120     return f->last_error;
 121 }
 122
 123 void qemu_file_set_error(QEMUFile *f, int ret)
 124 {
 125     if (f->last_error == 0) {
 126         f->last_error = ret;
 127     }
 128 }
 129
 130 bool qemu_file_is_writable(QEMUFile *f)
 131 {
 132     return f->ops->writev_buffer;
 133 }
 134
 135 /**
 136  * Flushes QEMUFile buffer
 137  *
 138  * If there is writev_buffer QEMUFileOps it uses it otherwise uses
 139  * put_buffer ops. This will flush all pending data. If data was
 140  * only partially flushed, it will set an error state.
 141  */
 142 void qemu_fflush(QEMUFile *f)
 143 {
 144     ssize_t ret = 0;
 145     ssize_t expect = 0;
 146
 147     if (!qemu_file_is_writable(f)) {
 148         return;
 149     }
 150
 151     if (f->iovcnt > 0) {
 152         expect = iov_size(f->iov, f->iovcnt);
 153         ret = f->ops->writev_buffer(f->opaque, f->iov, f->iovcnt, f->pos);
 154     }
 155
 156     if (ret >= 0) {
 157         f->pos += ret;
 158     }
 159     /* We expect the QEMUFile write impl to send the full
 160      * data set we requested, so sanity check that.
 161      */
 162     if (ret != expect) {
 163         qemu_file_set_error(f, ret < 0 ? ret : -EIO);
 164     }
 165     f->buf_index = 0;
 166     f->iovcnt = 0;
 167 }
 168
 169 void ram_control_before_iterate(QEMUFile *f, uint64_t flags)
 170 {
 171     int ret = 0;
 172
 173     if (f->hooks && f->hooks->before_ram_iterate) {
 174         ret = f->hooks->before_ram_iterate(f, f->opaque, flags, NULL);
 175         if (ret < 0) {
 176             qemu_file_set_error(f, ret);
 177         }
 178     }
 179 }
 180
 181 void ram_control_after_iterate(QEMUFile *f, uint64_t flags)
 182 {
 183     int ret = 0;
 184
 185     if (f->hooks && f->hooks->after_ram_iterate) {
 186         ret = f->hooks->after_ram_iterate(f, f->opaque, flags, NULL);
 187         if (ret < 0) {
 188             qemu_file_set_error(f, ret);
 189         }
 190     }
 191 }
 192
 193 void ram_control_load_hook(QEMUFile *f, uint64_t flags, void *data)
 194 {
 195     int ret = -EINVAL;
 196
 197     if (f->hooks && f->hooks->hook_ram_load) {
 198         ret = f->hooks->hook_ram_load(f, f->opaque, flags, data);
 199         if (ret < 0) {
 200             qemu_file_set_error(f, ret);
 201         }
 202     } else {
 203         /*
 204          * Hook is a hook specifically requested by the source sending a flag
 205          * that expects there to be a hook on the destination.
 206          */
 207         if (flags == RAM_CONTROL_HOOK) {
 208             qemu_file_set_error(f, ret);
 209         }
 210     }
 211 }
 212
 213 size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset,
 214                              ram_addr_t offset, size_t size,
 215                              uint64_t *bytes_sent)
 216 {
 217     if (f->hooks && f->hooks->save_page) {
 218         int ret = f->hooks->save_page(f, f->opaque, block_offset,
 219                                       offset, size, bytes_sent);
 220
 221         if (ret != RAM_SAVE_CONTROL_DELAYED) {
 222             if (bytes_sent && *bytes_sent > 0) {
 223                 qemu_update_position(f, *bytes_sent);
 224             } else if (ret < 0) {
 225                 qemu_file_set_error(f, ret);
 226             }
 227         }
 228
 229         return ret;
 230     }
 231
 232     return RAM_SAVE_CONTROL_NOT_SUPP;
 233 }
 234
 235 /*
 236  * Attempt to fill the buffer from the underlying file
 237  * Returns the number of bytes read, or negative value for an error.
 238  *
 239  * Note that it can return a partially full buffer even in a not error/not EOF
 240  * case if the underlying file descriptor gives a short read, and that can
 241  * happen even on a blocking fd.
 242  */
 243 static ssize_t qemu_fill_buffer(QEMUFile *f)
 244 {
 245     int len;
 246     int pending;
 247
 248     assert(!qemu_file_is_writable(f));
 249
 250     pending = f->buf_size - f->buf_index;
 251     if (pending > 0) {
 252         memmove(f->buf, f->buf + f->buf_index, pending);
 253     }
 254     f->buf_index = 0;
 255     f->buf_size = pending;
 256
 257     len = f->ops->get_buffer(f->opaque, f->buf + pending, f->pos,
 258                         IO_BUF_SIZE - pending);
 259     if (len > 0) {
 260         f->buf_size += len;
 261         f->pos += len;
 262     } else if (len == 0) {
 263         qemu_file_set_error(f, -EIO);
 264     } else if (len != -EAGAIN) {
 265         qemu_file_set_error(f, len);
 266     }
 267
 268     return len;
 269 }
 270
 271 void qemu_update_position(QEMUFile *f, size_t size)
 272 {
 273     f->pos += size;
 274 }
 275
 276 /** Closes the file
 277  *
 278  * Returns negative error value if any error happened on previous operations or
 279  * while closing the file. Returns 0 or positive number on success.
 280  *
 281  * The meaning of return value on success depends on the specific backend
 282  * being used.
 283  */
 284 int qemu_fclose(QEMUFile *f)
 285 {
 286     int ret;
 287     qemu_fflush(f);
 288     ret = qemu_file_get_error(f);
 289
 290     if (f->ops->close) {
 291         int ret2 = f->ops->close(f->opaque);
 292         if (ret >= 0) {
 293             ret = ret2;
 294         }
 295     }
 296     /* If any error was spotted before closing, we should report it
 297      * instead of the close() return value.
 298      */
 299     if (f->last_error) {
 300         ret = f->last_error;
 301     }
 302     g_free(f);
 303     trace_qemu_file_fclose();
 304     return ret;
 305 }
 306
 307 static void add_to_iovec(QEMUFile *f, const uint8_t *buf, size_t size)
 308 {
 309     /* check for adjacent buffer and coalesce them */
 310     if (f->iovcnt > 0 && buf == f->iov[f->iovcnt - 1].iov_base +
 311         f->iov[f->iovcnt - 1].iov_len) {
 312         f->iov[f->iovcnt - 1].iov_len += size;
 313     } else {
 314         f->iov[f->iovcnt].iov_base = (uint8_t *)buf;
 315         f->iov[f->iovcnt++].iov_len = size;
 316     }
 317
 318     if (f->iovcnt >= MAX_IOV_SIZE) {
 319         qemu_fflush(f);
 320     }
 321 }
 322
 323 void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, size_t size)
 324 {
 325     if (f->last_error) {
 326         return;
 327     }
 328
 329     f->bytes_xfer += size;
 330     add_to_iovec(f, buf, size);
 331 }
 332
 333 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, size_t size)
 334 {
 335     size_t l;
 336
 337     if (f->last_error) {
 338         return;
 339     }
 340
 341     while (size > 0) {
 342         l = IO_BUF_SIZE - f->buf_index;
 343         if (l > size) {
 344             l = size;
 345         }
 346         memcpy(f->buf + f->buf_index, buf, l);
 347         f->bytes_xfer += l;
 348         add_to_iovec(f, f->buf + f->buf_index, l);
 349         f->buf_index += l;
 350         if (f->buf_index == IO_BUF_SIZE) {
 351             qemu_fflush(f);
 352         }
 353         if (qemu_file_get_error(f)) {
 354             break;
 355         }
 356         buf += l;
 357         size -= l;
 358     }
 359 }
 360
 361 void qemu_put_byte(QEMUFile *f, int v)
 362 {
 363     if (f->last_error) {
 364         return;
 365     }
 366
 367     f->buf[f->buf_index] = v;
 368     f->bytes_xfer++;
 369     add_to_iovec(f, f->buf + f->buf_index, 1);
 370     f->buf_index++;
 371     if (f->buf_index == IO_BUF_SIZE) {
 372         qemu_fflush(f);
 373     }
 374 }
 375
 376 void qemu_file_skip(QEMUFile *f, int size)
 377 {
 378     if (f->buf_index + size <= f->buf_size) {
 379         f->buf_index += size;
 380     }
 381 }
 382
 383 /*
 384  * Read 'size' bytes from file (at 'offset') without moving the
 385  * pointer and set 'buf' to point to that data.
 386  *
 387  * It will return size bytes unless there was an error, in which case it will
 388  * return as many as it managed to read (assuming blocking fd's which
 389  * all current QEMUFile are)
 390  */
 391 size_t qemu_peek_buffer(QEMUFile *f, uint8_t **buf, size_t size, size_t offset)
 392 {
 393     ssize_t pending;
 394     size_t index;
 395
 396     assert(!qemu_file_is_writable(f));
 397     assert(offset < IO_BUF_SIZE);
 398     assert(size <= IO_BUF_SIZE - offset);
 399
 400     /* The 1st byte to read from */
 401     index = f->buf_index + offset;
 402     /* The number of available bytes starting at index */
 403     pending = f->buf_size - index;
 404
 405     /*
 406      * qemu_fill_buffer might return just a few bytes, even when there isn't
 407      * an error, so loop collecting them until we get enough.
 408      */
 409     while (pending < size) {
 410         int received = qemu_fill_buffer(f);
 411
 412         if (received <= 0) {
 413             break;
 414         }
 415
 416         index = f->buf_index + offset;
 417         pending = f->buf_size - index;
 418     }
 419
 420     if (pending <= 0) {
 421         return 0;
 422     }
 423     if (size > pending) {
 424         size = pending;
 425     }
 426
 427     *buf = f->buf + index;
 428     return size;
 429 }
 430
 431 /*
 432  * Read 'size' bytes of data from the file into buf.
 433  * 'size' can be larger than the internal buffer.
 434  *
 435  * It will return size bytes unless there was an error, in which case it will
 436  * return as many as it managed to read (assuming blocking fd's which
 437  * all current QEMUFile are)
 438  */
 439 size_t qemu_get_buffer(QEMUFile *f, uint8_t *buf, size_t size)
 440 {
 441     size_t pending = size;
 442     size_t done = 0;
 443
 444     while (pending > 0) {
 445         size_t res;
 446         uint8_t *src;
 447
 448         res = qemu_peek_buffer(f, &src, MIN(pending, IO_BUF_SIZE), 0);
 449         if (res == 0) {
 450             return done;
 451         }
 452         memcpy(buf, src, res);
 453         qemu_file_skip(f, res);
 454         buf += res;
 455         pending -= res;
 456         done += res;
 457     }
 458     return done;
 459 }
 460
 461 /*
 462  * Read 'size' bytes of data from the file.
 463  * 'size' can be larger than the internal buffer.
 464  *
 465  * The data:
 466  *   may be held on an internal buffer (in which case *buf is updated
 467  *     to point to it) that is valid until the next qemu_file operation.
 468  * OR
 469  *   will be copied to the *buf that was passed in.
 470  *
 471  * The code tries to avoid the copy if possible.
 472  *
 473  * It will return size bytes unless there was an error, in which case it will
 474  * return as many as it managed to read (assuming blocking fd's which
 475  * all current QEMUFile are)
 476  *
 477  * Note: Since **buf may get changed, the caller should take care to
 478  *       keep a pointer to the original buffer if it needs to deallocate it.
 479  */
 480 size_t qemu_get_buffer_in_place(QEMUFile *f, uint8_t **buf, size_t size)
 481 {
 482     if (size < IO_BUF_SIZE) {
 483         size_t res;
 484         uint8_t *src;
 485
 486         res = qemu_peek_buffer(f, &src, size, 0);
 487
 488         if (res == size) {
 489             qemu_file_skip(f, res);
 490             *buf = src;
 491             return res;
 492         }
 493     }
 494
 495     return qemu_get_buffer(f, *buf, size);
 496 }
 497
 498 /*
 499  * Peeks a single byte from the buffer; this isn't guaranteed to work if
 500  * offset leaves a gap after the previous read/peeked data.
 501  */
 502 int qemu_peek_byte(QEMUFile *f, int offset)
 503 {
 504     int index = f->buf_index + offset;
 505
 506     assert(!qemu_file_is_writable(f));
 507     assert(offset < IO_BUF_SIZE);
 508
 509     if (index >= f->buf_size) {
 510         qemu_fill_buffer(f);
 511         index = f->buf_index + offset;
 512         if (index >= f->buf_size) {
 513             return 0;
 514         }
 515     }
 516     return f->buf[index];
 517 }
 518
 519 int qemu_get_byte(QEMUFile *f)
 520 {
 521     int result;
 522
 523     result = qemu_peek_byte(f, 0);
 524     qemu_file_skip(f, 1);
 525     return result;
 526 }
 527
 528 int64_t qemu_ftell_fast(QEMUFile *f)
 529 {
 530     int64_t ret = f->pos;
 531     int i;
 532
 533     for (i = 0; i < f->iovcnt; i++) {
 534         ret += f->iov[i].iov_len;
 535     }
 536
 537     return ret;
 538 }
 539
 540 int64_t qemu_ftell(QEMUFile *f)
 541 {
 542     qemu_fflush(f);
 543     return f->pos;
 544 }
 545
 546 int qemu_file_rate_limit(QEMUFile *f)
 547 {
 548     if (qemu_file_get_error(f)) {
 549         return 1;
 550     }
 551     if (f->xfer_limit > 0 && f->bytes_xfer > f->xfer_limit) {
 552         return 1;
 553     }
 554     return 0;
 555 }
 556
 557 int64_t qemu_file_get_rate_limit(QEMUFile *f)
 558 {
 559     return f->xfer_limit;
 560 }
 561
 562 void qemu_file_set_rate_limit(QEMUFile *f, int64_t limit)
 563 {
 564     f->xfer_limit = limit;
 565 }
 566
 567 void qemu_file_reset_rate_limit(QEMUFile *f)
 568 {
 569     f->bytes_xfer = 0;
 570 }
 571
 572 void qemu_put_be16(QEMUFile *f, unsigned int v)
 573 {
 574     qemu_put_byte(f, v >> 8);
 575     qemu_put_byte(f, v);
 576 }
 577
 578 void qemu_put_be32(QEMUFile *f, unsigned int v)
 579 {
 580     qemu_put_byte(f, v >> 24);
 581     qemu_put_byte(f, v >> 16);
 582     qemu_put_byte(f, v >> 8);
 583     qemu_put_byte(f, v);
 584 }
 585
 586 void qemu_put_be64(QEMUFile *f, uint64_t v)
 587 {
 588     qemu_put_be32(f, v >> 32);
 589     qemu_put_be32(f, v);
 590 }
 591
 592 unsigned int qemu_get_be16(QEMUFile *f)
 593 {
 594     unsigned int v;
 595     v = qemu_get_byte(f) << 8;
 596     v |= qemu_get_byte(f);
 597     return v;
 598 }
 599
 600 unsigned int qemu_get_be32(QEMUFile *f)
 601 {
 602     unsigned int v;
 603     v = (unsigned int)qemu_get_byte(f) << 24;
 604     v |= qemu_get_byte(f) << 16;
 605     v |= qemu_get_byte(f) << 8;
 606     v |= qemu_get_byte(f);
 607     return v;
 608 }
 609
 610 uint64_t qemu_get_be64(QEMUFile *f)
 611 {
 612     uint64_t v;
 613     v = (uint64_t)qemu_get_be32(f) << 32;
 614     v |= qemu_get_be32(f);
 615     return v;
 616 }
 617
 618 /* compress size bytes of data start at p with specific compression
 619  * level and store the compressed data to the buffer of f.
 620  */
 621
 622 ssize_t qemu_put_compression_data(QEMUFile *f, const uint8_t *p, size_t size,
 623                                   int level)
 624 {
 625     ssize_t blen = IO_BUF_SIZE - f->buf_index - sizeof(int32_t);
 626
 627     if (blen < compressBound(size)) {
 628         return 0;
 629     }
 630     if (compress2(f->buf + f->buf_index + sizeof(int32_t), (uLongf *)&blen,
 631                   (Bytef *)p, size, level) != Z_OK) {
 632         error_report("Compress Failed!");
 633         return 0;
 634     }
 635     qemu_put_be32(f, blen);
 636     f->buf_index += blen;
 637     return blen + sizeof(int32_t);
 638 }
 639
 640 /* Put the data in the buffer of f_src to the buffer of f_des, and
 641  * then reset the buf_index of f_src to 0.
 642  */
 643
 644 int qemu_put_qemu_file(QEMUFile *f_des, QEMUFile *f_src)
 645 {
 646     int len = 0;
 647
 648     if (f_src->buf_index > 0) {
 649         len = f_src->buf_index;
 650         qemu_put_buffer(f_des, f_src->buf, f_src->buf_index);
 651         f_src->buf_index = 0;
 652     }
 653     return len;
 654 }
 655
 656 /*
 657  * Get a string whose length is determined by a single preceding byte
 658  * A preallocated 256 byte buffer must be passed in.
 659  * Returns: len on success and a 0 terminated string in the buffer
 660  *          else 0
 661  *          (Note a 0 length string will return 0 either way)
 662  */
 663 size_t qemu_get_counted_string(QEMUFile *f, char buf[256])
 664 {
 665     size_t len = qemu_get_byte(f);
 666     size_t res = qemu_get_buffer(f, (uint8_t *)buf, len);
 667
 668     buf[res] = 0;
 669
 670     return res == len ? res : 0;
 671 }
 672
 673 /*
 674  * Set the blocking state of the QEMUFile.
 675  * Note: On some transports the OS only keeps a single blocking state for
 676  *       both directions, and thus changing the blocking on the main
 677  *       QEMUFile can also affect the return path.
 678  */
 679 void qemu_file_set_blocking(QEMUFile *f, bool block)
 680 {
 681     if (f->ops->set_blocking) {
 682         f->ops->set_blocking(f->opaque, block);
 683     }
 684 }