]> git.proxmox.com Git - qemu.git/blame - vmstate.h
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
sun4u: implement interrupt clearing registers
[qemu.git] / vmstate.h
CommitLineData
701a8f76
PB		 1/*
2 * QEMU migration/snapshot declarations
3 *
4 * Copyright (c) 2009-2011 Red Hat, Inc.
5 *
6 * Original author: Juan Quintela <quintela@redhat.com>
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 * THE SOFTWARE.
25 */
26#ifndef QEMU_VMSTATE_H
27#define QEMU_VMSTATE_H 1
28
29typedef void SaveSetParamsHandler(int blk_enable, int shared, void * opaque);
30typedef void SaveStateHandler(QEMUFile *f, void *opaque);
539de124 31typedef int SaveLiveStateHandler(QEMUFile *f, int stage, void *opaque);
701a8f76
PB		 32typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id);
33
34int register_savevm(DeviceState *dev,
35 const char *idstr,
36 int instance_id,
37 int version_id,
38 SaveStateHandler *save_state,
39 LoadStateHandler *load_state,
40 void *opaque);
41
42int register_savevm_live(DeviceState *dev,
43 const char *idstr,
44 int instance_id,
45 int version_id,
46 SaveSetParamsHandler *set_params,
47 SaveLiveStateHandler *save_live_state,
48 SaveStateHandler *save_state,
49 LoadStateHandler *load_state,
50 void *opaque);
51
52void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque);
53void register_device_unmigratable(DeviceState *dev, const char *idstr,
54 void *opaque);
55
56
57typedef struct VMStateInfo VMStateInfo;
58typedef struct VMStateDescription VMStateDescription;
59
60struct VMStateInfo {
61 const char *name;
62 int (*get)(QEMUFile *f, void *pv, size_t size);
63 void (*put)(QEMUFile *f, void *pv, size_t size);
64};
65
66enum VMStateFlags {
67 VMS_SINGLE = 0x001,
68 VMS_POINTER = 0x002,
69 VMS_ARRAY = 0x004,
70 VMS_STRUCT = 0x008,
71 VMS_VARRAY_INT32 = 0x010, /* Array with size in int32_t field*/
72 VMS_BUFFER = 0x020, /* static sized buffer */
73 VMS_ARRAY_OF_POINTER = 0x040,
74 VMS_VARRAY_UINT16 = 0x080, /* Array with size in uint16_t field */
75 VMS_VBUFFER = 0x100, /* Buffer with size in int32_t field */
76 VMS_MULTIPLY = 0x200, /* multiply "size" field by field_size */
77 VMS_VARRAY_UINT8 = 0x400, /* Array with size in uint8_t field*/
78 VMS_VARRAY_UINT32 = 0x800, /* Array with size in uint32_t field*/
79};
80
81typedef struct {
82 const char *name;
83 size_t offset;
84 size_t size;
85 size_t start;
86 int num;
87 size_t num_offset;
88 size_t size_offset;
89 const VMStateInfo *info;
90 enum VMStateFlags flags;
91 const VMStateDescription *vmsd;
92 int version_id;
93 bool (*field_exists)(void *opaque, int version_id);
94} VMStateField;
95
96typedef struct VMStateSubsection {
97 const VMStateDescription *vmsd;
98 bool (*needed)(void *opaque);
99} VMStateSubsection;
100
101struct VMStateDescription {
102 const char *name;
103 int unmigratable;
104 int version_id;
105 int minimum_version_id;
106 int minimum_version_id_old;
107 LoadStateHandler *load_state_old;
108 int (*pre_load)(void *opaque);
109 int (*post_load)(void *opaque, int version_id);
110 void (*pre_save)(void *opaque);
111 VMStateField *fields;
112 const VMStateSubsection *subsections;
113};
114
115extern const VMStateInfo vmstate_info_bool;
116
117extern const VMStateInfo vmstate_info_int8;
118extern const VMStateInfo vmstate_info_int16;
119extern const VMStateInfo vmstate_info_int32;
120extern const VMStateInfo vmstate_info_int64;
121
122extern const VMStateInfo vmstate_info_uint8_equal;
123extern const VMStateInfo vmstate_info_uint16_equal;
124extern const VMStateInfo vmstate_info_int32_equal;
125extern const VMStateInfo vmstate_info_uint32_equal;
126extern const VMStateInfo vmstate_info_int32_le;
127
128extern const VMStateInfo vmstate_info_uint8;
129extern const VMStateInfo vmstate_info_uint16;
130extern const VMStateInfo vmstate_info_uint32;
131extern const VMStateInfo vmstate_info_uint64;
132
133extern const VMStateInfo vmstate_info_timer;
134extern const VMStateInfo vmstate_info_buffer;
135extern const VMStateInfo vmstate_info_unused_buffer;
136
137#define type_check_array(t1,t2,n) ((t1(*)[n])0 - (t2*)0)
138#define type_check_pointer(t1,t2) ((t1**)0 - (t2*)0)
139
140#define vmstate_offset_value(_state, _field, _type) \
141 (offsetof(_state, _field) + \
142 type_check(_type, typeof_field(_state, _field)))
143
144#define vmstate_offset_pointer(_state, _field, _type) \
145 (offsetof(_state, _field) + \
146 type_check_pointer(_type, typeof_field(_state, _field)))
147
148#define vmstate_offset_array(_state, _field, _type, _num) \
149 (offsetof(_state, _field) + \
150 type_check_array(_type, typeof_field(_state, _field), _num))
151
152#define vmstate_offset_sub_array(_state, _field, _type, _start) \
153 (offsetof(_state, _field[_start]))
154
155#define vmstate_offset_buffer(_state, _field) \
156 vmstate_offset_array(_state, _field, uint8_t, \
157 sizeof(typeof_field(_state, _field)))
158
159#define VMSTATE_SINGLE_TEST(_field, _state, _test, _version, _info, _type) { \
160 .name = (stringify(_field)), \
161 .version_id = (_version), \
162 .field_exists = (_test), \
163 .size = sizeof(_type), \
164 .info = &(_info), \
165 .flags = VMS_SINGLE, \
166 .offset = vmstate_offset_value(_state, _field, _type), \
167}
168
169#define VMSTATE_POINTER(_field, _state, _version, _info, _type) { \
170 .name = (stringify(_field)), \
171 .version_id = (_version), \
172 .info = &(_info), \
173 .size = sizeof(_type), \
174 .flags = VMS_SINGLE|VMS_POINTER, \
175 .offset = vmstate_offset_value(_state, _field, _type), \
176}
177
178#define VMSTATE_POINTER_TEST(_field, _state, _test, _info, _type) { \
179 .name = (stringify(_field)), \
180 .info = &(_info), \
181 .field_exists = (_test), \
182 .size = sizeof(_type), \
183 .flags = VMS_SINGLE|VMS_POINTER, \
184 .offset = vmstate_offset_value(_state, _field, _type), \
185}
186
187#define VMSTATE_ARRAY(_field, _state, _num, _version, _info, _type) {\
188 .name = (stringify(_field)), \
189 .version_id = (_version), \
190 .num = (_num), \
191 .info = &(_info), \
192 .size = sizeof(_type), \
193 .flags = VMS_ARRAY, \
194 .offset = vmstate_offset_array(_state, _field, _type, _num), \
195}
196
197#define VMSTATE_ARRAY_TEST(_field, _state, _num, _test, _info, _type) {\
198 .name = (stringify(_field)), \
199 .field_exists = (_test), \
200 .num = (_num), \
201 .info = &(_info), \
202 .size = sizeof(_type), \
203 .flags = VMS_ARRAY, \
204 .offset = vmstate_offset_array(_state, _field, _type, _num),\
205}
206
207#define VMSTATE_SUB_ARRAY(_field, _state, _start, _num, _version, _info, _type) { \
208 .name = (stringify(_field)), \
209 .version_id = (_version), \
210 .num = (_num), \
211 .info = &(_info), \
212 .size = sizeof(_type), \
213 .flags = VMS_ARRAY, \
214 .offset = vmstate_offset_sub_array(_state, _field, _type, _start), \
215}
216
217#define VMSTATE_ARRAY_INT32_UNSAFE(_field, _state, _field_num, _info, _type) {\
218 .name = (stringify(_field)), \
219 .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \
220 .info = &(_info), \
221 .size = sizeof(_type), \
222 .flags = VMS_VARRAY_INT32, \
223 .offset = offsetof(_state, _field), \
224}
225
226#define VMSTATE_VARRAY_INT32(_field, _state, _field_num, _version, _info, _type) {\
227 .name = (stringify(_field)), \
228 .version_id = (_version), \
229 .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \
230 .info = &(_info), \
231 .size = sizeof(_type), \
232 .flags = VMS_VARRAY_INT32|VMS_POINTER, \
233 .offset = vmstate_offset_pointer(_state, _field, _type), \
234}
235
236#define VMSTATE_VARRAY_UINT32(_field, _state, _field_num, _version, _info, _type) {\
237 .name = (stringify(_field)), \
238 .version_id = (_version), \
239 .num_offset = vmstate_offset_value(_state, _field_num, uint32_t),\
240 .info = &(_info), \
241 .size = sizeof(_type), \
242 .flags = VMS_VARRAY_UINT32|VMS_POINTER, \
243 .offset = vmstate_offset_pointer(_state, _field, _type), \
244}
245
246#define VMSTATE_VARRAY_UINT16_UNSAFE(_field, _state, _field_num, _version, _info, _type) {\
247 .name = (stringify(_field)), \
248 .version_id = (_version), \
249 .num_offset = vmstate_offset_value(_state, _field_num, uint16_t),\
250 .info = &(_info), \
251 .size = sizeof(_type), \
252 .flags = VMS_VARRAY_UINT16, \
253 .offset = offsetof(_state, _field), \
254}
255
256#define VMSTATE_STRUCT_TEST(_field, _state, _test, _version, _vmsd, _type) { \
257 .name = (stringify(_field)), \
258 .version_id = (_version), \
259 .field_exists = (_test), \
260 .vmsd = &(_vmsd), \
261 .size = sizeof(_type), \
262 .flags = VMS_STRUCT, \
263 .offset = vmstate_offset_value(_state, _field, _type), \
264}
265
266#define VMSTATE_STRUCT_POINTER_TEST(_field, _state, _test, _vmsd, _type) { \
267 .name = (stringify(_field)), \
268 .field_exists = (_test), \
269 .vmsd = &(_vmsd), \
270 .size = sizeof(_type), \
271 .flags = VMS_STRUCT|VMS_POINTER, \
272 .offset = vmstate_offset_value(_state, _field, _type), \
273}
274
275#define VMSTATE_ARRAY_OF_POINTER(_field, _state, _num, _version, _info, _type) {\
276 .name = (stringify(_field)), \
277 .version_id = (_version), \
278 .num = (_num), \
279 .info = &(_info), \
280 .size = sizeof(_type), \
281 .flags = VMS_ARRAY|VMS_ARRAY_OF_POINTER, \
282 .offset = vmstate_offset_array(_state, _field, _type, _num), \
283}
284
285#define VMSTATE_STRUCT_ARRAY_TEST(_field, _state, _num, _test, _version, _vmsd, _type) { \
286 .name = (stringify(_field)), \
287 .num = (_num), \
288 .field_exists = (_test), \
289 .version_id = (_version), \
290 .vmsd = &(_vmsd), \
291 .size = sizeof(_type), \
292 .flags = VMS_STRUCT|VMS_ARRAY, \
293 .offset = vmstate_offset_array(_state, _field, _type, _num),\
294}
295
296#define VMSTATE_STRUCT_VARRAY_UINT8(_field, _state, _field_num, _version, _vmsd, _type) { \
297 .name = (stringify(_field)), \
298 .num_offset = vmstate_offset_value(_state, _field_num, uint8_t), \
299 .version_id = (_version), \
300 .vmsd = &(_vmsd), \
301 .size = sizeof(_type), \
302 .flags = VMS_STRUCT|VMS_VARRAY_UINT8, \
303 .offset = offsetof(_state, _field), \
304}
305
306#define VMSTATE_STRUCT_VARRAY_POINTER_INT32(_field, _state, _field_num, _vmsd, _type) { \
307 .name = (stringify(_field)), \
308 .version_id = 0, \
309 .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \
310 .size = sizeof(_type), \
311 .vmsd = &(_vmsd), \
312 .flags = VMS_POINTER | VMS_VARRAY_INT32 | VMS_STRUCT, \
313 .offset = vmstate_offset_pointer(_state, _field, _type), \
314}
315
316#define VMSTATE_STRUCT_VARRAY_POINTER_UINT16(_field, _state, _field_num, _vmsd, _type) { \
317 .name = (stringify(_field)), \
318 .version_id = 0, \
319 .num_offset = vmstate_offset_value(_state, _field_num, uint16_t),\
320 .size = sizeof(_type), \
321 .vmsd = &(_vmsd), \
322 .flags = VMS_POINTER | VMS_VARRAY_UINT16 | VMS_STRUCT, \
323 .offset = vmstate_offset_pointer(_state, _field, _type), \
324}
325
326#define VMSTATE_STRUCT_VARRAY_INT32(_field, _state, _field_num, _version, _vmsd, _type) { \
327 .name = (stringify(_field)), \
328 .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \
329 .version_id = (_version), \
330 .vmsd = &(_vmsd), \
331 .size = sizeof(_type), \
332 .flags = VMS_STRUCT|VMS_VARRAY_INT32, \
333 .offset = offsetof(_state, _field), \
334}
335
336#define VMSTATE_STRUCT_VARRAY_UINT32(_field, _state, _field_num, _version, _vmsd, _type) { \
337 .name = (stringify(_field)), \
338 .num_offset = vmstate_offset_value(_state, _field_num, uint32_t), \
339 .version_id = (_version), \
340 .vmsd = &(_vmsd), \
341 .size = sizeof(_type), \
342 .flags = VMS_STRUCT|VMS_VARRAY_UINT32, \
343 .offset = offsetof(_state, _field), \
344}
345
346#define VMSTATE_STATIC_BUFFER(_field, _state, _version, _test, _start, _size) { \
347 .name = (stringify(_field)), \
348 .version_id = (_version), \
349 .field_exists = (_test), \
350 .size = (_size - _start), \
351 .info = &vmstate_info_buffer, \
352 .flags = VMS_BUFFER, \
353 .offset = vmstate_offset_buffer(_state, _field) + _start, \
354}
355
356#define VMSTATE_BUFFER_MULTIPLY(_field, _state, _version, _test, _start, _field_size, _multiply) { \
357 .name = (stringify(_field)), \
358 .version_id = (_version), \
359 .field_exists = (_test), \
360 .size_offset = vmstate_offset_value(_state, _field_size, uint32_t),\
361 .size = (_multiply), \
362 .info = &vmstate_info_buffer, \
363 .flags = VMS_VBUFFER|VMS_MULTIPLY, \
364 .offset = offsetof(_state, _field), \
365 .start = (_start), \
366}
367
368#define VMSTATE_VBUFFER(_field, _state, _version, _test, _start, _field_size) { \
369 .name = (stringify(_field)), \
370 .version_id = (_version), \
371 .field_exists = (_test), \
372 .size_offset = vmstate_offset_value(_state, _field_size, int32_t),\
373 .info = &vmstate_info_buffer, \
374 .flags = VMS_VBUFFER|VMS_POINTER, \
375 .offset = offsetof(_state, _field), \
376 .start = (_start), \
377}
378
379#define VMSTATE_VBUFFER_UINT32(_field, _state, _version, _test, _start, _field_size) { \
380 .name = (stringify(_field)), \
381 .version_id = (_version), \
382 .field_exists = (_test), \
383 .size_offset = vmstate_offset_value(_state, _field_size, uint32_t),\
384 .info = &vmstate_info_buffer, \
385 .flags = VMS_VBUFFER|VMS_POINTER, \
386 .offset = offsetof(_state, _field), \
387 .start = (_start), \
388}
389
390#define VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, _info, _size) { \
391 .name = (stringify(_field)), \
392 .version_id = (_version), \
393 .size = (_size), \
394 .info = &(_info), \
395 .flags = VMS_BUFFER, \
396 .offset = offsetof(_state, _field), \
397}
398
399#define VMSTATE_UNUSED_BUFFER(_test, _version, _size) { \
400 .name = "unused", \
401 .field_exists = (_test), \
402 .version_id = (_version), \
403 .size = (_size), \
404 .info = &vmstate_info_unused_buffer, \
405 .flags = VMS_BUFFER, \
406}
407
408/* _f : field name
409 _f_n : num of elements field_name
410 _n : num of elements
411 _s : struct state name
412 _v : version
413*/
414
415#define VMSTATE_SINGLE(_field, _state, _version, _info, _type) \
416 VMSTATE_SINGLE_TEST(_field, _state, NULL, _version, _info, _type)
417
418#define VMSTATE_STRUCT(_field, _state, _version, _vmsd, _type) \
419 VMSTATE_STRUCT_TEST(_field, _state, NULL, _version, _vmsd, _type)
420
421#define VMSTATE_STRUCT_POINTER(_field, _state, _vmsd, _type) \
422 VMSTATE_STRUCT_POINTER_TEST(_field, _state, NULL, _vmsd, _type)
423
424#define VMSTATE_STRUCT_ARRAY(_field, _state, _num, _version, _vmsd, _type) \
425 VMSTATE_STRUCT_ARRAY_TEST(_field, _state, _num, NULL, _version, \
426 _vmsd, _type)
427
428#define VMSTATE_BOOL_V(_f, _s, _v) \
429 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_bool, bool)
430
431#define VMSTATE_INT8_V(_f, _s, _v) \
432 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int8, int8_t)
433#define VMSTATE_INT16_V(_f, _s, _v) \
434 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int16, int16_t)
435#define VMSTATE_INT32_V(_f, _s, _v) \
436 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int32, int32_t)
437#define VMSTATE_INT64_V(_f, _s, _v) \
438 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int64, int64_t)
439
440#define VMSTATE_UINT8_V(_f, _s, _v) \
441 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint8, uint8_t)
442#define VMSTATE_UINT16_V(_f, _s, _v) \
443 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint16, uint16_t)
444#define VMSTATE_UINT32_V(_f, _s, _v) \
445 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint32, uint32_t)
446#define VMSTATE_UINT64_V(_f, _s, _v) \
447 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint64, uint64_t)
448
449#define VMSTATE_BOOL(_f, _s) \
450 VMSTATE_BOOL_V(_f, _s, 0)
451
452#define VMSTATE_INT8(_f, _s) \
453 VMSTATE_INT8_V(_f, _s, 0)
454#define VMSTATE_INT16(_f, _s) \
455 VMSTATE_INT16_V(_f, _s, 0)
456#define VMSTATE_INT32(_f, _s) \
457 VMSTATE_INT32_V(_f, _s, 0)
458#define VMSTATE_INT64(_f, _s) \
459 VMSTATE_INT64_V(_f, _s, 0)
460
461#define VMSTATE_UINT8(_f, _s) \
462 VMSTATE_UINT8_V(_f, _s, 0)
463#define VMSTATE_UINT16(_f, _s) \
464 VMSTATE_UINT16_V(_f, _s, 0)
465#define VMSTATE_UINT32(_f, _s) \
466 VMSTATE_UINT32_V(_f, _s, 0)
467#define VMSTATE_UINT64(_f, _s) \
468 VMSTATE_UINT64_V(_f, _s, 0)
469
470#define VMSTATE_UINT8_EQUAL(_f, _s) \
471 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint8_equal, uint8_t)
472
473#define VMSTATE_UINT16_EQUAL(_f, _s) \
474 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint16_equal, uint16_t)
475
476#define VMSTATE_UINT16_EQUAL_V(_f, _s, _v) \
477 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint16_equal, uint16_t)
478
479#define VMSTATE_INT32_EQUAL(_f, _s) \
480 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_equal, int32_t)
481
482#define VMSTATE_UINT32_EQUAL(_f, _s) \
483 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint32_equal, uint32_t)
484
485#define VMSTATE_INT32_LE(_f, _s) \
486 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_le, int32_t)
487
488#define VMSTATE_UINT8_TEST(_f, _s, _t) \
489 VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint8, uint8_t)
490
491#define VMSTATE_UINT16_TEST(_f, _s, _t) \
492 VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint16, uint16_t)
493
494#define VMSTATE_UINT32_TEST(_f, _s, _t) \
495 VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint32, uint32_t)
496
497#define VMSTATE_TIMER_TEST(_f, _s, _test) \
498 VMSTATE_POINTER_TEST(_f, _s, _test, vmstate_info_timer, QEMUTimer *)
499
500#define VMSTATE_TIMER(_f, _s) \
501 VMSTATE_TIMER_TEST(_f, _s, NULL)
502
503#define VMSTATE_TIMER_ARRAY(_f, _s, _n) \
504 VMSTATE_ARRAY_OF_POINTER(_f, _s, _n, 0, vmstate_info_timer, QEMUTimer *)
505
506#define VMSTATE_BOOL_ARRAY_V(_f, _s, _n, _v) \
507 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_bool, bool)
508
509#define VMSTATE_BOOL_ARRAY(_f, _s, _n) \
510 VMSTATE_BOOL_ARRAY_V(_f, _s, _n, 0)
511
512#define VMSTATE_UINT16_ARRAY_V(_f, _s, _n, _v) \
513 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint16, uint16_t)
514
515#define VMSTATE_UINT16_ARRAY(_f, _s, _n) \
516 VMSTATE_UINT16_ARRAY_V(_f, _s, _n, 0)
517
518#define VMSTATE_UINT8_ARRAY_V(_f, _s, _n, _v) \
519 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint8, uint8_t)
520
521#define VMSTATE_UINT8_ARRAY(_f, _s, _n) \
522 VMSTATE_UINT8_ARRAY_V(_f, _s, _n, 0)
523
524#define VMSTATE_UINT32_ARRAY_V(_f, _s, _n, _v) \
525 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint32, uint32_t)
526
527#define VMSTATE_UINT32_ARRAY(_f, _s, _n) \
528 VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0)
529
530#define VMSTATE_UINT64_ARRAY_V(_f, _s, _n, _v) \
531 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint64, uint64_t)
532
533#define VMSTATE_UINT64_ARRAY(_f, _s, _n) \
534 VMSTATE_UINT64_ARRAY_V(_f, _s, _n, 0)
535
536#define VMSTATE_INT16_ARRAY_V(_f, _s, _n, _v) \
537 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int16, int16_t)
538
539#define VMSTATE_INT16_ARRAY(_f, _s, _n) \
540 VMSTATE_INT16_ARRAY_V(_f, _s, _n, 0)
541
542#define VMSTATE_INT32_ARRAY_V(_f, _s, _n, _v) \
543 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int32, int32_t)
544
545#define VMSTATE_INT32_ARRAY(_f, _s, _n) \
546 VMSTATE_INT32_ARRAY_V(_f, _s, _n, 0)
547
548#define VMSTATE_UINT32_SUB_ARRAY(_f, _s, _start, _num) \
549 VMSTATE_SUB_ARRAY(_f, _s, _start, _num, 0, vmstate_info_uint32, uint32_t)
550
551#define VMSTATE_UINT32_ARRAY(_f, _s, _n) \
552 VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0)
553
554#define VMSTATE_INT64_ARRAY_V(_f, _s, _n, _v) \
555 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int64, int64_t)
556
557#define VMSTATE_INT64_ARRAY(_f, _s, _n) \
558 VMSTATE_INT64_ARRAY_V(_f, _s, _n, 0)
559
560#define VMSTATE_BUFFER_V(_f, _s, _v) \
561 VMSTATE_STATIC_BUFFER(_f, _s, _v, NULL, 0, sizeof(typeof_field(_s, _f)))
562
563#define VMSTATE_BUFFER(_f, _s) \
564 VMSTATE_BUFFER_V(_f, _s, 0)
565
566#define VMSTATE_PARTIAL_BUFFER(_f, _s, _size) \
567 VMSTATE_STATIC_BUFFER(_f, _s, 0, NULL, 0, _size)
568
569#define VMSTATE_BUFFER_START_MIDDLE(_f, _s, _start) \
570 VMSTATE_STATIC_BUFFER(_f, _s, 0, NULL, _start, sizeof(typeof_field(_s, _f)))
571
572#define VMSTATE_PARTIAL_VBUFFER(_f, _s, _size) \
573 VMSTATE_VBUFFER(_f, _s, 0, NULL, 0, _size)
574
575#define VMSTATE_PARTIAL_VBUFFER_UINT32(_f, _s, _size) \
576 VMSTATE_VBUFFER_UINT32(_f, _s, 0, NULL, 0, _size)
577
578#define VMSTATE_SUB_VBUFFER(_f, _s, _start, _size) \
579 VMSTATE_VBUFFER(_f, _s, 0, NULL, _start, _size)
580
581#define VMSTATE_BUFFER_TEST(_f, _s, _test) \
582 VMSTATE_STATIC_BUFFER(_f, _s, 0, _test, 0, sizeof(typeof_field(_s, _f)))
583
584#define VMSTATE_BUFFER_UNSAFE(_field, _state, _version, _size) \
585 VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, vmstate_info_buffer, _size)
586
587#define VMSTATE_UNUSED_V(_v, _size) \
588 VMSTATE_UNUSED_BUFFER(NULL, _v, _size)
589
590#define VMSTATE_UNUSED(_size) \
591 VMSTATE_UNUSED_V(0, _size)
592
593#define VMSTATE_UNUSED_TEST(_test, _size) \
594 VMSTATE_UNUSED_BUFFER(_test, 0, _size)
595
596#define VMSTATE_END_OF_LIST() \
597 {}
598
599int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
600 void *opaque, int version_id);
601void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
602 void *opaque);
603int vmstate_register(DeviceState *dev, int instance_id,
604 const VMStateDescription *vmsd, void *base);
605int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
606 const VMStateDescription *vmsd,
607 void *base, int alias_id,
608 int required_for_version);
609void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
610 void *opaque);
611
612struct MemoryRegion;
613void vmstate_register_ram(struct MemoryRegion *memory, DeviceState *dev);
614void vmstate_unregister_ram(struct MemoryRegion *memory, DeviceState *dev);
615void vmstate_register_ram_global(struct MemoryRegion *memory);
616
617#endif
Qemu copy for testing