vhost: switch to use IOTLB v2 format
[qemu.git] / 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/error-report.h"
27 #include "qemu/iov.h"
28 #include "migration.h"
29 #include "qemu-file.h"
30 #include "trace.h"
31 #include "qapi/error.h"
32
33 #define IO_BUF_SIZE 32768
34 #define MAX_IOV_SIZE MIN_CONST(IOV_MAX, 64)
35
36 struct QEMUFile {
37 const QEMUFileOps *ops;
38 const QEMUFileHooks *hooks;
39 void *opaque;
40
41 int64_t bytes_xfer;
42 int64_t xfer_limit;
43
44 int64_t pos; /* start of buffer when writing, end of buffer
45 when reading */
46 int buf_index;
47 int buf_size; /* 0 when writing */
48 uint8_t buf[IO_BUF_SIZE];
49
50 DECLARE_BITMAP(may_free, MAX_IOV_SIZE);
51 struct iovec iov[MAX_IOV_SIZE];
52 unsigned int iovcnt;
53
54 int last_error;
55 Error *last_error_obj;
56 /* has the file has been shutdown */
57 bool shutdown;
58 };
59
60 /*
61 * Stop a file from being read/written - not all backing files can do this
62 * typically only sockets can.
63 */
64 int qemu_file_shutdown(QEMUFile *f)
65 {
66 int ret;
67
68 f->shutdown = true;
69 if (!f->ops->shut_down) {
70 return -ENOSYS;
71 }
72 ret = f->ops->shut_down(f->opaque, true, true, NULL);
73
74 if (!f->last_error) {
75 qemu_file_set_error(f, -EIO);
76 }
77 return ret;
78 }
79
80 /*
81 * Result: QEMUFile* for a 'return path' for comms in the opposite direction
82 * NULL if not available
83 */
84 QEMUFile *qemu_file_get_return_path(QEMUFile *f)
85 {
86 if (!f->ops->get_return_path) {
87 return NULL;
88 }
89 return f->ops->get_return_path(f->opaque);
90 }
91
92 bool qemu_file_mode_is_not_valid(const char *mode)
93 {
94 if (mode == NULL ||
95 (mode[0] != 'r' && mode[0] != 'w') ||
96 mode[1] != 'b' || mode[2] != 0) {
97 fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
98 return true;
99 }
100
101 return false;
102 }
103
104 QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)
105 {
106 QEMUFile *f;
107
108 f = g_new0(QEMUFile, 1);
109
110 f->opaque = opaque;
111 f->ops = ops;
112 return f;
113 }
114
115
116 void qemu_file_set_hooks(QEMUFile *f, const QEMUFileHooks *hooks)
117 {
118 f->hooks = hooks;
119 }
120
121 /*
122 * Get last error for stream f with optional Error*
123 *
124 * Return negative error value if there has been an error on previous
125 * operations, return 0 if no error happened.
126 * Optional, it returns Error* in errp, but it may be NULL even if return value
127 * is not 0.
128 *
129 */
130 int qemu_file_get_error_obj(QEMUFile *f, Error **errp)
131 {
132 if (errp) {
133 *errp = f->last_error_obj ? error_copy(f->last_error_obj) : NULL;
134 }
135 return f->last_error;
136 }
137
138 /*
139 * Set the last error for stream f with optional Error*
140 */
141 void qemu_file_set_error_obj(QEMUFile *f, int ret, Error *err)
142 {
143 if (f->last_error == 0 && ret) {
144 f->last_error = ret;
145 error_propagate(&f->last_error_obj, err);
146 } else if (err) {
147 error_report_err(err);
148 }
149 }
150
151 /*
152 * Get last error for stream f
153 *
154 * Return negative error value if there has been an error on previous
155 * operations, return 0 if no error happened.
156 *
157 */
158 int qemu_file_get_error(QEMUFile *f)
159 {
160 return qemu_file_get_error_obj(f, NULL);
161 }
162
163 /*
164 * Set the last error for stream f
165 */
166 void qemu_file_set_error(QEMUFile *f, int ret)
167 {
168 qemu_file_set_error_obj(f, ret, NULL);
169 }
170
171 bool qemu_file_is_writable(QEMUFile *f)
172 {
173 return f->ops->writev_buffer;
174 }
175
176 static void qemu_iovec_release_ram(QEMUFile *f)
177 {
178 struct iovec iov;
179 unsigned long idx;
180
181 /* Find and release all the contiguous memory ranges marked as may_free. */
182 idx = find_next_bit(f->may_free, f->iovcnt, 0);
183 if (idx >= f->iovcnt) {
184 return;
185 }
186 iov = f->iov[idx];
187
188 /* The madvise() in the loop is called for iov within a continuous range and
189 * then reinitialize the iov. And in the end, madvise() is called for the
190 * last iov.
191 */
192 while ((idx = find_next_bit(f->may_free, f->iovcnt, idx + 1)) < f->iovcnt) {
193 /* check for adjacent buffer and coalesce them */
194 if (iov.iov_base + iov.iov_len == f->iov[idx].iov_base) {
195 iov.iov_len += f->iov[idx].iov_len;
196 continue;
197 }
198 if (qemu_madvise(iov.iov_base, iov.iov_len, QEMU_MADV_DONTNEED) < 0) {
199 error_report("migrate: madvise DONTNEED failed %p %zd: %s",
200 iov.iov_base, iov.iov_len, strerror(errno));
201 }
202 iov = f->iov[idx];
203 }
204 if (qemu_madvise(iov.iov_base, iov.iov_len, QEMU_MADV_DONTNEED) < 0) {
205 error_report("migrate: madvise DONTNEED failed %p %zd: %s",
206 iov.iov_base, iov.iov_len, strerror(errno));
207 }
208 memset(f->may_free, 0, sizeof(f->may_free));
209 }
210
211 /**
212 * Flushes QEMUFile buffer
213 *
214 * This will flush all pending data. If data was only partially flushed, it
215 * will set an error state.
216 */
217 void qemu_fflush(QEMUFile *f)
218 {
219 ssize_t ret = 0;
220 ssize_t expect = 0;
221 Error *local_error = NULL;
222
223 if (!qemu_file_is_writable(f)) {
224 return;
225 }
226
227 if (f->shutdown) {
228 return;
229 }
230 if (f->iovcnt > 0) {
231 expect = iov_size(f->iov, f->iovcnt);
232 ret = f->ops->writev_buffer(f->opaque, f->iov, f->iovcnt, f->pos,
233 &local_error);
234
235 qemu_iovec_release_ram(f);
236 }
237
238 if (ret >= 0) {
239 f->pos += ret;
240 }
241 /* We expect the QEMUFile write impl to send the full
242 * data set we requested, so sanity check that.
243 */
244 if (ret != expect) {
245 qemu_file_set_error_obj(f, ret < 0 ? ret : -EIO, local_error);
246 }
247 f->buf_index = 0;
248 f->iovcnt = 0;
249 }
250
251 void ram_control_before_iterate(QEMUFile *f, uint64_t flags)
252 {
253 int ret = 0;
254
255 if (f->hooks && f->hooks->before_ram_iterate) {
256 ret = f->hooks->before_ram_iterate(f, f->opaque, flags, NULL);
257 if (ret < 0) {
258 qemu_file_set_error(f, ret);
259 }
260 }
261 }
262
263 void ram_control_after_iterate(QEMUFile *f, uint64_t flags)
264 {
265 int ret = 0;
266
267 if (f->hooks && f->hooks->after_ram_iterate) {
268 ret = f->hooks->after_ram_iterate(f, f->opaque, flags, NULL);
269 if (ret < 0) {
270 qemu_file_set_error(f, ret);
271 }
272 }
273 }
274
275 void ram_control_load_hook(QEMUFile *f, uint64_t flags, void *data)
276 {
277 int ret = -EINVAL;
278
279 if (f->hooks && f->hooks->hook_ram_load) {
280 ret = f->hooks->hook_ram_load(f, f->opaque, flags, data);
281 if (ret < 0) {
282 qemu_file_set_error(f, ret);
283 }
284 } else {
285 /*
286 * Hook is a hook specifically requested by the source sending a flag
287 * that expects there to be a hook on the destination.
288 */
289 if (flags == RAM_CONTROL_HOOK) {
290 qemu_file_set_error(f, ret);
291 }
292 }
293 }
294
295 size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset,
296 ram_addr_t offset, size_t size,
297 uint64_t *bytes_sent)
298 {
299 if (f->hooks && f->hooks->save_page) {
300 int ret = f->hooks->save_page(f, f->opaque, block_offset,
301 offset, size, bytes_sent);
302 if (ret != RAM_SAVE_CONTROL_NOT_SUPP) {
303 f->bytes_xfer += size;
304 }
305
306 if (ret != RAM_SAVE_CONTROL_DELAYED &&
307 ret != RAM_SAVE_CONTROL_NOT_SUPP) {
308 if (bytes_sent && *bytes_sent > 0) {
309 qemu_update_position(f, *bytes_sent);
310 } else if (ret < 0) {
311 qemu_file_set_error(f, ret);
312 }
313 }
314
315 return ret;
316 }
317
318 return RAM_SAVE_CONTROL_NOT_SUPP;
319 }
320
321 /*
322 * Attempt to fill the buffer from the underlying file
323 * Returns the number of bytes read, or negative value for an error.
324 *
325 * Note that it can return a partially full buffer even in a not error/not EOF
326 * case if the underlying file descriptor gives a short read, and that can
327 * happen even on a blocking fd.
328 */
329 static ssize_t qemu_fill_buffer(QEMUFile *f)
330 {
331 int len;
332 int pending;
333 Error *local_error = NULL;
334
335 assert(!qemu_file_is_writable(f));
336
337 pending = f->buf_size - f->buf_index;
338 if (pending > 0) {
339 memmove(f->buf, f->buf + f->buf_index, pending);
340 }
341 f->buf_index = 0;
342 f->buf_size = pending;
343
344 if (f->shutdown) {
345 return 0;
346 }
347
348 len = f->ops->get_buffer(f->opaque, f->buf + pending, f->pos,
349 IO_BUF_SIZE - pending, &local_error);
350 if (len > 0) {
351 f->buf_size += len;
352 f->pos += len;
353 } else if (len == 0) {
354 qemu_file_set_error_obj(f, -EIO, local_error);
355 } else if (len != -EAGAIN) {
356 qemu_file_set_error_obj(f, len, local_error);
357 } else {
358 error_free(local_error);
359 }
360
361 return len;
362 }
363
364 void qemu_update_position(QEMUFile *f, size_t size)
365 {
366 f->pos += size;
367 }
368
369 /** Closes the file
370 *
371 * Returns negative error value if any error happened on previous operations or
372 * while closing the file. Returns 0 or positive number on success.
373 *
374 * The meaning of return value on success depends on the specific backend
375 * being used.
376 */
377 int qemu_fclose(QEMUFile *f)
378 {
379 int ret;
380 qemu_fflush(f);
381 ret = qemu_file_get_error(f);
382
383 if (f->ops->close) {
384 int ret2 = f->ops->close(f->opaque, NULL);
385 if (ret >= 0) {
386 ret = ret2;
387 }
388 }
389 /* If any error was spotted before closing, we should report it
390 * instead of the close() return value.
391 */
392 if (f->last_error) {
393 ret = f->last_error;
394 }
395 error_free(f->last_error_obj);
396 g_free(f);
397 trace_qemu_file_fclose();
398 return ret;
399 }
400
401 /*
402 * Add buf to iovec. Do flush if iovec is full.
403 *
404 * Return values:
405 * 1 iovec is full and flushed
406 * 0 iovec is not flushed
407 *
408 */
409 static int add_to_iovec(QEMUFile *f, const uint8_t *buf, size_t size,
410 bool may_free)
411 {
412 /* check for adjacent buffer and coalesce them */
413 if (f->iovcnt > 0 && buf == f->iov[f->iovcnt - 1].iov_base +
414 f->iov[f->iovcnt - 1].iov_len &&
415 may_free == test_bit(f->iovcnt - 1, f->may_free))
416 {
417 f->iov[f->iovcnt - 1].iov_len += size;
418 } else {
419 if (may_free) {
420 set_bit(f->iovcnt, f->may_free);
421 }
422 f->iov[f->iovcnt].iov_base = (uint8_t *)buf;
423 f->iov[f->iovcnt++].iov_len = size;
424 }
425
426 if (f->iovcnt >= MAX_IOV_SIZE) {
427 qemu_fflush(f);
428 return 1;
429 }
430
431 return 0;
432 }
433
434 static void add_buf_to_iovec(QEMUFile *f, size_t len)
435 {
436 if (!add_to_iovec(f, f->buf + f->buf_index, len, false)) {
437 f->buf_index += len;
438 if (f->buf_index == IO_BUF_SIZE) {
439 qemu_fflush(f);
440 }
441 }
442 }
443
444 void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, size_t size,
445 bool may_free)
446 {
447 if (f->last_error) {
448 return;
449 }
450
451 f->bytes_xfer += size;
452 add_to_iovec(f, buf, size, may_free);
453 }
454
455 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, size_t size)
456 {
457 size_t l;
458
459 if (f->last_error) {
460 return;
461 }
462
463 while (size > 0) {
464 l = IO_BUF_SIZE - f->buf_index;
465 if (l > size) {
466 l = size;
467 }
468 memcpy(f->buf + f->buf_index, buf, l);
469 f->bytes_xfer += l;
470 add_buf_to_iovec(f, l);
471 if (qemu_file_get_error(f)) {
472 break;
473 }
474 buf += l;
475 size -= l;
476 }
477 }
478
479 void qemu_put_byte(QEMUFile *f, int v)
480 {
481 if (f->last_error) {
482 return;
483 }
484
485 f->buf[f->buf_index] = v;
486 f->bytes_xfer++;
487 add_buf_to_iovec(f, 1);
488 }
489
490 void qemu_file_skip(QEMUFile *f, int size)
491 {
492 if (f->buf_index + size <= f->buf_size) {
493 f->buf_index += size;
494 }
495 }
496
497 /*
498 * Read 'size' bytes from file (at 'offset') without moving the
499 * pointer and set 'buf' to point to that data.
500 *
501 * It will return size bytes unless there was an error, in which case it will
502 * return as many as it managed to read (assuming blocking fd's which
503 * all current QEMUFile are)
504 */
505 size_t qemu_peek_buffer(QEMUFile *f, uint8_t **buf, size_t size, size_t offset)
506 {
507 ssize_t pending;
508 size_t index;
509
510 assert(!qemu_file_is_writable(f));
511 assert(offset < IO_BUF_SIZE);
512 assert(size <= IO_BUF_SIZE - offset);
513
514 /* The 1st byte to read from */
515 index = f->buf_index + offset;
516 /* The number of available bytes starting at index */
517 pending = f->buf_size - index;
518
519 /*
520 * qemu_fill_buffer might return just a few bytes, even when there isn't
521 * an error, so loop collecting them until we get enough.
522 */
523 while (pending < size) {
524 int received = qemu_fill_buffer(f);
525
526 if (received <= 0) {
527 break;
528 }
529
530 index = f->buf_index + offset;
531 pending = f->buf_size - index;
532 }
533
534 if (pending <= 0) {
535 return 0;
536 }
537 if (size > pending) {
538 size = pending;
539 }
540
541 *buf = f->buf + index;
542 return size;
543 }
544
545 /*
546 * Read 'size' bytes of data from the file into buf.
547 * 'size' can be larger than the internal buffer.
548 *
549 * It will return size bytes unless there was an error, in which case it will
550 * return as many as it managed to read (assuming blocking fd's which
551 * all current QEMUFile are)
552 */
553 size_t qemu_get_buffer(QEMUFile *f, uint8_t *buf, size_t size)
554 {
555 size_t pending = size;
556 size_t done = 0;
557
558 while (pending > 0) {
559 size_t res;
560 uint8_t *src;
561
562 res = qemu_peek_buffer(f, &src, MIN(pending, IO_BUF_SIZE), 0);
563 if (res == 0) {
564 return done;
565 }
566 memcpy(buf, src, res);
567 qemu_file_skip(f, res);
568 buf += res;
569 pending -= res;
570 done += res;
571 }
572 return done;
573 }
574
575 /*
576 * Read 'size' bytes of data from the file.
577 * 'size' can be larger than the internal buffer.
578 *
579 * The data:
580 * may be held on an internal buffer (in which case *buf is updated
581 * to point to it) that is valid until the next qemu_file operation.
582 * OR
583 * will be copied to the *buf that was passed in.
584 *
585 * The code tries to avoid the copy if possible.
586 *
587 * It will return size bytes unless there was an error, in which case it will
588 * return as many as it managed to read (assuming blocking fd's which
589 * all current QEMUFile are)
590 *
591 * Note: Since **buf may get changed, the caller should take care to
592 * keep a pointer to the original buffer if it needs to deallocate it.
593 */
594 size_t qemu_get_buffer_in_place(QEMUFile *f, uint8_t **buf, size_t size)
595 {
596 if (size < IO_BUF_SIZE) {
597 size_t res;
598 uint8_t *src;
599
600 res = qemu_peek_buffer(f, &src, size, 0);
601
602 if (res == size) {
603 qemu_file_skip(f, res);
604 *buf = src;
605 return res;
606 }
607 }
608
609 return qemu_get_buffer(f, *buf, size);
610 }
611
612 /*
613 * Peeks a single byte from the buffer; this isn't guaranteed to work if
614 * offset leaves a gap after the previous read/peeked data.
615 */
616 int qemu_peek_byte(QEMUFile *f, int offset)
617 {
618 int index = f->buf_index + offset;
619
620 assert(!qemu_file_is_writable(f));
621 assert(offset < IO_BUF_SIZE);
622
623 if (index >= f->buf_size) {
624 qemu_fill_buffer(f);
625 index = f->buf_index + offset;
626 if (index >= f->buf_size) {
627 return 0;
628 }
629 }
630 return f->buf[index];
631 }
632
633 int qemu_get_byte(QEMUFile *f)
634 {
635 int result;
636
637 result = qemu_peek_byte(f, 0);
638 qemu_file_skip(f, 1);
639 return result;
640 }
641
642 int64_t qemu_ftell_fast(QEMUFile *f)
643 {
644 int64_t ret = f->pos;
645 int i;
646
647 for (i = 0; i < f->iovcnt; i++) {
648 ret += f->iov[i].iov_len;
649 }
650
651 return ret;
652 }
653
654 int64_t qemu_ftell(QEMUFile *f)
655 {
656 qemu_fflush(f);
657 return f->pos;
658 }
659
660 int qemu_file_rate_limit(QEMUFile *f)
661 {
662 if (f->shutdown) {
663 return 1;
664 }
665 if (qemu_file_get_error(f)) {
666 return 1;
667 }
668 if (f->xfer_limit > 0 && f->bytes_xfer > f->xfer_limit) {
669 return 1;
670 }
671 return 0;
672 }
673
674 int64_t qemu_file_get_rate_limit(QEMUFile *f)
675 {
676 return f->xfer_limit;
677 }
678
679 void qemu_file_set_rate_limit(QEMUFile *f, int64_t limit)
680 {
681 f->xfer_limit = limit;
682 }
683
684 void qemu_file_reset_rate_limit(QEMUFile *f)
685 {
686 f->bytes_xfer = 0;
687 }
688
689 void qemu_file_update_transfer(QEMUFile *f, int64_t len)
690 {
691 f->bytes_xfer += len;
692 }
693
694 void qemu_put_be16(QEMUFile *f, unsigned int v)
695 {
696 qemu_put_byte(f, v >> 8);
697 qemu_put_byte(f, v);
698 }
699
700 void qemu_put_be32(QEMUFile *f, unsigned int v)
701 {
702 qemu_put_byte(f, v >> 24);
703 qemu_put_byte(f, v >> 16);
704 qemu_put_byte(f, v >> 8);
705 qemu_put_byte(f, v);
706 }
707
708 void qemu_put_be64(QEMUFile *f, uint64_t v)
709 {
710 qemu_put_be32(f, v >> 32);
711 qemu_put_be32(f, v);
712 }
713
714 unsigned int qemu_get_be16(QEMUFile *f)
715 {
716 unsigned int v;
717 v = qemu_get_byte(f) << 8;
718 v |= qemu_get_byte(f);
719 return v;
720 }
721
722 unsigned int qemu_get_be32(QEMUFile *f)
723 {
724 unsigned int v;
725 v = (unsigned int)qemu_get_byte(f) << 24;
726 v |= qemu_get_byte(f) << 16;
727 v |= qemu_get_byte(f) << 8;
728 v |= qemu_get_byte(f);
729 return v;
730 }
731
732 uint64_t qemu_get_be64(QEMUFile *f)
733 {
734 uint64_t v;
735 v = (uint64_t)qemu_get_be32(f) << 32;
736 v |= qemu_get_be32(f);
737 return v;
738 }
739
740 /* return the size after compression, or negative value on error */
741 static int qemu_compress_data(z_stream *stream, uint8_t *dest, size_t dest_len,
742 const uint8_t *source, size_t source_len)
743 {
744 int err;
745
746 err = deflateReset(stream);
747 if (err != Z_OK) {
748 return -1;
749 }
750
751 stream->avail_in = source_len;
752 stream->next_in = (uint8_t *)source;
753 stream->avail_out = dest_len;
754 stream->next_out = dest;
755
756 err = deflate(stream, Z_FINISH);
757 if (err != Z_STREAM_END) {
758 return -1;
759 }
760
761 return stream->next_out - dest;
762 }
763
764 /* Compress size bytes of data start at p and store the compressed
765 * data to the buffer of f.
766 *
767 * Since the file is dummy file with empty_ops, return -1 if f has no space to
768 * save the compressed data.
769 */
770 ssize_t qemu_put_compression_data(QEMUFile *f, z_stream *stream,
771 const uint8_t *p, size_t size)
772 {
773 ssize_t blen = IO_BUF_SIZE - f->buf_index - sizeof(int32_t);
774
775 if (blen < compressBound(size)) {
776 return -1;
777 }
778
779 blen = qemu_compress_data(stream, f->buf + f->buf_index + sizeof(int32_t),
780 blen, p, size);
781 if (blen < 0) {
782 return -1;
783 }
784
785 qemu_put_be32(f, blen);
786 add_buf_to_iovec(f, blen);
787 return blen + sizeof(int32_t);
788 }
789
790 /* Put the data in the buffer of f_src to the buffer of f_des, and
791 * then reset the buf_index of f_src to 0.
792 */
793
794 int qemu_put_qemu_file(QEMUFile *f_des, QEMUFile *f_src)
795 {
796 int len = 0;
797
798 if (f_src->buf_index > 0) {
799 len = f_src->buf_index;
800 qemu_put_buffer(f_des, f_src->buf, f_src->buf_index);
801 f_src->buf_index = 0;
802 f_src->iovcnt = 0;
803 }
804 return len;
805 }
806
807 /*
808 * Get a string whose length is determined by a single preceding byte
809 * A preallocated 256 byte buffer must be passed in.
810 * Returns: len on success and a 0 terminated string in the buffer
811 * else 0
812 * (Note a 0 length string will return 0 either way)
813 */
814 size_t qemu_get_counted_string(QEMUFile *f, char buf[256])
815 {
816 size_t len = qemu_get_byte(f);
817 size_t res = qemu_get_buffer(f, (uint8_t *)buf, len);
818
819 buf[res] = 0;
820
821 return res == len ? res : 0;
822 }
823
824 /*
825 * Put a string with one preceding byte containing its length. The length of
826 * the string should be less than 256.
827 */
828 void qemu_put_counted_string(QEMUFile *f, const char *str)
829 {
830 size_t len = strlen(str);
831
832 assert(len < 256);
833 qemu_put_byte(f, len);
834 qemu_put_buffer(f, (const uint8_t *)str, len);
835 }
836
837 /*
838 * Set the blocking state of the QEMUFile.
839 * Note: On some transports the OS only keeps a single blocking state for
840 * both directions, and thus changing the blocking on the main
841 * QEMUFile can also affect the return path.
842 */
843 void qemu_file_set_blocking(QEMUFile *f, bool block)
844 {
845 if (f->ops->set_blocking) {
846 f->ops->set_blocking(f->opaque, block, NULL);
847 }
848 }