qemu/migration/qemu-file-buf.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  * Copyright (c) 2014 IBM Corp.
   6  *
   7  * Authors:
   8  *  Stefan Berger <stefanb@linux.vnet.ibm.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  23  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  26  * THE SOFTWARE.
  27  */
  28 #include "qemu/osdep.h"
  29 #include "qemu-common.h"
  30 #include "qemu/error-report.h"
  31 #include "qemu/iov.h"
  32 #include "qemu/sockets.h"
  33 #include "qemu/coroutine.h"
  34 #include "migration/migration.h"
  35 #include "migration/qemu-file.h"
  36 #include "migration/qemu-file-internal.h"
  37 #include "trace.h"
  38
  39 #define QSB_CHUNK_SIZE      (1 << 10)
  40 #define QSB_MAX_CHUNK_SIZE  (16 * QSB_CHUNK_SIZE)
  41
  42 /**
  43  * Create a QEMUSizedBuffer
  44  * This type of buffer uses scatter-gather lists internally and
  45  * can grow to any size. Any data array in the scatter-gather list
  46  * can hold different amount of bytes.
  47  *
  48  * @buffer: Optional buffer to copy into the QSB
  49  * @len: size of initial buffer; if @buffer is given, buffer must
  50  *       hold at least len bytes
  51  *
  52  * Returns a pointer to a QEMUSizedBuffer or NULL on allocation failure
  53  */
  54 QEMUSizedBuffer *qsb_create(const uint8_t *buffer, size_t len)
  55 {
  56     QEMUSizedBuffer *qsb;
  57     size_t alloc_len, num_chunks, i, to_copy;
  58     size_t chunk_size = (len > QSB_MAX_CHUNK_SIZE)
  59                         ? QSB_MAX_CHUNK_SIZE
  60                         : QSB_CHUNK_SIZE;
  61
  62     num_chunks = DIV_ROUND_UP(len ? len : QSB_CHUNK_SIZE, chunk_size);
  63     alloc_len = num_chunks * chunk_size;
  64
  65     qsb = g_try_new0(QEMUSizedBuffer, 1);
  66     if (!qsb) {
  67         return NULL;
  68     }
  69
  70     qsb->iov = g_try_new0(struct iovec, num_chunks);
  71     if (!qsb->iov) {
  72         g_free(qsb);
  73         return NULL;
  74     }
  75
  76     qsb->n_iov = num_chunks;
  77
  78     for (i = 0; i < num_chunks; i++) {
  79         qsb->iov[i].iov_base = g_try_malloc0(chunk_size);
  80         if (!qsb->iov[i].iov_base) {
  81             /* qsb_free is safe since g_free can cope with NULL */
  82             qsb_free(qsb);
  83             return NULL;
  84         }
  85
  86         qsb->iov[i].iov_len = chunk_size;
  87         if (buffer) {
  88             to_copy = (len - qsb->used) > chunk_size
  89                       ? chunk_size : (len - qsb->used);
  90             memcpy(qsb->iov[i].iov_base, &buffer[qsb->used], to_copy);
  91             qsb->used += to_copy;
  92         }
  93     }
  94
  95     qsb->size = alloc_len;
  96
  97     return qsb;
  98 }
  99
 100 /**
 101  * Free the QEMUSizedBuffer
 102  *
 103  * @qsb: The QEMUSizedBuffer to free
 104  */
 105 void qsb_free(QEMUSizedBuffer *qsb)
 106 {
 107     size_t i;
 108
 109     if (!qsb) {
 110         return;
 111     }
 112
 113     for (i = 0; i < qsb->n_iov; i++) {
 114         g_free(qsb->iov[i].iov_base);
 115     }
 116     g_free(qsb->iov);
 117     g_free(qsb);
 118 }
 119
 120 /**
 121  * Get the number of used bytes in the QEMUSizedBuffer
 122  *
 123  * @qsb: A QEMUSizedBuffer
 124  *
 125  * Returns the number of bytes currently used in this buffer
 126  */
 127 size_t qsb_get_length(const QEMUSizedBuffer *qsb)
 128 {
 129     return qsb->used;
 130 }
 131
 132 /**
 133  * Set the length of the buffer; the primary usage of this
 134  * function is to truncate the number of used bytes in the buffer.
 135  * The size will not be extended beyond the current number of
 136  * allocated bytes in the QEMUSizedBuffer.
 137  *
 138  * @qsb: A QEMUSizedBuffer
 139  * @new_len: The new length of bytes in the buffer
 140  *
 141  * Returns the number of bytes the buffer was truncated or extended
 142  * to.
 143  */
 144 size_t qsb_set_length(QEMUSizedBuffer *qsb, size_t new_len)
 145 {
 146     if (new_len <= qsb->size) {
 147         qsb->used = new_len;
 148     } else {
 149         qsb->used = qsb->size;
 150     }
 151     return qsb->used;
 152 }
 153
 154 /**
 155  * Get the iovec that holds the data for a given position @pos.
 156  *
 157  * @qsb: A QEMUSizedBuffer
 158  * @pos: The index of a byte in the buffer
 159  * @d_off: Pointer to an offset that this function will indicate
 160  *         at what position within the returned iovec the byte
 161  *         is to be found
 162  *
 163  * Returns the index of the iovec that holds the byte at the given
 164  * index @pos in the byte stream; a negative number if the iovec
 165  * for the given position @pos does not exist.
 166  */
 167 static ssize_t qsb_get_iovec(const QEMUSizedBuffer *qsb,
 168                              off_t pos, off_t *d_off)
 169 {
 170     ssize_t i;
 171     off_t curr = 0;
 172
 173     if (pos > qsb->used) {
 174         return -1;
 175     }
 176
 177     for (i = 0; i < qsb->n_iov; i++) {
 178         if (curr + qsb->iov[i].iov_len > pos) {
 179             *d_off = pos - curr;
 180             return i;
 181         }
 182         curr += qsb->iov[i].iov_len;
 183     }
 184     return -1;
 185 }
 186
 187 /*
 188  * Convert the QEMUSizedBuffer into a flat buffer.
 189  *
 190  * Note: If at all possible, try to avoid this function since it
 191  *       may unnecessarily copy memory around.
 192  *
 193  * @qsb: pointer to QEMUSizedBuffer
 194  * @start: offset to start at
 195  * @count: number of bytes to copy
 196  * @buf: a pointer to a buffer to write into (at least @count bytes)
 197  *
 198  * Returns the number of bytes copied into the output buffer
 199  */
 200 ssize_t qsb_get_buffer(const QEMUSizedBuffer *qsb, off_t start,
 201                        size_t count, uint8_t *buffer)
 202 {
 203     const struct iovec *iov;
 204     size_t to_copy, all_copy;
 205     ssize_t index;
 206     off_t s_off;
 207     off_t d_off = 0;
 208     char *s;
 209
 210     if (start > qsb->used) {
 211         return 0;
 212     }
 213
 214     all_copy = qsb->used - start;
 215     if (all_copy > count) {
 216         all_copy = count;
 217     } else {
 218         count = all_copy;
 219     }
 220
 221     index = qsb_get_iovec(qsb, start, &s_off);
 222     if (index < 0) {
 223         return 0;
 224     }
 225
 226     while (all_copy > 0) {
 227         iov = &qsb->iov[index];
 228
 229         s = iov->iov_base;
 230
 231         to_copy = iov->iov_len - s_off;
 232         if (to_copy > all_copy) {
 233             to_copy = all_copy;
 234         }
 235         memcpy(&buffer[d_off], &s[s_off], to_copy);
 236
 237         d_off += to_copy;
 238         all_copy -= to_copy;
 239
 240         s_off = 0;
 241         index++;
 242     }
 243
 244     return count;
 245 }
 246
 247 /**
 248  * Grow the QEMUSizedBuffer to the given size and allocate
 249  * memory for it.
 250  *
 251  * @qsb: A QEMUSizedBuffer
 252  * @new_size: The new size of the buffer
 253  *
 254  * Return:
 255  *    a negative error code in case of memory allocation failure
 256  * or
 257  *    the new size of the buffer. The returned size may be greater or equal
 258  *    to @new_size.
 259  */
 260 static ssize_t qsb_grow(QEMUSizedBuffer *qsb, size_t new_size)
 261 {
 262     size_t needed_chunks, i;
 263
 264     if (qsb->size < new_size) {
 265         struct iovec *new_iov;
 266         size_t size_diff = new_size - qsb->size;
 267         size_t chunk_size = (size_diff > QSB_MAX_CHUNK_SIZE)
 268                              ? QSB_MAX_CHUNK_SIZE : QSB_CHUNK_SIZE;
 269
 270         needed_chunks = DIV_ROUND_UP(size_diff, chunk_size);
 271
 272         new_iov = g_try_new(struct iovec, qsb->n_iov + needed_chunks);
 273         if (new_iov == NULL) {
 274             return -ENOMEM;
 275         }
 276
 277         /* Allocate new chunks as needed into new_iov */
 278         for (i = qsb->n_iov; i < qsb->n_iov + needed_chunks; i++) {
 279             new_iov[i].iov_base = g_try_malloc0(chunk_size);
 280             new_iov[i].iov_len = chunk_size;
 281             if (!new_iov[i].iov_base) {
 282                 size_t j;
 283
 284                 /* Free previously allocated new chunks */
 285                 for (j = qsb->n_iov; j < i; j++) {
 286                     g_free(new_iov[j].iov_base);
 287                 }
 288                 g_free(new_iov);
 289
 290                 return -ENOMEM;
 291             }
 292         }
 293
 294         /*
 295          * Now we can't get any allocation errors, copy over to new iov
 296          * and switch.
 297          */
 298         for (i = 0; i < qsb->n_iov; i++) {
 299             new_iov[i] = qsb->iov[i];
 300         }
 301
 302         qsb->n_iov += needed_chunks;
 303         g_free(qsb->iov);
 304         qsb->iov = new_iov;
 305         qsb->size += (needed_chunks * chunk_size);
 306     }
 307
 308     return qsb->size;
 309 }
 310
 311 /**
 312  * Write into the QEMUSizedBuffer at a given position and a given
 313  * number of bytes. This function will automatically grow the
 314  * QEMUSizedBuffer.
 315  *
 316  * @qsb: A QEMUSizedBuffer
 317  * @source: A byte array to copy data from
 318  * @pos: The position within the @qsb to write data to
 319  * @size: The number of bytes to copy into the @qsb
 320  *
 321  * Returns @size or a negative error code in case of memory allocation failure,
 322  *           or with an invalid 'pos'
 323  */
 324 ssize_t qsb_write_at(QEMUSizedBuffer *qsb, const uint8_t *source,
 325                      off_t pos, size_t count)
 326 {
 327     ssize_t rc = qsb_grow(qsb, pos + count);
 328     size_t to_copy;
 329     size_t all_copy = count;
 330     const struct iovec *iov;
 331     ssize_t index;
 332     char *dest;
 333     off_t d_off, s_off = 0;
 334
 335     if (rc < 0) {
 336         return rc;
 337     }
 338
 339     if (pos + count > qsb->used) {
 340         qsb->used = pos + count;
 341     }
 342
 343     index = qsb_get_iovec(qsb, pos, &d_off);
 344     if (index < 0) {
 345         return -EINVAL;
 346     }
 347
 348     while (all_copy > 0) {
 349         iov = &qsb->iov[index];
 350
 351         dest = iov->iov_base;
 352
 353         to_copy = iov->iov_len - d_off;
 354         if (to_copy > all_copy) {
 355             to_copy = all_copy;
 356         }
 357
 358         memcpy(&dest[d_off], &source[s_off], to_copy);
 359
 360         s_off += to_copy;
 361         all_copy -= to_copy;
 362
 363         d_off = 0;
 364         index++;
 365     }
 366
 367     return count;
 368 }
 369
 370 typedef struct QEMUBuffer {
 371     QEMUSizedBuffer *qsb;
 372     QEMUFile *file;
 373     bool qsb_allocated;
 374 } QEMUBuffer;
 375
 376 static ssize_t buf_get_buffer(void *opaque, uint8_t *buf, int64_t pos,
 377                               size_t size)
 378 {
 379     QEMUBuffer *s = opaque;
 380     ssize_t len = qsb_get_length(s->qsb) - pos;
 381
 382     if (len <= 0) {
 383         return 0;
 384     }
 385
 386     if (len > size) {
 387         len = size;
 388     }
 389     return qsb_get_buffer(s->qsb, pos, len, buf);
 390 }
 391
 392 static ssize_t buf_put_buffer(void *opaque, const uint8_t *buf,
 393                               int64_t pos, size_t size)
 394 {
 395     QEMUBuffer *s = opaque;
 396
 397     return qsb_write_at(s->qsb, buf, pos, size);
 398 }
 399
 400 static int buf_close(void *opaque)
 401 {
 402     QEMUBuffer *s = opaque;
 403
 404     if (s->qsb_allocated) {
 405         qsb_free(s->qsb);
 406     }
 407
 408     g_free(s);
 409
 410     return 0;
 411 }
 412
 413 const QEMUSizedBuffer *qemu_buf_get(QEMUFile *f)
 414 {
 415     QEMUBuffer *p;
 416
 417     qemu_fflush(f);
 418
 419     p = f->opaque;
 420
 421     return p->qsb;
 422 }
 423
 424 static const QEMUFileOps buf_read_ops = {
 425     .get_buffer = buf_get_buffer,
 426     .close =      buf_close,
 427 };
 428
 429 static const QEMUFileOps buf_write_ops = {
 430     .put_buffer = buf_put_buffer,
 431     .close =      buf_close,
 432 };
 433
 434 QEMUFile *qemu_bufopen(const char *mode, QEMUSizedBuffer *input)
 435 {
 436     QEMUBuffer *s;
 437
 438     if (mode == NULL || (mode[0] != 'r' && mode[0] != 'w') ||
 439         mode[1] != '\0') {
 440         error_report("qemu_bufopen: Argument validity check failed");
 441         return NULL;
 442     }
 443
 444     s = g_new0(QEMUBuffer, 1);
 445     s->qsb = input;
 446
 447     if (s->qsb == NULL) {
 448         s->qsb = qsb_create(NULL, 0);
 449         s->qsb_allocated = true;
 450     }
 451     if (!s->qsb) {
 452         g_free(s);
 453         error_report("qemu_bufopen: qsb_create failed");
 454         return NULL;
 455     }
 456
 457
 458     if (mode[0] == 'r') {
 459         s->file = qemu_fopen_ops(s, &buf_read_ops);
 460     } else {
 461         s->file = qemu_fopen_ops(s, &buf_write_ops);
 462     }
 463     return s->file;
 464 }