]> Git Repo - qemu.git/blame - hw/hw.h
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Compile acpi only once
[qemu.git] / hw / hw.h
CommitLineData
87ecb68b
PB		 1/* Declarations for use by hardware emulation. */
2#ifndef QEMU_HW_H
3#define QEMU_HW_H
4
5#include "qemu-common.h"
1ad2134f
PB		 6
7#if defined(TARGET_PHYS_ADDR_BITS) && !defined(NEED_CPU_H)
8#include "targphys.h"
9#include "poison.h"
10#include "cpu-common.h"
11#endif
12
f11f6a5f 13#include <stdbool.h>
32993977 14#include "ioport.h"
87ecb68b
PB		 15#include "irq.h"
16
17/* VM Load/Save */
18
5dafc53f
AL		 19/* This function writes a chunk of data to a file at the given position.
20 * The pos argument can be ignored if the file is only being used for
21 * streaming. The handler should try to write all of the data it can.
22 */
871d2f07
AL		 23typedef int (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf,
24 int64_t pos, int size);
5dafc53f
AL		 25
26/* Read a chunk of data from a file at the given position. The pos argument
27 * can be ignored if the file is only be used for streaming. The number of
28 * bytes actually read should be returned.
29 */
30typedef int (QEMUFileGetBufferFunc)(void *opaque, uint8_t *buf,
31 int64_t pos, int size);
32
33/* Close a file and return an error code */
34typedef int (QEMUFileCloseFunc)(void *opaque);
35
36/* Called to determine if the file has exceeded it's bandwidth allocation. The
37 * bandwidth capping is a soft limit, not a hard limit.
38 */
39typedef int (QEMUFileRateLimit)(void *opaque);
40
19629537
GC		 41/* Called to change the current bandwidth allocation. This function must return
42 * the new actual bandwidth. It should be new_rate if everything goes ok, and
43 * the old rate otherwise
44 */
45typedef size_t (QEMUFileSetRateLimit)(void *opaque, size_t new_rate);
c163b5ca 46typedef size_t (QEMUFileGetRateLimit)(void *opaque);
19629537 47
5dafc53f
AL		 48QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
49 QEMUFileGetBufferFunc *get_buffer,
50 QEMUFileCloseFunc *close,
19629537 51 QEMUFileRateLimit *rate_limit,
c163b5ca
LS		 52 QEMUFileSetRateLimit *set_rate_limit,
53 QEMUFileGetRateLimit *get_rate_limit);
87ecb68b 54QEMUFile *qemu_fopen(const char *filename, const char *mode);
5ac1fad3 55QEMUFile *qemu_fdopen(int fd, const char *mode);
c1d36665 56QEMUFile *qemu_fopen_socket(int fd);
065e2813
AL		 57QEMUFile *qemu_popen(FILE *popen_file, const char *mode);
58QEMUFile *qemu_popen_cmd(const char *command, const char *mode);
7f79dd28 59int qemu_stdio_fd(QEMUFile *f);
87ecb68b 60void qemu_fflush(QEMUFile *f);
5dafc53f 61int qemu_fclose(QEMUFile *f);
2ca83a8d
BS		 62void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);
63void qemu_put_byte(QEMUFile *f, int v);
b6c4f71f
BS		 64
65static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v)
66{
67 qemu_put_byte(f, (int)v);
68}
69
70#define qemu_put_sbyte qemu_put_byte
71
2ca83a8d
BS		 72void qemu_put_be16(QEMUFile *f, unsigned int v);
73void qemu_put_be32(QEMUFile *f, unsigned int v);
87ecb68b 74void qemu_put_be64(QEMUFile *f, uint64_t v);
2ca83a8d
BS		 75int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);
76int qemu_get_byte(QEMUFile *f);
b6c4f71f
BS		 77
78static inline unsigned int qemu_get_ubyte(QEMUFile *f)
79{
80 return (unsigned int)qemu_get_byte(f);
81}
82
83#define qemu_get_sbyte qemu_get_byte
84
2ca83a8d
BS		 85unsigned int qemu_get_be16(QEMUFile *f);
86unsigned int qemu_get_be32(QEMUFile *f);
87ecb68b 87uint64_t qemu_get_be64(QEMUFile *f);
5dafc53f 88int qemu_file_rate_limit(QEMUFile *f);
19629537 89size_t qemu_file_set_rate_limit(QEMUFile *f, size_t new_rate);
c163b5ca 90size_t qemu_file_get_rate_limit(QEMUFile *f);
871d2f07 91int qemu_file_has_error(QEMUFile *f);
4dabe248 92void qemu_file_set_error(QEMUFile *f);
5dafc53f
AL		 93
94/* Try to send any outstanding data. This function is useful when output is
95 * halted due to rate limiting or EAGAIN errors occur as it can be used to
96 * resume output. */
97void qemu_file_put_notify(QEMUFile *f);
87ecb68b
PB		 98
99static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
100{
101 qemu_put_be64(f, *pv);
102}
103
104static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv)
105{
106 qemu_put_be32(f, *pv);
107}
108
109static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv)
110{
111 qemu_put_be16(f, *pv);
112}
113
114static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv)
115{
116 qemu_put_byte(f, *pv);
117}
118
119static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv)
120{
121 *pv = qemu_get_be64(f);
122}
123
124static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv)
125{
126 *pv = qemu_get_be32(f);
127}
128
129static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv)
130{
131 *pv = qemu_get_be16(f);
132}
133
134static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv)
135{
136 *pv = qemu_get_byte(f);
137}
138
b6c4f71f
BS		 139// Signed versions for type safety
140static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, int size)
141{
142 qemu_put_buffer(f, (const uint8_t *)buf, size);
143}
144
145static inline void qemu_put_sbe16(QEMUFile *f, int v)
146{
147 qemu_put_be16(f, (unsigned int)v);
148}
149
150static inline void qemu_put_sbe32(QEMUFile *f, int v)
151{
152 qemu_put_be32(f, (unsigned int)v);
153}
154
155static inline void qemu_put_sbe64(QEMUFile *f, int64_t v)
156{
157 qemu_put_be64(f, (uint64_t)v);
158}
159
160static inline size_t qemu_get_sbuffer(QEMUFile *f, int8_t *buf, int size)
161{
162 return qemu_get_buffer(f, (uint8_t *)buf, size);
163}
164
165static inline int qemu_get_sbe16(QEMUFile *f)
166{
167 return (int)qemu_get_be16(f);
168}
169
170static inline int qemu_get_sbe32(QEMUFile *f)
171{
172 return (int)qemu_get_be32(f);
173}
174
175static inline int64_t qemu_get_sbe64(QEMUFile *f)
176{
177 return (int64_t)qemu_get_be64(f);
178}
179
180static inline void qemu_put_s8s(QEMUFile *f, const int8_t *pv)
181{
182 qemu_put_8s(f, (const uint8_t *)pv);
183}
184
185static inline void qemu_put_sbe16s(QEMUFile *f, const int16_t *pv)
186{
187 qemu_put_be16s(f, (const uint16_t *)pv);
188}
189
190static inline void qemu_put_sbe32s(QEMUFile *f, const int32_t *pv)
191{
192 qemu_put_be32s(f, (const uint32_t *)pv);
193}
194
195static inline void qemu_put_sbe64s(QEMUFile *f, const int64_t *pv)
196{
197 qemu_put_be64s(f, (const uint64_t *)pv);
198}
199
200static inline void qemu_get_s8s(QEMUFile *f, int8_t *pv)
201{
202 qemu_get_8s(f, (uint8_t *)pv);
203}
204
205static inline void qemu_get_sbe16s(QEMUFile *f, int16_t *pv)
206{
207 qemu_get_be16s(f, (uint16_t *)pv);
208}
209
210static inline void qemu_get_sbe32s(QEMUFile *f, int32_t *pv)
211{
212 qemu_get_be32s(f, (uint32_t *)pv);
213}
214
215static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv)
216{
217 qemu_get_be64s(f, (uint64_t *)pv);
218}
219
87ecb68b
PB		 220#ifdef NEED_CPU_H
221#if TARGET_LONG_BITS == 64
222#define qemu_put_betl qemu_put_be64
223#define qemu_get_betl qemu_get_be64
224#define qemu_put_betls qemu_put_be64s
225#define qemu_get_betls qemu_get_be64s
b6c4f71f
BS		 226#define qemu_put_sbetl qemu_put_sbe64
227#define qemu_get_sbetl qemu_get_sbe64
228#define qemu_put_sbetls qemu_put_sbe64s
229#define qemu_get_sbetls qemu_get_sbe64s
87ecb68b
PB		 230#else
231#define qemu_put_betl qemu_put_be32
232#define qemu_get_betl qemu_get_be32
233#define qemu_put_betls qemu_put_be32s
234#define qemu_get_betls qemu_get_be32s
b6c4f71f
BS		 235#define qemu_put_sbetl qemu_put_sbe32
236#define qemu_get_sbetl qemu_get_sbe32
237#define qemu_put_sbetls qemu_put_sbe32s
238#define qemu_get_sbetls qemu_get_sbe32s
87ecb68b
PB		 239#endif
240#endif
241
242int64_t qemu_ftell(QEMUFile *f);
243int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence);
244
c163b5ca 245typedef void SaveSetParamsHandler(int blk_enable, int shared, void * opaque);
87ecb68b 246typedef void SaveStateHandler(QEMUFile *f, void *opaque);
f327aa0c
JK		 247typedef int SaveLiveStateHandler(Monitor *mon, QEMUFile *f, int stage,
248 void *opaque);
87ecb68b
PB		 249typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id);
250
251int register_savevm(const char *idstr,
252 int instance_id,
253 int version_id,
254 SaveStateHandler *save_state,
255 LoadStateHandler *load_state,
256 void *opaque);
257
9366f418
AL		 258int register_savevm_live(const char *idstr,
259 int instance_id,
260 int version_id,
c163b5ca
LS		 261 SaveSetParamsHandler *set_params,
262 SaveLiveStateHandler *save_live_state,
9366f418
AL		 263 SaveStateHandler *save_state,
264 LoadStateHandler *load_state,
265 void *opaque);
266
41bd13af
AL		 267void unregister_savevm(const char *idstr, void *opaque);
268
87ecb68b
PB		 269typedef void QEMUResetHandler(void *opaque);
270
a08d4367 271void qemu_register_reset(QEMUResetHandler *func, void *opaque);
dda9b29f 272void qemu_unregister_reset(QEMUResetHandler *func, void *opaque);
87ecb68b 273
76e30d0f 274/* handler to set the boot_device order for a specific type of QEMUMachine */
0ecdffbb 275/* return 0 if success */
76e30d0f 276typedef int QEMUBootSetHandler(void *opaque, const char *boot_devices);
3b4366de 277void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque);
76e30d0f 278int qemu_boot_set(const char *boot_devices);
0ecdffbb 279
9ed7d6ae
JQ		 280typedef struct VMStateInfo VMStateInfo;
281typedef struct VMStateDescription VMStateDescription;
282
283struct VMStateInfo {
284 const char *name;
285 int (*get)(QEMUFile *f, void *pv, size_t size);
84e2e3eb 286 void (*put)(QEMUFile *f, void *pv, size_t size);
9ed7d6ae
JQ		 287};
288
289enum VMStateFlags {
5139931f
JQ		 290 VMS_SINGLE = 0x001,
291 VMS_POINTER = 0x002,
292 VMS_ARRAY = 0x004,
293 VMS_STRUCT = 0x008,
bdb4941d 294 VMS_VARRAY_INT32 = 0x010, /* Array with size in int32_t field*/
5139931f 295 VMS_BUFFER = 0x020, /* static sized buffer */
19df438b 296 VMS_ARRAY_OF_POINTER = 0x040,
bdb4941d 297 VMS_VARRAY_UINT16 = 0x080, /* Array with size in uint16_t field */
e61a1e0a 298 VMS_VBUFFER = 0x100, /* Buffer with size in int32_t field */
33599e2a 299 VMS_MULTIPLY = 0x200, /* multiply "size" field by field_size */
9ed7d6ae
JQ		 300};
301
302typedef struct {
303 const char *name;
304 size_t offset;
305 size_t size;
e61a1e0a 306 size_t start;
f752a6aa 307 int num;
b00319a9 308 size_t num_offset;
e61a1e0a 309 size_t size_offset;
9ed7d6ae
JQ		 310 const VMStateInfo *info;
311 enum VMStateFlags flags;
ec245e21 312 const VMStateDescription *vmsd;
9ed7d6ae 313 int version_id;
f11f6a5f 314 bool (*field_exists)(void *opaque, int version_id);
9ed7d6ae
JQ		 315} VMStateField;
316
317struct VMStateDescription {
318 const char *name;
319 int version_id;
320 int minimum_version_id;
321 int minimum_version_id_old;
322 LoadStateHandler *load_state_old;
fd4d52de 323 int (*pre_load)(void *opaque);
e59fb374 324 int (*post_load)(void *opaque, int version_id);
d4bfa4d7
JQ		 325 void (*pre_save)(void *opaque);
326 void (*post_save)(void *opaque);
9ed7d6ae
JQ		 327 VMStateField *fields;
328};
329
330extern const VMStateInfo vmstate_info_int8;
331extern const VMStateInfo vmstate_info_int16;
332extern const VMStateInfo vmstate_info_int32;
333extern const VMStateInfo vmstate_info_int64;
334
80cd83e7 335extern const VMStateInfo vmstate_info_uint8_equal;
dc3b83a0 336extern const VMStateInfo vmstate_info_uint16_equal;
82501660 337extern const VMStateInfo vmstate_info_int32_equal;
0a031e0a 338extern const VMStateInfo vmstate_info_int32_le;
82501660 339
9ed7d6ae
JQ		 340extern const VMStateInfo vmstate_info_uint8;
341extern const VMStateInfo vmstate_info_uint16;
342extern const VMStateInfo vmstate_info_uint32;
343extern const VMStateInfo vmstate_info_uint64;
344
dde0463b 345extern const VMStateInfo vmstate_info_timer;
55a6e51f 346extern const VMStateInfo vmstate_info_ptimer;
6f67c50f 347extern const VMStateInfo vmstate_info_buffer;
76507c75 348extern const VMStateInfo vmstate_info_unused_buffer;
dde0463b 349
f752a6aa 350#define type_check_array(t1,t2,n) ((t1(*)[n])0 - (t2*)0)
b00319a9 351#define type_check_pointer(t1,t2) ((t1**)0 - (t2*)0)
f752a6aa 352
904ca304
JQ		 353#define vmstate_offset_value(_state, _field, _type) \
354 (offsetof(_state, _field) + \
355 type_check(_type, typeof_field(_state, _field)))
356
c29d8b1e
JQ		 357#define vmstate_offset_pointer(_state, _field, _type) \
358 (offsetof(_state, _field) + \
359 type_check_pointer(_type, typeof_field(_state, _field)))
360
646bef19
JQ		 361#define vmstate_offset_array(_state, _field, _type, _num) \
362 (offsetof(_state, _field) + \
363 type_check_array(_type, typeof_field(_state, _field), _num))
364
9ba2f660
JQ		 365#define vmstate_offset_sub_array(_state, _field, _type, _start) \
366 (offsetof(_state, _field[_start]))
367
844b236a
JQ		 368#define vmstate_offset_buffer(_state, _field) \
369 vmstate_offset_array(_state, _field, uint8_t, \
370 sizeof(typeof_field(_state, _field)))
371
d4829d49 372#define VMSTATE_SINGLE_TEST(_field, _state, _test, _version, _info, _type) { \
f11f6a5f 373 .name = (stringify(_field)), \
d4829d49 374 .version_id = (_version), \
f11f6a5f
JQ		 375 .field_exists = (_test), \
376 .size = sizeof(_type), \
377 .info = &(_info), \
378 .flags = VMS_SINGLE, \
904ca304 379 .offset = vmstate_offset_value(_state, _field, _type), \
f11f6a5f
JQ		 380}
381
dde0463b
JQ		 382#define VMSTATE_POINTER(_field, _state, _version, _info, _type) { \
383 .name = (stringify(_field)), \
384 .version_id = (_version), \
385 .info = &(_info), \
386 .size = sizeof(_type), \
387 .flags = VMS_SINGLE|VMS_POINTER, \
904ca304 388 .offset = vmstate_offset_value(_state, _field, _type), \
dde0463b
JQ		 389}
390
f752a6aa
JQ		 391#define VMSTATE_ARRAY(_field, _state, _num, _version, _info, _type) {\
392 .name = (stringify(_field)), \
393 .version_id = (_version), \
394 .num = (_num), \
395 .info = &(_info), \
396 .size = sizeof(_type), \
397 .flags = VMS_ARRAY, \
646bef19 398 .offset = vmstate_offset_array(_state, _field, _type, _num), \
f752a6aa
JQ		 399}
400
f11f6a5f
JQ		 401#define VMSTATE_ARRAY_TEST(_field, _state, _num, _test, _info, _type) {\
402 .name = (stringify(_field)), \
403 .field_exists = (_test), \
404 .num = (_num), \
405 .info = &(_info), \
406 .size = sizeof(_type), \
407 .flags = VMS_ARRAY, \
646bef19 408 .offset = vmstate_offset_array(_state, _field, _type, _num),\
f11f6a5f
JQ		 409}
410
9ba2f660
JQ		 411#define VMSTATE_SUB_ARRAY(_field, _state, _start, _num, _version, _info, _type) { \
412 .name = (stringify(_field)), \
413 .version_id = (_version), \
414 .num = (_num), \
415 .info = &(_info), \
416 .size = sizeof(_type), \
417 .flags = VMS_ARRAY, \
418 .offset = vmstate_offset_sub_array(_state, _field, _type, _start), \
419}
420
d6698281 421#define VMSTATE_VARRAY_INT32(_field, _state, _field_num, _version, _info, _type) {\
b00319a9
JQ		 422 .name = (stringify(_field)), \
423 .version_id = (_version), \
904ca304 424 .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \
b00319a9
JQ		 425 .info = &(_info), \
426 .size = sizeof(_type), \
d6698281 427 .flags = VMS_VARRAY_INT32|VMS_POINTER, \
c29d8b1e 428 .offset = vmstate_offset_pointer(_state, _field, _type), \
b00319a9
JQ		 429}
430
bdb4941d
JQ		 431#define VMSTATE_VARRAY_UINT16_UNSAFE(_field, _state, _field_num, _version, _info, _type) {\
432 .name = (stringify(_field)), \
433 .version_id = (_version), \
434 .num_offset = vmstate_offset_value(_state, _field_num, uint16_t),\
435 .info = &(_info), \
436 .size = sizeof(_type), \
437 .flags = VMS_VARRAY_UINT16, \
438 .offset = offsetof(_state, _field), \
439}
440
11fe0e6e
JQ		 441#define VMSTATE_STRUCT_TEST(_field, _state, _test, _version, _vmsd, _type) { \
442 .name = (stringify(_field)), \
443 .version_id = (_version), \
444 .field_exists = (_test), \
445 .vmsd = &(_vmsd), \
446 .size = sizeof(_type), \
447 .flags = VMS_STRUCT, \
448 .offset = vmstate_offset_value(_state, _field, _type), \
ec245e21
JQ		 449}
450
543fc7b2
JQ		 451#define VMSTATE_STRUCT_POINTER_TEST(_field, _state, _test, _vmsd, _type) { \
452 .name = (stringify(_field)), \
453 .field_exists = (_test), \
454 .vmsd = &(_vmsd), \
455 .size = sizeof(_type), \
456 .flags = VMS_STRUCT|VMS_POINTER, \
457 .offset = vmstate_offset_value(_state, _field, _type), \
840e9cef
JQ		 458}
459
19df438b
JQ		 460#define VMSTATE_ARRAY_OF_POINTER(_field, _state, _num, _version, _info, _type) {\
461 .name = (stringify(_field)), \
462 .version_id = (_version), \
463 .num = (_num), \
464 .info = &(_info), \
465 .size = sizeof(_type), \
466 .flags = VMS_ARRAY|VMS_ARRAY_OF_POINTER, \
646bef19 467 .offset = vmstate_offset_array(_state, _field, _type, _num), \
19df438b
JQ		 468}
469
79c451b9
JQ		 470#define VMSTATE_STRUCT_ARRAY(_field, _state, _num, _version, _vmsd, _type) { \
471 .name = (stringify(_field)), \
472 .num = (_num), \
473 .version_id = (_version), \
474 .vmsd = &(_vmsd), \
475 .size = sizeof(_type), \
476 .flags = VMS_STRUCT|VMS_ARRAY, \
646bef19 477 .offset = vmstate_offset_array(_state, _field, _type, _num), \
79c451b9
JQ		 478}
479
b2e15099 480#define VMSTATE_STATIC_BUFFER(_field, _state, _version, _test, _start, _size) { \
25dc563b 481 .name = (stringify(_field)), \
b2e15099 482 .version_id = (_version), \
25dc563b 483 .field_exists = (_test), \
b2e15099 484 .size = (_size - _start), \
25dc563b
JQ		 485 .info = &vmstate_info_buffer, \
486 .flags = VMS_BUFFER, \
b2e15099 487 .offset = vmstate_offset_buffer(_state, _field) + _start, \
7e72abc3
JQ		 488}
489
33599e2a
JQ		 490#define VMSTATE_BUFFER_MULTIPLY(_field, _state, _version, _test, _start, _field_size, _multiply) { \
491 .name = (stringify(_field)), \
492 .version_id = (_version), \
493 .field_exists = (_test), \
494 .size_offset = vmstate_offset_value(_state, _field_size, uint32_t),\
495 .size = (_multiply), \
496 .info = &vmstate_info_buffer, \
497 .flags = VMS_VBUFFER|VMS_MULTIPLY, \
498 .offset = offsetof(_state, _field), \
499 .start = (_start), \
500}
501
e61a1e0a
JQ		 502#define VMSTATE_VBUFFER(_field, _state, _version, _test, _start, _field_size) { \
503 .name = (stringify(_field)), \
504 .version_id = (_version), \
505 .field_exists = (_test), \
506 .size_offset = vmstate_offset_value(_state, _field_size, int32_t),\
507 .info = &vmstate_info_buffer, \
508 .flags = VMS_VBUFFER|VMS_POINTER, \
509 .offset = offsetof(_state, _field), \
510 .start = (_start), \
511}
512
9cae69bd 513#define VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, _info, _size) { \
1ae71a77
JQ		 514 .name = (stringify(_field)), \
515 .version_id = (_version), \
516 .size = (_size), \
9cae69bd 517 .info = &(_info), \
1ae71a77
JQ		 518 .flags = VMS_BUFFER, \
519 .offset = offsetof(_state, _field), \
520}
521
76507c75
JQ		 522#define VMSTATE_UNUSED_BUFFER(_test, _version, _size) { \
523 .name = "unused", \
524 .field_exists = (_test), \
525 .version_id = (_version), \
526 .size = (_size), \
527 .info = &vmstate_info_unused_buffer, \
528 .flags = VMS_BUFFER, \
529}
73534f2f
JQ		 530extern const VMStateDescription vmstate_pci_device;
531
532#define VMSTATE_PCI_DEVICE(_field, _state) { \
533 .name = (stringify(_field)), \
73534f2f
JQ		 534 .size = sizeof(PCIDevice), \
535 .vmsd = &vmstate_pci_device, \
536 .flags = VMS_STRUCT, \
904ca304 537 .offset = vmstate_offset_value(_state, _field, PCIDevice), \
73534f2f
JQ		 538}
539
a9f49946
IY		 540extern const VMStateDescription vmstate_pcie_device;
541
542#define VMSTATE_PCIE_DEVICE(_field, _state) { \
543 .name = (stringify(_field)), \
544 .version_id = 2, \
545 .size = sizeof(PCIDevice), \
546 .vmsd = &vmstate_pcie_device, \
547 .flags = VMS_STRUCT, \
548 .offset = vmstate_offset_value(_state, _field, PCIDevice), \
549}
550
1894839f
JQ		 551extern const VMStateDescription vmstate_i2c_slave;
552
553#define VMSTATE_I2C_SLAVE(_field, _state) { \
554 .name = (stringify(_field)), \
555 .size = sizeof(i2c_slave), \
556 .vmsd = &vmstate_i2c_slave, \
557 .flags = VMS_STRUCT, \
904ca304 558 .offset = vmstate_offset_value(_state, _field, i2c_slave), \
1894839f
JQ		 559}
560
9e77fcd0
JQ		 561#define vmstate_offset_macaddr(_state, _field) \
562 vmstate_offset_array(_state, _field.a, uint8_t, \
563 sizeof(typeof_field(_state, _field)))
564
565#define VMSTATE_MACADDR(_field, _state) { \
566 .name = (stringify(_field)), \
567 .size = sizeof(MACAddr), \
d9494b19 568 .info = &vmstate_info_buffer, \
9e77fcd0
JQ		 569 .flags = VMS_BUFFER, \
570 .offset = vmstate_offset_macaddr(_state, _field), \
571}
572
9ed7d6ae 573/* _f : field name
b00319a9 574 _f_n : num of elements field_name
f752a6aa 575 _n : num of elements
9ed7d6ae
JQ		 576 _s : struct state name
577 _v : version
578*/
579
d4829d49
JQ		 580#define VMSTATE_SINGLE(_field, _state, _version, _info, _type) \
581 VMSTATE_SINGLE_TEST(_field, _state, NULL, _version, _info, _type)
582
11fe0e6e
JQ		 583#define VMSTATE_STRUCT(_field, _state, _version, _vmsd, _type) \
584 VMSTATE_STRUCT_TEST(_field, _state, NULL, _version, _vmsd, _type)
585
543fc7b2
JQ		 586#define VMSTATE_STRUCT_POINTER(_field, _state, _vmsd, _type) \
587 VMSTATE_STRUCT_POINTER_TEST(_field, _state, NULL, _vmsd, _type)
588
9ed7d6ae
JQ		 589#define VMSTATE_INT8_V(_f, _s, _v) \
590 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int8, int8_t)
591#define VMSTATE_INT16_V(_f, _s, _v) \
592 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int16, int16_t)
593#define VMSTATE_INT32_V(_f, _s, _v) \
594 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int32, int32_t)
595#define VMSTATE_INT64_V(_f, _s, _v) \
596 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int64, int64_t)
597
598#define VMSTATE_UINT8_V(_f, _s, _v) \
599 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint8, uint8_t)
600#define VMSTATE_UINT16_V(_f, _s, _v) \
601 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint16, uint16_t)
602#define VMSTATE_UINT32_V(_f, _s, _v) \
603 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint32, uint32_t)
604#define VMSTATE_UINT64_V(_f, _s, _v) \
605 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint64, uint64_t)
606
607#define VMSTATE_INT8(_f, _s) \
608 VMSTATE_INT8_V(_f, _s, 0)
609#define VMSTATE_INT16(_f, _s) \
610 VMSTATE_INT16_V(_f, _s, 0)
611#define VMSTATE_INT32(_f, _s) \
612 VMSTATE_INT32_V(_f, _s, 0)
613#define VMSTATE_INT64(_f, _s) \
614 VMSTATE_INT64_V(_f, _s, 0)
615
616#define VMSTATE_UINT8(_f, _s) \
617 VMSTATE_UINT8_V(_f, _s, 0)
618#define VMSTATE_UINT16(_f, _s) \
619 VMSTATE_UINT16_V(_f, _s, 0)
620#define VMSTATE_UINT32(_f, _s) \
621 VMSTATE_UINT32_V(_f, _s, 0)
622#define VMSTATE_UINT64(_f, _s) \
623 VMSTATE_UINT64_V(_f, _s, 0)
624
80cd83e7
JQ		 625#define VMSTATE_UINT8_EQUAL(_f, _s) \
626 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint8_equal, uint8_t)
627
dc3b83a0
JQ		 628#define VMSTATE_UINT16_EQUAL(_f, _s) \
629 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint16_equal, uint16_t)
630
631#define VMSTATE_UINT16_EQUAL_V(_f, _s, _v) \
632 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint16_equal, uint16_t)
633
82501660
JQ		 634#define VMSTATE_INT32_EQUAL(_f, _s) \
635 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_equal, int32_t)
636
0a031e0a
JQ		 637#define VMSTATE_INT32_LE(_f, _s) \
638 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_le, int32_t)
639
2fee4078
JQ		 640#define VMSTATE_UINT16_TEST(_f, _s, _t) \
641 VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint16, uint16_t)
642
f11f6a5f 643#define VMSTATE_UINT32_TEST(_f, _s, _t) \
d4829d49 644 VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint32, uint32_t)
f11f6a5f 645
dde0463b
JQ		 646#define VMSTATE_TIMER_V(_f, _s, _v) \
647 VMSTATE_POINTER(_f, _s, _v, vmstate_info_timer, QEMUTimer *)
648
649#define VMSTATE_TIMER(_f, _s) \
650 VMSTATE_TIMER_V(_f, _s, 0)
651
19df438b
JQ		 652#define VMSTATE_TIMER_ARRAY(_f, _s, _n) \
653 VMSTATE_ARRAY_OF_POINTER(_f, _s, _n, 0, vmstate_info_timer, QEMUTimer *)
654
55a6e51f
BS		 655#define VMSTATE_PTIMER_V(_f, _s, _v) \
656 VMSTATE_POINTER(_f, _s, _v, vmstate_info_ptimer, ptimer_state *)
657
658#define VMSTATE_PTIMER(_f, _s) \
659 VMSTATE_PTIMER_V(_f, _s, 0)
660
632cf073
JQ		 661#define VMSTATE_UINT16_ARRAY_V(_f, _s, _n, _v) \
662 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint16, uint16_t)
663
664#define VMSTATE_UINT16_ARRAY(_f, _s, _n) \
665 VMSTATE_UINT16_ARRAY_V(_f, _s, _n, 0)
666
b6bd0bdc
JQ		 667#define VMSTATE_UINT8_ARRAY_V(_f, _s, _n, _v) \
668 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint8, uint8_t)
669
670#define VMSTATE_UINT8_ARRAY(_f, _s, _n) \
671 VMSTATE_UINT8_ARRAY_V(_f, _s, _n, 0)
672
f752a6aa
JQ		 673#define VMSTATE_UINT32_ARRAY_V(_f, _s, _n, _v) \
674 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint32, uint32_t)
675
676#define VMSTATE_UINT32_ARRAY(_f, _s, _n) \
677 VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0)
678
80a04bbe
JQ		 679#define VMSTATE_UINT64_ARRAY_V(_f, _s, _n, _v) \
680 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint64, uint64_t)
681
682#define VMSTATE_UINT64_ARRAY(_f, _s, _n) \
683 VMSTATE_UINT64_ARRAY_V(_f, _s, _n, 0)
684
289070c7
JQ		 685#define VMSTATE_INT16_ARRAY_V(_f, _s, _n, _v) \
686 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int16, int16_t)
687
688#define VMSTATE_INT16_ARRAY(_f, _s, _n) \
689 VMSTATE_INT16_ARRAY_V(_f, _s, _n, 0)
690
f752a6aa
JQ		 691#define VMSTATE_INT32_ARRAY_V(_f, _s, _n, _v) \
692 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int32, int32_t)
693
694#define VMSTATE_INT32_ARRAY(_f, _s, _n) \
695 VMSTATE_INT32_ARRAY_V(_f, _s, _n, 0)
696
9ba2f660
JQ		 697#define VMSTATE_UINT32_SUB_ARRAY(_f, _s, _start, _num) \
698 VMSTATE_SUB_ARRAY(_f, _s, _start, _num, 0, vmstate_info_uint32, uint32_t)
699
700#define VMSTATE_UINT32_ARRAY(_f, _s, _n) \
701 VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0)
702
6f67c50f 703#define VMSTATE_BUFFER_V(_f, _s, _v) \
b2e15099 704 VMSTATE_STATIC_BUFFER(_f, _s, _v, NULL, 0, sizeof(typeof_field(_s, _f)))
6f67c50f
JQ		 705
706#define VMSTATE_BUFFER(_f, _s) \
b2e15099
JQ		 707 VMSTATE_BUFFER_V(_f, _s, 0)
708
709#define VMSTATE_PARTIAL_BUFFER(_f, _s, _size) \
710 VMSTATE_STATIC_BUFFER(_f, _s, 0, NULL, 0, _size)
711
712#define VMSTATE_BUFFER_START_MIDDLE(_f, _s, _start) \
713 VMSTATE_STATIC_BUFFER(_f, _s, 0, NULL, _start, sizeof(typeof_field(_s, _f)))
6f67c50f 714
e61a1e0a
JQ		 715#define VMSTATE_PARTIAL_VBUFFER(_f, _s, _size) \
716 VMSTATE_VBUFFER(_f, _s, 0, NULL, 0, _size)
717
718#define VMSTATE_SUB_VBUFFER(_f, _s, _start, _size) \
719 VMSTATE_VBUFFER(_f, _s, 0, NULL, _start, _size)
720
b2e15099
JQ		 721#define VMSTATE_BUFFER_TEST(_f, _s, _test) \
722 VMSTATE_STATIC_BUFFER(_f, _s, 0, _test, 0, sizeof(typeof_field(_s, _f)))
25dc563b 723
9cae69bd
IY		 724#define VMSTATE_BUFFER_UNSAFE(_field, _state, _version, _size) \
725 VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, vmstate_info_buffer, _size)
726
76507c75
JQ		 727#define VMSTATE_UNUSED_V(_v, _size) \
728 VMSTATE_UNUSED_BUFFER(NULL, _v, _size)
729
730#define VMSTATE_UNUSED(_size) \
731 VMSTATE_UNUSED_V(0, _size)
732
733#define VMSTATE_UNUSED_TEST(_test, _size) \
734 VMSTATE_UNUSED_BUFFER(_test, 0, _size)
735
f89a8e4e
JQ		 736#ifdef NEED_CPU_H
737#if TARGET_LONG_BITS == 64
738#define VMSTATE_UINTTL_V(_f, _s, _v) \
739 VMSTATE_UINT64_V(_f, _s, _v)
740#define VMSTATE_UINTTL_ARRAY_V(_f, _s, _n, _v) \
741 VMSTATE_UINT64_ARRAY_V(_f, _s, _n, _v)
742#else
743#define VMSTATE_UINTTL_V(_f, _s, _v) \
744 VMSTATE_UINT32_V(_f, _s, _v)
745#define VMSTATE_UINTTL_ARRAY_V(_f, _s, _n, _v) \
746 VMSTATE_UINT32_ARRAY_V(_f, _s, _n, _v)
747#endif
748#define VMSTATE_UINTTL(_f, _s) \
749 VMSTATE_UINTTL_V(_f, _s, 0)
750#define VMSTATE_UINTTL_ARRAY(_f, _s, _n) \
751 VMSTATE_UINTTL_ARRAY_V(_f, _s, _n, 0)
752
753#endif
754
9ed7d6ae
JQ		 755#define VMSTATE_END_OF_LIST() \
756 {}
757
758extern int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
759 void *opaque, int version_id);
760extern void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
84e2e3eb 761 void *opaque);
9ed7d6ae
JQ		 762extern int vmstate_register(int instance_id, const VMStateDescription *vmsd,
763 void *base);
1eb7538b 764void vmstate_unregister(const VMStateDescription *vmsd, void *opaque);
87ecb68b 765#endif
Empty description
This page took 0.452726 seconds and 4 git commands to generate.