]>
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 | */ | |
24 | #ifndef QEMU_FILE_H | |
25 | #define QEMU_FILE_H 1 | |
43487c67 | 26 | #include "exec/cpu-common.h" |
701a8f76 | 27 | |
deb22f9a DDAG |
28 | #include <stdint.h> |
29 | ||
701a8f76 PB |
30 | /* 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 | */ | |
34 | typedef 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 | */ | |
41 | typedef 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 | */ | |
51 | typedef int (QEMUFileCloseFunc)(void *opaque); | |
52 | ||
70eb6330 PB |
53 | /* Called to return the OS file descriptor associated to the QEMUFile. |
54 | */ | |
55 | typedef int (QEMUFileGetFD)(void *opaque); | |
56 | ||
d913829f OW |
57 | /* |
58 | * This function writes an iovec to file. | |
59 | */ | |
60 | typedef ssize_t (QEMUFileWritevBufferFunc)(void *opaque, struct iovec *iov, | |
05fcc848 | 61 | int iovcnt, int64_t pos); |
d913829f | 62 | |
43487c67 MH |
63 | /* |
64 | * This function provides hooks around different | |
65 | * stages of RAM migration. | |
66 | */ | |
67 | typedef 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 | */ | |
81 | typedef size_t (QEMURamSaveFunc)(QEMUFile *f, void *opaque, | |
82 | ram_addr_t block_offset, | |
83 | ram_addr_t offset, | |
84 | size_t size, | |
85 | int *bytes_sent); | |
86 | ||
e1a8c9b6 DDAG |
87 | /* |
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 | */ | |
93 | typedef int (QEMUFileShutdownFunc)(void *opaque, bool rd, bool wr); | |
94 | ||
9229bf3c PB |
95 | typedef struct QEMUFileOps { |
96 | QEMUFilePutBufferFunc *put_buffer; | |
97 | QEMUFileGetBufferFunc *get_buffer; | |
98 | QEMUFileCloseFunc *close; | |
70eb6330 | 99 | QEMUFileGetFD *get_fd; |
d913829f | 100 | QEMUFileWritevBufferFunc *writev_buffer; |
43487c67 MH |
101 | QEMURamHookFunc *before_ram_iterate; |
102 | QEMURamHookFunc *after_ram_iterate; | |
103 | QEMURamHookFunc *hook_ram_load; | |
104 | QEMURamSaveFunc *save_page; | |
e1a8c9b6 | 105 | QEMUFileShutdownFunc *shut_down; |
9229bf3c PB |
106 | } QEMUFileOps; |
107 | ||
deb22f9a DDAG |
108 | struct 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 | ||
9229bf3c | 115 | QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops); |
701a8f76 PB |
116 | QEMUFile *qemu_fopen(const char *filename, const char *mode); |
117 | QEMUFile *qemu_fdopen(int fd, const char *mode); | |
0cc3f3cc | 118 | QEMUFile *qemu_fopen_socket(int fd, const char *mode); |
701a8f76 | 119 | QEMUFile *qemu_popen_cmd(const char *command, const char *mode); |
deb22f9a | 120 | QEMUFile *qemu_bufopen(const char *mode, QEMUSizedBuffer *input); |
70eb6330 | 121 | int qemu_get_fd(QEMUFile *f); |
701a8f76 | 122 | int qemu_fclose(QEMUFile *f); |
ad55ab42 | 123 | int64_t qemu_ftell(QEMUFile *f); |
701a8f76 PB |
124 | void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size); |
125 | void qemu_put_byte(QEMUFile *f, int v); | |
6181ec24 OW |
126 | /* |
127 | * put_buffer without copying the buffer. | |
128 | * The buffer should be available till it is sent asynchronously. | |
129 | */ | |
130 | void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, int size); | |
bc1256f7 | 131 | bool qemu_file_mode_is_not_valid(const char *mode); |
e68dd365 | 132 | bool qemu_file_is_writable(QEMUFile *f); |
701a8f76 | 133 | |
deb22f9a DDAG |
134 | QEMUSizedBuffer *qsb_create(const uint8_t *buffer, size_t len); |
135 | QEMUSizedBuffer *qsb_clone(const QEMUSizedBuffer *); | |
136 | void qsb_free(QEMUSizedBuffer *); | |
137 | size_t qsb_set_length(QEMUSizedBuffer *qsb, size_t length); | |
138 | size_t qsb_get_length(const QEMUSizedBuffer *qsb); | |
139 | ssize_t qsb_get_buffer(const QEMUSizedBuffer *, off_t start, size_t count, | |
140 | uint8_t *buf); | |
141 | ssize_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 | */ | |
148 | const QEMUSizedBuffer *qemu_buf_get(QEMUFile *f); | |
149 | ||
701a8f76 PB |
150 | static 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 | ||
157 | void qemu_put_be16(QEMUFile *f, unsigned int v); | |
158 | void qemu_put_be32(QEMUFile *f, unsigned int v); | |
159 | void qemu_put_be64(QEMUFile *f, uint64_t v); | |
c961514f | 160 | int qemu_peek_buffer(QEMUFile *f, uint8_t *buf, int size, size_t offset); |
701a8f76 | 161 | int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size); |
548f52ea DDAG |
162 | /* |
163 | * Note that you can only peek continuous bytes from where the current pointer | |
164 | * is; you aren't guaranteed to be able to peak to +n bytes unless you've | |
165 | * previously peeked +n-1. | |
166 | */ | |
c961514f | 167 | int qemu_peek_byte(QEMUFile *f, int offset); |
701a8f76 | 168 | int qemu_get_byte(QEMUFile *f); |
c961514f | 169 | void qemu_file_skip(QEMUFile *f, int size); |
2b0ce079 | 170 | void qemu_update_position(QEMUFile *f, size_t size); |
701a8f76 PB |
171 | |
172 | static inline unsigned int qemu_get_ubyte(QEMUFile *f) | |
173 | { | |
174 | return (unsigned int)qemu_get_byte(f); | |
175 | } | |
176 | ||
177 | #define qemu_get_sbyte qemu_get_byte | |
178 | ||
179 | unsigned int qemu_get_be16(QEMUFile *f); | |
180 | unsigned int qemu_get_be32(QEMUFile *f); | |
181 | uint64_t qemu_get_be64(QEMUFile *f); | |
182 | ||
183 | int qemu_file_rate_limit(QEMUFile *f); | |
1964a397 PB |
184 | void qemu_file_reset_rate_limit(QEMUFile *f); |
185 | void qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate); | |
701a8f76 PB |
186 | int64_t qemu_file_get_rate_limit(QEMUFile *f); |
187 | int qemu_file_get_error(QEMUFile *f); | |
c961514f | 188 | void qemu_file_set_error(QEMUFile *f, int ret); |
e1a8c9b6 | 189 | int qemu_file_shutdown(QEMUFile *f); |
be903b2a | 190 | void qemu_fflush(QEMUFile *f); |
701a8f76 | 191 | |
701a8f76 PB |
192 | static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv) |
193 | { | |
194 | qemu_put_be64(f, *pv); | |
195 | } | |
196 | ||
197 | static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv) | |
198 | { | |
199 | qemu_put_be32(f, *pv); | |
200 | } | |
201 | ||
202 | static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv) | |
203 | { | |
204 | qemu_put_be16(f, *pv); | |
205 | } | |
206 | ||
207 | static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv) | |
208 | { | |
209 | qemu_put_byte(f, *pv); | |
210 | } | |
211 | ||
212 | static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv) | |
213 | { | |
214 | *pv = qemu_get_be64(f); | |
215 | } | |
216 | ||
217 | static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv) | |
218 | { | |
219 | *pv = qemu_get_be32(f); | |
220 | } | |
221 | ||
222 | static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv) | |
223 | { | |
224 | *pv = qemu_get_be16(f); | |
225 | } | |
226 | ||
227 | static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv) | |
228 | { | |
229 | *pv = qemu_get_byte(f); | |
230 | } | |
231 | ||
232 | // Signed versions for type safety | |
233 | static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, int size) | |
234 | { | |
235 | qemu_put_buffer(f, (const uint8_t *)buf, size); | |
236 | } | |
237 | ||
238 | static inline void qemu_put_sbe16(QEMUFile *f, int v) | |
239 | { | |
240 | qemu_put_be16(f, (unsigned int)v); | |
241 | } | |
242 | ||
243 | static inline void qemu_put_sbe32(QEMUFile *f, int v) | |
244 | { | |
245 | qemu_put_be32(f, (unsigned int)v); | |
246 | } | |
247 | ||
248 | static inline void qemu_put_sbe64(QEMUFile *f, int64_t v) | |
249 | { | |
250 | qemu_put_be64(f, (uint64_t)v); | |
251 | } | |
252 | ||
253 | static inline size_t qemu_get_sbuffer(QEMUFile *f, int8_t *buf, int size) | |
254 | { | |
255 | return qemu_get_buffer(f, (uint8_t *)buf, size); | |
256 | } | |
257 | ||
258 | static inline int qemu_get_sbe16(QEMUFile *f) | |
259 | { | |
260 | return (int)qemu_get_be16(f); | |
261 | } | |
262 | ||
263 | static inline int qemu_get_sbe32(QEMUFile *f) | |
264 | { | |
265 | return (int)qemu_get_be32(f); | |
266 | } | |
267 | ||
268 | static inline int64_t qemu_get_sbe64(QEMUFile *f) | |
269 | { | |
270 | return (int64_t)qemu_get_be64(f); | |
271 | } | |
272 | ||
273 | static inline void qemu_put_s8s(QEMUFile *f, const int8_t *pv) | |
274 | { | |
275 | qemu_put_8s(f, (const uint8_t *)pv); | |
276 | } | |
277 | ||
278 | static inline void qemu_put_sbe16s(QEMUFile *f, const int16_t *pv) | |
279 | { | |
280 | qemu_put_be16s(f, (const uint16_t *)pv); | |
281 | } | |
282 | ||
283 | static inline void qemu_put_sbe32s(QEMUFile *f, const int32_t *pv) | |
284 | { | |
285 | qemu_put_be32s(f, (const uint32_t *)pv); | |
286 | } | |
287 | ||
288 | static inline void qemu_put_sbe64s(QEMUFile *f, const int64_t *pv) | |
289 | { | |
290 | qemu_put_be64s(f, (const uint64_t *)pv); | |
291 | } | |
292 | ||
293 | static inline void qemu_get_s8s(QEMUFile *f, int8_t *pv) | |
294 | { | |
295 | qemu_get_8s(f, (uint8_t *)pv); | |
296 | } | |
297 | ||
298 | static inline void qemu_get_sbe16s(QEMUFile *f, int16_t *pv) | |
299 | { | |
300 | qemu_get_be16s(f, (uint16_t *)pv); | |
301 | } | |
302 | ||
303 | static inline void qemu_get_sbe32s(QEMUFile *f, int32_t *pv) | |
304 | { | |
305 | qemu_get_be32s(f, (uint32_t *)pv); | |
306 | } | |
307 | ||
308 | static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv) | |
309 | { | |
310 | qemu_get_be64s(f, (uint64_t *)pv); | |
311 | } | |
701a8f76 | 312 | #endif |