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-common.h"
27 #include "qemu/error-report.h"
29 #include "qemu/sockets.h"
30 #include "qemu/coroutine.h"
31 #include "migration/migration.h"
32 #include "migration/qemu-file.h"
33 #include "migration/qemu-file-internal.h"
37 * Stop a file from being read/written - not all backing files can do this
38 * typically only sockets can.
40 int qemu_file_shutdown(QEMUFile
*f
)
42 if (!f
->ops
->shut_down
) {
45 return f
->ops
->shut_down(f
->opaque
, true, true);
49 * Result: QEMUFile* for a 'return path' for comms in the opposite direction
50 * NULL if not available
52 QEMUFile
*qemu_file_get_return_path(QEMUFile
*f
)
54 if (!f
->ops
->get_return_path
) {
57 return f
->ops
->get_return_path(f
->opaque
);
60 bool qemu_file_mode_is_not_valid(const char *mode
)
63 (mode
[0] != 'r' && mode
[0] != 'w') ||
64 mode
[1] != 'b' || mode
[2] != 0) {
65 fprintf(stderr
, "qemu_fopen: Argument validity check failed\n");
72 QEMUFile
*qemu_fopen_ops(void *opaque
, const QEMUFileOps
*ops
)
76 f
= g_new0(QEMUFile
, 1);
84 void qemu_file_set_hooks(QEMUFile
*f
, const QEMUFileHooks
*hooks
)
90 * Get last error for stream f
92 * Return negative error value if there has been an error on previous
93 * operations, return 0 if no error happened.
96 int qemu_file_get_error(QEMUFile
*f
)
101 void qemu_file_set_error(QEMUFile
*f
, int ret
)
103 if (f
->last_error
== 0) {
108 bool qemu_file_is_writable(QEMUFile
*f
)
110 return f
->ops
->writev_buffer
|| f
->ops
->put_buffer
;
114 * Flushes QEMUFile buffer
116 * If there is writev_buffer QEMUFileOps it uses it otherwise uses
117 * put_buffer ops. This will flush all pending data. If data was
118 * only partially flushed, it will set an error state.
120 void qemu_fflush(QEMUFile
*f
)
125 if (!qemu_file_is_writable(f
)) {
129 if (f
->ops
->writev_buffer
) {
131 expect
= iov_size(f
->iov
, f
->iovcnt
);
132 ret
= f
->ops
->writev_buffer(f
->opaque
, f
->iov
, f
->iovcnt
, f
->pos
);
135 if (f
->buf_index
> 0) {
136 expect
= f
->buf_index
;
137 ret
= f
->ops
->put_buffer(f
->opaque
, f
->buf
, f
->pos
, f
->buf_index
);
144 /* We expect the QEMUFile write impl to send the full
145 * data set we requested, so sanity check that.
148 qemu_file_set_error(f
, ret
< 0 ? ret
: -EIO
);
154 void ram_control_before_iterate(QEMUFile
*f
, uint64_t flags
)
158 if (f
->hooks
&& f
->hooks
->before_ram_iterate
) {
159 ret
= f
->hooks
->before_ram_iterate(f
, f
->opaque
, flags
, NULL
);
161 qemu_file_set_error(f
, ret
);
166 void ram_control_after_iterate(QEMUFile
*f
, uint64_t flags
)
170 if (f
->hooks
&& f
->hooks
->after_ram_iterate
) {
171 ret
= f
->hooks
->after_ram_iterate(f
, f
->opaque
, flags
, NULL
);
173 qemu_file_set_error(f
, ret
);
178 void ram_control_load_hook(QEMUFile
*f
, uint64_t flags
, void *data
)
182 if (f
->hooks
&& f
->hooks
->hook_ram_load
) {
183 ret
= f
->hooks
->hook_ram_load(f
, f
->opaque
, flags
, data
);
185 qemu_file_set_error(f
, ret
);
189 * Hook is a hook specifically requested by the source sending a flag
190 * that expects there to be a hook on the destination.
192 if (flags
== RAM_CONTROL_HOOK
) {
193 qemu_file_set_error(f
, ret
);
198 size_t ram_control_save_page(QEMUFile
*f
, ram_addr_t block_offset
,
199 ram_addr_t offset
, size_t size
,
200 uint64_t *bytes_sent
)
202 if (f
->hooks
&& f
->hooks
->save_page
) {
203 int ret
= f
->hooks
->save_page(f
, f
->opaque
, block_offset
,
204 offset
, size
, bytes_sent
);
206 if (ret
!= RAM_SAVE_CONTROL_DELAYED
) {
207 if (bytes_sent
&& *bytes_sent
> 0) {
208 qemu_update_position(f
, *bytes_sent
);
209 } else if (ret
< 0) {
210 qemu_file_set_error(f
, ret
);
217 return RAM_SAVE_CONTROL_NOT_SUPP
;
221 * Attempt to fill the buffer from the underlying file
222 * Returns the number of bytes read, or negative value for an error.
224 * Note that it can return a partially full buffer even in a not error/not EOF
225 * case if the underlying file descriptor gives a short read, and that can
226 * happen even on a blocking fd.
228 static ssize_t
qemu_fill_buffer(QEMUFile
*f
)
233 assert(!qemu_file_is_writable(f
));
235 pending
= f
->buf_size
- f
->buf_index
;
237 memmove(f
->buf
, f
->buf
+ f
->buf_index
, pending
);
240 f
->buf_size
= pending
;
242 len
= f
->ops
->get_buffer(f
->opaque
, f
->buf
+ pending
, f
->pos
,
243 IO_BUF_SIZE
- pending
);
247 } else if (len
== 0) {
248 qemu_file_set_error(f
, -EIO
);
249 } else if (len
!= -EAGAIN
) {
250 qemu_file_set_error(f
, len
);
256 int qemu_get_fd(QEMUFile
*f
)
258 if (f
->ops
->get_fd
) {
259 return f
->ops
->get_fd(f
->opaque
);
264 void qemu_update_position(QEMUFile
*f
, size_t size
)
271 * Returns negative error value if any error happened on previous operations or
272 * while closing the file. Returns 0 or positive number on success.
274 * The meaning of return value on success depends on the specific backend
277 int qemu_fclose(QEMUFile
*f
)
281 ret
= qemu_file_get_error(f
);
284 int ret2
= f
->ops
->close(f
->opaque
);
289 /* If any error was spotted before closing, we should report it
290 * instead of the close() return value.
296 trace_qemu_file_fclose();
300 static void add_to_iovec(QEMUFile
*f
, const uint8_t *buf
, size_t size
)
302 /* check for adjacent buffer and coalesce them */
303 if (f
->iovcnt
> 0 && buf
== f
->iov
[f
->iovcnt
- 1].iov_base
+
304 f
->iov
[f
->iovcnt
- 1].iov_len
) {
305 f
->iov
[f
->iovcnt
- 1].iov_len
+= size
;
307 f
->iov
[f
->iovcnt
].iov_base
= (uint8_t *)buf
;
308 f
->iov
[f
->iovcnt
++].iov_len
= size
;
311 if (f
->iovcnt
>= MAX_IOV_SIZE
) {
316 void qemu_put_buffer_async(QEMUFile
*f
, const uint8_t *buf
, size_t size
)
318 if (!f
->ops
->writev_buffer
) {
319 qemu_put_buffer(f
, buf
, size
);
327 f
->bytes_xfer
+= size
;
328 add_to_iovec(f
, buf
, size
);
331 void qemu_put_buffer(QEMUFile
*f
, const uint8_t *buf
, size_t size
)
340 l
= IO_BUF_SIZE
- f
->buf_index
;
344 memcpy(f
->buf
+ f
->buf_index
, buf
, l
);
346 if (f
->ops
->writev_buffer
) {
347 add_to_iovec(f
, f
->buf
+ f
->buf_index
, l
);
350 if (f
->buf_index
== IO_BUF_SIZE
) {
353 if (qemu_file_get_error(f
)) {
361 void qemu_put_byte(QEMUFile
*f
, int v
)
367 f
->buf
[f
->buf_index
] = v
;
369 if (f
->ops
->writev_buffer
) {
370 add_to_iovec(f
, f
->buf
+ f
->buf_index
, 1);
373 if (f
->buf_index
== IO_BUF_SIZE
) {
378 void qemu_file_skip(QEMUFile
*f
, int size
)
380 if (f
->buf_index
+ size
<= f
->buf_size
) {
381 f
->buf_index
+= size
;
386 * Read 'size' bytes from file (at 'offset') without moving the
387 * pointer and set 'buf' to point to that data.
389 * It will return size bytes unless there was an error, in which case it will
390 * return as many as it managed to read (assuming blocking fd's which
391 * all current QEMUFile are)
393 size_t qemu_peek_buffer(QEMUFile
*f
, uint8_t **buf
, size_t size
, size_t offset
)
398 assert(!qemu_file_is_writable(f
));
399 assert(offset
< IO_BUF_SIZE
);
400 assert(size
<= IO_BUF_SIZE
- offset
);
402 /* The 1st byte to read from */
403 index
= f
->buf_index
+ offset
;
404 /* The number of available bytes starting at index */
405 pending
= f
->buf_size
- index
;
408 * qemu_fill_buffer might return just a few bytes, even when there isn't
409 * an error, so loop collecting them until we get enough.
411 while (pending
< size
) {
412 int received
= qemu_fill_buffer(f
);
418 index
= f
->buf_index
+ offset
;
419 pending
= f
->buf_size
- index
;
425 if (size
> pending
) {
429 *buf
= f
->buf
+ index
;
434 * Read 'size' bytes of data from the file into buf.
435 * 'size' can be larger than the internal buffer.
437 * It will return size bytes unless there was an error, in which case it will
438 * return as many as it managed to read (assuming blocking fd's which
439 * all current QEMUFile are)
441 size_t qemu_get_buffer(QEMUFile
*f
, uint8_t *buf
, size_t size
)
443 size_t pending
= size
;
446 while (pending
> 0) {
450 res
= qemu_peek_buffer(f
, &src
, MIN(pending
, IO_BUF_SIZE
), 0);
454 memcpy(buf
, src
, res
);
455 qemu_file_skip(f
, res
);
464 * Read 'size' bytes of data from the file.
465 * 'size' can be larger than the internal buffer.
468 * may be held on an internal buffer (in which case *buf is updated
469 * to point to it) that is valid until the next qemu_file operation.
471 * will be copied to the *buf that was passed in.
473 * The code tries to avoid the copy if possible.
475 * It will return size bytes unless there was an error, in which case it will
476 * return as many as it managed to read (assuming blocking fd's which
477 * all current QEMUFile are)
479 * Note: Since **buf may get changed, the caller should take care to
480 * keep a pointer to the original buffer if it needs to deallocate it.
482 size_t qemu_get_buffer_in_place(QEMUFile
*f
, uint8_t **buf
, size_t size
)
484 if (size
< IO_BUF_SIZE
) {
488 res
= qemu_peek_buffer(f
, &src
, size
, 0);
491 qemu_file_skip(f
, res
);
497 return qemu_get_buffer(f
, *buf
, size
);
501 * Peeks a single byte from the buffer; this isn't guaranteed to work if
502 * offset leaves a gap after the previous read/peeked data.
504 int qemu_peek_byte(QEMUFile
*f
, int offset
)
506 int index
= f
->buf_index
+ offset
;
508 assert(!qemu_file_is_writable(f
));
509 assert(offset
< IO_BUF_SIZE
);
511 if (index
>= f
->buf_size
) {
513 index
= f
->buf_index
+ offset
;
514 if (index
>= f
->buf_size
) {
518 return f
->buf
[index
];
521 int qemu_get_byte(QEMUFile
*f
)
525 result
= qemu_peek_byte(f
, 0);
526 qemu_file_skip(f
, 1);
530 int64_t qemu_ftell_fast(QEMUFile
*f
)
532 int64_t ret
= f
->pos
;
535 if (f
->ops
->writev_buffer
) {
536 for (i
= 0; i
< f
->iovcnt
; i
++) {
537 ret
+= f
->iov
[i
].iov_len
;
546 int64_t qemu_ftell(QEMUFile
*f
)
552 int qemu_file_rate_limit(QEMUFile
*f
)
554 if (qemu_file_get_error(f
)) {
557 if (f
->xfer_limit
> 0 && f
->bytes_xfer
> f
->xfer_limit
) {
563 int64_t qemu_file_get_rate_limit(QEMUFile
*f
)
565 return f
->xfer_limit
;
568 void qemu_file_set_rate_limit(QEMUFile
*f
, int64_t limit
)
570 f
->xfer_limit
= limit
;
573 void qemu_file_reset_rate_limit(QEMUFile
*f
)
578 void qemu_put_be16(QEMUFile
*f
, unsigned int v
)
580 qemu_put_byte(f
, v
>> 8);
584 void qemu_put_be32(QEMUFile
*f
, unsigned int v
)
586 qemu_put_byte(f
, v
>> 24);
587 qemu_put_byte(f
, v
>> 16);
588 qemu_put_byte(f
, v
>> 8);
592 void qemu_put_be64(QEMUFile
*f
, uint64_t v
)
594 qemu_put_be32(f
, v
>> 32);
598 unsigned int qemu_get_be16(QEMUFile
*f
)
601 v
= qemu_get_byte(f
) << 8;
602 v
|= qemu_get_byte(f
);
606 unsigned int qemu_get_be32(QEMUFile
*f
)
609 v
= (unsigned int)qemu_get_byte(f
) << 24;
610 v
|= qemu_get_byte(f
) << 16;
611 v
|= qemu_get_byte(f
) << 8;
612 v
|= qemu_get_byte(f
);
616 uint64_t qemu_get_be64(QEMUFile
*f
)
619 v
= (uint64_t)qemu_get_be32(f
) << 32;
620 v
|= qemu_get_be32(f
);
624 /* compress size bytes of data start at p with specific compression
625 * level and store the compressed data to the buffer of f.
628 ssize_t
qemu_put_compression_data(QEMUFile
*f
, const uint8_t *p
, size_t size
,
631 ssize_t blen
= IO_BUF_SIZE
- f
->buf_index
- sizeof(int32_t);
633 if (blen
< compressBound(size
)) {
636 if (compress2(f
->buf
+ f
->buf_index
+ sizeof(int32_t), (uLongf
*)&blen
,
637 (Bytef
*)p
, size
, level
) != Z_OK
) {
638 error_report("Compress Failed!");
641 qemu_put_be32(f
, blen
);
642 f
->buf_index
+= blen
;
643 return blen
+ sizeof(int32_t);
646 /* Put the data in the buffer of f_src to the buffer of f_des, and
647 * then reset the buf_index of f_src to 0.
650 int qemu_put_qemu_file(QEMUFile
*f_des
, QEMUFile
*f_src
)
654 if (f_src
->buf_index
> 0) {
655 len
= f_src
->buf_index
;
656 qemu_put_buffer(f_des
, f_src
->buf
, f_src
->buf_index
);
657 f_src
->buf_index
= 0;
663 * Get a string whose length is determined by a single preceding byte
664 * A preallocated 256 byte buffer must be passed in.
665 * Returns: len on success and a 0 terminated string in the buffer
667 * (Note a 0 length string will return 0 either way)
669 size_t qemu_get_counted_string(QEMUFile
*f
, char buf
[256])
671 size_t len
= qemu_get_byte(f
);
672 size_t res
= qemu_get_buffer(f
, (uint8_t *)buf
, len
);
676 return res
== len
? res
: 0;
680 * Set the blocking state of the QEMUFile.
681 * Note: On some transports the OS only keeps a single blocking state for
682 * both directions, and thus changing the blocking on the main
683 * QEMUFile can also affect the return path.
685 void qemu_file_set_blocking(QEMUFile
*f
, bool block
)
687 if (f
->ops
->set_blocking
) {
688 f
->ops
->set_blocking(f
->opaque
, block
);
691 qemu_set_block(qemu_get_fd(f
));
693 qemu_set_nonblock(qemu_get_fd(f
));