4 * Copyright (c) 2003-2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
24 #include "qemu/osdep.h"
26 #include "qemu/error-report.h"
28 #include "migration.h"
29 #include "qemu-file.h"
31 #include "qapi/error.h"
33 #define IO_BUF_SIZE 32768
34 #define MAX_IOV_SIZE MIN_CONST(IOV_MAX, 64)
37 const QEMUFileOps
*ops
;
38 const QEMUFileHooks
*hooks
;
44 int64_t pos
; /* start of buffer when writing, end of buffer
47 int buf_size
; /* 0 when writing */
48 uint8_t buf
[IO_BUF_SIZE
];
50 DECLARE_BITMAP(may_free
, MAX_IOV_SIZE
);
51 struct iovec iov
[MAX_IOV_SIZE
];
55 Error
*last_error_obj
;
56 /* has the file has been shutdown */
61 * Stop a file from being read/written - not all backing files can do this
62 * typically only sockets can.
64 int qemu_file_shutdown(QEMUFile
*f
)
69 if (!f
->ops
->shut_down
) {
72 ret
= f
->ops
->shut_down(f
->opaque
, true, true, NULL
);
75 qemu_file_set_error(f
, -EIO
);
81 * Result: QEMUFile* for a 'return path' for comms in the opposite direction
82 * NULL if not available
84 QEMUFile
*qemu_file_get_return_path(QEMUFile
*f
)
86 if (!f
->ops
->get_return_path
) {
89 return f
->ops
->get_return_path(f
->opaque
);
92 bool qemu_file_mode_is_not_valid(const char *mode
)
95 (mode
[0] != 'r' && mode
[0] != 'w') ||
96 mode
[1] != 'b' || mode
[2] != 0) {
97 fprintf(stderr
, "qemu_fopen: Argument validity check failed\n");
104 QEMUFile
*qemu_fopen_ops(void *opaque
, const QEMUFileOps
*ops
)
108 f
= g_new0(QEMUFile
, 1);
116 void qemu_file_set_hooks(QEMUFile
*f
, const QEMUFileHooks
*hooks
)
122 * Get last error for stream f with optional Error*
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
130 int qemu_file_get_error_obj(QEMUFile
*f
, Error
**errp
)
133 *errp
= f
->last_error_obj
? error_copy(f
->last_error_obj
) : NULL
;
135 return f
->last_error
;
139 * Set the last error for stream f with optional Error*
141 void qemu_file_set_error_obj(QEMUFile
*f
, int ret
, Error
*err
)
143 if (f
->last_error
== 0 && ret
) {
145 error_propagate(&f
->last_error_obj
, err
);
147 error_report_err(err
);
152 * Get last error for stream f
154 * Return negative error value if there has been an error on previous
155 * operations, return 0 if no error happened.
158 int qemu_file_get_error(QEMUFile
*f
)
160 return qemu_file_get_error_obj(f
, NULL
);
164 * Set the last error for stream f
166 void qemu_file_set_error(QEMUFile
*f
, int ret
)
168 qemu_file_set_error_obj(f
, ret
, NULL
);
171 bool qemu_file_is_writable(QEMUFile
*f
)
173 return f
->ops
->writev_buffer
;
176 static void qemu_iovec_release_ram(QEMUFile
*f
)
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
) {
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
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
;
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
));
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
));
208 memset(f
->may_free
, 0, sizeof(f
->may_free
));
212 * Flushes QEMUFile buffer
214 * This will flush all pending data. If data was only partially flushed, it
215 * will set an error state.
217 void qemu_fflush(QEMUFile
*f
)
221 Error
*local_error
= NULL
;
223 if (!qemu_file_is_writable(f
)) {
231 expect
= iov_size(f
->iov
, f
->iovcnt
);
232 ret
= f
->ops
->writev_buffer(f
->opaque
, f
->iov
, f
->iovcnt
, f
->pos
,
235 qemu_iovec_release_ram(f
);
241 /* We expect the QEMUFile write impl to send the full
242 * data set we requested, so sanity check that.
245 qemu_file_set_error_obj(f
, ret
< 0 ? ret
: -EIO
, local_error
);
251 void ram_control_before_iterate(QEMUFile
*f
, uint64_t flags
)
255 if (f
->hooks
&& f
->hooks
->before_ram_iterate
) {
256 ret
= f
->hooks
->before_ram_iterate(f
, f
->opaque
, flags
, NULL
);
258 qemu_file_set_error(f
, ret
);
263 void ram_control_after_iterate(QEMUFile
*f
, uint64_t flags
)
267 if (f
->hooks
&& f
->hooks
->after_ram_iterate
) {
268 ret
= f
->hooks
->after_ram_iterate(f
, f
->opaque
, flags
, NULL
);
270 qemu_file_set_error(f
, ret
);
275 void ram_control_load_hook(QEMUFile
*f
, uint64_t flags
, void *data
)
279 if (f
->hooks
&& f
->hooks
->hook_ram_load
) {
280 ret
= f
->hooks
->hook_ram_load(f
, f
->opaque
, flags
, data
);
282 qemu_file_set_error(f
, ret
);
286 * Hook is a hook specifically requested by the source sending a flag
287 * that expects there to be a hook on the destination.
289 if (flags
== RAM_CONTROL_HOOK
) {
290 qemu_file_set_error(f
, ret
);
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
)
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
;
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
);
318 return RAM_SAVE_CONTROL_NOT_SUPP
;
322 * Attempt to fill the buffer from the underlying file
323 * Returns the number of bytes read, or negative value for an error.
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.
329 static ssize_t
qemu_fill_buffer(QEMUFile
*f
)
333 Error
*local_error
= NULL
;
335 assert(!qemu_file_is_writable(f
));
337 pending
= f
->buf_size
- f
->buf_index
;
339 memmove(f
->buf
, f
->buf
+ f
->buf_index
, pending
);
342 f
->buf_size
= pending
;
348 len
= f
->ops
->get_buffer(f
->opaque
, f
->buf
+ pending
, f
->pos
,
349 IO_BUF_SIZE
- pending
, &local_error
);
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
);
358 error_free(local_error
);
364 void qemu_update_position(QEMUFile
*f
, size_t size
)
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.
374 * The meaning of return value on success depends on the specific backend
377 int qemu_fclose(QEMUFile
*f
)
381 ret
= qemu_file_get_error(f
);
384 int ret2
= f
->ops
->close(f
->opaque
, NULL
);
389 /* If any error was spotted before closing, we should report it
390 * instead of the close() return value.
395 error_free(f
->last_error_obj
);
397 trace_qemu_file_fclose();
402 * Add buf to iovec. Do flush if iovec is full.
405 * 1 iovec is full and flushed
406 * 0 iovec is not flushed
409 static int add_to_iovec(QEMUFile
*f
, const uint8_t *buf
, size_t size
,
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
))
417 f
->iov
[f
->iovcnt
- 1].iov_len
+= size
;
420 set_bit(f
->iovcnt
, f
->may_free
);
422 f
->iov
[f
->iovcnt
].iov_base
= (uint8_t *)buf
;
423 f
->iov
[f
->iovcnt
++].iov_len
= size
;
426 if (f
->iovcnt
>= MAX_IOV_SIZE
) {
434 static void add_buf_to_iovec(QEMUFile
*f
, size_t len
)
436 if (!add_to_iovec(f
, f
->buf
+ f
->buf_index
, len
, false)) {
438 if (f
->buf_index
== IO_BUF_SIZE
) {
444 void qemu_put_buffer_async(QEMUFile
*f
, const uint8_t *buf
, size_t size
,
451 f
->bytes_xfer
+= size
;
452 add_to_iovec(f
, buf
, size
, may_free
);
455 void qemu_put_buffer(QEMUFile
*f
, const uint8_t *buf
, size_t size
)
464 l
= IO_BUF_SIZE
- f
->buf_index
;
468 memcpy(f
->buf
+ f
->buf_index
, buf
, l
);
470 add_buf_to_iovec(f
, l
);
471 if (qemu_file_get_error(f
)) {
479 void qemu_put_byte(QEMUFile
*f
, int v
)
485 f
->buf
[f
->buf_index
] = v
;
487 add_buf_to_iovec(f
, 1);
490 void qemu_file_skip(QEMUFile
*f
, int size
)
492 if (f
->buf_index
+ size
<= f
->buf_size
) {
493 f
->buf_index
+= size
;
498 * Read 'size' bytes from file (at 'offset') without moving the
499 * pointer and set 'buf' to point to that data.
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)
505 size_t qemu_peek_buffer(QEMUFile
*f
, uint8_t **buf
, size_t size
, size_t offset
)
510 assert(!qemu_file_is_writable(f
));
511 assert(offset
< IO_BUF_SIZE
);
512 assert(size
<= IO_BUF_SIZE
- offset
);
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
;
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.
523 while (pending
< size
) {
524 int received
= qemu_fill_buffer(f
);
530 index
= f
->buf_index
+ offset
;
531 pending
= f
->buf_size
- index
;
537 if (size
> pending
) {
541 *buf
= f
->buf
+ index
;
546 * Read 'size' bytes of data from the file into buf.
547 * 'size' can be larger than the internal buffer.
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)
553 size_t qemu_get_buffer(QEMUFile
*f
, uint8_t *buf
, size_t size
)
555 size_t pending
= size
;
558 while (pending
> 0) {
562 res
= qemu_peek_buffer(f
, &src
, MIN(pending
, IO_BUF_SIZE
), 0);
566 memcpy(buf
, src
, res
);
567 qemu_file_skip(f
, res
);
576 * Read 'size' bytes of data from the file.
577 * 'size' can be larger than the internal buffer.
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.
583 * will be copied to the *buf that was passed in.
585 * The code tries to avoid the copy if possible.
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)
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.
594 size_t qemu_get_buffer_in_place(QEMUFile
*f
, uint8_t **buf
, size_t size
)
596 if (size
< IO_BUF_SIZE
) {
600 res
= qemu_peek_buffer(f
, &src
, size
, 0);
603 qemu_file_skip(f
, res
);
609 return qemu_get_buffer(f
, *buf
, size
);
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.
616 int qemu_peek_byte(QEMUFile
*f
, int offset
)
618 int index
= f
->buf_index
+ offset
;
620 assert(!qemu_file_is_writable(f
));
621 assert(offset
< IO_BUF_SIZE
);
623 if (index
>= f
->buf_size
) {
625 index
= f
->buf_index
+ offset
;
626 if (index
>= f
->buf_size
) {
630 return f
->buf
[index
];
633 int qemu_get_byte(QEMUFile
*f
)
637 result
= qemu_peek_byte(f
, 0);
638 qemu_file_skip(f
, 1);
642 int64_t qemu_ftell_fast(QEMUFile
*f
)
644 int64_t ret
= f
->pos
;
647 for (i
= 0; i
< f
->iovcnt
; i
++) {
648 ret
+= f
->iov
[i
].iov_len
;
654 int64_t qemu_ftell(QEMUFile
*f
)
660 int qemu_file_rate_limit(QEMUFile
*f
)
665 if (qemu_file_get_error(f
)) {
668 if (f
->xfer_limit
> 0 && f
->bytes_xfer
> f
->xfer_limit
) {
674 int64_t qemu_file_get_rate_limit(QEMUFile
*f
)
676 return f
->xfer_limit
;
679 void qemu_file_set_rate_limit(QEMUFile
*f
, int64_t limit
)
681 f
->xfer_limit
= limit
;
684 void qemu_file_reset_rate_limit(QEMUFile
*f
)
689 void qemu_file_update_transfer(QEMUFile
*f
, int64_t len
)
691 f
->bytes_xfer
+= len
;
694 void qemu_put_be16(QEMUFile
*f
, unsigned int v
)
696 qemu_put_byte(f
, v
>> 8);
700 void qemu_put_be32(QEMUFile
*f
, unsigned int v
)
702 qemu_put_byte(f
, v
>> 24);
703 qemu_put_byte(f
, v
>> 16);
704 qemu_put_byte(f
, v
>> 8);
708 void qemu_put_be64(QEMUFile
*f
, uint64_t v
)
710 qemu_put_be32(f
, v
>> 32);
714 unsigned int qemu_get_be16(QEMUFile
*f
)
717 v
= qemu_get_byte(f
) << 8;
718 v
|= qemu_get_byte(f
);
722 unsigned int qemu_get_be32(QEMUFile
*f
)
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
);
732 uint64_t qemu_get_be64(QEMUFile
*f
)
735 v
= (uint64_t)qemu_get_be32(f
) << 32;
736 v
|= qemu_get_be32(f
);
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
)
746 err
= deflateReset(stream
);
751 stream
->avail_in
= source_len
;
752 stream
->next_in
= (uint8_t *)source
;
753 stream
->avail_out
= dest_len
;
754 stream
->next_out
= dest
;
756 err
= deflate(stream
, Z_FINISH
);
757 if (err
!= Z_STREAM_END
) {
761 return stream
->next_out
- dest
;
764 /* Compress size bytes of data start at p and store the compressed
765 * data to the buffer of f.
767 * Since the file is dummy file with empty_ops, return -1 if f has no space to
768 * save the compressed data.
770 ssize_t
qemu_put_compression_data(QEMUFile
*f
, z_stream
*stream
,
771 const uint8_t *p
, size_t size
)
773 ssize_t blen
= IO_BUF_SIZE
- f
->buf_index
- sizeof(int32_t);
775 if (blen
< compressBound(size
)) {
779 blen
= qemu_compress_data(stream
, f
->buf
+ f
->buf_index
+ sizeof(int32_t),
785 qemu_put_be32(f
, blen
);
786 add_buf_to_iovec(f
, blen
);
787 return blen
+ sizeof(int32_t);
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.
794 int qemu_put_qemu_file(QEMUFile
*f_des
, QEMUFile
*f_src
)
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;
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
812 * (Note a 0 length string will return 0 either way)
814 size_t qemu_get_counted_string(QEMUFile
*f
, char buf
[256])
816 size_t len
= qemu_get_byte(f
);
817 size_t res
= qemu_get_buffer(f
, (uint8_t *)buf
, len
);
821 return res
== len
? res
: 0;
825 * Put a string with one preceding byte containing its length. The length of
826 * the string should be less than 256.
828 void qemu_put_counted_string(QEMUFile
*f
, const char *str
)
830 size_t len
= strlen(str
);
833 qemu_put_byte(f
, len
);
834 qemu_put_buffer(f
, (const uint8_t *)str
, len
);
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.
843 void qemu_file_set_blocking(QEMUFile
*f
, bool block
)
845 if (f
->ops
->set_blocking
) {
846 f
->ops
->set_blocking(f
->opaque
, block
, NULL
);