1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "qemu/osdep.h"
25#include <zlib.h>
26#include "qemu/madvise.h"
27#include "qemu/error-report.h"
28#include "qemu/iov.h"
29#include "migration.h"
30#include "qemu-file.h"
31#include "trace.h"
32#include "qapi/error.h"
33
34#define IO_BUF_SIZE 32768
35#define MAX_IOV_SIZE MIN_CONST(IOV_MAX, 64)
36
37struct QEMUFile {
38 const QEMUFileHooks *hooks;
39 QIOChannel *ioc;
40 bool is_writable;
41
42
43
44
45
46 int64_t rate_limit_max;
47
48
49
50
51 int64_t rate_limit_used;
52
53
54 int64_t total_transferred;
55
56 int buf_index;
57 int buf_size;
58 uint8_t buf[IO_BUF_SIZE];
59
60 DECLARE_BITMAP(may_free, MAX_IOV_SIZE);
61 struct iovec iov[MAX_IOV_SIZE];
62 unsigned int iovcnt;
63
64 int last_error;
65 Error *last_error_obj;
66
67 bool shutdown;
68};
69
70
71
72
73
74
75
76
77int qemu_file_shutdown(QEMUFile *f)
78{
79 int ret = 0;
80
81 f->shutdown = true;
82 if (!qio_channel_has_feature(f->ioc,
83 QIO_CHANNEL_FEATURE_SHUTDOWN)) {
84 return -ENOSYS;
85 }
86
87 if (qio_channel_shutdown(f->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL) < 0) {
88 ret = -EIO;
89 }
90
91 if (!f->last_error) {
92 qemu_file_set_error(f, -EIO);
93 }
94 return ret;
95}
96
97bool qemu_file_mode_is_not_valid(const char *mode)
98{
99 if (mode == NULL ||
100 (mode[0] != 'r' && mode[0] != 'w') ||
101 mode[1] != 'b' || mode[2] != 0) {
102 fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
103 return true;
104 }
105
106 return false;
107}
108
109static QEMUFile *qemu_file_new_impl(QIOChannel *ioc, bool is_writable)
110{
111 QEMUFile *f;
112
113 f = g_new0(QEMUFile, 1);
114
115 object_ref(ioc);
116 f->ioc = ioc;
117 f->is_writable = is_writable;
118
119 return f;
120}
121
122
123
124
125
126QEMUFile *qemu_file_get_return_path(QEMUFile *f)
127{
128 return qemu_file_new_impl(f->ioc, !f->is_writable);
129}
130
131QEMUFile *qemu_file_new_output(QIOChannel *ioc)
132{
133 return qemu_file_new_impl(ioc, true);
134}
135
136QEMUFile *qemu_file_new_input(QIOChannel *ioc)
137{
138 return qemu_file_new_impl(ioc, false);
139}
140
141void qemu_file_set_hooks(QEMUFile *f, const QEMUFileHooks *hooks)
142{
143 f->hooks = hooks;
144}
145
146
147
148
149
150
151
152
153
154
155int qemu_file_get_error_obj(QEMUFile *f, Error **errp)
156{
157 if (errp) {
158 *errp = f->last_error_obj ? error_copy(f->last_error_obj) : NULL;
159 }
160 return f->last_error;
161}
162
163
164
165
166
167
168
169
170
171int qemu_file_get_error_obj_any(QEMUFile *f1, QEMUFile *f2, Error **errp)
172{
173 int ret = 0;
174
175 if (f1) {
176 ret = qemu_file_get_error_obj(f1, errp);
177
178 if (ret) {
179 return ret;
180 }
181 }
182
183 if (f2) {
184 ret = qemu_file_get_error_obj(f2, errp);
185 }
186
187 return ret;
188}
189
190
191
192
193void qemu_file_set_error_obj(QEMUFile *f, int ret, Error *err)
194{
195 if (f->last_error == 0 && ret) {
196 f->last_error = ret;
197 error_propagate(&f->last_error_obj, err);
198 } else if (err) {
199 error_report_err(err);
200 }
201}
202
203
204
205
206
207
208
209
210int qemu_file_get_error(QEMUFile *f)
211{
212 return qemu_file_get_error_obj(f, NULL);
213}
214
215
216
217
218void qemu_file_set_error(QEMUFile *f, int ret)
219{
220 qemu_file_set_error_obj(f, ret, NULL);
221}
222
223bool qemu_file_is_writable(QEMUFile *f)
224{
225 return f->is_writable;
226}
227
228static void qemu_iovec_release_ram(QEMUFile *f)
229{
230 struct iovec iov;
231 unsigned long idx;
232
233
234 idx = find_next_bit(f->may_free, f->iovcnt, 0);
235 if (idx >= f->iovcnt) {
236 return;
237 }
238 iov = f->iov[idx];
239
240
241
242
243
244 while ((idx = find_next_bit(f->may_free, f->iovcnt, idx + 1)) < f->iovcnt) {
245
246 if (iov.iov_base + iov.iov_len == f->iov[idx].iov_base) {
247 iov.iov_len += f->iov[idx].iov_len;
248 continue;
249 }
250 if (qemu_madvise(iov.iov_base, iov.iov_len, QEMU_MADV_DONTNEED) < 0) {
251 error_report("migrate: madvise DONTNEED failed %p %zd: %s",
252 iov.iov_base, iov.iov_len, strerror(errno));
253 }
254 iov = f->iov[idx];
255 }
256 if (qemu_madvise(iov.iov_base, iov.iov_len, QEMU_MADV_DONTNEED) < 0) {
257 error_report("migrate: madvise DONTNEED failed %p %zd: %s",
258 iov.iov_base, iov.iov_len, strerror(errno));
259 }
260 memset(f->may_free, 0, sizeof(f->may_free));
261}
262
263
264
265
266
267
268
269
270void qemu_fflush(QEMUFile *f)
271{
272 if (!qemu_file_is_writable(f)) {
273 return;
274 }
275
276 if (f->shutdown) {
277 return;
278 }
279 if (f->iovcnt > 0) {
280 Error *local_error = NULL;
281 if (qio_channel_writev_all(f->ioc,
282 f->iov, f->iovcnt,
283 &local_error) < 0) {
284 qemu_file_set_error_obj(f, -EIO, local_error);
285 } else {
286 f->total_transferred += iov_size(f->iov, f->iovcnt);
287 }
288
289 qemu_iovec_release_ram(f);
290 }
291
292 f->buf_index = 0;
293 f->iovcnt = 0;
294}
295
296void ram_control_before_iterate(QEMUFile *f, uint64_t flags)
297{
298 int ret = 0;
299
300 if (f->hooks && f->hooks->before_ram_iterate) {
301 ret = f->hooks->before_ram_iterate(f, flags, NULL);
302 if (ret < 0) {
303 qemu_file_set_error(f, ret);
304 }
305 }
306}
307
308void ram_control_after_iterate(QEMUFile *f, uint64_t flags)
309{
310 int ret = 0;
311
312 if (f->hooks && f->hooks->after_ram_iterate) {
313 ret = f->hooks->after_ram_iterate(f, flags, NULL);
314 if (ret < 0) {
315 qemu_file_set_error(f, ret);
316 }
317 }
318}
319
320void ram_control_load_hook(QEMUFile *f, uint64_t flags, void *data)
321{
322 int ret = -EINVAL;
323
324 if (f->hooks && f->hooks->hook_ram_load) {
325 ret = f->hooks->hook_ram_load(f, flags, data);
326 if (ret < 0) {
327 qemu_file_set_error(f, ret);
328 }
329 } else {
330
331
332
333
334 if (flags == RAM_CONTROL_HOOK) {
335 qemu_file_set_error(f, ret);
336 }
337 }
338}
339
340size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset,
341 ram_addr_t offset, size_t size,
342 uint64_t *bytes_sent)
343{
344 if (f->hooks && f->hooks->save_page) {
345 int ret = f->hooks->save_page(f, block_offset,
346 offset, size, bytes_sent);
347 if (ret != RAM_SAVE_CONTROL_NOT_SUPP) {
348 f->rate_limit_used += size;
349 }
350
351 if (ret != RAM_SAVE_CONTROL_DELAYED &&
352 ret != RAM_SAVE_CONTROL_NOT_SUPP) {
353 if (bytes_sent && *bytes_sent > 0) {
354 qemu_file_credit_transfer(f, *bytes_sent);
355 } else if (ret < 0) {
356 qemu_file_set_error(f, ret);
357 }
358 }
359
360 return ret;
361 }
362
363 return RAM_SAVE_CONTROL_NOT_SUPP;
364}
365
366
367
368
369
370
371
372
373
374static ssize_t qemu_fill_buffer(QEMUFile *f)
375{
376 int len;
377 int pending;
378 Error *local_error = NULL;
379
380 assert(!qemu_file_is_writable(f));
381
382 pending = f->buf_size - f->buf_index;
383 if (pending > 0) {
384 memmove(f->buf, f->buf + f->buf_index, pending);
385 }
386 f->buf_index = 0;
387 f->buf_size = pending;
388
389 if (f->shutdown) {
390 return 0;
391 }
392
393 do {
394 len = qio_channel_read(f->ioc,
395 (char *)f->buf + pending,
396 IO_BUF_SIZE - pending,
397 &local_error);
398 if (len == QIO_CHANNEL_ERR_BLOCK) {
399 if (qemu_in_coroutine()) {
400 qio_channel_yield(f->ioc, G_IO_IN);
401 } else {
402 qio_channel_wait(f->ioc, G_IO_IN);
403 }
404 } else if (len < 0) {
405 len = -EIO;
406 }
407 } while (len == QIO_CHANNEL_ERR_BLOCK);
408
409 if (len > 0) {
410 f->buf_size += len;
411 f->total_transferred += len;
412 } else if (len == 0) {
413 qemu_file_set_error_obj(f, -EIO, local_error);
414 } else {
415 qemu_file_set_error_obj(f, len, local_error);
416 }
417
418 return len;
419}
420
421void qemu_file_credit_transfer(QEMUFile *f, size_t size)
422{
423 f->total_transferred += size;
424}
425
426
427
428
429
430
431
432
433
434int qemu_fclose(QEMUFile *f)
435{
436 int ret, ret2;
437 qemu_fflush(f);
438 ret = qemu_file_get_error(f);
439
440 ret2 = qio_channel_close(f->ioc, NULL);
441 if (ret >= 0) {
442 ret = ret2;
443 }
444 g_clear_pointer(&f->ioc, object_unref);
445
446
447
448
449 if (f->last_error) {
450 ret = f->last_error;
451 }
452 error_free(f->last_error_obj);
453 g_free(f);
454 trace_qemu_file_fclose();
455 return ret;
456}
457
458
459
460
461
462
463
464
465
466static int add_to_iovec(QEMUFile *f, const uint8_t *buf, size_t size,
467 bool may_free)
468{
469
470 if (f->iovcnt > 0 && buf == f->iov[f->iovcnt - 1].iov_base +
471 f->iov[f->iovcnt - 1].iov_len &&
472 may_free == test_bit(f->iovcnt - 1, f->may_free))
473 {
474 f->iov[f->iovcnt - 1].iov_len += size;
475 } else {
476 if (f->iovcnt >= MAX_IOV_SIZE) {
477
478 assert(f->shutdown || !qemu_file_is_writable(f));
479 return 1;
480 }
481 if (may_free) {
482 set_bit(f->iovcnt, f->may_free);
483 }
484 f->iov[f->iovcnt].iov_base = (uint8_t *)buf;
485 f->iov[f->iovcnt++].iov_len = size;
486 }
487
488 if (f->iovcnt >= MAX_IOV_SIZE) {
489 qemu_fflush(f);
490 return 1;
491 }
492
493 return 0;
494}
495
496static void add_buf_to_iovec(QEMUFile *f, size_t len)
497{
498 if (!add_to_iovec(f, f->buf + f->buf_index, len, false)) {
499 f->buf_index += len;
500 if (f->buf_index == IO_BUF_SIZE) {
501 qemu_fflush(f);
502 }
503 }
504}
505
506void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, size_t size,
507 bool may_free)
508{
509 if (f->last_error) {
510 return;
511 }
512
513 f->rate_limit_used += size;
514 add_to_iovec(f, buf, size, may_free);
515}
516
517void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, size_t size)
518{
519 size_t l;
520
521 if (f->last_error) {
522 return;
523 }
524
525 while (size > 0) {
526 l = IO_BUF_SIZE - f->buf_index;
527 if (l > size) {
528 l = size;
529 }
530 memcpy(f->buf + f->buf_index, buf, l);
531 f->rate_limit_used += l;
532 add_buf_to_iovec(f, l);
533 if (qemu_file_get_error(f)) {
534 break;
535 }
536 buf += l;
537 size -= l;
538 }
539}
540
541void qemu_put_byte(QEMUFile *f, int v)
542{
543 if (f->last_error) {
544 return;
545 }
546
547 f->buf[f->buf_index] = v;
548 f->rate_limit_used++;
549 add_buf_to_iovec(f, 1);
550}
551
552void qemu_file_skip(QEMUFile *f, int size)
553{
554 if (f->buf_index + size <= f->buf_size) {
555 f->buf_index += size;
556 }
557}
558
559
560
561
562
563
564
565
566
567size_t qemu_peek_buffer(QEMUFile *f, uint8_t **buf, size_t size, size_t offset)
568{
569 ssize_t pending;
570 size_t index;
571
572 assert(!qemu_file_is_writable(f));
573 assert(offset < IO_BUF_SIZE);
574 assert(size <= IO_BUF_SIZE - offset);
575
576
577 index = f->buf_index + offset;
578
579 pending = f->buf_size - index;
580
581
582
583
584
585 while (pending < size) {
586 int received = qemu_fill_buffer(f);
587
588 if (received <= 0) {
589 break;
590 }
591
592 index = f->buf_index + offset;
593 pending = f->buf_size - index;
594 }
595
596 if (pending <= 0) {
597 return 0;
598 }
599 if (size > pending) {
600 size = pending;
601 }
602
603 *buf = f->buf + index;
604 return size;
605}
606
607
608
609
610
611
612
613
614
615size_t qemu_get_buffer(QEMUFile *f, uint8_t *buf, size_t size)
616{
617 size_t pending = size;
618 size_t done = 0;
619
620 while (pending > 0) {
621 size_t res;
622 uint8_t *src;
623
624 res = qemu_peek_buffer(f, &src, MIN(pending, IO_BUF_SIZE), 0);
625 if (res == 0) {
626 return done;
627 }
628 memcpy(buf, src, res);
629 qemu_file_skip(f, res);
630 buf += res;
631 pending -= res;
632 done += res;
633 }
634 return done;
635}
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656size_t qemu_get_buffer_in_place(QEMUFile *f, uint8_t **buf, size_t size)
657{
658 if (size < IO_BUF_SIZE) {
659 size_t res;
660 uint8_t *src = NULL;
661
662 res = qemu_peek_buffer(f, &src, size, 0);
663
664 if (res == size) {
665 qemu_file_skip(f, res);
666 *buf = src;
667 return res;
668 }
669 }
670
671 return qemu_get_buffer(f, *buf, size);
672}
673
674
675
676
677
678int qemu_peek_byte(QEMUFile *f, int offset)
679{
680 int index = f->buf_index + offset;
681
682 assert(!qemu_file_is_writable(f));
683 assert(offset < IO_BUF_SIZE);
684
685 if (index >= f->buf_size) {
686 qemu_fill_buffer(f);
687 index = f->buf_index + offset;
688 if (index >= f->buf_size) {
689 return 0;
690 }
691 }
692 return f->buf[index];
693}
694
695int qemu_get_byte(QEMUFile *f)
696{
697 int result;
698
699 result = qemu_peek_byte(f, 0);
700 qemu_file_skip(f, 1);
701 return result;
702}
703
704int64_t qemu_file_total_transferred_fast(QEMUFile *f)
705{
706 int64_t ret = f->total_transferred;
707 int i;
708
709 for (i = 0; i < f->iovcnt; i++) {
710 ret += f->iov[i].iov_len;
711 }
712
713 return ret;
714}
715
716int64_t qemu_file_total_transferred(QEMUFile *f)
717{
718 qemu_fflush(f);
719 return f->total_transferred;
720}
721
722int qemu_file_rate_limit(QEMUFile *f)
723{
724 if (f->shutdown) {
725 return 1;
726 }
727 if (qemu_file_get_error(f)) {
728 return 1;
729 }
730 if (f->rate_limit_max > 0 && f->rate_limit_used > f->rate_limit_max) {
731 return 1;
732 }
733 return 0;
734}
735
736int64_t qemu_file_get_rate_limit(QEMUFile *f)
737{
738 return f->rate_limit_max;
739}
740
741void qemu_file_set_rate_limit(QEMUFile *f, int64_t limit)
742{
743 f->rate_limit_max = limit;
744}
745
746void qemu_file_reset_rate_limit(QEMUFile *f)
747{
748 f->rate_limit_used = 0;
749}
750
751void qemu_file_acct_rate_limit(QEMUFile *f, int64_t len)
752{
753 f->rate_limit_used += len;
754}
755
756void qemu_put_be16(QEMUFile *f, unsigned int v)
757{
758 qemu_put_byte(f, v >> 8);
759 qemu_put_byte(f, v);
760}
761
762void qemu_put_be32(QEMUFile *f, unsigned int v)
763{
764 qemu_put_byte(f, v >> 24);
765 qemu_put_byte(f, v >> 16);
766 qemu_put_byte(f, v >> 8);
767 qemu_put_byte(f, v);
768}
769
770void qemu_put_be64(QEMUFile *f, uint64_t v)
771{
772 qemu_put_be32(f, v >> 32);
773 qemu_put_be32(f, v);
774}
775
776unsigned int qemu_get_be16(QEMUFile *f)
777{
778 unsigned int v;
779 v = qemu_get_byte(f) << 8;
780 v |= qemu_get_byte(f);
781 return v;
782}
783
784unsigned int qemu_get_be32(QEMUFile *f)
785{
786 unsigned int v;
787 v = (unsigned int)qemu_get_byte(f) << 24;
788 v |= qemu_get_byte(f) << 16;
789 v |= qemu_get_byte(f) << 8;
790 v |= qemu_get_byte(f);
791 return v;
792}
793
794uint64_t qemu_get_be64(QEMUFile *f)
795{
796 uint64_t v;
797 v = (uint64_t)qemu_get_be32(f) << 32;
798 v |= qemu_get_be32(f);
799 return v;
800}
801
802
803static int qemu_compress_data(z_stream *stream, uint8_t *dest, size_t dest_len,
804 const uint8_t *source, size_t source_len)
805{
806 int err;
807
808 err = deflateReset(stream);
809 if (err != Z_OK) {
810 return -1;
811 }
812
813 stream->avail_in = source_len;
814 stream->next_in = (uint8_t *)source;
815 stream->avail_out = dest_len;
816 stream->next_out = dest;
817
818 err = deflate(stream, Z_FINISH);
819 if (err != Z_STREAM_END) {
820 return -1;
821 }
822
823 return stream->next_out - dest;
824}
825
826
827
828
829
830
831
832ssize_t qemu_put_compression_data(QEMUFile *f, z_stream *stream,
833 const uint8_t *p, size_t size)
834{
835 ssize_t blen = IO_BUF_SIZE - f->buf_index - sizeof(int32_t);
836
837 if (blen < compressBound(size)) {
838 return -1;
839 }
840
841 blen = qemu_compress_data(stream, f->buf + f->buf_index + sizeof(int32_t),
842 blen, p, size);
843 if (blen < 0) {
844 return -1;
845 }
846
847 qemu_put_be32(f, blen);
848 add_buf_to_iovec(f, blen);
849 return blen + sizeof(int32_t);
850}
851
852
853
854
855
856int qemu_put_qemu_file(QEMUFile *f_des, QEMUFile *f_src)
857{
858 int len = 0;
859
860 if (f_src->buf_index > 0) {
861 len = f_src->buf_index;
862 qemu_put_buffer(f_des, f_src->buf, f_src->buf_index);
863 f_src->buf_index = 0;
864 f_src->iovcnt = 0;
865 }
866 return len;
867}
868
869
870
871
872
873
874
875
876size_t qemu_get_counted_string(QEMUFile *f, char buf[256])
877{
878 size_t len = qemu_get_byte(f);
879 size_t res = qemu_get_buffer(f, (uint8_t *)buf, len);
880
881 buf[res] = 0;
882
883 return res == len ? res : 0;
884}
885
886
887
888
889
890void qemu_put_counted_string(QEMUFile *f, const char *str)
891{
892 size_t len = strlen(str);
893
894 assert(len < 256);
895 qemu_put_byte(f, len);
896 qemu_put_buffer(f, (const uint8_t *)str, len);
897}
898
899
900
901
902
903
904
905void qemu_file_set_blocking(QEMUFile *f, bool block)
906{
907 qio_channel_set_blocking(f->ioc, block, NULL);
908}
909
910
911
912
913
914
915
916
917
918QIOChannel *qemu_file_get_ioc(QEMUFile *file)
919{
920 return file->ioc;
921}
922