blob: e9fae3115882aca356971032602304cfed580deb [file] [log] [blame]
Eduardo Habkost9a4ac512014-10-01 14:47:33 -03001/*
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 */
Peter Maydell1393a482016-01-26 18:16:54 +000024#include "qemu/osdep.h"
Liang Li44f0ead2015-03-23 16:32:19 +080025#include <zlib.h>
Eduardo Habkost093c4552013-11-28 12:01:16 -020026#include "qemu-common.h"
Markus Armbrusterd49b6832015-03-17 18:29:20 +010027#include "qemu/error-report.h"
Eduardo Habkost093c4552013-11-28 12:01:16 -020028#include "qemu/iov.h"
29#include "qemu/sockets.h"
Daniel P. Berrange10817bf2015-09-01 14:48:02 +010030#include "qemu/coroutine.h"
Eduardo Habkost093c4552013-11-28 12:01:16 -020031#include "migration/migration.h"
32#include "migration/qemu-file.h"
Alexey Kardashevskiy9013dca2014-03-11 10:42:29 +110033#include "trace.h"
Eduardo Habkost093c4552013-11-28 12:01:16 -020034
Daniel P. Berrangea24939f2016-04-27 11:05:13 +010035#define IO_BUF_SIZE 32768
36#define MAX_IOV_SIZE MIN(IOV_MAX, 64)
37
38struct QEMUFile {
39 const QEMUFileOps *ops;
40 const QEMUFileHooks *hooks;
41 void *opaque;
42
43 int64_t bytes_xfer;
44 int64_t xfer_limit;
45
46 int64_t pos; /* start of buffer when writing, end of buffer
47 when reading */
48 int buf_index;
49 int buf_size; /* 0 when writing */
50 uint8_t buf[IO_BUF_SIZE];
51
52 struct iovec iov[MAX_IOV_SIZE];
53 unsigned int iovcnt;
54
55 int last_error;
56};
57
Dr. David Alan Gilberte1a8c9b2015-01-08 11:11:30 +000058/*
59 * Stop a file from being read/written - not all backing files can do this
60 * typically only sockets can.
61 */
62int qemu_file_shutdown(QEMUFile *f)
63{
64 if (!f->ops->shut_down) {
65 return -ENOSYS;
66 }
67 return f->ops->shut_down(f->opaque, true, true);
68}
69
Dr. David Alan Gilbertadc468e2015-11-05 18:10:43 +000070/*
71 * Result: QEMUFile* for a 'return path' for comms in the opposite direction
72 * NULL if not available
73 */
74QEMUFile *qemu_file_get_return_path(QEMUFile *f)
75{
76 if (!f->ops->get_return_path) {
77 return NULL;
78 }
79 return f->ops->get_return_path(f->opaque);
80}
81
Eduardo Habkost093c4552013-11-28 12:01:16 -020082bool qemu_file_mode_is_not_valid(const char *mode)
83{
84 if (mode == NULL ||
85 (mode[0] != 'r' && mode[0] != 'w') ||
86 mode[1] != 'b' || mode[2] != 0) {
87 fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
88 return true;
89 }
90
91 return false;
92}
93
Eduardo Habkost093c4552013-11-28 12:01:16 -020094QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)
95{
96 QEMUFile *f;
97
Markus Armbruster97f3ad32015-09-14 13:51:31 +020098 f = g_new0(QEMUFile, 1);
Eduardo Habkost093c4552013-11-28 12:01:16 -020099
100 f->opaque = opaque;
101 f->ops = ops;
102 return f;
103}
104
Daniel P. Berrange0436e092016-04-27 11:04:55 +0100105
106void qemu_file_set_hooks(QEMUFile *f, const QEMUFileHooks *hooks)
107{
108 f->hooks = hooks;
109}
110
Eduardo Habkost093c4552013-11-28 12:01:16 -0200111/*
112 * Get last error for stream f
113 *
114 * Return negative error value if there has been an error on previous
115 * operations, return 0 if no error happened.
116 *
117 */
118int qemu_file_get_error(QEMUFile *f)
119{
120 return f->last_error;
121}
122
123void qemu_file_set_error(QEMUFile *f, int ret)
124{
125 if (f->last_error == 0) {
126 f->last_error = ret;
127 }
128}
129
Eduardo Habkoste68dd362014-10-01 17:34:34 -0300130bool qemu_file_is_writable(QEMUFile *f)
Eduardo Habkost093c4552013-11-28 12:01:16 -0200131{
Daniel P. Berrange11808bb2016-04-27 11:05:17 +0100132 return f->ops->writev_buffer;
Eduardo Habkost093c4552013-11-28 12:01:16 -0200133}
134
135/**
136 * Flushes QEMUFile buffer
137 *
138 * If there is writev_buffer QEMUFileOps it uses it otherwise uses
Daniel P. Berrangebaf51e72016-04-27 11:04:54 +0100139 * put_buffer ops. This will flush all pending data. If data was
140 * only partially flushed, it will set an error state.
Eduardo Habkost093c4552013-11-28 12:01:16 -0200141 */
142void qemu_fflush(QEMUFile *f)
143{
144 ssize_t ret = 0;
Daniel P. Berrangebaf51e72016-04-27 11:04:54 +0100145 ssize_t expect = 0;
Eduardo Habkost093c4552013-11-28 12:01:16 -0200146
147 if (!qemu_file_is_writable(f)) {
148 return;
149 }
150
Daniel P. Berrange11808bb2016-04-27 11:05:17 +0100151 if (f->iovcnt > 0) {
152 expect = iov_size(f->iov, f->iovcnt);
153 ret = f->ops->writev_buffer(f->opaque, f->iov, f->iovcnt, f->pos);
Eduardo Habkost093c4552013-11-28 12:01:16 -0200154 }
Daniel P. Berrangebaf51e72016-04-27 11:04:54 +0100155
Eduardo Habkost093c4552013-11-28 12:01:16 -0200156 if (ret >= 0) {
157 f->pos += ret;
158 }
Daniel P. Berrangebaf51e72016-04-27 11:04:54 +0100159 /* We expect the QEMUFile write impl to send the full
160 * data set we requested, so sanity check that.
161 */
162 if (ret != expect) {
163 qemu_file_set_error(f, ret < 0 ? ret : -EIO);
164 }
Eduardo Habkost093c4552013-11-28 12:01:16 -0200165 f->buf_index = 0;
166 f->iovcnt = 0;
Eduardo Habkost093c4552013-11-28 12:01:16 -0200167}
168
169void ram_control_before_iterate(QEMUFile *f, uint64_t flags)
170{
171 int ret = 0;
172
Daniel P. Berrange0436e092016-04-27 11:04:55 +0100173 if (f->hooks && f->hooks->before_ram_iterate) {
174 ret = f->hooks->before_ram_iterate(f, f->opaque, flags, NULL);
Eduardo Habkost093c4552013-11-28 12:01:16 -0200175 if (ret < 0) {
176 qemu_file_set_error(f, ret);
177 }
178 }
179}
180
181void ram_control_after_iterate(QEMUFile *f, uint64_t flags)
182{
183 int ret = 0;
184
Daniel P. Berrange0436e092016-04-27 11:04:55 +0100185 if (f->hooks && f->hooks->after_ram_iterate) {
186 ret = f->hooks->after_ram_iterate(f, f->opaque, flags, NULL);
Eduardo Habkost093c4552013-11-28 12:01:16 -0200187 if (ret < 0) {
188 qemu_file_set_error(f, ret);
189 }
190 }
191}
192
Dr. David Alan Gilbert632e3a52015-06-11 18:17:23 +0100193void ram_control_load_hook(QEMUFile *f, uint64_t flags, void *data)
Eduardo Habkost093c4552013-11-28 12:01:16 -0200194{
195 int ret = -EINVAL;
196
Daniel P. Berrange0436e092016-04-27 11:04:55 +0100197 if (f->hooks && f->hooks->hook_ram_load) {
198 ret = f->hooks->hook_ram_load(f, f->opaque, flags, data);
Eduardo Habkost093c4552013-11-28 12:01:16 -0200199 if (ret < 0) {
200 qemu_file_set_error(f, ret);
201 }
202 } else {
Dr. David Alan Gilbert632e3a52015-06-11 18:17:23 +0100203 /*
204 * Hook is a hook specifically requested by the source sending a flag
205 * that expects there to be a hook on the destination.
206 */
207 if (flags == RAM_CONTROL_HOOK) {
208 qemu_file_set_error(f, ret);
209 }
Eduardo Habkost093c4552013-11-28 12:01:16 -0200210 }
211}
212
213size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset,
Juan Quintela6e1dea42015-02-12 19:02:42 +0100214 ram_addr_t offset, size_t size,
215 uint64_t *bytes_sent)
Eduardo Habkost093c4552013-11-28 12:01:16 -0200216{
Daniel P. Berrange0436e092016-04-27 11:04:55 +0100217 if (f->hooks && f->hooks->save_page) {
218 int ret = f->hooks->save_page(f, f->opaque, block_offset,
219 offset, size, bytes_sent);
Eduardo Habkost093c4552013-11-28 12:01:16 -0200220
221 if (ret != RAM_SAVE_CONTROL_DELAYED) {
222 if (bytes_sent && *bytes_sent > 0) {
223 qemu_update_position(f, *bytes_sent);
224 } else if (ret < 0) {
225 qemu_file_set_error(f, ret);
226 }
227 }
228
229 return ret;
230 }
231
232 return RAM_SAVE_CONTROL_NOT_SUPP;
233}
234
Dr. David Alan Gilbert548f52e2014-04-08 15:29:37 +0100235/*
236 * Attempt to fill the buffer from the underlying file
237 * Returns the number of bytes read, or negative value for an error.
238 *
239 * Note that it can return a partially full buffer even in a not error/not EOF
240 * case if the underlying file descriptor gives a short read, and that can
241 * happen even on a blocking fd.
242 */
243static ssize_t qemu_fill_buffer(QEMUFile *f)
Eduardo Habkost093c4552013-11-28 12:01:16 -0200244{
245 int len;
246 int pending;
247
248 assert(!qemu_file_is_writable(f));
249
250 pending = f->buf_size - f->buf_index;
251 if (pending > 0) {
252 memmove(f->buf, f->buf + f->buf_index, pending);
253 }
254 f->buf_index = 0;
255 f->buf_size = pending;
256
257 len = f->ops->get_buffer(f->opaque, f->buf + pending, f->pos,
258 IO_BUF_SIZE - pending);
259 if (len > 0) {
260 f->buf_size += len;
261 f->pos += len;
262 } else if (len == 0) {
263 qemu_file_set_error(f, -EIO);
264 } else if (len != -EAGAIN) {
265 qemu_file_set_error(f, len);
266 }
Dr. David Alan Gilbert548f52e2014-04-08 15:29:37 +0100267
268 return len;
Eduardo Habkost093c4552013-11-28 12:01:16 -0200269}
270
Eduardo Habkost093c4552013-11-28 12:01:16 -0200271void qemu_update_position(QEMUFile *f, size_t size)
272{
273 f->pos += size;
274}
275
276/** Closes the file
277 *
278 * Returns negative error value if any error happened on previous operations or
279 * while closing the file. Returns 0 or positive number on success.
280 *
281 * The meaning of return value on success depends on the specific backend
282 * being used.
283 */
284int qemu_fclose(QEMUFile *f)
285{
286 int ret;
287 qemu_fflush(f);
288 ret = qemu_file_get_error(f);
289
290 if (f->ops->close) {
291 int ret2 = f->ops->close(f->opaque);
292 if (ret >= 0) {
293 ret = ret2;
294 }
295 }
296 /* If any error was spotted before closing, we should report it
297 * instead of the close() return value.
298 */
299 if (f->last_error) {
300 ret = f->last_error;
301 }
302 g_free(f);
Alexey Kardashevskiy9013dca2014-03-11 10:42:29 +1100303 trace_qemu_file_fclose();
Eduardo Habkost093c4552013-11-28 12:01:16 -0200304 return ret;
305}
306
Dr. David Alan Gilbert56f38352015-08-13 11:51:34 +0100307static void add_to_iovec(QEMUFile *f, const uint8_t *buf, size_t size)
Eduardo Habkost093c4552013-11-28 12:01:16 -0200308{
309 /* check for adjacent buffer and coalesce them */
310 if (f->iovcnt > 0 && buf == f->iov[f->iovcnt - 1].iov_base +
311 f->iov[f->iovcnt - 1].iov_len) {
312 f->iov[f->iovcnt - 1].iov_len += size;
313 } else {
314 f->iov[f->iovcnt].iov_base = (uint8_t *)buf;
315 f->iov[f->iovcnt++].iov_len = size;
316 }
317
318 if (f->iovcnt >= MAX_IOV_SIZE) {
319 qemu_fflush(f);
320 }
321}
322
Dr. David Alan Gilbert56f38352015-08-13 11:51:34 +0100323void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, size_t size)
Eduardo Habkost093c4552013-11-28 12:01:16 -0200324{
Eduardo Habkost093c4552013-11-28 12:01:16 -0200325 if (f->last_error) {
326 return;
327 }
328
329 f->bytes_xfer += size;
330 add_to_iovec(f, buf, size);
331}
332
Dr. David Alan Gilbert56f38352015-08-13 11:51:34 +0100333void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, size_t size)
Eduardo Habkost093c4552013-11-28 12:01:16 -0200334{
Dr. David Alan Gilbert56f38352015-08-13 11:51:34 +0100335 size_t l;
Eduardo Habkost093c4552013-11-28 12:01:16 -0200336
337 if (f->last_error) {
338 return;
339 }
340
341 while (size > 0) {
342 l = IO_BUF_SIZE - f->buf_index;
343 if (l > size) {
344 l = size;
345 }
346 memcpy(f->buf + f->buf_index, buf, l);
347 f->bytes_xfer += l;
Daniel P. Berrange11808bb2016-04-27 11:05:17 +0100348 add_to_iovec(f, f->buf + f->buf_index, l);
Eduardo Habkost093c4552013-11-28 12:01:16 -0200349 f->buf_index += l;
350 if (f->buf_index == IO_BUF_SIZE) {
351 qemu_fflush(f);
352 }
353 if (qemu_file_get_error(f)) {
354 break;
355 }
356 buf += l;
357 size -= l;
358 }
359}
360
361void qemu_put_byte(QEMUFile *f, int v)
362{
363 if (f->last_error) {
364 return;
365 }
366
367 f->buf[f->buf_index] = v;
368 f->bytes_xfer++;
Daniel P. Berrange11808bb2016-04-27 11:05:17 +0100369 add_to_iovec(f, f->buf + f->buf_index, 1);
Eduardo Habkost093c4552013-11-28 12:01:16 -0200370 f->buf_index++;
371 if (f->buf_index == IO_BUF_SIZE) {
372 qemu_fflush(f);
373 }
374}
375
376void qemu_file_skip(QEMUFile *f, int size)
377{
378 if (f->buf_index + size <= f->buf_size) {
379 f->buf_index += size;
380 }
381}
382
Dr. David Alan Gilbert548f52e2014-04-08 15:29:37 +0100383/*
Dr. David Alan Gilbert7c1e52b2015-05-21 13:24:15 +0100384 * Read 'size' bytes from file (at 'offset') without moving the
385 * pointer and set 'buf' to point to that data.
Dr. David Alan Gilbert548f52e2014-04-08 15:29:37 +0100386 *
387 * It will return size bytes unless there was an error, in which case it will
388 * return as many as it managed to read (assuming blocking fd's which
389 * all current QEMUFile are)
390 */
Dr. David Alan Gilbert56f38352015-08-13 11:51:34 +0100391size_t qemu_peek_buffer(QEMUFile *f, uint8_t **buf, size_t size, size_t offset)
Eduardo Habkost093c4552013-11-28 12:01:16 -0200392{
Dr. David Alan Gilbert56f38352015-08-13 11:51:34 +0100393 ssize_t pending;
394 size_t index;
Eduardo Habkost093c4552013-11-28 12:01:16 -0200395
396 assert(!qemu_file_is_writable(f));
Dr. David Alan Gilbert548f52e2014-04-08 15:29:37 +0100397 assert(offset < IO_BUF_SIZE);
398 assert(size <= IO_BUF_SIZE - offset);
Eduardo Habkost093c4552013-11-28 12:01:16 -0200399
Dr. David Alan Gilbert548f52e2014-04-08 15:29:37 +0100400 /* The 1st byte to read from */
Eduardo Habkost093c4552013-11-28 12:01:16 -0200401 index = f->buf_index + offset;
Dr. David Alan Gilbert548f52e2014-04-08 15:29:37 +0100402 /* The number of available bytes starting at index */
Eduardo Habkost093c4552013-11-28 12:01:16 -0200403 pending = f->buf_size - index;
Dr. David Alan Gilbert548f52e2014-04-08 15:29:37 +0100404
405 /*
406 * qemu_fill_buffer might return just a few bytes, even when there isn't
407 * an error, so loop collecting them until we get enough.
408 */
409 while (pending < size) {
410 int received = qemu_fill_buffer(f);
411
412 if (received <= 0) {
413 break;
414 }
415
Eduardo Habkost093c4552013-11-28 12:01:16 -0200416 index = f->buf_index + offset;
417 pending = f->buf_size - index;
418 }
419
420 if (pending <= 0) {
421 return 0;
422 }
423 if (size > pending) {
424 size = pending;
425 }
426
Dr. David Alan Gilbert7c1e52b2015-05-21 13:24:15 +0100427 *buf = f->buf + index;
Eduardo Habkost093c4552013-11-28 12:01:16 -0200428 return size;
429}
430
Dr. David Alan Gilbert548f52e2014-04-08 15:29:37 +0100431/*
432 * Read 'size' bytes of data from the file into buf.
433 * 'size' can be larger than the internal buffer.
434 *
435 * It will return size bytes unless there was an error, in which case it will
436 * return as many as it managed to read (assuming blocking fd's which
437 * all current QEMUFile are)
438 */
Dr. David Alan Gilbert56f38352015-08-13 11:51:34 +0100439size_t qemu_get_buffer(QEMUFile *f, uint8_t *buf, size_t size)
Eduardo Habkost093c4552013-11-28 12:01:16 -0200440{
Dr. David Alan Gilbert56f38352015-08-13 11:51:34 +0100441 size_t pending = size;
442 size_t done = 0;
Eduardo Habkost093c4552013-11-28 12:01:16 -0200443
444 while (pending > 0) {
Dr. David Alan Gilbert56f38352015-08-13 11:51:34 +0100445 size_t res;
Dr. David Alan Gilbert7c1e52b2015-05-21 13:24:15 +0100446 uint8_t *src;
Eduardo Habkost093c4552013-11-28 12:01:16 -0200447
Dr. David Alan Gilbert7c1e52b2015-05-21 13:24:15 +0100448 res = qemu_peek_buffer(f, &src, MIN(pending, IO_BUF_SIZE), 0);
Eduardo Habkost093c4552013-11-28 12:01:16 -0200449 if (res == 0) {
450 return done;
451 }
Dr. David Alan Gilbert7c1e52b2015-05-21 13:24:15 +0100452 memcpy(buf, src, res);
Eduardo Habkost093c4552013-11-28 12:01:16 -0200453 qemu_file_skip(f, res);
454 buf += res;
455 pending -= res;
456 done += res;
457 }
458 return done;
459}
460
Dr. David Alan Gilbert548f52e2014-04-08 15:29:37 +0100461/*
Dr. David Alan Gilbert9504fb52015-11-05 18:10:35 +0000462 * Read 'size' bytes of data from the file.
463 * 'size' can be larger than the internal buffer.
464 *
465 * The data:
466 * may be held on an internal buffer (in which case *buf is updated
467 * to point to it) that is valid until the next qemu_file operation.
468 * OR
469 * will be copied to the *buf that was passed in.
470 *
471 * The code tries to avoid the copy if possible.
472 *
473 * It will return size bytes unless there was an error, in which case it will
474 * return as many as it managed to read (assuming blocking fd's which
475 * all current QEMUFile are)
476 *
477 * Note: Since **buf may get changed, the caller should take care to
478 * keep a pointer to the original buffer if it needs to deallocate it.
479 */
480size_t qemu_get_buffer_in_place(QEMUFile *f, uint8_t **buf, size_t size)
481{
482 if (size < IO_BUF_SIZE) {
483 size_t res;
484 uint8_t *src;
485
486 res = qemu_peek_buffer(f, &src, size, 0);
487
488 if (res == size) {
489 qemu_file_skip(f, res);
490 *buf = src;
491 return res;
492 }
493 }
494
495 return qemu_get_buffer(f, *buf, size);
496}
497
498/*
Dr. David Alan Gilbert548f52e2014-04-08 15:29:37 +0100499 * Peeks a single byte from the buffer; this isn't guaranteed to work if
500 * offset leaves a gap after the previous read/peeked data.
501 */
Eduardo Habkost093c4552013-11-28 12:01:16 -0200502int qemu_peek_byte(QEMUFile *f, int offset)
503{
504 int index = f->buf_index + offset;
505
506 assert(!qemu_file_is_writable(f));
Dr. David Alan Gilbert548f52e2014-04-08 15:29:37 +0100507 assert(offset < IO_BUF_SIZE);
Eduardo Habkost093c4552013-11-28 12:01:16 -0200508
509 if (index >= f->buf_size) {
510 qemu_fill_buffer(f);
511 index = f->buf_index + offset;
512 if (index >= f->buf_size) {
513 return 0;
514 }
515 }
516 return f->buf[index];
517}
518
519int qemu_get_byte(QEMUFile *f)
520{
521 int result;
522
523 result = qemu_peek_byte(f, 0);
524 qemu_file_skip(f, 1);
525 return result;
526}
527
Alexander Graf97221402015-01-22 15:01:38 +0100528int64_t qemu_ftell_fast(QEMUFile *f)
529{
530 int64_t ret = f->pos;
531 int i;
532
Daniel P. Berrange11808bb2016-04-27 11:05:17 +0100533 for (i = 0; i < f->iovcnt; i++) {
534 ret += f->iov[i].iov_len;
Alexander Graf97221402015-01-22 15:01:38 +0100535 }
536
537 return ret;
538}
539
Eduardo Habkost093c4552013-11-28 12:01:16 -0200540int64_t qemu_ftell(QEMUFile *f)
541{
542 qemu_fflush(f);
543 return f->pos;
544}
545
546int qemu_file_rate_limit(QEMUFile *f)
547{
548 if (qemu_file_get_error(f)) {
549 return 1;
550 }
551 if (f->xfer_limit > 0 && f->bytes_xfer > f->xfer_limit) {
552 return 1;
553 }
554 return 0;
555}
556
557int64_t qemu_file_get_rate_limit(QEMUFile *f)
558{
559 return f->xfer_limit;
560}
561
562void qemu_file_set_rate_limit(QEMUFile *f, int64_t limit)
563{
564 f->xfer_limit = limit;
565}
566
567void qemu_file_reset_rate_limit(QEMUFile *f)
568{
569 f->bytes_xfer = 0;
570}
571
572void qemu_put_be16(QEMUFile *f, unsigned int v)
573{
574 qemu_put_byte(f, v >> 8);
575 qemu_put_byte(f, v);
576}
577
578void qemu_put_be32(QEMUFile *f, unsigned int v)
579{
580 qemu_put_byte(f, v >> 24);
581 qemu_put_byte(f, v >> 16);
582 qemu_put_byte(f, v >> 8);
583 qemu_put_byte(f, v);
584}
585
586void qemu_put_be64(QEMUFile *f, uint64_t v)
587{
588 qemu_put_be32(f, v >> 32);
589 qemu_put_be32(f, v);
590}
591
592unsigned int qemu_get_be16(QEMUFile *f)
593{
594 unsigned int v;
595 v = qemu_get_byte(f) << 8;
596 v |= qemu_get_byte(f);
597 return v;
598}
599
600unsigned int qemu_get_be32(QEMUFile *f)
601{
602 unsigned int v;
Peter Maydell90d6a672014-12-23 22:26:55 +0000603 v = (unsigned int)qemu_get_byte(f) << 24;
Eduardo Habkost093c4552013-11-28 12:01:16 -0200604 v |= qemu_get_byte(f) << 16;
605 v |= qemu_get_byte(f) << 8;
606 v |= qemu_get_byte(f);
607 return v;
608}
609
610uint64_t qemu_get_be64(QEMUFile *f)
611{
612 uint64_t v;
613 v = (uint64_t)qemu_get_be32(f) << 32;
614 v |= qemu_get_be32(f);
615 return v;
616}
Liang Li44f0ead2015-03-23 16:32:19 +0800617
Liang Lib3be2892016-05-05 15:32:54 +0800618/* Compress size bytes of data start at p with specific compression
Liang Li44f0ead2015-03-23 16:32:19 +0800619 * level and store the compressed data to the buffer of f.
Liang Lib3be2892016-05-05 15:32:54 +0800620 *
621 * When f is not writable, return -1 if f has no space to save the
622 * compressed data.
623 * When f is wirtable and it has no space to save the compressed data,
624 * do fflush first, if f still has no space to save the compressed
625 * data, return -1.
Liang Li44f0ead2015-03-23 16:32:19 +0800626 */
627
628ssize_t qemu_put_compression_data(QEMUFile *f, const uint8_t *p, size_t size,
629 int level)
630{
631 ssize_t blen = IO_BUF_SIZE - f->buf_index - sizeof(int32_t);
632
633 if (blen < compressBound(size)) {
Liang Lib3be2892016-05-05 15:32:54 +0800634 if (!qemu_file_is_writable(f)) {
635 return -1;
636 }
637 qemu_fflush(f);
638 blen = IO_BUF_SIZE - sizeof(int32_t);
639 if (blen < compressBound(size)) {
640 return -1;
641 }
Liang Li44f0ead2015-03-23 16:32:19 +0800642 }
643 if (compress2(f->buf + f->buf_index + sizeof(int32_t), (uLongf *)&blen,
644 (Bytef *)p, size, level) != Z_OK) {
645 error_report("Compress Failed!");
646 return 0;
647 }
648 qemu_put_be32(f, blen);
Liang Lib3be2892016-05-05 15:32:54 +0800649 if (f->ops->writev_buffer) {
650 add_to_iovec(f, f->buf + f->buf_index, blen);
651 }
Liang Li44f0ead2015-03-23 16:32:19 +0800652 f->buf_index += blen;
Liang Lib3be2892016-05-05 15:32:54 +0800653 if (f->buf_index == IO_BUF_SIZE) {
654 qemu_fflush(f);
655 }
Liang Li44f0ead2015-03-23 16:32:19 +0800656 return blen + sizeof(int32_t);
657}
658
659/* Put the data in the buffer of f_src to the buffer of f_des, and
660 * then reset the buf_index of f_src to 0.
661 */
662
663int qemu_put_qemu_file(QEMUFile *f_des, QEMUFile *f_src)
664{
665 int len = 0;
666
667 if (f_src->buf_index > 0) {
668 len = f_src->buf_index;
669 qemu_put_buffer(f_des, f_src->buf, f_src->buf_index);
670 f_src->buf_index = 0;
Liang Li787d1342016-08-09 08:22:26 +0800671 f_src->iovcnt = 0;
Liang Li44f0ead2015-03-23 16:32:19 +0800672 }
673 return len;
674}
Dr. David Alan Gilbertb3af1bc2015-05-21 13:24:11 +0100675
676/*
677 * Get a string whose length is determined by a single preceding byte
678 * A preallocated 256 byte buffer must be passed in.
679 * Returns: len on success and a 0 terminated string in the buffer
680 * else 0
681 * (Note a 0 length string will return 0 either way)
682 */
683size_t qemu_get_counted_string(QEMUFile *f, char buf[256])
684{
685 size_t len = qemu_get_byte(f);
686 size_t res = qemu_get_buffer(f, (uint8_t *)buf, len);
687
688 buf[res] = 0;
689
690 return res == len ? res : 0;
691}
Dr. David Alan Gilberta800cd52015-11-05 18:10:36 +0000692
693/*
694 * Set the blocking state of the QEMUFile.
695 * Note: On some transports the OS only keeps a single blocking state for
696 * both directions, and thus changing the blocking on the main
697 * QEMUFile can also affect the return path.
698 */
699void qemu_file_set_blocking(QEMUFile *f, bool block)
700{
Daniel P. Berrange06ad5132016-04-27 11:04:56 +0100701 if (f->ops->set_blocking) {
702 f->ops->set_blocking(f->opaque, block);
Dr. David Alan Gilberta800cd52015-11-05 18:10:36 +0000703 }
704}