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 <zlib.h>
  25 #include "qemu-common.h"
  26 #include "qemu/error-report.h"
  27 #include "qemu/iov.h"
  28 #include "qemu/sockets.h"
  29 #include "qemu/coroutine.h"
  30 #include "migration/migration.h"
  31 #include "migration/qemu-file.h"
  32 #include "migration/qemu-file-internal.h"
  33 #include "trace.h"
  34
  35 /*
  36  * Stop a file from being read/written - not all backing files can do this
  37  * typically only sockets can.
  38  */
  39 int qemu_file_shutdown(QEMUFile *f)
  40 {
  41     if (!f->ops->shut_down) {
  42         return -ENOSYS;
  43     }
  44     return f->ops->shut_down(f->opaque, true, true);
  45 }
  46
  47 bool qemu_file_mode_is_not_valid(const char *mode)
  48 {
  49     if (mode == NULL ||
  50         (mode[0] != 'r' && mode[0] != 'w') ||
  51         mode[1] != 'b' || mode[2] != 0) {
  52         fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
  53         return true;
  54     }
  55
  56     return false;
  57 }
  58
  59 QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)
  60 {
  61     QEMUFile *f;
  62
  63     f = g_new0(QEMUFile, 1);
  64
  65     f->opaque = opaque;
  66     f->ops = ops;
  67     return f;
  68 }
  69
  70 /*
  71  * Get last error for stream f
  72  *
  73  * Return negative error value if there has been an error on previous
  74  * operations, return 0 if no error happened.
  75  *
  76  */
  77 int qemu_file_get_error(QEMUFile *f)
  78 {
  79     return f->last_error;
  80 }
  81
  82 void qemu_file_set_error(QEMUFile *f, int ret)
  83 {
  84     if (f->last_error == 0) {
  85         f->last_error = ret;
  86     }
  87 }
  88
  89 bool qemu_file_is_writable(QEMUFile *f)
  90 {
  91     return f->ops->writev_buffer || f->ops->put_buffer;
  92 }
  93
  94 /**
  95  * Flushes QEMUFile buffer
  96  *
  97  * If there is writev_buffer QEMUFileOps it uses it otherwise uses
  98  * put_buffer ops.
  99  */
 100 void qemu_fflush(QEMUFile *f)
 101 {
 102     ssize_t ret = 0;
 103
 104     if (!qemu_file_is_writable(f)) {
 105         return;
 106     }
 107
 108     if (f->ops->writev_buffer) {
 109         if (f->iovcnt > 0) {
 110             ret = f->ops->writev_buffer(f->opaque, f->iov, f->iovcnt, f->pos);
 111         }
 112     } else {
 113         if (f->buf_index > 0) {
 114             ret = f->ops->put_buffer(f->opaque, f->buf, f->pos, f->buf_index);
 115         }
 116     }
 117     if (ret >= 0) {
 118         f->pos += ret;
 119     }
 120     f->buf_index = 0;
 121     f->iovcnt = 0;
 122     if (ret < 0) {
 123         qemu_file_set_error(f, ret);
 124     }
 125 }
 126
 127 void ram_control_before_iterate(QEMUFile *f, uint64_t flags)
 128 {
 129     int ret = 0;
 130
 131     if (f->ops->before_ram_iterate) {
 132         ret = f->ops->before_ram_iterate(f, f->opaque, flags, NULL);
 133         if (ret < 0) {
 134             qemu_file_set_error(f, ret);
 135         }
 136     }
 137 }
 138
 139 void ram_control_after_iterate(QEMUFile *f, uint64_t flags)
 140 {
 141     int ret = 0;
 142
 143     if (f->ops->after_ram_iterate) {
 144         ret = f->ops->after_ram_iterate(f, f->opaque, flags, NULL);
 145         if (ret < 0) {
 146             qemu_file_set_error(f, ret);
 147         }
 148     }
 149 }
 150
 151 void ram_control_load_hook(QEMUFile *f, uint64_t flags, void *data)
 152 {
 153     int ret = -EINVAL;
 154
 155     if (f->ops->hook_ram_load) {
 156         ret = f->ops->hook_ram_load(f, f->opaque, flags, data);
 157         if (ret < 0) {
 158             qemu_file_set_error(f, ret);
 159         }
 160     } else {
 161         /*
 162          * Hook is a hook specifically requested by the source sending a flag
 163          * that expects there to be a hook on the destination.
 164          */
 165         if (flags == RAM_CONTROL_HOOK) {
 166             qemu_file_set_error(f, ret);
 167         }
 168     }
 169 }
 170
 171 size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset,
 172                              ram_addr_t offset, size_t size,
 173                              uint64_t *bytes_sent)
 174 {
 175     if (f->ops->save_page) {
 176         int ret = f->ops->save_page(f, f->opaque, block_offset,
 177                                     offset, size, bytes_sent);
 178
 179         if (ret != RAM_SAVE_CONTROL_DELAYED) {
 180             if (bytes_sent && *bytes_sent > 0) {
 181                 qemu_update_position(f, *bytes_sent);
 182             } else if (ret < 0) {
 183                 qemu_file_set_error(f, ret);
 184             }
 185         }
 186
 187         return ret;
 188     }
 189
 190     return RAM_SAVE_CONTROL_NOT_SUPP;
 191 }
 192
 193 /*
 194  * Attempt to fill the buffer from the underlying file
 195  * Returns the number of bytes read, or negative value for an error.
 196  *
 197  * Note that it can return a partially full buffer even in a not error/not EOF
 198  * case if the underlying file descriptor gives a short read, and that can
 199  * happen even on a blocking fd.
 200  */
 201 static ssize_t qemu_fill_buffer(QEMUFile *f)
 202 {
 203     int len;
 204     int pending;
 205
 206     assert(!qemu_file_is_writable(f));
 207
 208     pending = f->buf_size - f->buf_index;
 209     if (pending > 0) {
 210         memmove(f->buf, f->buf + f->buf_index, pending);
 211     }
 212     f->buf_index = 0;
 213     f->buf_size = pending;
 214
 215     len = f->ops->get_buffer(f->opaque, f->buf + pending, f->pos,
 216                         IO_BUF_SIZE - pending);
 217     if (len > 0) {
 218         f->buf_size += len;
 219         f->pos += len;
 220     } else if (len == 0) {
 221         qemu_file_set_error(f, -EIO);
 222     } else if (len != -EAGAIN) {
 223         qemu_file_set_error(f, len);
 224     }
 225
 226     return len;
 227 }
 228
 229 int qemu_get_fd(QEMUFile *f)
 230 {
 231     if (f->ops->get_fd) {
 232         return f->ops->get_fd(f->opaque);
 233     }
 234     return -1;
 235 }
 236
 237 void qemu_update_position(QEMUFile *f, size_t size)
 238 {
 239     f->pos += size;
 240 }
 241
 242 /** Closes the file
 243  *
 244  * Returns negative error value if any error happened on previous operations or
 245  * while closing the file. Returns 0 or positive number on success.
 246  *
 247  * The meaning of return value on success depends on the specific backend
 248  * being used.
 249  */
 250 int qemu_fclose(QEMUFile *f)
 251 {
 252     int ret;
 253     qemu_fflush(f);
 254     ret = qemu_file_get_error(f);
 255
 256     if (f->ops->close) {
 257         int ret2 = f->ops->close(f->opaque);
 258         if (ret >= 0) {
 259             ret = ret2;
 260         }
 261     }
 262     /* If any error was spotted before closing, we should report it
 263      * instead of the close() return value.
 264      */
 265     if (f->last_error) {
 266         ret = f->last_error;
 267     }
 268     g_free(f);
 269     trace_qemu_file_fclose();
 270     return ret;
 271 }
 272
 273 static void add_to_iovec(QEMUFile *f, const uint8_t *buf, size_t size)
 274 {
 275     /* check for adjacent buffer and coalesce them */
 276     if (f->iovcnt > 0 && buf == f->iov[f->iovcnt - 1].iov_base +
 277         f->iov[f->iovcnt - 1].iov_len) {
 278         f->iov[f->iovcnt - 1].iov_len += size;
 279     } else {
 280         f->iov[f->iovcnt].iov_base = (uint8_t *)buf;
 281         f->iov[f->iovcnt++].iov_len = size;
 282     }
 283
 284     if (f->iovcnt >= MAX_IOV_SIZE) {
 285         qemu_fflush(f);
 286     }
 287 }
 288
 289 void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, size_t size)
 290 {
 291     if (!f->ops->writev_buffer) {
 292         qemu_put_buffer(f, buf, size);
 293         return;
 294     }
 295
 296     if (f->last_error) {
 297         return;
 298     }
 299
 300     f->bytes_xfer += size;
 301     add_to_iovec(f, buf, size);
 302 }
 303
 304 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, size_t size)
 305 {
 306     size_t l;
 307
 308     if (f->last_error) {
 309         return;
 310     }
 311
 312     while (size > 0) {
 313         l = IO_BUF_SIZE - f->buf_index;
 314         if (l > size) {
 315             l = size;
 316         }
 317         memcpy(f->buf + f->buf_index, buf, l);
 318         f->bytes_xfer += l;
 319         if (f->ops->writev_buffer) {
 320             add_to_iovec(f, f->buf + f->buf_index, l);
 321         }
 322         f->buf_index += l;
 323         if (f->buf_index == IO_BUF_SIZE) {
 324             qemu_fflush(f);
 325         }
 326         if (qemu_file_get_error(f)) {
 327             break;
 328         }
 329         buf += l;
 330         size -= l;
 331     }
 332 }
 333
 334 void qemu_put_byte(QEMUFile *f, int v)
 335 {
 336     if (f->last_error) {
 337         return;
 338     }
 339
 340     f->buf[f->buf_index] = v;
 341     f->bytes_xfer++;
 342     if (f->ops->writev_buffer) {
 343         add_to_iovec(f, f->buf + f->buf_index, 1);
 344     }
 345     f->buf_index++;
 346     if (f->buf_index == IO_BUF_SIZE) {
 347         qemu_fflush(f);
 348     }
 349 }
 350
 351 void qemu_file_skip(QEMUFile *f, int size)
 352 {
 353     if (f->buf_index + size <= f->buf_size) {
 354         f->buf_index += size;
 355     }
 356 }
 357
 358 /*
 359  * Read 'size' bytes from file (at 'offset') without moving the
 360  * pointer and set 'buf' to point to that data.
 361  *
 362  * It will return size bytes unless there was an error, in which case it will
 363  * return as many as it managed to read (assuming blocking fd's which
 364  * all current QEMUFile are)
 365  */
 366 size_t qemu_peek_buffer(QEMUFile *f, uint8_t **buf, size_t size, size_t offset)
 367 {
 368     ssize_t pending;
 369     size_t index;
 370
 371     assert(!qemu_file_is_writable(f));
 372     assert(offset < IO_BUF_SIZE);
 373     assert(size <= IO_BUF_SIZE - offset);
 374
 375     /* The 1st byte to read from */
 376     index = f->buf_index + offset;
 377     /* The number of available bytes starting at index */
 378     pending = f->buf_size - index;
 379
 380     /*
 381      * qemu_fill_buffer might return just a few bytes, even when there isn't
 382      * an error, so loop collecting them until we get enough.
 383      */
 384     while (pending < size) {
 385         int received = qemu_fill_buffer(f);
 386
 387         if (received <= 0) {
 388             break;
 389         }
 390
 391         index = f->buf_index + offset;
 392         pending = f->buf_size - index;
 393     }
 394
 395     if (pending <= 0) {
 396         return 0;
 397     }
 398     if (size > pending) {
 399         size = pending;
 400     }
 401
 402     *buf = f->buf + index;
 403     return size;
 404 }
 405
 406 /*
 407  * Read 'size' bytes of data from the file into buf.
 408  * 'size' can be larger than the internal buffer.
 409  *
 410  * It will return size bytes unless there was an error, in which case it will
 411  * return as many as it managed to read (assuming blocking fd's which
 412  * all current QEMUFile are)
 413  */
 414 size_t qemu_get_buffer(QEMUFile *f, uint8_t *buf, size_t size)
 415 {
 416     size_t pending = size;
 417     size_t done = 0;
 418
 419     while (pending > 0) {
 420         size_t res;
 421         uint8_t *src;
 422
 423         res = qemu_peek_buffer(f, &src, MIN(pending, IO_BUF_SIZE), 0);
 424         if (res == 0) {
 425             return done;
 426         }
 427         memcpy(buf, src, res);
 428         qemu_file_skip(f, res);
 429         buf += res;
 430         pending -= res;
 431         done += res;
 432     }
 433     return done;
 434 }
 435
 436 /*
 437  * Peeks a single byte from the buffer; this isn't guaranteed to work if
 438  * offset leaves a gap after the previous read/peeked data.
 439  */
 440 int qemu_peek_byte(QEMUFile *f, int offset)
 441 {
 442     int index = f->buf_index + offset;
 443
 444     assert(!qemu_file_is_writable(f));
 445     assert(offset < IO_BUF_SIZE);
 446
 447     if (index >= f->buf_size) {
 448         qemu_fill_buffer(f);
 449         index = f->buf_index + offset;
 450         if (index >= f->buf_size) {
 451             return 0;
 452         }
 453     }
 454     return f->buf[index];
 455 }
 456
 457 int qemu_get_byte(QEMUFile *f)
 458 {
 459     int result;
 460
 461     result = qemu_peek_byte(f, 0);
 462     qemu_file_skip(f, 1);
 463     return result;
 464 }
 465
 466 int64_t qemu_ftell_fast(QEMUFile *f)
 467 {
 468     int64_t ret = f->pos;
 469     int i;
 470
 471     if (f->ops->writev_buffer) {
 472         for (i = 0; i < f->iovcnt; i++) {
 473             ret += f->iov[i].iov_len;
 474         }
 475     } else {
 476         ret += f->buf_index;
 477     }
 478
 479     return ret;
 480 }
 481
 482 int64_t qemu_ftell(QEMUFile *f)
 483 {
 484     qemu_fflush(f);
 485     return f->pos;
 486 }
 487
 488 int qemu_file_rate_limit(QEMUFile *f)
 489 {
 490     if (qemu_file_get_error(f)) {
 491         return 1;
 492     }
 493     if (f->xfer_limit > 0 && f->bytes_xfer > f->xfer_limit) {
 494         return 1;
 495     }
 496     return 0;
 497 }
 498
 499 int64_t qemu_file_get_rate_limit(QEMUFile *f)
 500 {
 501     return f->xfer_limit;
 502 }
 503
 504 void qemu_file_set_rate_limit(QEMUFile *f, int64_t limit)
 505 {
 506     f->xfer_limit = limit;
 507 }
 508
 509 void qemu_file_reset_rate_limit(QEMUFile *f)
 510 {
 511     f->bytes_xfer = 0;
 512 }
 513
 514 void qemu_put_be16(QEMUFile *f, unsigned int v)
 515 {
 516     qemu_put_byte(f, v >> 8);
 517     qemu_put_byte(f, v);
 518 }
 519
 520 void qemu_put_be32(QEMUFile *f, unsigned int v)
 521 {
 522     qemu_put_byte(f, v >> 24);
 523     qemu_put_byte(f, v >> 16);
 524     qemu_put_byte(f, v >> 8);
 525     qemu_put_byte(f, v);
 526 }
 527
 528 void qemu_put_be64(QEMUFile *f, uint64_t v)
 529 {
 530     qemu_put_be32(f, v >> 32);
 531     qemu_put_be32(f, v);
 532 }
 533
 534 unsigned int qemu_get_be16(QEMUFile *f)
 535 {
 536     unsigned int v;
 537     v = qemu_get_byte(f) << 8;
 538     v |= qemu_get_byte(f);
 539     return v;
 540 }
 541
 542 unsigned int qemu_get_be32(QEMUFile *f)
 543 {
 544     unsigned int v;
 545     v = (unsigned int)qemu_get_byte(f) << 24;
 546     v |= qemu_get_byte(f) << 16;
 547     v |= qemu_get_byte(f) << 8;
 548     v |= qemu_get_byte(f);
 549     return v;
 550 }
 551
 552 uint64_t qemu_get_be64(QEMUFile *f)
 553 {
 554     uint64_t v;
 555     v = (uint64_t)qemu_get_be32(f) << 32;
 556     v |= qemu_get_be32(f);
 557     return v;
 558 }
 559
 560 /* compress size bytes of data start at p with specific compression
 561  * level and store the compressed data to the buffer of f.
 562  */
 563
 564 ssize_t qemu_put_compression_data(QEMUFile *f, const uint8_t *p, size_t size,
 565                                   int level)
 566 {
 567     ssize_t blen = IO_BUF_SIZE - f->buf_index - sizeof(int32_t);
 568
 569     if (blen < compressBound(size)) {
 570         return 0;
 571     }
 572     if (compress2(f->buf + f->buf_index + sizeof(int32_t), (uLongf *)&blen,
 573                   (Bytef *)p, size, level) != Z_OK) {
 574         error_report("Compress Failed!");
 575         return 0;
 576     }
 577     qemu_put_be32(f, blen);
 578     f->buf_index += blen;
 579     return blen + sizeof(int32_t);
 580 }
 581
 582 /* Put the data in the buffer of f_src to the buffer of f_des, and
 583  * then reset the buf_index of f_src to 0.
 584  */
 585
 586 int qemu_put_qemu_file(QEMUFile *f_des, QEMUFile *f_src)
 587 {
 588     int len = 0;
 589
 590     if (f_src->buf_index > 0) {
 591         len = f_src->buf_index;
 592         qemu_put_buffer(f_des, f_src->buf, f_src->buf_index);
 593         f_src->buf_index = 0;
 594     }
 595     return len;
 596 }
 597
 598 /*
 599  * Get a string whose length is determined by a single preceding byte
 600  * A preallocated 256 byte buffer must be passed in.
 601  * Returns: len on success and a 0 terminated string in the buffer
 602  *          else 0
 603  *          (Note a 0 length string will return 0 either way)
 604  */
 605 size_t qemu_get_counted_string(QEMUFile *f, char buf[256])
 606 {
 607     size_t len = qemu_get_byte(f);
 608     size_t res = qemu_get_buffer(f, (uint8_t *)buf, len);
 609
 610     buf[res] = 0;
 611
 612     return res == len ? res : 0;
 613 }