1 /* Declarations for use by hardware emulation. */
5 #include "qemu-common.h"
7 #if defined(TARGET_PHYS_ADDR_BITS) && !defined(NEED_CPU_H)
10 #include "cpu-common.h"
18 /* This function writes a chunk of data to a file at the given position.
19 * The pos argument can be ignored if the file is only being used for
20 * streaming. The handler should try to write all of the data it can.
22 typedef int (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf,
23 int64_t pos, int size);
25 /* Read a chunk of data from a file at the given position. The pos argument
26 * can be ignored if the file is only be used for streaming. The number of
27 * bytes actually read should be returned.
29 typedef int (QEMUFileGetBufferFunc)(void *opaque, uint8_t *buf,
30 int64_t pos, int size);
32 /* Close a file and return an error code */
33 typedef int (QEMUFileCloseFunc)(void *opaque);
35 /* Called to determine if the file has exceeded it's bandwidth allocation. The
36 * bandwidth capping is a soft limit, not a hard limit.
38 typedef int (QEMUFileRateLimit)(void *opaque);
40 /* Called to change the current bandwidth allocation. This function must return
41 * the new actual bandwidth. It should be new_rate if everything goes ok, and
42 * the old rate otherwise
44 typedef size_t (QEMUFileSetRateLimit)(void *opaque, size_t new_rate);
46 QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
47 QEMUFileGetBufferFunc *get_buffer,
48 QEMUFileCloseFunc *close,
49 QEMUFileRateLimit *rate_limit,
50 QEMUFileSetRateLimit *set_rate_limit);
51 QEMUFile *qemu_fopen(const char *filename, const char *mode);
52 QEMUFile *qemu_fdopen(int fd, const char *mode);
53 QEMUFile *qemu_fopen_socket(int fd);
54 QEMUFile *qemu_popen(FILE *popen_file, const char *mode);
55 QEMUFile *qemu_popen_cmd(const char *command, const char *mode);
56 int qemu_stdio_fd(QEMUFile *f);
57 void qemu_fflush(QEMUFile *f);
58 int qemu_fclose(QEMUFile *f);
59 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);
60 void qemu_put_byte(QEMUFile *f, int v);
62 static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v)
64 qemu_put_byte(f, (int)v);
67 #define qemu_put_sbyte qemu_put_byte
69 void qemu_put_be16(QEMUFile *f, unsigned int v);
70 void qemu_put_be32(QEMUFile *f, unsigned int v);
71 void qemu_put_be64(QEMUFile *f, uint64_t v);
72 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);
73 int qemu_get_byte(QEMUFile *f);
75 static inline unsigned int qemu_get_ubyte(QEMUFile *f)
77 return (unsigned int)qemu_get_byte(f);
80 #define qemu_get_sbyte qemu_get_byte
82 unsigned int qemu_get_be16(QEMUFile *f);
83 unsigned int qemu_get_be32(QEMUFile *f);
84 uint64_t qemu_get_be64(QEMUFile *f);
85 int qemu_file_rate_limit(QEMUFile *f);
86 size_t qemu_file_set_rate_limit(QEMUFile *f, size_t new_rate);
87 int qemu_file_has_error(QEMUFile *f);
88 void qemu_file_set_error(QEMUFile *f);
90 /* Try to send any outstanding data. This function is useful when output is
91 * halted due to rate limiting or EAGAIN errors occur as it can be used to
93 void qemu_file_put_notify(QEMUFile *f);
95 static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
97 qemu_put_be64(f, *pv);
100 static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv)
102 qemu_put_be32(f, *pv);
105 static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv)
107 qemu_put_be16(f, *pv);
110 static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv)
112 qemu_put_byte(f, *pv);
115 static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv)
117 *pv = qemu_get_be64(f);
120 static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv)
122 *pv = qemu_get_be32(f);
125 static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv)
127 *pv = qemu_get_be16(f);
130 static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv)
132 *pv = qemu_get_byte(f);
135 // Signed versions for type safety
136 static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, int size)
138 qemu_put_buffer(f, (const uint8_t *)buf, size);
141 static inline void qemu_put_sbe16(QEMUFile *f, int v)
143 qemu_put_be16(f, (unsigned int)v);
146 static inline void qemu_put_sbe32(QEMUFile *f, int v)
148 qemu_put_be32(f, (unsigned int)v);
151 static inline void qemu_put_sbe64(QEMUFile *f, int64_t v)
153 qemu_put_be64(f, (uint64_t)v);
156 static inline size_t qemu_get_sbuffer(QEMUFile *f, int8_t *buf, int size)
158 return qemu_get_buffer(f, (uint8_t *)buf, size);
161 static inline int qemu_get_sbe16(QEMUFile *f)
163 return (int)qemu_get_be16(f);
166 static inline int qemu_get_sbe32(QEMUFile *f)
168 return (int)qemu_get_be32(f);
171 static inline int64_t qemu_get_sbe64(QEMUFile *f)
173 return (int64_t)qemu_get_be64(f);
176 static inline void qemu_put_s8s(QEMUFile *f, const int8_t *pv)
178 qemu_put_8s(f, (const uint8_t *)pv);
181 static inline void qemu_put_sbe16s(QEMUFile *f, const int16_t *pv)
183 qemu_put_be16s(f, (const uint16_t *)pv);
186 static inline void qemu_put_sbe32s(QEMUFile *f, const int32_t *pv)
188 qemu_put_be32s(f, (const uint32_t *)pv);
191 static inline void qemu_put_sbe64s(QEMUFile *f, const int64_t *pv)
193 qemu_put_be64s(f, (const uint64_t *)pv);
196 static inline void qemu_get_s8s(QEMUFile *f, int8_t *pv)
198 qemu_get_8s(f, (uint8_t *)pv);
201 static inline void qemu_get_sbe16s(QEMUFile *f, int16_t *pv)
203 qemu_get_be16s(f, (uint16_t *)pv);
206 static inline void qemu_get_sbe32s(QEMUFile *f, int32_t *pv)
208 qemu_get_be32s(f, (uint32_t *)pv);
211 static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv)
213 qemu_get_be64s(f, (uint64_t *)pv);
217 #if TARGET_LONG_BITS == 64
218 #define qemu_put_betl qemu_put_be64
219 #define qemu_get_betl qemu_get_be64
220 #define qemu_put_betls qemu_put_be64s
221 #define qemu_get_betls qemu_get_be64s
222 #define qemu_put_sbetl qemu_put_sbe64
223 #define qemu_get_sbetl qemu_get_sbe64
224 #define qemu_put_sbetls qemu_put_sbe64s
225 #define qemu_get_sbetls qemu_get_sbe64s
227 #define qemu_put_betl qemu_put_be32
228 #define qemu_get_betl qemu_get_be32
229 #define qemu_put_betls qemu_put_be32s
230 #define qemu_get_betls qemu_get_be32s
231 #define qemu_put_sbetl qemu_put_sbe32
232 #define qemu_get_sbetl qemu_get_sbe32
233 #define qemu_put_sbetls qemu_put_sbe32s
234 #define qemu_get_sbetls qemu_get_sbe32s
238 int64_t qemu_ftell(QEMUFile *f);
239 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence);
241 typedef void SaveStateHandler(QEMUFile *f, void *opaque);
242 typedef int SaveLiveStateHandler(QEMUFile *f, int stage, void *opaque);
243 typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id);
245 int register_savevm(const char *idstr,
248 SaveStateHandler *save_state,
249 LoadStateHandler *load_state,
252 int register_savevm_live(const char *idstr,
255 SaveLiveStateHandler *save_live_state,
256 SaveStateHandler *save_state,
257 LoadStateHandler *load_state,
260 void unregister_savevm(const char *idstr, void *opaque);
262 typedef void QEMUResetHandler(void *opaque);
264 void qemu_register_reset(QEMUResetHandler *func, void *opaque);
265 void qemu_unregister_reset(QEMUResetHandler *func, void *opaque);
267 /* handler to set the boot_device order for a specific type of QEMUMachine */
268 /* return 0 if success */
269 typedef int QEMUBootSetHandler(void *opaque, const char *boot_devices);
270 void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque);
271 int qemu_boot_set(const char *boot_devices);
273 typedef struct VMStateInfo VMStateInfo;
274 typedef struct VMStateDescription VMStateDescription;
278 int (*get)(QEMUFile *f, void *pv, size_t size);
279 void (*put)(QEMUFile *f, const void *pv, size_t size);
293 const VMStateInfo *info;
294 enum VMStateFlags flags;
298 struct VMStateDescription {
301 int minimum_version_id;
302 int minimum_version_id_old;
303 LoadStateHandler *load_state_old;
304 VMStateField *fields;
307 extern const VMStateInfo vmstate_info_int8;
308 extern const VMStateInfo vmstate_info_int16;
309 extern const VMStateInfo vmstate_info_int32;
310 extern const VMStateInfo vmstate_info_int64;
312 extern const VMStateInfo vmstate_info_uint8;
313 extern const VMStateInfo vmstate_info_uint16;
314 extern const VMStateInfo vmstate_info_uint32;
315 extern const VMStateInfo vmstate_info_uint64;
317 extern const VMStateInfo vmstate_info_timer;
319 #define type_check_array(t1,t2,n) ((t1(*)[n])0 - (t2*)0)
321 #define VMSTATE_SINGLE(_field, _state, _version, _info, _type) { \
322 .name = (stringify(_field)), \
323 .version_id = (_version), \
324 .size = sizeof(_type), \
326 .flags = VMS_SINGLE, \
327 .offset = offsetof(_state, _field) \
328 + type_check(_type,typeof_field(_state, _field)) \
331 #define VMSTATE_POINTER(_field, _state, _version, _info, _type) { \
332 .name = (stringify(_field)), \
333 .version_id = (_version), \
335 .size = sizeof(_type), \
336 .flags = VMS_SINGLE|VMS_POINTER, \
337 .offset = offsetof(_state, _field) \
338 + type_check(_type,typeof_field(_state, _field)) \
341 #define VMSTATE_ARRAY(_field, _state, _num, _version, _info, _type) {\
342 .name = (stringify(_field)), \
343 .version_id = (_version), \
346 .size = sizeof(_type), \
347 .flags = VMS_ARRAY, \
348 .offset = offsetof(_state, _field) \
349 + type_check_array(_type,typeof_field(_state, _field),_num) \
354 _s : struct state name
358 #define VMSTATE_INT8_V(_f, _s, _v) \
359 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int8, int8_t)
360 #define VMSTATE_INT16_V(_f, _s, _v) \
361 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int16, int16_t)
362 #define VMSTATE_INT32_V(_f, _s, _v) \
363 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int32, int32_t)
364 #define VMSTATE_INT64_V(_f, _s, _v) \
365 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int64, int64_t)
367 #define VMSTATE_UINT8_V(_f, _s, _v) \
368 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint8, uint8_t)
369 #define VMSTATE_UINT16_V(_f, _s, _v) \
370 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint16, uint16_t)
371 #define VMSTATE_UINT32_V(_f, _s, _v) \
372 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint32, uint32_t)
373 #define VMSTATE_UINT64_V(_f, _s, _v) \
374 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint64, uint64_t)
376 #define VMSTATE_INT8(_f, _s) \
377 VMSTATE_INT8_V(_f, _s, 0)
378 #define VMSTATE_INT16(_f, _s) \
379 VMSTATE_INT16_V(_f, _s, 0)
380 #define VMSTATE_INT32(_f, _s) \
381 VMSTATE_INT32_V(_f, _s, 0)
382 #define VMSTATE_INT64(_f, _s) \
383 VMSTATE_INT64_V(_f, _s, 0)
385 #define VMSTATE_UINT8(_f, _s) \
386 VMSTATE_UINT8_V(_f, _s, 0)
387 #define VMSTATE_UINT16(_f, _s) \
388 VMSTATE_UINT16_V(_f, _s, 0)
389 #define VMSTATE_UINT32(_f, _s) \
390 VMSTATE_UINT32_V(_f, _s, 0)
391 #define VMSTATE_UINT64(_f, _s) \
392 VMSTATE_UINT64_V(_f, _s, 0)
394 #define VMSTATE_TIMER_V(_f, _s, _v) \
395 VMSTATE_POINTER(_f, _s, _v, vmstate_info_timer, QEMUTimer *)
397 #define VMSTATE_TIMER(_f, _s) \
398 VMSTATE_TIMER_V(_f, _s, 0)
400 #define VMSTATE_UINT32_ARRAY_V(_f, _s, _n, _v) \
401 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint32, uint32_t)
403 #define VMSTATE_UINT32_ARRAY(_f, _s, _n) \
404 VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0)
406 #define VMSTATE_INT32_ARRAY_V(_f, _s, _n, _v) \
407 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int32, int32_t)
409 #define VMSTATE_INT32_ARRAY(_f, _s, _n) \
410 VMSTATE_INT32_ARRAY_V(_f, _s, _n, 0)
412 #define VMSTATE_END_OF_LIST() \
415 extern int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
416 void *opaque, int version_id);
417 extern void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
419 extern int vmstate_register(int instance_id, const VMStateDescription *vmsd,
421 extern void vmstate_unregister(const char *idstr, void *opaque);