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