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