]>
Commit | Line | Data |
---|---|---|
701a8f76 PB |
1 | /* |
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 | */ | |
175de524 | 24 | |
701a8f76 | 25 | #ifndef QEMU_FILE_H |
175de524 MA |
26 | #define QEMU_FILE_H |
27 | ||
a9cfeb33 | 28 | #include "qemu-common.h" |
43487c67 | 29 | #include "exec/cpu-common.h" |
a9cfeb33 | 30 | #include "io/channel.h" |
701a8f76 | 31 | |
deb22f9a | 32 | |
701a8f76 PB |
33 | /* Read a chunk of data from a file at the given position. The pos argument |
34 | * can be ignored if the file is only be used for streaming. The number of | |
35 | * bytes actually read should be returned. | |
36 | */ | |
a202a4c0 DDAG |
37 | typedef ssize_t (QEMUFileGetBufferFunc)(void *opaque, uint8_t *buf, |
38 | int64_t pos, size_t size); | |
701a8f76 PB |
39 | |
40 | /* Close a file | |
41 | * | |
42 | * Return negative error number on error, 0 or positive value on success. | |
43 | * | |
44 | * The meaning of return value on success depends on the specific back-end being | |
45 | * used. | |
46 | */ | |
47 | typedef int (QEMUFileCloseFunc)(void *opaque); | |
48 | ||
70eb6330 PB |
49 | /* Called to return the OS file descriptor associated to the QEMUFile. |
50 | */ | |
51 | typedef int (QEMUFileGetFD)(void *opaque); | |
52 | ||
06ad5135 DB |
53 | /* Called to change the blocking mode of the file |
54 | */ | |
55 | typedef int (QEMUFileSetBlocking)(void *opaque, bool enabled); | |
56 | ||
d913829f | 57 | /* |
baf51e77 DB |
58 | * This function writes an iovec to file. The handler must write all |
59 | * of the data or return a negative errno value. | |
d913829f OW |
60 | */ |
61 | typedef ssize_t (QEMUFileWritevBufferFunc)(void *opaque, struct iovec *iov, | |
05fcc848 | 62 | int iovcnt, int64_t pos); |
d913829f | 63 | |
43487c67 MH |
64 | /* |
65 | * This function provides hooks around different | |
66 | * stages of RAM migration. | |
632e3a5c DDAG |
67 | * 'opaque' is the backend specific data in QEMUFile |
68 | * 'data' is call specific data associated with the 'flags' value | |
43487c67 | 69 | */ |
632e3a5c DDAG |
70 | typedef int (QEMURamHookFunc)(QEMUFile *f, void *opaque, uint64_t flags, |
71 | void *data); | |
43487c67 MH |
72 | |
73 | /* | |
74 | * Constants used by ram_control_* hooks | |
75 | */ | |
632e3a5c DDAG |
76 | #define RAM_CONTROL_SETUP 0 |
77 | #define RAM_CONTROL_ROUND 1 | |
78 | #define RAM_CONTROL_HOOK 2 | |
79 | #define RAM_CONTROL_FINISH 3 | |
80 | #define RAM_CONTROL_BLOCK_REG 4 | |
43487c67 MH |
81 | |
82 | /* | |
83 | * This function allows override of where the RAM page | |
84 | * is saved (such as RDMA, for example.) | |
85 | */ | |
86 | typedef size_t (QEMURamSaveFunc)(QEMUFile *f, void *opaque, | |
87 | ram_addr_t block_offset, | |
88 | ram_addr_t offset, | |
89 | size_t size, | |
6e1dea46 | 90 | uint64_t *bytes_sent); |
43487c67 | 91 | |
adc468e9 DDAG |
92 | /* |
93 | * Return a QEMUFile for comms in the opposite direction | |
94 | */ | |
95 | typedef QEMUFile *(QEMURetPathFunc)(void *opaque); | |
96 | ||
e1a8c9b6 DDAG |
97 | /* |
98 | * Stop any read or write (depending on flags) on the underlying | |
99 | * transport on the QEMUFile. | |
100 | * Existing blocking reads/writes must be woken | |
101 | * Returns 0 on success, -err on error | |
102 | */ | |
103 | typedef int (QEMUFileShutdownFunc)(void *opaque, bool rd, bool wr); | |
104 | ||
9229bf3c | 105 | typedef struct QEMUFileOps { |
9229bf3c PB |
106 | QEMUFileGetBufferFunc *get_buffer; |
107 | QEMUFileCloseFunc *close; | |
06ad5135 | 108 | QEMUFileSetBlocking *set_blocking; |
d913829f | 109 | QEMUFileWritevBufferFunc *writev_buffer; |
0436e09f DB |
110 | QEMURetPathFunc *get_return_path; |
111 | QEMUFileShutdownFunc *shut_down; | |
112 | } QEMUFileOps; | |
113 | ||
114 | typedef struct QEMUFileHooks { | |
43487c67 MH |
115 | QEMURamHookFunc *before_ram_iterate; |
116 | QEMURamHookFunc *after_ram_iterate; | |
117 | QEMURamHookFunc *hook_ram_load; | |
118 | QEMURamSaveFunc *save_page; | |
0436e09f | 119 | } QEMUFileHooks; |
9229bf3c PB |
120 | |
121 | QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops); | |
a9cfeb33 DB |
122 | QEMUFile *qemu_fopen_channel_input(QIOChannel *ioc); |
123 | QEMUFile *qemu_fopen_channel_output(QIOChannel *ioc); | |
0436e09f | 124 | void qemu_file_set_hooks(QEMUFile *f, const QEMUFileHooks *hooks); |
70eb6330 | 125 | int qemu_get_fd(QEMUFile *f); |
701a8f76 | 126 | int qemu_fclose(QEMUFile *f); |
ad55ab42 | 127 | int64_t qemu_ftell(QEMUFile *f); |
97221400 | 128 | int64_t qemu_ftell_fast(QEMUFile *f); |
56f3835f | 129 | void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, size_t size); |
701a8f76 | 130 | void qemu_put_byte(QEMUFile *f, int v); |
6181ec24 OW |
131 | /* |
132 | * put_buffer without copying the buffer. | |
133 | * The buffer should be available till it is sent asynchronously. | |
134 | */ | |
53f09a10 PB |
135 | void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, size_t size, |
136 | bool may_free); | |
bc1256f7 | 137 | bool qemu_file_mode_is_not_valid(const char *mode); |
e68dd365 | 138 | bool qemu_file_is_writable(QEMUFile *f); |
701a8f76 | 139 | |
deb22f9a | 140 | |
701a8f76 PB |
141 | static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v) |
142 | { | |
143 | qemu_put_byte(f, (int)v); | |
144 | } | |
145 | ||
146 | #define qemu_put_sbyte qemu_put_byte | |
147 | ||
148 | void qemu_put_be16(QEMUFile *f, unsigned int v); | |
149 | void qemu_put_be32(QEMUFile *f, unsigned int v); | |
150 | void qemu_put_be64(QEMUFile *f, uint64_t v); | |
56f3835f DDAG |
151 | size_t qemu_peek_buffer(QEMUFile *f, uint8_t **buf, size_t size, size_t offset); |
152 | size_t qemu_get_buffer(QEMUFile *f, uint8_t *buf, size_t size); | |
9504fb51 | 153 | size_t qemu_get_buffer_in_place(QEMUFile *f, uint8_t **buf, size_t size); |
44f0eadc LL |
154 | ssize_t qemu_put_compression_data(QEMUFile *f, const uint8_t *p, size_t size, |
155 | int level); | |
156 | int qemu_put_qemu_file(QEMUFile *f_des, QEMUFile *f_src); | |
9504fb51 | 157 | |
548f52ea DDAG |
158 | /* |
159 | * Note that you can only peek continuous bytes from where the current pointer | |
160 | * is; you aren't guaranteed to be able to peak to +n bytes unless you've | |
161 | * previously peeked +n-1. | |
162 | */ | |
c961514f | 163 | int qemu_peek_byte(QEMUFile *f, int offset); |
701a8f76 | 164 | int qemu_get_byte(QEMUFile *f); |
c961514f | 165 | void qemu_file_skip(QEMUFile *f, int size); |
2b0ce079 | 166 | void qemu_update_position(QEMUFile *f, size_t size); |
701a8f76 PB |
167 | |
168 | static inline unsigned int qemu_get_ubyte(QEMUFile *f) | |
169 | { | |
170 | return (unsigned int)qemu_get_byte(f); | |
171 | } | |
172 | ||
173 | #define qemu_get_sbyte qemu_get_byte | |
174 | ||
175 | unsigned int qemu_get_be16(QEMUFile *f); | |
176 | unsigned int qemu_get_be32(QEMUFile *f); | |
177 | uint64_t qemu_get_be64(QEMUFile *f); | |
178 | ||
179 | int qemu_file_rate_limit(QEMUFile *f); | |
1964a397 PB |
180 | void qemu_file_reset_rate_limit(QEMUFile *f); |
181 | void qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate); | |
701a8f76 PB |
182 | int64_t qemu_file_get_rate_limit(QEMUFile *f); |
183 | int qemu_file_get_error(QEMUFile *f); | |
c961514f | 184 | void qemu_file_set_error(QEMUFile *f, int ret); |
e1a8c9b6 | 185 | int qemu_file_shutdown(QEMUFile *f); |
adc468e9 | 186 | QEMUFile *qemu_file_get_return_path(QEMUFile *f); |
be903b2a | 187 | void qemu_fflush(QEMUFile *f); |
a800cd5c | 188 | void qemu_file_set_blocking(QEMUFile *f, bool block); |
701a8f76 | 189 | |
701a8f76 PB |
190 | static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv) |
191 | { | |
192 | qemu_put_be64(f, *pv); | |
193 | } | |
194 | ||
195 | static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv) | |
196 | { | |
197 | qemu_put_be32(f, *pv); | |
198 | } | |
199 | ||
200 | static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv) | |
201 | { | |
202 | qemu_put_be16(f, *pv); | |
203 | } | |
204 | ||
205 | static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv) | |
206 | { | |
207 | qemu_put_byte(f, *pv); | |
208 | } | |
209 | ||
210 | static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv) | |
211 | { | |
212 | *pv = qemu_get_be64(f); | |
213 | } | |
214 | ||
215 | static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv) | |
216 | { | |
217 | *pv = qemu_get_be32(f); | |
218 | } | |
219 | ||
220 | static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv) | |
221 | { | |
222 | *pv = qemu_get_be16(f); | |
223 | } | |
224 | ||
225 | static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv) | |
226 | { | |
227 | *pv = qemu_get_byte(f); | |
228 | } | |
229 | ||
230 | // Signed versions for type safety | |
56f3835f | 231 | static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, size_t size) |
701a8f76 PB |
232 | { |
233 | qemu_put_buffer(f, (const uint8_t *)buf, size); | |
234 | } | |
235 | ||
236 | static inline void qemu_put_sbe16(QEMUFile *f, int v) | |
237 | { | |
238 | qemu_put_be16(f, (unsigned int)v); | |
239 | } | |
240 | ||
241 | static inline void qemu_put_sbe32(QEMUFile *f, int v) | |
242 | { | |
243 | qemu_put_be32(f, (unsigned int)v); | |
244 | } | |
245 | ||
246 | static inline void qemu_put_sbe64(QEMUFile *f, int64_t v) | |
247 | { | |
248 | qemu_put_be64(f, (uint64_t)v); | |
249 | } | |
250 | ||
251 | static inline size_t qemu_get_sbuffer(QEMUFile *f, int8_t *buf, int size) | |
252 | { | |
253 | return qemu_get_buffer(f, (uint8_t *)buf, size); | |
254 | } | |
255 | ||
256 | static inline int qemu_get_sbe16(QEMUFile *f) | |
257 | { | |
258 | return (int)qemu_get_be16(f); | |
259 | } | |
260 | ||
261 | static inline int qemu_get_sbe32(QEMUFile *f) | |
262 | { | |
263 | return (int)qemu_get_be32(f); | |
264 | } | |
265 | ||
266 | static inline int64_t qemu_get_sbe64(QEMUFile *f) | |
267 | { | |
268 | return (int64_t)qemu_get_be64(f); | |
269 | } | |
270 | ||
271 | static inline void qemu_put_s8s(QEMUFile *f, const int8_t *pv) | |
272 | { | |
273 | qemu_put_8s(f, (const uint8_t *)pv); | |
274 | } | |
275 | ||
276 | static inline void qemu_put_sbe16s(QEMUFile *f, const int16_t *pv) | |
277 | { | |
278 | qemu_put_be16s(f, (const uint16_t *)pv); | |
279 | } | |
280 | ||
281 | static inline void qemu_put_sbe32s(QEMUFile *f, const int32_t *pv) | |
282 | { | |
283 | qemu_put_be32s(f, (const uint32_t *)pv); | |
284 | } | |
285 | ||
286 | static inline void qemu_put_sbe64s(QEMUFile *f, const int64_t *pv) | |
287 | { | |
288 | qemu_put_be64s(f, (const uint64_t *)pv); | |
289 | } | |
290 | ||
291 | static inline void qemu_get_s8s(QEMUFile *f, int8_t *pv) | |
292 | { | |
293 | qemu_get_8s(f, (uint8_t *)pv); | |
294 | } | |
295 | ||
296 | static inline void qemu_get_sbe16s(QEMUFile *f, int16_t *pv) | |
297 | { | |
298 | qemu_get_be16s(f, (uint16_t *)pv); | |
299 | } | |
300 | ||
301 | static inline void qemu_get_sbe32s(QEMUFile *f, int32_t *pv) | |
302 | { | |
303 | qemu_get_be32s(f, (uint32_t *)pv); | |
304 | } | |
305 | ||
306 | static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv) | |
307 | { | |
308 | qemu_get_be64s(f, (uint64_t *)pv); | |
309 | } | |
b3af1bc9 DDAG |
310 | |
311 | size_t qemu_get_counted_string(QEMUFile *f, char buf[256]); | |
312 | ||
701a8f76 | 313 | #endif |