blob: a01c5b817eff7e4fa15233af6dd5fd101ad829c5 [file] [log] [blame]
Paolo Bonzini701a8f72012-01-13 17:07:20 +01001/*
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 */
24#ifndef QEMU_FILE_H
25#define QEMU_FILE_H 1
Michael R. Hines43487c62013-06-25 21:35:35 -040026#include "exec/cpu-common.h"
Paolo Bonzini701a8f72012-01-13 17:07:20 +010027
Dr. David Alan Gilbertdeb22f92014-10-10 12:39:04 +010028#include <stdint.h>
29
Paolo Bonzini701a8f72012-01-13 17:07:20 +010030/* This function writes a chunk of data to a file at the given position.
31 * The pos argument can be ignored if the file is only being used for
32 * streaming. The handler should try to write all of the data it can.
33 */
34typedef int (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf,
35 int64_t pos, int size);
36
37/* Read a chunk of data from a file at the given position. The pos argument
38 * can be ignored if the file is only be used for streaming. The number of
39 * bytes actually read should be returned.
40 */
41typedef int (QEMUFileGetBufferFunc)(void *opaque, uint8_t *buf,
42 int64_t pos, int size);
43
44/* Close a file
45 *
46 * Return negative error number on error, 0 or positive value on success.
47 *
48 * The meaning of return value on success depends on the specific back-end being
49 * used.
50 */
51typedef int (QEMUFileCloseFunc)(void *opaque);
52
Paolo Bonzini70eb6332012-08-08 10:20:18 +020053/* Called to return the OS file descriptor associated to the QEMUFile.
54 */
55typedef int (QEMUFileGetFD)(void *opaque);
56
Orit Wassermand9138292013-03-22 16:47:57 +020057/*
58 * This function writes an iovec to file.
59 */
60typedef ssize_t (QEMUFileWritevBufferFunc)(void *opaque, struct iovec *iov,
Kevin Wolf05fcc842013-04-05 21:27:54 +020061 int iovcnt, int64_t pos);
Orit Wassermand9138292013-03-22 16:47:57 +020062
Michael R. Hines43487c62013-06-25 21:35:35 -040063/*
64 * This function provides hooks around different
65 * stages of RAM migration.
66 */
67typedef int (QEMURamHookFunc)(QEMUFile *f, void *opaque, uint64_t flags);
68
69/*
70 * Constants used by ram_control_* hooks
71 */
72#define RAM_CONTROL_SETUP 0
73#define RAM_CONTROL_ROUND 1
74#define RAM_CONTROL_HOOK 2
75#define RAM_CONTROL_FINISH 3
76
77/*
78 * This function allows override of where the RAM page
79 * is saved (such as RDMA, for example.)
80 */
81typedef size_t (QEMURamSaveFunc)(QEMUFile *f, void *opaque,
82 ram_addr_t block_offset,
83 ram_addr_t offset,
84 size_t size,
Juan Quintela6e1dea42015-02-12 19:02:42 +010085 uint64_t *bytes_sent);
Michael R. Hines43487c62013-06-25 21:35:35 -040086
Dr. David Alan Gilberte1a8c9b2015-01-08 11:11:30 +000087/*
88 * Stop any read or write (depending on flags) on the underlying
89 * transport on the QEMUFile.
90 * Existing blocking reads/writes must be woken
91 * Returns 0 on success, -err on error
92 */
93typedef int (QEMUFileShutdownFunc)(void *opaque, bool rd, bool wr);
94
Paolo Bonzini9229bf32012-08-08 10:15:15 +020095typedef struct QEMUFileOps {
96 QEMUFilePutBufferFunc *put_buffer;
97 QEMUFileGetBufferFunc *get_buffer;
98 QEMUFileCloseFunc *close;
Paolo Bonzini70eb6332012-08-08 10:20:18 +020099 QEMUFileGetFD *get_fd;
Orit Wassermand9138292013-03-22 16:47:57 +0200100 QEMUFileWritevBufferFunc *writev_buffer;
Michael R. Hines43487c62013-06-25 21:35:35 -0400101 QEMURamHookFunc *before_ram_iterate;
102 QEMURamHookFunc *after_ram_iterate;
103 QEMURamHookFunc *hook_ram_load;
104 QEMURamSaveFunc *save_page;
Dr. David Alan Gilberte1a8c9b2015-01-08 11:11:30 +0000105 QEMUFileShutdownFunc *shut_down;
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200106} QEMUFileOps;
107
Dr. David Alan Gilbertdeb22f92014-10-10 12:39:04 +0100108struct QEMUSizedBuffer {
109 struct iovec *iov;
110 size_t n_iov;
111 size_t size; /* total allocated size in all iov's */
112 size_t used; /* number of used bytes */
113};
114
Paolo Bonzini9229bf32012-08-08 10:15:15 +0200115QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops);
Paolo Bonzini701a8f72012-01-13 17:07:20 +0100116QEMUFile *qemu_fopen(const char *filename, const char *mode);
117QEMUFile *qemu_fdopen(int fd, const char *mode);
Paolo Bonzini0cc3f3c2013-02-22 17:36:39 +0100118QEMUFile *qemu_fopen_socket(int fd, const char *mode);
Paolo Bonzini701a8f72012-01-13 17:07:20 +0100119QEMUFile *qemu_popen_cmd(const char *command, const char *mode);
Dr. David Alan Gilbertdeb22f92014-10-10 12:39:04 +0100120QEMUFile *qemu_bufopen(const char *mode, QEMUSizedBuffer *input);
Paolo Bonzini70eb6332012-08-08 10:20:18 +0200121int qemu_get_fd(QEMUFile *f);
Paolo Bonzini701a8f72012-01-13 17:07:20 +0100122int qemu_fclose(QEMUFile *f);
Stefan Hajnocziad55ab42013-02-12 10:37:14 +0100123int64_t qemu_ftell(QEMUFile *f);
Alexander Graf97221402015-01-22 15:01:38 +0100124int64_t qemu_ftell_fast(QEMUFile *f);
Paolo Bonzini701a8f72012-01-13 17:07:20 +0100125void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);
126void qemu_put_byte(QEMUFile *f, int v);
Orit Wasserman6181ec22013-03-22 16:48:02 +0200127/*
128 * put_buffer without copying the buffer.
129 * The buffer should be available till it is sent asynchronously.
130 */
131void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, int size);
Michael R. Hinesbc1256f2013-06-25 21:35:31 -0400132bool qemu_file_mode_is_not_valid(const char *mode);
Eduardo Habkoste68dd362014-10-01 17:34:34 -0300133bool qemu_file_is_writable(QEMUFile *f);
Paolo Bonzini701a8f72012-01-13 17:07:20 +0100134
Dr. David Alan Gilbertdeb22f92014-10-10 12:39:04 +0100135QEMUSizedBuffer *qsb_create(const uint8_t *buffer, size_t len);
Dr. David Alan Gilbertdeb22f92014-10-10 12:39:04 +0100136void qsb_free(QEMUSizedBuffer *);
137size_t qsb_set_length(QEMUSizedBuffer *qsb, size_t length);
138size_t qsb_get_length(const QEMUSizedBuffer *qsb);
139ssize_t qsb_get_buffer(const QEMUSizedBuffer *, off_t start, size_t count,
140 uint8_t *buf);
141ssize_t qsb_write_at(QEMUSizedBuffer *qsb, const uint8_t *buf,
142 off_t pos, size_t count);
143
144
145/*
146 * For use on files opened with qemu_bufopen
147 */
148const QEMUSizedBuffer *qemu_buf_get(QEMUFile *f);
149
Paolo Bonzini701a8f72012-01-13 17:07:20 +0100150static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v)
151{
152 qemu_put_byte(f, (int)v);
153}
154
155#define qemu_put_sbyte qemu_put_byte
156
157void qemu_put_be16(QEMUFile *f, unsigned int v);
158void qemu_put_be32(QEMUFile *f, unsigned int v);
159void qemu_put_be64(QEMUFile *f, uint64_t v);
Eduardo Habkostc9615142013-11-28 12:01:10 -0200160int qemu_peek_buffer(QEMUFile *f, uint8_t *buf, int size, size_t offset);
Paolo Bonzini701a8f72012-01-13 17:07:20 +0100161int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);
Liang Li44f0ead2015-03-23 16:32:19 +0800162ssize_t qemu_put_compression_data(QEMUFile *f, const uint8_t *p, size_t size,
163 int level);
164int qemu_put_qemu_file(QEMUFile *f_des, QEMUFile *f_src);
Dr. David Alan Gilbert548f52e2014-04-08 15:29:37 +0100165/*
166 * Note that you can only peek continuous bytes from where the current pointer
167 * is; you aren't guaranteed to be able to peak to +n bytes unless you've
168 * previously peeked +n-1.
169 */
Eduardo Habkostc9615142013-11-28 12:01:10 -0200170int qemu_peek_byte(QEMUFile *f, int offset);
Paolo Bonzini701a8f72012-01-13 17:07:20 +0100171int qemu_get_byte(QEMUFile *f);
Eduardo Habkostc9615142013-11-28 12:01:10 -0200172void qemu_file_skip(QEMUFile *f, int size);
Michael R. Hines2b0ce072013-06-25 21:35:28 -0400173void qemu_update_position(QEMUFile *f, size_t size);
Paolo Bonzini701a8f72012-01-13 17:07:20 +0100174
175static inline unsigned int qemu_get_ubyte(QEMUFile *f)
176{
177 return (unsigned int)qemu_get_byte(f);
178}
179
180#define qemu_get_sbyte qemu_get_byte
181
182unsigned int qemu_get_be16(QEMUFile *f);
183unsigned int qemu_get_be32(QEMUFile *f);
184uint64_t qemu_get_be64(QEMUFile *f);
185
186int qemu_file_rate_limit(QEMUFile *f);
Paolo Bonzini1964a392013-02-22 17:36:45 +0100187void qemu_file_reset_rate_limit(QEMUFile *f);
188void qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate);
Paolo Bonzini701a8f72012-01-13 17:07:20 +0100189int64_t qemu_file_get_rate_limit(QEMUFile *f);
190int qemu_file_get_error(QEMUFile *f);
Eduardo Habkostc9615142013-11-28 12:01:10 -0200191void qemu_file_set_error(QEMUFile *f, int ret);
Dr. David Alan Gilberte1a8c9b2015-01-08 11:11:30 +0000192int qemu_file_shutdown(QEMUFile *f);
Michael R. Hinesbe903b22013-06-25 21:35:32 -0400193void qemu_fflush(QEMUFile *f);
Paolo Bonzini701a8f72012-01-13 17:07:20 +0100194
Paolo Bonzini701a8f72012-01-13 17:07:20 +0100195static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
196{
197 qemu_put_be64(f, *pv);
198}
199
200static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv)
201{
202 qemu_put_be32(f, *pv);
203}
204
205static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv)
206{
207 qemu_put_be16(f, *pv);
208}
209
210static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv)
211{
212 qemu_put_byte(f, *pv);
213}
214
215static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv)
216{
217 *pv = qemu_get_be64(f);
218}
219
220static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv)
221{
222 *pv = qemu_get_be32(f);
223}
224
225static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv)
226{
227 *pv = qemu_get_be16(f);
228}
229
230static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv)
231{
232 *pv = qemu_get_byte(f);
233}
234
235// Signed versions for type safety
236static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, int size)
237{
238 qemu_put_buffer(f, (const uint8_t *)buf, size);
239}
240
241static inline void qemu_put_sbe16(QEMUFile *f, int v)
242{
243 qemu_put_be16(f, (unsigned int)v);
244}
245
246static inline void qemu_put_sbe32(QEMUFile *f, int v)
247{
248 qemu_put_be32(f, (unsigned int)v);
249}
250
251static inline void qemu_put_sbe64(QEMUFile *f, int64_t v)
252{
253 qemu_put_be64(f, (uint64_t)v);
254}
255
256static inline size_t qemu_get_sbuffer(QEMUFile *f, int8_t *buf, int size)
257{
258 return qemu_get_buffer(f, (uint8_t *)buf, size);
259}
260
261static inline int qemu_get_sbe16(QEMUFile *f)
262{
263 return (int)qemu_get_be16(f);
264}
265
266static inline int qemu_get_sbe32(QEMUFile *f)
267{
268 return (int)qemu_get_be32(f);
269}
270
271static inline int64_t qemu_get_sbe64(QEMUFile *f)
272{
273 return (int64_t)qemu_get_be64(f);
274}
275
276static inline void qemu_put_s8s(QEMUFile *f, const int8_t *pv)
277{
278 qemu_put_8s(f, (const uint8_t *)pv);
279}
280
281static inline void qemu_put_sbe16s(QEMUFile *f, const int16_t *pv)
282{
283 qemu_put_be16s(f, (const uint16_t *)pv);
284}
285
286static inline void qemu_put_sbe32s(QEMUFile *f, const int32_t *pv)
287{
288 qemu_put_be32s(f, (const uint32_t *)pv);
289}
290
291static inline void qemu_put_sbe64s(QEMUFile *f, const int64_t *pv)
292{
293 qemu_put_be64s(f, (const uint64_t *)pv);
294}
295
296static inline void qemu_get_s8s(QEMUFile *f, int8_t *pv)
297{
298 qemu_get_8s(f, (uint8_t *)pv);
299}
300
301static inline void qemu_get_sbe16s(QEMUFile *f, int16_t *pv)
302{
303 qemu_get_be16s(f, (uint16_t *)pv);
304}
305
306static inline void qemu_get_sbe32s(QEMUFile *f, int32_t *pv)
307{
308 qemu_get_be32s(f, (uint32_t *)pv);
309}
310
311static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv)
312{
313 qemu_get_be64s(f, (uint64_t *)pv);
314}
Paolo Bonzini701a8f72012-01-13 17:07:20 +0100315#endif