]>
Commit | Line | Data |
---|---|---|
1 | /* Declarations for use by hardware emulation. */ | |
2 | #ifndef QEMU_HW_H | |
3 | #define QEMU_HW_H | |
4 | ||
5 | #include "qemu-common.h" | |
6 | ||
7 | #if defined(TARGET_PHYS_ADDR_BITS) && !defined(NEED_CPU_H) | |
8 | #include "cpu-common.h" | |
9 | #endif | |
10 | ||
11 | #include "ioport.h" | |
12 | #include "irq.h" | |
13 | ||
14 | /* VM Load/Save */ | |
15 | ||
16 | /* This function writes a chunk of data to a file at the given position. | |
17 | * The pos argument can be ignored if the file is only being used for | |
18 | * streaming. The handler should try to write all of the data it can. | |
19 | */ | |
20 | typedef int (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf, | |
21 | int64_t pos, int size); | |
22 | ||
23 | /* Read a chunk of data from a file at the given position. The pos argument | |
24 | * can be ignored if the file is only be used for streaming. The number of | |
25 | * bytes actually read should be returned. | |
26 | */ | |
27 | typedef int (QEMUFileGetBufferFunc)(void *opaque, uint8_t *buf, | |
28 | int64_t pos, int size); | |
29 | ||
30 | /* Close a file and return an error code */ | |
31 | typedef int (QEMUFileCloseFunc)(void *opaque); | |
32 | ||
33 | /* Called to determine if the file has exceeded it's bandwidth allocation. The | |
34 | * bandwidth capping is a soft limit, not a hard limit. | |
35 | */ | |
36 | typedef int (QEMUFileRateLimit)(void *opaque); | |
37 | ||
38 | /* Called to change the current bandwidth allocation. This function must return | |
39 | * the new actual bandwidth. It should be new_rate if everything goes ok, and | |
40 | * the old rate otherwise | |
41 | */ | |
42 | typedef int64_t (QEMUFileSetRateLimit)(void *opaque, int64_t new_rate); | |
43 | typedef int64_t (QEMUFileGetRateLimit)(void *opaque); | |
44 | ||
45 | QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer, | |
46 | QEMUFileGetBufferFunc *get_buffer, | |
47 | QEMUFileCloseFunc *close, | |
48 | QEMUFileRateLimit *rate_limit, | |
49 | QEMUFileSetRateLimit *set_rate_limit, | |
50 | QEMUFileGetRateLimit *get_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); | |
61 | ||
62 | static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v) | |
63 | { | |
64 | qemu_put_byte(f, (int)v); | |
65 | } | |
66 | ||
67 | #define qemu_put_sbyte qemu_put_byte | |
68 | ||
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); | |
74 | ||
75 | static inline unsigned int qemu_get_ubyte(QEMUFile *f) | |
76 | { | |
77 | return (unsigned int)qemu_get_byte(f); | |
78 | } | |
79 | ||
80 | #define qemu_get_sbyte qemu_get_byte | |
81 | ||
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 | int64_t qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate); | |
87 | int64_t qemu_file_get_rate_limit(QEMUFile *f); | |
88 | int qemu_file_has_error(QEMUFile *f); | |
89 | void qemu_file_set_error(QEMUFile *f); | |
90 | ||
91 | /* Try to send any outstanding data. This function is useful when output is | |
92 | * halted due to rate limiting or EAGAIN errors occur as it can be used to | |
93 | * resume output. */ | |
94 | void qemu_file_put_notify(QEMUFile *f); | |
95 | ||
96 | static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv) | |
97 | { | |
98 | qemu_put_be64(f, *pv); | |
99 | } | |
100 | ||
101 | static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv) | |
102 | { | |
103 | qemu_put_be32(f, *pv); | |
104 | } | |
105 | ||
106 | static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv) | |
107 | { | |
108 | qemu_put_be16(f, *pv); | |
109 | } | |
110 | ||
111 | static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv) | |
112 | { | |
113 | qemu_put_byte(f, *pv); | |
114 | } | |
115 | ||
116 | static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv) | |
117 | { | |
118 | *pv = qemu_get_be64(f); | |
119 | } | |
120 | ||
121 | static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv) | |
122 | { | |
123 | *pv = qemu_get_be32(f); | |
124 | } | |
125 | ||
126 | static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv) | |
127 | { | |
128 | *pv = qemu_get_be16(f); | |
129 | } | |
130 | ||
131 | static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv) | |
132 | { | |
133 | *pv = qemu_get_byte(f); | |
134 | } | |
135 | ||
136 | // Signed versions for type safety | |
137 | static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, int size) | |
138 | { | |
139 | qemu_put_buffer(f, (const uint8_t *)buf, size); | |
140 | } | |
141 | ||
142 | static inline void qemu_put_sbe16(QEMUFile *f, int v) | |
143 | { | |
144 | qemu_put_be16(f, (unsigned int)v); | |
145 | } | |
146 | ||
147 | static inline void qemu_put_sbe32(QEMUFile *f, int v) | |
148 | { | |
149 | qemu_put_be32(f, (unsigned int)v); | |
150 | } | |
151 | ||
152 | static inline void qemu_put_sbe64(QEMUFile *f, int64_t v) | |
153 | { | |
154 | qemu_put_be64(f, (uint64_t)v); | |
155 | } | |
156 | ||
157 | static inline size_t qemu_get_sbuffer(QEMUFile *f, int8_t *buf, int size) | |
158 | { | |
159 | return qemu_get_buffer(f, (uint8_t *)buf, size); | |
160 | } | |
161 | ||
162 | static inline int qemu_get_sbe16(QEMUFile *f) | |
163 | { | |
164 | return (int)qemu_get_be16(f); | |
165 | } | |
166 | ||
167 | static inline int qemu_get_sbe32(QEMUFile *f) | |
168 | { | |
169 | return (int)qemu_get_be32(f); | |
170 | } | |
171 | ||
172 | static inline int64_t qemu_get_sbe64(QEMUFile *f) | |
173 | { | |
174 | return (int64_t)qemu_get_be64(f); | |
175 | } | |
176 | ||
177 | static inline void qemu_put_s8s(QEMUFile *f, const int8_t *pv) | |
178 | { | |
179 | qemu_put_8s(f, (const uint8_t *)pv); | |
180 | } | |
181 | ||
182 | static inline void qemu_put_sbe16s(QEMUFile *f, const int16_t *pv) | |
183 | { | |
184 | qemu_put_be16s(f, (const uint16_t *)pv); | |
185 | } | |
186 | ||
187 | static inline void qemu_put_sbe32s(QEMUFile *f, const int32_t *pv) | |
188 | { | |
189 | qemu_put_be32s(f, (const uint32_t *)pv); | |
190 | } | |
191 | ||
192 | static inline void qemu_put_sbe64s(QEMUFile *f, const int64_t *pv) | |
193 | { | |
194 | qemu_put_be64s(f, (const uint64_t *)pv); | |
195 | } | |
196 | ||
197 | static inline void qemu_get_s8s(QEMUFile *f, int8_t *pv) | |
198 | { | |
199 | qemu_get_8s(f, (uint8_t *)pv); | |
200 | } | |
201 | ||
202 | static inline void qemu_get_sbe16s(QEMUFile *f, int16_t *pv) | |
203 | { | |
204 | qemu_get_be16s(f, (uint16_t *)pv); | |
205 | } | |
206 | ||
207 | static inline void qemu_get_sbe32s(QEMUFile *f, int32_t *pv) | |
208 | { | |
209 | qemu_get_be32s(f, (uint32_t *)pv); | |
210 | } | |
211 | ||
212 | static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv) | |
213 | { | |
214 | qemu_get_be64s(f, (uint64_t *)pv); | |
215 | } | |
216 | ||
217 | #ifdef NEED_CPU_H | |
218 | #if TARGET_LONG_BITS == 64 | |
219 | #define qemu_put_betl qemu_put_be64 | |
220 | #define qemu_get_betl qemu_get_be64 | |
221 | #define qemu_put_betls qemu_put_be64s | |
222 | #define qemu_get_betls qemu_get_be64s | |
223 | #define qemu_put_sbetl qemu_put_sbe64 | |
224 | #define qemu_get_sbetl qemu_get_sbe64 | |
225 | #define qemu_put_sbetls qemu_put_sbe64s | |
226 | #define qemu_get_sbetls qemu_get_sbe64s | |
227 | #else | |
228 | #define qemu_put_betl qemu_put_be32 | |
229 | #define qemu_get_betl qemu_get_be32 | |
230 | #define qemu_put_betls qemu_put_be32s | |
231 | #define qemu_get_betls qemu_get_be32s | |
232 | #define qemu_put_sbetl qemu_put_sbe32 | |
233 | #define qemu_get_sbetl qemu_get_sbe32 | |
234 | #define qemu_put_sbetls qemu_put_sbe32s | |
235 | #define qemu_get_sbetls qemu_get_sbe32s | |
236 | #endif | |
237 | #endif | |
238 | ||
239 | int64_t qemu_ftell(QEMUFile *f); | |
240 | int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence); | |
241 | ||
242 | typedef void SaveSetParamsHandler(int blk_enable, int shared, void * opaque); | |
243 | typedef void SaveStateHandler(QEMUFile *f, void *opaque); | |
244 | typedef int SaveLiveStateHandler(Monitor *mon, QEMUFile *f, int stage, | |
245 | void *opaque); | |
246 | typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id); | |
247 | ||
248 | int register_savevm(DeviceState *dev, | |
249 | const char *idstr, | |
250 | int instance_id, | |
251 | int version_id, | |
252 | SaveStateHandler *save_state, | |
253 | LoadStateHandler *load_state, | |
254 | void *opaque); | |
255 | ||
256 | int register_savevm_live(DeviceState *dev, | |
257 | const char *idstr, | |
258 | int instance_id, | |
259 | int version_id, | |
260 | SaveSetParamsHandler *set_params, | |
261 | SaveLiveStateHandler *save_live_state, | |
262 | SaveStateHandler *save_state, | |
263 | LoadStateHandler *load_state, | |
264 | void *opaque); | |
265 | ||
266 | void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque); | |
267 | void register_device_unmigratable(DeviceState *dev, const char *idstr, | |
268 | void *opaque); | |
269 | ||
270 | typedef void QEMUResetHandler(void *opaque); | |
271 | ||
272 | void qemu_register_reset(QEMUResetHandler *func, void *opaque); | |
273 | void qemu_unregister_reset(QEMUResetHandler *func, void *opaque); | |
274 | ||
275 | /* handler to set the boot_device order for a specific type of QEMUMachine */ | |
276 | /* return 0 if success */ | |
277 | typedef int QEMUBootSetHandler(void *opaque, const char *boot_devices); | |
278 | void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque); | |
279 | int qemu_boot_set(const char *boot_devices); | |
280 | ||
281 | typedef struct VMStateInfo VMStateInfo; | |
282 | typedef struct VMStateDescription VMStateDescription; | |
283 | ||
284 | struct VMStateInfo { | |
285 | const char *name; | |
286 | int (*get)(QEMUFile *f, void *pv, size_t size); | |
287 | void (*put)(QEMUFile *f, void *pv, size_t size); | |
288 | }; | |
289 | ||
290 | enum VMStateFlags { | |
291 | VMS_SINGLE = 0x001, | |
292 | VMS_POINTER = 0x002, | |
293 | VMS_ARRAY = 0x004, | |
294 | VMS_STRUCT = 0x008, | |
295 | VMS_VARRAY_INT32 = 0x010, /* Array with size in int32_t field*/ | |
296 | VMS_BUFFER = 0x020, /* static sized buffer */ | |
297 | VMS_ARRAY_OF_POINTER = 0x040, | |
298 | VMS_VARRAY_UINT16 = 0x080, /* Array with size in uint16_t field */ | |
299 | VMS_VBUFFER = 0x100, /* Buffer with size in int32_t field */ | |
300 | VMS_MULTIPLY = 0x200, /* multiply "size" field by field_size */ | |
301 | VMS_VARRAY_UINT8 = 0x400, /* Array with size in uint8_t field*/ | |
302 | VMS_VARRAY_UINT32 = 0x800, /* Array with size in uint32_t field*/ | |
303 | }; | |
304 | ||
305 | typedef struct { | |
306 | const char *name; | |
307 | size_t offset; | |
308 | size_t size; | |
309 | size_t start; | |
310 | int num; | |
311 | size_t num_offset; | |
312 | size_t size_offset; | |
313 | const VMStateInfo *info; | |
314 | enum VMStateFlags flags; | |
315 | const VMStateDescription *vmsd; | |
316 | int version_id; | |
317 | bool (*field_exists)(void *opaque, int version_id); | |
318 | } VMStateField; | |
319 | ||
320 | typedef struct VMStateSubsection { | |
321 | const VMStateDescription *vmsd; | |
322 | bool (*needed)(void *opaque); | |
323 | } VMStateSubsection; | |
324 | ||
325 | struct VMStateDescription { | |
326 | const char *name; | |
327 | int version_id; | |
328 | int minimum_version_id; | |
329 | int minimum_version_id_old; | |
330 | LoadStateHandler *load_state_old; | |
331 | int (*pre_load)(void *opaque); | |
332 | int (*post_load)(void *opaque, int version_id); | |
333 | void (*pre_save)(void *opaque); | |
334 | VMStateField *fields; | |
335 | const VMStateSubsection *subsections; | |
336 | }; | |
337 | ||
338 | extern const VMStateInfo vmstate_info_bool; | |
339 | ||
340 | extern const VMStateInfo vmstate_info_int8; | |
341 | extern const VMStateInfo vmstate_info_int16; | |
342 | extern const VMStateInfo vmstate_info_int32; | |
343 | extern const VMStateInfo vmstate_info_int64; | |
344 | ||
345 | extern const VMStateInfo vmstate_info_uint8_equal; | |
346 | extern const VMStateInfo vmstate_info_uint16_equal; | |
347 | extern const VMStateInfo vmstate_info_int32_equal; | |
348 | extern const VMStateInfo vmstate_info_uint32_equal; | |
349 | extern const VMStateInfo vmstate_info_int32_le; | |
350 | ||
351 | extern const VMStateInfo vmstate_info_uint8; | |
352 | extern const VMStateInfo vmstate_info_uint16; | |
353 | extern const VMStateInfo vmstate_info_uint32; | |
354 | extern const VMStateInfo vmstate_info_uint64; | |
355 | ||
356 | extern const VMStateInfo vmstate_info_timer; | |
357 | extern const VMStateInfo vmstate_info_ptimer; | |
358 | extern const VMStateInfo vmstate_info_buffer; | |
359 | extern const VMStateInfo vmstate_info_unused_buffer; | |
360 | ||
361 | #define type_check_array(t1,t2,n) ((t1(*)[n])0 - (t2*)0) | |
362 | #define type_check_pointer(t1,t2) ((t1**)0 - (t2*)0) | |
363 | ||
364 | #define vmstate_offset_value(_state, _field, _type) \ | |
365 | (offsetof(_state, _field) + \ | |
366 | type_check(_type, typeof_field(_state, _field))) | |
367 | ||
368 | #define vmstate_offset_pointer(_state, _field, _type) \ | |
369 | (offsetof(_state, _field) + \ | |
370 | type_check_pointer(_type, typeof_field(_state, _field))) | |
371 | ||
372 | #define vmstate_offset_array(_state, _field, _type, _num) \ | |
373 | (offsetof(_state, _field) + \ | |
374 | type_check_array(_type, typeof_field(_state, _field), _num)) | |
375 | ||
376 | #define vmstate_offset_sub_array(_state, _field, _type, _start) \ | |
377 | (offsetof(_state, _field[_start])) | |
378 | ||
379 | #define vmstate_offset_buffer(_state, _field) \ | |
380 | vmstate_offset_array(_state, _field, uint8_t, \ | |
381 | sizeof(typeof_field(_state, _field))) | |
382 | ||
383 | #define VMSTATE_SINGLE_TEST(_field, _state, _test, _version, _info, _type) { \ | |
384 | .name = (stringify(_field)), \ | |
385 | .version_id = (_version), \ | |
386 | .field_exists = (_test), \ | |
387 | .size = sizeof(_type), \ | |
388 | .info = &(_info), \ | |
389 | .flags = VMS_SINGLE, \ | |
390 | .offset = vmstate_offset_value(_state, _field, _type), \ | |
391 | } | |
392 | ||
393 | #define VMSTATE_POINTER(_field, _state, _version, _info, _type) { \ | |
394 | .name = (stringify(_field)), \ | |
395 | .version_id = (_version), \ | |
396 | .info = &(_info), \ | |
397 | .size = sizeof(_type), \ | |
398 | .flags = VMS_SINGLE|VMS_POINTER, \ | |
399 | .offset = vmstate_offset_value(_state, _field, _type), \ | |
400 | } | |
401 | ||
402 | #define VMSTATE_POINTER_TEST(_field, _state, _test, _info, _type) { \ | |
403 | .name = (stringify(_field)), \ | |
404 | .info = &(_info), \ | |
405 | .field_exists = (_test), \ | |
406 | .size = sizeof(_type), \ | |
407 | .flags = VMS_SINGLE|VMS_POINTER, \ | |
408 | .offset = vmstate_offset_value(_state, _field, _type), \ | |
409 | } | |
410 | ||
411 | #define VMSTATE_ARRAY(_field, _state, _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_array(_state, _field, _type, _num), \ | |
419 | } | |
420 | ||
421 | #define VMSTATE_ARRAY_TEST(_field, _state, _num, _test, _info, _type) {\ | |
422 | .name = (stringify(_field)), \ | |
423 | .field_exists = (_test), \ | |
424 | .num = (_num), \ | |
425 | .info = &(_info), \ | |
426 | .size = sizeof(_type), \ | |
427 | .flags = VMS_ARRAY, \ | |
428 | .offset = vmstate_offset_array(_state, _field, _type, _num),\ | |
429 | } | |
430 | ||
431 | #define VMSTATE_SUB_ARRAY(_field, _state, _start, _num, _version, _info, _type) { \ | |
432 | .name = (stringify(_field)), \ | |
433 | .version_id = (_version), \ | |
434 | .num = (_num), \ | |
435 | .info = &(_info), \ | |
436 | .size = sizeof(_type), \ | |
437 | .flags = VMS_ARRAY, \ | |
438 | .offset = vmstate_offset_sub_array(_state, _field, _type, _start), \ | |
439 | } | |
440 | ||
441 | #define VMSTATE_ARRAY_INT32_UNSAFE(_field, _state, _field_num, _info, _type) {\ | |
442 | .name = (stringify(_field)), \ | |
443 | .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \ | |
444 | .info = &(_info), \ | |
445 | .size = sizeof(_type), \ | |
446 | .flags = VMS_VARRAY_INT32, \ | |
447 | .offset = offsetof(_state, _field), \ | |
448 | } | |
449 | ||
450 | #define VMSTATE_VARRAY_INT32(_field, _state, _field_num, _version, _info, _type) {\ | |
451 | .name = (stringify(_field)), \ | |
452 | .version_id = (_version), \ | |
453 | .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \ | |
454 | .info = &(_info), \ | |
455 | .size = sizeof(_type), \ | |
456 | .flags = VMS_VARRAY_INT32|VMS_POINTER, \ | |
457 | .offset = vmstate_offset_pointer(_state, _field, _type), \ | |
458 | } | |
459 | ||
460 | #define VMSTATE_VARRAY_UINT32(_field, _state, _field_num, _version, _info, _type) {\ | |
461 | .name = (stringify(_field)), \ | |
462 | .version_id = (_version), \ | |
463 | .num_offset = vmstate_offset_value(_state, _field_num, uint32_t),\ | |
464 | .info = &(_info), \ | |
465 | .size = sizeof(_type), \ | |
466 | .flags = VMS_VARRAY_UINT32|VMS_POINTER, \ | |
467 | .offset = vmstate_offset_pointer(_state, _field, _type), \ | |
468 | } | |
469 | ||
470 | #define VMSTATE_VARRAY_UINT16_UNSAFE(_field, _state, _field_num, _version, _info, _type) {\ | |
471 | .name = (stringify(_field)), \ | |
472 | .version_id = (_version), \ | |
473 | .num_offset = vmstate_offset_value(_state, _field_num, uint16_t),\ | |
474 | .info = &(_info), \ | |
475 | .size = sizeof(_type), \ | |
476 | .flags = VMS_VARRAY_UINT16, \ | |
477 | .offset = offsetof(_state, _field), \ | |
478 | } | |
479 | ||
480 | #define VMSTATE_STRUCT_TEST(_field, _state, _test, _version, _vmsd, _type) { \ | |
481 | .name = (stringify(_field)), \ | |
482 | .version_id = (_version), \ | |
483 | .field_exists = (_test), \ | |
484 | .vmsd = &(_vmsd), \ | |
485 | .size = sizeof(_type), \ | |
486 | .flags = VMS_STRUCT, \ | |
487 | .offset = vmstate_offset_value(_state, _field, _type), \ | |
488 | } | |
489 | ||
490 | #define VMSTATE_STRUCT_POINTER_TEST(_field, _state, _test, _vmsd, _type) { \ | |
491 | .name = (stringify(_field)), \ | |
492 | .field_exists = (_test), \ | |
493 | .vmsd = &(_vmsd), \ | |
494 | .size = sizeof(_type), \ | |
495 | .flags = VMS_STRUCT|VMS_POINTER, \ | |
496 | .offset = vmstate_offset_value(_state, _field, _type), \ | |
497 | } | |
498 | ||
499 | #define VMSTATE_ARRAY_OF_POINTER(_field, _state, _num, _version, _info, _type) {\ | |
500 | .name = (stringify(_field)), \ | |
501 | .version_id = (_version), \ | |
502 | .num = (_num), \ | |
503 | .info = &(_info), \ | |
504 | .size = sizeof(_type), \ | |
505 | .flags = VMS_ARRAY|VMS_ARRAY_OF_POINTER, \ | |
506 | .offset = vmstate_offset_array(_state, _field, _type, _num), \ | |
507 | } | |
508 | ||
509 | #define VMSTATE_STRUCT_ARRAY_TEST(_field, _state, _num, _test, _version, _vmsd, _type) { \ | |
510 | .name = (stringify(_field)), \ | |
511 | .num = (_num), \ | |
512 | .field_exists = (_test), \ | |
513 | .version_id = (_version), \ | |
514 | .vmsd = &(_vmsd), \ | |
515 | .size = sizeof(_type), \ | |
516 | .flags = VMS_STRUCT|VMS_ARRAY, \ | |
517 | .offset = vmstate_offset_array(_state, _field, _type, _num),\ | |
518 | } | |
519 | ||
520 | #define VMSTATE_STRUCT_VARRAY_UINT8(_field, _state, _field_num, _version, _vmsd, _type) { \ | |
521 | .name = (stringify(_field)), \ | |
522 | .num_offset = vmstate_offset_value(_state, _field_num, uint8_t), \ | |
523 | .version_id = (_version), \ | |
524 | .vmsd = &(_vmsd), \ | |
525 | .size = sizeof(_type), \ | |
526 | .flags = VMS_STRUCT|VMS_VARRAY_UINT8, \ | |
527 | .offset = offsetof(_state, _field), \ | |
528 | } | |
529 | ||
530 | #define VMSTATE_STRUCT_VARRAY_POINTER_INT32(_field, _state, _field_num, _vmsd, _type) { \ | |
531 | .name = (stringify(_field)), \ | |
532 | .version_id = 0, \ | |
533 | .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \ | |
534 | .size = sizeof(_type), \ | |
535 | .vmsd = &(_vmsd), \ | |
536 | .flags = VMS_POINTER | VMS_VARRAY_INT32 | VMS_STRUCT, \ | |
537 | .offset = vmstate_offset_pointer(_state, _field, _type), \ | |
538 | } | |
539 | ||
540 | #define VMSTATE_STRUCT_VARRAY_POINTER_UINT16(_field, _state, _field_num, _vmsd, _type) { \ | |
541 | .name = (stringify(_field)), \ | |
542 | .version_id = 0, \ | |
543 | .num_offset = vmstate_offset_value(_state, _field_num, uint16_t),\ | |
544 | .size = sizeof(_type), \ | |
545 | .vmsd = &(_vmsd), \ | |
546 | .flags = VMS_POINTER | VMS_VARRAY_UINT16 | VMS_STRUCT, \ | |
547 | .offset = vmstate_offset_pointer(_state, _field, _type), \ | |
548 | } | |
549 | ||
550 | #define VMSTATE_STRUCT_VARRAY_INT32(_field, _state, _field_num, _version, _vmsd, _type) { \ | |
551 | .name = (stringify(_field)), \ | |
552 | .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \ | |
553 | .version_id = (_version), \ | |
554 | .vmsd = &(_vmsd), \ | |
555 | .size = sizeof(_type), \ | |
556 | .flags = VMS_STRUCT|VMS_VARRAY_INT32, \ | |
557 | .offset = offsetof(_state, _field), \ | |
558 | } | |
559 | ||
560 | #define VMSTATE_STRUCT_VARRAY_UINT32(_field, _state, _field_num, _version, _vmsd, _type) { \ | |
561 | .name = (stringify(_field)), \ | |
562 | .num_offset = vmstate_offset_value(_state, _field_num, uint32_t), \ | |
563 | .version_id = (_version), \ | |
564 | .vmsd = &(_vmsd), \ | |
565 | .size = sizeof(_type), \ | |
566 | .flags = VMS_STRUCT|VMS_VARRAY_UINT32, \ | |
567 | .offset = offsetof(_state, _field), \ | |
568 | } | |
569 | ||
570 | #define VMSTATE_STATIC_BUFFER(_field, _state, _version, _test, _start, _size) { \ | |
571 | .name = (stringify(_field)), \ | |
572 | .version_id = (_version), \ | |
573 | .field_exists = (_test), \ | |
574 | .size = (_size - _start), \ | |
575 | .info = &vmstate_info_buffer, \ | |
576 | .flags = VMS_BUFFER, \ | |
577 | .offset = vmstate_offset_buffer(_state, _field) + _start, \ | |
578 | } | |
579 | ||
580 | #define VMSTATE_BUFFER_MULTIPLY(_field, _state, _version, _test, _start, _field_size, _multiply) { \ | |
581 | .name = (stringify(_field)), \ | |
582 | .version_id = (_version), \ | |
583 | .field_exists = (_test), \ | |
584 | .size_offset = vmstate_offset_value(_state, _field_size, uint32_t),\ | |
585 | .size = (_multiply), \ | |
586 | .info = &vmstate_info_buffer, \ | |
587 | .flags = VMS_VBUFFER|VMS_MULTIPLY, \ | |
588 | .offset = offsetof(_state, _field), \ | |
589 | .start = (_start), \ | |
590 | } | |
591 | ||
592 | #define VMSTATE_VBUFFER(_field, _state, _version, _test, _start, _field_size) { \ | |
593 | .name = (stringify(_field)), \ | |
594 | .version_id = (_version), \ | |
595 | .field_exists = (_test), \ | |
596 | .size_offset = vmstate_offset_value(_state, _field_size, int32_t),\ | |
597 | .info = &vmstate_info_buffer, \ | |
598 | .flags = VMS_VBUFFER|VMS_POINTER, \ | |
599 | .offset = offsetof(_state, _field), \ | |
600 | .start = (_start), \ | |
601 | } | |
602 | ||
603 | #define VMSTATE_VBUFFER_UINT32(_field, _state, _version, _test, _start, _field_size) { \ | |
604 | .name = (stringify(_field)), \ | |
605 | .version_id = (_version), \ | |
606 | .field_exists = (_test), \ | |
607 | .size_offset = vmstate_offset_value(_state, _field_size, uint32_t),\ | |
608 | .info = &vmstate_info_buffer, \ | |
609 | .flags = VMS_VBUFFER|VMS_POINTER, \ | |
610 | .offset = offsetof(_state, _field), \ | |
611 | .start = (_start), \ | |
612 | } | |
613 | ||
614 | #define VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, _info, _size) { \ | |
615 | .name = (stringify(_field)), \ | |
616 | .version_id = (_version), \ | |
617 | .size = (_size), \ | |
618 | .info = &(_info), \ | |
619 | .flags = VMS_BUFFER, \ | |
620 | .offset = offsetof(_state, _field), \ | |
621 | } | |
622 | ||
623 | #define VMSTATE_UNUSED_BUFFER(_test, _version, _size) { \ | |
624 | .name = "unused", \ | |
625 | .field_exists = (_test), \ | |
626 | .version_id = (_version), \ | |
627 | .size = (_size), \ | |
628 | .info = &vmstate_info_unused_buffer, \ | |
629 | .flags = VMS_BUFFER, \ | |
630 | } | |
631 | extern const VMStateDescription vmstate_pci_device; | |
632 | ||
633 | #define VMSTATE_PCI_DEVICE(_field, _state) { \ | |
634 | .name = (stringify(_field)), \ | |
635 | .size = sizeof(PCIDevice), \ | |
636 | .vmsd = &vmstate_pci_device, \ | |
637 | .flags = VMS_STRUCT, \ | |
638 | .offset = vmstate_offset_value(_state, _field, PCIDevice), \ | |
639 | } | |
640 | ||
641 | #define VMSTATE_PCI_DEVICE_POINTER(_field, _state) { \ | |
642 | .name = (stringify(_field)), \ | |
643 | .size = sizeof(PCIDevice), \ | |
644 | .vmsd = &vmstate_pci_device, \ | |
645 | .flags = VMS_STRUCT|VMS_POINTER, \ | |
646 | .offset = vmstate_offset_pointer(_state, _field, PCIDevice), \ | |
647 | } | |
648 | ||
649 | extern const VMStateDescription vmstate_pcie_device; | |
650 | ||
651 | #define VMSTATE_PCIE_DEVICE(_field, _state) { \ | |
652 | .name = (stringify(_field)), \ | |
653 | .version_id = 2, \ | |
654 | .size = sizeof(PCIDevice), \ | |
655 | .vmsd = &vmstate_pcie_device, \ | |
656 | .flags = VMS_STRUCT, \ | |
657 | .offset = vmstate_offset_value(_state, _field, PCIDevice), \ | |
658 | } | |
659 | ||
660 | extern const VMStateDescription vmstate_i2c_slave; | |
661 | ||
662 | #define VMSTATE_I2C_SLAVE(_field, _state) { \ | |
663 | .name = (stringify(_field)), \ | |
664 | .size = sizeof(i2c_slave), \ | |
665 | .vmsd = &vmstate_i2c_slave, \ | |
666 | .flags = VMS_STRUCT, \ | |
667 | .offset = vmstate_offset_value(_state, _field, i2c_slave), \ | |
668 | } | |
669 | ||
670 | extern const VMStateDescription vmstate_usb_device; | |
671 | ||
672 | #define VMSTATE_USB_DEVICE(_field, _state) { \ | |
673 | .name = (stringify(_field)), \ | |
674 | .size = sizeof(USBDevice), \ | |
675 | .vmsd = &vmstate_usb_device, \ | |
676 | .flags = VMS_STRUCT, \ | |
677 | .offset = vmstate_offset_value(_state, _field, USBDevice), \ | |
678 | } | |
679 | ||
680 | #define vmstate_offset_macaddr(_state, _field) \ | |
681 | vmstate_offset_array(_state, _field.a, uint8_t, \ | |
682 | sizeof(typeof_field(_state, _field))) | |
683 | ||
684 | #define VMSTATE_MACADDR(_field, _state) { \ | |
685 | .name = (stringify(_field)), \ | |
686 | .size = sizeof(MACAddr), \ | |
687 | .info = &vmstate_info_buffer, \ | |
688 | .flags = VMS_BUFFER, \ | |
689 | .offset = vmstate_offset_macaddr(_state, _field), \ | |
690 | } | |
691 | ||
692 | extern const VMStateDescription vmstate_ptimer; | |
693 | ||
694 | #define VMSTATE_PTIMER(_field, _state) { \ | |
695 | .name = (stringify(_field)), \ | |
696 | .version_id = (1), \ | |
697 | .vmsd = &vmstate_ptimer, \ | |
698 | .size = sizeof(ptimer_state *), \ | |
699 | .flags = VMS_STRUCT|VMS_POINTER, \ | |
700 | .offset = vmstate_offset_pointer(_state, _field, ptimer_state), \ | |
701 | } | |
702 | ||
703 | /* _f : field name | |
704 | _f_n : num of elements field_name | |
705 | _n : num of elements | |
706 | _s : struct state name | |
707 | _v : version | |
708 | */ | |
709 | ||
710 | #define VMSTATE_SINGLE(_field, _state, _version, _info, _type) \ | |
711 | VMSTATE_SINGLE_TEST(_field, _state, NULL, _version, _info, _type) | |
712 | ||
713 | #define VMSTATE_STRUCT(_field, _state, _version, _vmsd, _type) \ | |
714 | VMSTATE_STRUCT_TEST(_field, _state, NULL, _version, _vmsd, _type) | |
715 | ||
716 | #define VMSTATE_STRUCT_POINTER(_field, _state, _vmsd, _type) \ | |
717 | VMSTATE_STRUCT_POINTER_TEST(_field, _state, NULL, _vmsd, _type) | |
718 | ||
719 | #define VMSTATE_STRUCT_ARRAY(_field, _state, _num, _version, _vmsd, _type) \ | |
720 | VMSTATE_STRUCT_ARRAY_TEST(_field, _state, _num, NULL, _version, \ | |
721 | _vmsd, _type) | |
722 | ||
723 | #define VMSTATE_BOOL_V(_f, _s, _v) \ | |
724 | VMSTATE_SINGLE(_f, _s, _v, vmstate_info_bool, bool) | |
725 | ||
726 | #define VMSTATE_INT8_V(_f, _s, _v) \ | |
727 | VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int8, int8_t) | |
728 | #define VMSTATE_INT16_V(_f, _s, _v) \ | |
729 | VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int16, int16_t) | |
730 | #define VMSTATE_INT32_V(_f, _s, _v) \ | |
731 | VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int32, int32_t) | |
732 | #define VMSTATE_INT64_V(_f, _s, _v) \ | |
733 | VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int64, int64_t) | |
734 | ||
735 | #define VMSTATE_UINT8_V(_f, _s, _v) \ | |
736 | VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint8, uint8_t) | |
737 | #define VMSTATE_UINT16_V(_f, _s, _v) \ | |
738 | VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint16, uint16_t) | |
739 | #define VMSTATE_UINT32_V(_f, _s, _v) \ | |
740 | VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint32, uint32_t) | |
741 | #define VMSTATE_UINT64_V(_f, _s, _v) \ | |
742 | VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint64, uint64_t) | |
743 | ||
744 | #define VMSTATE_BOOL(_f, _s) \ | |
745 | VMSTATE_BOOL_V(_f, _s, 0) | |
746 | ||
747 | #define VMSTATE_INT8(_f, _s) \ | |
748 | VMSTATE_INT8_V(_f, _s, 0) | |
749 | #define VMSTATE_INT16(_f, _s) \ | |
750 | VMSTATE_INT16_V(_f, _s, 0) | |
751 | #define VMSTATE_INT32(_f, _s) \ | |
752 | VMSTATE_INT32_V(_f, _s, 0) | |
753 | #define VMSTATE_INT64(_f, _s) \ | |
754 | VMSTATE_INT64_V(_f, _s, 0) | |
755 | ||
756 | #define VMSTATE_UINT8(_f, _s) \ | |
757 | VMSTATE_UINT8_V(_f, _s, 0) | |
758 | #define VMSTATE_UINT16(_f, _s) \ | |
759 | VMSTATE_UINT16_V(_f, _s, 0) | |
760 | #define VMSTATE_UINT32(_f, _s) \ | |
761 | VMSTATE_UINT32_V(_f, _s, 0) | |
762 | #define VMSTATE_UINT64(_f, _s) \ | |
763 | VMSTATE_UINT64_V(_f, _s, 0) | |
764 | ||
765 | #define VMSTATE_UINT8_EQUAL(_f, _s) \ | |
766 | VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint8_equal, uint8_t) | |
767 | ||
768 | #define VMSTATE_UINT16_EQUAL(_f, _s) \ | |
769 | VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint16_equal, uint16_t) | |
770 | ||
771 | #define VMSTATE_UINT16_EQUAL_V(_f, _s, _v) \ | |
772 | VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint16_equal, uint16_t) | |
773 | ||
774 | #define VMSTATE_INT32_EQUAL(_f, _s) \ | |
775 | VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_equal, int32_t) | |
776 | ||
777 | #define VMSTATE_UINT32_EQUAL(_f, _s) \ | |
778 | VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint32_equal, uint32_t) | |
779 | ||
780 | #define VMSTATE_INT32_LE(_f, _s) \ | |
781 | VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_le, int32_t) | |
782 | ||
783 | #define VMSTATE_UINT16_TEST(_f, _s, _t) \ | |
784 | VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint16, uint16_t) | |
785 | ||
786 | #define VMSTATE_UINT32_TEST(_f, _s, _t) \ | |
787 | VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint32, uint32_t) | |
788 | ||
789 | #define VMSTATE_TIMER_TEST(_f, _s, _test) \ | |
790 | VMSTATE_POINTER_TEST(_f, _s, _test, vmstate_info_timer, QEMUTimer *) | |
791 | ||
792 | #define VMSTATE_TIMER(_f, _s) \ | |
793 | VMSTATE_TIMER_TEST(_f, _s, NULL) | |
794 | ||
795 | #define VMSTATE_TIMER_ARRAY(_f, _s, _n) \ | |
796 | VMSTATE_ARRAY_OF_POINTER(_f, _s, _n, 0, vmstate_info_timer, QEMUTimer *) | |
797 | ||
798 | #define VMSTATE_BOOL_ARRAY_V(_f, _s, _n, _v) \ | |
799 | VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_bool, bool) | |
800 | ||
801 | #define VMSTATE_BOOL_ARRAY(_f, _s, _n) \ | |
802 | VMSTATE_BOOL_ARRAY_V(_f, _s, _n, 0) | |
803 | ||
804 | #define VMSTATE_UINT16_ARRAY_V(_f, _s, _n, _v) \ | |
805 | VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint16, uint16_t) | |
806 | ||
807 | #define VMSTATE_UINT16_ARRAY(_f, _s, _n) \ | |
808 | VMSTATE_UINT16_ARRAY_V(_f, _s, _n, 0) | |
809 | ||
810 | #define VMSTATE_UINT8_ARRAY_V(_f, _s, _n, _v) \ | |
811 | VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint8, uint8_t) | |
812 | ||
813 | #define VMSTATE_UINT8_ARRAY(_f, _s, _n) \ | |
814 | VMSTATE_UINT8_ARRAY_V(_f, _s, _n, 0) | |
815 | ||
816 | #define VMSTATE_UINT32_ARRAY_V(_f, _s, _n, _v) \ | |
817 | VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint32, uint32_t) | |
818 | ||
819 | #define VMSTATE_UINT32_ARRAY(_f, _s, _n) \ | |
820 | VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0) | |
821 | ||
822 | #define VMSTATE_UINT64_ARRAY_V(_f, _s, _n, _v) \ | |
823 | VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint64, uint64_t) | |
824 | ||
825 | #define VMSTATE_UINT64_ARRAY(_f, _s, _n) \ | |
826 | VMSTATE_UINT64_ARRAY_V(_f, _s, _n, 0) | |
827 | ||
828 | #define VMSTATE_INT16_ARRAY_V(_f, _s, _n, _v) \ | |
829 | VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int16, int16_t) | |
830 | ||
831 | #define VMSTATE_INT16_ARRAY(_f, _s, _n) \ | |
832 | VMSTATE_INT16_ARRAY_V(_f, _s, _n, 0) | |
833 | ||
834 | #define VMSTATE_INT32_ARRAY_V(_f, _s, _n, _v) \ | |
835 | VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int32, int32_t) | |
836 | ||
837 | #define VMSTATE_INT32_ARRAY(_f, _s, _n) \ | |
838 | VMSTATE_INT32_ARRAY_V(_f, _s, _n, 0) | |
839 | ||
840 | #define VMSTATE_UINT32_SUB_ARRAY(_f, _s, _start, _num) \ | |
841 | VMSTATE_SUB_ARRAY(_f, _s, _start, _num, 0, vmstate_info_uint32, uint32_t) | |
842 | ||
843 | #define VMSTATE_UINT32_ARRAY(_f, _s, _n) \ | |
844 | VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0) | |
845 | ||
846 | #define VMSTATE_INT64_ARRAY_V(_f, _s, _n, _v) \ | |
847 | VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int64, int64_t) | |
848 | ||
849 | #define VMSTATE_INT64_ARRAY(_f, _s, _n) \ | |
850 | VMSTATE_INT64_ARRAY_V(_f, _s, _n, 0) | |
851 | ||
852 | #define VMSTATE_BUFFER_V(_f, _s, _v) \ | |
853 | VMSTATE_STATIC_BUFFER(_f, _s, _v, NULL, 0, sizeof(typeof_field(_s, _f))) | |
854 | ||
855 | #define VMSTATE_BUFFER(_f, _s) \ | |
856 | VMSTATE_BUFFER_V(_f, _s, 0) | |
857 | ||
858 | #define VMSTATE_PARTIAL_BUFFER(_f, _s, _size) \ | |
859 | VMSTATE_STATIC_BUFFER(_f, _s, 0, NULL, 0, _size) | |
860 | ||
861 | #define VMSTATE_BUFFER_START_MIDDLE(_f, _s, _start) \ | |
862 | VMSTATE_STATIC_BUFFER(_f, _s, 0, NULL, _start, sizeof(typeof_field(_s, _f))) | |
863 | ||
864 | #define VMSTATE_PARTIAL_VBUFFER(_f, _s, _size) \ | |
865 | VMSTATE_VBUFFER(_f, _s, 0, NULL, 0, _size) | |
866 | ||
867 | #define VMSTATE_PARTIAL_VBUFFER_UINT32(_f, _s, _size) \ | |
868 | VMSTATE_VBUFFER_UINT32(_f, _s, 0, NULL, 0, _size) | |
869 | ||
870 | #define VMSTATE_SUB_VBUFFER(_f, _s, _start, _size) \ | |
871 | VMSTATE_VBUFFER(_f, _s, 0, NULL, _start, _size) | |
872 | ||
873 | #define VMSTATE_BUFFER_TEST(_f, _s, _test) \ | |
874 | VMSTATE_STATIC_BUFFER(_f, _s, 0, _test, 0, sizeof(typeof_field(_s, _f))) | |
875 | ||
876 | #define VMSTATE_BUFFER_UNSAFE(_field, _state, _version, _size) \ | |
877 | VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, vmstate_info_buffer, _size) | |
878 | ||
879 | #define VMSTATE_UNUSED_V(_v, _size) \ | |
880 | VMSTATE_UNUSED_BUFFER(NULL, _v, _size) | |
881 | ||
882 | #define VMSTATE_UNUSED(_size) \ | |
883 | VMSTATE_UNUSED_V(0, _size) | |
884 | ||
885 | #define VMSTATE_UNUSED_TEST(_test, _size) \ | |
886 | VMSTATE_UNUSED_BUFFER(_test, 0, _size) | |
887 | ||
888 | #ifdef NEED_CPU_H | |
889 | #if TARGET_LONG_BITS == 64 | |
890 | #define VMSTATE_UINTTL_V(_f, _s, _v) \ | |
891 | VMSTATE_UINT64_V(_f, _s, _v) | |
892 | #define VMSTATE_UINTTL_ARRAY_V(_f, _s, _n, _v) \ | |
893 | VMSTATE_UINT64_ARRAY_V(_f, _s, _n, _v) | |
894 | #else | |
895 | #define VMSTATE_UINTTL_V(_f, _s, _v) \ | |
896 | VMSTATE_UINT32_V(_f, _s, _v) | |
897 | #define VMSTATE_UINTTL_ARRAY_V(_f, _s, _n, _v) \ | |
898 | VMSTATE_UINT32_ARRAY_V(_f, _s, _n, _v) | |
899 | #endif | |
900 | #define VMSTATE_UINTTL(_f, _s) \ | |
901 | VMSTATE_UINTTL_V(_f, _s, 0) | |
902 | #define VMSTATE_UINTTL_ARRAY(_f, _s, _n) \ | |
903 | VMSTATE_UINTTL_ARRAY_V(_f, _s, _n, 0) | |
904 | ||
905 | #endif | |
906 | ||
907 | #define VMSTATE_END_OF_LIST() \ | |
908 | {} | |
909 | ||
910 | int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd, | |
911 | void *opaque, int version_id); | |
912 | void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd, | |
913 | void *opaque); | |
914 | int vmstate_register(DeviceState *dev, int instance_id, | |
915 | const VMStateDescription *vmsd, void *base); | |
916 | int vmstate_register_with_alias_id(DeviceState *dev, int instance_id, | |
917 | const VMStateDescription *vmsd, | |
918 | void *base, int alias_id, | |
919 | int required_for_version); | |
920 | void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd, | |
921 | void *opaque); | |
922 | #endif |