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"
35 #define IO_BUF_SIZE 32768
36 #define MAX_IOV_SIZE MIN(IOV_MAX, 64)
39 const QEMUFileOps
*ops
;
40 const QEMUFileHooks
*hooks
;
46 int64_t pos
; /* start of buffer when writing, end of buffer
49 int buf_size
; /* 0 when writing */
50 uint8_t buf
[IO_BUF_SIZE
];
52 struct iovec iov
[MAX_IOV_SIZE
];
59 * Stop a file from being read/written - not all backing files can do this
60 * typically only sockets can.
62 int qemu_file_shutdown(QEMUFile
*f
)
64 if (!f
->ops
->shut_down
) {
67 return f
->ops
->shut_down(f
->opaque
, true, true);
71 * Result: QEMUFile* for a 'return path' for comms in the opposite direction
72 * NULL if not available
74 QEMUFile
*qemu_file_get_return_path(QEMUFile
*f
)
76 if (!f
->ops
->get_return_path
) {
79 return f
->ops
->get_return_path(f
->opaque
);
82 bool qemu_file_mode_is_not_valid(const char *mode
)
85 (mode
[0] != 'r' && mode
[0] != 'w') ||
86 mode
[1] != 'b' || mode
[2] != 0) {
87 fprintf(stderr
, "qemu_fopen: Argument validity check failed\n");
94 QEMUFile
*qemu_fopen_ops(void *opaque
, const QEMUFileOps
*ops
)
98 f
= g_new0(QEMUFile
, 1);
106 void qemu_file_set_hooks(QEMUFile
*f
, const QEMUFileHooks
*hooks
)
112 * Get last error for stream f
114 * Return negative error value if there has been an error on previous
115 * operations, return 0 if no error happened.
118 int qemu_file_get_error(QEMUFile
*f
)
120 return f
->last_error
;
123 void qemu_file_set_error(QEMUFile
*f
, int ret
)
125 if (f
->last_error
== 0) {
130 bool qemu_file_is_writable(QEMUFile
*f
)
132 return f
->ops
->writev_buffer
|| f
->ops
->put_buffer
;
136 * Flushes QEMUFile buffer
138 * If there is writev_buffer QEMUFileOps it uses it otherwise uses
139 * put_buffer ops. This will flush all pending data. If data was
140 * only partially flushed, it will set an error state.
142 void qemu_fflush(QEMUFile
*f
)
147 if (!qemu_file_is_writable(f
)) {
151 if (f
->ops
->writev_buffer
) {
153 expect
= iov_size(f
->iov
, f
->iovcnt
);
154 ret
= f
->ops
->writev_buffer(f
->opaque
, f
->iov
, f
->iovcnt
, f
->pos
);
157 if (f
->buf_index
> 0) {
158 expect
= f
->buf_index
;
159 ret
= f
->ops
->put_buffer(f
->opaque
, f
->buf
, f
->pos
, f
->buf_index
);
166 /* We expect the QEMUFile write impl to send the full
167 * data set we requested, so sanity check that.
170 qemu_file_set_error(f
, ret
< 0 ? ret
: -EIO
);
176 void ram_control_before_iterate(QEMUFile
*f
, uint64_t flags
)
180 if (f
->hooks
&& f
->hooks
->before_ram_iterate
) {
181 ret
= f
->hooks
->before_ram_iterate(f
, f
->opaque
, flags
, NULL
);
183 qemu_file_set_error(f
, ret
);
188 void ram_control_after_iterate(QEMUFile
*f
, uint64_t flags
)
192 if (f
->hooks
&& f
->hooks
->after_ram_iterate
) {
193 ret
= f
->hooks
->after_ram_iterate(f
, f
->opaque
, flags
, NULL
);
195 qemu_file_set_error(f
, ret
);
200 void ram_control_load_hook(QEMUFile
*f
, uint64_t flags
, void *data
)
204 if (f
->hooks
&& f
->hooks
->hook_ram_load
) {
205 ret
= f
->hooks
->hook_ram_load(f
, f
->opaque
, flags
, data
);
207 qemu_file_set_error(f
, ret
);
211 * Hook is a hook specifically requested by the source sending a flag
212 * that expects there to be a hook on the destination.
214 if (flags
== RAM_CONTROL_HOOK
) {
215 qemu_file_set_error(f
, ret
);
220 size_t ram_control_save_page(QEMUFile
*f
, ram_addr_t block_offset
,
221 ram_addr_t offset
, size_t size
,
222 uint64_t *bytes_sent
)
224 if (f
->hooks
&& f
->hooks
->save_page
) {
225 int ret
= f
->hooks
->save_page(f
, f
->opaque
, block_offset
,
226 offset
, size
, bytes_sent
);
228 if (ret
!= RAM_SAVE_CONTROL_DELAYED
) {
229 if (bytes_sent
&& *bytes_sent
> 0) {
230 qemu_update_position(f
, *bytes_sent
);
231 } else if (ret
< 0) {
232 qemu_file_set_error(f
, ret
);
239 return RAM_SAVE_CONTROL_NOT_SUPP
;
243 * Attempt to fill the buffer from the underlying file
244 * Returns the number of bytes read, or negative value for an error.
246 * Note that it can return a partially full buffer even in a not error/not EOF
247 * case if the underlying file descriptor gives a short read, and that can
248 * happen even on a blocking fd.
250 static ssize_t
qemu_fill_buffer(QEMUFile
*f
)
255 assert(!qemu_file_is_writable(f
));
257 pending
= f
->buf_size
- f
->buf_index
;
259 memmove(f
->buf
, f
->buf
+ f
->buf_index
, pending
);
262 f
->buf_size
= pending
;
264 len
= f
->ops
->get_buffer(f
->opaque
, f
->buf
+ pending
, f
->pos
,
265 IO_BUF_SIZE
- pending
);
269 } else if (len
== 0) {
270 qemu_file_set_error(f
, -EIO
);
271 } else if (len
!= -EAGAIN
) {
272 qemu_file_set_error(f
, len
);
278 int qemu_get_fd(QEMUFile
*f
)
280 if (f
->ops
->get_fd
) {
281 return f
->ops
->get_fd(f
->opaque
);
286 void qemu_update_position(QEMUFile
*f
, size_t size
)
293 * Returns negative error value if any error happened on previous operations or
294 * while closing the file. Returns 0 or positive number on success.
296 * The meaning of return value on success depends on the specific backend
299 int qemu_fclose(QEMUFile
*f
)
303 ret
= qemu_file_get_error(f
);
306 int ret2
= f
->ops
->close(f
->opaque
);
311 /* If any error was spotted before closing, we should report it
312 * instead of the close() return value.
318 trace_qemu_file_fclose();
322 static void add_to_iovec(QEMUFile
*f
, const uint8_t *buf
, size_t size
)
324 /* check for adjacent buffer and coalesce them */
325 if (f
->iovcnt
> 0 && buf
== f
->iov
[f
->iovcnt
- 1].iov_base
+
326 f
->iov
[f
->iovcnt
- 1].iov_len
) {
327 f
->iov
[f
->iovcnt
- 1].iov_len
+= size
;
329 f
->iov
[f
->iovcnt
].iov_base
= (uint8_t *)buf
;
330 f
->iov
[f
->iovcnt
++].iov_len
= size
;
333 if (f
->iovcnt
>= MAX_IOV_SIZE
) {
338 void qemu_put_buffer_async(QEMUFile
*f
, const uint8_t *buf
, size_t size
)
340 if (!f
->ops
->writev_buffer
) {
341 qemu_put_buffer(f
, buf
, size
);
349 f
->bytes_xfer
+= size
;
350 add_to_iovec(f
, buf
, size
);
353 void qemu_put_buffer(QEMUFile
*f
, const uint8_t *buf
, size_t size
)
362 l
= IO_BUF_SIZE
- f
->buf_index
;
366 memcpy(f
->buf
+ f
->buf_index
, buf
, l
);
368 if (f
->ops
->writev_buffer
) {
369 add_to_iovec(f
, f
->buf
+ f
->buf_index
, l
);
372 if (f
->buf_index
== IO_BUF_SIZE
) {
375 if (qemu_file_get_error(f
)) {
383 void qemu_put_byte(QEMUFile
*f
, int v
)
389 f
->buf
[f
->buf_index
] = v
;
391 if (f
->ops
->writev_buffer
) {
392 add_to_iovec(f
, f
->buf
+ f
->buf_index
, 1);
395 if (f
->buf_index
== IO_BUF_SIZE
) {
400 void qemu_file_skip(QEMUFile
*f
, int size
)
402 if (f
->buf_index
+ size
<= f
->buf_size
) {
403 f
->buf_index
+= size
;
408 * Read 'size' bytes from file (at 'offset') without moving the
409 * pointer and set 'buf' to point to that data.
411 * It will return size bytes unless there was an error, in which case it will
412 * return as many as it managed to read (assuming blocking fd's which
413 * all current QEMUFile are)
415 size_t qemu_peek_buffer(QEMUFile
*f
, uint8_t **buf
, size_t size
, size_t offset
)
420 assert(!qemu_file_is_writable(f
));
421 assert(offset
< IO_BUF_SIZE
);
422 assert(size
<= IO_BUF_SIZE
- offset
);
424 /* The 1st byte to read from */
425 index
= f
->buf_index
+ offset
;
426 /* The number of available bytes starting at index */
427 pending
= f
->buf_size
- index
;
430 * qemu_fill_buffer might return just a few bytes, even when there isn't
431 * an error, so loop collecting them until we get enough.
433 while (pending
< size
) {
434 int received
= qemu_fill_buffer(f
);
440 index
= f
->buf_index
+ offset
;
441 pending
= f
->buf_size
- index
;
447 if (size
> pending
) {
451 *buf
= f
->buf
+ index
;
456 * Read 'size' bytes of data from the file into buf.
457 * 'size' can be larger than the internal buffer.
459 * It will return size bytes unless there was an error, in which case it will
460 * return as many as it managed to read (assuming blocking fd's which
461 * all current QEMUFile are)
463 size_t qemu_get_buffer(QEMUFile
*f
, uint8_t *buf
, size_t size
)
465 size_t pending
= size
;
468 while (pending
> 0) {
472 res
= qemu_peek_buffer(f
, &src
, MIN(pending
, IO_BUF_SIZE
), 0);
476 memcpy(buf
, src
, res
);
477 qemu_file_skip(f
, res
);
486 * Read 'size' bytes of data from the file.
487 * 'size' can be larger than the internal buffer.
490 * may be held on an internal buffer (in which case *buf is updated
491 * to point to it) that is valid until the next qemu_file operation.
493 * will be copied to the *buf that was passed in.
495 * The code tries to avoid the copy if possible.
497 * It will return size bytes unless there was an error, in which case it will
498 * return as many as it managed to read (assuming blocking fd's which
499 * all current QEMUFile are)
501 * Note: Since **buf may get changed, the caller should take care to
502 * keep a pointer to the original buffer if it needs to deallocate it.
504 size_t qemu_get_buffer_in_place(QEMUFile
*f
, uint8_t **buf
, size_t size
)
506 if (size
< IO_BUF_SIZE
) {
510 res
= qemu_peek_buffer(f
, &src
, size
, 0);
513 qemu_file_skip(f
, res
);
519 return qemu_get_buffer(f
, *buf
, size
);
523 * Peeks a single byte from the buffer; this isn't guaranteed to work if
524 * offset leaves a gap after the previous read/peeked data.
526 int qemu_peek_byte(QEMUFile
*f
, int offset
)
528 int index
= f
->buf_index
+ offset
;
530 assert(!qemu_file_is_writable(f
));
531 assert(offset
< IO_BUF_SIZE
);
533 if (index
>= f
->buf_size
) {
535 index
= f
->buf_index
+ offset
;
536 if (index
>= f
->buf_size
) {
540 return f
->buf
[index
];
543 int qemu_get_byte(QEMUFile
*f
)
547 result
= qemu_peek_byte(f
, 0);
548 qemu_file_skip(f
, 1);
552 int64_t qemu_ftell_fast(QEMUFile
*f
)
554 int64_t ret
= f
->pos
;
557 if (f
->ops
->writev_buffer
) {
558 for (i
= 0; i
< f
->iovcnt
; i
++) {
559 ret
+= f
->iov
[i
].iov_len
;
568 int64_t qemu_ftell(QEMUFile
*f
)
574 int qemu_file_rate_limit(QEMUFile
*f
)
576 if (qemu_file_get_error(f
)) {
579 if (f
->xfer_limit
> 0 && f
->bytes_xfer
> f
->xfer_limit
) {
585 int64_t qemu_file_get_rate_limit(QEMUFile
*f
)
587 return f
->xfer_limit
;
590 void qemu_file_set_rate_limit(QEMUFile
*f
, int64_t limit
)
592 f
->xfer_limit
= limit
;
595 void qemu_file_reset_rate_limit(QEMUFile
*f
)
600 void qemu_put_be16(QEMUFile
*f
, unsigned int v
)
602 qemu_put_byte(f
, v
>> 8);
606 void qemu_put_be32(QEMUFile
*f
, unsigned int v
)
608 qemu_put_byte(f
, v
>> 24);
609 qemu_put_byte(f
, v
>> 16);
610 qemu_put_byte(f
, v
>> 8);
614 void qemu_put_be64(QEMUFile
*f
, uint64_t v
)
616 qemu_put_be32(f
, v
>> 32);
620 unsigned int qemu_get_be16(QEMUFile
*f
)
623 v
= qemu_get_byte(f
) << 8;
624 v
|= qemu_get_byte(f
);
628 unsigned int qemu_get_be32(QEMUFile
*f
)
631 v
= (unsigned int)qemu_get_byte(f
) << 24;
632 v
|= qemu_get_byte(f
) << 16;
633 v
|= qemu_get_byte(f
) << 8;
634 v
|= qemu_get_byte(f
);
638 uint64_t qemu_get_be64(QEMUFile
*f
)
641 v
= (uint64_t)qemu_get_be32(f
) << 32;
642 v
|= qemu_get_be32(f
);
646 /* compress size bytes of data start at p with specific compression
647 * level and store the compressed data to the buffer of f.
650 ssize_t
qemu_put_compression_data(QEMUFile
*f
, const uint8_t *p
, size_t size
,
653 ssize_t blen
= IO_BUF_SIZE
- f
->buf_index
- sizeof(int32_t);
655 if (blen
< compressBound(size
)) {
658 if (compress2(f
->buf
+ f
->buf_index
+ sizeof(int32_t), (uLongf
*)&blen
,
659 (Bytef
*)p
, size
, level
) != Z_OK
) {
660 error_report("Compress Failed!");
663 qemu_put_be32(f
, blen
);
664 f
->buf_index
+= blen
;
665 return blen
+ sizeof(int32_t);
668 /* Put the data in the buffer of f_src to the buffer of f_des, and
669 * then reset the buf_index of f_src to 0.
672 int qemu_put_qemu_file(QEMUFile
*f_des
, QEMUFile
*f_src
)
676 if (f_src
->buf_index
> 0) {
677 len
= f_src
->buf_index
;
678 qemu_put_buffer(f_des
, f_src
->buf
, f_src
->buf_index
);
679 f_src
->buf_index
= 0;
685 * Get a string whose length is determined by a single preceding byte
686 * A preallocated 256 byte buffer must be passed in.
687 * Returns: len on success and a 0 terminated string in the buffer
689 * (Note a 0 length string will return 0 either way)
691 size_t qemu_get_counted_string(QEMUFile
*f
, char buf
[256])
693 size_t len
= qemu_get_byte(f
);
694 size_t res
= qemu_get_buffer(f
, (uint8_t *)buf
, len
);
698 return res
== len
? res
: 0;
702 * Set the blocking state of the QEMUFile.
703 * Note: On some transports the OS only keeps a single blocking state for
704 * both directions, and thus changing the blocking on the main
705 * QEMUFile can also affect the return path.
707 void qemu_file_set_blocking(QEMUFile
*f
, bool block
)
709 if (f
->ops
->set_blocking
) {
710 f
->ops
->set_blocking(f
->opaque
, block
);
713 qemu_set_block(qemu_get_fd(f
));
715 qemu_set_nonblock(qemu_get_fd(f
));